diff --git a/sys/compat/freebsd32/freebsd32.h b/sys/compat/freebsd32/freebsd32.h index b2f99949f920..6f219d0f733f 100644 --- a/sys/compat/freebsd32/freebsd32.h +++ b/sys/compat/freebsd32/freebsd32.h @@ -1,443 +1,443 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2001 Doug Rabson * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _COMPAT_FREEBSD32_FREEBSD32_H_ #define _COMPAT_FREEBSD32_FREEBSD32_H_ #include #include #include #include /* * i386 is the only arch with a 32-bit time_t */ #ifdef __amd64__ typedef int32_t time32_t; #else typedef int64_t time32_t; #endif struct timeval32 { time32_t tv_sec; int32_t tv_usec; }; struct timespec32 { time32_t tv_sec; int32_t tv_nsec; }; struct itimerspec32 { struct timespec32 it_interval; struct timespec32 it_value; }; struct bintime32 { time32_t sec; uint32_t frac[2]; }; struct rusage32 { struct timeval32 ru_utime; struct timeval32 ru_stime; int32_t ru_maxrss; int32_t ru_ixrss; int32_t ru_idrss; int32_t ru_isrss; int32_t ru_minflt; int32_t ru_majflt; int32_t ru_nswap; int32_t ru_inblock; int32_t ru_oublock; int32_t ru_msgsnd; int32_t ru_msgrcv; int32_t ru_nsignals; int32_t ru_nvcsw; int32_t ru_nivcsw; }; -struct wrusage32 { +struct __wrusage32 { struct rusage32 wru_self; struct rusage32 wru_children; }; struct itimerval32 { struct timeval32 it_interval; struct timeval32 it_value; }; struct umtx_time32 { struct timespec32 _timeout; uint32_t _flags; uint32_t _clockid; }; struct umtx_robust_lists_params_compat32 { uint32_t robust_list_offset; uint32_t robust_priv_list_offset; uint32_t robust_inact_offset; }; struct umutex32 { volatile __lwpid_t m_owner; /* Owner of the mutex */ __uint32_t m_flags; /* Flags of the mutex */ __uint32_t m_ceilings[2]; /* Priority protect ceiling */ __uint32_t m_rb_lnk; /* Robust linkage */ __uint32_t m_pad; __uint32_t m_spare[2]; }; #define FREEBSD4_OMFSNAMELEN 16 #define FREEBSD4_OMNAMELEN (88 - 2 * sizeof(int32_t)) /* 4.x version */ struct ostatfs32 { int32_t f_spare2; int32_t f_bsize; int32_t f_iosize; int32_t f_blocks; int32_t f_bfree; int32_t f_bavail; int32_t f_files; int32_t f_ffree; fsid_t f_fsid; uid_t f_owner; int32_t f_type; int32_t f_flags; int32_t f_syncwrites; int32_t f_asyncwrites; char f_fstypename[FREEBSD4_OMFSNAMELEN]; char f_mntonname[FREEBSD4_OMNAMELEN]; int32_t f_syncreads; int32_t f_asyncreads; int16_t f_spares1; char f_mntfromname[FREEBSD4_OMNAMELEN]; int16_t f_spares2 __packed; int32_t f_spare[2]; }; struct iovec32 { u_int32_t iov_base; int iov_len; }; struct msghdr32 { u_int32_t msg_name; socklen_t msg_namelen; u_int32_t msg_iov; int msg_iovlen; u_int32_t msg_control; socklen_t msg_controllen; int msg_flags; }; #if defined(__amd64__) #define __STAT32_TIME_T_EXT 1 #endif struct stat32 { dev_t st_dev; ino_t st_ino; nlink_t st_nlink; mode_t st_mode; u_int16_t st_padding0; uid_t st_uid; gid_t st_gid; u_int32_t st_padding1; dev_t st_rdev; #ifdef __STAT32_TIME_T_EXT __int32_t st_atim_ext; #endif struct timespec32 st_atim; #ifdef __STAT32_TIME_T_EXT __int32_t st_mtim_ext; #endif struct timespec32 st_mtim; #ifdef __STAT32_TIME_T_EXT __int32_t st_ctim_ext; #endif struct timespec32 st_ctim; #ifdef __STAT32_TIME_T_EXT __int32_t st_btim_ext; #endif struct timespec32 st_birthtim; off_t st_size; int64_t st_blocks; u_int32_t st_blksize; u_int32_t st_flags; u_int64_t st_gen; u_int64_t st_spare[10]; }; struct freebsd11_stat32 { u_int32_t st_dev; u_int32_t st_ino; mode_t st_mode; u_int16_t st_nlink; uid_t st_uid; gid_t st_gid; u_int32_t st_rdev; struct timespec32 st_atim; struct timespec32 st_mtim; struct timespec32 st_ctim; off_t st_size; int64_t st_blocks; u_int32_t st_blksize; u_int32_t st_flags; u_int32_t st_gen; int32_t st_lspare; struct timespec32 st_birthtim; unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec32)); unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec32)); }; struct ostat32 { __uint16_t st_dev; __uint32_t st_ino; mode_t st_mode; __uint16_t st_nlink; __uint16_t st_uid; __uint16_t st_gid; __uint16_t st_rdev; __int32_t st_size; struct timespec32 st_atim; struct timespec32 st_mtim; struct timespec32 st_ctim; __int32_t st_blksize; __int32_t st_blocks; u_int32_t st_flags; __uint32_t st_gen; }; struct jail32_v0 { u_int32_t version; uint32_t path; uint32_t hostname; u_int32_t ip_number; }; struct jail32 { uint32_t version; uint32_t path; uint32_t hostname; uint32_t jailname; uint32_t ip4s; uint32_t ip6s; uint32_t ip4; uint32_t ip6; }; struct sigaction32 { u_int32_t sa_u; int sa_flags; sigset_t sa_mask; }; struct thr_param32 { uint32_t start_func; uint32_t arg; uint32_t stack_base; uint32_t stack_size; uint32_t tls_base; uint32_t tls_size; uint32_t child_tid; uint32_t parent_tid; int32_t flags; uint32_t rtp; uint32_t spare[3]; }; struct i386_ldt_args32 { uint32_t start; uint32_t descs; uint32_t num; }; struct mq_attr32 { int mq_flags; int mq_maxmsg; int mq_msgsize; int mq_curmsgs; int __reserved[4]; }; struct kinfo_proc32 { int ki_structsize; int ki_layout; uint32_t ki_args; uint32_t ki_paddr; uint32_t ki_addr; uint32_t ki_tracep; uint32_t ki_textvp; uint32_t ki_fd; uint32_t ki_vmspace; uint32_t ki_wchan; pid_t ki_pid; pid_t ki_ppid; pid_t ki_pgid; pid_t ki_tpgid; pid_t ki_sid; pid_t ki_tsid; short ki_jobc; short ki_spare_short1; uint32_t ki_tdev_freebsd11; sigset_t ki_siglist; sigset_t ki_sigmask; sigset_t ki_sigignore; sigset_t ki_sigcatch; uid_t ki_uid; uid_t ki_ruid; uid_t ki_svuid; gid_t ki_rgid; gid_t ki_svgid; short ki_ngroups; short ki_spare_short2; gid_t ki_groups[KI_NGROUPS]; uint32_t ki_size; int32_t ki_rssize; int32_t ki_swrss; int32_t ki_tsize; int32_t ki_dsize; int32_t ki_ssize; u_short ki_xstat; u_short ki_acflag; fixpt_t ki_pctcpu; u_int ki_estcpu; u_int ki_slptime; u_int ki_swtime; u_int ki_cow; u_int64_t ki_runtime; struct timeval32 ki_start; struct timeval32 ki_childtime; int ki_flag; int ki_kiflag; int ki_traceflag; char ki_stat; signed char ki_nice; char ki_lock; char ki_rqindex; u_char ki_oncpu_old; u_char ki_lastcpu_old; char ki_tdname[TDNAMLEN+1]; char ki_wmesg[WMESGLEN+1]; char ki_login[LOGNAMELEN+1]; char ki_lockname[LOCKNAMELEN+1]; char ki_comm[COMMLEN+1]; char ki_emul[KI_EMULNAMELEN+1]; char ki_loginclass[LOGINCLASSLEN+1]; char ki_moretdname[MAXCOMLEN-TDNAMLEN+1]; char ki_sparestrings[46]; int ki_spareints[KI_NSPARE_INT]; uint64_t ki_tdev; int ki_oncpu; int ki_lastcpu; int ki_tracer; int ki_flag2; int ki_fibnum; u_int ki_cr_flags; int ki_jid; int ki_numthreads; lwpid_t ki_tid; struct priority ki_pri; struct rusage32 ki_rusage; struct rusage32 ki_rusage_ch; uint32_t ki_pcb; uint32_t ki_kstack; uint32_t ki_udata; uint32_t ki_tdaddr; uint32_t ki_spareptrs[KI_NSPARE_PTR]; /* spare room for growth */ int ki_sparelongs[KI_NSPARE_LONG]; int ki_sflag; int ki_tdflags; }; struct kinfo_sigtramp32 { uint32_t ksigtramp_start; uint32_t ksigtramp_end; uint32_t ksigtramp_spare[4]; }; struct kld_file_stat_1_32 { int version; /* set to sizeof(struct kld_file_stat_1) */ char name[MAXPATHLEN]; int refs; int id; uint32_t address; /* load address */ uint32_t size; /* size in bytes */ }; struct kld_file_stat32 { int version; /* set to sizeof(struct kld_file_stat) */ char name[MAXPATHLEN]; int refs; int id; uint32_t address; /* load address */ uint32_t size; /* size in bytes */ char pathname[MAXPATHLEN]; }; struct procctl_reaper_pids32 { u_int rp_count; u_int rp_pad0[15]; uint32_t rp_pids; }; struct timex32 { unsigned int modes; int32_t offset; int32_t freq; int32_t maxerror; int32_t esterror; int status; int32_t constant; int32_t precision; int32_t tolerance; int32_t ppsfreq; int32_t jitter; int shift; int32_t stabil; int32_t jitcnt; int32_t calcnt; int32_t errcnt; int32_t stbcnt; }; struct ptrace_coredump32 { int pc_fd; uint32_t pc_flags; uint32_t pc_limit1, pc_limit2; }; struct spacectl_range32 { uint32_t r_offset1, r_offset2; uint32_t r_len1, r_len2; }; #endif /* !_COMPAT_FREEBSD32_FREEBSD32_H_ */ diff --git a/sys/compat/freebsd32/freebsd32_misc.c b/sys/compat/freebsd32/freebsd32_misc.c index 902543144dd4..d9298890aaf1 100644 --- a/sys/compat/freebsd32/freebsd32_misc.c +++ b/sys/compat/freebsd32/freebsd32_misc.c @@ -1,3890 +1,3890 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2002 Doug Rabson * 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_inet.h" #include "opt_inet6.h" #include "opt_ktrace.h" #define __ELF_WORD_SIZE 32 #ifdef COMPAT_FREEBSD11 #define _WANT_FREEBSD11_KEVENT #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Must come after sys/malloc.h */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Must come after sys/selinfo.h */ #include /* Must come after sys/selinfo.h */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef KTRACE #include #endif #ifdef INET #include #endif #include #include #include #include #include #include #include #include #ifdef __amd64__ #include #endif #include #include #include #include #include #include #include FEATURE(compat_freebsd_32bit, "Compatible with 32-bit FreeBSD"); struct ptrace_io_desc32 { int piod_op; uint32_t piod_offs; uint32_t piod_addr; uint32_t piod_len; }; struct ptrace_sc_ret32 { uint32_t sr_retval[2]; int sr_error; }; struct ptrace_vm_entry32 { int pve_entry; int pve_timestamp; uint32_t pve_start; uint32_t pve_end; uint32_t pve_offset; u_int pve_prot; u_int pve_pathlen; int32_t pve_fileid; u_int pve_fsid; uint32_t pve_path; }; #ifdef __amd64__ CTASSERT(sizeof(struct timeval32) == 8); CTASSERT(sizeof(struct timespec32) == 8); CTASSERT(sizeof(struct itimerval32) == 16); CTASSERT(sizeof(struct bintime32) == 12); #endif CTASSERT(sizeof(struct ostatfs32) == 256); #ifdef __amd64__ CTASSERT(sizeof(struct rusage32) == 72); #endif CTASSERT(sizeof(struct sigaltstack32) == 12); #ifdef __amd64__ CTASSERT(sizeof(struct kevent32) == 56); #else CTASSERT(sizeof(struct kevent32) == 64); #endif CTASSERT(sizeof(struct iovec32) == 8); CTASSERT(sizeof(struct msghdr32) == 28); #ifdef __amd64__ CTASSERT(sizeof(struct stat32) == 208); CTASSERT(sizeof(struct freebsd11_stat32) == 96); #endif CTASSERT(sizeof(struct sigaction32) == 24); static int freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count); static int freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count); static int freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id, int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp); void freebsd32_rusage_out(const struct rusage *s, struct rusage32 *s32) { TV_CP(*s, *s32, ru_utime); TV_CP(*s, *s32, ru_stime); CP(*s, *s32, ru_maxrss); CP(*s, *s32, ru_ixrss); CP(*s, *s32, ru_idrss); CP(*s, *s32, ru_isrss); CP(*s, *s32, ru_minflt); CP(*s, *s32, ru_majflt); CP(*s, *s32, ru_nswap); CP(*s, *s32, ru_inblock); CP(*s, *s32, ru_oublock); CP(*s, *s32, ru_msgsnd); CP(*s, *s32, ru_msgrcv); CP(*s, *s32, ru_nsignals); CP(*s, *s32, ru_nvcsw); CP(*s, *s32, ru_nivcsw); } int freebsd32_wait4(struct thread *td, struct freebsd32_wait4_args *uap) { int error, status; struct rusage32 ru32; struct rusage ru, *rup; if (uap->rusage != NULL) rup = &ru; else rup = NULL; error = kern_wait(td, uap->pid, &status, uap->options, rup); if (error) return (error); if (uap->status != NULL) error = copyout(&status, uap->status, sizeof(status)); if (uap->rusage != NULL && error == 0) { freebsd32_rusage_out(&ru, &ru32); error = copyout(&ru32, uap->rusage, sizeof(ru32)); } return (error); } int freebsd32_wait6(struct thread *td, struct freebsd32_wait6_args *uap) { - struct wrusage32 wru32; + struct __wrusage32 wru32; struct __wrusage wru, *wrup; struct siginfo32 si32; struct __siginfo si, *sip; int error, status; if (uap->wrusage != NULL) wrup = &wru; else wrup = NULL; if (uap->info != NULL) { sip = &si; bzero(sip, sizeof(*sip)); } else sip = NULL; error = kern_wait6(td, uap->idtype, PAIR32TO64(id_t, uap->id), &status, uap->options, wrup, sip); if (error != 0) return (error); if (uap->status != NULL) error = copyout(&status, uap->status, sizeof(status)); if (uap->wrusage != NULL && error == 0) { freebsd32_rusage_out(&wru.wru_self, &wru32.wru_self); freebsd32_rusage_out(&wru.wru_children, &wru32.wru_children); error = copyout(&wru32, uap->wrusage, sizeof(wru32)); } if (uap->info != NULL && error == 0) { siginfo_to_siginfo32 (&si, &si32); error = copyout(&si32, uap->info, sizeof(si32)); } return (error); } #ifdef COMPAT_FREEBSD4 static void copy_statfs(struct statfs *in, struct ostatfs32 *out) { statfs_scale_blocks(in, INT32_MAX); bzero(out, sizeof(*out)); CP(*in, *out, f_bsize); out->f_iosize = MIN(in->f_iosize, INT32_MAX); CP(*in, *out, f_blocks); CP(*in, *out, f_bfree); CP(*in, *out, f_bavail); out->f_files = MIN(in->f_files, INT32_MAX); out->f_ffree = MIN(in->f_ffree, INT32_MAX); CP(*in, *out, f_fsid); CP(*in, *out, f_owner); CP(*in, *out, f_type); CP(*in, *out, f_flags); out->f_syncwrites = MIN(in->f_syncwrites, INT32_MAX); out->f_asyncwrites = MIN(in->f_asyncwrites, INT32_MAX); strlcpy(out->f_fstypename, in->f_fstypename, MFSNAMELEN); strlcpy(out->f_mntonname, in->f_mntonname, min(MNAMELEN, FREEBSD4_OMNAMELEN)); out->f_syncreads = MIN(in->f_syncreads, INT32_MAX); out->f_asyncreads = MIN(in->f_asyncreads, INT32_MAX); strlcpy(out->f_mntfromname, in->f_mntfromname, min(MNAMELEN, FREEBSD4_OMNAMELEN)); } #endif #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_getfsstat(struct thread *td, struct freebsd4_freebsd32_getfsstat_args *uap) { struct statfs *buf, *sp; struct ostatfs32 stat32; size_t count, size, copycount; int error; count = uap->bufsize / sizeof(struct ostatfs32); size = count * sizeof(struct statfs); error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE, uap->mode); if (size > 0) { sp = buf; copycount = count; while (copycount > 0 && error == 0) { copy_statfs(sp, &stat32); error = copyout(&stat32, uap->buf, sizeof(stat32)); sp++; uap->buf++; copycount--; } free(buf, M_STATFS); } if (error == 0) td->td_retval[0] = count; return (error); } #endif #ifdef COMPAT_FREEBSD10 int freebsd10_freebsd32_pipe(struct thread *td, struct freebsd10_freebsd32_pipe_args *uap) { return (freebsd10_pipe(td, (struct freebsd10_pipe_args*)uap)); } #endif int freebsd32_sigaltstack(struct thread *td, struct freebsd32_sigaltstack_args *uap) { struct sigaltstack32 s32; struct sigaltstack ss, oss, *ssp; int error; if (uap->ss != NULL) { error = copyin(uap->ss, &s32, sizeof(s32)); if (error) return (error); PTRIN_CP(s32, ss, ss_sp); CP(s32, ss, ss_size); CP(s32, ss, ss_flags); ssp = &ss; } else ssp = NULL; error = kern_sigaltstack(td, ssp, &oss); if (error == 0 && uap->oss != NULL) { PTROUT_CP(oss, s32, ss_sp); CP(oss, s32, ss_size); CP(oss, s32, ss_flags); error = copyout(&s32, uap->oss, sizeof(s32)); } return (error); } /* * Custom version of exec_copyin_args() so that we can translate * the pointers. */ int freebsd32_exec_copyin_args(struct image_args *args, const char *fname, enum uio_seg segflg, u_int32_t *argv, u_int32_t *envv) { char *argp, *envp; u_int32_t *p32, arg; int error; bzero(args, sizeof(*args)); if (argv == NULL) return (EFAULT); /* * Allocate demand-paged memory for the file name, argument, and * environment strings. */ error = exec_alloc_args(args); if (error != 0) return (error); /* * Copy the file name. */ error = exec_args_add_fname(args, fname, segflg); if (error != 0) goto err_exit; /* * extract arguments first */ p32 = argv; for (;;) { error = copyin(p32++, &arg, sizeof(arg)); if (error) goto err_exit; if (arg == 0) break; argp = PTRIN(arg); error = exec_args_add_arg(args, argp, UIO_USERSPACE); if (error != 0) goto err_exit; } /* * extract environment strings */ if (envv) { p32 = envv; for (;;) { error = copyin(p32++, &arg, sizeof(arg)); if (error) goto err_exit; if (arg == 0) break; envp = PTRIN(arg); error = exec_args_add_env(args, envp, UIO_USERSPACE); if (error != 0) goto err_exit; } } return (0); err_exit: exec_free_args(args); return (error); } int freebsd32_execve(struct thread *td, struct freebsd32_execve_args *uap) { struct image_args eargs; struct vmspace *oldvmspace; int error; error = pre_execve(td, &oldvmspace); if (error != 0) return (error); error = freebsd32_exec_copyin_args(&eargs, uap->fname, UIO_USERSPACE, uap->argv, uap->envv); if (error == 0) error = kern_execve(td, &eargs, NULL, oldvmspace); post_execve(td, error, oldvmspace); AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td); return (error); } int freebsd32_fexecve(struct thread *td, struct freebsd32_fexecve_args *uap) { struct image_args eargs; struct vmspace *oldvmspace; int error; error = pre_execve(td, &oldvmspace); if (error != 0) return (error); error = freebsd32_exec_copyin_args(&eargs, NULL, UIO_SYSSPACE, uap->argv, uap->envv); if (error == 0) { eargs.fd = uap->fd; error = kern_execve(td, &eargs, NULL, oldvmspace); } post_execve(td, error, oldvmspace); AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td); return (error); } int freebsd32_mknodat(struct thread *td, struct freebsd32_mknodat_args *uap) { return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode, PAIR32TO64(dev_t, uap->dev))); } int freebsd32_mprotect(struct thread *td, struct freebsd32_mprotect_args *uap) { int prot; prot = uap->prot; #if defined(__amd64__) if (i386_read_exec && (prot & PROT_READ) != 0) prot |= PROT_EXEC; #endif return (kern_mprotect(td, (uintptr_t)PTRIN(uap->addr), uap->len, prot)); } int freebsd32_mmap(struct thread *td, struct freebsd32_mmap_args *uap) { int prot; prot = uap->prot; #if defined(__amd64__) if (i386_read_exec && (prot & PROT_READ)) prot |= PROT_EXEC; #endif return (kern_mmap(td, &(struct mmap_req){ .mr_hint = (uintptr_t)uap->addr, .mr_len = uap->len, .mr_prot = prot, .mr_flags = uap->flags, .mr_fd = uap->fd, .mr_pos = PAIR32TO64(off_t, uap->pos), })); } #ifdef COMPAT_FREEBSD6 int freebsd6_freebsd32_mmap(struct thread *td, struct freebsd6_freebsd32_mmap_args *uap) { int prot; prot = uap->prot; #if defined(__amd64__) if (i386_read_exec && (prot & PROT_READ)) prot |= PROT_EXEC; #endif return (kern_mmap(td, &(struct mmap_req){ .mr_hint = (uintptr_t)uap->addr, .mr_len = uap->len, .mr_prot = prot, .mr_flags = uap->flags, .mr_fd = uap->fd, .mr_pos = PAIR32TO64(off_t, uap->pos), })); } #endif #ifdef COMPAT_43 int ofreebsd32_mmap(struct thread *td, struct ofreebsd32_mmap_args *uap) { return (kern_ommap(td, (uintptr_t)uap->addr, uap->len, uap->prot, uap->flags, uap->fd, uap->pos)); } #endif int freebsd32_setitimer(struct thread *td, struct freebsd32_setitimer_args *uap) { struct itimerval itv, oitv, *itvp; struct itimerval32 i32; int error; if (uap->itv != NULL) { error = copyin(uap->itv, &i32, sizeof(i32)); if (error) return (error); TV_CP(i32, itv, it_interval); TV_CP(i32, itv, it_value); itvp = &itv; } else itvp = NULL; error = kern_setitimer(td, uap->which, itvp, &oitv); if (error || uap->oitv == NULL) return (error); TV_CP(oitv, i32, it_interval); TV_CP(oitv, i32, it_value); return (copyout(&i32, uap->oitv, sizeof(i32))); } int freebsd32_getitimer(struct thread *td, struct freebsd32_getitimer_args *uap) { struct itimerval itv; struct itimerval32 i32; int error; error = kern_getitimer(td, uap->which, &itv); if (error || uap->itv == NULL) return (error); TV_CP(itv, i32, it_interval); TV_CP(itv, i32, it_value); return (copyout(&i32, uap->itv, sizeof(i32))); } int freebsd32_select(struct thread *td, struct freebsd32_select_args *uap) { struct timeval32 tv32; struct timeval tv, *tvp; int error; if (uap->tv != NULL) { error = copyin(uap->tv, &tv32, sizeof(tv32)); if (error) return (error); CP(tv32, tv, tv_sec); CP(tv32, tv, tv_usec); tvp = &tv; } else tvp = NULL; /* * XXX Do pointers need PTRIN()? */ return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp, sizeof(int32_t) * 8)); } int freebsd32_pselect(struct thread *td, struct freebsd32_pselect_args *uap) { struct timespec32 ts32; struct timespec ts; struct timeval tv, *tvp; sigset_t set, *uset; int error; if (uap->ts != NULL) { error = copyin(uap->ts, &ts32, sizeof(ts32)); if (error != 0) return (error); CP(ts32, ts, tv_sec); CP(ts32, ts, tv_nsec); TIMESPEC_TO_TIMEVAL(&tv, &ts); tvp = &tv; } else tvp = NULL; if (uap->sm != NULL) { error = copyin(uap->sm, &set, sizeof(set)); if (error != 0) return (error); uset = &set; } else uset = NULL; /* * XXX Do pointers need PTRIN()? */ error = kern_pselect(td, uap->nd, uap->in, uap->ou, uap->ex, tvp, uset, sizeof(int32_t) * 8); return (error); } /* * Copy 'count' items into the destination list pointed to by uap->eventlist. */ static int freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count) { struct freebsd32_kevent_args *uap; struct kevent32 ks32[KQ_NEVENTS]; uint64_t e; int i, j, error; KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count)); uap = (struct freebsd32_kevent_args *)arg; for (i = 0; i < count; i++) { CP(kevp[i], ks32[i], ident); CP(kevp[i], ks32[i], filter); CP(kevp[i], ks32[i], flags); CP(kevp[i], ks32[i], fflags); #if BYTE_ORDER == LITTLE_ENDIAN ks32[i].data1 = kevp[i].data; ks32[i].data2 = kevp[i].data >> 32; #else ks32[i].data1 = kevp[i].data >> 32; ks32[i].data2 = kevp[i].data; #endif PTROUT_CP(kevp[i], ks32[i], udata); for (j = 0; j < nitems(kevp->ext); j++) { e = kevp[i].ext[j]; #if BYTE_ORDER == LITTLE_ENDIAN ks32[i].ext64[2 * j] = e; ks32[i].ext64[2 * j + 1] = e >> 32; #else ks32[i].ext64[2 * j] = e >> 32; ks32[i].ext64[2 * j + 1] = e; #endif } } error = copyout(ks32, uap->eventlist, count * sizeof *ks32); if (error == 0) uap->eventlist += count; return (error); } /* * Copy 'count' items from the list pointed to by uap->changelist. */ static int freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count) { struct freebsd32_kevent_args *uap; struct kevent32 ks32[KQ_NEVENTS]; uint64_t e; int i, j, error; KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count)); uap = (struct freebsd32_kevent_args *)arg; error = copyin(uap->changelist, ks32, count * sizeof *ks32); if (error) goto done; uap->changelist += count; for (i = 0; i < count; i++) { CP(ks32[i], kevp[i], ident); CP(ks32[i], kevp[i], filter); CP(ks32[i], kevp[i], flags); CP(ks32[i], kevp[i], fflags); kevp[i].data = PAIR32TO64(uint64_t, ks32[i].data); PTRIN_CP(ks32[i], kevp[i], udata); for (j = 0; j < nitems(kevp->ext); j++) { #if BYTE_ORDER == LITTLE_ENDIAN e = ks32[i].ext64[2 * j + 1]; e <<= 32; e += ks32[i].ext64[2 * j]; #else e = ks32[i].ext64[2 * j]; e <<= 32; e += ks32[i].ext64[2 * j + 1]; #endif kevp[i].ext[j] = e; } } done: return (error); } int freebsd32_kevent(struct thread *td, struct freebsd32_kevent_args *uap) { struct timespec32 ts32; struct timespec ts, *tsp; struct kevent_copyops k_ops = { .arg = uap, .k_copyout = freebsd32_kevent_copyout, .k_copyin = freebsd32_kevent_copyin, }; #ifdef KTRACE struct kevent32 *eventlist = uap->eventlist; #endif int error; if (uap->timeout) { error = copyin(uap->timeout, &ts32, sizeof(ts32)); if (error) return (error); CP(ts32, ts, tv_sec); CP(ts32, ts, tv_nsec); tsp = &ts; } else tsp = NULL; #ifdef KTRACE if (KTRPOINT(td, KTR_STRUCT_ARRAY)) ktrstructarray("kevent32", UIO_USERSPACE, uap->changelist, uap->nchanges, sizeof(struct kevent32)); #endif error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents, &k_ops, tsp); #ifdef KTRACE if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY)) ktrstructarray("kevent32", UIO_USERSPACE, eventlist, td->td_retval[0], sizeof(struct kevent32)); #endif return (error); } #ifdef COMPAT_FREEBSD11 static int freebsd32_kevent11_copyout(void *arg, struct kevent *kevp, int count) { struct freebsd11_freebsd32_kevent_args *uap; struct freebsd11_kevent32 ks32[KQ_NEVENTS]; int i, error; KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count)); uap = (struct freebsd11_freebsd32_kevent_args *)arg; for (i = 0; i < count; i++) { CP(kevp[i], ks32[i], ident); CP(kevp[i], ks32[i], filter); CP(kevp[i], ks32[i], flags); CP(kevp[i], ks32[i], fflags); CP(kevp[i], ks32[i], data); PTROUT_CP(kevp[i], ks32[i], udata); } error = copyout(ks32, uap->eventlist, count * sizeof *ks32); if (error == 0) uap->eventlist += count; return (error); } /* * Copy 'count' items from the list pointed to by uap->changelist. */ static int freebsd32_kevent11_copyin(void *arg, struct kevent *kevp, int count) { struct freebsd11_freebsd32_kevent_args *uap; struct freebsd11_kevent32 ks32[KQ_NEVENTS]; int i, j, error; KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count)); uap = (struct freebsd11_freebsd32_kevent_args *)arg; error = copyin(uap->changelist, ks32, count * sizeof *ks32); if (error) goto done; uap->changelist += count; for (i = 0; i < count; i++) { CP(ks32[i], kevp[i], ident); CP(ks32[i], kevp[i], filter); CP(ks32[i], kevp[i], flags); CP(ks32[i], kevp[i], fflags); CP(ks32[i], kevp[i], data); PTRIN_CP(ks32[i], kevp[i], udata); for (j = 0; j < nitems(kevp->ext); j++) kevp[i].ext[j] = 0; } done: return (error); } int freebsd11_freebsd32_kevent(struct thread *td, struct freebsd11_freebsd32_kevent_args *uap) { struct timespec32 ts32; struct timespec ts, *tsp; struct kevent_copyops k_ops = { .arg = uap, .k_copyout = freebsd32_kevent11_copyout, .k_copyin = freebsd32_kevent11_copyin, }; #ifdef KTRACE struct freebsd11_kevent32 *eventlist = uap->eventlist; #endif int error; if (uap->timeout) { error = copyin(uap->timeout, &ts32, sizeof(ts32)); if (error) return (error); CP(ts32, ts, tv_sec); CP(ts32, ts, tv_nsec); tsp = &ts; } else tsp = NULL; #ifdef KTRACE if (KTRPOINT(td, KTR_STRUCT_ARRAY)) ktrstructarray("freebsd11_kevent32", UIO_USERSPACE, uap->changelist, uap->nchanges, sizeof(struct freebsd11_kevent32)); #endif error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents, &k_ops, tsp); #ifdef KTRACE if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY)) ktrstructarray("freebsd11_kevent32", UIO_USERSPACE, eventlist, td->td_retval[0], sizeof(struct freebsd11_kevent32)); #endif return (error); } #endif int freebsd32_gettimeofday(struct thread *td, struct freebsd32_gettimeofday_args *uap) { struct timeval atv; struct timeval32 atv32; struct timezone rtz; int error = 0; if (uap->tp) { microtime(&atv); CP(atv, atv32, tv_sec); CP(atv, atv32, tv_usec); error = copyout(&atv32, uap->tp, sizeof (atv32)); } if (error == 0 && uap->tzp != NULL) { rtz.tz_minuteswest = 0; rtz.tz_dsttime = 0; error = copyout(&rtz, uap->tzp, sizeof (rtz)); } return (error); } int freebsd32_getrusage(struct thread *td, struct freebsd32_getrusage_args *uap) { struct rusage32 s32; struct rusage s; int error; error = kern_getrusage(td, uap->who, &s); if (error == 0) { freebsd32_rusage_out(&s, &s32); error = copyout(&s32, uap->rusage, sizeof(s32)); } return (error); } static void ptrace_lwpinfo_to32(const struct ptrace_lwpinfo *pl, struct ptrace_lwpinfo32 *pl32) { bzero(pl32, sizeof(*pl32)); pl32->pl_lwpid = pl->pl_lwpid; pl32->pl_event = pl->pl_event; pl32->pl_flags = pl->pl_flags; pl32->pl_sigmask = pl->pl_sigmask; pl32->pl_siglist = pl->pl_siglist; siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo); strcpy(pl32->pl_tdname, pl->pl_tdname); pl32->pl_child_pid = pl->pl_child_pid; pl32->pl_syscall_code = pl->pl_syscall_code; pl32->pl_syscall_narg = pl->pl_syscall_narg; } static void ptrace_sc_ret_to32(const struct ptrace_sc_ret *psr, struct ptrace_sc_ret32 *psr32) { bzero(psr32, sizeof(*psr32)); psr32->sr_retval[0] = psr->sr_retval[0]; psr32->sr_retval[1] = psr->sr_retval[1]; psr32->sr_error = psr->sr_error; } int freebsd32_ptrace(struct thread *td, struct freebsd32_ptrace_args *uap) { union { struct ptrace_io_desc piod; struct ptrace_lwpinfo pl; struct ptrace_vm_entry pve; struct ptrace_coredump pc; struct dbreg32 dbreg; struct fpreg32 fpreg; struct reg32 reg; register_t args[nitems(td->td_sa.args)]; struct ptrace_sc_ret psr; int ptevents; } r; union { struct ptrace_io_desc32 piod; struct ptrace_lwpinfo32 pl; struct ptrace_vm_entry32 pve; struct ptrace_coredump32 pc; uint32_t args[nitems(td->td_sa.args)]; struct ptrace_sc_ret32 psr; } r32; void *addr; int data, error = 0, i; AUDIT_ARG_PID(uap->pid); AUDIT_ARG_CMD(uap->req); AUDIT_ARG_VALUE(uap->data); addr = &r; data = uap->data; switch (uap->req) { case PT_GET_EVENT_MASK: case PT_GET_SC_ARGS: case PT_GET_SC_RET: break; case PT_LWPINFO: if (uap->data > sizeof(r32.pl)) return (EINVAL); /* * Pass size of native structure in 'data'. Truncate * if necessary to avoid siginfo. */ data = sizeof(r.pl); if (uap->data < offsetof(struct ptrace_lwpinfo32, pl_siginfo) + sizeof(struct siginfo32)) data = offsetof(struct ptrace_lwpinfo, pl_siginfo); break; case PT_GETREGS: bzero(&r.reg, sizeof(r.reg)); break; case PT_GETFPREGS: bzero(&r.fpreg, sizeof(r.fpreg)); break; case PT_GETDBREGS: bzero(&r.dbreg, sizeof(r.dbreg)); break; case PT_SETREGS: error = copyin(uap->addr, &r.reg, sizeof(r.reg)); break; case PT_SETFPREGS: error = copyin(uap->addr, &r.fpreg, sizeof(r.fpreg)); break; case PT_SETDBREGS: error = copyin(uap->addr, &r.dbreg, sizeof(r.dbreg)); break; case PT_SET_EVENT_MASK: if (uap->data != sizeof(r.ptevents)) error = EINVAL; else error = copyin(uap->addr, &r.ptevents, uap->data); break; case PT_IO: error = copyin(uap->addr, &r32.piod, sizeof(r32.piod)); if (error) break; CP(r32.piod, r.piod, piod_op); PTRIN_CP(r32.piod, r.piod, piod_offs); PTRIN_CP(r32.piod, r.piod, piod_addr); CP(r32.piod, r.piod, piod_len); break; case PT_VM_ENTRY: error = copyin(uap->addr, &r32.pve, sizeof(r32.pve)); if (error) break; CP(r32.pve, r.pve, pve_entry); CP(r32.pve, r.pve, pve_timestamp); CP(r32.pve, r.pve, pve_start); CP(r32.pve, r.pve, pve_end); CP(r32.pve, r.pve, pve_offset); CP(r32.pve, r.pve, pve_prot); CP(r32.pve, r.pve, pve_pathlen); CP(r32.pve, r.pve, pve_fileid); CP(r32.pve, r.pve, pve_fsid); PTRIN_CP(r32.pve, r.pve, pve_path); break; case PT_COREDUMP: if (uap->data != sizeof(r32.pc)) error = EINVAL; else error = copyin(uap->addr, &r32.pc, uap->data); CP(r32.pc, r.pc, pc_fd); CP(r32.pc, r.pc, pc_flags); r.pc.pc_limit = PAIR32TO64(off_t, r32.pc.pc_limit); data = sizeof(r.pc); break; default: addr = uap->addr; break; } if (error) return (error); error = kern_ptrace(td, uap->req, uap->pid, addr, data); if (error) return (error); switch (uap->req) { case PT_VM_ENTRY: CP(r.pve, r32.pve, pve_entry); CP(r.pve, r32.pve, pve_timestamp); CP(r.pve, r32.pve, pve_start); CP(r.pve, r32.pve, pve_end); CP(r.pve, r32.pve, pve_offset); CP(r.pve, r32.pve, pve_prot); CP(r.pve, r32.pve, pve_pathlen); CP(r.pve, r32.pve, pve_fileid); CP(r.pve, r32.pve, pve_fsid); error = copyout(&r32.pve, uap->addr, sizeof(r32.pve)); break; case PT_IO: CP(r.piod, r32.piod, piod_len); error = copyout(&r32.piod, uap->addr, sizeof(r32.piod)); break; case PT_GETREGS: error = copyout(&r.reg, uap->addr, sizeof(r.reg)); break; case PT_GETFPREGS: error = copyout(&r.fpreg, uap->addr, sizeof(r.fpreg)); break; case PT_GETDBREGS: error = copyout(&r.dbreg, uap->addr, sizeof(r.dbreg)); break; case PT_GET_EVENT_MASK: /* NB: The size in uap->data is validated in kern_ptrace(). */ error = copyout(&r.ptevents, uap->addr, uap->data); break; case PT_LWPINFO: ptrace_lwpinfo_to32(&r.pl, &r32.pl); error = copyout(&r32.pl, uap->addr, uap->data); break; case PT_GET_SC_ARGS: for (i = 0; i < nitems(r.args); i++) r32.args[i] = (uint32_t)r.args[i]; error = copyout(r32.args, uap->addr, MIN(uap->data, sizeof(r32.args))); break; case PT_GET_SC_RET: ptrace_sc_ret_to32(&r.psr, &r32.psr); error = copyout(&r32.psr, uap->addr, MIN(uap->data, sizeof(r32.psr))); break; } return (error); } int freebsd32_copyinuio(struct iovec32 *iovp, u_int iovcnt, struct uio **uiop) { struct iovec32 iov32; struct iovec *iov; struct uio *uio; u_int 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 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 freebsd32_readv(struct thread *td, struct freebsd32_readv_args *uap) { struct uio *auio; int error; error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_readv(td, uap->fd, auio); free(auio, M_IOV); return (error); } int freebsd32_writev(struct thread *td, struct freebsd32_writev_args *uap) { struct uio *auio; int error; error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_writev(td, uap->fd, auio); free(auio, M_IOV); return (error); } int freebsd32_preadv(struct thread *td, struct freebsd32_preadv_args *uap) { struct uio *auio; int error; error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_preadv(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset)); free(auio, M_IOV); return (error); } int freebsd32_pwritev(struct thread *td, struct freebsd32_pwritev_args *uap) { struct uio *auio; int error; error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_pwritev(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset)); free(auio, M_IOV); return (error); } int freebsd32_copyiniov(struct iovec32 *iovp32, u_int iovcnt, struct iovec **iovp, int error) { struct iovec32 iov32; struct iovec *iov; u_int 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 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); } static int freebsd32_copyinmsghdr(const struct msghdr32 *msg32, struct msghdr *msg) { struct msghdr32 m32; int error; error = copyin(msg32, &m32, sizeof(m32)); if (error) return (error); msg->msg_name = PTRIN(m32.msg_name); msg->msg_namelen = m32.msg_namelen; msg->msg_iov = PTRIN(m32.msg_iov); msg->msg_iovlen = m32.msg_iovlen; msg->msg_control = PTRIN(m32.msg_control); msg->msg_controllen = m32.msg_controllen; msg->msg_flags = m32.msg_flags; return (0); } static int freebsd32_copyoutmsghdr(struct msghdr *msg, struct msghdr32 *msg32) { struct msghdr32 m32; int error; m32.msg_name = PTROUT(msg->msg_name); m32.msg_namelen = msg->msg_namelen; m32.msg_iov = PTROUT(msg->msg_iov); m32.msg_iovlen = msg->msg_iovlen; m32.msg_control = PTROUT(msg->msg_control); m32.msg_controllen = msg->msg_controllen; m32.msg_flags = msg->msg_flags; error = copyout(&m32, msg32, sizeof(m32)); return (error); } #ifndef __mips__ #define FREEBSD32_ALIGNBYTES (sizeof(int) - 1) #else #define FREEBSD32_ALIGNBYTES (sizeof(long) - 1) #endif #define FREEBSD32_ALIGN(p) \ (((u_long)(p) + FREEBSD32_ALIGNBYTES) & ~FREEBSD32_ALIGNBYTES) #define FREEBSD32_CMSG_SPACE(l) \ (FREEBSD32_ALIGN(sizeof(struct cmsghdr)) + FREEBSD32_ALIGN(l)) #define FREEBSD32_CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + \ FREEBSD32_ALIGN(sizeof(struct cmsghdr))) static size_t freebsd32_cmsg_convert(const struct cmsghdr *cm, void *data, socklen_t datalen) { size_t copylen; union { struct timespec32 ts; struct timeval32 tv; struct bintime32 bt; } tmp32; union { struct timespec ts; struct timeval tv; struct bintime bt; } *in; in = data; copylen = 0; switch (cm->cmsg_level) { case SOL_SOCKET: switch (cm->cmsg_type) { case SCM_TIMESTAMP: TV_CP(*in, tmp32, tv); copylen = sizeof(tmp32.tv); break; case SCM_BINTIME: BT_CP(*in, tmp32, bt); copylen = sizeof(tmp32.bt); break; case SCM_REALTIME: case SCM_MONOTONIC: TS_CP(*in, tmp32, ts); copylen = sizeof(tmp32.ts); break; default: break; } default: break; } if (copylen == 0) return (datalen); KASSERT((datalen >= copylen), ("corrupted cmsghdr")); bcopy(&tmp32, data, copylen); return (copylen); } static int freebsd32_copy_msg_out(struct msghdr *msg, struct mbuf *control) { struct cmsghdr *cm; void *data; socklen_t clen, datalen, datalen_out, oldclen; int error; caddr_t ctlbuf; int len, maxlen, copylen; struct mbuf *m; error = 0; len = msg->msg_controllen; maxlen = msg->msg_controllen; msg->msg_controllen = 0; ctlbuf = msg->msg_control; for (m = control; m != NULL && len > 0; m = m->m_next) { cm = mtod(m, struct cmsghdr *); clen = m->m_len; while (cm != NULL) { if (sizeof(struct cmsghdr) > clen || cm->cmsg_len > clen) { error = EINVAL; break; } data = CMSG_DATA(cm); datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data; datalen_out = freebsd32_cmsg_convert(cm, data, datalen); /* * Copy out the message header. Preserve the native * message size in case we need to inspect the message * contents later. */ copylen = sizeof(struct cmsghdr); if (len < copylen) { msg->msg_flags |= MSG_CTRUNC; m_dispose_extcontrolm(m); goto exit; } oldclen = cm->cmsg_len; cm->cmsg_len = FREEBSD32_ALIGN(sizeof(struct cmsghdr)) + datalen_out; error = copyout(cm, ctlbuf, copylen); cm->cmsg_len = oldclen; if (error != 0) goto exit; ctlbuf += FREEBSD32_ALIGN(copylen); len -= FREEBSD32_ALIGN(copylen); copylen = datalen_out; if (len < copylen) { msg->msg_flags |= MSG_CTRUNC; m_dispose_extcontrolm(m); break; } /* Copy out the message data. */ error = copyout(data, ctlbuf, copylen); if (error) goto exit; ctlbuf += FREEBSD32_ALIGN(copylen); len -= FREEBSD32_ALIGN(copylen); if (CMSG_SPACE(datalen) < clen) { clen -= CMSG_SPACE(datalen); cm = (struct cmsghdr *) ((caddr_t)cm + CMSG_SPACE(datalen)); } else { clen = 0; cm = NULL; } msg->msg_controllen += FREEBSD32_CMSG_SPACE(datalen_out); } } if (len == 0 && m != NULL) { msg->msg_flags |= MSG_CTRUNC; m_dispose_extcontrolm(m); } exit: return (error); } int freebsd32_recvmsg(struct thread *td, struct freebsd32_recvmsg_args *uap) { struct msghdr msg; struct iovec *uiov, *iov; struct mbuf *control = NULL; struct mbuf **controlp; int error; error = freebsd32_copyinmsghdr(uap->msg, &msg); if (error) return (error); error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE); if (error) return (error); msg.msg_flags = uap->flags; uiov = msg.msg_iov; msg.msg_iov = iov; controlp = (msg.msg_control != NULL) ? &control : NULL; error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, controlp); if (error == 0) { msg.msg_iov = uiov; if (control != NULL) error = freebsd32_copy_msg_out(&msg, control); else msg.msg_controllen = 0; if (error == 0) error = freebsd32_copyoutmsghdr(&msg, uap->msg); } free(iov, M_IOV); if (control != NULL) { if (error != 0) m_dispose_extcontrolm(control); m_freem(control); } return (error); } /* * Copy-in the array of control messages constructed using alignment * and padding suitable for a 32-bit environment and construct an * mbuf using alignment and padding suitable for a 64-bit kernel. * The alignment and padding are defined indirectly by CMSG_DATA(), * CMSG_SPACE() and CMSG_LEN(). */ static int freebsd32_copyin_control(struct mbuf **mp, caddr_t buf, u_int buflen) { struct cmsghdr *cm; struct mbuf *m; void *in, *in1, *md; u_int msglen, outlen; int error; if (buflen > MCLBYTES) return (EINVAL); in = malloc(buflen, M_TEMP, M_WAITOK); error = copyin(buf, in, buflen); if (error != 0) goto out; /* * Make a pass over the input buffer to determine the amount of space * required for 64 bit-aligned copies of the control messages. */ in1 = in; outlen = 0; while (buflen > 0) { if (buflen < sizeof(*cm)) { error = EINVAL; break; } cm = (struct cmsghdr *)in1; if (cm->cmsg_len < FREEBSD32_ALIGN(sizeof(*cm))) { error = EINVAL; break; } msglen = FREEBSD32_ALIGN(cm->cmsg_len); if (msglen > buflen || msglen < cm->cmsg_len) { error = EINVAL; break; } buflen -= msglen; in1 = (char *)in1 + msglen; outlen += CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen - FREEBSD32_ALIGN(sizeof(*cm))); } if (error == 0 && outlen > MCLBYTES) { /* * XXXMJ This implies that the upper limit on 32-bit aligned * control messages is less than MCLBYTES, and so we are not * perfectly compatible. However, there is no platform * guarantee that mbuf clusters larger than MCLBYTES can be * allocated. */ error = EINVAL; } if (error != 0) goto out; m = m_get2(outlen, M_WAITOK, MT_CONTROL, 0); m->m_len = outlen; md = mtod(m, void *); /* * Make a second pass over input messages, copying them into the output * buffer. */ in1 = in; while (outlen > 0) { /* Copy the message header and align the length field. */ cm = md; memcpy(cm, in1, sizeof(*cm)); msglen = cm->cmsg_len - FREEBSD32_ALIGN(sizeof(*cm)); cm->cmsg_len = CMSG_ALIGN(sizeof(*cm)) + msglen; /* Copy the message body. */ in1 = (char *)in1 + FREEBSD32_ALIGN(sizeof(*cm)); md = (char *)md + CMSG_ALIGN(sizeof(*cm)); memcpy(md, in1, msglen); in1 = (char *)in1 + FREEBSD32_ALIGN(msglen); md = (char *)md + CMSG_ALIGN(msglen); KASSERT(outlen >= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen), ("outlen %u underflow, msglen %u", outlen, msglen)); outlen -= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen); } *mp = m; out: free(in, M_TEMP); return (error); } int freebsd32_sendmsg(struct thread *td, struct freebsd32_sendmsg_args *uap) { struct msghdr msg; struct iovec *iov; struct mbuf *control = NULL; struct sockaddr *to = NULL; int error; error = freebsd32_copyinmsghdr(uap->msg, &msg); if (error) return (error); error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE); if (error) return (error); msg.msg_iov = iov; if (msg.msg_name != NULL) { error = getsockaddr(&to, msg.msg_name, msg.msg_namelen); if (error) { to = NULL; goto out; } msg.msg_name = to; } if (msg.msg_control) { if (msg.msg_controllen < sizeof(struct cmsghdr)) { error = EINVAL; goto out; } error = freebsd32_copyin_control(&control, msg.msg_control, msg.msg_controllen); if (error) goto out; msg.msg_control = NULL; msg.msg_controllen = 0; } error = kern_sendit(td, uap->s, &msg, uap->flags, control, UIO_USERSPACE); out: free(iov, M_IOV); if (to) free(to, M_SONAME); return (error); } int freebsd32_recvfrom(struct thread *td, struct freebsd32_recvfrom_args *uap) { struct msghdr msg; struct iovec aiov; int error; if (uap->fromlenaddr) { error = copyin(PTRIN(uap->fromlenaddr), &msg.msg_namelen, sizeof(msg.msg_namelen)); if (error) return (error); } else { msg.msg_namelen = 0; } msg.msg_name = PTRIN(uap->from); msg.msg_iov = &aiov; msg.msg_iovlen = 1; aiov.iov_base = PTRIN(uap->buf); aiov.iov_len = uap->len; msg.msg_control = NULL; msg.msg_flags = uap->flags; error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, NULL); if (error == 0 && uap->fromlenaddr) error = copyout(&msg.msg_namelen, PTRIN(uap->fromlenaddr), sizeof (msg.msg_namelen)); return (error); } int freebsd32_settimeofday(struct thread *td, struct freebsd32_settimeofday_args *uap) { struct timeval32 tv32; struct timeval tv, *tvp; struct timezone tz, *tzp; int error; if (uap->tv) { error = copyin(uap->tv, &tv32, sizeof(tv32)); if (error) return (error); CP(tv32, tv, tv_sec); CP(tv32, tv, tv_usec); tvp = &tv; } else tvp = NULL; if (uap->tzp) { error = copyin(uap->tzp, &tz, sizeof(tz)); if (error) return (error); tzp = &tz; } else tzp = NULL; return (kern_settimeofday(td, tvp, tzp)); } int freebsd32_utimes(struct thread *td, struct freebsd32_utimes_args *uap) { struct timeval32 s32[2]; struct timeval s[2], *sp; int error; if (uap->tptr != NULL) { error = copyin(uap->tptr, s32, sizeof(s32)); if (error) return (error); CP(s32[0], s[0], tv_sec); CP(s32[0], s[0], tv_usec); CP(s32[1], s[1], tv_sec); CP(s32[1], s[1], tv_usec); sp = s; } else sp = NULL; return (kern_utimesat(td, AT_FDCWD, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE)); } int freebsd32_lutimes(struct thread *td, struct freebsd32_lutimes_args *uap) { struct timeval32 s32[2]; struct timeval s[2], *sp; int error; if (uap->tptr != NULL) { error = copyin(uap->tptr, s32, sizeof(s32)); if (error) return (error); CP(s32[0], s[0], tv_sec); CP(s32[0], s[0], tv_usec); CP(s32[1], s[1], tv_sec); CP(s32[1], s[1], tv_usec); sp = s; } else sp = NULL; return (kern_lutimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE)); } int freebsd32_futimes(struct thread *td, struct freebsd32_futimes_args *uap) { struct timeval32 s32[2]; struct timeval s[2], *sp; int error; if (uap->tptr != NULL) { error = copyin(uap->tptr, s32, sizeof(s32)); if (error) return (error); CP(s32[0], s[0], tv_sec); CP(s32[0], s[0], tv_usec); CP(s32[1], s[1], tv_sec); CP(s32[1], s[1], tv_usec); sp = s; } else sp = NULL; return (kern_futimes(td, uap->fd, sp, UIO_SYSSPACE)); } int freebsd32_futimesat(struct thread *td, struct freebsd32_futimesat_args *uap) { struct timeval32 s32[2]; struct timeval s[2], *sp; int error; if (uap->times != NULL) { error = copyin(uap->times, s32, sizeof(s32)); if (error) return (error); CP(s32[0], s[0], tv_sec); CP(s32[0], s[0], tv_usec); CP(s32[1], s[1], tv_sec); CP(s32[1], s[1], tv_usec); sp = s; } else sp = NULL; return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE)); } int freebsd32_futimens(struct thread *td, struct freebsd32_futimens_args *uap) { struct timespec32 ts32[2]; struct timespec ts[2], *tsp; int error; if (uap->times != NULL) { error = copyin(uap->times, ts32, sizeof(ts32)); if (error) return (error); CP(ts32[0], ts[0], tv_sec); CP(ts32[0], ts[0], tv_nsec); CP(ts32[1], ts[1], tv_sec); CP(ts32[1], ts[1], tv_nsec); tsp = ts; } else tsp = NULL; return (kern_futimens(td, uap->fd, tsp, UIO_SYSSPACE)); } int freebsd32_utimensat(struct thread *td, struct freebsd32_utimensat_args *uap) { struct timespec32 ts32[2]; struct timespec ts[2], *tsp; int error; if (uap->times != NULL) { error = copyin(uap->times, ts32, sizeof(ts32)); if (error) return (error); CP(ts32[0], ts[0], tv_sec); CP(ts32[0], ts[0], tv_nsec); CP(ts32[1], ts[1], tv_sec); CP(ts32[1], ts[1], tv_nsec); tsp = ts; } else tsp = NULL; return (kern_utimensat(td, uap->fd, uap->path, UIO_USERSPACE, tsp, UIO_SYSSPACE, uap->flag)); } int freebsd32_adjtime(struct thread *td, struct freebsd32_adjtime_args *uap) { struct timeval32 tv32; struct timeval delta, olddelta, *deltap; int error; if (uap->delta) { error = copyin(uap->delta, &tv32, sizeof(tv32)); if (error) return (error); CP(tv32, delta, tv_sec); CP(tv32, delta, tv_usec); deltap = δ } else deltap = NULL; error = kern_adjtime(td, deltap, &olddelta); if (uap->olddelta && error == 0) { CP(olddelta, tv32, tv_sec); CP(olddelta, tv32, tv_usec); error = copyout(&tv32, uap->olddelta, sizeof(tv32)); } return (error); } #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_statfs(struct thread *td, struct freebsd4_freebsd32_statfs_args *uap) { struct ostatfs32 s32; struct statfs *sp; int error; sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK); error = kern_statfs(td, uap->path, UIO_USERSPACE, sp); if (error == 0) { copy_statfs(sp, &s32); error = copyout(&s32, uap->buf, sizeof(s32)); } free(sp, M_STATFS); return (error); } #endif #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_fstatfs(struct thread *td, struct freebsd4_freebsd32_fstatfs_args *uap) { struct ostatfs32 s32; struct statfs *sp; int error; sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK); error = kern_fstatfs(td, uap->fd, sp); if (error == 0) { copy_statfs(sp, &s32); error = copyout(&s32, uap->buf, sizeof(s32)); } free(sp, M_STATFS); return (error); } #endif #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_fhstatfs(struct thread *td, struct freebsd4_freebsd32_fhstatfs_args *uap) { struct ostatfs32 s32; struct statfs *sp; fhandle_t fh; int error; if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0) return (error); sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK); error = kern_fhstatfs(td, fh, sp); if (error == 0) { copy_statfs(sp, &s32); error = copyout(&s32, uap->buf, sizeof(s32)); } free(sp, M_STATFS); return (error); } #endif int freebsd32_pread(struct thread *td, struct freebsd32_pread_args *uap) { return (kern_pread(td, uap->fd, uap->buf, uap->nbyte, PAIR32TO64(off_t, uap->offset))); } int freebsd32_pwrite(struct thread *td, struct freebsd32_pwrite_args *uap) { return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, PAIR32TO64(off_t, uap->offset))); } #ifdef COMPAT_43 int ofreebsd32_lseek(struct thread *td, struct ofreebsd32_lseek_args *uap) { return (kern_lseek(td, uap->fd, uap->offset, uap->whence)); } #endif int freebsd32_lseek(struct thread *td, struct freebsd32_lseek_args *uap) { int error; off_t pos; error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset), uap->whence); /* Expand the quad return into two parts for eax and edx */ pos = td->td_uretoff.tdu_off; td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */ td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */ return error; } int freebsd32_truncate(struct thread *td, struct freebsd32_truncate_args *uap) { return (kern_truncate(td, uap->path, UIO_USERSPACE, PAIR32TO64(off_t, uap->length))); } int freebsd32_ftruncate(struct thread *td, struct freebsd32_ftruncate_args *uap) { return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length))); } #ifdef COMPAT_43 int ofreebsd32_getdirentries(struct thread *td, struct ofreebsd32_getdirentries_args *uap) { struct ogetdirentries_args ap; int error; long loff; int32_t loff_cut; ap.fd = uap->fd; ap.buf = uap->buf; ap.count = uap->count; ap.basep = NULL; error = kern_ogetdirentries(td, &ap, &loff); if (error == 0) { loff_cut = loff; error = copyout(&loff_cut, uap->basep, sizeof(int32_t)); } return (error); } #endif #if defined(COMPAT_FREEBSD11) int freebsd11_freebsd32_getdirentries(struct thread *td, struct freebsd11_freebsd32_getdirentries_args *uap) { long base; int32_t base32; int error; error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count, &base, NULL); if (error) return (error); if (uap->basep != NULL) { base32 = base; error = copyout(&base32, uap->basep, sizeof(int32_t)); } return (error); } int freebsd11_freebsd32_getdents(struct thread *td, struct freebsd11_freebsd32_getdents_args *uap) { struct freebsd11_freebsd32_getdirentries_args ap; ap.fd = uap->fd; ap.buf = uap->buf; ap.count = uap->count; ap.basep = NULL; return (freebsd11_freebsd32_getdirentries(td, &ap)); } #endif /* COMPAT_FREEBSD11 */ #ifdef COMPAT_FREEBSD6 /* versions with the 'int pad' argument */ int freebsd6_freebsd32_pread(struct thread *td, struct freebsd6_freebsd32_pread_args *uap) { return (kern_pread(td, uap->fd, uap->buf, uap->nbyte, PAIR32TO64(off_t, uap->offset))); } int freebsd6_freebsd32_pwrite(struct thread *td, struct freebsd6_freebsd32_pwrite_args *uap) { return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, PAIR32TO64(off_t, uap->offset))); } int freebsd6_freebsd32_lseek(struct thread *td, struct freebsd6_freebsd32_lseek_args *uap) { int error; off_t pos; error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset), uap->whence); /* Expand the quad return into two parts for eax and edx */ pos = *(off_t *)(td->td_retval); td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */ td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */ return error; } int freebsd6_freebsd32_truncate(struct thread *td, struct freebsd6_freebsd32_truncate_args *uap) { return (kern_truncate(td, uap->path, UIO_USERSPACE, PAIR32TO64(off_t, uap->length))); } int freebsd6_freebsd32_ftruncate(struct thread *td, struct freebsd6_freebsd32_ftruncate_args *uap) { return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length))); } #endif /* COMPAT_FREEBSD6 */ struct sf_hdtr32 { uint32_t headers; int hdr_cnt; uint32_t trailers; int trl_cnt; }; static int freebsd32_do_sendfile(struct thread *td, struct freebsd32_sendfile_args *uap, int compat) { struct sf_hdtr32 hdtr32; struct sf_hdtr hdtr; struct uio *hdr_uio, *trl_uio; struct file *fp; cap_rights_t rights; struct iovec32 *iov32; off_t offset, sbytes; int error; offset = PAIR32TO64(off_t, uap->offset); if (offset < 0) return (EINVAL); hdr_uio = trl_uio = NULL; if (uap->hdtr != NULL) { error = copyin(uap->hdtr, &hdtr32, sizeof(hdtr32)); if (error) goto out; PTRIN_CP(hdtr32, hdtr, headers); CP(hdtr32, hdtr, hdr_cnt); PTRIN_CP(hdtr32, hdtr, trailers); CP(hdtr32, hdtr, trl_cnt); if (hdtr.headers != NULL) { iov32 = PTRIN(hdtr32.headers); error = freebsd32_copyinuio(iov32, hdtr32.hdr_cnt, &hdr_uio); if (error) goto out; #ifdef COMPAT_FREEBSD4 /* * In FreeBSD < 5.0 the nbytes to send also included * the header. If compat is specified subtract the * header size from nbytes. */ if (compat) { if (uap->nbytes > hdr_uio->uio_resid) uap->nbytes -= hdr_uio->uio_resid; else uap->nbytes = 0; } #endif } if (hdtr.trailers != NULL) { iov32 = PTRIN(hdtr32.trailers); error = freebsd32_copyinuio(iov32, hdtr32.trl_cnt, &trl_uio); if (error) goto out; } } AUDIT_ARG_FD(uap->fd); if ((error = fget_read(td, uap->fd, cap_rights_init_one(&rights, CAP_PREAD), &fp)) != 0) goto out; error = fo_sendfile(fp, uap->s, hdr_uio, trl_uio, offset, uap->nbytes, &sbytes, uap->flags, td); fdrop(fp, td); if (uap->sbytes != NULL) copyout(&sbytes, uap->sbytes, sizeof(off_t)); out: if (hdr_uio) free(hdr_uio, M_IOV); if (trl_uio) free(trl_uio, M_IOV); return (error); } #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_sendfile(struct thread *td, struct freebsd4_freebsd32_sendfile_args *uap) { return (freebsd32_do_sendfile(td, (struct freebsd32_sendfile_args *)uap, 1)); } #endif int freebsd32_sendfile(struct thread *td, struct freebsd32_sendfile_args *uap) { return (freebsd32_do_sendfile(td, uap, 0)); } static void copy_stat(struct stat *in, struct stat32 *out) { CP(*in, *out, st_dev); CP(*in, *out, st_ino); CP(*in, *out, st_mode); CP(*in, *out, st_nlink); CP(*in, *out, st_uid); CP(*in, *out, st_gid); CP(*in, *out, st_rdev); TS_CP(*in, *out, st_atim); TS_CP(*in, *out, st_mtim); TS_CP(*in, *out, st_ctim); CP(*in, *out, st_size); CP(*in, *out, st_blocks); CP(*in, *out, st_blksize); CP(*in, *out, st_flags); CP(*in, *out, st_gen); TS_CP(*in, *out, st_birthtim); out->st_padding0 = 0; out->st_padding1 = 0; #ifdef __STAT32_TIME_T_EXT out->st_atim_ext = 0; out->st_mtim_ext = 0; out->st_ctim_ext = 0; out->st_btim_ext = 0; #endif bzero(out->st_spare, sizeof(out->st_spare)); } #ifdef COMPAT_43 static void copy_ostat(struct stat *in, struct ostat32 *out) { bzero(out, sizeof(*out)); CP(*in, *out, st_dev); CP(*in, *out, st_ino); CP(*in, *out, st_mode); CP(*in, *out, st_nlink); CP(*in, *out, st_uid); CP(*in, *out, st_gid); CP(*in, *out, st_rdev); out->st_size = MIN(in->st_size, INT32_MAX); TS_CP(*in, *out, st_atim); TS_CP(*in, *out, st_mtim); TS_CP(*in, *out, st_ctim); CP(*in, *out, st_blksize); CP(*in, *out, st_blocks); CP(*in, *out, st_flags); CP(*in, *out, st_gen); } #endif #ifdef COMPAT_43 int ofreebsd32_stat(struct thread *td, struct ofreebsd32_stat_args *uap) { struct stat sb; struct ostat32 sb32; int error; error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, &sb, NULL); if (error) return (error); copy_ostat(&sb, &sb32); error = copyout(&sb32, uap->ub, sizeof (sb32)); return (error); } #endif int freebsd32_fstat(struct thread *td, struct freebsd32_fstat_args *uap) { struct stat ub; struct stat32 ub32; int error; error = kern_fstat(td, uap->fd, &ub); if (error) return (error); copy_stat(&ub, &ub32); error = copyout(&ub32, uap->sb, sizeof(ub32)); return (error); } #ifdef COMPAT_43 int ofreebsd32_fstat(struct thread *td, struct ofreebsd32_fstat_args *uap) { struct stat ub; struct ostat32 ub32; int error; error = kern_fstat(td, uap->fd, &ub); if (error) return (error); copy_ostat(&ub, &ub32); error = copyout(&ub32, uap->ub, sizeof(ub32)); return (error); } #endif int freebsd32_fstatat(struct thread *td, struct freebsd32_fstatat_args *uap) { struct stat ub; struct stat32 ub32; int error; error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE, &ub, NULL); if (error) return (error); copy_stat(&ub, &ub32); error = copyout(&ub32, uap->buf, sizeof(ub32)); return (error); } #ifdef COMPAT_43 int ofreebsd32_lstat(struct thread *td, struct ofreebsd32_lstat_args *uap) { struct stat sb; struct ostat32 sb32; int error; error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path, UIO_USERSPACE, &sb, NULL); if (error) return (error); copy_ostat(&sb, &sb32); error = copyout(&sb32, uap->ub, sizeof (sb32)); return (error); } #endif int freebsd32_fhstat(struct thread *td, struct freebsd32_fhstat_args *uap) { struct stat sb; struct stat32 sb32; struct fhandle fh; int error; error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t)); if (error != 0) return (error); error = kern_fhstat(td, fh, &sb); if (error != 0) return (error); copy_stat(&sb, &sb32); error = copyout(&sb32, uap->sb, sizeof (sb32)); return (error); } #if defined(COMPAT_FREEBSD11) extern int ino64_trunc_error; static int freebsd11_cvtstat32(struct stat *in, struct freebsd11_stat32 *out) { CP(*in, *out, st_ino); if (in->st_ino != out->st_ino) { switch (ino64_trunc_error) { default: case 0: break; case 1: return (EOVERFLOW); case 2: out->st_ino = UINT32_MAX; break; } } CP(*in, *out, st_nlink); if (in->st_nlink != out->st_nlink) { switch (ino64_trunc_error) { default: case 0: break; case 1: return (EOVERFLOW); case 2: out->st_nlink = UINT16_MAX; break; } } out->st_dev = in->st_dev; if (out->st_dev != in->st_dev) { switch (ino64_trunc_error) { default: break; case 1: return (EOVERFLOW); } } CP(*in, *out, st_mode); CP(*in, *out, st_uid); CP(*in, *out, st_gid); out->st_rdev = in->st_rdev; if (out->st_rdev != in->st_rdev) { switch (ino64_trunc_error) { default: break; case 1: return (EOVERFLOW); } } TS_CP(*in, *out, st_atim); TS_CP(*in, *out, st_mtim); TS_CP(*in, *out, st_ctim); CP(*in, *out, st_size); CP(*in, *out, st_blocks); CP(*in, *out, st_blksize); CP(*in, *out, st_flags); CP(*in, *out, st_gen); TS_CP(*in, *out, st_birthtim); out->st_lspare = 0; bzero((char *)&out->st_birthtim + sizeof(out->st_birthtim), sizeof(*out) - offsetof(struct freebsd11_stat32, st_birthtim) - sizeof(out->st_birthtim)); return (0); } int freebsd11_freebsd32_stat(struct thread *td, struct freebsd11_freebsd32_stat_args *uap) { struct stat sb; struct freebsd11_stat32 sb32; int error; error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, &sb, NULL); if (error != 0) return (error); error = freebsd11_cvtstat32(&sb, &sb32); if (error == 0) error = copyout(&sb32, uap->ub, sizeof (sb32)); return (error); } int freebsd11_freebsd32_fstat(struct thread *td, struct freebsd11_freebsd32_fstat_args *uap) { struct stat sb; struct freebsd11_stat32 sb32; int error; error = kern_fstat(td, uap->fd, &sb); if (error != 0) return (error); error = freebsd11_cvtstat32(&sb, &sb32); if (error == 0) error = copyout(&sb32, uap->ub, sizeof (sb32)); return (error); } int freebsd11_freebsd32_fstatat(struct thread *td, struct freebsd11_freebsd32_fstatat_args *uap) { struct stat sb; struct freebsd11_stat32 sb32; int error; error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE, &sb, NULL); if (error != 0) return (error); error = freebsd11_cvtstat32(&sb, &sb32); if (error == 0) error = copyout(&sb32, uap->buf, sizeof (sb32)); return (error); } int freebsd11_freebsd32_lstat(struct thread *td, struct freebsd11_freebsd32_lstat_args *uap) { struct stat sb; struct freebsd11_stat32 sb32; int error; error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path, UIO_USERSPACE, &sb, NULL); if (error != 0) return (error); error = freebsd11_cvtstat32(&sb, &sb32); if (error == 0) error = copyout(&sb32, uap->ub, sizeof (sb32)); return (error); } int freebsd11_freebsd32_fhstat(struct thread *td, struct freebsd11_freebsd32_fhstat_args *uap) { struct stat sb; struct freebsd11_stat32 sb32; struct fhandle fh; int error; error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t)); if (error != 0) return (error); error = kern_fhstat(td, fh, &sb); if (error != 0) return (error); error = freebsd11_cvtstat32(&sb, &sb32); if (error == 0) error = copyout(&sb32, uap->sb, sizeof (sb32)); return (error); } #endif int freebsd32___sysctl(struct thread *td, struct freebsd32___sysctl_args *uap) { int error, name[CTL_MAXNAME]; size_t j, oldlen; uint32_t tmp; if (uap->namelen > CTL_MAXNAME || uap->namelen < 2) return (EINVAL); error = copyin(uap->name, name, uap->namelen * sizeof(int)); if (error) return (error); if (uap->oldlenp) { error = fueword32(uap->oldlenp, &tmp); oldlen = tmp; } else { oldlen = 0; } if (error != 0) return (EFAULT); error = userland_sysctl(td, name, uap->namelen, uap->old, &oldlen, 1, uap->new, uap->newlen, &j, SCTL_MASK32); if (error) return (error); if (uap->oldlenp) suword32(uap->oldlenp, j); return (0); } int freebsd32___sysctlbyname(struct thread *td, struct freebsd32___sysctlbyname_args *uap) { size_t oldlen, rv; int error; uint32_t tmp; if (uap->oldlenp != NULL) { error = fueword32(uap->oldlenp, &tmp); oldlen = tmp; } else { error = oldlen = 0; } if (error != 0) return (EFAULT); error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old, &oldlen, uap->new, uap->newlen, &rv, SCTL_MASK32, 1); if (error != 0) return (error); if (uap->oldlenp != NULL) error = suword32(uap->oldlenp, rv); return (error); } int freebsd32_jail(struct thread *td, struct freebsd32_jail_args *uap) { uint32_t version; int error; struct jail j; error = copyin(uap->jail, &version, sizeof(uint32_t)); if (error) return (error); switch (version) { case 0: { /* FreeBSD single IPv4 jails. */ struct jail32_v0 j32_v0; bzero(&j, sizeof(struct jail)); error = copyin(uap->jail, &j32_v0, sizeof(struct jail32_v0)); if (error) return (error); CP(j32_v0, j, version); PTRIN_CP(j32_v0, j, path); PTRIN_CP(j32_v0, j, hostname); j.ip4s = htonl(j32_v0.ip_number); /* jail_v0 is host order */ break; } case 1: /* * Version 1 was used by multi-IPv4 jail implementations * that never made it into the official kernel. */ return (EINVAL); case 2: /* JAIL_API_VERSION */ { /* FreeBSD multi-IPv4/IPv6,noIP jails. */ struct jail32 j32; error = copyin(uap->jail, &j32, sizeof(struct jail32)); if (error) return (error); CP(j32, j, version); PTRIN_CP(j32, j, path); PTRIN_CP(j32, j, hostname); PTRIN_CP(j32, j, jailname); CP(j32, j, ip4s); CP(j32, j, ip6s); PTRIN_CP(j32, j, ip4); PTRIN_CP(j32, j, ip6); break; } default: /* Sci-Fi jails are not supported, sorry. */ return (EINVAL); } return (kern_jail(td, &j)); } int freebsd32_jail_set(struct thread *td, struct freebsd32_jail_set_args *uap) { struct uio *auio; int error; /* Check that we have an even number of iovecs. */ if (uap->iovcnt & 1) return (EINVAL); error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_jail_set(td, auio, uap->flags); free(auio, M_IOV); return (error); } int freebsd32_jail_get(struct thread *td, struct freebsd32_jail_get_args *uap) { struct iovec32 iov32; struct uio *auio; int error, i; /* Check that we have an even number of iovecs. */ if (uap->iovcnt & 1) return (EINVAL); error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = kern_jail_get(td, auio, uap->flags); if (error == 0) for (i = 0; i < uap->iovcnt; i++) { PTROUT_CP(auio->uio_iov[i], iov32, iov_base); CP(auio->uio_iov[i], iov32, iov_len); error = copyout(&iov32, uap->iovp + i, sizeof(iov32)); if (error != 0) break; } free(auio, M_IOV); return (error); } int freebsd32_sigaction(struct thread *td, struct freebsd32_sigaction_args *uap) { struct sigaction32 s32; struct sigaction sa, osa, *sap; int error; if (uap->act) { error = copyin(uap->act, &s32, sizeof(s32)); if (error) return (error); sa.sa_handler = PTRIN(s32.sa_u); CP(s32, sa, sa_flags); CP(s32, sa, sa_mask); sap = &sa; } else sap = NULL; error = kern_sigaction(td, uap->sig, sap, &osa, 0); if (error == 0 && uap->oact != NULL) { s32.sa_u = PTROUT(osa.sa_handler); CP(osa, s32, sa_flags); CP(osa, s32, sa_mask); error = copyout(&s32, uap->oact, sizeof(s32)); } return (error); } #ifdef COMPAT_FREEBSD4 int freebsd4_freebsd32_sigaction(struct thread *td, struct freebsd4_freebsd32_sigaction_args *uap) { struct sigaction32 s32; struct sigaction sa, osa, *sap; int error; if (uap->act) { error = copyin(uap->act, &s32, sizeof(s32)); if (error) return (error); sa.sa_handler = PTRIN(s32.sa_u); CP(s32, sa, sa_flags); CP(s32, sa, sa_mask); sap = &sa; } else sap = NULL; error = kern_sigaction(td, uap->sig, sap, &osa, KSA_FREEBSD4); if (error == 0 && uap->oact != NULL) { s32.sa_u = PTROUT(osa.sa_handler); CP(osa, s32, sa_flags); CP(osa, s32, sa_mask); error = copyout(&s32, uap->oact, sizeof(s32)); } return (error); } #endif #ifdef COMPAT_43 struct osigaction32 { u_int32_t sa_u; osigset_t sa_mask; int sa_flags; }; #define ONSIG 32 int ofreebsd32_sigaction(struct thread *td, struct ofreebsd32_sigaction_args *uap) { struct osigaction32 s32; struct sigaction sa, osa, *sap; int error; if (uap->signum <= 0 || uap->signum >= ONSIG) return (EINVAL); if (uap->nsa) { error = copyin(uap->nsa, &s32, sizeof(s32)); if (error) return (error); sa.sa_handler = PTRIN(s32.sa_u); CP(s32, sa, sa_flags); OSIG2SIG(s32.sa_mask, sa.sa_mask); sap = &sa; } else sap = NULL; error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET); if (error == 0 && uap->osa != NULL) { s32.sa_u = PTROUT(osa.sa_handler); CP(osa, s32, sa_flags); SIG2OSIG(osa.sa_mask, s32.sa_mask); error = copyout(&s32, uap->osa, sizeof(s32)); } return (error); } int ofreebsd32_sigprocmask(struct thread *td, struct ofreebsd32_sigprocmask_args *uap) { sigset_t set, oset; int error; OSIG2SIG(uap->mask, set); error = kern_sigprocmask(td, uap->how, &set, &oset, SIGPROCMASK_OLD); SIG2OSIG(oset, td->td_retval[0]); return (error); } int ofreebsd32_sigpending(struct thread *td, struct ofreebsd32_sigpending_args *uap) { struct proc *p = td->td_proc; sigset_t siglist; PROC_LOCK(p); siglist = p->p_siglist; SIGSETOR(siglist, td->td_siglist); PROC_UNLOCK(p); SIG2OSIG(siglist, td->td_retval[0]); return (0); } struct sigvec32 { u_int32_t sv_handler; int sv_mask; int sv_flags; }; int ofreebsd32_sigvec(struct thread *td, struct ofreebsd32_sigvec_args *uap) { struct sigvec32 vec; struct sigaction sa, osa, *sap; int error; if (uap->signum <= 0 || uap->signum >= ONSIG) return (EINVAL); if (uap->nsv) { error = copyin(uap->nsv, &vec, sizeof(vec)); if (error) return (error); sa.sa_handler = PTRIN(vec.sv_handler); OSIG2SIG(vec.sv_mask, sa.sa_mask); sa.sa_flags = vec.sv_flags; sa.sa_flags ^= SA_RESTART; sap = &sa; } else sap = NULL; error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET); if (error == 0 && uap->osv != NULL) { vec.sv_handler = PTROUT(osa.sa_handler); SIG2OSIG(osa.sa_mask, vec.sv_mask); vec.sv_flags = osa.sa_flags; vec.sv_flags &= ~SA_NOCLDWAIT; vec.sv_flags ^= SA_RESTART; error = copyout(&vec, uap->osv, sizeof(vec)); } return (error); } int ofreebsd32_sigblock(struct thread *td, struct ofreebsd32_sigblock_args *uap) { sigset_t set, oset; OSIG2SIG(uap->mask, set); kern_sigprocmask(td, SIG_BLOCK, &set, &oset, 0); SIG2OSIG(oset, td->td_retval[0]); return (0); } int ofreebsd32_sigsetmask(struct thread *td, struct ofreebsd32_sigsetmask_args *uap) { sigset_t set, oset; OSIG2SIG(uap->mask, set); kern_sigprocmask(td, SIG_SETMASK, &set, &oset, 0); SIG2OSIG(oset, td->td_retval[0]); return (0); } int ofreebsd32_sigsuspend(struct thread *td, struct ofreebsd32_sigsuspend_args *uap) { sigset_t mask; OSIG2SIG(uap->mask, mask); return (kern_sigsuspend(td, mask)); } struct sigstack32 { u_int32_t ss_sp; int ss_onstack; }; int ofreebsd32_sigstack(struct thread *td, struct ofreebsd32_sigstack_args *uap) { struct sigstack32 s32; struct sigstack nss, oss; int error = 0, unss; if (uap->nss != NULL) { error = copyin(uap->nss, &s32, sizeof(s32)); if (error) return (error); nss.ss_sp = PTRIN(s32.ss_sp); CP(s32, nss, ss_onstack); unss = 1; } else { unss = 0; } oss.ss_sp = td->td_sigstk.ss_sp; oss.ss_onstack = sigonstack(cpu_getstack(td)); if (unss) { td->td_sigstk.ss_sp = nss.ss_sp; td->td_sigstk.ss_size = 0; td->td_sigstk.ss_flags |= (nss.ss_onstack & SS_ONSTACK); td->td_pflags |= TDP_ALTSTACK; } if (uap->oss != NULL) { s32.ss_sp = PTROUT(oss.ss_sp); CP(oss, s32, ss_onstack); error = copyout(&s32, uap->oss, sizeof(s32)); } return (error); } #endif int freebsd32_nanosleep(struct thread *td, struct freebsd32_nanosleep_args *uap) { return (freebsd32_user_clock_nanosleep(td, CLOCK_REALTIME, TIMER_RELTIME, uap->rqtp, uap->rmtp)); } int freebsd32_clock_nanosleep(struct thread *td, struct freebsd32_clock_nanosleep_args *uap) { int error; error = freebsd32_user_clock_nanosleep(td, uap->clock_id, uap->flags, uap->rqtp, uap->rmtp); return (kern_posix_error(td, error)); } static int freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id, int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp) { struct timespec32 rmt32, rqt32; struct timespec rmt, rqt; int error, error2; error = copyin(ua_rqtp, &rqt32, sizeof(rqt32)); if (error) return (error); CP(rqt32, rqt, tv_sec); CP(rqt32, rqt, tv_nsec); error = kern_clock_nanosleep(td, clock_id, flags, &rqt, &rmt); if (error == EINTR && ua_rmtp != NULL && (flags & TIMER_ABSTIME) == 0) { CP(rmt, rmt32, tv_sec); CP(rmt, rmt32, tv_nsec); error2 = copyout(&rmt32, ua_rmtp, sizeof(rmt32)); if (error2 != 0) error = error2; } return (error); } int freebsd32_clock_gettime(struct thread *td, struct freebsd32_clock_gettime_args *uap) { struct timespec ats; struct timespec32 ats32; int error; error = kern_clock_gettime(td, uap->clock_id, &ats); if (error == 0) { CP(ats, ats32, tv_sec); CP(ats, ats32, tv_nsec); error = copyout(&ats32, uap->tp, sizeof(ats32)); } return (error); } int freebsd32_clock_settime(struct thread *td, struct freebsd32_clock_settime_args *uap) { struct timespec ats; struct timespec32 ats32; int error; error = copyin(uap->tp, &ats32, sizeof(ats32)); if (error) return (error); CP(ats32, ats, tv_sec); CP(ats32, ats, tv_nsec); return (kern_clock_settime(td, uap->clock_id, &ats)); } int freebsd32_clock_getres(struct thread *td, struct freebsd32_clock_getres_args *uap) { struct timespec ts; struct timespec32 ts32; int error; if (uap->tp == NULL) return (0); error = kern_clock_getres(td, uap->clock_id, &ts); if (error == 0) { CP(ts, ts32, tv_sec); CP(ts, ts32, tv_nsec); error = copyout(&ts32, uap->tp, sizeof(ts32)); } return (error); } int freebsd32_ktimer_create(struct thread *td, struct freebsd32_ktimer_create_args *uap) { struct sigevent32 ev32; struct sigevent ev, *evp; int error, id; if (uap->evp == NULL) { evp = NULL; } else { evp = &ev; error = copyin(uap->evp, &ev32, sizeof(ev32)); if (error != 0) return (error); error = convert_sigevent32(&ev32, &ev); if (error != 0) return (error); } error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1); if (error == 0) { error = copyout(&id, uap->timerid, sizeof(int)); if (error != 0) kern_ktimer_delete(td, id); } return (error); } int freebsd32_ktimer_settime(struct thread *td, struct freebsd32_ktimer_settime_args *uap) { struct itimerspec32 val32, oval32; struct itimerspec val, oval, *ovalp; int error; error = copyin(uap->value, &val32, sizeof(val32)); if (error != 0) return (error); ITS_CP(val32, val); ovalp = uap->ovalue != NULL ? &oval : NULL; error = kern_ktimer_settime(td, uap->timerid, uap->flags, &val, ovalp); if (error == 0 && uap->ovalue != NULL) { ITS_CP(oval, oval32); error = copyout(&oval32, uap->ovalue, sizeof(oval32)); } return (error); } int freebsd32_ktimer_gettime(struct thread *td, struct freebsd32_ktimer_gettime_args *uap) { struct itimerspec32 val32; struct itimerspec val; int error; error = kern_ktimer_gettime(td, uap->timerid, &val); if (error == 0) { ITS_CP(val, val32); error = copyout(&val32, uap->value, sizeof(val32)); } return (error); } int freebsd32_clock_getcpuclockid2(struct thread *td, struct freebsd32_clock_getcpuclockid2_args *uap) { clockid_t clk_id; int error; error = kern_clock_getcpuclockid2(td, PAIR32TO64(id_t, uap->id), uap->which, &clk_id); if (error == 0) error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t)); return (error); } int freebsd32_thr_new(struct thread *td, struct freebsd32_thr_new_args *uap) { struct thr_param32 param32; struct thr_param param; int error; if (uap->param_size < 0 || uap->param_size > sizeof(struct thr_param32)) return (EINVAL); bzero(¶m, sizeof(struct thr_param)); bzero(¶m32, sizeof(struct thr_param32)); error = copyin(uap->param, ¶m32, uap->param_size); if (error != 0) return (error); param.start_func = PTRIN(param32.start_func); param.arg = PTRIN(param32.arg); param.stack_base = PTRIN(param32.stack_base); param.stack_size = param32.stack_size; param.tls_base = PTRIN(param32.tls_base); param.tls_size = param32.tls_size; param.child_tid = PTRIN(param32.child_tid); param.parent_tid = PTRIN(param32.parent_tid); param.flags = param32.flags; param.rtp = PTRIN(param32.rtp); param.spare[0] = PTRIN(param32.spare[0]); param.spare[1] = PTRIN(param32.spare[1]); param.spare[2] = PTRIN(param32.spare[2]); return (kern_thr_new(td, ¶m)); } int freebsd32_thr_suspend(struct thread *td, struct freebsd32_thr_suspend_args *uap) { struct timespec32 ts32; struct timespec ts, *tsp; int error; error = 0; tsp = NULL; if (uap->timeout != NULL) { error = copyin((const void *)uap->timeout, (void *)&ts32, sizeof(struct timespec32)); if (error != 0) return (error); ts.tv_sec = ts32.tv_sec; ts.tv_nsec = ts32.tv_nsec; tsp = &ts; } return (kern_thr_suspend(td, tsp)); } void siginfo_to_siginfo32(const siginfo_t *src, struct siginfo32 *dst) { bzero(dst, sizeof(*dst)); dst->si_signo = src->si_signo; dst->si_errno = src->si_errno; dst->si_code = src->si_code; dst->si_pid = src->si_pid; dst->si_uid = src->si_uid; dst->si_status = src->si_status; dst->si_addr = (uintptr_t)src->si_addr; dst->si_value.sival_int = src->si_value.sival_int; dst->si_timerid = src->si_timerid; dst->si_overrun = src->si_overrun; } #ifndef _FREEBSD32_SYSPROTO_H_ struct freebsd32_sigqueue_args { pid_t pid; int signum; /* union sigval32 */ int value; }; #endif int freebsd32_sigqueue(struct thread *td, struct freebsd32_sigqueue_args *uap) { union sigval sv; /* * On 32-bit ABIs, sival_int and sival_ptr are the same. * On 64-bit little-endian ABIs, the low bits are the same. * In 64-bit big-endian ABIs, sival_int overlaps with * sival_ptr's HIGH bits. We choose to support sival_int * rather than sival_ptr in this case as it seems to be * more common. */ bzero(&sv, sizeof(sv)); sv.sival_int = uap->value; return (kern_sigqueue(td, uap->pid, uap->signum, &sv)); } int freebsd32_sigtimedwait(struct thread *td, struct freebsd32_sigtimedwait_args *uap) { struct timespec32 ts32; struct timespec ts; struct timespec *timeout; sigset_t set; ksiginfo_t ksi; struct siginfo32 si32; int error; if (uap->timeout) { error = copyin(uap->timeout, &ts32, sizeof(ts32)); if (error) return (error); ts.tv_sec = ts32.tv_sec; ts.tv_nsec = ts32.tv_nsec; timeout = &ts; } else timeout = NULL; error = copyin(uap->set, &set, sizeof(set)); if (error) return (error); error = kern_sigtimedwait(td, set, &ksi, timeout); if (error) return (error); if (uap->info) { siginfo_to_siginfo32(&ksi.ksi_info, &si32); error = copyout(&si32, uap->info, sizeof(struct siginfo32)); } if (error == 0) td->td_retval[0] = ksi.ksi_signo; return (error); } /* * MPSAFE */ int freebsd32_sigwaitinfo(struct thread *td, struct freebsd32_sigwaitinfo_args *uap) { ksiginfo_t ksi; struct siginfo32 si32; sigset_t set; int error; error = copyin(uap->set, &set, sizeof(set)); if (error) return (error); error = kern_sigtimedwait(td, set, &ksi, NULL); if (error) return (error); if (uap->info) { siginfo_to_siginfo32(&ksi.ksi_info, &si32); error = copyout(&si32, uap->info, sizeof(struct siginfo32)); } if (error == 0) td->td_retval[0] = ksi.ksi_signo; return (error); } int freebsd32_cpuset_setid(struct thread *td, struct freebsd32_cpuset_setid_args *uap) { return (kern_cpuset_setid(td, uap->which, PAIR32TO64(id_t, uap->id), uap->setid)); } int freebsd32_cpuset_getid(struct thread *td, struct freebsd32_cpuset_getid_args *uap) { return (kern_cpuset_getid(td, uap->level, uap->which, PAIR32TO64(id_t, uap->id), uap->setid)); } int freebsd32_cpuset_getaffinity(struct thread *td, struct freebsd32_cpuset_getaffinity_args *uap) { return (kern_cpuset_getaffinity(td, uap->level, uap->which, PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask)); } int freebsd32_cpuset_setaffinity(struct thread *td, struct freebsd32_cpuset_setaffinity_args *uap) { return (kern_cpuset_setaffinity(td, uap->level, uap->which, PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask)); } int freebsd32_cpuset_getdomain(struct thread *td, struct freebsd32_cpuset_getdomain_args *uap) { return (kern_cpuset_getdomain(td, uap->level, uap->which, PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy)); } int freebsd32_cpuset_setdomain(struct thread *td, struct freebsd32_cpuset_setdomain_args *uap) { return (kern_cpuset_setdomain(td, uap->level, uap->which, PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy)); } int freebsd32_nmount(struct thread *td, struct freebsd32_nmount_args /* { struct iovec *iovp; unsigned int iovcnt; int flags; } */ *uap) { struct uio *auio; uint64_t flags; int error; /* * Mount flags are now 64-bits. On 32-bit archtectures only * 32-bits are passed in, but from here on everything handles * 64-bit flags correctly. */ flags = uap->flags; AUDIT_ARG_FFLAGS(flags); /* * Filter out MNT_ROOTFS. We do not want clients of nmount() in * userspace to set this flag, but we must filter it out if we want * MNT_UPDATE on the root file system to work. * MNT_ROOTFS should only be set by the kernel when mounting its * root file system. */ flags &= ~MNT_ROOTFS; /* * check that we have an even number of iovec's * and that we have at least two options. */ if ((uap->iovcnt & 1) || (uap->iovcnt < 4)) return (EINVAL); error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio); if (error) return (error); error = vfs_donmount(td, flags, auio); free(auio, M_IOV); return error; } #if 0 int freebsd32_xxx(struct thread *td, struct freebsd32_xxx_args *uap) { struct yyy32 *p32, s32; struct yyy *p = NULL, s; struct xxx_arg ap; int error; if (uap->zzz) { error = copyin(uap->zzz, &s32, sizeof(s32)); if (error) return (error); /* translate in */ p = &s; } error = kern_xxx(td, p); if (error) return (error); if (uap->zzz) { /* translate out */ error = copyout(&s32, p32, sizeof(s32)); } return (error); } #endif int syscall32_module_handler(struct module *mod, int what, void *arg) { return (kern_syscall_module_handler(freebsd32_sysent, mod, what, arg)); } int syscall32_helper_register(struct syscall_helper_data *sd, int flags) { return (kern_syscall_helper_register(freebsd32_sysent, sd, flags)); } int syscall32_helper_unregister(struct syscall_helper_data *sd) { return (kern_syscall_helper_unregister(freebsd32_sysent, sd)); } int freebsd32_copyout_strings(struct image_params *imgp, uintptr_t *stack_base) { int argc, envc, i; u_int32_t *vectp; char *stringp; uintptr_t destp, ustringp; struct freebsd32_ps_strings *arginfo; char canary[sizeof(long) * 8]; int32_t pagesizes32[MAXPAGESIZES]; size_t execpath_len; int error, szsigcode; /* * Calculate string base and vector table pointers. * Also deal with signal trampoline code for this exec type. */ if (imgp->execpath != NULL && imgp->auxargs != NULL) execpath_len = strlen(imgp->execpath) + 1; else execpath_len = 0; arginfo = (struct freebsd32_ps_strings *)curproc->p_sysent-> sv_psstrings; imgp->ps_strings = arginfo; if (imgp->proc->p_sysent->sv_sigcode_base == 0) szsigcode = *(imgp->proc->p_sysent->sv_szsigcode); else szsigcode = 0; destp = (uintptr_t)arginfo; /* * install sigcode */ if (szsigcode != 0) { destp -= szsigcode; destp = rounddown2(destp, sizeof(uint32_t)); error = copyout(imgp->proc->p_sysent->sv_sigcode, (void *)destp, szsigcode); if (error != 0) return (error); } /* * Copy the image path for the rtld. */ if (execpath_len != 0) { destp -= execpath_len; imgp->execpathp = (void *)destp; error = copyout(imgp->execpath, imgp->execpathp, execpath_len); if (error != 0) return (error); } /* * Prepare the canary for SSP. */ arc4rand(canary, sizeof(canary), 0); destp -= sizeof(canary); imgp->canary = (void *)destp; error = copyout(canary, imgp->canary, sizeof(canary)); if (error != 0) return (error); imgp->canarylen = sizeof(canary); /* * Prepare the pagesizes array. */ for (i = 0; i < MAXPAGESIZES; i++) pagesizes32[i] = (uint32_t)pagesizes[i]; destp -= sizeof(pagesizes32); destp = rounddown2(destp, sizeof(uint32_t)); imgp->pagesizes = (void *)destp; error = copyout(pagesizes32, imgp->pagesizes, sizeof(pagesizes32)); if (error != 0) return (error); imgp->pagesizeslen = sizeof(pagesizes32); /* * Allocate room for the argument and environment strings. */ destp -= ARG_MAX - imgp->args->stringspace; destp = rounddown2(destp, sizeof(uint32_t)); ustringp = destp; exec_stackgap(imgp, &destp); if (imgp->auxargs) { /* * Allocate room on the stack for the ELF auxargs * array. It has up to AT_COUNT entries. */ destp -= AT_COUNT * sizeof(Elf32_Auxinfo); destp = rounddown2(destp, sizeof(uint32_t)); } vectp = (uint32_t *)destp; /* * Allocate room for the argv[] and env vectors including the * terminating NULL pointers. */ vectp -= imgp->args->argc + 1 + imgp->args->envc + 1; /* * vectp also becomes our initial stack base */ *stack_base = (uintptr_t)vectp; stringp = imgp->args->begin_argv; argc = imgp->args->argc; envc = imgp->args->envc; /* * Copy out strings - arguments and environment. */ error = copyout(stringp, (void *)ustringp, ARG_MAX - imgp->args->stringspace); if (error != 0) return (error); /* * Fill in "ps_strings" struct for ps, w, etc. */ imgp->argv = vectp; if (suword32(&arginfo->ps_argvstr, (u_int32_t)(intptr_t)vectp) != 0 || suword32(&arginfo->ps_nargvstr, argc) != 0) return (EFAULT); /* * Fill in argument portion of vector table. */ for (; argc > 0; --argc) { if (suword32(vectp++, ustringp) != 0) return (EFAULT); while (*stringp++ != 0) ustringp++; ustringp++; } /* a null vector table pointer separates the argp's from the envp's */ if (suword32(vectp++, 0) != 0) return (EFAULT); imgp->envv = vectp; if (suword32(&arginfo->ps_envstr, (u_int32_t)(intptr_t)vectp) != 0 || suword32(&arginfo->ps_nenvstr, envc) != 0) return (EFAULT); /* * Fill in environment portion of vector table. */ for (; envc > 0; --envc) { if (suword32(vectp++, ustringp) != 0) return (EFAULT); while (*stringp++ != 0) ustringp++; ustringp++; } /* end of vector table is a null pointer */ if (suword32(vectp, 0) != 0) return (EFAULT); if (imgp->auxargs) { vectp++; error = imgp->sysent->sv_copyout_auxargs(imgp, (uintptr_t)vectp); if (error != 0) return (error); } return (0); } int freebsd32_kldstat(struct thread *td, struct freebsd32_kldstat_args *uap) { struct kld_file_stat *stat; struct kld_file_stat32 *stat32; int error, version; if ((error = copyin(&uap->stat->version, &version, sizeof(version))) != 0) return (error); if (version != sizeof(struct kld_file_stat_1_32) && version != sizeof(struct kld_file_stat32)) return (EINVAL); stat = malloc(sizeof(*stat), M_TEMP, M_WAITOK | M_ZERO); stat32 = malloc(sizeof(*stat32), M_TEMP, M_WAITOK | M_ZERO); error = kern_kldstat(td, uap->fileid, stat); if (error == 0) { bcopy(&stat->name[0], &stat32->name[0], sizeof(stat->name)); CP(*stat, *stat32, refs); CP(*stat, *stat32, id); PTROUT_CP(*stat, *stat32, address); CP(*stat, *stat32, size); bcopy(&stat->pathname[0], &stat32->pathname[0], sizeof(stat->pathname)); stat32->version = version; error = copyout(stat32, uap->stat, version); } free(stat, M_TEMP); free(stat32, M_TEMP); return (error); } int freebsd32_posix_fallocate(struct thread *td, struct freebsd32_posix_fallocate_args *uap) { int error; error = kern_posix_fallocate(td, uap->fd, PAIR32TO64(off_t, uap->offset), PAIR32TO64(off_t, uap->len)); return (kern_posix_error(td, error)); } int freebsd32_posix_fadvise(struct thread *td, struct freebsd32_posix_fadvise_args *uap) { int error; error = kern_posix_fadvise(td, uap->fd, PAIR32TO64(off_t, uap->offset), PAIR32TO64(off_t, uap->len), uap->advice); return (kern_posix_error(td, error)); } int convert_sigevent32(struct sigevent32 *sig32, struct sigevent *sig) { CP(*sig32, *sig, sigev_notify); switch (sig->sigev_notify) { case SIGEV_NONE: break; case SIGEV_THREAD_ID: CP(*sig32, *sig, sigev_notify_thread_id); /* FALLTHROUGH */ case SIGEV_SIGNAL: CP(*sig32, *sig, sigev_signo); PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr); break; case SIGEV_KEVENT: CP(*sig32, *sig, sigev_notify_kqueue); CP(*sig32, *sig, sigev_notify_kevent_flags); PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr); break; default: return (EINVAL); } return (0); } int freebsd32_procctl(struct thread *td, struct freebsd32_procctl_args *uap) { void *data; union { struct procctl_reaper_status rs; struct procctl_reaper_pids rp; struct procctl_reaper_kill rk; } x; union { struct procctl_reaper_pids32 rp; } x32; int error, error1, flags, signum; if (uap->com >= PROC_PROCCTL_MD_MIN) return (cpu_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id), uap->com, PTRIN(uap->data))); switch (uap->com) { case PROC_ASLR_CTL: case PROC_PROTMAX_CTL: case PROC_SPROTECT: case PROC_STACKGAP_CTL: case PROC_TRACE_CTL: case PROC_TRAPCAP_CTL: case PROC_NO_NEW_PRIVS_CTL: case PROC_WXMAP_CTL: error = copyin(PTRIN(uap->data), &flags, sizeof(flags)); if (error != 0) return (error); data = &flags; break; case PROC_REAP_ACQUIRE: case PROC_REAP_RELEASE: if (uap->data != NULL) return (EINVAL); data = NULL; break; case PROC_REAP_STATUS: data = &x.rs; break; case PROC_REAP_GETPIDS: error = copyin(uap->data, &x32.rp, sizeof(x32.rp)); if (error != 0) return (error); CP(x32.rp, x.rp, rp_count); PTRIN_CP(x32.rp, x.rp, rp_pids); data = &x.rp; break; case PROC_REAP_KILL: error = copyin(uap->data, &x.rk, sizeof(x.rk)); if (error != 0) return (error); data = &x.rk; break; case PROC_ASLR_STATUS: case PROC_PROTMAX_STATUS: case PROC_STACKGAP_STATUS: case PROC_TRACE_STATUS: case PROC_TRAPCAP_STATUS: case PROC_NO_NEW_PRIVS_STATUS: case PROC_WXMAP_STATUS: data = &flags; break; case PROC_PDEATHSIG_CTL: error = copyin(uap->data, &signum, sizeof(signum)); if (error != 0) return (error); data = &signum; break; case PROC_PDEATHSIG_STATUS: data = &signum; break; default: return (EINVAL); } error = kern_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id), uap->com, data); switch (uap->com) { case PROC_REAP_STATUS: if (error == 0) error = copyout(&x.rs, uap->data, sizeof(x.rs)); break; case PROC_REAP_KILL: error1 = copyout(&x.rk, uap->data, sizeof(x.rk)); if (error == 0) error = error1; break; case PROC_ASLR_STATUS: case PROC_PROTMAX_STATUS: case PROC_STACKGAP_STATUS: case PROC_TRACE_STATUS: case PROC_TRAPCAP_STATUS: case PROC_NO_NEW_PRIVS_STATUS: case PROC_WXMAP_STATUS: if (error == 0) error = copyout(&flags, uap->data, sizeof(flags)); break; case PROC_PDEATHSIG_STATUS: if (error == 0) error = copyout(&signum, uap->data, sizeof(signum)); break; } return (error); } int freebsd32_fcntl(struct thread *td, struct freebsd32_fcntl_args *uap) { long tmp; switch (uap->cmd) { /* * Do unsigned conversion for arg when operation * interprets it as flags or pointer. */ case F_SETLK_REMOTE: case F_SETLKW: case F_SETLK: case F_GETLK: case F_SETFD: case F_SETFL: case F_OGETLK: case F_OSETLK: case F_OSETLKW: tmp = (unsigned int)(uap->arg); break; default: tmp = uap->arg; break; } return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, tmp)); } int freebsd32_ppoll(struct thread *td, struct freebsd32_ppoll_args *uap) { struct timespec32 ts32; struct timespec ts, *tsp; sigset_t set, *ssp; int error; if (uap->ts != NULL) { error = copyin(uap->ts, &ts32, sizeof(ts32)); if (error != 0) return (error); CP(ts32, ts, tv_sec); CP(ts32, ts, tv_nsec); tsp = &ts; } else tsp = NULL; if (uap->set != NULL) { error = copyin(uap->set, &set, sizeof(set)); if (error != 0) return (error); ssp = &set; } else ssp = NULL; return (kern_poll(td, uap->fds, uap->nfds, tsp, ssp)); } int freebsd32_sched_rr_get_interval(struct thread *td, struct freebsd32_sched_rr_get_interval_args *uap) { struct timespec ts; struct timespec32 ts32; int error; error = kern_sched_rr_get_interval(td, uap->pid, &ts); if (error == 0) { CP(ts, ts32, tv_sec); CP(ts, ts32, tv_nsec); error = copyout(&ts32, uap->interval, sizeof(ts32)); } return (error); } static void timex_to_32(struct timex32 *dst, struct timex *src) { CP(*src, *dst, modes); CP(*src, *dst, offset); CP(*src, *dst, freq); CP(*src, *dst, maxerror); CP(*src, *dst, esterror); CP(*src, *dst, status); CP(*src, *dst, constant); CP(*src, *dst, precision); CP(*src, *dst, tolerance); CP(*src, *dst, ppsfreq); CP(*src, *dst, jitter); CP(*src, *dst, shift); CP(*src, *dst, stabil); CP(*src, *dst, jitcnt); CP(*src, *dst, calcnt); CP(*src, *dst, errcnt); CP(*src, *dst, stbcnt); } static void timex_from_32(struct timex *dst, struct timex32 *src) { CP(*src, *dst, modes); CP(*src, *dst, offset); CP(*src, *dst, freq); CP(*src, *dst, maxerror); CP(*src, *dst, esterror); CP(*src, *dst, status); CP(*src, *dst, constant); CP(*src, *dst, precision); CP(*src, *dst, tolerance); CP(*src, *dst, ppsfreq); CP(*src, *dst, jitter); CP(*src, *dst, shift); CP(*src, *dst, stabil); CP(*src, *dst, jitcnt); CP(*src, *dst, calcnt); CP(*src, *dst, errcnt); CP(*src, *dst, stbcnt); } int freebsd32_ntp_adjtime(struct thread *td, struct freebsd32_ntp_adjtime_args *uap) { struct timex tx; struct timex32 tx32; int error, retval; error = copyin(uap->tp, &tx32, sizeof(tx32)); if (error == 0) { timex_from_32(&tx, &tx32); error = kern_ntp_adjtime(td, &tx, &retval); if (error == 0) { timex_to_32(&tx32, &tx); error = copyout(&tx32, uap->tp, sizeof(tx32)); if (error == 0) td->td_retval[0] = retval; } } return (error); } int freebsd32_fspacectl(struct thread *td, struct freebsd32_fspacectl_args *uap) { struct spacectl_range rqsr, rmsr; struct spacectl_range32 rqsr32, rmsr32; int error, cerror; error = copyin(uap->rqsr, &rqsr32, sizeof(rqsr32)); if (error != 0) return (error); rqsr.r_offset = PAIR32TO64(off_t, rqsr32.r_offset); rqsr.r_len = PAIR32TO64(off_t, rqsr32.r_len); error = kern_fspacectl(td, uap->fd, uap->cmd, &rqsr, uap->flags, &rmsr); if (uap->rmsr != NULL) { #if BYTE_ORDER == LITTLE_ENDIAN rmsr32.r_offset1 = rmsr.r_offset; rmsr32.r_offset2 = rmsr.r_offset >> 32; rmsr32.r_len1 = rmsr.r_len; rmsr32.r_len2 = rmsr.r_len >> 32; #else rmsr32.r_offset1 = rmsr.r_offset >> 32; rmsr32.r_offset2 = rmsr.r_offset; rmsr32.r_len1 = rmsr.r_len >> 32; rmsr32.r_len2 = rmsr.r_len; #endif cerror = copyout(&rmsr32, uap->rmsr, sizeof(rmsr32)); if (error == 0) error = cerror; } return (error); } diff --git a/sys/compat/freebsd32/freebsd32_proto.h b/sys/compat/freebsd32/freebsd32_proto.h index 1d538f9dcac8..d5b5bf28e739 100644 --- a/sys/compat/freebsd32/freebsd32_proto.h +++ b/sys/compat/freebsd32/freebsd32_proto.h @@ -1,1513 +1,1513 @@ /* * System call prototypes. * * DO NOT EDIT-- this file is automatically @generated. * $FreeBSD$ */ #ifndef _FREEBSD32_SYSPROTO_H_ #define _FREEBSD32_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 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd32_wait4_args { char pid_l_[PADL_(int)]; int pid; char pid_r_[PADR_(int)]; char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)]; char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; char rusage_l_[PADL_(struct rusage32 *)]; struct rusage32 * rusage; char rusage_r_[PADR_(struct rusage32 *)]; }; struct freebsd32_ptrace_args { char req_l_[PADL_(int)]; int req; char req_r_[PADR_(int)]; char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; char addr_l_[PADL_(caddr_t)]; caddr_t addr; char addr_r_[PADR_(caddr_t)]; char data_l_[PADL_(int)]; int data; char data_r_[PADR_(int)]; }; struct freebsd32_recvmsg_args { char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; char msg_l_[PADL_(struct msghdr32 *)]; struct msghdr32 * msg; char msg_r_[PADR_(struct msghdr32 *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32_sendmsg_args { char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; char msg_l_[PADL_(const struct msghdr32 *)]; const struct msghdr32 * msg; char msg_r_[PADR_(const struct msghdr32 *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32_recvfrom_args { char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)]; char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char from_l_[PADL_(struct sockaddr *)]; struct sockaddr * from; char from_r_[PADR_(struct sockaddr *)]; char fromlenaddr_l_[PADL_(uint32_t)]; uint32_t fromlenaddr; char fromlenaddr_r_[PADR_(uint32_t)]; }; struct freebsd10_freebsd32_pipe_args { register_t dummy; }; struct ofreebsd32_sigpending_args { register_t dummy; }; struct freebsd32_sigaltstack_args { char ss_l_[PADL_(const struct sigaltstack32 *)]; const struct sigaltstack32 * ss; char ss_r_[PADR_(const struct sigaltstack32 *)]; char oss_l_[PADL_(struct sigaltstack32 *)]; struct sigaltstack32 * oss; char oss_r_[PADR_(struct sigaltstack32 *)]; }; struct freebsd32_ioctl_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char com_l_[PADL_(u_long)]; u_long com; char com_r_[PADR_(u_long)]; char data_l_[PADL_(char *)]; char * data; char data_r_[PADR_(char *)]; }; struct freebsd32_execve_args { char fname_l_[PADL_(const char *)]; const char * fname; char fname_r_[PADR_(const char *)]; char argv_l_[PADL_(uint32_t *)]; uint32_t * argv; char argv_r_[PADR_(uint32_t *)]; char envv_l_[PADL_(uint32_t *)]; uint32_t * envv; char envv_r_[PADR_(uint32_t *)]; }; struct freebsd32_mprotect_args { char addr_l_[PADL_(const void *)]; const void * addr; char addr_r_[PADR_(const void *)]; char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; }; struct freebsd32_setitimer_args { char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char itv_l_[PADL_(const struct itimerval32 *)]; const struct itimerval32 * itv; char itv_r_[PADR_(const struct itimerval32 *)]; char oitv_l_[PADL_(struct itimerval32 *)]; struct itimerval32 * oitv; char oitv_r_[PADR_(struct itimerval32 *)]; }; struct freebsd32_getitimer_args { char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char itv_l_[PADL_(struct itimerval32 *)]; struct itimerval32 * itv; char itv_r_[PADR_(struct itimerval32 *)]; }; struct freebsd32_fcntl_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char arg_l_[PADL_(int)]; int arg; char arg_r_[PADR_(int)]; }; struct freebsd32_select_args { char nd_l_[PADL_(int)]; int nd; char nd_r_[PADR_(int)]; char in_l_[PADL_(fd_set *)]; fd_set * in; char in_r_[PADR_(fd_set *)]; char ou_l_[PADL_(fd_set *)]; fd_set * ou; char ou_r_[PADR_(fd_set *)]; char ex_l_[PADL_(fd_set *)]; fd_set * ex; char ex_r_[PADR_(fd_set *)]; char tv_l_[PADL_(struct timeval32 *)]; struct timeval32 * tv; char tv_r_[PADR_(struct timeval32 *)]; }; struct freebsd32_gettimeofday_args { char tp_l_[PADL_(struct timeval32 *)]; struct timeval32 * tp; char tp_r_[PADR_(struct timeval32 *)]; char tzp_l_[PADL_(struct timezone *)]; struct timezone * tzp; char tzp_r_[PADR_(struct timezone *)]; }; struct freebsd32_getrusage_args { char who_l_[PADL_(int)]; int who; char who_r_[PADR_(int)]; char rusage_l_[PADL_(struct rusage32 *)]; struct rusage32 * rusage; char rusage_r_[PADR_(struct rusage32 *)]; }; struct freebsd32_readv_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; }; struct freebsd32_writev_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; }; struct freebsd32_settimeofday_args { char tv_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * tv; char tv_r_[PADR_(const struct timeval32 *)]; char tzp_l_[PADL_(const struct timezone *)]; const struct timezone * tzp; char tzp_r_[PADR_(const struct timezone *)]; }; struct freebsd32_utimes_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char tptr_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * tptr; char tptr_r_[PADR_(const struct timeval32 *)]; }; struct freebsd32_adjtime_args { char delta_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * delta; char delta_r_[PADR_(const struct timeval32 *)]; char olddelta_l_[PADL_(struct timeval32 *)]; struct timeval32 * olddelta; char olddelta_r_[PADR_(struct timeval32 *)]; }; struct freebsd32_sysarch_args { char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)]; char parms_l_[PADL_(char *)]; char * parms; char parms_r_[PADR_(char *)]; }; struct freebsd32_semsys_args { char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char a2_l_[PADL_(int)]; int a2; char a2_r_[PADR_(int)]; char a3_l_[PADL_(int)]; int a3; char a3_r_[PADR_(int)]; char a4_l_[PADL_(int)]; int a4; char a4_r_[PADR_(int)]; char a5_l_[PADL_(int)]; int a5; char a5_r_[PADR_(int)]; }; struct freebsd32_msgsys_args { char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char a2_l_[PADL_(int)]; int a2; char a2_r_[PADR_(int)]; char a3_l_[PADL_(int)]; int a3; char a3_r_[PADR_(int)]; char a4_l_[PADL_(int)]; int a4; char a4_r_[PADR_(int)]; char a5_l_[PADL_(int)]; int a5; char a5_r_[PADR_(int)]; char a6_l_[PADL_(int)]; int a6; char a6_r_[PADR_(int)]; }; struct freebsd32_shmsys_args { char which_l_[PADL_(uint32_t)]; uint32_t which; char which_r_[PADR_(uint32_t)]; char a2_l_[PADL_(uint32_t)]; uint32_t a2; char a2_r_[PADR_(uint32_t)]; char a3_l_[PADL_(uint32_t)]; uint32_t a3; char a3_r_[PADR_(uint32_t)]; char a4_l_[PADL_(uint32_t)]; uint32_t a4; char a4_r_[PADR_(uint32_t)]; }; struct freebsd32_ntp_adjtime_args { char tp_l_[PADL_(struct timex32 *)]; struct timex32 * tp; char tp_r_[PADR_(struct timex32 *)]; }; struct freebsd32___sysctl_args { char name_l_[PADL_(int *)]; int * name; char name_r_[PADR_(int *)]; char namelen_l_[PADL_(u_int)]; u_int namelen; char namelen_r_[PADR_(u_int)]; char old_l_[PADL_(void *)]; void * old; char old_r_[PADR_(void *)]; char oldlenp_l_[PADL_(uint32_t *)]; uint32_t * oldlenp; char oldlenp_r_[PADR_(uint32_t *)]; char new_l_[PADL_(const void *)]; const void * new; char new_r_[PADR_(const void *)]; char newlen_l_[PADL_(size_t)]; size_t newlen; char newlen_r_[PADR_(size_t)]; }; struct freebsd32_futimes_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char tptr_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * tptr; char tptr_r_[PADR_(const struct timeval32 *)]; }; struct freebsd32_msgsnd_args { char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; char msgp_l_[PADL_(const void *)]; const void * msgp; char msgp_r_[PADR_(const void *)]; char msgsz_l_[PADL_(size_t)]; size_t msgsz; char msgsz_r_[PADR_(size_t)]; char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; }; struct freebsd32_msgrcv_args { char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; char msgp_l_[PADL_(void *)]; void * msgp; char msgp_r_[PADR_(void *)]; char msgsz_l_[PADL_(size_t)]; size_t msgsz; char msgsz_r_[PADR_(size_t)]; char msgtyp_l_[PADL_(long)]; long msgtyp; char msgtyp_r_[PADR_(long)]; char msgflg_l_[PADL_(int)]; int msgflg; char msgflg_r_[PADR_(int)]; }; struct freebsd32_clock_gettime_args { char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)]; char tp_l_[PADL_(struct timespec32 *)]; struct timespec32 * tp; char tp_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_clock_settime_args { char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)]; char tp_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * tp; char tp_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_clock_getres_args { char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)]; char tp_l_[PADL_(struct timespec32 *)]; struct timespec32 * tp; char tp_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_ktimer_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 sigevent32 *)]; struct sigevent32 * evp; char evp_r_[PADR_(struct sigevent32 *)]; char timerid_l_[PADL_(int *)]; int * timerid; char timerid_r_[PADR_(int *)]; }; struct freebsd32_ktimer_settime_args { char timerid_l_[PADL_(int)]; int timerid; char timerid_r_[PADR_(int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char value_l_[PADL_(const struct itimerspec32 *)]; const struct itimerspec32 * value; char value_r_[PADR_(const struct itimerspec32 *)]; char ovalue_l_[PADL_(struct itimerspec32 *)]; struct itimerspec32 * ovalue; char ovalue_r_[PADR_(struct itimerspec32 *)]; }; struct freebsd32_ktimer_gettime_args { char timerid_l_[PADL_(int)]; int timerid; char timerid_r_[PADR_(int)]; char value_l_[PADL_(struct itimerspec32 *)]; struct itimerspec32 * value; char value_r_[PADR_(struct itimerspec32 *)]; }; struct freebsd32_nanosleep_args { char rqtp_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * rqtp; char rqtp_r_[PADR_(const struct timespec32 *)]; char rmtp_l_[PADL_(struct timespec32 *)]; struct timespec32 * rmtp; char rmtp_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_clock_nanosleep_args { char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char rqtp_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * rqtp; char rqtp_r_[PADR_(const struct timespec32 *)]; char rmtp_l_[PADL_(struct timespec32 *)]; struct timespec32 * rmtp; char rmtp_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_clock_getcpuclockid2_args { char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)]; char clock_id_l_[PADL_(clockid_t *)]; clockid_t * clock_id; char clock_id_r_[PADR_(clockid_t *)]; }; struct freebsd32_aio_read_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_aio_write_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_lio_listio_args { char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; char acb_list_l_[PADL_(uint32_t *)]; uint32_t * acb_list; char acb_list_r_[PADR_(uint32_t *)]; char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; char sig_l_[PADL_(struct sigevent32 *)]; struct sigevent32 * sig; char sig_r_[PADR_(struct sigevent32 *)]; }; struct freebsd32_lutimes_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char tptr_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * tptr; char tptr_r_[PADR_(const struct timeval32 *)]; }; struct freebsd32_preadv_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 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 freebsd32_pwritev_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(u_int)]; u_int iovcnt; char iovcnt_r_[PADR_(u_int)]; 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 freebsd32_modstat_args { char modid_l_[PADL_(int)]; int modid; char modid_r_[PADR_(int)]; char stat_l_[PADL_(struct module_stat32 *)]; struct module_stat32 * stat; char stat_r_[PADR_(struct module_stat32 *)]; }; struct freebsd32_kldstat_args { char fileid_l_[PADL_(int)]; int fileid; char fileid_r_[PADR_(int)]; char stat_l_[PADL_(struct kld_file_stat32 *)]; struct kld_file_stat32 * stat; char stat_r_[PADR_(struct kld_file_stat32 *)]; }; struct freebsd32_aio_return_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_aio_suspend_args { char aiocbp_l_[PADL_(uint32_t *)]; uint32_t * aiocbp; char aiocbp_r_[PADR_(uint32_t *)]; char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; char timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * timeout; char timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_aio_error_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_sched_rr_get_interval_args { char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; char interval_l_[PADL_(struct timespec32 *)]; struct timespec32 * interval; char interval_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_jail_args { char jail_l_[PADL_(struct jail32 *)]; struct jail32 * jail; char jail_r_[PADR_(struct jail32 *)]; }; struct freebsd32_sigtimedwait_args { char set_l_[PADL_(const sigset_t *)]; const sigset_t * set; char set_r_[PADR_(const sigset_t *)]; char info_l_[PADL_(struct siginfo32 *)]; struct siginfo32 * info; char info_r_[PADR_(struct siginfo32 *)]; char timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * timeout; char timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_sigwaitinfo_args { char set_l_[PADL_(const sigset_t *)]; const sigset_t * set; char set_r_[PADR_(const sigset_t *)]; char info_l_[PADL_(struct siginfo32 *)]; struct siginfo32 * info; char info_r_[PADR_(struct siginfo32 *)]; }; struct freebsd32_aio_waitcomplete_args { char aiocbp_l_[PADL_(uint32_t *)]; uint32_t * aiocbp; char aiocbp_r_[PADR_(uint32_t *)]; char timeout_l_[PADL_(struct timespec32 *)]; struct timespec32 * timeout; char timeout_r_[PADR_(struct timespec32 *)]; }; struct freebsd32_nmount_args { char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(unsigned int)]; unsigned int iovcnt; char iovcnt_r_[PADR_(unsigned int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32_sendfile_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 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 nbytes_l_[PADL_(size_t)]; size_t nbytes; char nbytes_r_[PADR_(size_t)]; char hdtr_l_[PADL_(struct sf_hdtr32 *)]; struct sf_hdtr32 * hdtr; char hdtr_r_[PADR_(struct sf_hdtr32 *)]; char sbytes_l_[PADL_(off_t *)]; off_t * sbytes; char sbytes_r_[PADR_(off_t *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32_ksem_init_args { char idp_l_[PADL_(semid_t *)]; semid_t * idp; char idp_r_[PADR_(semid_t *)]; char value_l_[PADL_(unsigned int)]; unsigned int value; char value_r_[PADR_(unsigned int)]; }; struct freebsd32_ksem_open_args { char idp_l_[PADL_(semid_t *)]; semid_t * idp; char idp_r_[PADR_(semid_t *)]; char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; char oflag_l_[PADL_(int)]; int oflag; char oflag_r_[PADR_(int)]; char mode_l_[PADL_(mode_t)]; mode_t mode; char mode_r_[PADR_(mode_t)]; char value_l_[PADL_(unsigned int)]; unsigned int value; char value_r_[PADR_(unsigned int)]; }; struct freebsd32_sigaction_args { char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; char act_l_[PADL_(const struct sigaction32 *)]; const struct sigaction32 * act; char act_r_[PADR_(const struct sigaction32 *)]; char oact_l_[PADL_(struct sigaction32 *)]; struct sigaction32 * oact; char oact_r_[PADR_(struct sigaction32 *)]; }; struct freebsd32_sigreturn_args { char sigcntxp_l_[PADL_(const struct __ucontext32 *)]; const struct __ucontext32 * sigcntxp; char sigcntxp_r_[PADR_(const struct __ucontext32 *)]; }; struct freebsd32_getcontext_args { char ucp_l_[PADL_(struct __ucontext32 *)]; struct __ucontext32 * ucp; char ucp_r_[PADR_(struct __ucontext32 *)]; }; struct freebsd32_setcontext_args { char ucp_l_[PADL_(const struct __ucontext32 *)]; const struct __ucontext32 * ucp; char ucp_r_[PADR_(const struct __ucontext32 *)]; }; struct freebsd32_swapcontext_args { char oucp_l_[PADL_(struct __ucontext32 *)]; struct __ucontext32 * oucp; char oucp_r_[PADR_(struct __ucontext32 *)]; char ucp_l_[PADL_(const struct __ucontext32 *)]; const struct __ucontext32 * ucp; char ucp_r_[PADR_(const struct __ucontext32 *)]; }; struct freebsd32_ksem_timedwait_args { char id_l_[PADL_(semid_t)]; semid_t id; char id_r_[PADR_(semid_t)]; char abstime_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * abstime; char abstime_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_thr_suspend_args { char timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * timeout; char timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32__umtx_op_args { char obj_l_[PADL_(void *)]; void * obj; char obj_r_[PADR_(void *)]; char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)]; char val_l_[PADL_(u_long)]; u_long val; char val_r_[PADR_(u_long)]; char uaddr1_l_[PADL_(void *)]; void * uaddr1; char uaddr1_r_[PADR_(void *)]; char uaddr2_l_[PADL_(void *)]; void * uaddr2; char uaddr2_r_[PADR_(void *)]; }; struct freebsd32_thr_new_args { char param_l_[PADL_(struct thr_param32 *)]; struct thr_param32 * param; char param_r_[PADR_(struct thr_param32 *)]; char param_size_l_[PADL_(int)]; int param_size; char param_size_r_[PADR_(int)]; }; struct freebsd32_sigqueue_args { char pid_l_[PADL_(pid_t)]; pid_t pid; char pid_r_[PADR_(pid_t)]; char signum_l_[PADL_(int)]; int signum; char signum_r_[PADR_(int)]; char value_l_[PADL_(int)]; int value; char value_r_[PADR_(int)]; }; struct freebsd32_kmq_open_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char mode_l_[PADL_(mode_t)]; mode_t mode; char mode_r_[PADR_(mode_t)]; char attr_l_[PADL_(const struct mq_attr32 *)]; const struct mq_attr32 * attr; char attr_r_[PADR_(const struct mq_attr32 *)]; }; struct freebsd32_kmq_setattr_args { char mqd_l_[PADL_(int)]; int mqd; char mqd_r_[PADR_(int)]; char attr_l_[PADL_(const struct mq_attr32 *)]; const struct mq_attr32 * attr; char attr_r_[PADR_(const struct mq_attr32 *)]; char oattr_l_[PADL_(struct mq_attr32 *)]; struct mq_attr32 * oattr; char oattr_r_[PADR_(struct mq_attr32 *)]; }; struct freebsd32_kmq_timedreceive_args { char mqd_l_[PADL_(int)]; int mqd; char mqd_r_[PADR_(int)]; char msg_ptr_l_[PADL_(char *)]; char * msg_ptr; char msg_ptr_r_[PADR_(char *)]; char msg_len_l_[PADL_(size_t)]; size_t msg_len; char msg_len_r_[PADR_(size_t)]; char msg_prio_l_[PADL_(unsigned *)]; unsigned * msg_prio; char msg_prio_r_[PADR_(unsigned *)]; char abs_timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * abs_timeout; char abs_timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_kmq_timedsend_args { char mqd_l_[PADL_(int)]; int mqd; char mqd_r_[PADR_(int)]; char msg_ptr_l_[PADL_(const char *)]; const char * msg_ptr; char msg_ptr_r_[PADR_(const char *)]; char msg_len_l_[PADL_(size_t)]; size_t msg_len; char msg_len_r_[PADR_(size_t)]; char msg_prio_l_[PADL_(unsigned)]; unsigned msg_prio; char msg_prio_r_[PADR_(unsigned)]; char abs_timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * abs_timeout; char abs_timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_kmq_notify_args { char mqd_l_[PADL_(int)]; int mqd; char mqd_r_[PADR_(int)]; char sigev_l_[PADL_(const struct sigevent32 *)]; const struct sigevent32 * sigev; char sigev_r_[PADR_(const struct sigevent32 *)]; }; struct freebsd32_aio_fsync_args { char op_l_[PADL_(int)]; int op; char op_r_[PADR_(int)]; char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; #ifdef PAD64_REQUIRED struct freebsd32_pread_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd32_pwrite_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(const void *)]; const void * buf; char buf_r_[PADR_(const void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd32_mmap_args { char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)]; char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char pos1_l_[PADL_(uint32_t)]; uint32_t pos1; char pos1_r_[PADR_(uint32_t)]; char pos2_l_[PADL_(uint32_t)]; uint32_t pos2; char pos2_r_[PADR_(uint32_t)]; }; struct freebsd32_lseek_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 whence_l_[PADL_(int)]; int whence; char whence_r_[PADR_(int)]; }; struct freebsd32_truncate_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd32_ftruncate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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)]; }; #else struct freebsd32_pread_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_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 freebsd32_pwrite_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(const void *)]; const void * buf; char buf_r_[PADR_(const void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_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 freebsd32_mmap_args { char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)]; char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pos1_l_[PADL_(uint32_t)]; uint32_t pos1; char pos1_r_[PADR_(uint32_t)]; char pos2_l_[PADL_(uint32_t)]; uint32_t pos2; char pos2_r_[PADR_(uint32_t)]; }; struct freebsd32_lseek_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 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 whence_l_[PADL_(int)]; int whence; char whence_r_[PADR_(int)]; }; struct freebsd32_truncate_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; 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 freebsd32_ftruncate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 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)]; }; #endif #ifdef PAD64_REQUIRED struct freebsd32_cpuset_setid_args { char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char setid_l_[PADL_(cpusetid_t)]; cpusetid_t setid; char setid_r_[PADR_(cpusetid_t)]; }; #else struct freebsd32_cpuset_setid_args { char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char setid_l_[PADL_(cpusetid_t)]; cpusetid_t setid; char setid_r_[PADR_(cpusetid_t)]; }; #endif struct freebsd32_cpuset_getid_args { char level_l_[PADL_(cpulevel_t)]; cpulevel_t level; char level_r_[PADR_(cpulevel_t)]; char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char setid_l_[PADL_(cpusetid_t *)]; cpusetid_t * setid; char setid_r_[PADR_(cpusetid_t *)]; }; struct freebsd32_cpuset_getaffinity_args { char level_l_[PADL_(cpulevel_t)]; cpulevel_t level; char level_r_[PADR_(cpulevel_t)]; char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char cpusetsize_l_[PADL_(size_t)]; size_t cpusetsize; char cpusetsize_r_[PADR_(size_t)]; char mask_l_[PADL_(cpuset_t *)]; cpuset_t * mask; char mask_r_[PADR_(cpuset_t *)]; }; struct freebsd32_cpuset_setaffinity_args { char level_l_[PADL_(cpulevel_t)]; cpulevel_t level; char level_r_[PADR_(cpulevel_t)]; char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char cpusetsize_l_[PADL_(size_t)]; size_t cpusetsize; char cpusetsize_r_[PADR_(size_t)]; char mask_l_[PADL_(const cpuset_t *)]; const cpuset_t * mask; char mask_r_[PADR_(const cpuset_t *)]; }; struct freebsd32_fexecve_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char argv_l_[PADL_(uint32_t *)]; uint32_t * argv; char argv_r_[PADR_(uint32_t *)]; char envv_l_[PADL_(uint32_t *)]; uint32_t * envv; char envv_r_[PADR_(uint32_t *)]; }; struct freebsd32_futimesat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char times_l_[PADL_(const struct timeval32 *)]; const struct timeval32 * times; char times_r_[PADR_(const struct timeval32 *)]; }; struct freebsd32_jail_get_args { char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(unsigned int)]; unsigned int iovcnt; char iovcnt_r_[PADR_(unsigned int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32_jail_set_args { char iovp_l_[PADL_(struct iovec32 *)]; struct iovec32 * iovp; char iovp_r_[PADR_(struct iovec32 *)]; char iovcnt_l_[PADL_(unsigned int)]; unsigned int iovcnt; char iovcnt_r_[PADR_(unsigned int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd32___semctl_args { char semid_l_[PADL_(int)]; int semid; char semid_r_[PADR_(int)]; char semnum_l_[PADL_(int)]; int semnum; char semnum_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char arg_l_[PADL_(union semun32 *)]; union semun32 * arg; char arg_r_[PADR_(union semun32 *)]; }; struct freebsd32_msgctl_args { char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char buf_l_[PADL_(struct msqid_ds32 *)]; struct msqid_ds32 * buf; char buf_r_[PADR_(struct msqid_ds32 *)]; }; struct freebsd32_shmctl_args { char shmid_l_[PADL_(int)]; int shmid; char shmid_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char buf_l_[PADL_(struct shmid_ds32 *)]; struct shmid_ds32 * buf; char buf_r_[PADR_(struct shmid_ds32 *)]; }; struct freebsd32_pselect_args { char nd_l_[PADL_(int)]; int nd; char nd_r_[PADR_(int)]; char in_l_[PADL_(fd_set *)]; fd_set * in; char in_r_[PADR_(fd_set *)]; char ou_l_[PADL_(fd_set *)]; fd_set * ou; char ou_r_[PADR_(fd_set *)]; char ex_l_[PADL_(fd_set *)]; fd_set * ex; char ex_r_[PADR_(fd_set *)]; char ts_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * ts; char ts_r_[PADR_(const struct timespec32 *)]; char sm_l_[PADL_(const sigset_t *)]; const sigset_t * sm; char sm_r_[PADR_(const sigset_t *)]; }; #ifdef PAD64_REQUIRED struct freebsd32_posix_fallocate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd32_posix_fadvise_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd32_wait6_args { char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)]; char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; - char wrusage_l_[PADL_(struct wrusage32 *)]; struct wrusage32 * wrusage; char wrusage_r_[PADR_(struct wrusage32 *)]; + char wrusage_l_[PADL_(struct __wrusage32 *)]; struct __wrusage32 * wrusage; char wrusage_r_[PADR_(struct __wrusage32 *)]; char info_l_[PADL_(struct siginfo32 *)]; struct siginfo32 * info; char info_r_[PADR_(struct siginfo32 *)]; }; #else struct freebsd32_posix_fallocate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 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 freebsd32_posix_fadvise_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; 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 freebsd32_wait6_args { char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)]; char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)]; - char wrusage_l_[PADL_(struct wrusage32 *)]; struct wrusage32 * wrusage; char wrusage_r_[PADR_(struct wrusage32 *)]; + char wrusage_l_[PADL_(struct __wrusage32 *)]; struct __wrusage32 * wrusage; char wrusage_r_[PADR_(struct __wrusage32 *)]; char info_l_[PADL_(struct siginfo32 *)]; struct siginfo32 * info; char info_r_[PADR_(struct siginfo32 *)]; }; #endif struct freebsd32_cap_ioctls_limit_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char cmds_l_[PADL_(const uint32_t *)]; const uint32_t * cmds; char cmds_r_[PADR_(const uint32_t *)]; char ncmds_l_[PADL_(size_t)]; size_t ncmds; char ncmds_r_[PADR_(size_t)]; }; struct freebsd32_cap_ioctls_get_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char cmds_l_[PADL_(uint32_t *)]; uint32_t * cmds; char cmds_r_[PADR_(uint32_t *)]; char maxcmds_l_[PADL_(size_t)]; size_t maxcmds; char maxcmds_r_[PADR_(size_t)]; }; struct freebsd32_aio_mlock_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; #ifdef PAD64_REQUIRED struct freebsd32_procctl_args { char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char com_l_[PADL_(int)]; int com; char com_r_[PADR_(int)]; char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)]; }; #else struct freebsd32_procctl_args { char idtype_l_[PADL_(idtype_t)]; idtype_t idtype; char idtype_r_[PADR_(idtype_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char com_l_[PADL_(int)]; int com; char com_r_[PADR_(int)]; char data_l_[PADL_(void *)]; void * data; char data_r_[PADR_(void *)]; }; #endif struct freebsd32_ppoll_args { char fds_l_[PADL_(struct pollfd *)]; struct pollfd * fds; char fds_r_[PADR_(struct pollfd *)]; char nfds_l_[PADL_(u_int)]; u_int nfds; char nfds_r_[PADR_(u_int)]; char ts_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * ts; char ts_r_[PADR_(const struct timespec32 *)]; char set_l_[PADL_(const sigset_t *)]; const sigset_t * set; char set_r_[PADR_(const sigset_t *)]; }; struct freebsd32_futimens_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char times_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * times; char times_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_utimensat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char times_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * times; char times_r_[PADR_(const struct timespec32 *)]; char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; }; struct freebsd32_fstat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char sb_l_[PADL_(struct stat32 *)]; struct stat32 * sb; char sb_r_[PADR_(struct stat32 *)]; }; struct freebsd32_fstatat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char buf_l_[PADL_(struct stat32 *)]; struct stat32 * buf; char buf_r_[PADR_(struct stat32 *)]; char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; }; struct freebsd32_fhstat_args { char u_fhp_l_[PADL_(const struct fhandle *)]; const struct fhandle * u_fhp; char u_fhp_r_[PADR_(const struct fhandle *)]; char sb_l_[PADL_(struct stat32 *)]; struct stat32 * sb; char sb_r_[PADR_(struct stat32 *)]; }; #ifdef PAD64_REQUIRED struct freebsd32_mknodat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char mode_l_[PADL_(mode_t)]; mode_t mode; char mode_r_[PADR_(mode_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char dev1_l_[PADL_(uint32_t)]; uint32_t dev1; char dev1_r_[PADR_(uint32_t)]; char dev2_l_[PADL_(uint32_t)]; uint32_t dev2; char dev2_r_[PADR_(uint32_t)]; }; #else struct freebsd32_mknodat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char mode_l_[PADL_(mode_t)]; mode_t mode; char mode_r_[PADR_(mode_t)]; char dev1_l_[PADL_(uint32_t)]; uint32_t dev1; char dev1_r_[PADR_(uint32_t)]; char dev2_l_[PADL_(uint32_t)]; uint32_t dev2; char dev2_r_[PADR_(uint32_t)]; }; #endif struct freebsd32_kevent_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char changelist_l_[PADL_(const struct kevent32 *)]; const struct kevent32 * changelist; char changelist_r_[PADR_(const struct kevent32 *)]; char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)]; char eventlist_l_[PADL_(struct kevent32 *)]; struct kevent32 * eventlist; char eventlist_r_[PADR_(struct kevent32 *)]; char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)]; char timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * timeout; char timeout_r_[PADR_(const struct timespec32 *)]; }; struct freebsd32_cpuset_getdomain_args { char level_l_[PADL_(cpulevel_t)]; cpulevel_t level; char level_r_[PADR_(cpulevel_t)]; char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char domainsetsize_l_[PADL_(size_t)]; size_t domainsetsize; char domainsetsize_r_[PADR_(size_t)]; char mask_l_[PADL_(domainset_t *)]; domainset_t * mask; char mask_r_[PADR_(domainset_t *)]; char policy_l_[PADL_(int *)]; int * policy; char policy_r_[PADR_(int *)]; }; struct freebsd32_cpuset_setdomain_args { char level_l_[PADL_(cpulevel_t)]; cpulevel_t level; char level_r_[PADR_(cpulevel_t)]; char which_l_[PADL_(cpuwhich_t)]; cpuwhich_t which; char which_r_[PADR_(cpuwhich_t)]; char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)]; char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)]; char domainsetsize_l_[PADL_(size_t)]; size_t domainsetsize; char domainsetsize_r_[PADR_(size_t)]; char mask_l_[PADL_(domainset_t *)]; domainset_t * mask; char mask_r_[PADR_(domainset_t *)]; char policy_l_[PADL_(int)]; int policy; char policy_r_[PADR_(int)]; }; struct freebsd32___sysctlbyname_args { char name_l_[PADL_(const char *)]; const char * name; char name_r_[PADR_(const char *)]; char namelen_l_[PADL_(size_t)]; size_t namelen; char namelen_r_[PADR_(size_t)]; char old_l_[PADL_(void *)]; void * old; char old_r_[PADR_(void *)]; char oldlenp_l_[PADL_(uint32_t *)]; uint32_t * oldlenp; char oldlenp_r_[PADR_(uint32_t *)]; char new_l_[PADL_(void *)]; void * new; char new_r_[PADR_(void *)]; char newlen_l_[PADL_(size_t)]; size_t newlen; char newlen_r_[PADR_(size_t)]; }; struct freebsd32_aio_writev_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_aio_readv_args { char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)]; }; struct freebsd32_fspacectl_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char rqsr_l_[PADL_(const struct spacectl_range32 *)]; const struct spacectl_range32 * rqsr; char rqsr_r_[PADR_(const struct spacectl_range32 *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char rmsr_l_[PADL_(struct spacectl_range32 *)]; struct spacectl_range32 * rmsr; char rmsr_r_[PADR_(struct spacectl_range32 *)]; }; #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif int freebsd32_wait4(struct thread *, struct freebsd32_wait4_args *); int freebsd32_ptrace(struct thread *, struct freebsd32_ptrace_args *); int freebsd32_recvmsg(struct thread *, struct freebsd32_recvmsg_args *); int freebsd32_sendmsg(struct thread *, struct freebsd32_sendmsg_args *); int freebsd32_recvfrom(struct thread *, struct freebsd32_recvfrom_args *); int freebsd32_sigaltstack(struct thread *, struct freebsd32_sigaltstack_args *); int freebsd32_ioctl(struct thread *, struct freebsd32_ioctl_args *); int freebsd32_execve(struct thread *, struct freebsd32_execve_args *); int freebsd32_mprotect(struct thread *, struct freebsd32_mprotect_args *); int freebsd32_setitimer(struct thread *, struct freebsd32_setitimer_args *); int freebsd32_getitimer(struct thread *, struct freebsd32_getitimer_args *); int freebsd32_fcntl(struct thread *, struct freebsd32_fcntl_args *); int freebsd32_select(struct thread *, struct freebsd32_select_args *); int freebsd32_gettimeofday(struct thread *, struct freebsd32_gettimeofday_args *); int freebsd32_getrusage(struct thread *, struct freebsd32_getrusage_args *); int freebsd32_readv(struct thread *, struct freebsd32_readv_args *); int freebsd32_writev(struct thread *, struct freebsd32_writev_args *); int freebsd32_settimeofday(struct thread *, struct freebsd32_settimeofday_args *); int freebsd32_utimes(struct thread *, struct freebsd32_utimes_args *); int freebsd32_adjtime(struct thread *, struct freebsd32_adjtime_args *); int freebsd32_sysarch(struct thread *, struct freebsd32_sysarch_args *); int freebsd32_semsys(struct thread *, struct freebsd32_semsys_args *); int freebsd32_msgsys(struct thread *, struct freebsd32_msgsys_args *); int freebsd32_shmsys(struct thread *, struct freebsd32_shmsys_args *); int freebsd32_ntp_adjtime(struct thread *, struct freebsd32_ntp_adjtime_args *); int freebsd32___sysctl(struct thread *, struct freebsd32___sysctl_args *); int freebsd32_futimes(struct thread *, struct freebsd32_futimes_args *); int freebsd32_msgsnd(struct thread *, struct freebsd32_msgsnd_args *); int freebsd32_msgrcv(struct thread *, struct freebsd32_msgrcv_args *); int freebsd32_clock_gettime(struct thread *, struct freebsd32_clock_gettime_args *); int freebsd32_clock_settime(struct thread *, struct freebsd32_clock_settime_args *); int freebsd32_clock_getres(struct thread *, struct freebsd32_clock_getres_args *); int freebsd32_ktimer_create(struct thread *, struct freebsd32_ktimer_create_args *); int freebsd32_ktimer_settime(struct thread *, struct freebsd32_ktimer_settime_args *); int freebsd32_ktimer_gettime(struct thread *, struct freebsd32_ktimer_gettime_args *); int freebsd32_nanosleep(struct thread *, struct freebsd32_nanosleep_args *); int freebsd32_clock_nanosleep(struct thread *, struct freebsd32_clock_nanosleep_args *); int freebsd32_clock_getcpuclockid2(struct thread *, struct freebsd32_clock_getcpuclockid2_args *); int freebsd32_aio_read(struct thread *, struct freebsd32_aio_read_args *); int freebsd32_aio_write(struct thread *, struct freebsd32_aio_write_args *); int freebsd32_lio_listio(struct thread *, struct freebsd32_lio_listio_args *); int freebsd32_lutimes(struct thread *, struct freebsd32_lutimes_args *); int freebsd32_preadv(struct thread *, struct freebsd32_preadv_args *); int freebsd32_pwritev(struct thread *, struct freebsd32_pwritev_args *); int freebsd32_modstat(struct thread *, struct freebsd32_modstat_args *); int freebsd32_kldstat(struct thread *, struct freebsd32_kldstat_args *); int freebsd32_aio_return(struct thread *, struct freebsd32_aio_return_args *); int freebsd32_aio_suspend(struct thread *, struct freebsd32_aio_suspend_args *); int freebsd32_aio_error(struct thread *, struct freebsd32_aio_error_args *); int freebsd32_sched_rr_get_interval(struct thread *, struct freebsd32_sched_rr_get_interval_args *); int freebsd32_jail(struct thread *, struct freebsd32_jail_args *); int freebsd32_sigtimedwait(struct thread *, struct freebsd32_sigtimedwait_args *); int freebsd32_sigwaitinfo(struct thread *, struct freebsd32_sigwaitinfo_args *); int freebsd32_aio_waitcomplete(struct thread *, struct freebsd32_aio_waitcomplete_args *); int freebsd32_nmount(struct thread *, struct freebsd32_nmount_args *); int freebsd32_sendfile(struct thread *, struct freebsd32_sendfile_args *); int freebsd32_ksem_init(struct thread *, struct freebsd32_ksem_init_args *); int freebsd32_ksem_open(struct thread *, struct freebsd32_ksem_open_args *); int freebsd32_sigaction(struct thread *, struct freebsd32_sigaction_args *); int freebsd32_sigreturn(struct thread *, struct freebsd32_sigreturn_args *); int freebsd32_getcontext(struct thread *, struct freebsd32_getcontext_args *); int freebsd32_setcontext(struct thread *, struct freebsd32_setcontext_args *); int freebsd32_swapcontext(struct thread *, struct freebsd32_swapcontext_args *); int freebsd32_ksem_timedwait(struct thread *, struct freebsd32_ksem_timedwait_args *); int freebsd32_thr_suspend(struct thread *, struct freebsd32_thr_suspend_args *); int freebsd32__umtx_op(struct thread *, struct freebsd32__umtx_op_args *); int freebsd32_thr_new(struct thread *, struct freebsd32_thr_new_args *); int freebsd32_sigqueue(struct thread *, struct freebsd32_sigqueue_args *); int freebsd32_kmq_open(struct thread *, struct freebsd32_kmq_open_args *); int freebsd32_kmq_setattr(struct thread *, struct freebsd32_kmq_setattr_args *); int freebsd32_kmq_timedreceive(struct thread *, struct freebsd32_kmq_timedreceive_args *); int freebsd32_kmq_timedsend(struct thread *, struct freebsd32_kmq_timedsend_args *); int freebsd32_kmq_notify(struct thread *, struct freebsd32_kmq_notify_args *); int freebsd32_aio_fsync(struct thread *, struct freebsd32_aio_fsync_args *); #ifdef PAD64_REQUIRED int freebsd32_pread(struct thread *, struct freebsd32_pread_args *); int freebsd32_pwrite(struct thread *, struct freebsd32_pwrite_args *); int freebsd32_mmap(struct thread *, struct freebsd32_mmap_args *); int freebsd32_lseek(struct thread *, struct freebsd32_lseek_args *); int freebsd32_truncate(struct thread *, struct freebsd32_truncate_args *); int freebsd32_ftruncate(struct thread *, struct freebsd32_ftruncate_args *); #else int freebsd32_pread(struct thread *, struct freebsd32_pread_args *); int freebsd32_pwrite(struct thread *, struct freebsd32_pwrite_args *); int freebsd32_mmap(struct thread *, struct freebsd32_mmap_args *); int freebsd32_lseek(struct thread *, struct freebsd32_lseek_args *); int freebsd32_truncate(struct thread *, struct freebsd32_truncate_args *); int freebsd32_ftruncate(struct thread *, struct freebsd32_ftruncate_args *); #endif #ifdef PAD64_REQUIRED int freebsd32_cpuset_setid(struct thread *, struct freebsd32_cpuset_setid_args *); #else int freebsd32_cpuset_setid(struct thread *, struct freebsd32_cpuset_setid_args *); #endif int freebsd32_cpuset_getid(struct thread *, struct freebsd32_cpuset_getid_args *); int freebsd32_cpuset_getaffinity(struct thread *, struct freebsd32_cpuset_getaffinity_args *); int freebsd32_cpuset_setaffinity(struct thread *, struct freebsd32_cpuset_setaffinity_args *); int freebsd32_fexecve(struct thread *, struct freebsd32_fexecve_args *); int freebsd32_futimesat(struct thread *, struct freebsd32_futimesat_args *); int freebsd32_jail_get(struct thread *, struct freebsd32_jail_get_args *); int freebsd32_jail_set(struct thread *, struct freebsd32_jail_set_args *); int freebsd32___semctl(struct thread *, struct freebsd32___semctl_args *); int freebsd32_msgctl(struct thread *, struct freebsd32_msgctl_args *); int freebsd32_shmctl(struct thread *, struct freebsd32_shmctl_args *); int freebsd32_pselect(struct thread *, struct freebsd32_pselect_args *); #ifdef PAD64_REQUIRED int freebsd32_posix_fallocate(struct thread *, struct freebsd32_posix_fallocate_args *); int freebsd32_posix_fadvise(struct thread *, struct freebsd32_posix_fadvise_args *); int freebsd32_wait6(struct thread *, struct freebsd32_wait6_args *); #else int freebsd32_posix_fallocate(struct thread *, struct freebsd32_posix_fallocate_args *); int freebsd32_posix_fadvise(struct thread *, struct freebsd32_posix_fadvise_args *); int freebsd32_wait6(struct thread *, struct freebsd32_wait6_args *); #endif int freebsd32_cap_ioctls_limit(struct thread *, struct freebsd32_cap_ioctls_limit_args *); int freebsd32_cap_ioctls_get(struct thread *, struct freebsd32_cap_ioctls_get_args *); int freebsd32_aio_mlock(struct thread *, struct freebsd32_aio_mlock_args *); #ifdef PAD64_REQUIRED int freebsd32_procctl(struct thread *, struct freebsd32_procctl_args *); #else int freebsd32_procctl(struct thread *, struct freebsd32_procctl_args *); #endif int freebsd32_ppoll(struct thread *, struct freebsd32_ppoll_args *); int freebsd32_futimens(struct thread *, struct freebsd32_futimens_args *); int freebsd32_utimensat(struct thread *, struct freebsd32_utimensat_args *); int freebsd32_fstat(struct thread *, struct freebsd32_fstat_args *); int freebsd32_fstatat(struct thread *, struct freebsd32_fstatat_args *); int freebsd32_fhstat(struct thread *, struct freebsd32_fhstat_args *); #ifdef PAD64_REQUIRED int freebsd32_mknodat(struct thread *, struct freebsd32_mknodat_args *); #else int freebsd32_mknodat(struct thread *, struct freebsd32_mknodat_args *); #endif int freebsd32_kevent(struct thread *, struct freebsd32_kevent_args *); int freebsd32_cpuset_getdomain(struct thread *, struct freebsd32_cpuset_getdomain_args *); int freebsd32_cpuset_setdomain(struct thread *, struct freebsd32_cpuset_setdomain_args *); int freebsd32___sysctlbyname(struct thread *, struct freebsd32___sysctlbyname_args *); int freebsd32_aio_writev(struct thread *, struct freebsd32_aio_writev_args *); int freebsd32_aio_readv(struct thread *, struct freebsd32_aio_readv_args *); int freebsd32_fspacectl(struct thread *, struct freebsd32_fspacectl_args *); #ifdef COMPAT_43 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct ofreebsd32_lseek_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char offset_l_[PADL_(int)]; int offset; char offset_r_[PADR_(int)]; char whence_l_[PADL_(int)]; int whence; char whence_r_[PADR_(int)]; }; struct ofreebsd32_stat_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char ub_l_[PADL_(struct ostat32 *)]; struct ostat32 * ub; char ub_r_[PADR_(struct ostat32 *)]; }; struct ofreebsd32_lstat_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char ub_l_[PADL_(struct ostat32 *)]; struct ostat32 * ub; char ub_r_[PADR_(struct ostat32 *)]; }; struct ofreebsd32_sigaction_args { char signum_l_[PADL_(int)]; int signum; char signum_r_[PADR_(int)]; char nsa_l_[PADL_(struct osigaction32 *)]; struct osigaction32 * nsa; char nsa_r_[PADR_(struct osigaction32 *)]; char osa_l_[PADL_(struct osigaction32 *)]; struct osigaction32 * osa; char osa_r_[PADR_(struct osigaction32 *)]; }; struct ofreebsd32_sigprocmask_args { char how_l_[PADL_(int)]; int how; char how_r_[PADR_(int)]; char mask_l_[PADL_(osigset_t)]; osigset_t mask; char mask_r_[PADR_(osigset_t)]; }; struct ofreebsd32_fstat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char ub_l_[PADL_(struct ostat32 *)]; struct ostat32 * ub; char ub_r_[PADR_(struct ostat32 *)]; }; struct ofreebsd32_getpagesize_args { char dummy_l_[PADL_(int32_t)]; int32_t dummy; char dummy_r_[PADR_(int32_t)]; }; struct ofreebsd32_mmap_args { char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)]; char len_l_[PADL_(int)]; int len; char len_r_[PADR_(int)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pos_l_[PADL_(int32_t)]; int32_t pos; char pos_r_[PADR_(int32_t)]; }; struct ofreebsd32_sigreturn_args { char sigcntxp_l_[PADL_(struct ia32_sigcontext3 *)]; struct ia32_sigcontext3 * sigcntxp; char sigcntxp_r_[PADR_(struct ia32_sigcontext3 *)]; }; struct ofreebsd32_sigvec_args { char signum_l_[PADL_(int)]; int signum; char signum_r_[PADR_(int)]; char nsv_l_[PADL_(struct sigvec32 *)]; struct sigvec32 * nsv; char nsv_r_[PADR_(struct sigvec32 *)]; char osv_l_[PADL_(struct sigvec32 *)]; struct sigvec32 * osv; char osv_r_[PADR_(struct sigvec32 *)]; }; struct ofreebsd32_sigblock_args { char mask_l_[PADL_(int)]; int mask; char mask_r_[PADR_(int)]; }; struct ofreebsd32_sigsetmask_args { char mask_l_[PADL_(int)]; int mask; char mask_r_[PADR_(int)]; }; struct ofreebsd32_sigsuspend_args { char mask_l_[PADL_(int)]; int mask; char mask_r_[PADR_(int)]; }; struct ofreebsd32_sigstack_args { char nss_l_[PADL_(struct sigstack32 *)]; struct sigstack32 * nss; char nss_r_[PADR_(struct sigstack32 *)]; char oss_l_[PADL_(struct sigstack32 *)]; struct sigstack32 * oss; char oss_r_[PADR_(struct sigstack32 *)]; }; struct ofreebsd32_getdirentries_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; char count_l_[PADL_(u_int)]; u_int count; char count_r_[PADR_(u_int)]; char basep_l_[PADL_(uint32_t *)]; uint32_t * basep; char basep_r_[PADR_(uint32_t *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int ofreebsd32_lseek(struct thread *, struct ofreebsd32_lseek_args *); int ofreebsd32_stat(struct thread *, struct ofreebsd32_stat_args *); int ofreebsd32_lstat(struct thread *, struct ofreebsd32_lstat_args *); int ofreebsd32_sigaction(struct thread *, struct ofreebsd32_sigaction_args *); int ofreebsd32_sigprocmask(struct thread *, struct ofreebsd32_sigprocmask_args *); int ofreebsd32_sigpending(struct thread *, struct ofreebsd32_sigpending_args *); int ofreebsd32_fstat(struct thread *, struct ofreebsd32_fstat_args *); int ofreebsd32_getpagesize(struct thread *, struct ofreebsd32_getpagesize_args *); int ofreebsd32_mmap(struct thread *, struct ofreebsd32_mmap_args *); int ofreebsd32_sigreturn(struct thread *, struct ofreebsd32_sigreturn_args *); int ofreebsd32_sigvec(struct thread *, struct ofreebsd32_sigvec_args *); int ofreebsd32_sigblock(struct thread *, struct ofreebsd32_sigblock_args *); int ofreebsd32_sigsetmask(struct thread *, struct ofreebsd32_sigsetmask_args *); int ofreebsd32_sigsuspend(struct thread *, struct ofreebsd32_sigsuspend_args *); int ofreebsd32_sigstack(struct thread *, struct ofreebsd32_sigstack_args *); int ofreebsd32_getdirentries(struct thread *, struct ofreebsd32_getdirentries_args *); #endif /* COMPAT_43 */ #ifdef COMPAT_FREEBSD4 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd4_freebsd32_getfsstat_args { char buf_l_[PADL_(struct ostatfs32 *)]; struct ostatfs32 * buf; char buf_r_[PADR_(struct ostatfs32 *)]; char bufsize_l_[PADL_(long)]; long bufsize; char bufsize_r_[PADR_(long)]; char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; }; struct freebsd4_freebsd32_statfs_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char buf_l_[PADL_(struct ostatfs32 *)]; struct ostatfs32 * buf; char buf_r_[PADR_(struct ostatfs32 *)]; }; struct freebsd4_freebsd32_fstatfs_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(struct ostatfs32 *)]; struct ostatfs32 * buf; char buf_r_[PADR_(struct ostatfs32 *)]; }; struct freebsd4_freebsd32_fhstatfs_args { char u_fhp_l_[PADL_(const struct fhandle *)]; const struct fhandle * u_fhp; char u_fhp_r_[PADR_(const struct fhandle *)]; char buf_l_[PADL_(struct ostatfs32 *)]; struct ostatfs32 * buf; char buf_r_[PADR_(struct ostatfs32 *)]; }; struct freebsd4_freebsd32_sendfile_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char s_l_[PADL_(int)]; int s; char s_r_[PADR_(int)]; 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 nbytes_l_[PADL_(size_t)]; size_t nbytes; char nbytes_r_[PADR_(size_t)]; char hdtr_l_[PADL_(struct sf_hdtr32 *)]; struct sf_hdtr32 * hdtr; char hdtr_r_[PADR_(struct sf_hdtr32 *)]; char sbytes_l_[PADL_(off_t *)]; off_t * sbytes; char sbytes_r_[PADR_(off_t *)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; }; struct freebsd4_freebsd32_sigaction_args { char sig_l_[PADL_(int)]; int sig; char sig_r_[PADR_(int)]; char act_l_[PADL_(const struct sigaction32 *)]; const struct sigaction32 * act; char act_r_[PADR_(const struct sigaction32 *)]; char oact_l_[PADL_(struct sigaction32 *)]; struct sigaction32 * oact; char oact_r_[PADR_(struct sigaction32 *)]; }; struct freebsd4_freebsd32_sigreturn_args { char sigcntxp_l_[PADL_(const struct freebsd4_ucontext32 *)]; const struct freebsd4_ucontext32 * sigcntxp; char sigcntxp_r_[PADR_(const struct freebsd4_ucontext32 *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int freebsd4_freebsd32_getfsstat(struct thread *, struct freebsd4_freebsd32_getfsstat_args *); int freebsd4_freebsd32_statfs(struct thread *, struct freebsd4_freebsd32_statfs_args *); int freebsd4_freebsd32_fstatfs(struct thread *, struct freebsd4_freebsd32_fstatfs_args *); int freebsd4_freebsd32_fhstatfs(struct thread *, struct freebsd4_freebsd32_fhstatfs_args *); int freebsd4_freebsd32_sendfile(struct thread *, struct freebsd4_freebsd32_sendfile_args *); int freebsd4_freebsd32_sigaction(struct thread *, struct freebsd4_freebsd32_sigaction_args *); int freebsd4_freebsd32_sigreturn(struct thread *, struct freebsd4_freebsd32_sigreturn_args *); #endif /* COMPAT_FREEBSD4 */ #ifdef COMPAT_FREEBSD6 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd6_freebsd32_pread_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(void *)]; void * buf; char buf_r_[PADR_(void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd6_freebsd32_pwrite_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(const void *)]; const void * buf; char buf_r_[PADR_(const void *)]; char nbyte_l_[PADL_(size_t)]; size_t nbyte; char nbyte_r_[PADR_(size_t)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd6_freebsd32_mmap_args { char addr_l_[PADL_(void *)]; void * addr; char addr_r_[PADR_(void *)]; char len_l_[PADL_(size_t)]; size_t len; char len_r_[PADR_(size_t)]; char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)]; char flags_l_[PADL_(int)]; int flags; char flags_r_[PADR_(int)]; char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; char pos1_l_[PADL_(uint32_t)]; uint32_t pos1; char pos1_r_[PADR_(uint32_t)]; char pos2_l_[PADL_(uint32_t)]; uint32_t pos2; char pos2_r_[PADR_(uint32_t)]; }; struct freebsd6_freebsd32_lseek_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 whence_l_[PADL_(int)]; int whence; char whence_r_[PADR_(int)]; }; struct freebsd6_freebsd32_truncate_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd6_freebsd32_ftruncate_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char pad_l_[PADL_(int)]; int pad; char pad_r_[PADR_(int)]; 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 freebsd6_freebsd32_aio_read_args { char aiocbp_l_[PADL_(struct oaiocb32 *)]; struct oaiocb32 * aiocbp; char aiocbp_r_[PADR_(struct oaiocb32 *)]; }; struct freebsd6_freebsd32_aio_write_args { char aiocbp_l_[PADL_(struct oaiocb32 *)]; struct oaiocb32 * aiocbp; char aiocbp_r_[PADR_(struct oaiocb32 *)]; }; struct freebsd6_freebsd32_lio_listio_args { char mode_l_[PADL_(int)]; int mode; char mode_r_[PADR_(int)]; char acb_list_l_[PADL_(uint32_t *)]; uint32_t * acb_list; char acb_list_r_[PADR_(uint32_t *)]; char nent_l_[PADL_(int)]; int nent; char nent_r_[PADR_(int)]; char sig_l_[PADL_(struct osigevent32 *)]; struct osigevent32 * sig; char sig_r_[PADR_(struct osigevent32 *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int freebsd6_freebsd32_pread(struct thread *, struct freebsd6_freebsd32_pread_args *); int freebsd6_freebsd32_pwrite(struct thread *, struct freebsd6_freebsd32_pwrite_args *); int freebsd6_freebsd32_mmap(struct thread *, struct freebsd6_freebsd32_mmap_args *); int freebsd6_freebsd32_lseek(struct thread *, struct freebsd6_freebsd32_lseek_args *); int freebsd6_freebsd32_truncate(struct thread *, struct freebsd6_freebsd32_truncate_args *); int freebsd6_freebsd32_ftruncate(struct thread *, struct freebsd6_freebsd32_ftruncate_args *); int freebsd6_freebsd32_aio_read(struct thread *, struct freebsd6_freebsd32_aio_read_args *); int freebsd6_freebsd32_aio_write(struct thread *, struct freebsd6_freebsd32_aio_write_args *); int freebsd6_freebsd32_lio_listio(struct thread *, struct freebsd6_freebsd32_lio_listio_args *); #endif /* COMPAT_FREEBSD6 */ #ifdef COMPAT_FREEBSD7 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd7_freebsd32___semctl_args { char semid_l_[PADL_(int)]; int semid; char semid_r_[PADR_(int)]; char semnum_l_[PADL_(int)]; int semnum; char semnum_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char arg_l_[PADL_(union semun_old32 *)]; union semun_old32 * arg; char arg_r_[PADR_(union semun_old32 *)]; }; struct freebsd7_freebsd32_msgctl_args { char msqid_l_[PADL_(int)]; int msqid; char msqid_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char buf_l_[PADL_(struct msqid_ds_old32 *)]; struct msqid_ds_old32 * buf; char buf_r_[PADR_(struct msqid_ds_old32 *)]; }; struct freebsd7_freebsd32_shmctl_args { char shmid_l_[PADL_(int)]; int shmid; char shmid_r_[PADR_(int)]; char cmd_l_[PADL_(int)]; int cmd; char cmd_r_[PADR_(int)]; char buf_l_[PADL_(struct shmid_ds_old32 *)]; struct shmid_ds_old32 * buf; char buf_r_[PADR_(struct shmid_ds_old32 *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int freebsd7_freebsd32___semctl(struct thread *, struct freebsd7_freebsd32___semctl_args *); int freebsd7_freebsd32_msgctl(struct thread *, struct freebsd7_freebsd32_msgctl_args *); int freebsd7_freebsd32_shmctl(struct thread *, struct freebsd7_freebsd32_shmctl_args *); #endif /* COMPAT_FREEBSD7 */ #ifdef COMPAT_FREEBSD10 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd10_freebsd32_umtx_lock_args { char umtx_l_[PADL_(struct umtx *)]; struct umtx * umtx; char umtx_r_[PADR_(struct umtx *)]; }; struct freebsd10_freebsd32_umtx_unlock_args { char umtx_l_[PADL_(struct umtx *)]; struct umtx * umtx; char umtx_r_[PADR_(struct umtx *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int freebsd10_freebsd32_pipe(struct thread *, struct freebsd10_freebsd32_pipe_args *); int freebsd10_freebsd32_umtx_lock(struct thread *, struct freebsd10_freebsd32_umtx_lock_args *); int freebsd10_freebsd32_umtx_unlock(struct thread *, struct freebsd10_freebsd32_umtx_unlock_args *); #endif /* COMPAT_FREEBSD10 */ #ifdef COMPAT_FREEBSD11 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif struct freebsd11_freebsd32_stat_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char ub_l_[PADL_(struct freebsd11_stat32 *)]; struct freebsd11_stat32 * ub; char ub_r_[PADR_(struct freebsd11_stat32 *)]; }; struct freebsd11_freebsd32_fstat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char ub_l_[PADL_(struct freebsd11_stat32 *)]; struct freebsd11_stat32 * ub; char ub_r_[PADR_(struct freebsd11_stat32 *)]; }; struct freebsd11_freebsd32_lstat_args { char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char ub_l_[PADL_(struct freebsd11_stat32 *)]; struct freebsd11_stat32 * ub; char ub_r_[PADR_(struct freebsd11_stat32 *)]; }; struct freebsd11_freebsd32_getdirentries_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; char count_l_[PADL_(u_int)]; u_int count; char count_r_[PADR_(u_int)]; char basep_l_[PADL_(int32_t *)]; int32_t * basep; char basep_r_[PADR_(int32_t *)]; }; struct freebsd11_freebsd32_getdents_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)]; char count_l_[PADL_(int)]; int count; char count_r_[PADR_(int)]; }; struct freebsd11_freebsd32_fhstat_args { char u_fhp_l_[PADL_(const struct fhandle *)]; const struct fhandle * u_fhp; char u_fhp_r_[PADR_(const struct fhandle *)]; char sb_l_[PADL_(struct freebsd11_stat32 *)]; struct freebsd11_stat32 * sb; char sb_r_[PADR_(struct freebsd11_stat32 *)]; }; struct freebsd11_freebsd32_kevent_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char changelist_l_[PADL_(const struct freebsd11_kevent32 *)]; const struct freebsd11_kevent32 * changelist; char changelist_r_[PADR_(const struct freebsd11_kevent32 *)]; char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)]; char eventlist_l_[PADL_(struct freebsd11_kevent32 *)]; struct freebsd11_kevent32 * eventlist; char eventlist_r_[PADR_(struct freebsd11_kevent32 *)]; char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)]; char timeout_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * timeout; char timeout_r_[PADR_(const struct timespec32 *)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif struct freebsd11_freebsd32_fstatat_args { char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)]; char path_l_[PADL_(const char *)]; const char * path; char path_r_[PADR_(const char *)]; char buf_l_[PADL_(struct freebsd11_stat32 *)]; struct freebsd11_stat32 * buf; char buf_r_[PADR_(struct freebsd11_stat32 *)]; char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; }; #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif int freebsd11_freebsd32_stat(struct thread *, struct freebsd11_freebsd32_stat_args *); int freebsd11_freebsd32_fstat(struct thread *, struct freebsd11_freebsd32_fstat_args *); int freebsd11_freebsd32_lstat(struct thread *, struct freebsd11_freebsd32_lstat_args *); int freebsd11_freebsd32_getdirentries(struct thread *, struct freebsd11_freebsd32_getdirentries_args *); int freebsd11_freebsd32_getdents(struct thread *, struct freebsd11_freebsd32_getdents_args *); int freebsd11_freebsd32_fhstat(struct thread *, struct freebsd11_freebsd32_fhstat_args *); int freebsd11_freebsd32_kevent(struct thread *, struct freebsd11_freebsd32_kevent_args *); int freebsd11_freebsd32_fstatat(struct thread *, struct freebsd11_freebsd32_fstatat_args *); #endif /* COMPAT_FREEBSD11 */ #ifdef COMPAT_FREEBSD12 #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #ifdef PAD64_REQUIRED #else #endif #endif /* COMPAT_FREEBSD12 */ #define FREEBSD32_SYS_AUE_freebsd32_wait4 AUE_WAIT4 #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_getfsstat AUE_GETFSSTAT #define FREEBSD32_SYS_AUE_ofreebsd32_lseek AUE_LSEEK #define FREEBSD32_SYS_AUE_freebsd32_ptrace AUE_PTRACE #define FREEBSD32_SYS_AUE_freebsd32_recvmsg AUE_RECVMSG #define FREEBSD32_SYS_AUE_freebsd32_sendmsg AUE_SENDMSG #define FREEBSD32_SYS_AUE_freebsd32_recvfrom AUE_RECVFROM #define FREEBSD32_SYS_AUE_ofreebsd32_stat AUE_STAT #define FREEBSD32_SYS_AUE_ofreebsd32_lstat AUE_LSTAT #define FREEBSD32_SYS_AUE_freebsd10_freebsd32_pipe AUE_PIPE #define FREEBSD32_SYS_AUE_ofreebsd32_sigaction AUE_SIGACTION #define FREEBSD32_SYS_AUE_ofreebsd32_sigprocmask AUE_SIGPROCMASK #define FREEBSD32_SYS_AUE_ofreebsd32_sigpending AUE_SIGPENDING #define FREEBSD32_SYS_AUE_freebsd32_sigaltstack AUE_SIGALTSTACK #define FREEBSD32_SYS_AUE_freebsd32_ioctl AUE_IOCTL #define FREEBSD32_SYS_AUE_freebsd32_execve AUE_EXECVE #define FREEBSD32_SYS_AUE_ofreebsd32_fstat AUE_FSTAT #define FREEBSD32_SYS_AUE_ofreebsd32_getpagesize AUE_NULL #define FREEBSD32_SYS_AUE_ofreebsd32_mmap AUE_MMAP #define FREEBSD32_SYS_AUE_freebsd32_mprotect AUE_MPROTECT #define FREEBSD32_SYS_AUE_freebsd32_setitimer AUE_SETITIMER #define FREEBSD32_SYS_AUE_freebsd32_getitimer AUE_GETITIMER #define FREEBSD32_SYS_AUE_freebsd32_fcntl AUE_FCNTL #define FREEBSD32_SYS_AUE_freebsd32_select AUE_SELECT #define FREEBSD32_SYS_AUE_ofreebsd32_sigreturn AUE_SIGRETURN #define FREEBSD32_SYS_AUE_ofreebsd32_sigvec AUE_O_SIGVEC #define FREEBSD32_SYS_AUE_ofreebsd32_sigblock AUE_O_SIGBLOCK #define FREEBSD32_SYS_AUE_ofreebsd32_sigsetmask AUE_O_SIGSETMASK #define FREEBSD32_SYS_AUE_ofreebsd32_sigsuspend AUE_SIGSUSPEND #define FREEBSD32_SYS_AUE_ofreebsd32_sigstack AUE_O_SIGSTACK #define FREEBSD32_SYS_AUE_freebsd32_gettimeofday AUE_GETTIMEOFDAY #define FREEBSD32_SYS_AUE_freebsd32_getrusage AUE_GETRUSAGE #define FREEBSD32_SYS_AUE_freebsd32_readv AUE_READV #define FREEBSD32_SYS_AUE_freebsd32_writev AUE_WRITEV #define FREEBSD32_SYS_AUE_freebsd32_settimeofday AUE_SETTIMEOFDAY #define FREEBSD32_SYS_AUE_freebsd32_utimes AUE_UTIMES #define FREEBSD32_SYS_AUE_freebsd32_adjtime AUE_ADJTIME #define FREEBSD32_SYS_AUE_ofreebsd32_getdirentries AUE_GETDIRENTRIES #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_statfs AUE_STATFS #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_fstatfs AUE_FSTATFS #define FREEBSD32_SYS_AUE_freebsd32_sysarch AUE_SYSARCH #define FREEBSD32_SYS_AUE_freebsd32_semsys AUE_SEMSYS #define FREEBSD32_SYS_AUE_freebsd32_msgsys AUE_MSGSYS #define FREEBSD32_SYS_AUE_freebsd32_shmsys AUE_SHMSYS #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_pread AUE_PREAD #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_pwrite AUE_PWRITE #define FREEBSD32_SYS_AUE_freebsd32_ntp_adjtime AUE_NTP_ADJTIME #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_stat AUE_STAT #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_fstat AUE_FSTAT #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_lstat AUE_LSTAT #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_getdirentries AUE_GETDIRENTRIES #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_mmap AUE_MMAP #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_lseek AUE_LSEEK #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_truncate AUE_TRUNCATE #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_ftruncate AUE_FTRUNCATE #define FREEBSD32_SYS_AUE_freebsd32___sysctl AUE_SYSCTL #define FREEBSD32_SYS_AUE_freebsd32_futimes AUE_FUTIMES #define FREEBSD32_SYS_AUE_freebsd7_freebsd32___semctl AUE_SEMCTL #define FREEBSD32_SYS_AUE_freebsd7_freebsd32_msgctl AUE_MSGCTL #define FREEBSD32_SYS_AUE_freebsd32_msgsnd AUE_MSGSND #define FREEBSD32_SYS_AUE_freebsd32_msgrcv AUE_MSGRCV #define FREEBSD32_SYS_AUE_freebsd7_freebsd32_shmctl AUE_SHMCTL #define FREEBSD32_SYS_AUE_freebsd32_clock_gettime AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_clock_settime AUE_CLOCK_SETTIME #define FREEBSD32_SYS_AUE_freebsd32_clock_getres AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_ktimer_create AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_ktimer_settime AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_ktimer_gettime AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_nanosleep AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_clock_nanosleep AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_clock_getcpuclockid2 AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_aio_read AUE_AIO_READ #define FREEBSD32_SYS_AUE_freebsd32_aio_write AUE_AIO_WRITE #define FREEBSD32_SYS_AUE_freebsd32_lio_listio AUE_LIO_LISTIO #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_getdents AUE_O_GETDENTS #define FREEBSD32_SYS_AUE_freebsd32_lutimes AUE_LUTIMES #define FREEBSD32_SYS_AUE_freebsd32_preadv AUE_PREADV #define FREEBSD32_SYS_AUE_freebsd32_pwritev AUE_PWRITEV #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_fhstatfs AUE_FHSTATFS #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_fhstat AUE_FHSTAT #define FREEBSD32_SYS_AUE_freebsd32_modstat AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_kldstat AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_aio_return AUE_AIO_RETURN #define FREEBSD32_SYS_AUE_freebsd32_aio_suspend AUE_AIO_SUSPEND #define FREEBSD32_SYS_AUE_freebsd32_aio_error AUE_AIO_ERROR #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_aio_read AUE_AIO_READ #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_aio_write AUE_AIO_WRITE #define FREEBSD32_SYS_AUE_freebsd6_freebsd32_lio_listio AUE_LIO_LISTIO #define FREEBSD32_SYS_AUE_freebsd32_sched_rr_get_interval AUE_NULL #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_sendfile AUE_SENDFILE #define FREEBSD32_SYS_AUE_freebsd32_jail AUE_JAIL #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_sigaction AUE_SIGACTION #define FREEBSD32_SYS_AUE_freebsd4_freebsd32_sigreturn AUE_SIGRETURN #define FREEBSD32_SYS_AUE_freebsd32_sigtimedwait AUE_SIGWAIT #define FREEBSD32_SYS_AUE_freebsd32_sigwaitinfo AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_aio_waitcomplete AUE_AIO_WAITCOMPLETE #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_kevent AUE_KEVENT #define FREEBSD32_SYS_AUE_freebsd32_nmount AUE_NMOUNT #define FREEBSD32_SYS_AUE_freebsd32_sendfile AUE_SENDFILE #define FREEBSD32_SYS_AUE_freebsd32_ksem_init AUE_SEMINIT #define FREEBSD32_SYS_AUE_freebsd32_ksem_open AUE_SEMOPEN #define FREEBSD32_SYS_AUE_freebsd32_sigaction AUE_SIGACTION #define FREEBSD32_SYS_AUE_freebsd32_sigreturn AUE_SIGRETURN #define FREEBSD32_SYS_AUE_freebsd32_getcontext AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_setcontext AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_swapcontext AUE_NULL #define FREEBSD32_SYS_AUE_freebsd10_freebsd32_umtx_lock AUE_NULL #define FREEBSD32_SYS_AUE_freebsd10_freebsd32_umtx_unlock AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_ksem_timedwait AUE_SEMWAIT #define FREEBSD32_SYS_AUE_freebsd32_thr_suspend AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32__umtx_op AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_thr_new AUE_THR_NEW #define FREEBSD32_SYS_AUE_freebsd32_sigqueue AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_kmq_open AUE_MQ_OPEN #define FREEBSD32_SYS_AUE_freebsd32_kmq_setattr AUE_MQ_SETATTR #define FREEBSD32_SYS_AUE_freebsd32_kmq_timedreceive AUE_MQ_TIMEDRECEIVE #define FREEBSD32_SYS_AUE_freebsd32_kmq_timedsend AUE_MQ_TIMEDSEND #define FREEBSD32_SYS_AUE_freebsd32_kmq_notify AUE_MQ_NOTIFY #define FREEBSD32_SYS_AUE_freebsd32_aio_fsync AUE_AIO_FSYNC #define FREEBSD32_SYS_AUE_freebsd32_pread AUE_PREAD #define FREEBSD32_SYS_AUE_freebsd32_pwrite AUE_PWRITE #define FREEBSD32_SYS_AUE_freebsd32_mmap AUE_MMAP #define FREEBSD32_SYS_AUE_freebsd32_lseek AUE_LSEEK #define FREEBSD32_SYS_AUE_freebsd32_truncate AUE_TRUNCATE #define FREEBSD32_SYS_AUE_freebsd32_ftruncate AUE_FTRUNCATE #define FREEBSD32_SYS_AUE_freebsd32_pread AUE_PREAD #define FREEBSD32_SYS_AUE_freebsd32_pwrite AUE_PWRITE #define FREEBSD32_SYS_AUE_freebsd32_mmap AUE_MMAP #define FREEBSD32_SYS_AUE_freebsd32_lseek AUE_LSEEK #define FREEBSD32_SYS_AUE_freebsd32_truncate AUE_TRUNCATE #define FREEBSD32_SYS_AUE_freebsd32_ftruncate AUE_FTRUNCATE #define FREEBSD32_SYS_AUE_freebsd32_cpuset_setid AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_cpuset_setid AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_cpuset_getid AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_cpuset_getaffinity AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_cpuset_setaffinity AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_fexecve AUE_FEXECVE #define FREEBSD32_SYS_AUE_freebsd11_freebsd32_fstatat AUE_FSTATAT #define FREEBSD32_SYS_AUE_freebsd32_futimesat AUE_FUTIMESAT #define FREEBSD32_SYS_AUE_freebsd32_jail_get AUE_JAIL_GET #define FREEBSD32_SYS_AUE_freebsd32_jail_set AUE_JAIL_SET #define FREEBSD32_SYS_AUE_freebsd32___semctl AUE_SEMCTL #define FREEBSD32_SYS_AUE_freebsd32_msgctl AUE_MSGCTL #define FREEBSD32_SYS_AUE_freebsd32_shmctl AUE_SHMCTL #define FREEBSD32_SYS_AUE_freebsd32_pselect AUE_SELECT #define FREEBSD32_SYS_AUE_freebsd32_posix_fallocate AUE_POSIX_FALLOCATE #define FREEBSD32_SYS_AUE_freebsd32_posix_fadvise AUE_POSIX_FADVISE #define FREEBSD32_SYS_AUE_freebsd32_wait6 AUE_WAIT6 #define FREEBSD32_SYS_AUE_freebsd32_posix_fallocate AUE_POSIX_FALLOCATE #define FREEBSD32_SYS_AUE_freebsd32_posix_fadvise AUE_POSIX_FADVISE #define FREEBSD32_SYS_AUE_freebsd32_wait6 AUE_WAIT6 #define FREEBSD32_SYS_AUE_freebsd32_cap_ioctls_limit AUE_CAP_IOCTLS_LIMIT #define FREEBSD32_SYS_AUE_freebsd32_cap_ioctls_get AUE_CAP_IOCTLS_GET #define FREEBSD32_SYS_AUE_freebsd32_aio_mlock AUE_AIO_MLOCK #define FREEBSD32_SYS_AUE_freebsd32_procctl AUE_PROCCTL #define FREEBSD32_SYS_AUE_freebsd32_procctl AUE_PROCCTL #define FREEBSD32_SYS_AUE_freebsd32_ppoll AUE_POLL #define FREEBSD32_SYS_AUE_freebsd32_futimens AUE_FUTIMES #define FREEBSD32_SYS_AUE_freebsd32_utimensat AUE_FUTIMESAT #define FREEBSD32_SYS_AUE_freebsd32_fstat AUE_FSTAT #define FREEBSD32_SYS_AUE_freebsd32_fstatat AUE_FSTATAT #define FREEBSD32_SYS_AUE_freebsd32_fhstat AUE_FHSTAT #define FREEBSD32_SYS_AUE_freebsd32_mknodat AUE_MKNODAT #define FREEBSD32_SYS_AUE_freebsd32_mknodat AUE_MKNODAT #define FREEBSD32_SYS_AUE_freebsd32_kevent AUE_KEVENT #define FREEBSD32_SYS_AUE_freebsd32_cpuset_getdomain AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32_cpuset_setdomain AUE_NULL #define FREEBSD32_SYS_AUE_freebsd32___sysctlbyname AUE_SYSCTL #define FREEBSD32_SYS_AUE_freebsd32_aio_writev AUE_AIO_WRITEV #define FREEBSD32_SYS_AUE_freebsd32_aio_readv AUE_AIO_READV #define FREEBSD32_SYS_AUE_freebsd32_fspacectl AUE_FSPACECTL #undef PAD_ #undef PADL_ #undef PADR_ #endif /* !_FREEBSD32_SYSPROTO_H_ */ diff --git a/sys/compat/freebsd32/freebsd32_systrace_args.c b/sys/compat/freebsd32/freebsd32_systrace_args.c index 3a5bd3b9a9a8..7544c55bd499 100644 --- a/sys/compat/freebsd32/freebsd32_systrace_args.c +++ b/sys/compat/freebsd32/freebsd32_systrace_args.c @@ -1,11180 +1,11180 @@ /* * 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) { #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif /* nosys */ case 0: { *n_args = 0; break; } /* sys_exit */ case 1: { struct sys_exit_args *p = params; iarg[0] = p->rval; /* int */ *n_args = 1; break; } /* 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; /* void * */ uarg[2] = p->nbyte; /* size_t */ *n_args = 3; break; } /* write */ case 4: { struct write_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* const void * */ uarg[2] = p->nbyte; /* size_t */ *n_args = 3; break; } /* open */ case 5: { struct open_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->flags; /* int */ iarg[2] = p->mode; /* mode_t */ *n_args = 3; break; } /* close */ case 6: { struct close_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* freebsd32_wait4 */ case 7: { struct freebsd32_wait4_args *p = params; iarg[0] = p->pid; /* int */ uarg[1] = (intptr_t)p->status; /* int * */ iarg[2] = p->options; /* int */ uarg[3] = (intptr_t)p->rusage; /* struct rusage32 * */ *n_args = 4; break; } /* link */ case 9: { struct link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->link; /* const char * */ *n_args = 2; break; } /* unlink */ case 10: { struct unlink_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* chdir */ case 12: { struct chdir_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* fchdir */ case 13: { struct fchdir_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* chmod */ case 15: { struct chmod_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->mode; /* mode_t */ *n_args = 2; break; } /* chown */ case 16: { struct chown_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->uid; /* int */ iarg[2] = p->gid; /* int */ *n_args = 3; break; } /* break */ case 17: { struct break_args *p = params; uarg[0] = (intptr_t)p->nsize; /* char * */ *n_args = 1; break; } /* getpid */ case 20: { *n_args = 0; break; } /* mount */ case 21: { struct mount_args *p = params; uarg[0] = (intptr_t)p->type; /* const char * */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->flags; /* int */ uarg[3] = (intptr_t)p->data; /* void * */ *n_args = 4; break; } /* unmount */ case 22: { struct unmount_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->flags; /* int */ *n_args = 2; break; } /* setuid */ case 23: { struct setuid_args *p = params; uarg[0] = p->uid; /* uid_t */ *n_args = 1; break; } /* getuid */ case 24: { *n_args = 0; break; } /* geteuid */ case 25: { *n_args = 0; break; } /* freebsd32_ptrace */ case 26: { struct freebsd32_ptrace_args *p = params; iarg[0] = p->req; /* int */ iarg[1] = p->pid; /* pid_t */ uarg[2] = (intptr_t)p->addr; /* caddr_t */ iarg[3] = p->data; /* int */ *n_args = 4; break; } /* freebsd32_recvmsg */ case 27: { struct freebsd32_recvmsg_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->msg; /* struct msghdr32 * */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* freebsd32_sendmsg */ case 28: { struct freebsd32_sendmsg_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->msg; /* const struct msghdr32 * */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* freebsd32_recvfrom */ case 29: { struct freebsd32_recvfrom_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->buf; /* void * */ uarg[2] = p->len; /* size_t */ iarg[3] = p->flags; /* int */ uarg[4] = (intptr_t)p->from; /* struct sockaddr * */ uarg[5] = p->fromlenaddr; /* uint32_t */ *n_args = 6; break; } /* accept */ case 30: { struct accept_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->name; /* struct sockaddr * */ uarg[2] = (intptr_t)p->anamelen; /* int * */ *n_args = 3; break; } /* getpeername */ case 31: { struct getpeername_args *p = params; iarg[0] = p->fdes; /* int */ uarg[1] = (intptr_t)p->asa; /* struct sockaddr * */ uarg[2] = (intptr_t)p->alen; /* int * */ *n_args = 3; break; } /* getsockname */ case 32: { struct getsockname_args *p = params; iarg[0] = p->fdes; /* int */ uarg[1] = (intptr_t)p->asa; /* struct sockaddr * */ uarg[2] = (intptr_t)p->alen; /* int * */ *n_args = 3; break; } /* access */ case 33: { struct access_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->amode; /* int */ *n_args = 2; break; } /* chflags */ case 34: { struct chflags_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = p->flags; /* u_long */ *n_args = 2; break; } /* fchflags */ case 35: { struct fchflags_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->flags; /* u_long */ *n_args = 2; break; } /* sync */ case 36: { *n_args = 0; break; } /* kill */ case 37: { struct kill_args *p = params; iarg[0] = p->pid; /* int */ iarg[1] = p->signum; /* int */ *n_args = 2; break; } /* getppid */ case 39: { *n_args = 0; break; } /* dup */ case 41: { struct dup_args *p = params; uarg[0] = p->fd; /* u_int */ *n_args = 1; break; } /* getegid */ case 43: { *n_args = 0; break; } /* profil */ case 44: { struct profil_args *p = params; uarg[0] = (intptr_t)p->samples; /* char * */ uarg[1] = p->size; /* size_t */ uarg[2] = p->offset; /* size_t */ uarg[3] = p->scale; /* u_int */ *n_args = 4; break; } /* ktrace */ case 45: { struct ktrace_args *p = params; uarg[0] = (intptr_t)p->fname; /* const char * */ iarg[1] = p->ops; /* int */ iarg[2] = p->facs; /* int */ iarg[3] = p->pid; /* int */ *n_args = 4; break; } /* getgid */ case 47: { *n_args = 0; break; } /* getlogin */ case 49: { struct getlogin_args *p = params; uarg[0] = (intptr_t)p->namebuf; /* char * */ uarg[1] = p->namelen; /* u_int */ *n_args = 2; break; } /* setlogin */ case 50: { struct setlogin_args *p = params; uarg[0] = (intptr_t)p->namebuf; /* const char * */ *n_args = 1; break; } /* acct */ case 51: { struct acct_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* freebsd32_sigaltstack */ case 53: { struct freebsd32_sigaltstack_args *p = params; uarg[0] = (intptr_t)p->ss; /* const struct sigaltstack32 * */ uarg[1] = (intptr_t)p->oss; /* struct sigaltstack32 * */ *n_args = 2; break; } /* freebsd32_ioctl */ case 54: { struct freebsd32_ioctl_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->com; /* u_long */ uarg[2] = (intptr_t)p->data; /* char * */ *n_args = 3; break; } /* reboot */ case 55: { struct reboot_args *p = params; iarg[0] = p->opt; /* int */ *n_args = 1; break; } /* revoke */ case 56: { struct revoke_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* symlink */ case 57: { struct symlink_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->link; /* const char * */ *n_args = 2; break; } /* readlink */ case 58: { struct readlink_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->buf; /* char * */ uarg[2] = p->count; /* size_t */ *n_args = 3; break; } /* freebsd32_execve */ case 59: { struct freebsd32_execve_args *p = params; uarg[0] = (intptr_t)p->fname; /* const char * */ uarg[1] = (intptr_t)p->argv; /* uint32_t * */ uarg[2] = (intptr_t)p->envv; /* uint32_t * */ *n_args = 3; break; } /* umask */ case 60: { struct umask_args *p = params; iarg[0] = p->newmask; /* mode_t */ *n_args = 1; break; } /* chroot */ case 61: { struct chroot_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* msync */ case 65: { struct msync_args *p = params; uarg[0] = (intptr_t)p->addr; /* void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* vfork */ case 66: { *n_args = 0; break; } /* sbrk */ case 69: { struct sbrk_args *p = params; iarg[0] = p->incr; /* int */ *n_args = 1; break; } /* sstk */ case 70: { struct sstk_args *p = params; iarg[0] = p->incr; /* int */ *n_args = 1; break; } /* munmap */ case 73: { struct munmap_args *p = params; uarg[0] = (intptr_t)p->addr; /* void * */ uarg[1] = p->len; /* size_t */ *n_args = 2; break; } /* freebsd32_mprotect */ case 74: { struct freebsd32_mprotect_args *p = params; uarg[0] = (intptr_t)p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->prot; /* int */ *n_args = 3; break; } /* madvise */ case 75: { 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; } /* mincore */ case 78: { struct mincore_args *p = params; uarg[0] = (intptr_t)p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ uarg[2] = (intptr_t)p->vec; /* char * */ *n_args = 3; break; } /* getgroups */ case 79: { struct getgroups_args *p = params; uarg[0] = p->gidsetsize; /* u_int */ uarg[1] = (intptr_t)p->gidset; /* gid_t * */ *n_args = 2; break; } /* setgroups */ case 80: { struct setgroups_args *p = params; uarg[0] = p->gidsetsize; /* u_int */ uarg[1] = (intptr_t)p->gidset; /* const gid_t * */ *n_args = 2; break; } /* getpgrp */ case 81: { *n_args = 0; break; } /* setpgid */ case 82: { struct setpgid_args *p = params; iarg[0] = p->pid; /* int */ iarg[1] = p->pgid; /* int */ *n_args = 2; break; } /* freebsd32_setitimer */ case 83: { struct freebsd32_setitimer_args *p = params; iarg[0] = p->which; /* int */ uarg[1] = (intptr_t)p->itv; /* const struct itimerval32 * */ uarg[2] = (intptr_t)p->oitv; /* struct itimerval32 * */ *n_args = 3; break; } /* swapon */ case 85: { struct swapon_args *p = params; uarg[0] = (intptr_t)p->name; /* const char * */ *n_args = 1; break; } /* freebsd32_getitimer */ case 86: { struct freebsd32_getitimer_args *p = params; iarg[0] = p->which; /* int */ uarg[1] = (intptr_t)p->itv; /* struct itimerval32 * */ *n_args = 2; break; } /* getdtablesize */ case 89: { *n_args = 0; break; } /* dup2 */ case 90: { struct dup2_args *p = params; uarg[0] = p->from; /* u_int */ uarg[1] = p->to; /* u_int */ *n_args = 2; break; } /* freebsd32_fcntl */ case 92: { struct freebsd32_fcntl_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->cmd; /* int */ iarg[2] = p->arg; /* int */ *n_args = 3; break; } /* freebsd32_select */ case 93: { struct freebsd32_select_args *p = params; iarg[0] = p->nd; /* int */ uarg[1] = (intptr_t)p->in; /* fd_set * */ uarg[2] = (intptr_t)p->ou; /* fd_set * */ uarg[3] = (intptr_t)p->ex; /* fd_set * */ uarg[4] = (intptr_t)p->tv; /* struct timeval32 * */ *n_args = 5; break; } /* fsync */ case 95: { struct fsync_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* setpriority */ case 96: { struct setpriority_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->who; /* int */ iarg[2] = p->prio; /* int */ *n_args = 3; break; } /* socket */ case 97: { struct socket_args *p = params; iarg[0] = p->domain; /* int */ iarg[1] = p->type; /* int */ iarg[2] = p->protocol; /* int */ *n_args = 3; break; } /* connect */ case 98: { struct connect_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->name; /* const struct sockaddr * */ iarg[2] = p->namelen; /* int */ *n_args = 3; break; } /* getpriority */ case 100: { struct getpriority_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->who; /* int */ *n_args = 2; break; } /* bind */ case 104: { struct bind_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->name; /* const struct sockaddr * */ iarg[2] = p->namelen; /* int */ *n_args = 3; break; } /* setsockopt */ case 105: { struct setsockopt_args *p = params; iarg[0] = p->s; /* int */ iarg[1] = p->level; /* int */ iarg[2] = p->name; /* int */ uarg[3] = (intptr_t)p->val; /* const void * */ iarg[4] = p->valsize; /* int */ *n_args = 5; break; } /* listen */ case 106: { struct listen_args *p = params; iarg[0] = p->s; /* int */ iarg[1] = p->backlog; /* int */ *n_args = 2; break; } /* freebsd32_gettimeofday */ case 116: { struct freebsd32_gettimeofday_args *p = params; uarg[0] = (intptr_t)p->tp; /* struct timeval32 * */ uarg[1] = (intptr_t)p->tzp; /* struct timezone * */ *n_args = 2; break; } /* freebsd32_getrusage */ case 117: { struct freebsd32_getrusage_args *p = params; iarg[0] = p->who; /* int */ uarg[1] = (intptr_t)p->rusage; /* struct rusage32 * */ *n_args = 2; break; } /* getsockopt */ case 118: { struct getsockopt_args *p = params; iarg[0] = p->s; /* int */ iarg[1] = p->level; /* int */ iarg[2] = p->name; /* int */ uarg[3] = (intptr_t)p->val; /* void * */ uarg[4] = (intptr_t)p->avalsize; /* int * */ *n_args = 5; break; } /* freebsd32_readv */ case 120: { struct freebsd32_readv_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[2] = p->iovcnt; /* u_int */ *n_args = 3; break; } /* freebsd32_writev */ case 121: { struct freebsd32_writev_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[2] = p->iovcnt; /* u_int */ *n_args = 3; break; } /* freebsd32_settimeofday */ case 122: { struct freebsd32_settimeofday_args *p = params; uarg[0] = (intptr_t)p->tv; /* const struct timeval32 * */ uarg[1] = (intptr_t)p->tzp; /* const struct timezone * */ *n_args = 2; break; } /* fchown */ case 123: { struct fchown_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->uid; /* int */ iarg[2] = p->gid; /* int */ *n_args = 3; break; } /* fchmod */ case 124: { struct fchmod_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->mode; /* mode_t */ *n_args = 2; break; } /* setreuid */ case 126: { struct setreuid_args *p = params; iarg[0] = p->ruid; /* int */ iarg[1] = p->euid; /* int */ *n_args = 2; break; } /* setregid */ case 127: { struct setregid_args *p = params; iarg[0] = p->rgid; /* int */ iarg[1] = p->egid; /* int */ *n_args = 2; break; } /* rename */ case 128: { struct rename_args *p = params; uarg[0] = (intptr_t)p->from; /* const char * */ uarg[1] = (intptr_t)p->to; /* const char * */ *n_args = 2; break; } /* flock */ case 131: { struct flock_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->how; /* int */ *n_args = 2; break; } /* mkfifo */ case 132: { struct mkfifo_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->mode; /* mode_t */ *n_args = 2; break; } /* sendto */ case 133: { struct sendto_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->buf; /* const void * */ uarg[2] = p->len; /* size_t */ iarg[3] = p->flags; /* int */ uarg[4] = (intptr_t)p->to; /* const struct sockaddr * */ iarg[5] = p->tolen; /* int */ *n_args = 6; break; } /* shutdown */ case 134: { struct shutdown_args *p = params; iarg[0] = p->s; /* int */ iarg[1] = p->how; /* int */ *n_args = 2; break; } /* socketpair */ case 135: { struct socketpair_args *p = params; iarg[0] = p->domain; /* int */ iarg[1] = p->type; /* int */ iarg[2] = p->protocol; /* int */ uarg[3] = (intptr_t)p->rsv; /* int * */ *n_args = 4; break; } /* mkdir */ case 136: { struct mkdir_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->mode; /* mode_t */ *n_args = 2; break; } /* rmdir */ case 137: { struct rmdir_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* freebsd32_utimes */ case 138: { struct freebsd32_utimes_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->tptr; /* const struct timeval32 * */ *n_args = 2; break; } /* freebsd32_adjtime */ case 140: { struct freebsd32_adjtime_args *p = params; uarg[0] = (intptr_t)p->delta; /* const struct timeval32 * */ uarg[1] = (intptr_t)p->olddelta; /* struct timeval32 * */ *n_args = 2; break; } /* setsid */ case 147: { *n_args = 0; break; } /* quotactl */ case 148: { struct quotactl_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->cmd; /* int */ iarg[2] = p->uid; /* int */ uarg[3] = (intptr_t)p->arg; /* void * */ *n_args = 4; break; } /* getfh */ case 161: { struct getfh_args *p = params; uarg[0] = (intptr_t)p->fname; /* const char * */ uarg[1] = (intptr_t)p->fhp; /* struct fhandle * */ *n_args = 2; break; } /* freebsd32_sysarch */ case 165: { struct freebsd32_sysarch_args *p = params; iarg[0] = p->op; /* int */ uarg[1] = (intptr_t)p->parms; /* char * */ *n_args = 2; break; } /* rtprio */ case 166: { struct rtprio_args *p = params; iarg[0] = p->function; /* int */ iarg[1] = p->pid; /* pid_t */ uarg[2] = (intptr_t)p->rtp; /* struct rtprio * */ *n_args = 3; break; } /* freebsd32_semsys */ case 169: { struct freebsd32_semsys_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->a2; /* int */ iarg[2] = p->a3; /* int */ iarg[3] = p->a4; /* int */ iarg[4] = p->a5; /* int */ *n_args = 5; break; } /* freebsd32_msgsys */ case 170: { struct freebsd32_msgsys_args *p = params; iarg[0] = p->which; /* int */ iarg[1] = p->a2; /* int */ iarg[2] = p->a3; /* int */ iarg[3] = p->a4; /* int */ iarg[4] = p->a5; /* int */ iarg[5] = p->a6; /* int */ *n_args = 6; break; } /* freebsd32_shmsys */ case 171: { struct freebsd32_shmsys_args *p = params; uarg[0] = p->which; /* uint32_t */ uarg[1] = p->a2; /* uint32_t */ uarg[2] = p->a3; /* uint32_t */ uarg[3] = p->a4; /* uint32_t */ *n_args = 4; break; } /* freebsd32_ntp_adjtime */ case 176: { struct freebsd32_ntp_adjtime_args *p = params; uarg[0] = (intptr_t)p->tp; /* struct timex32 * */ *n_args = 1; break; } /* setgid */ case 181: { struct setgid_args *p = params; iarg[0] = p->gid; /* gid_t */ *n_args = 1; break; } /* setegid */ case 182: { struct setegid_args *p = params; iarg[0] = p->egid; /* gid_t */ *n_args = 1; break; } /* seteuid */ case 183: { struct seteuid_args *p = params; uarg[0] = p->euid; /* uid_t */ *n_args = 1; break; } /* pathconf */ case 191: { struct pathconf_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->name; /* int */ *n_args = 2; break; } /* fpathconf */ case 192: { struct fpathconf_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->name; /* int */ *n_args = 2; break; } /* getrlimit */ case 194: { struct __getrlimit_args *p = params; uarg[0] = p->which; /* u_int */ uarg[1] = (intptr_t)p->rlp; /* struct rlimit * */ *n_args = 2; break; } /* setrlimit */ case 195: { struct __setrlimit_args *p = params; uarg[0] = p->which; /* u_int */ uarg[1] = (intptr_t)p->rlp; /* struct rlimit * */ *n_args = 2; break; } /* nosys */ case 198: { *n_args = 0; break; } /* freebsd32___sysctl */ case 202: { struct freebsd32___sysctl_args *p = params; uarg[0] = (intptr_t)p->name; /* int * */ uarg[1] = p->namelen; /* u_int */ uarg[2] = (intptr_t)p->old; /* void * */ uarg[3] = (intptr_t)p->oldlenp; /* uint32_t * */ uarg[4] = (intptr_t)p->new; /* const void * */ uarg[5] = p->newlen; /* size_t */ *n_args = 6; break; } /* mlock */ case 203: { 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 204: { struct munlock_args *p = params; uarg[0] = (intptr_t)p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ *n_args = 2; break; } /* undelete */ case 205: { struct undelete_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* freebsd32_futimes */ case 206: { struct freebsd32_futimes_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->tptr; /* const struct timeval32 * */ *n_args = 2; break; } /* getpgid */ case 207: { struct getpgid_args *p = params; iarg[0] = p->pid; /* pid_t */ *n_args = 1; break; } /* poll */ case 209: { struct poll_args *p = params; uarg[0] = (intptr_t)p->fds; /* struct pollfd * */ uarg[1] = p->nfds; /* u_int */ iarg[2] = p->timeout; /* int */ *n_args = 3; break; } /* lkmnosys */ case 210: { *n_args = 0; break; } /* lkmnosys */ case 211: { *n_args = 0; break; } /* lkmnosys */ case 212: { *n_args = 0; break; } /* lkmnosys */ case 213: { *n_args = 0; break; } /* lkmnosys */ case 214: { *n_args = 0; break; } /* lkmnosys */ case 215: { *n_args = 0; break; } /* lkmnosys */ case 216: { *n_args = 0; break; } /* lkmnosys */ case 217: { *n_args = 0; break; } /* lkmnosys */ case 218: { *n_args = 0; break; } /* lkmnosys */ case 219: { *n_args = 0; break; } /* semget */ case 221: { struct semget_args *p = params; iarg[0] = p->key; /* key_t */ iarg[1] = p->nsems; /* int */ iarg[2] = p->semflg; /* int */ *n_args = 3; break; } /* semop */ case 222: { struct semop_args *p = params; iarg[0] = p->semid; /* int */ uarg[1] = (intptr_t)p->sops; /* struct sembuf * */ uarg[2] = p->nsops; /* size_t */ *n_args = 3; break; } /* msgget */ case 225: { struct msgget_args *p = params; iarg[0] = p->key; /* key_t */ iarg[1] = p->msgflg; /* int */ *n_args = 2; break; } /* freebsd32_msgsnd */ case 226: { struct freebsd32_msgsnd_args *p = params; iarg[0] = p->msqid; /* int */ uarg[1] = (intptr_t)p->msgp; /* const void * */ uarg[2] = p->msgsz; /* size_t */ iarg[3] = p->msgflg; /* int */ *n_args = 4; break; } /* freebsd32_msgrcv */ case 227: { struct freebsd32_msgrcv_args *p = params; iarg[0] = p->msqid; /* int */ uarg[1] = (intptr_t)p->msgp; /* void * */ uarg[2] = p->msgsz; /* size_t */ iarg[3] = p->msgtyp; /* long */ iarg[4] = p->msgflg; /* int */ *n_args = 5; break; } /* shmat */ case 228: { struct shmat_args *p = params; iarg[0] = p->shmid; /* int */ uarg[1] = (intptr_t)p->shmaddr; /* const void * */ iarg[2] = p->shmflg; /* int */ *n_args = 3; break; } /* shmdt */ case 230: { struct shmdt_args *p = params; uarg[0] = (intptr_t)p->shmaddr; /* const void * */ *n_args = 1; break; } /* shmget */ case 231: { struct shmget_args *p = params; iarg[0] = p->key; /* key_t */ uarg[1] = p->size; /* size_t */ iarg[2] = p->shmflg; /* int */ *n_args = 3; break; } /* freebsd32_clock_gettime */ case 232: { struct freebsd32_clock_gettime_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ uarg[1] = (intptr_t)p->tp; /* struct timespec32 * */ *n_args = 2; break; } /* freebsd32_clock_settime */ case 233: { struct freebsd32_clock_settime_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ uarg[1] = (intptr_t)p->tp; /* const struct timespec32 * */ *n_args = 2; break; } /* freebsd32_clock_getres */ case 234: { struct freebsd32_clock_getres_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ uarg[1] = (intptr_t)p->tp; /* struct timespec32 * */ *n_args = 2; break; } /* freebsd32_ktimer_create */ case 235: { struct freebsd32_ktimer_create_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ uarg[1] = (intptr_t)p->evp; /* struct sigevent32 * */ uarg[2] = (intptr_t)p->timerid; /* int * */ *n_args = 3; break; } /* ktimer_delete */ case 236: { struct ktimer_delete_args *p = params; iarg[0] = p->timerid; /* int */ *n_args = 1; break; } /* freebsd32_ktimer_settime */ case 237: { struct freebsd32_ktimer_settime_args *p = params; iarg[0] = p->timerid; /* int */ iarg[1] = p->flags; /* int */ uarg[2] = (intptr_t)p->value; /* const struct itimerspec32 * */ uarg[3] = (intptr_t)p->ovalue; /* struct itimerspec32 * */ *n_args = 4; break; } /* freebsd32_ktimer_gettime */ case 238: { struct freebsd32_ktimer_gettime_args *p = params; iarg[0] = p->timerid; /* int */ uarg[1] = (intptr_t)p->value; /* struct itimerspec32 * */ *n_args = 2; break; } /* ktimer_getoverrun */ case 239: { struct ktimer_getoverrun_args *p = params; iarg[0] = p->timerid; /* int */ *n_args = 1; break; } /* freebsd32_nanosleep */ case 240: { struct freebsd32_nanosleep_args *p = params; uarg[0] = (intptr_t)p->rqtp; /* const struct timespec32 * */ uarg[1] = (intptr_t)p->rmtp; /* struct timespec32 * */ *n_args = 2; break; } /* ffclock_getcounter */ case 241: { struct ffclock_getcounter_args *p = params; uarg[0] = (intptr_t)p->ffcount; /* ffcounter * */ *n_args = 1; break; } /* ffclock_setestimate */ case 242: { struct ffclock_setestimate_args *p = params; uarg[0] = (intptr_t)p->cest; /* struct ffclock_estimate * */ *n_args = 1; break; } /* ffclock_getestimate */ case 243: { struct ffclock_getestimate_args *p = params; uarg[0] = (intptr_t)p->cest; /* struct ffclock_estimate * */ *n_args = 1; break; } /* freebsd32_clock_nanosleep */ case 244: { struct freebsd32_clock_nanosleep_args *p = params; iarg[0] = p->clock_id; /* clockid_t */ iarg[1] = p->flags; /* int */ uarg[2] = (intptr_t)p->rqtp; /* const struct timespec32 * */ uarg[3] = (intptr_t)p->rmtp; /* struct timespec32 * */ *n_args = 4; break; } /* freebsd32_clock_getcpuclockid2 */ case 247: { struct freebsd32_clock_getcpuclockid2_args *p = params; uarg[0] = p->id1; /* uint32_t */ uarg[1] = p->id2; /* uint32_t */ iarg[2] = p->which; /* int */ uarg[3] = (intptr_t)p->clock_id; /* clockid_t * */ *n_args = 4; break; } /* minherit */ case 250: { struct minherit_args *p = params; uarg[0] = (intptr_t)p->addr; /* void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->inherit; /* int */ *n_args = 3; break; } /* rfork */ case 251: { struct rfork_args *p = params; iarg[0] = p->flags; /* int */ *n_args = 1; break; } /* issetugid */ case 253: { *n_args = 0; break; } /* lchown */ case 254: { struct lchown_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->uid; /* int */ iarg[2] = p->gid; /* int */ *n_args = 3; break; } /* freebsd32_aio_read */ case 255: { struct freebsd32_aio_read_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* freebsd32_aio_write */ case 256: { struct freebsd32_aio_write_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* freebsd32_lio_listio */ case 257: { struct freebsd32_lio_listio_args *p = params; iarg[0] = p->mode; /* int */ uarg[1] = (intptr_t)p->acb_list; /* uint32_t * */ iarg[2] = p->nent; /* int */ uarg[3] = (intptr_t)p->sig; /* struct sigevent32 * */ *n_args = 4; break; } /* lchmod */ case 274: { struct lchmod_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->mode; /* mode_t */ *n_args = 2; break; } /* freebsd32_lutimes */ case 276: { struct freebsd32_lutimes_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->tptr; /* const struct timeval32 * */ *n_args = 2; break; } /* freebsd32_preadv */ case 289: { struct freebsd32_preadv_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[2] = p->iovcnt; /* u_int */ uarg[3] = p->offset1; /* uint32_t */ uarg[4] = p->offset2; /* uint32_t */ *n_args = 5; break; } /* freebsd32_pwritev */ case 290: { struct freebsd32_pwritev_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[2] = p->iovcnt; /* u_int */ uarg[3] = p->offset1; /* uint32_t */ uarg[4] = p->offset2; /* uint32_t */ *n_args = 5; break; } /* fhopen */ case 298: { struct fhopen_args *p = params; uarg[0] = (intptr_t)p->u_fhp; /* const struct fhandle * */ iarg[1] = p->flags; /* int */ *n_args = 2; break; } /* modnext */ case 300: { struct modnext_args *p = params; iarg[0] = p->modid; /* int */ *n_args = 1; break; } /* freebsd32_modstat */ case 301: { struct freebsd32_modstat_args *p = params; iarg[0] = p->modid; /* int */ uarg[1] = (intptr_t)p->stat; /* struct module_stat32 * */ *n_args = 2; break; } /* modfnext */ case 302: { struct modfnext_args *p = params; iarg[0] = p->modid; /* int */ *n_args = 1; break; } /* modfind */ case 303: { struct modfind_args *p = params; uarg[0] = (intptr_t)p->name; /* const char * */ *n_args = 1; break; } /* kldload */ case 304: { struct kldload_args *p = params; uarg[0] = (intptr_t)p->file; /* const char * */ *n_args = 1; break; } /* kldunload */ case 305: { struct kldunload_args *p = params; iarg[0] = p->fileid; /* int */ *n_args = 1; break; } /* kldfind */ case 306: { struct kldfind_args *p = params; uarg[0] = (intptr_t)p->file; /* const char * */ *n_args = 1; break; } /* kldnext */ case 307: { struct kldnext_args *p = params; iarg[0] = p->fileid; /* int */ *n_args = 1; break; } /* freebsd32_kldstat */ case 308: { struct freebsd32_kldstat_args *p = params; iarg[0] = p->fileid; /* int */ uarg[1] = (intptr_t)p->stat; /* struct kld_file_stat32 * */ *n_args = 2; break; } /* kldfirstmod */ case 309: { struct kldfirstmod_args *p = params; iarg[0] = p->fileid; /* int */ *n_args = 1; break; } /* getsid */ case 310: { struct getsid_args *p = params; iarg[0] = p->pid; /* pid_t */ *n_args = 1; break; } /* setresuid */ case 311: { 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; } /* setresgid */ case 312: { 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; } /* freebsd32_aio_return */ case 314: { struct freebsd32_aio_return_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* freebsd32_aio_suspend */ case 315: { struct freebsd32_aio_suspend_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* uint32_t * */ iarg[1] = p->nent; /* int */ uarg[2] = (intptr_t)p->timeout; /* const struct timespec32 * */ *n_args = 3; break; } /* aio_cancel */ case 316: { struct aio_cancel_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->aiocbp; /* struct aiocb * */ *n_args = 2; break; } /* freebsd32_aio_error */ case 317: { struct freebsd32_aio_error_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* yield */ case 321: { *n_args = 0; break; } /* mlockall */ case 324: { struct mlockall_args *p = params; iarg[0] = p->how; /* int */ *n_args = 1; break; } /* munlockall */ case 325: { *n_args = 0; break; } /* __getcwd */ case 326: { struct __getcwd_args *p = params; uarg[0] = (intptr_t)p->buf; /* char * */ uarg[1] = p->buflen; /* size_t */ *n_args = 2; break; } /* sched_setparam */ case 327: { struct sched_setparam_args *p = params; iarg[0] = p->pid; /* pid_t */ uarg[1] = (intptr_t)p->param; /* const struct sched_param * */ *n_args = 2; break; } /* sched_getparam */ case 328: { struct sched_getparam_args *p = params; iarg[0] = p->pid; /* pid_t */ uarg[1] = (intptr_t)p->param; /* struct sched_param * */ *n_args = 2; break; } /* sched_setscheduler */ case 329: { struct sched_setscheduler_args *p = params; iarg[0] = p->pid; /* pid_t */ iarg[1] = p->policy; /* int */ uarg[2] = (intptr_t)p->param; /* const struct sched_param * */ *n_args = 3; break; } /* sched_getscheduler */ case 330: { struct sched_getscheduler_args *p = params; iarg[0] = p->pid; /* pid_t */ *n_args = 1; break; } /* sched_yield */ case 331: { *n_args = 0; break; } /* sched_get_priority_max */ case 332: { struct sched_get_priority_max_args *p = params; iarg[0] = p->policy; /* int */ *n_args = 1; break; } /* sched_get_priority_min */ case 333: { struct sched_get_priority_min_args *p = params; iarg[0] = p->policy; /* int */ *n_args = 1; break; } /* freebsd32_sched_rr_get_interval */ case 334: { struct freebsd32_sched_rr_get_interval_args *p = params; iarg[0] = p->pid; /* pid_t */ uarg[1] = (intptr_t)p->interval; /* struct timespec32 * */ *n_args = 2; break; } /* utrace */ case 335: { struct utrace_args *p = params; uarg[0] = (intptr_t)p->addr; /* const void * */ uarg[1] = p->len; /* size_t */ *n_args = 2; break; } /* kldsym */ case 337: { struct kldsym_args *p = params; iarg[0] = p->fileid; /* int */ iarg[1] = p->cmd; /* int */ uarg[2] = (intptr_t)p->data; /* void * */ *n_args = 3; break; } /* freebsd32_jail */ case 338: { struct freebsd32_jail_args *p = params; uarg[0] = (intptr_t)p->jail; /* struct jail32 * */ *n_args = 1; break; } /* sigprocmask */ case 340: { struct sigprocmask_args *p = params; iarg[0] = p->how; /* int */ uarg[1] = (intptr_t)p->set; /* const sigset_t * */ uarg[2] = (intptr_t)p->oset; /* sigset_t * */ *n_args = 3; break; } /* sigsuspend */ case 341: { struct sigsuspend_args *p = params; uarg[0] = (intptr_t)p->sigmask; /* const sigset_t * */ *n_args = 1; break; } /* sigpending */ case 343: { struct sigpending_args *p = params; uarg[0] = (intptr_t)p->set; /* sigset_t * */ *n_args = 1; break; } /* freebsd32_sigtimedwait */ case 345: { struct freebsd32_sigtimedwait_args *p = params; uarg[0] = (intptr_t)p->set; /* const sigset_t * */ uarg[1] = (intptr_t)p->info; /* struct siginfo32 * */ uarg[2] = (intptr_t)p->timeout; /* const struct timespec32 * */ *n_args = 3; break; } /* freebsd32_sigwaitinfo */ case 346: { struct freebsd32_sigwaitinfo_args *p = params; uarg[0] = (intptr_t)p->set; /* const sigset_t * */ uarg[1] = (intptr_t)p->info; /* struct siginfo32 * */ *n_args = 2; break; } /* __acl_get_file */ case 347: { struct __acl_get_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_set_file */ case 348: { struct __acl_set_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_get_fd */ case 349: { struct __acl_get_fd_args *p = params; iarg[0] = p->filedes; /* int */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_set_fd */ case 350: { struct __acl_set_fd_args *p = params; iarg[0] = p->filedes; /* int */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_delete_file */ case 351: { struct __acl_delete_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ *n_args = 2; break; } /* __acl_delete_fd */ case 352: { struct __acl_delete_fd_args *p = params; iarg[0] = p->filedes; /* int */ iarg[1] = p->type; /* acl_type_t */ *n_args = 2; break; } /* __acl_aclcheck_file */ case 353: { struct __acl_aclcheck_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_aclcheck_fd */ case 354: { struct __acl_aclcheck_fd_args *p = params; iarg[0] = p->filedes; /* int */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* extattrctl */ case 355: { struct extattrctl_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->cmd; /* int */ uarg[2] = (intptr_t)p->filename; /* const char * */ iarg[3] = p->attrnamespace; /* int */ uarg[4] = (intptr_t)p->attrname; /* const char * */ *n_args = 5; break; } /* extattr_set_file */ case 356: { struct extattr_set_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_get_file */ case 357: { struct extattr_get_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_delete_file */ case 358: { struct extattr_delete_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ *n_args = 3; break; } /* freebsd32_aio_waitcomplete */ case 359: { struct freebsd32_aio_waitcomplete_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* uint32_t * */ uarg[1] = (intptr_t)p->timeout; /* struct timespec32 * */ *n_args = 2; break; } /* getresuid */ case 360: { 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; } /* getresgid */ case 361: { 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; } /* kqueue */ case 362: { *n_args = 0; break; } /* extattr_set_fd */ case 371: { struct extattr_set_fd_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_get_fd */ case 372: { struct extattr_get_fd_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_delete_fd */ case 373: { struct extattr_delete_fd_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ *n_args = 3; break; } /* __setugid */ case 374: { struct __setugid_args *p = params; iarg[0] = p->flag; /* int */ *n_args = 1; break; } /* eaccess */ case 376: { struct eaccess_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->amode; /* int */ *n_args = 2; break; } /* freebsd32_nmount */ case 378: { struct freebsd32_nmount_args *p = params; uarg[0] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[1] = p->iovcnt; /* unsigned int */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* kenv */ case 390: { struct kenv_args *p = params; iarg[0] = p->what; /* int */ uarg[1] = (intptr_t)p->name; /* const char * */ uarg[2] = (intptr_t)p->value; /* char * */ iarg[3] = p->len; /* int */ *n_args = 4; break; } /* lchflags */ case 391: { struct lchflags_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = p->flags; /* u_long */ *n_args = 2; break; } /* uuidgen */ case 392: { struct uuidgen_args *p = params; uarg[0] = (intptr_t)p->store; /* struct uuid * */ iarg[1] = p->count; /* int */ *n_args = 2; break; } /* freebsd32_sendfile */ case 393: { struct freebsd32_sendfile_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->s; /* int */ uarg[2] = p->offset1; /* uint32_t */ uarg[3] = p->offset2; /* uint32_t */ uarg[4] = p->nbytes; /* size_t */ uarg[5] = (intptr_t)p->hdtr; /* struct sf_hdtr32 * */ uarg[6] = (intptr_t)p->sbytes; /* off_t * */ iarg[7] = p->flags; /* int */ *n_args = 8; break; } /* ksem_close */ case 400: { struct ksem_close_args *p = params; iarg[0] = p->id; /* semid_t */ *n_args = 1; break; } /* ksem_post */ case 401: { struct ksem_post_args *p = params; iarg[0] = p->id; /* semid_t */ *n_args = 1; break; } /* ksem_wait */ case 402: { struct ksem_wait_args *p = params; iarg[0] = p->id; /* semid_t */ *n_args = 1; break; } /* ksem_trywait */ case 403: { struct ksem_trywait_args *p = params; iarg[0] = p->id; /* semid_t */ *n_args = 1; break; } /* freebsd32_ksem_init */ case 404: { struct freebsd32_ksem_init_args *p = params; uarg[0] = (intptr_t)p->idp; /* semid_t * */ uarg[1] = p->value; /* unsigned int */ *n_args = 2; break; } /* freebsd32_ksem_open */ case 405: { struct freebsd32_ksem_open_args *p = params; uarg[0] = (intptr_t)p->idp; /* semid_t * */ uarg[1] = (intptr_t)p->name; /* const char * */ iarg[2] = p->oflag; /* int */ iarg[3] = p->mode; /* mode_t */ uarg[4] = p->value; /* unsigned int */ *n_args = 5; break; } /* ksem_unlink */ case 406: { struct ksem_unlink_args *p = params; uarg[0] = (intptr_t)p->name; /* const char * */ *n_args = 1; break; } /* ksem_getvalue */ case 407: { struct ksem_getvalue_args *p = params; iarg[0] = p->id; /* semid_t */ uarg[1] = (intptr_t)p->val; /* int * */ *n_args = 2; break; } /* ksem_destroy */ case 408: { struct ksem_destroy_args *p = params; iarg[0] = p->id; /* semid_t */ *n_args = 1; break; } /* extattr_set_link */ case 412: { struct extattr_set_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_get_link */ case 413: { struct extattr_get_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ uarg[3] = (intptr_t)p->data; /* void * */ uarg[4] = p->nbytes; /* size_t */ *n_args = 5; break; } /* extattr_delete_link */ case 414: { struct extattr_delete_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->attrname; /* const char * */ *n_args = 3; break; } /* freebsd32_sigaction */ case 416: { struct freebsd32_sigaction_args *p = params; iarg[0] = p->sig; /* int */ uarg[1] = (intptr_t)p->act; /* const struct sigaction32 * */ uarg[2] = (intptr_t)p->oact; /* struct sigaction32 * */ *n_args = 3; break; } /* freebsd32_sigreturn */ case 417: { struct freebsd32_sigreturn_args *p = params; uarg[0] = (intptr_t)p->sigcntxp; /* const struct __ucontext32 * */ *n_args = 1; break; } /* freebsd32_getcontext */ case 421: { struct freebsd32_getcontext_args *p = params; uarg[0] = (intptr_t)p->ucp; /* struct __ucontext32 * */ *n_args = 1; break; } /* freebsd32_setcontext */ case 422: { struct freebsd32_setcontext_args *p = params; uarg[0] = (intptr_t)p->ucp; /* const struct __ucontext32 * */ *n_args = 1; break; } /* freebsd32_swapcontext */ case 423: { struct freebsd32_swapcontext_args *p = params; uarg[0] = (intptr_t)p->oucp; /* struct __ucontext32 * */ uarg[1] = (intptr_t)p->ucp; /* const struct __ucontext32 * */ *n_args = 2; break; } /* __acl_get_link */ case 425: { struct __acl_get_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_set_link */ case 426: { struct __acl_set_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* __acl_delete_link */ case 427: { struct __acl_delete_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ *n_args = 2; break; } /* __acl_aclcheck_link */ case 428: { struct __acl_aclcheck_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->type; /* acl_type_t */ uarg[2] = (intptr_t)p->aclp; /* struct acl * */ *n_args = 3; break; } /* sigwait */ case 429: { struct sigwait_args *p = params; uarg[0] = (intptr_t)p->set; /* const sigset_t * */ uarg[1] = (intptr_t)p->sig; /* int * */ *n_args = 2; break; } /* thr_exit */ case 431: { struct thr_exit_args *p = params; uarg[0] = (intptr_t)p->state; /* int32_t * */ *n_args = 1; break; } /* thr_self */ case 432: { struct thr_self_args *p = params; uarg[0] = (intptr_t)p->id; /* int32_t * */ *n_args = 1; break; } /* thr_kill */ case 433: { struct thr_kill_args *p = params; iarg[0] = p->id; /* int32_t */ iarg[1] = p->sig; /* int */ *n_args = 2; break; } /* jail_attach */ case 436: { struct jail_attach_args *p = params; iarg[0] = p->jid; /* int */ *n_args = 1; break; } /* extattr_list_fd */ case 437: { struct extattr_list_fd_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->data; /* void * */ uarg[3] = p->nbytes; /* size_t */ *n_args = 4; break; } /* extattr_list_file */ case 438: { struct extattr_list_file_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->data; /* void * */ uarg[3] = p->nbytes; /* size_t */ *n_args = 4; break; } /* extattr_list_link */ case 439: { struct extattr_list_link_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->attrnamespace; /* int */ uarg[2] = (intptr_t)p->data; /* void * */ uarg[3] = p->nbytes; /* size_t */ *n_args = 4; break; } /* freebsd32_ksem_timedwait */ case 441: { struct freebsd32_ksem_timedwait_args *p = params; iarg[0] = p->id; /* semid_t */ uarg[1] = (intptr_t)p->abstime; /* const struct timespec32 * */ *n_args = 2; break; } /* freebsd32_thr_suspend */ case 442: { struct freebsd32_thr_suspend_args *p = params; uarg[0] = (intptr_t)p->timeout; /* const struct timespec32 * */ *n_args = 1; break; } /* thr_wake */ case 443: { struct thr_wake_args *p = params; iarg[0] = p->id; /* int32_t */ *n_args = 1; break; } /* kldunloadf */ case 444: { struct kldunloadf_args *p = params; iarg[0] = p->fileid; /* int */ iarg[1] = p->flags; /* int */ *n_args = 2; break; } /* audit */ case 445: { struct audit_args *p = params; uarg[0] = (intptr_t)p->record; /* const void * */ uarg[1] = p->length; /* u_int */ *n_args = 2; break; } /* auditon */ case 446: { struct auditon_args *p = params; iarg[0] = p->cmd; /* int */ uarg[1] = (intptr_t)p->data; /* void * */ uarg[2] = p->length; /* u_int */ *n_args = 3; break; } /* getauid */ case 447: { struct getauid_args *p = params; uarg[0] = (intptr_t)p->auid; /* uid_t * */ *n_args = 1; break; } /* setauid */ case 448: { struct setauid_args *p = params; uarg[0] = (intptr_t)p->auid; /* uid_t * */ *n_args = 1; break; } /* getaudit */ case 449: { struct getaudit_args *p = params; uarg[0] = (intptr_t)p->auditinfo; /* struct auditinfo * */ *n_args = 1; break; } /* setaudit */ case 450: { struct setaudit_args *p = params; uarg[0] = (intptr_t)p->auditinfo; /* struct auditinfo * */ *n_args = 1; break; } /* getaudit_addr */ case 451: { struct getaudit_addr_args *p = params; uarg[0] = (intptr_t)p->auditinfo_addr; /* struct auditinfo_addr * */ uarg[1] = p->length; /* u_int */ *n_args = 2; break; } /* setaudit_addr */ case 452: { struct setaudit_addr_args *p = params; uarg[0] = (intptr_t)p->auditinfo_addr; /* struct auditinfo_addr * */ uarg[1] = p->length; /* u_int */ *n_args = 2; break; } /* auditctl */ case 453: { struct auditctl_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* freebsd32__umtx_op */ case 454: { struct freebsd32__umtx_op_args *p = params; uarg[0] = (intptr_t)p->obj; /* void * */ iarg[1] = p->op; /* int */ uarg[2] = p->val; /* u_long */ uarg[3] = (intptr_t)p->uaddr1; /* void * */ uarg[4] = (intptr_t)p->uaddr2; /* void * */ *n_args = 5; break; } /* freebsd32_thr_new */ case 455: { struct freebsd32_thr_new_args *p = params; uarg[0] = (intptr_t)p->param; /* struct thr_param32 * */ iarg[1] = p->param_size; /* int */ *n_args = 2; break; } /* freebsd32_sigqueue */ case 456: { struct freebsd32_sigqueue_args *p = params; iarg[0] = p->pid; /* pid_t */ iarg[1] = p->signum; /* int */ iarg[2] = p->value; /* int */ *n_args = 3; break; } /* freebsd32_kmq_open */ case 457: { struct freebsd32_kmq_open_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->flags; /* int */ iarg[2] = p->mode; /* mode_t */ uarg[3] = (intptr_t)p->attr; /* const struct mq_attr32 * */ *n_args = 4; break; } /* freebsd32_kmq_setattr */ case 458: { struct freebsd32_kmq_setattr_args *p = params; iarg[0] = p->mqd; /* int */ uarg[1] = (intptr_t)p->attr; /* const struct mq_attr32 * */ uarg[2] = (intptr_t)p->oattr; /* struct mq_attr32 * */ *n_args = 3; break; } /* freebsd32_kmq_timedreceive */ case 459: { struct freebsd32_kmq_timedreceive_args *p = params; iarg[0] = p->mqd; /* int */ uarg[1] = (intptr_t)p->msg_ptr; /* char * */ uarg[2] = p->msg_len; /* size_t */ uarg[3] = (intptr_t)p->msg_prio; /* unsigned * */ uarg[4] = (intptr_t)p->abs_timeout; /* const struct timespec32 * */ *n_args = 5; break; } /* freebsd32_kmq_timedsend */ case 460: { struct freebsd32_kmq_timedsend_args *p = params; iarg[0] = p->mqd; /* int */ uarg[1] = (intptr_t)p->msg_ptr; /* const char * */ uarg[2] = p->msg_len; /* size_t */ uarg[3] = p->msg_prio; /* unsigned */ uarg[4] = (intptr_t)p->abs_timeout; /* const struct timespec32 * */ *n_args = 5; break; } /* freebsd32_kmq_notify */ case 461: { struct freebsd32_kmq_notify_args *p = params; iarg[0] = p->mqd; /* int */ uarg[1] = (intptr_t)p->sigev; /* const struct sigevent32 * */ *n_args = 2; break; } /* kmq_unlink */ case 462: { struct kmq_unlink_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* abort2 */ case 463: { struct abort2_args *p = params; uarg[0] = (intptr_t)p->why; /* const char * */ iarg[1] = p->nargs; /* int */ uarg[2] = (intptr_t)p->args; /* uint32_t * */ *n_args = 3; break; } /* thr_set_name */ case 464: { struct thr_set_name_args *p = params; iarg[0] = p->id; /* int32_t */ uarg[1] = (intptr_t)p->name; /* const char * */ *n_args = 2; break; } /* freebsd32_aio_fsync */ case 465: { struct freebsd32_aio_fsync_args *p = params; iarg[0] = p->op; /* int */ uarg[1] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 2; break; } /* rtprio_thread */ case 466: { struct rtprio_thread_args *p = params; iarg[0] = p->function; /* int */ iarg[1] = p->lwpid; /* lwpid_t */ uarg[2] = (intptr_t)p->rtp; /* struct rtprio * */ *n_args = 3; break; } /* sctp_peeloff */ case 471: { struct sctp_peeloff_args *p = params; iarg[0] = p->sd; /* int */ uarg[1] = p->name; /* uint32_t */ *n_args = 2; break; } /* sctp_generic_sendmsg */ case 472: { struct sctp_generic_sendmsg_args *p = params; iarg[0] = p->sd; /* int */ uarg[1] = (intptr_t)p->msg; /* void * */ iarg[2] = p->mlen; /* int */ uarg[3] = (intptr_t)p->to; /* const struct sockaddr * */ iarg[4] = p->tolen; /* __socklen_t */ uarg[5] = (intptr_t)p->sinfo; /* struct sctp_sndrcvinfo * */ iarg[6] = p->flags; /* int */ *n_args = 7; break; } /* sctp_generic_sendmsg_iov */ case 473: { struct sctp_generic_sendmsg_iov_args *p = params; iarg[0] = p->sd; /* int */ uarg[1] = (intptr_t)p->iov; /* struct iovec * */ iarg[2] = p->iovlen; /* int */ uarg[3] = (intptr_t)p->to; /* const struct sockaddr * */ iarg[4] = p->tolen; /* __socklen_t */ uarg[5] = (intptr_t)p->sinfo; /* struct sctp_sndrcvinfo * */ iarg[6] = p->flags; /* int */ *n_args = 7; break; } /* sctp_generic_recvmsg */ case 474: { struct sctp_generic_recvmsg_args *p = params; iarg[0] = p->sd; /* int */ uarg[1] = (intptr_t)p->iov; /* struct iovec * */ iarg[2] = p->iovlen; /* int */ uarg[3] = (intptr_t)p->from; /* struct sockaddr * */ uarg[4] = (intptr_t)p->fromlenaddr; /* __socklen_t * */ uarg[5] = (intptr_t)p->sinfo; /* struct sctp_sndrcvinfo * */ uarg[6] = (intptr_t)p->msg_flags; /* int * */ *n_args = 7; break; } #ifdef PAD64_REQUIRED /* freebsd32_pread */ case 475: { struct freebsd32_pread_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* void * */ uarg[2] = p->nbyte; /* size_t */ iarg[3] = p->pad; /* int */ uarg[4] = p->offset1; /* uint32_t */ uarg[5] = p->offset2; /* uint32_t */ *n_args = 6; break; } /* freebsd32_pwrite */ case 476: { struct freebsd32_pwrite_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* const void * */ uarg[2] = p->nbyte; /* size_t */ iarg[3] = p->pad; /* int */ uarg[4] = p->offset1; /* uint32_t */ uarg[5] = p->offset2; /* uint32_t */ *n_args = 6; break; } /* freebsd32_mmap */ case 477: { struct freebsd32_mmap_args *p = params; uarg[0] = (intptr_t)p->addr; /* void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->prot; /* int */ iarg[3] = p->flags; /* int */ iarg[4] = p->fd; /* int */ iarg[5] = p->pad; /* int */ uarg[6] = p->pos1; /* uint32_t */ uarg[7] = p->pos2; /* uint32_t */ *n_args = 8; break; } /* freebsd32_lseek */ case 478: { struct freebsd32_lseek_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->pad; /* int */ uarg[2] = p->offset1; /* uint32_t */ uarg[3] = p->offset2; /* uint32_t */ iarg[4] = p->whence; /* int */ *n_args = 5; break; } /* freebsd32_truncate */ case 479: { struct freebsd32_truncate_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->pad; /* int */ uarg[2] = p->length1; /* uint32_t */ uarg[3] = p->length2; /* uint32_t */ *n_args = 4; break; } /* freebsd32_ftruncate */ case 480: { struct freebsd32_ftruncate_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->pad; /* int */ uarg[2] = p->length1; /* uint32_t */ uarg[3] = p->length2; /* uint32_t */ *n_args = 4; break; } #else /* freebsd32_pread */ case 475: { struct freebsd32_pread_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* void * */ uarg[2] = p->nbyte; /* size_t */ uarg[3] = p->offset1; /* uint32_t */ uarg[4] = p->offset2; /* uint32_t */ *n_args = 5; break; } /* freebsd32_pwrite */ case 476: { struct freebsd32_pwrite_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* const void * */ uarg[2] = p->nbyte; /* size_t */ uarg[3] = p->offset1; /* uint32_t */ uarg[4] = p->offset2; /* uint32_t */ *n_args = 5; break; } /* freebsd32_mmap */ case 477: { struct freebsd32_mmap_args *p = params; uarg[0] = (intptr_t)p->addr; /* void * */ uarg[1] = p->len; /* size_t */ iarg[2] = p->prot; /* int */ iarg[3] = p->flags; /* int */ iarg[4] = p->fd; /* int */ uarg[5] = p->pos1; /* uint32_t */ uarg[6] = p->pos2; /* uint32_t */ *n_args = 7; break; } /* freebsd32_lseek */ case 478: { struct freebsd32_lseek_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->offset1; /* uint32_t */ uarg[2] = p->offset2; /* uint32_t */ iarg[3] = p->whence; /* int */ *n_args = 4; break; } /* freebsd32_truncate */ case 479: { struct freebsd32_truncate_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = p->length1; /* uint32_t */ uarg[2] = p->length2; /* uint32_t */ *n_args = 3; break; } /* freebsd32_ftruncate */ case 480: { struct freebsd32_ftruncate_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->length1; /* uint32_t */ uarg[2] = p->length2; /* uint32_t */ *n_args = 3; break; } #endif /* thr_kill2 */ case 481: { struct thr_kill2_args *p = params; iarg[0] = p->pid; /* pid_t */ iarg[1] = p->id; /* int32_t */ iarg[2] = p->sig; /* int */ *n_args = 3; break; } /* shm_unlink */ case 483: { struct shm_unlink_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* cpuset */ case 484: { struct cpuset_args *p = params; uarg[0] = (intptr_t)p->setid; /* cpusetid_t * */ *n_args = 1; break; } #ifdef PAD64_REQUIRED /* freebsd32_cpuset_setid */ case 485: { struct freebsd32_cpuset_setid_args *p = params; iarg[0] = p->which; /* cpuwhich_t */ iarg[1] = p->pad; /* int */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ iarg[4] = p->setid; /* cpusetid_t */ *n_args = 5; break; } #else /* freebsd32_cpuset_setid */ case 485: { struct freebsd32_cpuset_setid_args *p = params; iarg[0] = p->which; /* cpuwhich_t */ uarg[1] = p->id1; /* uint32_t */ uarg[2] = p->id2; /* uint32_t */ iarg[3] = p->setid; /* cpusetid_t */ *n_args = 4; break; } #endif /* freebsd32_cpuset_getid */ case 486: { struct freebsd32_cpuset_getid_args *p = params; iarg[0] = p->level; /* cpulevel_t */ iarg[1] = p->which; /* cpuwhich_t */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = (intptr_t)p->setid; /* cpusetid_t * */ *n_args = 5; break; } /* freebsd32_cpuset_getaffinity */ case 487: { struct freebsd32_cpuset_getaffinity_args *p = params; iarg[0] = p->level; /* cpulevel_t */ iarg[1] = p->which; /* cpuwhich_t */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = p->cpusetsize; /* size_t */ uarg[5] = (intptr_t)p->mask; /* cpuset_t * */ *n_args = 6; break; } /* freebsd32_cpuset_setaffinity */ case 488: { struct freebsd32_cpuset_setaffinity_args *p = params; iarg[0] = p->level; /* cpulevel_t */ iarg[1] = p->which; /* cpuwhich_t */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = p->cpusetsize; /* size_t */ uarg[5] = (intptr_t)p->mask; /* const cpuset_t * */ *n_args = 6; break; } /* faccessat */ case 489: { struct faccessat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->amode; /* int */ iarg[3] = p->flag; /* int */ *n_args = 4; break; } /* fchmodat */ case 490: { struct fchmodat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->mode; /* mode_t */ iarg[3] = p->flag; /* int */ *n_args = 4; break; } /* fchownat */ case 491: { struct fchownat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = p->uid; /* uid_t */ iarg[3] = p->gid; /* gid_t */ iarg[4] = p->flag; /* int */ *n_args = 5; break; } /* freebsd32_fexecve */ case 492: { struct freebsd32_fexecve_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->argv; /* uint32_t * */ uarg[2] = (intptr_t)p->envv; /* uint32_t * */ *n_args = 3; break; } /* freebsd32_futimesat */ case 494: { struct freebsd32_futimesat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = (intptr_t)p->times; /* const struct timeval32 * */ *n_args = 3; break; } /* linkat */ case 495: { struct linkat_args *p = params; iarg[0] = p->fd1; /* int */ uarg[1] = (intptr_t)p->path1; /* const char * */ iarg[2] = p->fd2; /* int */ uarg[3] = (intptr_t)p->path2; /* const char * */ iarg[4] = p->flag; /* int */ *n_args = 5; break; } /* mkdirat */ case 496: { struct mkdirat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->mode; /* mode_t */ *n_args = 3; break; } /* mkfifoat */ case 497: { struct mkfifoat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->mode; /* mode_t */ *n_args = 3; break; } /* openat */ case 499: { struct openat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->flag; /* int */ iarg[3] = p->mode; /* mode_t */ *n_args = 4; break; } /* readlinkat */ case 500: { struct readlinkat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = (intptr_t)p->buf; /* char * */ uarg[3] = p->bufsize; /* size_t */ *n_args = 4; break; } /* renameat */ case 501: { struct renameat_args *p = params; iarg[0] = p->oldfd; /* int */ uarg[1] = (intptr_t)p->old; /* const char * */ iarg[2] = p->newfd; /* int */ uarg[3] = (intptr_t)p->new; /* const char * */ *n_args = 4; break; } /* symlinkat */ case 502: { struct symlinkat_args *p = params; uarg[0] = (intptr_t)p->path1; /* const char * */ iarg[1] = p->fd; /* int */ uarg[2] = (intptr_t)p->path2; /* const char * */ *n_args = 3; break; } /* unlinkat */ case 503: { struct unlinkat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->flag; /* int */ *n_args = 3; break; } /* posix_openpt */ case 504: { struct posix_openpt_args *p = params; iarg[0] = p->flags; /* int */ *n_args = 1; break; } /* gssd_syscall */ case 505: { struct gssd_syscall_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ *n_args = 1; break; } /* freebsd32_jail_get */ case 506: { struct freebsd32_jail_get_args *p = params; uarg[0] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[1] = p->iovcnt; /* unsigned int */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* freebsd32_jail_set */ case 507: { struct freebsd32_jail_set_args *p = params; uarg[0] = (intptr_t)p->iovp; /* struct iovec32 * */ uarg[1] = p->iovcnt; /* unsigned int */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* jail_remove */ case 508: { struct jail_remove_args *p = params; iarg[0] = p->jid; /* int */ *n_args = 1; break; } /* freebsd32___semctl */ case 510: { struct freebsd32___semctl_args *p = params; iarg[0] = p->semid; /* int */ iarg[1] = p->semnum; /* int */ iarg[2] = p->cmd; /* int */ uarg[3] = (intptr_t)p->arg; /* union semun32 * */ *n_args = 4; break; } /* freebsd32_msgctl */ case 511: { struct freebsd32_msgctl_args *p = params; iarg[0] = p->msqid; /* int */ iarg[1] = p->cmd; /* int */ uarg[2] = (intptr_t)p->buf; /* struct msqid_ds32 * */ *n_args = 3; break; } /* freebsd32_shmctl */ case 512: { struct freebsd32_shmctl_args *p = params; iarg[0] = p->shmid; /* int */ iarg[1] = p->cmd; /* int */ uarg[2] = (intptr_t)p->buf; /* struct shmid_ds32 * */ *n_args = 3; break; } /* lpathconf */ case 513: { struct lpathconf_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->name; /* int */ *n_args = 2; break; } /* __cap_rights_get */ case 515: { struct __cap_rights_get_args *p = params; iarg[0] = p->version; /* int */ iarg[1] = p->fd; /* int */ uarg[2] = (intptr_t)p->rightsp; /* cap_rights_t * */ *n_args = 3; break; } /* cap_enter */ case 516: { *n_args = 0; break; } /* cap_getmode */ case 517: { struct cap_getmode_args *p = params; uarg[0] = (intptr_t)p->modep; /* u_int * */ *n_args = 1; break; } /* pdfork */ case 518: { struct pdfork_args *p = params; uarg[0] = (intptr_t)p->fdp; /* int * */ iarg[1] = p->flags; /* int */ *n_args = 2; break; } /* pdkill */ case 519: { struct pdkill_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->signum; /* int */ *n_args = 2; break; } /* pdgetpid */ case 520: { struct pdgetpid_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->pidp; /* pid_t * */ *n_args = 2; break; } /* freebsd32_pselect */ case 522: { struct freebsd32_pselect_args *p = params; iarg[0] = p->nd; /* int */ uarg[1] = (intptr_t)p->in; /* fd_set * */ uarg[2] = (intptr_t)p->ou; /* fd_set * */ uarg[3] = (intptr_t)p->ex; /* fd_set * */ uarg[4] = (intptr_t)p->ts; /* const struct timespec32 * */ uarg[5] = (intptr_t)p->sm; /* const sigset_t * */ *n_args = 6; break; } /* getloginclass */ case 523: { struct getloginclass_args *p = params; uarg[0] = (intptr_t)p->namebuf; /* char * */ uarg[1] = p->namelen; /* size_t */ *n_args = 2; break; } /* setloginclass */ case 524: { struct setloginclass_args *p = params; uarg[0] = (intptr_t)p->namebuf; /* const char * */ *n_args = 1; break; } /* rctl_get_racct */ case 525: { struct rctl_get_racct_args *p = params; uarg[0] = (intptr_t)p->inbufp; /* const void * */ uarg[1] = p->inbuflen; /* size_t */ uarg[2] = (intptr_t)p->outbufp; /* void * */ uarg[3] = p->outbuflen; /* size_t */ *n_args = 4; break; } /* rctl_get_rules */ case 526: { struct rctl_get_rules_args *p = params; uarg[0] = (intptr_t)p->inbufp; /* const void * */ uarg[1] = p->inbuflen; /* size_t */ uarg[2] = (intptr_t)p->outbufp; /* void * */ uarg[3] = p->outbuflen; /* size_t */ *n_args = 4; break; } /* rctl_get_limits */ case 527: { struct rctl_get_limits_args *p = params; uarg[0] = (intptr_t)p->inbufp; /* const void * */ uarg[1] = p->inbuflen; /* size_t */ uarg[2] = (intptr_t)p->outbufp; /* void * */ uarg[3] = p->outbuflen; /* size_t */ *n_args = 4; break; } /* rctl_add_rule */ case 528: { struct rctl_add_rule_args *p = params; uarg[0] = (intptr_t)p->inbufp; /* const void * */ uarg[1] = p->inbuflen; /* size_t */ uarg[2] = (intptr_t)p->outbufp; /* void * */ uarg[3] = p->outbuflen; /* size_t */ *n_args = 4; break; } /* rctl_remove_rule */ case 529: { struct rctl_remove_rule_args *p = params; uarg[0] = (intptr_t)p->inbufp; /* const void * */ uarg[1] = p->inbuflen; /* size_t */ uarg[2] = (intptr_t)p->outbufp; /* void * */ uarg[3] = p->outbuflen; /* size_t */ *n_args = 4; break; } #ifdef PAD64_REQUIRED /* freebsd32_posix_fallocate */ case 530: { struct freebsd32_posix_fallocate_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->pad; /* int */ 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; } /* freebsd32_posix_fadvise */ case 531: { struct freebsd32_posix_fadvise_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->pad; /* int */ uarg[2] = p->offset1; /* uint32_t */ uarg[3] = p->offset2; /* uint32_t */ uarg[4] = p->len1; /* uint32_t */ uarg[5] = p->len2; /* uint32_t */ iarg[6] = p->advice; /* int */ *n_args = 7; break; } /* freebsd32_wait6 */ case 532: { struct freebsd32_wait6_args *p = params; iarg[0] = p->idtype; /* idtype_t */ iarg[1] = p->pad; /* int */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = (intptr_t)p->status; /* int * */ iarg[5] = p->options; /* int */ - uarg[6] = (intptr_t)p->wrusage; /* struct wrusage32 * */ + uarg[6] = (intptr_t)p->wrusage; /* struct __wrusage32 * */ uarg[7] = (intptr_t)p->info; /* struct siginfo32 * */ *n_args = 8; break; } #else /* freebsd32_posix_fallocate */ case 530: { struct freebsd32_posix_fallocate_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->offset1; /* uint32_t */ uarg[2] = p->offset2; /* uint32_t */ uarg[3] = p->len1; /* uint32_t */ uarg[4] = p->len2; /* uint32_t */ *n_args = 5; break; } /* freebsd32_posix_fadvise */ case 531: { struct freebsd32_posix_fadvise_args *p = params; iarg[0] = p->fd; /* int */ 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; } /* freebsd32_wait6 */ case 532: { struct freebsd32_wait6_args *p = params; iarg[0] = p->idtype; /* idtype_t */ uarg[1] = p->id1; /* uint32_t */ uarg[2] = p->id2; /* uint32_t */ uarg[3] = (intptr_t)p->status; /* int * */ iarg[4] = p->options; /* int */ - uarg[5] = (intptr_t)p->wrusage; /* struct wrusage32 * */ + uarg[5] = (intptr_t)p->wrusage; /* struct __wrusage32 * */ uarg[6] = (intptr_t)p->info; /* struct siginfo32 * */ *n_args = 7; break; } #endif /* cap_rights_limit */ case 533: { struct cap_rights_limit_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->rightsp; /* cap_rights_t * */ *n_args = 2; break; } /* freebsd32_cap_ioctls_limit */ case 534: { struct freebsd32_cap_ioctls_limit_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->cmds; /* const uint32_t * */ uarg[2] = p->ncmds; /* size_t */ *n_args = 3; break; } /* freebsd32_cap_ioctls_get */ case 535: { struct freebsd32_cap_ioctls_get_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->cmds; /* uint32_t * */ uarg[2] = p->maxcmds; /* size_t */ *n_args = 3; break; } /* cap_fcntls_limit */ case 536: { struct cap_fcntls_limit_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = p->fcntlrights; /* uint32_t */ *n_args = 2; break; } /* cap_fcntls_get */ case 537: { struct cap_fcntls_get_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->fcntlrightsp; /* uint32_t * */ *n_args = 2; break; } /* bindat */ case 538: { struct bindat_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->s; /* int */ uarg[2] = (intptr_t)p->name; /* const struct sockaddr * */ iarg[3] = p->namelen; /* int */ *n_args = 4; break; } /* connectat */ case 539: { struct connectat_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->s; /* int */ uarg[2] = (intptr_t)p->name; /* const struct sockaddr * */ iarg[3] = p->namelen; /* int */ *n_args = 4; break; } /* chflagsat */ case 540: { struct chflagsat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = p->flags; /* u_long */ iarg[3] = p->atflag; /* int */ *n_args = 4; break; } /* accept4 */ case 541: { struct accept4_args *p = params; iarg[0] = p->s; /* int */ uarg[1] = (intptr_t)p->name; /* struct sockaddr * */ uarg[2] = (intptr_t)p->anamelen; /* __socklen_t * */ iarg[3] = p->flags; /* int */ *n_args = 4; break; } /* pipe2 */ case 542: { struct pipe2_args *p = params; uarg[0] = (intptr_t)p->fildes; /* int * */ iarg[1] = p->flags; /* int */ *n_args = 2; break; } /* freebsd32_aio_mlock */ case 543: { struct freebsd32_aio_mlock_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } #ifdef PAD64_REQUIRED /* freebsd32_procctl */ case 544: { struct freebsd32_procctl_args *p = params; iarg[0] = p->idtype; /* idtype_t */ iarg[1] = p->pad; /* int */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ iarg[4] = p->com; /* int */ uarg[5] = (intptr_t)p->data; /* void * */ *n_args = 6; break; } #else /* freebsd32_procctl */ case 544: { struct freebsd32_procctl_args *p = params; iarg[0] = p->idtype; /* idtype_t */ uarg[1] = p->id1; /* uint32_t */ uarg[2] = p->id2; /* uint32_t */ iarg[3] = p->com; /* int */ uarg[4] = (intptr_t)p->data; /* void * */ *n_args = 5; break; } #endif /* freebsd32_ppoll */ case 545: { struct freebsd32_ppoll_args *p = params; uarg[0] = (intptr_t)p->fds; /* struct pollfd * */ uarg[1] = p->nfds; /* u_int */ uarg[2] = (intptr_t)p->ts; /* const struct timespec32 * */ uarg[3] = (intptr_t)p->set; /* const sigset_t * */ *n_args = 4; break; } /* freebsd32_futimens */ case 546: { struct freebsd32_futimens_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->times; /* const struct timespec32 * */ *n_args = 2; break; } /* freebsd32_utimensat */ case 547: { struct freebsd32_utimensat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = (intptr_t)p->times; /* const struct timespec32 * */ iarg[3] = p->flag; /* int */ *n_args = 4; break; } /* fdatasync */ case 550: { struct fdatasync_args *p = params; iarg[0] = p->fd; /* int */ *n_args = 1; break; } /* freebsd32_fstat */ case 551: { struct freebsd32_fstat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->sb; /* struct stat32 * */ *n_args = 2; break; } /* freebsd32_fstatat */ case 552: { struct freebsd32_fstatat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = (intptr_t)p->buf; /* struct stat32 * */ iarg[3] = p->flag; /* int */ *n_args = 4; break; } /* freebsd32_fhstat */ case 553: { struct freebsd32_fhstat_args *p = params; uarg[0] = (intptr_t)p->u_fhp; /* const struct fhandle * */ uarg[1] = (intptr_t)p->sb; /* struct stat32 * */ *n_args = 2; break; } /* getdirentries */ case 554: { struct getdirentries_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* char * */ uarg[2] = p->count; /* size_t */ uarg[3] = (intptr_t)p->basep; /* off_t * */ *n_args = 4; break; } /* statfs */ case 555: { struct statfs_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ uarg[1] = (intptr_t)p->buf; /* struct statfs * */ *n_args = 2; break; } /* fstatfs */ case 556: { struct fstatfs_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->buf; /* struct statfs * */ *n_args = 2; break; } /* getfsstat */ case 557: { struct getfsstat_args *p = params; uarg[0] = (intptr_t)p->buf; /* struct statfs * */ iarg[1] = p->bufsize; /* long */ iarg[2] = p->mode; /* int */ *n_args = 3; break; } /* fhstatfs */ case 558: { struct fhstatfs_args *p = params; uarg[0] = (intptr_t)p->u_fhp; /* const struct fhandle * */ uarg[1] = (intptr_t)p->buf; /* struct statfs * */ *n_args = 2; break; } #ifdef PAD64_REQUIRED /* freebsd32_mknodat */ case 559: { struct freebsd32_mknodat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->mode; /* mode_t */ iarg[3] = p->pad; /* int */ uarg[4] = p->dev1; /* uint32_t */ uarg[5] = p->dev2; /* uint32_t */ *n_args = 6; break; } #else /* freebsd32_mknodat */ case 559: { struct freebsd32_mknodat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->mode; /* mode_t */ uarg[3] = p->dev1; /* uint32_t */ uarg[4] = p->dev2; /* uint32_t */ *n_args = 5; break; } #endif /* freebsd32_kevent */ case 560: { struct freebsd32_kevent_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->changelist; /* const struct kevent32 * */ iarg[2] = p->nchanges; /* int */ uarg[3] = (intptr_t)p->eventlist; /* struct kevent32 * */ iarg[4] = p->nevents; /* int */ uarg[5] = (intptr_t)p->timeout; /* const struct timespec32 * */ *n_args = 6; break; } /* freebsd32_cpuset_getdomain */ case 561: { struct freebsd32_cpuset_getdomain_args *p = params; iarg[0] = p->level; /* cpulevel_t */ iarg[1] = p->which; /* cpuwhich_t */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = p->domainsetsize; /* size_t */ uarg[5] = (intptr_t)p->mask; /* domainset_t * */ uarg[6] = (intptr_t)p->policy; /* int * */ *n_args = 7; break; } /* freebsd32_cpuset_setdomain */ case 562: { struct freebsd32_cpuset_setdomain_args *p = params; iarg[0] = p->level; /* cpulevel_t */ iarg[1] = p->which; /* cpuwhich_t */ uarg[2] = p->id1; /* uint32_t */ uarg[3] = p->id2; /* uint32_t */ uarg[4] = p->domainsetsize; /* size_t */ uarg[5] = (intptr_t)p->mask; /* domainset_t * */ iarg[6] = p->policy; /* int */ *n_args = 7; break; } /* getrandom */ case 563: { struct getrandom_args *p = params; uarg[0] = (intptr_t)p->buf; /* void * */ uarg[1] = p->buflen; /* size_t */ uarg[2] = p->flags; /* unsigned int */ *n_args = 3; break; } /* getfhat */ case 564: { struct getfhat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* char * */ uarg[2] = (intptr_t)p->fhp; /* struct fhandle * */ iarg[3] = p->flags; /* int */ *n_args = 4; break; } /* fhlink */ case 565: { struct fhlink_args *p = params; uarg[0] = (intptr_t)p->fhp; /* struct fhandle * */ uarg[1] = (intptr_t)p->to; /* const char * */ *n_args = 2; break; } /* fhlinkat */ case 566: { struct fhlinkat_args *p = params; uarg[0] = (intptr_t)p->fhp; /* struct fhandle * */ iarg[1] = p->tofd; /* int */ uarg[2] = (intptr_t)p->to; /* const char * */ *n_args = 3; break; } /* fhreadlink */ case 567: { struct fhreadlink_args *p = params; uarg[0] = (intptr_t)p->fhp; /* struct fhandle * */ uarg[1] = (intptr_t)p->buf; /* char * */ uarg[2] = p->bufsize; /* size_t */ *n_args = 3; break; } /* funlinkat */ case 568: { struct funlinkat_args *p = params; iarg[0] = p->dfd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ iarg[2] = p->fd; /* int */ iarg[3] = p->flag; /* int */ *n_args = 4; break; } /* copy_file_range */ case 569: { struct copy_file_range_args *p = params; iarg[0] = p->infd; /* int */ uarg[1] = (intptr_t)p->inoffp; /* off_t * */ iarg[2] = p->outfd; /* int */ uarg[3] = (intptr_t)p->outoffp; /* off_t * */ uarg[4] = p->len; /* size_t */ uarg[5] = p->flags; /* unsigned int */ *n_args = 6; break; } /* freebsd32___sysctlbyname */ case 570: { struct freebsd32___sysctlbyname_args *p = params; uarg[0] = (intptr_t)p->name; /* const char * */ uarg[1] = p->namelen; /* size_t */ uarg[2] = (intptr_t)p->old; /* void * */ uarg[3] = (intptr_t)p->oldlenp; /* uint32_t * */ uarg[4] = (intptr_t)p->new; /* void * */ uarg[5] = p->newlen; /* size_t */ *n_args = 6; break; } /* shm_open2 */ case 571: { struct shm_open2_args *p = params; uarg[0] = (intptr_t)p->path; /* const char * */ iarg[1] = p->flags; /* int */ iarg[2] = p->mode; /* mode_t */ iarg[3] = p->shmflags; /* int */ uarg[4] = (intptr_t)p->name; /* const char * */ *n_args = 5; break; } /* shm_rename */ case 572: { struct shm_rename_args *p = params; uarg[0] = (intptr_t)p->path_from; /* const char * */ uarg[1] = (intptr_t)p->path_to; /* const char * */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* sigfastblock */ case 573: { struct sigfastblock_args *p = params; iarg[0] = p->cmd; /* int */ uarg[1] = (intptr_t)p->ptr; /* uint32_t * */ *n_args = 2; break; } /* __realpathat */ case 574: { struct __realpathat_args *p = params; iarg[0] = p->fd; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ uarg[2] = (intptr_t)p->buf; /* char * */ uarg[3] = p->size; /* size_t */ iarg[4] = p->flags; /* int */ *n_args = 5; break; } /* close_range */ case 575: { struct close_range_args *p = params; uarg[0] = p->lowfd; /* u_int */ uarg[1] = p->highfd; /* u_int */ iarg[2] = p->flags; /* int */ *n_args = 3; break; } /* rpctls_syscall */ case 576: { struct rpctls_syscall_args *p = params; iarg[0] = p->op; /* int */ uarg[1] = (intptr_t)p->path; /* const char * */ *n_args = 2; break; } /* __specialfd */ case 577: { struct __specialfd_args *p = params; iarg[0] = p->type; /* int */ uarg[1] = (intptr_t)p->req; /* const void * */ uarg[2] = p->len; /* size_t */ *n_args = 3; break; } /* freebsd32_aio_writev */ case 578: { struct freebsd32_aio_writev_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* freebsd32_aio_readv */ case 579: { struct freebsd32_aio_readv_args *p = params; uarg[0] = (intptr_t)p->aiocbp; /* struct aiocb32 * */ *n_args = 1; break; } /* freebsd32_fspacectl */ case 580: { struct freebsd32_fspacectl_args *p = params; iarg[0] = p->fd; /* int */ iarg[1] = p->cmd; /* int */ uarg[2] = (intptr_t)p->rqsr; /* const struct spacectl_range32 * */ iarg[3] = p->flags; /* int */ uarg[4] = (intptr_t)p->rmsr; /* struct spacectl_range32 * */ *n_args = 5; break; } /* sched_getcpu */ case 581: { *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) { #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif /* nosys */ case 0: break; /* sys_exit */ case 1: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* fork */ case 2: break; /* read */ case 3: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "size_t"; break; default: break; }; break; /* write */ case 4: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; default: break; }; break; /* open */ case 5: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "mode_t"; break; default: break; }; break; /* close */ case 6: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_wait4 */ case 7: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland int *"; break; case 2: p = "int"; break; case 3: p = "userland struct rusage32 *"; break; default: break; }; break; /* link */ case 9: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* unlink */ case 10: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* chdir */ case 12: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* fchdir */ case 13: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* chmod */ case 15: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "mode_t"; break; default: break; }; break; /* chown */ case 16: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* break */ case 17: switch (ndx) { case 0: p = "userland char *"; break; default: break; }; break; /* getpid */ case 20: break; /* mount */ case 21: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "userland void *"; break; default: break; }; break; /* unmount */ case 22: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; default: break; }; break; /* setuid */ case 23: switch (ndx) { case 0: p = "uid_t"; break; default: break; }; break; /* getuid */ case 24: break; /* geteuid */ case 25: break; /* freebsd32_ptrace */ case 26: switch (ndx) { case 0: p = "int"; break; case 1: p = "pid_t"; break; case 2: p = "caddr_t"; break; case 3: p = "int"; break; default: break; }; break; /* freebsd32_recvmsg */ case 27: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct msghdr32 *"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_sendmsg */ case 28: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct msghdr32 *"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_recvfrom */ case 29: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "size_t"; break; case 3: p = "int"; break; case 4: p = "userland struct sockaddr *"; break; case 5: p = "uint32_t"; break; default: break; }; break; /* accept */ case 30: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct sockaddr *"; break; case 2: p = "userland int *"; break; default: break; }; break; /* getpeername */ case 31: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct sockaddr *"; break; case 2: p = "userland int *"; break; default: break; }; break; /* getsockname */ case 32: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct sockaddr *"; break; case 2: p = "userland int *"; break; default: break; }; break; /* access */ case 33: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; default: break; }; break; /* chflags */ case 34: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "u_long"; break; default: break; }; break; /* fchflags */ case 35: switch (ndx) { case 0: p = "int"; break; case 1: p = "u_long"; break; default: break; }; break; /* sync */ case 36: break; /* kill */ case 37: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* getppid */ case 39: break; /* dup */ case 41: switch (ndx) { case 0: p = "u_int"; break; default: break; }; break; /* getegid */ case 43: break; /* profil */ case 44: switch (ndx) { case 0: p = "userland char *"; break; case 1: p = "size_t"; break; case 2: p = "size_t"; break; case 3: p = "u_int"; break; default: break; }; break; /* ktrace */ case 45: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "int"; break; default: break; }; break; /* getgid */ case 47: break; /* getlogin */ case 49: switch (ndx) { case 0: p = "userland char *"; break; case 1: p = "u_int"; break; default: break; }; break; /* setlogin */ case 50: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* acct */ case 51: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32_sigaltstack */ case 53: switch (ndx) { case 0: p = "userland const struct sigaltstack32 *"; break; case 1: p = "userland struct sigaltstack32 *"; break; default: break; }; break; /* freebsd32_ioctl */ case 54: switch (ndx) { case 0: p = "int"; break; case 1: p = "u_long"; break; case 2: p = "userland char *"; break; default: break; }; break; /* reboot */ case 55: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* revoke */ case 56: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* symlink */ case 57: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* readlink */ case 58: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland char *"; break; case 2: p = "size_t"; break; default: break; }; break; /* freebsd32_execve */ case 59: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland uint32_t *"; break; case 2: p = "userland uint32_t *"; break; default: break; }; break; /* umask */ case 60: switch (ndx) { case 0: p = "mode_t"; break; default: break; }; break; /* chroot */ case 61: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* msync */ case 65: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* vfork */ case 66: break; /* sbrk */ case 69: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* sstk */ case 70: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* munmap */ case 73: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; default: break; }; break; /* freebsd32_mprotect */ case 74: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* madvise */ case 75: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* mincore */ case 78: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland char *"; break; default: break; }; break; /* getgroups */ case 79: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "userland gid_t *"; break; default: break; }; break; /* setgroups */ case 80: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "userland const gid_t *"; break; default: break; }; break; /* getpgrp */ case 81: break; /* setpgid */ case 82: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_setitimer */ case 83: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct itimerval32 *"; break; case 2: p = "userland struct itimerval32 *"; break; default: break; }; break; /* swapon */ case 85: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32_getitimer */ case 86: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct itimerval32 *"; break; default: break; }; break; /* getdtablesize */ case 89: break; /* dup2 */ case 90: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "u_int"; break; default: break; }; break; /* freebsd32_fcntl */ case 92: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_select */ case 93: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland fd_set *"; break; case 2: p = "userland fd_set *"; break; case 3: p = "userland fd_set *"; break; case 4: p = "userland struct timeval32 *"; break; default: break; }; break; /* fsync */ case 95: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* setpriority */ case 96: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* socket */ case 97: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* connect */ case 98: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct sockaddr *"; break; case 2: p = "int"; break; default: break; }; break; /* getpriority */ case 100: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* bind */ case 104: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct sockaddr *"; break; case 2: p = "int"; break; default: break; }; break; /* setsockopt */ case 105: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "userland const void *"; break; case 4: p = "int"; break; default: break; }; break; /* listen */ case 106: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_gettimeofday */ case 116: switch (ndx) { case 0: p = "userland struct timeval32 *"; break; case 1: p = "userland struct timezone *"; break; default: break; }; break; /* freebsd32_getrusage */ case 117: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct rusage32 *"; break; default: break; }; break; /* getsockopt */ case 118: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "userland void *"; break; case 4: p = "userland int *"; break; default: break; }; break; /* freebsd32_readv */ case 120: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec32 *"; break; case 2: p = "u_int"; break; default: break; }; break; /* freebsd32_writev */ case 121: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec32 *"; break; case 2: p = "u_int"; break; default: break; }; break; /* freebsd32_settimeofday */ case 122: switch (ndx) { case 0: p = "userland const struct timeval32 *"; break; case 1: p = "userland const struct timezone *"; break; default: break; }; break; /* fchown */ case 123: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* fchmod */ case 124: switch (ndx) { case 0: p = "int"; break; case 1: p = "mode_t"; break; default: break; }; break; /* setreuid */ case 126: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* setregid */ case 127: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* rename */ case 128: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* flock */ case 131: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* mkfifo */ case 132: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "mode_t"; break; default: break; }; break; /* sendto */ case 133: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; case 3: p = "int"; break; case 4: p = "userland const struct sockaddr *"; break; case 5: p = "int"; break; default: break; }; break; /* shutdown */ case 134: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* socketpair */ case 135: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "userland int *"; break; default: break; }; break; /* mkdir */ case 136: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "mode_t"; break; default: break; }; break; /* rmdir */ case 137: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32_utimes */ case 138: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const struct timeval32 *"; break; default: break; }; break; /* freebsd32_adjtime */ case 140: switch (ndx) { case 0: p = "userland const struct timeval32 *"; break; case 1: p = "userland struct timeval32 *"; break; default: break; }; break; /* setsid */ case 147: break; /* quotactl */ case 148: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "userland void *"; break; default: break; }; break; /* getfh */ case 161: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland struct fhandle *"; break; default: break; }; break; /* freebsd32_sysarch */ case 165: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland char *"; break; default: break; }; break; /* rtprio */ case 166: switch (ndx) { case 0: p = "int"; break; case 1: p = "pid_t"; break; case 2: p = "userland struct rtprio *"; break; default: break; }; break; /* freebsd32_semsys */ case 169: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "int"; break; case 4: p = "int"; break; default: break; }; break; /* freebsd32_msgsys */ case 170: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "int"; break; case 4: p = "int"; break; case 5: p = "int"; break; default: break; }; break; /* freebsd32_shmsys */ case 171: switch (ndx) { case 0: p = "uint32_t"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; default: break; }; break; /* freebsd32_ntp_adjtime */ case 176: switch (ndx) { case 0: p = "userland struct timex32 *"; break; default: break; }; break; /* setgid */ case 181: switch (ndx) { case 0: p = "gid_t"; break; default: break; }; break; /* setegid */ case 182: switch (ndx) { case 0: p = "gid_t"; break; default: break; }; break; /* seteuid */ case 183: switch (ndx) { case 0: p = "uid_t"; break; default: break; }; break; /* pathconf */ case 191: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; default: break; }; break; /* fpathconf */ case 192: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* getrlimit */ case 194: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "userland struct rlimit *"; break; default: break; }; break; /* setrlimit */ case 195: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "userland struct rlimit *"; break; default: break; }; break; /* nosys */ case 198: break; /* freebsd32___sysctl */ case 202: switch (ndx) { case 0: p = "userland int *"; break; case 1: p = "u_int"; break; case 2: p = "userland void *"; break; case 3: p = "userland uint32_t *"; break; case 4: p = "userland const void *"; break; case 5: p = "size_t"; break; default: break; }; break; /* mlock */ case 203: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; default: break; }; break; /* munlock */ case 204: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; default: break; }; break; /* undelete */ case 205: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32_futimes */ case 206: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct timeval32 *"; break; default: break; }; break; /* getpgid */ case 207: switch (ndx) { case 0: p = "pid_t"; break; default: break; }; break; /* poll */ case 209: switch (ndx) { case 0: p = "userland struct pollfd *"; break; case 1: p = "u_int"; break; case 2: p = "int"; break; default: break; }; break; /* lkmnosys */ case 210: break; /* lkmnosys */ case 211: break; /* lkmnosys */ case 212: break; /* lkmnosys */ case 213: break; /* lkmnosys */ case 214: break; /* lkmnosys */ case 215: break; /* lkmnosys */ case 216: break; /* lkmnosys */ case 217: break; /* lkmnosys */ case 218: break; /* lkmnosys */ case 219: break; /* semget */ case 221: switch (ndx) { case 0: p = "key_t"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* semop */ case 222: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct sembuf *"; break; case 2: p = "size_t"; break; default: break; }; break; /* msgget */ case 225: switch (ndx) { case 0: p = "key_t"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_msgsnd */ case 226: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; case 3: p = "int"; break; default: break; }; break; /* freebsd32_msgrcv */ case 227: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "size_t"; break; case 3: p = "long"; break; case 4: p = "int"; break; default: break; }; break; /* shmat */ case 228: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "int"; break; default: break; }; break; /* shmdt */ case 230: switch (ndx) { case 0: p = "userland const void *"; break; default: break; }; break; /* shmget */ case 231: switch (ndx) { case 0: p = "key_t"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_clock_gettime */ case 232: switch (ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct timespec32 *"; break; default: break; }; break; /* freebsd32_clock_settime */ case 233: switch (ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_clock_getres */ case 234: switch (ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct timespec32 *"; break; default: break; }; break; /* freebsd32_ktimer_create */ case 235: switch (ndx) { case 0: p = "clockid_t"; break; case 1: p = "userland struct sigevent32 *"; break; case 2: p = "userland int *"; break; default: break; }; break; /* ktimer_delete */ case 236: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_ktimer_settime */ case 237: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const struct itimerspec32 *"; break; case 3: p = "userland struct itimerspec32 *"; break; default: break; }; break; /* freebsd32_ktimer_gettime */ case 238: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct itimerspec32 *"; break; default: break; }; break; /* ktimer_getoverrun */ case 239: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_nanosleep */ case 240: switch (ndx) { case 0: p = "userland const struct timespec32 *"; break; case 1: p = "userland struct timespec32 *"; break; default: break; }; break; /* ffclock_getcounter */ case 241: switch (ndx) { case 0: p = "userland ffcounter *"; break; default: break; }; break; /* ffclock_setestimate */ case 242: switch (ndx) { case 0: p = "userland struct ffclock_estimate *"; break; default: break; }; break; /* ffclock_getestimate */ case 243: switch (ndx) { case 0: p = "userland struct ffclock_estimate *"; break; default: break; }; break; /* freebsd32_clock_nanosleep */ case 244: switch (ndx) { case 0: p = "clockid_t"; break; case 1: p = "int"; break; case 2: p = "userland const struct timespec32 *"; break; case 3: p = "userland struct timespec32 *"; break; default: break; }; break; /* freebsd32_clock_getcpuclockid2 */ case 247: switch (ndx) { case 0: p = "uint32_t"; break; case 1: p = "uint32_t"; break; case 2: p = "int"; break; case 3: p = "userland clockid_t *"; break; default: break; }; break; /* minherit */ case 250: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; default: break; }; break; /* rfork */ case 251: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* issetugid */ case 253: break; /* lchown */ case 254: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_aio_read */ case 255: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* freebsd32_aio_write */ case 256: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* freebsd32_lio_listio */ case 257: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland uint32_t *"; break; case 2: p = "int"; break; case 3: p = "userland struct sigevent32 *"; break; default: break; }; break; /* lchmod */ case 274: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "mode_t"; break; default: break; }; break; /* freebsd32_lutimes */ case 276: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const struct timeval32 *"; break; default: break; }; break; /* freebsd32_preadv */ case 289: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec32 *"; break; case 2: p = "u_int"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; /* freebsd32_pwritev */ case 290: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec32 *"; break; case 2: p = "u_int"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; /* fhopen */ case 298: switch (ndx) { case 0: p = "userland const struct fhandle *"; break; case 1: p = "int"; break; default: break; }; break; /* modnext */ case 300: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_modstat */ case 301: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct module_stat32 *"; break; default: break; }; break; /* modfnext */ case 302: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* modfind */ case 303: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* kldload */ case 304: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* kldunload */ case 305: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* kldfind */ case 306: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* kldnext */ case 307: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_kldstat */ case 308: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct kld_file_stat32 *"; break; default: break; }; break; /* kldfirstmod */ case 309: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* getsid */ case 310: switch (ndx) { case 0: p = "pid_t"; break; default: break; }; break; /* setresuid */ case 311: switch (ndx) { case 0: p = "uid_t"; break; case 1: p = "uid_t"; break; case 2: p = "uid_t"; break; default: break; }; break; /* setresgid */ case 312: switch (ndx) { case 0: p = "gid_t"; break; case 1: p = "gid_t"; break; case 2: p = "gid_t"; break; default: break; }; break; /* freebsd32_aio_return */ case 314: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* freebsd32_aio_suspend */ case 315: switch (ndx) { case 0: p = "userland uint32_t *"; break; case 1: p = "int"; break; case 2: p = "userland const struct timespec32 *"; break; default: break; }; break; /* aio_cancel */ case 316: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct aiocb *"; break; default: break; }; break; /* freebsd32_aio_error */ case 317: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* yield */ case 321: break; /* mlockall */ case 324: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* munlockall */ case 325: break; /* __getcwd */ case 326: switch (ndx) { case 0: p = "userland char *"; break; case 1: p = "size_t"; break; default: break; }; break; /* sched_setparam */ case 327: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "userland const struct sched_param *"; break; default: break; }; break; /* sched_getparam */ case 328: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "userland struct sched_param *"; break; default: break; }; break; /* sched_setscheduler */ case 329: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "int"; break; case 2: p = "userland const struct sched_param *"; break; default: break; }; break; /* sched_getscheduler */ case 330: switch (ndx) { case 0: p = "pid_t"; break; default: break; }; break; /* sched_yield */ case 331: break; /* sched_get_priority_max */ case 332: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* sched_get_priority_min */ case 333: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_sched_rr_get_interval */ case 334: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "userland struct timespec32 *"; break; default: break; }; break; /* utrace */ case 335: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; default: break; }; break; /* kldsym */ case 337: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland void *"; break; default: break; }; break; /* freebsd32_jail */ case 338: switch (ndx) { case 0: p = "userland struct jail32 *"; break; default: break; }; break; /* sigprocmask */ case 340: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const sigset_t *"; break; case 2: p = "userland sigset_t *"; break; default: break; }; break; /* sigsuspend */ case 341: switch (ndx) { case 0: p = "userland const sigset_t *"; break; default: break; }; break; /* sigpending */ case 343: switch (ndx) { case 0: p = "userland sigset_t *"; break; default: break; }; break; /* freebsd32_sigtimedwait */ case 345: switch (ndx) { case 0: p = "userland const sigset_t *"; break; case 1: p = "userland struct siginfo32 *"; break; case 2: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_sigwaitinfo */ case 346: switch (ndx) { case 0: p = "userland const sigset_t *"; break; case 1: p = "userland struct siginfo32 *"; break; default: break; }; break; /* __acl_get_file */ case 347: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_set_file */ case 348: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_get_fd */ case 349: switch (ndx) { case 0: p = "int"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_set_fd */ case 350: switch (ndx) { case 0: p = "int"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_delete_file */ case 351: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; default: break; }; break; /* __acl_delete_fd */ case 352: switch (ndx) { case 0: p = "int"; break; case 1: p = "acl_type_t"; break; default: break; }; break; /* __acl_aclcheck_file */ case 353: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_aclcheck_fd */ case 354: switch (ndx) { case 0: p = "int"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* extattrctl */ case 355: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "int"; break; case 4: p = "userland const char *"; break; default: break; }; break; /* extattr_set_file */ case 356: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_get_file */ case 357: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_delete_file */ case 358: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; default: break; }; break; /* freebsd32_aio_waitcomplete */ case 359: switch (ndx) { case 0: p = "userland uint32_t *"; break; case 1: p = "userland struct timespec32 *"; break; default: break; }; break; /* getresuid */ case 360: 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; /* getresgid */ case 361: 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; /* kqueue */ case 362: break; /* extattr_set_fd */ case 371: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_get_fd */ case 372: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_delete_fd */ case 373: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; default: break; }; break; /* __setugid */ case 374: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* eaccess */ case 376: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_nmount */ case 378: switch (ndx) { case 0: p = "userland struct iovec32 *"; break; case 1: p = "unsigned int"; break; case 2: p = "int"; break; default: break; }; break; /* kenv */ case 390: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland char *"; break; case 3: p = "int"; break; default: break; }; break; /* lchflags */ case 391: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "u_long"; break; default: break; }; break; /* uuidgen */ case 392: switch (ndx) { case 0: p = "userland struct uuid *"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_sendfile */ case 393: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "size_t"; break; case 5: p = "userland struct sf_hdtr32 *"; break; case 6: p = "userland off_t *"; break; case 7: p = "int"; break; default: break; }; break; /* ksem_close */ case 400: switch (ndx) { case 0: p = "semid_t"; break; default: break; }; break; /* ksem_post */ case 401: switch (ndx) { case 0: p = "semid_t"; break; default: break; }; break; /* ksem_wait */ case 402: switch (ndx) { case 0: p = "semid_t"; break; default: break; }; break; /* ksem_trywait */ case 403: switch (ndx) { case 0: p = "semid_t"; break; default: break; }; break; /* freebsd32_ksem_init */ case 404: switch (ndx) { case 0: p = "userland semid_t *"; break; case 1: p = "unsigned int"; break; default: break; }; break; /* freebsd32_ksem_open */ case 405: switch (ndx) { case 0: p = "userland semid_t *"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "mode_t"; break; case 4: p = "unsigned int"; break; default: break; }; break; /* ksem_unlink */ case 406: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* ksem_getvalue */ case 407: switch (ndx) { case 0: p = "semid_t"; break; case 1: p = "userland int *"; break; default: break; }; break; /* ksem_destroy */ case 408: switch (ndx) { case 0: p = "semid_t"; break; default: break; }; break; /* extattr_set_link */ case 412: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_get_link */ case 413: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; case 3: p = "userland void *"; break; case 4: p = "size_t"; break; default: break; }; break; /* extattr_delete_link */ case 414: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; default: break; }; break; /* freebsd32_sigaction */ case 416: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct sigaction32 *"; break; case 2: p = "userland struct sigaction32 *"; break; default: break; }; break; /* freebsd32_sigreturn */ case 417: switch (ndx) { case 0: p = "userland const struct __ucontext32 *"; break; default: break; }; break; /* freebsd32_getcontext */ case 421: switch (ndx) { case 0: p = "userland struct __ucontext32 *"; break; default: break; }; break; /* freebsd32_setcontext */ case 422: switch (ndx) { case 0: p = "userland const struct __ucontext32 *"; break; default: break; }; break; /* freebsd32_swapcontext */ case 423: switch (ndx) { case 0: p = "userland struct __ucontext32 *"; break; case 1: p = "userland const struct __ucontext32 *"; break; default: break; }; break; /* __acl_get_link */ case 425: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_set_link */ case 426: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* __acl_delete_link */ case 427: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; default: break; }; break; /* __acl_aclcheck_link */ case 428: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "acl_type_t"; break; case 2: p = "userland struct acl *"; break; default: break; }; break; /* sigwait */ case 429: switch (ndx) { case 0: p = "userland const sigset_t *"; break; case 1: p = "userland int *"; break; default: break; }; break; /* thr_exit */ case 431: switch (ndx) { case 0: p = "userland int32_t *"; break; default: break; }; break; /* thr_self */ case 432: switch (ndx) { case 0: p = "userland int32_t *"; break; default: break; }; break; /* thr_kill */ case 433: switch (ndx) { case 0: p = "int32_t"; break; case 1: p = "int"; break; default: break; }; break; /* jail_attach */ case 436: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* extattr_list_fd */ case 437: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* extattr_list_file */ case 438: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* extattr_list_link */ case 439: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* freebsd32_ksem_timedwait */ case 441: switch (ndx) { case 0: p = "semid_t"; break; case 1: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_thr_suspend */ case 442: switch (ndx) { case 0: p = "userland const struct timespec32 *"; break; default: break; }; break; /* thr_wake */ case 443: switch (ndx) { case 0: p = "int32_t"; break; default: break; }; break; /* kldunloadf */ case 444: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* audit */ case 445: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "u_int"; break; default: break; }; break; /* auditon */ case 446: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "u_int"; break; default: break; }; break; /* getauid */ case 447: switch (ndx) { case 0: p = "userland uid_t *"; break; default: break; }; break; /* setauid */ case 448: switch (ndx) { case 0: p = "userland uid_t *"; break; default: break; }; break; /* getaudit */ case 449: switch (ndx) { case 0: p = "userland struct auditinfo *"; break; default: break; }; break; /* setaudit */ case 450: switch (ndx) { case 0: p = "userland struct auditinfo *"; break; default: break; }; break; /* getaudit_addr */ case 451: switch (ndx) { case 0: p = "userland struct auditinfo_addr *"; break; case 1: p = "u_int"; break; default: break; }; break; /* setaudit_addr */ case 452: switch (ndx) { case 0: p = "userland struct auditinfo_addr *"; break; case 1: p = "u_int"; break; default: break; }; break; /* auditctl */ case 453: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32__umtx_op */ case 454: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "int"; break; case 2: p = "u_long"; break; case 3: p = "userland void *"; break; case 4: p = "userland void *"; break; default: break; }; break; /* freebsd32_thr_new */ case 455: switch (ndx) { case 0: p = "userland struct thr_param32 *"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_sigqueue */ case 456: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "int"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_kmq_open */ case 457: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "mode_t"; break; case 3: p = "userland const struct mq_attr32 *"; break; default: break; }; break; /* freebsd32_kmq_setattr */ case 458: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct mq_attr32 *"; break; case 2: p = "userland struct mq_attr32 *"; break; default: break; }; break; /* freebsd32_kmq_timedreceive */ case 459: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland char *"; break; case 2: p = "size_t"; break; case 3: p = "userland unsigned *"; break; case 4: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_kmq_timedsend */ case 460: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "size_t"; break; case 3: p = "unsigned"; break; case 4: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_kmq_notify */ case 461: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct sigevent32 *"; break; default: break; }; break; /* kmq_unlink */ case 462: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* abort2 */ case 463: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland uint32_t *"; break; default: break; }; break; /* thr_set_name */ case 464: switch (ndx) { case 0: p = "int32_t"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* freebsd32_aio_fsync */ case 465: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct aiocb32 *"; break; default: break; }; break; /* rtprio_thread */ case 466: switch (ndx) { case 0: p = "int"; break; case 1: p = "lwpid_t"; break; case 2: p = "userland struct rtprio *"; break; default: break; }; break; /* sctp_peeloff */ case 471: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; default: break; }; break; /* sctp_generic_sendmsg */ case 472: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "int"; break; case 3: p = "userland const struct sockaddr *"; break; case 4: p = "__socklen_t"; break; case 5: p = "userland struct sctp_sndrcvinfo *"; break; case 6: p = "int"; break; default: break; }; break; /* sctp_generic_sendmsg_iov */ case 473: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec *"; break; case 2: p = "int"; break; case 3: p = "userland const struct sockaddr *"; break; case 4: p = "__socklen_t"; break; case 5: p = "userland struct sctp_sndrcvinfo *"; break; case 6: p = "int"; break; default: break; }; break; /* sctp_generic_recvmsg */ case 474: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct iovec *"; break; case 2: p = "int"; break; case 3: p = "userland struct sockaddr *"; break; case 4: p = "userland __socklen_t *"; break; case 5: p = "userland struct sctp_sndrcvinfo *"; break; case 6: p = "userland int *"; break; default: break; }; break; #ifdef PAD64_REQUIRED /* freebsd32_pread */ case 475: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "size_t"; break; case 3: p = "int"; break; case 4: p = "uint32_t"; break; case 5: p = "uint32_t"; break; default: break; }; break; /* freebsd32_pwrite */ case 476: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; case 3: p = "int"; break; case 4: p = "uint32_t"; break; case 5: p = "uint32_t"; break; default: break; }; break; /* freebsd32_mmap */ case 477: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; case 3: p = "int"; break; case 4: p = "int"; break; case 5: p = "int"; break; case 6: p = "uint32_t"; break; case 7: p = "uint32_t"; break; default: break; }; break; /* freebsd32_lseek */ case 478: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "int"; break; default: break; }; break; /* freebsd32_truncate */ case 479: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; default: break; }; break; /* freebsd32_ftruncate */ case 480: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; default: break; }; break; #else /* freebsd32_pread */ case 475: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland void *"; break; case 2: p = "size_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; /* freebsd32_pwrite */ case 476: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; /* freebsd32_mmap */ case 477: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "int"; break; case 3: p = "int"; break; case 4: p = "int"; break; case 5: p = "uint32_t"; break; case 6: p = "uint32_t"; break; default: break; }; break; /* freebsd32_lseek */ case 478: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "int"; break; default: break; }; break; /* freebsd32_truncate */ case 479: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; default: break; }; break; /* freebsd32_ftruncate */ case 480: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; default: break; }; break; #endif /* thr_kill2 */ case 481: switch (ndx) { case 0: p = "pid_t"; break; case 1: p = "int32_t"; break; case 2: p = "int"; break; default: break; }; break; /* shm_unlink */ case 483: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* cpuset */ case 484: switch (ndx) { case 0: p = "userland cpusetid_t *"; break; default: break; }; break; #ifdef PAD64_REQUIRED /* freebsd32_cpuset_setid */ case 485: switch (ndx) { case 0: p = "cpuwhich_t"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "cpusetid_t"; break; default: break; }; break; #else /* freebsd32_cpuset_setid */ case 485: switch (ndx) { case 0: p = "cpuwhich_t"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "cpusetid_t"; break; default: break; }; break; #endif /* freebsd32_cpuset_getid */ case 486: switch (ndx) { case 0: p = "cpulevel_t"; break; case 1: p = "cpuwhich_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "userland cpusetid_t *"; break; default: break; }; break; /* freebsd32_cpuset_getaffinity */ case 487: switch (ndx) { case 0: p = "cpulevel_t"; break; case 1: p = "cpuwhich_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "size_t"; break; case 5: p = "userland cpuset_t *"; break; default: break; }; break; /* freebsd32_cpuset_setaffinity */ case 488: switch (ndx) { case 0: p = "cpulevel_t"; break; case 1: p = "cpuwhich_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "size_t"; break; case 5: p = "userland const cpuset_t *"; break; default: break; }; break; /* faccessat */ case 489: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "int"; break; default: break; }; break; /* fchmodat */ case 490: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "mode_t"; break; case 3: p = "int"; break; default: break; }; break; /* fchownat */ case 491: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "uid_t"; break; case 3: p = "gid_t"; break; case 4: p = "int"; break; default: break; }; break; /* freebsd32_fexecve */ case 492: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland uint32_t *"; break; case 2: p = "userland uint32_t *"; break; default: break; }; break; /* freebsd32_futimesat */ case 494: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland const struct timeval32 *"; break; default: break; }; break; /* linkat */ case 495: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "userland const char *"; break; case 4: p = "int"; break; default: break; }; break; /* mkdirat */ case 496: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "mode_t"; break; default: break; }; break; /* mkfifoat */ case 497: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "mode_t"; break; default: break; }; break; /* openat */ case 499: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "mode_t"; break; default: break; }; break; /* readlinkat */ case 500: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland char *"; break; case 3: p = "size_t"; break; default: break; }; break; /* renameat */ case 501: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "userland const char *"; break; default: break; }; break; /* symlinkat */ case 502: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; default: break; }; break; /* unlinkat */ case 503: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; default: break; }; break; /* posix_openpt */ case 504: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* gssd_syscall */ case 505: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* freebsd32_jail_get */ case 506: switch (ndx) { case 0: p = "userland struct iovec32 *"; break; case 1: p = "unsigned int"; break; case 2: p = "int"; break; default: break; }; break; /* freebsd32_jail_set */ case 507: switch (ndx) { case 0: p = "userland struct iovec32 *"; break; case 1: p = "unsigned int"; break; case 2: p = "int"; break; default: break; }; break; /* jail_remove */ case 508: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32___semctl */ case 510: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "int"; break; case 3: p = "userland union semun32 *"; break; default: break; }; break; /* freebsd32_msgctl */ case 511: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland struct msqid_ds32 *"; break; default: break; }; break; /* freebsd32_shmctl */ case 512: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland struct shmid_ds32 *"; break; default: break; }; break; /* lpathconf */ case 513: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; default: break; }; break; /* __cap_rights_get */ case 515: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland cap_rights_t *"; break; default: break; }; break; /* cap_enter */ case 516: break; /* cap_getmode */ case 517: switch (ndx) { case 0: p = "userland u_int *"; break; default: break; }; break; /* pdfork */ case 518: switch (ndx) { case 0: p = "userland int *"; break; case 1: p = "int"; break; default: break; }; break; /* pdkill */ case 519: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; default: break; }; break; /* pdgetpid */ case 520: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland pid_t *"; break; default: break; }; break; /* freebsd32_pselect */ case 522: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland fd_set *"; break; case 2: p = "userland fd_set *"; break; case 3: p = "userland fd_set *"; break; case 4: p = "userland const struct timespec32 *"; break; case 5: p = "userland const sigset_t *"; break; default: break; }; break; /* getloginclass */ case 523: switch (ndx) { case 0: p = "userland char *"; break; case 1: p = "size_t"; break; default: break; }; break; /* setloginclass */ case 524: switch (ndx) { case 0: p = "userland const char *"; break; default: break; }; break; /* rctl_get_racct */ case 525: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* rctl_get_rules */ case 526: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* rctl_get_limits */ case 527: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* rctl_add_rule */ case 528: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; /* rctl_remove_rule */ case 529: switch (ndx) { case 0: p = "userland const void *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "size_t"; break; default: break; }; break; #ifdef PAD64_REQUIRED /* freebsd32_posix_fallocate */ case 530: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; case 5: p = "uint32_t"; break; default: break; }; break; /* freebsd32_posix_fadvise */ case 531: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; case 5: p = "uint32_t"; break; case 6: p = "int"; break; default: break; }; break; /* freebsd32_wait6 */ case 532: switch (ndx) { case 0: p = "idtype_t"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "userland int *"; break; case 5: p = "int"; break; case 6: - p = "userland struct wrusage32 *"; + p = "userland struct __wrusage32 *"; break; case 7: p = "userland struct siginfo32 *"; break; default: break; }; break; #else /* freebsd32_posix_fallocate */ case 530: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; /* freebsd32_posix_fadvise */ case 531: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; case 5: p = "int"; break; default: break; }; break; /* freebsd32_wait6 */ case 532: switch (ndx) { case 0: p = "idtype_t"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "userland int *"; break; case 4: p = "int"; break; case 5: - p = "userland struct wrusage32 *"; + p = "userland struct __wrusage32 *"; break; case 6: p = "userland struct siginfo32 *"; break; default: break; }; break; #endif /* cap_rights_limit */ case 533: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland cap_rights_t *"; break; default: break; }; break; /* freebsd32_cap_ioctls_limit */ case 534: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const uint32_t *"; break; case 2: p = "size_t"; break; default: break; }; break; /* freebsd32_cap_ioctls_get */ case 535: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland uint32_t *"; break; case 2: p = "size_t"; break; default: break; }; break; /* cap_fcntls_limit */ case 536: switch (ndx) { case 0: p = "int"; break; case 1: p = "uint32_t"; break; default: break; }; break; /* cap_fcntls_get */ case 537: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland uint32_t *"; break; default: break; }; break; /* bindat */ case 538: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const struct sockaddr *"; break; case 3: p = "int"; break; default: break; }; break; /* connectat */ case 539: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const struct sockaddr *"; break; case 3: p = "int"; break; default: break; }; break; /* chflagsat */ case 540: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "u_long"; break; case 3: p = "int"; break; default: break; }; break; /* accept4 */ case 541: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct sockaddr *"; break; case 2: p = "userland __socklen_t *"; break; case 3: p = "int"; break; default: break; }; break; /* pipe2 */ case 542: switch (ndx) { case 0: p = "userland int *"; break; case 1: p = "int"; break; default: break; }; break; /* freebsd32_aio_mlock */ case 543: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; #ifdef PAD64_REQUIRED /* freebsd32_procctl */ case 544: switch (ndx) { case 0: p = "idtype_t"; break; case 1: p = "int"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "int"; break; case 5: p = "userland void *"; break; default: break; }; break; #else /* freebsd32_procctl */ case 544: switch (ndx) { case 0: p = "idtype_t"; break; case 1: p = "uint32_t"; break; case 2: p = "uint32_t"; break; case 3: p = "int"; break; case 4: p = "userland void *"; break; default: break; }; break; #endif /* freebsd32_ppoll */ case 545: switch (ndx) { case 0: p = "userland struct pollfd *"; break; case 1: p = "u_int"; break; case 2: p = "userland const struct timespec32 *"; break; case 3: p = "userland const sigset_t *"; break; default: break; }; break; /* freebsd32_futimens */ case 546: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_utimensat */ case 547: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland const struct timespec32 *"; break; case 3: p = "int"; break; default: break; }; break; /* fdatasync */ case 550: switch (ndx) { case 0: p = "int"; break; default: break; }; break; /* freebsd32_fstat */ case 551: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct stat32 *"; break; default: break; }; break; /* freebsd32_fstatat */ case 552: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland struct stat32 *"; break; case 3: p = "int"; break; default: break; }; break; /* freebsd32_fhstat */ case 553: switch (ndx) { case 0: p = "userland const struct fhandle *"; break; case 1: p = "userland struct stat32 *"; break; default: break; }; break; /* getdirentries */ case 554: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland char *"; break; case 2: p = "size_t"; break; case 3: p = "userland off_t *"; break; default: break; }; break; /* statfs */ case 555: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland struct statfs *"; break; default: break; }; break; /* fstatfs */ case 556: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland struct statfs *"; break; default: break; }; break; /* getfsstat */ case 557: switch (ndx) { case 0: p = "userland struct statfs *"; break; case 1: p = "long"; break; case 2: p = "int"; break; default: break; }; break; /* fhstatfs */ case 558: switch (ndx) { case 0: p = "userland const struct fhandle *"; break; case 1: p = "userland struct statfs *"; break; default: break; }; break; #ifdef PAD64_REQUIRED /* freebsd32_mknodat */ case 559: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "mode_t"; break; case 3: p = "int"; break; case 4: p = "uint32_t"; break; case 5: p = "uint32_t"; break; default: break; }; break; #else /* freebsd32_mknodat */ case 559: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "mode_t"; break; case 3: p = "uint32_t"; break; case 4: p = "uint32_t"; break; default: break; }; break; #endif /* freebsd32_kevent */ case 560: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const struct kevent32 *"; break; case 2: p = "int"; break; case 3: p = "userland struct kevent32 *"; break; case 4: p = "int"; break; case 5: p = "userland const struct timespec32 *"; break; default: break; }; break; /* freebsd32_cpuset_getdomain */ case 561: switch (ndx) { case 0: p = "cpulevel_t"; break; case 1: p = "cpuwhich_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "size_t"; break; case 5: p = "userland domainset_t *"; break; case 6: p = "userland int *"; break; default: break; }; break; /* freebsd32_cpuset_setdomain */ case 562: switch (ndx) { case 0: p = "cpulevel_t"; break; case 1: p = "cpuwhich_t"; break; case 2: p = "uint32_t"; break; case 3: p = "uint32_t"; break; case 4: p = "size_t"; break; case 5: p = "userland domainset_t *"; break; case 6: p = "int"; break; default: break; }; break; /* getrandom */ case 563: switch (ndx) { case 0: p = "userland void *"; break; case 1: p = "size_t"; break; case 2: p = "unsigned int"; break; default: break; }; break; /* getfhat */ case 564: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland char *"; break; case 2: p = "userland struct fhandle *"; break; case 3: p = "int"; break; default: break; }; break; /* fhlink */ case 565: switch (ndx) { case 0: p = "userland struct fhandle *"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* fhlinkat */ case 566: switch (ndx) { case 0: p = "userland struct fhandle *"; break; case 1: p = "int"; break; case 2: p = "userland const char *"; break; default: break; }; break; /* fhreadlink */ case 567: switch (ndx) { case 0: p = "userland struct fhandle *"; break; case 1: p = "userland char *"; break; case 2: p = "size_t"; break; default: break; }; break; /* funlinkat */ case 568: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; case 3: p = "int"; break; default: break; }; break; /* copy_file_range */ case 569: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland off_t *"; break; case 2: p = "int"; break; case 3: p = "userland off_t *"; break; case 4: p = "size_t"; break; case 5: p = "unsigned int"; break; default: break; }; break; /* freebsd32___sysctlbyname */ case 570: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "size_t"; break; case 2: p = "userland void *"; break; case 3: p = "userland uint32_t *"; break; case 4: p = "userland void *"; break; case 5: p = "size_t"; break; default: break; }; break; /* shm_open2 */ case 571: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "int"; break; case 2: p = "mode_t"; break; case 3: p = "int"; break; case 4: p = "userland const char *"; break; default: break; }; break; /* shm_rename */ case 572: switch (ndx) { case 0: p = "userland const char *"; break; case 1: p = "userland const char *"; break; case 2: p = "int"; break; default: break; }; break; /* sigfastblock */ case 573: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland uint32_t *"; break; default: break; }; break; /* __realpathat */ case 574: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; case 2: p = "userland char *"; break; case 3: p = "size_t"; break; case 4: p = "int"; break; default: break; }; break; /* close_range */ case 575: switch (ndx) { case 0: p = "u_int"; break; case 1: p = "u_int"; break; case 2: p = "int"; break; default: break; }; break; /* rpctls_syscall */ case 576: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const char *"; break; default: break; }; break; /* __specialfd */ case 577: switch (ndx) { case 0: p = "int"; break; case 1: p = "userland const void *"; break; case 2: p = "size_t"; break; default: break; }; break; /* freebsd32_aio_writev */ case 578: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* freebsd32_aio_readv */ case 579: switch (ndx) { case 0: p = "userland struct aiocb32 *"; break; default: break; }; break; /* freebsd32_fspacectl */ case 580: switch (ndx) { case 0: p = "int"; break; case 1: p = "int"; break; case 2: p = "userland const struct spacectl_range32 *"; break; case 3: p = "int"; break; case 4: p = "userland struct spacectl_range32 *"; break; default: break; }; break; /* sched_getcpu */ case 581: 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) { #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif /* nosys */ case 0: /* sys_exit */ case 1: if (ndx == 0 || ndx == 1) p = "void"; break; /* fork */ case 2: /* read */ case 3: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* write */ case 4: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* open */ case 5: if (ndx == 0 || ndx == 1) p = "int"; break; /* close */ case 6: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_wait4 */ case 7: if (ndx == 0 || ndx == 1) p = "int"; break; /* link */ case 9: if (ndx == 0 || ndx == 1) p = "int"; break; /* unlink */ case 10: if (ndx == 0 || ndx == 1) p = "int"; break; /* chdir */ case 12: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchdir */ case 13: if (ndx == 0 || ndx == 1) p = "int"; break; /* chmod */ case 15: if (ndx == 0 || ndx == 1) p = "int"; break; /* chown */ case 16: if (ndx == 0 || ndx == 1) p = "int"; break; /* break */ case 17: if (ndx == 0 || ndx == 1) p = "void *"; break; /* getpid */ case 20: /* mount */ case 21: if (ndx == 0 || ndx == 1) p = "int"; break; /* unmount */ case 22: if (ndx == 0 || ndx == 1) p = "int"; break; /* setuid */ case 23: if (ndx == 0 || ndx == 1) p = "int"; break; /* getuid */ case 24: /* geteuid */ case 25: /* freebsd32_ptrace */ case 26: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_recvmsg */ case 27: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sendmsg */ case 28: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_recvfrom */ case 29: if (ndx == 0 || ndx == 1) p = "int"; break; /* accept */ case 30: if (ndx == 0 || ndx == 1) p = "int"; break; /* getpeername */ case 31: if (ndx == 0 || ndx == 1) p = "int"; break; /* getsockname */ case 32: if (ndx == 0 || ndx == 1) p = "int"; break; /* access */ case 33: if (ndx == 0 || ndx == 1) p = "int"; break; /* chflags */ case 34: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchflags */ case 35: if (ndx == 0 || ndx == 1) p = "int"; break; /* sync */ case 36: /* kill */ case 37: if (ndx == 0 || ndx == 1) p = "int"; break; /* getppid */ case 39: /* dup */ case 41: if (ndx == 0 || ndx == 1) p = "int"; break; /* getegid */ case 43: /* profil */ case 44: if (ndx == 0 || ndx == 1) p = "int"; break; /* ktrace */ case 45: if (ndx == 0 || ndx == 1) p = "int"; break; /* getgid */ case 47: /* getlogin */ case 49: if (ndx == 0 || ndx == 1) p = "int"; break; /* setlogin */ case 50: if (ndx == 0 || ndx == 1) p = "int"; break; /* acct */ case 51: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigaltstack */ case 53: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ioctl */ case 54: if (ndx == 0 || ndx == 1) p = "int"; break; /* reboot */ case 55: if (ndx == 0 || ndx == 1) p = "int"; break; /* revoke */ case 56: if (ndx == 0 || ndx == 1) p = "int"; break; /* symlink */ case 57: if (ndx == 0 || ndx == 1) p = "int"; break; /* readlink */ case 58: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_execve */ case 59: if (ndx == 0 || ndx == 1) p = "int"; break; /* umask */ case 60: if (ndx == 0 || ndx == 1) p = "int"; break; /* chroot */ case 61: if (ndx == 0 || ndx == 1) p = "int"; break; /* msync */ case 65: if (ndx == 0 || ndx == 1) p = "int"; break; /* vfork */ case 66: /* sbrk */ case 69: if (ndx == 0 || ndx == 1) p = "int"; break; /* sstk */ case 70: if (ndx == 0 || ndx == 1) p = "int"; break; /* munmap */ case 73: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_mprotect */ case 74: if (ndx == 0 || ndx == 1) p = "int"; break; /* madvise */ case 75: if (ndx == 0 || ndx == 1) p = "int"; break; /* mincore */ case 78: if (ndx == 0 || ndx == 1) p = "int"; break; /* getgroups */ case 79: if (ndx == 0 || ndx == 1) p = "int"; break; /* setgroups */ case 80: if (ndx == 0 || ndx == 1) p = "int"; break; /* getpgrp */ case 81: /* setpgid */ case 82: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_setitimer */ case 83: if (ndx == 0 || ndx == 1) p = "int"; break; /* swapon */ case 85: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_getitimer */ case 86: if (ndx == 0 || ndx == 1) p = "int"; break; /* getdtablesize */ case 89: /* dup2 */ case 90: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fcntl */ case 92: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_select */ case 93: if (ndx == 0 || ndx == 1) p = "int"; break; /* fsync */ case 95: if (ndx == 0 || ndx == 1) p = "int"; break; /* setpriority */ case 96: if (ndx == 0 || ndx == 1) p = "int"; break; /* socket */ case 97: if (ndx == 0 || ndx == 1) p = "int"; break; /* connect */ case 98: if (ndx == 0 || ndx == 1) p = "int"; break; /* getpriority */ case 100: if (ndx == 0 || ndx == 1) p = "int"; break; /* bind */ case 104: if (ndx == 0 || ndx == 1) p = "int"; break; /* setsockopt */ case 105: if (ndx == 0 || ndx == 1) p = "int"; break; /* listen */ case 106: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_gettimeofday */ case 116: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_getrusage */ case 117: if (ndx == 0 || ndx == 1) p = "int"; break; /* getsockopt */ case 118: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_readv */ case 120: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_writev */ case 121: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_settimeofday */ case 122: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchown */ case 123: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchmod */ case 124: if (ndx == 0 || ndx == 1) p = "int"; break; /* setreuid */ case 126: if (ndx == 0 || ndx == 1) p = "int"; break; /* setregid */ case 127: if (ndx == 0 || ndx == 1) p = "int"; break; /* rename */ case 128: if (ndx == 0 || ndx == 1) p = "int"; break; /* flock */ case 131: if (ndx == 0 || ndx == 1) p = "int"; break; /* mkfifo */ case 132: if (ndx == 0 || ndx == 1) p = "int"; break; /* sendto */ case 133: if (ndx == 0 || ndx == 1) p = "int"; break; /* shutdown */ case 134: if (ndx == 0 || ndx == 1) p = "int"; break; /* socketpair */ case 135: if (ndx == 0 || ndx == 1) p = "int"; break; /* mkdir */ case 136: if (ndx == 0 || ndx == 1) p = "int"; break; /* rmdir */ case 137: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_utimes */ case 138: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_adjtime */ case 140: if (ndx == 0 || ndx == 1) p = "int"; break; /* setsid */ case 147: /* quotactl */ case 148: if (ndx == 0 || ndx == 1) p = "int"; break; /* getfh */ case 161: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sysarch */ case 165: if (ndx == 0 || ndx == 1) p = "int"; break; /* rtprio */ case 166: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_semsys */ case 169: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_msgsys */ case 170: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_shmsys */ case 171: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ntp_adjtime */ case 176: if (ndx == 0 || ndx == 1) p = "int"; break; /* setgid */ case 181: if (ndx == 0 || ndx == 1) p = "int"; break; /* setegid */ case 182: if (ndx == 0 || ndx == 1) p = "int"; break; /* seteuid */ case 183: if (ndx == 0 || ndx == 1) p = "int"; break; /* pathconf */ case 191: if (ndx == 0 || ndx == 1) p = "int"; break; /* fpathconf */ case 192: if (ndx == 0 || ndx == 1) p = "int"; break; /* getrlimit */ case 194: if (ndx == 0 || ndx == 1) p = "int"; break; /* setrlimit */ case 195: if (ndx == 0 || ndx == 1) p = "int"; break; /* nosys */ case 198: /* freebsd32___sysctl */ case 202: if (ndx == 0 || ndx == 1) p = "int"; break; /* mlock */ case 203: if (ndx == 0 || ndx == 1) p = "int"; break; /* munlock */ case 204: if (ndx == 0 || ndx == 1) p = "int"; break; /* undelete */ case 205: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_futimes */ case 206: if (ndx == 0 || ndx == 1) p = "int"; break; /* getpgid */ case 207: if (ndx == 0 || ndx == 1) p = "int"; break; /* poll */ case 209: if (ndx == 0 || ndx == 1) p = "int"; break; /* lkmnosys */ case 210: /* lkmnosys */ case 211: /* lkmnosys */ case 212: /* lkmnosys */ case 213: /* lkmnosys */ case 214: /* lkmnosys */ case 215: /* lkmnosys */ case 216: /* lkmnosys */ case 217: /* lkmnosys */ case 218: /* lkmnosys */ case 219: /* semget */ case 221: if (ndx == 0 || ndx == 1) p = "int"; break; /* semop */ case 222: if (ndx == 0 || ndx == 1) p = "int"; break; /* msgget */ case 225: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_msgsnd */ case 226: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_msgrcv */ case 227: if (ndx == 0 || ndx == 1) p = "int"; break; /* shmat */ case 228: if (ndx == 0 || ndx == 1) p = "void *"; break; /* shmdt */ case 230: if (ndx == 0 || ndx == 1) p = "int"; break; /* shmget */ case 231: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_clock_gettime */ case 232: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_clock_settime */ case 233: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_clock_getres */ case 234: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ktimer_create */ case 235: if (ndx == 0 || ndx == 1) p = "int"; break; /* ktimer_delete */ case 236: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ktimer_settime */ case 237: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ktimer_gettime */ case 238: if (ndx == 0 || ndx == 1) p = "int"; break; /* ktimer_getoverrun */ case 239: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_nanosleep */ case 240: if (ndx == 0 || ndx == 1) p = "int"; break; /* ffclock_getcounter */ case 241: if (ndx == 0 || ndx == 1) p = "int"; break; /* ffclock_setestimate */ case 242: if (ndx == 0 || ndx == 1) p = "int"; break; /* ffclock_getestimate */ case 243: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_clock_nanosleep */ case 244: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_clock_getcpuclockid2 */ case 247: if (ndx == 0 || ndx == 1) p = "int"; break; /* minherit */ case 250: if (ndx == 0 || ndx == 1) p = "int"; break; /* rfork */ case 251: if (ndx == 0 || ndx == 1) p = "int"; break; /* issetugid */ case 253: /* lchown */ case 254: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_read */ case 255: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_write */ case 256: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_lio_listio */ case 257: if (ndx == 0 || ndx == 1) p = "int"; break; /* lchmod */ case 274: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_lutimes */ case 276: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_preadv */ case 289: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_pwritev */ case 290: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* fhopen */ case 298: if (ndx == 0 || ndx == 1) p = "int"; break; /* modnext */ case 300: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_modstat */ case 301: if (ndx == 0 || ndx == 1) p = "int"; break; /* modfnext */ case 302: if (ndx == 0 || ndx == 1) p = "int"; break; /* modfind */ case 303: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldload */ case 304: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldunload */ case 305: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldfind */ case 306: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldnext */ case 307: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kldstat */ case 308: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldfirstmod */ case 309: if (ndx == 0 || ndx == 1) p = "int"; break; /* getsid */ case 310: if (ndx == 0 || ndx == 1) p = "int"; break; /* setresuid */ case 311: if (ndx == 0 || ndx == 1) p = "int"; break; /* setresgid */ case 312: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_return */ case 314: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_suspend */ case 315: if (ndx == 0 || ndx == 1) p = "int"; break; /* aio_cancel */ case 316: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_error */ case 317: if (ndx == 0 || ndx == 1) p = "int"; break; /* yield */ case 321: /* mlockall */ case 324: if (ndx == 0 || ndx == 1) p = "int"; break; /* munlockall */ case 325: /* __getcwd */ case 326: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_setparam */ case 327: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_getparam */ case 328: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_setscheduler */ case 329: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_getscheduler */ case 330: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_yield */ case 331: /* sched_get_priority_max */ case 332: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_get_priority_min */ case 333: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sched_rr_get_interval */ case 334: if (ndx == 0 || ndx == 1) p = "int"; break; /* utrace */ case 335: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldsym */ case 337: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_jail */ case 338: if (ndx == 0 || ndx == 1) p = "int"; break; /* sigprocmask */ case 340: if (ndx == 0 || ndx == 1) p = "int"; break; /* sigsuspend */ case 341: if (ndx == 0 || ndx == 1) p = "int"; break; /* sigpending */ case 343: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigtimedwait */ case 345: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigwaitinfo */ case 346: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_get_file */ case 347: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_set_file */ case 348: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_get_fd */ case 349: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_set_fd */ case 350: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_delete_file */ case 351: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_delete_fd */ case 352: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_aclcheck_file */ case 353: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_aclcheck_fd */ case 354: if (ndx == 0 || ndx == 1) p = "int"; break; /* extattrctl */ case 355: if (ndx == 0 || ndx == 1) p = "int"; break; /* extattr_set_file */ case 356: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_get_file */ case 357: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_delete_file */ case 358: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_waitcomplete */ case 359: if (ndx == 0 || ndx == 1) p = "int"; break; /* getresuid */ case 360: if (ndx == 0 || ndx == 1) p = "int"; break; /* getresgid */ case 361: if (ndx == 0 || ndx == 1) p = "int"; break; /* kqueue */ case 362: /* extattr_set_fd */ case 371: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_get_fd */ case 372: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_delete_fd */ case 373: if (ndx == 0 || ndx == 1) p = "int"; break; /* __setugid */ case 374: if (ndx == 0 || ndx == 1) p = "int"; break; /* eaccess */ case 376: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_nmount */ case 378: if (ndx == 0 || ndx == 1) p = "int"; break; /* kenv */ case 390: if (ndx == 0 || ndx == 1) p = "int"; break; /* lchflags */ case 391: if (ndx == 0 || ndx == 1) p = "int"; break; /* uuidgen */ case 392: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sendfile */ case 393: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_close */ case 400: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_post */ case 401: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_wait */ case 402: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_trywait */ case 403: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ksem_init */ case 404: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ksem_open */ case 405: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_unlink */ case 406: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_getvalue */ case 407: if (ndx == 0 || ndx == 1) p = "int"; break; /* ksem_destroy */ case 408: if (ndx == 0 || ndx == 1) p = "int"; break; /* extattr_set_link */ case 412: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_get_link */ case 413: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_delete_link */ case 414: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigaction */ case 416: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigreturn */ case 417: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_getcontext */ case 421: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_setcontext */ case 422: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_swapcontext */ case 423: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_get_link */ case 425: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_set_link */ case 426: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_delete_link */ case 427: if (ndx == 0 || ndx == 1) p = "int"; break; /* __acl_aclcheck_link */ case 428: if (ndx == 0 || ndx == 1) p = "int"; break; /* sigwait */ case 429: if (ndx == 0 || ndx == 1) p = "int"; break; /* thr_exit */ case 431: if (ndx == 0 || ndx == 1) p = "void"; break; /* thr_self */ case 432: if (ndx == 0 || ndx == 1) p = "int"; break; /* thr_kill */ case 433: if (ndx == 0 || ndx == 1) p = "int"; break; /* jail_attach */ case 436: if (ndx == 0 || ndx == 1) p = "int"; break; /* extattr_list_fd */ case 437: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_list_file */ case 438: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* extattr_list_link */ case 439: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_ksem_timedwait */ case 441: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_thr_suspend */ case 442: if (ndx == 0 || ndx == 1) p = "int"; break; /* thr_wake */ case 443: if (ndx == 0 || ndx == 1) p = "int"; break; /* kldunloadf */ case 444: if (ndx == 0 || ndx == 1) p = "int"; break; /* audit */ case 445: if (ndx == 0 || ndx == 1) p = "int"; break; /* auditon */ case 446: if (ndx == 0 || ndx == 1) p = "int"; break; /* getauid */ case 447: if (ndx == 0 || ndx == 1) p = "int"; break; /* setauid */ case 448: if (ndx == 0 || ndx == 1) p = "int"; break; /* getaudit */ case 449: if (ndx == 0 || ndx == 1) p = "int"; break; /* setaudit */ case 450: if (ndx == 0 || ndx == 1) p = "int"; break; /* getaudit_addr */ case 451: if (ndx == 0 || ndx == 1) p = "int"; break; /* setaudit_addr */ case 452: if (ndx == 0 || ndx == 1) p = "int"; break; /* auditctl */ case 453: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32__umtx_op */ case 454: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_thr_new */ case 455: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_sigqueue */ case 456: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kmq_open */ case 457: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kmq_setattr */ case 458: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kmq_timedreceive */ case 459: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kmq_timedsend */ case 460: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_kmq_notify */ case 461: if (ndx == 0 || ndx == 1) p = "int"; break; /* kmq_unlink */ case 462: if (ndx == 0 || ndx == 1) p = "int"; break; /* abort2 */ case 463: if (ndx == 0 || ndx == 1) p = "int"; break; /* thr_set_name */ case 464: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_fsync */ case 465: if (ndx == 0 || ndx == 1) p = "int"; break; /* rtprio_thread */ case 466: if (ndx == 0 || ndx == 1) p = "int"; break; /* sctp_peeloff */ case 471: if (ndx == 0 || ndx == 1) p = "int"; break; /* sctp_generic_sendmsg */ case 472: if (ndx == 0 || ndx == 1) p = "int"; break; /* sctp_generic_sendmsg_iov */ case 473: if (ndx == 0 || ndx == 1) p = "int"; break; /* sctp_generic_recvmsg */ case 474: if (ndx == 0 || ndx == 1) p = "int"; break; #ifdef PAD64_REQUIRED /* freebsd32_pread */ case 475: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_pwrite */ case 476: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_mmap */ case 477: if (ndx == 0 || ndx == 1) p = "void *"; break; /* freebsd32_lseek */ case 478: if (ndx == 0 || ndx == 1) p = "off_t"; break; /* freebsd32_truncate */ case 479: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ftruncate */ case 480: if (ndx == 0 || ndx == 1) p = "int"; break; #else /* freebsd32_pread */ case 475: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_pwrite */ case 476: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32_mmap */ case 477: if (ndx == 0 || ndx == 1) p = "void *"; break; /* freebsd32_lseek */ case 478: if (ndx == 0 || ndx == 1) p = "off_t"; break; /* freebsd32_truncate */ case 479: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_ftruncate */ case 480: if (ndx == 0 || ndx == 1) p = "int"; break; #endif /* thr_kill2 */ case 481: if (ndx == 0 || ndx == 1) p = "int"; break; /* shm_unlink */ case 483: if (ndx == 0 || ndx == 1) p = "int"; break; /* cpuset */ case 484: if (ndx == 0 || ndx == 1) p = "int"; break; #ifdef PAD64_REQUIRED /* freebsd32_cpuset_setid */ case 485: if (ndx == 0 || ndx == 1) p = "int"; break; #else /* freebsd32_cpuset_setid */ case 485: if (ndx == 0 || ndx == 1) p = "int"; break; #endif /* freebsd32_cpuset_getid */ case 486: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cpuset_getaffinity */ case 487: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cpuset_setaffinity */ case 488: if (ndx == 0 || ndx == 1) p = "int"; break; /* faccessat */ case 489: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchmodat */ case 490: if (ndx == 0 || ndx == 1) p = "int"; break; /* fchownat */ case 491: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fexecve */ case 492: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_futimesat */ case 494: if (ndx == 0 || ndx == 1) p = "int"; break; /* linkat */ case 495: if (ndx == 0 || ndx == 1) p = "int"; break; /* mkdirat */ case 496: if (ndx == 0 || ndx == 1) p = "int"; break; /* mkfifoat */ case 497: if (ndx == 0 || ndx == 1) p = "int"; break; /* openat */ case 499: if (ndx == 0 || ndx == 1) p = "int"; break; /* readlinkat */ case 500: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* renameat */ case 501: if (ndx == 0 || ndx == 1) p = "int"; break; /* symlinkat */ case 502: if (ndx == 0 || ndx == 1) p = "int"; break; /* unlinkat */ case 503: if (ndx == 0 || ndx == 1) p = "int"; break; /* posix_openpt */ case 504: if (ndx == 0 || ndx == 1) p = "int"; break; /* gssd_syscall */ case 505: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_jail_get */ case 506: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_jail_set */ case 507: if (ndx == 0 || ndx == 1) p = "int"; break; /* jail_remove */ case 508: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32___semctl */ case 510: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_msgctl */ case 511: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_shmctl */ case 512: if (ndx == 0 || ndx == 1) p = "int"; break; /* lpathconf */ case 513: if (ndx == 0 || ndx == 1) p = "int"; break; /* __cap_rights_get */ case 515: if (ndx == 0 || ndx == 1) p = "int"; break; /* cap_enter */ case 516: /* cap_getmode */ case 517: if (ndx == 0 || ndx == 1) p = "int"; break; /* pdfork */ case 518: if (ndx == 0 || ndx == 1) p = "int"; break; /* pdkill */ case 519: if (ndx == 0 || ndx == 1) p = "int"; break; /* pdgetpid */ case 520: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_pselect */ case 522: if (ndx == 0 || ndx == 1) p = "int"; break; /* getloginclass */ case 523: if (ndx == 0 || ndx == 1) p = "int"; break; /* setloginclass */ case 524: if (ndx == 0 || ndx == 1) p = "int"; break; /* rctl_get_racct */ case 525: if (ndx == 0 || ndx == 1) p = "int"; break; /* rctl_get_rules */ case 526: if (ndx == 0 || ndx == 1) p = "int"; break; /* rctl_get_limits */ case 527: if (ndx == 0 || ndx == 1) p = "int"; break; /* rctl_add_rule */ case 528: if (ndx == 0 || ndx == 1) p = "int"; break; /* rctl_remove_rule */ case 529: if (ndx == 0 || ndx == 1) p = "int"; break; #ifdef PAD64_REQUIRED /* freebsd32_posix_fallocate */ case 530: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_posix_fadvise */ case 531: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_wait6 */ case 532: if (ndx == 0 || ndx == 1) p = "int"; break; #else /* freebsd32_posix_fallocate */ case 530: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_posix_fadvise */ case 531: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_wait6 */ case 532: if (ndx == 0 || ndx == 1) p = "int"; break; #endif /* cap_rights_limit */ case 533: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cap_ioctls_limit */ case 534: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cap_ioctls_get */ case 535: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* cap_fcntls_limit */ case 536: if (ndx == 0 || ndx == 1) p = "int"; break; /* cap_fcntls_get */ case 537: if (ndx == 0 || ndx == 1) p = "int"; break; /* bindat */ case 538: if (ndx == 0 || ndx == 1) p = "int"; break; /* connectat */ case 539: if (ndx == 0 || ndx == 1) p = "int"; break; /* chflagsat */ case 540: if (ndx == 0 || ndx == 1) p = "int"; break; /* accept4 */ case 541: if (ndx == 0 || ndx == 1) p = "int"; break; /* pipe2 */ case 542: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_mlock */ case 543: if (ndx == 0 || ndx == 1) p = "int"; break; #ifdef PAD64_REQUIRED /* freebsd32_procctl */ case 544: if (ndx == 0 || ndx == 1) p = "int"; break; #else /* freebsd32_procctl */ case 544: if (ndx == 0 || ndx == 1) p = "int"; break; #endif /* freebsd32_ppoll */ case 545: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_futimens */ case 546: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_utimensat */ case 547: if (ndx == 0 || ndx == 1) p = "int"; break; /* fdatasync */ case 550: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fstat */ case 551: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fstatat */ case 552: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fhstat */ case 553: if (ndx == 0 || ndx == 1) p = "int"; break; /* getdirentries */ case 554: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* statfs */ case 555: if (ndx == 0 || ndx == 1) p = "int"; break; /* fstatfs */ case 556: if (ndx == 0 || ndx == 1) p = "int"; break; /* getfsstat */ case 557: if (ndx == 0 || ndx == 1) p = "int"; break; /* fhstatfs */ case 558: if (ndx == 0 || ndx == 1) p = "int"; break; #ifdef PAD64_REQUIRED /* freebsd32_mknodat */ case 559: if (ndx == 0 || ndx == 1) p = "int"; break; #else /* freebsd32_mknodat */ case 559: if (ndx == 0 || ndx == 1) p = "int"; break; #endif /* freebsd32_kevent */ case 560: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cpuset_getdomain */ case 561: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_cpuset_setdomain */ case 562: if (ndx == 0 || ndx == 1) p = "int"; break; /* getrandom */ case 563: if (ndx == 0 || ndx == 1) p = "int"; break; /* getfhat */ case 564: if (ndx == 0 || ndx == 1) p = "int"; break; /* fhlink */ case 565: if (ndx == 0 || ndx == 1) p = "int"; break; /* fhlinkat */ case 566: if (ndx == 0 || ndx == 1) p = "int"; break; /* fhreadlink */ case 567: if (ndx == 0 || ndx == 1) p = "int"; break; /* funlinkat */ case 568: if (ndx == 0 || ndx == 1) p = "int"; break; /* copy_file_range */ case 569: if (ndx == 0 || ndx == 1) p = "ssize_t"; break; /* freebsd32___sysctlbyname */ case 570: if (ndx == 0 || ndx == 1) p = "int"; break; /* shm_open2 */ case 571: if (ndx == 0 || ndx == 1) p = "int"; break; /* shm_rename */ case 572: if (ndx == 0 || ndx == 1) p = "int"; break; /* sigfastblock */ case 573: if (ndx == 0 || ndx == 1) p = "int"; break; /* __realpathat */ case 574: if (ndx == 0 || ndx == 1) p = "int"; break; /* close_range */ case 575: if (ndx == 0 || ndx == 1) p = "int"; break; /* rpctls_syscall */ case 576: if (ndx == 0 || ndx == 1) p = "int"; break; /* __specialfd */ case 577: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_writev */ case 578: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_aio_readv */ case 579: if (ndx == 0 || ndx == 1) p = "int"; break; /* freebsd32_fspacectl */ case 580: if (ndx == 0 || ndx == 1) p = "int"; break; /* sched_getcpu */ case 581: default: break; }; if (p != NULL) strlcpy(desc, p, descsz); } diff --git a/sys/compat/freebsd32/syscalls.master b/sys/compat/freebsd32/syscalls.master index c72fb54df0a1..59da4d40eae4 100644 --- a/sys/compat/freebsd32/syscalls.master +++ b/sys/compat/freebsd32/syscalls.master @@ -1,1186 +1,1186 @@ $FreeBSD$ ; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94 ; from: src/sys/kern/syscalls.master 1.107 ; ; System call name/number master file. ; Processed to created init_sysent.c, syscalls.c and syscall.h. ; Columns: number audit type name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; audit the audit event associated with the system call ; A value of AUE_NULL means no auditing, but it also means that ; there is no audit event for the call at this time. For the ; case where the event exists, but we don't want auditing, the ; event should be #defined to AUE_NULL in audit_kevents.h. ; type one of STD, OBSOL, UNIMPL, COMPAT, COMPAT4, COMPAT6, ; COMPAT7, COMPAT11, COMPAT12, NODEF, NOARGS, NOPROTO, NOSTD ; The COMPAT* options may be combined with one or more NO* ; options separated by '|' with no spaces (e.g. COMPAT|NOARGS) ; 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/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; COMPAT4 included on COMPAT_FREEBSD4 #ifdef (FreeBSD 4 compat) ; COMPAT6 included on COMPAT_FREEBSD6 #ifdef (FreeBSD 6 compat) ; COMPAT7 included on COMPAT_FREEBSD7 #ifdef (FreeBSD 7 compat) ; COMPAT10 included on COMPAT_FREEBSD10 #ifdef (FreeBSD 10 compat) ; COMPAT11 included on COMPAT_FREEBSD11 #ifdef (FreeBSD 11 compat) ; COMPAT12 included on COMPAT_FREEBSD12 #ifdef (FreeBSD 12 compat) ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only ; NOSTD implemented but as a lkm that can be statically ; compiled in; sysent entry will be filled with lkmressys ; so the SYSCALL_MODULE macro works ; NOARGS same as STD except do not create structure in sys/sysproto.h ; NODEF same as STD except only have the entry in the syscall table ; added. Meaning - do not create structure or function ; prototype in sys/sysproto.h ; 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. ; #ifdef's, etc. may be included, and are copied to the output files. #include #include #include #include #include #include #include #if !defined(PAD64_REQUIRED) && !defined(__amd64__) #define PAD64_REQUIRED #endif ; Reserved/unimplemented system calls in the range 0-150 inclusive ; are reserved for use in future Berkeley releases. ; Additional system calls implemented in vendor and other ; redistributions should be placed in the reserved range at the end ; of the current calls. 0 AUE_NULL NOPROTO { int nosys(void); } syscall nosys_args int 1 AUE_EXIT NOPROTO { void sys_exit(int rval); } exit \ sys_exit_args void 2 AUE_FORK NOPROTO { int fork(void); } 3 AUE_READ NOPROTO { ssize_t read(int fd, void *buf, \ size_t nbyte); } 4 AUE_WRITE NOPROTO { ssize_t write(int fd, const void *buf, \ size_t nbyte); } 5 AUE_OPEN_RWTC NOPROTO { int open(const char *path, int flags, \ mode_t mode); } 6 AUE_CLOSE NOPROTO { int close(int fd); } 7 AUE_WAIT4 STD { int freebsd32_wait4(int pid, int *status, \ int options, struct rusage32 *rusage); } 8 AUE_CREAT OBSOL old creat 9 AUE_LINK NOPROTO { int link(const char *path, \ const char *link); } 10 AUE_UNLINK NOPROTO { int unlink(const char *path); } 11 AUE_NULL OBSOL execv 12 AUE_CHDIR NOPROTO { int chdir(const char *path); } 13 AUE_FCHDIR NOPROTO { int fchdir(int fd); } 14 AUE_MKNOD COMPAT11|NOPROTO { int mknod(const char *path, \ int mode, uint32_t dev); } 15 AUE_CHMOD NOPROTO { int chmod(const char *path, mode_t mode); } 16 AUE_CHOWN NOPROTO { int chown(const char *path, int uid, int gid); } 17 AUE_NULL NOPROTO { void *break(char *nsize); } 18 AUE_GETFSSTAT COMPAT4 { int freebsd32_getfsstat( \ struct ostatfs32 *buf, long bufsize, \ int mode); } 19 AUE_LSEEK COMPAT { int freebsd32_lseek(int fd, int offset, \ int whence); } 20 AUE_GETPID NOPROTO { pid_t getpid(void); } 21 AUE_MOUNT NOPROTO { int mount(const char *type, \ const char *path, \ int flags, void *data); } 22 AUE_UMOUNT NOPROTO { int unmount(const char *path, int flags); } 23 AUE_SETUID NOPROTO { int setuid(uid_t uid); } 24 AUE_GETUID NOPROTO { uid_t getuid(void); } 25 AUE_GETEUID NOPROTO { uid_t geteuid(void); } 26 AUE_PTRACE STD { int freebsd32_ptrace(int req, pid_t pid, \ caddr_t addr, int data); } 27 AUE_RECVMSG STD { int freebsd32_recvmsg(int s, struct msghdr32 *msg, \ int flags); } 28 AUE_SENDMSG STD { int freebsd32_sendmsg(int s, \ const struct msghdr32 *msg, int flags); } 29 AUE_RECVFROM STD { int freebsd32_recvfrom(int s, void *buf, \ size_t len, int flags, \ struct sockaddr *from, \ uint32_t fromlenaddr); } 30 AUE_ACCEPT NOPROTO { int accept(int s, struct sockaddr *name, \ int *anamelen); } 31 AUE_GETPEERNAME NOPROTO { int getpeername(int fdes, \ struct sockaddr *asa, \ int *alen); } 32 AUE_GETSOCKNAME NOPROTO { int getsockname(int fdes, \ struct sockaddr *asa, \ int *alen); } 33 AUE_ACCESS NOPROTO { int access(const char *path, int amode); } 34 AUE_CHFLAGS NOPROTO { int chflags(const char *path, u_long flags); } 35 AUE_FCHFLAGS NOPROTO { int fchflags(int fd, u_long flags); } 36 AUE_SYNC NOPROTO { int sync(void); } 37 AUE_KILL NOPROTO { int kill(int pid, int signum); } 38 AUE_STAT COMPAT { int freebsd32_stat(const char *path, \ struct ostat32 *ub); } 39 AUE_GETPPID NOPROTO { pid_t getppid(void); } 40 AUE_LSTAT COMPAT { int freebsd32_lstat(const char *path, \ struct ostat32 *ub); } 41 AUE_DUP NOPROTO { int dup(u_int fd); } 42 AUE_PIPE COMPAT10 { int freebsd32_pipe(void); } 43 AUE_GETEGID NOPROTO { gid_t getegid(void); } 44 AUE_PROFILE NOPROTO { int profil(char *samples, size_t size, \ size_t offset, u_int scale); } 45 AUE_KTRACE NOPROTO { int ktrace(const char *fname, int ops, \ int facs, int pid); } 46 AUE_SIGACTION COMPAT { int freebsd32_sigaction( int signum, \ struct osigaction32 *nsa, \ struct osigaction32 *osa); } 47 AUE_GETGID NOPROTO { gid_t getgid(void); } 48 AUE_SIGPROCMASK COMPAT { int freebsd32_sigprocmask(int how, \ osigset_t mask); } 49 AUE_GETLOGIN NOPROTO { int getlogin(char *namebuf, \ u_int namelen); } 50 AUE_SETLOGIN NOPROTO { int setlogin(const char *namebuf); } 51 AUE_ACCT NOPROTO { int acct(const char *path); } 52 AUE_SIGPENDING COMPAT { int freebsd32_sigpending(void); } 53 AUE_SIGALTSTACK STD { int freebsd32_sigaltstack( \ const struct sigaltstack32 *ss, \ struct sigaltstack32 *oss); } 54 AUE_IOCTL STD { int freebsd32_ioctl(int fd, u_long com, \ char *data); } 55 AUE_REBOOT NOPROTO { int reboot(int opt); } 56 AUE_REVOKE NOPROTO { int revoke(const char *path); } 57 AUE_SYMLINK NOPROTO { int symlink(const char *path, \ const char *link); } 58 AUE_READLINK NOPROTO { ssize_t readlink(const char *path, char *buf, \ size_t count); } 59 AUE_EXECVE STD { int freebsd32_execve(const char *fname, \ uint32_t *argv, uint32_t *envv); } 60 AUE_UMASK NOPROTO { int umask(mode_t newmask); } 61 AUE_CHROOT NOPROTO { int chroot(const char *path); } 62 AUE_FSTAT COMPAT { int freebsd32_fstat(int fd, \ struct ostat32 *ub); } 63 AUE_NULL OBSOL ogetkerninfo 64 AUE_NULL COMPAT { int freebsd32_getpagesize( \ int32_t dummy); } 65 AUE_MSYNC NOPROTO { int msync(void *addr, size_t len, \ int flags); } 66 AUE_VFORK NOPROTO { int vfork(void); } 67 AUE_NULL OBSOL vread 68 AUE_NULL OBSOL vwrite 69 AUE_SBRK NOPROTO { int sbrk(int incr); } 70 AUE_SSTK NOPROTO { int sstk(int incr); } 71 AUE_MMAP COMPAT { void *freebsd32_mmap(void *addr, int len, \ int prot, int flags, int fd, int32_t pos); } 72 AUE_O_VADVISE COMPAT11|NOPROTO { int vadvise(int anom); } 73 AUE_MUNMAP NOPROTO { int munmap(void *addr, size_t len); } 74 AUE_MPROTECT STD { int freebsd32_mprotect(const void *addr, \ size_t len, int prot); } 75 AUE_MADVISE NOPROTO { int madvise(void *addr, size_t len, \ int behav); } 76 AUE_NULL OBSOL vhangup 77 AUE_NULL OBSOL vlimit 78 AUE_MINCORE NOPROTO { int mincore(const void *addr, size_t len, \ char *vec); } 79 AUE_GETGROUPS NOPROTO { int getgroups(u_int gidsetsize, \ gid_t *gidset); } 80 AUE_SETGROUPS NOPROTO { int setgroups(u_int gidsetsize, \ const gid_t *gidset); } 81 AUE_GETPGRP NOPROTO { int getpgrp(void); } 82 AUE_SETPGRP NOPROTO { int setpgid(int pid, int pgid); } 83 AUE_SETITIMER STD { int freebsd32_setitimer(int which, \ const struct itimerval32 *itv, \ struct itimerval32 *oitv); } 84 AUE_NULL OBSOL owait ; XXX implement 85 AUE_SWAPON NOPROTO { int swapon(const char *name); } 86 AUE_GETITIMER STD { int freebsd32_getitimer(int which, \ struct itimerval32 *itv); } 87 AUE_O_GETHOSTNAME OBSOL ogethostname 88 AUE_O_SETHOSTNAME OBSOL osethostname 89 AUE_GETDTABLESIZE NOPROTO { int getdtablesize(void); } 90 AUE_DUP2 NOPROTO { int dup2(u_int from, u_int to); } 91 AUE_NULL UNIMPL getdopt 92 AUE_FCNTL STD { int freebsd32_fcntl(int fd, int cmd, \ int arg); } 93 AUE_SELECT STD { int freebsd32_select(int nd, fd_set *in, \ fd_set *ou, fd_set *ex, \ struct timeval32 *tv); } 94 AUE_NULL UNIMPL setdopt 95 AUE_FSYNC NOPROTO { int fsync(int fd); } 96 AUE_SETPRIORITY NOPROTO { int setpriority(int which, int who, \ int prio); } 97 AUE_SOCKET NOPROTO { int socket(int domain, int type, \ int protocol); } 98 AUE_CONNECT NOPROTO { int connect(int s, \ const struct sockaddr *name, \ int namelen); } 99 AUE_NULL OBSOL oaccept 100 AUE_GETPRIORITY NOPROTO { int getpriority(int which, int who); } 101 AUE_NULL OBSOL osend 102 AUE_NULL OBSOL orecv 103 AUE_SIGRETURN COMPAT { int freebsd32_sigreturn( \ struct ia32_sigcontext3 *sigcntxp); } 104 AUE_BIND NOPROTO { int bind(int s, const struct sockaddr *name, \ int namelen); } 105 AUE_SETSOCKOPT NOPROTO { int setsockopt(int s, int level, \ int name, const void *val, int valsize); } 106 AUE_LISTEN NOPROTO { int listen(int s, int backlog); } 107 AUE_NULL OBSOL vtimes 108 AUE_O_SIGVEC COMPAT { int freebsd32_sigvec(int signum, \ struct sigvec32 *nsv, \ struct sigvec32 *osv); } 109 AUE_O_SIGBLOCK COMPAT { int freebsd32_sigblock(int mask); } 110 AUE_O_SIGSETMASK COMPAT { int freebsd32_sigsetmask( int mask); } 111 AUE_SIGSUSPEND COMPAT { int freebsd32_sigsuspend( int mask); } 112 AUE_O_SIGSTACK COMPAT { int freebsd32_sigstack( \ struct sigstack32 *nss, \ struct sigstack32 *oss); } 113 AUE_NULL OBSOL orecvmsg 114 AUE_NULL OBSOL osendmsg 115 AUE_NULL OBSOL vtrace 116 AUE_GETTIMEOFDAY STD { int freebsd32_gettimeofday( \ struct timeval32 *tp, \ struct timezone *tzp); } 117 AUE_GETRUSAGE STD { int freebsd32_getrusage(int who, \ struct rusage32 *rusage); } 118 AUE_GETSOCKOPT NOPROTO { int getsockopt(int s, int level, \ int name, void *val, int *avalsize); } 119 AUE_NULL UNIMPL resuba (BSD/OS 2.x) 120 AUE_READV STD { int freebsd32_readv(int fd, \ struct iovec32 *iovp, u_int iovcnt); } 121 AUE_WRITEV STD { int freebsd32_writev(int fd, \ struct iovec32 *iovp, u_int iovcnt); } 122 AUE_SETTIMEOFDAY STD { int freebsd32_settimeofday( \ const struct timeval32 *tv, \ const struct timezone *tzp); } 123 AUE_FCHOWN NOPROTO { int fchown(int fd, int uid, int gid); } 124 AUE_FCHMOD NOPROTO { int fchmod(int fd, mode_t mode); } 125 AUE_RECVFROM OBSOL orecvfrom 126 AUE_SETREUID NOPROTO { int setreuid(int ruid, int euid); } 127 AUE_SETREGID NOPROTO { int setregid(int rgid, int egid); } 128 AUE_RENAME NOPROTO { int rename(const char *from, \ const char *to); } 129 AUE_TRUNCATE COMPAT|NOPROTO { int truncate(const char *path, \ int length); } 130 AUE_FTRUNCATE COMPAT|NOPROTO { int ftruncate(int fd, int length); } 131 AUE_FLOCK NOPROTO { int flock(int fd, int how); } 132 AUE_MKFIFO NOPROTO { int mkfifo(const char *path, mode_t mode); } 133 AUE_SENDTO NOPROTO { int sendto(int s, const void *buf, \ size_t len, int flags, \ const struct sockaddr *to, \ int tolen); } 134 AUE_SHUTDOWN NOPROTO { int shutdown(int s, int how); } 135 AUE_SOCKETPAIR NOPROTO { int socketpair(int domain, int type, \ int protocol, int *rsv); } 136 AUE_MKDIR NOPROTO { int mkdir(const char *path, mode_t mode); } 137 AUE_RMDIR NOPROTO { int rmdir(const char *path); } 138 AUE_UTIMES STD { int freebsd32_utimes(const char *path, \ const struct timeval32 *tptr); } 139 AUE_NULL OBSOL 4.2 sigreturn 140 AUE_ADJTIME STD { int freebsd32_adjtime( \ const struct timeval32 *delta, \ struct timeval32 *olddelta); } 141 AUE_GETPEERNAME OBSOL ogetpeername 142 AUE_SYSCTL OBSOL ogethostid 143 AUE_SYSCTL OBSOL sethostid 144 AUE_GETRLIMIT OBSOL getrlimit 145 AUE_SETRLIMIT OBSOL setrlimit 146 AUE_KILLPG OBSOL killpg 147 AUE_SETSID NOPROTO { int setsid(void); } 148 AUE_QUOTACTL NOPROTO { int quotactl(const char *path, int cmd, \ int uid, void *arg); } 149 AUE_O_QUOTA OBSOL oquota 150 AUE_GETSOCKNAME OBSOL ogetsockname ; Syscalls 151-180 inclusive are reserved for vendor-specific ; system calls. (This includes various calls added for compatibity ; with other Unix variants.) ; Some of these calls are now supported by BSD... 151 AUE_NULL UNIMPL sem_lock (BSD/OS 2.x) 152 AUE_NULL UNIMPL sem_wakeup (BSD/OS 2.x) 153 AUE_NULL UNIMPL asyncdaemon (BSD/OS 2.x) ; 154 is initialised by the NLM code, if present. 154 AUE_NULL UNIMPL nlm_syscall ; 155 is initialized by the NFS code, if present. ; XXX this is a problem!!! 155 AUE_NFS_SVC UNIMPL nfssvc 156 AUE_GETDIRENTRIES COMPAT { int freebsd32_getdirentries(int fd, \ char *buf, u_int count, uint32_t *basep); } 157 AUE_STATFS COMPAT4 { int freebsd32_statfs(const char *path, \ struct ostatfs32 *buf); } 158 AUE_FSTATFS COMPAT4 { int freebsd32_fstatfs(int fd, \ struct ostatfs32 *buf); } 159 AUE_NULL UNIMPL nosys 160 AUE_LGETFH UNIMPL lgetfh 161 AUE_NFS_GETFH NOPROTO { int getfh(const char *fname, \ struct fhandle *fhp); } 162 AUE_SYSCTL OBSOL getdomainname 163 AUE_SYSCTL OBSOL setdomainname 164 AUE_NULL OBSOL uname 165 AUE_SYSARCH STD { int freebsd32_sysarch(int op, char *parms); } 166 AUE_RTPRIO NOPROTO { int rtprio(int function, pid_t pid, \ struct rtprio *rtp); } 167 AUE_NULL UNIMPL nosys 168 AUE_NULL UNIMPL nosys 169 AUE_SEMSYS NOSTD { int freebsd32_semsys(int which, int a2, \ int a3, int a4, int a5); } 170 AUE_MSGSYS NOSTD { int freebsd32_msgsys(int which, int a2, \ int a3, int a4, int a5, int a6); } 171 AUE_SHMSYS NOSTD { int freebsd32_shmsys(uint32_t which, uint32_t a2, \ uint32_t a3, uint32_t a4); } 172 AUE_NULL UNIMPL nosys 173 AUE_PREAD COMPAT6 { ssize_t freebsd32_pread(int fd, void *buf, \ size_t nbyte, int pad, \ uint32_t offset1, uint32_t offset2); } 174 AUE_PWRITE COMPAT6 { ssize_t freebsd32_pwrite(int fd, \ const void *buf, size_t nbyte, int pad, \ uint32_t offset1, uint32_t offset2); } 175 AUE_NULL UNIMPL nosys 176 AUE_NTP_ADJTIME STD { int freebsd32_ntp_adjtime( \ struct timex32 *tp); } 177 AUE_NULL UNIMPL sfork (BSD/OS 2.x) 178 AUE_NULL UNIMPL getdescriptor (BSD/OS 2.x) 179 AUE_NULL UNIMPL setdescriptor (BSD/OS 2.x) 180 AUE_NULL UNIMPL nosys ; Syscalls 181-199 are used by/reserved for BSD 181 AUE_SETGID NOPROTO { int setgid(gid_t gid); } 182 AUE_SETEGID NOPROTO { int setegid(gid_t egid); } 183 AUE_SETEUID NOPROTO { int seteuid(uid_t euid); } 184 AUE_NULL OBSOL lfs_bmapv 185 AUE_NULL OBSOL lfs_markv 186 AUE_NULL OBSOL lfs_segclean 187 AUE_NULL OBSOL lfs_segwait 188 AUE_STAT COMPAT11 { int freebsd32_stat(const char *path, \ struct freebsd11_stat32 *ub); } 189 AUE_FSTAT COMPAT11 { int freebsd32_fstat(int fd, \ struct freebsd11_stat32 *ub); } 190 AUE_LSTAT COMPAT11 { int freebsd32_lstat(const char *path, \ struct freebsd11_stat32 *ub); } 191 AUE_PATHCONF NOPROTO { int pathconf(const char *path, int name); } 192 AUE_FPATHCONF NOPROTO { int fpathconf(int fd, int name); } 193 AUE_NULL UNIMPL nosys 194 AUE_GETRLIMIT NOPROTO { int getrlimit(u_int which, \ struct rlimit *rlp); } getrlimit \ __getrlimit_args int 195 AUE_SETRLIMIT NOPROTO { int setrlimit(u_int which, \ struct rlimit *rlp); } setrlimit \ __setrlimit_args int 196 AUE_GETDIRENTRIES COMPAT11 { int freebsd32_getdirentries(int fd, \ char *buf, u_int count, int32_t *basep); } 197 AUE_MMAP COMPAT6 { void *freebsd32_mmap(void *addr, \ size_t len, int prot, int flags, int fd, \ int pad, uint32_t pos1, uint32_t pos2); } 198 AUE_NULL NOPROTO { int nosys(void); } __syscall \ __syscall_args int 199 AUE_LSEEK COMPAT6 { off_t freebsd32_lseek(int fd, int pad, \ uint32_t offset1, uint32_t offset2, \ int whence); } 200 AUE_TRUNCATE COMPAT6 { int freebsd32_truncate(const char *path, \ int pad, uint32_t length1, \ uint32_t length2); } 201 AUE_FTRUNCATE COMPAT6 { int freebsd32_ftruncate(int fd, int pad, \ uint32_t length1, uint32_t length2); } 202 AUE_SYSCTL STD { int freebsd32___sysctl(int *name, \ u_int namelen, void *old, \ uint32_t *oldlenp, const void *new, \ size_t newlen); } 203 AUE_MLOCK NOPROTO { int mlock(const void *addr, \ size_t len); } 204 AUE_MUNLOCK NOPROTO { int munlock(const void *addr, \ size_t len); } 205 AUE_UNDELETE NOPROTO { int undelete(const char *path); } 206 AUE_FUTIMES STD { int freebsd32_futimes(int fd, \ const struct timeval32 *tptr); } 207 AUE_GETPGID NOPROTO { int getpgid(pid_t pid); } 208 AUE_NULL UNIMPL nosys 209 AUE_POLL NOPROTO { int poll(struct pollfd *fds, u_int nfds, \ int timeout); } ; ; The following are reserved for loadable syscalls ; 210 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 211 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 212 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 213 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 214 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 215 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 216 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 217 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 218 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 219 AUE_NULL NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int 220 AUE_SEMCTL COMPAT7|NOSTD { int freebsd32___semctl( \ int semid, int semnum, \ int cmd, union semun_old32 *arg); } 221 AUE_SEMGET NOSTD|NOPROTO { int semget(key_t key, int nsems, \ int semflg); } 222 AUE_SEMOP NOSTD|NOPROTO { int semop(int semid, \ struct sembuf *sops, size_t nsops); } 223 AUE_NULL OBSOL semconfig 224 AUE_MSGCTL COMPAT7|NOSTD { int freebsd32_msgctl( \ int msqid, int cmd, \ struct msqid_ds_old32 *buf); } 225 AUE_MSGGET NOSTD|NOPROTO { int msgget(key_t key, int msgflg); } 226 AUE_MSGSND NOSTD { int freebsd32_msgsnd(int msqid, const void *msgp, \ size_t msgsz, int msgflg); } 227 AUE_MSGRCV NOSTD { int freebsd32_msgrcv(int msqid, void *msgp, \ size_t msgsz, long msgtyp, int msgflg); } 228 AUE_SHMAT NOSTD|NOPROTO { void *shmat(int shmid, const void *shmaddr, \ int shmflg); } 229 AUE_SHMCTL COMPAT7|NOSTD { int freebsd32_shmctl( \ int shmid, int cmd, \ struct shmid_ds_old32 *buf); } 230 AUE_SHMDT NOSTD|NOPROTO { int shmdt(const void *shmaddr); } 231 AUE_SHMGET NOSTD|NOPROTO { int shmget(key_t key, size_t size, \ int shmflg); } ; 232 AUE_NULL STD { int freebsd32_clock_gettime(clockid_t clock_id, \ struct timespec32 *tp); } 233 AUE_CLOCK_SETTIME STD { int freebsd32_clock_settime(clockid_t clock_id, \ const struct timespec32 *tp); } 234 AUE_NULL STD { int freebsd32_clock_getres(clockid_t clock_id, \ struct timespec32 *tp); } 235 AUE_NULL STD { int freebsd32_ktimer_create(\ clockid_t clock_id, \ struct sigevent32 *evp, int *timerid); } 236 AUE_NULL NOPROTO { int ktimer_delete(int timerid); } 237 AUE_NULL STD { int freebsd32_ktimer_settime(int timerid,\ int flags, \ const struct itimerspec32 *value, \ struct itimerspec32 *ovalue); } 238 AUE_NULL STD { int freebsd32_ktimer_gettime(int timerid,\ struct itimerspec32 *value); } 239 AUE_NULL NOPROTO { int ktimer_getoverrun(int timerid); } 240 AUE_NULL STD { int freebsd32_nanosleep( \ const struct timespec32 *rqtp, \ struct timespec32 *rmtp); } 241 AUE_NULL NOPROTO { int ffclock_getcounter(ffcounter *ffcount); } 242 AUE_NULL NOPROTO { int ffclock_setestimate( \ struct ffclock_estimate *cest); } 243 AUE_NULL NOPROTO { int ffclock_getestimate( \ struct ffclock_estimate *cest); } 244 AUE_NULL STD { int freebsd32_clock_nanosleep( \ clockid_t clock_id, int flags, \ const struct timespec32 *rqtp, \ struct timespec32 *rmtp); } 245 AUE_NULL UNIMPL nosys 246 AUE_NULL UNIMPL nosys 247 AUE_NULL STD { int freebsd32_clock_getcpuclockid2(\ uint32_t id1, uint32_t id2,\ int which, clockid_t *clock_id); } 248 AUE_NULL UNIMPL ntp_gettime 249 AUE_NULL UNIMPL nosys 250 AUE_MINHERIT NOPROTO { int minherit(void *addr, size_t len, \ int inherit); } 251 AUE_RFORK NOPROTO { int rfork(int flags); } 252 AUE_POLL OBSOL openbsd_poll 253 AUE_ISSETUGID NOPROTO { int issetugid(void); } 254 AUE_LCHOWN NOPROTO { int lchown(const char *path, int uid, \ int gid); } 255 AUE_AIO_READ STD { int freebsd32_aio_read( \ struct aiocb32 *aiocbp); } 256 AUE_AIO_WRITE STD { int freebsd32_aio_write( \ struct aiocb32 *aiocbp); } 257 AUE_LIO_LISTIO STD { int freebsd32_lio_listio(int mode, \ uint32_t *acb_list, \ int nent, struct sigevent32 *sig); } 258 AUE_NULL UNIMPL nosys 259 AUE_NULL UNIMPL nosys 260 AUE_NULL UNIMPL nosys 261 AUE_NULL UNIMPL nosys 262 AUE_NULL UNIMPL nosys 263 AUE_NULL UNIMPL nosys 264 AUE_NULL UNIMPL nosys 265 AUE_NULL UNIMPL nosys 266 AUE_NULL UNIMPL nosys 267 AUE_NULL UNIMPL nosys 268 AUE_NULL UNIMPL nosys 269 AUE_NULL UNIMPL nosys 270 AUE_NULL UNIMPL nosys 271 AUE_NULL UNIMPL nosys 272 AUE_O_GETDENTS COMPAT11 { int freebsd32_getdents(int fd, char *buf, \ int count); } 273 AUE_NULL UNIMPL nosys 274 AUE_LCHMOD NOPROTO { int lchmod(const char *path, mode_t mode); } 275 AUE_NULL OBSOL netbsd_lchown 276 AUE_LUTIMES STD { int freebsd32_lutimes(const char *path, \ const struct timeval32 *tptr); } 277 AUE_NULL OBSOL netbsd_msync 278 AUE_STAT COMPAT11|NOPROTO { int nstat(const char *path, \ struct nstat *ub); } 279 AUE_FSTAT COMPAT11|NOPROTO { int nfstat(int fd, struct nstat *sb); } 280 AUE_LSTAT COMPAT11|NOPROTO { int nlstat(const char *path, \ struct nstat *ub); } 281 AUE_NULL UNIMPL nosys 282 AUE_NULL UNIMPL nosys 283 AUE_NULL UNIMPL nosys 284 AUE_NULL UNIMPL nosys 285 AUE_NULL UNIMPL nosys 286 AUE_NULL UNIMPL nosys 287 AUE_NULL UNIMPL nosys 288 AUE_NULL UNIMPL nosys 289 AUE_PREADV STD { ssize_t freebsd32_preadv(int fd, \ struct iovec32 *iovp, \ u_int iovcnt, \ uint32_t offset1, uint32_t offset2); } 290 AUE_PWRITEV STD { ssize_t freebsd32_pwritev(int fd, \ struct iovec32 *iovp, \ u_int iovcnt, \ uint32_t offset1, uint32_t offset2); } 291 AUE_NULL UNIMPL nosys 292 AUE_NULL UNIMPL nosys 293 AUE_NULL UNIMPL nosys 294 AUE_NULL UNIMPL nosys 295 AUE_NULL UNIMPL nosys 296 AUE_NULL UNIMPL nosys 297 AUE_FHSTATFS COMPAT4 { int freebsd32_fhstatfs( \ const struct fhandle *u_fhp, \ struct ostatfs32 *buf); } 298 AUE_FHOPEN NOPROTO { int fhopen(const struct fhandle *u_fhp, \ int flags); } 299 AUE_FHSTAT COMPAT11 { int freebsd32_fhstat( \ const struct fhandle *u_fhp, \ struct freebsd11_stat32 *sb); } ; syscall numbers for FreeBSD 300 AUE_NULL NOPROTO { int modnext(int modid); } 301 AUE_NULL STD { int freebsd32_modstat(int modid, \ struct module_stat32 *stat); } 302 AUE_NULL NOPROTO { int modfnext(int modid); } 303 AUE_NULL NOPROTO { int modfind(const char *name); } 304 AUE_MODLOAD NOPROTO { int kldload(const char *file); } 305 AUE_MODUNLOAD NOPROTO { int kldunload(int fileid); } 306 AUE_NULL NOPROTO { int kldfind(const char *file); } 307 AUE_NULL NOPROTO { int kldnext(int fileid); } 308 AUE_NULL STD { int freebsd32_kldstat(int fileid, \ struct kld_file_stat32 *stat); } 309 AUE_NULL NOPROTO { int kldfirstmod(int fileid); } 310 AUE_GETSID NOPROTO { int getsid(pid_t pid); } 311 AUE_SETRESUID NOPROTO { int setresuid(uid_t ruid, uid_t euid, \ uid_t suid); } 312 AUE_SETRESGID NOPROTO { int setresgid(gid_t rgid, gid_t egid, \ gid_t sgid); } 313 AUE_NULL OBSOL signanosleep 314 AUE_AIO_RETURN STD { int freebsd32_aio_return( \ struct aiocb32 *aiocbp); } 315 AUE_AIO_SUSPEND STD { int freebsd32_aio_suspend( \ uint32_t * aiocbp, int nent, \ const struct timespec32 *timeout); } 316 AUE_AIO_CANCEL NOPROTO { int aio_cancel(int fd, \ struct aiocb *aiocbp); } 317 AUE_AIO_ERROR STD { int freebsd32_aio_error( \ struct aiocb32 *aiocbp); } 318 AUE_AIO_READ COMPAT6 { int freebsd32_aio_read( \ struct oaiocb32 *aiocbp); } 319 AUE_AIO_WRITE COMPAT6 { int freebsd32_aio_write( \ struct oaiocb32 *aiocbp); } 320 AUE_LIO_LISTIO COMPAT6 { int freebsd32_lio_listio(int mode, \ uint32_t *acb_list, \ int nent, struct osigevent32 *sig); } 321 AUE_NULL NOPROTO { int yield(void); } 322 AUE_NULL OBSOL thr_sleep 323 AUE_NULL OBSOL thr_wakeup 324 AUE_MLOCKALL NOPROTO { int mlockall(int how); } 325 AUE_MUNLOCKALL NOPROTO { int munlockall(void); } 326 AUE_GETCWD NOPROTO { int __getcwd(char *buf, size_t buflen); } 327 AUE_NULL NOPROTO { int sched_setparam (pid_t pid, \ const struct sched_param *param); } 328 AUE_NULL NOPROTO { int sched_getparam (pid_t pid, \ struct sched_param *param); } 329 AUE_NULL NOPROTO { int sched_setscheduler (pid_t pid, \ int policy, \ const struct sched_param *param); } 330 AUE_NULL NOPROTO { int sched_getscheduler (pid_t pid); } 331 AUE_NULL NOPROTO { int sched_yield (void); } 332 AUE_NULL NOPROTO { int sched_get_priority_max (int policy); } 333 AUE_NULL NOPROTO { int sched_get_priority_min (int policy); } 334 AUE_NULL STD { int freebsd32_sched_rr_get_interval ( \ pid_t pid, \ struct timespec32 *interval); } 335 AUE_NULL NOPROTO { int utrace(const void *addr, size_t len); } 336 AUE_SENDFILE COMPAT4 { int freebsd32_sendfile(int fd, int s, \ uint32_t offset1, uint32_t offset2, \ size_t nbytes, struct sf_hdtr32 *hdtr, \ off_t *sbytes, int flags); } 337 AUE_NULL NOPROTO { int kldsym(int fileid, int cmd, \ void *data); } 338 AUE_JAIL STD { int freebsd32_jail(struct jail32 *jail); } 339 AUE_NULL UNIMPL pioctl 340 AUE_SIGPROCMASK NOPROTO { int sigprocmask(int how, \ const sigset_t *set, sigset_t *oset); } 341 AUE_SIGSUSPEND NOPROTO { int sigsuspend(const sigset_t *sigmask); } 342 AUE_SIGACTION COMPAT4 { int freebsd32_sigaction(int sig, \ const struct sigaction32 *act, \ struct sigaction32 *oact); } 343 AUE_SIGPENDING NOPROTO { int sigpending(sigset_t *set); } 344 AUE_SIGRETURN COMPAT4 { int freebsd32_sigreturn( \ const struct freebsd4_ucontext32 *sigcntxp); } 345 AUE_SIGWAIT STD { int freebsd32_sigtimedwait(const sigset_t *set, \ struct siginfo32 *info, \ const struct timespec32 *timeout); } 346 AUE_NULL STD { int freebsd32_sigwaitinfo(const sigset_t *set, \ struct siginfo32 *info); } 347 AUE_ACL_GET_FILE NOPROTO { int __acl_get_file(const char *path, \ acl_type_t type, struct acl *aclp); } 348 AUE_ACL_SET_FILE NOPROTO { int __acl_set_file(const char *path, \ acl_type_t type, struct acl *aclp); } 349 AUE_ACL_GET_FD NOPROTO { int __acl_get_fd(int filedes, \ acl_type_t type, struct acl *aclp); } 350 AUE_ACL_SET_FD NOPROTO { int __acl_set_fd(int filedes, \ acl_type_t type, struct acl *aclp); } 351 AUE_ACL_DELETE_FILE NOPROTO { int __acl_delete_file(const char *path, \ acl_type_t type); } 352 AUE_ACL_DELETE_FD NOPROTO { int __acl_delete_fd(int filedes, \ acl_type_t type); } 353 AUE_ACL_CHECK_FILE NOPROTO { int __acl_aclcheck_file(const char *path, \ acl_type_t type, struct acl *aclp); } 354 AUE_ACL_CHECK_FD NOPROTO { int __acl_aclcheck_fd(int filedes, \ acl_type_t type, struct acl *aclp); } 355 AUE_EXTATTRCTL NOPROTO { int extattrctl(const char *path, int cmd, \ const char *filename, int attrnamespace, \ const char *attrname); } 356 AUE_EXTATTR_SET_FILE NOPROTO { ssize_t extattr_set_file( \ const char *path, int attrnamespace, \ const char *attrname, void *data, \ size_t nbytes); } 357 AUE_EXTATTR_GET_FILE NOPROTO { ssize_t extattr_get_file( \ const char *path, int attrnamespace, \ const char *attrname, void *data, \ size_t nbytes); } 358 AUE_EXTATTR_DELETE_FILE NOPROTO { int extattr_delete_file( \ const char *path, int attrnamespace, \ const char *attrname); } 359 AUE_AIO_WAITCOMPLETE STD { int freebsd32_aio_waitcomplete( \ uint32_t *aiocbp, \ struct timespec32 *timeout); } 360 AUE_GETRESUID NOPROTO { int getresuid(uid_t *ruid, uid_t *euid, \ uid_t *suid); } 361 AUE_GETRESGID NOPROTO { int getresgid(gid_t *rgid, gid_t *egid, \ gid_t *sgid); } 362 AUE_KQUEUE NOPROTO { int kqueue(void); } 363 AUE_KEVENT COMPAT11 { int freebsd32_kevent(int fd, \ const struct freebsd11_kevent32 * \ changelist, \ int nchanges, \ struct freebsd11_kevent32 *eventlist, \ int nevents, \ const struct timespec32 *timeout); } 364 AUE_NULL OBSOL __cap_get_proc 365 AUE_NULL OBSOL __cap_set_proc 366 AUE_NULL OBSOL __cap_get_fd 367 AUE_NULL OBSOL __cap_get_file 368 AUE_NULL OBSOL __cap_set_fd 369 AUE_NULL OBSOL __cap_set_file 370 AUE_NULL UNIMPL nosys 371 AUE_EXTATTR_SET_FD NOPROTO { ssize_t extattr_set_fd(int fd, \ int attrnamespace, const char *attrname, \ void *data, size_t nbytes); } 372 AUE_EXTATTR_GET_FD NOPROTO { ssize_t extattr_get_fd(int fd, \ int attrnamespace, const char *attrname, \ void *data, size_t nbytes); } 373 AUE_EXTATTR_DELETE_FD NOPROTO { int extattr_delete_fd(int fd, \ int attrnamespace, \ const char *attrname); } 374 AUE_SETUGID NOPROTO { int __setugid(int flag); } 375 AUE_NULL OBSOL nfsclnt 376 AUE_EACCESS NOPROTO { int eaccess(const char *path, int amode); } 377 AUE_NULL UNIMPL afs_syscall 378 AUE_NMOUNT STD { int freebsd32_nmount(struct iovec32 *iovp, \ unsigned int iovcnt, int flags); } 379 AUE_NULL OBSOL kse_exit 380 AUE_NULL OBSOL kse_wakeup 381 AUE_NULL OBSOL kse_create 382 AUE_NULL OBSOL kse_thr_interrupt 383 AUE_NULL OBSOL kse_release 384 AUE_NULL UNIMPL __mac_get_proc 385 AUE_NULL UNIMPL __mac_set_proc 386 AUE_NULL UNIMPL __mac_get_fd 387 AUE_NULL UNIMPL __mac_get_file 388 AUE_NULL UNIMPL __mac_set_fd 389 AUE_NULL UNIMPL __mac_set_file 390 AUE_NULL NOPROTO { int kenv(int what, const char *name, \ char *value, int len); } 391 AUE_LCHFLAGS NOPROTO { int lchflags(const char *path, \ u_long flags); } 392 AUE_NULL NOPROTO { int uuidgen(struct uuid *store, \ int count); } 393 AUE_SENDFILE STD { int freebsd32_sendfile(int fd, int s, \ uint32_t offset1, uint32_t offset2, \ size_t nbytes, struct sf_hdtr32 *hdtr, \ off_t *sbytes, int flags); } 394 AUE_NULL UNIMPL mac_syscall 395 AUE_GETFSSTAT COMPAT11|NOPROTO { int getfsstat( \ struct freebsd11_statfs *buf, \ long bufsize, int mode); } 396 AUE_STATFS COMPAT11|NOPROTO { int statfs(const char *path, \ struct statfs *buf); } 397 AUE_FSTATFS COMPAT11|NOPROTO { int fstatfs(int fd, \ struct freebsd11_statfs *buf); } 398 AUE_FHSTATFS COMPAT11|NOPROTO { int fhstatfs( \ const struct fhandle *u_fhp, \ struct freebsd11_statfs *buf); } 399 AUE_NULL UNIMPL nosys 400 AUE_SEMCLOSE NOSTD|NOPROTO { int ksem_close(semid_t id); } 401 AUE_SEMPOST NOSTD|NOPROTO { int ksem_post(semid_t id); } 402 AUE_SEMWAIT NOSTD|NOPROTO { int ksem_wait(semid_t id); } 403 AUE_SEMTRYWAIT NOSTD|NOPROTO { int ksem_trywait(semid_t id); } 404 AUE_SEMINIT NOSTD { int freebsd32_ksem_init(semid_t *idp, \ unsigned int value); } 405 AUE_SEMOPEN NOSTD { int freebsd32_ksem_open(semid_t *idp, \ const char *name, int oflag, \ mode_t mode, unsigned int value); } 406 AUE_SEMUNLINK NOSTD|NOPROTO { int ksem_unlink(const char *name); } 407 AUE_SEMGETVALUE NOSTD|NOPROTO { int ksem_getvalue(semid_t id, \ int *val); } 408 AUE_SEMDESTROY NOSTD|NOPROTO { int ksem_destroy(semid_t id); } 409 AUE_NULL UNIMPL __mac_get_pid 410 AUE_NULL UNIMPL __mac_get_link 411 AUE_NULL UNIMPL __mac_set_link 412 AUE_EXTATTR_SET_LINK NOPROTO { ssize_t extattr_set_link( \ const char *path, int attrnamespace, \ const char *attrname, void *data, \ size_t nbytes); } 413 AUE_EXTATTR_GET_LINK NOPROTO { ssize_t extattr_get_link( \ const char *path, int attrnamespace, \ const char *attrname, void *data, \ size_t nbytes); } 414 AUE_EXTATTR_DELETE_LINK NOPROTO { int extattr_delete_link( \ const char *path, int attrnamespace, \ const char *attrname); } 415 AUE_NULL UNIMPL __mac_execve 416 AUE_SIGACTION STD { int freebsd32_sigaction(int sig, \ const struct sigaction32 *act, \ struct sigaction32 *oact); } 417 AUE_SIGRETURN STD { int freebsd32_sigreturn( \ const struct __ucontext32 *sigcntxp); } 418 AUE_NULL UNIMPL __xstat 419 AUE_NULL UNIMPL __xfstat 420 AUE_NULL UNIMPL __xlstat 421 AUE_NULL STD { int freebsd32_getcontext( \ struct __ucontext32 *ucp); } 422 AUE_NULL STD { int freebsd32_setcontext( \ const struct __ucontext32 *ucp); } 423 AUE_NULL STD { int freebsd32_swapcontext( \ struct __ucontext32 *oucp, \ const struct __ucontext32 *ucp); } 424 AUE_SWAPOFF UNIMPL swapoff 425 AUE_ACL_GET_LINK NOPROTO { int __acl_get_link(const char *path, \ acl_type_t type, struct acl *aclp); } 426 AUE_ACL_SET_LINK NOPROTO { int __acl_set_link(const char *path, \ acl_type_t type, struct acl *aclp); } 427 AUE_ACL_DELETE_LINK NOPROTO { int __acl_delete_link(const char *path, \ acl_type_t type); } 428 AUE_ACL_CHECK_LINK NOPROTO { int __acl_aclcheck_link(const char *path, \ acl_type_t type, struct acl *aclp); } 429 AUE_SIGWAIT NOPROTO { int sigwait(const sigset_t *set, \ int *sig); } 430 AUE_THR_CREATE UNIMPL thr_create; 431 AUE_THR_EXIT NOPROTO { void thr_exit(int32_t *state); } 432 AUE_NULL NOPROTO { int thr_self(int32_t *id); } 433 AUE_THR_KILL NOPROTO { int thr_kill(int32_t id, int sig); } 434 AUE_NULL COMPAT10 { int freebsd32_umtx_lock( \ struct umtx *umtx); } 435 AUE_NULL COMPAT10 { int freebsd32_umtx_unlock( \ struct umtx *umtx); } 436 AUE_JAIL_ATTACH NOPROTO { int jail_attach(int jid); } 437 AUE_EXTATTR_LIST_FD NOPROTO { ssize_t extattr_list_fd(int fd, \ int attrnamespace, void *data, \ size_t nbytes); } 438 AUE_EXTATTR_LIST_FILE NOPROTO { ssize_t extattr_list_file( \ const char *path, int attrnamespace, \ void *data, size_t nbytes); } 439 AUE_EXTATTR_LIST_LINK NOPROTO { ssize_t extattr_list_link( \ const char *path, int attrnamespace, \ void *data, size_t nbytes); } 440 AUE_NULL OBSOL kse_switchin 441 AUE_SEMWAIT NOSTD { int freebsd32_ksem_timedwait(semid_t id, \ const struct timespec32 *abstime); } 442 AUE_NULL STD { int freebsd32_thr_suspend( \ const struct timespec32 *timeout); } 443 AUE_NULL NOPROTO { int thr_wake(int32_t id); } 444 AUE_MODUNLOAD NOPROTO { int kldunloadf(int fileid, int flags); } 445 AUE_AUDIT NOPROTO { int audit(const void *record, \ u_int length); } 446 AUE_AUDITON NOPROTO { int auditon(int cmd, void *data, \ u_int length); } 447 AUE_GETAUID NOPROTO { int getauid(uid_t *auid); } 448 AUE_SETAUID NOPROTO { int setauid(uid_t *auid); } 449 AUE_GETAUDIT NOPROTO { int getaudit(struct auditinfo *auditinfo); } 450 AUE_SETAUDIT NOPROTO { int setaudit(struct auditinfo *auditinfo); } 451 AUE_GETAUDIT_ADDR NOPROTO { int getaudit_addr( \ struct auditinfo_addr *auditinfo_addr, \ u_int length); } 452 AUE_SETAUDIT_ADDR NOPROTO { int setaudit_addr( \ struct auditinfo_addr *auditinfo_addr, \ u_int length); } 453 AUE_AUDITCTL NOPROTO { int auditctl(const char *path); } 454 AUE_NULL STD { int freebsd32__umtx_op(void *obj, int op,\ u_long val, void *uaddr1, \ void *uaddr2); } 455 AUE_THR_NEW STD { int freebsd32_thr_new( \ struct thr_param32 *param, \ int param_size); } 456 AUE_NULL STD { int freebsd32_sigqueue(pid_t pid, \ int signum, int value); } 457 AUE_MQ_OPEN NOSTD { int freebsd32_kmq_open( \ const char *path, int flags, mode_t mode, \ const struct mq_attr32 *attr); } 458 AUE_MQ_SETATTR NOSTD { int freebsd32_kmq_setattr(int mqd, \ const struct mq_attr32 *attr, \ struct mq_attr32 *oattr); } 459 AUE_MQ_TIMEDRECEIVE NOSTD { int freebsd32_kmq_timedreceive(int mqd, \ char *msg_ptr, size_t msg_len, \ unsigned *msg_prio, \ const struct timespec32 *abs_timeout); } 460 AUE_MQ_TIMEDSEND NOSTD { int freebsd32_kmq_timedsend(int mqd, \ const char *msg_ptr, size_t msg_len,\ unsigned msg_prio, \ const struct timespec32 *abs_timeout);} 461 AUE_MQ_NOTIFY NOSTD { int freebsd32_kmq_notify(int mqd, \ const struct sigevent32 *sigev); } 462 AUE_MQ_UNLINK NOPROTO|NOSTD { int kmq_unlink(const char *path); } 463 AUE_NULL NOPROTO { int abort2(const char *why, int nargs, uint32_t *args); } 464 AUE_NULL NOPROTO { int thr_set_name(int32_t id, const char *name); } 465 AUE_AIO_FSYNC STD { int freebsd32_aio_fsync(int op, \ struct aiocb32 *aiocbp); } 466 AUE_RTPRIO NOPROTO { int rtprio_thread(int function, \ lwpid_t lwpid, struct rtprio *rtp); } 467 AUE_NULL UNIMPL nosys 468 AUE_NULL UNIMPL nosys 469 AUE_NULL UNIMPL __getpath_fromfd 470 AUE_NULL UNIMPL __getpath_fromaddr 471 AUE_SCTP_PEELOFF NOPROTO|NOSTD { int sctp_peeloff(int sd, uint32_t name); } 472 AUE_SCTP_GENERIC_SENDMSG NOPROTO|NOSTD { int sctp_generic_sendmsg( \ int sd, void *msg, int mlen, \ const struct sockaddr *to, __socklen_t tolen, \ struct sctp_sndrcvinfo *sinfo, int flags); } 473 AUE_SCTP_GENERIC_SENDMSG_IOV NOPROTO|NOSTD { int sctp_generic_sendmsg_iov(int sd, struct iovec *iov, int iovlen, \ const struct sockaddr *to, __socklen_t tolen, \ struct sctp_sndrcvinfo *sinfo, int flags); } 474 AUE_SCTP_GENERIC_RECVMSG NOPROTO|NOSTD { int sctp_generic_recvmsg(int sd, struct iovec *iov, int iovlen, \ struct sockaddr * from, __socklen_t *fromlenaddr, \ struct sctp_sndrcvinfo *sinfo, int *msg_flags); } #ifdef PAD64_REQUIRED 475 AUE_PREAD STD { ssize_t freebsd32_pread(int fd, \ void *buf,size_t nbyte, \ int pad, \ uint32_t offset1, uint32_t offset2); } 476 AUE_PWRITE STD { ssize_t freebsd32_pwrite(int fd, \ const void *buf, size_t nbyte, \ int pad, \ uint32_t offset1, uint32_t offset2); } 477 AUE_MMAP STD { void *freebsd32_mmap(void *addr, \ size_t len, int prot, int flags, int fd, \ int pad, \ uint32_t pos1, uint32_t pos2); } 478 AUE_LSEEK STD { off_t freebsd32_lseek(int fd, \ int pad, \ uint32_t offset1, uint32_t offset2, \ int whence); } 479 AUE_TRUNCATE STD { int freebsd32_truncate(const char *path, \ int pad, \ uint32_t length1, uint32_t length2); } 480 AUE_FTRUNCATE STD { int freebsd32_ftruncate(int fd, \ int pad, \ uint32_t length1, uint32_t length2); } #else 475 AUE_PREAD STD { ssize_t freebsd32_pread(int fd, \ void *buf,size_t nbyte, \ uint32_t offset1, uint32_t offset2); } 476 AUE_PWRITE STD { ssize_t freebsd32_pwrite(int fd, \ const void *buf, size_t nbyte, \ uint32_t offset1, uint32_t offset2); } 477 AUE_MMAP STD { void *freebsd32_mmap(void *addr, \ size_t len, int prot, int flags, int fd, \ uint32_t pos1, uint32_t pos2); } 478 AUE_LSEEK STD { off_t freebsd32_lseek(int fd, \ uint32_t offset1, uint32_t offset2, \ int whence); } 479 AUE_TRUNCATE STD { int freebsd32_truncate(const char *path, \ uint32_t length1, uint32_t length2); } 480 AUE_FTRUNCATE STD { int freebsd32_ftruncate(int fd, \ uint32_t length1, uint32_t length2); } #endif 481 AUE_THR_KILL2 NOPROTO { int thr_kill2(pid_t pid, int32_t id, int sig); } 482 AUE_SHMOPEN COMPAT12|NOPROTO { int shm_open( \ const char *path, int flags, mode_t mode); } 483 AUE_SHMUNLINK NOPROTO { int shm_unlink(const char *path); } 484 AUE_NULL NOPROTO { int cpuset(cpusetid_t *setid); } #ifdef PAD64_REQUIRED 485 AUE_NULL STD { int freebsd32_cpuset_setid(cpuwhich_t which, \ int pad, \ uint32_t id1, uint32_t id2, \ cpusetid_t setid); } #else 485 AUE_NULL STD { int freebsd32_cpuset_setid(cpuwhich_t which, \ uint32_t id1, uint32_t id2, \ cpusetid_t setid); } #endif 486 AUE_NULL STD { int freebsd32_cpuset_getid(cpulevel_t level, \ cpuwhich_t which, \ uint32_t id1, uint32_t id2, \ cpusetid_t *setid); } 487 AUE_NULL STD { int freebsd32_cpuset_getaffinity( \ cpulevel_t level, cpuwhich_t which, \ uint32_t id1, uint32_t id2, \ size_t cpusetsize, \ cpuset_t *mask); } 488 AUE_NULL STD { int freebsd32_cpuset_setaffinity( \ cpulevel_t level, cpuwhich_t which, \ uint32_t id1, uint32_t id2, \ size_t cpusetsize, \ const cpuset_t *mask); } 489 AUE_FACCESSAT NOPROTO { int faccessat(int fd, const char *path, \ int amode, int flag); } 490 AUE_FCHMODAT NOPROTO { int fchmodat(int fd, const char *path, \ mode_t mode, int flag); } 491 AUE_FCHOWNAT NOPROTO { int fchownat(int fd, const char *path, \ uid_t uid, gid_t gid, int flag); } 492 AUE_FEXECVE STD { int freebsd32_fexecve(int fd, \ uint32_t *argv, uint32_t *envv); } 493 AUE_FSTATAT COMPAT11 { int freebsd32_fstatat(int fd, \ const char *path, \ struct freebsd11_stat32 *buf, \ int flag); } 494 AUE_FUTIMESAT STD { int freebsd32_futimesat(int fd, \ const char *path, \ const struct timeval32 *times); } 495 AUE_LINKAT NOPROTO { int linkat(int fd1, const char *path1, \ int fd2, const char *path2, int flag); } 496 AUE_MKDIRAT NOPROTO { int mkdirat(int fd, const char *path, \ mode_t mode); } 497 AUE_MKFIFOAT NOPROTO { int mkfifoat(int fd, const char *path, \ mode_t mode); } 498 AUE_MKNODAT COMPAT11|NOPROTO { int mknodat(int fd, \ const char *path, mode_t mode, \ uint32_t dev); } 499 AUE_OPENAT_RWTC NOPROTO { int openat(int fd, const char *path, \ int flag, mode_t mode); } 500 AUE_READLINKAT NOPROTO { ssize_t readlinkat(int fd, const char *path, \ char *buf, size_t bufsize); } 501 AUE_RENAMEAT NOPROTO { int renameat(int oldfd, const char *old, \ int newfd, const char *new); } 502 AUE_SYMLINKAT NOPROTO { int symlinkat(const char *path1, int fd, \ const char *path2); } 503 AUE_UNLINKAT NOPROTO { int unlinkat(int fd, const char *path, \ int flag); } 504 AUE_POSIX_OPENPT NOPROTO { int posix_openpt(int flags); } ; 505 is initialised by the kgssapi code, if present. 505 AUE_NULL NOPROTO|NOSTD { int gssd_syscall(const char *path); } 506 AUE_JAIL_GET STD { int freebsd32_jail_get(struct iovec32 *iovp, \ unsigned int iovcnt, int flags); } 507 AUE_JAIL_SET STD { int freebsd32_jail_set(struct iovec32 *iovp, \ unsigned int iovcnt, int flags); } 508 AUE_JAIL_REMOVE NOPROTO { int jail_remove(int jid); } 509 AUE_CLOSEFROM COMPAT12|NOPROTO { int closefrom(int lowfd); } 510 AUE_SEMCTL NOSTD { int freebsd32___semctl(int semid, int semnum, \ int cmd, union semun32 *arg); } 511 AUE_MSGCTL NOSTD { int freebsd32_msgctl(int msqid, int cmd, \ struct msqid_ds32 *buf); } 512 AUE_SHMCTL NOSTD { int freebsd32_shmctl(int shmid, int cmd, \ struct shmid_ds32 *buf); } 513 AUE_LPATHCONF NOPROTO { int lpathconf(const char *path, int name); } 514 AUE_NULL OBSOL cap_new 515 AUE_CAP_RIGHTS_GET NOPROTO { int __cap_rights_get(int version, \ int fd, cap_rights_t *rightsp); } 516 AUE_CAP_ENTER NOPROTO { int cap_enter(void); } 517 AUE_CAP_GETMODE NOPROTO { int cap_getmode(u_int *modep); } 518 AUE_PDFORK NOPROTO { int pdfork(int *fdp, int flags); } 519 AUE_PDKILL NOPROTO { int pdkill(int fd, int signum); } 520 AUE_PDGETPID NOPROTO { int pdgetpid(int fd, pid_t *pidp); } 521 AUE_PDWAIT UNIMPL pdwait4 522 AUE_SELECT STD { int freebsd32_pselect(int nd, fd_set *in, \ fd_set *ou, fd_set *ex, \ const struct timespec32 *ts, \ const sigset_t *sm); } 523 AUE_GETLOGINCLASS NOPROTO { int getloginclass(char *namebuf, \ size_t namelen); } 524 AUE_SETLOGINCLASS NOPROTO { int setloginclass(const char *namebuf); } 525 AUE_NULL NOPROTO { int rctl_get_racct(const void *inbufp, \ size_t inbuflen, void *outbufp, \ size_t outbuflen); } 526 AUE_NULL NOPROTO { int rctl_get_rules(const void *inbufp, \ size_t inbuflen, void *outbufp, \ size_t outbuflen); } 527 AUE_NULL NOPROTO { int rctl_get_limits(const void *inbufp, \ size_t inbuflen, void *outbufp, \ size_t outbuflen); } 528 AUE_NULL NOPROTO { int rctl_add_rule(const void *inbufp, \ size_t inbuflen, void *outbufp, \ size_t outbuflen); } 529 AUE_NULL NOPROTO { int rctl_remove_rule(const void *inbufp, \ size_t inbuflen, void *outbufp, \ size_t outbuflen); } #ifdef PAD64_REQUIRED 530 AUE_POSIX_FALLOCATE STD { int freebsd32_posix_fallocate(int fd, \ int pad, \ uint32_t offset1, uint32_t offset2,\ uint32_t len1, uint32_t len2); } 531 AUE_POSIX_FADVISE STD { int freebsd32_posix_fadvise(int fd, \ int pad, \ uint32_t offset1, uint32_t offset2,\ uint32_t len1, uint32_t len2, \ int advice); } 532 AUE_WAIT6 STD { int freebsd32_wait6(idtype_t idtype, int pad, \ uint32_t id1, uint32_t id2, \ int *status, int options, \ - struct wrusage32 *wrusage, \ + struct __wrusage32 *wrusage, \ struct siginfo32 *info); } #else 530 AUE_POSIX_FALLOCATE STD { int freebsd32_posix_fallocate(int fd,\ uint32_t offset1, uint32_t offset2,\ uint32_t len1, uint32_t len2); } 531 AUE_POSIX_FADVISE STD { int freebsd32_posix_fadvise(int fd, \ uint32_t offset1, uint32_t offset2,\ uint32_t len1, uint32_t len2, \ int advice); } 532 AUE_WAIT6 STD { int freebsd32_wait6(idtype_t idtype, \ uint32_t id1, uint32_t id2, \ int *status, int options, \ - struct wrusage32 *wrusage, \ + struct __wrusage32 *wrusage, \ struct siginfo32 *info); } #endif 533 AUE_CAP_RIGHTS_LIMIT NOPROTO { \ int cap_rights_limit(int fd, \ cap_rights_t *rightsp); } 534 AUE_CAP_IOCTLS_LIMIT STD { \ int freebsd32_cap_ioctls_limit(int fd, \ const uint32_t *cmds, size_t ncmds); } 535 AUE_CAP_IOCTLS_GET STD { \ ssize_t freebsd32_cap_ioctls_get(int fd, \ uint32_t *cmds, size_t maxcmds); } 536 AUE_CAP_FCNTLS_LIMIT NOPROTO { int cap_fcntls_limit(int fd, \ uint32_t fcntlrights); } 537 AUE_CAP_FCNTLS_GET NOPROTO { int cap_fcntls_get(int fd, \ uint32_t *fcntlrightsp); } 538 AUE_BINDAT NOPROTO { int bindat(int fd, int s, \ const struct sockaddr *name, \ int namelen); } 539 AUE_CONNECTAT NOPROTO { int connectat(int fd, int s, \ const struct sockaddr *name, \ int namelen); } 540 AUE_CHFLAGSAT NOPROTO { int chflagsat(int fd, const char *path, \ u_long flags, int atflag); } 541 AUE_ACCEPT NOPROTO { int accept4(int s, \ struct sockaddr *name, \ __socklen_t *anamelen, \ int flags); } 542 AUE_PIPE NOPROTO { int pipe2(int *fildes, int flags); } 543 AUE_AIO_MLOCK STD { int freebsd32_aio_mlock( \ struct aiocb32 *aiocbp); } #ifdef PAD64_REQUIRED 544 AUE_PROCCTL STD { int freebsd32_procctl(idtype_t idtype, int pad, \ uint32_t id1, uint32_t id2, int com, \ void *data); } #else 544 AUE_PROCCTL STD { int freebsd32_procctl(idtype_t idtype, \ uint32_t id1, uint32_t id2, int com, \ void *data); } #endif 545 AUE_POLL STD { int freebsd32_ppoll(struct pollfd *fds, \ u_int nfds, const struct timespec32 *ts, \ const sigset_t *set); } 546 AUE_FUTIMES STD { int freebsd32_futimens(int fd, \ const struct timespec32 *times); } 547 AUE_FUTIMESAT STD { int freebsd32_utimensat(int fd, \ const char *path, \ const struct timespec32 *times, \ int flag); } 548 AUE_NULL OBSOL numa_getaffinity 549 AUE_NULL OBSOL numa_setaffinity 550 AUE_FSYNC NOPROTO { int fdatasync(int fd); } 551 AUE_FSTAT STD { int freebsd32_fstat(int fd, \ struct stat32 *sb); } 552 AUE_FSTATAT STD { int freebsd32_fstatat(int fd, \ const char *path, struct stat32 *buf, \ int flag); } 553 AUE_FHSTAT STD { int freebsd32_fhstat( \ const struct fhandle *u_fhp, \ struct stat32 *sb); } 554 AUE_GETDIRENTRIES NOPROTO { ssize_t getdirentries( \ int fd, char *buf, size_t count, \ off_t *basep); } 555 AUE_STATFS NOPROTO { int statfs(const char *path, \ struct statfs *buf); } 556 AUE_FSTATFS NOPROTO { int fstatfs(int fd, struct statfs *buf); } 557 AUE_GETFSSTAT NOPROTO { int getfsstat(struct statfs *buf, \ long bufsize, int mode); } 558 AUE_FHSTATFS NOPROTO { int fhstatfs(const struct fhandle *u_fhp, \ struct statfs *buf); } #ifdef PAD64_REQUIRED 559 AUE_MKNODAT STD { int freebsd32_mknodat(int fd, \ const char *path, mode_t mode, \ int pad, uint32_t dev1, uint32_t dev2); } #else 559 AUE_MKNODAT STD { int freebsd32_mknodat(int fd, \ const char *path, mode_t mode, \ uint32_t dev1, uint32_t dev2); } #endif 560 AUE_KEVENT STD { int freebsd32_kevent(int fd, \ const struct kevent32 *changelist, \ int nchanges, \ struct kevent32 *eventlist, \ int nevents, \ const struct timespec32 *timeout); } 561 AUE_NULL STD { int freebsd32_cpuset_getdomain(cpulevel_t level, \ cpuwhich_t which, uint32_t id1, uint32_t id2, \ size_t domainsetsize, domainset_t *mask, \ int *policy); } 562 AUE_NULL STD { int freebsd32_cpuset_setdomain(cpulevel_t level, \ cpuwhich_t which, uint32_t id1, uint32_t id2, \ size_t domainsetsize, domainset_t *mask, \ int policy); } 563 AUE_NULL NOPROTO { int getrandom(void *buf, size_t buflen, \ unsigned int flags); } 564 AUE_NULL NOPROTO { int getfhat( int fd, char *path, \ struct fhandle *fhp, int flags); } 565 AUE_NULL NOPROTO { int fhlink( struct fhandle *fhp, const char *to ); } 566 AUE_NULL NOPROTO { int fhlinkat( struct fhandle *fhp, int tofd, \ const char *to); } 567 AUE_NULL NOPROTO { int fhreadlink( struct fhandle *fhp, char *buf, \ size_t bufsize); } 568 AUE_UNLINKAT NOPROTO { int funlinkat(int dfd, const char *path, int fd, \ int flag); } 569 AUE_NULL NOPROTO { ssize_t copy_file_range(int infd, \ off_t *inoffp, int outfd, off_t *outoffp, \ size_t len, unsigned int flags); } 570 AUE_SYSCTL STD { int freebsd32___sysctlbyname(const char *name, \ size_t namelen, void *old, uint32_t *oldlenp, \ void *new, size_t newlen); } 571 AUE_SHMOPEN NOPROTO { int shm_open2( \ const char *path, int flags, mode_t mode, \ int shmflags, const char *name); } 572 AUE_SHMRENAME NOPROTO { int shm_rename(const char *path_from, \ const char *path_to, int flags); } 573 AUE_NULL NOPROTO { int sigfastblock(int cmd, uint32_t *ptr); } 574 AUE_REALPATHAT NOPROTO { int __realpathat(int fd, const char *path, \ char *buf, size_t size, int flags); } 575 AUE_CLOSERANGE NOPROTO { int close_range(u_int lowfd, u_int highfd, \ int flags); } ; 576 is initialised by the krpc code, if present. 576 AUE_NULL NOSTD|NOPROTO { int rpctls_syscall(int op, \ const char *path); } 577 AUE_SPECIALFD NOPROTO { int __specialfd(int type, const void *req, \ size_t len); } 578 AUE_AIO_WRITEV STD { int freebsd32_aio_writev( \ struct aiocb32 *aiocbp); } 579 AUE_AIO_READV STD { int freebsd32_aio_readv( \ struct aiocb32 *aiocbp); } 580 AUE_FSPACECTL STD { int freebsd32_fspacectl(int fd, \ int cmd, \ const struct spacectl_range32 *rqsr, \ int flags, \ struct spacectl_range32 *rmsr); } 581 AUE_NULL NOPROTO { int sched_getcpu(void); } ; vim: syntax=off