diff --git a/Makefile.inc1 b/Makefile.inc1 --- a/Makefile.inc1 +++ b/Makefile.inc1 @@ -1569,7 +1569,8 @@ _sysent_dirs+= sys/amd64/linux \ sys/amd64/linux32 \ sys/arm64/linux \ - sys/i386/linux + sys/i386/linux \ + sys/powerpc/linux sysent: .PHONY .for _dir in ${_sysent_dirs} diff --git a/sys/compat/linprocfs/linprocfs.c b/sys/compat/linprocfs/linprocfs.c --- a/sys/compat/linprocfs/linprocfs.c +++ b/sys/compat/linprocfs/linprocfs.c @@ -2265,7 +2265,7 @@ } PSEUDOFS(linprocfs, 1, VFCF_JAIL); -#if defined(__aarch64__) || defined(__amd64__) +#if defined(__aarch64__) || defined(__amd64__) || defined(__powerpc64__) MODULE_DEPEND(linprocfs, linux_common, 1, 1, 1); #else MODULE_DEPEND(linprocfs, linux, 1, 1, 1); diff --git a/sys/compat/linsysfs/linsysfs.c b/sys/compat/linsysfs/linsysfs.c --- a/sys/compat/linsysfs/linsysfs.c +++ b/sys/compat/linsysfs/linsysfs.c @@ -558,7 +558,7 @@ } PSEUDOFS(linsysfs, 1, VFCF_JAIL); -#if defined(__aarch64__) || defined(__amd64__) +#if defined(__aarch64__) || defined(__amd64__) || defined(__powerpc64__) MODULE_DEPEND(linsysfs, linux_common, 1, 1, 1); #else MODULE_DEPEND(linsysfs, linux, 1, 1, 1); diff --git a/sys/compat/linux/linux_file.c b/sys/compat/linux/linux_file.c --- a/sys/compat/linux/linux_file.c +++ b/sys/compat/linux/linux_file.c @@ -316,7 +316,7 @@ return (kern_lseek(td, args->fdes, args->off, args->whence)); } -#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) +#if defined(__powerpc64__) || defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_llseek(struct thread *td, struct linux_llseek_args *args) { @@ -336,7 +336,7 @@ td->td_retval[0] = 0; return (0); } -#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ +#endif /* __powerpc64__ || __i386__ || (__amd64__ && COMPAT_LINUX32) */ /* * Note that linux_getdents(2) and linux_getdents64(2) have the same diff --git a/sys/compat/linux/linux_ioctl.h b/sys/compat/linux/linux_ioctl.h --- a/sys/compat/linux/linux_ioctl.h +++ b/sys/compat/linux/linux_ioctl.h @@ -35,11 +35,12 @@ * XXX comments in Linux' indicate these * could be arch-dependant... */ +#ifndef LINUX_IOCTL #define LINUX_IOC_VOID 0 #define LINUX_IOC_IN 0x40000000 #define LINUX_IOC_OUT 0x80000000 #define LINUX_IOC_INOUT (LINUX_IOC_IN|LINUX_IOC_OUT) - +#endif /* * disk */ @@ -331,9 +332,13 @@ /* * termio */ +#ifndef __powerpc64__ #define LINUX_TCGETS 0x5401 +#endif #define LINUX_TCSETS 0x5402 +#ifndef __powerpc64__ #define LINUX_TCSETSW 0x5403 +#endif #define LINUX_TCSETSF 0x5404 #define LINUX_TCGETA 0x5405 #define LINUX_TCSETA 0x5406 @@ -347,14 +352,18 @@ #define LINUX_TIOCNXCL 0x540D #define LINUX_TIOCSCTTY 0x540E +#ifndef __powerpc64__ #define LINUX_TIOCGPGRP 0x540F #define LINUX_TIOCSPGRP 0x5410 +#endif #define LINUX_TIOCOUTQ 0x5411 #define LINUX_TIOCSTI 0x5412 +#ifndef __powerpc64__ #define LINUX_TIOCGWINSZ 0x5413 #define LINUX_TIOCSWINSZ 0x5414 +#endif #define LINUX_TIOCMGET 0x5415 #define LINUX_TIOCMBIS 0x5416 @@ -398,8 +407,10 @@ #define LINUX_TIOCGLCKTRMIOS 0x5456 #define LINUX_TIOCSLCKTRMIOS 0x5457 -#define LINUX_IOCTL_TERMIO_MIN LINUX_TCGETS +#define LINUX_IOCTL_TERMIO_MIN LINUX_TCSETS +#ifndef __powerpc64__ #define LINUX_IOCTL_TERMIO_MAX LINUX_TIOCSLCKTRMIOS +#endif /* arguments for tcflow() and LINUX_TCXONC */ #define LINUX_TCOOFF 0 @@ -419,6 +430,7 @@ #define LINUX_N_PPP 3 /* Linux termio c_cc values */ +#ifndef __powerpc64__ #define LINUX_VINTR 0 #define LINUX_VQUIT 1 #define LINUX_VERASE 2 @@ -427,10 +439,12 @@ #define LINUX_VTIME 5 #define LINUX_VMIN 6 #define LINUX_VSWTC 7 +#endif #define LINUX_NCC 8 /* Linux termios c_cc values */ /* In addition to the termio values */ +#ifndef LINUX_CFLAGS #define LINUX_VSTART 8 #define LINUX_VSTOP 9 #define LINUX_VSUSP 10 @@ -440,6 +454,7 @@ #define LINUX_VWERASE 14 #define LINUX_VLNEXT 15 #define LINUX_VEOL2 16 +#endif #define LINUX_VSTATUS 18 #define LINUX_NCCS 19 @@ -456,18 +471,24 @@ #define LINUX_IGNCR 0x0000080 #define LINUX_ICRNL 0x0000100 +#ifndef LINUX_CFLAGS #define LINUX_IUCLC 0x0000200 #define LINUX_IXON 0x0000400 +#endif #define LINUX_IXANY 0x0000800 +#ifndef LINUX_CFLAGS #define LINUX_IXOFF 0x0001000 #define LINUX_IMAXBEL 0x0002000 +#endif /* Linux c_oflag masks */ #define LINUX_OPOST 0x0000001 +#ifndef LINUX_CFLAGS #define LINUX_OLCUC 0x0000002 #define LINUX_ONLCR 0x0000004 +#endif #define LINUX_OCRNL 0x0000008 #define LINUX_ONOCR 0x0000010 @@ -475,6 +496,7 @@ #define LINUX_OFILL 0x0000040 #define LINUX_OFDEL 0x0000080 +#ifndef LINUX_CFLAGS #define LINUX_NLDLY 0x0000100 #define LINUX_NL0 0x0000000 #define LINUX_NL1 0x0000100 @@ -498,8 +520,11 @@ #define LINUX_FFDLY 0x0008000 #define LINUX_FF0 0x0000000 #define LINUX_FF1 0x0008000 +#endif +#ifndef LINUX_CFLAGS #define LINUX_CBAUD 0x0000100f +#endif #define LINUX_B0 0x00000000 #define LINUX_B50 0x00000001 @@ -520,10 +545,13 @@ #define LINUX_EXTA LINUX_B19200 #define LINUX_EXTB LINUX_B38400 +#ifndef LINUX_CFLAGS #define LINUX_CBAUDEX 0x00001000 +#endif #define LINUX_B57600 0x00001001 #define LINUX_B115200 0x00001002 +#ifndef LINUX_CFLAGS #define LINUX_CSIZE 0x00000030 #define LINUX_CS5 0x00000000 #define LINUX_CS6 0x00000010 @@ -535,10 +563,12 @@ #define LINUX_PARODD 0x00000200 #define LINUX_HUPCL 0x00000400 #define LINUX_CLOCAL 0x00000800 +#endif #define LINUX_CRTSCTS 0x80000000 /* Linux c_lflag masks */ +#ifndef LINUX_CFLAGS #define LINUX_ISIG 0x00000001 #define LINUX_ICANON 0x00000002 #define LINUX_XCASE 0x00000004 @@ -554,6 +584,7 @@ #define LINUX_FLUSHO 0x00001000 #define LINUX_PENDIN 0x00002000 #define LINUX_IEXTEN 0x00008000 +#endif /* serial_struct values for TIOC[GS]SERIAL ioctls */ #define LINUX_ASYNC_CLOSING_WAIT_INF 0 diff --git a/sys/compat/linux/linux_misc.h b/sys/compat/linux/linux_misc.h --- a/sys/compat/linux/linux_misc.h +++ b/sys/compat/linux/linux_misc.h @@ -161,7 +161,7 @@ #define LINUX_OOM_SCORE_ADJ_MIN -1000 #define LINUX_OOM_SCORE_ADJ_MAX 1000 -#if defined(__aarch64__) || (defined(__amd64__) && !defined(COMPAT_LINUX32)) +#if defined(__powerpc64__) || defined(__aarch64__) || (defined(__amd64__) && !defined(COMPAT_LINUX32)) int linux_ptrace_status(struct thread *td, int pid, int status); #endif void linux_to_bsd_waitopts(int options, int *bsdopts); diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c --- a/sys/compat/linux/linux_misc.c +++ b/sys/compat/linux/linux_misc.c @@ -2543,7 +2543,7 @@ return (error); } -#if defined(__i386__) || defined(__amd64__) +#if defined(__i386__) || defined(__amd64__) || defined(__powerpc64__) int linux_poll(struct thread *td, struct linux_poll_args *args) { diff --git a/sys/compat/linux/linux_stats.c b/sys/compat/linux/linux_stats.c --- a/sys/compat/linux/linux_stats.c +++ b/sys/compat/linux/linux_stats.c @@ -390,7 +390,7 @@ return (copyout(&linux_statfs, args->buf, sizeof(linux_statfs))); } -#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) +#if defined(__powerpc64__) || defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) static void bsd_to_linux_statfs64(struct statfs *bsd_statfs, struct l_statfs64 *linux_statfs) { @@ -449,7 +449,7 @@ return (error); return (copyout(&linux_statfs, args->buf, sizeof(linux_statfs))); } -#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ +#endif /* __powerpc64__ || __i386__ || (__amd64__ && COMPAT_LINUX32) */ int linux_fstatfs(struct thread *td, struct linux_fstatfs_args *args) diff --git a/sys/conf/files.powerpc b/sys/conf/files.powerpc --- a/sys/conf/files.powerpc +++ b/sys/conf/files.powerpc @@ -376,4 +376,4 @@ powerpc/psim/iobus.c optional psim powerpc/psim/ata_iobus.c optional ata psim powerpc/psim/openpic_iobus.c optional psim -powerpc/psim/uart_iobus.c optional uart psim +powerpc/psim/uart_iobus.c optional uart psim \ No newline at end of file diff --git a/sys/modules/Makefile b/sys/modules/Makefile --- a/sys/modules/Makefile +++ b/sys/modules/Makefile @@ -519,14 +519,14 @@ # Linuxulator .if ${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64" || \ - ${MACHINE_CPUARCH} == "i386" + ${MACHINE_CPUARCH} == "i386" || ${MACHINE_ARCH} == "powerpc64" SUBDIR+= linprocfs SUBDIR+= linsysfs .endif .if ${MACHINE_CPUARCH} == "amd64" || ${MACHINE_CPUARCH} == "i386" SUBDIR+= linux .endif -.if ${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64" +.if ${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64" || ${MACHINE_ARCH} == "powerpc64" SUBDIR+= linux64 SUBDIR+= linux_common .endif diff --git a/sys/modules/linux64/Makefile b/sys/modules/linux64/Makefile --- a/sys/modules/linux64/Makefile +++ b/sys/modules/linux64/Makefile @@ -59,6 +59,8 @@ # The Linux uses tiny memory model, but our ld does not know about # some of relocation types which is generated by cc VDSOFLAGS=-mgeneral-regs-only -mcmodel=small -ffixed-x18 +.elif ${MACHINE_ARCH:Mpowerpc64*} +VDSOFLAGS= -mcmodel=medium .endif linux_locore.o: linux_assym.h assym.inc @@ -68,6 +70,8 @@ -fno-omit-frame-pointer -foptimize-sibling-calls \ -fno-stack-protector -I. -I${SYSDIR} -I${SRCTOP}/include \ ${.IMPSRC} -o ${.TARGET} + #-Wl,-T${SRCTOP}/sys/${MACHINE}/linux/linux_vdso.lds.s \ + #-Wl,-soname=linux_vdso.so.1,-warn-common -nostdlib \ linux_vdso_gtod.o: linux_vdso_gtod.inc ${VDSODEPS} ${CC} -c -fPIC -pipe -O2 -Werror ${VDSOFLAGS} \ @@ -87,6 +91,8 @@ OBJCOPY_TARGET=--output-target elf64-littleaarch64 --binary-architecture aarch64 .elif ${MACHINE_CPUARCH} == "amd64" OBJCOPY_TARGET=--output-target elf64-x86-64 --binary-architecture i386:x86-64 +.elif ${MACHINE_ARCH:Mpowerpc64*} != "" +OBJCOPY_TARGET=--output-target elf64-powerpc .else .error ${MACHINE_CPUARCH} not yet supported by linux64 .endif @@ -96,6 +102,11 @@ linux_vdso.so.o ${.TARGET} ${STRIPBIN} -N _binary_linux_vdso_so_o_size ${.TARGET} +#linux_vdso.so: linux_vdso.so.o + #${OBJCOPY} --input-target binary ${OBJCOPY_TARGET} \ + #linux_vdso.so.o ${.TARGET} + #${STRIPBIN} -N _binary_linux_vdso_so_o_size ${.TARGET} + linux_support.o: linux_support.S assym.inc linux_assym.h ${CC} -c -x assembler-with-cpp -DLOCORE ${CFLAGS} \ ${.ALLSRC:M*.S:u} -o ${.TARGET} diff --git a/sys/powerpc/linux/Makefile b/sys/powerpc/linux/Makefile new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/Makefile @@ -0,0 +1,7 @@ +# Makefile for syscall tables +# +# $FreeBSD$ + +GENERATED_PREFIX= linux_ + +.include "../../conf/sysent.mk" diff --git a/sys/powerpc/linux/linux.h b/sys/powerpc/linux/linux.h new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux.h @@ -0,0 +1,353 @@ +/*- + * Copyright (c) 1994-1996 Søren Schmidt + * Copyright (c) 2013 Dmitry Chagin + * Copyright (c) 2018 Turing Robotic Industries Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * $FreeBSD$ + */ +#ifndef _POWERPC_LINUX_H_ +#define _POWERPC_LINUX_H_ + +#include + +#include +#include + +#define LINUX_LEGACY_SYSCALLS + +#define LINUX_DTRACE linuxulator + +/* 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_uint l_gid_t; +typedef l_ushort l_gid16_t; /* XXX */ +typedef l_uint l_uid_t; +typedef l_ushort l_uid16_t; /* XXX */ +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_suseconds_t; +typedef l_long l_time_t; +typedef l_int l_timer_t; /* XXX */ +typedef l_int l_mqd_t; +typedef l_ulong l_fd_mask; + +#include + +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_AT_COUNT 17 + +struct l___sysctl_args +{ + l_uintptr_t name; + l_int nlen; + l_uintptr_t oldval; + l_uintptr_t oldlenp; + l_uintptr_t newval; + l_uintptr_t newlen; + l_ulong __spare[4]; +}; + +/* 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; +}; + +/* stat family of syscalls */ +struct l_timespec { + l_ulong tv_sec; + l_ulong tv_nsec; +}; + +#define LINUX_O_DIRECTORY 040000 /* must be a directory */ +#define LINUX_O_NOFOLLOW 0100000 /* don't follow links */ +#define LINUX_O_LARGEFILE 0200000 +#define LINUX_O_DIRECT 0400000 /* direct disk access hint */ + +/* Definitions for syscalls */ +#define LINUX_FIRSTARG 3 /* first arg in reg 3 */ +#define LINUX_NARGREG 8 /* 8 args in regs */ + +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_dev_t st_rdev; + l_long st_size; + l_ulong st_blksize; + l_ulong st_blocks; + + struct l_timespec st_atim; + struct l_timespec st_mtim; + struct l_timespec st_ctim; + l_ulong __unused1; + l_ulong __unused2; + l_ulong __unused3; +}; + +struct l_statfs64 { + l_int f_type; + l_int f_bsize; + uint64_t f_blocks; + uint64_t f_bfree; + uint64_t f_bavail; + uint64_t f_files; + uint64_t f_ffree; + l_fsid_t f_fsid; + l_int f_namelen; + l_int f_frsize; + l_int f_flags; + l_int f_spare[4]; +}; + +/* 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 /* XXX */ +#define LINUX_SA_NOMASK 0x40000000 /* SA_NODEFER */ +#define LINUX_SA_ONESHOT 0x80000000 /* SA_RESETHAND */ + +/* sigaltstack */ +#define LINUX_MINSIGSTKSZ 8192 +#define LINUX_SIGSTKSZ 32768 + +typedef void (*l_handler_t)(l_int); + +typedef struct { + l_handler_t lsa_handler; + l_ulong lsa_flags; + l_uintptr_t lsa_restorer; + l_sigset_t lsa_mask; +} l_sigaction_t; /* XXX */ + +typedef struct { + l_uintptr_t ss_sp; + l_int ss_flags; + l_size_t ss_size; +} l_stack_t; + +union l_semun { + l_int val; + l_uintptr_t buf; + l_uintptr_t array; + l_uintptr_t __buf; + l_uintptr_t __pad; +}; + +#define linux_copyout_rusage(r, u) copyout(r, u, sizeof(*r)) + +struct reg; +struct syscall_info; + +struct linux_pt_regset { +}; + + +#ifdef _KERNEL +struct reg; +struct syscall_info; + +void bsd_to_linux_regset(const struct reg *b_reg, + struct linux_pt_regset *l_regset); +void linux_to_bsd_regset(struct reg *b_reg, + const struct linux_pt_regset *l_regset); +void linux_ptrace_get_syscall_info_machdep(const struct reg *reg, + struct syscall_info *si); +int linux_ptrace_getregs_machdep(struct thread *td, pid_t pid, + struct linux_pt_regset *l_regset); +int linux_ptrace_peekuser(struct thread *td, pid_t pid, + void *addr, void *data); +int linux_ptrace_pokeuser(struct thread *td, pid_t pid, + void *addr, void *data); +#endif /* _KERNEL */ + + +/* + * ioctl + * + * XXX comments in Linux' indicate these + * could be arch-dependant... + */ +#define LINUX_IOCTL +#define LINUX_IOC_VOID 0x20000000 +#define LINUX_IOC_IN 0x40000000 +#define LINUX_IOC_OUT 0x80000000 +#define LINUX_IOC_INOUT (LINUX_IOC_IN|LINUX_IOC_OUT) + + +/* + * termio + */ +#define LINUX_CFLAGS +#define LINUX_TCGETS 0x7413 +#define LINUX_TCSETSW 0x7415 +#define LINUX_TIOCSWINSZ 0x7467 +#define LINUX_TIOCGWINSZ 0x7468 +#define LINUX_TIOCSPGRP 0x7476 +#define LINUX_TIOCGPGRP 0x7477 + +#define LINUX_IOCTL_TERMIO_MAX LINUX_TIOCGPGRP + +/* c_cc characters */ +#define LINUX_VINTR 0 +#define LINUX_VQUIT 1 +#define LINUX_VERASE 2 +#define LINUX_VKILL 3 +#define LINUX_VEOF 4 +#define LINUX_VMIN 5 +#define LINUX_VEOL 6 +#define LINUX_VTIME 7 +#define LINUX_VEOL2 8 +#define LINUX_VSWTC 9 +#define LINUX_VWERASE 10 +#define LINUX_VREPRINT 11 +#define LINUX_VSUSP 12 +#define LINUX_VSTART 13 +#define LINUX_VSTOP 14 +#define LINUX_VLNEXT 15 +#define LINUX_VDISCARD 16 + +/* c_iflag bits */ +#define LINUX_IXON 0x0200 +#define LINUX_IXOFF 0x0400 +#define LINUX_IUCLC 0x1000 +#define LINUX_IMAXBEL 0x2000 +#define LINUX_IUTF8 0x4000 + +/* c_oflag bits */ +#define LINUX_ONLCR 0x00002 +#define LINUX_OLCUC 0x00004 +#define LINUX_NLDLY 0x00300 +#define LINUX_NL0 0x00000 +#define LINUX_NL1 0x00100 +#define LINUX_TABDLY 0x00c00 +#define LINUX_TAB0 0x00000 +#define LINUX_TAB1 0x00400 +#define LINUX_TAB2 0x00800 +#define LINUX_TAB3 0x00c00 +#define LINUX_XTABS 0x00c00 /* required by POSIX to == TAB3 */ +#define LINUX_CRDLY 0x03000 +#define LINUX_CR0 0x00000 +#define LINUX_CR1 0x01000 +#define LINUX_CR2 0x02000 +#define LINUX_CR3 0x03000 +#define LINUX_FFDLY 0x04000 +#define LINUX_FF0 0x00000 +#define LINUX_FF1 0x04000 +#define LINUX_BSDLY 0x08000 +#define LINUX_BS0 0x00000 +#define LINUX_BS1 0x08000 +#define LINUX_VTDLY 0x10000 +#define LINUX_VT0 0x00000 +#define LINUX_VT1 0x10000 + +/* c_cflag bit meaning */ +#define LINUX_CBAUD 0x000000ff +#define LINUX_CBAUDEX 0x00000000 +#define LINUX_BOTHER 0x0000001f +#define LINUX_CSIZE 0x00000300 +#define LINUX_CS5 0x00000000 +#define LINUX_CS6 0x00000100 +#define LINUX_CS7 0x00000200 +#define LINUX_CS8 0x00000300 +#define LINUX_CSTOPB 0x00000400 +#define LINUX_CREAD 0x00000800 +#define LINUX_PARENB 0x00001000 +#define LINUX_PARODD 0x00002000 +#define LINUX_HUPCL 0x00004000 +#define LINUX_CLOCAL 0x00008000 + +/* c_lflag bits */ +#define LINUX_ISIG 0x00000080 +#define LINUX_ICANON 0x00000100 +#define LINUX_XCASE 0x00004000 +#define LINUX_ECHO 0x00000008 +#define LINUX_ECHOE 0x00000002 +#define LINUX_ECHOK 0x00000004 +#define LINUX_ECHONL 0x00000010 +#define LINUX_NOFLSH 0x80000000 +#define LINUX_TOSTOP 0x00400000 +#define LINUX_ECHOCTL 0x00000040 +#define LINUX_ECHOPRT 0x00000020 +#define LINUX_ECHOKE 0x00000001 +#define LINUX_FLUSHO 0x00800000 +#define LINUX_PENDIN 0x20000000 +#define LINUX_IEXTEN 0x00000400 + +struct l_func_desc { + unsigned long addr; + unsigned long toc; + unsigned long env; +}; + +#endif /* _POWERPC_LINUX_H_ */ diff --git a/sys/powerpc/linux/linux_dummy_machdep.c b/sys/powerpc/linux/linux_dummy_machdep.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_dummy_machdep.c @@ -0,0 +1,60 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2013 Dmitry Chagin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include + +#include +#include +#include +#include + +/* DTrace init */ +LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE); + +/* + * Before adding new stubs to this file, please check if a stub can be added to + * the machine-independent code in sys/compat/linux/linux_dummy.c. + */ + +//UNIMPLEMENTED(get_thread_area); +//UNIMPLEMENTED(set_thread_area); +//UNIMPLEMENTED(uselib); + +//DUMMY(mq_open); +//DUMMY(mq_unlink); +//DUMMY(mq_timedsend); +//DUMMY(mq_timedreceive); +//DUMMY(mq_notify); +//DUMMY(mq_getsetattr); +//DUMMY(kexec_file_load); +DUMMY(map_shadow_stack); diff --git a/sys/powerpc/linux/linux_genassym.c b/sys/powerpc/linux/linux_genassym.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_genassym.c @@ -0,0 +1,2 @@ +#include +__FBSDID("$FreeBSD$"); diff --git a/sys/powerpc/linux/linux_locore.asm b/sys/powerpc/linux/linux_locore.asm new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_locore.asm @@ -0,0 +1,62 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (C) 2018 Turing Robotic Industries Inc. + * Copyright (C) 2020 Andrew Turner + * Copyright (C) 2022 Dmitry Chagin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * powerpc64 Linux signal trampoline. + + */ + +#include + +#include + + .data + + .globl linux_platform + .globl CNAME(linux_vdso_sigcode) +linux_platform: + .asciz "powerpc64" + + .text + +CNAME(linux_vdso_sigcode): + bctrl /* call the handler */ + addi 1,1,128 /* SIGNAL_FRAMESIZE */ + li 0, 172 /* __NR_rt_sigreturn */ + sc + /* + * If we get back to here, it means sigreturn failed. + * As such, we are now stuck in the wrong context. + * Exit immediately without touching the stack. + */ + li 0,1 /* exit */ + sc /* exit(errno) */ + diff --git a/sys/powerpc/linux/linux_machdep.c b/sys/powerpc/linux/linux_machdep.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_machdep.c @@ -0,0 +1,176 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2018 Turing Robotic Industries Inc. + * Copyright (c) 2000 Marcel Moolenaar + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +//#include +#include + +#include +#include +#include +#include +#include +#include +#include + + +int +linux_mmap(struct thread *td, struct linux_mmap_args *uap) +{ + + return (linux_mmap_common(td, PTROUT(uap->addr), uap->len, uap->prot, + uap->flags, uap->fd, uap->pgoff)); +} + +int +linux_set_upcall(struct thread *td, register_t stack) +{ + //TODO + return 0; +} + +int +linux_set_cloned_tls(struct thread *td, void *desc) +{ + //TODO + return 0; +} + +void +bsd_to_linux_regset(const struct reg *b_reg, struct linux_pt_regset *l_regset) +{ + //TODO +} + +void +linux_to_bsd_regset(struct reg *b_reg, const struct linux_pt_regset *l_regset) +{ + //TODO +} + +void +linux_ptrace_get_syscall_info_machdep(const struct reg *reg, + struct syscall_info *si) +{ + //TODO +} + +int +linux_ptrace_getregs_machdep(struct thread *td, pid_t pid, + struct linux_pt_regset *l_regset) +{ + //TODO + return 0; +} + +int +linux_pause(struct thread *td, struct linux_pause_args *args) +{ + return 0; +} + +int +linux_ioperm(struct thread *td, struct linux_ioperm_args *args) +{ + return 0; +} + +int +linux_iopl(struct thread *td, struct linux_iopl_args *args) +{ + return 0; +} + +int +linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap) +{ + return 0; +} + +/* XXX: this wont work with module - convert it */ +int +linux_mq_open(struct thread *td, struct linux_mq_open_args *args) +{ + return 0; +} + +int +linux_mq_unlink(struct thread *td, struct linux_mq_unlink_args *args) +{ + return 0; +} + +int +linux_mq_timedsend(struct thread *td, struct linux_mq_timedsend_args *args) +{ + return 0; +} + +int +linux_mq_timedreceive(struct thread *td, struct linux_mq_timedreceive_args *args) +{ + return 0; +} + +int +linux_mq_notify(struct thread *td, struct linux_mq_notify_args *args) +{ + return 0; +} + +int +linux_mq_getsetattr(struct thread *td, struct linux_mq_getsetattr_args *args) +{ + return 0; +} + +int +linux_quotactl(struct thread *td, struct linux_quotactl_args * args) +{ + return 0; +} + +int +linux_ptrace_peekuser(struct thread *td, pid_t pid, void *addr, void *data) +{ + return (ENOSYS); +} +int +linux_ptrace_pokeuser(struct thread *td, pid_t pid, void *addr, void *data) +{ + return (ENOSYS); +} diff --git a/sys/powerpc/linux/linux_proto.h b/sys/powerpc/linux/linux_proto.h new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_proto.h @@ -0,0 +1,2079 @@ +/* + * System call prototypes. + * + * DO NOT EDIT-- this file is automatically @generated. + */ + +#ifndef _LINUX_SYSPROTO_H_ +#define _LINUX_SYSPROTO_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +struct proc; + +struct thread; + +#define PAD_(t) (sizeof(syscallarg_t) <= sizeof(t) ? \ + 0 : sizeof(syscallarg_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 + +struct linux_exit_args { + char rval_l_[PADL_(u_int)]; u_int rval; char rval_r_[PADR_(u_int)]; +}; +struct linux_fork_args { + syscallarg_t dummy; +}; +struct linux_write_args { + char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; + 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)]; +}; +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_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; +}; +struct linux_creat_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_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_execve_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char argp_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * argp; char argp_r_[PADR_(l_uintptr_t *)]; + char envp_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * envp; char envp_r_[PADR_(l_uintptr_t *)]; +}; +struct linux_chdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; +}; +struct linux_time_args { + char tm_l_[PADL_(l_time_t *)]; l_time_t * tm; char tm_r_[PADR_(l_time_t *)]; +}; +struct linux_mknod_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)]; + char dev_l_[PADL_(l_uint)]; l_uint dev; char dev_r_[PADR_(l_uint)]; +}; +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_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_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_getpid_args { + syscallarg_t dummy; +}; +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_getuid_args { + syscallarg_t dummy; +}; +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_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)]; + char data_l_[PADL_(l_ulong)]; l_ulong data; char data_r_[PADR_(l_ulong)]; +}; +struct linux_alarm_args { + char secs_l_[PADL_(l_uint)]; l_uint secs; char secs_r_[PADR_(l_uint)]; +}; +struct linux_pause_args { + syscallarg_t dummy; +}; +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_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_kill_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char signum_l_[PADL_(l_int)]; l_int signum; char signum_r_[PADR_(l_int)]; +}; +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_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; +}; +struct linux_rmdir_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; +}; +struct linux_pipe_args { + char pipefds_l_[PADL_(l_int *)]; l_int * pipefds; char pipefds_r_[PADR_(l_int *)]; +}; +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_brk_args { + char dsend_l_[PADL_(l_ulong)]; l_ulong dsend; char dsend_r_[PADR_(l_ulong)]; +}; +struct linux_getgid_args { + syscallarg_t dummy; +}; +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_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; +}; +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_ustat_args { + char dev_l_[PADL_(l_uint)]; l_uint dev; char dev_r_[PADR_(l_uint)]; + char ubuf_l_[PADL_(struct l_ustat *)]; struct l_ustat * ubuf; char ubuf_r_[PADR_(struct l_ustat *)]; +}; +struct linux_getppid_args { + syscallarg_t dummy; +}; +struct linux_sethostname_args { + char hostname_l_[PADL_(char *)]; char * hostname; char hostname_r_[PADR_(char *)]; + char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)]; +}; +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_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_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_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_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_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_mmap_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_truncate_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char length_l_[PADL_(l_long)]; l_long length; char length_r_[PADR_(l_long)]; +}; +struct linux_ftruncate_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)]; +}; +struct linux_getpriority_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char who_l_[PADL_(l_int)]; l_int who; char who_r_[PADR_(l_int)]; +}; +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_ioperm_args { + syscallarg_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_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_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_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_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_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_iopl_args { + char level_l_[PADL_(l_uint)]; l_uint level; char level_r_[PADR_(l_uint)]; +}; +struct linux_vhangup_args { + syscallarg_t dummy; +}; +struct linux_wait4_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char status_l_[PADL_(l_int *)]; l_int * status; char status_r_[PADR_(l_int *)]; + char options_l_[PADL_(l_int)]; l_int options; char options_r_[PADR_(l_int)]; + char rusage_l_[PADL_(struct rusage *)]; struct rusage * rusage; char rusage_r_[PADR_(struct rusage *)]; +}; +struct linux_swapoff_args { + syscallarg_t dummy; +}; +struct linux_sysinfo_args { + char info_l_[PADL_(struct l_sysinfo *)]; struct l_sysinfo * info; char info_r_[PADR_(struct l_sysinfo *)]; +}; +struct linux_clone_args { + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char stack_l_[PADL_(l_ulong)]; l_ulong stack; char stack_r_[PADR_(l_ulong)]; + char parent_tidptr_l_[PADL_(l_int *)]; l_int * parent_tidptr; char parent_tidptr_r_[PADR_(l_int *)]; + char child_tidptr_l_[PADL_(l_int *)]; l_int * child_tidptr; char child_tidptr_r_[PADR_(l_int *)]; + char tls_l_[PADL_(l_ulong)]; l_ulong tls; char tls_r_[PADR_(l_ulong)]; +}; +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_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_modify_ldt_args { + syscallarg_t dummy; +}; +struct linux_adjtimex_args { + syscallarg_t dummy; +}; +struct linux_mprotect_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 prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)]; +}; +struct linux_init_module_args { + syscallarg_t dummy; +}; +struct linux_delete_module_args { + syscallarg_t dummy; +}; +struct linux_quotactl_args { + syscallarg_t dummy; +}; +struct linux_personality_args { + char per_l_[PADL_(l_uint)]; l_uint per; char per_r_[PADR_(l_uint)]; +}; +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_llseek_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char ohigh_l_[PADL_(l_ulong)]; l_ulong ohigh; char ohigh_r_[PADR_(l_ulong)]; + char olow_l_[PADL_(l_ulong)]; l_ulong olow; char olow_r_[PADR_(l_ulong)]; + char res_l_[PADL_(l_loff_t *)]; l_loff_t * res; char res_r_[PADR_(l_loff_t *)]; + char whence_l_[PADL_(l_uint)]; l_uint whence; char whence_r_[PADR_(l_uint)]; +}; +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_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_writev_args { + char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; + char iovp_l_[PADL_(struct iovec *)]; struct iovec * iovp; char iovp_r_[PADR_(struct iovec *)]; + char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; +}; +struct linux_getsid_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; +}; +struct linux_fdatasync_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; +}; +struct linux_sysctl_args { + char args_l_[PADL_(struct l___sysctl_args *)]; struct l___sysctl_args * args; char args_r_[PADR_(struct l___sysctl_args *)]; +}; +struct linux_sched_setparam_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char param_l_[PADL_(struct sched_param *)]; struct sched_param * param; char param_r_[PADR_(struct 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 sched_param *)]; struct sched_param * param; char param_r_[PADR_(struct 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 sched_param *)]; struct sched_param * param; char param_r_[PADR_(struct 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_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_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_poll_args { + char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)]; + char nfds_l_[PADL_(u_int)]; u_int nfds; char nfds_r_[PADR_(u_int)]; + char timeout_l_[PADL_(int)]; int timeout; char timeout_r_[PADR_(int)]; +}; +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_rt_sigreturn_args { + syscallarg_t dummy; +}; +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_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_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; + 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_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_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_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_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_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_sendfile_args { + char out_l_[PADL_(l_int)]; l_int out; char out_r_[PADR_(l_int)]; + char in_l_[PADL_(l_int)]; l_int in; char in_r_[PADR_(l_int)]; + char offset_l_[PADL_(l_off_t *)]; l_off_t * offset; char offset_r_[PADR_(l_off_t *)]; + char count_l_[PADL_(l_size_t)]; l_size_t count; char count_r_[PADR_(l_size_t)]; +}; +struct linux_vfork_args { + syscallarg_t dummy; +}; +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_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_pivot_root_args { + syscallarg_t dummy; +}; +struct linux_madvise_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 behav_l_[PADL_(l_int)]; l_int behav; char behav_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_gettid_args { + syscallarg_t dummy; +}; +struct linux_tkill_args { + char tid_l_[PADL_(l_pid_t)]; l_pid_t tid; char tid_r_[PADR_(l_pid_t)]; + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; +}; +struct linux_setxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(void *)]; void * value; char value_r_[PADR_(void *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_lsetxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(void *)]; void * value; char value_r_[PADR_(void *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_fsetxattr_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(void *)]; void * value; char value_r_[PADR_(void *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_getxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(char *)]; char * value; char value_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_lgetxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(char *)]; char * value; char value_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_fgetxattr_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char value_l_[PADL_(char *)]; char * value; char value_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_listxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char list_l_[PADL_(char *)]; char * list; char list_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_llistxattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char list_l_[PADL_(char *)]; char * list; char list_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_flistxattr_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char list_l_[PADL_(char *)]; char * list; char list_r_[PADR_(char *)]; + char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)]; +}; +struct linux_removexattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; +}; +struct linux_lremovexattr_args { + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; +}; +struct linux_fremovexattr_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; +}; +struct linux_sys_futex_args { + char uaddr_l_[PADL_(uint32_t *)]; uint32_t * uaddr; char uaddr_r_[PADR_(uint32_t *)]; + char op_l_[PADL_(l_int)]; l_int op; char op_r_[PADR_(l_int)]; + char val_l_[PADL_(uint32_t)]; uint32_t val; char val_r_[PADR_(uint32_t)]; + char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; + char uaddr2_l_[PADL_(uint32_t *)]; uint32_t * uaddr2; char uaddr2_r_[PADR_(uint32_t *)]; + char val3_l_[PADL_(uint32_t)]; uint32_t val3; char val3_r_[PADR_(uint32_t)]; +}; +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_tid_address_args { + char tidptr_l_[PADL_(l_int *)]; l_int * tidptr; char tidptr_r_[PADR_(l_int *)]; +}; +struct linux_fadvise64_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char advice_l_[PADL_(l_int)]; l_int advice; char advice_r_[PADR_(l_int)]; +}; +struct linux_exit_group_args { + char error_code_l_[PADL_(l_int)]; l_int error_code; char error_code_r_[PADR_(l_int)]; +}; +struct linux_lookup_dcookie_args { + syscallarg_t dummy; +}; +struct linux_epoll_create_args { + char size_l_[PADL_(l_int)]; l_int size; char size_r_[PADR_(l_int)]; +}; +struct linux_epoll_ctl_args { + char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)]; + char op_l_[PADL_(l_int)]; l_int op; char op_r_[PADR_(l_int)]; + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char event_l_[PADL_(struct epoll_event *)]; struct epoll_event * event; char event_r_[PADR_(struct epoll_event *)]; +}; +struct linux_epoll_wait_args { + char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)]; + char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)]; + char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)]; + char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)]; +}; +struct linux_remap_file_pages_args { + syscallarg_t dummy; +}; +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_(l_int)]; l_int flags; char flags_r_[PADR_(l_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_tgkill_args { + char tgid_l_[PADL_(l_pid_t)]; l_pid_t tgid; char tgid_r_[PADR_(l_pid_t)]; + 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)]; +}; +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_statfs64_args { + char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; + char bufsize_l_[PADL_(size_t)]; size_t bufsize; char bufsize_r_[PADR_(size_t)]; + char buf_l_[PADL_(struct l_statfs64_buf *)]; struct l_statfs64_buf * buf; char buf_r_[PADR_(struct l_statfs64_buf *)]; +}; +struct linux_fstatfs64_args { + char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; + char bufsize_l_[PADL_(size_t)]; size_t bufsize; char bufsize_r_[PADR_(size_t)]; + char buf_l_[PADL_(struct l_statfs64_buf *)]; struct l_statfs64_buf * buf; char buf_r_[PADR_(struct l_statfs64_buf *)]; +}; +struct linux_migrate_pages_args { + syscallarg_t dummy; +}; +struct linux_mbind_args { + syscallarg_t dummy; +}; +struct linux_get_mempolicy_args { + syscallarg_t dummy; +}; +struct linux_set_mempolicy_args { + syscallarg_t dummy; +}; +struct linux_mq_open_args { + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char oflag_l_[PADL_(l_int)]; l_int oflag; char oflag_r_[PADR_(l_int)]; + char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; + char attr_l_[PADL_(struct mq_attr *)]; struct mq_attr * attr; char attr_r_[PADR_(struct mq_attr *)]; +}; +struct linux_mq_unlink_args { + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; +}; +struct linux_mq_timedsend_args { + char mqd_l_[PADL_(l_mqd_t)]; l_mqd_t mqd; char mqd_r_[PADR_(l_mqd_t)]; + char msg_ptr_l_[PADL_(const char *)]; const char * msg_ptr; char msg_ptr_r_[PADR_(const char *)]; + char msg_len_l_[PADL_(l_size_t)]; l_size_t msg_len; char msg_len_r_[PADR_(l_size_t)]; + char msg_prio_l_[PADL_(l_uint)]; l_uint msg_prio; char msg_prio_r_[PADR_(l_uint)]; + char abs_timeout_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * abs_timeout; char abs_timeout_r_[PADR_(const struct l_timespec *)]; +}; +struct linux_mq_timedreceive_args { + char mqd_l_[PADL_(l_mqd_t)]; l_mqd_t mqd; char mqd_r_[PADR_(l_mqd_t)]; + char msg_ptr_l_[PADL_(char *)]; char * msg_ptr; char msg_ptr_r_[PADR_(char *)]; + char msg_len_l_[PADL_(l_size_t)]; l_size_t msg_len; char msg_len_r_[PADR_(l_size_t)]; + char msg_prio_l_[PADL_(l_uint *)]; l_uint * msg_prio; char msg_prio_r_[PADR_(l_uint *)]; + char abs_timeout_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * abs_timeout; char abs_timeout_r_[PADR_(const struct l_timespec *)]; +}; +struct linux_mq_notify_args { + char mqd_l_[PADL_(l_mqd_t)]; l_mqd_t mqd; char mqd_r_[PADR_(l_mqd_t)]; + char abs_timeout_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * abs_timeout; char abs_timeout_r_[PADR_(const struct l_timespec *)]; +}; +struct linux_mq_getsetattr_args { + char mqd_l_[PADL_(l_mqd_t)]; l_mqd_t mqd; char mqd_r_[PADR_(l_mqd_t)]; + char attr_l_[PADL_(const struct mq_attr *)]; const struct mq_attr * attr; char attr_r_[PADR_(const struct mq_attr *)]; + char oattr_l_[PADL_(struct mq_attr *)]; struct mq_attr * oattr; char oattr_r_[PADR_(struct mq_attr *)]; +}; +struct linux_kexec_load_args { + syscallarg_t dummy; +}; +struct linux_add_key_args { + syscallarg_t dummy; +}; +struct linux_request_key_args { + syscallarg_t dummy; +}; +struct linux_keyctl_args { + syscallarg_t dummy; +}; +struct linux_waitid_args { + char idtype_l_[PADL_(l_int)]; l_int idtype; char idtype_r_[PADR_(l_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_(l_int)]; l_int options; char options_r_[PADR_(l_int)]; + char rusage_l_[PADL_(struct rusage *)]; struct rusage * rusage; char rusage_r_[PADR_(struct rusage *)]; +}; +struct linux_ioprio_set_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char who_l_[PADL_(l_int)]; l_int who; char who_r_[PADR_(l_int)]; + char ioprio_l_[PADL_(l_int)]; l_int ioprio; char ioprio_r_[PADR_(l_int)]; +}; +struct linux_ioprio_get_args { + char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)]; + char who_l_[PADL_(l_int)]; l_int who; char who_r_[PADR_(l_int)]; +}; +struct linux_inotify_add_watch_args { + syscallarg_t dummy; +}; +struct linux_inotify_rm_watch_args { + syscallarg_t dummy; +}; +struct linux_pselect6_args { + char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)]; + char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)]; + char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)]; + char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)]; + char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)]; + char sig_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * sig; char sig_r_[PADR_(l_uintptr_t *)]; +}; +struct linux_ppoll_args { + char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)]; + char nfds_l_[PADL_(l_uint)]; l_uint nfds; char nfds_r_[PADR_(l_uint)]; + char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)]; + char sset_l_[PADL_(l_sigset_t *)]; l_sigset_t * sset; char sset_r_[PADR_(l_sigset_t *)]; + char ssize_l_[PADL_(l_size_t)]; l_size_t ssize; char ssize_r_[PADR_(l_size_t)]; +}; +struct linux_unshare_args { + syscallarg_t dummy; +}; +struct linux_splice_args { + char fd_in_l_[PADL_(int)]; int fd_in; char fd_in_r_[PADR_(int)]; + char off_in_l_[PADL_(l_loff_t *)]; l_loff_t * off_in; char off_in_r_[PADR_(l_loff_t *)]; + char fd_out_l_[PADL_(int)]; int fd_out; char fd_out_r_[PADR_(int)]; + char off_out_l_[PADL_(l_loff_t *)]; l_loff_t * off_out; char off_out_r_[PADR_(l_loff_t *)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_tee_args { + syscallarg_t dummy; +}; +struct linux_vmsplice_args { + syscallarg_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_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; +}; +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_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; +}; +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_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; + char dev_l_[PADL_(l_uint)]; l_uint dev; char dev_r_[PADR_(l_uint)]; +}; +struct linux_fchownat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; + char uid_l_[PADL_(l_uid_t)]; l_uid_t uid; char uid_r_[PADR_(l_uid_t)]; + char gid_l_[PADL_(l_gid_t)]; l_gid_t gid; char gid_r_[PADR_(l_gid_t)]; + char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; +}; +struct linux_futimesat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char filename_l_[PADL_(char *)]; char * filename; char filename_r_[PADR_(char *)]; + char utimes_l_[PADL_(struct l_timeval *)]; struct l_timeval * utimes; char utimes_r_[PADR_(struct l_timeval *)]; +}; +struct linux_newfstatat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char pathname_l_[PADL_(char *)]; char * pathname; char pathname_r_[PADR_(char *)]; + char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; + char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; +}; +struct linux_unlinkat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)]; + char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; +}; +struct linux_renameat_args { + char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)]; + char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; + char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; + char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; +}; +struct linux_linkat_args { + char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)]; + char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; + char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; + char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; + char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; +}; +struct linux_symlinkat_args { + char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; + char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; + char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; +}; +struct linux_readlinkat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char bufsiz_l_[PADL_(l_int)]; l_int bufsiz; char bufsiz_r_[PADR_(l_int)]; +}; +struct linux_fchmodat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; + char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; +}; +struct linux_faccessat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; + char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)]; +}; +struct linux_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_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_move_pages_args { + syscallarg_t dummy; +}; +struct linux_getcpu_args { + char cpu_l_[PADL_(l_uint *)]; l_uint * cpu; char cpu_r_[PADR_(l_uint *)]; + char node_l_[PADL_(l_uint *)]; l_uint * node; char node_r_[PADR_(l_uint *)]; + char cache_l_[PADL_(void *)]; void * cache; char cache_r_[PADR_(void *)]; +}; +struct linux_epoll_pwait_args { + char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)]; + char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)]; + char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)]; + char timeout_l_[PADL_(l_int)]; l_int timeout; char timeout_r_[PADR_(l_int)]; + char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)]; + char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; +}; +struct linux_utimensat_args { + char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; + char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)]; + char times_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * times; char times_r_[PADR_(const struct l_timespec *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_timerfd_create_args { + char clockid_l_[PADL_(l_int)]; l_int clockid; char clockid_r_[PADR_(l_int)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_eventfd_args { + char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)]; +}; +struct linux_sync_file_range_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; + char nbytes_l_[PADL_(l_loff_t)]; l_loff_t nbytes; char nbytes_r_[PADR_(l_loff_t)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_fallocate_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; + char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; + char len_l_[PADL_(l_loff_t)]; l_loff_t len; char len_r_[PADR_(l_loff_t)]; +}; +struct linux_timerfd_settime_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char new_value_l_[PADL_(const struct l_itimerspec *)]; const struct l_itimerspec * new_value; char new_value_r_[PADR_(const struct l_itimerspec *)]; + char old_value_l_[PADL_(struct l_itimerspec *)]; struct l_itimerspec * old_value; char old_value_r_[PADR_(struct l_itimerspec *)]; +}; +struct linux_timerfd_gettime_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char old_value_l_[PADL_(struct l_itimerspec *)]; struct l_itimerspec * old_value; char old_value_r_[PADR_(struct l_itimerspec *)]; +}; +struct linux_signalfd4_args { + syscallarg_t dummy; +}; +struct linux_eventfd2_args { + char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_epoll_create1_args { + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_dup3_args { + char oldfd_l_[PADL_(l_uint)]; l_uint oldfd; char oldfd_r_[PADR_(l_uint)]; + char newfd_l_[PADL_(l_uint)]; l_uint newfd; char newfd_r_[PADR_(l_uint)]; + 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 { + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_perf_event_open_args { + syscallarg_t dummy; +}; +struct linux_preadv_args { + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char vec_l_[PADL_(struct iovec *)]; struct iovec * vec; char vec_r_[PADR_(struct iovec *)]; + char vlen_l_[PADL_(l_ulong)]; l_ulong vlen; char vlen_r_[PADR_(l_ulong)]; + char pos_l_l_[PADL_(l_ulong)]; l_ulong pos_l; char pos_l_r_[PADR_(l_ulong)]; + char pos_h_l_[PADL_(l_ulong)]; l_ulong pos_h; char pos_h_r_[PADR_(l_ulong)]; +}; +struct linux_pwritev_args { + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char vec_l_[PADL_(struct iovec *)]; struct iovec * vec; char vec_r_[PADR_(struct iovec *)]; + char vlen_l_[PADL_(l_ulong)]; l_ulong vlen; char vlen_r_[PADR_(l_ulong)]; + char pos_l_l_[PADL_(l_ulong)]; l_ulong pos_l; char pos_l_r_[PADR_(l_ulong)]; + char pos_h_l_[PADL_(l_ulong)]; l_ulong pos_h; char pos_h_r_[PADR_(l_ulong)]; +}; +struct linux_rt_tgsigqueueinfo_args { + char tgid_l_[PADL_(l_pid_t)]; l_pid_t tgid; char tgid_r_[PADR_(l_pid_t)]; + char tid_l_[PADL_(l_pid_t)]; l_pid_t tid; char tid_r_[PADR_(l_pid_t)]; + char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; + char uinfo_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * uinfo; char uinfo_r_[PADR_(l_siginfo_t *)]; +}; +struct linux_fanotify_init_args { + syscallarg_t dummy; +}; +struct linux_fanotify_mark_args { + syscallarg_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_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_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_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_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_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_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_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_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; + 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_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; + 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_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_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_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_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +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_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_recvmmsg_args { + char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; + char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)]; + char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; + char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; +}; +struct linux_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_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_name_to_handle_at_args { + char dirfd_l_[PADL_(l_int)]; l_int dirfd; char dirfd_r_[PADR_(l_int)]; + char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; + char handle_l_[PADL_(struct l_file_handle *)]; struct l_file_handle * handle; char handle_r_[PADR_(struct l_file_handle *)]; + char mnt_id_l_[PADL_(l_int *)]; l_int * mnt_id; char mnt_id_r_[PADR_(l_int *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_open_by_handle_at_args { + char mountdirfd_l_[PADL_(l_int)]; l_int mountdirfd; char mountdirfd_r_[PADR_(l_int)]; + char handle_l_[PADL_(struct l_file_handle *)]; struct l_file_handle * handle; char handle_r_[PADR_(struct l_file_handle *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_clock_adjtime_args { + syscallarg_t dummy; +}; +struct linux_syncfs_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; +}; +struct linux_sendmmsg_args { + char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; + char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)]; + char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_setns_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char nstype_l_[PADL_(l_int)]; l_int nstype; char nstype_r_[PADR_(l_int)]; +}; +struct linux_process_vm_readv_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char lvec_l_[PADL_(const struct iovec *)]; const struct iovec * lvec; char lvec_r_[PADR_(const struct iovec *)]; + char liovcnt_l_[PADL_(l_ulong)]; l_ulong liovcnt; char liovcnt_r_[PADR_(l_ulong)]; + char rvec_l_[PADL_(const struct iovec *)]; const struct iovec * rvec; char rvec_r_[PADR_(const struct iovec *)]; + char riovcnt_l_[PADL_(l_ulong)]; l_ulong riovcnt; char riovcnt_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; +}; +struct linux_process_vm_writev_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char lvec_l_[PADL_(const struct iovec *)]; const struct iovec * lvec; char lvec_r_[PADR_(const struct iovec *)]; + char liovcnt_l_[PADL_(l_ulong)]; l_ulong liovcnt; char liovcnt_r_[PADR_(l_ulong)]; + char rvec_l_[PADL_(const struct iovec *)]; const struct iovec * rvec; char rvec_r_[PADR_(const struct iovec *)]; + char riovcnt_l_[PADL_(l_ulong)]; l_ulong riovcnt; char riovcnt_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; +}; +struct linux_finit_module_args { + char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; + char uargs_l_[PADL_(const char *)]; const char * uargs; char uargs_r_[PADR_(const char *)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_kcmp_args { + char pid1_l_[PADL_(l_pid_t)]; l_pid_t pid1; char pid1_r_[PADR_(l_pid_t)]; + char pid2_l_[PADL_(l_pid_t)]; l_pid_t pid2; char pid2_r_[PADR_(l_pid_t)]; + char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)]; + char idx1_l_[PADL_(l_ulong)]; l_ulong idx1; char idx1_r_[PADR_(l_ulong)]; + char idx_l_[PADL_(l_ulong)]; l_ulong idx; char idx_r_[PADR_(l_ulong)]; +}; +struct linux_sched_setattr_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char attr_l_[PADL_(void *)]; void * attr; char attr_r_[PADR_(void *)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_sched_getattr_args { + char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; + char attr_l_[PADL_(void *)]; void * attr; char attr_r_[PADR_(void *)]; + char size_l_[PADL_(l_uint)]; l_uint size; char size_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_renameat2_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 flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_seccomp_args { + char op_l_[PADL_(l_uint)]; l_uint op; char op_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; + char uargs_l_[PADL_(const char *)]; const char * uargs; char uargs_r_[PADR_(const char *)]; +}; +struct linux_getrandom_args { + char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; + char count_l_[PADL_(l_size_t)]; l_size_t count; char count_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_memfd_create_args { + char uname_ptr_l_[PADL_(const char *)]; const char * uname_ptr; char uname_ptr_r_[PADR_(const char *)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_bpf_args { + char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)]; + char attr_l_[PADL_(void *)]; void * attr; char attr_r_[PADR_(void *)]; + char size_l_[PADL_(l_uint)]; l_uint size; char size_r_[PADR_(l_uint)]; +}; +struct linux_execveat_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 argv_l_[PADL_(const char **)]; const char ** argv; char argv_r_[PADR_(const char **)]; + char envp_l_[PADL_(const char **)]; const char ** envp; char envp_r_[PADR_(const char **)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_userfaultfd_args { + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_membarrier_args { + char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_mlock2_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 flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_copy_file_range_args { + char fd_in_l_[PADL_(l_int)]; l_int fd_in; char fd_in_r_[PADR_(l_int)]; + char off_in_l_[PADL_(l_loff_t *)]; l_loff_t * off_in; char off_in_r_[PADR_(l_loff_t *)]; + char fd_out_l_[PADL_(l_int)]; l_int fd_out; char fd_out_r_[PADR_(l_int)]; + char off_out_l_[PADL_(l_loff_t *)]; l_loff_t * off_out; char off_out_r_[PADR_(l_loff_t *)]; + char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_preadv2_args { + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char vec_l_[PADL_(const struct iovec *)]; const struct iovec * vec; char vec_r_[PADR_(const struct iovec *)]; + char vlen_l_[PADL_(l_ulong)]; l_ulong vlen; char vlen_r_[PADR_(l_ulong)]; + char pos_l_l_[PADL_(l_ulong)]; l_ulong pos_l; char pos_l_r_[PADR_(l_ulong)]; + char pos_h_l_[PADL_(l_ulong)]; l_ulong pos_h; char pos_h_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_pwritev2_args { + char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; + char vec_l_[PADL_(const struct iovec *)]; const struct iovec * vec; char vec_r_[PADR_(const struct iovec *)]; + char vlen_l_[PADL_(l_ulong)]; l_ulong vlen; char vlen_r_[PADR_(l_ulong)]; + char pos_l_l_[PADL_(l_ulong)]; l_ulong pos_l; char pos_l_r_[PADR_(l_ulong)]; + char pos_h_l_[PADL_(l_ulong)]; l_ulong pos_h; char pos_h_r_[PADR_(l_ulong)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_statx_args { + char dirfd_l_[PADL_(l_int)]; l_int dirfd; char dirfd_r_[PADR_(l_int)]; + char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; + char mask_l_[PADL_(l_uint)]; l_uint mask; char mask_r_[PADR_(l_uint)]; + char statxbuf_l_[PADL_(void *)]; void * statxbuf; char statxbuf_r_[PADR_(void *)]; +}; +struct linux_pkey_alloc_args { + char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)]; + char init_val_l_[PADL_(l_ulong)]; l_ulong init_val; char init_val_r_[PADR_(l_ulong)]; +}; +struct linux_pkey_free_args { + char pkey_l_[PADL_(l_int)]; l_int pkey; char pkey_r_[PADR_(l_int)]; +}; +struct linux_pkey_mprotect_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 prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)]; + char pkey_l_[PADL_(l_int)]; l_int pkey; char pkey_r_[PADR_(l_int)]; +}; +struct linux_rseq_args { + char rseq_l_[PADL_(struct linux_rseq *)]; struct linux_rseq * rseq; char rseq_r_[PADR_(struct linux_rseq *)]; + char rseq_len_l_[PADL_(uint32_t)]; uint32_t rseq_len; char rseq_len_r_[PADR_(uint32_t)]; + char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; + char sig_l_[PADL_(uint32_t)]; uint32_t sig; char sig_r_[PADR_(uint32_t)]; +}; +struct linux_io_pgetevents_args { + syscallarg_t dummy; +}; +struct linux_semtimedop_args { + char semid_l_[PADL_(l_int)]; l_int semid; char semid_r_[PADR_(l_int)]; + char tsops_l_[PADL_(struct sembuf *)]; struct sembuf * tsops; char tsops_r_[PADR_(struct sembuf *)]; + char nsops_l_[PADL_(l_size_t)]; l_size_t nsops; char nsops_r_[PADR_(l_size_t)]; + char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; +}; +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_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_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_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_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_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_pidfd_send_signal_args { + char pidfd_l_[PADL_(l_int)]; l_int pidfd; char pidfd_r_[PADR_(l_int)]; + 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 *)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_io_uring_setup_args { + syscallarg_t dummy; +}; +struct linux_io_uring_enter_args { + syscallarg_t dummy; +}; +struct linux_io_uring_register_args { + syscallarg_t dummy; +}; +struct linux_open_tree_args { + syscallarg_t dummy; +}; +struct linux_move_mount_args { + syscallarg_t dummy; +}; +struct linux_fsopen_args { + syscallarg_t dummy; +}; +struct linux_fsconfig_args { + syscallarg_t dummy; +}; +struct linux_fsmount_args { + syscallarg_t dummy; +}; +struct linux_fspick_args { + syscallarg_t dummy; +}; +struct linux_pidfd_open_args { + syscallarg_t dummy; +}; +struct linux_clone3_args { + char uargs_l_[PADL_(struct l_user_clone_args *)]; struct l_user_clone_args * uargs; char uargs_r_[PADR_(struct l_user_clone_args *)]; + char usize_l_[PADL_(l_size_t)]; l_size_t usize; char usize_r_[PADR_(l_size_t)]; +}; +struct linux_close_range_args { + char first_l_[PADL_(l_uint)]; l_uint first; char first_r_[PADR_(l_uint)]; + char last_l_[PADL_(l_uint)]; l_uint last; char last_r_[PADR_(l_uint)]; + char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; +}; +struct linux_openat2_args { + syscallarg_t dummy; +}; +struct linux_pidfd_getfd_args { + syscallarg_t dummy; +}; +struct linux_faccessat2_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 flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; +}; +struct linux_process_madvise_args { + syscallarg_t dummy; +}; +struct linux_epoll_pwait2_args { + char epfd_l_[PADL_(l_int)]; l_int epfd; char epfd_r_[PADR_(l_int)]; + char events_l_[PADL_(struct epoll_event *)]; struct epoll_event * events; char events_r_[PADR_(struct epoll_event *)]; + char maxevents_l_[PADL_(l_int)]; l_int maxevents; char maxevents_r_[PADR_(l_int)]; + char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; + char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_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_mount_setattr_args { + syscallarg_t dummy; +}; +struct linux_quotactl_fd_args { + syscallarg_t dummy; +}; +struct linux_landlock_create_ruleset_args { + syscallarg_t dummy; +}; +struct linux_landlock_add_rule_args { + syscallarg_t dummy; +}; +struct linux_landlock_restrict_self_args { + syscallarg_t dummy; +}; +struct linux_memfd_secret_args { + syscallarg_t dummy; +}; +struct linux_process_mrelease_args { + syscallarg_t dummy; +}; +struct linux_futex_waitv_args { + syscallarg_t dummy; +}; +struct linux_set_mempolicy_home_node_args { + syscallarg_t dummy; +}; +struct linux_cachestat_args { + syscallarg_t dummy; +}; +struct linux_fchmodat2_args { + syscallarg_t dummy; +}; +struct linux_map_shadow_stack_args { + syscallarg_t dummy; +}; +int linux_exit(struct thread *, struct linux_exit_args *); +int linux_fork(struct thread *, struct linux_fork_args *); +int linux_write(struct thread *, struct linux_write_args *); +int linux_open(struct thread *, struct linux_open_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_execve(struct thread *, struct linux_execve_args *); +int linux_chdir(struct thread *, struct linux_chdir_args *); +int linux_time(struct thread *, struct linux_time_args *); +int linux_mknod(struct thread *, struct linux_mknod_args *); +int linux_chmod(struct thread *, struct linux_chmod_args *); +int linux_lchown(struct thread *, struct linux_lchown_args *); +int linux_lseek(struct thread *, struct linux_lseek_args *); +int linux_getpid(struct thread *, struct linux_getpid_args *); +int linux_mount(struct thread *, struct linux_mount_args *); +int linux_umount(struct thread *, struct linux_umount_args *); +int linux_getuid(struct thread *, struct linux_getuid_args *); +int linux_ptrace(struct thread *, struct linux_ptrace_args *); +int linux_alarm(struct thread *, struct linux_alarm_args *); +int linux_pause(struct thread *, struct linux_pause_args *); +int linux_utime(struct thread *, struct linux_utime_args *); +int linux_access(struct thread *, struct linux_access_args *); +int linux_kill(struct thread *, struct linux_kill_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_pipe(struct thread *, struct linux_pipe_args *); +int linux_times(struct thread *, struct linux_times_args *); +int linux_brk(struct thread *, struct linux_brk_args *); +int linux_getgid(struct thread *, struct linux_getgid_args *); +int linux_ioctl(struct thread *, struct linux_ioctl_args *); +int linux_fcntl(struct thread *, struct linux_fcntl_args *); +int linux_ustat(struct thread *, struct linux_ustat_args *); +int linux_getppid(struct thread *, struct linux_getppid_args *); +int linux_sethostname(struct thread *, struct linux_sethostname_args *); +int linux_setrlimit(struct thread *, struct linux_setrlimit_args *); +int linux_getrlimit(struct thread *, struct linux_getrlimit_args *); +int linux_getgroups(struct thread *, struct linux_getgroups_args *); +int linux_setgroups(struct thread *, struct linux_setgroups_args *); +int linux_select(struct thread *, struct linux_select_args *); +int linux_symlink(struct thread *, struct linux_symlink_args *); +int linux_readlink(struct thread *, struct linux_readlink_args *); +int linux_reboot(struct thread *, struct linux_reboot_args *); +int linux_mmap(struct thread *, struct linux_mmap_args *); +int linux_truncate(struct thread *, struct linux_truncate_args *); +int linux_ftruncate(struct thread *, struct linux_ftruncate_args *); +int linux_getpriority(struct thread *, struct linux_getpriority_args *); +int linux_statfs(struct thread *, struct linux_statfs_args *); +int linux_fstatfs(struct thread *, struct linux_fstatfs_args *); +int linux_ioperm(struct thread *, struct linux_ioperm_args *); +int linux_syslog(struct thread *, struct linux_syslog_args *); +int linux_setitimer(struct thread *, struct linux_setitimer_args *); +int linux_getitimer(struct thread *, struct linux_getitimer_args *); +int linux_newstat(struct thread *, struct linux_newstat_args *); +int linux_newlstat(struct thread *, struct linux_newlstat_args *); +int linux_newfstat(struct thread *, struct linux_newfstat_args *); +int linux_iopl(struct thread *, struct linux_iopl_args *); +int linux_vhangup(struct thread *, struct linux_vhangup_args *); +int linux_wait4(struct thread *, struct linux_wait4_args *); +int linux_swapoff(struct thread *, struct linux_swapoff_args *); +int linux_sysinfo(struct thread *, struct linux_sysinfo_args *); +int linux_clone(struct thread *, struct linux_clone_args *); +int linux_setdomainname(struct thread *, struct linux_setdomainname_args *); +int linux_newuname(struct thread *, struct linux_newuname_args *); +int linux_modify_ldt(struct thread *, struct linux_modify_ldt_args *); +int linux_adjtimex(struct thread *, struct linux_adjtimex_args *); +int linux_mprotect(struct thread *, struct linux_mprotect_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_quotactl(struct thread *, struct linux_quotactl_args *); +int linux_personality(struct thread *, struct linux_personality_args *); +int linux_setfsuid(struct thread *, struct linux_setfsuid_args *); +int linux_setfsgid(struct thread *, struct linux_setfsgid_args *); +int linux_llseek(struct thread *, struct linux_llseek_args *); +int linux_getdents(struct thread *, struct linux_getdents_args *); +int linux_msync(struct thread *, struct linux_msync_args *); +int linux_writev(struct thread *, struct linux_writev_args *); +int linux_getsid(struct thread *, struct linux_getsid_args *); +int linux_fdatasync(struct thread *, struct linux_fdatasync_args *); +int linux_sysctl(struct thread *, struct linux_sysctl_args *); +int linux_sched_setparam(struct thread *, struct linux_sched_setparam_args *); +int linux_sched_getparam(struct thread *, struct linux_sched_getparam_args *); +int linux_sched_setscheduler(struct thread *, struct linux_sched_setscheduler_args *); +int linux_sched_getscheduler(struct thread *, struct linux_sched_getscheduler_args *); +int linux_sched_get_priority_max(struct thread *, struct linux_sched_get_priority_max_args *); +int linux_sched_get_priority_min(struct thread *, struct linux_sched_get_priority_min_args *); +int linux_sched_rr_get_interval(struct thread *, struct linux_sched_rr_get_interval_args *); +int linux_nanosleep(struct thread *, struct linux_nanosleep_args *); +int linux_mremap(struct thread *, struct linux_mremap_args *); +int linux_poll(struct thread *, struct linux_poll_args *); +int linux_prctl(struct thread *, struct linux_prctl_args *); +int linux_rt_sigreturn(struct thread *, struct linux_rt_sigreturn_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_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_pread(struct thread *, struct linux_pread_args *); +int linux_pwrite(struct thread *, struct linux_pwrite_args *); +int linux_chown(struct thread *, struct linux_chown_args *); +int linux_getcwd(struct thread *, struct linux_getcwd_args *); +int linux_capget(struct thread *, struct linux_capget_args *); +int linux_capset(struct thread *, struct linux_capset_args *); +int linux_sigaltstack(struct thread *, struct linux_sigaltstack_args *); +int linux_sendfile(struct thread *, struct linux_sendfile_args *); +int linux_vfork(struct thread *, struct linux_vfork_args *); +int linux_mmap2(struct thread *, struct linux_mmap2_args *); +int linux_getdents64(struct thread *, struct linux_getdents64_args *); +int linux_pivot_root(struct thread *, struct linux_pivot_root_args *); +int linux_madvise(struct thread *, struct linux_madvise_args *); +int linux_mincore(struct thread *, struct linux_mincore_args *); +int linux_gettid(struct thread *, struct linux_gettid_args *); +int linux_tkill(struct thread *, struct linux_tkill_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_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_tid_address(struct thread *, struct linux_set_tid_address_args *); +int linux_fadvise64(struct thread *, struct linux_fadvise64_args *); +int linux_exit_group(struct thread *, struct linux_exit_group_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(struct thread *, struct linux_epoll_ctl_args *); +int linux_epoll_wait(struct thread *, struct linux_epoll_wait_args *); +int linux_remap_file_pages(struct thread *, struct linux_remap_file_pages_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_tgkill(struct thread *, struct linux_tgkill_args *); +int linux_utimes(struct thread *, struct linux_utimes_args *); +int linux_statfs64(struct thread *, struct linux_statfs64_args *); +int linux_fstatfs64(struct thread *, struct linux_fstatfs64_args *); +int linux_migrate_pages(struct thread *, struct linux_migrate_pages_args *); +int linux_mbind(struct thread *, struct linux_mbind_args *); +int linux_get_mempolicy(struct thread *, struct linux_get_mempolicy_args *); +int linux_set_mempolicy(struct thread *, struct linux_set_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_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_waitid(struct thread *, struct linux_waitid_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_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_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_splice(struct thread *, struct linux_splice_args *); +int linux_tee(struct thread *, struct linux_tee_args *); +int linux_vmsplice(struct thread *, struct linux_vmsplice_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_get_robust_list(struct thread *, struct linux_get_robust_list_args *); +int linux_set_robust_list(struct thread *, struct linux_set_robust_list_args *); +int linux_move_pages(struct thread *, struct linux_move_pages_args *); +int linux_getcpu(struct thread *, struct linux_getcpu_args *); +int linux_epoll_pwait(struct thread *, struct linux_epoll_pwait_args *); +int linux_utimensat(struct thread *, struct linux_utimensat_args *); +int linux_timerfd_create(struct thread *, struct linux_timerfd_create_args *); +int linux_eventfd(struct thread *, struct linux_eventfd_args *); +int linux_sync_file_range(struct thread *, struct linux_sync_file_range_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_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_perf_event_open(struct thread *, struct linux_perf_event_open_args *); +int linux_preadv(struct thread *, struct linux_preadv_args *); +int linux_pwritev(struct thread *, struct linux_pwritev_args *); +int linux_rt_tgsigqueueinfo(struct thread *, struct linux_rt_tgsigqueueinfo_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_socket(struct thread *, struct linux_socket_args *); +int linux_bind(struct thread *, struct linux_bind_args *); +int linux_connect(struct thread *, struct linux_connect_args *); +int linux_listen(struct thread *, struct linux_listen_args *); +int linux_accept(struct thread *, struct linux_accept_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_sendto(struct thread *, struct linux_sendto_args *); +int linux_recvfrom(struct thread *, struct linux_recvfrom_args *); +int linux_shutdown(struct thread *, struct linux_shutdown_args *); +int linux_setsockopt(struct thread *, struct linux_setsockopt_args *); +int linux_getsockopt(struct thread *, struct linux_getsockopt_args *); +int linux_sendmsg(struct thread *, struct linux_sendmsg_args *); +int linux_recvmsg(struct thread *, struct linux_recvmsg_args *); +int linux_recvmmsg(struct thread *, struct linux_recvmmsg_args *); +int linux_accept4(struct thread *, struct linux_accept4_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_finit_module(struct thread *, struct linux_finit_module_args *); +int linux_kcmp(struct thread *, struct linux_kcmp_args *); +int linux_sched_setattr(struct thread *, struct linux_sched_setattr_args *); +int linux_sched_getattr(struct thread *, struct linux_sched_getattr_args *); +int linux_renameat2(struct thread *, struct linux_renameat2_args *); +int linux_seccomp(struct thread *, struct linux_seccomp_args *); +int linux_getrandom(struct thread *, struct linux_getrandom_args *); +int linux_memfd_create(struct thread *, struct linux_memfd_create_args *); +int linux_bpf(struct thread *, struct linux_bpf_args *); +int linux_execveat(struct thread *, struct linux_execveat_args *); +int linux_userfaultfd(struct thread *, struct linux_userfaultfd_args *); +int linux_membarrier(struct thread *, struct linux_membarrier_args *); +int linux_mlock2(struct thread *, struct linux_mlock2_args *); +int linux_copy_file_range(struct thread *, struct linux_copy_file_range_args *); +int linux_preadv2(struct thread *, struct linux_preadv2_args *); +int linux_pwritev2(struct thread *, struct linux_pwritev2_args *); +int linux_statx(struct thread *, struct linux_statx_args *); +int linux_pkey_alloc(struct thread *, struct linux_pkey_alloc_args *); +int linux_pkey_free(struct thread *, struct linux_pkey_free_args *); +int linux_pkey_mprotect(struct thread *, struct linux_pkey_mprotect_args *); +int linux_rseq(struct thread *, struct linux_rseq_args *); +int linux_io_pgetevents(struct thread *, struct linux_io_pgetevents_args *); +int linux_semtimedop(struct thread *, struct linux_semtimedop_args *); +int linux_semget(struct thread *, struct linux_semget_args *); +int linux_semctl(struct thread *, struct linux_semctl_args *); +int linux_shmget(struct thread *, struct linux_shmget_args *); +int linux_shmctl(struct thread *, struct linux_shmctl_args *); +int linux_shmat(struct thread *, struct linux_shmat_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_pidfd_send_signal(struct thread *, struct linux_pidfd_send_signal_args *); +int linux_io_uring_setup(struct thread *, struct linux_io_uring_setup_args *); +int linux_io_uring_enter(struct thread *, struct linux_io_uring_enter_args *); +int linux_io_uring_register(struct thread *, struct linux_io_uring_register_args *); +int linux_open_tree(struct thread *, struct linux_open_tree_args *); +int linux_move_mount(struct thread *, struct linux_move_mount_args *); +int linux_fsopen(struct thread *, struct linux_fsopen_args *); +int linux_fsconfig(struct thread *, struct linux_fsconfig_args *); +int linux_fsmount(struct thread *, struct linux_fsmount_args *); +int linux_fspick(struct thread *, struct linux_fspick_args *); +int linux_pidfd_open(struct thread *, struct linux_pidfd_open_args *); +int linux_clone3(struct thread *, struct linux_clone3_args *); +int linux_close_range(struct thread *, struct linux_close_range_args *); +int linux_openat2(struct thread *, struct linux_openat2_args *); +int linux_pidfd_getfd(struct thread *, struct linux_pidfd_getfd_args *); +int linux_faccessat2(struct thread *, struct linux_faccessat2_args *); +int linux_process_madvise(struct thread *, struct linux_process_madvise_args *); +int linux_epoll_pwait2(struct thread *, struct linux_epoll_pwait2_args *); +int linux_mount_setattr(struct thread *, struct linux_mount_setattr_args *); +int linux_quotactl_fd(struct thread *, struct linux_quotactl_fd_args *); +int linux_landlock_create_ruleset(struct thread *, struct linux_landlock_create_ruleset_args *); +int linux_landlock_add_rule(struct thread *, struct linux_landlock_add_rule_args *); +int linux_landlock_restrict_self(struct thread *, struct linux_landlock_restrict_self_args *); +int linux_memfd_secret(struct thread *, struct linux_memfd_secret_args *); +int linux_process_mrelease(struct thread *, struct linux_process_mrelease_args *); +int linux_futex_waitv(struct thread *, struct linux_futex_waitv_args *); +int linux_set_mempolicy_home_node(struct thread *, struct linux_set_mempolicy_home_node_args *); +int linux_cachestat(struct thread *, struct linux_cachestat_args *); +int linux_fchmodat2(struct thread *, struct linux_fchmodat2_args *); +int linux_map_shadow_stack(struct thread *, struct linux_map_shadow_stack_args *); + +#ifdef COMPAT_43 + + +#endif /* COMPAT_43 */ + + +#ifdef COMPAT_FREEBSD4 + + +#endif /* COMPAT_FREEBSD4 */ + + +#ifdef COMPAT_FREEBSD6 + + +#endif /* COMPAT_FREEBSD6 */ + + +#ifdef COMPAT_FREEBSD7 + + +#endif /* COMPAT_FREEBSD7 */ + + +#ifdef COMPAT_FREEBSD10 + + +#endif /* COMPAT_FREEBSD10 */ + + +#ifdef COMPAT_FREEBSD11 + + +#endif /* COMPAT_FREEBSD11 */ + + +#ifdef COMPAT_FREEBSD12 + + +#endif /* COMPAT_FREEBSD12 */ + + +#ifdef COMPAT_FREEBSD13 + + +#endif /* COMPAT_FREEBSD13 */ + +#define LINUX_SYS_AUE_linux_exit AUE_EXIT +#define LINUX_SYS_AUE_linux_fork AUE_FORK +#define LINUX_SYS_AUE_linux_write AUE_NULL +#define LINUX_SYS_AUE_linux_open AUE_OPEN_RWTC +#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_execve AUE_EXECVE +#define LINUX_SYS_AUE_linux_chdir AUE_CHDIR +#define LINUX_SYS_AUE_linux_time AUE_NULL +#define LINUX_SYS_AUE_linux_mknod AUE_MKNOD +#define LINUX_SYS_AUE_linux_chmod AUE_CHMOD +#define LINUX_SYS_AUE_linux_lchown AUE_LCHOWN +#define LINUX_SYS_AUE_linux_lseek AUE_LSEEK +#define LINUX_SYS_AUE_linux_getpid AUE_GETPID +#define LINUX_SYS_AUE_linux_mount AUE_MOUNT +#define LINUX_SYS_AUE_linux_umount AUE_UMOUNT +#define LINUX_SYS_AUE_linux_getuid AUE_GETUID +#define LINUX_SYS_AUE_linux_ptrace AUE_PTRACE +#define LINUX_SYS_AUE_linux_alarm AUE_NULL +#define LINUX_SYS_AUE_linux_pause AUE_NULL +#define LINUX_SYS_AUE_linux_utime AUE_UTIME +#define LINUX_SYS_AUE_linux_access AUE_ACCESS +#define LINUX_SYS_AUE_linux_kill AUE_KILL +#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_pipe AUE_PIPE +#define LINUX_SYS_AUE_linux_times AUE_NULL +#define LINUX_SYS_AUE_linux_brk AUE_NULL +#define LINUX_SYS_AUE_linux_getgid AUE_GETGID +#define LINUX_SYS_AUE_linux_ioctl AUE_IOCTL +#define LINUX_SYS_AUE_linux_fcntl AUE_FCNTL +#define LINUX_SYS_AUE_linux_ustat AUE_NULL +#define LINUX_SYS_AUE_linux_getppid AUE_GETPPID +#define LINUX_SYS_AUE_linux_sethostname AUE_SYSCTL +#define LINUX_SYS_AUE_linux_setrlimit AUE_SETRLIMIT +#define LINUX_SYS_AUE_linux_getrlimit AUE_GETRLIMIT +#define LINUX_SYS_AUE_linux_getgroups AUE_GETGROUPS +#define LINUX_SYS_AUE_linux_setgroups AUE_SETGROUPS +#define LINUX_SYS_AUE_linux_select AUE_SELECT +#define LINUX_SYS_AUE_linux_symlink AUE_SYMLINK +#define LINUX_SYS_AUE_linux_readlink AUE_READLINK +#define LINUX_SYS_AUE_linux_reboot AUE_REBOOT +#define LINUX_SYS_AUE_linux_mmap AUE_MMAP +#define LINUX_SYS_AUE_linux_truncate AUE_TRUNCATE +#define LINUX_SYS_AUE_linux_ftruncate AUE_FTRUNCATE +#define LINUX_SYS_AUE_linux_getpriority AUE_GETPRIORITY +#define LINUX_SYS_AUE_linux_statfs AUE_STATFS +#define LINUX_SYS_AUE_linux_fstatfs AUE_FSTATFS +#define LINUX_SYS_AUE_linux_ioperm AUE_NULL +#define LINUX_SYS_AUE_linux_syslog AUE_NULL +#define LINUX_SYS_AUE_linux_setitimer AUE_SETITIMER +#define LINUX_SYS_AUE_linux_getitimer AUE_GETITIMER +#define LINUX_SYS_AUE_linux_newstat AUE_STAT +#define LINUX_SYS_AUE_linux_newlstat AUE_LSTAT +#define LINUX_SYS_AUE_linux_newfstat AUE_FSTAT +#define LINUX_SYS_AUE_linux_iopl AUE_NULL +#define LINUX_SYS_AUE_linux_vhangup AUE_NULL +#define LINUX_SYS_AUE_linux_wait4 AUE_WAIT4 +#define LINUX_SYS_AUE_linux_swapoff AUE_SWAPOFF +#define LINUX_SYS_AUE_linux_sysinfo AUE_NULL +#define LINUX_SYS_AUE_linux_clone AUE_RFORK +#define LINUX_SYS_AUE_linux_setdomainname AUE_SYSCTL +#define LINUX_SYS_AUE_linux_newuname AUE_NULL +#define LINUX_SYS_AUE_linux_modify_ldt AUE_NULL +#define LINUX_SYS_AUE_linux_adjtimex AUE_ADJTIME +#define LINUX_SYS_AUE_linux_mprotect AUE_MPROTECT +#define LINUX_SYS_AUE_linux_init_module AUE_NULL +#define LINUX_SYS_AUE_linux_delete_module AUE_NULL +#define LINUX_SYS_AUE_linux_quotactl AUE_QUOTACTL +#define LINUX_SYS_AUE_linux_personality AUE_PERSONALITY +#define LINUX_SYS_AUE_linux_setfsuid AUE_SETFSUID +#define LINUX_SYS_AUE_linux_setfsgid AUE_SETFSGID +#define LINUX_SYS_AUE_linux_llseek AUE_LSEEK +#define LINUX_SYS_AUE_linux_getdents AUE_GETDIRENTRIES +#define LINUX_SYS_AUE_linux_msync AUE_MSYNC +#define LINUX_SYS_AUE_linux_writev AUE_WRITEV +#define LINUX_SYS_AUE_linux_getsid AUE_GETSID +#define LINUX_SYS_AUE_linux_fdatasync AUE_NULL +#define LINUX_SYS_AUE_linux_sysctl AUE_SYSCTL +#define LINUX_SYS_AUE_linux_sched_setparam AUE_SCHED_SETPARAM +#define LINUX_SYS_AUE_linux_sched_getparam AUE_SCHED_GETPARAM +#define LINUX_SYS_AUE_linux_sched_setscheduler AUE_SCHED_SETSCHEDULER +#define LINUX_SYS_AUE_linux_sched_getscheduler AUE_SCHED_GETSCHEDULER +#define LINUX_SYS_AUE_linux_sched_get_priority_max AUE_SCHED_GET_PRIORITY_MAX +#define LINUX_SYS_AUE_linux_sched_get_priority_min AUE_SCHED_GET_PRIORITY_MIN +#define LINUX_SYS_AUE_linux_sched_rr_get_interval AUE_SCHED_RR_GET_INTERVAL +#define LINUX_SYS_AUE_linux_nanosleep AUE_NULL +#define LINUX_SYS_AUE_linux_mremap AUE_NULL +#define LINUX_SYS_AUE_linux_poll AUE_POLL +#define LINUX_SYS_AUE_linux_prctl AUE_PRCTL +#define LINUX_SYS_AUE_linux_rt_sigreturn 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_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_pread AUE_PREAD +#define LINUX_SYS_AUE_linux_pwrite AUE_PWRITE +#define LINUX_SYS_AUE_linux_chown AUE_LCHOWN +#define LINUX_SYS_AUE_linux_getcwd AUE_GETCWD +#define LINUX_SYS_AUE_linux_capget AUE_CAPGET +#define LINUX_SYS_AUE_linux_capset AUE_CAPSET +#define LINUX_SYS_AUE_linux_sigaltstack AUE_NULL +#define LINUX_SYS_AUE_linux_sendfile AUE_SENDFILE +#define LINUX_SYS_AUE_linux_vfork AUE_VFORK +#define LINUX_SYS_AUE_linux_mmap2 AUE_MMAP +#define LINUX_SYS_AUE_linux_getdents64 AUE_GETDIRENTRIES +#define LINUX_SYS_AUE_linux_pivot_root AUE_PIVOT_ROOT +#define LINUX_SYS_AUE_linux_madvise AUE_MADVISE +#define LINUX_SYS_AUE_linux_mincore AUE_MINCORE +#define LINUX_SYS_AUE_linux_gettid AUE_NULL +#define LINUX_SYS_AUE_linux_tkill 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_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_tid_address AUE_NULL +#define LINUX_SYS_AUE_linux_fadvise64 AUE_NULL +#define LINUX_SYS_AUE_linux_exit_group AUE_EXIT +#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 AUE_NULL +#define LINUX_SYS_AUE_linux_epoll_wait AUE_NULL +#define LINUX_SYS_AUE_linux_remap_file_pages 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_tgkill AUE_NULL +#define LINUX_SYS_AUE_linux_utimes AUE_UTIMES +#define LINUX_SYS_AUE_linux_statfs64 AUE_STATFS +#define LINUX_SYS_AUE_linux_fstatfs64 AUE_FSTATFS +#define LINUX_SYS_AUE_linux_migrate_pages AUE_NULL +#define LINUX_SYS_AUE_linux_mbind AUE_NULL +#define LINUX_SYS_AUE_linux_get_mempolicy AUE_NULL +#define LINUX_SYS_AUE_linux_set_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_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_waitid AUE_WAIT6 +#define LINUX_SYS_AUE_linux_ioprio_set AUE_SETPRIORITY +#define LINUX_SYS_AUE_linux_ioprio_get AUE_GETPRIORITY +#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_pselect6 AUE_SELECT +#define LINUX_SYS_AUE_linux_ppoll AUE_POLL +#define LINUX_SYS_AUE_linux_unshare AUE_NULL +#define LINUX_SYS_AUE_linux_splice AUE_NULL +#define LINUX_SYS_AUE_linux_tee AUE_NULL +#define LINUX_SYS_AUE_linux_vmsplice 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_get_robust_list AUE_NULL +#define LINUX_SYS_AUE_linux_set_robust_list AUE_NULL +#define LINUX_SYS_AUE_linux_move_pages AUE_NULL +#define LINUX_SYS_AUE_linux_getcpu AUE_NULL +#define LINUX_SYS_AUE_linux_epoll_pwait AUE_NULL +#define LINUX_SYS_AUE_linux_utimensat AUE_FUTIMESAT +#define LINUX_SYS_AUE_linux_timerfd_create AUE_NULL +#define LINUX_SYS_AUE_linux_eventfd AUE_NULL +#define LINUX_SYS_AUE_linux_sync_file_range 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_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_perf_event_open AUE_NULL +#define LINUX_SYS_AUE_linux_preadv AUE_NULL +#define LINUX_SYS_AUE_linux_pwritev AUE_NULL +#define LINUX_SYS_AUE_linux_rt_tgsigqueueinfo 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_socket AUE_SOCKET +#define LINUX_SYS_AUE_linux_bind AUE_BIND +#define LINUX_SYS_AUE_linux_connect AUE_CONNECT +#define LINUX_SYS_AUE_linux_listen AUE_LISTEN +#define LINUX_SYS_AUE_linux_accept AUE_ACCEPT +#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_sendto AUE_SENDTO +#define LINUX_SYS_AUE_linux_recvfrom AUE_RECVFROM +#define LINUX_SYS_AUE_linux_shutdown AUE_NULL +#define LINUX_SYS_AUE_linux_setsockopt AUE_SETSOCKOPT +#define LINUX_SYS_AUE_linux_getsockopt AUE_GETSOCKOPT +#define LINUX_SYS_AUE_linux_sendmsg AUE_SENDMSG +#define LINUX_SYS_AUE_linux_recvmsg AUE_RECVMSG +#define LINUX_SYS_AUE_linux_recvmmsg AUE_NULL +#define LINUX_SYS_AUE_linux_accept4 AUE_ACCEPT +#define LINUX_SYS_AUE_linux_name_to_handle_at AUE_NULL +#define LINUX_SYS_AUE_linux_open_by_handle_at AUE_NULL +#define LINUX_SYS_AUE_linux_clock_adjtime AUE_NULL +#define LINUX_SYS_AUE_linux_syncfs AUE_SYNC +#define LINUX_SYS_AUE_linux_sendmmsg AUE_NULL +#define LINUX_SYS_AUE_linux_setns AUE_NULL +#define LINUX_SYS_AUE_linux_process_vm_readv AUE_NULL +#define LINUX_SYS_AUE_linux_process_vm_writev AUE_NULL +#define LINUX_SYS_AUE_linux_finit_module AUE_NULL +#define LINUX_SYS_AUE_linux_kcmp AUE_NULL +#define LINUX_SYS_AUE_linux_sched_setattr AUE_NULL +#define LINUX_SYS_AUE_linux_sched_getattr AUE_NULL +#define LINUX_SYS_AUE_linux_renameat2 AUE_NULL +#define LINUX_SYS_AUE_linux_seccomp AUE_NULL +#define LINUX_SYS_AUE_linux_getrandom AUE_NULL +#define LINUX_SYS_AUE_linux_memfd_create AUE_NULL +#define LINUX_SYS_AUE_linux_bpf AUE_NULL +#define LINUX_SYS_AUE_linux_execveat AUE_NULL +#define LINUX_SYS_AUE_linux_userfaultfd AUE_NULL +#define LINUX_SYS_AUE_linux_membarrier AUE_NULL +#define LINUX_SYS_AUE_linux_mlock2 AUE_NULL +#define LINUX_SYS_AUE_linux_copy_file_range AUE_NULL +#define LINUX_SYS_AUE_linux_preadv2 AUE_NULL +#define LINUX_SYS_AUE_linux_pwritev2 AUE_NULL +#define LINUX_SYS_AUE_linux_statx AUE_NULL +#define LINUX_SYS_AUE_linux_pkey_alloc AUE_NULL +#define LINUX_SYS_AUE_linux_pkey_free AUE_NULL +#define LINUX_SYS_AUE_linux_pkey_mprotect AUE_NULL +#define LINUX_SYS_AUE_linux_rseq AUE_NULL +#define LINUX_SYS_AUE_linux_io_pgetevents AUE_NULL +#define LINUX_SYS_AUE_linux_semtimedop AUE_NULL +#define LINUX_SYS_AUE_linux_semget AUE_NULL +#define LINUX_SYS_AUE_linux_semctl AUE_NULL +#define LINUX_SYS_AUE_linux_shmget AUE_NULL +#define LINUX_SYS_AUE_linux_shmctl AUE_NULL +#define LINUX_SYS_AUE_linux_shmat 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_pidfd_send_signal AUE_NULL +#define LINUX_SYS_AUE_linux_io_uring_setup AUE_NULL +#define LINUX_SYS_AUE_linux_io_uring_enter AUE_NULL +#define LINUX_SYS_AUE_linux_io_uring_register AUE_NULL +#define LINUX_SYS_AUE_linux_open_tree AUE_NULL +#define LINUX_SYS_AUE_linux_move_mount AUE_NULL +#define LINUX_SYS_AUE_linux_fsopen AUE_NULL +#define LINUX_SYS_AUE_linux_fsconfig AUE_NULL +#define LINUX_SYS_AUE_linux_fsmount AUE_NULL +#define LINUX_SYS_AUE_linux_fspick AUE_NULL +#define LINUX_SYS_AUE_linux_pidfd_open AUE_NULL +#define LINUX_SYS_AUE_linux_clone3 AUE_NULL +#define LINUX_SYS_AUE_linux_close_range AUE_CLOSERANGE +#define LINUX_SYS_AUE_linux_openat2 AUE_NULL +#define LINUX_SYS_AUE_linux_pidfd_getfd AUE_NULL +#define LINUX_SYS_AUE_linux_faccessat2 AUE_NULL +#define LINUX_SYS_AUE_linux_process_madvise AUE_NULL +#define LINUX_SYS_AUE_linux_epoll_pwait2 AUE_NULL +#define LINUX_SYS_AUE_linux_mount_setattr AUE_NULL +#define LINUX_SYS_AUE_linux_quotactl_fd AUE_NULL +#define LINUX_SYS_AUE_linux_landlock_create_ruleset AUE_NULL +#define LINUX_SYS_AUE_linux_landlock_add_rule AUE_NULL +#define LINUX_SYS_AUE_linux_landlock_restrict_self AUE_NULL +#define LINUX_SYS_AUE_linux_memfd_secret AUE_NULL +#define LINUX_SYS_AUE_linux_process_mrelease AUE_NULL +#define LINUX_SYS_AUE_linux_futex_waitv AUE_NULL +#define LINUX_SYS_AUE_linux_set_mempolicy_home_node AUE_NULL +#define LINUX_SYS_AUE_linux_cachestat AUE_NULL +#define LINUX_SYS_AUE_linux_fchmodat2 AUE_NULL +#define LINUX_SYS_AUE_linux_map_shadow_stack AUE_NULL + +#undef PAD_ +#undef PADL_ +#undef PADR_ + +#endif /* !_LINUX_SYSPROTO_H_ */ diff --git a/sys/powerpc/linux/linux_sigframe.h b/sys/powerpc/linux/linux_sigframe.h new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_sigframe.h @@ -0,0 +1,189 @@ +/*- + * Copyright (c) 1994-1996 Søren Schmidt + * Copyright (c) 2018 Turing Robotic Industries Inc. + * Copyright (c) 2022 Dmitry Chagin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _POWERPC_LINUX_SIGFRAME_H_ +#define _POWERPC_LINUX_SIGFRAME_H_ + + +#define LINUX_ELF_NGREG 48 /* includes nip, msr, lr, etc. */ +#define LINUX_ELF_NFPREG 33 /* includes fpscr */ +#define LINUX_ELF_NVRREG 34 /* includes vscr & vrsave in split vectors */ +#define GP_REGS_SIZE min(sizeof(l_elf_greg_t64), sizeof(struct l_user_pt_regs)) +#define PT_SOFTE 39 + + +typedef unsigned long l_elf_greg_t64; +typedef l_elf_greg_t64 l_elf_gregset_t64[LINUX_ELF_NGREG]; +typedef l_elf_gregset_t64 l_elf_gregset_t; + +/* Floating point registers */ +typedef double l_elf_fpreg_t; +typedef l_elf_fpreg_t l_elf_fpregset_t[LINUX_ELF_NFPREG]; + +typedef struct { + unsigned int u[4]; +} __attribute__((aligned(16))) l__vector128; + +typedef l__vector128 l_elf_vrreg_t; + +struct l_user_pt_regs +{ + unsigned long gpr[32]; + unsigned long nip; + unsigned long msr; + unsigned long orig_gpr3; /* Used for restarting system calls */ + unsigned long ctr; + unsigned long link; + unsigned long xer; + unsigned long ccr; +#ifdef __powerpc64__ + unsigned long softe; /* Soft enabled/disabled */ +#else + unsigned long mq; /* 601 only (not used at present) */ + /* Used on APUS to hold IPL value. */ +#endif + unsigned long trap; /* Reason for being here */ + /* N.B. for critical exceptions on 4xx, the dar and dsisr + fields are overloaded to hold srr0 and srr1. */ + unsigned long dar; /* Fault registers */ + unsigned long dsisr; /* on 4xx/Book-E used for ESR */ + unsigned long result; /* Result of a system call */ +}; + + +struct l_sigcontext { + unsigned long _unused[4]; + int signal; +#ifdef __powerpc64__ + int _pad0; +#endif + unsigned long handler; + unsigned long oldmask; + struct l_user_pt_regs *regs; +#ifdef __powerpc64__ + l_elf_gregset_t gp_regs; + l_elf_fpregset_t fp_regs; +/* + * To maintain compatibility with current implementations the sigcontext is + * extended by appending a pointer (v_regs) to a quadword type (elf_vrreg_t) + * followed by an unstructured (vmx_reserve) field of 101 doublewords. This + * allows the array of vector registers to be quadword aligned independent of + * the alignment of the containing sigcontext or ucontext. It is the + * responsibility of the code setting the sigcontext to set this pointer to + * either NULL (if this processor does not support the VMX feature) or the + * address of the first quadword within the allocated (vmx_reserve) area. + * + * The pointer (v_regs) of vector type (elf_vrreg_t) is type compatible with + * an array of 34 quadword entries (elf_vrregset_t). The entries with + * indexes 0-31 contain the corresponding vector registers. The entry with + * index 32 contains the vscr as the last word (offset 12) within the + * quadword. This allows the vscr to be stored as either a quadword (since + * it must be copied via a vector register to/from storage) or as a word. + * The entry with index 33 contains the vrsave as the first word (offset 0) + * within the quadword. + * + * Part of the VSX data is stored here also by extending vmx_restore + * by an additional 32 double words. Architecturally the layout of + * the VSR registers and how they overlap on top of the legacy FPR and + * VR registers is shown below: + * + * VSR doubleword 0 VSR doubleword 1 + * ---------------------------------------------------------------- + * VSR[0] | FPR[0] | | + * ---------------------------------------------------------------- + * VSR[1] | FPR[1] | | + * ---------------------------------------------------------------- + * | ... | | + * | ... | | + * ---------------------------------------------------------------- + * VSR[30] | FPR[30] | | + * ---------------------------------------------------------------- + * VSR[31] | FPR[31] | | + * ---------------------------------------------------------------- + * VSR[32] | VR[0] | + * ---------------------------------------------------------------- + * VSR[33] | VR[1] | + * ---------------------------------------------------------------- + * | ... | + * | ... | + * ---------------------------------------------------------------- + * VSR[62] | VR[30] | + * ---------------------------------------------------------------- + * VSR[63] | VR[31] | + * ---------------------------------------------------------------- + * + * FPR/VSR 0-31 doubleword 0 is stored in fp_regs, and VMX/VSR 32-63 + * is stored at the start of vmx_reserve. vmx_reserve is extended for + * backwards compatility to store VSR 0-31 doubleword 1 after the VMX + * registers and vscr/vrsave. + */ + l_elf_vrreg_t *v_regs; + long vmx_reserve[LINUX_ELF_NVRREG + LINUX_ELF_NVRREG + 1 + 32]; +#endif +}; + +struct l_ucontext { + unsigned long uc_flags; + struct l_ucontext *uc_link; + l_stack_t uc_stack; + l_sigset_t uc_sigmask; + l_sigset_t _unused[15]; /* Allow for uc_sigmask growth */ + struct l_sigcontext uc_mcontext; /* last for extensibility */ +}; + + +#define LINUX_TRAMP_TRACEBACK 4 +#define LINUX_TRAMP_SIZE 7 +#define LINUX_USER_REDZONE_SIZE 512 + +struct l_rt_sigframe { + struct l_ucontext uc; + unsigned long _unused[2]; + unsigned int tramp[LINUX_TRAMP_SIZE]; + l_siginfo_t *pinfo; + void *puc; + l_siginfo_t info; + char abigap[LINUX_USER_REDZONE_SIZE]; +} __attribute__((__aligned__(16))); + + +struct l_sigframe { + struct l_rt_sigframe sf; + /* frame_record */ + uint64_t fp; + uint64_t lr; + ucontext_t f_uc; +}; + +#define LINUX__SIGNAL_FRAMESIZE 128 + +void __kernel_start_sigtramp_rt64(int, void*, void*, void*); + + +#endif /* _POWERPC_LINUX_SIGFRAME_H_ */ diff --git a/sys/powerpc/linux/linux_support.S b/sys/powerpc/linux/linux_support.S new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_support.S @@ -0,0 +1,73 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (C) 2018 Turing Robotic Industries Inc. + * Copyright (C) 2022 Dmitry Chagin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include + +#include + +#include "assym.inc" + +ENTRY(futex_xchgl) + li %r3, ENOTSUP + blr + nop +END(futex_xchgl) + +/* (int *)uaddr2 += oparg */ +ENTRY(futex_addl) + li %r3, ENOTSUP + blr + nop +END(futex_addl) + +/* (int *)uaddr2 |= oparg */ +ENTRY(futex_orl) + li %r3, ENOTSUP + blr + nop +END(futex_orl) + +/* (int *)uaddr2 &= oparg */ +ENTRY(futex_andl) + li %r3, ENOTSUP + blr + nop +END(futex_andl) + +/* (int *)uaddr2 ^= oparg */ +ENTRY(futex_xorl) + li %r3, ENOTSUP + blr + nop +END(futex_xorl) diff --git a/sys/powerpc/linux/linux_syscall.h b/sys/powerpc/linux/linux_syscall.h new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_syscall.h @@ -0,0 +1,348 @@ +/* + * System call numbers. + * + * DO NOT EDIT-- this file is automatically @generated. + */ + +#define LINUX_SYS_linux_exit 1 +#define LINUX_SYS_linux_fork 2 +#define LINUX_SYS_read 3 +#define LINUX_SYS_linux_write 4 +#define LINUX_SYS_linux_open 5 +#define LINUX_SYS_close 6 +#define LINUX_SYS_linux_creat 8 +#define LINUX_SYS_linux_link 9 +#define LINUX_SYS_linux_unlink 10 +#define LINUX_SYS_linux_execve 11 +#define LINUX_SYS_linux_chdir 12 +#define LINUX_SYS_linux_time 13 +#define LINUX_SYS_linux_mknod 14 +#define LINUX_SYS_linux_chmod 15 +#define LINUX_SYS_linux_lchown 16 +#define LINUX_SYS_linux_lseek 19 +#define LINUX_SYS_linux_getpid 20 +#define LINUX_SYS_linux_mount 21 +#define LINUX_SYS_linux_umount 22 +#define LINUX_SYS_setuid 23 +#define LINUX_SYS_linux_getuid 24 +#define LINUX_SYS_linux_ptrace 26 +#define LINUX_SYS_linux_alarm 27 +#define LINUX_SYS_linux_pause 29 +#define LINUX_SYS_linux_utime 30 +#define LINUX_SYS_linux_access 33 +#define LINUX_SYS_sync 36 +#define LINUX_SYS_linux_kill 37 +#define LINUX_SYS_linux_rename 38 +#define LINUX_SYS_linux_mkdir 39 +#define LINUX_SYS_linux_rmdir 40 +#define LINUX_SYS_dup 41 +#define LINUX_SYS_linux_pipe 42 +#define LINUX_SYS_linux_times 43 +#define LINUX_SYS_linux_brk 45 +#define LINUX_SYS_setgid 46 +#define LINUX_SYS_linux_getgid 47 +#define LINUX_SYS_geteuid 49 +#define LINUX_SYS_getegid 50 +#define LINUX_SYS_acct 51 +#define LINUX_SYS_linux_ioctl 54 +#define LINUX_SYS_linux_fcntl 55 +#define LINUX_SYS_setpgid 57 +#define LINUX_SYS_umask 60 +#define LINUX_SYS_chroot 61 +#define LINUX_SYS_linux_ustat 62 +#define LINUX_SYS_dup2 63 +#define LINUX_SYS_linux_getppid 64 +#define LINUX_SYS_getpgrp 65 +#define LINUX_SYS_setsid 66 +#define LINUX_SYS_setreuid 70 +#define LINUX_SYS_setregid 71 +#define LINUX_SYS_linux_sethostname 74 +#define LINUX_SYS_linux_setrlimit 75 +#define LINUX_SYS_linux_getrlimit 76 +#define LINUX_SYS_getrusage 77 +#define LINUX_SYS_gettimeofday 78 +#define LINUX_SYS_settimeofday 79 +#define LINUX_SYS_linux_getgroups 80 +#define LINUX_SYS_linux_setgroups 81 +#define LINUX_SYS_linux_select 82 +#define LINUX_SYS_linux_symlink 83 +#define LINUX_SYS_linux_readlink 85 +#define LINUX_SYS_swapon 87 +#define LINUX_SYS_linux_reboot 88 +#define LINUX_SYS_linux_mmap 90 +#define LINUX_SYS_munmap 91 +#define LINUX_SYS_linux_truncate 92 +#define LINUX_SYS_linux_ftruncate 93 +#define LINUX_SYS_fchmod 94 +#define LINUX_SYS_fchown 95 +#define LINUX_SYS_linux_getpriority 96 +#define LINUX_SYS_setpriority 97 +#define LINUX_SYS_linux_statfs 99 +#define LINUX_SYS_linux_fstatfs 100 +#define LINUX_SYS_linux_ioperm 101 +#define LINUX_SYS_linux_syslog 103 +#define LINUX_SYS_linux_setitimer 104 +#define LINUX_SYS_linux_getitimer 105 +#define LINUX_SYS_linux_newstat 106 +#define LINUX_SYS_linux_newlstat 107 +#define LINUX_SYS_linux_newfstat 108 +#define LINUX_SYS_linux_iopl 110 +#define LINUX_SYS_linux_vhangup 111 +#define LINUX_SYS_linux_wait4 114 +#define LINUX_SYS_linux_swapoff 115 +#define LINUX_SYS_linux_sysinfo 116 +#define LINUX_SYS_fsync 118 +#define LINUX_SYS_linux_clone 120 +#define LINUX_SYS_linux_setdomainname 121 +#define LINUX_SYS_linux_newuname 122 +#define LINUX_SYS_linux_modify_ldt 123 +#define LINUX_SYS_linux_adjtimex 124 +#define LINUX_SYS_linux_mprotect 125 +#define LINUX_SYS_linux_init_module 128 +#define LINUX_SYS_linux_delete_module 129 +#define LINUX_SYS_linux_quotactl 131 +#define LINUX_SYS_getpgid 132 +#define LINUX_SYS_fchdir 133 +#define LINUX_SYS_linux_personality 136 +#define LINUX_SYS_linux_setfsuid 138 +#define LINUX_SYS_linux_setfsgid 139 +#define LINUX_SYS_linux_llseek 140 +#define LINUX_SYS_linux_getdents 141 +#define LINUX_SYS_flock 143 +#define LINUX_SYS_linux_msync 144 +#define LINUX_SYS_readv 145 +#define LINUX_SYS_linux_writev 146 +#define LINUX_SYS_linux_getsid 147 +#define LINUX_SYS_linux_fdatasync 148 +#define LINUX_SYS_linux_sysctl 149 +#define LINUX_SYS_mlock 150 +#define LINUX_SYS_munlock 151 +#define LINUX_SYS_mlockall 152 +#define LINUX_SYS_munlockall 153 +#define LINUX_SYS_linux_sched_setparam 154 +#define LINUX_SYS_linux_sched_getparam 155 +#define LINUX_SYS_linux_sched_setscheduler 156 +#define LINUX_SYS_linux_sched_getscheduler 157 +#define LINUX_SYS_sched_yield 158 +#define LINUX_SYS_linux_sched_get_priority_max 159 +#define LINUX_SYS_linux_sched_get_priority_min 160 +#define LINUX_SYS_linux_sched_rr_get_interval 161 +#define LINUX_SYS_linux_nanosleep 162 +#define LINUX_SYS_linux_mremap 163 +#define LINUX_SYS_setresuid 164 +#define LINUX_SYS_getresuid 165 +#define LINUX_SYS_linux_poll 167 +#define LINUX_SYS_setresgid 169 +#define LINUX_SYS_getresgid 170 +#define LINUX_SYS_linux_prctl 171 +#define LINUX_SYS_linux_rt_sigreturn 172 +#define LINUX_SYS_linux_rt_sigaction 173 +#define LINUX_SYS_linux_rt_sigprocmask 174 +#define LINUX_SYS_linux_rt_sigpending 175 +#define LINUX_SYS_linux_rt_sigtimedwait 176 +#define LINUX_SYS_linux_rt_sigqueueinfo 177 +#define LINUX_SYS_linux_rt_sigsuspend 178 +#define LINUX_SYS_linux_pread 179 +#define LINUX_SYS_linux_pwrite 180 +#define LINUX_SYS_linux_chown 181 +#define LINUX_SYS_linux_getcwd 182 +#define LINUX_SYS_linux_capget 183 +#define LINUX_SYS_linux_capset 184 +#define LINUX_SYS_linux_sigaltstack 185 +#define LINUX_SYS_linux_sendfile 186 +#define LINUX_SYS_linux_vfork 189 +#define LINUX_SYS_linux_mmap2 192 +#define LINUX_SYS_linux_getdents64 202 +#define LINUX_SYS_linux_pivot_root 203 +#define LINUX_SYS_linux_madvise 205 +#define LINUX_SYS_linux_mincore 206 +#define LINUX_SYS_linux_gettid 207 +#define LINUX_SYS_linux_tkill 208 +#define LINUX_SYS_linux_setxattr 209 +#define LINUX_SYS_linux_lsetxattr 210 +#define LINUX_SYS_linux_fsetxattr 211 +#define LINUX_SYS_linux_getxattr 212 +#define LINUX_SYS_linux_lgetxattr 213 +#define LINUX_SYS_linux_fgetxattr 214 +#define LINUX_SYS_linux_listxattr 215 +#define LINUX_SYS_linux_llistxattr 216 +#define LINUX_SYS_linux_flistxattr 217 +#define LINUX_SYS_linux_removexattr 218 +#define LINUX_SYS_linux_lremovexattr 219 +#define LINUX_SYS_linux_fremovexattr 220 +#define LINUX_SYS_linux_sys_futex 221 +#define LINUX_SYS_linux_sched_setaffinity 222 +#define LINUX_SYS_linux_sched_getaffinity 223 +#define LINUX_SYS_linux_set_tid_address 232 +#define LINUX_SYS_linux_fadvise64 233 +#define LINUX_SYS_linux_exit_group 234 +#define LINUX_SYS_linux_lookup_dcookie 235 +#define LINUX_SYS_linux_epoll_create 236 +#define LINUX_SYS_linux_epoll_ctl 237 +#define LINUX_SYS_linux_epoll_wait 238 +#define LINUX_SYS_linux_remap_file_pages 239 +#define LINUX_SYS_linux_timer_create 240 +#define LINUX_SYS_linux_timer_settime 241 +#define LINUX_SYS_linux_timer_gettime 242 +#define LINUX_SYS_linux_timer_getoverrun 243 +#define LINUX_SYS_linux_timer_delete 244 +#define LINUX_SYS_linux_clock_settime 245 +#define LINUX_SYS_linux_clock_gettime 246 +#define LINUX_SYS_linux_clock_getres 247 +#define LINUX_SYS_linux_clock_nanosleep 248 +#define LINUX_SYS_linux_tgkill 250 +#define LINUX_SYS_linux_utimes 251 +#define LINUX_SYS_linux_statfs64 252 +#define LINUX_SYS_linux_fstatfs64 253 +#define LINUX_SYS_linux_migrate_pages 258 +#define LINUX_SYS_linux_mbind 259 +#define LINUX_SYS_linux_get_mempolicy 260 +#define LINUX_SYS_linux_set_mempolicy 261 +#define LINUX_SYS_linux_mq_open 262 +#define LINUX_SYS_linux_mq_unlink 263 +#define LINUX_SYS_linux_mq_timedsend 264 +#define LINUX_SYS_linux_mq_timedreceive 265 +#define LINUX_SYS_linux_mq_notify 266 +#define LINUX_SYS_linux_mq_getsetattr 267 +#define LINUX_SYS_linux_kexec_load 268 +#define LINUX_SYS_linux_add_key 269 +#define LINUX_SYS_linux_request_key 270 +#define LINUX_SYS_linux_keyctl 271 +#define LINUX_SYS_linux_waitid 272 +#define LINUX_SYS_linux_ioprio_set 273 +#define LINUX_SYS_linux_ioprio_get 274 +#define LINUX_SYS_linux_inotify_add_watch 276 +#define LINUX_SYS_linux_inotify_rm_watch 277 +#define LINUX_SYS_linux_pselect6 280 +#define LINUX_SYS_linux_ppoll 281 +#define LINUX_SYS_linux_unshare 282 +#define LINUX_SYS_linux_splice 283 +#define LINUX_SYS_linux_tee 284 +#define LINUX_SYS_linux_vmsplice 285 +#define LINUX_SYS_linux_openat 286 +#define LINUX_SYS_linux_mkdirat 287 +#define LINUX_SYS_linux_mknodat 288 +#define LINUX_SYS_linux_fchownat 289 +#define LINUX_SYS_linux_futimesat 290 +#define LINUX_SYS_linux_newfstatat 291 +#define LINUX_SYS_linux_unlinkat 292 +#define LINUX_SYS_linux_renameat 293 +#define LINUX_SYS_linux_linkat 294 +#define LINUX_SYS_linux_symlinkat 295 +#define LINUX_SYS_linux_readlinkat 296 +#define LINUX_SYS_linux_fchmodat 297 +#define LINUX_SYS_linux_faccessat 298 +#define LINUX_SYS_linux_get_robust_list 299 +#define LINUX_SYS_linux_set_robust_list 300 +#define LINUX_SYS_linux_move_pages 301 +#define LINUX_SYS_linux_getcpu 302 +#define LINUX_SYS_linux_epoll_pwait 303 +#define LINUX_SYS_linux_utimensat 304 +#define LINUX_SYS_linux_timerfd_create 306 +#define LINUX_SYS_linux_eventfd 307 +#define LINUX_SYS_linux_sync_file_range 308 +#define LINUX_SYS_linux_fallocate 309 +#define LINUX_SYS_linux_timerfd_settime 311 +#define LINUX_SYS_linux_timerfd_gettime 312 +#define LINUX_SYS_linux_signalfd4 313 +#define LINUX_SYS_linux_eventfd2 314 +#define LINUX_SYS_linux_epoll_create1 315 +#define LINUX_SYS_linux_dup3 316 +#define LINUX_SYS_linux_pipe2 317 +#define LINUX_SYS_linux_inotify_init1 318 +#define LINUX_SYS_linux_perf_event_open 319 +#define LINUX_SYS_linux_preadv 320 +#define LINUX_SYS_linux_pwritev 321 +#define LINUX_SYS_linux_rt_tgsigqueueinfo 322 +#define LINUX_SYS_linux_fanotify_init 323 +#define LINUX_SYS_linux_fanotify_mark 324 +#define LINUX_SYS_linux_prlimit64 325 +#define LINUX_SYS_linux_socket 326 +#define LINUX_SYS_linux_bind 327 +#define LINUX_SYS_linux_connect 328 +#define LINUX_SYS_linux_listen 329 +#define LINUX_SYS_linux_accept 330 +#define LINUX_SYS_linux_getsockname 331 +#define LINUX_SYS_linux_getpeername 332 +#define LINUX_SYS_linux_socketpair 333 +#define LINUX_SYS_linux_sendto 335 +#define LINUX_SYS_linux_recvfrom 337 +#define LINUX_SYS_linux_shutdown 338 +#define LINUX_SYS_linux_setsockopt 339 +#define LINUX_SYS_linux_getsockopt 340 +#define LINUX_SYS_linux_sendmsg 341 +#define LINUX_SYS_linux_recvmsg 342 +#define LINUX_SYS_linux_recvmmsg 343 +#define LINUX_SYS_linux_accept4 344 +#define LINUX_SYS_linux_name_to_handle_at 345 +#define LINUX_SYS_linux_open_by_handle_at 346 +#define LINUX_SYS_linux_clock_adjtime 347 +#define LINUX_SYS_linux_syncfs 348 +#define LINUX_SYS_linux_sendmmsg 349 +#define LINUX_SYS_linux_setns 350 +#define LINUX_SYS_linux_process_vm_readv 351 +#define LINUX_SYS_linux_process_vm_writev 352 +#define LINUX_SYS_linux_finit_module 353 +#define LINUX_SYS_linux_kcmp 354 +#define LINUX_SYS_linux_sched_setattr 355 +#define LINUX_SYS_linux_sched_getattr 356 +#define LINUX_SYS_linux_renameat2 357 +#define LINUX_SYS_linux_seccomp 358 +#define LINUX_SYS_linux_getrandom 359 +#define LINUX_SYS_linux_memfd_create 360 +#define LINUX_SYS_linux_bpf 361 +#define LINUX_SYS_linux_execveat 362 +#define LINUX_SYS_linux_userfaultfd 364 +#define LINUX_SYS_linux_membarrier 365 +#define LINUX_SYS_linux_mlock2 378 +#define LINUX_SYS_linux_copy_file_range 379 +#define LINUX_SYS_linux_preadv2 380 +#define LINUX_SYS_linux_pwritev2 381 +#define LINUX_SYS_linux_statx 383 +#define LINUX_SYS_linux_pkey_alloc 384 +#define LINUX_SYS_linux_pkey_free 385 +#define LINUX_SYS_linux_pkey_mprotect 386 +#define LINUX_SYS_linux_rseq 387 +#define LINUX_SYS_linux_io_pgetevents 388 +#define LINUX_SYS_linux_semtimedop 392 +#define LINUX_SYS_linux_semget 393 +#define LINUX_SYS_linux_semctl 394 +#define LINUX_SYS_linux_shmget 395 +#define LINUX_SYS_linux_shmctl 396 +#define LINUX_SYS_linux_shmat 397 +#define LINUX_SYS_linux_shmdt 398 +#define LINUX_SYS_linux_msgget 399 +#define LINUX_SYS_linux_msgsnd 400 +#define LINUX_SYS_linux_msgrcv 401 +#define LINUX_SYS_linux_msgctl 402 +#define LINUX_SYS_linux_pidfd_send_signal 424 +#define LINUX_SYS_linux_io_uring_setup 425 +#define LINUX_SYS_linux_io_uring_enter 426 +#define LINUX_SYS_linux_io_uring_register 427 +#define LINUX_SYS_linux_open_tree 428 +#define LINUX_SYS_linux_move_mount 429 +#define LINUX_SYS_linux_fsopen 430 +#define LINUX_SYS_linux_fsconfig 431 +#define LINUX_SYS_linux_fsmount 432 +#define LINUX_SYS_linux_fspick 433 +#define LINUX_SYS_linux_pidfd_open 434 +#define LINUX_SYS_linux_clone3 435 +#define LINUX_SYS_linux_close_range 436 +#define LINUX_SYS_linux_openat2 437 +#define LINUX_SYS_linux_pidfd_getfd 438 +#define LINUX_SYS_linux_faccessat2 439 +#define LINUX_SYS_linux_process_madvise 440 +#define LINUX_SYS_linux_epoll_pwait2 441 +#define LINUX_SYS_linux_mount_setattr 442 +#define LINUX_SYS_linux_quotactl_fd 443 +#define LINUX_SYS_linux_landlock_create_ruleset 444 +#define LINUX_SYS_linux_landlock_add_rule 445 +#define LINUX_SYS_linux_landlock_restrict_self 446 +#define LINUX_SYS_linux_memfd_secret 447 +#define LINUX_SYS_linux_process_mrelease 448 +#define LINUX_SYS_linux_futex_waitv 449 +#define LINUX_SYS_linux_set_mempolicy_home_node 450 +#define LINUX_SYS_linux_cachestat 451 +#define LINUX_SYS_linux_fchmodat2 452 +#define LINUX_SYS_linux_map_shadow_stack 453 +#define LINUX_SYS_MAXSYSCALL 454 diff --git a/sys/powerpc/linux/linux_syscalls.c b/sys/powerpc/linux/linux_syscalls.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_syscalls.c @@ -0,0 +1,462 @@ +/* + * System call names. + * + * DO NOT EDIT-- this file is automatically @generated. + */ + +const char *linux_syscallnames[] = { + "#0", /* 0 = restart_syscall */ + "linux_exit", /* 1 = linux_exit */ + "linux_fork", /* 2 = linux_fork */ + "read", /* 3 = read */ + "linux_write", /* 4 = linux_write */ + "linux_open", /* 5 = linux_open */ + "close", /* 6 = close */ + "#7", /* 7 = linux_waitpid */ + "linux_creat", /* 8 = linux_creat */ + "linux_link", /* 9 = linux_link */ + "linux_unlink", /* 10 = linux_unlink */ + "linux_execve", /* 11 = linux_execve */ + "linux_chdir", /* 12 = linux_chdir */ + "linux_time", /* 13 = linux_time */ + "linux_mknod", /* 14 = linux_mknod */ + "linux_chmod", /* 15 = linux_chmod */ + "linux_lchown", /* 16 = linux_lchown */ + "#17", /* 17 = linux_break */ + "#18", /* 18 = linux_oldstat */ + "linux_lseek", /* 19 = linux_lseek */ + "linux_getpid", /* 20 = linux_getpid */ + "linux_mount", /* 21 = linux_mount */ + "linux_umount", /* 22 = linux_umount */ + "setuid", /* 23 = setuid */ + "linux_getuid", /* 24 = linux_getuid */ + "#25", /* 25 = linux_stime */ + "linux_ptrace", /* 26 = linux_ptrace */ + "linux_alarm", /* 27 = linux_alarm */ + "#28", /* 28 = linux_oldfstat */ + "linux_pause", /* 29 = linux_pause */ + "linux_utime", /* 30 = linux_utime */ + "#31", /* 31 = linux_stty */ + "#32", /* 32 = linux_gtty */ + "linux_access", /* 33 = linux_access */ + "#34", /* 34 = linux_nice */ + "#35", /* 35 = linux_ftime */ + "sync", /* 36 = sync */ + "linux_kill", /* 37 = linux_kill */ + "linux_rename", /* 38 = linux_rename */ + "linux_mkdir", /* 39 = linux_mkdir */ + "linux_rmdir", /* 40 = linux_rmdir */ + "dup", /* 41 = dup */ + "linux_pipe", /* 42 = linux_pipe */ + "linux_times", /* 43 = linux_times */ + "#44", /* 44 = linux_prof */ + "linux_brk", /* 45 = linux_brk */ + "setgid", /* 46 = setgid */ + "linux_getgid", /* 47 = linux_getgid */ + "#48", /* 48 = linux_signal */ + "geteuid", /* 49 = geteuid */ + "getegid", /* 50 = getegid */ + "acct", /* 51 = acct */ + "#52", /* 52 = linux_umount2 */ + "#53", /* 53 = linux_lock */ + "linux_ioctl", /* 54 = linux_ioctl */ + "linux_fcntl", /* 55 = linux_fcntl */ + "#56", /* 56 = linux_mpx */ + "setpgid", /* 57 = setpgid */ + "#58", /* 58 = linux_ulimit */ + "#59", /* 59 = linux_olduname */ + "umask", /* 60 = umask */ + "chroot", /* 61 = chroot */ + "linux_ustat", /* 62 = linux_ustat */ + "dup2", /* 63 = dup2 */ + "linux_getppid", /* 64 = linux_getppid */ + "getpgrp", /* 65 = getpgrp */ + "setsid", /* 66 = setsid */ + "#67", /* 67 = linux_sigaction */ + "#68", /* 68 = linux_sgetmask */ + "#69", /* 69 = linux_ssetmask */ + "setreuid", /* 70 = setreuid */ + "setregid", /* 71 = setregid */ + "#72", /* 72 = linux_sigsuspend */ + "#73", /* 73 = linux_sigpending */ + "linux_sethostname", /* 74 = linux_sethostname */ + "linux_setrlimit", /* 75 = linux_setrlimit */ + "linux_getrlimit", /* 76 = linux_getrlimit */ + "getrusage", /* 77 = getrusage */ + "gettimeofday", /* 78 = gettimeofday */ + "settimeofday", /* 79 = settimeofday */ + "linux_getgroups", /* 80 = linux_getgroups */ + "linux_setgroups", /* 81 = linux_setgroups */ + "linux_select", /* 82 = linux_select */ + "linux_symlink", /* 83 = linux_symlink */ + "#84", /* 84 = linux_oldlstat */ + "linux_readlink", /* 85 = linux_readlink */ + "#86", /* 86 = linux_uselib */ + "swapon", /* 87 = swapon */ + "linux_reboot", /* 88 = linux_reboot */ + "#89", /* 89 = linux_readdir */ + "linux_mmap", /* 90 = linux_mmap */ + "munmap", /* 91 = munmap */ + "linux_truncate", /* 92 = linux_truncate */ + "linux_ftruncate", /* 93 = linux_ftruncate */ + "fchmod", /* 94 = fchmod */ + "fchown", /* 95 = fchown */ + "linux_getpriority", /* 96 = linux_getpriority */ + "setpriority", /* 97 = setpriority */ + "#98", /* 98 = linux_profil */ + "linux_statfs", /* 99 = linux_statfs */ + "linux_fstatfs", /* 100 = linux_fstatfs */ + "linux_ioperm", /* 101 = linux_ioperm */ + "#102", /* 102 = linux_socketcall */ + "linux_syslog", /* 103 = linux_syslog */ + "linux_setitimer", /* 104 = linux_setitimer */ + "linux_getitimer", /* 105 = linux_getitimer */ + "linux_newstat", /* 106 = linux_newstat */ + "linux_newlstat", /* 107 = linux_newlstat */ + "linux_newfstat", /* 108 = linux_newfstat */ + "#109", /* 109 = linux_olduname */ + "linux_iopl", /* 110 = linux_iopl */ + "linux_vhangup", /* 111 = linux_vhangup */ + "#112", /* 112 = linux_idle */ + "#113", /* 113 = linux_vm86 */ + "linux_wait4", /* 114 = linux_wait4 */ + "linux_swapoff", /* 115 = linux_swapoff */ + "linux_sysinfo", /* 116 = linux_sysinfo */ + "#117", /* 117 = linux_ipc */ + "fsync", /* 118 = fsync */ + "#119", /* 119 = linux_sigreturn */ + "linux_clone", /* 120 = linux_clone */ + "linux_setdomainname", /* 121 = linux_setdomainname */ + "linux_newuname", /* 122 = linux_newuname */ + "linux_modify_ldt", /* 123 = linux_modify_ldt */ + "linux_adjtimex", /* 124 = linux_adjtimex */ + "linux_mprotect", /* 125 = linux_mprotect */ + "#126", /* 126 = linux_sigprocmask */ + "#127", /* 127 = linux_create_module */ + "linux_init_module", /* 128 = linux_init_module */ + "linux_delete_module", /* 129 = linux_delete_module */ + "#130", /* 130 = linux_get_kernel_syms */ + "linux_quotactl", /* 131 = linux_quotactl */ + "getpgid", /* 132 = getpgid */ + "fchdir", /* 133 = fchdir */ + "#134", /* 134 = linux_bdflush */ + "#135", /* 135 = linux_sysfs */ + "linux_personality", /* 136 = linux_personality */ + "#137", /* 137 = linux_afs_syscall */ + "linux_setfsuid", /* 138 = linux_setfsuid */ + "linux_setfsgid", /* 139 = linux_setfsgid */ + "linux_llseek", /* 140 = linux_llseek */ + "linux_getdents", /* 141 = linux_getdents */ + "#142", /* 142 = linux__newselect */ + "flock", /* 143 = flock */ + "linux_msync", /* 144 = linux_msync */ + "readv", /* 145 = readv */ + "linux_writev", /* 146 = linux_writev */ + "linux_getsid", /* 147 = linux_getsid */ + "linux_fdatasync", /* 148 = linux_fdatasync */ + "linux_sysctl", /* 149 = linux_sysctl */ + "mlock", /* 150 = mlock */ + "munlock", /* 151 = munlock */ + "mlockall", /* 152 = mlockall */ + "munlockall", /* 153 = munlockall */ + "linux_sched_setparam", /* 154 = linux_sched_setparam */ + "linux_sched_getparam", /* 155 = linux_sched_getparam */ + "linux_sched_setscheduler", /* 156 = linux_sched_setscheduler */ + "linux_sched_getscheduler", /* 157 = linux_sched_getscheduler */ + "sched_yield", /* 158 = sched_yield */ + "linux_sched_get_priority_max", /* 159 = linux_sched_get_priority_max */ + "linux_sched_get_priority_min", /* 160 = linux_sched_get_priority_min */ + "linux_sched_rr_get_interval", /* 161 = linux_sched_rr_get_interval */ + "linux_nanosleep", /* 162 = linux_nanosleep */ + "linux_mremap", /* 163 = linux_mremap */ + "setresuid", /* 164 = setresuid */ + "getresuid", /* 165 = getresuid */ + "#166", /* 166 = linux_query_module */ + "linux_poll", /* 167 = linux_poll */ + "#168", /* 168 = linux_nfsservctl */ + "setresgid", /* 169 = setresgid */ + "getresgid", /* 170 = getresgid */ + "linux_prctl", /* 171 = linux_prctl */ + "linux_rt_sigreturn", /* 172 = linux_rt_sigreturn */ + "linux_rt_sigaction", /* 173 = linux_rt_sigaction */ + "linux_rt_sigprocmask", /* 174 = linux_rt_sigprocmask */ + "linux_rt_sigpending", /* 175 = linux_rt_sigpending */ + "linux_rt_sigtimedwait", /* 176 = linux_rt_sigtimedwait */ + "linux_rt_sigqueueinfo", /* 177 = linux_rt_sigqueueinfo */ + "linux_rt_sigsuspend", /* 178 = linux_rt_sigsuspend */ + "linux_pread", /* 179 = linux_pread */ + "linux_pwrite", /* 180 = linux_pwrite */ + "linux_chown", /* 181 = linux_chown */ + "linux_getcwd", /* 182 = linux_getcwd */ + "linux_capget", /* 183 = linux_capget */ + "linux_capset", /* 184 = linux_capset */ + "linux_sigaltstack", /* 185 = linux_sigaltstack */ + "linux_sendfile", /* 186 = linux_sendfile */ + "#187", /* 187 = linux_getpmsg */ + "#188", /* 188 = linux_putpmsg */ + "linux_vfork", /* 189 = linux_vfork */ + "#190", /* 190 = linux_ugetrlimit */ + "#191", /* 191 = linux_readahead */ + "linux_mmap2", /* 192 = linux_mmap2 */ + "#193", /* 193 = linux_truncate64 */ + "#194", /* 194 = linux_ftruncate64 */ + "#195", /* 195 = linux_stat64 */ + "#196", /* 196 = linux_lstat64 */ + "#197", /* 197 = linux_fstat64 */ + "#198", /* 198 = linux_pciconfig_read */ + "#199", /* 199 = linux_pciconfig_write */ + "#200", /* 200 = linux_pciconfig_iobase */ + "#201", /* 201 = linux_multiplexer */ + "linux_getdents64", /* 202 = linux_getdents64 */ + "linux_pivot_root", /* 203 = linux_pivot_root */ + "#204", /* 204 = linux_fcntl64 */ + "linux_madvise", /* 205 = linux_madvise */ + "linux_mincore", /* 206 = linux_mincore */ + "linux_gettid", /* 207 = linux_gettid */ + "linux_tkill", /* 208 = linux_tkill */ + "linux_setxattr", /* 209 = linux_setxattr */ + "linux_lsetxattr", /* 210 = linux_lsetxattr */ + "linux_fsetxattr", /* 211 = linux_fsetxattr */ + "linux_getxattr", /* 212 = linux_getxattr */ + "linux_lgetxattr", /* 213 = linux_lgetxattr */ + "linux_fgetxattr", /* 214 = linux_fgetxattr */ + "linux_listxattr", /* 215 = linux_listxattr */ + "linux_llistxattr", /* 216 = linux_llistxattr */ + "linux_flistxattr", /* 217 = linux_flistxattr */ + "linux_removexattr", /* 218 = linux_removexattr */ + "linux_lremovexattr", /* 219 = linux_lremovexattr */ + "linux_fremovexattr", /* 220 = linux_fremovexattr */ + "linux_sys_futex", /* 221 = linux_sys_futex */ + "linux_sched_setaffinity", /* 222 = linux_sched_setaffinity */ + "linux_sched_getaffinity", /* 223 = linux_sched_getaffinity */ + "#224", /* 224 = */ + "#225", /* 225 = linux_tuxcall */ + "#226", /* 226 = linux_sendfile64 */ + "#227", /* 227 = linux_io_setup */ + "#228", /* 228 = linux_io_destroy */ + "#229", /* 229 = linux_io_getevents */ + "#230", /* 230 = linux_io_submit */ + "#231", /* 231 = linux_io_cancel */ + "linux_set_tid_address", /* 232 = linux_set_tid_address */ + "linux_fadvise64", /* 233 = linux_fadvise64 */ + "linux_exit_group", /* 234 = linux_exit_group */ + "linux_lookup_dcookie", /* 235 = linux_lookup_dcookie */ + "linux_epoll_create", /* 236 = linux_epoll_create */ + "linux_epoll_ctl", /* 237 = linux_epoll_ctl */ + "linux_epoll_wait", /* 238 = linux_epoll_wait */ + "linux_remap_file_pages", /* 239 = linux_remap_file_pages */ + "linux_timer_create", /* 240 = linux_timer_create */ + "linux_timer_settime", /* 241 = linux_timer_settime */ + "linux_timer_gettime", /* 242 = linux_timer_gettime */ + "linux_timer_getoverrun", /* 243 = linux_timer_getoverrun */ + "linux_timer_delete", /* 244 = linux_timer_delete */ + "linux_clock_settime", /* 245 = linux_clock_settime */ + "linux_clock_gettime", /* 246 = linux_clock_gettime */ + "linux_clock_getres", /* 247 = linux_clock_getres */ + "linux_clock_nanosleep", /* 248 = linux_clock_nanosleep */ + "#249", /* 249 = linux_swapcontext */ + "linux_tgkill", /* 250 = linux_tgkill */ + "linux_utimes", /* 251 = linux_utimes */ + "linux_statfs64", /* 252 = linux_statfs64 */ + "linux_fstatfs64", /* 253 = linux_fstatfs64 */ + "#254", /* 254 = linux_fadvise64_64 */ + "#255", /* 255 = linux_rtas */ + "#256", /* 256 = linux_sys_debug_setcontext */ + "#257", /* 257 = */ + "linux_migrate_pages", /* 258 = linux_migrate_pages */ + "linux_mbind", /* 259 = linux_mbind */ + "linux_get_mempolicy", /* 260 = linux_get_mempolicy */ + "linux_set_mempolicy", /* 261 = linux_set_mempolicy */ + "linux_mq_open", /* 262 = linux_mq_open */ + "linux_mq_unlink", /* 263 = linux_mq_unlink */ + "linux_mq_timedsend", /* 264 = linux_mq_timedsend */ + "linux_mq_timedreceive", /* 265 = linux_mq_timedreceive */ + "linux_mq_notify", /* 266 = linux_mq_notify */ + "linux_mq_getsetattr", /* 267 = linux_mq_getsetattr */ + "linux_kexec_load", /* 268 = linux_kexec_load */ + "linux_add_key", /* 269 = linux_add_key */ + "linux_request_key", /* 270 = linux_request_key */ + "linux_keyctl", /* 271 = linux_keyctl */ + "linux_waitid", /* 272 = linux_waitid */ + "linux_ioprio_set", /* 273 = linux_ioprio_set */ + "linux_ioprio_get", /* 274 = linux_ioprio_get */ + "#275", /* 275 = linux_inotify_init */ + "linux_inotify_add_watch", /* 276 = linux_inotify_add_watch */ + "linux_inotify_rm_watch", /* 277 = linux_inotify_rm_watch */ + "#278", /* 278 = linux_spu_run */ + "#279", /* 279 = linux_spu_create */ + "linux_pselect6", /* 280 = linux_pselect6 */ + "linux_ppoll", /* 281 = linux_ppoll */ + "linux_unshare", /* 282 = linux_unshare */ + "linux_splice", /* 283 = linux_splice */ + "linux_tee", /* 284 = linux_tee */ + "linux_vmsplice", /* 285 = linux_vmsplice */ + "linux_openat", /* 286 = linux_openat */ + "linux_mkdirat", /* 287 = linux_mkdirat */ + "linux_mknodat", /* 288 = linux_mknodat */ + "linux_fchownat", /* 289 = linux_fchownat */ + "linux_futimesat", /* 290 = linux_futimesat */ + "linux_newfstatat", /* 291 = linux_newfstatat */ + "linux_unlinkat", /* 292 = linux_unlinkat */ + "linux_renameat", /* 293 = linux_renameat */ + "linux_linkat", /* 294 = linux_linkat */ + "linux_symlinkat", /* 295 = linux_symlinkat */ + "linux_readlinkat", /* 296 = linux_readlinkat */ + "linux_fchmodat", /* 297 = linux_fchmodat */ + "linux_faccessat", /* 298 = linux_faccessat */ + "linux_get_robust_list", /* 299 = linux_get_robust_list */ + "linux_set_robust_list", /* 300 = linux_set_robust_list */ + "linux_move_pages", /* 301 = linux_move_pages */ + "linux_getcpu", /* 302 = linux_getcpu */ + "linux_epoll_pwait", /* 303 = linux_epoll_pwait */ + "linux_utimensat", /* 304 = linux_utimensat */ + "#305", /* 305 = linux_signalfd */ + "linux_timerfd_create", /* 306 = linux_timerfd_create */ + "linux_eventfd", /* 307 = linux_eventfd */ + "linux_sync_file_range", /* 308 = linux_sync_file_range */ + "linux_fallocate", /* 309 = linux_fallocate */ + "#310", /* 310 = linux_subpage_prot */ + "linux_timerfd_settime", /* 311 = linux_timerfd_settime */ + "linux_timerfd_gettime", /* 312 = linux_timerfd_gettime */ + "linux_signalfd4", /* 313 = linux_signalfd4 */ + "linux_eventfd2", /* 314 = linux_eventfd2 */ + "linux_epoll_create1", /* 315 = linux_epoll_create1 */ + "linux_dup3", /* 316 = linux_dup3 */ + "linux_pipe2", /* 317 = linux_pipe2 */ + "linux_inotify_init1", /* 318 = linux_inotify_init1 */ + "linux_perf_event_open", /* 319 = linux_perf_event_open */ + "linux_preadv", /* 320 = linux_preadv */ + "linux_pwritev", /* 321 = linux_pwritev */ + "linux_rt_tgsigqueueinfo", /* 322 = linux_rt_tgsigqueueinfo */ + "linux_fanotify_init", /* 323 = linux_fanotify_init */ + "linux_fanotify_mark", /* 324 = linux_fanotify_mark */ + "linux_prlimit64", /* 325 = linux_prlimit64 */ + "linux_socket", /* 326 = linux_socket */ + "linux_bind", /* 327 = linux_bind */ + "linux_connect", /* 328 = linux_connect */ + "linux_listen", /* 329 = linux_listen */ + "linux_accept", /* 330 = linux_accept */ + "linux_getsockname", /* 331 = linux_getsockname */ + "linux_getpeername", /* 332 = linux_getpeername */ + "linux_socketpair", /* 333 = linux_socketpair */ + "#334", /* 334 = linux_send */ + "linux_sendto", /* 335 = linux_sendto */ + "#336", /* 336 = linux_recv */ + "linux_recvfrom", /* 337 = linux_recvfrom */ + "linux_shutdown", /* 338 = linux_shutdown */ + "linux_setsockopt", /* 339 = linux_setsockopt */ + "linux_getsockopt", /* 340 = linux_getsockopt */ + "linux_sendmsg", /* 341 = linux_sendmsg */ + "linux_recvmsg", /* 342 = linux_recvmsg */ + "linux_recvmmsg", /* 343 = linux_recvmmsg */ + "linux_accept4", /* 344 = linux_accept4 */ + "linux_name_to_handle_at", /* 345 = linux_name_to_handle_at */ + "linux_open_by_handle_at", /* 346 = linux_open_by_handle_at */ + "linux_clock_adjtime", /* 347 = linux_clock_adjtime */ + "linux_syncfs", /* 348 = linux_syncfs */ + "linux_sendmmsg", /* 349 = linux_sendmmsg */ + "linux_setns", /* 350 = linux_setns */ + "linux_process_vm_readv", /* 351 = linux_process_vm_readv */ + "linux_process_vm_writev", /* 352 = linux_process_vm_writev */ + "linux_finit_module", /* 353 = linux_finit_module */ + "linux_kcmp", /* 354 = linux_kcmp */ + "linux_sched_setattr", /* 355 = linux_sched_setattr */ + "linux_sched_getattr", /* 356 = linux_sched_getattr */ + "linux_renameat2", /* 357 = linux_renameat2 */ + "linux_seccomp", /* 358 = linux_seccomp */ + "linux_getrandom", /* 359 = linux_getrandom */ + "linux_memfd_create", /* 360 = linux_memfd_create */ + "linux_bpf", /* 361 = linux_bpf */ + "linux_execveat", /* 362 = linux_execveat */ + "#363", /* 363 = linux_switch_endian */ + "linux_userfaultfd", /* 364 = linux_userfaultfd */ + "linux_membarrier", /* 365 = linux_membarrier */ + "#366", /* 366 = */ + "#367", /* 367 = */ + "#368", /* 368 = */ + "#369", /* 369 = */ + "#370", /* 370 = */ + "#371", /* 371 = */ + "#372", /* 372 = */ + "#373", /* 373 = */ + "#374", /* 374 = */ + "#375", /* 375 = */ + "#376", /* 376 = */ + "#377", /* 377 = */ + "linux_mlock2", /* 378 = linux_mlock2 */ + "linux_copy_file_range", /* 379 = linux_copy_file_range */ + "linux_preadv2", /* 380 = linux_preadv2 */ + "linux_pwritev2", /* 381 = linux_pwritev2 */ + "#382", /* 382 = linux_kexec_file_load */ + "linux_statx", /* 383 = linux_statx */ + "linux_pkey_alloc", /* 384 = linux_pkey_alloc */ + "linux_pkey_free", /* 385 = linux_pkey_free */ + "linux_pkey_mprotect", /* 386 = linux_pkey_mprotect */ + "linux_rseq", /* 387 = linux_rseq */ + "linux_io_pgetevents", /* 388 = linux_io_pgetevents */ + "#389", /* 389 = */ + "#390", /* 390 = */ + "#391", /* 391 = */ + "linux_semtimedop", /* 392 = linux_semtimedop */ + "linux_semget", /* 393 = linux_semget */ + "linux_semctl", /* 394 = linux_semctl */ + "linux_shmget", /* 395 = linux_shmget */ + "linux_shmctl", /* 396 = linux_shmctl */ + "linux_shmat", /* 397 = linux_shmat */ + "linux_shmdt", /* 398 = linux_shmdt */ + "linux_msgget", /* 399 = linux_msgget */ + "linux_msgsnd", /* 400 = linux_msgsnd */ + "linux_msgrcv", /* 401 = linux_msgrcv */ + "linux_msgctl", /* 402 = linux_msgctl */ + "#403", /* 403 = linux_clock_gettime64 */ + "#404", /* 404 = linux_clock_settime64 */ + "#405", /* 405 = linux_clock_adjtime64 */ + "#406", /* 406 = linux_clock_getres_time64 */ + "#407", /* 407 = linux_clock_nanosleep_time64 */ + "#408", /* 408 = linux_timer_gettime64 */ + "#409", /* 409 = linux_timer_settime64 */ + "#410", /* 410 = linux_timerfd_gettime64 */ + "#411", /* 411 = linux_timerfd_settime64 */ + "#412", /* 412 = linux_utimensat_time64 */ + "#413", /* 413 = linux_pselect6_time64 */ + "#414", /* 414 = linux_ppoll_time64 */ + "#415", /* 415 = */ + "#416", /* 416 = linux_io_pgetevents_time64 */ + "#417", /* 417 = linux_recvmmsg_time64 */ + "#418", /* 418 = linux_mq_timedsend_time64 */ + "#419", /* 419 = linux_mq_timedreceive_time64 */ + "#420", /* 420 = linux_semtimedop_time64 */ + "#421", /* 421 = linux_rt_sigtimedwait_time64 */ + "#422", /* 422 = linux_futex_time64 */ + "#423", /* 423 = linux_sched_rr_get_interval_time64 */ + "linux_pidfd_send_signal", /* 424 = linux_pidfd_send_signal */ + "linux_io_uring_setup", /* 425 = linux_io_uring_setup */ + "linux_io_uring_enter", /* 426 = linux_io_uring_enter */ + "linux_io_uring_register", /* 427 = linux_io_uring_register */ + "linux_open_tree", /* 428 = linux_open_tree */ + "linux_move_mount", /* 429 = linux_move_mount */ + "linux_fsopen", /* 430 = linux_fsopen */ + "linux_fsconfig", /* 431 = linux_fsconfig */ + "linux_fsmount", /* 432 = linux_fsmount */ + "linux_fspick", /* 433 = linux_fspick */ + "linux_pidfd_open", /* 434 = linux_pidfd_open */ + "linux_clone3", /* 435 = linux_clone3 */ + "linux_close_range", /* 436 = linux_close_range */ + "linux_openat2", /* 437 = linux_openat2 */ + "linux_pidfd_getfd", /* 438 = linux_pidfd_getfd */ + "linux_faccessat2", /* 439 = linux_faccessat2 */ + "linux_process_madvise", /* 440 = linux_process_madvise */ + "linux_epoll_pwait2", /* 441 = linux_epoll_pwait2 */ + "linux_mount_setattr", /* 442 = linux_mount_setattr */ + "linux_quotactl_fd", /* 443 = linux_quotactl_fd */ + "linux_landlock_create_ruleset", /* 444 = linux_landlock_create_ruleset */ + "linux_landlock_add_rule", /* 445 = linux_landlock_add_rule */ + "linux_landlock_restrict_self", /* 446 = linux_landlock_restrict_self */ + "linux_memfd_secret", /* 447 = linux_memfd_secret */ + "linux_process_mrelease", /* 448 = linux_process_mrelease */ + "linux_futex_waitv", /* 449 = linux_futex_waitv */ + "linux_set_mempolicy_home_node", /* 450 = linux_set_mempolicy_home_node */ + "linux_cachestat", /* 451 = linux_cachestat */ + "linux_fchmodat2", /* 452 = linux_fchmodat2 */ + "linux_map_shadow_stack", /* 453 = linux_map_shadow_stack */ +}; diff --git a/sys/powerpc/linux/linux_sysent.c b/sys/powerpc/linux/linux_sysent.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_sysent.c @@ -0,0 +1,471 @@ +/* + * System call switch table. + * + * DO NOT EDIT-- this file is automatically @generated. + */ + +#include +#include +#include +#include +#include + +#define AS(name) (sizeof(struct name) / sizeof(syscallarg_t)) + +/* The casts are bogus but will do for now. */ +struct sysent linux_sysent[] = { + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 0 = restart_syscall */ + { .sy_narg = AS(linux_exit_args), .sy_call = (sy_call_t *)linux_exit, .sy_auevent = AUE_EXIT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 1 = linux_exit */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fork, .sy_auevent = AUE_FORK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 2 = linux_fork */ + { .sy_narg = AS(read_args), .sy_call = (sy_call_t *)sys_read, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 3 = read */ + { .sy_narg = AS(linux_write_args), .sy_call = (sy_call_t *)linux_write, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 4 = linux_write */ + { .sy_narg = AS(linux_open_args), .sy_call = (sy_call_t *)linux_open, .sy_auevent = AUE_OPEN_RWTC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 5 = linux_open */ + { .sy_narg = AS(close_args), .sy_call = (sy_call_t *)sys_close, .sy_auevent = AUE_CLOSE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 6 = close */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 7 = linux_waitpid */ + { .sy_narg = AS(linux_creat_args), .sy_call = (sy_call_t *)linux_creat, .sy_auevent = AUE_CREAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 8 = linux_creat */ + { .sy_narg = AS(linux_link_args), .sy_call = (sy_call_t *)linux_link, .sy_auevent = AUE_LINK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 9 = linux_link */ + { .sy_narg = AS(linux_unlink_args), .sy_call = (sy_call_t *)linux_unlink, .sy_auevent = AUE_UNLINK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 10 = linux_unlink */ + { .sy_narg = AS(linux_execve_args), .sy_call = (sy_call_t *)linux_execve, .sy_auevent = AUE_EXECVE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 11 = linux_execve */ + { .sy_narg = AS(linux_chdir_args), .sy_call = (sy_call_t *)linux_chdir, .sy_auevent = AUE_CHDIR, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 12 = linux_chdir */ + { .sy_narg = AS(linux_time_args), .sy_call = (sy_call_t *)linux_time, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 13 = linux_time */ + { .sy_narg = AS(linux_mknod_args), .sy_call = (sy_call_t *)linux_mknod, .sy_auevent = AUE_MKNOD, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 14 = linux_mknod */ + { .sy_narg = AS(linux_chmod_args), .sy_call = (sy_call_t *)linux_chmod, .sy_auevent = AUE_CHMOD, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 15 = linux_chmod */ + { .sy_narg = AS(linux_lchown_args), .sy_call = (sy_call_t *)linux_lchown, .sy_auevent = AUE_LCHOWN, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 16 = linux_lchown */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 17 = linux_break */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 18 = linux_oldstat */ + { .sy_narg = AS(linux_lseek_args), .sy_call = (sy_call_t *)linux_lseek, .sy_auevent = AUE_LSEEK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 19 = linux_lseek */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_getpid, .sy_auevent = AUE_GETPID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 20 = linux_getpid */ + { .sy_narg = AS(linux_mount_args), .sy_call = (sy_call_t *)linux_mount, .sy_auevent = AUE_MOUNT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 21 = linux_mount */ + { .sy_narg = AS(linux_umount_args), .sy_call = (sy_call_t *)linux_umount, .sy_auevent = AUE_UMOUNT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 22 = linux_umount */ + { .sy_narg = AS(setuid_args), .sy_call = (sy_call_t *)sys_setuid, .sy_auevent = AUE_SETUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 23 = setuid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_getuid, .sy_auevent = AUE_GETUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 24 = linux_getuid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 25 = linux_stime */ + { .sy_narg = AS(linux_ptrace_args), .sy_call = (sy_call_t *)linux_ptrace, .sy_auevent = AUE_PTRACE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 26 = linux_ptrace */ + { .sy_narg = AS(linux_alarm_args), .sy_call = (sy_call_t *)linux_alarm, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 27 = linux_alarm */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 28 = linux_oldfstat */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_pause, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 29 = linux_pause */ + { .sy_narg = AS(linux_utime_args), .sy_call = (sy_call_t *)linux_utime, .sy_auevent = AUE_UTIME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 30 = linux_utime */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 31 = linux_stty */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 32 = linux_gtty */ + { .sy_narg = AS(linux_access_args), .sy_call = (sy_call_t *)linux_access, .sy_auevent = AUE_ACCESS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 33 = linux_access */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 34 = linux_nice */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 35 = linux_ftime */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_sync, .sy_auevent = AUE_SYNC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 36 = sync */ + { .sy_narg = AS(linux_kill_args), .sy_call = (sy_call_t *)linux_kill, .sy_auevent = AUE_KILL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 37 = linux_kill */ + { .sy_narg = AS(linux_rename_args), .sy_call = (sy_call_t *)linux_rename, .sy_auevent = AUE_RENAME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 38 = linux_rename */ + { .sy_narg = AS(linux_mkdir_args), .sy_call = (sy_call_t *)linux_mkdir, .sy_auevent = AUE_MKDIR, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 39 = linux_mkdir */ + { .sy_narg = AS(linux_rmdir_args), .sy_call = (sy_call_t *)linux_rmdir, .sy_auevent = AUE_RMDIR, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 40 = linux_rmdir */ + { .sy_narg = AS(dup_args), .sy_call = (sy_call_t *)sys_dup, .sy_auevent = AUE_DUP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 41 = dup */ + { .sy_narg = AS(linux_pipe_args), .sy_call = (sy_call_t *)linux_pipe, .sy_auevent = AUE_PIPE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 42 = linux_pipe */ + { .sy_narg = AS(linux_times_args), .sy_call = (sy_call_t *)linux_times, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 43 = linux_times */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 44 = linux_prof */ + { .sy_narg = AS(linux_brk_args), .sy_call = (sy_call_t *)linux_brk, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 45 = linux_brk */ + { .sy_narg = AS(setgid_args), .sy_call = (sy_call_t *)sys_setgid, .sy_auevent = AUE_SETGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 46 = setgid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_getgid, .sy_auevent = AUE_GETGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 47 = linux_getgid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 48 = linux_signal */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_geteuid, .sy_auevent = AUE_GETEUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 49 = geteuid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_getegid, .sy_auevent = AUE_GETEGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 50 = getegid */ + { .sy_narg = AS(acct_args), .sy_call = (sy_call_t *)sys_acct, .sy_auevent = AUE_ACCT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 51 = acct */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 52 = linux_umount2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 53 = linux_lock */ + { .sy_narg = AS(linux_ioctl_args), .sy_call = (sy_call_t *)linux_ioctl, .sy_auevent = AUE_IOCTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 54 = linux_ioctl */ + { .sy_narg = AS(linux_fcntl_args), .sy_call = (sy_call_t *)linux_fcntl, .sy_auevent = AUE_FCNTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 55 = linux_fcntl */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 56 = linux_mpx */ + { .sy_narg = AS(setpgid_args), .sy_call = (sy_call_t *)sys_setpgid, .sy_auevent = AUE_SETPGRP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 57 = setpgid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 58 = linux_ulimit */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 59 = linux_olduname */ + { .sy_narg = AS(umask_args), .sy_call = (sy_call_t *)sys_umask, .sy_auevent = AUE_UMASK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 60 = umask */ + { .sy_narg = AS(chroot_args), .sy_call = (sy_call_t *)sys_chroot, .sy_auevent = AUE_CHROOT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 61 = chroot */ + { .sy_narg = AS(linux_ustat_args), .sy_call = (sy_call_t *)linux_ustat, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 62 = linux_ustat */ + { .sy_narg = AS(dup2_args), .sy_call = (sy_call_t *)sys_dup2, .sy_auevent = AUE_DUP2, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 63 = dup2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_getppid, .sy_auevent = AUE_GETPPID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 64 = linux_getppid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_getpgrp, .sy_auevent = AUE_GETPGRP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 65 = getpgrp */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_setsid, .sy_auevent = AUE_SETSID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 66 = setsid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 67 = linux_sigaction */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 68 = linux_sgetmask */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 69 = linux_ssetmask */ + { .sy_narg = AS(setreuid_args), .sy_call = (sy_call_t *)sys_setreuid, .sy_auevent = AUE_SETREUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 70 = setreuid */ + { .sy_narg = AS(setregid_args), .sy_call = (sy_call_t *)sys_setregid, .sy_auevent = AUE_SETREGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 71 = setregid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 72 = linux_sigsuspend */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 73 = linux_sigpending */ + { .sy_narg = AS(linux_sethostname_args), .sy_call = (sy_call_t *)linux_sethostname, .sy_auevent = AUE_SYSCTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 74 = linux_sethostname */ + { .sy_narg = AS(linux_setrlimit_args), .sy_call = (sy_call_t *)linux_setrlimit, .sy_auevent = AUE_SETRLIMIT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 75 = linux_setrlimit */ + { .sy_narg = AS(linux_getrlimit_args), .sy_call = (sy_call_t *)linux_getrlimit, .sy_auevent = AUE_GETRLIMIT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 76 = linux_getrlimit */ + { .sy_narg = AS(getrusage_args), .sy_call = (sy_call_t *)sys_getrusage, .sy_auevent = AUE_GETRUSAGE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 77 = getrusage */ + { .sy_narg = AS(gettimeofday_args), .sy_call = (sy_call_t *)sys_gettimeofday, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 78 = gettimeofday */ + { .sy_narg = AS(settimeofday_args), .sy_call = (sy_call_t *)sys_settimeofday, .sy_auevent = AUE_SETTIMEOFDAY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 79 = settimeofday */ + { .sy_narg = AS(linux_getgroups_args), .sy_call = (sy_call_t *)linux_getgroups, .sy_auevent = AUE_GETGROUPS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 80 = linux_getgroups */ + { .sy_narg = AS(linux_setgroups_args), .sy_call = (sy_call_t *)linux_setgroups, .sy_auevent = AUE_SETGROUPS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 81 = linux_setgroups */ + { .sy_narg = AS(linux_select_args), .sy_call = (sy_call_t *)linux_select, .sy_auevent = AUE_SELECT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 82 = linux_select */ + { .sy_narg = AS(linux_symlink_args), .sy_call = (sy_call_t *)linux_symlink, .sy_auevent = AUE_SYMLINK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 83 = linux_symlink */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 84 = linux_oldlstat */ + { .sy_narg = AS(linux_readlink_args), .sy_call = (sy_call_t *)linux_readlink, .sy_auevent = AUE_READLINK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 85 = linux_readlink */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 86 = linux_uselib */ + { .sy_narg = AS(swapon_args), .sy_call = (sy_call_t *)sys_swapon, .sy_auevent = AUE_SWAPON, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 87 = swapon */ + { .sy_narg = AS(linux_reboot_args), .sy_call = (sy_call_t *)linux_reboot, .sy_auevent = AUE_REBOOT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 88 = linux_reboot */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 89 = linux_readdir */ + { .sy_narg = AS(linux_mmap_args), .sy_call = (sy_call_t *)linux_mmap, .sy_auevent = AUE_MMAP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 90 = linux_mmap */ + { .sy_narg = AS(munmap_args), .sy_call = (sy_call_t *)sys_munmap, .sy_auevent = AUE_MUNMAP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 91 = munmap */ + { .sy_narg = AS(linux_truncate_args), .sy_call = (sy_call_t *)linux_truncate, .sy_auevent = AUE_TRUNCATE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 92 = linux_truncate */ + { .sy_narg = AS(linux_ftruncate_args), .sy_call = (sy_call_t *)linux_ftruncate, .sy_auevent = AUE_FTRUNCATE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 93 = linux_ftruncate */ + { .sy_narg = AS(fchmod_args), .sy_call = (sy_call_t *)sys_fchmod, .sy_auevent = AUE_FCHMOD, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 94 = fchmod */ + { .sy_narg = AS(fchown_args), .sy_call = (sy_call_t *)sys_fchown, .sy_auevent = AUE_FCHOWN, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 95 = fchown */ + { .sy_narg = AS(linux_getpriority_args), .sy_call = (sy_call_t *)linux_getpriority, .sy_auevent = AUE_GETPRIORITY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 96 = linux_getpriority */ + { .sy_narg = AS(setpriority_args), .sy_call = (sy_call_t *)sys_setpriority, .sy_auevent = AUE_SETPRIORITY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 97 = setpriority */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 98 = linux_profil */ + { .sy_narg = AS(linux_statfs_args), .sy_call = (sy_call_t *)linux_statfs, .sy_auevent = AUE_STATFS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 99 = linux_statfs */ + { .sy_narg = AS(linux_fstatfs_args), .sy_call = (sy_call_t *)linux_fstatfs, .sy_auevent = AUE_FSTATFS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 100 = linux_fstatfs */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_ioperm, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 101 = linux_ioperm */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 102 = linux_socketcall */ + { .sy_narg = AS(linux_syslog_args), .sy_call = (sy_call_t *)linux_syslog, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 103 = linux_syslog */ + { .sy_narg = AS(linux_setitimer_args), .sy_call = (sy_call_t *)linux_setitimer, .sy_auevent = AUE_SETITIMER, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 104 = linux_setitimer */ + { .sy_narg = AS(linux_getitimer_args), .sy_call = (sy_call_t *)linux_getitimer, .sy_auevent = AUE_GETITIMER, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 105 = linux_getitimer */ + { .sy_narg = AS(linux_newstat_args), .sy_call = (sy_call_t *)linux_newstat, .sy_auevent = AUE_STAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 106 = linux_newstat */ + { .sy_narg = AS(linux_newlstat_args), .sy_call = (sy_call_t *)linux_newlstat, .sy_auevent = AUE_LSTAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 107 = linux_newlstat */ + { .sy_narg = AS(linux_newfstat_args), .sy_call = (sy_call_t *)linux_newfstat, .sy_auevent = AUE_FSTAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 108 = linux_newfstat */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 109 = linux_olduname */ + { .sy_narg = AS(linux_iopl_args), .sy_call = (sy_call_t *)linux_iopl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 110 = linux_iopl */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_vhangup, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 111 = linux_vhangup */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 112 = linux_idle */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 113 = linux_vm86 */ + { .sy_narg = AS(linux_wait4_args), .sy_call = (sy_call_t *)linux_wait4, .sy_auevent = AUE_WAIT4, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 114 = linux_wait4 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_swapoff, .sy_auevent = AUE_SWAPOFF, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 115 = linux_swapoff */ + { .sy_narg = AS(linux_sysinfo_args), .sy_call = (sy_call_t *)linux_sysinfo, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 116 = linux_sysinfo */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 117 = linux_ipc */ + { .sy_narg = AS(fsync_args), .sy_call = (sy_call_t *)sys_fsync, .sy_auevent = AUE_FSYNC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 118 = fsync */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 119 = linux_sigreturn */ + { .sy_narg = AS(linux_clone_args), .sy_call = (sy_call_t *)linux_clone, .sy_auevent = AUE_RFORK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 120 = linux_clone */ + { .sy_narg = AS(linux_setdomainname_args), .sy_call = (sy_call_t *)linux_setdomainname, .sy_auevent = AUE_SYSCTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 121 = linux_setdomainname */ + { .sy_narg = AS(linux_newuname_args), .sy_call = (sy_call_t *)linux_newuname, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 122 = linux_newuname */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_modify_ldt, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 123 = linux_modify_ldt */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_adjtimex, .sy_auevent = AUE_ADJTIME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 124 = linux_adjtimex */ + { .sy_narg = AS(linux_mprotect_args), .sy_call = (sy_call_t *)linux_mprotect, .sy_auevent = AUE_MPROTECT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 125 = linux_mprotect */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 126 = linux_sigprocmask */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 127 = linux_create_module */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_init_module, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 128 = linux_init_module */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_delete_module, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 129 = linux_delete_module */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 130 = linux_get_kernel_syms */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_quotactl, .sy_auevent = AUE_QUOTACTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 131 = linux_quotactl */ + { .sy_narg = AS(getpgid_args), .sy_call = (sy_call_t *)sys_getpgid, .sy_auevent = AUE_GETPGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 132 = getpgid */ + { .sy_narg = AS(fchdir_args), .sy_call = (sy_call_t *)sys_fchdir, .sy_auevent = AUE_FCHDIR, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 133 = fchdir */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 134 = linux_bdflush */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 135 = linux_sysfs */ + { .sy_narg = AS(linux_personality_args), .sy_call = (sy_call_t *)linux_personality, .sy_auevent = AUE_PERSONALITY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 136 = linux_personality */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 137 = linux_afs_syscall */ + { .sy_narg = AS(linux_setfsuid_args), .sy_call = (sy_call_t *)linux_setfsuid, .sy_auevent = AUE_SETFSUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 138 = linux_setfsuid */ + { .sy_narg = AS(linux_setfsgid_args), .sy_call = (sy_call_t *)linux_setfsgid, .sy_auevent = AUE_SETFSGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 139 = linux_setfsgid */ + { .sy_narg = AS(linux_llseek_args), .sy_call = (sy_call_t *)linux_llseek, .sy_auevent = AUE_LSEEK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 140 = linux_llseek */ + { .sy_narg = AS(linux_getdents_args), .sy_call = (sy_call_t *)linux_getdents, .sy_auevent = AUE_GETDIRENTRIES, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 141 = linux_getdents */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 142 = linux__newselect */ + { .sy_narg = AS(flock_args), .sy_call = (sy_call_t *)sys_flock, .sy_auevent = AUE_FLOCK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 143 = flock */ + { .sy_narg = AS(linux_msync_args), .sy_call = (sy_call_t *)linux_msync, .sy_auevent = AUE_MSYNC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 144 = linux_msync */ + { .sy_narg = AS(readv_args), .sy_call = (sy_call_t *)sys_readv, .sy_auevent = AUE_READV, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 145 = readv */ + { .sy_narg = AS(linux_writev_args), .sy_call = (sy_call_t *)linux_writev, .sy_auevent = AUE_WRITEV, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 146 = linux_writev */ + { .sy_narg = AS(linux_getsid_args), .sy_call = (sy_call_t *)linux_getsid, .sy_auevent = AUE_GETSID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 147 = linux_getsid */ + { .sy_narg = AS(linux_fdatasync_args), .sy_call = (sy_call_t *)linux_fdatasync, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 148 = linux_fdatasync */ + { .sy_narg = AS(linux_sysctl_args), .sy_call = (sy_call_t *)linux_sysctl, .sy_auevent = AUE_SYSCTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 149 = linux_sysctl */ + { .sy_narg = AS(mlock_args), .sy_call = (sy_call_t *)sys_mlock, .sy_auevent = AUE_MLOCK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 150 = mlock */ + { .sy_narg = AS(munlock_args), .sy_call = (sy_call_t *)sys_munlock, .sy_auevent = AUE_MUNLOCK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 151 = munlock */ + { .sy_narg = AS(mlockall_args), .sy_call = (sy_call_t *)sys_mlockall, .sy_auevent = AUE_MLOCKALL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 152 = mlockall */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_munlockall, .sy_auevent = AUE_MUNLOCKALL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 153 = munlockall */ + { .sy_narg = AS(linux_sched_setparam_args), .sy_call = (sy_call_t *)linux_sched_setparam, .sy_auevent = AUE_SCHED_SETPARAM, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 154 = linux_sched_setparam */ + { .sy_narg = AS(linux_sched_getparam_args), .sy_call = (sy_call_t *)linux_sched_getparam, .sy_auevent = AUE_SCHED_GETPARAM, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 155 = linux_sched_getparam */ + { .sy_narg = AS(linux_sched_setscheduler_args), .sy_call = (sy_call_t *)linux_sched_setscheduler, .sy_auevent = AUE_SCHED_SETSCHEDULER, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 156 = linux_sched_setscheduler */ + { .sy_narg = AS(linux_sched_getscheduler_args), .sy_call = (sy_call_t *)linux_sched_getscheduler, .sy_auevent = AUE_SCHED_GETSCHEDULER, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 157 = linux_sched_getscheduler */ + { .sy_narg = 0, .sy_call = (sy_call_t *)sys_sched_yield, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 158 = sched_yield */ + { .sy_narg = AS(linux_sched_get_priority_max_args), .sy_call = (sy_call_t *)linux_sched_get_priority_max, .sy_auevent = AUE_SCHED_GET_PRIORITY_MAX, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 159 = linux_sched_get_priority_max */ + { .sy_narg = AS(linux_sched_get_priority_min_args), .sy_call = (sy_call_t *)linux_sched_get_priority_min, .sy_auevent = AUE_SCHED_GET_PRIORITY_MIN, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 160 = linux_sched_get_priority_min */ + { .sy_narg = AS(linux_sched_rr_get_interval_args), .sy_call = (sy_call_t *)linux_sched_rr_get_interval, .sy_auevent = AUE_SCHED_RR_GET_INTERVAL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 161 = linux_sched_rr_get_interval */ + { .sy_narg = AS(linux_nanosleep_args), .sy_call = (sy_call_t *)linux_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 162 = linux_nanosleep */ + { .sy_narg = AS(linux_mremap_args), .sy_call = (sy_call_t *)linux_mremap, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 163 = linux_mremap */ + { .sy_narg = AS(setresuid_args), .sy_call = (sy_call_t *)sys_setresuid, .sy_auevent = AUE_SETRESUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 164 = setresuid */ + { .sy_narg = AS(getresuid_args), .sy_call = (sy_call_t *)sys_getresuid, .sy_auevent = AUE_GETRESUID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 165 = getresuid */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 166 = linux_query_module */ + { .sy_narg = AS(linux_poll_args), .sy_call = (sy_call_t *)linux_poll, .sy_auevent = AUE_POLL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 167 = linux_poll */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 168 = linux_nfsservctl */ + { .sy_narg = AS(setresgid_args), .sy_call = (sy_call_t *)sys_setresgid, .sy_auevent = AUE_SETRESGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 169 = setresgid */ + { .sy_narg = AS(getresgid_args), .sy_call = (sy_call_t *)sys_getresgid, .sy_auevent = AUE_GETRESGID, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 170 = getresgid */ + { .sy_narg = AS(linux_prctl_args), .sy_call = (sy_call_t *)linux_prctl, .sy_auevent = AUE_PRCTL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 171 = linux_prctl */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_rt_sigreturn, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 172 = linux_rt_sigreturn */ + { .sy_narg = AS(linux_rt_sigaction_args), .sy_call = (sy_call_t *)linux_rt_sigaction, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 173 = linux_rt_sigaction */ + { .sy_narg = AS(linux_rt_sigprocmask_args), .sy_call = (sy_call_t *)linux_rt_sigprocmask, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 174 = linux_rt_sigprocmask */ + { .sy_narg = AS(linux_rt_sigpending_args), .sy_call = (sy_call_t *)linux_rt_sigpending, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 175 = linux_rt_sigpending */ + { .sy_narg = AS(linux_rt_sigtimedwait_args), .sy_call = (sy_call_t *)linux_rt_sigtimedwait, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 176 = linux_rt_sigtimedwait */ + { .sy_narg = AS(linux_rt_sigqueueinfo_args), .sy_call = (sy_call_t *)linux_rt_sigqueueinfo, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 177 = linux_rt_sigqueueinfo */ + { .sy_narg = AS(linux_rt_sigsuspend_args), .sy_call = (sy_call_t *)linux_rt_sigsuspend, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 178 = linux_rt_sigsuspend */ + { .sy_narg = AS(linux_pread_args), .sy_call = (sy_call_t *)linux_pread, .sy_auevent = AUE_PREAD, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 179 = linux_pread */ + { .sy_narg = AS(linux_pwrite_args), .sy_call = (sy_call_t *)linux_pwrite, .sy_auevent = AUE_PWRITE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 180 = linux_pwrite */ + { .sy_narg = AS(linux_chown_args), .sy_call = (sy_call_t *)linux_chown, .sy_auevent = AUE_LCHOWN, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 181 = linux_chown */ + { .sy_narg = AS(linux_getcwd_args), .sy_call = (sy_call_t *)linux_getcwd, .sy_auevent = AUE_GETCWD, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 182 = linux_getcwd */ + { .sy_narg = AS(linux_capget_args), .sy_call = (sy_call_t *)linux_capget, .sy_auevent = AUE_CAPGET, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 183 = linux_capget */ + { .sy_narg = AS(linux_capset_args), .sy_call = (sy_call_t *)linux_capset, .sy_auevent = AUE_CAPSET, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 184 = linux_capset */ + { .sy_narg = AS(linux_sigaltstack_args), .sy_call = (sy_call_t *)linux_sigaltstack, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 185 = linux_sigaltstack */ + { .sy_narg = AS(linux_sendfile_args), .sy_call = (sy_call_t *)linux_sendfile, .sy_auevent = AUE_SENDFILE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 186 = linux_sendfile */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 187 = linux_getpmsg */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 188 = linux_putpmsg */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_vfork, .sy_auevent = AUE_VFORK, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 189 = linux_vfork */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 190 = linux_ugetrlimit */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 191 = linux_readahead */ + { .sy_narg = AS(linux_mmap2_args), .sy_call = (sy_call_t *)linux_mmap2, .sy_auevent = AUE_MMAP, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 192 = linux_mmap2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 193 = linux_truncate64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 194 = linux_ftruncate64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 195 = linux_stat64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 196 = linux_lstat64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 197 = linux_fstat64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 198 = linux_pciconfig_read */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 199 = linux_pciconfig_write */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 200 = linux_pciconfig_iobase */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 201 = linux_multiplexer */ + { .sy_narg = AS(linux_getdents64_args), .sy_call = (sy_call_t *)linux_getdents64, .sy_auevent = AUE_GETDIRENTRIES, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 202 = linux_getdents64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_pivot_root, .sy_auevent = AUE_PIVOT_ROOT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 203 = linux_pivot_root */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 204 = linux_fcntl64 */ + { .sy_narg = AS(linux_madvise_args), .sy_call = (sy_call_t *)linux_madvise, .sy_auevent = AUE_MADVISE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 205 = linux_madvise */ + { .sy_narg = AS(linux_mincore_args), .sy_call = (sy_call_t *)linux_mincore, .sy_auevent = AUE_MINCORE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 206 = linux_mincore */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_gettid, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 207 = linux_gettid */ + { .sy_narg = AS(linux_tkill_args), .sy_call = (sy_call_t *)linux_tkill, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 208 = linux_tkill */ + { .sy_narg = AS(linux_setxattr_args), .sy_call = (sy_call_t *)linux_setxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 209 = linux_setxattr */ + { .sy_narg = AS(linux_lsetxattr_args), .sy_call = (sy_call_t *)linux_lsetxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 210 = linux_lsetxattr */ + { .sy_narg = AS(linux_fsetxattr_args), .sy_call = (sy_call_t *)linux_fsetxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 211 = linux_fsetxattr */ + { .sy_narg = AS(linux_getxattr_args), .sy_call = (sy_call_t *)linux_getxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 212 = linux_getxattr */ + { .sy_narg = AS(linux_lgetxattr_args), .sy_call = (sy_call_t *)linux_lgetxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 213 = linux_lgetxattr */ + { .sy_narg = AS(linux_fgetxattr_args), .sy_call = (sy_call_t *)linux_fgetxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 214 = linux_fgetxattr */ + { .sy_narg = AS(linux_listxattr_args), .sy_call = (sy_call_t *)linux_listxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 215 = linux_listxattr */ + { .sy_narg = AS(linux_llistxattr_args), .sy_call = (sy_call_t *)linux_llistxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 216 = linux_llistxattr */ + { .sy_narg = AS(linux_flistxattr_args), .sy_call = (sy_call_t *)linux_flistxattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 217 = linux_flistxattr */ + { .sy_narg = AS(linux_removexattr_args), .sy_call = (sy_call_t *)linux_removexattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 218 = linux_removexattr */ + { .sy_narg = AS(linux_lremovexattr_args), .sy_call = (sy_call_t *)linux_lremovexattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 219 = linux_lremovexattr */ + { .sy_narg = AS(linux_fremovexattr_args), .sy_call = (sy_call_t *)linux_fremovexattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 220 = linux_fremovexattr */ + { .sy_narg = AS(linux_sys_futex_args), .sy_call = (sy_call_t *)linux_sys_futex, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 221 = linux_sys_futex */ + { .sy_narg = AS(linux_sched_setaffinity_args), .sy_call = (sy_call_t *)linux_sched_setaffinity, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 222 = linux_sched_setaffinity */ + { .sy_narg = AS(linux_sched_getaffinity_args), .sy_call = (sy_call_t *)linux_sched_getaffinity, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 223 = linux_sched_getaffinity */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 224 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 225 = linux_tuxcall */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 226 = linux_sendfile64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 227 = linux_io_setup */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 228 = linux_io_destroy */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 229 = linux_io_getevents */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 230 = linux_io_submit */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 231 = linux_io_cancel */ + { .sy_narg = AS(linux_set_tid_address_args), .sy_call = (sy_call_t *)linux_set_tid_address, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 232 = linux_set_tid_address */ + { .sy_narg = AS(linux_fadvise64_args), .sy_call = (sy_call_t *)linux_fadvise64, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 233 = linux_fadvise64 */ + { .sy_narg = AS(linux_exit_group_args), .sy_call = (sy_call_t *)linux_exit_group, .sy_auevent = AUE_EXIT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 234 = linux_exit_group */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_lookup_dcookie, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 235 = linux_lookup_dcookie */ + { .sy_narg = AS(linux_epoll_create_args), .sy_call = (sy_call_t *)linux_epoll_create, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 236 = linux_epoll_create */ + { .sy_narg = AS(linux_epoll_ctl_args), .sy_call = (sy_call_t *)linux_epoll_ctl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 237 = linux_epoll_ctl */ + { .sy_narg = AS(linux_epoll_wait_args), .sy_call = (sy_call_t *)linux_epoll_wait, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 238 = linux_epoll_wait */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_remap_file_pages, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 239 = linux_remap_file_pages */ + { .sy_narg = AS(linux_timer_create_args), .sy_call = (sy_call_t *)linux_timer_create, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 240 = linux_timer_create */ + { .sy_narg = AS(linux_timer_settime_args), .sy_call = (sy_call_t *)linux_timer_settime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 241 = linux_timer_settime */ + { .sy_narg = AS(linux_timer_gettime_args), .sy_call = (sy_call_t *)linux_timer_gettime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 242 = linux_timer_gettime */ + { .sy_narg = AS(linux_timer_getoverrun_args), .sy_call = (sy_call_t *)linux_timer_getoverrun, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 243 = linux_timer_getoverrun */ + { .sy_narg = AS(linux_timer_delete_args), .sy_call = (sy_call_t *)linux_timer_delete, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 244 = linux_timer_delete */ + { .sy_narg = AS(linux_clock_settime_args), .sy_call = (sy_call_t *)linux_clock_settime, .sy_auevent = AUE_CLOCK_SETTIME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 245 = linux_clock_settime */ + { .sy_narg = AS(linux_clock_gettime_args), .sy_call = (sy_call_t *)linux_clock_gettime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 246 = linux_clock_gettime */ + { .sy_narg = AS(linux_clock_getres_args), .sy_call = (sy_call_t *)linux_clock_getres, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 247 = linux_clock_getres */ + { .sy_narg = AS(linux_clock_nanosleep_args), .sy_call = (sy_call_t *)linux_clock_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 248 = linux_clock_nanosleep */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 249 = linux_swapcontext */ + { .sy_narg = AS(linux_tgkill_args), .sy_call = (sy_call_t *)linux_tgkill, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 250 = linux_tgkill */ + { .sy_narg = AS(linux_utimes_args), .sy_call = (sy_call_t *)linux_utimes, .sy_auevent = AUE_UTIMES, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 251 = linux_utimes */ + { .sy_narg = AS(linux_statfs64_args), .sy_call = (sy_call_t *)linux_statfs64, .sy_auevent = AUE_STATFS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 252 = linux_statfs64 */ + { .sy_narg = AS(linux_fstatfs64_args), .sy_call = (sy_call_t *)linux_fstatfs64, .sy_auevent = AUE_FSTATFS, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 253 = linux_fstatfs64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 254 = linux_fadvise64_64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 255 = linux_rtas */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 256 = linux_sys_debug_setcontext */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 257 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_migrate_pages, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 258 = linux_migrate_pages */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_mbind, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 259 = linux_mbind */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_get_mempolicy, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 260 = linux_get_mempolicy */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_set_mempolicy, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 261 = linux_set_mempolicy */ + { .sy_narg = AS(linux_mq_open_args), .sy_call = (sy_call_t *)linux_mq_open, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 262 = linux_mq_open */ + { .sy_narg = AS(linux_mq_unlink_args), .sy_call = (sy_call_t *)linux_mq_unlink, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 263 = linux_mq_unlink */ + { .sy_narg = AS(linux_mq_timedsend_args), .sy_call = (sy_call_t *)linux_mq_timedsend, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 264 = linux_mq_timedsend */ + { .sy_narg = AS(linux_mq_timedreceive_args), .sy_call = (sy_call_t *)linux_mq_timedreceive, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 265 = linux_mq_timedreceive */ + { .sy_narg = AS(linux_mq_notify_args), .sy_call = (sy_call_t *)linux_mq_notify, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 266 = linux_mq_notify */ + { .sy_narg = AS(linux_mq_getsetattr_args), .sy_call = (sy_call_t *)linux_mq_getsetattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 267 = linux_mq_getsetattr */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_kexec_load, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 268 = linux_kexec_load */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_add_key, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 269 = linux_add_key */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_request_key, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 270 = linux_request_key */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_keyctl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 271 = linux_keyctl */ + { .sy_narg = AS(linux_waitid_args), .sy_call = (sy_call_t *)linux_waitid, .sy_auevent = AUE_WAIT6, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 272 = linux_waitid */ + { .sy_narg = AS(linux_ioprio_set_args), .sy_call = (sy_call_t *)linux_ioprio_set, .sy_auevent = AUE_SETPRIORITY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 273 = linux_ioprio_set */ + { .sy_narg = AS(linux_ioprio_get_args), .sy_call = (sy_call_t *)linux_ioprio_get, .sy_auevent = AUE_GETPRIORITY, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 274 = linux_ioprio_get */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 275 = linux_inotify_init */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_inotify_add_watch, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 276 = linux_inotify_add_watch */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_inotify_rm_watch, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 277 = linux_inotify_rm_watch */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 278 = linux_spu_run */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 279 = linux_spu_create */ + { .sy_narg = AS(linux_pselect6_args), .sy_call = (sy_call_t *)linux_pselect6, .sy_auevent = AUE_SELECT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 280 = linux_pselect6 */ + { .sy_narg = AS(linux_ppoll_args), .sy_call = (sy_call_t *)linux_ppoll, .sy_auevent = AUE_POLL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 281 = linux_ppoll */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_unshare, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 282 = linux_unshare */ + { .sy_narg = AS(linux_splice_args), .sy_call = (sy_call_t *)linux_splice, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 283 = linux_splice */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_tee, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 284 = linux_tee */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_vmsplice, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 285 = linux_vmsplice */ + { .sy_narg = AS(linux_openat_args), .sy_call = (sy_call_t *)linux_openat, .sy_auevent = AUE_OPEN_RWTC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 286 = linux_openat */ + { .sy_narg = AS(linux_mkdirat_args), .sy_call = (sy_call_t *)linux_mkdirat, .sy_auevent = AUE_MKDIRAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 287 = linux_mkdirat */ + { .sy_narg = AS(linux_mknodat_args), .sy_call = (sy_call_t *)linux_mknodat, .sy_auevent = AUE_MKNODAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 288 = linux_mknodat */ + { .sy_narg = AS(linux_fchownat_args), .sy_call = (sy_call_t *)linux_fchownat, .sy_auevent = AUE_FCHOWNAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 289 = linux_fchownat */ + { .sy_narg = AS(linux_futimesat_args), .sy_call = (sy_call_t *)linux_futimesat, .sy_auevent = AUE_FUTIMESAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 290 = linux_futimesat */ + { .sy_narg = AS(linux_newfstatat_args), .sy_call = (sy_call_t *)linux_newfstatat, .sy_auevent = AUE_FSTATAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 291 = linux_newfstatat */ + { .sy_narg = AS(linux_unlinkat_args), .sy_call = (sy_call_t *)linux_unlinkat, .sy_auevent = AUE_UNLINKAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 292 = linux_unlinkat */ + { .sy_narg = AS(linux_renameat_args), .sy_call = (sy_call_t *)linux_renameat, .sy_auevent = AUE_RENAMEAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 293 = linux_renameat */ + { .sy_narg = AS(linux_linkat_args), .sy_call = (sy_call_t *)linux_linkat, .sy_auevent = AUE_LINKAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 294 = linux_linkat */ + { .sy_narg = AS(linux_symlinkat_args), .sy_call = (sy_call_t *)linux_symlinkat, .sy_auevent = AUE_SYMLINKAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 295 = linux_symlinkat */ + { .sy_narg = AS(linux_readlinkat_args), .sy_call = (sy_call_t *)linux_readlinkat, .sy_auevent = AUE_READLINKAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 296 = linux_readlinkat */ + { .sy_narg = AS(linux_fchmodat_args), .sy_call = (sy_call_t *)linux_fchmodat, .sy_auevent = AUE_FCHMODAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 297 = linux_fchmodat */ + { .sy_narg = AS(linux_faccessat_args), .sy_call = (sy_call_t *)linux_faccessat, .sy_auevent = AUE_FACCESSAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 298 = linux_faccessat */ + { .sy_narg = AS(linux_get_robust_list_args), .sy_call = (sy_call_t *)linux_get_robust_list, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 299 = linux_get_robust_list */ + { .sy_narg = AS(linux_set_robust_list_args), .sy_call = (sy_call_t *)linux_set_robust_list, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 300 = linux_set_robust_list */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_move_pages, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 301 = linux_move_pages */ + { .sy_narg = AS(linux_getcpu_args), .sy_call = (sy_call_t *)linux_getcpu, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 302 = linux_getcpu */ + { .sy_narg = AS(linux_epoll_pwait_args), .sy_call = (sy_call_t *)linux_epoll_pwait, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 303 = linux_epoll_pwait */ + { .sy_narg = AS(linux_utimensat_args), .sy_call = (sy_call_t *)linux_utimensat, .sy_auevent = AUE_FUTIMESAT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 304 = linux_utimensat */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 305 = linux_signalfd */ + { .sy_narg = AS(linux_timerfd_create_args), .sy_call = (sy_call_t *)linux_timerfd_create, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 306 = linux_timerfd_create */ + { .sy_narg = AS(linux_eventfd_args), .sy_call = (sy_call_t *)linux_eventfd, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 307 = linux_eventfd */ + { .sy_narg = AS(linux_sync_file_range_args), .sy_call = (sy_call_t *)linux_sync_file_range, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 308 = linux_sync_file_range */ + { .sy_narg = AS(linux_fallocate_args), .sy_call = (sy_call_t *)linux_fallocate, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 309 = linux_fallocate */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 310 = linux_subpage_prot */ + { .sy_narg = AS(linux_timerfd_settime_args), .sy_call = (sy_call_t *)linux_timerfd_settime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 311 = linux_timerfd_settime */ + { .sy_narg = AS(linux_timerfd_gettime_args), .sy_call = (sy_call_t *)linux_timerfd_gettime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 312 = linux_timerfd_gettime */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_signalfd4, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 313 = linux_signalfd4 */ + { .sy_narg = AS(linux_eventfd2_args), .sy_call = (sy_call_t *)linux_eventfd2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 314 = linux_eventfd2 */ + { .sy_narg = AS(linux_epoll_create1_args), .sy_call = (sy_call_t *)linux_epoll_create1, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 315 = linux_epoll_create1 */ + { .sy_narg = AS(linux_dup3_args), .sy_call = (sy_call_t *)linux_dup3, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 316 = linux_dup3 */ + { .sy_narg = AS(linux_pipe2_args), .sy_call = (sy_call_t *)linux_pipe2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 317 = linux_pipe2 */ + { .sy_narg = AS(linux_inotify_init1_args), .sy_call = (sy_call_t *)linux_inotify_init1, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 318 = linux_inotify_init1 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_perf_event_open, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 319 = linux_perf_event_open */ + { .sy_narg = AS(linux_preadv_args), .sy_call = (sy_call_t *)linux_preadv, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 320 = linux_preadv */ + { .sy_narg = AS(linux_pwritev_args), .sy_call = (sy_call_t *)linux_pwritev, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 321 = linux_pwritev */ + { .sy_narg = AS(linux_rt_tgsigqueueinfo_args), .sy_call = (sy_call_t *)linux_rt_tgsigqueueinfo, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 322 = linux_rt_tgsigqueueinfo */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fanotify_init, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 323 = linux_fanotify_init */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fanotify_mark, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 324 = linux_fanotify_mark */ + { .sy_narg = AS(linux_prlimit64_args), .sy_call = (sy_call_t *)linux_prlimit64, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 325 = linux_prlimit64 */ + { .sy_narg = AS(linux_socket_args), .sy_call = (sy_call_t *)linux_socket, .sy_auevent = AUE_SOCKET, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 326 = linux_socket */ + { .sy_narg = AS(linux_bind_args), .sy_call = (sy_call_t *)linux_bind, .sy_auevent = AUE_BIND, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 327 = linux_bind */ + { .sy_narg = AS(linux_connect_args), .sy_call = (sy_call_t *)linux_connect, .sy_auevent = AUE_CONNECT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 328 = linux_connect */ + { .sy_narg = AS(linux_listen_args), .sy_call = (sy_call_t *)linux_listen, .sy_auevent = AUE_LISTEN, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 329 = linux_listen */ + { .sy_narg = AS(linux_accept_args), .sy_call = (sy_call_t *)linux_accept, .sy_auevent = AUE_ACCEPT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 330 = linux_accept */ + { .sy_narg = AS(linux_getsockname_args), .sy_call = (sy_call_t *)linux_getsockname, .sy_auevent = AUE_GETSOCKNAME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 331 = linux_getsockname */ + { .sy_narg = AS(linux_getpeername_args), .sy_call = (sy_call_t *)linux_getpeername, .sy_auevent = AUE_GETPEERNAME, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 332 = linux_getpeername */ + { .sy_narg = AS(linux_socketpair_args), .sy_call = (sy_call_t *)linux_socketpair, .sy_auevent = AUE_SOCKETPAIR, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 333 = linux_socketpair */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 334 = linux_send */ + { .sy_narg = AS(linux_sendto_args), .sy_call = (sy_call_t *)linux_sendto, .sy_auevent = AUE_SENDTO, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 335 = linux_sendto */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 336 = linux_recv */ + { .sy_narg = AS(linux_recvfrom_args), .sy_call = (sy_call_t *)linux_recvfrom, .sy_auevent = AUE_RECVFROM, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 337 = linux_recvfrom */ + { .sy_narg = AS(linux_shutdown_args), .sy_call = (sy_call_t *)linux_shutdown, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 338 = linux_shutdown */ + { .sy_narg = AS(linux_setsockopt_args), .sy_call = (sy_call_t *)linux_setsockopt, .sy_auevent = AUE_SETSOCKOPT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 339 = linux_setsockopt */ + { .sy_narg = AS(linux_getsockopt_args), .sy_call = (sy_call_t *)linux_getsockopt, .sy_auevent = AUE_GETSOCKOPT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 340 = linux_getsockopt */ + { .sy_narg = AS(linux_sendmsg_args), .sy_call = (sy_call_t *)linux_sendmsg, .sy_auevent = AUE_SENDMSG, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 341 = linux_sendmsg */ + { .sy_narg = AS(linux_recvmsg_args), .sy_call = (sy_call_t *)linux_recvmsg, .sy_auevent = AUE_RECVMSG, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 342 = linux_recvmsg */ + { .sy_narg = AS(linux_recvmmsg_args), .sy_call = (sy_call_t *)linux_recvmmsg, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 343 = linux_recvmmsg */ + { .sy_narg = AS(linux_accept4_args), .sy_call = (sy_call_t *)linux_accept4, .sy_auevent = AUE_ACCEPT, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 344 = linux_accept4 */ + { .sy_narg = AS(linux_name_to_handle_at_args), .sy_call = (sy_call_t *)linux_name_to_handle_at, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 345 = linux_name_to_handle_at */ + { .sy_narg = AS(linux_open_by_handle_at_args), .sy_call = (sy_call_t *)linux_open_by_handle_at, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 346 = linux_open_by_handle_at */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_clock_adjtime, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 347 = linux_clock_adjtime */ + { .sy_narg = AS(linux_syncfs_args), .sy_call = (sy_call_t *)linux_syncfs, .sy_auevent = AUE_SYNC, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 348 = linux_syncfs */ + { .sy_narg = AS(linux_sendmmsg_args), .sy_call = (sy_call_t *)linux_sendmmsg, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 349 = linux_sendmmsg */ + { .sy_narg = AS(linux_setns_args), .sy_call = (sy_call_t *)linux_setns, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 350 = linux_setns */ + { .sy_narg = AS(linux_process_vm_readv_args), .sy_call = (sy_call_t *)linux_process_vm_readv, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 351 = linux_process_vm_readv */ + { .sy_narg = AS(linux_process_vm_writev_args), .sy_call = (sy_call_t *)linux_process_vm_writev, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 352 = linux_process_vm_writev */ + { .sy_narg = AS(linux_finit_module_args), .sy_call = (sy_call_t *)linux_finit_module, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 353 = linux_finit_module */ + { .sy_narg = AS(linux_kcmp_args), .sy_call = (sy_call_t *)linux_kcmp, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 354 = linux_kcmp */ + { .sy_narg = AS(linux_sched_setattr_args), .sy_call = (sy_call_t *)linux_sched_setattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 355 = linux_sched_setattr */ + { .sy_narg = AS(linux_sched_getattr_args), .sy_call = (sy_call_t *)linux_sched_getattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 356 = linux_sched_getattr */ + { .sy_narg = AS(linux_renameat2_args), .sy_call = (sy_call_t *)linux_renameat2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 357 = linux_renameat2 */ + { .sy_narg = AS(linux_seccomp_args), .sy_call = (sy_call_t *)linux_seccomp, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 358 = linux_seccomp */ + { .sy_narg = AS(linux_getrandom_args), .sy_call = (sy_call_t *)linux_getrandom, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 359 = linux_getrandom */ + { .sy_narg = AS(linux_memfd_create_args), .sy_call = (sy_call_t *)linux_memfd_create, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 360 = linux_memfd_create */ + { .sy_narg = AS(linux_bpf_args), .sy_call = (sy_call_t *)linux_bpf, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 361 = linux_bpf */ + { .sy_narg = AS(linux_execveat_args), .sy_call = (sy_call_t *)linux_execveat, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 362 = linux_execveat */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 363 = linux_switch_endian */ + { .sy_narg = AS(linux_userfaultfd_args), .sy_call = (sy_call_t *)linux_userfaultfd, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 364 = linux_userfaultfd */ + { .sy_narg = AS(linux_membarrier_args), .sy_call = (sy_call_t *)linux_membarrier, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 365 = linux_membarrier */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 366 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 367 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 368 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 369 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 370 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 371 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 372 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 373 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 374 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 375 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 376 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 377 = */ + { .sy_narg = AS(linux_mlock2_args), .sy_call = (sy_call_t *)linux_mlock2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 378 = linux_mlock2 */ + { .sy_narg = AS(linux_copy_file_range_args), .sy_call = (sy_call_t *)linux_copy_file_range, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 379 = linux_copy_file_range */ + { .sy_narg = AS(linux_preadv2_args), .sy_call = (sy_call_t *)linux_preadv2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 380 = linux_preadv2 */ + { .sy_narg = AS(linux_pwritev2_args), .sy_call = (sy_call_t *)linux_pwritev2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 381 = linux_pwritev2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 382 = linux_kexec_file_load */ + { .sy_narg = AS(linux_statx_args), .sy_call = (sy_call_t *)linux_statx, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 383 = linux_statx */ + { .sy_narg = AS(linux_pkey_alloc_args), .sy_call = (sy_call_t *)linux_pkey_alloc, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 384 = linux_pkey_alloc */ + { .sy_narg = AS(linux_pkey_free_args), .sy_call = (sy_call_t *)linux_pkey_free, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 385 = linux_pkey_free */ + { .sy_narg = AS(linux_pkey_mprotect_args), .sy_call = (sy_call_t *)linux_pkey_mprotect, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 386 = linux_pkey_mprotect */ + { .sy_narg = AS(linux_rseq_args), .sy_call = (sy_call_t *)linux_rseq, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 387 = linux_rseq */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_io_pgetevents, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 388 = linux_io_pgetevents */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 389 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 390 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 391 = */ + { .sy_narg = AS(linux_semtimedop_args), .sy_call = (sy_call_t *)linux_semtimedop, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 392 = linux_semtimedop */ + { .sy_narg = AS(linux_semget_args), .sy_call = (sy_call_t *)linux_semget, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 393 = linux_semget */ + { .sy_narg = AS(linux_semctl_args), .sy_call = (sy_call_t *)linux_semctl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 394 = linux_semctl */ + { .sy_narg = AS(linux_shmget_args), .sy_call = (sy_call_t *)linux_shmget, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 395 = linux_shmget */ + { .sy_narg = AS(linux_shmctl_args), .sy_call = (sy_call_t *)linux_shmctl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 396 = linux_shmctl */ + { .sy_narg = AS(linux_shmat_args), .sy_call = (sy_call_t *)linux_shmat, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 397 = linux_shmat */ + { .sy_narg = AS(linux_shmdt_args), .sy_call = (sy_call_t *)linux_shmdt, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 398 = linux_shmdt */ + { .sy_narg = AS(linux_msgget_args), .sy_call = (sy_call_t *)linux_msgget, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 399 = linux_msgget */ + { .sy_narg = AS(linux_msgsnd_args), .sy_call = (sy_call_t *)linux_msgsnd, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 400 = linux_msgsnd */ + { .sy_narg = AS(linux_msgrcv_args), .sy_call = (sy_call_t *)linux_msgrcv, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 401 = linux_msgrcv */ + { .sy_narg = AS(linux_msgctl_args), .sy_call = (sy_call_t *)linux_msgctl, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 402 = linux_msgctl */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 403 = linux_clock_gettime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 404 = linux_clock_settime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 405 = linux_clock_adjtime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 406 = linux_clock_getres_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 407 = linux_clock_nanosleep_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 408 = linux_timer_gettime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 409 = linux_timer_settime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 410 = linux_timerfd_gettime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 411 = linux_timerfd_settime64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 412 = linux_utimensat_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 413 = linux_pselect6_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 414 = linux_ppoll_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 415 = */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 416 = linux_io_pgetevents_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 417 = linux_recvmmsg_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 418 = linux_mq_timedsend_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 419 = linux_mq_timedreceive_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 420 = linux_semtimedop_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 421 = linux_rt_sigtimedwait_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 422 = linux_futex_time64 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 423 = linux_sched_rr_get_interval_time64 */ + { .sy_narg = AS(linux_pidfd_send_signal_args), .sy_call = (sy_call_t *)linux_pidfd_send_signal, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 424 = linux_pidfd_send_signal */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_io_uring_setup, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 425 = linux_io_uring_setup */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_io_uring_enter, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 426 = linux_io_uring_enter */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_io_uring_register, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 427 = linux_io_uring_register */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_open_tree, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 428 = linux_open_tree */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_move_mount, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 429 = linux_move_mount */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fsopen, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 430 = linux_fsopen */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fsconfig, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 431 = linux_fsconfig */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fsmount, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 432 = linux_fsmount */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fspick, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 433 = linux_fspick */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_pidfd_open, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 434 = linux_pidfd_open */ + { .sy_narg = AS(linux_clone3_args), .sy_call = (sy_call_t *)linux_clone3, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 435 = linux_clone3 */ + { .sy_narg = AS(linux_close_range_args), .sy_call = (sy_call_t *)linux_close_range, .sy_auevent = AUE_CLOSERANGE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 436 = linux_close_range */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_openat2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 437 = linux_openat2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_pidfd_getfd, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 438 = linux_pidfd_getfd */ + { .sy_narg = AS(linux_faccessat2_args), .sy_call = (sy_call_t *)linux_faccessat2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 439 = linux_faccessat2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_process_madvise, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 440 = linux_process_madvise */ + { .sy_narg = AS(linux_epoll_pwait2_args), .sy_call = (sy_call_t *)linux_epoll_pwait2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 441 = linux_epoll_pwait2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_mount_setattr, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 442 = linux_mount_setattr */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_quotactl_fd, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 443 = linux_quotactl_fd */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_landlock_create_ruleset, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 444 = linux_landlock_create_ruleset */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_landlock_add_rule, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 445 = linux_landlock_add_rule */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_landlock_restrict_self, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 446 = linux_landlock_restrict_self */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_memfd_secret, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 447 = linux_memfd_secret */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_process_mrelease, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 448 = linux_process_mrelease */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_futex_waitv, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 449 = linux_futex_waitv */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_set_mempolicy_home_node, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 450 = linux_set_mempolicy_home_node */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_cachestat, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 451 = linux_cachestat */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_fchmodat2, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 452 = linux_fchmodat2 */ + { .sy_narg = 0, .sy_call = (sy_call_t *)linux_map_shadow_stack, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 453 = linux_map_shadow_stack */ +}; diff --git a/sys/powerpc/linux/linux_systrace_args.c b/sys/powerpc/linux/linux_systrace_args.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_systrace_args.c @@ -0,0 +1,8710 @@ +/* + * System call argument to DTrace register array converstion. + * + * DO NOT EDIT-- this file is automatically @generated. + * 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; + int a = 0; + switch (sysnum) { + /* linux_exit */ + case 1: { + struct linux_exit_args *p = params; + uarg[a++] = p->rval; /* u_int */ + *n_args = 1; + break; + } + /* linux_fork */ + case 2: { + *n_args = 0; + break; + } + /* read */ + case 3: { + struct read_args *p = params; + iarg[a++] = p->fd; /* int */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->nbyte; /* l_size_t */ + *n_args = 3; + break; + } + /* linux_write */ + case 4: { + struct linux_write_args *p = params; + iarg[a++] = p->fd; /* int */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->nbyte; /* l_size_t */ + *n_args = 3; + break; + } + /* linux_open */ + case 5: { + struct linux_open_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->flags; /* l_int */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 3; + break; + } + /* close */ + case 6: { + struct close_args *p = params; + iarg[a++] = p->fd; /* int */ + *n_args = 1; + break; + } + /* linux_creat */ + case 8: { + struct linux_creat_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 2; + break; + } + /* linux_link */ + case 9: { + struct linux_link_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->to; /* char * */ + *n_args = 2; + break; + } + /* linux_unlink */ + case 10: { + struct linux_unlink_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + *n_args = 1; + break; + } + /* linux_execve */ + case 11: { + struct linux_execve_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->argp; /* l_uintptr_t * */ + uarg[a++] = (intptr_t)p->envp; /* l_uintptr_t * */ + *n_args = 3; + break; + } + /* linux_chdir */ + case 12: { + struct linux_chdir_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + *n_args = 1; + break; + } + /* linux_time */ + case 13: { + struct linux_time_args *p = params; + uarg[a++] = (intptr_t)p->tm; /* l_time_t * */ + *n_args = 1; + break; + } + /* linux_mknod */ + case 14: { + struct linux_mknod_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->mode; /* l_mode_t */ + iarg[a++] = p->dev; /* l_uint */ + *n_args = 3; + break; + } + /* linux_chmod */ + case 15: { + struct linux_chmod_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 2; + break; + } + /* linux_lchown */ + case 16: { + struct linux_lchown_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->uid; /* l_uid_t */ + iarg[a++] = p->gid; /* l_gid_t */ + *n_args = 3; + break; + } + /* linux_lseek */ + case 19: { + struct linux_lseek_args *p = params; + iarg[a++] = p->fdes; /* l_uint */ + iarg[a++] = p->off; /* l_off_t */ + iarg[a++] = p->whence; /* l_int */ + *n_args = 3; + break; + } + /* linux_getpid */ + case 20: { + *n_args = 0; + break; + } + /* linux_mount */ + case 21: { + struct linux_mount_args *p = params; + uarg[a++] = (intptr_t)p->specialfile; /* char * */ + uarg[a++] = (intptr_t)p->dir; /* char * */ + uarg[a++] = (intptr_t)p->filesystemtype; /* char * */ + iarg[a++] = p->rwflag; /* l_ulong */ + uarg[a++] = (intptr_t)p->data; /* void * */ + *n_args = 5; + break; + } + /* linux_umount */ + case 22: { + struct linux_umount_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 2; + break; + } + /* setuid */ + case 23: { + struct setuid_args *p = params; + uarg[a++] = p->uid; /* uid_t */ + *n_args = 1; + break; + } + /* linux_getuid */ + case 24: { + *n_args = 0; + break; + } + /* linux_ptrace */ + case 26: { + struct linux_ptrace_args *p = params; + iarg[a++] = p->req; /* l_long */ + iarg[a++] = p->pid; /* l_long */ + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->data; /* l_ulong */ + *n_args = 4; + break; + } + /* linux_alarm */ + case 27: { + struct linux_alarm_args *p = params; + iarg[a++] = p->secs; /* l_uint */ + *n_args = 1; + break; + } + /* linux_pause */ + case 29: { + *n_args = 0; + break; + } + /* linux_utime */ + case 30: { + struct linux_utime_args *p = params; + uarg[a++] = (intptr_t)p->fname; /* char * */ + uarg[a++] = (intptr_t)p->times; /* struct l_utimbuf * */ + *n_args = 2; + break; + } + /* linux_access */ + case 33: { + struct linux_access_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->amode; /* l_int */ + *n_args = 2; + break; + } + /* sync */ + case 36: { + *n_args = 0; + break; + } + /* linux_kill */ + case 37: { + struct linux_kill_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->signum; /* l_int */ + *n_args = 2; + break; + } + /* linux_rename */ + case 38: { + struct linux_rename_args *p = params; + uarg[a++] = (intptr_t)p->from; /* char * */ + uarg[a++] = (intptr_t)p->to; /* char * */ + *n_args = 2; + break; + } + /* linux_mkdir */ + case 39: { + struct linux_mkdir_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 2; + break; + } + /* linux_rmdir */ + case 40: { + struct linux_rmdir_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + *n_args = 1; + break; + } + /* dup */ + case 41: { + struct dup_args *p = params; + uarg[a++] = p->fd; /* u_int */ + *n_args = 1; + break; + } + /* linux_pipe */ + case 42: { + struct linux_pipe_args *p = params; + uarg[a++] = (intptr_t)p->pipefds; /* l_int * */ + *n_args = 1; + break; + } + /* linux_times */ + case 43: { + struct linux_times_args *p = params; + uarg[a++] = (intptr_t)p->buf; /* struct l_times_argv * */ + *n_args = 1; + break; + } + /* linux_brk */ + case 45: { + struct linux_brk_args *p = params; + iarg[a++] = p->dsend; /* l_ulong */ + *n_args = 1; + break; + } + /* setgid */ + case 46: { + struct setgid_args *p = params; + iarg[a++] = p->gid; /* gid_t */ + *n_args = 1; + break; + } + /* linux_getgid */ + case 47: { + *n_args = 0; + break; + } + /* geteuid */ + case 49: { + *n_args = 0; + break; + } + /* getegid */ + case 50: { + *n_args = 0; + break; + } + /* acct */ + case 51: { + struct acct_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + *n_args = 1; + break; + } + /* linux_ioctl */ + case 54: { + struct linux_ioctl_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + iarg[a++] = p->cmd; /* l_uint */ + iarg[a++] = p->arg; /* l_ulong */ + *n_args = 3; + break; + } + /* linux_fcntl */ + case 55: { + struct linux_fcntl_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + iarg[a++] = p->cmd; /* l_uint */ + iarg[a++] = p->arg; /* l_ulong */ + *n_args = 3; + break; + } + /* setpgid */ + case 57: { + struct setpgid_args *p = params; + iarg[a++] = p->pid; /* int */ + iarg[a++] = p->pgid; /* int */ + *n_args = 2; + break; + } + /* umask */ + case 60: { + struct umask_args *p = params; + iarg[a++] = p->newmask; /* int */ + *n_args = 1; + break; + } + /* chroot */ + case 61: { + struct chroot_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + *n_args = 1; + break; + } + /* linux_ustat */ + case 62: { + struct linux_ustat_args *p = params; + iarg[a++] = p->dev; /* l_uint */ + uarg[a++] = (intptr_t)p->ubuf; /* struct l_ustat * */ + *n_args = 2; + break; + } + /* dup2 */ + case 63: { + struct dup2_args *p = params; + uarg[a++] = p->from; /* u_int */ + uarg[a++] = p->to; /* u_int */ + *n_args = 2; + break; + } + /* linux_getppid */ + case 64: { + *n_args = 0; + break; + } + /* getpgrp */ + case 65: { + *n_args = 0; + break; + } + /* setsid */ + case 66: { + *n_args = 0; + break; + } + /* setreuid */ + case 70: { + struct setreuid_args *p = params; + uarg[a++] = p->ruid; /* uid_t */ + uarg[a++] = p->euid; /* uid_t */ + *n_args = 2; + break; + } + /* setregid */ + case 71: { + struct setregid_args *p = params; + iarg[a++] = p->rgid; /* gid_t */ + iarg[a++] = p->egid; /* gid_t */ + *n_args = 2; + break; + } + /* linux_sethostname */ + case 74: { + struct linux_sethostname_args *p = params; + uarg[a++] = (intptr_t)p->hostname; /* char * */ + iarg[a++] = p->len; /* l_int */ + *n_args = 2; + break; + } + /* linux_setrlimit */ + case 75: { + struct linux_setrlimit_args *p = params; + iarg[a++] = p->resource; /* l_uint */ + uarg[a++] = (intptr_t)p->rlim; /* struct l_rlimit * */ + *n_args = 2; + break; + } + /* linux_getrlimit */ + case 76: { + struct linux_getrlimit_args *p = params; + iarg[a++] = p->resource; /* l_uint */ + uarg[a++] = (intptr_t)p->rlim; /* struct l_rlimit * */ + *n_args = 2; + break; + } + /* getrusage */ + case 77: { + struct getrusage_args *p = params; + iarg[a++] = p->who; /* int */ + uarg[a++] = (intptr_t)p->rusage; /* struct rusage * */ + *n_args = 2; + break; + } + /* gettimeofday */ + case 78: { + struct gettimeofday_args *p = params; + uarg[a++] = (intptr_t)p->tp; /* struct l_timeval * */ + uarg[a++] = (intptr_t)p->tzp; /* struct timezone * */ + *n_args = 2; + break; + } + /* settimeofday */ + case 79: { + struct settimeofday_args *p = params; + uarg[a++] = (intptr_t)p->tv; /* struct l_timeval * */ + uarg[a++] = (intptr_t)p->tzp; /* struct timezone * */ + *n_args = 2; + break; + } + /* linux_getgroups */ + case 80: { + struct linux_getgroups_args *p = params; + iarg[a++] = p->gidsetsize; /* l_int */ + uarg[a++] = (intptr_t)p->grouplist; /* l_gid_t * */ + *n_args = 2; + break; + } + /* linux_setgroups */ + case 81: { + struct linux_setgroups_args *p = params; + iarg[a++] = p->gidsetsize; /* l_int */ + uarg[a++] = (intptr_t)p->grouplist; /* l_gid_t * */ + *n_args = 2; + break; + } + /* linux_select */ + case 82: { + struct linux_select_args *p = params; + iarg[a++] = p->nfds; /* l_int */ + uarg[a++] = (intptr_t)p->readfds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->writefds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->exceptfds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timeval * */ + *n_args = 5; + break; + } + /* linux_symlink */ + case 83: { + struct linux_symlink_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->to; /* char * */ + *n_args = 2; + break; + } + /* linux_readlink */ + case 85: { + struct linux_readlink_args *p = params; + uarg[a++] = (intptr_t)p->name; /* char * */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->count; /* l_int */ + *n_args = 3; + break; + } + /* swapon */ + case 87: { + struct swapon_args *p = params; + uarg[a++] = (intptr_t)p->name; /* char * */ + *n_args = 1; + break; + } + /* linux_reboot */ + case 88: { + struct linux_reboot_args *p = params; + iarg[a++] = p->magic1; /* l_int */ + iarg[a++] = p->magic2; /* l_int */ + iarg[a++] = p->cmd; /* l_uint */ + uarg[a++] = (intptr_t)p->arg; /* void * */ + *n_args = 4; + break; + } + /* linux_mmap */ + case 90: { + struct linux_mmap_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->len; /* l_ulong */ + iarg[a++] = p->prot; /* l_ulong */ + iarg[a++] = p->flags; /* l_ulong */ + iarg[a++] = p->fd; /* l_ulong */ + iarg[a++] = p->pgoff; /* l_ulong */ + *n_args = 6; + break; + } + /* munmap */ + case 91: { + struct munmap_args *p = params; + uarg[a++] = (intptr_t)p->addr; /* void * */ + iarg[a++] = p->len; /* l_size_t */ + *n_args = 2; + break; + } + /* linux_truncate */ + case 92: { + struct linux_truncate_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->length; /* l_long */ + *n_args = 2; + break; + } + /* linux_ftruncate */ + case 93: { + struct linux_ftruncate_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->length; /* l_ulong */ + *n_args = 2; + break; + } + /* fchmod */ + case 94: { + struct fchmod_args *p = params; + iarg[a++] = p->fd; /* int */ + iarg[a++] = p->mode; /* int */ + *n_args = 2; + break; + } + /* fchown */ + case 95: { + struct fchown_args *p = params; + iarg[a++] = p->fd; /* int */ + iarg[a++] = p->uid; /* int */ + iarg[a++] = p->gid; /* int */ + *n_args = 3; + break; + } + /* linux_getpriority */ + case 96: { + struct linux_getpriority_args *p = params; + iarg[a++] = p->which; /* l_int */ + iarg[a++] = p->who; /* l_int */ + *n_args = 2; + break; + } + /* setpriority */ + case 97: { + struct setpriority_args *p = params; + iarg[a++] = p->which; /* int */ + iarg[a++] = p->who; /* int */ + iarg[a++] = p->prio; /* int */ + *n_args = 3; + break; + } + /* linux_statfs */ + case 99: { + struct linux_statfs_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->buf; /* struct l_statfs_buf * */ + *n_args = 2; + break; + } + /* linux_fstatfs */ + case 100: { + struct linux_fstatfs_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->buf; /* struct l_statfs_buf * */ + *n_args = 2; + break; + } + /* linux_ioperm */ + case 101: { + *n_args = 0; + break; + } + /* linux_syslog */ + case 103: { + struct linux_syslog_args *p = params; + iarg[a++] = p->type; /* l_int */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->len; /* l_int */ + *n_args = 3; + break; + } + /* linux_setitimer */ + case 104: { + struct linux_setitimer_args *p = params; + iarg[a++] = p->which; /* l_int */ + uarg[a++] = (intptr_t)p->itv; /* struct l_itimerval * */ + uarg[a++] = (intptr_t)p->oitv; /* struct l_itimerval * */ + *n_args = 3; + break; + } + /* linux_getitimer */ + case 105: { + struct linux_getitimer_args *p = params; + iarg[a++] = p->which; /* l_int */ + uarg[a++] = (intptr_t)p->itv; /* struct l_itimerval * */ + *n_args = 2; + break; + } + /* linux_newstat */ + case 106: { + struct linux_newstat_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->buf; /* struct l_newstat * */ + *n_args = 2; + break; + } + /* linux_newlstat */ + case 107: { + struct linux_newlstat_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = (intptr_t)p->buf; /* struct l_newstat * */ + *n_args = 2; + break; + } + /* linux_newfstat */ + case 108: { + struct linux_newfstat_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->buf; /* struct l_newstat * */ + *n_args = 2; + break; + } + /* linux_iopl */ + case 110: { + struct linux_iopl_args *p = params; + iarg[a++] = p->level; /* l_uint */ + *n_args = 1; + break; + } + /* linux_vhangup */ + case 111: { + *n_args = 0; + break; + } + /* linux_wait4 */ + case 114: { + struct linux_wait4_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->status; /* l_int * */ + iarg[a++] = p->options; /* l_int */ + uarg[a++] = (intptr_t)p->rusage; /* struct rusage * */ + *n_args = 4; + break; + } + /* linux_swapoff */ + case 115: { + *n_args = 0; + break; + } + /* linux_sysinfo */ + case 116: { + struct linux_sysinfo_args *p = params; + uarg[a++] = (intptr_t)p->info; /* struct l_sysinfo * */ + *n_args = 1; + break; + } + /* fsync */ + case 118: { + struct fsync_args *p = params; + iarg[a++] = p->fd; /* int */ + *n_args = 1; + break; + } + /* linux_clone */ + case 120: { + struct linux_clone_args *p = params; + iarg[a++] = p->flags; /* l_ulong */ + iarg[a++] = p->stack; /* l_ulong */ + uarg[a++] = (intptr_t)p->parent_tidptr; /* l_int * */ + uarg[a++] = (intptr_t)p->child_tidptr; /* l_int * */ + iarg[a++] = p->tls; /* l_ulong */ + *n_args = 5; + break; + } + /* linux_setdomainname */ + case 121: { + struct linux_setdomainname_args *p = params; + uarg[a++] = (intptr_t)p->name; /* char * */ + iarg[a++] = p->len; /* l_int */ + *n_args = 2; + break; + } + /* linux_newuname */ + case 122: { + struct linux_newuname_args *p = params; + uarg[a++] = (intptr_t)p->buf; /* struct l_new_utsname * */ + *n_args = 1; + break; + } + /* linux_modify_ldt */ + case 123: { + *n_args = 0; + break; + } + /* linux_adjtimex */ + case 124: { + *n_args = 0; + break; + } + /* linux_mprotect */ + case 125: { + struct linux_mprotect_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->prot; /* l_ulong */ + *n_args = 3; + break; + } + /* linux_init_module */ + case 128: { + *n_args = 0; + break; + } + /* linux_delete_module */ + case 129: { + *n_args = 0; + break; + } + /* linux_quotactl */ + case 131: { + *n_args = 0; + break; + } + /* getpgid */ + case 132: { + struct getpgid_args *p = params; + iarg[a++] = p->pid; /* int */ + *n_args = 1; + break; + } + /* fchdir */ + case 133: { + struct fchdir_args *p = params; + iarg[a++] = p->fd; /* int */ + *n_args = 1; + break; + } + /* linux_personality */ + case 136: { + struct linux_personality_args *p = params; + iarg[a++] = p->per; /* l_uint */ + *n_args = 1; + break; + } + /* linux_setfsuid */ + case 138: { + struct linux_setfsuid_args *p = params; + iarg[a++] = p->uid; /* l_uid_t */ + *n_args = 1; + break; + } + /* linux_setfsgid */ + case 139: { + struct linux_setfsgid_args *p = params; + iarg[a++] = p->gid; /* l_gid_t */ + *n_args = 1; + break; + } + /* linux_llseek */ + case 140: { + struct linux_llseek_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->ohigh; /* l_ulong */ + iarg[a++] = p->olow; /* l_ulong */ + uarg[a++] = (intptr_t)p->res; /* l_loff_t * */ + iarg[a++] = p->whence; /* l_uint */ + *n_args = 5; + break; + } + /* linux_getdents */ + case 141: { + struct linux_getdents_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->dent; /* void * */ + iarg[a++] = p->count; /* l_uint */ + *n_args = 3; + break; + } + /* flock */ + case 143: { + struct flock_args *p = params; + iarg[a++] = p->fd; /* int */ + iarg[a++] = p->how; /* int */ + *n_args = 2; + break; + } + /* linux_msync */ + case 144: { + struct linux_msync_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->fl; /* l_int */ + *n_args = 3; + break; + } + /* readv */ + case 145: { + struct readv_args *p = params; + iarg[a++] = p->fd; /* int */ + uarg[a++] = (intptr_t)p->iovp; /* struct iovec * */ + uarg[a++] = p->iovcnt; /* u_int */ + *n_args = 3; + break; + } + /* linux_writev */ + case 146: { + struct linux_writev_args *p = params; + iarg[a++] = p->fd; /* int */ + uarg[a++] = (intptr_t)p->iovp; /* struct iovec * */ + uarg[a++] = p->iovcnt; /* u_int */ + *n_args = 3; + break; + } + /* linux_getsid */ + case 147: { + struct linux_getsid_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + *n_args = 1; + break; + } + /* linux_fdatasync */ + case 148: { + struct linux_fdatasync_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + *n_args = 1; + break; + } + /* linux_sysctl */ + case 149: { + struct linux_sysctl_args *p = params; + uarg[a++] = (intptr_t)p->args; /* struct l___sysctl_args * */ + *n_args = 1; + break; + } + /* mlock */ + case 150: { + struct mlock_args *p = params; + uarg[a++] = (intptr_t)p->addr; /* const void * */ + uarg[a++] = p->len; /* size_t */ + *n_args = 2; + break; + } + /* munlock */ + case 151: { + struct munlock_args *p = params; + uarg[a++] = (intptr_t)p->addr; /* const void * */ + uarg[a++] = p->len; /* size_t */ + *n_args = 2; + break; + } + /* mlockall */ + case 152: { + struct mlockall_args *p = params; + iarg[a++] = p->how; /* int */ + *n_args = 1; + break; + } + /* munlockall */ + case 153: { + *n_args = 0; + break; + } + /* linux_sched_setparam */ + case 154: { + struct linux_sched_setparam_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->param; /* struct sched_param * */ + *n_args = 2; + break; + } + /* linux_sched_getparam */ + case 155: { + struct linux_sched_getparam_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->param; /* struct sched_param * */ + *n_args = 2; + break; + } + /* linux_sched_setscheduler */ + case 156: { + struct linux_sched_setscheduler_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->policy; /* l_int */ + uarg[a++] = (intptr_t)p->param; /* struct sched_param * */ + *n_args = 3; + break; + } + /* linux_sched_getscheduler */ + case 157: { + struct linux_sched_getscheduler_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + *n_args = 1; + break; + } + /* sched_yield */ + case 158: { + *n_args = 0; + break; + } + /* linux_sched_get_priority_max */ + case 159: { + struct linux_sched_get_priority_max_args *p = params; + iarg[a++] = p->policy; /* l_int */ + *n_args = 1; + break; + } + /* linux_sched_get_priority_min */ + case 160: { + struct linux_sched_get_priority_min_args *p = params; + iarg[a++] = p->policy; /* l_int */ + *n_args = 1; + break; + } + /* linux_sched_rr_get_interval */ + case 161: { + struct linux_sched_rr_get_interval_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->interval; /* struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_nanosleep */ + case 162: { + struct linux_nanosleep_args *p = params; + uarg[a++] = (intptr_t)p->rqtp; /* const struct l_timespec * */ + uarg[a++] = (intptr_t)p->rmtp; /* struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_mremap */ + case 163: { + struct linux_mremap_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->old_len; /* l_ulong */ + iarg[a++] = p->new_len; /* l_ulong */ + iarg[a++] = p->flags; /* l_ulong */ + iarg[a++] = p->new_addr; /* l_ulong */ + *n_args = 5; + break; + } + /* setresuid */ + case 164: { + struct setresuid_args *p = params; + uarg[a++] = p->ruid; /* uid_t */ + uarg[a++] = p->euid; /* uid_t */ + uarg[a++] = p->suid; /* uid_t */ + *n_args = 3; + break; + } + /* getresuid */ + case 165: { + struct getresuid_args *p = params; + uarg[a++] = (intptr_t)p->ruid; /* uid_t * */ + uarg[a++] = (intptr_t)p->euid; /* uid_t * */ + uarg[a++] = (intptr_t)p->suid; /* uid_t * */ + *n_args = 3; + break; + } + /* linux_poll */ + case 167: { + struct linux_poll_args *p = params; + uarg[a++] = (intptr_t)p->fds; /* struct pollfd * */ + uarg[a++] = p->nfds; /* u_int */ + iarg[a++] = p->timeout; /* int */ + *n_args = 3; + break; + } + /* setresgid */ + case 169: { + struct setresgid_args *p = params; + iarg[a++] = p->rgid; /* gid_t */ + iarg[a++] = p->egid; /* gid_t */ + iarg[a++] = p->sgid; /* gid_t */ + *n_args = 3; + break; + } + /* getresgid */ + case 170: { + struct getresgid_args *p = params; + uarg[a++] = (intptr_t)p->rgid; /* gid_t * */ + uarg[a++] = (intptr_t)p->egid; /* gid_t * */ + uarg[a++] = (intptr_t)p->sgid; /* gid_t * */ + *n_args = 3; + break; + } + /* linux_prctl */ + case 171: { + struct linux_prctl_args *p = params; + iarg[a++] = p->option; /* l_int */ + uarg[a++] = (intptr_t)p->arg2; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->arg3; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->arg4; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->arg5; /* l_uintptr_t */ + *n_args = 5; + break; + } + /* linux_rt_sigreturn */ + case 172: { + *n_args = 0; + break; + } + /* linux_rt_sigaction */ + case 173: { + struct linux_rt_sigaction_args *p = params; + iarg[a++] = p->sig; /* l_int */ + uarg[a++] = (intptr_t)p->act; /* l_sigaction_t * */ + uarg[a++] = (intptr_t)p->oact; /* l_sigaction_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_rt_sigprocmask */ + case 174: { + struct linux_rt_sigprocmask_args *p = params; + iarg[a++] = p->how; /* l_int */ + uarg[a++] = (intptr_t)p->mask; /* l_sigset_t * */ + uarg[a++] = (intptr_t)p->omask; /* l_sigset_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_rt_sigpending */ + case 175: { + struct linux_rt_sigpending_args *p = params; + uarg[a++] = (intptr_t)p->set; /* l_sigset_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 2; + break; + } + /* linux_rt_sigtimedwait */ + case 176: { + struct linux_rt_sigtimedwait_args *p = params; + uarg[a++] = (intptr_t)p->mask; /* l_sigset_t * */ + uarg[a++] = (intptr_t)p->ptr; /* l_siginfo_t * */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timespec * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_rt_sigqueueinfo */ + case 177: { + struct linux_rt_sigqueueinfo_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->sig; /* l_int */ + uarg[a++] = (intptr_t)p->info; /* l_siginfo_t * */ + *n_args = 3; + break; + } + /* linux_rt_sigsuspend */ + case 178: { + struct linux_rt_sigsuspend_args *p = params; + uarg[a++] = (intptr_t)p->newset; /* l_sigset_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 2; + break; + } + /* linux_pread */ + case 179: { + struct linux_pread_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->nbyte; /* l_size_t */ + iarg[a++] = p->offset; /* l_loff_t */ + *n_args = 4; + break; + } + /* linux_pwrite */ + case 180: { + struct linux_pwrite_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->nbyte; /* l_size_t */ + iarg[a++] = p->offset; /* l_loff_t */ + *n_args = 4; + break; + } + /* linux_chown */ + case 181: { + struct linux_chown_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + iarg[a++] = p->uid; /* l_uid_t */ + iarg[a++] = p->gid; /* l_gid_t */ + *n_args = 3; + break; + } + /* linux_getcwd */ + case 182: { + struct linux_getcwd_args *p = params; + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->bufsize; /* l_ulong */ + *n_args = 2; + break; + } + /* linux_capget */ + case 183: { + struct linux_capget_args *p = params; + uarg[a++] = (intptr_t)p->hdrp; /* struct l_user_cap_header * */ + uarg[a++] = (intptr_t)p->datap; /* struct l_user_cap_data * */ + *n_args = 2; + break; + } + /* linux_capset */ + case 184: { + struct linux_capset_args *p = params; + uarg[a++] = (intptr_t)p->hdrp; /* struct l_user_cap_header * */ + uarg[a++] = (intptr_t)p->datap; /* struct l_user_cap_data * */ + *n_args = 2; + break; + } + /* linux_sigaltstack */ + case 185: { + struct linux_sigaltstack_args *p = params; + uarg[a++] = (intptr_t)p->uss; /* l_stack_t * */ + uarg[a++] = (intptr_t)p->uoss; /* l_stack_t * */ + *n_args = 2; + break; + } + /* linux_sendfile */ + case 186: { + struct linux_sendfile_args *p = params; + iarg[a++] = p->out; /* l_int */ + iarg[a++] = p->in; /* l_int */ + uarg[a++] = (intptr_t)p->offset; /* l_off_t * */ + iarg[a++] = p->count; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_vfork */ + case 189: { + *n_args = 0; + break; + } + /* linux_mmap2 */ + case 192: { + struct linux_mmap2_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->len; /* l_ulong */ + iarg[a++] = p->prot; /* l_ulong */ + iarg[a++] = p->flags; /* l_ulong */ + iarg[a++] = p->fd; /* l_ulong */ + iarg[a++] = p->pgoff; /* l_ulong */ + *n_args = 6; + break; + } + /* linux_getdents64 */ + case 202: { + struct linux_getdents64_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = (intptr_t)p->dirent; /* void * */ + iarg[a++] = p->count; /* l_uint */ + *n_args = 3; + break; + } + /* linux_pivot_root */ + case 203: { + *n_args = 0; + break; + } + /* linux_madvise */ + case 205: { + struct linux_madvise_args *p = params; + iarg[a++] = p->addr; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->behav; /* l_int */ + *n_args = 3; + break; + } + /* linux_mincore */ + case 206: { + struct linux_mincore_args *p = params; + iarg[a++] = p->start; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + uarg[a++] = (intptr_t)p->vec; /* u_char * */ + *n_args = 3; + break; + } + /* linux_gettid */ + case 207: { + *n_args = 0; + break; + } + /* linux_tkill */ + case 208: { + struct linux_tkill_args *p = params; + iarg[a++] = p->tid; /* l_pid_t */ + iarg[a++] = p->sig; /* l_int */ + *n_args = 2; + break; + } + /* linux_setxattr */ + case 209: { + struct linux_setxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* void * */ + iarg[a++] = p->size; /* l_size_t */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 5; + break; + } + /* linux_lsetxattr */ + case 210: { + struct linux_lsetxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* void * */ + iarg[a++] = p->size; /* l_size_t */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 5; + break; + } + /* linux_fsetxattr */ + case 211: { + struct linux_fsetxattr_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* void * */ + iarg[a++] = p->size; /* l_size_t */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 5; + break; + } + /* linux_getxattr */ + case 212: { + struct linux_getxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_lgetxattr */ + case 213: { + struct linux_lgetxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_fgetxattr */ + case 214: { + struct linux_fgetxattr_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->value; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 4; + break; + } + /* linux_listxattr */ + case 215: { + struct linux_listxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->list; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 3; + break; + } + /* linux_llistxattr */ + case 216: { + struct linux_llistxattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->list; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 3; + break; + } + /* linux_flistxattr */ + case 217: { + struct linux_flistxattr_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->list; /* char * */ + iarg[a++] = p->size; /* l_size_t */ + *n_args = 3; + break; + } + /* linux_removexattr */ + case 218: { + struct linux_removexattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + *n_args = 2; + break; + } + /* linux_lremovexattr */ + case 219: { + struct linux_lremovexattr_args *p = params; + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + *n_args = 2; + break; + } + /* linux_fremovexattr */ + case 220: { + struct linux_fremovexattr_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + *n_args = 2; + break; + } + /* linux_sys_futex */ + case 221: { + struct linux_sys_futex_args *p = params; + uarg[a++] = (intptr_t)p->uaddr; /* uint32_t * */ + iarg[a++] = p->op; /* l_int */ + uarg[a++] = p->val; /* uint32_t */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timespec * */ + uarg[a++] = (intptr_t)p->uaddr2; /* uint32_t * */ + uarg[a++] = p->val3; /* uint32_t */ + *n_args = 6; + break; + } + /* linux_sched_setaffinity */ + case 222: { + struct linux_sched_setaffinity_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->len; /* l_uint */ + uarg[a++] = (intptr_t)p->user_mask_ptr; /* l_ulong * */ + *n_args = 3; + break; + } + /* linux_sched_getaffinity */ + case 223: { + struct linux_sched_getaffinity_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->len; /* l_uint */ + uarg[a++] = (intptr_t)p->user_mask_ptr; /* l_ulong * */ + *n_args = 3; + break; + } + /* linux_set_tid_address */ + case 232: { + struct linux_set_tid_address_args *p = params; + uarg[a++] = (intptr_t)p->tidptr; /* l_int * */ + *n_args = 1; + break; + } + /* linux_fadvise64 */ + case 233: { + struct linux_fadvise64_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->offset; /* l_loff_t */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->advice; /* l_int */ + *n_args = 4; + break; + } + /* linux_exit_group */ + case 234: { + struct linux_exit_group_args *p = params; + iarg[a++] = p->error_code; /* l_int */ + *n_args = 1; + break; + } + /* linux_lookup_dcookie */ + case 235: { + *n_args = 0; + break; + } + /* linux_epoll_create */ + case 236: { + struct linux_epoll_create_args *p = params; + iarg[a++] = p->size; /* l_int */ + *n_args = 1; + break; + } + /* linux_epoll_ctl */ + case 237: { + struct linux_epoll_ctl_args *p = params; + iarg[a++] = p->epfd; /* l_int */ + iarg[a++] = p->op; /* l_int */ + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->event; /* struct epoll_event * */ + *n_args = 4; + break; + } + /* linux_epoll_wait */ + case 238: { + struct linux_epoll_wait_args *p = params; + iarg[a++] = p->epfd; /* l_int */ + uarg[a++] = (intptr_t)p->events; /* struct epoll_event * */ + iarg[a++] = p->maxevents; /* l_int */ + iarg[a++] = p->timeout; /* l_int */ + *n_args = 4; + break; + } + /* linux_remap_file_pages */ + case 239: { + *n_args = 0; + break; + } + /* linux_timer_create */ + case 240: { + struct linux_timer_create_args *p = params; + iarg[a++] = p->clock_id; /* clockid_t */ + uarg[a++] = (intptr_t)p->evp; /* struct sigevent * */ + uarg[a++] = (intptr_t)p->timerid; /* l_timer_t * */ + *n_args = 3; + break; + } + /* linux_timer_settime */ + case 241: { + struct linux_timer_settime_args *p = params; + iarg[a++] = p->timerid; /* l_timer_t */ + iarg[a++] = p->flags; /* l_int */ + uarg[a++] = (intptr_t)p->new; /* const struct itimerspec * */ + uarg[a++] = (intptr_t)p->old; /* struct itimerspec * */ + *n_args = 4; + break; + } + /* linux_timer_gettime */ + case 242: { + struct linux_timer_gettime_args *p = params; + iarg[a++] = p->timerid; /* l_timer_t */ + uarg[a++] = (intptr_t)p->setting; /* struct itimerspec * */ + *n_args = 2; + break; + } + /* linux_timer_getoverrun */ + case 243: { + struct linux_timer_getoverrun_args *p = params; + iarg[a++] = p->timerid; /* l_timer_t */ + *n_args = 1; + break; + } + /* linux_timer_delete */ + case 244: { + struct linux_timer_delete_args *p = params; + iarg[a++] = p->timerid; /* l_timer_t */ + *n_args = 1; + break; + } + /* linux_clock_settime */ + case 245: { + struct linux_clock_settime_args *p = params; + iarg[a++] = p->which; /* clockid_t */ + uarg[a++] = (intptr_t)p->tp; /* struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_clock_gettime */ + case 246: { + struct linux_clock_gettime_args *p = params; + iarg[a++] = p->which; /* clockid_t */ + uarg[a++] = (intptr_t)p->tp; /* struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_clock_getres */ + case 247: { + struct linux_clock_getres_args *p = params; + iarg[a++] = p->which; /* clockid_t */ + uarg[a++] = (intptr_t)p->tp; /* struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_clock_nanosleep */ + case 248: { + struct linux_clock_nanosleep_args *p = params; + iarg[a++] = p->which; /* clockid_t */ + iarg[a++] = p->flags; /* l_int */ + uarg[a++] = (intptr_t)p->rqtp; /* struct l_timespec * */ + uarg[a++] = (intptr_t)p->rmtp; /* struct l_timespec * */ + *n_args = 4; + break; + } + /* linux_tgkill */ + case 250: { + struct linux_tgkill_args *p = params; + iarg[a++] = p->tgid; /* l_pid_t */ + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->sig; /* l_int */ + *n_args = 3; + break; + } + /* linux_utimes */ + case 251: { + struct linux_utimes_args *p = params; + uarg[a++] = (intptr_t)p->fname; /* char * */ + uarg[a++] = (intptr_t)p->tptr; /* struct l_timeval * */ + *n_args = 2; + break; + } + /* linux_statfs64 */ + case 252: { + struct linux_statfs64_args *p = params; + uarg[a++] = (intptr_t)p->path; /* char * */ + uarg[a++] = p->bufsize; /* size_t */ + uarg[a++] = (intptr_t)p->buf; /* struct l_statfs64_buf * */ + *n_args = 3; + break; + } + /* linux_fstatfs64 */ + case 253: { + struct linux_fstatfs64_args *p = params; + iarg[a++] = p->fd; /* l_uint */ + uarg[a++] = p->bufsize; /* size_t */ + uarg[a++] = (intptr_t)p->buf; /* struct l_statfs64_buf * */ + *n_args = 3; + break; + } + /* linux_migrate_pages */ + case 258: { + *n_args = 0; + break; + } + /* linux_mbind */ + case 259: { + *n_args = 0; + break; + } + /* linux_get_mempolicy */ + case 260: { + *n_args = 0; + break; + } + /* linux_set_mempolicy */ + case 261: { + *n_args = 0; + break; + } + /* linux_mq_open */ + case 262: { + struct linux_mq_open_args *p = params; + uarg[a++] = (intptr_t)p->name; /* const char * */ + iarg[a++] = p->oflag; /* l_int */ + iarg[a++] = p->mode; /* l_mode_t */ + uarg[a++] = (intptr_t)p->attr; /* struct mq_attr * */ + *n_args = 4; + break; + } + /* linux_mq_unlink */ + case 263: { + struct linux_mq_unlink_args *p = params; + uarg[a++] = (intptr_t)p->name; /* const char * */ + *n_args = 1; + break; + } + /* linux_mq_timedsend */ + case 264: { + struct linux_mq_timedsend_args *p = params; + iarg[a++] = p->mqd; /* l_mqd_t */ + uarg[a++] = (intptr_t)p->msg_ptr; /* const char * */ + iarg[a++] = p->msg_len; /* l_size_t */ + iarg[a++] = p->msg_prio; /* l_uint */ + uarg[a++] = (intptr_t)p->abs_timeout; /* const struct l_timespec * */ + *n_args = 5; + break; + } + /* linux_mq_timedreceive */ + case 265: { + struct linux_mq_timedreceive_args *p = params; + iarg[a++] = p->mqd; /* l_mqd_t */ + uarg[a++] = (intptr_t)p->msg_ptr; /* char * */ + iarg[a++] = p->msg_len; /* l_size_t */ + uarg[a++] = (intptr_t)p->msg_prio; /* l_uint * */ + uarg[a++] = (intptr_t)p->abs_timeout; /* const struct l_timespec * */ + *n_args = 5; + break; + } + /* linux_mq_notify */ + case 266: { + struct linux_mq_notify_args *p = params; + iarg[a++] = p->mqd; /* l_mqd_t */ + uarg[a++] = (intptr_t)p->abs_timeout; /* const struct l_timespec * */ + *n_args = 2; + break; + } + /* linux_mq_getsetattr */ + case 267: { + struct linux_mq_getsetattr_args *p = params; + iarg[a++] = p->mqd; /* l_mqd_t */ + uarg[a++] = (intptr_t)p->attr; /* const struct mq_attr * */ + uarg[a++] = (intptr_t)p->oattr; /* struct mq_attr * */ + *n_args = 3; + break; + } + /* linux_kexec_load */ + case 268: { + *n_args = 0; + break; + } + /* linux_add_key */ + case 269: { + *n_args = 0; + break; + } + /* linux_request_key */ + case 270: { + *n_args = 0; + break; + } + /* linux_keyctl */ + case 271: { + *n_args = 0; + break; + } + /* linux_waitid */ + case 272: { + struct linux_waitid_args *p = params; + iarg[a++] = p->idtype; /* l_int */ + iarg[a++] = p->id; /* l_pid_t */ + uarg[a++] = (intptr_t)p->info; /* l_siginfo_t * */ + iarg[a++] = p->options; /* l_int */ + uarg[a++] = (intptr_t)p->rusage; /* struct rusage * */ + *n_args = 5; + break; + } + /* linux_ioprio_set */ + case 273: { + struct linux_ioprio_set_args *p = params; + iarg[a++] = p->which; /* l_int */ + iarg[a++] = p->who; /* l_int */ + iarg[a++] = p->ioprio; /* l_int */ + *n_args = 3; + break; + } + /* linux_ioprio_get */ + case 274: { + struct linux_ioprio_get_args *p = params; + iarg[a++] = p->which; /* l_int */ + iarg[a++] = p->who; /* l_int */ + *n_args = 2; + break; + } + /* linux_inotify_add_watch */ + case 276: { + *n_args = 0; + break; + } + /* linux_inotify_rm_watch */ + case 277: { + *n_args = 0; + break; + } + /* linux_pselect6 */ + case 280: { + struct linux_pselect6_args *p = params; + iarg[a++] = p->nfds; /* l_int */ + uarg[a++] = (intptr_t)p->readfds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->writefds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->exceptfds; /* l_fd_set * */ + uarg[a++] = (intptr_t)p->tsp; /* struct l_timespec * */ + uarg[a++] = (intptr_t)p->sig; /* l_uintptr_t * */ + *n_args = 6; + break; + } + /* linux_ppoll */ + case 281: { + struct linux_ppoll_args *p = params; + uarg[a++] = (intptr_t)p->fds; /* struct pollfd * */ + iarg[a++] = p->nfds; /* l_uint */ + uarg[a++] = (intptr_t)p->tsp; /* struct l_timespec * */ + uarg[a++] = (intptr_t)p->sset; /* l_sigset_t * */ + iarg[a++] = p->ssize; /* l_size_t */ + *n_args = 5; + break; + } + /* linux_unshare */ + case 282: { + *n_args = 0; + break; + } + /* linux_splice */ + case 283: { + struct linux_splice_args *p = params; + iarg[a++] = p->fd_in; /* int */ + uarg[a++] = (intptr_t)p->off_in; /* l_loff_t * */ + iarg[a++] = p->fd_out; /* int */ + uarg[a++] = (intptr_t)p->off_out; /* l_loff_t * */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 6; + break; + } + /* linux_tee */ + case 284: { + *n_args = 0; + break; + } + /* linux_vmsplice */ + case 285: { + *n_args = 0; + break; + } + /* linux_openat */ + case 286: { + struct linux_openat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->flags; /* l_int */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 4; + break; + } + /* linux_mkdirat */ + case 287: { + struct linux_mkdirat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->pathname; /* const char * */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 3; + break; + } + /* linux_mknodat */ + case 288: { + struct linux_mknodat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->mode; /* l_mode_t */ + iarg[a++] = p->dev; /* l_uint */ + *n_args = 4; + break; + } + /* linux_fchownat */ + case 289: { + struct linux_fchownat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->uid; /* l_uid_t */ + iarg[a++] = p->gid; /* l_gid_t */ + iarg[a++] = p->flag; /* l_int */ + *n_args = 5; + break; + } + /* linux_futimesat */ + case 290: { + struct linux_futimesat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* char * */ + uarg[a++] = (intptr_t)p->utimes; /* struct l_timeval * */ + *n_args = 3; + break; + } + /* linux_newfstatat */ + case 291: { + struct linux_newfstatat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->pathname; /* char * */ + uarg[a++] = (intptr_t)p->statbuf; /* struct l_stat64 * */ + iarg[a++] = p->flag; /* l_int */ + *n_args = 4; + break; + } + /* linux_unlinkat */ + case 292: { + struct linux_unlinkat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->pathname; /* const char * */ + iarg[a++] = p->flag; /* l_int */ + *n_args = 3; + break; + } + /* linux_renameat */ + case 293: { + struct linux_renameat_args *p = params; + iarg[a++] = p->olddfd; /* l_int */ + uarg[a++] = (intptr_t)p->oldname; /* const char * */ + iarg[a++] = p->newdfd; /* l_int */ + uarg[a++] = (intptr_t)p->newname; /* const char * */ + *n_args = 4; + break; + } + /* linux_linkat */ + case 294: { + struct linux_linkat_args *p = params; + iarg[a++] = p->olddfd; /* l_int */ + uarg[a++] = (intptr_t)p->oldname; /* const char * */ + iarg[a++] = p->newdfd; /* l_int */ + uarg[a++] = (intptr_t)p->newname; /* const char * */ + iarg[a++] = p->flag; /* l_int */ + *n_args = 5; + break; + } + /* linux_symlinkat */ + case 295: { + struct linux_symlinkat_args *p = params; + uarg[a++] = (intptr_t)p->oldname; /* const char * */ + iarg[a++] = p->newdfd; /* l_int */ + uarg[a++] = (intptr_t)p->newname; /* const char * */ + *n_args = 3; + break; + } + /* linux_readlinkat */ + case 296: { + struct linux_readlinkat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->path; /* const char * */ + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->bufsiz; /* l_int */ + *n_args = 4; + break; + } + /* linux_fchmodat */ + case 297: { + struct linux_fchmodat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->mode; /* l_mode_t */ + *n_args = 3; + break; + } + /* linux_faccessat */ + case 298: { + struct linux_faccessat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->amode; /* l_int */ + *n_args = 3; + break; + } + /* linux_get_robust_list */ + case 299: { + struct linux_get_robust_list_args *p = params; + iarg[a++] = p->pid; /* l_int */ + uarg[a++] = (intptr_t)p->head; /* struct linux_robust_list_head ** */ + uarg[a++] = (intptr_t)p->len; /* l_size_t * */ + *n_args = 3; + break; + } + /* linux_set_robust_list */ + case 300: { + struct linux_set_robust_list_args *p = params; + uarg[a++] = (intptr_t)p->head; /* struct linux_robust_list_head * */ + iarg[a++] = p->len; /* l_size_t */ + *n_args = 2; + break; + } + /* linux_move_pages */ + case 301: { + *n_args = 0; + break; + } + /* linux_getcpu */ + case 302: { + struct linux_getcpu_args *p = params; + uarg[a++] = (intptr_t)p->cpu; /* l_uint * */ + uarg[a++] = (intptr_t)p->node; /* l_uint * */ + uarg[a++] = (intptr_t)p->cache; /* void * */ + *n_args = 3; + break; + } + /* linux_epoll_pwait */ + case 303: { + struct linux_epoll_pwait_args *p = params; + iarg[a++] = p->epfd; /* l_int */ + uarg[a++] = (intptr_t)p->events; /* struct epoll_event * */ + iarg[a++] = p->maxevents; /* l_int */ + iarg[a++] = p->timeout; /* l_int */ + uarg[a++] = (intptr_t)p->mask; /* l_sigset_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 6; + break; + } + /* linux_utimensat */ + case 304: { + struct linux_utimensat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->pathname; /* const char * */ + uarg[a++] = (intptr_t)p->times; /* const struct l_timespec * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 4; + break; + } + /* linux_timerfd_create */ + case 306: { + struct linux_timerfd_create_args *p = params; + iarg[a++] = p->clockid; /* l_int */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 2; + break; + } + /* linux_eventfd */ + case 307: { + struct linux_eventfd_args *p = params; + iarg[a++] = p->initval; /* l_uint */ + *n_args = 1; + break; + } + /* linux_sync_file_range */ + case 308: { + struct linux_sync_file_range_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->offset; /* l_loff_t */ + iarg[a++] = p->nbytes; /* l_loff_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 4; + break; + } + /* linux_fallocate */ + case 309: { + struct linux_fallocate_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->mode; /* l_int */ + iarg[a++] = p->offset; /* l_loff_t */ + iarg[a++] = p->len; /* l_loff_t */ + *n_args = 4; + break; + } + /* linux_timerfd_settime */ + case 311: { + struct linux_timerfd_settime_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->flags; /* l_int */ + uarg[a++] = (intptr_t)p->new_value; /* const struct l_itimerspec * */ + uarg[a++] = (intptr_t)p->old_value; /* struct l_itimerspec * */ + *n_args = 4; + break; + } + /* linux_timerfd_gettime */ + case 312: { + struct linux_timerfd_gettime_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->old_value; /* struct l_itimerspec * */ + *n_args = 2; + break; + } + /* linux_signalfd4 */ + case 313: { + *n_args = 0; + break; + } + /* linux_eventfd2 */ + case 314: { + struct linux_eventfd2_args *p = params; + iarg[a++] = p->initval; /* l_uint */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 2; + break; + } + /* linux_epoll_create1 */ + case 315: { + struct linux_epoll_create1_args *p = params; + iarg[a++] = p->flags; /* l_int */ + *n_args = 1; + break; + } + /* linux_dup3 */ + case 316: { + struct linux_dup3_args *p = params; + iarg[a++] = p->oldfd; /* l_uint */ + iarg[a++] = p->newfd; /* l_uint */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 3; + break; + } + /* linux_pipe2 */ + case 317: { + struct linux_pipe2_args *p = params; + uarg[a++] = (intptr_t)p->pipefds; /* l_int * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 2; + break; + } + /* linux_inotify_init1 */ + case 318: { + struct linux_inotify_init1_args *p = params; + iarg[a++] = p->flags; /* l_int */ + *n_args = 1; + break; + } + /* linux_perf_event_open */ + case 319: { + *n_args = 0; + break; + } + /* linux_preadv */ + case 320: { + struct linux_preadv_args *p = params; + iarg[a++] = p->fd; /* l_ulong */ + uarg[a++] = (intptr_t)p->vec; /* struct iovec * */ + iarg[a++] = p->vlen; /* l_ulong */ + iarg[a++] = p->pos_l; /* l_ulong */ + iarg[a++] = p->pos_h; /* l_ulong */ + *n_args = 5; + break; + } + /* linux_pwritev */ + case 321: { + struct linux_pwritev_args *p = params; + iarg[a++] = p->fd; /* l_ulong */ + uarg[a++] = (intptr_t)p->vec; /* struct iovec * */ + iarg[a++] = p->vlen; /* l_ulong */ + iarg[a++] = p->pos_l; /* l_ulong */ + iarg[a++] = p->pos_h; /* l_ulong */ + *n_args = 5; + break; + } + /* linux_rt_tgsigqueueinfo */ + case 322: { + struct linux_rt_tgsigqueueinfo_args *p = params; + iarg[a++] = p->tgid; /* l_pid_t */ + iarg[a++] = p->tid; /* l_pid_t */ + iarg[a++] = p->sig; /* l_int */ + uarg[a++] = (intptr_t)p->uinfo; /* l_siginfo_t * */ + *n_args = 4; + break; + } + /* linux_fanotify_init */ + case 323: { + *n_args = 0; + break; + } + /* linux_fanotify_mark */ + case 324: { + *n_args = 0; + break; + } + /* linux_prlimit64 */ + case 325: { + struct linux_prlimit64_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + iarg[a++] = p->resource; /* l_uint */ + uarg[a++] = (intptr_t)p->new; /* struct rlimit * */ + uarg[a++] = (intptr_t)p->old; /* struct rlimit * */ + *n_args = 4; + break; + } + /* linux_socket */ + case 326: { + struct linux_socket_args *p = params; + iarg[a++] = p->domain; /* l_int */ + iarg[a++] = p->type; /* l_int */ + iarg[a++] = p->protocol; /* l_int */ + *n_args = 3; + break; + } + /* linux_bind */ + case 327: { + struct linux_bind_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* l_uintptr_t */ + iarg[a++] = p->namelen; /* l_int */ + *n_args = 3; + break; + } + /* linux_connect */ + case 328: { + struct linux_connect_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* l_uintptr_t */ + iarg[a++] = p->namelen; /* l_int */ + *n_args = 3; + break; + } + /* linux_listen */ + case 329: { + struct linux_listen_args *p = params; + iarg[a++] = p->s; /* l_int */ + iarg[a++] = p->backlog; /* l_int */ + *n_args = 2; + break; + } + /* linux_accept */ + case 330: { + struct linux_accept_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->addr; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->namelen; /* l_uintptr_t */ + *n_args = 3; + break; + } + /* linux_getsockname */ + case 331: { + struct linux_getsockname_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->addr; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->namelen; /* l_uintptr_t */ + *n_args = 3; + break; + } + /* linux_getpeername */ + case 332: { + struct linux_getpeername_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->addr; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->namelen; /* l_uintptr_t */ + *n_args = 3; + break; + } + /* linux_socketpair */ + case 333: { + struct linux_socketpair_args *p = params; + iarg[a++] = p->domain; /* l_int */ + iarg[a++] = p->type; /* l_int */ + iarg[a++] = p->protocol; /* l_int */ + uarg[a++] = (intptr_t)p->rsv; /* l_uintptr_t */ + *n_args = 4; + break; + } + /* linux_sendto */ + case 335: { + struct linux_sendto_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->msg; /* l_uintptr_t */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->flags; /* l_uint */ + uarg[a++] = (intptr_t)p->to; /* l_uintptr_t */ + iarg[a++] = p->tolen; /* l_int */ + *n_args = 6; + break; + } + /* linux_recvfrom */ + case 337: { + struct linux_recvfrom_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->buf; /* l_uintptr_t */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->flags; /* l_uint */ + uarg[a++] = (intptr_t)p->from; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->fromlen; /* l_uintptr_t */ + *n_args = 6; + break; + } + /* linux_shutdown */ + case 338: { + struct linux_shutdown_args *p = params; + iarg[a++] = p->s; /* l_int */ + iarg[a++] = p->how; /* l_int */ + *n_args = 2; + break; + } + /* linux_setsockopt */ + case 339: { + struct linux_setsockopt_args *p = params; + iarg[a++] = p->s; /* l_int */ + iarg[a++] = p->level; /* l_int */ + iarg[a++] = p->optname; /* l_int */ + uarg[a++] = (intptr_t)p->optval; /* l_uintptr_t */ + iarg[a++] = p->optlen; /* l_int */ + *n_args = 5; + break; + } + /* linux_getsockopt */ + case 340: { + struct linux_getsockopt_args *p = params; + iarg[a++] = p->s; /* l_int */ + iarg[a++] = p->level; /* l_int */ + iarg[a++] = p->optname; /* l_int */ + uarg[a++] = (intptr_t)p->optval; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->optlen; /* l_uintptr_t */ + *n_args = 5; + break; + } + /* linux_sendmsg */ + case 341: { + struct linux_sendmsg_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->msg; /* l_uintptr_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 3; + break; + } + /* linux_recvmsg */ + case 342: { + struct linux_recvmsg_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->msg; /* l_uintptr_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 3; + break; + } + /* linux_recvmmsg */ + case 343: { + struct linux_recvmmsg_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->msg; /* struct l_mmsghdr * */ + iarg[a++] = p->vlen; /* l_uint */ + iarg[a++] = p->flags; /* l_uint */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timespec * */ + *n_args = 5; + break; + } + /* linux_accept4 */ + case 344: { + struct linux_accept4_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->addr; /* l_uintptr_t */ + uarg[a++] = (intptr_t)p->namelen; /* l_uintptr_t */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 4; + break; + } + /* linux_name_to_handle_at */ + case 345: { + struct linux_name_to_handle_at_args *p = params; + iarg[a++] = p->dirfd; /* l_int */ + uarg[a++] = (intptr_t)p->name; /* const char * */ + uarg[a++] = (intptr_t)p->handle; /* struct l_file_handle * */ + uarg[a++] = (intptr_t)p->mnt_id; /* l_int * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 5; + break; + } + /* linux_open_by_handle_at */ + case 346: { + struct linux_open_by_handle_at_args *p = params; + iarg[a++] = p->mountdirfd; /* l_int */ + uarg[a++] = (intptr_t)p->handle; /* struct l_file_handle * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 3; + break; + } + /* linux_clock_adjtime */ + case 347: { + *n_args = 0; + break; + } + /* linux_syncfs */ + case 348: { + struct linux_syncfs_args *p = params; + iarg[a++] = p->fd; /* l_int */ + *n_args = 1; + break; + } + /* linux_sendmmsg */ + case 349: { + struct linux_sendmmsg_args *p = params; + iarg[a++] = p->s; /* l_int */ + uarg[a++] = (intptr_t)p->msg; /* struct l_mmsghdr * */ + iarg[a++] = p->vlen; /* l_uint */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 4; + break; + } + /* linux_setns */ + case 350: { + struct linux_setns_args *p = params; + iarg[a++] = p->fd; /* l_int */ + iarg[a++] = p->nstype; /* l_int */ + *n_args = 2; + break; + } + /* linux_process_vm_readv */ + case 351: { + struct linux_process_vm_readv_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->lvec; /* const struct iovec * */ + iarg[a++] = p->liovcnt; /* l_ulong */ + uarg[a++] = (intptr_t)p->rvec; /* const struct iovec * */ + iarg[a++] = p->riovcnt; /* l_ulong */ + iarg[a++] = p->flags; /* l_ulong */ + *n_args = 6; + break; + } + /* linux_process_vm_writev */ + case 352: { + struct linux_process_vm_writev_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->lvec; /* const struct iovec * */ + iarg[a++] = p->liovcnt; /* l_ulong */ + uarg[a++] = (intptr_t)p->rvec; /* const struct iovec * */ + iarg[a++] = p->riovcnt; /* l_ulong */ + iarg[a++] = p->flags; /* l_ulong */ + *n_args = 6; + break; + } + /* linux_finit_module */ + case 353: { + struct linux_finit_module_args *p = params; + iarg[a++] = p->fd; /* l_int */ + uarg[a++] = (intptr_t)p->uargs; /* const char * */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 3; + break; + } + /* linux_kcmp */ + case 354: { + struct linux_kcmp_args *p = params; + iarg[a++] = p->pid1; /* l_pid_t */ + iarg[a++] = p->pid2; /* l_pid_t */ + iarg[a++] = p->type; /* l_int */ + iarg[a++] = p->idx1; /* l_ulong */ + iarg[a++] = p->idx; /* l_ulong */ + *n_args = 5; + break; + } + /* linux_sched_setattr */ + case 355: { + struct linux_sched_setattr_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->attr; /* void * */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 3; + break; + } + /* linux_sched_getattr */ + case 356: { + struct linux_sched_getattr_args *p = params; + iarg[a++] = p->pid; /* l_pid_t */ + uarg[a++] = (intptr_t)p->attr; /* void * */ + iarg[a++] = p->size; /* l_uint */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 4; + break; + } + /* linux_renameat2 */ + case 357: { + struct linux_renameat2_args *p = params; + iarg[a++] = p->olddfd; /* l_int */ + uarg[a++] = (intptr_t)p->oldname; /* const char * */ + iarg[a++] = p->newdfd; /* l_int */ + uarg[a++] = (intptr_t)p->newname; /* const char * */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 5; + break; + } + /* linux_seccomp */ + case 358: { + struct linux_seccomp_args *p = params; + iarg[a++] = p->op; /* l_uint */ + iarg[a++] = p->flags; /* l_uint */ + uarg[a++] = (intptr_t)p->uargs; /* const char * */ + *n_args = 3; + break; + } + /* linux_getrandom */ + case 359: { + struct linux_getrandom_args *p = params; + uarg[a++] = (intptr_t)p->buf; /* char * */ + iarg[a++] = p->count; /* l_size_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 3; + break; + } + /* linux_memfd_create */ + case 360: { + struct linux_memfd_create_args *p = params; + uarg[a++] = (intptr_t)p->uname_ptr; /* const char * */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 2; + break; + } + /* linux_bpf */ + case 361: { + struct linux_bpf_args *p = params; + iarg[a++] = p->cmd; /* l_int */ + uarg[a++] = (intptr_t)p->attr; /* void * */ + iarg[a++] = p->size; /* l_uint */ + *n_args = 3; + break; + } + /* linux_execveat */ + case 362: { + struct linux_execveat_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + uarg[a++] = (intptr_t)p->argv; /* const char ** */ + uarg[a++] = (intptr_t)p->envp; /* const char ** */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 5; + break; + } + /* linux_userfaultfd */ + case 364: { + struct linux_userfaultfd_args *p = params; + iarg[a++] = p->flags; /* l_int */ + *n_args = 1; + break; + } + /* linux_membarrier */ + case 365: { + struct linux_membarrier_args *p = params; + iarg[a++] = p->cmd; /* l_int */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 2; + break; + } + /* linux_mlock2 */ + case 378: { + struct linux_mlock2_args *p = params; + iarg[a++] = p->start; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 3; + break; + } + /* linux_copy_file_range */ + case 379: { + struct linux_copy_file_range_args *p = params; + iarg[a++] = p->fd_in; /* l_int */ + uarg[a++] = (intptr_t)p->off_in; /* l_loff_t * */ + iarg[a++] = p->fd_out; /* l_int */ + uarg[a++] = (intptr_t)p->off_out; /* l_loff_t * */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 6; + break; + } + /* linux_preadv2 */ + case 380: { + struct linux_preadv2_args *p = params; + iarg[a++] = p->fd; /* l_ulong */ + uarg[a++] = (intptr_t)p->vec; /* const struct iovec * */ + iarg[a++] = p->vlen; /* l_ulong */ + iarg[a++] = p->pos_l; /* l_ulong */ + iarg[a++] = p->pos_h; /* l_ulong */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 6; + break; + } + /* linux_pwritev2 */ + case 381: { + struct linux_pwritev2_args *p = params; + iarg[a++] = p->fd; /* l_ulong */ + uarg[a++] = (intptr_t)p->vec; /* const struct iovec * */ + iarg[a++] = p->vlen; /* l_ulong */ + iarg[a++] = p->pos_l; /* l_ulong */ + iarg[a++] = p->pos_h; /* l_ulong */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 6; + break; + } + /* linux_statx */ + case 383: { + struct linux_statx_args *p = params; + iarg[a++] = p->dirfd; /* l_int */ + uarg[a++] = (intptr_t)p->pathname; /* const char * */ + iarg[a++] = p->flags; /* l_uint */ + iarg[a++] = p->mask; /* l_uint */ + uarg[a++] = (intptr_t)p->statxbuf; /* void * */ + *n_args = 5; + break; + } + /* linux_pkey_alloc */ + case 384: { + struct linux_pkey_alloc_args *p = params; + iarg[a++] = p->flags; /* l_ulong */ + iarg[a++] = p->init_val; /* l_ulong */ + *n_args = 2; + break; + } + /* linux_pkey_free */ + case 385: { + struct linux_pkey_free_args *p = params; + iarg[a++] = p->pkey; /* l_int */ + *n_args = 1; + break; + } + /* linux_pkey_mprotect */ + case 386: { + struct linux_pkey_mprotect_args *p = params; + iarg[a++] = p->start; /* l_ulong */ + iarg[a++] = p->len; /* l_size_t */ + iarg[a++] = p->prot; /* l_ulong */ + iarg[a++] = p->pkey; /* l_int */ + *n_args = 4; + break; + } + /* linux_rseq */ + case 387: { + struct linux_rseq_args *p = params; + uarg[a++] = (intptr_t)p->rseq; /* struct linux_rseq * */ + uarg[a++] = p->rseq_len; /* uint32_t */ + iarg[a++] = p->flags; /* l_int */ + uarg[a++] = p->sig; /* uint32_t */ + *n_args = 4; + break; + } + /* linux_io_pgetevents */ + case 388: { + *n_args = 0; + break; + } + /* linux_semtimedop */ + case 392: { + struct linux_semtimedop_args *p = params; + iarg[a++] = p->semid; /* l_int */ + uarg[a++] = (intptr_t)p->tsops; /* struct sembuf * */ + iarg[a++] = p->nsops; /* l_size_t */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timespec * */ + *n_args = 4; + break; + } + /* linux_semget */ + case 393: { + struct linux_semget_args *p = params; + iarg[a++] = p->key; /* l_key_t */ + iarg[a++] = p->nsems; /* l_int */ + iarg[a++] = p->semflg; /* l_int */ + *n_args = 3; + break; + } + /* linux_semctl */ + case 394: { + struct linux_semctl_args *p = params; + iarg[a++] = p->semid; /* l_int */ + iarg[a++] = p->semnum; /* l_int */ + iarg[a++] = p->cmd; /* l_int */ + uarg[a++] = p->arg.buf; /* union l_semun */ + *n_args = 4; + break; + } + /* linux_shmget */ + case 395: { + struct linux_shmget_args *p = params; + iarg[a++] = p->key; /* l_key_t */ + iarg[a++] = p->size; /* l_size_t */ + iarg[a++] = p->shmflg; /* l_int */ + *n_args = 3; + break; + } + /* linux_shmctl */ + case 396: { + struct linux_shmctl_args *p = params; + iarg[a++] = p->shmid; /* l_int */ + iarg[a++] = p->cmd; /* l_int */ + uarg[a++] = (intptr_t)p->buf; /* struct l_shmid_ds * */ + *n_args = 3; + break; + } + /* linux_shmat */ + case 397: { + struct linux_shmat_args *p = params; + iarg[a++] = p->shmid; /* l_int */ + uarg[a++] = (intptr_t)p->shmaddr; /* char * */ + iarg[a++] = p->shmflg; /* l_int */ + *n_args = 3; + break; + } + /* linux_shmdt */ + case 398: { + struct linux_shmdt_args *p = params; + uarg[a++] = (intptr_t)p->shmaddr; /* char * */ + *n_args = 1; + break; + } + /* linux_msgget */ + case 399: { + struct linux_msgget_args *p = params; + iarg[a++] = p->key; /* l_key_t */ + iarg[a++] = p->msgflg; /* l_int */ + *n_args = 2; + break; + } + /* linux_msgsnd */ + case 400: { + struct linux_msgsnd_args *p = params; + iarg[a++] = p->msqid; /* l_int */ + uarg[a++] = (intptr_t)p->msgp; /* struct l_msgbuf * */ + iarg[a++] = p->msgsz; /* l_size_t */ + iarg[a++] = p->msgflg; /* l_int */ + *n_args = 4; + break; + } + /* linux_msgrcv */ + case 401: { + struct linux_msgrcv_args *p = params; + iarg[a++] = p->msqid; /* l_int */ + uarg[a++] = (intptr_t)p->msgp; /* struct l_msgbuf * */ + iarg[a++] = p->msgsz; /* l_size_t */ + iarg[a++] = p->msgtyp; /* l_long */ + iarg[a++] = p->msgflg; /* l_int */ + *n_args = 5; + break; + } + /* linux_msgctl */ + case 402: { + struct linux_msgctl_args *p = params; + iarg[a++] = p->msqid; /* l_int */ + iarg[a++] = p->cmd; /* l_int */ + uarg[a++] = (intptr_t)p->buf; /* struct l_msqid_ds * */ + *n_args = 3; + break; + } + /* linux_pidfd_send_signal */ + case 424: { + struct linux_pidfd_send_signal_args *p = params; + iarg[a++] = p->pidfd; /* l_int */ + iarg[a++] = p->sig; /* l_int */ + uarg[a++] = (intptr_t)p->info; /* l_siginfo_t * */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 4; + break; + } + /* linux_io_uring_setup */ + case 425: { + *n_args = 0; + break; + } + /* linux_io_uring_enter */ + case 426: { + *n_args = 0; + break; + } + /* linux_io_uring_register */ + case 427: { + *n_args = 0; + break; + } + /* linux_open_tree */ + case 428: { + *n_args = 0; + break; + } + /* linux_move_mount */ + case 429: { + *n_args = 0; + break; + } + /* linux_fsopen */ + case 430: { + *n_args = 0; + break; + } + /* linux_fsconfig */ + case 431: { + *n_args = 0; + break; + } + /* linux_fsmount */ + case 432: { + *n_args = 0; + break; + } + /* linux_fspick */ + case 433: { + *n_args = 0; + break; + } + /* linux_pidfd_open */ + case 434: { + *n_args = 0; + break; + } + /* linux_clone3 */ + case 435: { + struct linux_clone3_args *p = params; + uarg[a++] = (intptr_t)p->uargs; /* struct l_user_clone_args * */ + iarg[a++] = p->usize; /* l_size_t */ + *n_args = 2; + break; + } + /* linux_close_range */ + case 436: { + struct linux_close_range_args *p = params; + iarg[a++] = p->first; /* l_uint */ + iarg[a++] = p->last; /* l_uint */ + iarg[a++] = p->flags; /* l_uint */ + *n_args = 3; + break; + } + /* linux_openat2 */ + case 437: { + *n_args = 0; + break; + } + /* linux_pidfd_getfd */ + case 438: { + *n_args = 0; + break; + } + /* linux_faccessat2 */ + case 439: { + struct linux_faccessat2_args *p = params; + iarg[a++] = p->dfd; /* l_int */ + uarg[a++] = (intptr_t)p->filename; /* const char * */ + iarg[a++] = p->amode; /* l_int */ + iarg[a++] = p->flags; /* l_int */ + *n_args = 4; + break; + } + /* linux_process_madvise */ + case 440: { + *n_args = 0; + break; + } + /* linux_epoll_pwait2 */ + case 441: { + struct linux_epoll_pwait2_args *p = params; + iarg[a++] = p->epfd; /* l_int */ + uarg[a++] = (intptr_t)p->events; /* struct epoll_event * */ + iarg[a++] = p->maxevents; /* l_int */ + uarg[a++] = (intptr_t)p->timeout; /* struct l_timespec * */ + uarg[a++] = (intptr_t)p->mask; /* l_sigset_t * */ + iarg[a++] = p->sigsetsize; /* l_size_t */ + *n_args = 6; + break; + } + /* linux_mount_setattr */ + case 442: { + *n_args = 0; + break; + } + /* linux_quotactl_fd */ + case 443: { + *n_args = 0; + break; + } + /* linux_landlock_create_ruleset */ + case 444: { + *n_args = 0; + break; + } + /* linux_landlock_add_rule */ + case 445: { + *n_args = 0; + break; + } + /* linux_landlock_restrict_self */ + case 446: { + *n_args = 0; + break; + } + /* linux_memfd_secret */ + case 447: { + *n_args = 0; + break; + } + /* linux_process_mrelease */ + case 448: { + *n_args = 0; + break; + } + /* linux_futex_waitv */ + case 449: { + *n_args = 0; + break; + } + /* linux_set_mempolicy_home_node */ + case 450: { + *n_args = 0; + break; + } + /* linux_cachestat */ + case 451: { + *n_args = 0; + break; + } + /* linux_fchmodat2 */ + case 452: { + *n_args = 0; + break; + } + /* linux_map_shadow_stack */ + case 453: { + *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) { + /* linux_exit */ + case 1: + switch (ndx) { + case 0: + p = "u_int"; + break; + default: + break; + }; + break; + /* linux_fork */ + case 2: + break; + /* read */ + case 3: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_write */ + case 4: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_open */ + case 5: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* close */ + case 6: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* linux_creat */ + case 8: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_link */ + case 9: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_unlink */ + case 10: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_execve */ + case 11: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland l_uintptr_t *"; + break; + case 2: + p = "userland l_uintptr_t *"; + break; + default: + break; + }; + break; + /* linux_chdir */ + case 12: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_time */ + case 13: + switch (ndx) { + case 0: + p = "userland l_time_t *"; + break; + default: + break; + }; + break; + /* linux_mknod */ + case 14: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_mode_t"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_chmod */ + case 15: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_lchown */ + case 16: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_uid_t"; + break; + case 2: + p = "l_gid_t"; + break; + default: + break; + }; + break; + /* linux_lseek */ + case 19: + 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_getpid */ + case 20: + break; + /* linux_mount */ + case 21: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "userland char *"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "userland void *"; + break; + default: + break; + }; + break; + /* linux_umount */ + case 22: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* setuid */ + case 23: + switch (ndx) { + case 0: + p = "uid_t"; + break; + default: + break; + }; + break; + /* linux_getuid */ + case 24: + break; + /* linux_ptrace */ + case 26: + switch (ndx) { + case 0: + p = "l_long"; + break; + case 1: + p = "l_long"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_alarm */ + case 27: + switch (ndx) { + case 0: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_pause */ + case 29: + break; + /* linux_utime */ + case 30: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland struct l_utimbuf *"; + break; + default: + break; + }; + break; + /* linux_access */ + case 33: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* sync */ + case 36: + break; + /* linux_kill */ + case 37: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_rename */ + case 38: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_mkdir */ + case 39: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_rmdir */ + case 40: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* dup */ + case 41: + switch (ndx) { + case 0: + p = "u_int"; + break; + default: + break; + }; + break; + /* linux_pipe */ + case 42: + switch (ndx) { + case 0: + p = "userland l_int *"; + break; + default: + break; + }; + break; + /* linux_times */ + case 43: + switch (ndx) { + case 0: + p = "userland struct l_times_argv *"; + break; + default: + break; + }; + break; + /* linux_brk */ + case 45: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* setgid */ + case 46: + switch (ndx) { + case 0: + p = "gid_t"; + break; + default: + break; + }; + break; + /* linux_getgid */ + case 47: + break; + /* geteuid */ + case 49: + break; + /* getegid */ + case 50: + break; + /* acct */ + case 51: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_ioctl */ + case 54: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_fcntl */ + case 55: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* setpgid */ + case 57: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "int"; + break; + default: + break; + }; + break; + /* umask */ + case 60: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* chroot */ + case 61: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_ustat */ + case 62: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland struct l_ustat *"; + break; + default: + break; + }; + break; + /* dup2 */ + case 63: + switch (ndx) { + case 0: + p = "u_int"; + break; + case 1: + p = "u_int"; + break; + default: + break; + }; + break; + /* linux_getppid */ + case 64: + break; + /* getpgrp */ + case 65: + break; + /* setsid */ + case 66: + break; + /* setreuid */ + case 70: + switch (ndx) { + case 0: + p = "uid_t"; + break; + case 1: + p = "uid_t"; + break; + default: + break; + }; + break; + /* setregid */ + case 71: + switch (ndx) { + case 0: + p = "gid_t"; + break; + case 1: + p = "gid_t"; + break; + default: + break; + }; + break; + /* linux_sethostname */ + case 74: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_setrlimit */ + case 75: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland struct l_rlimit *"; + break; + default: + break; + }; + break; + /* linux_getrlimit */ + case 76: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland struct l_rlimit *"; + break; + default: + break; + }; + break; + /* getrusage */ + case 77: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland struct rusage *"; + break; + default: + break; + }; + break; + /* gettimeofday */ + case 78: + switch (ndx) { + case 0: + p = "userland struct l_timeval *"; + break; + case 1: + p = "userland struct timezone *"; + break; + default: + break; + }; + break; + /* settimeofday */ + case 79: + switch (ndx) { + case 0: + p = "userland struct l_timeval *"; + break; + case 1: + p = "userland struct timezone *"; + break; + default: + break; + }; + break; + /* linux_getgroups */ + case 80: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_gid_t *"; + break; + default: + break; + }; + break; + /* linux_setgroups */ + case 81: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_gid_t *"; + break; + default: + break; + }; + break; + /* linux_select */ + case 82: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_fd_set *"; + break; + case 2: + p = "userland l_fd_set *"; + break; + case 3: + p = "userland l_fd_set *"; + break; + case 4: + p = "userland struct l_timeval *"; + break; + default: + break; + }; + break; + /* linux_symlink */ + case 83: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_readlink */ + case 85: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* swapon */ + case 87: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_reboot */ + case 88: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_uint"; + break; + case 3: + p = "userland void *"; + break; + default: + break; + }; + break; + /* linux_mmap */ + case 90: + 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; + /* munmap */ + case 91: + switch (ndx) { + case 0: + p = "userland void *"; + break; + case 1: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_truncate */ + case 92: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_long"; + break; + default: + break; + }; + break; + /* linux_ftruncate */ + case 93: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* fchmod */ + case 94: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "int"; + break; + default: + break; + }; + break; + /* fchown */ + case 95: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "int"; + break; + case 2: + p = "int"; + break; + default: + break; + }; + break; + /* linux_getpriority */ + case 96: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* setpriority */ + case 97: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "int"; + break; + case 2: + p = "int"; + break; + default: + break; + }; + break; + /* linux_statfs */ + case 99: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland struct l_statfs_buf *"; + break; + default: + break; + }; + break; + /* linux_fstatfs */ + case 100: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland struct l_statfs_buf *"; + break; + default: + break; + }; + break; + /* linux_ioperm */ + case 101: + break; + /* linux_syslog */ + case 103: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_setitimer */ + case 104: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_itimerval *"; + break; + case 2: + p = "userland struct l_itimerval *"; + break; + default: + break; + }; + break; + /* linux_getitimer */ + case 105: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_itimerval *"; + break; + default: + break; + }; + break; + /* linux_newstat */ + case 106: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland struct l_newstat *"; + break; + default: + break; + }; + break; + /* linux_newlstat */ + case 107: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland struct l_newstat *"; + break; + default: + break; + }; + break; + /* linux_newfstat */ + case 108: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland struct l_newstat *"; + break; + default: + break; + }; + break; + /* linux_iopl */ + case 110: + switch (ndx) { + case 0: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_vhangup */ + case 111: + break; + /* linux_wait4 */ + case 114: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland l_int *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland struct rusage *"; + break; + default: + break; + }; + break; + /* linux_swapoff */ + case 115: + break; + /* linux_sysinfo */ + case 116: + switch (ndx) { + case 0: + p = "userland struct l_sysinfo *"; + break; + default: + break; + }; + break; + /* fsync */ + case 118: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* linux_clone */ + case 120: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_ulong"; + break; + case 2: + p = "userland l_int *"; + break; + case 3: + p = "userland l_int *"; + break; + case 4: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_setdomainname */ + case 121: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_newuname */ + case 122: + switch (ndx) { + case 0: + p = "userland struct l_new_utsname *"; + break; + default: + break; + }; + break; + /* linux_modify_ldt */ + case 123: + break; + /* linux_adjtimex */ + case 124: + break; + /* linux_mprotect */ + case 125: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_size_t"; + break; + case 2: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_init_module */ + case 128: + break; + /* linux_delete_module */ + case 129: + break; + /* linux_quotactl */ + case 131: + break; + /* getpgid */ + case 132: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* fchdir */ + case 133: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* linux_personality */ + case 136: + switch (ndx) { + case 0: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_setfsuid */ + case 138: + switch (ndx) { + case 0: + p = "l_uid_t"; + break; + default: + break; + }; + break; + /* linux_setfsgid */ + case 139: + switch (ndx) { + case 0: + p = "l_gid_t"; + break; + default: + break; + }; + break; + /* linux_llseek */ + case 140: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_ulong"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "userland l_loff_t *"; + break; + case 4: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_getdents */ + case 141: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland void *"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* flock */ + case 143: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "int"; + break; + default: + break; + }; + break; + /* linux_msync */ + case 144: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_size_t"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* readv */ + case 145: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland struct iovec *"; + break; + case 2: + p = "u_int"; + break; + default: + break; + }; + break; + /* linux_writev */ + case 146: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland struct iovec *"; + break; + case 2: + p = "u_int"; + break; + default: + break; + }; + break; + /* linux_getsid */ + case 147: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + default: + break; + }; + break; + /* linux_fdatasync */ + case 148: + switch (ndx) { + case 0: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_sysctl */ + case 149: + switch (ndx) { + case 0: + p = "userland struct l___sysctl_args *"; + break; + default: + break; + }; + break; + /* mlock */ + case 150: + switch (ndx) { + case 0: + p = "userland const void *"; + break; + case 1: + p = "size_t"; + break; + default: + break; + }; + break; + /* munlock */ + case 151: + switch (ndx) { + case 0: + p = "userland const void *"; + break; + case 1: + p = "size_t"; + break; + default: + break; + }; + break; + /* mlockall */ + case 152: + switch (ndx) { + case 0: + p = "int"; + break; + default: + break; + }; + break; + /* munlockall */ + case 153: + break; + /* linux_sched_setparam */ + case 154: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland struct sched_param *"; + break; + default: + break; + }; + break; + /* linux_sched_getparam */ + case 155: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland struct sched_param *"; + break; + default: + break; + }; + break; + /* linux_sched_setscheduler */ + case 156: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland struct sched_param *"; + break; + default: + break; + }; + break; + /* linux_sched_getscheduler */ + case 157: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + default: + break; + }; + break; + /* sched_yield */ + case 158: + break; + /* linux_sched_get_priority_max */ + case 159: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_sched_get_priority_min */ + case 160: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_sched_rr_get_interval */ + case 161: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_nanosleep */ + case 162: + switch (ndx) { + case 0: + p = "userland const struct l_timespec *"; + break; + case 1: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_mremap */ + case 163: + 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; + /* setresuid */ + case 164: + 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 165: + switch (ndx) { + case 0: + p = "userland uid_t *"; + break; + case 1: + p = "userland uid_t *"; + break; + case 2: + p = "userland uid_t *"; + break; + default: + break; + }; + break; + /* linux_poll */ + case 167: + switch (ndx) { + case 0: + p = "userland struct pollfd *"; + break; + case 1: + p = "u_int"; + break; + case 2: + p = "int"; + break; + default: + break; + }; + break; + /* setresgid */ + case 169: + 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 170: + switch (ndx) { + case 0: + p = "userland gid_t *"; + break; + case 1: + p = "userland gid_t *"; + break; + case 2: + p = "userland gid_t *"; + break; + default: + break; + }; + break; + /* linux_prctl */ + case 171: + 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_rt_sigreturn */ + case 172: + break; + /* linux_rt_sigaction */ + case 173: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_sigaction_t *"; + break; + case 2: + p = "userland l_sigaction_t *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_rt_sigprocmask */ + case 174: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_sigset_t *"; + break; + case 2: + p = "userland l_sigset_t *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_rt_sigpending */ + case 175: + switch (ndx) { + case 0: + p = "userland l_sigset_t *"; + break; + case 1: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_rt_sigtimedwait */ + case 176: + switch (ndx) { + case 0: + p = "userland l_sigset_t *"; + break; + case 1: + p = "userland l_siginfo_t *"; + break; + case 2: + p = "userland struct l_timespec *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_rt_sigqueueinfo */ + case 177: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland l_siginfo_t *"; + break; + default: + break; + }; + break; + /* linux_rt_sigsuspend */ + case 178: + switch (ndx) { + case 0: + p = "userland l_sigset_t *"; + break; + case 1: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_pread */ + case 179: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "l_loff_t"; + break; + default: + break; + }; + break; + /* linux_pwrite */ + case 180: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "l_loff_t"; + break; + default: + break; + }; + break; + /* linux_chown */ + case 181: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_uid_t"; + break; + case 2: + p = "l_gid_t"; + break; + default: + break; + }; + break; + /* linux_getcwd */ + case 182: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_capget */ + case 183: + switch (ndx) { + case 0: + p = "userland struct l_user_cap_header *"; + break; + case 1: + p = "userland struct l_user_cap_data *"; + break; + default: + break; + }; + break; + /* linux_capset */ + case 184: + switch (ndx) { + case 0: + p = "userland struct l_user_cap_header *"; + break; + case 1: + p = "userland struct l_user_cap_data *"; + break; + default: + break; + }; + break; + /* linux_sigaltstack */ + case 185: + switch (ndx) { + case 0: + p = "userland l_stack_t *"; + break; + case 1: + p = "userland l_stack_t *"; + break; + default: + break; + }; + break; + /* linux_sendfile */ + case 186: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland l_off_t *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_vfork */ + case 189: + break; + /* linux_mmap2 */ + case 192: + 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_getdents64 */ + case 202: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "userland void *"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_pivot_root */ + case 203: + break; + /* linux_madvise */ + case 205: + 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 206: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_size_t"; + break; + case 2: + p = "userland u_char *"; + break; + default: + break; + }; + break; + /* linux_gettid */ + case 207: + break; + /* linux_tkill */ + case 208: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_setxattr */ + case 209: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland void *"; + break; + case 3: + p = "l_size_t"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_lsetxattr */ + case 210: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland void *"; + break; + case 3: + p = "l_size_t"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_fsetxattr */ + case 211: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland void *"; + break; + case 3: + p = "l_size_t"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_getxattr */ + case 212: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland char *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_lgetxattr */ + case 213: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland char *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_fgetxattr */ + case 214: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland char *"; + break; + case 3: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_listxattr */ + case 215: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_llistxattr */ + case 216: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_flistxattr */ + case 217: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_removexattr */ + case 218: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_lremovexattr */ + case 219: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_fremovexattr */ + case 220: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_sys_futex */ + case 221: + switch (ndx) { + case 0: + p = "userland uint32_t *"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "uint32_t"; + break; + case 3: + p = "userland struct l_timespec *"; + break; + case 4: + p = "userland uint32_t *"; + break; + case 5: + p = "uint32_t"; + break; + default: + break; + }; + break; + /* linux_sched_setaffinity */ + case 222: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "userland l_ulong *"; + break; + default: + break; + }; + break; + /* linux_sched_getaffinity */ + case 223: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "userland l_ulong *"; + break; + default: + break; + }; + break; + /* linux_set_tid_address */ + case 232: + switch (ndx) { + case 0: + p = "userland l_int *"; + break; + default: + break; + }; + break; + /* linux_fadvise64 */ + case 233: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_loff_t"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_exit_group */ + case 234: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_lookup_dcookie */ + case 235: + break; + /* linux_epoll_create */ + case 236: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_epoll_ctl */ + case 237: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland struct epoll_event *"; + break; + default: + break; + }; + break; + /* linux_epoll_wait */ + case 238: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct epoll_event *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_remap_file_pages */ + case 239: + break; + /* linux_timer_create */ + case 240: + switch (ndx) { + case 0: + p = "clockid_t"; + break; + case 1: + p = "userland struct sigevent *"; + break; + case 2: + p = "userland l_timer_t *"; + break; + default: + break; + }; + break; + /* linux_timer_settime */ + case 241: + switch (ndx) { + case 0: + p = "l_timer_t"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland const struct itimerspec *"; + break; + case 3: + p = "userland struct itimerspec *"; + break; + default: + break; + }; + break; + /* linux_timer_gettime */ + case 242: + switch (ndx) { + case 0: + p = "l_timer_t"; + break; + case 1: + p = "userland struct itimerspec *"; + break; + default: + break; + }; + break; + /* linux_timer_getoverrun */ + case 243: + switch (ndx) { + case 0: + p = "l_timer_t"; + break; + default: + break; + }; + break; + /* linux_timer_delete */ + case 244: + switch (ndx) { + case 0: + p = "l_timer_t"; + break; + default: + break; + }; + break; + /* linux_clock_settime */ + case 245: + switch (ndx) { + case 0: + p = "clockid_t"; + break; + case 1: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_clock_gettime */ + case 246: + switch (ndx) { + case 0: + p = "clockid_t"; + break; + case 1: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_clock_getres */ + case 247: + switch (ndx) { + case 0: + p = "clockid_t"; + break; + case 1: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_clock_nanosleep */ + case 248: + switch (ndx) { + case 0: + p = "clockid_t"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland struct l_timespec *"; + break; + case 3: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_tgkill */ + case 250: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_pid_t"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_utimes */ + case 251: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "userland struct l_timeval *"; + break; + default: + break; + }; + break; + /* linux_statfs64 */ + case 252: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "size_t"; + break; + case 2: + p = "userland struct l_statfs64_buf *"; + break; + default: + break; + }; + break; + /* linux_fstatfs64 */ + case 253: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "size_t"; + break; + case 2: + p = "userland struct l_statfs64_buf *"; + break; + default: + break; + }; + break; + /* linux_migrate_pages */ + case 258: + break; + /* linux_mbind */ + case 259: + break; + /* linux_get_mempolicy */ + case 260: + break; + /* linux_set_mempolicy */ + case 261: + break; + /* linux_mq_open */ + case 262: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_mode_t"; + break; + case 3: + p = "userland struct mq_attr *"; + break; + default: + break; + }; + break; + /* linux_mq_unlink */ + case 263: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_mq_timedsend */ + case 264: + switch (ndx) { + case 0: + p = "l_mqd_t"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "l_uint"; + break; + case 4: + p = "userland const struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_mq_timedreceive */ + case 265: + switch (ndx) { + case 0: + p = "l_mqd_t"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "userland l_uint *"; + break; + case 4: + p = "userland const struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_mq_notify */ + case 266: + switch (ndx) { + case 0: + p = "l_mqd_t"; + break; + case 1: + p = "userland const struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_mq_getsetattr */ + case 267: + switch (ndx) { + case 0: + p = "l_mqd_t"; + break; + case 1: + p = "userland const struct mq_attr *"; + break; + case 2: + p = "userland struct mq_attr *"; + break; + default: + break; + }; + break; + /* linux_kexec_load */ + case 268: + break; + /* linux_add_key */ + case 269: + break; + /* linux_request_key */ + case 270: + break; + /* linux_keyctl */ + case 271: + break; + /* linux_waitid */ + case 272: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_pid_t"; + break; + case 2: + p = "userland l_siginfo_t *"; + break; + case 3: + p = "l_int"; + break; + case 4: + p = "userland struct rusage *"; + break; + default: + break; + }; + break; + /* linux_ioprio_set */ + case 273: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_ioprio_get */ + case 274: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_inotify_add_watch */ + case 276: + break; + /* linux_inotify_rm_watch */ + case 277: + break; + /* linux_pselect6 */ + case 280: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_fd_set *"; + break; + case 2: + p = "userland l_fd_set *"; + break; + case 3: + p = "userland l_fd_set *"; + break; + case 4: + p = "userland struct l_timespec *"; + break; + case 5: + p = "userland l_uintptr_t *"; + break; + default: + break; + }; + break; + /* linux_ppoll */ + case 281: + switch (ndx) { + case 0: + p = "userland struct pollfd *"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "userland struct l_timespec *"; + break; + case 3: + p = "userland l_sigset_t *"; + break; + case 4: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_unshare */ + case 282: + break; + /* linux_splice */ + case 283: + switch (ndx) { + case 0: + p = "int"; + break; + case 1: + p = "userland l_loff_t *"; + break; + case 2: + p = "int"; + break; + case 3: + p = "userland l_loff_t *"; + break; + case 4: + p = "l_size_t"; + break; + case 5: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_tee */ + case 284: + break; + /* linux_vmsplice */ + case 285: + break; + /* linux_openat */ + case 286: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_mkdirat */ + case 287: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_mknodat */ + case 288: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_mode_t"; + break; + case 3: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_fchownat */ + case 289: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland 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 290: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "userland struct l_timeval *"; + break; + default: + break; + }; + break; + /* linux_newfstatat */ + case 291: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "userland struct l_stat64 *"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_unlinkat */ + case 292: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_renameat */ + case 293: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_linkat */ + case 294: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland const char *"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_symlinkat */ + case 295: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_readlinkat */ + case 296: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland char *"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_fchmodat */ + case 297: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_mode_t"; + break; + default: + break; + }; + break; + /* linux_faccessat */ + case 298: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_get_robust_list */ + case 299: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct linux_robust_list_head **"; + break; + case 2: + p = "userland l_size_t *"; + break; + default: + break; + }; + break; + /* linux_set_robust_list */ + case 300: + switch (ndx) { + case 0: + p = "userland struct linux_robust_list_head *"; + break; + case 1: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_move_pages */ + case 301: + break; + /* linux_getcpu */ + case 302: + switch (ndx) { + case 0: + p = "userland l_uint *"; + break; + case 1: + p = "userland l_uint *"; + break; + case 2: + p = "userland void *"; + break; + default: + break; + }; + break; + /* linux_epoll_pwait */ + case 303: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct epoll_event *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "l_int"; + break; + case 4: + p = "userland l_sigset_t *"; + break; + case 5: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_utimensat */ + case 304: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland const struct l_timespec *"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_timerfd_create */ + case 306: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_eventfd */ + case 307: + switch (ndx) { + case 0: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_sync_file_range */ + case 308: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_loff_t"; + break; + case 2: + p = "l_loff_t"; + break; + case 3: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_fallocate */ + case 309: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_loff_t"; + break; + case 3: + p = "l_loff_t"; + break; + default: + break; + }; + break; + /* linux_timerfd_settime */ + case 311: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland const struct l_itimerspec *"; + break; + case 3: + p = "userland struct l_itimerspec *"; + break; + default: + break; + }; + break; + /* linux_timerfd_gettime */ + case 312: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_itimerspec *"; + break; + default: + break; + }; + break; + /* linux_signalfd4 */ + case 313: + break; + /* linux_eventfd2 */ + case 314: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_epoll_create1 */ + case 315: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_dup3 */ + case 316: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_pipe2 */ + case 317: + switch (ndx) { + case 0: + p = "userland l_int *"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_inotify_init1 */ + case 318: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_perf_event_open */ + case 319: + break; + /* linux_preadv */ + case 320: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "userland struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_pwritev */ + case 321: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "userland struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_rt_tgsigqueueinfo */ + case 322: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_pid_t"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland l_siginfo_t *"; + break; + default: + break; + }; + break; + /* linux_fanotify_init */ + case 323: + break; + /* linux_fanotify_mark */ + case 324: + break; + /* linux_prlimit64 */ + case 325: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "userland struct rlimit *"; + break; + case 3: + p = "userland struct rlimit *"; + break; + default: + break; + }; + break; + /* linux_socket */ + case 326: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_bind */ + case 327: + 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_connect */ + case 328: + 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 329: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_accept */ + case 330: + 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_getsockname */ + case 331: + 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 332: + 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 333: + 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_sendto */ + case 335: + 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_uint"; + break; + case 4: + p = "l_uintptr_t"; + break; + case 5: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_recvfrom */ + case 337: + 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_uint"; + break; + case 4: + p = "l_uintptr_t"; + break; + case 5: + p = "l_uintptr_t"; + break; + default: + break; + }; + break; + /* linux_shutdown */ + case 338: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_setsockopt */ + case 339: + 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 340: + 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_sendmsg */ + case 341: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_uintptr_t"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_recvmsg */ + case 342: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_uintptr_t"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_recvmmsg */ + case 343: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_mmsghdr *"; + break; + case 2: + p = "l_uint"; + break; + case 3: + p = "l_uint"; + break; + case 4: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_accept4 */ + case 344: + 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_int"; + break; + default: + break; + }; + break; + /* linux_name_to_handle_at */ + case 345: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland struct l_file_handle *"; + break; + case 3: + p = "userland l_int *"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_open_by_handle_at */ + case 346: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_file_handle *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_clock_adjtime */ + case 347: + break; + /* linux_syncfs */ + case 348: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_sendmmsg */ + case 349: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_mmsghdr *"; + break; + case 2: + p = "l_uint"; + break; + case 3: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_setns */ + case 350: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_process_vm_readv */ + case 351: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland const struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "userland const struct iovec *"; + break; + case 4: + p = "l_ulong"; + break; + case 5: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_process_vm_writev */ + case 352: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland const struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "userland const struct iovec *"; + break; + case 4: + p = "l_ulong"; + break; + case 5: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_finit_module */ + case 353: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_kcmp */ + case 354: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "l_pid_t"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_sched_setattr */ + case 355: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland void *"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_sched_getattr */ + case 356: + switch (ndx) { + case 0: + p = "l_pid_t"; + break; + case 1: + p = "userland void *"; + break; + case 2: + p = "l_uint"; + break; + case 3: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_renameat2 */ + case 357: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland const char *"; + break; + case 4: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_seccomp */ + case 358: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "userland const char *"; + break; + default: + break; + }; + break; + /* linux_getrandom */ + case 359: + switch (ndx) { + case 0: + p = "userland char *"; + break; + case 1: + p = "l_size_t"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_memfd_create */ + case 360: + switch (ndx) { + case 0: + p = "userland const char *"; + break; + case 1: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_bpf */ + case 361: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland void *"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_execveat */ + case 362: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "userland const char **"; + break; + case 3: + p = "userland const char **"; + break; + case 4: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_userfaultfd */ + case 364: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_membarrier */ + case 365: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_mlock2 */ + case 378: + 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_copy_file_range */ + case 379: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland l_loff_t *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland l_loff_t *"; + break; + case 4: + p = "l_size_t"; + break; + case 5: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_preadv2 */ + case 380: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "userland const struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "l_ulong"; + break; + case 5: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_pwritev2 */ + case 381: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "userland const struct iovec *"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_ulong"; + break; + case 4: + p = "l_ulong"; + break; + case 5: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_statx */ + case 383: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_uint"; + break; + case 3: + p = "l_uint"; + break; + case 4: + p = "userland void *"; + break; + default: + break; + }; + break; + /* linux_pkey_alloc */ + case 384: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_ulong"; + break; + default: + break; + }; + break; + /* linux_pkey_free */ + case 385: + switch (ndx) { + case 0: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_pkey_mprotect */ + case 386: + switch (ndx) { + case 0: + p = "l_ulong"; + break; + case 1: + p = "l_size_t"; + break; + case 2: + p = "l_ulong"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_rseq */ + case 387: + switch (ndx) { + case 0: + p = "userland struct linux_rseq *"; + break; + case 1: + p = "uint32_t"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "uint32_t"; + break; + default: + break; + }; + break; + /* linux_io_pgetevents */ + case 388: + break; + /* linux_semtimedop */ + case 392: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct sembuf *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "userland struct l_timespec *"; + break; + default: + break; + }; + break; + /* linux_semget */ + case 393: + 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_semctl */ + case 394: + 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_shmget */ + case 395: + 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_shmctl */ + case 396: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland struct l_shmid_ds *"; + break; + default: + break; + }; + break; + /* linux_shmat */ + case 397: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland char *"; + break; + case 2: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_shmdt */ + case 398: + switch (ndx) { + case 0: + p = "userland char *"; + break; + default: + break; + }; + break; + /* linux_msgget */ + case 399: + switch (ndx) { + case 0: + p = "l_key_t"; + break; + case 1: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_msgsnd */ + case 400: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct l_msgbuf *"; + break; + case 2: + p = "l_size_t"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_msgrcv */ + case 401: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland 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 402: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland struct l_msqid_ds *"; + break; + default: + break; + }; + break; + /* linux_pidfd_send_signal */ + case 424: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "l_int"; + break; + case 2: + p = "userland l_siginfo_t *"; + break; + case 3: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_io_uring_setup */ + case 425: + break; + /* linux_io_uring_enter */ + case 426: + break; + /* linux_io_uring_register */ + case 427: + break; + /* linux_open_tree */ + case 428: + break; + /* linux_move_mount */ + case 429: + break; + /* linux_fsopen */ + case 430: + break; + /* linux_fsconfig */ + case 431: + break; + /* linux_fsmount */ + case 432: + break; + /* linux_fspick */ + case 433: + break; + /* linux_pidfd_open */ + case 434: + break; + /* linux_clone3 */ + case 435: + switch (ndx) { + case 0: + p = "userland struct l_user_clone_args *"; + break; + case 1: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_close_range */ + case 436: + switch (ndx) { + case 0: + p = "l_uint"; + break; + case 1: + p = "l_uint"; + break; + case 2: + p = "l_uint"; + break; + default: + break; + }; + break; + /* linux_openat2 */ + case 437: + break; + /* linux_pidfd_getfd */ + case 438: + break; + /* linux_faccessat2 */ + case 439: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland const char *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "l_int"; + break; + default: + break; + }; + break; + /* linux_process_madvise */ + case 440: + break; + /* linux_epoll_pwait2 */ + case 441: + switch (ndx) { + case 0: + p = "l_int"; + break; + case 1: + p = "userland struct epoll_event *"; + break; + case 2: + p = "l_int"; + break; + case 3: + p = "userland struct l_timespec *"; + break; + case 4: + p = "userland l_sigset_t *"; + break; + case 5: + p = "l_size_t"; + break; + default: + break; + }; + break; + /* linux_mount_setattr */ + case 442: + break; + /* linux_quotactl_fd */ + case 443: + break; + /* linux_landlock_create_ruleset */ + case 444: + break; + /* linux_landlock_add_rule */ + case 445: + break; + /* linux_landlock_restrict_self */ + case 446: + break; + /* linux_memfd_secret */ + case 447: + break; + /* linux_process_mrelease */ + case 448: + break; + /* linux_futex_waitv */ + case 449: + break; + /* linux_set_mempolicy_home_node */ + case 450: + break; + /* linux_cachestat */ + case 451: + break; + /* linux_fchmodat2 */ + case 452: + break; + /* linux_map_shadow_stack */ + case 453: + 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) { + /* linux_exit */ + case 1: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fork */ + case 2: + /* read */ + case 3: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_write */ + case 4: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_open */ + case 5: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* close */ + case 6: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_creat */ + case 8: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_link */ + case 9: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_unlink */ + case 10: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_execve */ + case 11: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_chdir */ + case 12: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_time */ + case 13: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mknod */ + case 14: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_chmod */ + case 15: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lchown */ + case 16: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lseek */ + case 19: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getpid */ + case 20: + /* linux_mount */ + case 21: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_umount */ + case 22: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setuid */ + case 23: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getuid */ + case 24: + /* linux_ptrace */ + case 26: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_alarm */ + case 27: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pause */ + case 29: + /* linux_utime */ + case 30: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_access */ + case 33: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* sync */ + case 36: + /* linux_kill */ + case 37: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rename */ + case 38: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mkdir */ + case 39: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rmdir */ + case 40: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* dup */ + case 41: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pipe */ + case 42: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_times */ + case 43: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_brk */ + case 45: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setgid */ + case 46: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getgid */ + case 47: + /* geteuid */ + case 49: + /* getegid */ + case 50: + /* acct */ + case 51: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ioctl */ + case 54: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fcntl */ + case 55: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setpgid */ + case 57: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* umask */ + case 60: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* chroot */ + case 61: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ustat */ + case 62: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* dup2 */ + case 63: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getppid */ + case 64: + /* getpgrp */ + case 65: + /* setsid */ + case 66: + /* setreuid */ + case 70: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setregid */ + case 71: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sethostname */ + case 74: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setrlimit */ + case 75: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getrlimit */ + case 76: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* getrusage */ + case 77: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* gettimeofday */ + case 78: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* settimeofday */ + case 79: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getgroups */ + case 80: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setgroups */ + case 81: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_select */ + case 82: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_symlink */ + case 83: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_readlink */ + case 85: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* swapon */ + case 87: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_reboot */ + case 88: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mmap */ + case 90: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* munmap */ + case 91: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_truncate */ + case 92: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ftruncate */ + case 93: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* fchmod */ + case 94: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* fchown */ + case 95: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getpriority */ + case 96: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setpriority */ + case 97: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_statfs */ + case 99: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fstatfs */ + case 100: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ioperm */ + case 101: + /* linux_syslog */ + case 103: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setitimer */ + case 104: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getitimer */ + case 105: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_newstat */ + case 106: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_newlstat */ + case 107: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_newfstat */ + case 108: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_iopl */ + case 110: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_vhangup */ + case 111: + /* linux_wait4 */ + case 114: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_swapoff */ + case 115: + /* linux_sysinfo */ + case 116: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* fsync */ + case 118: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clone */ + case 120: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setdomainname */ + case 121: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_newuname */ + case 122: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_modify_ldt */ + case 123: + /* linux_adjtimex */ + case 124: + /* linux_mprotect */ + case 125: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_init_module */ + case 128: + /* linux_delete_module */ + case 129: + /* linux_quotactl */ + case 131: + /* getpgid */ + case 132: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* fchdir */ + case 133: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_personality */ + case 136: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setfsuid */ + case 138: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setfsgid */ + case 139: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_llseek */ + case 140: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getdents */ + case 141: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* flock */ + case 143: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_msync */ + case 144: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* readv */ + case 145: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_writev */ + case 146: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getsid */ + case 147: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fdatasync */ + case 148: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sysctl */ + case 149: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* mlock */ + case 150: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* munlock */ + case 151: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* mlockall */ + case 152: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* munlockall */ + case 153: + /* linux_sched_setparam */ + case 154: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_getparam */ + case 155: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_setscheduler */ + case 156: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_getscheduler */ + case 157: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* sched_yield */ + case 158: + /* linux_sched_get_priority_max */ + case 159: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_get_priority_min */ + case 160: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_rr_get_interval */ + case 161: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_nanosleep */ + case 162: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mremap */ + case 163: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setresuid */ + case 164: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* getresuid */ + case 165: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_poll */ + case 167: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* setresgid */ + case 169: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* getresgid */ + case 170: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_prctl */ + case 171: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigreturn */ + case 172: + /* linux_rt_sigaction */ + case 173: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigprocmask */ + case 174: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigpending */ + case 175: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigtimedwait */ + case 176: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigqueueinfo */ + case 177: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_sigsuspend */ + case 178: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pread */ + case 179: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pwrite */ + case 180: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_chown */ + case 181: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getcwd */ + case 182: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_capget */ + case 183: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_capset */ + case 184: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sigaltstack */ + case 185: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sendfile */ + case 186: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_vfork */ + case 189: + /* linux_mmap2 */ + case 192: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getdents64 */ + case 202: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pivot_root */ + case 203: + /* linux_madvise */ + case 205: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mincore */ + case 206: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_gettid */ + case 207: + /* linux_tkill */ + case 208: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setxattr */ + case 209: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lsetxattr */ + case 210: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fsetxattr */ + case 211: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getxattr */ + case 212: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lgetxattr */ + case 213: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fgetxattr */ + case 214: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_listxattr */ + case 215: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_llistxattr */ + case 216: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_flistxattr */ + case 217: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_removexattr */ + case 218: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lremovexattr */ + case 219: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fremovexattr */ + case 220: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sys_futex */ + case 221: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_setaffinity */ + case 222: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_getaffinity */ + case 223: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_set_tid_address */ + case 232: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fadvise64 */ + case 233: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_exit_group */ + case 234: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_lookup_dcookie */ + case 235: + /* linux_epoll_create */ + case 236: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_epoll_ctl */ + case 237: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_epoll_wait */ + case 238: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_remap_file_pages */ + case 239: + /* linux_timer_create */ + case 240: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timer_settime */ + case 241: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timer_gettime */ + case 242: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timer_getoverrun */ + case 243: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timer_delete */ + case 244: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clock_settime */ + case 245: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clock_gettime */ + case 246: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clock_getres */ + case 247: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clock_nanosleep */ + case 248: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_tgkill */ + case 250: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_utimes */ + case 251: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_statfs64 */ + case 252: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fstatfs64 */ + case 253: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_migrate_pages */ + case 258: + /* linux_mbind */ + case 259: + /* linux_get_mempolicy */ + case 260: + /* linux_set_mempolicy */ + case 261: + /* linux_mq_open */ + case 262: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mq_unlink */ + case 263: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mq_timedsend */ + case 264: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mq_timedreceive */ + case 265: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mq_notify */ + case 266: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mq_getsetattr */ + case 267: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_kexec_load */ + case 268: + /* linux_add_key */ + case 269: + /* linux_request_key */ + case 270: + /* linux_keyctl */ + case 271: + /* linux_waitid */ + case 272: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ioprio_set */ + case 273: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ioprio_get */ + case 274: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_inotify_add_watch */ + case 276: + /* linux_inotify_rm_watch */ + case 277: + /* linux_pselect6 */ + case 280: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_ppoll */ + case 281: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_unshare */ + case 282: + /* linux_splice */ + case 283: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_tee */ + case 284: + /* linux_vmsplice */ + case 285: + /* linux_openat */ + case 286: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mkdirat */ + case 287: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mknodat */ + case 288: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fchownat */ + case 289: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_futimesat */ + case 290: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_newfstatat */ + case 291: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_unlinkat */ + case 292: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_renameat */ + case 293: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_linkat */ + case 294: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_symlinkat */ + case 295: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_readlinkat */ + case 296: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fchmodat */ + case 297: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_faccessat */ + case 298: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_get_robust_list */ + case 299: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_set_robust_list */ + case 300: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_move_pages */ + case 301: + /* linux_getcpu */ + case 302: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_epoll_pwait */ + case 303: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_utimensat */ + case 304: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timerfd_create */ + case 306: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_eventfd */ + case 307: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sync_file_range */ + case 308: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fallocate */ + case 309: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timerfd_settime */ + case 311: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_timerfd_gettime */ + case 312: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_signalfd4 */ + case 313: + /* linux_eventfd2 */ + case 314: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_epoll_create1 */ + case 315: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_dup3 */ + case 316: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pipe2 */ + case 317: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_inotify_init1 */ + case 318: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_perf_event_open */ + case 319: + /* linux_preadv */ + case 320: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pwritev */ + case 321: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rt_tgsigqueueinfo */ + case 322: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_fanotify_init */ + case 323: + /* linux_fanotify_mark */ + case 324: + /* linux_prlimit64 */ + case 325: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_socket */ + case 326: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_bind */ + case 327: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_connect */ + case 328: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_listen */ + case 329: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_accept */ + case 330: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getsockname */ + case 331: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getpeername */ + case 332: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_socketpair */ + case 333: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sendto */ + case 335: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_recvfrom */ + case 337: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_shutdown */ + case 338: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setsockopt */ + case 339: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getsockopt */ + case 340: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sendmsg */ + case 341: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_recvmsg */ + case 342: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_recvmmsg */ + case 343: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_accept4 */ + case 344: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_name_to_handle_at */ + case 345: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_open_by_handle_at */ + case 346: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_clock_adjtime */ + case 347: + /* linux_syncfs */ + case 348: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sendmmsg */ + case 349: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_setns */ + case 350: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_process_vm_readv */ + case 351: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_process_vm_writev */ + case 352: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_finit_module */ + case 353: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_kcmp */ + case 354: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_setattr */ + case 355: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_sched_getattr */ + case 356: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_renameat2 */ + case 357: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_seccomp */ + case 358: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_getrandom */ + case 359: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_memfd_create */ + case 360: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_bpf */ + case 361: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_execveat */ + case 362: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_userfaultfd */ + case 364: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_membarrier */ + case 365: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mlock2 */ + case 378: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_copy_file_range */ + case 379: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_preadv2 */ + case 380: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pwritev2 */ + case 381: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_statx */ + case 383: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pkey_alloc */ + case 384: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pkey_free */ + case 385: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pkey_mprotect */ + case 386: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_rseq */ + case 387: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_io_pgetevents */ + case 388: + /* linux_semtimedop */ + case 392: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_semget */ + case 393: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_semctl */ + case 394: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_shmget */ + case 395: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_shmctl */ + case 396: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_shmat */ + case 397: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_shmdt */ + case 398: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_msgget */ + case 399: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_msgsnd */ + case 400: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_msgrcv */ + case 401: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_msgctl */ + case 402: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_pidfd_send_signal */ + case 424: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_io_uring_setup */ + case 425: + /* linux_io_uring_enter */ + case 426: + /* linux_io_uring_register */ + case 427: + /* linux_open_tree */ + case 428: + /* linux_move_mount */ + case 429: + /* linux_fsopen */ + case 430: + /* linux_fsconfig */ + case 431: + /* linux_fsmount */ + case 432: + /* linux_fspick */ + case 433: + /* linux_pidfd_open */ + case 434: + /* linux_clone3 */ + case 435: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_close_range */ + case 436: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_openat2 */ + case 437: + /* linux_pidfd_getfd */ + case 438: + /* linux_faccessat2 */ + case 439: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_process_madvise */ + case 440: + /* linux_epoll_pwait2 */ + case 441: + if (ndx == 0 || ndx == 1) + p = "int"; + break; + /* linux_mount_setattr */ + case 442: + /* linux_quotactl_fd */ + case 443: + /* linux_landlock_create_ruleset */ + case 444: + /* linux_landlock_add_rule */ + case 445: + /* linux_landlock_restrict_self */ + case 446: + /* linux_memfd_secret */ + case 447: + /* linux_process_mrelease */ + case 448: + /* linux_futex_waitv */ + case 449: + /* linux_set_mempolicy_home_node */ + case 450: + /* linux_cachestat */ + case 451: + /* linux_fchmodat2 */ + case 452: + /* linux_map_shadow_stack */ + case 453: + default: + break; + }; + if (p != NULL) + strlcpy(desc, p, descsz); +} diff --git a/sys/powerpc/linux/linux_sysvec.c b/sys/powerpc/linux/linux_sysvec.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_sysvec.c @@ -0,0 +1,808 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 1994-1996 Søren Schmidt + * Copyright (c) 2018 Turing Robotic Industries Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__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 + +#ifdef VFP +#include +#endif + +MODULE_VERSION(linux64elf, 1); + +#define LINUX_VDSOPAGE_SIZE PAGE_SIZE * 2 +#define LINUX_VDSOPAGE (VM_MAXUSER_ADDRESS - \ + LINUX_VDSOPAGE_SIZE) +#define LINUX_SHAREDPAGE (LINUX_VDSOPAGE - PAGE_SIZE) + /* + * PAGE_SIZE - the size + * of the native SHAREDPAGE + */ +#define LINUX_USRSTACK LINUX_SHAREDPAGE +#define LINUX_PS_STRINGS (LINUX_USRSTACK - \ + sizeof(struct ps_strings)) + +static int linux_szsigcode; +static vm_object_t linux_vdso_obj; +static char *linux_vdso_mapping; +extern char _binary_linux_vdso_so_o_start; +extern char _binary_linux_vdso_so_o_end; +extern char _binary_linux_locore_o_start; +extern char _binary_linux_locore_o_end; +static vm_offset_t linux_vdso_base; + +extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL]; +uintptr_t aux_vec; + +SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler); + +static int linux_copyout_strings(struct image_params *imgp, + uintptr_t *stack_base); +static void linux_set_syscall_retval(struct thread *td, int error); +static int linux_fetch_syscall_args(struct thread *td); +static void linux_exec_setregs(struct thread *td, struct image_params *imgp, + uintptr_t stack); +static void linux_exec_sysvec_init(void *param); +static int linux_on_exec_vmspace(struct proc *p, + struct image_params *imgp); +static void linux_exec_setregs_funcdesc(struct thread *td, struct image_params *imgp, + uintptr_t stack); +static void linux_vdso_install(const void *param); +static void linux_vdso_deinstall(const void *param); +static void linux_vdso_reloc(char *mapping, Elf_Addr offset); + +LINUX_VDSO_SYM_INTPTR(linux_vdso_sigcode); +LINUX_VDSO_SYM_INTPTR(linux_vdso_rt_sigcode); +LINUX_VDSO_SYM_INTPTR(kern_timekeep_base); + +static int +linux_fetch_syscall_args(struct thread *td) +{ + struct proc *p; + struct syscall_args *sa; + struct trapframe *frame; + //register_t *ap; + + p = td->td_proc; + frame = td->td_frame; + sa = &td->td_sa; + + sa->args[0] = frame->fixreg[LINUX_FIRSTARG]; + sa->args[1] = frame->fixreg[LINUX_FIRSTARG+1]; + sa->args[2] = frame->fixreg[LINUX_FIRSTARG+2]; + sa->args[3] = frame->fixreg[LINUX_FIRSTARG+3]; + sa->args[4] = frame->fixreg[LINUX_FIRSTARG+4]; + sa->args[5] = frame->fixreg[LINUX_FIRSTARG+5]; + + sa->code = frame->fixreg[0]; + sa->original_code = sa->code; + + // What to do with cr registers? + + if (sa->code >= p->p_sysent->sv_size) + sa->callp = &p->p_sysent->sv_table[0]; + else + sa->callp = &p->p_sysent->sv_table[sa->code]; + + td->td_retval[0] = 0; + td->td_retval[1] = frame->fixreg[LINUX_FIRSTARG+1]; + + return (0); +} + +static void +linux_set_syscall_retval(struct thread *td, int error) +{ + struct trapframe *tf; + + if (error == EJUSTRETURN) + return; + + tf = td->td_frame; + + if(error == 0){ + tf->fixreg[LINUX_FIRSTARG] = td->td_retval[0]; + tf->fixreg[LINUX_FIRSTARG + 1] = td->td_retval[1]; + }else if(error == ERESTART){ + ///* + //* Set user's pc back to redo the system call. + //*/ + tf->srr0 -= 4; + }else{ + tf->fixreg[FIRSTARG] = error; + tf->cr |= 0x10000000; /* Set summary overflow */ + } + + if (__predict_false(error != 0)) { + if (error != ERESTART && error != EJUSTRETURN) + td->td_frame->fixreg[FIRSTARG] = bsd_to_linux_errno(error); + } + +} + +void +linux64_arch_copyout_auxargs(struct image_params *imgp, Elf_Auxinfo **pos) +{ + // TODO + //AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR, linux_vdso_base); + //AUXARGS_ENTRY(pos, LINUX_AT_MINSIGSTKSZ, LINUX_MINSIGSTKSZ); + //AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, *imgp->sysent->sv_hwcap); + //AUXARGS_ENTRY(pos, LINUX_AT_HWCAP2, *imgp->sysent->sv_hwcap2); + // TODO + //AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(linux_platform)); +} + +/* + * 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. + * LINUXTODO: deduplicate against other linuxulator archs + */ +static int +linux_copyout_strings(struct image_params *imgp, uintptr_t *stack_base) +{ + char **vectp; + char *stringp; + uintptr_t destp, ustringp; + struct ps_strings *arginfo; + char canary[LINUX_AT_RANDOM_LEN]; + size_t execpath_len; + struct proc *p; + int argc, envc, error; + + p = imgp->proc; + arginfo = (struct ps_strings *)PROC_PS_STRINGS(p); + destp = (uintptr_t)arginfo; + + if (imgp->execpath != NULL && imgp->auxargs != NULL) { + execpath_len = strlen(imgp->execpath) + 1; + destp -= execpath_len; + destp = rounddown2(destp, sizeof(void *)); + imgp->execpathp = (void *)destp; + error = copyout(imgp->execpath, imgp->execpathp, execpath_len); + if (error != 0) + return (error); + } + + /* Prepare the canary for SSP. */ + arc4rand(canary, sizeof(canary), 0); + destp -= roundup(sizeof(canary), sizeof(void *)); + imgp->canary = (void *)destp; + error = copyout(canary, imgp->canary, sizeof(canary)); + if (error != 0) + return (error); + + /* Allocate room for the argument and environment strings. */ + destp -= ARG_MAX - imgp->args->stringspace; + destp = rounddown2(destp, sizeof(void *)); + ustringp = destp; + + if (imgp->auxargs) { + /* + * Allocate room on the stack for the ELF auxargs + * array. It has up to LINUX_AT_COUNT entries. + */ + destp -= LINUX_AT_COUNT * sizeof(Elf64_Auxinfo); + destp = rounddown2(destp, sizeof(void *)); + } + + vectp = (char **)destp; + + /* + * Allocate room for argc and the argv[] and env vectors including the + * terminating NULL pointers. + */ + vectp -= imgp->args->argc + 1 + imgp->args->envc + 1; + + /* NOT SURE WITH THIS + * Starting with 2.24, glibc depends on a 16-byte stack alignment. + * One "long argc" will be prepended later. + */ + vectp = (char **)((((uintptr_t)vectp + 8) & ~0xF) - 8); + + /* vectp also becomes our initial stack base. */ + *stack_base = (uintptr_t)vectp; + + stringp = imgp->args->begin_argv; + argc = imgp->args->argc; + envc = imgp->args->envc; + + /* Copy out strings - arguments and environment. */ + error = copyout(stringp, (void *)ustringp, + ARG_MAX - imgp->args->stringspace); + if (error != 0) + return (error); + + /* Fill in "ps_strings" struct for ps, w, etc. */ + if (suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp) != 0 || + suword(&arginfo->ps_nargvstr, argc) != 0) + return (EFAULT); + + /* Fill in argument portion of vector table. */ + for (; argc > 0; --argc) { + if (suword(vectp++, ustringp) != 0) + return (EFAULT); + while (*stringp++ != 0) + ustringp++; + ustringp++; + } + + /* A null vector table pointer separates the argp's from the envp's. */ + if (suword(vectp++, 0) != 0) + return (EFAULT); + + if (suword(&arginfo->ps_envstr, (long)(intptr_t)vectp) != 0 || + suword(&arginfo->ps_nenvstr, envc) != 0) + return (EFAULT); + + /* Fill in environment portion of vector table. */ + for (; envc > 0; --envc) { + if (suword(vectp++, ustringp) != 0) + return (EFAULT); + while (*stringp++ != 0) + ustringp++; + ustringp++; + } + + /* The end of the vector table is a null pointer. */ + if (suword(vectp, 0) != 0) + return (EFAULT); + + if (imgp->auxargs) { + vectp++; + aux_vec = (uintptr_t)vectp; + error = imgp->sysent->sv_copyout_auxargs(imgp, + (uintptr_t)vectp); + if (error != 0) + return (error); + } + + return (0); +} + +static void +cleanup_power_extras(struct thread *td) +{ + uint32_t pcb_flags; + + if (td != curthread) + return; + + pcb_flags = td->td_pcb->pcb_flags; + /* Clean up registers not managed by MSR. */ + if (pcb_flags & PCB_CFSCR) + mtspr(SPR_FSCR, 0); + if (pcb_flags & PCB_CDSCR) + mtspr(SPR_DSCRP, 0); + + /*if (pcb_flags & PCB_FPU) + cleanup_fpscr(); */ +} + + +static void +linux_exec_setregs_funcdesc(struct thread *td, struct image_params *imgp, + uintptr_t stack) +{ + struct trapframe *tf; + register_t entry_desc[3]; + + tf = trapframe(td); + linux_exec_setregs(td, imgp, stack); + + /* + * For 64-bit ELFv1, we need to disentangle the function + * descriptor + * + * 0. entry point + * 1. TOC value (r2) + * 2. Environment pointer (r11) + */ + + (void)copyin((void *)imgp->entry_addr, entry_desc, + sizeof(entry_desc)); + tf->srr0 = entry_desc[0] + imgp->reloc_base; + tf->fixreg[2] = entry_desc[1] + imgp->reloc_base; + tf->fixreg[11] = entry_desc[2] + imgp->reloc_base; +} + +/* + * Reset registers to default values on exec. + */ +static void +linux_exec_setregs(struct thread *td, struct image_params *imgp, + uintptr_t stack) +{ + struct trapframe *tf; + register_t argc; + + tf = trapframe(td); + bzero(tf, sizeof *tf); + tf->fixreg[1] = stack; + + /* + * Set up arguments for _start(): + * _start(argc, argv, envp, obj, cleanup, ps_strings); + * + * Notes: + * - obj and cleanup are the auxilliary and termination + * vectors. They are fixed up by ld.elf_so. + * - ps_strings is a NetBSD extention, and will be + * ignored by executables which are strictly + * compliant with the SVR4 ABI. + */ + + /* Collect argc from the user stack */ + argc = fuword((void *)stack); + + tf->fixreg[3] = argc; + tf->fixreg[4] = stack + sizeof(register_t); + tf->fixreg[5] = stack + (2 + argc)*sizeof(register_t); + tf->fixreg[6] = aux_vec; /* auxillary vector */ + tf->fixreg[7] = 0; /* termination vector */ + tf->fixreg[8] = (register_t)imgp->ps_strings; /* NetBSD extension */ + + tf->srr0 = imgp->entry_addr; + #ifdef __powerpc64__ + tf->fixreg[12] = imgp->entry_addr; + #endif + tf->srr1 = psl_userset | PSL_FE_DFLT; + cleanup_power_extras(td); + td->td_pcb->pcb_flags = 0; + + +} + +int +linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args) +{ + struct l_sigframe *frame; + ucontext_t uc; + struct trapframe *tf; + int error; + + tf = td->td_frame; + frame = (struct l_sigframe *)tf->fixreg[1]; + + if (copyin((void *)&frame->f_uc, &uc, sizeof(uc))) + return (EFAULT); + + error = set_mcontext(td, &uc.uc_mcontext); + if (error != 0) + return (error); + + /* Restore signal mask. */ + kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0); + + return (EJUSTRETURN); +} + +static void +linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) +{ + struct thread *td; + struct proc *p; + struct trapframe *tf; + struct l_sigframe *fp, *frame; + struct l_rt_sigframe *l_frame; + l_stack_t uc_stack; + ucontext_t f_uc; + struct sigacts *psp; + int onstack, sig, issiginfo; + unsigned long newsp; + + td = curthread; + p = td->td_proc; + PROC_LOCK_ASSERT(p, MA_OWNED); + + sig = ksi->ksi_signo; + psp = p->p_sigacts; + mtx_assert(&psp->ps_mtx, MA_OWNED); + + tf = td->td_frame; + onstack = sigonstack(tf->fixreg[1]); + issiginfo = SIGISMEMBER(psp->ps_siginfo, sig); + + + fp = (struct l_sigframe *)td->td_frame->fixreg[1]; + + /* Might need to keep the stack align */ + fp--; + + mtx_unlock(&psp->ps_mtx); + PROC_UNLOCK(td->td_proc); + get_mcontext(td, &f_uc.uc_mcontext, 0); + PROC_LOCK(p); + mtx_lock(&psp->ps_mtx); + + f_uc.uc_sigmask = *mask; + /* What about the other ucontext_t member variables? No need to initialize? */ + + uc_stack.ss_sp = PTROUT(td->td_sigstk.ss_sp); + uc_stack.ss_size = td->td_sigstk.ss_size; + uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) != 0 ? + (onstack ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE; + + mtx_unlock(&psp->ps_mtx); + PROC_UNLOCK(td->td_proc); + + /* Fill in the frame to copy out */ + frame = malloc(sizeof(*frame), M_LINUX, M_WAITOK | M_ZERO); + memcpy(&frame->f_uc, &f_uc, sizeof(f_uc)); + l_frame = (struct l_rt_sigframe*)frame; + + l_frame->pinfo = &l_frame->info; + l_frame->puc = &l_frame->uc; + + ///* Create the l_ucontext */ + l_frame->uc.uc_flags = 0; + memcpy(&l_frame->uc.uc_stack, &uc_stack, sizeof(uc_stack)); + l_frame->uc.uc_link = 0; + ///* __unsafe_setup_sigcontext() */ + unsigned long softe = 0x1; + l_frame->uc.uc_mcontext.v_regs = 0; + ///* if CONFIG_VSX or CONFIG_PPC_FPU_REGS is defined, unsafe_copy_fpr_to_usr() must be called */ + l_frame->uc.uc_mcontext.regs = (struct l_user_pt_regs*)&l_frame->uc.uc_mcontext.gp_regs; + memcpy(&l_frame->uc.uc_mcontext.gp_regs, &tf, GP_REGS_SIZE); + l_frame->uc.uc_mcontext.gp_regs[PT_SOFTE] = softe; + sig = bsd_to_linux_signal(sig); + l_frame->uc.uc_mcontext.signal = sig; + l_frame->uc.uc_mcontext.handler = (unsigned long)catcher; + + bsd_to_linux_sigset(mask, &l_frame->uc.uc_sigmask); + + siginfo_to_lsiginfo(&ksi->ksi_info, &l_frame->info, sig); + + /* Might need to make sure signal handler doesn't get spurious FP exceptions? */ + + /* Copy the sigframe out to the user's stack. */ + if (copyout(frame, fp, sizeof(*fp)) != 0) { + /* Process has trashed its stack. Kill it. */ + free(frame, M_LINUX); + CTR2(KTR_SIG, "sendsig: sigexit td=%p fp=%p", td, fp); + PROC_LOCK(p); + sigexit(td, SIGILL); + } + free(frame, M_LINUX); + + /* Set up to return from userspace. */ + tf->srr0 = (register_t)linux_vdso_sigcode; + + /* Allocate a dummy caller frame for the signal handler. */ + newsp = (unsigned long)fp - LINUX__SIGNAL_FRAMESIZE; + + /* For ELFv1 */ + /* Handler is *really* a pointer to the function descriptor for + * the signal routine. The first entry in the function + * descriptor is the entry address of signal and the second + * entry is the TOC value we need to use. + */ + struct l_func_desc *ptr = (struct l_func_desc*)catcher; + tf->ctr = (register_t)ptr->addr; + tf->fixreg[2] = (register_t)ptr->toc; + + tf->fixreg[1] = (register_t)newsp; + tf->fixreg[3] = (register_t)sig; + + if(issiginfo){ + tf->fixreg[4] = (register_t)&fp->sf.info; + tf->fixreg[5] = (register_t)&fp->sf.uc; + tf->fixreg[6] = (register_t)&fp->sf; + }else{ + tf->fixreg[4] = (register_t)&fp->sf.uc.uc_mcontext; + } + + PROC_LOCK(p); + mtx_lock(&psp->ps_mtx); +} + +struct sysentvec elf_linux_sysvec = { + .sv_size = LINUX_SYS_MAXSYSCALL, + .sv_table = linux_sysent, + .sv_fixup = __elfN(freebsd_fixup), + .sv_sendsig = linux_rt_sendsig, + .sv_sigcode = &_binary_linux_vdso_so_o_start, + .sv_szsigcode = &linux_szsigcode, + .sv_name = "Linux ELF64", + .sv_coredump = elf64_coredump, + .sv_elf_core_osabi = ELFOSABI_NONE, + .sv_elf_core_abi_vendor = LINUX_ABI_VENDOR, + .sv_elf_core_prepare_notes = linux64_prepare_notes, + .sv_minsigstksz = LINUX_MINSIGSTKSZ, + .sv_minuser = VM_MIN_ADDRESS, + .sv_maxuser = VM_MAXUSER_ADDRESS, + .sv_usrstack = LINUX_USRSTACK, + .sv_psstrings = LINUX_PS_STRINGS, + .sv_psstringssz = sizeof(struct ps_strings), + .sv_stackprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE, /* Enabling the execution of stack temporarily for signal trampoline. */ + .sv_copyout_auxargs = linux64_copyout_auxargs, + .sv_copyout_strings = linux_copyout_strings, + //.sv_setregs = linux_exec_setregs, + .sv_setregs = linux_exec_setregs_funcdesc, + .sv_fixlimit = NULL, + .sv_maxssiz = NULL, + .sv_flags = SV_ABI_LINUX | SV_LP64 | SV_SHP | SV_SIG_DISCIGN | + SV_SIG_WAITNDQ, + .sv_set_syscall_retval = linux_set_syscall_retval, + .sv_fetch_syscall_args = linux_fetch_syscall_args, + .sv_syscallnames = NULL, + .sv_shared_page_base = LINUX_SHAREDPAGE, + .sv_shared_page_len = PAGE_SIZE, + .sv_schedtail = linux_schedtail, + .sv_thread_detach = linux_thread_detach, + .sv_trap = NULL, + .sv_hwcap = NULL, + .sv_hwcap2 = NULL, + .sv_onexec = linux_on_exec_vmspace, + .sv_onexit = linux_on_exit, + .sv_ontdexit = linux_thread_dtor, + .sv_setid_allowed = &linux_setid_allowed_query, +}; + +static int +linux_on_exec_vmspace(struct proc *p, struct image_params *imgp) +{ + int error; + + error = linux_map_vdso(p, linux_vdso_obj, linux_vdso_base, + LINUX_VDSOPAGE_SIZE, imgp); + if (error == 0) + linux_on_exec(p, imgp); + return (0); +} + +#ifdef notyet +/* + * linux_vdso_install() and linux_exec_sysvec_init() must be called + * after exec_sysvec_init() which is SI_SUB_EXEC (SI_ORDER_ANY). + */ +static void +linux_exec_sysvec_init(void *param) +{ + l_uintptr_t *ktimekeep_base; + struct sysentvec *sv; + ptrdiff_t tkoff; + + sv = param; + /* Fill timekeep_base */ + exec_sysvec_init(sv); + + tkoff = kern_timekeep_base - linux_vdso_base; + ktimekeep_base = (l_uintptr_t *)(linux_vdso_mapping + tkoff); + *ktimekeep_base = sv->sv_shared_page_base + sv->sv_timekeep_offset; +} +SYSINIT(elf_linux_exec_sysvec_init, SI_SUB_EXEC + 1, SI_ORDER_ANY, + linux_exec_sysvec_init, &elf_linux_sysvec); +#endif + +static void +linux_vdso_install(const void *param) +{ + char *vdso_start = &_binary_linux_vdso_so_o_start; + char *vdso_end = &_binary_linux_vdso_so_o_end; + + linux_szsigcode = vdso_end - vdso_start; + MPASS(linux_szsigcode <= LINUX_VDSOPAGE_SIZE); + + linux_vdso_base = LINUX_VDSOPAGE; + + __elfN(linux_vdso_fixup)(vdso_start, linux_vdso_base); + + linux_vdso_obj = __elfN(linux_shared_page_init) + (&linux_vdso_mapping, LINUX_VDSOPAGE_SIZE); + bcopy(vdso_start, linux_vdso_mapping, linux_szsigcode); + + linux_vdso_reloc(linux_vdso_mapping, linux_vdso_base); +} +SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC + 1, SI_ORDER_FIRST, + linux_vdso_install, NULL); + +static void +linux_vdso_deinstall(const void *param) +{ + + __elfN(linux_shared_page_fini)(linux_vdso_obj, + linux_vdso_mapping, LINUX_VDSOPAGE_SIZE); +} +SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST, + linux_vdso_deinstall, NULL); + +static void +linux_vdso_reloc(char *mapping, Elf_Addr offset) +{ + Elf_Size rtype, symidx; + const Elf_Rela *rela; + const Elf_Shdr *shdr; + const Elf_Ehdr *ehdr; + Elf_Addr *where; + Elf_Addr addr, addend; + int i, relacnt; + + MPASS(offset != 0); + + relacnt = 0; + ehdr = (const Elf_Ehdr *)mapping; + shdr = (const Elf_Shdr *)(mapping + ehdr->e_shoff); + for (i = 0; i < ehdr->e_shnum; i++) + { + switch (shdr[i].sh_type) { + case SHT_REL: + printf("Linux Powerpc64 vDSO: unexpected Rel section\n"); + break; + case SHT_RELA: + rela = (const Elf_Rela *)(mapping + shdr[i].sh_offset); + relacnt = shdr[i].sh_size / sizeof(*rela); + } + } + + for (i = 0; i < relacnt; i++, rela++) { + where = (Elf_Addr *)(mapping + rela->r_offset); + addend = rela->r_addend; + rtype = ELF_R_TYPE(rela->r_info); + symidx = ELF_R_SYM(rela->r_info); + + switch (rtype) { + case R_PPC_NONE: /* none */ + break; + + case R_PPC_RELATIVE: /* B + A */ + addr = (Elf_Addr)(mapping + addend); + if (*where != addr) + *where = addr; + break; + default: + printf("Linux Powerpc64 vDSO: unexpected relocation type %ld, " + "symbol index %ld\n", rtype, symidx); + } + } +} + +static Elf_Brandnote linux64_brandnote = { + .hdr.n_namesz = sizeof(GNU_ABI_VENDOR), + .hdr.n_descsz = 16, + .hdr.n_type = 1, + .vendor = GNU_ABI_VENDOR, + .flags = BN_TRANSLATE_OSREL, + .trans_osrel = linux_trans_osrel +}; + +static Elf64_Brandinfo linux_glibc2brand = { + .brand = ELFOSABI_LINUX, + .machine = EM_PPC64, + .compat_3_brand = "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 +}; + +Elf64_Brandinfo *linux_brandlist[] = { + &linux_glibc2brand, + NULL +}; + +static int +linux64_elf_modevent(module_t mod, int type, void *data) +{ + Elf64_Brandinfo **brandinfo; + struct linux_ioctl_handler**lihp; + int error; + + 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); + stclohz = (stathz ? stathz : hz); + if (bootverbose) + printf("Linux powerpc64 ELF exec handler installed\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); + if (bootverbose) + printf("Linux powerpc64 ELF exec handler removed\n"); + } else + printf("Could not deinstall Linux powerpc64 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); +FEATURE(linux64, "Powerpc64 Linux 64bit support"); diff --git a/sys/powerpc/linux/linux_vdso.lds.s b/sys/powerpc/linux/linux_vdso.lds.s new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_vdso.lds.s @@ -0,0 +1,106 @@ +/* + * Linker script for 64-bit vDSO. + * Copied from Linux kernel arch/powerpc/kernel/vdso/vdso64.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 + + . = ALIGN(0x100); + .text : { + *(.text .stub .text.* ) + *(.sfpr .glink) + } :text =0x90909090 + PROVIDE(__etext = .); + PROVIDE(_etext = .); + PROVIDE(etext = .); + + /* + * Other stuff is appended to the text segment: + */ + .rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) } + .rodata1 : { *(.rodata1) } + + .dynamic : { *(.dynamic) } :text :dynamic + + /*.eh_frame_hdr : { *(.eh_frame_hdr) } :text :eh_frame_hdr + .eh_frame : { KEEP (*(.eh_frame)) } :text + .gcc_except_table : { *(.gcc_except_table) }*/ + .rela.dyn ALIGN(8) : { *(.rela.dyn) } + + .got ALIGN(8) : { *(.got .toc) } + + _end = .; + PROVIDE(end = .); + + /* STABS_DEBUG + DWARF_DEBUG + ELF_DETAILS */ + + /DISCARD/ : { + *(.note.GNU-stack) + *(.branch_lt) + *(.data .data.* .gnu.linkonce.d.* .sdata*) + *(.bss .sbss .dynbss .dynsbss) + *(.opd) + } +} + +/* + * Very old versions of ld do not recognize this name token; use the constant. + */ +/*#define PT_GNU_EH_FRAME 0x6474e550*/ + +/* + * We must supply the ELF program headers explicitly to get just one + * PT_LOAD segment, and set the flags explicitly to make segments read-only. + */ +PHDRS +{ + text PT_LOAD FILEHDR PHDRS FLAGS(5); /* 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;*/ +} + +/* + * This controls what symbols we export from the DSO. + */ +VERSION +{ + /* LINUX_2.6.15 { + global: + __kernel_get_syscall_map; + __kernel_gettimeofday; + __kernel_clock_gettime; + __kernel_clock_getres; + __kernel_get_tbfreq; + __kernel_sync_dicache; + __kernel_sigtramp_rt64; + __kernel_getcpu; + __kernel_time; + + local: *; + }; */ + + LINUX_0.0 { + global: + linux_platform; + kern_timekeep_base; + linux_vdso_sigcode; + local: *; + }; +} diff --git a/sys/powerpc/linux/linux_vdso_gtod.c b/sys/powerpc/linux/linux_vdso_gtod.c new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/linux_vdso_gtod.c @@ -0,0 +1,92 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2012 Konstantin Belousov + * Copyright (c) 2021 Dmitry Chagin + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#define _KERNEL +#include +#undef _KERNEL +#include + +#include +#include + +#include +#include +#include +#include + +/* The kernel fixup this at vDSO install */ +uintptr_t *kern_timekeep_base = NULL; +uint32_t kern_tsc_selector = 0; + +static int +__vdso_clock_gettime_fallback(clockid_t clock_id, struct l_timespec *lts) +{ + return (0); +} + +static int +__vdso_gettimeofday_fallback(l_timeval *ltv, struct timezone *ltz) +{ + return (0); +} + +static int +__vdso_clock_getres_fallback(clockid_t clock_id, struct l_timespec *lts) +{ + return (0); +} + +/* + * copied from lib/libc/powerpc64/sys/__vdso_gettc.c + */ + +int +__vdso_gettc(const struct vdso_timehands *th, u_int *tc) +{ + u_quad_t tb; + + if (__predict_false(th->th_algo != VDSO_TH_ALGO_PPC_TB)) + return (ENOSYS); + + __asm __volatile ("mftb %0" : "=r"(tb)); + *tc = tb; + return (0); +} + + +#include diff --git a/sys/powerpc/linux/syscalls.conf b/sys/powerpc/linux/syscalls.conf new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/syscalls.conf @@ -0,0 +1,12 @@ +# $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" +#compat_set="" diff --git a/sys/powerpc/linux/syscalls.master b/sys/powerpc/linux/syscalls.master new file mode 100644 --- /dev/null +++ b/sys/powerpc/linux/syscalls.master @@ -0,0 +1,2203 @@ + $FreeBSD$ + +; Linux ABI system call generic name/number map, based on Linux file +; include/uapi/asm-generic/unistd.h + +#include +#include +#include +#include +#include + +; Isn't pretty, but there seems to be no other way to trap nosys +; #define nosys linux_nosys + +0 AUE_NULL UNIMPL restart_syscall +1 AUE_EXIT STD { + int linux_exit( + u_int rval + ); + } +2 AUE_FORK STD { + int linux_fork(void); + } + +3 AUE_NULL NOPROTO { + int read( + int fd, + char *buf, + l_size_t nbyte + ); + } +4 AUE_NULL STD { + int linux_write( + int fd, + char *buf, + l_size_t nbyte + ); + } +5 AUE_OPEN_RWTC STD { + int linux_open( + char *path, + l_int flags, + l_mode_t mode + ); + } +6 AUE_CLOSE NOPROTO { + int close( + int fd + ); + } +7 AUE_NULL UNIMPL linux_waitpid +8 AUE_CREAT STD { + int linux_creat( + char *path, + l_mode_t mode + ); + } +9 AUE_LINK STD { + int linux_link( + char *path, + char *to + ); + } +10 AUE_UNLINK STD { + int linux_unlink( + char *path + ); + } +11 AUE_EXECVE STD { + int linux_execve( + char *path, + l_uintptr_t *argp, + l_uintptr_t *envp + ); + } +12 AUE_CHDIR STD { + int linux_chdir( + char *path + ); + } +13 AUE_NULL STD { + int linux_time( + l_time_t *tm + ); + } +14 AUE_MKNOD STD { + int linux_mknod( + char *path, + l_mode_t mode, + l_uint dev + ); + } +15 AUE_CHMOD STD { + int linux_chmod( + char *path, + l_mode_t mode + ); + } +16 AUE_LCHOWN STD { + int linux_lchown( + char *path, + l_uid_t uid, + l_gid_t gid + ); + } +17 AUE_NULL UNIMPL linux_break +18 AUE_NULL UNIMPL linux_oldstat +19 AUE_LSEEK STD { + int linux_lseek( + l_uint fdes, + l_off_t off, + l_int whence + ); + } +20 AUE_GETPID STD { + int linux_getpid(void); + } +21 AUE_MOUNT STD { + int linux_mount( + char *specialfile, + char *dir, + char *filesystemtype, + l_ulong rwflag, + void *data + ); + } +22 AUE_UMOUNT STD { + int linux_umount( + char *path, + l_int flags + ); + } +23 AUE_SETUID NOPROTO { + int setuid( + uid_t uid + ); + } +24 AUE_GETUID STD { + int linux_getuid(void); + } +25 AUE_NULL UNIMPL linux_stime +26 AUE_PTRACE STD { + int linux_ptrace( + l_long req, + l_long pid, + l_ulong addr, + l_ulong data + ); + } +27 AUE_NULL STD { + int linux_alarm( + l_uint secs + ); + } +28 AUE_NULL UNIMPL linux_oldfstat +29 AUE_NULL STD { + int linux_pause(void); + } +30 AUE_UTIME STD { + int linux_utime( + char *fname, + struct l_utimbuf *times + ); + } +31 AUE_NULL UNIMPL linux_stty +32 AUE_NULL UNIMPL linux_gtty +33 AUE_ACCESS STD { + int linux_access( + char *path, + l_int amode + ); + } +34 AUE_NULL UNIMPL linux_nice +35 AUE_NULL UNIMPL linux_ftime +36 AUE_SYNC NOPROTO { + int sync(void); + } +37 AUE_KILL STD { + int linux_kill( + l_pid_t pid, + l_int signum + ); + } +38 AUE_RENAME STD { + int linux_rename( + char *from, + char *to + ); + } +39 AUE_MKDIR STD { + int linux_mkdir( + char *path, + l_mode_t mode + ); + } +40 AUE_RMDIR STD { + int linux_rmdir( + char *path + ); + } +41 AUE_DUP NOPROTO { + int dup( + u_int fd + ); + } +42 AUE_PIPE STD { + int linux_pipe( + l_int *pipefds + ); + } +43 AUE_NULL STD { + int linux_times( + struct l_times_argv *buf + ); + } +44 AUE_NULL UNIMPL linux_prof +45 AUE_NULL STD { + int linux_brk( + l_ulong dsend + ); + } +46 AUE_SETGID NOPROTO { + int setgid( + gid_t gid + ); + } +47 AUE_GETGID STD { + int linux_getgid(void); + } +48 AUE_NULL UNIMPL linux_signal +49 AUE_GETEUID NOPROTO { + int geteuid(void); + } +50 AUE_GETEGID NOPROTO { + int getegid(void); + } +51 AUE_ACCT NOPROTO { + int acct( + char *path + ); + } +52 AUE_NULL UNIMPL linux_umount2 +53 AUE_NULL UNIMPL linux_lock +54 AUE_IOCTL STD { + int linux_ioctl( + l_uint fd, + l_uint cmd, + l_ulong arg + ); + } +55 AUE_FCNTL STD { + int linux_fcntl( + l_uint fd, + l_uint cmd, + l_ulong arg + ); + } +56 AUE_NULL UNIMPL linux_mpx +57 AUE_SETPGRP NOPROTO { + int setpgid( + int pid, + int pgid + ); + } +58 AUE_NULL UNIMPL linux_ulimit +59 AUE_NULL UNIMPL linux_olduname +60 AUE_UMASK NOPROTO { + int umask( + int newmask + ); + } +61 AUE_CHROOT NOPROTO { + int chroot( + char *path + ); + } +62 AUE_NULL STD { + int linux_ustat( + l_uint dev, + struct l_ustat *ubuf + ); + } +63 AUE_DUP2 NOPROTO { + int dup2( + u_int from, + u_int to + ); + } +64 AUE_GETPPID STD { + int linux_getppid(void); + } +65 AUE_GETPGRP NOPROTO { + int getpgrp(void); + } +66 AUE_SETSID NOPROTO { + int setsid(void); + } +67 AUE_NULL UNIMPL linux_sigaction +68 AUE_NULL UNIMPL linux_sgetmask +69 AUE_NULL UNIMPL linux_ssetmask +70 AUE_SETREUID NOPROTO { + int setreuid( + uid_t ruid, + uid_t euid + ); + } +71 AUE_SETREGID NOPROTO { + int setregid( + gid_t rgid, + gid_t egid + ); + } +72 AUE_NULL UNIMPL linux_sigsuspend +73 AUE_NULL UNIMPL linux_sigpending +74 AUE_SYSCTL STD { + int linux_sethostname( + char *hostname, + l_int len + ); + } +75 AUE_SETRLIMIT STD { + int linux_setrlimit( + l_uint resource, + struct l_rlimit *rlim + ); + } +76 AUE_GETRLIMIT STD { + int linux_getrlimit( + l_uint resource, + struct l_rlimit *rlim + ); + } +77 AUE_GETRUSAGE NOPROTO { + int getrusage( + int who, + struct rusage *rusage + ); + } +78 AUE_NULL NOPROTO { + int gettimeofday( + struct l_timeval *tp, + struct timezone *tzp + ); + } +79 AUE_SETTIMEOFDAY NOPROTO { + int settimeofday( + struct l_timeval *tv, + struct timezone *tzp + ); + } +80 AUE_GETGROUPS STD { + int linux_getgroups( + l_int gidsetsize, + l_gid_t *grouplist + ); + } +81 AUE_SETGROUPS STD { + int linux_setgroups( + l_int gidsetsize, + l_gid_t *grouplist + ); + } +82 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 + ); + } +83 AUE_SYMLINK STD { + int linux_symlink( + char *path, + char *to + ); + } +84 AUE_NULL UNIMPL linux_oldlstat +85 AUE_READLINK STD { + int linux_readlink( + char *name, + char *buf, + l_int count + ); + } +86 AUE_NULL UNIMPL linux_uselib +87 AUE_SWAPON NOPROTO { + int swapon( + char *name + ); + } +88 AUE_REBOOT STD { + int linux_reboot( + l_int magic1, + l_int magic2, + l_uint cmd, + void *arg + ); + } +89 AUE_NULL UNIMPL linux_readdir +90 AUE_MMAP STD { + int linux_mmap( + l_ulong addr, + l_ulong len, + l_ulong prot, + l_ulong flags, + l_ulong fd, + l_ulong pgoff + ); + } +91 AUE_MUNMAP NOPROTO { + int munmap( + void *addr, + l_size_t len + ); + } +92 AUE_TRUNCATE STD { + int linux_truncate( + char *path, + l_long length + ); + } +93 AUE_FTRUNCATE STD { + int linux_ftruncate( + l_int fd, + l_ulong length + ); + } +94 AUE_FCHMOD NOPROTO { + int fchmod( + int fd, + int mode + ); + } +95 AUE_FCHOWN NOPROTO { + int fchown( + int fd, + int uid, + int gid + ); + } +96 AUE_GETPRIORITY STD { + int linux_getpriority( + l_int which, + l_int who + ); + } +97 AUE_SETPRIORITY NOPROTO { + int setpriority( + int which, + int who, + int prio + ); + } +98 AUE_NULL UNIMPL linux_profil +99 AUE_STATFS STD { + int linux_statfs( + char *path, + struct l_statfs_buf *buf + ); + } +100 AUE_FSTATFS STD { + int linux_fstatfs( + l_uint fd, + struct l_statfs_buf *buf + ); + } +101 AUE_NULL STD { + int linux_ioperm(void); + } +102 AUE_NULL UNIMPL linux_socketcall +103 AUE_NULL STD { + int linux_syslog( + l_int type, + char *buf, + l_int len + ); + } +104 AUE_SETITIMER STD { + int linux_setitimer( + l_int which, + struct l_itimerval *itv, + struct l_itimerval *oitv + ); + } +105 AUE_GETITIMER STD { + int linux_getitimer( + l_int which, + struct l_itimerval *itv + ); + } +106 AUE_STAT STD { + int linux_newstat( + char *path, + struct l_newstat *buf + ); + } +107 AUE_LSTAT STD { + int linux_newlstat( + char *path, + struct l_newstat *buf + ); + } +108 AUE_FSTAT STD { + int linux_newfstat( + l_uint fd, + struct l_newstat *buf + ); + } +109 AUE_NULL UNIMPL linux_olduname +110 AUE_NULL STD { + int linux_iopl( + l_uint level + ); + } +111 AUE_NULL STD { + int linux_vhangup(void); + } +112 AUE_NULL UNIMPL linux_idle +113 AUE_NULL UNIMPL linux_vm86 +114 AUE_WAIT4 STD { + int linux_wait4( + l_pid_t pid, + l_int *status, + l_int options, + struct rusage *rusage + ); + } +115 AUE_SWAPOFF STD { + int linux_swapoff(void); + } +116 AUE_NULL STD { + int linux_sysinfo( + struct l_sysinfo *info + ); + } +117 AUE_NULL UNIMPL linux_ipc +118 AUE_FSYNC NOPROTO { + int fsync( + int fd + ); + } +119 AUE_NULL UNIMPL linux_sigreturn +120 AUE_RFORK STD { + int linux_clone( + l_ulong flags, + l_ulong stack, + l_int *parent_tidptr, + l_int *child_tidptr, + l_ulong tls + ); + } +121 AUE_SYSCTL STD { + int linux_setdomainname( + char *name, + l_int len + ); + } +122 AUE_NULL STD { + int linux_newuname( + struct l_new_utsname *buf + ); + } +123 AUE_NULL STD { + int linux_modify_ldt(void); + } +124 AUE_ADJTIME STD { + int linux_adjtimex(void); + } +125 AUE_MPROTECT STD { + int linux_mprotect( + l_ulong addr, + l_size_t len, + l_ulong prot + ); + } +126 AUE_NULL UNIMPL linux_sigprocmask +127 AUE_NULL UNIMPL linux_create_module +128 AUE_NULL STD { + int linux_init_module(void); + } +129 AUE_NULL STD { + int linux_delete_module(void); + } +130 AUE_NULL UNIMPL linux_get_kernel_syms +131 AUE_QUOTACTL STD { + int linux_quotactl(void); + } +132 AUE_GETPGID NOPROTO { + int getpgid( + int pid + ); + } +133 AUE_FCHDIR NOPROTO { + int fchdir( + int fd + ); + } +134 AUE_NULL UNIMPL linux_bdflush +135 AUE_NULL UNIMPL linux_sysfs +136 AUE_PERSONALITY STD { + int linux_personality( + l_uint per + ); + } +137 AUE_NULL UNIMPL linux_afs_syscall +138 AUE_SETFSUID STD { + int linux_setfsuid( + l_uid_t uid + ); + } +139 AUE_SETFSGID STD { + int linux_setfsgid( + l_gid_t gid + ); + } +140 AUE_LSEEK STD { + int linux_llseek( + l_int fd, + l_ulong ohigh, + l_ulong olow, + l_loff_t *res, + l_uint whence + ); + } +141 AUE_GETDIRENTRIES STD { + int linux_getdents( + l_uint fd, + void *dent, + l_uint count + ); + } +142 AUE_NULL UNIMPL linux__newselect +143 AUE_FLOCK NOPROTO { + int flock( + int fd, + int how + ); + } +144 AUE_MSYNC STD { + int linux_msync( + l_ulong addr, + l_size_t len, + l_int fl + ); + } +145 AUE_READV NOPROTO { + int readv( + int fd, + struct iovec *iovp, + u_int iovcnt + ); + } +146 AUE_WRITEV STD { + int linux_writev( + int fd, + struct iovec *iovp, + u_int iovcnt + ); + } +147 AUE_GETSID STD { + int linux_getsid( + l_pid_t pid + ); + } +148 AUE_NULL STD { + int linux_fdatasync( + l_uint fd + ); + } +149 AUE_SYSCTL STD { + int linux_sysctl( + struct l___sysctl_args *args + ); + } +150 AUE_MLOCK NOPROTO { + int mlock( + const void *addr, + size_t len + ); + } +151 AUE_MUNLOCK NOPROTO { + int munlock( + const void *addr, + size_t len + ); + } +152 AUE_MLOCKALL NOPROTO { + int mlockall( + int how + ); + } +153 AUE_MUNLOCKALL NOPROTO { + int munlockall(void); + } +154 AUE_SCHED_SETPARAM STD { + int linux_sched_setparam( + l_pid_t pid, + struct sched_param *param + ); + } +155 AUE_SCHED_GETPARAM STD { + int linux_sched_getparam( + l_pid_t pid, + struct sched_param *param + ); + } +156 AUE_SCHED_SETSCHEDULER STD { + int linux_sched_setscheduler( + l_pid_t pid, + l_int policy, + struct sched_param *param + ); + } +157 AUE_SCHED_GETSCHEDULER STD { + int linux_sched_getscheduler( + l_pid_t pid + ); + } +158 AUE_NULL NOPROTO { + int sched_yield(void); + } +159 AUE_SCHED_GET_PRIORITY_MAX STD { + int linux_sched_get_priority_max( + l_int policy + ); + } +160 AUE_SCHED_GET_PRIORITY_MIN STD { + int linux_sched_get_priority_min( + l_int policy + ); + } +161 AUE_SCHED_RR_GET_INTERVAL STD { + int linux_sched_rr_get_interval( + l_pid_t pid, + struct l_timespec *interval + ); + } +162 AUE_NULL STD { + int linux_nanosleep( + const struct l_timespec *rqtp, + struct l_timespec *rmtp + ); + } +163 AUE_NULL STD { + int linux_mremap( + l_ulong addr, + l_ulong old_len, + l_ulong new_len, + l_ulong flags, + l_ulong new_addr + ); + } +164 AUE_SETRESUID NOPROTO { + int setresuid( + uid_t ruid, + uid_t euid, + uid_t suid + ); + } +165 AUE_GETRESUID NOPROTO { + int getresuid( + uid_t *ruid, + uid_t *euid, + uid_t *suid + ); + } +166 AUE_NULL UNIMPL linux_query_module +167 AUE_POLL STD { + int linux_poll( + struct pollfd *fds, + u_int nfds, + int timeout + ); + } +168 AUE_NULL UNIMPL linux_nfsservctl +169 AUE_SETRESGID NOPROTO { + int setresgid( + gid_t rgid, + gid_t egid, + gid_t sgid + ); + } +170 AUE_GETRESGID NOPROTO { + int getresgid( + gid_t *rgid, + gid_t *egid, + gid_t *sgid + ); + } +171 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 + ); + } +172 AUE_NULL STD { + int linux_rt_sigreturn(void); + } +173 AUE_NULL STD { + int linux_rt_sigaction( + l_int sig, + l_sigaction_t *act, + l_sigaction_t *oact, + l_size_t sigsetsize + ); + } +174 AUE_NULL STD { + int linux_rt_sigprocmask( + l_int how, + l_sigset_t *mask, + l_sigset_t *omask, + l_size_t sigsetsize + ); + } +175 AUE_NULL STD { + int linux_rt_sigpending( + l_sigset_t *set, + l_size_t sigsetsize + ); + } +176 AUE_NULL STD { + int linux_rt_sigtimedwait( + l_sigset_t *mask, + l_siginfo_t *ptr, + struct l_timespec *timeout, + l_size_t sigsetsize + ); + } +177 AUE_NULL STD { + int linux_rt_sigqueueinfo( + l_pid_t pid, + l_int sig, + l_siginfo_t *info + ); + } +178 AUE_NULL STD { + int linux_rt_sigsuspend( + l_sigset_t *newset, + l_size_t sigsetsize + ); + } +179 AUE_PREAD STD { + int linux_pread( + l_uint fd, + char *buf, + l_size_t nbyte, + l_loff_t offset + ); + } +180 AUE_PWRITE STD { + int linux_pwrite( + l_uint fd, + char *buf, + l_size_t nbyte, + l_loff_t offset + ); + } +181 AUE_LCHOWN STD { + int linux_chown( + char *path, + l_uid_t uid, + l_gid_t gid + ); + } +182 AUE_GETCWD STD { + int linux_getcwd( + char *buf, + l_ulong bufsize + ); + } +183 AUE_CAPGET STD { + int linux_capget( + struct l_user_cap_header *hdrp, + struct l_user_cap_data *datap + ); + } +184 AUE_CAPSET STD { + int linux_capset( + struct l_user_cap_header *hdrp, + struct l_user_cap_data *datap + ); + } +185 AUE_NULL STD { + int linux_sigaltstack( + l_stack_t *uss, + l_stack_t *uoss + ); + } +186 AUE_SENDFILE STD { + int linux_sendfile( + l_int out, + l_int in, + l_off_t *offset, + l_size_t count + ); + } +187 AUE_NULL UNIMPL linux_getpmsg +188 AUE_NULL UNIMPL linux_putpmsg +189 AUE_VFORK STD { + int linux_vfork(void); + } +190 AUE_NULL UNIMPL linux_ugetrlimit +191 AUE_NULL UNIMPL linux_readahead +192 AUE_MMAP STD { + int linux_mmap2( + l_ulong addr, + l_ulong len, + l_ulong prot, + l_ulong flags, + l_ulong fd, + l_ulong pgoff + ); + } +193 AUE_NULL UNIMPL linux_truncate64 +194 AUE_NULL UNIMPL linux_ftruncate64 +195 AUE_NULL UNIMPL linux_stat64 +196 AUE_NULL UNIMPL linux_lstat64 +197 AUE_NULL UNIMPL linux_fstat64 +198 AUE_NULL UNIMPL linux_pciconfig_read +199 AUE_NULL UNIMPL linux_pciconfig_write +200 AUE_NULL UNIMPL linux_pciconfig_iobase +201 AUE_NULL UNIMPL linux_multiplexer +202 AUE_GETDIRENTRIES STD { + int linux_getdents64( + l_uint fd, + void *dirent, + l_uint count + ); + } +203 AUE_PIVOT_ROOT STD { + int linux_pivot_root(void); + } +204 AUE_NULL UNIMPL linux_fcntl64 +205 AUE_MADVISE STD { + int linux_madvise( + l_ulong addr, + l_size_t len, + l_int behav + ); + } +206 AUE_MINCORE STD { + int linux_mincore( + l_ulong start, + l_size_t len, + u_char *vec + ); + } +207 AUE_NULL STD { + int linux_gettid(void); + } +208 AUE_NULL STD { + int linux_tkill( + l_pid_t tid, + l_int sig + ); + } +209 AUE_NULL STD { + int linux_setxattr( + const char *path, + const char *name, + void *value, + l_size_t size, + l_int flags + ); + } +210 AUE_NULL STD { + int linux_lsetxattr( + const char *path, + const char *name, + void *value, + l_size_t size, + l_int flags + ); + } +211 AUE_NULL STD { + int linux_fsetxattr( + l_int fd, + const char *name, + void *value, + l_size_t size, + l_int flags + ); + } +212 AUE_NULL STD { + int linux_getxattr( + const char *path, + const char *name, + char *value, + l_size_t size + ); + } +213 AUE_NULL STD { + int linux_lgetxattr( + const char *path, + const char *name, + char *value, + l_size_t size + ); + } +214 AUE_NULL STD { + int linux_fgetxattr( + l_int fd, + const char *name, + char *value, + l_size_t size + ); + } +215 AUE_NULL STD { + int linux_listxattr( + const char *path, + char *list, + l_size_t size + ); + } +216 AUE_NULL STD { + int linux_llistxattr( + const char *path, + char *list, + l_size_t size + ); + } +217 AUE_NULL STD { + int linux_flistxattr( + l_int fd, + char *list, + l_size_t size + ); + } +218 AUE_NULL STD { + int linux_removexattr( + const char *path, + const char *name + ); + } +219 AUE_NULL STD { + int linux_lremovexattr( + const char *path, + const char *name + ); + } +220 AUE_NULL STD { + int linux_fremovexattr( + l_int fd, + const char *name + ); + } +221 AUE_NULL STD { + int linux_sys_futex( + uint32_t *uaddr, + l_int op, + uint32_t val, + struct l_timespec *timeout, + uint32_t *uaddr2, + uint32_t val3 + ); + } +222 AUE_NULL STD { + int linux_sched_setaffinity( + l_pid_t pid, + l_uint len, + l_ulong *user_mask_ptr + ); + } +223 AUE_NULL STD { + int linux_sched_getaffinity( + l_pid_t pid, + l_uint len, + l_ulong *user_mask_ptr + ); + } +224 AUE_NULL UNIMPL +225 AUE_NULL UNIMPL linux_tuxcall +226 AUE_NULL UNIMPL linux_sendfile64 +227 AUE_NULL UNIMPL linux_io_setup +228 AUE_NULL UNIMPL linux_io_destroy +229 AUE_NULL UNIMPL linux_io_getevents +230 AUE_NULL UNIMPL linux_io_submit +231 AUE_NULL UNIMPL linux_io_cancel +232 AUE_NULL STD { + int linux_set_tid_address( + l_int *tidptr + ); + } +233 AUE_NULL STD { + int linux_fadvise64( + l_int fd, + l_loff_t offset, + l_size_t len, + l_int advice + ); + } +234 AUE_EXIT STD { + int linux_exit_group( + l_int error_code + ); + } +235 AUE_NULL STD { + int linux_lookup_dcookie(void); + } +236 AUE_NULL STD { + int linux_epoll_create( + l_int size + ); + } +237 AUE_NULL STD { + int linux_epoll_ctl( + l_int epfd, + l_int op, + l_int fd, + struct epoll_event *event + ); + } +238 AUE_NULL STD { + int linux_epoll_wait( + l_int epfd, + struct epoll_event *events, + l_int maxevents, + l_int timeout + ); + } +239 AUE_NULL STD { + int linux_remap_file_pages(void); + } +240 AUE_NULL STD { + int linux_timer_create( + clockid_t clock_id, + struct sigevent *evp, + l_timer_t *timerid + ); + } +241 AUE_NULL STD { + int linux_timer_settime( + l_timer_t timerid, + l_int flags, + const struct itimerspec *new, + struct itimerspec *old + ); + } +242 AUE_NULL STD { + int linux_timer_gettime( + l_timer_t timerid, + struct itimerspec *setting + ); + } +243 AUE_NULL STD { + int linux_timer_getoverrun( + l_timer_t timerid + ); + } +244 AUE_NULL STD { + int linux_timer_delete( + l_timer_t timerid + ); + } +245 AUE_CLOCK_SETTIME STD { + int linux_clock_settime( + clockid_t which, + struct l_timespec *tp + ); + } +246 AUE_NULL STD { + int linux_clock_gettime( + clockid_t which, + struct l_timespec *tp + ); + } +247 AUE_NULL STD { + int linux_clock_getres( + clockid_t which, + struct l_timespec *tp + ); + } +248 AUE_NULL STD { + int linux_clock_nanosleep( + clockid_t which, + l_int flags, + struct l_timespec *rqtp, + struct l_timespec *rmtp + ); + } +249 AUE_NULL UNIMPL linux_swapcontext +250 AUE_NULL STD { + int linux_tgkill( + l_pid_t tgid, + l_pid_t pid, + l_int sig + ); + } +251 AUE_UTIMES STD { + int linux_utimes( + char *fname, + struct l_timeval *tptr + ); + } +252 AUE_STATFS STD { + int linux_statfs64( + char *path, + size_t bufsize, + struct l_statfs64_buf *buf + ); + } +253 AUE_FSTATFS STD { + int linux_fstatfs64( + l_uint fd, + size_t bufsize, + struct l_statfs64_buf *buf + ); + } +254 AUE_NULL UNIMPL linux_fadvise64_64 +255 AUE_NULL UNIMPL linux_rtas +256 AUE_NULL UNIMPL linux_sys_debug_setcontext +257 AUE_NULL UNIMPL +258 AUE_NULL STD { + int linux_migrate_pages(void); + } +259 AUE_NULL STD { + int linux_mbind(void); + } +260 AUE_NULL STD { + int linux_get_mempolicy(void); + } +261 AUE_NULL STD { + int linux_set_mempolicy(void); + } +262 AUE_NULL STD { + int linux_mq_open( + const char *name, + l_int oflag, + l_mode_t mode, + struct mq_attr *attr + ); + } +263 AUE_NULL STD { + int linux_mq_unlink( + const char *name + ); + } +264 AUE_NULL STD { + int linux_mq_timedsend( + l_mqd_t mqd, + const char *msg_ptr, + l_size_t msg_len, + l_uint msg_prio, + const struct l_timespec *abs_timeout + ); + } +265 AUE_NULL STD { + int linux_mq_timedreceive( + l_mqd_t mqd, + char *msg_ptr, + l_size_t msg_len, + l_uint *msg_prio, + const struct l_timespec *abs_timeout + ); + } +266 AUE_NULL STD { + int linux_mq_notify( + l_mqd_t mqd, + const struct l_timespec *abs_timeout + ); + } +267 AUE_NULL STD { + int linux_mq_getsetattr( + l_mqd_t mqd, + const struct mq_attr *attr, + struct mq_attr *oattr + ); + } +268 AUE_NULL STD { + int linux_kexec_load(void); + } +269 AUE_NULL STD { + int linux_add_key(void); + } +270 AUE_NULL STD { + int linux_request_key(void); + } +271 AUE_NULL STD { + int linux_keyctl(void); + } +272 AUE_WAIT6 STD { + int linux_waitid( + l_int idtype, + l_pid_t id, + l_siginfo_t *info, + l_int options, + struct rusage *rusage + ); + } +273 AUE_SETPRIORITY STD { + int linux_ioprio_set( + l_int which, + l_int who, + l_int ioprio + ); + } +274 AUE_GETPRIORITY STD { + int linux_ioprio_get( + l_int which, + l_int who + ); + } +275 AUE_NULL UNIMPL linux_inotify_init +276 AUE_NULL STD { + int linux_inotify_add_watch(void); + } +277 AUE_NULL STD { + int linux_inotify_rm_watch(void); + } +278 AUE_NULL UNIMPL linux_spu_run +279 AUE_NULL UNIMPL linux_spu_create +280 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 + ); + } +281 AUE_POLL STD { + int linux_ppoll( + struct pollfd *fds, + l_uint nfds, + struct l_timespec *tsp, + l_sigset_t *sset, + l_size_t ssize + ); + } +282 AUE_NULL STD { + int linux_unshare(void); + } +283 AUE_NULL STD { + int linux_splice( + int fd_in, + l_loff_t *off_in, + int fd_out, + l_loff_t *off_out, + l_size_t len, + l_uint flags + ); + } +284 AUE_NULL STD { + int linux_tee(void); + } +285 AUE_NULL STD { + int linux_vmsplice(void); + } +286 AUE_OPEN_RWTC STD { + int linux_openat( + l_int dfd, + const char *filename, + l_int flags, + l_mode_t mode + ); + } +287 AUE_MKDIRAT STD { + int linux_mkdirat( + l_int dfd, + const char *pathname, + l_mode_t mode + ); + } +288 AUE_MKNODAT STD { + int linux_mknodat( + l_int dfd, + const char *filename, + l_mode_t mode, + l_uint dev + ); + } +289 AUE_FCHOWNAT STD { + int linux_fchownat( + l_int dfd, + const char *filename, + l_uid_t uid, + l_gid_t gid, + l_int flag + ); + } +290 AUE_FUTIMESAT STD { + int linux_futimesat( + l_int dfd, + char *filename, + struct l_timeval *utimes + ); + } +291 AUE_FSTATAT STD { + int linux_newfstatat( + l_int dfd, + char *pathname, + struct l_stat64 *statbuf, + l_int flag + ); + } +292 AUE_UNLINKAT STD { + int linux_unlinkat( + l_int dfd, + const char *pathname, + l_int flag + ); + } +293 AUE_RENAMEAT STD { + int linux_renameat( + l_int olddfd, + const char *oldname, + l_int newdfd, + const char *newname + ); + } +294 AUE_LINKAT STD { + int linux_linkat( + l_int olddfd, + const char *oldname, + l_int newdfd, + const char *newname, + l_int flag + ); + } +295 AUE_SYMLINKAT STD { + int linux_symlinkat( + const char *oldname, + l_int newdfd, + const char *newname + ); + } +296 AUE_READLINKAT STD { + int linux_readlinkat( + l_int dfd, + const char *path, + char *buf, + l_int bufsiz + ); + } +297 AUE_FCHMODAT STD { + int linux_fchmodat( + l_int dfd, + const char *filename, + l_mode_t mode + ); + } +298 AUE_FACCESSAT STD { + int linux_faccessat( + l_int dfd, + const char *filename, + l_int amode + ); + } +299 AUE_NULL STD { + int linux_get_robust_list( + l_int pid, + struct linux_robust_list_head **head, + l_size_t *len + ); + } +300 AUE_NULL STD { + int linux_set_robust_list( + struct linux_robust_list_head *head, + l_size_t len + ); + } +301 AUE_NULL STD { + int linux_move_pages(void); + } +302 AUE_NULL STD { + int linux_getcpu( + l_uint *cpu, + l_uint *node, + void *cache + ); + } +303 AUE_NULL STD { + int linux_epoll_pwait( + l_int epfd, + struct epoll_event *events, + l_int maxevents, + l_int timeout, + l_sigset_t *mask, + l_size_t sigsetsize + ); + } +304 AUE_FUTIMESAT STD { + int linux_utimensat( + l_int dfd, + const char *pathname, + const struct l_timespec *times, + l_int flags + ); + } +305 AUE_NULL UNIMPL linux_signalfd +306 AUE_NULL STD { + int linux_timerfd_create( + l_int clockid, + l_int flags + ); + } +307 AUE_NULL STD { + int linux_eventfd( + l_uint initval + ); + } +308 AUE_NULL STD { + int linux_sync_file_range( + l_int fd, + l_loff_t offset, + l_loff_t nbytes, + l_uint flags + ); + } +309 AUE_NULL STD { + int linux_fallocate( + l_int fd, + l_int mode, + l_loff_t offset, + l_loff_t len + ); + } +310 AUE_NULL UNIMPL linux_subpage_prot +311 AUE_NULL STD { + int linux_timerfd_settime( + l_int fd, + l_int flags, + const struct l_itimerspec *new_value, + struct l_itimerspec *old_value + ); + } +312 AUE_NULL STD { + int linux_timerfd_gettime( + l_int fd, + struct l_itimerspec *old_value + ); + } +313 AUE_NULL STD { + int linux_signalfd4(void); + } +314 AUE_NULL STD { + int linux_eventfd2( + l_uint initval, + l_int flags + ); + } +315 AUE_NULL STD { + int linux_epoll_create1( + l_int flags + ); + } +316 AUE_NULL STD { + int linux_dup3( + l_uint oldfd, + l_uint newfd, + l_int flags + ); + } +317 AUE_NULL STD { + int linux_pipe2( + l_int *pipefds, + l_int flags + ); + } +318 AUE_NULL STD { + int linux_inotify_init1( + l_int flags + ); + } +319 AUE_NULL STD { + int linux_perf_event_open(void); + } +320 AUE_NULL STD { + int linux_preadv( + l_ulong fd, + struct iovec *vec, + l_ulong vlen, + l_ulong pos_l, + l_ulong pos_h + ); + } +321 AUE_NULL STD { + int linux_pwritev( + l_ulong fd, + struct iovec *vec, + l_ulong vlen, + l_ulong pos_l, + l_ulong pos_h + ); + } +322 AUE_NULL STD { + int linux_rt_tgsigqueueinfo( + l_pid_t tgid, + l_pid_t tid, + l_int sig, + l_siginfo_t *uinfo + ); + } +323 AUE_NULL STD { + int linux_fanotify_init(void); + } +324 AUE_NULL STD { + int linux_fanotify_mark(void); + } +325 AUE_NULL STD { + int linux_prlimit64( + l_pid_t pid, + l_uint resource, + struct rlimit *new, + struct rlimit *old + ); + } +326 AUE_SOCKET STD { + int linux_socket( + l_int domain, + l_int type, + l_int protocol + ); + } +327 AUE_BIND STD { + int linux_bind( + l_int s, + l_uintptr_t name, + l_int namelen + ); + } +328 AUE_CONNECT STD { + int linux_connect( + l_int s, + l_uintptr_t name, + l_int namelen + ); + } +329 AUE_LISTEN STD { + int linux_listen( + l_int s, + l_int backlog + ); + } +330 AUE_ACCEPT STD { + int linux_accept( + l_int s, + l_uintptr_t addr, + l_uintptr_t namelen + ); + } +331 AUE_GETSOCKNAME STD { + int linux_getsockname( + l_int s, + l_uintptr_t addr, + l_uintptr_t namelen + ); + } +332 AUE_GETPEERNAME STD { + int linux_getpeername( + l_int s, + l_uintptr_t addr, + l_uintptr_t namelen + ); + } +333 AUE_SOCKETPAIR STD { + int linux_socketpair( + l_int domain, + l_int type, + l_int protocol, + l_uintptr_t rsv + ); + } +334 AUE_NULL UNIMPL linux_send +335 AUE_SENDTO STD { + int linux_sendto( + l_int s, + l_uintptr_t msg, + l_size_t len, + l_uint flags, + l_uintptr_t to, + l_int tolen + ); + } +336 AUE_NULL UNIMPL linux_recv +337 AUE_RECVFROM STD { + int linux_recvfrom( + l_int s, + l_uintptr_t buf, + l_size_t len, + l_uint flags, + l_uintptr_t from, + l_uintptr_t fromlen + ); + } +338 AUE_NULL STD { + int linux_shutdown( + l_int s, + l_int how + ); + } +339 AUE_SETSOCKOPT STD { + int linux_setsockopt( + l_int s, + l_int level, + l_int optname, + l_uintptr_t optval, + l_int optlen + ); + } +340 AUE_GETSOCKOPT STD { + int linux_getsockopt( + l_int s, + l_int level, + l_int optname, + l_uintptr_t optval, + l_uintptr_t optlen + ); + } +341 AUE_SENDMSG STD { + int linux_sendmsg( + l_int s, + l_uintptr_t msg, + l_uint flags + ); + } +342 AUE_RECVMSG STD { + int linux_recvmsg( + l_int s, + l_uintptr_t msg, + l_uint flags + ); + } +343 AUE_NULL STD { + int linux_recvmmsg( + l_int s, + struct l_mmsghdr *msg, + l_uint vlen, + l_uint flags, + struct l_timespec *timeout + ); + } +344 AUE_ACCEPT STD { + int linux_accept4( + l_int s, + l_uintptr_t addr, + l_uintptr_t namelen, + l_int flags + ); + } +345 AUE_NULL STD { + int linux_name_to_handle_at( + l_int dirfd, + const char *name, + struct l_file_handle *handle, + l_int *mnt_id, + l_int flags + ); + } +346 AUE_NULL STD { + int linux_open_by_handle_at( + l_int mountdirfd, + struct l_file_handle *handle, + l_int flags + ); + } +347 AUE_NULL STD { + int linux_clock_adjtime(void); + } +348 AUE_SYNC STD { + int linux_syncfs( + l_int fd + ); + } +349 AUE_NULL STD { + int linux_sendmmsg( + l_int s, + struct l_mmsghdr *msg, + l_uint vlen, + l_uint flags + ); + } +350 AUE_NULL STD { + int linux_setns( + l_int fd, + l_int nstype + ); + } +351 AUE_NULL STD { + int linux_process_vm_readv( + l_pid_t pid, + const struct iovec *lvec, + l_ulong liovcnt, + const struct iovec *rvec, + l_ulong riovcnt, + l_ulong flags + ); + } +352 AUE_NULL STD { + int linux_process_vm_writev( + l_pid_t pid, + const struct iovec *lvec, + l_ulong liovcnt, + const struct iovec *rvec, + l_ulong riovcnt, + l_ulong flags + ); + } +353 AUE_NULL STD { + int linux_finit_module( + l_int fd, + const char *uargs, + l_int flags + ); + } +354 AUE_NULL STD { + int linux_kcmp( + l_pid_t pid1, + l_pid_t pid2, + l_int type, + l_ulong idx1, + l_ulong idx + ); + } +355 AUE_NULL STD { + int linux_sched_setattr( + l_pid_t pid, + void *attr, + l_uint flags + ); + } +356 AUE_NULL STD { + int linux_sched_getattr( + l_pid_t pid, + void *attr, + l_uint size, + l_uint flags + ); + } +357 AUE_NULL STD { + int linux_renameat2( + l_int olddfd, + const char *oldname, + l_int newdfd, + const char *newname, + l_uint flags + ); + } +358 AUE_NULL STD { + int linux_seccomp( + l_uint op, + l_uint flags, + const char *uargs + ); + } +359 AUE_NULL STD { + int linux_getrandom( + char *buf, + l_size_t count, + l_uint flags + ); + } +360 AUE_NULL STD { + int linux_memfd_create( + const char *uname_ptr, + l_uint flags + ); + } +361 AUE_NULL STD { + int linux_bpf( + l_int cmd, + void *attr, + l_uint size + ); + } +362 AUE_NULL STD { + int linux_execveat( + l_int dfd, + const char *filename, + const char **argv, + const char **envp, + l_int flags + ); + } +363 AUE_NULL UNIMPL linux_switch_endian +364 AUE_NULL STD { + int linux_userfaultfd( + l_int flags + ); + } +365 AUE_NULL STD { + int linux_membarrier( + l_int cmd, + l_int flags + ); + } +366 AUE_NULL UNIMPL +367 AUE_NULL UNIMPL +368 AUE_NULL UNIMPL +369 AUE_NULL UNIMPL +370 AUE_NULL UNIMPL +371 AUE_NULL UNIMPL +372 AUE_NULL UNIMPL +373 AUE_NULL UNIMPL +374 AUE_NULL UNIMPL +375 AUE_NULL UNIMPL +376 AUE_NULL UNIMPL +377 AUE_NULL UNIMPL +378 AUE_NULL STD { + int linux_mlock2( + l_ulong start, + l_size_t len, + l_int flags + ); + } +379 AUE_NULL STD { + int linux_copy_file_range( + l_int fd_in, + l_loff_t *off_in, + l_int fd_out, + l_loff_t *off_out, + l_size_t len, + l_uint flags + ); + } +380 AUE_NULL STD { + int linux_preadv2( + l_ulong fd, + const struct iovec *vec, + l_ulong vlen, + l_ulong pos_l, + l_ulong pos_h, + l_int flags + ); + } +381 AUE_NULL STD { + int linux_pwritev2( + l_ulong fd, + const struct iovec *vec, + l_ulong vlen, + l_ulong pos_l, + l_ulong pos_h, + l_int flags + ); + } +382 AUE_NULL UNIMPL linux_kexec_file_load +383 AUE_NULL STD { + int linux_statx( + l_int dirfd, + const char *pathname, + l_uint flags, + l_uint mask, + void *statxbuf + ); + } +384 AUE_NULL STD { + int linux_pkey_alloc( + l_ulong flags, + l_ulong init_val + ); + } +385 AUE_NULL STD { + int linux_pkey_free( + l_int pkey + ); + } +386 AUE_NULL STD { + int linux_pkey_mprotect( + l_ulong start, + l_size_t len, + l_ulong prot, + l_int pkey + ); + } +387 AUE_NULL STD { + int linux_rseq( + struct linux_rseq *rseq, + uint32_t rseq_len, + l_int flags, + uint32_t sig + ); + } +388 AUE_NULL STD { + int linux_io_pgetevents(void); + } +389 AUE_NULL UNIMPL +390 AUE_NULL UNIMPL +391 AUE_NULL UNIMPL +392 AUE_NULL STD { + int linux_semtimedop( + l_int semid, + struct sembuf *tsops, + l_size_t nsops, + struct l_timespec *timeout + ); + } +393 AUE_NULL STD { + int linux_semget( + l_key_t key, + l_int nsems, + l_int semflg + ); + } +394 AUE_NULL STD { + int linux_semctl( + l_int semid, + l_int semnum, + l_int cmd, + union l_semun arg + ); + } +395 AUE_NULL STD { + int linux_shmget( + l_key_t key, + l_size_t size, + l_int shmflg + ); + } +396 AUE_NULL STD { + int linux_shmctl( + l_int shmid, + l_int cmd, + struct l_shmid_ds *buf + ); + } +397 AUE_NULL STD { + int linux_shmat( + l_int shmid, + char *shmaddr, + l_int shmflg + ); + } +398 AUE_NULL STD { + int linux_shmdt( + char *shmaddr + ); + } +399 AUE_NULL STD { + int linux_msgget( + l_key_t key, + l_int msgflg + ); + } +400 AUE_NULL STD { + int linux_msgsnd( + l_int msqid, + struct l_msgbuf *msgp, + l_size_t msgsz, + l_int msgflg + ); + } +401 AUE_NULL STD { + int linux_msgrcv( + l_int msqid, + struct l_msgbuf *msgp, + l_size_t msgsz, + l_long msgtyp, + l_int msgflg + ); + } +402 AUE_NULL STD { + int linux_msgctl( + l_int msqid, + l_int cmd, + struct l_msqid_ds *buf + ); + } +403 AUE_NULL UNIMPL linux_clock_gettime64 +404 AUE_NULL UNIMPL linux_clock_settime64 +405 AUE_NULL UNIMPL linux_clock_adjtime64 +406 AUE_NULL UNIMPL linux_clock_getres_time64 +407 AUE_NULL UNIMPL linux_clock_nanosleep_time64 +408 AUE_NULL UNIMPL linux_timer_gettime64 +409 AUE_NULL UNIMPL linux_timer_settime64 +410 AUE_NULL UNIMPL linux_timerfd_gettime64 +411 AUE_NULL UNIMPL linux_timerfd_settime64 +412 AUE_NULL UNIMPL linux_utimensat_time64 +413 AUE_NULL UNIMPL linux_pselect6_time64 +414 AUE_NULL UNIMPL linux_ppoll_time64 +415 AUE_NULL UNIMPL +416 AUE_NULL UNIMPL linux_io_pgetevents_time64 +417 AUE_NULL UNIMPL linux_recvmmsg_time64 +418 AUE_NULL UNIMPL linux_mq_timedsend_time64 +419 AUE_NULL UNIMPL linux_mq_timedreceive_time64 +420 AUE_NULL UNIMPL linux_semtimedop_time64 +421 AUE_NULL UNIMPL linux_rt_sigtimedwait_time64 +422 AUE_NULL UNIMPL linux_futex_time64 +423 AUE_NULL UNIMPL linux_sched_rr_get_interval_time64 +424 AUE_NULL STD { + int linux_pidfd_send_signal( + l_int pidfd, + l_int sig, + l_siginfo_t *info, + l_uint flags + ); + } +425 AUE_NULL STD { + int linux_io_uring_setup(void); + } +426 AUE_NULL STD { + int linux_io_uring_enter(void); + } +427 AUE_NULL STD { + int linux_io_uring_register(void); + } +428 AUE_NULL STD { + int linux_open_tree(void); + } +429 AUE_NULL STD { + int linux_move_mount(void); + } +430 AUE_NULL STD { + int linux_fsopen(void); + } +431 AUE_NULL STD { + int linux_fsconfig(void); + } +432 AUE_NULL STD { + int linux_fsmount(void); + } +433 AUE_NULL STD { + int linux_fspick(void); + } +434 AUE_NULL STD { + int linux_pidfd_open(void); + } +435 AUE_NULL STD { + int linux_clone3( + struct l_user_clone_args *uargs, + l_size_t usize + ); + } +436 AUE_CLOSERANGE STD { + int linux_close_range( + l_uint first, + l_uint last, + l_uint flags + ); + } +437 AUE_NULL STD { + int linux_openat2(void); + } +438 AUE_NULL STD { + int linux_pidfd_getfd(void); + } +439 AUE_NULL STD { + int linux_faccessat2( + l_int dfd, + const char *filename, + l_int amode, + l_int flags + ); + } +440 AUE_NULL STD { + int linux_process_madvise(void); + } +441 AUE_NULL STD { + int linux_epoll_pwait2( + l_int epfd, + struct epoll_event *events, + l_int maxevents, + struct l_timespec *timeout, + l_sigset_t *mask, + l_size_t sigsetsize + ); + } +442 AUE_NULL STD { + int linux_mount_setattr(void); + } +443 AUE_NULL STD { + int linux_quotactl_fd(void); + } +444 AUE_NULL STD { + int linux_landlock_create_ruleset(void); + } +445 AUE_NULL STD { + int linux_landlock_add_rule(void); + } +446 AUE_NULL STD { + int linux_landlock_restrict_self(void); + } +; Linux 5.14: +447 AUE_NULL STD { + int linux_memfd_secret(void); + } +; Linux 5.15: +448 AUE_NULL STD { + int linux_process_mrelease(void); + } +; Linux 5.16: +449 AUE_NULL STD { + int linux_futex_waitv(void); + } +; Linux 5.17: +450 AUE_NULL STD { + int linux_set_mempolicy_home_node(void); + } +; Linux 6.5: +451 AUE_NULL STD { + int linux_cachestat(void); + } +; Linux 6.6: +452 AUE_NULL STD { + int linux_fchmodat2(void); + } +453 AUE_NULL STD { + int linux_map_shadow_stack(void); + }