Index: stable/12/sys/amd64/linux32/linux32_machdep.c =================================================================== --- stable/12/sys/amd64/linux32/linux32_machdep.c (revision 359604) +++ stable/12/sys/amd64/linux32/linux32_machdep.c (revision 359605) @@ -1,878 +1,865 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 2004 Tim J. Robbins * Copyright (c) 2002 Doug Rabson * Copyright (c) 2000 Marcel Moolenaar * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include "opt_compat.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static void bsd_to_linux_rusage(struct rusage *ru, struct l_rusage *lru); struct l_old_select_argv { l_int nfds; l_uintptr_t readfds; l_uintptr_t writefds; l_uintptr_t exceptfds; l_uintptr_t timeout; } __packed; static void bsd_to_linux_rusage(struct rusage *ru, struct l_rusage *lru) { lru->ru_utime.tv_sec = ru->ru_utime.tv_sec; lru->ru_utime.tv_usec = ru->ru_utime.tv_usec; lru->ru_stime.tv_sec = ru->ru_stime.tv_sec; lru->ru_stime.tv_usec = ru->ru_stime.tv_usec; lru->ru_maxrss = ru->ru_maxrss; lru->ru_ixrss = ru->ru_ixrss; lru->ru_idrss = ru->ru_idrss; lru->ru_isrss = ru->ru_isrss; lru->ru_minflt = ru->ru_minflt; lru->ru_majflt = ru->ru_majflt; lru->ru_nswap = ru->ru_nswap; lru->ru_inblock = ru->ru_inblock; lru->ru_oublock = ru->ru_oublock; lru->ru_msgsnd = ru->ru_msgsnd; lru->ru_msgrcv = ru->ru_msgrcv; lru->ru_nsignals = ru->ru_nsignals; lru->ru_nvcsw = ru->ru_nvcsw; lru->ru_nivcsw = ru->ru_nivcsw; } int linux_copyout_rusage(struct rusage *ru, void *uaddr) { struct l_rusage lru; bsd_to_linux_rusage(ru, &lru); return (copyout(&lru, uaddr, sizeof(struct l_rusage))); } int linux_execve(struct thread *td, struct linux_execve_args *args) { struct image_args eargs; char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(execve)) printf(ARGS(execve, "%s"), path); #endif error = freebsd32_exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp, args->envp); free(path, M_TEMP); if (error == 0) error = linux_common_execve(td, &eargs); return (error); } CTASSERT(sizeof(struct l_iovec32) == 8); int linux32_copyinuio(struct l_iovec32 *iovp, l_ulong iovcnt, struct uio **uiop) { struct l_iovec32 iov32; struct iovec *iov; struct uio *uio; uint32_t iovlen; int error, i; *uiop = NULL; if (iovcnt > UIO_MAXIOV) return (EINVAL); iovlen = iovcnt * sizeof(struct iovec); uio = malloc(iovlen + sizeof(*uio), M_IOV, M_WAITOK); iov = (struct iovec *)(uio + 1); for (i = 0; i < iovcnt; i++) { error = copyin(&iovp[i], &iov32, sizeof(struct l_iovec32)); if (error) { free(uio, M_IOV); return (error); } iov[i].iov_base = PTRIN(iov32.iov_base); iov[i].iov_len = iov32.iov_len; } uio->uio_iov = iov; uio->uio_iovcnt = iovcnt; uio->uio_segflg = UIO_USERSPACE; uio->uio_offset = -1; uio->uio_resid = 0; for (i = 0; i < iovcnt; i++) { if (iov->iov_len > INT_MAX - uio->uio_resid) { free(uio, M_IOV); return (EINVAL); } uio->uio_resid += iov->iov_len; iov++; } *uiop = uio; return (0); } int linux32_copyiniov(struct l_iovec32 *iovp32, l_ulong iovcnt, struct iovec **iovp, int error) { struct l_iovec32 iov32; struct iovec *iov; uint32_t iovlen; int i; *iovp = NULL; if (iovcnt > UIO_MAXIOV) return (error); iovlen = iovcnt * sizeof(struct iovec); iov = malloc(iovlen, M_IOV, M_WAITOK); for (i = 0; i < iovcnt; i++) { error = copyin(&iovp32[i], &iov32, sizeof(struct l_iovec32)); if (error) { free(iov, M_IOV); return (error); } iov[i].iov_base = PTRIN(iov32.iov_base); iov[i].iov_len = iov32.iov_len; } *iovp = iov; return(0); } int linux_readv(struct thread *td, struct linux_readv_args *uap) { struct uio *auio; int error; error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_readv(td, uap->fd, auio); free(auio, M_IOV); return (error); } int linux_writev(struct thread *td, struct linux_writev_args *uap) { struct uio *auio; int error; error = linux32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_writev(td, uap->fd, auio); free(auio, M_IOV); return (error); } struct l_ipc_kludge { l_uintptr_t msgp; l_long msgtyp; } __packed; int linux_ipc(struct thread *td, struct linux_ipc_args *args) { switch (args->what & 0xFFFF) { case LINUX_SEMOP: { struct linux_semop_args a; a.semid = args->arg1; a.tsops = PTRIN(args->ptr); a.nsops = args->arg2; return (linux_semop(td, &a)); } case LINUX_SEMGET: { struct linux_semget_args a; a.key = args->arg1; a.nsems = args->arg2; a.semflg = args->arg3; return (linux_semget(td, &a)); } case LINUX_SEMCTL: { struct linux_semctl_args a; int error; a.semid = args->arg1; a.semnum = args->arg2; a.cmd = args->arg3; error = copyin(PTRIN(args->ptr), &a.arg, sizeof(a.arg)); if (error) return (error); return (linux_semctl(td, &a)); } case LINUX_MSGSND: { struct linux_msgsnd_args a; a.msqid = args->arg1; a.msgp = PTRIN(args->ptr); a.msgsz = args->arg2; a.msgflg = args->arg3; return (linux_msgsnd(td, &a)); } case LINUX_MSGRCV: { struct linux_msgrcv_args a; a.msqid = args->arg1; a.msgsz = args->arg2; a.msgflg = args->arg3; if ((args->what >> 16) == 0) { struct l_ipc_kludge tmp; int error; if (args->ptr == 0) return (EINVAL); error = copyin(PTRIN(args->ptr), &tmp, sizeof(tmp)); if (error) return (error); a.msgp = PTRIN(tmp.msgp); a.msgtyp = tmp.msgtyp; } else { a.msgp = PTRIN(args->ptr); a.msgtyp = args->arg5; } return (linux_msgrcv(td, &a)); } case LINUX_MSGGET: { struct linux_msgget_args a; a.key = args->arg1; a.msgflg = args->arg2; return (linux_msgget(td, &a)); } case LINUX_MSGCTL: { struct linux_msgctl_args a; a.msqid = args->arg1; a.cmd = args->arg2; a.buf = PTRIN(args->ptr); return (linux_msgctl(td, &a)); } case LINUX_SHMAT: { struct linux_shmat_args a; l_uintptr_t addr; int error; a.shmid = args->arg1; a.shmaddr = PTRIN(args->ptr); a.shmflg = args->arg2; error = linux_shmat(td, &a); if (error != 0) return (error); addr = td->td_retval[0]; error = copyout(&addr, PTRIN(args->arg3), sizeof(addr)); td->td_retval[0] = 0; return (error); } case LINUX_SHMDT: { struct linux_shmdt_args a; a.shmaddr = PTRIN(args->ptr); return (linux_shmdt(td, &a)); } case LINUX_SHMGET: { struct linux_shmget_args a; a.key = args->arg1; a.size = args->arg2; a.shmflg = args->arg3; return (linux_shmget(td, &a)); } case LINUX_SHMCTL: { struct linux_shmctl_args a; a.shmid = args->arg1; a.cmd = args->arg2; a.buf = PTRIN(args->ptr); return (linux_shmctl(td, &a)); } default: break; } return (EINVAL); } int linux_old_select(struct thread *td, struct linux_old_select_args *args) { struct l_old_select_argv linux_args; struct linux_select_args newsel; int error; #ifdef DEBUG if (ldebug(old_select)) printf(ARGS(old_select, "%p"), args->ptr); #endif error = copyin(args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); newsel.nfds = linux_args.nfds; newsel.readfds = PTRIN(linux_args.readfds); newsel.writefds = PTRIN(linux_args.writefds); newsel.exceptfds = PTRIN(linux_args.exceptfds); newsel.timeout = PTRIN(linux_args.timeout); return (linux_select(td, &newsel)); } int linux_set_cloned_tls(struct thread *td, void *desc) { struct user_segment_descriptor sd; struct l_user_desc info; struct pcb *pcb; int error; int a[2]; error = copyin(desc, &info, sizeof(struct l_user_desc)); if (error) { printf(LMSG("copyin failed!")); } else { /* We might copy out the entry_number as GUGS32_SEL. */ info.entry_number = GUGS32_SEL; error = copyout(&info, desc, sizeof(struct l_user_desc)); if (error) printf(LMSG("copyout failed!")); a[0] = LINUX_LDT_entry_a(&info); a[1] = LINUX_LDT_entry_b(&info); memcpy(&sd, &a, sizeof(a)); #ifdef DEBUG if (ldebug(clone)) printf("Segment created in clone with " "CLONE_SETTLS: lobase: %x, hibase: %x, " "lolimit: %x, hilimit: %x, type: %i, " "dpl: %i, p: %i, xx: %i, long: %i, " "def32: %i, gran: %i\n", sd.sd_lobase, sd.sd_hibase, sd.sd_lolimit, sd.sd_hilimit, sd.sd_type, sd.sd_dpl, sd.sd_p, sd.sd_xx, sd.sd_long, sd.sd_def32, sd.sd_gran); #endif pcb = td->td_pcb; pcb->pcb_gsbase = (register_t)info.base_addr; td->td_frame->tf_gs = GSEL(GUGS32_SEL, SEL_UPL); set_pcb_flags(pcb, PCB_32BIT); } return (error); } int linux_set_upcall_kse(struct thread *td, register_t stack) { if (stack) td->td_frame->tf_rsp = stack; /* * The newly created Linux thread returns * to the user space by the same path that a parent do. */ td->td_frame->tf_rax = 0; return (0); } int linux_mmap2(struct thread *td, struct linux_mmap2_args *args) { #ifdef DEBUG if (ldebug(mmap2)) printf(ARGS(mmap2, "0x%08x, %d, %d, 0x%08x, %d, %d"), args->addr, args->len, args->prot, args->flags, args->fd, args->pgoff); #endif return (linux_mmap_common(td, PTROUT(args->addr), args->len, args->prot, args->flags, args->fd, (uint64_t)(uint32_t)args->pgoff * PAGE_SIZE)); } int linux_mmap(struct thread *td, struct linux_mmap_args *args) { int error; struct l_mmap_argv linux_args; error = copyin(args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); #ifdef DEBUG if (ldebug(mmap)) printf(ARGS(mmap, "0x%08x, %d, %d, 0x%08x, %d, %d"), linux_args.addr, linux_args.len, linux_args.prot, linux_args.flags, linux_args.fd, linux_args.pgoff); #endif return (linux_mmap_common(td, linux_args.addr, linux_args.len, linux_args.prot, linux_args.flags, linux_args.fd, (uint32_t)linux_args.pgoff)); } int linux_mprotect(struct thread *td, struct linux_mprotect_args *uap) { return (linux_mprotect_common(td, PTROUT(uap->addr), uap->len, uap->prot)); } int linux_iopl(struct thread *td, struct linux_iopl_args *args) { int error; if (args->level < 0 || args->level > 3) return (EINVAL); if ((error = priv_check(td, PRIV_IO)) != 0) return (error); if ((error = securelevel_gt(td->td_ucred, 0)) != 0) return (error); td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) | (args->level * (PSL_IOPL / 3)); return (0); } int linux_sigaction(struct thread *td, struct linux_sigaction_args *args) { l_osigaction_t osa; l_sigaction_t act, oact; int error; #ifdef DEBUG if (ldebug(sigaction)) printf(ARGS(sigaction, "%d, %p, %p"), args->sig, (void *)args->nsa, (void *)args->osa); #endif if (args->nsa != NULL) { error = copyin(args->nsa, &osa, sizeof(l_osigaction_t)); if (error) return (error); act.lsa_handler = osa.lsa_handler; act.lsa_flags = osa.lsa_flags; act.lsa_restorer = osa.lsa_restorer; LINUX_SIGEMPTYSET(act.lsa_mask); act.lsa_mask.__mask = osa.lsa_mask; } error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, args->osa ? &oact : NULL); if (args->osa != NULL && !error) { osa.lsa_handler = oact.lsa_handler; osa.lsa_flags = oact.lsa_flags; osa.lsa_restorer = oact.lsa_restorer; osa.lsa_mask = oact.lsa_mask.__mask; error = copyout(&osa, args->osa, sizeof(l_osigaction_t)); } return (error); } /* * Linux has two extra args, restart and oldmask. We don't use these, * but it seems that "restart" is actually a context pointer that * enables the signal to happen with a different register set. */ int linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) { sigset_t sigmask; l_sigset_t mask; #ifdef DEBUG if (ldebug(sigsuspend)) printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask); #endif LINUX_SIGEMPTYSET(mask); mask.__mask = args->mask; linux_to_bsd_sigset(&mask, &sigmask); return (kern_sigsuspend(td, sigmask)); } int linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap) { l_sigset_t lmask; sigset_t sigmask; int error; #ifdef DEBUG if (ldebug(rt_sigsuspend)) printf(ARGS(rt_sigsuspend, "%p, %d"), (void *)uap->newset, uap->sigsetsize); #endif if (uap->sigsetsize != sizeof(l_sigset_t)) return (EINVAL); error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); if (error) return (error); linux_to_bsd_sigset(&lmask, &sigmask); return (kern_sigsuspend(td, sigmask)); } int linux_pause(struct thread *td, struct linux_pause_args *args) { struct proc *p = td->td_proc; sigset_t sigmask; #ifdef DEBUG if (ldebug(pause)) printf(ARGS(pause, "")); #endif PROC_LOCK(p); sigmask = td->td_sigmask; PROC_UNLOCK(p); return (kern_sigsuspend(td, sigmask)); } int linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) { stack_t ss, oss; l_stack_t lss; int error; #ifdef DEBUG if (ldebug(sigaltstack)) printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss); #endif if (uap->uss != NULL) { error = copyin(uap->uss, &lss, sizeof(l_stack_t)); if (error) return (error); ss.ss_sp = PTRIN(lss.ss_sp); ss.ss_size = lss.ss_size; ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags); } error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL, (uap->uoss != NULL) ? &oss : NULL); if (!error && uap->uoss != NULL) { lss.ss_sp = PTROUT(oss.ss_sp); lss.ss_size = oss.ss_size; lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags); error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); } return (error); } int -linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) -{ - -#ifdef DEBUG - if (ldebug(ftruncate64)) - printf(ARGS(ftruncate64, "%u, %jd"), args->fd, - (intmax_t)args->length); -#endif - - return (kern_ftruncate(td, args->fd, args->length)); -} - -int linux_gettimeofday(struct thread *td, struct linux_gettimeofday_args *uap) { struct timeval atv; l_timeval atv32; struct timezone rtz; int error = 0; if (uap->tp) { microtime(&atv); atv32.tv_sec = atv.tv_sec; atv32.tv_usec = atv.tv_usec; error = copyout(&atv32, uap->tp, sizeof(atv32)); } if (error == 0 && uap->tzp != NULL) { rtz.tz_minuteswest = tz_minuteswest; rtz.tz_dsttime = tz_dsttime; error = copyout(&rtz, uap->tzp, sizeof(rtz)); } return (error); } int linux_settimeofday(struct thread *td, struct linux_settimeofday_args *uap) { l_timeval atv32; struct timeval atv, *tvp; struct timezone atz, *tzp; int error; if (uap->tp) { error = copyin(uap->tp, &atv32, sizeof(atv32)); if (error) return (error); atv.tv_sec = atv32.tv_sec; atv.tv_usec = atv32.tv_usec; tvp = &atv; } else tvp = NULL; if (uap->tzp) { error = copyin(uap->tzp, &atz, sizeof(atz)); if (error) return (error); tzp = &atz; } else tzp = NULL; return (kern_settimeofday(td, tvp, tzp)); } int linux_getrusage(struct thread *td, struct linux_getrusage_args *uap) { struct rusage s; int error; error = kern_getrusage(td, uap->who, &s); if (error != 0) return (error); if (uap->rusage != NULL) error = linux_copyout_rusage(&s, uap->rusage); return (error); } int linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args) { struct l_user_desc info; struct user_segment_descriptor sd; struct pcb *pcb; int a[2]; int error; error = copyin(args->desc, &info, sizeof(struct l_user_desc)); if (error) return (error); #ifdef DEBUG if (ldebug(set_thread_area)) printf(ARGS(set_thread_area, "%i, %x, %x, %i, %i, %i, " "%i, %i, %i"), info.entry_number, info.base_addr, info.limit, info.seg_32bit, info.contents, info.read_exec_only, info.limit_in_pages, info.seg_not_present, info.useable); #endif /* * Semantics of Linux version: every thread in the system has array * of three TLS descriptors. 1st is GLIBC TLS, 2nd is WINE, 3rd unknown. * This syscall loads one of the selected TLS decriptors with a value * and also loads GDT descriptors 6, 7 and 8 with the content of * the per-thread descriptors. * * Semantics of FreeBSD version: I think we can ignore that Linux has * three per-thread descriptors and use just the first one. * The tls_array[] is used only in [gs]et_thread_area() syscalls and * for loading the GDT descriptors. We use just one GDT descriptor * for TLS, so we will load just one. * * XXX: This doesn't work when a user space process tries to use more * than one TLS segment. Comment in the Linux source says wine might * do this. */ /* * GLIBC reads current %gs and call set_thread_area() with it. * We should let GUDATA_SEL and GUGS32_SEL proceed as well because * we use these segments. */ switch (info.entry_number) { case GUGS32_SEL: case GUDATA_SEL: case 6: case -1: info.entry_number = GUGS32_SEL; break; default: return (EINVAL); } /* * We have to copy out the GDT entry we use. * * XXX: What if a user space program does not check the return value * and tries to use 6, 7 or 8? */ error = copyout(&info, args->desc, sizeof(struct l_user_desc)); if (error) return (error); if (LINUX_LDT_empty(&info)) { a[0] = 0; a[1] = 0; } else { a[0] = LINUX_LDT_entry_a(&info); a[1] = LINUX_LDT_entry_b(&info); } memcpy(&sd, &a, sizeof(a)); #ifdef DEBUG if (ldebug(set_thread_area)) printf("Segment created in set_thread_area: " "lobase: %x, hibase: %x, lolimit: %x, hilimit: %x, " "type: %i, dpl: %i, p: %i, xx: %i, long: %i, " "def32: %i, gran: %i\n", sd.sd_lobase, sd.sd_hibase, sd.sd_lolimit, sd.sd_hilimit, sd.sd_type, sd.sd_dpl, sd.sd_p, sd.sd_xx, sd.sd_long, sd.sd_def32, sd.sd_gran); #endif pcb = td->td_pcb; pcb->pcb_gsbase = (register_t)info.base_addr; set_pcb_flags(pcb, PCB_32BIT); update_gdt_gsbase(td, info.base_addr); return (0); } int futex_xchgl_nosmap(int oparg, uint32_t *uaddr, int *oldval); int futex_xchgl_smap(int oparg, uint32_t *uaddr, int *oldval); DEFINE_IFUNC(, int, futex_xchgl, (int, uint32_t *, int *), static) { return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ? futex_xchgl_smap : futex_xchgl_nosmap); } int futex_addl_nosmap(int oparg, uint32_t *uaddr, int *oldval); int futex_addl_smap(int oparg, uint32_t *uaddr, int *oldval); DEFINE_IFUNC(, int, futex_addl, (int, uint32_t *, int *), static) { return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ? futex_addl_smap : futex_addl_nosmap); } int futex_orl_nosmap(int oparg, uint32_t *uaddr, int *oldval); int futex_orl_smap(int oparg, uint32_t *uaddr, int *oldval); DEFINE_IFUNC(, int, futex_orl, (int, uint32_t *, int *), static) { return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ? futex_orl_smap : futex_orl_nosmap); } int futex_andl_nosmap(int oparg, uint32_t *uaddr, int *oldval); int futex_andl_smap(int oparg, uint32_t *uaddr, int *oldval); DEFINE_IFUNC(, int, futex_andl, (int, uint32_t *, int *), static) { return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ? futex_andl_smap : futex_andl_nosmap); } int futex_xorl_nosmap(int oparg, uint32_t *uaddr, int *oldval); int futex_xorl_smap(int oparg, uint32_t *uaddr, int *oldval); DEFINE_IFUNC(, int, futex_xorl, (int, uint32_t *, int *), static) { return ((cpu_stdext_feature & CPUID_STDEXT_SMAP) != 0 ? futex_xorl_smap : futex_xorl_nosmap); } Index: stable/12/sys/amd64/linux32/linux32_proto.h =================================================================== --- stable/12/sys/amd64/linux32/linux32_proto.h (revision 359604) +++ stable/12/sys/amd64/linux32/linux32_proto.h (revision 359605) @@ -1,2252 +1,2263 @@ /* * System call prototypes. * * DO NOT EDIT-- this file is automatically @generated. * $FreeBSD$ */ #ifndef _LINUX32_SYSPROTO_H_ #define _LINUX32_SYSPROTO_H_ #include #include #include #include #include #include #include #include #include struct proc; struct thread; #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) #if BYTE_ORDER == LITTLE_ENDIAN #define PADL_(t) 0 #define PADR_(t) PAD_(t) #else #define PADL_(t) PAD_(t) #define PADR_(t) 0 #endif #define nosys linux_nosys struct linux_exit_args { char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)]; }; struct linux_fork_args { register_t dummy; }; struct linux_open_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; struct linux_waitpid_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)]; }; struct linux_creat_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; struct linux_link_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; struct linux_unlink_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; struct linux_execve_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char argp_l_[PADL_(uint32_t *)]; uint32_t * argp; char argp_r_[PADR_(uint32_t *)]; char envp_l_[PADL_(uint32_t *)]; uint32_t * envp; char envp_r_[PADR_(uint32_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_int)]; l_int mode; char mode_r_[PADR_(l_int)]; char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; }; struct linux_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_lchown16_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; struct linux_stat_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char up_l_[PADL_(struct linux_stat *)]; struct linux_stat * up; char up_r_[PADR_(struct linux_stat *)]; }; 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 { register_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_oldumount_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; struct linux_setuid16_args { char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; }; struct linux_getuid16_args { register_t dummy; }; struct linux_stime_args { register_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_long)]; l_long addr; char addr_r_[PADR_(l_long)]; char data_l_[PADL_(l_long)]; l_long data; char data_r_[PADR_(l_long)]; }; struct linux_alarm_args { char secs_l_[PADL_(l_uint)]; l_uint secs; char secs_r_[PADR_(l_uint)]; }; struct linux_pause_args { register_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_nice_args { char inc_l_[PADL_(l_int)]; l_int inc; char inc_r_[PADR_(l_int)]; }; struct linux_kill_args { char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)]; char signum_l_[PADL_(l_int)]; l_int signum; char signum_r_[PADR_(l_int)]; }; struct linux_rename_args { char from_l_[PADL_(char *)]; char * from; char from_r_[PADR_(char *)]; char to_l_[PADL_(char *)]; char * to; char to_r_[PADR_(char *)]; }; struct linux_mkdir_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; struct linux_rmdir_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; }; struct linux_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_setgid16_args { char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_t)]; }; struct linux_getgid16_args { register_t dummy; }; struct linux_signal_args { char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; char handler_l_[PADL_(l_handler_t)]; l_handler_t handler; char handler_r_[PADR_(l_handler_t)]; }; struct linux_geteuid16_args { register_t dummy; }; struct linux_getegid16_args { register_t dummy; }; 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_ioctl_args { char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; char arg_l_[PADL_(uintptr_t)]; uintptr_t arg; char arg_r_[PADR_(uintptr_t)]; }; struct linux_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_(uintptr_t)]; uintptr_t arg; char arg_r_[PADR_(uintptr_t)]; }; struct linux_olduname_args { register_t dummy; }; struct linux_ustat_args { char dev_l_[PADL_(l_dev_t)]; l_dev_t dev; char dev_r_[PADR_(l_dev_t)]; char ubuf_l_[PADL_(struct l_ustat *)]; struct l_ustat * ubuf; char ubuf_r_[PADR_(struct l_ustat *)]; }; struct linux_getppid_args { register_t dummy; }; struct linux_sigaction_args { char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; char nsa_l_[PADL_(l_osigaction_t *)]; l_osigaction_t * nsa; char nsa_r_[PADR_(l_osigaction_t *)]; char osa_l_[PADL_(l_osigaction_t *)]; l_osigaction_t * osa; char osa_r_[PADR_(l_osigaction_t *)]; }; struct linux_sgetmask_args { register_t dummy; }; struct linux_ssetmask_args { char mask_l_[PADL_(l_osigset_t)]; l_osigset_t mask; char mask_r_[PADR_(l_osigset_t)]; }; struct linux_setreuid16_args { char ruid_l_[PADL_(l_uid16_t)]; l_uid16_t ruid; char ruid_r_[PADR_(l_uid16_t)]; char euid_l_[PADL_(l_uid16_t)]; l_uid16_t euid; char euid_r_[PADR_(l_uid16_t)]; }; struct linux_setregid16_args { char rgid_l_[PADL_(l_gid16_t)]; l_gid16_t rgid; char rgid_r_[PADR_(l_gid16_t)]; char egid_l_[PADL_(l_gid16_t)]; l_gid16_t egid; char egid_r_[PADR_(l_gid16_t)]; }; struct linux_sigsuspend_args { char hist0_l_[PADL_(l_int)]; l_int hist0; char hist0_r_[PADR_(l_int)]; char hist1_l_[PADL_(l_int)]; l_int hist1; char hist1_r_[PADR_(l_int)]; char mask_l_[PADL_(l_osigset_t)]; l_osigset_t mask; char mask_r_[PADR_(l_osigset_t)]; }; struct linux_sigpending_args { char mask_l_[PADL_(l_osigset_t *)]; l_osigset_t * mask; char mask_r_[PADR_(l_osigset_t *)]; }; struct linux_sethostname_args { char hostname_l_[PADL_(char *)]; char * hostname; char hostname_r_[PADR_(char *)]; char len_l_[PADL_(u_int)]; u_int len; char len_r_[PADR_(u_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_old_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_getrusage_args { char who_l_[PADL_(int)]; int who; char who_r_[PADR_(int)]; char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)]; }; struct linux_gettimeofday_args { char tp_l_[PADL_(struct l_timeval *)]; struct l_timeval * tp; char tp_r_[PADR_(struct l_timeval *)]; char tzp_l_[PADL_(struct timezone *)]; struct timezone * tzp; char tzp_r_[PADR_(struct timezone *)]; }; struct linux_settimeofday_args { char tp_l_[PADL_(struct l_timeval *)]; struct l_timeval * tp; char tp_r_[PADR_(struct l_timeval *)]; char tzp_l_[PADL_(struct timezone *)]; struct timezone * tzp; char tzp_r_[PADR_(struct timezone *)]; }; struct linux_getgroups16_args { char gidsetsize_l_[PADL_(l_uint)]; l_uint gidsetsize; char gidsetsize_r_[PADR_(l_uint)]; char gidset_l_[PADL_(l_gid16_t *)]; l_gid16_t * gidset; char gidset_r_[PADR_(l_gid16_t *)]; }; struct linux_setgroups16_args { char gidsetsize_l_[PADL_(l_uint)]; l_uint gidsetsize; char gidsetsize_r_[PADR_(l_uint)]; char gidset_l_[PADL_(l_gid16_t *)]; l_gid16_t * gidset; char gidset_r_[PADR_(l_gid16_t *)]; }; struct linux_old_select_args { char ptr_l_[PADL_(struct l_old_select_argv *)]; struct l_old_select_argv * ptr; char ptr_r_[PADR_(struct l_old_select_argv *)]; }; 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_lstat_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char up_l_[PADL_(struct linux_lstat *)]; struct linux_lstat * up; char up_r_[PADR_(struct linux_lstat *)]; }; 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_readdir_args { char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; char dent_l_[PADL_(struct l_dirent *)]; struct l_dirent * dent; char dent_r_[PADR_(struct l_dirent *)]; char count_l_[PADL_(l_uint)]; l_uint count; char count_r_[PADR_(l_uint)]; }; struct linux_mmap_args { char ptr_l_[PADL_(struct l_mmap_argv *)]; struct l_mmap_argv * ptr; char ptr_r_[PADR_(struct l_mmap_argv *)]; }; struct linux_truncate_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char length_l_[PADL_(l_ulong)]; l_ulong length; char length_r_[PADR_(l_ulong)]; }; struct linux_ftruncate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char length_l_[PADL_(long)]; long length; char length_r_[PADR_(long)]; }; struct linux_getpriority_args { char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char who_l_[PADL_(int)]; int who; char who_r_[PADR_(int)]; }; struct linux_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_socketcall_args { char what_l_[PADL_(l_int)]; l_int what; char what_r_[PADR_(l_int)]; char args_l_[PADL_(l_ulong)]; l_ulong args; char args_r_[PADR_(l_ulong)]; }; 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_uname_args { register_t dummy; }; struct linux_iopl_args { char level_l_[PADL_(l_int)]; l_int level; char level_r_[PADR_(l_int)]; }; struct linux_vhangup_args { register_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 l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)]; }; struct linux_swapoff_args { register_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_ipc_args { char what_l_[PADL_(l_uint)]; l_uint what; char what_r_[PADR_(l_uint)]; char arg1_l_[PADL_(l_int)]; l_int arg1; char arg1_r_[PADR_(l_int)]; char arg2_l_[PADL_(l_int)]; l_int arg2; char arg2_r_[PADR_(l_int)]; char arg3_l_[PADL_(l_uint)]; l_uint arg3; char arg3_r_[PADR_(l_uint)]; char ptr_l_[PADL_(l_uintptr_t)]; l_uintptr_t ptr; char ptr_r_[PADR_(l_uintptr_t)]; char arg5_l_[PADL_(l_uint)]; l_uint arg5; char arg5_r_[PADR_(l_uint)]; }; struct linux_sigreturn_args { char sfp_l_[PADL_(struct l_sigframe *)]; struct l_sigframe * sfp; char sfp_r_[PADR_(struct l_sigframe *)]; }; struct linux_clone_args { char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char stack_l_[PADL_(void *)]; void * stack; char stack_r_[PADR_(void *)]; char parent_tidptr_l_[PADL_(void *)]; void * parent_tidptr; char parent_tidptr_r_[PADR_(void *)]; char tls_l_[PADL_(void *)]; void * tls; char tls_r_[PADR_(void *)]; char child_tidptr_l_[PADL_(void *)]; void * child_tidptr; char child_tidptr_r_[PADR_(void *)]; }; struct linux_setdomainname_args { char name_l_[PADL_(char *)]; char * name; char name_r_[PADR_(char *)]; char len_l_[PADL_(int)]; int len; char len_r_[PADR_(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_adjtimex_args { register_t dummy; }; struct linux_mprotect_args { char addr_l_[PADL_(caddr_t)]; caddr_t addr; char addr_r_[PADR_(caddr_t)]; char len_l_[PADL_(int)]; int len; char len_r_[PADR_(int)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; }; struct linux_sigprocmask_args { char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)]; char mask_l_[PADL_(l_osigset_t *)]; l_osigset_t * mask; char mask_r_[PADR_(l_osigset_t *)]; char omask_l_[PADL_(l_osigset_t *)]; l_osigset_t * omask; char omask_r_[PADR_(l_osigset_t *)]; }; struct linux_init_module_args { register_t dummy; }; struct linux_delete_module_args { register_t dummy; }; struct linux_quotactl_args { register_t dummy; }; struct linux_bdflush_args { register_t dummy; }; struct linux_sysfs_args { char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)]; char arg1_l_[PADL_(l_ulong)]; l_ulong arg1; char arg1_r_[PADR_(l_ulong)]; char arg2_l_[PADL_(l_ulong)]; l_ulong arg2; char arg2_r_[PADR_(l_ulong)]; }; struct linux_personality_args { char per_l_[PADL_(l_uint)]; l_uint per; char per_r_[PADR_(l_uint)]; }; struct linux_setfsuid16_args { char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; }; struct linux_setfsgid16_args { char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_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_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_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_readv_args { char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; char iovp_l_[PADL_(struct l_iovec32 *)]; struct l_iovec32 * iovp; char iovp_r_[PADR_(struct l_iovec32 *)]; char iovcnt_l_[PADL_(l_ulong)]; l_ulong iovcnt; char iovcnt_r_[PADR_(l_ulong)]; }; struct linux_writev_args { char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)]; char iovp_l_[PADL_(struct l_iovec32 *)]; struct l_iovec32 * iovp; char iovp_r_[PADR_(struct l_iovec32 *)]; char iovcnt_l_[PADL_(l_ulong)]; l_ulong iovcnt; char iovcnt_r_[PADR_(l_ulong)]; }; 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_setresuid16_args { char ruid_l_[PADL_(l_uid16_t)]; l_uid16_t ruid; char ruid_r_[PADR_(l_uid16_t)]; char euid_l_[PADL_(l_uid16_t)]; l_uid16_t euid; char euid_r_[PADR_(l_uid16_t)]; char suid_l_[PADL_(l_uid16_t)]; l_uid16_t suid; char suid_r_[PADR_(l_uid16_t)]; }; struct linux_getresuid16_args { char ruid_l_[PADL_(l_uid16_t *)]; l_uid16_t * ruid; char ruid_r_[PADR_(l_uid16_t *)]; char euid_l_[PADL_(l_uid16_t *)]; l_uid16_t * euid; char euid_r_[PADR_(l_uid16_t *)]; char suid_l_[PADL_(l_uid16_t *)]; l_uid16_t * suid; char suid_r_[PADR_(l_uid16_t *)]; }; struct linux_setresgid16_args { char rgid_l_[PADL_(l_gid16_t)]; l_gid16_t rgid; char rgid_r_[PADR_(l_gid16_t)]; char egid_l_[PADL_(l_gid16_t)]; l_gid16_t egid; char egid_r_[PADR_(l_gid16_t)]; char sgid_l_[PADL_(l_gid16_t)]; l_gid16_t sgid; char sgid_r_[PADR_(l_gid16_t)]; }; struct linux_getresgid16_args { char rgid_l_[PADL_(l_gid16_t *)]; l_gid16_t * rgid; char rgid_r_[PADR_(l_gid16_t *)]; char egid_l_[PADL_(l_gid16_t *)]; l_gid16_t * egid; char egid_r_[PADR_(l_gid16_t *)]; char sgid_l_[PADL_(l_gid16_t *)]; l_gid16_t * sgid; char sgid_r_[PADR_(l_gid16_t *)]; }; struct linux_prctl_args { char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)]; char arg2_l_[PADL_(l_int)]; l_int arg2; char arg2_r_[PADR_(l_int)]; char arg3_l_[PADL_(l_int)]; l_int arg3; char arg3_r_[PADR_(l_int)]; char arg4_l_[PADL_(l_int)]; l_int arg4; char arg4_r_[PADR_(l_int)]; char arg5_l_[PADL_(l_int)]; l_int arg5; char arg5_r_[PADR_(l_int)]; }; struct linux_rt_sigreturn_args { char ucp_l_[PADL_(struct l_ucontext *)]; struct l_ucontext * ucp; char ucp_r_[PADR_(struct l_ucontext *)]; }; struct linux_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_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)]; char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; struct linux_rt_sigqueueinfo_args { char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)]; char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)]; }; struct linux_rt_sigsuspend_args { char newset_l_[PADL_(l_sigset_t *)]; l_sigset_t * newset; char newset_r_[PADR_(l_sigset_t *)]; char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)]; }; struct linux_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)]; + char offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_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)]; + char offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_t)]; }; struct linux_chown16_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_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 { register_t dummy; }; struct linux_vfork_args { register_t dummy; }; 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_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_truncate64_args { char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)]; - char length_l_[PADL_(l_loff_t)]; l_loff_t length; char length_r_[PADR_(l_loff_t)]; + char length1_l_[PADL_(uint32_t)]; uint32_t length1; char length1_r_[PADR_(uint32_t)]; + char length2_l_[PADL_(uint32_t)]; uint32_t length2; char length2_r_[PADR_(uint32_t)]; }; struct linux_ftruncate64_args { char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; - char length_l_[PADL_(l_loff_t)]; l_loff_t length; char length_r_[PADR_(l_loff_t)]; + char length1_l_[PADL_(uint32_t)]; uint32_t length1; char length1_r_[PADR_(uint32_t)]; + char length2_l_[PADL_(uint32_t)]; uint32_t length2; char length2_r_[PADR_(uint32_t)]; }; struct linux_stat64_args { char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; }; struct linux_lstat64_args { char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; }; struct linux_fstat64_args { char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; }; 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_getuid_args { register_t dummy; }; struct linux_getgid_args { register_t dummy; }; struct linux_getgroups_args { char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; }; struct linux_setgroups_args { char gidsetsize_l_[PADL_(l_int)]; l_int gidsetsize; char gidsetsize_r_[PADR_(l_int)]; char grouplist_l_[PADL_(l_gid_t *)]; l_gid_t * grouplist; char grouplist_r_[PADR_(l_gid_t *)]; }; struct linux_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_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_pivot_root_args { char new_root_l_[PADL_(char *)]; char * new_root; char new_root_r_[PADR_(char *)]; char put_old_l_[PADL_(char *)]; char * put_old; char put_old_r_[PADR_(char *)]; }; 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_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_fcntl64_args { char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)]; char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; char arg_l_[PADL_(uintptr_t)]; uintptr_t arg; char arg_r_[PADR_(uintptr_t)]; }; struct linux_gettid_args { register_t dummy; }; struct linux_setxattr_args { register_t dummy; }; struct linux_lsetxattr_args { register_t dummy; }; struct linux_fsetxattr_args { register_t dummy; }; struct linux_getxattr_args { register_t dummy; }; struct linux_lgetxattr_args { register_t dummy; }; struct linux_fgetxattr_args { register_t dummy; }; struct linux_listxattr_args { register_t dummy; }; struct linux_llistxattr_args { register_t dummy; }; struct linux_flistxattr_args { register_t dummy; }; struct linux_removexattr_args { register_t dummy; }; struct linux_lremovexattr_args { register_t dummy; }; struct linux_fremovexattr_args { register_t dummy; }; struct linux_tkill_args { char tid_l_[PADL_(int)]; int tid; char tid_r_[PADR_(int)]; char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; }; struct linux_sys_futex_args { char uaddr_l_[PADL_(void *)]; void * uaddr; char uaddr_r_[PADR_(void *)]; char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)]; char val_l_[PADL_(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_thread_area_args { char desc_l_[PADL_(struct l_user_desc *)]; struct l_user_desc * desc; char desc_r_[PADR_(struct l_user_desc *)]; }; struct linux_fadvise64_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; - char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; + char offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_t)]; char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; char advice_l_[PADL_(int)]; int advice; char advice_r_[PADR_(int)]; }; struct linux_exit_group_args { char error_code_l_[PADL_(int)]; int error_code; char error_code_r_[PADR_(int)]; }; struct linux_lookup_dcookie_args { register_t dummy; }; struct linux_epoll_create_args { char size_l_[PADL_(l_int)]; l_int size; char size_r_[PADR_(l_int)]; }; struct linux_epoll_ctl_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 { register_t dummy; }; struct linux_set_tid_address_args { char tidptr_l_[PADL_(int *)]; int * tidptr; char tidptr_r_[PADR_(int *)]; }; struct linux_timer_create_args { char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)]; char evp_l_[PADL_(struct sigevent *)]; struct sigevent * evp; char evp_r_[PADR_(struct sigevent *)]; char timerid_l_[PADL_(l_timer_t *)]; l_timer_t * timerid; char timerid_r_[PADR_(l_timer_t *)]; }; struct linux_timer_settime_args { char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char new_l_[PADL_(const struct itimerspec *)]; const struct itimerspec * new; char new_r_[PADR_(const struct itimerspec *)]; char old_l_[PADL_(struct itimerspec *)]; struct itimerspec * old; char old_r_[PADR_(struct itimerspec *)]; }; struct linux_timer_gettime_args { char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)]; char setting_l_[PADL_(struct itimerspec *)]; struct itimerspec * setting; char setting_r_[PADR_(struct itimerspec *)]; }; struct linux_timer_getoverrun_args { char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)]; }; struct linux_timer_delete_args { char timerid_l_[PADL_(l_timer_t)]; l_timer_t timerid; char timerid_r_[PADR_(l_timer_t)]; }; struct linux_clock_settime_args { char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)]; char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)]; }; struct linux_clock_gettime_args { char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)]; char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)]; }; struct linux_clock_getres_args { char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)]; char tp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tp; char tp_r_[PADR_(struct l_timespec *)]; }; struct linux_clock_nanosleep_args { char which_l_[PADL_(clockid_t)]; clockid_t which; char which_r_[PADR_(clockid_t)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char rqtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rqtp; char rqtp_r_[PADR_(struct l_timespec *)]; char rmtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rmtp; char rmtp_r_[PADR_(struct l_timespec *)]; }; struct linux_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_tgkill_args { char tgid_l_[PADL_(int)]; int tgid; char tgid_r_[PADR_(int)]; char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; }; struct linux_utimes_args { char fname_l_[PADL_(char *)]; char * fname; char fname_r_[PADR_(char *)]; char tptr_l_[PADL_(struct l_timeval *)]; struct l_timeval * tptr; char tptr_r_[PADR_(struct l_timeval *)]; }; struct linux_fadvise64_64_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; - char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)]; - char len_l_[PADL_(l_loff_t)]; l_loff_t len; char len_r_[PADR_(l_loff_t)]; + char offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_t)]; + char len1_l_[PADL_(uint32_t)]; uint32_t len1; char len1_r_[PADR_(uint32_t)]; + char len2_l_[PADL_(uint32_t)]; uint32_t len2; char len2_r_[PADR_(uint32_t)]; char advice_l_[PADL_(int)]; int advice; char advice_r_[PADR_(int)]; }; struct linux_mbind_args { register_t dummy; }; struct linux_get_mempolicy_args { register_t dummy; }; struct linux_set_mempolicy_args { register_t dummy; }; struct linux_mq_open_args { register_t dummy; }; struct linux_mq_unlink_args { register_t dummy; }; struct linux_mq_timedsend_args { register_t dummy; }; struct linux_mq_timedreceive_args { register_t dummy; }; struct linux_mq_notify_args { register_t dummy; }; struct linux_mq_getsetattr_args { register_t dummy; }; struct linux_kexec_load_args { register_t dummy; }; struct linux_waitid_args { char idtype_l_[PADL_(int)]; int idtype; char idtype_r_[PADR_(int)]; char id_l_[PADL_(l_pid_t)]; l_pid_t id; char id_r_[PADR_(l_pid_t)]; char info_l_[PADL_(l_siginfo_t *)]; l_siginfo_t * info; char info_r_[PADR_(l_siginfo_t *)]; char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; char rusage_l_[PADL_(struct l_rusage *)]; struct l_rusage * rusage; char rusage_r_[PADR_(struct l_rusage *)]; }; struct linux_add_key_args { register_t dummy; }; struct linux_request_key_args { register_t dummy; }; struct linux_keyctl_args { register_t dummy; }; struct linux_ioprio_set_args { register_t dummy; }; struct linux_ioprio_get_args { register_t dummy; }; struct linux_inotify_init_args { register_t dummy; }; struct linux_inotify_add_watch_args { register_t dummy; }; struct linux_inotify_rm_watch_args { register_t dummy; }; struct linux_migrate_pages_args { register_t dummy; }; struct linux_openat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; struct linux_mkdirat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; }; struct linux_mknodat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)]; char dev_l_[PADL_(l_uint)]; l_uint dev; char dev_r_[PADR_(l_uint)]; }; struct linux_fchownat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char uid_l_[PADL_(l_uid16_t)]; l_uid16_t uid; char uid_r_[PADR_(l_uid16_t)]; char gid_l_[PADL_(l_gid16_t)]; l_gid16_t gid; char gid_r_[PADR_(l_gid16_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_fstatat64_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char pathname_l_[PADL_(char *)]; char * pathname; char pathname_r_[PADR_(char *)]; char statbuf_l_[PADL_(struct l_stat64 *)]; struct l_stat64 * statbuf; char statbuf_r_[PADR_(struct l_stat64 *)]; char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; }; struct linux_unlinkat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char pathname_l_[PADL_(const char *)]; const char * pathname; char pathname_r_[PADR_(const char *)]; char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; }; struct linux_renameat_args { char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)]; char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; }; struct linux_linkat_args { char olddfd_l_[PADL_(l_int)]; l_int olddfd; char olddfd_r_[PADR_(l_int)]; char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; char flag_l_[PADL_(l_int)]; l_int flag; char flag_r_[PADR_(l_int)]; }; struct linux_symlinkat_args { char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; char newdfd_l_[PADL_(l_int)]; l_int newdfd; char newdfd_r_[PADR_(l_int)]; char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; }; struct linux_readlinkat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; char bufsiz_l_[PADL_(l_int)]; l_int bufsiz; char bufsiz_r_[PADR_(l_int)]; }; struct linux_fchmodat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char mode_l_[PADL_(l_mode_t)]; l_mode_t mode; char mode_r_[PADR_(l_mode_t)]; }; struct linux_faccessat_args { char dfd_l_[PADL_(l_int)]; l_int dfd; char dfd_r_[PADR_(l_int)]; char filename_l_[PADL_(const char *)]; const char * filename; char filename_r_[PADR_(const char *)]; char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)]; }; struct linux_pselect6_args { char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)]; char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)]; char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)]; char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)]; char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)]; char sig_l_[PADL_(l_uintptr_t *)]; l_uintptr_t * sig; char sig_r_[PADR_(l_uintptr_t *)]; }; struct linux_ppoll_args { char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)]; char nfds_l_[PADL_(uint32_t)]; uint32_t nfds; char nfds_r_[PADR_(uint32_t)]; char tsp_l_[PADL_(struct l_timespec *)]; struct l_timespec * tsp; char tsp_r_[PADR_(struct l_timespec *)]; char sset_l_[PADL_(l_sigset_t *)]; l_sigset_t * sset; char sset_r_[PADR_(l_sigset_t *)]; char ssize_l_[PADL_(l_size_t)]; l_size_t ssize; char ssize_r_[PADR_(l_size_t)]; }; struct linux_unshare_args { register_t dummy; }; struct linux_set_robust_list_args { char head_l_[PADL_(struct linux_robust_list_head *)]; struct linux_robust_list_head * head; char head_r_[PADR_(struct linux_robust_list_head *)]; char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; }; struct linux_get_robust_list_args { char pid_l_[PADL_(l_int)]; l_int pid; char pid_r_[PADR_(l_int)]; char head_l_[PADL_(struct linux_robust_list_head **)]; struct linux_robust_list_head ** head; char head_r_[PADR_(struct linux_robust_list_head **)]; char len_l_[PADL_(l_size_t *)]; l_size_t * len; char len_r_[PADR_(l_size_t *)]; }; struct linux_splice_args { register_t dummy; }; struct linux_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 offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_t)]; + char nbytes1_l_[PADL_(uint32_t)]; uint32_t nbytes1; char nbytes1_r_[PADR_(uint32_t)]; + char nbytes2_l_[PADL_(uint32_t)]; uint32_t nbytes2; char nbytes2_r_[PADR_(uint32_t)]; char flags_l_[PADL_(unsigned int)]; unsigned int flags; char flags_r_[PADR_(unsigned int)]; }; struct linux_tee_args { register_t dummy; }; struct linux_vmsplice_args { register_t dummy; }; struct linux_move_pages_args { register_t dummy; }; struct linux_getcpu_args { register_t dummy; }; 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_signalfd_args { register_t dummy; }; 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_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)]; + char offset1_l_[PADL_(uint32_t)]; uint32_t offset1; char offset1_r_[PADR_(uint32_t)]; + char offset2_l_[PADL_(uint32_t)]; uint32_t offset2; char offset2_r_[PADR_(uint32_t)]; + char len1_l_[PADL_(uint32_t)]; uint32_t len1; char len1_r_[PADR_(uint32_t)]; + char len2_l_[PADL_(uint32_t)]; uint32_t len2; char len2_r_[PADR_(uint32_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 { register_t dummy; }; struct linux_eventfd2_args { char initval_l_[PADL_(l_uint)]; l_uint initval; char initval_r_[PADR_(l_uint)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_epoll_create1_args { char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_dup3_args { char oldfd_l_[PADL_(l_int)]; l_int oldfd; char oldfd_r_[PADR_(l_int)]; char newfd_l_[PADL_(l_int)]; l_int newfd; char newfd_r_[PADR_(l_int)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_pipe2_args { char pipefds_l_[PADL_(l_int *)]; l_int * pipefds; char pipefds_r_[PADR_(l_int *)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_inotify_init1_args { register_t dummy; }; struct linux_preadv_args { 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_perf_event_open_args { register_t dummy; }; struct linux_recvmmsg_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)]; char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)]; char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; char timeout_l_[PADL_(struct l_timespec *)]; struct l_timespec * timeout; char timeout_r_[PADR_(struct l_timespec *)]; }; struct linux_fanotify_init_args { register_t dummy; }; struct linux_fanotify_mark_args { register_t dummy; }; struct linux_prlimit64_args { char pid_l_[PADL_(l_pid_t)]; l_pid_t pid; char pid_r_[PADR_(l_pid_t)]; char resource_l_[PADL_(l_uint)]; l_uint resource; char resource_r_[PADR_(l_uint)]; char new_l_[PADL_(struct rlimit *)]; struct rlimit * new; char new_r_[PADR_(struct rlimit *)]; char old_l_[PADL_(struct rlimit *)]; struct rlimit * old; char old_r_[PADR_(struct rlimit *)]; }; struct linux_name_to_handle_at_args { register_t dummy; }; struct linux_open_by_handle_at_args { register_t dummy; }; struct linux_clock_adjtime_args { register_t dummy; }; struct linux_syncfs_args { char fd_l_[PADL_(l_int)]; l_int fd; char fd_r_[PADR_(l_int)]; }; struct linux_sendmmsg_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char msg_l_[PADL_(struct l_mmsghdr *)]; struct l_mmsghdr * msg; char msg_r_[PADR_(struct l_mmsghdr *)]; char vlen_l_[PADL_(l_uint)]; l_uint vlen; char vlen_r_[PADR_(l_uint)]; char flags_l_[PADL_(l_uint)]; l_uint flags; char flags_r_[PADR_(l_uint)]; }; struct linux_setns_args { register_t dummy; }; struct linux_process_vm_readv_args { 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_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_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_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 oldfd_l_[PADL_(l_int)]; l_int oldfd; char oldfd_r_[PADR_(l_int)]; char oldname_l_[PADL_(const char *)]; const char * oldname; char oldname_r_[PADR_(const char *)]; char newfd_l_[PADL_(l_int)]; l_int newfd; char newfd_r_[PADR_(l_int)]; char newname_l_[PADL_(const char *)]; const char * newname; char newname_r_[PADR_(const char *)]; char flags_l_[PADL_(unsigned int)]; unsigned int flags; char flags_r_[PADR_(unsigned int)]; }; 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_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_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_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_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_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_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_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_sendto_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)]; char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char to_l_[PADL_(l_uintptr_t)]; l_uintptr_t to; char to_r_[PADR_(l_uintptr_t)]; char tolen_l_[PADL_(l_int)]; l_int tolen; char tolen_r_[PADR_(l_int)]; }; struct linux_sendmsg_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_recvfrom_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char buf_l_[PADL_(l_uintptr_t)]; l_uintptr_t buf; char buf_r_[PADR_(l_uintptr_t)]; char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; char from_l_[PADL_(l_uintptr_t)]; l_uintptr_t from; char from_r_[PADR_(l_uintptr_t)]; char fromlen_l_[PADL_(l_uintptr_t)]; l_uintptr_t fromlen; char fromlen_r_[PADR_(l_uintptr_t)]; }; struct linux_recvmsg_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)]; char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)]; }; struct linux_shutdown_args { char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)]; char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)]; }; struct linux_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_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_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_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_arch_prctl_args { char option_l_[PADL_(l_int)]; l_int option; char option_r_[PADR_(l_int)]; char arg2_l_[PADL_(l_ulong)]; l_ulong arg2; char arg2_r_[PADR_(l_ulong)]; }; struct linux_io_pgetevents_args { register_t dummy; }; struct linux_rseq_args { register_t dummy; }; 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_clock_gettime64_args { register_t dummy; }; struct linux_clock_settime64_args { register_t dummy; }; struct linux_clock_adjtime64_args { register_t dummy; }; struct linux_clock_getres_time64_args { register_t dummy; }; struct linux_clock_nanosleep_time64_args { register_t dummy; }; struct linux_timer_gettime64_args { register_t dummy; }; struct linux_timer_settime64_args { register_t dummy; }; struct linux_timerfd_gettime64_args { register_t dummy; }; struct linux_timerfd_settime64_args { register_t dummy; }; struct linux_utimensat_time64_args { register_t dummy; }; struct linux_pselect6_time64_args { register_t dummy; }; struct linux_ppoll_time64_args { register_t dummy; }; struct linux_io_pgetevents_time64_args { register_t dummy; }; struct linux_recvmmsg_time64_args { register_t dummy; }; struct linux_mq_timedsend_time64_args { register_t dummy; }; struct linux_mq_timedreceive_time64_args { register_t dummy; }; struct linux_semtimedop_time64_args { register_t dummy; }; struct linux_rt_sigtimedwait_time64_args { register_t dummy; }; struct linux_futex_time64_args { register_t dummy; }; struct linux_sched_rr_get_interval_time64_args { register_t dummy; }; 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 { register_t dummy; }; struct linux_io_uring_enter_args { register_t dummy; }; struct linux_io_uring_register_args { register_t dummy; }; #define nosys linux_nosys int linux_exit(struct thread *, struct linux_exit_args *); int linux_fork(struct thread *, struct linux_fork_args *); int linux_open(struct thread *, struct linux_open_args *); int linux_waitpid(struct thread *, struct linux_waitpid_args *); 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_lchown16(struct thread *, struct linux_lchown16_args *); int linux_stat(struct thread *, struct linux_stat_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_oldumount(struct thread *, struct linux_oldumount_args *); int linux_setuid16(struct thread *, struct linux_setuid16_args *); int linux_getuid16(struct thread *, struct linux_getuid16_args *); int linux_stime(struct thread *, struct linux_stime_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_nice(struct thread *, struct linux_nice_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_setgid16(struct thread *, struct linux_setgid16_args *); int linux_getgid16(struct thread *, struct linux_getgid16_args *); int linux_signal(struct thread *, struct linux_signal_args *); int linux_geteuid16(struct thread *, struct linux_geteuid16_args *); int linux_getegid16(struct thread *, struct linux_getegid16_args *); int linux_umount(struct thread *, struct linux_umount_args *); int linux_ioctl(struct thread *, struct linux_ioctl_args *); int linux_fcntl(struct thread *, struct linux_fcntl_args *); int linux_olduname(struct thread *, struct linux_olduname_args *); int linux_ustat(struct thread *, struct linux_ustat_args *); int linux_getppid(struct thread *, struct linux_getppid_args *); int linux_sigaction(struct thread *, struct linux_sigaction_args *); int linux_sgetmask(struct thread *, struct linux_sgetmask_args *); int linux_ssetmask(struct thread *, struct linux_ssetmask_args *); int linux_setreuid16(struct thread *, struct linux_setreuid16_args *); int linux_setregid16(struct thread *, struct linux_setregid16_args *); int linux_sigsuspend(struct thread *, struct linux_sigsuspend_args *); int linux_sigpending(struct thread *, struct linux_sigpending_args *); int linux_sethostname(struct thread *, struct linux_sethostname_args *); int linux_setrlimit(struct thread *, struct linux_setrlimit_args *); int linux_old_getrlimit(struct thread *, struct linux_old_getrlimit_args *); int linux_getrusage(struct thread *, struct linux_getrusage_args *); int linux_gettimeofday(struct thread *, struct linux_gettimeofday_args *); int linux_settimeofday(struct thread *, struct linux_settimeofday_args *); int linux_getgroups16(struct thread *, struct linux_getgroups16_args *); int linux_setgroups16(struct thread *, struct linux_setgroups16_args *); int linux_old_select(struct thread *, struct linux_old_select_args *); int linux_symlink(struct thread *, struct linux_symlink_args *); int linux_lstat(struct thread *, struct linux_lstat_args *); int linux_readlink(struct thread *, struct linux_readlink_args *); int linux_reboot(struct thread *, struct linux_reboot_args *); int linux_readdir(struct thread *, struct linux_readdir_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_socketcall(struct thread *, struct linux_socketcall_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_uname(struct thread *, struct linux_uname_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_ipc(struct thread *, struct linux_ipc_args *); int linux_sigreturn(struct thread *, struct linux_sigreturn_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_adjtimex(struct thread *, struct linux_adjtimex_args *); int linux_mprotect(struct thread *, struct linux_mprotect_args *); int linux_sigprocmask(struct thread *, struct linux_sigprocmask_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_bdflush(struct thread *, struct linux_bdflush_args *); int linux_sysfs(struct thread *, struct linux_sysfs_args *); int linux_personality(struct thread *, struct linux_personality_args *); int linux_setfsuid16(struct thread *, struct linux_setfsuid16_args *); int linux_setfsgid16(struct thread *, struct linux_setfsgid16_args *); int linux_llseek(struct thread *, struct linux_llseek_args *); int linux_getdents(struct thread *, struct linux_getdents_args *); int linux_select(struct thread *, struct linux_select_args *); int linux_msync(struct thread *, struct linux_msync_args *); int linux_readv(struct thread *, struct linux_readv_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_setresuid16(struct thread *, struct linux_setresuid16_args *); int linux_getresuid16(struct thread *, struct linux_getresuid16_args *); int linux_setresgid16(struct thread *, struct linux_setresgid16_args *); int linux_getresgid16(struct thread *, struct linux_getresgid16_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_chown16(struct thread *, struct linux_chown16_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_getrlimit(struct thread *, struct linux_getrlimit_args *); int linux_mmap2(struct thread *, struct linux_mmap2_args *); int linux_truncate64(struct thread *, struct linux_truncate64_args *); int linux_ftruncate64(struct thread *, struct linux_ftruncate64_args *); int linux_stat64(struct thread *, struct linux_stat64_args *); int linux_lstat64(struct thread *, struct linux_lstat64_args *); int linux_fstat64(struct thread *, struct linux_fstat64_args *); int linux_lchown(struct thread *, struct linux_lchown_args *); int linux_getuid(struct thread *, struct linux_getuid_args *); int linux_getgid(struct thread *, struct linux_getgid_args *); int linux_getgroups(struct thread *, struct linux_getgroups_args *); int linux_setgroups(struct thread *, struct linux_setgroups_args *); int linux_chown(struct thread *, struct linux_chown_args *); int linux_setfsuid(struct thread *, struct linux_setfsuid_args *); int linux_setfsgid(struct thread *, struct linux_setfsgid_args *); int linux_pivot_root(struct thread *, struct linux_pivot_root_args *); int linux_mincore(struct thread *, struct linux_mincore_args *); int linux_getdents64(struct thread *, struct linux_getdents64_args *); int linux_fcntl64(struct thread *, struct linux_fcntl64_args *); int linux_gettid(struct thread *, struct linux_gettid_args *); int linux_setxattr(struct thread *, struct linux_setxattr_args *); int linux_lsetxattr(struct thread *, struct linux_lsetxattr_args *); int linux_fsetxattr(struct thread *, struct linux_fsetxattr_args *); int linux_getxattr(struct thread *, struct linux_getxattr_args *); int linux_lgetxattr(struct thread *, struct linux_lgetxattr_args *); int linux_fgetxattr(struct thread *, struct linux_fgetxattr_args *); int linux_listxattr(struct thread *, struct linux_listxattr_args *); int linux_llistxattr(struct thread *, struct linux_llistxattr_args *); int linux_flistxattr(struct thread *, struct linux_flistxattr_args *); int linux_removexattr(struct thread *, struct linux_removexattr_args *); int linux_lremovexattr(struct thread *, struct linux_lremovexattr_args *); int linux_fremovexattr(struct thread *, struct linux_fremovexattr_args *); int linux_tkill(struct thread *, struct linux_tkill_args *); int linux_sys_futex(struct thread *, struct linux_sys_futex_args *); int linux_sched_setaffinity(struct thread *, struct linux_sched_setaffinity_args *); int linux_sched_getaffinity(struct thread *, struct linux_sched_getaffinity_args *); int linux_set_thread_area(struct thread *, struct linux_set_thread_area_args *); int linux_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_set_tid_address(struct thread *, struct linux_set_tid_address_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_statfs64(struct thread *, struct linux_statfs64_args *); int linux_fstatfs64(struct thread *, struct linux_fstatfs64_args *); int linux_tgkill(struct thread *, struct linux_tgkill_args *); int linux_utimes(struct thread *, struct linux_utimes_args *); int linux_fadvise64_64(struct thread *, struct linux_fadvise64_64_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_waitid(struct thread *, struct linux_waitid_args *); int linux_add_key(struct thread *, struct linux_add_key_args *); int linux_request_key(struct thread *, struct linux_request_key_args *); int linux_keyctl(struct thread *, struct linux_keyctl_args *); int linux_ioprio_set(struct thread *, struct linux_ioprio_set_args *); int linux_ioprio_get(struct thread *, struct linux_ioprio_get_args *); int linux_inotify_init(struct thread *, struct linux_inotify_init_args *); int linux_inotify_add_watch(struct thread *, struct linux_inotify_add_watch_args *); int linux_inotify_rm_watch(struct thread *, struct linux_inotify_rm_watch_args *); int linux_migrate_pages(struct thread *, struct linux_migrate_pages_args *); int linux_openat(struct thread *, struct linux_openat_args *); int linux_mkdirat(struct thread *, struct linux_mkdirat_args *); int linux_mknodat(struct thread *, struct linux_mknodat_args *); int linux_fchownat(struct thread *, struct linux_fchownat_args *); int linux_futimesat(struct thread *, struct linux_futimesat_args *); int linux_fstatat64(struct thread *, struct linux_fstatat64_args *); int linux_unlinkat(struct thread *, struct linux_unlinkat_args *); int linux_renameat(struct thread *, struct linux_renameat_args *); int linux_linkat(struct thread *, struct linux_linkat_args *); int linux_symlinkat(struct thread *, struct linux_symlinkat_args *); int linux_readlinkat(struct thread *, struct linux_readlinkat_args *); int linux_fchmodat(struct thread *, struct linux_fchmodat_args *); int linux_faccessat(struct thread *, struct linux_faccessat_args *); int linux_pselect6(struct thread *, struct linux_pselect6_args *); int linux_ppoll(struct thread *, struct linux_ppoll_args *); int linux_unshare(struct thread *, struct linux_unshare_args *); int linux_set_robust_list(struct thread *, struct linux_set_robust_list_args *); int linux_get_robust_list(struct thread *, struct linux_get_robust_list_args *); int linux_splice(struct thread *, struct linux_splice_args *); int linux_sync_file_range(struct thread *, struct linux_sync_file_range_args *); int linux_tee(struct thread *, struct linux_tee_args *); int linux_vmsplice(struct thread *, struct linux_vmsplice_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_signalfd(struct thread *, struct linux_signalfd_args *); int linux_timerfd_create(struct thread *, struct linux_timerfd_create_args *); int linux_eventfd(struct thread *, struct linux_eventfd_args *); int linux_fallocate(struct thread *, struct linux_fallocate_args *); int linux_timerfd_settime(struct thread *, struct linux_timerfd_settime_args *); int linux_timerfd_gettime(struct thread *, struct linux_timerfd_gettime_args *); int linux_signalfd4(struct thread *, struct linux_signalfd4_args *); int linux_eventfd2(struct thread *, struct linux_eventfd2_args *); int linux_epoll_create1(struct thread *, struct linux_epoll_create1_args *); int linux_dup3(struct thread *, struct linux_dup3_args *); int linux_pipe2(struct thread *, struct linux_pipe2_args *); int linux_inotify_init1(struct thread *, struct linux_inotify_init1_args *); int linux_preadv(struct thread *, struct linux_preadv_args *); int linux_pwritev(struct thread *, struct linux_pwritev_args *); int linux_rt_tgsigqueueinfo(struct thread *, struct linux_rt_tgsigqueueinfo_args *); int linux_perf_event_open(struct thread *, struct linux_perf_event_open_args *); int linux_recvmmsg(struct thread *, struct linux_recvmmsg_args *); int linux_fanotify_init(struct thread *, struct linux_fanotify_init_args *); int linux_fanotify_mark(struct thread *, struct linux_fanotify_mark_args *); int linux_prlimit64(struct thread *, struct linux_prlimit64_args *); int linux_name_to_handle_at(struct thread *, struct linux_name_to_handle_at_args *); int linux_open_by_handle_at(struct thread *, struct linux_open_by_handle_at_args *); int linux_clock_adjtime(struct thread *, struct linux_clock_adjtime_args *); int linux_syncfs(struct thread *, struct linux_syncfs_args *); int linux_sendmmsg(struct thread *, struct linux_sendmmsg_args *); int linux_setns(struct thread *, struct linux_setns_args *); int linux_process_vm_readv(struct thread *, struct linux_process_vm_readv_args *); int linux_process_vm_writev(struct thread *, struct linux_process_vm_writev_args *); int linux_kcmp(struct thread *, struct linux_kcmp_args *); int linux_finit_module(struct thread *, struct linux_finit_module_args *); 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_socket(struct thread *, struct linux_socket_args *); int linux_socketpair(struct thread *, struct linux_socketpair_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_accept4(struct thread *, struct linux_accept4_args *); int linux_getsockopt(struct thread *, struct linux_getsockopt_args *); int linux_setsockopt(struct thread *, struct linux_setsockopt_args *); int linux_getsockname(struct thread *, struct linux_getsockname_args *); int linux_getpeername(struct thread *, struct linux_getpeername_args *); int linux_sendto(struct thread *, struct linux_sendto_args *); int linux_sendmsg(struct thread *, struct linux_sendmsg_args *); int linux_recvfrom(struct thread *, struct linux_recvfrom_args *); int linux_recvmsg(struct thread *, struct linux_recvmsg_args *); int linux_shutdown(struct thread *, struct linux_shutdown_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_pkey_mprotect(struct thread *, struct linux_pkey_mprotect_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_statx(struct thread *, struct linux_statx_args *); int linux_arch_prctl(struct thread *, struct linux_arch_prctl_args *); int linux_io_pgetevents(struct thread *, struct linux_io_pgetevents_args *); int linux_rseq(struct thread *, struct linux_rseq_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_clock_gettime64(struct thread *, struct linux_clock_gettime64_args *); int linux_clock_settime64(struct thread *, struct linux_clock_settime64_args *); int linux_clock_adjtime64(struct thread *, struct linux_clock_adjtime64_args *); int linux_clock_getres_time64(struct thread *, struct linux_clock_getres_time64_args *); int linux_clock_nanosleep_time64(struct thread *, struct linux_clock_nanosleep_time64_args *); int linux_timer_gettime64(struct thread *, struct linux_timer_gettime64_args *); int linux_timer_settime64(struct thread *, struct linux_timer_settime64_args *); int linux_timerfd_gettime64(struct thread *, struct linux_timerfd_gettime64_args *); int linux_timerfd_settime64(struct thread *, struct linux_timerfd_settime64_args *); int linux_utimensat_time64(struct thread *, struct linux_utimensat_time64_args *); int linux_pselect6_time64(struct thread *, struct linux_pselect6_time64_args *); int linux_ppoll_time64(struct thread *, struct linux_ppoll_time64_args *); int linux_io_pgetevents_time64(struct thread *, struct linux_io_pgetevents_time64_args *); int linux_recvmmsg_time64(struct thread *, struct linux_recvmmsg_time64_args *); int linux_mq_timedsend_time64(struct thread *, struct linux_mq_timedsend_time64_args *); int linux_mq_timedreceive_time64(struct thread *, struct linux_mq_timedreceive_time64_args *); int linux_semtimedop_time64(struct thread *, struct linux_semtimedop_time64_args *); int linux_rt_sigtimedwait_time64(struct thread *, struct linux_rt_sigtimedwait_time64_args *); int linux_futex_time64(struct thread *, struct linux_futex_time64_args *); int linux_sched_rr_get_interval_time64(struct thread *, struct linux_sched_rr_get_interval_time64_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 *); #ifdef COMPAT_43 #define nosys linux_nosys #endif /* COMPAT_43 */ #ifdef COMPAT_FREEBSD4 #define nosys linux_nosys #endif /* COMPAT_FREEBSD4 */ #ifdef COMPAT_FREEBSD6 #define nosys linux_nosys #endif /* COMPAT_FREEBSD6 */ #ifdef COMPAT_FREEBSD7 #define nosys linux_nosys #endif /* COMPAT_FREEBSD7 */ #ifdef COMPAT_FREEBSD10 #define nosys linux_nosys #endif /* COMPAT_FREEBSD10 */ #ifdef COMPAT_FREEBSD11 #define nosys linux_nosys #endif /* COMPAT_FREEBSD11 */ #define LINUX32_SYS_AUE_linux_exit AUE_EXIT #define LINUX32_SYS_AUE_linux_fork AUE_FORK #define LINUX32_SYS_AUE_linux_open AUE_OPEN_RWTC #define LINUX32_SYS_AUE_linux_waitpid AUE_WAIT4 #define LINUX32_SYS_AUE_linux_creat AUE_CREAT #define LINUX32_SYS_AUE_linux_link AUE_LINK #define LINUX32_SYS_AUE_linux_unlink AUE_UNLINK #define LINUX32_SYS_AUE_linux_execve AUE_EXECVE #define LINUX32_SYS_AUE_linux_chdir AUE_CHDIR #define LINUX32_SYS_AUE_linux_time AUE_NULL #define LINUX32_SYS_AUE_linux_mknod AUE_MKNOD #define LINUX32_SYS_AUE_linux_chmod AUE_CHMOD #define LINUX32_SYS_AUE_linux_lchown16 AUE_LCHOWN #define LINUX32_SYS_AUE_linux_stat AUE_STAT #define LINUX32_SYS_AUE_linux_lseek AUE_LSEEK #define LINUX32_SYS_AUE_linux_getpid AUE_GETPID #define LINUX32_SYS_AUE_linux_mount AUE_MOUNT #define LINUX32_SYS_AUE_linux_oldumount AUE_UMOUNT #define LINUX32_SYS_AUE_linux_setuid16 AUE_SETUID #define LINUX32_SYS_AUE_linux_getuid16 AUE_GETUID #define LINUX32_SYS_AUE_linux_stime AUE_SETTIMEOFDAY #define LINUX32_SYS_AUE_linux_ptrace AUE_PTRACE #define LINUX32_SYS_AUE_linux_alarm AUE_NULL #define LINUX32_SYS_AUE_linux_pause AUE_NULL #define LINUX32_SYS_AUE_linux_utime AUE_UTIME #define LINUX32_SYS_AUE_linux_access AUE_ACCESS #define LINUX32_SYS_AUE_linux_nice AUE_NICE #define LINUX32_SYS_AUE_linux_kill AUE_KILL #define LINUX32_SYS_AUE_linux_rename AUE_RENAME #define LINUX32_SYS_AUE_linux_mkdir AUE_MKDIR #define LINUX32_SYS_AUE_linux_rmdir AUE_RMDIR #define LINUX32_SYS_AUE_linux_pipe AUE_PIPE #define LINUX32_SYS_AUE_linux_times AUE_NULL #define LINUX32_SYS_AUE_linux_brk AUE_NULL #define LINUX32_SYS_AUE_linux_setgid16 AUE_SETGID #define LINUX32_SYS_AUE_linux_getgid16 AUE_GETGID #define LINUX32_SYS_AUE_linux_signal AUE_NULL #define LINUX32_SYS_AUE_linux_geteuid16 AUE_GETEUID #define LINUX32_SYS_AUE_linux_getegid16 AUE_GETEGID #define LINUX32_SYS_AUE_linux_umount AUE_UMOUNT #define LINUX32_SYS_AUE_linux_ioctl AUE_IOCTL #define LINUX32_SYS_AUE_linux_fcntl AUE_FCNTL #define LINUX32_SYS_AUE_linux_olduname AUE_NULL #define LINUX32_SYS_AUE_linux_ustat AUE_NULL #define LINUX32_SYS_AUE_linux_getppid AUE_GETPPID #define LINUX32_SYS_AUE_linux_sigaction AUE_NULL #define LINUX32_SYS_AUE_linux_sgetmask AUE_NULL #define LINUX32_SYS_AUE_linux_ssetmask AUE_NULL #define LINUX32_SYS_AUE_linux_setreuid16 AUE_SETREUID #define LINUX32_SYS_AUE_linux_setregid16 AUE_SETREGID #define LINUX32_SYS_AUE_linux_sigsuspend AUE_NULL #define LINUX32_SYS_AUE_linux_sigpending AUE_NULL #define LINUX32_SYS_AUE_linux_sethostname AUE_SYSCTL #define LINUX32_SYS_AUE_linux_setrlimit AUE_SETRLIMIT #define LINUX32_SYS_AUE_linux_old_getrlimit AUE_GETRLIMIT #define LINUX32_SYS_AUE_linux_getrusage AUE_GETRUSAGE #define LINUX32_SYS_AUE_linux_gettimeofday AUE_NULL #define LINUX32_SYS_AUE_linux_settimeofday AUE_SETTIMEOFDAY #define LINUX32_SYS_AUE_linux_getgroups16 AUE_GETGROUPS #define LINUX32_SYS_AUE_linux_setgroups16 AUE_SETGROUPS #define LINUX32_SYS_AUE_linux_old_select AUE_SELECT #define LINUX32_SYS_AUE_linux_symlink AUE_SYMLINK #define LINUX32_SYS_AUE_linux_lstat AUE_LSTAT #define LINUX32_SYS_AUE_linux_readlink AUE_READLINK #define LINUX32_SYS_AUE_linux_reboot AUE_REBOOT #define LINUX32_SYS_AUE_linux_readdir AUE_GETDIRENTRIES #define LINUX32_SYS_AUE_linux_mmap AUE_MMAP #define LINUX32_SYS_AUE_linux_truncate AUE_TRUNCATE #define LINUX32_SYS_AUE_linux_ftruncate AUE_FTRUNCATE #define LINUX32_SYS_AUE_linux_getpriority AUE_GETPRIORITY #define LINUX32_SYS_AUE_linux_statfs AUE_STATFS #define LINUX32_SYS_AUE_linux_fstatfs AUE_FSTATFS #define LINUX32_SYS_AUE_linux_socketcall AUE_NULL #define LINUX32_SYS_AUE_linux_syslog AUE_NULL #define LINUX32_SYS_AUE_linux_setitimer AUE_SETITIMER #define LINUX32_SYS_AUE_linux_getitimer AUE_GETITIMER #define LINUX32_SYS_AUE_linux_newstat AUE_STAT #define LINUX32_SYS_AUE_linux_newlstat AUE_LSTAT #define LINUX32_SYS_AUE_linux_newfstat AUE_FSTAT #define LINUX32_SYS_AUE_linux_uname AUE_NULL #define LINUX32_SYS_AUE_linux_iopl AUE_NULL #define LINUX32_SYS_AUE_linux_vhangup AUE_NULL #define LINUX32_SYS_AUE_linux_wait4 AUE_WAIT4 #define LINUX32_SYS_AUE_linux_swapoff AUE_SWAPOFF #define LINUX32_SYS_AUE_linux_sysinfo AUE_NULL #define LINUX32_SYS_AUE_linux_ipc AUE_NULL #define LINUX32_SYS_AUE_linux_sigreturn AUE_SIGRETURN #define LINUX32_SYS_AUE_linux_clone AUE_RFORK #define LINUX32_SYS_AUE_linux_setdomainname AUE_SYSCTL #define LINUX32_SYS_AUE_linux_newuname AUE_NULL #define LINUX32_SYS_AUE_linux_adjtimex AUE_ADJTIME #define LINUX32_SYS_AUE_linux_mprotect AUE_MPROTECT #define LINUX32_SYS_AUE_linux_sigprocmask AUE_SIGPROCMASK #define LINUX32_SYS_AUE_linux_init_module AUE_NULL #define LINUX32_SYS_AUE_linux_delete_module AUE_NULL #define LINUX32_SYS_AUE_linux_quotactl AUE_QUOTACTL #define LINUX32_SYS_AUE_linux_bdflush AUE_BDFLUSH #define LINUX32_SYS_AUE_linux_sysfs AUE_NULL #define LINUX32_SYS_AUE_linux_personality AUE_PERSONALITY #define LINUX32_SYS_AUE_linux_setfsuid16 AUE_SETFSUID #define LINUX32_SYS_AUE_linux_setfsgid16 AUE_SETFSGID #define LINUX32_SYS_AUE_linux_llseek AUE_LSEEK #define LINUX32_SYS_AUE_linux_getdents AUE_GETDIRENTRIES #define LINUX32_SYS_AUE_linux_select AUE_SELECT #define LINUX32_SYS_AUE_linux_msync AUE_MSYNC #define LINUX32_SYS_AUE_linux_readv AUE_READV #define LINUX32_SYS_AUE_linux_writev AUE_WRITEV #define LINUX32_SYS_AUE_linux_getsid AUE_GETSID #define LINUX32_SYS_AUE_linux_fdatasync AUE_NULL #define LINUX32_SYS_AUE_linux_sysctl AUE_SYSCTL #define LINUX32_SYS_AUE_linux_sched_setparam AUE_SCHED_SETPARAM #define LINUX32_SYS_AUE_linux_sched_getparam AUE_SCHED_GETPARAM #define LINUX32_SYS_AUE_linux_sched_setscheduler AUE_SCHED_SETSCHEDULER #define LINUX32_SYS_AUE_linux_sched_getscheduler AUE_SCHED_GETSCHEDULER #define LINUX32_SYS_AUE_linux_sched_get_priority_max AUE_SCHED_GET_PRIORITY_MAX #define LINUX32_SYS_AUE_linux_sched_get_priority_min AUE_SCHED_GET_PRIORITY_MIN #define LINUX32_SYS_AUE_linux_sched_rr_get_interval AUE_SCHED_RR_GET_INTERVAL #define LINUX32_SYS_AUE_linux_nanosleep AUE_NULL #define LINUX32_SYS_AUE_linux_mremap AUE_NULL #define LINUX32_SYS_AUE_linux_setresuid16 AUE_SETRESUID #define LINUX32_SYS_AUE_linux_getresuid16 AUE_GETRESUID #define LINUX32_SYS_AUE_linux_setresgid16 AUE_SETRESGID #define LINUX32_SYS_AUE_linux_getresgid16 AUE_GETRESGID #define LINUX32_SYS_AUE_linux_prctl AUE_PRCTL #define LINUX32_SYS_AUE_linux_rt_sigreturn AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigaction AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigprocmask AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigpending AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigtimedwait AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigqueueinfo AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigsuspend AUE_NULL #define LINUX32_SYS_AUE_linux_pread AUE_PREAD #define LINUX32_SYS_AUE_linux_pwrite AUE_PWRITE #define LINUX32_SYS_AUE_linux_chown16 AUE_CHOWN #define LINUX32_SYS_AUE_linux_getcwd AUE_GETCWD #define LINUX32_SYS_AUE_linux_capget AUE_CAPGET #define LINUX32_SYS_AUE_linux_capset AUE_CAPSET #define LINUX32_SYS_AUE_linux_sigaltstack AUE_NULL #define LINUX32_SYS_AUE_linux_sendfile AUE_SENDFILE #define LINUX32_SYS_AUE_linux_vfork AUE_VFORK #define LINUX32_SYS_AUE_linux_getrlimit AUE_GETRLIMIT #define LINUX32_SYS_AUE_linux_mmap2 AUE_MMAP #define LINUX32_SYS_AUE_linux_truncate64 AUE_TRUNCATE #define LINUX32_SYS_AUE_linux_ftruncate64 AUE_FTRUNCATE #define LINUX32_SYS_AUE_linux_stat64 AUE_STAT #define LINUX32_SYS_AUE_linux_lstat64 AUE_LSTAT #define LINUX32_SYS_AUE_linux_fstat64 AUE_FSTAT #define LINUX32_SYS_AUE_linux_lchown AUE_LCHOWN #define LINUX32_SYS_AUE_linux_getuid AUE_GETUID #define LINUX32_SYS_AUE_linux_getgid AUE_GETGID #define LINUX32_SYS_AUE_linux_getgroups AUE_GETGROUPS #define LINUX32_SYS_AUE_linux_setgroups AUE_SETGROUPS #define LINUX32_SYS_AUE_linux_chown AUE_CHOWN #define LINUX32_SYS_AUE_linux_setfsuid AUE_SETFSUID #define LINUX32_SYS_AUE_linux_setfsgid AUE_SETFSGID #define LINUX32_SYS_AUE_linux_pivot_root AUE_PIVOT_ROOT #define LINUX32_SYS_AUE_linux_mincore AUE_MINCORE #define LINUX32_SYS_AUE_linux_getdents64 AUE_GETDIRENTRIES #define LINUX32_SYS_AUE_linux_fcntl64 AUE_FCNTL #define LINUX32_SYS_AUE_linux_gettid AUE_NULL #define LINUX32_SYS_AUE_linux_setxattr AUE_NULL #define LINUX32_SYS_AUE_linux_lsetxattr AUE_NULL #define LINUX32_SYS_AUE_linux_fsetxattr AUE_NULL #define LINUX32_SYS_AUE_linux_getxattr AUE_NULL #define LINUX32_SYS_AUE_linux_lgetxattr AUE_NULL #define LINUX32_SYS_AUE_linux_fgetxattr AUE_NULL #define LINUX32_SYS_AUE_linux_listxattr AUE_NULL #define LINUX32_SYS_AUE_linux_llistxattr AUE_NULL #define LINUX32_SYS_AUE_linux_flistxattr AUE_NULL #define LINUX32_SYS_AUE_linux_removexattr AUE_NULL #define LINUX32_SYS_AUE_linux_lremovexattr AUE_NULL #define LINUX32_SYS_AUE_linux_fremovexattr AUE_NULL #define LINUX32_SYS_AUE_linux_tkill AUE_NULL #define LINUX32_SYS_AUE_linux_sys_futex AUE_NULL #define LINUX32_SYS_AUE_linux_sched_setaffinity AUE_NULL #define LINUX32_SYS_AUE_linux_sched_getaffinity AUE_NULL #define LINUX32_SYS_AUE_linux_set_thread_area AUE_NULL #define LINUX32_SYS_AUE_linux_fadvise64 AUE_NULL #define LINUX32_SYS_AUE_linux_exit_group AUE_EXIT #define LINUX32_SYS_AUE_linux_lookup_dcookie AUE_NULL #define LINUX32_SYS_AUE_linux_epoll_create AUE_NULL #define LINUX32_SYS_AUE_linux_epoll_ctl AUE_NULL #define LINUX32_SYS_AUE_linux_epoll_wait AUE_NULL #define LINUX32_SYS_AUE_linux_remap_file_pages AUE_NULL #define LINUX32_SYS_AUE_linux_set_tid_address AUE_NULL #define LINUX32_SYS_AUE_linux_timer_create AUE_NULL #define LINUX32_SYS_AUE_linux_timer_settime AUE_NULL #define LINUX32_SYS_AUE_linux_timer_gettime AUE_NULL #define LINUX32_SYS_AUE_linux_timer_getoverrun AUE_NULL #define LINUX32_SYS_AUE_linux_timer_delete AUE_NULL #define LINUX32_SYS_AUE_linux_clock_settime AUE_CLOCK_SETTIME #define LINUX32_SYS_AUE_linux_clock_gettime AUE_NULL #define LINUX32_SYS_AUE_linux_clock_getres AUE_NULL #define LINUX32_SYS_AUE_linux_clock_nanosleep AUE_NULL #define LINUX32_SYS_AUE_linux_statfs64 AUE_STATFS #define LINUX32_SYS_AUE_linux_fstatfs64 AUE_FSTATFS #define LINUX32_SYS_AUE_linux_tgkill AUE_NULL #define LINUX32_SYS_AUE_linux_utimes AUE_UTIMES #define LINUX32_SYS_AUE_linux_fadvise64_64 AUE_NULL #define LINUX32_SYS_AUE_linux_mbind AUE_NULL #define LINUX32_SYS_AUE_linux_get_mempolicy AUE_NULL #define LINUX32_SYS_AUE_linux_set_mempolicy AUE_NULL #define LINUX32_SYS_AUE_linux_mq_open AUE_NULL #define LINUX32_SYS_AUE_linux_mq_unlink AUE_NULL #define LINUX32_SYS_AUE_linux_mq_timedsend AUE_NULL #define LINUX32_SYS_AUE_linux_mq_timedreceive AUE_NULL #define LINUX32_SYS_AUE_linux_mq_notify AUE_NULL #define LINUX32_SYS_AUE_linux_mq_getsetattr AUE_NULL #define LINUX32_SYS_AUE_linux_kexec_load AUE_NULL #define LINUX32_SYS_AUE_linux_waitid AUE_WAIT6 #define LINUX32_SYS_AUE_linux_add_key AUE_NULL #define LINUX32_SYS_AUE_linux_request_key AUE_NULL #define LINUX32_SYS_AUE_linux_keyctl AUE_NULL #define LINUX32_SYS_AUE_linux_ioprio_set AUE_NULL #define LINUX32_SYS_AUE_linux_ioprio_get AUE_NULL #define LINUX32_SYS_AUE_linux_inotify_init AUE_NULL #define LINUX32_SYS_AUE_linux_inotify_add_watch AUE_NULL #define LINUX32_SYS_AUE_linux_inotify_rm_watch AUE_NULL #define LINUX32_SYS_AUE_linux_migrate_pages AUE_NULL #define LINUX32_SYS_AUE_linux_openat AUE_OPEN_RWTC #define LINUX32_SYS_AUE_linux_mkdirat AUE_MKDIRAT #define LINUX32_SYS_AUE_linux_mknodat AUE_MKNODAT #define LINUX32_SYS_AUE_linux_fchownat AUE_FCHOWNAT #define LINUX32_SYS_AUE_linux_futimesat AUE_FUTIMESAT #define LINUX32_SYS_AUE_linux_fstatat64 AUE_FSTATAT #define LINUX32_SYS_AUE_linux_unlinkat AUE_UNLINKAT #define LINUX32_SYS_AUE_linux_renameat AUE_RENAMEAT #define LINUX32_SYS_AUE_linux_linkat AUE_LINKAT #define LINUX32_SYS_AUE_linux_symlinkat AUE_SYMLINKAT #define LINUX32_SYS_AUE_linux_readlinkat AUE_READLINKAT #define LINUX32_SYS_AUE_linux_fchmodat AUE_FCHMODAT #define LINUX32_SYS_AUE_linux_faccessat AUE_FACCESSAT #define LINUX32_SYS_AUE_linux_pselect6 AUE_SELECT #define LINUX32_SYS_AUE_linux_ppoll AUE_POLL #define LINUX32_SYS_AUE_linux_unshare AUE_NULL #define LINUX32_SYS_AUE_linux_set_robust_list AUE_NULL #define LINUX32_SYS_AUE_linux_get_robust_list AUE_NULL #define LINUX32_SYS_AUE_linux_splice AUE_NULL #define LINUX32_SYS_AUE_linux_sync_file_range AUE_NULL #define LINUX32_SYS_AUE_linux_tee AUE_NULL #define LINUX32_SYS_AUE_linux_vmsplice AUE_NULL #define LINUX32_SYS_AUE_linux_move_pages AUE_NULL #define LINUX32_SYS_AUE_linux_getcpu AUE_NULL #define LINUX32_SYS_AUE_linux_epoll_pwait AUE_NULL #define LINUX32_SYS_AUE_linux_utimensat AUE_FUTIMESAT #define LINUX32_SYS_AUE_linux_signalfd AUE_NULL #define LINUX32_SYS_AUE_linux_timerfd_create AUE_NULL #define LINUX32_SYS_AUE_linux_eventfd AUE_NULL #define LINUX32_SYS_AUE_linux_fallocate AUE_NULL #define LINUX32_SYS_AUE_linux_timerfd_settime AUE_NULL #define LINUX32_SYS_AUE_linux_timerfd_gettime AUE_NULL #define LINUX32_SYS_AUE_linux_signalfd4 AUE_NULL #define LINUX32_SYS_AUE_linux_eventfd2 AUE_NULL #define LINUX32_SYS_AUE_linux_epoll_create1 AUE_NULL #define LINUX32_SYS_AUE_linux_dup3 AUE_NULL #define LINUX32_SYS_AUE_linux_pipe2 AUE_NULL #define LINUX32_SYS_AUE_linux_inotify_init1 AUE_NULL #define LINUX32_SYS_AUE_linux_preadv AUE_NULL #define LINUX32_SYS_AUE_linux_pwritev AUE_NULL #define LINUX32_SYS_AUE_linux_rt_tgsigqueueinfo AUE_NULL #define LINUX32_SYS_AUE_linux_perf_event_open AUE_NULL #define LINUX32_SYS_AUE_linux_recvmmsg AUE_NULL #define LINUX32_SYS_AUE_linux_fanotify_init AUE_NULL #define LINUX32_SYS_AUE_linux_fanotify_mark AUE_NULL #define LINUX32_SYS_AUE_linux_prlimit64 AUE_NULL #define LINUX32_SYS_AUE_linux_name_to_handle_at AUE_NULL #define LINUX32_SYS_AUE_linux_open_by_handle_at AUE_NULL #define LINUX32_SYS_AUE_linux_clock_adjtime AUE_NULL #define LINUX32_SYS_AUE_linux_syncfs AUE_SYNC #define LINUX32_SYS_AUE_linux_sendmmsg AUE_NULL #define LINUX32_SYS_AUE_linux_setns AUE_NULL #define LINUX32_SYS_AUE_linux_process_vm_readv AUE_NULL #define LINUX32_SYS_AUE_linux_process_vm_writev AUE_NULL #define LINUX32_SYS_AUE_linux_kcmp AUE_NULL #define LINUX32_SYS_AUE_linux_finit_module AUE_NULL #define LINUX32_SYS_AUE_linux_sched_setattr AUE_NULL #define LINUX32_SYS_AUE_linux_sched_getattr AUE_NULL #define LINUX32_SYS_AUE_linux_renameat2 AUE_NULL #define LINUX32_SYS_AUE_linux_seccomp AUE_NULL #define LINUX32_SYS_AUE_linux_getrandom AUE_NULL #define LINUX32_SYS_AUE_linux_memfd_create AUE_NULL #define LINUX32_SYS_AUE_linux_bpf AUE_NULL #define LINUX32_SYS_AUE_linux_execveat AUE_NULL #define LINUX32_SYS_AUE_linux_socket AUE_SOCKET #define LINUX32_SYS_AUE_linux_socketpair AUE_SOCKETPAIR #define LINUX32_SYS_AUE_linux_bind AUE_BIND #define LINUX32_SYS_AUE_linux_connect AUE_CONNECT #define LINUX32_SYS_AUE_linux_listen AUE_LISTEN #define LINUX32_SYS_AUE_linux_accept4 AUE_ACCEPT #define LINUX32_SYS_AUE_linux_getsockopt AUE_GETSOCKOPT #define LINUX32_SYS_AUE_linux_setsockopt AUE_SETSOCKOPT #define LINUX32_SYS_AUE_linux_getsockname AUE_GETSOCKNAME #define LINUX32_SYS_AUE_linux_getpeername AUE_GETPEERNAME #define LINUX32_SYS_AUE_linux_sendto AUE_SENDTO #define LINUX32_SYS_AUE_linux_sendmsg AUE_SENDMSG #define LINUX32_SYS_AUE_linux_recvfrom AUE_RECVFROM #define LINUX32_SYS_AUE_linux_recvmsg AUE_RECVMSG #define LINUX32_SYS_AUE_linux_shutdown AUE_NULL #define LINUX32_SYS_AUE_linux_userfaultfd AUE_NULL #define LINUX32_SYS_AUE_linux_membarrier AUE_NULL #define LINUX32_SYS_AUE_linux_mlock2 AUE_NULL #define LINUX32_SYS_AUE_linux_copy_file_range AUE_NULL #define LINUX32_SYS_AUE_linux_preadv2 AUE_NULL #define LINUX32_SYS_AUE_linux_pwritev2 AUE_NULL #define LINUX32_SYS_AUE_linux_pkey_mprotect AUE_NULL #define LINUX32_SYS_AUE_linux_pkey_alloc AUE_NULL #define LINUX32_SYS_AUE_linux_pkey_free AUE_NULL #define LINUX32_SYS_AUE_linux_statx AUE_NULL #define LINUX32_SYS_AUE_linux_arch_prctl AUE_NULL #define LINUX32_SYS_AUE_linux_io_pgetevents AUE_NULL #define LINUX32_SYS_AUE_linux_rseq AUE_NULL #define LINUX32_SYS_AUE_linux_semget AUE_NULL #define LINUX32_SYS_AUE_linux_semctl AUE_NULL #define LINUX32_SYS_AUE_linux_shmget AUE_NULL #define LINUX32_SYS_AUE_linux_shmctl AUE_NULL #define LINUX32_SYS_AUE_linux_shmat AUE_NULL #define LINUX32_SYS_AUE_linux_shmdt AUE_NULL #define LINUX32_SYS_AUE_linux_msgget AUE_NULL #define LINUX32_SYS_AUE_linux_msgsnd AUE_NULL #define LINUX32_SYS_AUE_linux_msgrcv AUE_NULL #define LINUX32_SYS_AUE_linux_msgctl AUE_NULL #define LINUX32_SYS_AUE_linux_clock_gettime64 AUE_NULL #define LINUX32_SYS_AUE_linux_clock_settime64 AUE_NULL #define LINUX32_SYS_AUE_linux_clock_adjtime64 AUE_NULL #define LINUX32_SYS_AUE_linux_clock_getres_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_clock_nanosleep_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_timer_gettime64 AUE_NULL #define LINUX32_SYS_AUE_linux_timer_settime64 AUE_NULL #define LINUX32_SYS_AUE_linux_timerfd_gettime64 AUE_NULL #define LINUX32_SYS_AUE_linux_timerfd_settime64 AUE_NULL #define LINUX32_SYS_AUE_linux_utimensat_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_pselect6_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_ppoll_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_io_pgetevents_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_recvmmsg_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_mq_timedsend_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_mq_timedreceive_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_semtimedop_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_rt_sigtimedwait_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_futex_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_sched_rr_get_interval_time64 AUE_NULL #define LINUX32_SYS_AUE_linux_pidfd_send_signal AUE_NULL #define LINUX32_SYS_AUE_linux_io_uring_setup AUE_NULL #define LINUX32_SYS_AUE_linux_io_uring_enter AUE_NULL #define LINUX32_SYS_AUE_linux_io_uring_register AUE_NULL #undef PAD_ #undef PADL_ #undef PADR_ #endif /* !_LINUX32_SYSPROTO_H_ */ Index: stable/12/sys/amd64/linux32/linux32_systrace_args.c =================================================================== --- stable/12/sys/amd64/linux32/linux32_systrace_args.c (revision 359604) +++ stable/12/sys/amd64/linux32/linux32_systrace_args.c (revision 359605) @@ -1,9099 +1,9143 @@ /* * System call argument to DTrace register array converstion. * * DO NOT EDIT-- this file is automatically @generated. * $FreeBSD$ * This file is part of the DTrace syscall provider. */ static void systrace_args(int sysnum, void *params, uint64_t *uarg, int *n_args) { int64_t *iarg = (int64_t *) uarg; switch (sysnum) { #define nosys linux_nosys /* linux_exit */ case 1: { struct linux_exit_args *p = params; iarg[0] = p->rval; /* int */ *n_args = 1; break; } /* linux_fork */ case 2: { *n_args = 0; break; } /* read */ case 3: { struct read_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t) p->buf; /* char * */ uarg[2] = p->nbyte; /* u_int */ *n_args = 3; break; } /* write */ case 4: { struct write_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t) p->buf; /* char * */ uarg[2] = p->nbyte; /* u_int */ *n_args = 3; break; } /* linux_open */ case 5: { struct linux_open_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->flags; /* l_int */ iarg[2] = p->mode; /* l_int */ *n_args = 3; break; } /* close */ case 6: { struct close_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* linux_waitpid */ case 7: { struct linux_waitpid_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->status; /* l_int * */ iarg[2] = p->options; /* l_int */ *n_args = 3; break; } /* linux_creat */ case 8: { struct linux_creat_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->mode; /* l_int */ *n_args = 2; break; } /* linux_link */ case 9: { struct linux_link_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->to; /* char * */ *n_args = 2; break; } /* linux_unlink */ case 10: { struct linux_unlink_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* linux_execve */ case 11: { struct linux_execve_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->argp; /* uint32_t * */ uarg[2] = (intptr_t) p->envp; /* uint32_t * */ *n_args = 3; break; } /* linux_chdir */ case 12: { struct linux_chdir_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* linux_time */ case 13: { struct linux_time_args *p = params; uarg[0] = (intptr_t) p->tm; /* l_time_t * */ *n_args = 1; break; } /* linux_mknod */ case 14: { struct linux_mknod_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->mode; /* l_int */ iarg[2] = p->dev; /* l_dev_t */ *n_args = 3; break; } /* linux_chmod */ case 15: { struct linux_chmod_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->mode; /* l_mode_t */ *n_args = 2; break; } /* linux_lchown16 */ case 16: { struct linux_lchown16_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->uid; /* l_uid16_t */ iarg[2] = p->gid; /* l_gid16_t */ *n_args = 3; break; } /* linux_stat */ case 18: { struct linux_stat_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->up; /* struct linux_stat * */ *n_args = 2; break; } /* linux_lseek */ case 19: { struct linux_lseek_args *p = params; iarg[0] = p->fdes; /* l_uint */ iarg[1] = p->off; /* l_off_t */ iarg[2] = p->whence; /* l_int */ *n_args = 3; break; } /* linux_getpid */ case 20: { *n_args = 0; break; } /* linux_mount */ case 21: { struct linux_mount_args *p = params; uarg[0] = (intptr_t) p->specialfile; /* char * */ uarg[1] = (intptr_t) p->dir; /* char * */ uarg[2] = (intptr_t) p->filesystemtype; /* char * */ iarg[3] = p->rwflag; /* l_ulong */ uarg[4] = (intptr_t) p->data; /* void * */ *n_args = 5; break; } /* linux_oldumount */ case 22: { struct linux_oldumount_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* linux_setuid16 */ case 23: { struct linux_setuid16_args *p = params; iarg[0] = p->uid; /* l_uid16_t */ *n_args = 1; break; } /* linux_getuid16 */ case 24: { *n_args = 0; break; } /* linux_stime */ case 25: { *n_args = 0; break; } /* linux_ptrace */ case 26: { struct linux_ptrace_args *p = params; iarg[0] = p->req; /* l_long */ iarg[1] = p->pid; /* l_long */ iarg[2] = p->addr; /* l_long */ iarg[3] = p->data; /* l_long */ *n_args = 4; break; } /* linux_alarm */ case 27: { struct linux_alarm_args *p = params; iarg[0] = 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[0] = (intptr_t) p->fname; /* char * */ uarg[1] = (intptr_t) p->times; /* struct l_utimbuf * */ *n_args = 2; break; } /* linux_access */ case 33: { struct linux_access_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->amode; /* l_int */ *n_args = 2; break; } /* linux_nice */ case 34: { struct linux_nice_args *p = params; iarg[0] = p->inc; /* l_int */ *n_args = 1; break; } /* sync */ case 36: { *n_args = 0; break; } /* linux_kill */ case 37: { struct linux_kill_args *p = params; iarg[0] = p->pid; /* l_int */ iarg[1] = p->signum; /* l_int */ *n_args = 2; break; } /* linux_rename */ case 38: { struct linux_rename_args *p = params; uarg[0] = (intptr_t) p->from; /* char * */ uarg[1] = (intptr_t) p->to; /* char * */ *n_args = 2; break; } /* linux_mkdir */ case 39: { struct linux_mkdir_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->mode; /* l_int */ *n_args = 2; break; } /* linux_rmdir */ case 40: { struct linux_rmdir_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* dup */ case 41: { struct dup_args *p = params; uarg[0] = p->fd; /* u_int */ *n_args = 1; break; } /* linux_pipe */ case 42: { struct linux_pipe_args *p = params; uarg[0] = (intptr_t) p->pipefds; /* l_int * */ *n_args = 1; break; } /* linux_times */ case 43: { struct linux_times_args *p = params; uarg[0] = (intptr_t) p->buf; /* struct l_times_argv * */ *n_args = 1; break; } /* linux_brk */ case 45: { struct linux_brk_args *p = params; iarg[0] = p->dsend; /* l_ulong */ *n_args = 1; break; } /* linux_setgid16 */ case 46: { struct linux_setgid16_args *p = params; iarg[0] = p->gid; /* l_gid16_t */ *n_args = 1; break; } /* linux_getgid16 */ case 47: { *n_args = 0; break; } /* linux_signal */ case 48: { struct linux_signal_args *p = params; iarg[0] = p->sig; /* l_int */ iarg[1] = p->handler; /* l_handler_t */ *n_args = 2; break; } /* linux_geteuid16 */ case 49: { *n_args = 0; break; } /* linux_getegid16 */ case 50: { *n_args = 0; break; } /* acct */ case 51: { struct acct_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* linux_umount */ case 52: { struct linux_umount_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->flags; /* l_int */ *n_args = 2; break; } /* linux_ioctl */ case 54: { struct linux_ioctl_args *p = params; iarg[0] = p->fd; /* l_uint */ iarg[1] = p->cmd; /* l_uint */ uarg[2] = p->arg; /* uintptr_t */ *n_args = 3; break; } /* linux_fcntl */ case 55: { struct linux_fcntl_args *p = params; iarg[0] = p->fd; /* l_uint */ iarg[1] = p->cmd; /* l_uint */ uarg[2] = p->arg; /* uintptr_t */ *n_args = 3; break; } /* setpgid */ case 57: { struct setpgid_args *p = params; iarg[0] = p->pid; /* int */ iarg[1] = p->pgid; /* int */ *n_args = 2; break; } /* linux_olduname */ case 59: { *n_args = 0; break; } /* umask */ case 60: { struct umask_args *p = params; iarg[0] = p->newmask; /* int */ *n_args = 1; break; } /* chroot */ case 61: { struct chroot_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ *n_args = 1; break; } /* linux_ustat */ case 62: { struct linux_ustat_args *p = params; iarg[0] = p->dev; /* l_dev_t */ uarg[1] = (intptr_t) p->ubuf; /* struct l_ustat * */ *n_args = 2; break; } /* dup2 */ case 63: { struct dup2_args *p = params; uarg[0] = p->from; /* u_int */ uarg[1] = 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; } /* linux_sigaction */ case 67: { struct linux_sigaction_args *p = params; iarg[0] = p->sig; /* l_int */ uarg[1] = (intptr_t) p->nsa; /* l_osigaction_t * */ uarg[2] = (intptr_t) p->osa; /* l_osigaction_t * */ *n_args = 3; break; } /* linux_sgetmask */ case 68: { *n_args = 0; break; } /* linux_ssetmask */ case 69: { struct linux_ssetmask_args *p = params; iarg[0] = p->mask; /* l_osigset_t */ *n_args = 1; break; } /* linux_setreuid16 */ case 70: { struct linux_setreuid16_args *p = params; iarg[0] = p->ruid; /* l_uid16_t */ iarg[1] = p->euid; /* l_uid16_t */ *n_args = 2; break; } /* linux_setregid16 */ case 71: { struct linux_setregid16_args *p = params; iarg[0] = p->rgid; /* l_gid16_t */ iarg[1] = p->egid; /* l_gid16_t */ *n_args = 2; break; } /* linux_sigsuspend */ case 72: { struct linux_sigsuspend_args *p = params; iarg[0] = p->hist0; /* l_int */ iarg[1] = p->hist1; /* l_int */ iarg[2] = p->mask; /* l_osigset_t */ *n_args = 3; break; } /* linux_sigpending */ case 73: { struct linux_sigpending_args *p = params; uarg[0] = (intptr_t) p->mask; /* l_osigset_t * */ *n_args = 1; break; } /* linux_sethostname */ case 74: { struct linux_sethostname_args *p = params; uarg[0] = (intptr_t) p->hostname; /* char * */ uarg[1] = p->len; /* u_int */ *n_args = 2; break; } /* linux_setrlimit */ case 75: { struct linux_setrlimit_args *p = params; iarg[0] = p->resource; /* l_uint */ uarg[1] = (intptr_t) p->rlim; /* struct l_rlimit * */ *n_args = 2; break; } /* linux_old_getrlimit */ case 76: { struct linux_old_getrlimit_args *p = params; iarg[0] = p->resource; /* l_uint */ uarg[1] = (intptr_t) p->rlim; /* struct l_rlimit * */ *n_args = 2; break; } /* linux_getrusage */ case 77: { struct linux_getrusage_args *p = params; iarg[0] = p->who; /* int */ uarg[1] = (intptr_t) p->rusage; /* struct l_rusage * */ *n_args = 2; break; } /* linux_gettimeofday */ case 78: { struct linux_gettimeofday_args *p = params; uarg[0] = (intptr_t) p->tp; /* struct l_timeval * */ uarg[1] = (intptr_t) p->tzp; /* struct timezone * */ *n_args = 2; break; } /* linux_settimeofday */ case 79: { struct linux_settimeofday_args *p = params; uarg[0] = (intptr_t) p->tp; /* struct l_timeval * */ uarg[1] = (intptr_t) p->tzp; /* struct timezone * */ *n_args = 2; break; } /* linux_getgroups16 */ case 80: { struct linux_getgroups16_args *p = params; iarg[0] = p->gidsetsize; /* l_uint */ uarg[1] = (intptr_t) p->gidset; /* l_gid16_t * */ *n_args = 2; break; } /* linux_setgroups16 */ case 81: { struct linux_setgroups16_args *p = params; iarg[0] = p->gidsetsize; /* l_uint */ uarg[1] = (intptr_t) p->gidset; /* l_gid16_t * */ *n_args = 2; break; } /* linux_old_select */ case 82: { struct linux_old_select_args *p = params; uarg[0] = (intptr_t) p->ptr; /* struct l_old_select_argv * */ *n_args = 1; break; } /* linux_symlink */ case 83: { struct linux_symlink_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->to; /* char * */ *n_args = 2; break; } /* linux_lstat */ case 84: { struct linux_lstat_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->up; /* struct linux_lstat * */ *n_args = 2; break; } /* linux_readlink */ case 85: { struct linux_readlink_args *p = params; uarg[0] = (intptr_t) p->name; /* char * */ uarg[1] = (intptr_t) p->buf; /* char * */ iarg[2] = p->count; /* l_int */ *n_args = 3; break; } /* swapon */ case 87: { struct swapon_args *p = params; uarg[0] = (intptr_t) p->name; /* char * */ *n_args = 1; break; } /* linux_reboot */ case 88: { struct linux_reboot_args *p = params; iarg[0] = p->magic1; /* l_int */ iarg[1] = p->magic2; /* l_int */ iarg[2] = p->cmd; /* l_uint */ uarg[3] = (intptr_t) p->arg; /* void * */ *n_args = 4; break; } /* linux_readdir */ case 89: { struct linux_readdir_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->dent; /* struct l_dirent * */ iarg[2] = p->count; /* l_uint */ *n_args = 3; break; } /* linux_mmap */ case 90: { struct linux_mmap_args *p = params; uarg[0] = (intptr_t) p->ptr; /* struct l_mmap_argv * */ *n_args = 1; break; } /* munmap */ case 91: { struct munmap_args *p = params; uarg[0] = (intptr_t) p->addr; /* caddr_t */ iarg[1] = p->len; /* int */ *n_args = 2; break; } /* linux_truncate */ case 92: { struct linux_truncate_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->length; /* l_ulong */ *n_args = 2; break; } /* linux_ftruncate */ case 93: { struct linux_ftruncate_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->length; /* long */ *n_args = 2; break; } /* fchmod */ case 94: { struct fchmod_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->mode; /* int */ *n_args = 2; break; } /* fchown */ case 95: { struct fchown_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->uid; /* int */ iarg[2] = p->gid; /* int */ *n_args = 3; break; } /* linux_getpriority */ case 96: { struct linux_getpriority_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->who; /* int */ *n_args = 2; break; } /* setpriority */ case 97: { struct setpriority_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->who; /* int */ iarg[2] = p->prio; /* int */ *n_args = 3; break; } /* linux_statfs */ case 99: { struct linux_statfs_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->buf; /* struct l_statfs_buf * */ *n_args = 2; break; } /* linux_fstatfs */ case 100: { struct linux_fstatfs_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->buf; /* struct l_statfs_buf * */ *n_args = 2; break; } /* linux_socketcall */ case 102: { struct linux_socketcall_args *p = params; iarg[0] = p->what; /* l_int */ iarg[1] = p->args; /* l_ulong */ *n_args = 2; break; } /* linux_syslog */ case 103: { struct linux_syslog_args *p = params; iarg[0] = p->type; /* l_int */ uarg[1] = (intptr_t) p->buf; /* char * */ iarg[2] = p->len; /* l_int */ *n_args = 3; break; } /* linux_setitimer */ case 104: { struct linux_setitimer_args *p = params; iarg[0] = p->which; /* l_int */ uarg[1] = (intptr_t) p->itv; /* struct l_itimerval * */ uarg[2] = (intptr_t) p->oitv; /* struct l_itimerval * */ *n_args = 3; break; } /* linux_getitimer */ case 105: { struct linux_getitimer_args *p = params; iarg[0] = p->which; /* l_int */ uarg[1] = (intptr_t) p->itv; /* struct l_itimerval * */ *n_args = 2; break; } /* linux_newstat */ case 106: { struct linux_newstat_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */ *n_args = 2; break; } /* linux_newlstat */ case 107: { struct linux_newlstat_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */ *n_args = 2; break; } /* linux_newfstat */ case 108: { struct linux_newfstat_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->buf; /* struct l_newstat * */ *n_args = 2; break; } /* linux_uname */ case 109: { *n_args = 0; break; } /* linux_iopl */ case 110: { struct linux_iopl_args *p = params; iarg[0] = p->level; /* l_int */ *n_args = 1; break; } /* linux_vhangup */ case 111: { *n_args = 0; break; } /* linux_wait4 */ case 114: { struct linux_wait4_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->status; /* l_int * */ iarg[2] = p->options; /* l_int */ uarg[3] = (intptr_t) p->rusage; /* struct l_rusage * */ *n_args = 4; break; } /* linux_swapoff */ case 115: { *n_args = 0; break; } /* linux_sysinfo */ case 116: { struct linux_sysinfo_args *p = params; uarg[0] = (intptr_t) p->info; /* struct l_sysinfo * */ *n_args = 1; break; } /* linux_ipc */ case 117: { struct linux_ipc_args *p = params; iarg[0] = p->what; /* l_uint */ iarg[1] = p->arg1; /* l_int */ iarg[2] = p->arg2; /* l_int */ iarg[3] = p->arg3; /* l_uint */ iarg[4] = p->ptr; /* l_uintptr_t */ iarg[5] = p->arg5; /* l_uint */ *n_args = 6; break; } /* fsync */ case 118: { struct fsync_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* linux_sigreturn */ case 119: { struct linux_sigreturn_args *p = params; uarg[0] = (intptr_t) p->sfp; /* struct l_sigframe * */ *n_args = 1; break; } /* linux_clone */ case 120: { struct linux_clone_args *p = params; iarg[0] = p->flags; /* l_int */ uarg[1] = (intptr_t) p->stack; /* void * */ uarg[2] = (intptr_t) p->parent_tidptr; /* void * */ uarg[3] = (intptr_t) p->tls; /* void * */ uarg[4] = (intptr_t) p->child_tidptr; /* void * */ *n_args = 5; break; } /* linux_setdomainname */ case 121: { struct linux_setdomainname_args *p = params; uarg[0] = (intptr_t) p->name; /* char * */ iarg[1] = p->len; /* int */ *n_args = 2; break; } /* linux_newuname */ case 122: { struct linux_newuname_args *p = params; uarg[0] = (intptr_t) p->buf; /* struct l_new_utsname * */ *n_args = 1; break; } /* linux_adjtimex */ case 124: { *n_args = 0; break; } /* linux_mprotect */ case 125: { struct linux_mprotect_args *p = params; uarg[0] = (intptr_t) p->addr; /* caddr_t */ iarg[1] = p->len; /* int */ iarg[2] = p->prot; /* int */ *n_args = 3; break; } /* linux_sigprocmask */ case 126: { struct linux_sigprocmask_args *p = params; iarg[0] = p->how; /* l_int */ uarg[1] = (intptr_t) p->mask; /* l_osigset_t * */ uarg[2] = (intptr_t) p->omask; /* l_osigset_t * */ *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[0] = p->pid; /* int */ *n_args = 1; break; } /* fchdir */ case 133: { struct fchdir_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* linux_bdflush */ case 134: { *n_args = 0; break; } /* linux_sysfs */ case 135: { struct linux_sysfs_args *p = params; iarg[0] = p->option; /* l_int */ iarg[1] = p->arg1; /* l_ulong */ iarg[2] = p->arg2; /* l_ulong */ *n_args = 3; break; } /* linux_personality */ case 136: { struct linux_personality_args *p = params; iarg[0] = p->per; /* l_uint */ *n_args = 1; break; } /* linux_setfsuid16 */ case 138: { struct linux_setfsuid16_args *p = params; iarg[0] = p->uid; /* l_uid16_t */ *n_args = 1; break; } /* linux_setfsgid16 */ case 139: { struct linux_setfsgid16_args *p = params; iarg[0] = p->gid; /* l_gid16_t */ *n_args = 1; break; } /* linux_llseek */ case 140: { struct linux_llseek_args *p = params; iarg[0] = p->fd; /* l_int */ iarg[1] = p->ohigh; /* l_ulong */ iarg[2] = p->olow; /* l_ulong */ uarg[3] = (intptr_t) p->res; /* l_loff_t * */ iarg[4] = p->whence; /* l_uint */ *n_args = 5; break; } /* linux_getdents */ case 141: { struct linux_getdents_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->dent; /* void * */ iarg[2] = p->count; /* l_uint */ *n_args = 3; break; } /* linux_select */ case 142: { struct linux_select_args *p = params; iarg[0] = p->nfds; /* l_int */ uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */ uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */ uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */ uarg[4] = (intptr_t) p->timeout; /* struct l_timeval * */ *n_args = 5; break; } /* flock */ case 143: { struct flock_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->how; /* int */ *n_args = 2; break; } /* linux_msync */ case 144: { struct linux_msync_args *p = params; iarg[0] = p->addr; /* l_ulong */ iarg[1] = p->len; /* l_size_t */ iarg[2] = p->fl; /* l_int */ *n_args = 3; break; } /* linux_readv */ case 145: { struct linux_readv_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->iovp; /* struct l_iovec32 * */ iarg[2] = p->iovcnt; /* l_ulong */ *n_args = 3; break; } /* linux_writev */ case 146: { struct linux_writev_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->iovp; /* struct l_iovec32 * */ iarg[2] = p->iovcnt; /* l_ulong */ *n_args = 3; break; } /* linux_getsid */ case 147: { struct linux_getsid_args *p = params; iarg[0] = p->pid; /* l_pid_t */ *n_args = 1; break; } /* linux_fdatasync */ case 148: { struct linux_fdatasync_args *p = params; iarg[0] = p->fd; /* l_uint */ *n_args = 1; break; } /* linux_sysctl */ case 149: { struct linux_sysctl_args *p = params; uarg[0] = (intptr_t) p->args; /* struct l___sysctl_args * */ *n_args = 1; break; } /* mlock */ case 150: { struct mlock_args *p = params; uarg[0] = (intptr_t) p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ *n_args = 2; break; } /* munlock */ case 151: { struct munlock_args *p = params; uarg[0] = (intptr_t) p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ *n_args = 2; break; } /* mlockall */ case 152: { struct mlockall_args *p = params; iarg[0] = 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[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->param; /* struct sched_param * */ *n_args = 2; break; } /* linux_sched_getparam */ case 155: { struct linux_sched_getparam_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->param; /* struct sched_param * */ *n_args = 2; break; } /* linux_sched_setscheduler */ case 156: { struct linux_sched_setscheduler_args *p = params; iarg[0] = p->pid; /* l_pid_t */ iarg[1] = p->policy; /* l_int */ uarg[2] = (intptr_t) p->param; /* struct sched_param * */ *n_args = 3; break; } /* linux_sched_getscheduler */ case 157: { struct linux_sched_getscheduler_args *p = params; iarg[0] = 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[0] = 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[0] = 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[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->interval; /* struct l_timespec * */ *n_args = 2; break; } /* linux_nanosleep */ case 162: { struct linux_nanosleep_args *p = params; uarg[0] = (intptr_t) p->rqtp; /* const struct l_timespec * */ uarg[1] = (intptr_t) p->rmtp; /* struct l_timespec * */ *n_args = 2; break; } /* linux_mremap */ case 163: { struct linux_mremap_args *p = params; iarg[0] = p->addr; /* l_ulong */ iarg[1] = p->old_len; /* l_ulong */ iarg[2] = p->new_len; /* l_ulong */ iarg[3] = p->flags; /* l_ulong */ iarg[4] = p->new_addr; /* l_ulong */ *n_args = 5; break; } /* linux_setresuid16 */ case 164: { struct linux_setresuid16_args *p = params; iarg[0] = p->ruid; /* l_uid16_t */ iarg[1] = p->euid; /* l_uid16_t */ iarg[2] = p->suid; /* l_uid16_t */ *n_args = 3; break; } /* linux_getresuid16 */ case 165: { struct linux_getresuid16_args *p = params; uarg[0] = (intptr_t) p->ruid; /* l_uid16_t * */ uarg[1] = (intptr_t) p->euid; /* l_uid16_t * */ uarg[2] = (intptr_t) p->suid; /* l_uid16_t * */ *n_args = 3; break; } /* poll */ case 168: { struct poll_args *p = params; uarg[0] = (intptr_t) p->fds; /* struct pollfd * */ uarg[1] = p->nfds; /* unsigned int */ iarg[2] = p->timeout; /* int */ *n_args = 3; break; } /* linux_setresgid16 */ case 170: { struct linux_setresgid16_args *p = params; iarg[0] = p->rgid; /* l_gid16_t */ iarg[1] = p->egid; /* l_gid16_t */ iarg[2] = p->sgid; /* l_gid16_t */ *n_args = 3; break; } /* linux_getresgid16 */ case 171: { struct linux_getresgid16_args *p = params; uarg[0] = (intptr_t) p->rgid; /* l_gid16_t * */ uarg[1] = (intptr_t) p->egid; /* l_gid16_t * */ uarg[2] = (intptr_t) p->sgid; /* l_gid16_t * */ *n_args = 3; break; } /* linux_prctl */ case 172: { struct linux_prctl_args *p = params; iarg[0] = p->option; /* l_int */ iarg[1] = p->arg2; /* l_int */ iarg[2] = p->arg3; /* l_int */ iarg[3] = p->arg4; /* l_int */ iarg[4] = p->arg5; /* l_int */ *n_args = 5; break; } /* linux_rt_sigreturn */ case 173: { struct linux_rt_sigreturn_args *p = params; uarg[0] = (intptr_t) p->ucp; /* struct l_ucontext * */ *n_args = 1; break; } /* linux_rt_sigaction */ case 174: { struct linux_rt_sigaction_args *p = params; iarg[0] = p->sig; /* l_int */ uarg[1] = (intptr_t) p->act; /* l_sigaction_t * */ uarg[2] = (intptr_t) p->oact; /* l_sigaction_t * */ iarg[3] = p->sigsetsize; /* l_size_t */ *n_args = 4; break; } /* linux_rt_sigprocmask */ case 175: { struct linux_rt_sigprocmask_args *p = params; iarg[0] = p->how; /* l_int */ uarg[1] = (intptr_t) p->mask; /* l_sigset_t * */ uarg[2] = (intptr_t) p->omask; /* l_sigset_t * */ iarg[3] = p->sigsetsize; /* l_size_t */ *n_args = 4; break; } /* linux_rt_sigpending */ case 176: { struct linux_rt_sigpending_args *p = params; uarg[0] = (intptr_t) p->set; /* l_sigset_t * */ iarg[1] = p->sigsetsize; /* l_size_t */ *n_args = 2; break; } /* linux_rt_sigtimedwait */ case 177: { struct linux_rt_sigtimedwait_args *p = params; uarg[0] = (intptr_t) p->mask; /* l_sigset_t * */ uarg[1] = (intptr_t) p->ptr; /* l_siginfo_t * */ uarg[2] = (intptr_t) p->timeout; /* struct l_timeval * */ iarg[3] = p->sigsetsize; /* l_size_t */ *n_args = 4; break; } /* linux_rt_sigqueueinfo */ case 178: { struct linux_rt_sigqueueinfo_args *p = params; iarg[0] = p->pid; /* l_pid_t */ iarg[1] = p->sig; /* l_int */ uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */ *n_args = 3; break; } /* linux_rt_sigsuspend */ case 179: { struct linux_rt_sigsuspend_args *p = params; uarg[0] = (intptr_t) p->newset; /* l_sigset_t * */ iarg[1] = p->sigsetsize; /* l_size_t */ *n_args = 2; break; } /* linux_pread */ case 180: { struct linux_pread_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->buf; /* char * */ iarg[2] = p->nbyte; /* l_size_t */ - iarg[3] = p->offset; /* l_loff_t */ - *n_args = 4; + uarg[3] = p->offset1; /* uint32_t */ + uarg[4] = p->offset2; /* uint32_t */ + *n_args = 5; break; } /* linux_pwrite */ case 181: { struct linux_pwrite_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->buf; /* char * */ iarg[2] = p->nbyte; /* l_size_t */ - iarg[3] = p->offset; /* l_loff_t */ - *n_args = 4; + uarg[3] = p->offset1; /* uint32_t */ + uarg[4] = p->offset2; /* uint32_t */ + *n_args = 5; break; } /* linux_chown16 */ case 182: { struct linux_chown16_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->uid; /* l_uid16_t */ iarg[2] = p->gid; /* l_gid16_t */ *n_args = 3; break; } /* linux_getcwd */ case 183: { struct linux_getcwd_args *p = params; uarg[0] = (intptr_t) p->buf; /* char * */ iarg[1] = p->bufsize; /* l_ulong */ *n_args = 2; break; } /* linux_capget */ case 184: { struct linux_capget_args *p = params; uarg[0] = (intptr_t) p->hdrp; /* struct l_user_cap_header * */ uarg[1] = (intptr_t) p->datap; /* struct l_user_cap_data * */ *n_args = 2; break; } /* linux_capset */ case 185: { struct linux_capset_args *p = params; uarg[0] = (intptr_t) p->hdrp; /* struct l_user_cap_header * */ uarg[1] = (intptr_t) p->datap; /* struct l_user_cap_data * */ *n_args = 2; break; } /* linux_sigaltstack */ case 186: { struct linux_sigaltstack_args *p = params; uarg[0] = (intptr_t) p->uss; /* l_stack_t * */ uarg[1] = (intptr_t) p->uoss; /* l_stack_t * */ *n_args = 2; break; } /* linux_sendfile */ case 187: { *n_args = 0; break; } /* linux_vfork */ case 190: { *n_args = 0; break; } /* linux_getrlimit */ case 191: { struct linux_getrlimit_args *p = params; iarg[0] = p->resource; /* l_uint */ uarg[1] = (intptr_t) p->rlim; /* struct l_rlimit * */ *n_args = 2; break; } /* linux_mmap2 */ case 192: { struct linux_mmap2_args *p = params; iarg[0] = p->addr; /* l_ulong */ iarg[1] = p->len; /* l_ulong */ iarg[2] = p->prot; /* l_ulong */ iarg[3] = p->flags; /* l_ulong */ iarg[4] = p->fd; /* l_ulong */ iarg[5] = p->pgoff; /* l_ulong */ *n_args = 6; break; } /* linux_truncate64 */ case 193: { struct linux_truncate64_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ - iarg[1] = p->length; /* l_loff_t */ - *n_args = 2; + uarg[1] = p->length1; /* uint32_t */ + uarg[2] = p->length2; /* uint32_t */ + *n_args = 3; break; } /* linux_ftruncate64 */ case 194: { struct linux_ftruncate64_args *p = params; iarg[0] = p->fd; /* l_uint */ - iarg[1] = p->length; /* l_loff_t */ - *n_args = 2; + uarg[1] = p->length1; /* uint32_t */ + uarg[2] = p->length2; /* uint32_t */ + *n_args = 3; break; } /* linux_stat64 */ case 195: { struct linux_stat64_args *p = params; uarg[0] = (intptr_t) p->filename; /* const char * */ uarg[1] = (intptr_t) p->statbuf; /* struct l_stat64 * */ *n_args = 2; break; } /* linux_lstat64 */ case 196: { struct linux_lstat64_args *p = params; uarg[0] = (intptr_t) p->filename; /* const char * */ uarg[1] = (intptr_t) p->statbuf; /* struct l_stat64 * */ *n_args = 2; break; } /* linux_fstat64 */ case 197: { struct linux_fstat64_args *p = params; iarg[0] = p->fd; /* l_int */ uarg[1] = (intptr_t) p->statbuf; /* struct l_stat64 * */ *n_args = 2; break; } /* linux_lchown */ case 198: { struct linux_lchown_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->uid; /* l_uid_t */ iarg[2] = p->gid; /* l_gid_t */ *n_args = 3; break; } /* linux_getuid */ case 199: { *n_args = 0; break; } /* linux_getgid */ case 200: { *n_args = 0; break; } /* geteuid */ case 201: { *n_args = 0; break; } /* getegid */ case 202: { *n_args = 0; break; } /* setreuid */ case 203: { struct setreuid_args *p = params; uarg[0] = p->ruid; /* uid_t */ uarg[1] = p->euid; /* uid_t */ *n_args = 2; break; } /* setregid */ case 204: { struct setregid_args *p = params; iarg[0] = p->rgid; /* gid_t */ iarg[1] = p->egid; /* gid_t */ *n_args = 2; break; } /* linux_getgroups */ case 205: { struct linux_getgroups_args *p = params; iarg[0] = p->gidsetsize; /* l_int */ uarg[1] = (intptr_t) p->grouplist; /* l_gid_t * */ *n_args = 2; break; } /* linux_setgroups */ case 206: { struct linux_setgroups_args *p = params; iarg[0] = p->gidsetsize; /* l_int */ uarg[1] = (intptr_t) p->grouplist; /* l_gid_t * */ *n_args = 2; break; } /* fchown */ case 207: { *n_args = 0; break; } /* setresuid */ case 208: { struct setresuid_args *p = params; uarg[0] = p->ruid; /* uid_t */ uarg[1] = p->euid; /* uid_t */ uarg[2] = p->suid; /* uid_t */ *n_args = 3; break; } /* getresuid */ case 209: { struct getresuid_args *p = params; uarg[0] = (intptr_t) p->ruid; /* uid_t * */ uarg[1] = (intptr_t) p->euid; /* uid_t * */ uarg[2] = (intptr_t) p->suid; /* uid_t * */ *n_args = 3; break; } /* setresgid */ case 210: { struct setresgid_args *p = params; iarg[0] = p->rgid; /* gid_t */ iarg[1] = p->egid; /* gid_t */ iarg[2] = p->sgid; /* gid_t */ *n_args = 3; break; } /* getresgid */ case 211: { struct getresgid_args *p = params; uarg[0] = (intptr_t) p->rgid; /* gid_t * */ uarg[1] = (intptr_t) p->egid; /* gid_t * */ uarg[2] = (intptr_t) p->sgid; /* gid_t * */ *n_args = 3; break; } /* linux_chown */ case 212: { struct linux_chown_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ iarg[1] = p->uid; /* l_uid_t */ iarg[2] = p->gid; /* l_gid_t */ *n_args = 3; break; } /* setuid */ case 213: { struct setuid_args *p = params; uarg[0] = p->uid; /* uid_t */ *n_args = 1; break; } /* setgid */ case 214: { struct setgid_args *p = params; iarg[0] = p->gid; /* gid_t */ *n_args = 1; break; } /* linux_setfsuid */ case 215: { struct linux_setfsuid_args *p = params; iarg[0] = p->uid; /* l_uid_t */ *n_args = 1; break; } /* linux_setfsgid */ case 216: { struct linux_setfsgid_args *p = params; iarg[0] = p->gid; /* l_gid_t */ *n_args = 1; break; } /* linux_pivot_root */ case 217: { struct linux_pivot_root_args *p = params; uarg[0] = (intptr_t) p->new_root; /* char * */ uarg[1] = (intptr_t) p->put_old; /* char * */ *n_args = 2; break; } /* linux_mincore */ case 218: { struct linux_mincore_args *p = params; iarg[0] = p->start; /* l_ulong */ iarg[1] = p->len; /* l_size_t */ uarg[2] = (intptr_t) p->vec; /* u_char * */ *n_args = 3; break; } /* madvise */ case 219: { struct madvise_args *p = params; uarg[0] = (intptr_t) p->addr; /* void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->behav; /* int */ *n_args = 3; break; } /* linux_getdents64 */ case 220: { struct linux_getdents64_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = (intptr_t) p->dirent; /* void * */ iarg[2] = p->count; /* l_uint */ *n_args = 3; break; } /* linux_fcntl64 */ case 221: { struct linux_fcntl64_args *p = params; iarg[0] = p->fd; /* l_uint */ iarg[1] = p->cmd; /* l_uint */ uarg[2] = p->arg; /* uintptr_t */ *n_args = 3; break; } /* linux_gettid */ case 224: { *n_args = 0; break; } /* linux_setxattr */ case 226: { *n_args = 0; break; } /* linux_lsetxattr */ case 227: { *n_args = 0; break; } /* linux_fsetxattr */ case 228: { *n_args = 0; break; } /* linux_getxattr */ case 229: { *n_args = 0; break; } /* linux_lgetxattr */ case 230: { *n_args = 0; break; } /* linux_fgetxattr */ case 231: { *n_args = 0; break; } /* linux_listxattr */ case 232: { *n_args = 0; break; } /* linux_llistxattr */ case 233: { *n_args = 0; break; } /* linux_flistxattr */ case 234: { *n_args = 0; break; } /* linux_removexattr */ case 235: { *n_args = 0; break; } /* linux_lremovexattr */ case 236: { *n_args = 0; break; } /* linux_fremovexattr */ case 237: { *n_args = 0; break; } /* linux_tkill */ case 238: { struct linux_tkill_args *p = params; iarg[0] = p->tid; /* int */ iarg[1] = p->sig; /* int */ *n_args = 2; break; } /* linux_sys_futex */ case 240: { struct linux_sys_futex_args *p = params; uarg[0] = (intptr_t) p->uaddr; /* void * */ iarg[1] = p->op; /* int */ uarg[2] = p->val; /* uint32_t */ uarg[3] = (intptr_t) p->timeout; /* struct l_timespec * */ uarg[4] = (intptr_t) p->uaddr2; /* uint32_t * */ uarg[5] = p->val3; /* uint32_t */ *n_args = 6; break; } /* linux_sched_setaffinity */ case 241: { struct linux_sched_setaffinity_args *p = params; iarg[0] = p->pid; /* l_pid_t */ iarg[1] = p->len; /* l_uint */ uarg[2] = (intptr_t) p->user_mask_ptr; /* l_ulong * */ *n_args = 3; break; } /* linux_sched_getaffinity */ case 242: { struct linux_sched_getaffinity_args *p = params; iarg[0] = p->pid; /* l_pid_t */ iarg[1] = p->len; /* l_uint */ uarg[2] = (intptr_t) p->user_mask_ptr; /* l_ulong * */ *n_args = 3; break; } /* linux_set_thread_area */ case 243: { struct linux_set_thread_area_args *p = params; uarg[0] = (intptr_t) p->desc; /* struct l_user_desc * */ *n_args = 1; break; } /* linux_fadvise64 */ case 250: { struct linux_fadvise64_args *p = params; iarg[0] = p->fd; /* int */ - iarg[1] = p->offset; /* l_loff_t */ - iarg[2] = p->len; /* l_size_t */ - iarg[3] = p->advice; /* int */ - *n_args = 4; + uarg[1] = p->offset1; /* uint32_t */ + uarg[2] = p->offset2; /* uint32_t */ + iarg[3] = p->len; /* l_size_t */ + iarg[4] = p->advice; /* int */ + *n_args = 5; break; } /* linux_exit_group */ case 252: { struct linux_exit_group_args *p = params; iarg[0] = p->error_code; /* int */ *n_args = 1; break; } /* linux_lookup_dcookie */ case 253: { *n_args = 0; break; } /* linux_epoll_create */ case 254: { struct linux_epoll_create_args *p = params; iarg[0] = p->size; /* l_int */ *n_args = 1; break; } /* linux_epoll_ctl */ case 255: { struct linux_epoll_ctl_args *p = params; iarg[0] = p->epfd; /* l_int */ iarg[1] = p->op; /* l_int */ iarg[2] = p->fd; /* l_int */ uarg[3] = (intptr_t) p->event; /* struct epoll_event * */ *n_args = 4; break; } /* linux_epoll_wait */ case 256: { struct linux_epoll_wait_args *p = params; iarg[0] = p->epfd; /* l_int */ uarg[1] = (intptr_t) p->events; /* struct epoll_event * */ iarg[2] = p->maxevents; /* l_int */ iarg[3] = p->timeout; /* l_int */ *n_args = 4; break; } /* linux_remap_file_pages */ case 257: { *n_args = 0; break; } /* linux_set_tid_address */ case 258: { struct linux_set_tid_address_args *p = params; uarg[0] = (intptr_t) p->tidptr; /* int * */ *n_args = 1; break; } /* linux_timer_create */ case 259: { struct linux_timer_create_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ uarg[1] = (intptr_t) p->evp; /* struct sigevent * */ uarg[2] = (intptr_t) p->timerid; /* l_timer_t * */ *n_args = 3; break; } /* linux_timer_settime */ case 260: { struct linux_timer_settime_args *p = params; iarg[0] = p->timerid; /* l_timer_t */ iarg[1] = p->flags; /* l_int */ uarg[2] = (intptr_t) p->new; /* const struct itimerspec * */ uarg[3] = (intptr_t) p->old; /* struct itimerspec * */ *n_args = 4; break; } /* linux_timer_gettime */ case 261: { struct linux_timer_gettime_args *p = params; iarg[0] = p->timerid; /* l_timer_t */ uarg[1] = (intptr_t) p->setting; /* struct itimerspec * */ *n_args = 2; break; } /* linux_timer_getoverrun */ case 262: { struct linux_timer_getoverrun_args *p = params; iarg[0] = p->timerid; /* l_timer_t */ *n_args = 1; break; } /* linux_timer_delete */ case 263: { struct linux_timer_delete_args *p = params; iarg[0] = p->timerid; /* l_timer_t */ *n_args = 1; break; } /* linux_clock_settime */ case 264: { struct linux_clock_settime_args *p = params; iarg[0] = p->which; /* clockid_t */ uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */ *n_args = 2; break; } /* linux_clock_gettime */ case 265: { struct linux_clock_gettime_args *p = params; iarg[0] = p->which; /* clockid_t */ uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */ *n_args = 2; break; } /* linux_clock_getres */ case 266: { struct linux_clock_getres_args *p = params; iarg[0] = p->which; /* clockid_t */ uarg[1] = (intptr_t) p->tp; /* struct l_timespec * */ *n_args = 2; break; } /* linux_clock_nanosleep */ case 267: { struct linux_clock_nanosleep_args *p = params; iarg[0] = p->which; /* clockid_t */ iarg[1] = p->flags; /* int */ uarg[2] = (intptr_t) p->rqtp; /* struct l_timespec * */ uarg[3] = (intptr_t) p->rmtp; /* struct l_timespec * */ *n_args = 4; break; } /* linux_statfs64 */ case 268: { struct linux_statfs64_args *p = params; uarg[0] = (intptr_t) p->path; /* char * */ uarg[1] = p->bufsize; /* size_t */ uarg[2] = (intptr_t) p->buf; /* struct l_statfs64_buf * */ *n_args = 3; break; } /* linux_fstatfs64 */ case 269: { struct linux_fstatfs64_args *p = params; iarg[0] = p->fd; /* l_uint */ uarg[1] = p->bufsize; /* size_t */ uarg[2] = (intptr_t) p->buf; /* struct l_statfs64_buf * */ *n_args = 3; break; } /* linux_tgkill */ case 270: { struct linux_tgkill_args *p = params; iarg[0] = p->tgid; /* int */ iarg[1] = p->pid; /* int */ iarg[2] = p->sig; /* int */ *n_args = 3; break; } /* linux_utimes */ case 271: { struct linux_utimes_args *p = params; uarg[0] = (intptr_t) p->fname; /* char * */ uarg[1] = (intptr_t) p->tptr; /* struct l_timeval * */ *n_args = 2; break; } /* linux_fadvise64_64 */ case 272: { struct linux_fadvise64_64_args *p = params; iarg[0] = p->fd; /* int */ - iarg[1] = p->offset; /* l_loff_t */ - iarg[2] = p->len; /* l_loff_t */ - iarg[3] = p->advice; /* int */ - *n_args = 4; + uarg[1] = p->offset1; /* uint32_t */ + uarg[2] = p->offset2; /* uint32_t */ + uarg[3] = p->len1; /* uint32_t */ + uarg[4] = p->len2; /* uint32_t */ + iarg[5] = p->advice; /* int */ + *n_args = 6; break; } /* linux_mbind */ case 274: { *n_args = 0; break; } /* linux_get_mempolicy */ case 275: { *n_args = 0; break; } /* linux_set_mempolicy */ case 276: { *n_args = 0; break; } /* linux_mq_open */ case 277: { *n_args = 0; break; } /* linux_mq_unlink */ case 278: { *n_args = 0; break; } /* linux_mq_timedsend */ case 279: { *n_args = 0; break; } /* linux_mq_timedreceive */ case 280: { *n_args = 0; break; } /* linux_mq_notify */ case 281: { *n_args = 0; break; } /* linux_mq_getsetattr */ case 282: { *n_args = 0; break; } /* linux_kexec_load */ case 283: { *n_args = 0; break; } /* linux_waitid */ case 284: { struct linux_waitid_args *p = params; iarg[0] = p->idtype; /* int */ iarg[1] = p->id; /* l_pid_t */ uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */ iarg[3] = p->options; /* int */ uarg[4] = (intptr_t) p->rusage; /* struct l_rusage * */ *n_args = 5; break; } /* linux_add_key */ case 286: { *n_args = 0; break; } /* linux_request_key */ case 287: { *n_args = 0; break; } /* linux_keyctl */ case 288: { *n_args = 0; break; } /* linux_ioprio_set */ case 289: { *n_args = 0; break; } /* linux_ioprio_get */ case 290: { *n_args = 0; break; } /* linux_inotify_init */ case 291: { *n_args = 0; break; } /* linux_inotify_add_watch */ case 292: { *n_args = 0; break; } /* linux_inotify_rm_watch */ case 293: { *n_args = 0; break; } /* linux_migrate_pages */ case 294: { *n_args = 0; break; } /* linux_openat */ case 295: { struct linux_openat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ iarg[2] = p->flags; /* l_int */ iarg[3] = p->mode; /* l_int */ *n_args = 4; break; } /* linux_mkdirat */ case 296: { struct linux_mkdirat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->pathname; /* const char * */ iarg[2] = p->mode; /* l_int */ *n_args = 3; break; } /* linux_mknodat */ case 297: { struct linux_mknodat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ iarg[2] = p->mode; /* l_int */ iarg[3] = p->dev; /* l_uint */ *n_args = 4; break; } /* linux_fchownat */ case 298: { struct linux_fchownat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ iarg[2] = p->uid; /* l_uid16_t */ iarg[3] = p->gid; /* l_gid16_t */ iarg[4] = p->flag; /* l_int */ *n_args = 5; break; } /* linux_futimesat */ case 299: { struct linux_futimesat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* char * */ uarg[2] = (intptr_t) p->utimes; /* struct l_timeval * */ *n_args = 3; break; } /* linux_fstatat64 */ case 300: { struct linux_fstatat64_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->pathname; /* char * */ uarg[2] = (intptr_t) p->statbuf; /* struct l_stat64 * */ iarg[3] = p->flag; /* l_int */ *n_args = 4; break; } /* linux_unlinkat */ case 301: { struct linux_unlinkat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->pathname; /* const char * */ iarg[2] = p->flag; /* l_int */ *n_args = 3; break; } /* linux_renameat */ case 302: { struct linux_renameat_args *p = params; iarg[0] = p->olddfd; /* l_int */ uarg[1] = (intptr_t) p->oldname; /* const char * */ iarg[2] = p->newdfd; /* l_int */ uarg[3] = (intptr_t) p->newname; /* const char * */ *n_args = 4; break; } /* linux_linkat */ case 303: { struct linux_linkat_args *p = params; iarg[0] = p->olddfd; /* l_int */ uarg[1] = (intptr_t) p->oldname; /* const char * */ iarg[2] = p->newdfd; /* l_int */ uarg[3] = (intptr_t) p->newname; /* const char * */ iarg[4] = p->flag; /* l_int */ *n_args = 5; break; } /* linux_symlinkat */ case 304: { struct linux_symlinkat_args *p = params; uarg[0] = (intptr_t) p->oldname; /* const char * */ iarg[1] = p->newdfd; /* l_int */ uarg[2] = (intptr_t) p->newname; /* const char * */ *n_args = 3; break; } /* linux_readlinkat */ case 305: { struct linux_readlinkat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->path; /* const char * */ uarg[2] = (intptr_t) p->buf; /* char * */ iarg[3] = p->bufsiz; /* l_int */ *n_args = 4; break; } /* linux_fchmodat */ case 306: { struct linux_fchmodat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ iarg[2] = p->mode; /* l_mode_t */ *n_args = 3; break; } /* linux_faccessat */ case 307: { struct linux_faccessat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ iarg[2] = p->amode; /* l_int */ *n_args = 3; break; } /* linux_pselect6 */ case 308: { struct linux_pselect6_args *p = params; iarg[0] = p->nfds; /* l_int */ uarg[1] = (intptr_t) p->readfds; /* l_fd_set * */ uarg[2] = (intptr_t) p->writefds; /* l_fd_set * */ uarg[3] = (intptr_t) p->exceptfds; /* l_fd_set * */ uarg[4] = (intptr_t) p->tsp; /* struct l_timespec * */ uarg[5] = (intptr_t) p->sig; /* l_uintptr_t * */ *n_args = 6; break; } /* linux_ppoll */ case 309: { struct linux_ppoll_args *p = params; uarg[0] = (intptr_t) p->fds; /* struct pollfd * */ uarg[1] = p->nfds; /* uint32_t */ uarg[2] = (intptr_t) p->tsp; /* struct l_timespec * */ uarg[3] = (intptr_t) p->sset; /* l_sigset_t * */ iarg[4] = p->ssize; /* l_size_t */ *n_args = 5; break; } /* linux_unshare */ case 310: { *n_args = 0; break; } /* linux_set_robust_list */ case 311: { struct linux_set_robust_list_args *p = params; uarg[0] = (intptr_t) p->head; /* struct linux_robust_list_head * */ iarg[1] = p->len; /* l_size_t */ *n_args = 2; break; } /* linux_get_robust_list */ case 312: { struct linux_get_robust_list_args *p = params; iarg[0] = p->pid; /* l_int */ uarg[1] = (intptr_t) p->head; /* struct linux_robust_list_head ** */ uarg[2] = (intptr_t) p->len; /* l_size_t * */ *n_args = 3; break; } /* linux_splice */ case 313: { *n_args = 0; break; } /* linux_sync_file_range */ case 314: { struct linux_sync_file_range_args *p = params; iarg[0] = p->fd; /* l_int */ - iarg[1] = p->offset; /* l_loff_t */ - iarg[2] = p->nbytes; /* l_loff_t */ - uarg[3] = p->flags; /* unsigned int */ - *n_args = 4; + uarg[1] = p->offset1; /* uint32_t */ + uarg[2] = p->offset2; /* uint32_t */ + uarg[3] = p->nbytes1; /* uint32_t */ + uarg[4] = p->nbytes2; /* uint32_t */ + uarg[5] = p->flags; /* unsigned int */ + *n_args = 6; break; } /* linux_tee */ case 315: { *n_args = 0; break; } /* linux_vmsplice */ case 316: { *n_args = 0; break; } /* linux_move_pages */ case 317: { *n_args = 0; break; } /* linux_getcpu */ case 318: { *n_args = 0; break; } /* linux_epoll_pwait */ case 319: { struct linux_epoll_pwait_args *p = params; iarg[0] = p->epfd; /* l_int */ uarg[1] = (intptr_t) p->events; /* struct epoll_event * */ iarg[2] = p->maxevents; /* l_int */ iarg[3] = p->timeout; /* l_int */ uarg[4] = (intptr_t) p->mask; /* l_sigset_t * */ iarg[5] = p->sigsetsize; /* l_size_t */ *n_args = 6; break; } /* linux_utimensat */ case 320: { struct linux_utimensat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->pathname; /* const char * */ uarg[2] = (intptr_t) p->times; /* const struct l_timespec * */ iarg[3] = p->flags; /* l_int */ *n_args = 4; break; } /* linux_signalfd */ case 321: { *n_args = 0; break; } /* linux_timerfd_create */ case 322: { struct linux_timerfd_create_args *p = params; iarg[0] = p->clockid; /* l_int */ iarg[1] = p->flags; /* l_int */ *n_args = 2; break; } /* linux_eventfd */ case 323: { struct linux_eventfd_args *p = params; iarg[0] = p->initval; /* l_uint */ *n_args = 1; break; } /* linux_fallocate */ case 324: { struct linux_fallocate_args *p = params; iarg[0] = p->fd; /* l_int */ iarg[1] = p->mode; /* l_int */ - iarg[2] = p->offset; /* l_loff_t */ - iarg[3] = p->len; /* l_loff_t */ - *n_args = 4; + uarg[2] = p->offset1; /* uint32_t */ + uarg[3] = p->offset2; /* uint32_t */ + uarg[4] = p->len1; /* uint32_t */ + uarg[5] = p->len2; /* uint32_t */ + *n_args = 6; break; } /* linux_timerfd_settime */ case 325: { struct linux_timerfd_settime_args *p = params; iarg[0] = p->fd; /* l_int */ iarg[1] = p->flags; /* l_int */ uarg[2] = (intptr_t) p->new_value; /* const struct l_itimerspec * */ uarg[3] = (intptr_t) p->old_value; /* struct l_itimerspec * */ *n_args = 4; break; } /* linux_timerfd_gettime */ case 326: { struct linux_timerfd_gettime_args *p = params; iarg[0] = p->fd; /* l_int */ uarg[1] = (intptr_t) p->old_value; /* struct l_itimerspec * */ *n_args = 2; break; } /* linux_signalfd4 */ case 327: { *n_args = 0; break; } /* linux_eventfd2 */ case 328: { struct linux_eventfd2_args *p = params; iarg[0] = p->initval; /* l_uint */ iarg[1] = p->flags; /* l_int */ *n_args = 2; break; } /* linux_epoll_create1 */ case 329: { struct linux_epoll_create1_args *p = params; iarg[0] = p->flags; /* l_int */ *n_args = 1; break; } /* linux_dup3 */ case 330: { struct linux_dup3_args *p = params; iarg[0] = p->oldfd; /* l_int */ iarg[1] = p->newfd; /* l_int */ iarg[2] = p->flags; /* l_int */ *n_args = 3; break; } /* linux_pipe2 */ case 331: { struct linux_pipe2_args *p = params; uarg[0] = (intptr_t) p->pipefds; /* l_int * */ iarg[1] = p->flags; /* l_int */ *n_args = 2; break; } /* linux_inotify_init1 */ case 332: { *n_args = 0; break; } /* linux_preadv */ case 333: { struct linux_preadv_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->vec; /* struct iovec * */ iarg[2] = p->vlen; /* l_ulong */ iarg[3] = p->pos_l; /* l_ulong */ iarg[4] = p->pos_h; /* l_ulong */ *n_args = 5; break; } /* linux_pwritev */ case 334: { struct linux_pwritev_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->vec; /* struct iovec * */ iarg[2] = p->vlen; /* l_ulong */ iarg[3] = p->pos_l; /* l_ulong */ iarg[4] = p->pos_h; /* l_ulong */ *n_args = 5; break; } /* linux_rt_tgsigqueueinfo */ case 335: { struct linux_rt_tgsigqueueinfo_args *p = params; iarg[0] = p->tgid; /* l_pid_t */ iarg[1] = p->tid; /* l_pid_t */ iarg[2] = p->sig; /* l_int */ uarg[3] = (intptr_t) p->uinfo; /* l_siginfo_t * */ *n_args = 4; break; } /* linux_perf_event_open */ case 336: { *n_args = 0; break; } /* linux_recvmmsg */ case 337: { struct linux_recvmmsg_args *p = params; iarg[0] = p->s; /* l_int */ uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */ iarg[2] = p->vlen; /* l_uint */ iarg[3] = p->flags; /* l_uint */ uarg[4] = (intptr_t) p->timeout; /* struct l_timespec * */ *n_args = 5; break; } /* linux_fanotify_init */ case 338: { *n_args = 0; break; } /* linux_fanotify_mark */ case 339: { *n_args = 0; break; } /* linux_prlimit64 */ case 340: { struct linux_prlimit64_args *p = params; iarg[0] = p->pid; /* l_pid_t */ iarg[1] = p->resource; /* l_uint */ uarg[2] = (intptr_t) p->new; /* struct rlimit * */ uarg[3] = (intptr_t) p->old; /* struct rlimit * */ *n_args = 4; break; } /* linux_name_to_handle_at */ case 341: { *n_args = 0; break; } /* linux_open_by_handle_at */ case 342: { *n_args = 0; break; } /* linux_clock_adjtime */ case 343: { *n_args = 0; break; } /* linux_syncfs */ case 344: { struct linux_syncfs_args *p = params; iarg[0] = p->fd; /* l_int */ *n_args = 1; break; } /* linux_sendmmsg */ case 345: { struct linux_sendmmsg_args *p = params; iarg[0] = p->s; /* l_int */ uarg[1] = (intptr_t) p->msg; /* struct l_mmsghdr * */ iarg[2] = p->vlen; /* l_uint */ iarg[3] = p->flags; /* l_uint */ *n_args = 4; break; } /* linux_setns */ case 346: { *n_args = 0; break; } /* linux_process_vm_readv */ case 347: { struct linux_process_vm_readv_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->lvec; /* const struct iovec * */ iarg[2] = p->liovcnt; /* l_ulong */ uarg[3] = (intptr_t) p->rvec; /* const struct iovec * */ iarg[4] = p->riovcnt; /* l_ulong */ iarg[5] = p->flags; /* l_ulong */ *n_args = 6; break; } /* linux_process_vm_writev */ case 348: { struct linux_process_vm_writev_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->lvec; /* const struct iovec * */ iarg[2] = p->liovcnt; /* l_ulong */ uarg[3] = (intptr_t) p->rvec; /* const struct iovec * */ iarg[4] = p->riovcnt; /* l_ulong */ iarg[5] = p->flags; /* l_ulong */ *n_args = 6; break; } /* linux_kcmp */ case 349: { struct linux_kcmp_args *p = params; iarg[0] = p->pid1; /* l_pid_t */ iarg[1] = p->pid2; /* l_pid_t */ iarg[2] = p->type; /* l_int */ iarg[3] = p->idx1; /* l_ulong */ iarg[4] = p->idx; /* l_ulong */ *n_args = 5; break; } /* linux_finit_module */ case 350: { struct linux_finit_module_args *p = params; iarg[0] = p->fd; /* l_int */ uarg[1] = (intptr_t) p->uargs; /* const char * */ iarg[2] = p->flags; /* l_int */ *n_args = 3; break; } /* linux_sched_setattr */ case 351: { struct linux_sched_setattr_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->attr; /* void * */ iarg[2] = p->flags; /* l_uint */ *n_args = 3; break; } /* linux_sched_getattr */ case 352: { struct linux_sched_getattr_args *p = params; iarg[0] = p->pid; /* l_pid_t */ uarg[1] = (intptr_t) p->attr; /* void * */ iarg[2] = p->size; /* l_uint */ iarg[3] = p->flags; /* l_uint */ *n_args = 4; break; } /* linux_renameat2 */ case 353: { struct linux_renameat2_args *p = params; iarg[0] = p->oldfd; /* l_int */ uarg[1] = (intptr_t) p->oldname; /* const char * */ iarg[2] = p->newfd; /* l_int */ uarg[3] = (intptr_t) p->newname; /* const char * */ uarg[4] = p->flags; /* unsigned int */ *n_args = 5; break; } /* linux_seccomp */ case 354: { struct linux_seccomp_args *p = params; iarg[0] = p->op; /* l_uint */ iarg[1] = p->flags; /* l_uint */ uarg[2] = (intptr_t) p->uargs; /* const char * */ *n_args = 3; break; } /* linux_getrandom */ case 355: { struct linux_getrandom_args *p = params; uarg[0] = (intptr_t) p->buf; /* char * */ iarg[1] = p->count; /* l_size_t */ iarg[2] = p->flags; /* l_uint */ *n_args = 3; break; } /* linux_memfd_create */ case 356: { struct linux_memfd_create_args *p = params; uarg[0] = (intptr_t) p->uname_ptr; /* const char * */ iarg[1] = p->flags; /* l_uint */ *n_args = 2; break; } /* linux_bpf */ case 357: { struct linux_bpf_args *p = params; iarg[0] = p->cmd; /* l_int */ uarg[1] = (intptr_t) p->attr; /* void * */ iarg[2] = p->size; /* l_uint */ *n_args = 3; break; } /* linux_execveat */ case 358: { struct linux_execveat_args *p = params; iarg[0] = p->dfd; /* l_int */ uarg[1] = (intptr_t) p->filename; /* const char * */ uarg[2] = (intptr_t) p->argv; /* const char ** */ uarg[3] = (intptr_t) p->envp; /* const char ** */ iarg[4] = p->flags; /* l_int */ *n_args = 5; break; } /* linux_socket */ case 359: { struct linux_socket_args *p = params; iarg[0] = p->domain; /* l_int */ iarg[1] = p->type; /* l_int */ iarg[2] = p->protocol; /* l_int */ *n_args = 3; break; } /* linux_socketpair */ case 360: { struct linux_socketpair_args *p = params; iarg[0] = p->domain; /* l_int */ iarg[1] = p->type; /* l_int */ iarg[2] = p->protocol; /* l_int */ iarg[3] = p->rsv; /* l_uintptr_t */ *n_args = 4; break; } /* linux_bind */ case 361: { struct linux_bind_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->name; /* l_uintptr_t */ iarg[2] = p->namelen; /* l_int */ *n_args = 3; break; } /* linux_connect */ case 362: { struct linux_connect_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->name; /* l_uintptr_t */ iarg[2] = p->namelen; /* l_int */ *n_args = 3; break; } /* linux_listen */ case 363: { struct linux_listen_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->backlog; /* l_int */ *n_args = 2; break; } /* linux_accept4 */ case 364: { struct linux_accept4_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->addr; /* l_uintptr_t */ iarg[2] = p->namelen; /* l_uintptr_t */ iarg[3] = p->flags; /* l_int */ *n_args = 4; break; } /* linux_getsockopt */ case 365: { struct linux_getsockopt_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->level; /* l_int */ iarg[2] = p->optname; /* l_int */ iarg[3] = p->optval; /* l_uintptr_t */ iarg[4] = p->optlen; /* l_uintptr_t */ *n_args = 5; break; } /* linux_setsockopt */ case 366: { struct linux_setsockopt_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->level; /* l_int */ iarg[2] = p->optname; /* l_int */ iarg[3] = p->optval; /* l_uintptr_t */ iarg[4] = p->optlen; /* l_int */ *n_args = 5; break; } /* linux_getsockname */ case 367: { struct linux_getsockname_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->addr; /* l_uintptr_t */ iarg[2] = p->namelen; /* l_uintptr_t */ *n_args = 3; break; } /* linux_getpeername */ case 368: { struct linux_getpeername_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->addr; /* l_uintptr_t */ iarg[2] = p->namelen; /* l_uintptr_t */ *n_args = 3; break; } /* linux_sendto */ case 369: { struct linux_sendto_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->msg; /* l_uintptr_t */ iarg[2] = p->len; /* l_int */ iarg[3] = p->flags; /* l_int */ iarg[4] = p->to; /* l_uintptr_t */ iarg[5] = p->tolen; /* l_int */ *n_args = 6; break; } /* linux_sendmsg */ case 370: { struct linux_sendmsg_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->msg; /* l_uintptr_t */ iarg[2] = p->flags; /* l_int */ *n_args = 3; break; } /* linux_recvfrom */ case 371: { struct linux_recvfrom_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->buf; /* l_uintptr_t */ iarg[2] = p->len; /* l_size_t */ iarg[3] = p->flags; /* l_int */ iarg[4] = p->from; /* l_uintptr_t */ iarg[5] = p->fromlen; /* l_uintptr_t */ *n_args = 6; break; } /* linux_recvmsg */ case 372: { struct linux_recvmsg_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->msg; /* l_uintptr_t */ iarg[2] = p->flags; /* l_int */ *n_args = 3; break; } /* linux_shutdown */ case 373: { struct linux_shutdown_args *p = params; iarg[0] = p->s; /* l_int */ iarg[1] = p->how; /* l_int */ *n_args = 2; break; } /* linux_userfaultfd */ case 374: { struct linux_userfaultfd_args *p = params; iarg[0] = p->flags; /* l_int */ *n_args = 1; break; } /* linux_membarrier */ case 375: { struct linux_membarrier_args *p = params; iarg[0] = p->cmd; /* l_int */ iarg[1] = p->flags; /* l_int */ *n_args = 2; break; } /* linux_mlock2 */ case 376: { struct linux_mlock2_args *p = params; iarg[0] = p->start; /* l_ulong */ iarg[1] = p->len; /* l_size_t */ iarg[2] = p->flags; /* l_int */ *n_args = 3; break; } /* linux_copy_file_range */ case 377: { struct linux_copy_file_range_args *p = params; iarg[0] = p->fd_in; /* l_int */ uarg[1] = (intptr_t) p->off_in; /* l_loff_t * */ iarg[2] = p->fd_out; /* l_int */ uarg[3] = (intptr_t) p->off_out; /* l_loff_t * */ iarg[4] = p->len; /* l_size_t */ iarg[5] = p->flags; /* l_uint */ *n_args = 6; break; } /* linux_preadv2 */ case 378: { struct linux_preadv2_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->vec; /* const struct iovec * */ iarg[2] = p->vlen; /* l_ulong */ iarg[3] = p->pos_l; /* l_ulong */ iarg[4] = p->pos_h; /* l_ulong */ iarg[5] = p->flags; /* l_int */ *n_args = 6; break; } /* linux_pwritev2 */ case 379: { struct linux_pwritev2_args *p = params; iarg[0] = p->fd; /* l_ulong */ uarg[1] = (intptr_t) p->vec; /* const struct iovec * */ iarg[2] = p->vlen; /* l_ulong */ iarg[3] = p->pos_l; /* l_ulong */ iarg[4] = p->pos_h; /* l_ulong */ iarg[5] = p->flags; /* l_int */ *n_args = 6; break; } /* linux_pkey_mprotect */ case 380: { struct linux_pkey_mprotect_args *p = params; iarg[0] = p->start; /* l_ulong */ iarg[1] = p->len; /* l_size_t */ iarg[2] = p->prot; /* l_ulong */ iarg[3] = p->pkey; /* l_int */ *n_args = 4; break; } /* linux_pkey_alloc */ case 381: { struct linux_pkey_alloc_args *p = params; iarg[0] = p->flags; /* l_ulong */ iarg[1] = p->init_val; /* l_ulong */ *n_args = 2; break; } /* linux_pkey_free */ case 382: { struct linux_pkey_free_args *p = params; iarg[0] = p->pkey; /* l_int */ *n_args = 1; break; } /* linux_statx */ case 383: { struct linux_statx_args *p = params; iarg[0] = p->dirfd; /* l_int */ uarg[1] = (intptr_t) p->pathname; /* const char * */ iarg[2] = p->flags; /* l_uint */ iarg[3] = p->mask; /* l_uint */ uarg[4] = (intptr_t) p->statxbuf; /* void * */ *n_args = 5; break; } /* linux_arch_prctl */ case 384: { struct linux_arch_prctl_args *p = params; iarg[0] = p->option; /* l_int */ iarg[1] = p->arg2; /* l_ulong */ *n_args = 2; break; } /* linux_io_pgetevents */ case 385: { *n_args = 0; break; } /* linux_rseq */ case 386: { *n_args = 0; break; } /* linux_semget */ case 393: { struct linux_semget_args *p = params; iarg[0] = p->key; /* l_key_t */ iarg[1] = p->nsems; /* l_int */ iarg[2] = p->semflg; /* l_int */ *n_args = 3; break; } /* linux_semctl */ case 394: { struct linux_semctl_args *p = params; iarg[0] = p->semid; /* l_int */ iarg[1] = p->semnum; /* l_int */ iarg[2] = p->cmd; /* l_int */ uarg[3] = p->arg.buf; /* union l_semun */ *n_args = 4; break; } /* linux_shmget */ case 395: { struct linux_shmget_args *p = params; iarg[0] = p->key; /* l_key_t */ iarg[1] = p->size; /* l_size_t */ iarg[2] = p->shmflg; /* l_int */ *n_args = 3; break; } /* linux_shmctl */ case 396: { struct linux_shmctl_args *p = params; iarg[0] = p->shmid; /* l_int */ iarg[1] = p->cmd; /* l_int */ uarg[2] = (intptr_t) p->buf; /* struct l_shmid_ds * */ *n_args = 3; break; } /* linux_shmat */ case 397: { struct linux_shmat_args *p = params; iarg[0] = p->shmid; /* l_int */ uarg[1] = (intptr_t) p->shmaddr; /* char * */ iarg[2] = p->shmflg; /* l_int */ *n_args = 3; break; } /* linux_shmdt */ case 398: { struct linux_shmdt_args *p = params; uarg[0] = (intptr_t) p->shmaddr; /* char * */ *n_args = 1; break; } /* linux_msgget */ case 399: { struct linux_msgget_args *p = params; iarg[0] = p->key; /* l_key_t */ iarg[1] = p->msgflg; /* l_int */ *n_args = 2; break; } /* linux_msgsnd */ case 400: { struct linux_msgsnd_args *p = params; iarg[0] = p->msqid; /* l_int */ uarg[1] = (intptr_t) p->msgp; /* struct l_msgbuf * */ iarg[2] = p->msgsz; /* l_size_t */ iarg[3] = p->msgflg; /* l_int */ *n_args = 4; break; } /* linux_msgrcv */ case 401: { struct linux_msgrcv_args *p = params; iarg[0] = p->msqid; /* l_int */ uarg[1] = (intptr_t) p->msgp; /* struct l_msgbuf * */ iarg[2] = p->msgsz; /* l_size_t */ iarg[3] = p->msgtyp; /* l_long */ iarg[4] = p->msgflg; /* l_int */ *n_args = 5; break; } /* linux_msgctl */ case 402: { struct linux_msgctl_args *p = params; iarg[0] = p->msqid; /* l_int */ iarg[1] = p->cmd; /* l_int */ uarg[2] = (intptr_t) p->buf; /* struct l_msqid_ds * */ *n_args = 3; break; } /* linux_clock_gettime64 */ case 403: { *n_args = 0; break; } /* linux_clock_settime64 */ case 404: { *n_args = 0; break; } /* linux_clock_adjtime64 */ case 405: { *n_args = 0; break; } /* linux_clock_getres_time64 */ case 406: { *n_args = 0; break; } /* linux_clock_nanosleep_time64 */ case 407: { *n_args = 0; break; } /* linux_timer_gettime64 */ case 408: { *n_args = 0; break; } /* linux_timer_settime64 */ case 409: { *n_args = 0; break; } /* linux_timerfd_gettime64 */ case 410: { *n_args = 0; break; } /* linux_timerfd_settime64 */ case 411: { *n_args = 0; break; } /* linux_utimensat_time64 */ case 412: { *n_args = 0; break; } /* linux_pselect6_time64 */ case 413: { *n_args = 0; break; } /* linux_ppoll_time64 */ case 414: { *n_args = 0; break; } /* linux_io_pgetevents_time64 */ case 416: { *n_args = 0; break; } /* linux_recvmmsg_time64 */ case 417: { *n_args = 0; break; } /* linux_mq_timedsend_time64 */ case 418: { *n_args = 0; break; } /* linux_mq_timedreceive_time64 */ case 419: { *n_args = 0; break; } /* linux_semtimedop_time64 */ case 420: { *n_args = 0; break; } /* linux_rt_sigtimedwait_time64 */ case 421: { *n_args = 0; break; } /* linux_futex_time64 */ case 422: { *n_args = 0; break; } /* linux_sched_rr_get_interval_time64 */ case 423: { *n_args = 0; break; } /* linux_pidfd_send_signal */ case 424: { struct linux_pidfd_send_signal_args *p = params; iarg[0] = p->pidfd; /* l_int */ iarg[1] = p->sig; /* l_int */ uarg[2] = (intptr_t) p->info; /* l_siginfo_t * */ iarg[3] = 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; } default: *n_args = 0; break; }; } static void systrace_entry_setargdesc(int sysnum, int ndx, char *desc, size_t descsz) { const char *p = NULL; switch (sysnum) { #define nosys linux_nosys /* linux_exit */ case 1: switch(ndx) { case 0: p = "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 = "u_int"; break; default: break; }; break; /* write */ case 4: switch(ndx) { case 0: p = "int"; break; case 1: p = "userland char *"; break; case 2: p = "u_int"; 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_int"; break; default: break; }; break; /* close */ case 6: switch(ndx) { case 0: p = "int"; break; default: break; }; break; /* linux_waitpid */ case 7: switch(ndx) { case 0: p = "l_pid_t"; break; case 1: p = "userland l_int *"; break; case 2: p = "l_int"; break; default: break; }; break; /* linux_creat */ case 8: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_int"; 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 uint32_t *"; break; case 2: p = "userland uint32_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_int"; break; case 2: p = "l_dev_t"; 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_lchown16 */ case 16: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_uid16_t"; break; case 2: p = "l_gid16_t"; break; default: break; }; break; /* linux_stat */ case 18: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "userland struct linux_stat *"; 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_oldumount */ case 22: switch(ndx) { case 0: p = "userland char *"; break; default: break; }; break; /* linux_setuid16 */ case 23: switch(ndx) { case 0: p = "l_uid16_t"; break; default: break; }; break; /* linux_getuid16 */ case 24: break; /* linux_stime */ case 25: break; /* linux_ptrace */ case 26: switch(ndx) { case 0: p = "l_long"; break; case 1: p = "l_long"; break; case 2: p = "l_long"; break; case 3: p = "l_long"; break; default: break; }; break; /* linux_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; /* linux_nice */ case 34: switch(ndx) { case 0: p = "l_int"; break; default: break; }; break; /* sync */ case 36: break; /* linux_kill */ case 37: switch(ndx) { case 0: p = "l_int"; 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_int"; 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; /* linux_setgid16 */ case 46: switch(ndx) { case 0: p = "l_gid16_t"; break; default: break; }; break; /* linux_getgid16 */ case 47: break; /* linux_signal */ case 48: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_handler_t"; break; default: break; }; break; /* linux_geteuid16 */ case 49: break; /* linux_getegid16 */ case 50: break; /* acct */ case 51: switch(ndx) { case 0: p = "userland char *"; break; default: break; }; break; /* linux_umount */ case 52: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_int"; 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 = "uintptr_t"; 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 = "uintptr_t"; break; default: break; }; break; /* setpgid */ case 57: switch(ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* linux_olduname */ case 59: 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_dev_t"; 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; /* linux_sigaction */ case 67: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland l_osigaction_t *"; break; case 2: p = "userland l_osigaction_t *"; break; default: break; }; break; /* linux_sgetmask */ case 68: break; /* linux_ssetmask */ case 69: switch(ndx) { case 0: p = "l_osigset_t"; break; default: break; }; break; /* linux_setreuid16 */ case 70: switch(ndx) { case 0: p = "l_uid16_t"; break; case 1: p = "l_uid16_t"; break; default: break; }; break; /* linux_setregid16 */ case 71: switch(ndx) { case 0: p = "l_gid16_t"; break; case 1: p = "l_gid16_t"; break; default: break; }; break; /* linux_sigsuspend */ case 72: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: p = "l_osigset_t"; break; default: break; }; break; /* linux_sigpending */ case 73: switch(ndx) { case 0: p = "userland l_osigset_t *"; break; default: break; }; break; /* linux_sethostname */ case 74: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "u_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_old_getrlimit */ case 76: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland struct l_rlimit *"; break; default: break; }; break; /* linux_getrusage */ case 77: switch(ndx) { case 0: p = "int"; break; case 1: p = "userland struct l_rusage *"; break; default: break; }; break; /* linux_gettimeofday */ case 78: switch(ndx) { case 0: p = "userland struct l_timeval *"; break; case 1: p = "userland struct timezone *"; break; default: break; }; break; /* linux_settimeofday */ case 79: switch(ndx) { case 0: p = "userland struct l_timeval *"; break; case 1: p = "userland struct timezone *"; break; default: break; }; break; /* linux_getgroups16 */ case 80: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland l_gid16_t *"; break; default: break; }; break; /* linux_setgroups16 */ case 81: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland l_gid16_t *"; break; default: break; }; break; /* linux_old_select */ case 82: switch(ndx) { case 0: p = "userland struct l_old_select_argv *"; 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_lstat */ case 84: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "userland struct linux_lstat *"; 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_readdir */ case 89: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland struct l_dirent *"; break; case 2: p = "l_uint"; break; default: break; }; break; /* linux_mmap */ case 90: switch(ndx) { case 0: p = "userland struct l_mmap_argv *"; break; default: break; }; break; /* munmap */ case 91: switch(ndx) { case 0: p = "caddr_t"; break; case 1: p = "int"; break; default: break; }; break; /* linux_truncate */ case 92: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_ulong"; break; default: break; }; break; /* linux_ftruncate */ case 93: switch(ndx) { case 0: p = "int"; break; case 1: p = "long"; 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 = "int"; break; case 1: p = "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_socketcall */ case 102: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_ulong"; break; default: break; }; 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_uname */ case 109: break; /* linux_iopl */ case 110: switch(ndx) { case 0: p = "l_int"; 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 l_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; /* linux_ipc */ case 117: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "l_int"; break; case 2: p = "l_int"; break; case 3: p = "l_uint"; break; case 4: p = "l_uintptr_t"; break; case 5: p = "l_uint"; break; default: break; }; break; /* fsync */ case 118: switch(ndx) { case 0: p = "int"; break; default: break; }; break; /* linux_sigreturn */ case 119: switch(ndx) { case 0: p = "userland struct l_sigframe *"; break; default: break; }; break; /* linux_clone */ case 120: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland void *"; break; case 2: p = "userland void *"; break; case 3: p = "userland void *"; break; case 4: p = "userland void *"; break; default: break; }; break; /* linux_setdomainname */ case 121: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "int"; break; default: break; }; break; /* linux_newuname */ case 122: switch(ndx) { case 0: p = "userland struct l_new_utsname *"; break; default: break; }; break; /* linux_adjtimex */ case 124: break; /* linux_mprotect */ case 125: switch(ndx) { case 0: p = "caddr_t"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* linux_sigprocmask */ case 126: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland l_osigset_t *"; break; case 2: p = "userland l_osigset_t *"; 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_bdflush */ case 134: break; /* linux_sysfs */ case 135: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_ulong"; break; case 2: p = "l_ulong"; break; default: break; }; break; /* linux_personality */ case 136: switch(ndx) { case 0: p = "l_uint"; break; default: break; }; break; /* linux_setfsuid16 */ case 138: switch(ndx) { case 0: p = "l_uid16_t"; break; default: break; }; break; /* linux_setfsgid16 */ case 139: switch(ndx) { case 0: p = "l_gid16_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; /* linux_select */ case 142: 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; /* 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; /* linux_readv */ case 145: switch(ndx) { case 0: p = "l_ulong"; break; case 1: p = "userland struct l_iovec32 *"; break; case 2: p = "l_ulong"; break; default: break; }; break; /* linux_writev */ case 146: switch(ndx) { case 0: p = "l_ulong"; break; case 1: p = "userland struct l_iovec32 *"; break; case 2: p = "l_ulong"; 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; /* linux_setresuid16 */ case 164: switch(ndx) { case 0: p = "l_uid16_t"; break; case 1: p = "l_uid16_t"; break; case 2: p = "l_uid16_t"; break; default: break; }; break; /* linux_getresuid16 */ case 165: switch(ndx) { case 0: p = "userland l_uid16_t *"; break; case 1: p = "userland l_uid16_t *"; break; case 2: p = "userland l_uid16_t *"; break; default: break; }; break; /* poll */ case 168: switch(ndx) { case 0: p = "userland struct pollfd *"; break; case 1: p = "unsigned int"; break; case 2: p = "int"; break; default: break; }; break; /* linux_setresgid16 */ case 170: switch(ndx) { case 0: p = "l_gid16_t"; break; case 1: p = "l_gid16_t"; break; case 2: p = "l_gid16_t"; break; default: break; }; break; /* linux_getresgid16 */ case 171: switch(ndx) { case 0: p = "userland l_gid16_t *"; break; case 1: p = "userland l_gid16_t *"; break; case 2: p = "userland l_gid16_t *"; break; default: break; }; break; /* linux_prctl */ case 172: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: p = "l_int"; break; case 3: p = "l_int"; break; case 4: p = "l_int"; break; default: break; }; break; /* linux_rt_sigreturn */ case 173: switch(ndx) { case 0: p = "userland struct l_ucontext *"; break; default: break; }; break; /* linux_rt_sigaction */ case 174: 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 175: 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 176: switch(ndx) { case 0: p = "userland l_sigset_t *"; break; case 1: p = "l_size_t"; break; default: break; }; break; /* linux_rt_sigtimedwait */ case 177: switch(ndx) { case 0: p = "userland l_sigset_t *"; break; case 1: p = "userland l_siginfo_t *"; break; case 2: p = "userland struct l_timeval *"; break; case 3: p = "l_size_t"; break; default: break; }; break; /* linux_rt_sigqueueinfo */ case 178: 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 179: switch(ndx) { case 0: p = "userland l_sigset_t *"; break; case 1: p = "l_size_t"; break; default: break; }; break; /* linux_pread */ 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"; + p = "uint32_t"; break; + case 4: + p = "uint32_t"; + break; default: break; }; break; /* linux_pwrite */ case 181: 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"; + p = "uint32_t"; break; + case 4: + p = "uint32_t"; + break; default: break; }; break; /* linux_chown16 */ case 182: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_uid16_t"; break; case 2: p = "l_gid16_t"; break; default: break; }; break; /* linux_getcwd */ case 183: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "l_ulong"; break; default: break; }; break; /* linux_capget */ 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_capset */ case 185: 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 186: switch(ndx) { case 0: p = "userland l_stack_t *"; break; case 1: p = "userland l_stack_t *"; break; default: break; }; break; /* linux_sendfile */ case 187: break; /* linux_vfork */ case 190: break; /* linux_getrlimit */ case 191: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland struct l_rlimit *"; break; default: break; }; 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_truncate64 */ case 193: switch(ndx) { case 0: p = "userland char *"; break; case 1: - p = "l_loff_t"; + p = "uint32_t"; break; + case 2: + p = "uint32_t"; + break; default: break; }; break; /* linux_ftruncate64 */ case 194: switch(ndx) { case 0: p = "l_uint"; break; case 1: - p = "l_loff_t"; + p = "uint32_t"; break; + case 2: + p = "uint32_t"; + break; default: break; }; break; /* linux_stat64 */ case 195: switch(ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland struct l_stat64 *"; break; default: break; }; break; /* linux_lstat64 */ case 196: switch(ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland struct l_stat64 *"; break; default: break; }; break; /* linux_fstat64 */ case 197: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland struct l_stat64 *"; break; default: break; }; break; /* linux_lchown */ case 198: 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_getuid */ case 199: break; /* linux_getgid */ case 200: break; /* geteuid */ case 201: break; /* getegid */ case 202: break; /* setreuid */ case 203: switch(ndx) { case 0: p = "uid_t"; break; case 1: p = "uid_t"; break; default: break; }; break; /* setregid */ case 204: switch(ndx) { case 0: p = "gid_t"; break; case 1: p = "gid_t"; break; default: break; }; break; /* linux_getgroups */ case 205: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland l_gid_t *"; break; default: break; }; break; /* linux_setgroups */ case 206: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland l_gid_t *"; break; default: break; }; break; /* fchown */ case 207: break; /* setresuid */ case 208: 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 209: 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; /* setresgid */ case 210: 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 211: 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_chown */ case 212: 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; /* setuid */ case 213: switch(ndx) { case 0: p = "uid_t"; break; default: break; }; break; /* setgid */ case 214: switch(ndx) { case 0: p = "gid_t"; break; default: break; }; break; /* linux_setfsuid */ case 215: switch(ndx) { case 0: p = "l_uid_t"; break; default: break; }; break; /* linux_setfsgid */ case 216: switch(ndx) { case 0: p = "l_gid_t"; break; default: break; }; break; /* linux_pivot_root */ case 217: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "userland char *"; break; default: break; }; break; /* linux_mincore */ case 218: 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; /* madvise */ case 219: switch(ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* linux_getdents64 */ case 220: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "userland void *"; break; case 2: p = "l_uint"; break; default: break; }; break; /* linux_fcntl64 */ case 221: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "l_uint"; break; case 2: p = "uintptr_t"; break; default: break; }; break; /* linux_gettid */ case 224: break; /* linux_setxattr */ case 226: break; /* linux_lsetxattr */ case 227: break; /* linux_fsetxattr */ case 228: break; /* linux_getxattr */ case 229: break; /* linux_lgetxattr */ case 230: break; /* linux_fgetxattr */ case 231: break; /* linux_listxattr */ case 232: break; /* linux_llistxattr */ case 233: break; /* linux_flistxattr */ case 234: break; /* linux_removexattr */ case 235: break; /* linux_lremovexattr */ case 236: break; /* linux_fremovexattr */ case 237: break; /* linux_tkill */ case 238: switch(ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* linux_sys_futex */ case 240: switch(ndx) { case 0: p = "userland void *"; break; case 1: p = "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 241: 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 242: 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_thread_area */ case 243: switch(ndx) { case 0: p = "userland struct l_user_desc *"; break; default: break; }; break; /* linux_fadvise64 */ case 250: switch(ndx) { case 0: p = "int"; break; case 1: - p = "l_loff_t"; + p = "uint32_t"; break; case 2: - p = "l_size_t"; + p = "uint32_t"; break; case 3: + p = "l_size_t"; + break; + case 4: p = "int"; break; default: break; }; break; /* linux_exit_group */ case 252: switch(ndx) { case 0: p = "int"; break; default: break; }; break; /* linux_lookup_dcookie */ case 253: break; /* linux_epoll_create */ case 254: switch(ndx) { case 0: p = "l_int"; break; default: break; }; break; /* linux_epoll_ctl */ case 255: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: p = "l_int"; break; case 3: p = "userland struct epoll_event *"; break; default: break; }; break; /* linux_epoll_wait */ case 256: 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 257: break; /* linux_set_tid_address */ case 258: switch(ndx) { case 0: p = "userland int *"; break; default: break; }; break; /* linux_timer_create */ case 259: 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 260: 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 261: switch(ndx) { case 0: p = "l_timer_t"; break; case 1: p = "userland struct itimerspec *"; break; default: break; }; break; /* linux_timer_getoverrun */ case 262: switch(ndx) { case 0: p = "l_timer_t"; break; default: break; }; break; /* linux_timer_delete */ case 263: switch(ndx) { case 0: p = "l_timer_t"; break; default: break; }; break; /* linux_clock_settime */ case 264: switch(ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct l_timespec *"; break; default: break; }; break; /* linux_clock_gettime */ case 265: switch(ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct l_timespec *"; break; default: break; }; break; /* linux_clock_getres */ case 266: switch(ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct l_timespec *"; break; default: break; }; break; /* linux_clock_nanosleep */ case 267: switch(ndx) { case 0: p = "clockid_t"; break; case 1: p = "int"; break; case 2: p = "userland struct l_timespec *"; break; case 3: p = "userland struct l_timespec *"; break; default: break; }; break; /* linux_statfs64 */ case 268: 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 269: 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_tgkill */ case 270: switch(ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* linux_utimes */ case 271: switch(ndx) { case 0: p = "userland char *"; break; case 1: p = "userland struct l_timeval *"; break; default: break; }; break; /* linux_fadvise64_64 */ case 272: switch(ndx) { case 0: p = "int"; break; case 1: - p = "l_loff_t"; + p = "uint32_t"; break; case 2: - p = "l_loff_t"; + p = "uint32_t"; break; case 3: + p = "uint32_t"; + break; + case 4: + p = "uint32_t"; + break; + case 5: p = "int"; break; default: break; }; break; /* linux_mbind */ case 274: break; /* linux_get_mempolicy */ case 275: break; /* linux_set_mempolicy */ case 276: break; /* linux_mq_open */ case 277: break; /* linux_mq_unlink */ case 278: break; /* linux_mq_timedsend */ case 279: break; /* linux_mq_timedreceive */ case 280: break; /* linux_mq_notify */ case 281: break; /* linux_mq_getsetattr */ case 282: break; /* linux_kexec_load */ case 283: break; /* linux_waitid */ case 284: switch(ndx) { case 0: p = "int"; break; case 1: p = "l_pid_t"; break; case 2: p = "userland l_siginfo_t *"; break; case 3: p = "int"; break; case 4: p = "userland struct l_rusage *"; break; default: break; }; break; /* linux_add_key */ case 286: break; /* linux_request_key */ case 287: break; /* linux_keyctl */ case 288: break; /* linux_ioprio_set */ case 289: break; /* linux_ioprio_get */ case 290: break; /* linux_inotify_init */ case 291: break; /* linux_inotify_add_watch */ case 292: break; /* linux_inotify_rm_watch */ case 293: break; /* linux_migrate_pages */ case 294: break; /* linux_openat */ case 295: 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_mkdirat */ case 296: 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_mknodat */ case 297: 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_uint"; break; default: break; }; break; /* linux_fchownat */ case 298: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland const char *"; break; case 2: p = "l_uid16_t"; break; case 3: p = "l_gid16_t"; break; case 4: p = "l_int"; break; default: break; }; break; /* linux_futimesat */ case 299: 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_fstatat64 */ case 300: 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 301: 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 302: 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 303: 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 304: 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 305: 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 306: 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 307: 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_pselect6 */ case 308: 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 309: switch(ndx) { case 0: p = "userland struct pollfd *"; break; case 1: p = "uint32_t"; 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 310: break; /* linux_set_robust_list */ case 311: switch(ndx) { case 0: p = "userland struct linux_robust_list_head *"; break; case 1: p = "l_size_t"; break; default: break; }; break; /* linux_get_robust_list */ case 312: 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_splice */ case 313: break; /* linux_sync_file_range */ case 314: switch(ndx) { case 0: p = "l_int"; break; case 1: - p = "l_loff_t"; + p = "uint32_t"; break; case 2: - p = "l_loff_t"; + p = "uint32_t"; break; case 3: + p = "uint32_t"; + break; + case 4: + p = "uint32_t"; + break; + case 5: p = "unsigned int"; break; default: break; }; break; /* linux_tee */ case 315: break; /* linux_vmsplice */ case 316: break; /* linux_move_pages */ case 317: break; /* linux_getcpu */ case 318: break; /* linux_epoll_pwait */ case 319: 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 320: 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_signalfd */ case 321: break; /* linux_timerfd_create */ case 322: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_eventfd */ case 323: switch(ndx) { case 0: p = "l_uint"; break; default: break; }; break; /* linux_fallocate */ case 324: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: - p = "l_loff_t"; + p = "uint32_t"; break; case 3: - p = "l_loff_t"; + p = "uint32_t"; + break; + case 4: + p = "uint32_t"; + break; + case 5: + p = "uint32_t"; break; default: break; }; break; /* linux_timerfd_settime */ case 325: 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 326: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland struct l_itimerspec *"; break; default: break; }; break; /* linux_signalfd4 */ case 327: break; /* linux_eventfd2 */ case 328: switch(ndx) { case 0: p = "l_uint"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_epoll_create1 */ case 329: switch(ndx) { case 0: p = "l_int"; break; default: break; }; break; /* linux_dup3 */ case 330: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: p = "l_int"; break; default: break; }; break; /* linux_pipe2 */ case 331: switch(ndx) { case 0: p = "userland l_int *"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_inotify_init1 */ case 332: break; /* linux_preadv */ case 333: 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 334: 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 335: 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_perf_event_open */ case 336: break; /* linux_recvmmsg */ case 337: 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_fanotify_init */ case 338: break; /* linux_fanotify_mark */ case 339: break; /* linux_prlimit64 */ case 340: 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_name_to_handle_at */ case 341: break; /* linux_open_by_handle_at */ case 342: break; /* linux_clock_adjtime */ case 343: break; /* linux_syncfs */ case 344: switch(ndx) { case 0: p = "l_int"; break; default: break; }; break; /* linux_sendmmsg */ case 345: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "userland struct l_mmsghdr *"; break; case 2: p = "l_uint"; break; case 3: p = "l_uint"; break; default: break; }; break; /* linux_setns */ case 346: break; /* linux_process_vm_readv */ case 347: 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 348: 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_kcmp */ case 349: 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_finit_module */ case 350: 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_sched_setattr */ case 351: 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 352: 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 353: 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 = "unsigned int"; break; default: break; }; break; /* linux_seccomp */ case 354: 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 355: 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 356: switch(ndx) { case 0: p = "userland const char *"; break; case 1: p = "l_uint"; break; default: break; }; break; /* linux_bpf */ case 357: 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 358: 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_socket */ case 359: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; case 2: p = "l_int"; break; default: break; }; break; /* linux_socketpair */ case 360: 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_bind */ case 361: 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 362: 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 363: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_accept4 */ case 364: 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_getsockopt */ case 365: 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_setsockopt */ case 366: 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_getsockname */ case 367: 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 368: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_uintptr_t"; break; case 2: p = "l_uintptr_t"; break; default: break; }; break; /* linux_sendto */ case 369: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_uintptr_t"; break; case 2: p = "l_int"; break; case 3: p = "l_int"; break; case 4: p = "l_uintptr_t"; break; case 5: p = "l_int"; break; default: break; }; break; /* linux_sendmsg */ case 370: 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_recvfrom */ case 371: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_uintptr_t"; break; case 2: p = "l_size_t"; break; case 3: p = "l_int"; break; case 4: p = "l_uintptr_t"; break; case 5: p = "l_uintptr_t"; break; default: break; }; break; /* linux_recvmsg */ case 372: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_uintptr_t"; break; case 2: p = "l_int"; break; default: break; }; break; /* linux_shutdown */ case 373: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_userfaultfd */ case 374: switch(ndx) { case 0: p = "l_int"; break; default: break; }; break; /* linux_membarrier */ case 375: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_int"; break; default: break; }; break; /* linux_mlock2 */ case 376: 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 377: 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 378: 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 379: 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_pkey_mprotect */ case 380: 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_pkey_alloc */ case 381: switch(ndx) { case 0: p = "l_ulong"; break; case 1: p = "l_ulong"; break; default: break; }; break; /* linux_pkey_free */ case 382: switch(ndx) { case 0: 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_arch_prctl */ case 384: switch(ndx) { case 0: p = "l_int"; break; case 1: p = "l_ulong"; break; default: break; }; break; /* linux_io_pgetevents */ case 385: break; /* linux_rseq */ case 386: 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_clock_gettime64 */ case 403: break; /* linux_clock_settime64 */ case 404: break; /* linux_clock_adjtime64 */ case 405: break; /* linux_clock_getres_time64 */ case 406: break; /* linux_clock_nanosleep_time64 */ case 407: break; /* linux_timer_gettime64 */ case 408: break; /* linux_timer_settime64 */ case 409: break; /* linux_timerfd_gettime64 */ case 410: break; /* linux_timerfd_settime64 */ case 411: break; /* linux_utimensat_time64 */ case 412: break; /* linux_pselect6_time64 */ case 413: break; /* linux_ppoll_time64 */ case 414: break; /* linux_io_pgetevents_time64 */ case 416: break; /* linux_recvmmsg_time64 */ case 417: break; /* linux_mq_timedsend_time64 */ case 418: break; /* linux_mq_timedreceive_time64 */ case 419: break; /* linux_semtimedop_time64 */ case 420: break; /* linux_rt_sigtimedwait_time64 */ case 421: break; /* linux_futex_time64 */ case 422: break; /* linux_sched_rr_get_interval_time64 */ case 423: 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; default: break; }; if (p != NULL) strlcpy(desc, p, descsz); } static void systrace_return_setargdesc(int sysnum, int ndx, char *desc, size_t descsz) { const char *p = NULL; switch (sysnum) { #define nosys linux_nosys /* linux_exit */ case 1: if (ndx == 0 || ndx == 1) p = "void"; break; /* linux_fork */ case 2: /* read */ case 3: if (ndx == 0 || ndx == 1) p = "int"; break; /* 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_waitpid */ case 7: 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_lchown16 */ case 16: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_stat */ case 18: 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_oldumount */ case 22: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setuid16 */ case 23: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getuid16 */ case 24: /* linux_stime */ case 25: /* 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; /* linux_nice */ case 34: 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; /* linux_setgid16 */ case 46: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getgid16 */ case 47: /* linux_signal */ case 48: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_geteuid16 */ case 49: /* linux_getegid16 */ case 50: /* acct */ case 51: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_umount */ case 52: 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; /* linux_olduname */ case 59: /* 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: /* linux_sigaction */ case 67: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sgetmask */ case 68: /* linux_ssetmask */ case 69: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setreuid16 */ case 70: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setregid16 */ case 71: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sigsuspend */ case 72: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sigpending */ case 73: 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_old_getrlimit */ case 76: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getrusage */ case 77: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_gettimeofday */ case 78: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_settimeofday */ case 79: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getgroups16 */ case 80: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setgroups16 */ case 81: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_old_select */ case 82: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_symlink */ case 83: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_lstat */ case 84: 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_readdir */ case 89: 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_socketcall */ case 102: if (ndx == 0 || ndx == 1) p = "int"; break; /* 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_uname */ case 109: /* 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; /* linux_ipc */ case 117: if (ndx == 0 || ndx == 1) p = "int"; break; /* fsync */ case 118: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sigreturn */ case 119: 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_adjtimex */ case 124: /* linux_mprotect */ case 125: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sigprocmask */ case 126: 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_bdflush */ case 134: /* linux_sysfs */ case 135: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_personality */ case 136: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setfsuid16 */ case 138: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setfsgid16 */ 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; /* linux_select */ case 142: 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; /* linux_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; /* linux_setresuid16 */ case 164: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getresuid16 */ case 165: if (ndx == 0 || ndx == 1) p = "int"; break; /* poll */ case 168: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setresgid16 */ case 170: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getresgid16 */ case 171: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_prctl */ case 172: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigreturn */ case 173: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigaction */ case 174: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigprocmask */ case 175: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigpending */ case 176: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigtimedwait */ case 177: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigqueueinfo */ case 178: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_sigsuspend */ case 179: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pread */ case 180: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pwrite */ case 181: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_chown16 */ case 182: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getcwd */ case 183: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_capget */ case 184: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_capset */ case 185: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sigaltstack */ case 186: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sendfile */ case 187: /* linux_vfork */ case 190: /* linux_getrlimit */ case 191: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mmap2 */ case 192: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_truncate64 */ case 193: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_ftruncate64 */ case 194: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_stat64 */ case 195: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_lstat64 */ case 196: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fstat64 */ case 197: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_lchown */ case 198: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getuid */ case 199: /* linux_getgid */ case 200: /* geteuid */ case 201: /* getegid */ case 202: /* setreuid */ case 203: if (ndx == 0 || ndx == 1) p = "int"; break; /* setregid */ case 204: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getgroups */ case 205: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setgroups */ case 206: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchown */ case 207: /* setresuid */ case 208: if (ndx == 0 || ndx == 1) p = "int"; break; /* getresuid */ case 209: if (ndx == 0 || ndx == 1) p = "int"; break; /* setresgid */ case 210: if (ndx == 0 || ndx == 1) p = "int"; break; /* getresgid */ case 211: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_chown */ case 212: if (ndx == 0 || ndx == 1) p = "int"; break; /* setuid */ case 213: if (ndx == 0 || ndx == 1) p = "int"; break; /* setgid */ case 214: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setfsuid */ case 215: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setfsgid */ case 216: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pivot_root */ case 217: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mincore */ case 218: if (ndx == 0 || ndx == 1) p = "int"; break; /* madvise */ case 219: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getdents64 */ case 220: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fcntl64 */ case 221: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_gettid */ case 224: /* linux_setxattr */ case 226: /* linux_lsetxattr */ case 227: /* linux_fsetxattr */ case 228: /* linux_getxattr */ case 229: /* linux_lgetxattr */ case 230: /* linux_fgetxattr */ case 231: /* linux_listxattr */ case 232: /* linux_llistxattr */ case 233: /* linux_flistxattr */ case 234: /* linux_removexattr */ case 235: /* linux_lremovexattr */ case 236: /* linux_fremovexattr */ case 237: /* linux_tkill */ case 238: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sys_futex */ case 240: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sched_setaffinity */ case 241: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sched_getaffinity */ case 242: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_set_thread_area */ case 243: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fadvise64 */ case 250: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_exit_group */ case 252: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_lookup_dcookie */ case 253: /* linux_epoll_create */ case 254: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_epoll_ctl */ case 255: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_epoll_wait */ case 256: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_remap_file_pages */ case 257: /* linux_set_tid_address */ case 258: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timer_create */ case 259: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timer_settime */ case 260: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timer_gettime */ case 261: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timer_getoverrun */ case 262: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timer_delete */ case 263: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_clock_settime */ case 264: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_clock_gettime */ case 265: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_clock_getres */ case 266: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_clock_nanosleep */ case 267: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_statfs64 */ case 268: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fstatfs64 */ case 269: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_tgkill */ case 270: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_utimes */ case 271: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fadvise64_64 */ case 272: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mbind */ case 274: /* linux_get_mempolicy */ case 275: /* linux_set_mempolicy */ case 276: /* linux_mq_open */ case 277: /* linux_mq_unlink */ case 278: /* linux_mq_timedsend */ case 279: /* linux_mq_timedreceive */ case 280: /* linux_mq_notify */ case 281: /* linux_mq_getsetattr */ case 282: /* linux_kexec_load */ case 283: /* linux_waitid */ case 284: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_add_key */ case 286: /* linux_request_key */ case 287: /* linux_keyctl */ case 288: /* linux_ioprio_set */ case 289: /* linux_ioprio_get */ case 290: /* linux_inotify_init */ case 291: /* linux_inotify_add_watch */ case 292: /* linux_inotify_rm_watch */ case 293: /* linux_migrate_pages */ case 294: /* linux_openat */ case 295: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mkdirat */ case 296: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mknodat */ case 297: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fchownat */ case 298: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_futimesat */ case 299: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fstatat64 */ case 300: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_unlinkat */ case 301: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_renameat */ case 302: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_linkat */ case 303: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_symlinkat */ case 304: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_readlinkat */ case 305: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fchmodat */ case 306: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_faccessat */ case 307: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pselect6 */ case 308: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_ppoll */ case 309: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_unshare */ case 310: /* linux_set_robust_list */ case 311: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_get_robust_list */ case 312: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_splice */ case 313: /* linux_sync_file_range */ case 314: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_tee */ case 315: /* linux_vmsplice */ case 316: /* linux_move_pages */ case 317: /* linux_getcpu */ case 318: /* linux_epoll_pwait */ case 319: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_utimensat */ case 320: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_signalfd */ case 321: /* linux_timerfd_create */ case 322: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_eventfd */ case 323: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fallocate */ case 324: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timerfd_settime */ case 325: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_timerfd_gettime */ case 326: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_signalfd4 */ case 327: /* linux_eventfd2 */ case 328: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_epoll_create1 */ case 329: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_dup3 */ case 330: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pipe2 */ case 331: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_inotify_init1 */ case 332: /* linux_preadv */ case 333: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pwritev */ case 334: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_rt_tgsigqueueinfo */ case 335: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_perf_event_open */ case 336: /* linux_recvmmsg */ case 337: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_fanotify_init */ case 338: /* linux_fanotify_mark */ case 339: /* linux_prlimit64 */ case 340: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_name_to_handle_at */ case 341: /* linux_open_by_handle_at */ case 342: /* linux_clock_adjtime */ case 343: /* linux_syncfs */ case 344: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sendmmsg */ case 345: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setns */ case 346: /* linux_process_vm_readv */ case 347: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_process_vm_writev */ case 348: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_kcmp */ case 349: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_finit_module */ case 350: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sched_setattr */ case 351: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sched_getattr */ case 352: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_renameat2 */ case 353: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_seccomp */ case 354: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getrandom */ case 355: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_memfd_create */ case 356: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_bpf */ case 357: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_execveat */ case 358: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_socket */ case 359: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_socketpair */ case 360: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_bind */ case 361: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_connect */ case 362: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_listen */ case 363: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_accept4 */ case 364: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getsockopt */ case 365: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_setsockopt */ case 366: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getsockname */ case 367: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_getpeername */ case 368: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sendto */ case 369: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_sendmsg */ case 370: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_recvfrom */ case 371: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_recvmsg */ case 372: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_shutdown */ case 373: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_userfaultfd */ case 374: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_membarrier */ case 375: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_mlock2 */ case 376: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_copy_file_range */ case 377: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_preadv2 */ case 378: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pwritev2 */ case 379: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pkey_mprotect */ case 380: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pkey_alloc */ case 381: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_pkey_free */ case 382: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_statx */ case 383: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_arch_prctl */ case 384: if (ndx == 0 || ndx == 1) p = "int"; break; /* linux_io_pgetevents */ case 385: /* linux_rseq */ case 386: /* 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_clock_gettime64 */ case 403: /* linux_clock_settime64 */ case 404: /* linux_clock_adjtime64 */ case 405: /* linux_clock_getres_time64 */ case 406: /* linux_clock_nanosleep_time64 */ case 407: /* linux_timer_gettime64 */ case 408: /* linux_timer_settime64 */ case 409: /* linux_timerfd_gettime64 */ case 410: /* linux_timerfd_settime64 */ case 411: /* linux_utimensat_time64 */ case 412: /* linux_pselect6_time64 */ case 413: /* linux_ppoll_time64 */ case 414: /* linux_io_pgetevents_time64 */ case 416: /* linux_recvmmsg_time64 */ case 417: /* linux_mq_timedsend_time64 */ case 418: /* linux_mq_timedreceive_time64 */ case 419: /* linux_semtimedop_time64 */ case 420: /* linux_rt_sigtimedwait_time64 */ case 421: /* linux_futex_time64 */ case 422: /* linux_sched_rr_get_interval_time64 */ case 423: /* 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: default: break; }; if (p != NULL) strlcpy(desc, p, descsz); } Index: stable/12/sys/amd64/linux32/syscalls.master =================================================================== --- stable/12/sys/amd64/linux32/syscalls.master (revision 359604) +++ stable/12/sys/amd64/linux32/syscalls.master (revision 359605) @@ -1,750 +1,753 @@ $FreeBSD$ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; System call name/number master file (or rather, slave, from LINUX). ; Processed to create linux32_sysent.c, linux32_proto.h and linux32_syscall.h. ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; audit the audit event associated with the system call ; A value of AUE_NULL means no auditing, but it also means that ; there is no audit event for the call at this time. For the ; case where the event exists, but we don't want auditing, the ; event should be #defined to AUE_NULL in audit_kevents.h. ; type one of STD, NOPROTO, UNIMPL ; name pseudo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL, name continues with comments ; types: ; STD always included ; UNIMPL not implemented, placeholder only ; NOPROTO same as STD except do not create structure or ; function prototype in sys/sysproto.h. Does add a ; definition to syscall.h besides adding a sysent. #include #include #include #include #include #include ; Isn't pretty, but there seems to be no other way to trap nosys #define nosys linux_nosys ; #ifdef's, etc. may be included, and are copied to the output files. 0 AUE_NULL UNIMPL setup 1 AUE_EXIT STD { void linux_exit(int rval); } 2 AUE_FORK STD { int linux_fork(void); } 3 AUE_NULL NOPROTO { int read(int fd, char *buf, \ u_int nbyte); } 4 AUE_NULL NOPROTO { int write(int fd, char *buf, \ u_int nbyte); } 5 AUE_OPEN_RWTC STD { int linux_open(char *path, l_int flags, \ l_int mode); } 6 AUE_CLOSE NOPROTO { int close(int fd); } 7 AUE_WAIT4 STD { int linux_waitpid(l_pid_t pid, \ l_int *status, l_int options); } 8 AUE_CREAT STD { int linux_creat(char *path, \ l_int 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, uint32_t *argp, \ uint32_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_int mode, \ l_dev_t dev); } 15 AUE_CHMOD STD { int linux_chmod(char *path, \ l_mode_t mode); } 16 AUE_LCHOWN STD { int linux_lchown16(char *path, \ l_uid16_t uid, l_gid16_t gid); } 17 AUE_NULL UNIMPL break 18 AUE_STAT STD { int linux_stat(char *path, \ struct linux_stat *up); } 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_oldumount(char *path); } 23 AUE_SETUID STD { int linux_setuid16(l_uid16_t uid); } 24 AUE_GETUID STD { int linux_getuid16(void); } 25 AUE_SETTIMEOFDAY STD { int linux_stime(void); } 26 AUE_PTRACE STD { int linux_ptrace(l_long req, l_long pid, \ l_long addr, l_long data); } 27 AUE_NULL STD { int linux_alarm(l_uint secs); } 28 AUE_FSTAT UNIMPL fstat 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 stty 32 AUE_NULL UNIMPL gtty 33 AUE_ACCESS STD { int linux_access(char *path, l_int amode); } 34 AUE_NICE STD { int linux_nice(l_int inc); } 35 AUE_NULL UNIMPL ftime 36 AUE_SYNC NOPROTO { int sync(void); } 37 AUE_KILL STD { int linux_kill(l_int 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_int 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 prof 45 AUE_NULL STD { int linux_brk(l_ulong dsend); } 46 AUE_SETGID STD { int linux_setgid16(l_gid16_t gid); } 47 AUE_GETGID STD { int linux_getgid16(void); } 48 AUE_NULL STD { int linux_signal(l_int sig, \ l_handler_t handler); } 49 AUE_GETEUID STD { int linux_geteuid16(void); } 50 AUE_GETEGID STD { int linux_getegid16(void); } 51 AUE_ACCT NOPROTO { int acct(char *path); } 52 AUE_UMOUNT STD { int linux_umount(char *path, l_int flags); } 53 AUE_NULL UNIMPL lock 54 AUE_IOCTL STD { int linux_ioctl(l_uint fd, l_uint cmd, \ uintptr_t arg); } 55 AUE_FCNTL STD { int linux_fcntl(l_uint fd, l_uint cmd, \ uintptr_t arg); } 56 AUE_NULL UNIMPL mpx 57 AUE_SETPGRP NOPROTO { int setpgid(int pid, int pgid); } 58 AUE_NULL UNIMPL ulimit 59 AUE_NULL STD { int linux_olduname(void); } 60 AUE_UMASK NOPROTO { int umask(int newmask); } 61 AUE_CHROOT NOPROTO { int chroot(char *path); } 62 AUE_NULL STD { int linux_ustat(l_dev_t 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 STD { int linux_sigaction(l_int sig, \ l_osigaction_t *nsa, \ l_osigaction_t *osa); } 68 AUE_NULL STD { int linux_sgetmask(void); } 69 AUE_NULL STD { int linux_ssetmask(l_osigset_t mask); } 70 AUE_SETREUID STD { int linux_setreuid16(l_uid16_t ruid, \ l_uid16_t euid); } 71 AUE_SETREGID STD { int linux_setregid16(l_gid16_t rgid, \ l_gid16_t egid); } 72 AUE_NULL STD { int linux_sigsuspend(l_int hist0, \ l_int hist1, l_osigset_t mask); } 73 AUE_NULL STD { int linux_sigpending(l_osigset_t *mask); } 74 AUE_SYSCTL STD { int linux_sethostname(char *hostname, \ u_int len); } 75 AUE_SETRLIMIT STD { int linux_setrlimit(l_uint resource, \ struct l_rlimit *rlim); } 76 AUE_GETRLIMIT STD { int linux_old_getrlimit(l_uint resource, \ struct l_rlimit *rlim); } 77 AUE_GETRUSAGE STD { int linux_getrusage(int who, \ struct l_rusage *rusage); } 78 AUE_NULL STD { int linux_gettimeofday( \ struct l_timeval *tp, \ struct timezone *tzp); } 79 AUE_SETTIMEOFDAY STD { int linux_settimeofday( \ struct l_timeval *tp, \ struct timezone *tzp); } 80 AUE_GETGROUPS STD { int linux_getgroups16(l_uint gidsetsize, \ l_gid16_t *gidset); } 81 AUE_SETGROUPS STD { int linux_setgroups16(l_uint gidsetsize, \ l_gid16_t *gidset); } 82 AUE_SELECT STD { int linux_old_select( \ struct l_old_select_argv *ptr); } 83 AUE_SYMLINK STD { int linux_symlink(char *path, char *to); } ; 84: oldlstat 84 AUE_LSTAT STD { int linux_lstat(char *path, struct linux_lstat *up); } 85 AUE_READLINK STD { int linux_readlink(char *name, char *buf, \ l_int count); } 86 AUE_USELIB 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: old_readdir 89 AUE_GETDIRENTRIES STD { int linux_readdir(l_uint fd, \ struct l_dirent *dent, l_uint count); } ; 90: old_mmap 90 AUE_MMAP STD { int linux_mmap(struct l_mmap_argv *ptr); } 91 AUE_MUNMAP NOPROTO { int munmap(caddr_t addr, int len); } 92 AUE_TRUNCATE STD { int linux_truncate(char *path, \ l_ulong length); } 93 AUE_FTRUNCATE STD { int linux_ftruncate(int fd, long 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(int which, int who); } 97 AUE_SETPRIORITY NOPROTO { int setpriority(int which, int who, \ int prio); } 98 AUE_PROFILE UNIMPL 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 UNIMPL ioperm 102 AUE_NULL STD { int linux_socketcall(l_int what, \ l_ulong args); } 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: olduname 109 AUE_NULL STD { int linux_uname(void); } 110 AUE_NULL STD { int linux_iopl(l_int level); } 111 AUE_NULL STD { int linux_vhangup(void); } 112 AUE_NULL UNIMPL idle 113 AUE_NULL UNIMPL vm86old 114 AUE_WAIT4 STD { int linux_wait4(l_pid_t pid, \ l_int *status, l_int options, \ struct l_rusage *rusage); } 115 AUE_SWAPOFF STD { int linux_swapoff(void); } 116 AUE_NULL STD { int linux_sysinfo(struct l_sysinfo *info); } 117 AUE_NULL STD { int linux_ipc(l_uint what, l_int arg1, \ l_int arg2, l_uint arg3, l_uintptr_t ptr, \ l_uint arg5); } 118 AUE_FSYNC NOPROTO { int fsync(int fd); } 119 AUE_SIGRETURN STD { int linux_sigreturn( \ struct l_sigframe *sfp); } 120 AUE_RFORK STD { int linux_clone(l_int flags, void *stack, \ void *parent_tidptr, void *tls, void * child_tidptr); } 121 AUE_SYSCTL STD { int linux_setdomainname(char *name, \ int len); } 122 AUE_NULL STD { int linux_newuname( \ struct l_new_utsname *buf); } 123 AUE_NULL UNIMPL modify_ldt 124 AUE_ADJTIME STD { int linux_adjtimex(void); } 125 AUE_MPROTECT STD { int linux_mprotect(caddr_t addr, int len, \ int prot); } 126 AUE_SIGPROCMASK STD { int linux_sigprocmask(l_int how, \ l_osigset_t *mask, l_osigset_t *omask); } 127 AUE_NULL UNIMPL create_module 128 AUE_NULL STD { int linux_init_module(void); } 129 AUE_NULL STD { int linux_delete_module(void); } 130 AUE_NULL UNIMPL 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_BDFLUSH STD { int linux_bdflush(void); } 135 AUE_NULL STD { int linux_sysfs(l_int option, \ l_ulong arg1, l_ulong arg2); } 136 AUE_PERSONALITY STD { int linux_personality(l_uint per); } 137 AUE_NULL UNIMPL afs_syscall 138 AUE_SETFSUID STD { int linux_setfsuid16(l_uid16_t uid); } 139 AUE_SETFSGID STD { int linux_setfsgid16(l_gid16_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: newselect 142 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); } 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 STD { int linux_readv(l_ulong fd, struct l_iovec32 *iovp, \ l_ulong iovcnt); } 146 AUE_WRITEV STD { int linux_writev(l_ulong fd, struct l_iovec32 *iovp, \ l_ulong 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 STD { int linux_setresuid16(l_uid16_t ruid, \ l_uid16_t euid, l_uid16_t suid); } 165 AUE_GETRESUID STD { int linux_getresuid16(l_uid16_t *ruid, \ l_uid16_t *euid, l_uid16_t *suid); } 166 AUE_NULL UNIMPL vm86 167 AUE_NULL UNIMPL query_module 168 AUE_POLL NOPROTO { int poll(struct pollfd *fds, \ unsigned int nfds, int timeout); } 169 AUE_NULL UNIMPL nfsservctl 170 AUE_SETRESGID STD { int linux_setresgid16(l_gid16_t rgid, \ l_gid16_t egid, l_gid16_t sgid); } 171 AUE_GETRESGID STD { int linux_getresgid16(l_gid16_t *rgid, \ l_gid16_t *egid, l_gid16_t *sgid); } 172 AUE_PRCTL STD { int linux_prctl(l_int option, l_int arg2, l_int arg3, \ l_int arg4, l_int arg5); } 173 AUE_NULL STD { int linux_rt_sigreturn( \ struct l_ucontext *ucp); } 174 AUE_NULL STD { int linux_rt_sigaction(l_int sig, \ l_sigaction_t *act, l_sigaction_t *oact, \ l_size_t sigsetsize); } 175 AUE_NULL STD { int linux_rt_sigprocmask(l_int how, \ l_sigset_t *mask, l_sigset_t *omask, \ l_size_t sigsetsize); } 176 AUE_NULL STD { int linux_rt_sigpending(l_sigset_t *set, \ l_size_t sigsetsize); } 177 AUE_NULL STD { int linux_rt_sigtimedwait(l_sigset_t *mask, \ l_siginfo_t *ptr, \ struct l_timeval *timeout, \ l_size_t sigsetsize); } 178 AUE_NULL STD { int linux_rt_sigqueueinfo(l_pid_t pid, l_int sig, \ l_siginfo_t *info); } 179 AUE_NULL STD { int linux_rt_sigsuspend( \ l_sigset_t *newset, \ l_size_t sigsetsize); } 180 AUE_PREAD STD { int linux_pread(l_uint fd, char *buf, \ - l_size_t nbyte, l_loff_t offset); } + l_size_t nbyte, uint32_t offset1, uint32_t offset2); } 181 AUE_PWRITE STD { int linux_pwrite(l_uint fd, char *buf, \ - l_size_t nbyte, l_loff_t offset); } + l_size_t nbyte, uint32_t offset1, uint32_t offset2); } 182 AUE_CHOWN STD { int linux_chown16(char *path, \ l_uid16_t uid, l_gid16_t gid); } 183 AUE_GETCWD STD { int linux_getcwd(char *buf, \ l_ulong bufsize); } 184 AUE_CAPGET STD { int linux_capget(struct l_user_cap_header *hdrp, \ struct l_user_cap_data *datap); } 185 AUE_CAPSET STD { int linux_capset(struct l_user_cap_header *hdrp, \ struct l_user_cap_data *datap); } 186 AUE_NULL STD { int linux_sigaltstack(l_stack_t *uss, \ l_stack_t *uoss); } 187 AUE_SENDFILE STD { int linux_sendfile(void); } 188 AUE_GETPMSG UNIMPL getpmsg 189 AUE_PUTPMSG UNIMPL putpmsg 190 AUE_VFORK STD { int linux_vfork(void); } ; 191: ugetrlimit 191 AUE_GETRLIMIT STD { int linux_getrlimit(l_uint resource, \ struct l_rlimit *rlim); } 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_TRUNCATE STD { int linux_truncate64(char *path, \ - l_loff_t length); } + uint32_t length1, uint32_t length2); } 194 AUE_FTRUNCATE STD { int linux_ftruncate64(l_uint fd, \ - l_loff_t length); } + uint32_t length1, uint32_t length2); } 195 AUE_STAT STD { int linux_stat64(const char *filename, \ struct l_stat64 *statbuf); } 196 AUE_LSTAT STD { int linux_lstat64(const char *filename, \ struct l_stat64 *statbuf); } 197 AUE_FSTAT STD { int linux_fstat64(l_int fd, \ struct l_stat64 *statbuf); } 198 AUE_LCHOWN STD { int linux_lchown(char *path, l_uid_t uid, \ l_gid_t gid); } 199 AUE_GETUID STD { int linux_getuid(void); } 200 AUE_GETGID STD { int linux_getgid(void); } 201 AUE_GETEUID NOPROTO { int geteuid(void); } 202 AUE_GETEGID NOPROTO { int getegid(void); } 203 AUE_SETREUID NOPROTO { int setreuid(uid_t ruid, uid_t euid); } 204 AUE_SETREGID NOPROTO { int setregid(gid_t rgid, gid_t egid); } 205 AUE_GETGROUPS STD { int linux_getgroups(l_int gidsetsize, \ l_gid_t *grouplist); } 206 AUE_SETGROUPS STD { int linux_setgroups(l_int gidsetsize, \ l_gid_t *grouplist); } 207 AUE_FCHOWN NODEF fchown fchown fchown_args int 208 AUE_SETRESUID NOPROTO { int setresuid(uid_t ruid, uid_t euid, \ uid_t suid); } 209 AUE_GETRESUID NOPROTO { int getresuid(uid_t *ruid, uid_t *euid, \ uid_t *suid); } 210 AUE_SETRESGID NOPROTO { int setresgid(gid_t rgid, gid_t egid, \ gid_t sgid); } 211 AUE_GETRESGID NOPROTO { int getresgid(gid_t *rgid, gid_t *egid, \ gid_t *sgid); } 212 AUE_CHOWN STD { int linux_chown(char *path, l_uid_t uid, \ l_gid_t gid); } 213 AUE_SETUID NOPROTO { int setuid(uid_t uid); } 214 AUE_SETGID NOPROTO { int setgid(gid_t gid); } 215 AUE_SETFSUID STD { int linux_setfsuid(l_uid_t uid); } 216 AUE_SETFSGID STD { int linux_setfsgid(l_gid_t gid); } 217 AUE_PIVOT_ROOT STD { int linux_pivot_root(char *new_root, \ char *put_old); } 218 AUE_MINCORE STD { int linux_mincore(l_ulong start, \ l_size_t len, u_char *vec); } 219 AUE_MADVISE NOPROTO { int madvise(void *addr, size_t len, \ int behav); } 220 AUE_GETDIRENTRIES STD { int linux_getdents64(l_uint fd, \ void *dirent, l_uint count); } 221 AUE_FCNTL STD { int linux_fcntl64(l_uint fd, l_uint cmd, \ uintptr_t arg); } 222 AUE_NULL UNIMPL 223 AUE_NULL UNIMPL 224 AUE_NULL STD { long linux_gettid(void); } 225 AUE_NULL UNIMPL linux_readahead 226 AUE_NULL STD { int linux_setxattr(void); } 227 AUE_NULL STD { int linux_lsetxattr(void); } 228 AUE_NULL STD { int linux_fsetxattr(void); } 229 AUE_NULL STD { int linux_getxattr(void); } 230 AUE_NULL STD { int linux_lgetxattr(void); } 231 AUE_NULL STD { int linux_fgetxattr(void); } 232 AUE_NULL STD { int linux_listxattr(void); } 233 AUE_NULL STD { int linux_llistxattr(void); } 234 AUE_NULL STD { int linux_flistxattr(void); } 235 AUE_NULL STD { int linux_removexattr(void); } 236 AUE_NULL STD { int linux_lremovexattr(void); } 237 AUE_NULL STD { int linux_fremovexattr(void); } 238 AUE_NULL STD { int linux_tkill(int tid, int sig); } 239 AUE_SENDFILE UNIMPL linux_sendfile64 240 AUE_NULL STD { int linux_sys_futex(void *uaddr, int op, uint32_t val, \ struct l_timespec *timeout, uint32_t *uaddr2, uint32_t val3); } 241 AUE_NULL STD { int linux_sched_setaffinity(l_pid_t pid, l_uint len, \ l_ulong *user_mask_ptr); } 242 AUE_NULL STD { int linux_sched_getaffinity(l_pid_t pid, l_uint len, \ l_ulong *user_mask_ptr); } 243 AUE_NULL STD { int linux_set_thread_area(struct l_user_desc *desc); } 244 AUE_NULL UNIMPL linux_get_thread_area 245 AUE_NULL UNIMPL linux_io_setup 246 AUE_NULL UNIMPL linux_io_destroy 247 AUE_NULL UNIMPL linux_io_getevents 248 AUE_NULL UNIMPL linux_io_submit 249 AUE_NULL UNIMPL linux_io_cancel -250 AUE_NULL STD { int linux_fadvise64(int fd, l_loff_t offset, \ +250 AUE_NULL STD { int linux_fadvise64(int fd, uint32_t offset1, uint32_t offset2, \ l_size_t len, int advice); } 251 AUE_NULL UNIMPL 252 AUE_EXIT STD { int linux_exit_group(int error_code); } 253 AUE_NULL STD { int linux_lookup_dcookie(void); } 254 AUE_NULL STD { int linux_epoll_create(l_int size); } 255 AUE_NULL STD { int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \ struct epoll_event *event); } 256 AUE_NULL STD { int linux_epoll_wait(l_int epfd, struct epoll_event *events, \ l_int maxevents, l_int timeout); } 257 AUE_NULL STD { int linux_remap_file_pages(void); } 258 AUE_NULL STD { int linux_set_tid_address(int *tidptr); } 259 AUE_NULL STD { int linux_timer_create(clockid_t clock_id, \ struct sigevent *evp, l_timer_t *timerid); } 260 AUE_NULL STD { int linux_timer_settime(l_timer_t timerid, l_int flags, \ const struct itimerspec *new, struct itimerspec *old); } 261 AUE_NULL STD { int linux_timer_gettime(l_timer_t timerid, struct itimerspec *setting); } 262 AUE_NULL STD { int linux_timer_getoverrun(l_timer_t timerid); } 263 AUE_NULL STD { int linux_timer_delete(l_timer_t timerid); } 264 AUE_CLOCK_SETTIME STD { int linux_clock_settime(clockid_t which, struct l_timespec *tp); } 265 AUE_NULL STD { int linux_clock_gettime(clockid_t which, struct l_timespec *tp); } 266 AUE_NULL STD { int linux_clock_getres(clockid_t which, struct l_timespec *tp); } 267 AUE_NULL STD { int linux_clock_nanosleep(clockid_t which, int flags, \ struct l_timespec *rqtp, struct l_timespec *rmtp); } 268 AUE_STATFS STD { int linux_statfs64(char *path, size_t bufsize, struct l_statfs64_buf *buf); } 269 AUE_FSTATFS STD { int linux_fstatfs64(l_uint fd, size_t bufsize, struct l_statfs64_buf *buf); } 270 AUE_NULL STD { int linux_tgkill(int tgid, int pid, int sig); } 271 AUE_UTIMES STD { int linux_utimes(char *fname, \ struct l_timeval *tptr); } 272 AUE_NULL STD { int linux_fadvise64_64(int fd, \ - l_loff_t offset, l_loff_t len, \ + uint32_t offset1, uint32_t offset2, \ + uint32_t len1, uint32_t len2, \ int advice); } 273 AUE_NULL UNIMPL vserver 274 AUE_NULL STD { int linux_mbind(void); } 275 AUE_NULL STD { int linux_get_mempolicy(void); } 276 AUE_NULL STD { int linux_set_mempolicy(void); } ; Linux 2.6.6: 277 AUE_NULL STD { int linux_mq_open(void); } 278 AUE_NULL STD { int linux_mq_unlink(void); } 279 AUE_NULL STD { int linux_mq_timedsend(void); } 280 AUE_NULL STD { int linux_mq_timedreceive(void); } 281 AUE_NULL STD { int linux_mq_notify(void); } 282 AUE_NULL STD { int linux_mq_getsetattr(void); } 283 AUE_NULL STD { int linux_kexec_load(void); } 284 AUE_WAIT6 STD { int linux_waitid(int idtype, l_pid_t id, \ l_siginfo_t *info, int options, \ struct l_rusage *rusage); } 285 AUE_NULL UNIMPL ; Linux 2.6.11: 286 AUE_NULL STD { int linux_add_key(void); } 287 AUE_NULL STD { int linux_request_key(void); } 288 AUE_NULL STD { int linux_keyctl(void); } ; Linux 2.6.13: 289 AUE_NULL STD { int linux_ioprio_set(void); } 290 AUE_NULL STD { int linux_ioprio_get(void); } 291 AUE_NULL STD { int linux_inotify_init(void); } 292 AUE_NULL STD { int linux_inotify_add_watch(void); } 293 AUE_NULL STD { int linux_inotify_rm_watch(void); } ; Linux 2.6.16: 294 AUE_NULL STD { int linux_migrate_pages(void); } 295 AUE_OPEN_RWTC STD { int linux_openat(l_int dfd, const char *filename, \ l_int flags, l_int mode); } 296 AUE_MKDIRAT STD { int linux_mkdirat(l_int dfd, const char *pathname, \ l_int mode); } 297 AUE_MKNODAT STD { int linux_mknodat(l_int dfd, const char *filename, \ l_int mode, l_uint dev); } 298 AUE_FCHOWNAT STD { int linux_fchownat(l_int dfd, const char *filename, \ l_uid16_t uid, l_gid16_t gid, l_int flag); } 299 AUE_FUTIMESAT STD { int linux_futimesat(l_int dfd, char *filename, \ struct l_timeval *utimes); } 300 AUE_FSTATAT STD { int linux_fstatat64(l_int dfd, char *pathname, \ struct l_stat64 *statbuf, l_int flag); } 301 AUE_UNLINKAT STD { int linux_unlinkat(l_int dfd, const char *pathname, \ l_int flag); } 302 AUE_RENAMEAT STD { int linux_renameat(l_int olddfd, const char *oldname, \ l_int newdfd, const char *newname); } 303 AUE_LINKAT STD { int linux_linkat(l_int olddfd, const char *oldname, \ l_int newdfd, const char *newname, l_int flag); } 304 AUE_SYMLINKAT STD { int linux_symlinkat(const char *oldname, l_int newdfd, \ const char *newname); } 305 AUE_READLINKAT STD { int linux_readlinkat(l_int dfd, const char *path, \ char *buf, l_int bufsiz); } 306 AUE_FCHMODAT STD { int linux_fchmodat(l_int dfd, const char *filename, \ l_mode_t mode); } 307 AUE_FACCESSAT STD { int linux_faccessat(l_int dfd, const char *filename, \ l_int amode); } 308 AUE_SELECT STD { int linux_pselect6(l_int nfds, l_fd_set *readfds, \ l_fd_set *writefds, l_fd_set *exceptfds, \ struct l_timespec *tsp, l_uintptr_t *sig); } 309 AUE_POLL STD { int linux_ppoll(struct pollfd *fds, uint32_t nfds, \ struct l_timespec *tsp, l_sigset_t *sset, l_size_t ssize); } 310 AUE_NULL STD { int linux_unshare(void); } ; Linux 2.6.17: 311 AUE_NULL STD { int linux_set_robust_list(struct linux_robust_list_head *head, \ l_size_t len); } 312 AUE_NULL STD { int linux_get_robust_list(l_int pid, \ struct linux_robust_list_head **head, l_size_t *len); } 313 AUE_NULL STD { int linux_splice(void); } -314 AUE_NULL STD { int linux_sync_file_range(l_int fd, l_loff_t offset, - l_loff_t nbytes, unsigned int flags); } +314 AUE_NULL STD { int linux_sync_file_range(l_int fd, uint32_t offset1, + uint32_t offset2, uint32_t nbytes1, uint32_t nbytes2, + unsigned int flags); } 315 AUE_NULL STD { int linux_tee(void); } 316 AUE_NULL STD { int linux_vmsplice(void); } ; Linux 2.6.18: 317 AUE_NULL STD { int linux_move_pages(void); } ; Linux 2.6.19: 318 AUE_NULL STD { int linux_getcpu(void); } 319 AUE_NULL STD { int linux_epoll_pwait(l_int epfd, struct epoll_event *events, \ l_int maxevents, l_int timeout, l_sigset_t *mask, \ l_size_t sigsetsize); } ; Linux 2.6.22: 320 AUE_FUTIMESAT STD { int linux_utimensat(l_int dfd, const char *pathname, \ const struct l_timespec *times, l_int flags); } 321 AUE_NULL STD { int linux_signalfd(void); } 322 AUE_NULL STD { int linux_timerfd_create(l_int clockid, l_int flags); } 323 AUE_NULL STD { int linux_eventfd(l_uint initval); } ; Linux 2.6.23: 324 AUE_NULL STD { int linux_fallocate(l_int fd, l_int mode, \ - l_loff_t offset, l_loff_t len); } + uint32_t offset1, uint32_t offset2, uint32_t len1, + uint32_t len2); } ; Linux 2.6.25: 325 AUE_NULL STD { int linux_timerfd_settime(l_int fd, l_int flags, \ const struct l_itimerspec *new_value, \ struct l_itimerspec *old_value); } 326 AUE_NULL STD { int linux_timerfd_gettime(l_int fd, \ struct l_itimerspec *old_value); } ; Linux 2.6.27: 327 AUE_NULL STD { int linux_signalfd4(void); } 328 AUE_NULL STD { int linux_eventfd2(l_uint initval, l_int flags); } 329 AUE_NULL STD { int linux_epoll_create1(l_int flags); } 330 AUE_NULL STD { int linux_dup3(l_int oldfd, \ l_int newfd, l_int flags); } 331 AUE_NULL STD { int linux_pipe2(l_int *pipefds, l_int flags); } 332 AUE_NULL STD { int linux_inotify_init1(void); } ; Linux 2.6.30: 333 AUE_NULL STD { int linux_preadv(l_ulong fd, \ struct iovec *vec, l_ulong vlen, \ l_ulong pos_l, l_ulong pos_h); } 334 AUE_NULL STD { int linux_pwritev(l_ulong fd, \ struct iovec *vec, l_ulong vlen, \ l_ulong pos_l, l_ulong pos_h); } ; Linux 2.6.31: 335 AUE_NULL STD { int linux_rt_tgsigqueueinfo(l_pid_t tgid, \ l_pid_t tid, l_int sig, l_siginfo_t *uinfo); } 336 AUE_NULL STD { int linux_perf_event_open(void); } ; Linux 2.6.33: 337 AUE_NULL STD { int linux_recvmmsg(l_int s, \ struct l_mmsghdr *msg, l_uint vlen, \ l_uint flags, struct l_timespec *timeout); } 338 AUE_NULL STD { int linux_fanotify_init(void); } 339 AUE_NULL STD { int linux_fanotify_mark(void); } ; Linux 2.6.36: 340 AUE_NULL STD { int linux_prlimit64(l_pid_t pid, \ l_uint resource, \ struct rlimit *new, \ struct rlimit *old); } ; Linux 2.6.39: 341 AUE_NULL STD { int linux_name_to_handle_at(void); } 342 AUE_NULL STD { int linux_open_by_handle_at(void); } 343 AUE_NULL STD { int linux_clock_adjtime(void); } 344 AUE_SYNC STD { int linux_syncfs(l_int fd); } ; Linux 3.0: 345 AUE_NULL STD { int linux_sendmmsg(l_int s, \ struct l_mmsghdr *msg, l_uint vlen, \ l_uint flags); } 346 AUE_NULL STD { int linux_setns(void); } ; Linux 3.2 (glibc 2.15): 347 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); } 348 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); } ; Linux 3.5 (no glibc wrapper): 349 AUE_NULL STD { int linux_kcmp(l_pid_t pid1, l_pid_t pid2, \ l_int type, l_ulong idx1, l_ulong idx); } ; Linux 3.8 (no glibc wrapper): 350 AUE_NULL STD { int linux_finit_module(l_int fd, \ const char *uargs, l_int flags); } ; Linux 3.14: 351 AUE_NULL STD { int linux_sched_setattr(l_pid_t pid, \ void *attr, l_uint flags); } 352 AUE_NULL STD { int linux_sched_getattr(l_pid_t pid, \ void *attr, l_uint size, l_uint flags); } ; Linux 3.15: 353 AUE_NULL STD { int linux_renameat2(l_int oldfd, \ const char *oldname, l_int newfd, \ const char *newname, unsigned int flags); } ; Linux 3.17: 354 AUE_NULL STD { int linux_seccomp(l_uint op, l_uint flags, \ const char *uargs); } 355 AUE_NULL STD { int linux_getrandom(char *buf, \ l_size_t count, l_uint flags); } 356 AUE_NULL STD { int linux_memfd_create(const char *uname_ptr, \ l_uint flags); } ; Linux 3.18: 357 AUE_NULL STD { int linux_bpf(l_int cmd, void *attr, \ l_uint size); } ; Linux 3.19: 358 AUE_NULL STD { int linux_execveat(l_int dfd, \ const char *filename, const char **argv, \ const char **envp, l_int flags); } ; Linux 4.3: sockets now direct system calls: 359 AUE_SOCKET STD { int linux_socket(l_int domain, l_int type, \ l_int protocol); } 360 AUE_SOCKETPAIR STD { int linux_socketpair(l_int domain, \ l_int type, l_int protocol, l_uintptr_t rsv); } 361 AUE_BIND STD { int linux_bind(l_int s, l_uintptr_t name, \ l_int namelen); } 362 AUE_CONNECT STD { int linux_connect(l_int s, l_uintptr_t name, \ l_int namelen); } 363 AUE_LISTEN STD { int linux_listen(l_int s, l_int backlog); } 364 AUE_ACCEPT STD { int linux_accept4(l_int s, l_uintptr_t addr, \ l_uintptr_t namelen, l_int flags); } 365 AUE_GETSOCKOPT STD { int linux_getsockopt(l_int s, l_int level, \ l_int optname, l_uintptr_t optval, \ l_uintptr_t optlen); } 366 AUE_SETSOCKOPT STD { int linux_setsockopt(l_int s, l_int level, \ l_int optname, l_uintptr_t optval, \ l_int optlen); } 367 AUE_GETSOCKNAME STD { int linux_getsockname(l_int s, \ l_uintptr_t addr, l_uintptr_t namelen); } 368 AUE_GETPEERNAME STD { int linux_getpeername(l_int s, \ l_uintptr_t addr, l_uintptr_t namelen); } 369 AUE_SENDTO STD { int linux_sendto(l_int s, l_uintptr_t msg, \ l_int len, l_int flags, l_uintptr_t to, \ l_int tolen); } 370 AUE_SENDMSG STD { int linux_sendmsg(l_int s, l_uintptr_t msg, \ l_int flags); } 371 AUE_RECVFROM STD { int linux_recvfrom(l_int s, l_uintptr_t buf, \ l_size_t len, l_int flags, l_uintptr_t from, \ l_uintptr_t fromlen); } 372 AUE_RECVMSG STD { int linux_recvmsg(l_int s, l_uintptr_t msg, \ l_int flags); } 373 AUE_NULL STD { int linux_shutdown(l_int s, l_int how); } ; ; Linux 4.2: 374 AUE_NULL STD { int linux_userfaultfd(l_int flags); } ; Linux 4.3: 375 AUE_NULL STD { int linux_membarrier(l_int cmd, l_int flags); } ; Linux 4.4: 376 AUE_NULL STD { int linux_mlock2(l_ulong start, l_size_t len, \ l_int flags); } ; Linux 4.5: 377 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); } ; Linux 4.6: 378 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); } 379 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); } ; Linux 4.8: 380 AUE_NULL STD { int linux_pkey_mprotect(l_ulong start, \ l_size_t len, l_ulong prot, l_int pkey); } 381 AUE_NULL STD { int linux_pkey_alloc(l_ulong flags, \ l_ulong init_val); } 382 AUE_NULL STD { int linux_pkey_free(l_int pkey); } ; Linux 4.11: 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_arch_prctl(l_int option, \ l_ulong arg2); } ; Linux 4.18: 385 AUE_NULL STD { int linux_io_pgetevents(void); } 386 AUE_NULL STD { int linux_rseq(void); } 387-392 AUE_NULL UNIMPL nosys 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); } ; Linux 5.0: 403 AUE_NULL STD { int linux_clock_gettime64(void); } 404 AUE_NULL STD { int linux_clock_settime64(void); } 405 AUE_NULL STD { int linux_clock_adjtime64(void); } 406 AUE_NULL STD { int linux_clock_getres_time64(void); } 407 AUE_NULL STD { int linux_clock_nanosleep_time64(void); } 408 AUE_NULL STD { int linux_timer_gettime64(void); } 409 AUE_NULL STD { int linux_timer_settime64(void); } 410 AUE_NULL STD { int linux_timerfd_gettime64(void); } 411 AUE_NULL STD { int linux_timerfd_settime64(void); } 412 AUE_NULL STD { int linux_utimensat_time64(void); } 413 AUE_NULL STD { int linux_pselect6_time64(void); } 414 AUE_NULL STD { int linux_ppoll_time64(void); } 415 AUE_NULL UNIMPL nosys 416 AUE_NULL STD { int linux_io_pgetevents_time64(void); } 417 AUE_NULL STD { int linux_recvmmsg_time64(void); } 418 AUE_NULL STD { int linux_mq_timedsend_time64(void); } 419 AUE_NULL STD { int linux_mq_timedreceive_time64(void); } 420 AUE_NULL STD { int linux_semtimedop_time64(void); } 421 AUE_NULL STD { int linux_rt_sigtimedwait_time64(void); } 422 AUE_NULL STD { int linux_futex_time64(void); } 423 AUE_NULL STD { int linux_sched_rr_get_interval_time64(void); } 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); } ; please, keep this line at the end. 428 AUE_NULL UNIMPL nosys ; vim: syntax=off Index: stable/12/sys/compat/linux/linux_file.c =================================================================== --- stable/12/sys/compat/linux/linux_file.c (revision 359604) +++ stable/12/sys/compat/linux/linux_file.c (revision 359605) @@ -1,1702 +1,1767 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 1994-1995 Søren Schmidt * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 "opt_compat.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef COMPAT_LINUX32 +#include #include #include #else #include #include #endif #include #include #include static int linux_common_open(struct thread *, int, char *, int, int); static int linux_getdents_error(struct thread *, int, int); - #ifdef LINUX_LEGACY_SYSCALLS int linux_creat(struct thread *td, struct linux_creat_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(creat)) printf(ARGS(creat, "%s, %d"), path, args->mode); #endif error = kern_openat(td, AT_FDCWD, path, UIO_SYSSPACE, O_WRONLY | O_CREAT | O_TRUNC, args->mode); LFREEPATH(path); return (error); } #endif static int linux_common_open(struct thread *td, int dirfd, char *path, int l_flags, int mode) { struct proc *p = td->td_proc; struct file *fp; int fd; int bsd_flags, error; bsd_flags = 0; switch (l_flags & LINUX_O_ACCMODE) { case LINUX_O_WRONLY: bsd_flags |= O_WRONLY; break; case LINUX_O_RDWR: bsd_flags |= O_RDWR; break; default: bsd_flags |= O_RDONLY; } if (l_flags & LINUX_O_NDELAY) bsd_flags |= O_NONBLOCK; if (l_flags & LINUX_O_APPEND) bsd_flags |= O_APPEND; if (l_flags & LINUX_O_SYNC) bsd_flags |= O_FSYNC; if (l_flags & LINUX_O_NONBLOCK) bsd_flags |= O_NONBLOCK; if (l_flags & LINUX_FASYNC) bsd_flags |= O_ASYNC; if (l_flags & LINUX_O_CREAT) bsd_flags |= O_CREAT; if (l_flags & LINUX_O_TRUNC) bsd_flags |= O_TRUNC; if (l_flags & LINUX_O_EXCL) bsd_flags |= O_EXCL; if (l_flags & LINUX_O_NOCTTY) bsd_flags |= O_NOCTTY; if (l_flags & LINUX_O_DIRECT) bsd_flags |= O_DIRECT; if (l_flags & LINUX_O_NOFOLLOW) bsd_flags |= O_NOFOLLOW; if (l_flags & LINUX_O_DIRECTORY) bsd_flags |= O_DIRECTORY; /* XXX LINUX_O_NOATIME: unable to be easily implemented. */ error = kern_openat(td, dirfd, path, UIO_SYSSPACE, bsd_flags, mode); if (error != 0) goto done; if (bsd_flags & O_NOCTTY) goto done; /* * XXX In between kern_openat() and fget(), another process * having the same filedesc could use that fd without * checking below. */ fd = td->td_retval[0]; if (fget(td, fd, &cap_ioctl_rights, &fp) == 0) { if (fp->f_type != DTYPE_VNODE) { fdrop(fp, td); goto done; } sx_slock(&proctree_lock); PROC_LOCK(p); if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { PROC_UNLOCK(p); sx_sunlock(&proctree_lock); /* XXXPJD: Verify if TIOCSCTTY is allowed. */ (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td->td_ucred, td); } else { PROC_UNLOCK(p); sx_sunlock(&proctree_lock); } fdrop(fp, td); } done: #ifdef DEBUG #ifdef LINUX_LEGACY_SYSCALLS if (ldebug(open)) #else if (ldebug(openat)) #endif printf(LMSG("open returns error %d"), error); #endif LFREEPATH(path); return (error); } int linux_openat(struct thread *td, struct linux_openat_args *args) { char *path; int dfd; dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; if (args->flags & LINUX_O_CREAT) LCONVPATH_AT(td, args->filename, &path, 1, dfd); else LCONVPATH_AT(td, args->filename, &path, 0, dfd); #ifdef DEBUG if (ldebug(openat)) printf(ARGS(openat, "%i, %s, 0x%x, 0x%x"), args->dfd, path, args->flags, args->mode); #endif return (linux_common_open(td, dfd, path, args->flags, args->mode)); } #ifdef LINUX_LEGACY_SYSCALLS int linux_open(struct thread *td, struct linux_open_args *args) { char *path; if (args->flags & LINUX_O_CREAT) LCONVPATHCREAT(td, args->path, &path); else LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(open)) printf(ARGS(open, "%s, 0x%x, 0x%x"), path, args->flags, args->mode); #endif return (linux_common_open(td, AT_FDCWD, path, args->flags, args->mode)); } #endif int linux_lseek(struct thread *td, struct linux_lseek_args *args) { #ifdef DEBUG if (ldebug(lseek)) printf(ARGS(lseek, "%d, %ld, %d"), args->fdes, (long)args->off, args->whence); #endif return (kern_lseek(td, args->fdes, args->off, args->whence)); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_llseek(struct thread *td, struct linux_llseek_args *args) { int error; off_t off; #ifdef DEBUG if (ldebug(llseek)) printf(ARGS(llseek, "%d, %d:%d, %d"), args->fd, args->ohigh, args->olow, args->whence); #endif off = (args->olow) | (((off_t) args->ohigh) << 32); error = kern_lseek(td, args->fd, off, args->whence); if (error != 0) return (error); error = copyout(td->td_retval, args->res, sizeof(off_t)); if (error != 0) return (error); td->td_retval[0] = 0; return (0); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ /* * Note that linux_getdents(2) and linux_getdents64(2) have the same * arguments. They only differ in the definition of struct dirent they * operate on. * Note that linux_readdir(2) is a special case of linux_getdents(2) * where count is always equals 1, meaning that the buffer is one * dirent-structure in size and that the code can't handle more anyway. * Note that linux_readdir(2) can't be implemented by means of linux_getdents(2) * as in case when the *dent buffer size is equal to 1 linux_getdents(2) will * trash user stack. */ static int linux_getdents_error(struct thread *td, int fd, int err) { struct vnode *vp; struct file *fp; int error; /* Linux return ENOTDIR in case when fd is not a directory. */ error = getvnode(td, fd, &cap_read_rights, &fp); if (error != 0) return (error); vp = fp->f_vnode; if (vp->v_type != VDIR) { fdrop(fp, td); return (ENOTDIR); } fdrop(fp, td); return (err); } struct l_dirent { l_ulong d_ino; l_off_t d_off; l_ushort d_reclen; char d_name[LINUX_NAME_MAX + 1]; }; struct l_dirent64 { uint64_t d_ino; int64_t d_off; l_ushort d_reclen; u_char d_type; char d_name[LINUX_NAME_MAX + 1]; }; /* * Linux uses the last byte in the dirent buffer to store d_type, * at least glibc-2.7 requires it. That is why l_dirent is padded with 2 bytes. */ #define LINUX_RECLEN(namlen) \ roundup(offsetof(struct l_dirent, d_name) + (namlen) + 2, sizeof(l_ulong)) #define LINUX_RECLEN64(namlen) \ roundup(offsetof(struct l_dirent64, d_name) + (namlen) + 1, \ sizeof(uint64_t)) #ifdef LINUX_LEGACY_SYSCALLS int linux_getdents(struct thread *td, struct linux_getdents_args *args) { struct dirent *bdp; caddr_t inp, buf; /* BSD-format */ int len, reclen; /* BSD-format */ caddr_t outp; /* Linux-format */ int resid, linuxreclen; /* Linux-format */ caddr_t lbuf; /* Linux-format */ off_t base; struct l_dirent *linux_dirent; int buflen, error; size_t retval; #ifdef DEBUG if (ldebug(getdents)) printf(ARGS(getdents, "%d, *, %d"), args->fd, args->count); #endif buflen = min(args->count, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); error = kern_getdirentries(td, args->fd, buf, buflen, &base, NULL, UIO_SYSSPACE); if (error != 0) { error = linux_getdents_error(td, args->fd, error); goto out1; } lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO); len = td->td_retval[0]; inp = buf; outp = (caddr_t)args->dent; resid = args->count; retval = 0; while (len > 0) { bdp = (struct dirent *) inp; reclen = bdp->d_reclen; linuxreclen = LINUX_RECLEN(bdp->d_namlen); /* * No more space in the user supplied dirent buffer. * Return EINVAL. */ if (resid < linuxreclen) { error = EINVAL; goto out; } linux_dirent = (struct l_dirent*)lbuf; linux_dirent->d_ino = bdp->d_fileno; linux_dirent->d_off = base + reclen; linux_dirent->d_reclen = linuxreclen; /* * Copy d_type to last byte of l_dirent buffer */ lbuf[linuxreclen - 1] = bdp->d_type; strlcpy(linux_dirent->d_name, bdp->d_name, linuxreclen - offsetof(struct l_dirent, d_name)-1); error = copyout(linux_dirent, outp, linuxreclen); if (error != 0) goto out; inp += reclen; base += reclen; len -= reclen; retval += linuxreclen; outp += linuxreclen; resid -= linuxreclen; } td->td_retval[0] = retval; out: free(lbuf, M_TEMP); out1: free(buf, M_TEMP); return (error); } #endif int linux_getdents64(struct thread *td, struct linux_getdents64_args *args) { struct dirent *bdp; caddr_t inp, buf; /* BSD-format */ int len, reclen; /* BSD-format */ caddr_t outp; /* Linux-format */ int resid, linuxreclen; /* Linux-format */ caddr_t lbuf; /* Linux-format */ off_t base; struct l_dirent64 *linux_dirent64; int buflen, error; size_t retval; #ifdef DEBUG if (ldebug(getdents64)) uprintf(ARGS(getdents64, "%d, *, %d"), args->fd, args->count); #endif buflen = min(args->count, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); error = kern_getdirentries(td, args->fd, buf, buflen, &base, NULL, UIO_SYSSPACE); if (error != 0) { error = linux_getdents_error(td, args->fd, error); goto out1; } lbuf = malloc(LINUX_RECLEN64(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO); len = td->td_retval[0]; inp = buf; outp = (caddr_t)args->dirent; resid = args->count; retval = 0; while (len > 0) { bdp = (struct dirent *) inp; reclen = bdp->d_reclen; linuxreclen = LINUX_RECLEN64(bdp->d_namlen); /* * No more space in the user supplied dirent buffer. * Return EINVAL. */ if (resid < linuxreclen) { error = EINVAL; goto out; } linux_dirent64 = (struct l_dirent64*)lbuf; linux_dirent64->d_ino = bdp->d_fileno; linux_dirent64->d_off = base + reclen; linux_dirent64->d_reclen = linuxreclen; linux_dirent64->d_type = bdp->d_type; strlcpy(linux_dirent64->d_name, bdp->d_name, linuxreclen - offsetof(struct l_dirent64, d_name)); error = copyout(linux_dirent64, outp, linuxreclen); if (error != 0) goto out; inp += reclen; base += reclen; len -= reclen; retval += linuxreclen; outp += linuxreclen; resid -= linuxreclen; } td->td_retval[0] = retval; out: free(lbuf, M_TEMP); out1: free(buf, M_TEMP); return (error); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_readdir(struct thread *td, struct linux_readdir_args *args) { struct dirent *bdp; caddr_t buf; /* BSD-format */ int linuxreclen; /* Linux-format */ caddr_t lbuf; /* Linux-format */ off_t base; struct l_dirent *linux_dirent; int buflen, error; #ifdef DEBUG if (ldebug(readdir)) printf(ARGS(readdir, "%d, *"), args->fd); #endif buflen = LINUX_RECLEN(LINUX_NAME_MAX); buf = malloc(buflen, M_TEMP, M_WAITOK); error = kern_getdirentries(td, args->fd, buf, buflen, &base, NULL, UIO_SYSSPACE); if (error != 0) { error = linux_getdents_error(td, args->fd, error); goto out; } if (td->td_retval[0] == 0) goto out; lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO); bdp = (struct dirent *) buf; linuxreclen = LINUX_RECLEN(bdp->d_namlen); linux_dirent = (struct l_dirent*)lbuf; linux_dirent->d_ino = bdp->d_fileno; linux_dirent->d_off = linuxreclen; linux_dirent->d_reclen = bdp->d_namlen; strlcpy(linux_dirent->d_name, bdp->d_name, linuxreclen - offsetof(struct l_dirent, d_name)); error = copyout(linux_dirent, args->dent, linuxreclen); if (error == 0) td->td_retval[0] = linuxreclen; free(lbuf, M_TEMP); out: free(buf, M_TEMP); return (error); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ /* * These exist mainly for hooks for doing /compat/linux translation. */ #ifdef LINUX_LEGACY_SYSCALLS int linux_access(struct thread *td, struct linux_access_args *args) { char *path; int error; /* Linux convention. */ if (args->amode & ~(F_OK | X_OK | W_OK | R_OK)) return (EINVAL); LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(access)) printf(ARGS(access, "%s, %d"), path, args->amode); #endif error = kern_accessat(td, AT_FDCWD, path, UIO_SYSSPACE, 0, args->amode); LFREEPATH(path); return (error); } #endif int linux_faccessat(struct thread *td, struct linux_faccessat_args *args) { char *path; int error, dfd; /* Linux convention. */ if (args->amode & ~(F_OK | X_OK | W_OK | R_OK)) return (EINVAL); dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHEXIST_AT(td, args->filename, &path, dfd); #ifdef DEBUG if (ldebug(faccessat)) printf(ARGS(access, "%s, %d"), path, args->amode); #endif error = kern_accessat(td, dfd, path, UIO_SYSSPACE, 0, args->amode); LFREEPATH(path); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_unlink(struct thread *td, struct linux_unlink_args *args) { char *path; int error; struct stat st; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(unlink)) printf(ARGS(unlink, "%s"), path); #endif error = kern_unlinkat(td, AT_FDCWD, path, UIO_SYSSPACE, 0); if (error == EPERM) { /* Introduce POSIX noncompliant behaviour of Linux */ if (kern_statat(td, 0, AT_FDCWD, path, UIO_SYSSPACE, &st, NULL) == 0) { if (S_ISDIR(st.st_mode)) error = EISDIR; } } LFREEPATH(path); return (error); } #endif int linux_unlinkat(struct thread *td, struct linux_unlinkat_args *args) { char *path; int error, dfd; struct stat st; if (args->flag & ~LINUX_AT_REMOVEDIR) return (EINVAL); dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHEXIST_AT(td, args->pathname, &path, dfd); #ifdef DEBUG if (ldebug(unlinkat)) printf(ARGS(unlinkat, "%s"), path); #endif if (args->flag & LINUX_AT_REMOVEDIR) error = kern_rmdirat(td, dfd, path, UIO_SYSSPACE); else error = kern_unlinkat(td, dfd, path, UIO_SYSSPACE, 0); if (error == EPERM && !(args->flag & LINUX_AT_REMOVEDIR)) { /* Introduce POSIX noncompliant behaviour of Linux */ if (kern_statat(td, AT_SYMLINK_NOFOLLOW, dfd, path, UIO_SYSSPACE, &st, NULL) == 0 && S_ISDIR(st.st_mode)) error = EISDIR; } LFREEPATH(path); return (error); } int linux_chdir(struct thread *td, struct linux_chdir_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(chdir)) printf(ARGS(chdir, "%s"), path); #endif error = kern_chdir(td, path, UIO_SYSSPACE); LFREEPATH(path); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_chmod(struct thread *td, struct linux_chmod_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(chmod)) printf(ARGS(chmod, "%s, %d"), path, args->mode); #endif error = kern_fchmodat(td, AT_FDCWD, path, UIO_SYSSPACE, args->mode, 0); LFREEPATH(path); return (error); } #endif int linux_fchmodat(struct thread *td, struct linux_fchmodat_args *args) { char *path; int error, dfd; dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHEXIST_AT(td, args->filename, &path, dfd); #ifdef DEBUG if (ldebug(fchmodat)) printf(ARGS(fchmodat, "%s, %d"), path, args->mode); #endif error = kern_fchmodat(td, dfd, path, UIO_SYSSPACE, args->mode, 0); LFREEPATH(path); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_mkdir(struct thread *td, struct linux_mkdir_args *args) { char *path; int error; LCONVPATHCREAT(td, args->path, &path); #ifdef DEBUG if (ldebug(mkdir)) printf(ARGS(mkdir, "%s, %d"), path, args->mode); #endif error = kern_mkdirat(td, AT_FDCWD, path, UIO_SYSSPACE, args->mode); LFREEPATH(path); return (error); } #endif int linux_mkdirat(struct thread *td, struct linux_mkdirat_args *args) { char *path; int error, dfd; dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHCREAT_AT(td, args->pathname, &path, dfd); #ifdef DEBUG if (ldebug(mkdirat)) printf(ARGS(mkdirat, "%s, %d"), path, args->mode); #endif error = kern_mkdirat(td, dfd, path, UIO_SYSSPACE, args->mode); LFREEPATH(path); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_rmdir(struct thread *td, struct linux_rmdir_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(rmdir)) printf(ARGS(rmdir, "%s"), path); #endif error = kern_rmdirat(td, AT_FDCWD, path, UIO_SYSSPACE); LFREEPATH(path); return (error); } int linux_rename(struct thread *td, struct linux_rename_args *args) { char *from, *to; int error; LCONVPATHEXIST(td, args->from, &from); /* Expand LCONVPATHCREATE so that `from' can be freed on errors */ error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD); if (to == NULL) { LFREEPATH(from); return (error); } #ifdef DEBUG if (ldebug(rename)) printf(ARGS(rename, "%s, %s"), from, to); #endif error = kern_renameat(td, AT_FDCWD, from, AT_FDCWD, to, UIO_SYSSPACE); LFREEPATH(from); LFREEPATH(to); return (error); } #endif int linux_renameat(struct thread *td, struct linux_renameat_args *args) { char *from, *to; int error, olddfd, newdfd; olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd; newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd; LCONVPATHEXIST_AT(td, args->oldname, &from, olddfd); /* Expand LCONVPATHCREATE so that `from' can be freed on errors */ error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, newdfd); if (to == NULL) { LFREEPATH(from); return (error); } #ifdef DEBUG if (ldebug(renameat)) printf(ARGS(renameat, "%s, %s"), from, to); #endif error = kern_renameat(td, olddfd, from, newdfd, to, UIO_SYSSPACE); LFREEPATH(from); LFREEPATH(to); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_symlink(struct thread *td, struct linux_symlink_args *args) { char *path, *to; int error; LCONVPATHEXIST(td, args->path, &path); /* Expand LCONVPATHCREATE so that `path' can be freed on errors */ error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD); if (to == NULL) { LFREEPATH(path); return (error); } #ifdef DEBUG if (ldebug(symlink)) printf(ARGS(symlink, "%s, %s"), path, to); #endif error = kern_symlinkat(td, path, AT_FDCWD, to, UIO_SYSSPACE); LFREEPATH(path); LFREEPATH(to); return (error); } #endif int linux_symlinkat(struct thread *td, struct linux_symlinkat_args *args) { char *path, *to; int error, dfd; dfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd; LCONVPATHEXIST(td, args->oldname, &path); /* Expand LCONVPATHCREATE so that `path' can be freed on errors */ error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, dfd); if (to == NULL) { LFREEPATH(path); return (error); } #ifdef DEBUG if (ldebug(symlinkat)) printf(ARGS(symlinkat, "%s, %s"), path, to); #endif error = kern_symlinkat(td, path, dfd, to, UIO_SYSSPACE); LFREEPATH(path); LFREEPATH(to); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_readlink(struct thread *td, struct linux_readlink_args *args) { char *name; int error; LCONVPATHEXIST(td, args->name, &name); #ifdef DEBUG if (ldebug(readlink)) printf(ARGS(readlink, "%s, %p, %d"), name, (void *)args->buf, args->count); #endif error = kern_readlinkat(td, AT_FDCWD, name, UIO_SYSSPACE, args->buf, UIO_USERSPACE, args->count); LFREEPATH(name); return (error); } #endif int linux_readlinkat(struct thread *td, struct linux_readlinkat_args *args) { char *name; int error, dfd; dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHEXIST_AT(td, args->path, &name, dfd); #ifdef DEBUG if (ldebug(readlinkat)) printf(ARGS(readlinkat, "%s, %p, %d"), name, (void *)args->buf, args->bufsiz); #endif error = kern_readlinkat(td, dfd, name, UIO_SYSSPACE, args->buf, UIO_USERSPACE, args->bufsiz); LFREEPATH(name); return (error); } int linux_truncate(struct thread *td, struct linux_truncate_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); - #ifdef DEBUG if (ldebug(truncate)) printf(ARGS(truncate, "%s, %ld"), path, (long)args->length); #endif error = kern_truncate(td, path, UIO_SYSSPACE, args->length); LFREEPATH(path); return (error); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_truncate64(struct thread *td, struct linux_truncate64_args *args) { char *path; + off_t length; int error; +#if defined(__amd64__) && defined(COMPAT_LINUX32) + length = PAIR32TO64(off_t, args->length); +#else + length = args->length; +#endif + LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(truncate64)) printf(ARGS(truncate64, "%s, %jd"), path, args->length); #endif - error = kern_truncate(td, path, UIO_SYSSPACE, args->length); + error = kern_truncate(td, path, UIO_SYSSPACE, length); LFREEPATH(path); return (error); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ int linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args) { return (kern_ftruncate(td, args->fd, args->length)); } +#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) +int +linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) +{ + off_t length; + +#if defined(__amd64__) && defined(COMPAT_LINUX32) + length = PAIR32TO64(off_t, args->length); +#else + length = args->length; +#endif + + return (kern_ftruncate(td, args->fd, length)); +} +#endif + #ifdef LINUX_LEGACY_SYSCALLS int linux_link(struct thread *td, struct linux_link_args *args) { char *path, *to; int error; LCONVPATHEXIST(td, args->path, &path); /* Expand LCONVPATHCREATE so that `path' can be freed on errors */ error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD); if (to == NULL) { LFREEPATH(path); return (error); } #ifdef DEBUG if (ldebug(link)) printf(ARGS(link, "%s, %s"), path, to); #endif error = kern_linkat(td, AT_FDCWD, AT_FDCWD, path, to, UIO_SYSSPACE, FOLLOW); LFREEPATH(path); LFREEPATH(to); return (error); } #endif int linux_linkat(struct thread *td, struct linux_linkat_args *args) { char *path, *to; int error, olddfd, newdfd, follow; if (args->flag & ~LINUX_AT_SYMLINK_FOLLOW) return (EINVAL); olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd; newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd; LCONVPATHEXIST_AT(td, args->oldname, &path, olddfd); /* Expand LCONVPATHCREATE so that `path' can be freed on errors */ error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, newdfd); if (to == NULL) { LFREEPATH(path); return (error); } #ifdef DEBUG if (ldebug(linkat)) printf(ARGS(linkat, "%i, %s, %i, %s, %i"), args->olddfd, path, args->newdfd, to, args->flag); #endif follow = (args->flag & LINUX_AT_SYMLINK_FOLLOW) == 0 ? NOFOLLOW : FOLLOW; error = kern_linkat(td, olddfd, newdfd, path, to, UIO_SYSSPACE, follow); LFREEPATH(path); LFREEPATH(to); return (error); } int linux_fdatasync(struct thread *td, struct linux_fdatasync_args *uap) { return (kern_fsync(td, uap->fd, false)); } int linux_sync_file_range(struct thread *td, struct linux_sync_file_range_args *uap) { + off_t nbytes, offset; - if (uap->offset < 0 || uap->nbytes < 0 || +#if defined(__amd64__) && defined(COMPAT_LINUX32) + nbytes = PAIR32TO64(off_t, uap->nbytes); + offset = PAIR32TO64(off_t, uap->offset); +#else + nbytes = uap->nbytes; + offset = uap->offset; +#endif + + if (offset < 0 || nbytes < 0 || (uap->flags & ~(LINUX_SYNC_FILE_RANGE_WAIT_BEFORE | LINUX_SYNC_FILE_RANGE_WRITE | LINUX_SYNC_FILE_RANGE_WAIT_AFTER)) != 0) { return (EINVAL); } return (kern_fsync(td, uap->fd, false)); } int linux_pread(struct thread *td, struct linux_pread_args *uap) { struct vnode *vp; + off_t offset; int error; - error = kern_pread(td, uap->fd, uap->buf, uap->nbyte, uap->offset); +#if defined(__amd64__) && defined(COMPAT_LINUX32) + offset = PAIR32TO64(off_t, uap->offset); +#else + offset = uap->offset; +#endif + + error = kern_pread(td, uap->fd, uap->buf, uap->nbyte, offset); if (error == 0) { /* This seems to violate POSIX but Linux does it. */ error = fgetvp(td, uap->fd, &cap_pread_rights, &vp); if (error != 0) return (error); - if (vp->v_type == VDIR) { - vrele(vp); - return (EISDIR); - } + if (vp->v_type == VDIR) + error = EISDIR; vrele(vp); } return (error); } int linux_pwrite(struct thread *td, struct linux_pwrite_args *uap) { + off_t offset; - return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, uap->offset)); +#if defined(__amd64__) && defined(COMPAT_LINUX32) + offset = PAIR32TO64(off_t, uap->offset); +#else + offset = uap->offset; +#endif + + return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, offset)); } int linux_preadv(struct thread *td, struct linux_preadv_args *uap) { struct uio *auio; int error; off_t offset; /* * According http://man7.org/linux/man-pages/man2/preadv.2.html#NOTES * pos_l and pos_h, respectively, contain the * low order and high order 32 bits of offset. */ offset = (((off_t)uap->pos_h << (sizeof(offset) * 4)) << (sizeof(offset) * 4)) | uap->pos_l; if (offset < 0) return (EINVAL); #ifdef COMPAT_LINUX32 error = linux32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio); #else error = copyinuio(uap->vec, uap->vlen, &auio); #endif if (error != 0) return (error); error = kern_preadv(td, uap->fd, auio, offset); free(auio, M_IOV); return (error); } int linux_pwritev(struct thread *td, struct linux_pwritev_args *uap) { struct uio *auio; int error; off_t offset; /* * According http://man7.org/linux/man-pages/man2/pwritev.2.html#NOTES * pos_l and pos_h, respectively, contain the * low order and high order 32 bits of offset. */ offset = (((off_t)uap->pos_h << (sizeof(offset) * 4)) << (sizeof(offset) * 4)) | uap->pos_l; if (offset < 0) return (EINVAL); #ifdef COMPAT_LINUX32 error = linux32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio); #else error = copyinuio(uap->vec, uap->vlen, &auio); #endif if (error != 0) return (error); error = kern_pwritev(td, uap->fd, auio, offset); free(auio, M_IOV); return (error); } int linux_mount(struct thread *td, struct linux_mount_args *args) { char fstypename[MFSNAMELEN]; char *mntonname, *mntfromname; int error, fsflags; mntonname = malloc(MNAMELEN, M_TEMP, M_WAITOK); mntfromname = malloc(MNAMELEN, M_TEMP, M_WAITOK); error = copyinstr(args->filesystemtype, fstypename, MFSNAMELEN - 1, NULL); if (error != 0) goto out; error = copyinstr(args->specialfile, mntfromname, MNAMELEN - 1, NULL); if (error != 0) goto out; error = copyinstr(args->dir, mntonname, MNAMELEN - 1, NULL); if (error != 0) goto out; #ifdef DEBUG if (ldebug(mount)) printf(ARGS(mount, "%s, %s, %s"), fstypename, mntfromname, mntonname); #endif if (strcmp(fstypename, "ext2") == 0) { strcpy(fstypename, "ext2fs"); } else if (strcmp(fstypename, "proc") == 0) { strcpy(fstypename, "linprocfs"); } else if (strcmp(fstypename, "vfat") == 0) { strcpy(fstypename, "msdosfs"); } fsflags = 0; if ((args->rwflag & 0xffff0000) == 0xc0ed0000) { /* * Linux SYNC flag is not included; the closest equivalent * FreeBSD has is !ASYNC, which is our default. */ if (args->rwflag & LINUX_MS_RDONLY) fsflags |= MNT_RDONLY; if (args->rwflag & LINUX_MS_NOSUID) fsflags |= MNT_NOSUID; if (args->rwflag & LINUX_MS_NOEXEC) fsflags |= MNT_NOEXEC; if (args->rwflag & LINUX_MS_REMOUNT) fsflags |= MNT_UPDATE; } error = kernel_vmount(fsflags, "fstype", fstypename, "fspath", mntonname, "from", mntfromname, NULL); out: free(mntonname, M_TEMP); free(mntfromname, M_TEMP); return (error); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_oldumount(struct thread *td, struct linux_oldumount_args *args) { struct linux_umount_args args2; args2.path = args->path; args2.flags = 0; return (linux_umount(td, &args2)); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ #ifdef LINUX_LEGACY_SYSCALLS int linux_umount(struct thread *td, struct linux_umount_args *args) { struct unmount_args bsd; bsd.path = args->path; bsd.flags = args->flags; /* XXX correct? */ return (sys_unmount(td, &bsd)); } #endif /* * fcntl family of syscalls */ struct l_flock { l_short l_type; l_short l_whence; l_off_t l_start; l_off_t l_len; l_pid_t l_pid; } #if defined(__amd64__) && defined(COMPAT_LINUX32) __packed #endif ; static void linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock) { switch (linux_flock->l_type) { case LINUX_F_RDLCK: bsd_flock->l_type = F_RDLCK; break; case LINUX_F_WRLCK: bsd_flock->l_type = F_WRLCK; break; case LINUX_F_UNLCK: bsd_flock->l_type = F_UNLCK; break; default: bsd_flock->l_type = -1; break; } bsd_flock->l_whence = linux_flock->l_whence; bsd_flock->l_start = (off_t)linux_flock->l_start; bsd_flock->l_len = (off_t)linux_flock->l_len; bsd_flock->l_pid = (pid_t)linux_flock->l_pid; bsd_flock->l_sysid = 0; } static void bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock) { switch (bsd_flock->l_type) { case F_RDLCK: linux_flock->l_type = LINUX_F_RDLCK; break; case F_WRLCK: linux_flock->l_type = LINUX_F_WRLCK; break; case F_UNLCK: linux_flock->l_type = LINUX_F_UNLCK; break; } linux_flock->l_whence = bsd_flock->l_whence; linux_flock->l_start = (l_off_t)bsd_flock->l_start; linux_flock->l_len = (l_off_t)bsd_flock->l_len; linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid; } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) struct l_flock64 { l_short l_type; l_short l_whence; l_loff_t l_start; l_loff_t l_len; l_pid_t l_pid; } #if defined(__amd64__) && defined(COMPAT_LINUX32) __packed #endif ; static void linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock) { switch (linux_flock->l_type) { case LINUX_F_RDLCK: bsd_flock->l_type = F_RDLCK; break; case LINUX_F_WRLCK: bsd_flock->l_type = F_WRLCK; break; case LINUX_F_UNLCK: bsd_flock->l_type = F_UNLCK; break; default: bsd_flock->l_type = -1; break; } bsd_flock->l_whence = linux_flock->l_whence; bsd_flock->l_start = (off_t)linux_flock->l_start; bsd_flock->l_len = (off_t)linux_flock->l_len; bsd_flock->l_pid = (pid_t)linux_flock->l_pid; bsd_flock->l_sysid = 0; } static void bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock) { switch (bsd_flock->l_type) { case F_RDLCK: linux_flock->l_type = LINUX_F_RDLCK; break; case F_WRLCK: linux_flock->l_type = LINUX_F_WRLCK; break; case F_UNLCK: linux_flock->l_type = LINUX_F_UNLCK; break; } linux_flock->l_whence = bsd_flock->l_whence; linux_flock->l_start = (l_loff_t)bsd_flock->l_start; linux_flock->l_len = (l_loff_t)bsd_flock->l_len; linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid; } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ static int fcntl_common(struct thread *td, struct linux_fcntl_args *args) { struct l_flock linux_flock; struct flock bsd_flock; struct file *fp; long arg; int error, result; switch (args->cmd) { case LINUX_F_DUPFD: return (kern_fcntl(td, args->fd, F_DUPFD, args->arg)); case LINUX_F_GETFD: return (kern_fcntl(td, args->fd, F_GETFD, 0)); case LINUX_F_SETFD: return (kern_fcntl(td, args->fd, F_SETFD, args->arg)); case LINUX_F_GETFL: error = kern_fcntl(td, args->fd, F_GETFL, 0); result = td->td_retval[0]; td->td_retval[0] = 0; if (result & O_RDONLY) td->td_retval[0] |= LINUX_O_RDONLY; if (result & O_WRONLY) td->td_retval[0] |= LINUX_O_WRONLY; if (result & O_RDWR) td->td_retval[0] |= LINUX_O_RDWR; if (result & O_NDELAY) td->td_retval[0] |= LINUX_O_NONBLOCK; if (result & O_APPEND) td->td_retval[0] |= LINUX_O_APPEND; if (result & O_FSYNC) td->td_retval[0] |= LINUX_O_SYNC; if (result & O_ASYNC) td->td_retval[0] |= LINUX_FASYNC; #ifdef LINUX_O_NOFOLLOW if (result & O_NOFOLLOW) td->td_retval[0] |= LINUX_O_NOFOLLOW; #endif #ifdef LINUX_O_DIRECT if (result & O_DIRECT) td->td_retval[0] |= LINUX_O_DIRECT; #endif return (error); case LINUX_F_SETFL: arg = 0; if (args->arg & LINUX_O_NDELAY) arg |= O_NONBLOCK; if (args->arg & LINUX_O_APPEND) arg |= O_APPEND; if (args->arg & LINUX_O_SYNC) arg |= O_FSYNC; if (args->arg & LINUX_FASYNC) arg |= O_ASYNC; #ifdef LINUX_O_NOFOLLOW if (args->arg & LINUX_O_NOFOLLOW) arg |= O_NOFOLLOW; #endif #ifdef LINUX_O_DIRECT if (args->arg & LINUX_O_DIRECT) arg |= O_DIRECT; #endif return (kern_fcntl(td, args->fd, F_SETFL, arg)); case LINUX_F_GETLK: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock(&linux_flock, &bsd_flock); error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock); if (error) return (error); bsd_to_linux_flock(&bsd_flock, &linux_flock); return (copyout(&linux_flock, (void *)args->arg, sizeof(linux_flock))); case LINUX_F_SETLK: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock(&linux_flock, &bsd_flock); return (kern_fcntl(td, args->fd, F_SETLK, (intptr_t)&bsd_flock)); case LINUX_F_SETLKW: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock(&linux_flock, &bsd_flock); return (kern_fcntl(td, args->fd, F_SETLKW, (intptr_t)&bsd_flock)); case LINUX_F_GETOWN: return (kern_fcntl(td, args->fd, F_GETOWN, 0)); case LINUX_F_SETOWN: /* * XXX some Linux applications depend on F_SETOWN having no * significant effect for pipes (SIGIO is not delivered for * pipes under Linux-2.2.35 at least). */ error = fget(td, args->fd, &cap_fcntl_rights, &fp); if (error) return (error); if (fp->f_type == DTYPE_PIPE) { fdrop(fp, td); return (EINVAL); } fdrop(fp, td); return (kern_fcntl(td, args->fd, F_SETOWN, args->arg)); case LINUX_F_DUPFD_CLOEXEC: return (kern_fcntl(td, args->fd, F_DUPFD_CLOEXEC, args->arg)); } return (EINVAL); } int linux_fcntl(struct thread *td, struct linux_fcntl_args *args) { #ifdef DEBUG if (ldebug(fcntl)) printf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd); #endif return (fcntl_common(td, args)); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args) { struct l_flock64 linux_flock; struct flock bsd_flock; struct linux_fcntl_args fcntl_args; int error; #ifdef DEBUG if (ldebug(fcntl64)) printf(ARGS(fcntl64, "%d, %08x, *"), args->fd, args->cmd); #endif switch (args->cmd) { case LINUX_F_GETLK64: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock64(&linux_flock, &bsd_flock); error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock); if (error) return (error); bsd_to_linux_flock64(&bsd_flock, &linux_flock); return (copyout(&linux_flock, (void *)args->arg, sizeof(linux_flock))); case LINUX_F_SETLK64: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock64(&linux_flock, &bsd_flock); return (kern_fcntl(td, args->fd, F_SETLK, (intptr_t)&bsd_flock)); case LINUX_F_SETLKW64: error = copyin((void *)args->arg, &linux_flock, sizeof(linux_flock)); if (error) return (error); linux_to_bsd_flock64(&linux_flock, &bsd_flock); return (kern_fcntl(td, args->fd, F_SETLKW, (intptr_t)&bsd_flock)); } fcntl_args.fd = args->fd; fcntl_args.cmd = args->cmd; fcntl_args.arg = args->arg; return (fcntl_common(td, &fcntl_args)); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ #ifdef LINUX_LEGACY_SYSCALLS int linux_chown(struct thread *td, struct linux_chown_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(chown)) printf(ARGS(chown, "%s, %d, %d"), path, args->uid, args->gid); #endif error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE, args->uid, args->gid, 0); LFREEPATH(path); return (error); } #endif int linux_fchownat(struct thread *td, struct linux_fchownat_args *args) { char *path; int error, dfd, flag; if (args->flag & ~LINUX_AT_SYMLINK_NOFOLLOW) return (EINVAL); dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd; LCONVPATHEXIST_AT(td, args->filename, &path, dfd); #ifdef DEBUG if (ldebug(fchownat)) printf(ARGS(fchownat, "%s, %d, %d"), path, args->uid, args->gid); #endif flag = (args->flag & LINUX_AT_SYMLINK_NOFOLLOW) == 0 ? 0 : AT_SYMLINK_NOFOLLOW; error = kern_fchownat(td, dfd, path, UIO_SYSSPACE, args->uid, args->gid, flag); LFREEPATH(path); return (error); } #ifdef LINUX_LEGACY_SYSCALLS int linux_lchown(struct thread *td, struct linux_lchown_args *args) { char *path; int error; LCONVPATHEXIST(td, args->path, &path); #ifdef DEBUG if (ldebug(lchown)) printf(ARGS(lchown, "%s, %d, %d"), path, args->uid, args->gid); #endif error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE, args->uid, args->gid, AT_SYMLINK_NOFOLLOW); LFREEPATH(path); return (error); } #endif static int convert_fadvice(int advice) { switch (advice) { case LINUX_POSIX_FADV_NORMAL: return (POSIX_FADV_NORMAL); case LINUX_POSIX_FADV_RANDOM: return (POSIX_FADV_RANDOM); case LINUX_POSIX_FADV_SEQUENTIAL: return (POSIX_FADV_SEQUENTIAL); case LINUX_POSIX_FADV_WILLNEED: return (POSIX_FADV_WILLNEED); case LINUX_POSIX_FADV_DONTNEED: return (POSIX_FADV_DONTNEED); case LINUX_POSIX_FADV_NOREUSE: return (POSIX_FADV_NOREUSE); default: return (-1); } } int linux_fadvise64(struct thread *td, struct linux_fadvise64_args *args) { + off_t offset; int advice; +#if defined(__amd64__) && defined(COMPAT_LINUX32) + offset = PAIR32TO64(off_t, args->offset); +#else + offset = args->offset; +#endif + advice = convert_fadvice(args->advice); if (advice == -1) return (EINVAL); - return (kern_posix_fadvise(td, args->fd, args->offset, args->len, - advice)); + return (kern_posix_fadvise(td, args->fd, offset, args->len, advice)); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_fadvise64_64(struct thread *td, struct linux_fadvise64_64_args *args) { + off_t len, offset; int advice; +#if defined(__amd64__) && defined(COMPAT_LINUX32) + len = PAIR32TO64(off_t, args->len); + offset = PAIR32TO64(off_t, args->offset); +#else + len = args->len; + offset = args->offset; +#endif + advice = convert_fadvice(args->advice); if (advice == -1) return (EINVAL); - return (kern_posix_fadvise(td, args->fd, args->offset, args->len, - advice)); + return (kern_posix_fadvise(td, args->fd, offset, len, advice)); } #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */ #ifdef LINUX_LEGACY_SYSCALLS int linux_pipe(struct thread *td, struct linux_pipe_args *args) { int fildes[2]; int error; #ifdef DEBUG if (ldebug(pipe)) printf(ARGS(pipe, "*")); #endif error = kern_pipe(td, fildes, 0, NULL, NULL); if (error != 0) return (error); error = copyout(fildes, args->pipefds, sizeof(fildes)); if (error != 0) { (void)kern_close(td, fildes[0]); (void)kern_close(td, fildes[1]); } return (error); } #endif int linux_pipe2(struct thread *td, struct linux_pipe2_args *args) { int fildes[2]; int error, flags; #ifdef DEBUG if (ldebug(pipe2)) printf(ARGS(pipe2, "*, %d"), args->flags); #endif if ((args->flags & ~(LINUX_O_NONBLOCK | LINUX_O_CLOEXEC)) != 0) return (EINVAL); flags = 0; if ((args->flags & LINUX_O_NONBLOCK) != 0) flags |= O_NONBLOCK; if ((args->flags & LINUX_O_CLOEXEC) != 0) flags |= O_CLOEXEC; error = kern_pipe(td, fildes, flags, NULL, NULL); if (error != 0) return (error); error = copyout(fildes, args->pipefds, sizeof(fildes)); if (error != 0) { (void)kern_close(td, fildes[0]); (void)kern_close(td, fildes[1]); } return (error); } int linux_dup3(struct thread *td, struct linux_dup3_args *args) { int cmd; intptr_t newfd; if (args->oldfd == args->newfd) return (EINVAL); if ((args->flags & ~LINUX_O_CLOEXEC) != 0) return (EINVAL); if (args->flags & LINUX_O_CLOEXEC) cmd = F_DUP2FD_CLOEXEC; else cmd = F_DUP2FD; newfd = args->newfd; return (kern_fcntl(td, args->oldfd, cmd, newfd)); } int linux_fallocate(struct thread *td, struct linux_fallocate_args *args) { + off_t len, offset; /* * We emulate only posix_fallocate system call for which * mode should be 0. */ if (args->mode != 0) return (ENOSYS); - return (kern_posix_fallocate(td, args->fd, args->offset, - args->len)); +#if defined(__amd64__) && defined(COMPAT_LINUX32) + len = PAIR32TO64(off_t, args->len); + offset = PAIR32TO64(off_t, args->offset); +#else + len = args->len; + offset = args->offset; +#endif + + return (kern_posix_fallocate(td, args->fd, offset, len)); } Index: stable/12/sys/i386/linux/linux_machdep.c =================================================================== --- stable/12/sys/i386/linux/linux_machdep.c (revision 359604) +++ stable/12/sys/i386/linux/linux_machdep.c (revision 359605) @@ -1,839 +1,826 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2000 Marcel Moolenaar * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 /* needed for pcb definition in linux_set_thread_area */ #include "opt_posix.h" extern struct sysentvec elf32_freebsd_sysvec; /* defined in i386/i386/elf_machdep.c */ struct l_descriptor { l_uint entry_number; l_ulong base_addr; l_uint limit; l_uint seg_32bit:1; l_uint contents:2; l_uint read_exec_only:1; l_uint limit_in_pages:1; l_uint seg_not_present:1; l_uint useable:1; }; struct l_old_select_argv { l_int nfds; l_fd_set *readfds; l_fd_set *writefds; l_fd_set *exceptfds; struct l_timeval *timeout; }; int linux_execve(struct thread *td, struct linux_execve_args *args) { struct image_args eargs; char *newpath; int error; LCONVPATHEXIST(td, args->path, &newpath); #ifdef DEBUG if (ldebug(execve)) printf(ARGS(execve, "%s"), newpath); #endif error = exec_copyin_args(&eargs, newpath, UIO_SYSSPACE, args->argp, args->envp); free(newpath, M_TEMP); if (error == 0) error = linux_common_execve(td, &eargs); return (error); } struct l_ipc_kludge { struct l_msgbuf *msgp; l_long msgtyp; }; int linux_ipc(struct thread *td, struct linux_ipc_args *args) { switch (args->what & 0xFFFF) { case LINUX_SEMOP: { struct linux_semop_args a; a.semid = args->arg1; a.tsops = PTRIN(args->ptr); a.nsops = args->arg2; return (linux_semop(td, &a)); } case LINUX_SEMGET: { struct linux_semget_args a; a.key = args->arg1; a.nsems = args->arg2; a.semflg = args->arg3; return (linux_semget(td, &a)); } case LINUX_SEMCTL: { struct linux_semctl_args a; int error; a.semid = args->arg1; a.semnum = args->arg2; a.cmd = args->arg3; error = copyin(PTRIN(args->ptr), &a.arg, sizeof(a.arg)); if (error) return (error); return (linux_semctl(td, &a)); } case LINUX_MSGSND: { struct linux_msgsnd_args a; a.msqid = args->arg1; a.msgp = PTRIN(args->ptr); a.msgsz = args->arg2; a.msgflg = args->arg3; return (linux_msgsnd(td, &a)); } case LINUX_MSGRCV: { struct linux_msgrcv_args a; a.msqid = args->arg1; a.msgsz = args->arg2; a.msgflg = args->arg3; if ((args->what >> 16) == 0) { struct l_ipc_kludge tmp; int error; if (args->ptr == 0) return (EINVAL); error = copyin(PTRIN(args->ptr), &tmp, sizeof(tmp)); if (error) return (error); a.msgp = PTRIN(tmp.msgp); a.msgtyp = tmp.msgtyp; } else { a.msgp = PTRIN(args->ptr); a.msgtyp = args->arg5; } return (linux_msgrcv(td, &a)); } case LINUX_MSGGET: { struct linux_msgget_args a; a.key = args->arg1; a.msgflg = args->arg2; return (linux_msgget(td, &a)); } case LINUX_MSGCTL: { struct linux_msgctl_args a; a.msqid = args->arg1; a.cmd = args->arg2; a.buf = PTRIN(args->ptr); return (linux_msgctl(td, &a)); } case LINUX_SHMAT: { struct linux_shmat_args a; l_uintptr_t addr; int error; a.shmid = args->arg1; a.shmaddr = PTRIN(args->ptr); a.shmflg = args->arg2; error = linux_shmat(td, &a); if (error != 0) return (error); addr = td->td_retval[0]; error = copyout(&addr, PTRIN(args->arg3), sizeof(addr)); td->td_retval[0] = 0; return (error); } case LINUX_SHMDT: { struct linux_shmdt_args a; a.shmaddr = PTRIN(args->ptr); return (linux_shmdt(td, &a)); } case LINUX_SHMGET: { struct linux_shmget_args a; a.key = args->arg1; a.size = args->arg2; a.shmflg = args->arg3; return (linux_shmget(td, &a)); } case LINUX_SHMCTL: { struct linux_shmctl_args a; a.shmid = args->arg1; a.cmd = args->arg2; a.buf = PTRIN(args->ptr); return (linux_shmctl(td, &a)); } default: break; } return (EINVAL); } int linux_old_select(struct thread *td, struct linux_old_select_args *args) { struct l_old_select_argv linux_args; struct linux_select_args newsel; int error; #ifdef DEBUG if (ldebug(old_select)) printf(ARGS(old_select, "%p"), args->ptr); #endif error = copyin(args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); newsel.nfds = linux_args.nfds; newsel.readfds = linux_args.readfds; newsel.writefds = linux_args.writefds; newsel.exceptfds = linux_args.exceptfds; newsel.timeout = linux_args.timeout; return (linux_select(td, &newsel)); } int linux_set_cloned_tls(struct thread *td, void *desc) { struct segment_descriptor sd; struct l_user_desc info; int idx, error; int a[2]; error = copyin(desc, &info, sizeof(struct l_user_desc)); if (error) { printf(LMSG("copyin failed!")); } else { idx = info.entry_number; /* * looks like we're getting the idx we returned * in the set_thread_area() syscall */ if (idx != 6 && idx != 3) { printf(LMSG("resetting idx!")); idx = 3; } /* this doesnt happen in practice */ if (idx == 6) { /* we might copy out the entry_number as 3 */ info.entry_number = 3; error = copyout(&info, desc, sizeof(struct l_user_desc)); if (error) printf(LMSG("copyout failed!")); } a[0] = LINUX_LDT_entry_a(&info); a[1] = LINUX_LDT_entry_b(&info); memcpy(&sd, &a, sizeof(a)); #ifdef DEBUG if (ldebug(clone)) printf("Segment created in clone with " "CLONE_SETTLS: lobase: %x, hibase: %x, " "lolimit: %x, hilimit: %x, type: %i, " "dpl: %i, p: %i, xx: %i, def32: %i, " "gran: %i\n", sd.sd_lobase, sd.sd_hibase, sd.sd_lolimit, sd.sd_hilimit, sd.sd_type, sd.sd_dpl, sd.sd_p, sd.sd_xx, sd.sd_def32, sd.sd_gran); #endif /* set %gs */ td->td_pcb->pcb_gsd = sd; td->td_pcb->pcb_gs = GSEL(GUGS_SEL, SEL_UPL); } return (error); } int linux_set_upcall_kse(struct thread *td, register_t stack) { if (stack) td->td_frame->tf_esp = stack; /* * The newly created Linux thread returns * to the user space by the same path that a parent do. */ td->td_frame->tf_eax = 0; return (0); } int linux_mmap2(struct thread *td, struct linux_mmap2_args *args) { #ifdef DEBUG if (ldebug(mmap2)) printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"), (void *)args->addr, args->len, args->prot, args->flags, args->fd, args->pgoff); #endif return (linux_mmap_common(td, args->addr, args->len, args->prot, args->flags, args->fd, (uint64_t)(uint32_t)args->pgoff * PAGE_SIZE)); } int linux_mmap(struct thread *td, struct linux_mmap_args *args) { int error; struct l_mmap_argv linux_args; error = copyin(args->ptr, &linux_args, sizeof(linux_args)); if (error) return (error); #ifdef DEBUG if (ldebug(mmap)) printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"), (void *)linux_args.addr, linux_args.len, linux_args.prot, linux_args.flags, linux_args.fd, linux_args.pgoff); #endif return (linux_mmap_common(td, linux_args.addr, linux_args.len, linux_args.prot, linux_args.flags, linux_args.fd, (uint32_t)linux_args.pgoff)); } int linux_mprotect(struct thread *td, struct linux_mprotect_args *uap) { return (linux_mprotect_common(td, PTROUT(uap->addr), uap->len, uap->prot)); } int linux_ioperm(struct thread *td, struct linux_ioperm_args *args) { int error; struct i386_ioperm_args iia; iia.start = args->start; iia.length = args->length; iia.enable = args->enable; error = i386_set_ioperm(td, &iia); return (error); } int linux_iopl(struct thread *td, struct linux_iopl_args *args) { int error; if (args->level < 0 || args->level > 3) return (EINVAL); if ((error = priv_check(td, PRIV_IO)) != 0) return (error); if ((error = securelevel_gt(td->td_ucred, 0)) != 0) return (error); td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) | (args->level * (PSL_IOPL / 3)); return (0); } int linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap) { int error; struct i386_ldt_args ldt; struct l_descriptor ld; union descriptor desc; int size, written; switch (uap->func) { case 0x00: /* read_ldt */ ldt.start = 0; ldt.descs = uap->ptr; ldt.num = uap->bytecount / sizeof(union descriptor); error = i386_get_ldt(td, &ldt); td->td_retval[0] *= sizeof(union descriptor); break; case 0x02: /* read_default_ldt = 0 */ size = 5*sizeof(struct l_desc_struct); if (size > uap->bytecount) size = uap->bytecount; for (written = error = 0; written < size && error == 0; written++) error = subyte((char *)uap->ptr + written, 0); td->td_retval[0] = written; break; case 0x01: /* write_ldt */ case 0x11: /* write_ldt */ if (uap->bytecount != sizeof(ld)) return (EINVAL); error = copyin(uap->ptr, &ld, sizeof(ld)); if (error) return (error); ldt.start = ld.entry_number; ldt.descs = &desc; ldt.num = 1; desc.sd.sd_lolimit = (ld.limit & 0x0000ffff); desc.sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16; desc.sd.sd_lobase = (ld.base_addr & 0x00ffffff); desc.sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24; desc.sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) | (ld.contents << 2); desc.sd.sd_dpl = 3; desc.sd.sd_p = (ld.seg_not_present ^ 1); desc.sd.sd_xx = 0; desc.sd.sd_def32 = ld.seg_32bit; desc.sd.sd_gran = ld.limit_in_pages; error = i386_set_ldt(td, &ldt, &desc); break; default: error = ENOSYS; break; } if (error == EOPNOTSUPP) { printf("linux: modify_ldt needs kernel option USER_LDT\n"); error = ENOSYS; } return (error); } int linux_sigaction(struct thread *td, struct linux_sigaction_args *args) { l_osigaction_t osa; l_sigaction_t act, oact; int error; #ifdef DEBUG if (ldebug(sigaction)) printf(ARGS(sigaction, "%d, %p, %p"), args->sig, (void *)args->nsa, (void *)args->osa); #endif if (args->nsa != NULL) { error = copyin(args->nsa, &osa, sizeof(l_osigaction_t)); if (error) return (error); act.lsa_handler = osa.lsa_handler; act.lsa_flags = osa.lsa_flags; act.lsa_restorer = osa.lsa_restorer; LINUX_SIGEMPTYSET(act.lsa_mask); act.lsa_mask.__mask = osa.lsa_mask; } error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, args->osa ? &oact : NULL); if (args->osa != NULL && !error) { osa.lsa_handler = oact.lsa_handler; osa.lsa_flags = oact.lsa_flags; osa.lsa_restorer = oact.lsa_restorer; osa.lsa_mask = oact.lsa_mask.__mask; error = copyout(&osa, args->osa, sizeof(l_osigaction_t)); } return (error); } /* * Linux has two extra args, restart and oldmask. We dont use these, * but it seems that "restart" is actually a context pointer that * enables the signal to happen with a different register set. */ int linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) { sigset_t sigmask; l_sigset_t mask; #ifdef DEBUG if (ldebug(sigsuspend)) printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask); #endif LINUX_SIGEMPTYSET(mask); mask.__mask = args->mask; linux_to_bsd_sigset(&mask, &sigmask); return (kern_sigsuspend(td, sigmask)); } int linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap) { l_sigset_t lmask; sigset_t sigmask; int error; #ifdef DEBUG if (ldebug(rt_sigsuspend)) printf(ARGS(rt_sigsuspend, "%p, %d"), (void *)uap->newset, uap->sigsetsize); #endif if (uap->sigsetsize != sizeof(l_sigset_t)) return (EINVAL); error = copyin(uap->newset, &lmask, sizeof(l_sigset_t)); if (error) return (error); linux_to_bsd_sigset(&lmask, &sigmask); return (kern_sigsuspend(td, sigmask)); } int linux_pause(struct thread *td, struct linux_pause_args *args) { struct proc *p = td->td_proc; sigset_t sigmask; #ifdef DEBUG if (ldebug(pause)) printf(ARGS(pause, "")); #endif PROC_LOCK(p); sigmask = td->td_sigmask; PROC_UNLOCK(p); return (kern_sigsuspend(td, sigmask)); } int linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) { stack_t ss, oss; l_stack_t lss; int error; #ifdef DEBUG if (ldebug(sigaltstack)) printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss); #endif if (uap->uss != NULL) { error = copyin(uap->uss, &lss, sizeof(l_stack_t)); if (error) return (error); ss.ss_sp = lss.ss_sp; ss.ss_size = lss.ss_size; ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags); } error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL, (uap->uoss != NULL) ? &oss : NULL); if (!error && uap->uoss != NULL) { lss.ss_sp = oss.ss_sp; lss.ss_size = oss.ss_size; lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags); error = copyout(&lss, uap->uoss, sizeof(l_stack_t)); } return (error); } int -linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args) -{ - -#ifdef DEBUG - if (ldebug(ftruncate64)) - printf(ARGS(ftruncate64, "%u, %jd"), args->fd, - (intmax_t)args->length); -#endif - - return (kern_ftruncate(td, args->fd, args->length)); -} - -int linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args) { struct l_user_desc info; int error; int idx; int a[2]; struct segment_descriptor sd; error = copyin(args->desc, &info, sizeof(struct l_user_desc)); if (error) return (error); #ifdef DEBUG if (ldebug(set_thread_area)) printf(ARGS(set_thread_area, "%i, %x, %x, %i, %i, %i, %i, %i, %i\n"), info.entry_number, info.base_addr, info.limit, info.seg_32bit, info.contents, info.read_exec_only, info.limit_in_pages, info.seg_not_present, info.useable); #endif idx = info.entry_number; /* * Semantics of Linux version: every thread in the system has array of * 3 tls descriptors. 1st is GLIBC TLS, 2nd is WINE, 3rd unknown. This * syscall loads one of the selected tls decriptors with a value and * also loads GDT descriptors 6, 7 and 8 with the content of the * per-thread descriptors. * * Semantics of FreeBSD version: I think we can ignore that Linux has 3 * per-thread descriptors and use just the 1st one. The tls_array[] * is used only in set/get-thread_area() syscalls and for loading the * GDT descriptors. In FreeBSD we use just one GDT descriptor for TLS * so we will load just one. * * XXX: this doesn't work when a user space process tries to use more * than 1 TLS segment. Comment in the Linux sources says wine might do * this. */ /* * we support just GLIBC TLS now * we should let 3 proceed as well because we use this segment so * if code does two subsequent calls it should succeed */ if (idx != 6 && idx != -1 && idx != 3) return (EINVAL); /* * we have to copy out the GDT entry we use * FreeBSD uses GDT entry #3 for storing %gs so load that * * XXX: what if a user space program doesn't check this value and tries * to use 6, 7 or 8? */ idx = info.entry_number = 3; error = copyout(&info, args->desc, sizeof(struct l_user_desc)); if (error) return (error); if (LINUX_LDT_empty(&info)) { a[0] = 0; a[1] = 0; } else { a[0] = LINUX_LDT_entry_a(&info); a[1] = LINUX_LDT_entry_b(&info); } memcpy(&sd, &a, sizeof(a)); #ifdef DEBUG if (ldebug(set_thread_area)) printf("Segment created in set_thread_area: lobase: %x, hibase: %x, lolimit: %x, hilimit: %x, type: %i, dpl: %i, p: %i, xx: %i, def32: %i, gran: %i\n", sd.sd_lobase, sd.sd_hibase, sd.sd_lolimit, sd.sd_hilimit, sd.sd_type, sd.sd_dpl, sd.sd_p, sd.sd_xx, sd.sd_def32, sd.sd_gran); #endif /* this is taken from i386 version of cpu_set_user_tls() */ critical_enter(); /* set %gs */ td->td_pcb->pcb_gsd = sd; PCPU_GET(fsgs_gdt)[1] = sd; load_gs(GSEL(GUGS_SEL, SEL_UPL)); critical_exit(); return (0); } int linux_get_thread_area(struct thread *td, struct linux_get_thread_area_args *args) { struct l_user_desc info; int error; int idx; struct l_desc_struct desc; struct segment_descriptor sd; #ifdef DEBUG if (ldebug(get_thread_area)) printf(ARGS(get_thread_area, "%p"), args->desc); #endif error = copyin(args->desc, &info, sizeof(struct l_user_desc)); if (error) return (error); idx = info.entry_number; /* XXX: I am not sure if we want 3 to be allowed too. */ if (idx != 6 && idx != 3) return (EINVAL); idx = 3; memset(&info, 0, sizeof(info)); sd = PCPU_GET(fsgs_gdt)[1]; memcpy(&desc, &sd, sizeof(desc)); info.entry_number = idx; info.base_addr = LINUX_GET_BASE(&desc); info.limit = LINUX_GET_LIMIT(&desc); info.seg_32bit = LINUX_GET_32BIT(&desc); info.contents = LINUX_GET_CONTENTS(&desc); info.read_exec_only = !LINUX_GET_WRITABLE(&desc); info.limit_in_pages = LINUX_GET_LIMIT_PAGES(&desc); info.seg_not_present = !LINUX_GET_PRESENT(&desc); info.useable = LINUX_GET_USEABLE(&desc); error = copyout(&info, args->desc, sizeof(struct l_user_desc)); if (error) return (EFAULT); return (0); } /* XXX: this wont work with module - convert it */ int linux_mq_open(struct thread *td, struct linux_mq_open_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_open(td, (struct kmq_open_args *)args)); #else return (ENOSYS); #endif } int linux_mq_unlink(struct thread *td, struct linux_mq_unlink_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_unlink(td, (struct kmq_unlink_args *)args)); #else return (ENOSYS); #endif } int linux_mq_timedsend(struct thread *td, struct linux_mq_timedsend_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_timedsend(td, (struct kmq_timedsend_args *)args)); #else return (ENOSYS); #endif } int linux_mq_timedreceive(struct thread *td, struct linux_mq_timedreceive_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_timedreceive(td, (struct kmq_timedreceive_args *)args)); #else return (ENOSYS); #endif } int linux_mq_notify(struct thread *td, struct linux_mq_notify_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_notify(td, (struct kmq_notify_args *)args)); #else return (ENOSYS); #endif } int linux_mq_getsetattr(struct thread *td, struct linux_mq_getsetattr_args *args) { #ifdef P1003_1B_MQUEUE return (sys_kmq_setattr(td, (struct kmq_setattr_args *)args)); #else return (ENOSYS); #endif } Index: stable/12 =================================================================== --- stable/12 (revision 359604) +++ stable/12 (revision 359605) Property changes on: stable/12 ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head:r356945-356946