FreeBSD/Linux Kernel Cross Reference
sys/amd64/linux32/syscalls.master

      $FreeBSD$
     
     ;       @(#)syscalls.master     8.1 (Berkeley) 7/19/93
     ; System call name/number master file (or rather, slave, from LINUX).
     ; Processed to create linux32_sysent.c, linux32_proto.h and linux32_syscall.h.
     
     ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
     ;       number  system call number, must be in order
     ;       audit   the audit event associated with the system call
    ;               A value of AUE_NULL means no auditing, but it also means that
    ;               there is no audit event for the call at this time. For the
    ;               case where the event exists, but we don't want auditing, the
    ;               event should be #defined to AUE_NULL in audit_kevents.h.
    ;       type    one of STD, NOPROTO, UNIMPL
    ;       name    pseudo-prototype of syscall routine
    ;               If one of the following alts is different, then all appear:
    ;       altname name of system call if different
    ;       alttag  name of args struct tag if different from [o]`name'"_args"
    ;       altrtyp return type if not int (bogus - syscalls always return int)
    ;               for UNIMPL, name continues with comments
    
    ; types:
    ;       STD     always included
    ;       UNIMPL  not implemented, placeholder only
    ;       NOPROTO same as STD except do not create structure or
    ;               function prototype in sys/sysproto.h.  Does add a
    ;               definition to syscall.h besides adding a sysent.
    
    #include <sys/param.h>
    #include <sys/sysent.h>
    #include <sys/sysproto.h>
    #include <compat/linux/linux_sysproto.h>
    #include <amd64/linux32/linux.h>
    #include <amd64/linux32/linux32_proto.h>
    
    ; Isn't pretty, but there seems to be no other way to trap nosys
    #define nosys   linux_nosys
    
    ; #ifdef's, etc. may be included, and are copied to the output files.
    
    0       AUE_NULL        UNIMPL  setup
    1       AUE_EXIT        STD {
                    void linux_exit(
                        int rval
                    );
            }
    2       AUE_FORK        STD {
                    int linux_fork(void);
            }
    3       AUE_NULL        NOPROTO {
                    int read(
                        int fd,
                        char *buf,
                        u_int nbyte
                    );
            }
    4       AUE_NULL        NOPROTO {
                    int write(
                        int fd,
                        char *buf,
                        u_int nbyte
                    );
            }
    5       AUE_OPEN_RWTC   STD {
                    int linux_open(
                        char *path,
                        l_int flags,
                        l_int mode
                    );
            }
    6       AUE_CLOSE       NOPROTO {
                    int close(
                        int fd
                    );
            }
    7       AUE_WAIT4       STD {
                    int linux_waitpid(
                        l_pid_t pid,
                        l_int *status,
                        l_int options
                    );
            }
    8       AUE_CREAT       STD {
                    int linux_creat(
                        char *path,
                        l_int mode
                    );
            }
    9       AUE_LINK        STD {
                    int linux_link(
                        char *path,
                        char *to
                    );
            }
    10      AUE_UNLINK      STD {
                    int linux_unlink(
                        char *path
                    );
            }
   11      AUE_EXECVE      STD {
                   int linux_execve(
                       char *path,
                       uint32_t *argp,
                       uint32_t *envp
                   );
           }
   12      AUE_CHDIR       STD {
                   int linux_chdir(
                       char *path
                   );
           }
   13      AUE_NULL        STD {
                   int linux_time(
                       l_time_t *tm
                   );
           }
   14      AUE_MKNOD       STD {
                   int linux_mknod(
                       char *path,
                       l_int mode,
                       l_dev_t dev
                   );
           }
   15      AUE_CHMOD       STD {
                   int linux_chmod(
                       char *path,
                       l_mode_t mode
                   );
           }
   16      AUE_LCHOWN      STD {
                   int linux_lchown16(
                       char *path,
                       l_uid16_t uid,
                       l_gid16_t gid
                   );
           }
   17      AUE_NULL        UNIMPL  break
   18      AUE_STAT        STD {
                   int linux_stat(
                       char *path,
                       struct linux_stat *up
                   );
           }
   19      AUE_LSEEK       STD {
                   int linux_lseek(
                       l_uint fdes,
                       l_off_t off,
                       l_int whence
                   );
           }
   20      AUE_GETPID      STD {
                   int linux_getpid(void);
           }
   21      AUE_MOUNT       STD {
                   int linux_mount(
                       char *specialfile,
                       char *dir,
                       char *filesystemtype,
                       l_ulong rwflag,
                       void *data
                   );
           }
   22      AUE_UMOUNT      STD {
                   int linux_oldumount(
                       char *path
                   );
           }
   23      AUE_SETUID      STD {
                   int linux_setuid16(
                       l_uid16_t uid
                   );
           }
   24      AUE_GETUID      STD {
                   int linux_getuid16(void);
           }
   25      AUE_SETTIMEOFDAY        STD {
                   int linux_stime(void);
           }
   26      AUE_PTRACE      STD {
                   int linux_ptrace(
                       l_long req,
                       l_long pid,
                       l_long addr,
                       l_long data
                   );
           }
   27      AUE_NULL        STD {
                   int linux_alarm(
                       l_uint secs
                   );
           }
   28      AUE_FSTAT       UNIMPL  fstat
   29      AUE_NULL        STD {
                   int linux_pause(void);
           }
   30      AUE_UTIME       STD {
                   int linux_utime(
                       char *fname,
                       struct l_utimbuf *times
                   );
           }
   31      AUE_NULL        UNIMPL  stty
   32      AUE_NULL        UNIMPL  gtty
   33      AUE_ACCESS      STD {
                   int linux_access(
                       char *path,
                       l_int amode
                   );
           }
   34      AUE_NICE        STD {
                   int linux_nice(
                       l_int inc
                   );
           }
   35      AUE_NULL        UNIMPL  ftime
   36      AUE_SYNC        NOPROTO {
                   int sync(void);
           }
   37      AUE_KILL        STD {
                   int linux_kill(
                       l_int pid,
                       l_int signum
                   );
           }
   38      AUE_RENAME      STD {
                   int linux_rename(
                       char *from,
                       char *to
                   );
           }
   39      AUE_MKDIR       STD {
                   int linux_mkdir(
                       char *path,
                       l_int mode
                   );
           }
   40      AUE_RMDIR       STD {
                   int linux_rmdir(
                       char *path
                   );
           }
   41      AUE_DUP         NOPROTO {
                   int dup(
                       u_int fd
                   );
           }
   42      AUE_PIPE        STD {
                   int linux_pipe(
                       l_int *pipefds
                   );
           }
   43      AUE_NULL        STD {
                   int linux_times(
                       struct l_times_argv *buf
                   );
           }
   44      AUE_NULL        UNIMPL  prof
   45      AUE_NULL        STD {
                   int linux_brk(
                       l_ulong dsend
                   );
           }
   46      AUE_SETGID      STD {
                   int linux_setgid16(
                       l_gid16_t gid
                   );
           }
   47      AUE_GETGID      STD {
                   int linux_getgid16(void);
           }
   48      AUE_NULL        STD {
                   int linux_signal(
                       l_int sig,
                       l_handler_t handler
                   );
           }
   49      AUE_GETEUID     STD {
                   int linux_geteuid16(void);
           }
   50      AUE_GETEGID     STD {
                   int linux_getegid16(void);
           }
   51      AUE_ACCT        NOPROTO {
                   int acct(
                       char *path
                   );
           }
   52      AUE_UMOUNT      STD {
                   int linux_umount(
                       char *path,
                       l_int flags
                   );
           }
   53      AUE_NULL        UNIMPL  lock
   54      AUE_IOCTL       STD {
                   int linux_ioctl(
                       l_uint fd,
                       l_uint cmd,
                       uintptr_t arg
                   );
           }
   55      AUE_FCNTL       STD {
                   int linux_fcntl(
                       l_uint fd,
                       l_uint cmd,
                       uintptr_t arg
                   );
           }
   56      AUE_NULL        UNIMPL  mpx
   57      AUE_SETPGRP     NOPROTO {
                   int setpgid(
                       int pid,
                       int pgid
                   );
           }
   58      AUE_NULL        UNIMPL  ulimit
   59      AUE_NULL        STD {
                   int linux_olduname(void);
           }
   60      AUE_UMASK       NOPROTO {
                   int umask(
                       int newmask
                   );
           }
   61      AUE_CHROOT      NOPROTO {
                   int chroot(
                       char *path
                   );
           }
   62      AUE_NULL        STD {
                   int linux_ustat(
                       l_dev_t dev,
                       struct l_ustat *ubuf
                   );
           }
   63      AUE_DUP2        NOPROTO {
                   int dup2(
                       u_int from,
                       u_int to
                   );
           }
   64      AUE_GETPPID     STD {
                   int linux_getppid(void);
           }
   65      AUE_GETPGRP     NOPROTO {
                   int getpgrp(void);
           }
   66      AUE_SETSID      NOPROTO {
                   int setsid(void);
           }
   67      AUE_NULL        STD {
                   int linux_sigaction(
                       l_int sig,
                       l_osigaction_t *nsa,
                       l_osigaction_t *osa
                   );
           }
   68      AUE_NULL        STD {
                   int linux_sgetmask(void);
           }
   69      AUE_NULL        STD {
                   int linux_ssetmask(
                       l_osigset_t mask
                   );
           }
   70      AUE_SETREUID    STD {
                   int linux_setreuid16(
                       l_uid16_t ruid,
                       l_uid16_t euid
                   );
           }
   71      AUE_SETREGID    STD {
                   int linux_setregid16(
                       l_gid16_t rgid,
                       l_gid16_t egid
                   );
           }
   72      AUE_NULL        STD {
                   int linux_sigsuspend(
                       l_int hist0,
                       l_int hist1,
                       l_osigset_t mask
                   );
           }
   73      AUE_NULL        STD {
                   int linux_sigpending(
                       l_osigset_t *mask
                   );
           }
   74      AUE_SYSCTL      STD {
                   int linux_sethostname(
                       char *hostname,
                       u_int len
                   );
           }
   75      AUE_SETRLIMIT   STD {
                   int linux_setrlimit(
                       l_uint resource,
                       struct l_rlimit *rlim
                   );
           }
   76      AUE_GETRLIMIT   STD {
                   int linux_old_getrlimit(
                       l_uint resource,
                       struct l_rlimit *rlim
                   );
           }
   77      AUE_GETRUSAGE   STD {
                   int linux_getrusage(
                       int who,
                       struct l_rusage *rusage
                   );
           }
   78      AUE_NULL        STD {
                   int linux_gettimeofday(
                       struct l_timeval *tp,
                       struct timezone *tzp
                   );
           }
   79      AUE_SETTIMEOFDAY STD {
                   int linux_settimeofday(
                       struct l_timeval *tp,
                       struct timezone *tzp
                   );
           }
   80      AUE_GETGROUPS   STD {
                   int linux_getgroups16(
                       l_uint gidsetsize,
                       l_gid16_t *gidset
                   );
           }
   81      AUE_SETGROUPS   STD {
                   int linux_setgroups16(
                       l_uint gidsetsize,
                       l_gid16_t *gidset
                   );
           }
   82      AUE_SELECT      STD {
                   int linux_old_select(
                       struct l_old_select_argv *ptr
                   );
           }
   83      AUE_SYMLINK     STD {
                   int linux_symlink(
                       char *path,
                       char *to
                   );
           }
   ; 84: oldlstat
   84      AUE_LSTAT       STD {
                   int linux_lstat(
                       char *path,
                       struct linux_lstat *up
                   );
           }
   85      AUE_READLINK    STD {
                   int linux_readlink(
                       char *name,
                       char *buf,
                       l_int count
                   );
           }
   86      AUE_USELIB      UNIMPL  linux_uselib
   87      AUE_SWAPON      NOPROTO {
                   int swapon(
                       char *name
                   );
           }
   88      AUE_REBOOT      STD {
                   int linux_reboot(
                       l_int magic1,
                       l_int magic2,
                       l_uint cmd,
                       void *arg
                   );
           }
   ; 89: old_readdir
   89      AUE_GETDIRENTRIES       STD  {
                   int linux_readdir(
                       l_uint fd,
                       struct l_dirent *dent,
                       l_uint count
                   );
           }
   ; 90: old_mmap
   90      AUE_MMAP        STD {
                   int linux_mmap(
                       struct l_mmap_argv *ptr
                   );
           }
   91      AUE_MUNMAP      NOPROTO {
                   int munmap(
                       caddr_t addr,
                       int len
                   );
           }
   92      AUE_TRUNCATE    STD {
                   int linux_truncate(
                       char *path,
                       l_ulong length
                   );
           }
   93      AUE_FTRUNCATE   STD {
                   int linux_ftruncate(
                       int fd,
                       long length
                   );
           }
   94      AUE_FCHMOD      NOPROTO {
                   int fchmod(
                       int fd,
                       int mode
                   );
           }
   95      AUE_FCHOWN      NOPROTO {
                   int fchown(
                       int fd,
                       int uid,
                       int gid
                   );
           }
   96      AUE_GETPRIORITY STD {
                   int linux_getpriority(
                       int which,
                       int who
                   );
           }
   97      AUE_SETPRIORITY NOPROTO {
                   int setpriority(
                       int which,
                       int who,
                       int prio
                   );
           }
   98      AUE_PROFILE     UNIMPL  profil
   99      AUE_STATFS      STD {
                   int linux_statfs(
                       char *path,
                       struct l_statfs_buf *buf
                   );
           }
   100     AUE_FSTATFS     STD {
                   int linux_fstatfs(
                       l_uint fd,
                       struct l_statfs_buf *buf
                   );
           }
   101     AUE_NULL        UNIMPL  ioperm
   102     AUE_NULL        STD {
                   int linux_socketcall(
                       l_int what,
                       l_ulong args
                   );
           }
   103     AUE_NULL        STD {
                   int linux_syslog(
                       l_int type,
                       char *buf,
                       l_int len
                   );
           }
   104     AUE_SETITIMER   STD {
                   int linux_setitimer(
                       l_int which,
                       struct l_itimerval *itv,
                       struct l_itimerval *oitv
                   );
           }
   105     AUE_GETITIMER   STD {
                   int linux_getitimer(
                       l_int which,
                       struct l_itimerval *itv
                   );
           }
   106     AUE_STAT        STD {
                   int linux_newstat(
                       char *path,
                       struct l_newstat *buf
                   );
           }
   107     AUE_LSTAT       STD {
                   int linux_newlstat(
                       char *path,
                       struct l_newstat *buf
                   );
           }
   108     AUE_FSTAT       STD {
                   int linux_newfstat(
                       l_uint fd,
                       struct l_newstat *buf
                   );
           }
   ; 109: olduname
   109     AUE_NULL        STD {
                   int linux_uname(void);
           }
   110     AUE_NULL        STD {
                   int linux_iopl(
                       l_int level
                   );
           }
   111     AUE_NULL        STD {
                   int linux_vhangup(void);
           }
   112     AUE_NULL        UNIMPL  idle
   113     AUE_NULL        UNIMPL  vm86old
   114     AUE_WAIT4       STD {
                   int linux_wait4(
                       l_pid_t pid,
                       l_int *status,
                       l_int options,
                       struct l_rusage *rusage
                   );
           }
   115     AUE_SWAPOFF     STD {
                   int linux_swapoff(void);
           }
   116     AUE_NULL        STD {
                   int linux_sysinfo(
                       struct l_sysinfo *info
                   );
           }
   117     AUE_NULL        STD {
                   int linux_ipc(
                       l_uint what,
                       l_int arg1,
                       l_int arg2,
                       l_uint arg3,
                       l_uintptr_t ptr,
                       l_uint arg5
                   );
           }
   118     AUE_FSYNC       NOPROTO {
                   int fsync(
                       int fd
                   );
           }
   119     AUE_SIGRETURN   STD {
                   int linux_sigreturn(
                       struct l_sigframe *sfp
                   );
           }
   120     AUE_RFORK       STD {
                   int linux_clone(
                       l_ulong flags,
                       l_ulong stack,
                       l_int *parent_tidptr,
                       l_ulong tls,
                       l_int *child_tidptr
                   );
           }
   121     AUE_SYSCTL      STD {
                   int linux_setdomainname(
                       char *name,
                       int len
                   );
           }
   122     AUE_NULL        STD {
                   int linux_newuname(
                       struct l_new_utsname *buf
                   );
           }
   123     AUE_NULL        UNIMPL  modify_ldt
   124     AUE_ADJTIME     STD {
                   int linux_adjtimex(void);
           }
   125     AUE_MPROTECT    STD {
                   int linux_mprotect(
                       caddr_t addr,
                       int len,
                       int prot
                   );
           }
   126     AUE_SIGPROCMASK STD {
                   int linux_sigprocmask(
                       l_int how,
                       l_osigset_t *mask,
                       l_osigset_t *omask
                   );
           }
   127     AUE_NULL        UNIMPL  create_module
   128     AUE_NULL        STD {
                   int linux_init_module(void);
           }
   129     AUE_NULL        STD {
                   int linux_delete_module(void);
           }
   130     AUE_NULL        UNIMPL  get_kernel_syms
   131     AUE_QUOTACTL    STD {
                   int linux_quotactl(void);
           }
   132     AUE_GETPGID     NOPROTO {
                   int getpgid(
                       int pid
                   );
           }
   133     AUE_FCHDIR      NOPROTO {
                   int fchdir(
                       int fd
                   );
           }
   134     AUE_BDFLUSH     STD {
                   int linux_bdflush(void);
           }
   135     AUE_NULL        STD {
                   int linux_sysfs(
                       l_int option,
                       l_ulong arg1,
                       l_ulong arg2
                   );
           }
   136     AUE_PERSONALITY STD {
                   int linux_personality(
                       l_uint per
                   );
           }
   137     AUE_NULL        UNIMPL  afs_syscall
   138     AUE_SETFSUID    STD {
                   int linux_setfsuid16(
                       l_uid16_t uid
                   );
           }
   139     AUE_SETFSGID    STD {
                   int linux_setfsgid16(
                       l_gid16_t gid
                   );
           }
   140     AUE_LSEEK       STD {
                   int linux_llseek(
                       l_int fd,
                       l_ulong ohigh,
                       l_ulong olow,
                       l_loff_t *res,
                       l_uint whence
                   );
           }
   141     AUE_GETDIRENTRIES       STD  {
                   int linux_getdents(
                       l_uint fd,
                       void *dent,
                       l_uint count
                   );
           }
   ; 142: newselect
   142     AUE_SELECT      STD {
                   int linux_select(
                       l_int nfds,
                       l_fd_set *readfds,
                       l_fd_set *writefds,
                       l_fd_set *exceptfds,
                       struct l_timeval *timeout
                   );
           }
   143     AUE_FLOCK       NOPROTO {
                   int flock(
                       int fd,
                       int how
                   );
           }
   144     AUE_MSYNC       STD {
                   int linux_msync(
                       l_ulong addr,
                       l_size_t len,
                       l_int fl
                   );
           }
   145     AUE_READV       STD  {
                   int linux_readv(
                       l_ulong fd,
                       struct l_iovec32 *iovp,
                       l_ulong iovcnt
                   );
           }
   146     AUE_WRITEV      STD  {
                   int linux_writev(
                       l_ulong fd,
                       struct l_iovec32 *iovp,
                       l_ulong iovcnt
                   );
           }
   147     AUE_GETSID      STD {
                   int linux_getsid(
                       l_pid_t pid
                   );
           }
   148     AUE_NULL        STD {
                   int linux_fdatasync(
                       l_uint fd
                   );
           }
   149     AUE_SYSCTL      STD {
                   int linux_sysctl(
                       struct l___sysctl_args *args
                   );
           }
   150     AUE_MLOCK       NOPROTO {
                   int mlock(
                       const void *addr,
                       size_t len
                   );
           }
   151     AUE_MUNLOCK     NOPROTO {
                   int munlock(
                       const void *addr,
                       size_t len
                   );
           }
   152     AUE_MLOCKALL    NOPROTO {
                   int mlockall(
                       int how
                   );
           }
   153     AUE_MUNLOCKALL  NOPROTO {
                   int munlockall(void);
           }
   154     AUE_SCHED_SETPARAM      STD {
                   int linux_sched_setparam(
                       l_pid_t pid,
                       struct sched_param *param
                   );
           }
   155     AUE_SCHED_GETPARAM      STD {
                   int linux_sched_getparam(
                       l_pid_t pid,
                       struct sched_param *param
                   );
           }
   156     AUE_SCHED_SETSCHEDULER  STD  {
                   int linux_sched_setscheduler(
                       l_pid_t pid,
                       l_int policy,
                       struct sched_param *param
                   );
           }
   157     AUE_SCHED_GETSCHEDULER  STD  {
                   int linux_sched_getscheduler(
                       l_pid_t pid
                   );
           }
   158     AUE_NULL        NOPROTO {
                   int sched_yield(void);
           }
   159     AUE_SCHED_GET_PRIORITY_MAX      STD  {
                   int linux_sched_get_priority_max(
                       l_int policy
                   );
           }
   160     AUE_SCHED_GET_PRIORITY_MIN      STD  {
                   int linux_sched_get_priority_min(
                       l_int policy
                   );
           }
   161     AUE_SCHED_RR_GET_INTERVAL       STD  {
                   int linux_sched_rr_get_interval(
                       l_pid_t pid,
                       struct l_timespec *interval
                   );
           }
   162     AUE_NULL        STD {
                   int linux_nanosleep(
                       const struct l_timespec *rqtp,
                       struct l_timespec *rmtp
                   );
           }
   163     AUE_NULL        STD {
                   int linux_mremap(
                       l_ulong addr,
                       l_ulong old_len,
                       l_ulong new_len,
                       l_ulong flags,
                       l_ulong new_addr
                   );
           }
   164     AUE_SETRESUID   STD {
                   int linux_setresuid16(
                       l_uid16_t ruid,
                       l_uid16_t euid,
                       l_uid16_t suid
                   );
           }
   165     AUE_GETRESUID   STD {
                   int linux_getresuid16(
                       l_uid16_t *ruid,
                       l_uid16_t *euid,
                       l_uid16_t *suid
                   );
           }
   166     AUE_NULL        UNIMPL  vm86
   167     AUE_NULL        UNIMPL  query_module
   168     AUE_POLL        STD {
                   int linux_poll(
                       struct pollfd *fds,
                       unsigned int nfds,
                       int timeout
                   );
           }
   169     AUE_NULL        UNIMPL  nfsservctl
   170     AUE_SETRESGID   STD {
                   int linux_setresgid16(
                       l_gid16_t rgid,
                       l_gid16_t egid,
                       l_gid16_t sgid
                   );
           }
   171     AUE_GETRESGID   STD {
                   int linux_getresgid16(
                       l_gid16_t *rgid,
                       l_gid16_t *egid,
                       l_gid16_t *sgid
                   );
           }
   172     AUE_PRCTL       STD {
                   int linux_prctl(
                       l_int option,
                       l_uintptr_t arg2,
                       l_uintptr_t arg3,
                       l_uintptr_t arg4,
                       l_uintptr_t arg5
                   );
           }
   173     AUE_NULL        STD {
                   int linux_rt_sigreturn(
                       struct l_ucontext *ucp
                   );
           }
   174     AUE_NULL        STD {
                   int linux_rt_sigaction(
                       l_int sig,
                       l_sigaction_t *act,
                       l_sigaction_t *oact,
                       l_size_t sigsetsize
                   );
           }
   175     AUE_NULL        STD {
                   int linux_rt_sigprocmask(
                       l_int how,
                       l_sigset_t *mask,
                       l_sigset_t *omask,
                       l_size_t sigsetsize
                   );
           }
   176     AUE_NULL        STD {
                   int linux_rt_sigpending(
                       l_sigset_t *set,
                       l_size_t sigsetsize
                   );
           }
   177     AUE_NULL        STD {
                   int linux_rt_sigtimedwait(
                       l_sigset_t *mask,
                       l_siginfo_t *ptr,
                       struct l_timespec *timeout,
                       l_size_t sigsetsize
                   );
           }
   178     AUE_NULL        STD {
                   int linux_rt_sigqueueinfo(
                       l_pid_t pid,
                       l_int sig,
                       l_siginfo_t *info
                   );
           }
   179     AUE_NULL        STD {
                   int linux_rt_sigsuspend(
                       l_sigset_t *newset,
                       l_size_t sigsetsize
                   );
           }
   180     AUE_PREAD       STD {
                   int linux_pread(
                       l_uint fd,
                       char *buf,
                       l_size_t nbyte,
                       uint32_t offset1,
                       uint32_t offset2
                   );
           }
   181     AUE_PWRITE      STD {
                   int linux_pwrite(
                       l_uint fd,
                       char *buf,
                       l_size_t nbyte,
                       uint32_t offset1,
                       uint32_t offset2
                   );
           }
   182     AUE_CHOWN       STD {
                   int linux_chown16(
                       char *path,
                       l_uid16_t uid,
                       l_gid16_t gid
                   );
           }
   183     AUE_GETCWD      STD {
                   int linux_getcwd(
                       char *buf,
                       l_ulong bufsize
                   );
           }
  184     AUE_CAPGET      STD {
                  int linux_capget(
                      struct l_user_cap_header *hdrp,
                      struct l_user_cap_data *datap
                  );
          }
  185     AUE_CAPSET      STD {
                  int linux_capset(
                      struct l_user_cap_header *hdrp,
                      struct l_user_cap_data *datap
                  );
          }
  186     AUE_NULL        STD {
                  int linux_sigaltstack(
                      l_stack_t *uss,
                      l_stack_t *uoss
                  );
          }
  187     AUE_SENDFILE    STD {
                  int linux_sendfile(
                      l_int out,
                      l_int in,
                      l_long *offset,
                      l_size_t count
                  );
          }
  188     AUE_GETPMSG     UNIMPL  getpmsg
  189     AUE_PUTPMSG     UNIMPL  putpmsg
  190     AUE_VFORK       STD {
                  int linux_vfork(void);
          }
  ; 191: ugetrlimit
  191     AUE_GETRLIMIT   STD {
                  int linux_getrlimit(
                      l_uint resource,
                      struct l_rlimit *rlim
                  );
          }
  192     AUE_MMAP        STD {
                  int linux_mmap2(
                      l_ulong addr,
                      l_ulong len,
                      l_ulong prot,
                      l_ulong flags,
                      l_ulong fd,
                      l_ulong pgoff
                  );
          }
  193     AUE_TRUNCATE    STD {
                  int linux_truncate64(
                      char *path,
                      uint32_t length1,
                      uint32_t length2
                  );
          }
  194     AUE_FTRUNCATE   STD {
                  int linux_ftruncate64(
                      l_uint fd,
                      uint32_t length1,
                      uint32_t length2
                  );
          }
  195     AUE_STAT        STD {
                  int linux_stat64(
                      const char *filename,
                      struct l_stat64 *statbuf
                  );
          }
  196     AUE_LSTAT       STD {
                  int linux_lstat64(
                      const char *filename,
                      struct l_stat64 *statbuf
                  );
          }
  197     AUE_FSTAT       STD {
                  int linux_fstat64(
                      l_int fd,
                      struct l_stat64 *statbuf
                  );
          }
  198     AUE_LCHOWN      STD {
                  int linux_lchown(
                      char *path,
                      l_uid_t uid,
                      l_gid_t gid
                  );
          }
  199     AUE_GETUID      STD {
                  int linux_getuid(void);
          }
  200     AUE_GETGID      STD {
                  int linux_getgid(void);
          }
  201     AUE_GETEUID     NOPROTO {
                  int geteuid(void);
          }
  202     AUE_GETEGID     NOPROTO {
                  int getegid(void);
          }
  203     AUE_SETREUID    NOPROTO {
                  int setreuid(
                      uid_t ruid,
                      uid_t euid
                  );
          }
  204     AUE_SETREGID    NOPROTO {
                  int setregid(
                      gid_t rgid,
                      gid_t egid
                  );
          }
  205     AUE_GETGROUPS   STD {
                  int linux_getgroups(
                      l_int gidsetsize,
                      l_gid_t *grouplist
                  );
          }
  206     AUE_SETGROUPS   STD {
                  int linux_setgroups(
                      l_int gidsetsize,
                      l_gid_t *grouplist
                  );
          }
  207     AUE_FCHOWN      NODEF   fchown fchown fchown_args int
  208     AUE_SETRESUID   NOPROTO {
                  int setresuid(
                      uid_t ruid,
                      uid_t euid,
                      uid_t suid
                  );
          }
  209     AUE_GETRESUID   NOPROTO {
                  int getresuid(
                      uid_t *ruid,
                      uid_t *euid,
                      uid_t *suid
                  );
          }
  210     AUE_SETRESGID   NOPROTO {
                  int setresgid(
                      gid_t rgid,
                      gid_t egid,
                      gid_t sgid
                  );
          }
  211     AUE_GETRESGID   NOPROTO {
                  int getresgid(
                      gid_t *rgid,
                      gid_t *egid,
                      gid_t *sgid
                  );
          }
  212     AUE_CHOWN       STD {
                  int linux_chown(
                      char *path,
                      l_uid_t uid,
                      l_gid_t gid
                  );
          }
  213     AUE_SETUID      NOPROTO {
                  int setuid(
                      uid_t uid
                  );
          }
  214     AUE_SETGID      NOPROTO {
                  int setgid(
                      gid_t gid
                  );
          }
  215     AUE_SETFSUID    STD {
                  int linux_setfsuid(
                      l_uid_t uid
                  );
          }
  216     AUE_SETFSGID    STD {
                  int linux_setfsgid(
                      l_gid_t gid
                  );
          }
  217     AUE_PIVOT_ROOT  STD {
                  int linux_pivot_root(
                      char *new_root,
                      char *put_old
                  );
          }
  218     AUE_MINCORE     STD {
                  int linux_mincore(
                      l_ulong start,
                      l_size_t len,
                      u_char *vec
                  );
          }
  219     AUE_MADVISE     STD {
                  int linux_madvise(
                      void *addr,
                      size_t len,
                      int behav
                  );
          }
  220     AUE_GETDIRENTRIES       STD  {
                  int linux_getdents64(
                      l_uint fd,
                      void *dirent,
                      l_uint count
                  );
          }
  221     AUE_FCNTL       STD {
                  int linux_fcntl64(
                      l_uint fd,
                      l_uint cmd,
                      uintptr_t arg
                  );
          }
  222     AUE_NULL        UNIMPL
  223     AUE_NULL        UNIMPL
  224     AUE_NULL        STD {
                  long linux_gettid(void);
          }
  225     AUE_NULL        UNIMPL  linux_readahead
  226     AUE_NULL        STD {
                  int linux_setxattr(
                      const char *path,
                      const char *name,
                      const char *value,
                      l_size_t size,
                      l_int flags
                  );
          }
  227     AUE_NULL        STD {
                  int linux_lsetxattr(
                      const char *path,
                      const char *name,
                      const char *value,
                      l_size_t size,
                      l_int flags
                  );
          }
  228     AUE_NULL        STD {
                  int linux_fsetxattr(
                      l_int fd,
                      const char *name,
                      const char *value,
                      l_size_t size,
                      l_int flags
                  );
          }
  229     AUE_NULL        STD {
                  int linux_getxattr(
                      const char *path,
                      const char *name,
                      char *value,
                      l_size_t size
                  );
          }
  230     AUE_NULL        STD {
                  int linux_lgetxattr(
                      const char *path,
                      const char *name,
                      char *value,
                      l_size_t size
                  );
          }
  231     AUE_NULL        STD {
                  int linux_fgetxattr(
                      l_int fd,
                      const char *name,
                      char *value,
                      l_size_t size
                  );
          }
  232     AUE_NULL        STD {
                  int linux_listxattr(
                      const char *path,
                      const char *list,
                      l_size_t size
                  );
          }
  233     AUE_NULL        STD {
                  int linux_llistxattr(
                      const char *path,
                      const char *list,
                      l_size_t size
                  );
          }
  234     AUE_NULL        STD {
                  int linux_flistxattr(
                      l_int fd,
                      const char *list,
                      l_size_t size
                  );
          }
  235     AUE_NULL        STD {
                  int linux_removexattr(
                      const char *path,
                      const char *name
                  );
          }
  236     AUE_NULL        STD {
                  int linux_lremovexattr(
                      const char *path,
                      const char *name
                  );
          }
  237     AUE_NULL        STD {
                  int linux_fremovexattr(
                      l_int fd,
                      const char *name
                  );
          }
  238     AUE_NULL        STD {
                  int linux_tkill(
                      int tid,
                      int sig
                  );
          }
  239     AUE_SENDFILE    STD {
                  int linux_sendfile64(
                      l_int out,
                      l_int in,
                      l_loff_t *offset,
                      l_size_t count
                  );
          }
  240     AUE_NULL        STD {
                  int linux_sys_futex(
                      uint32_t *uaddr,
                      l_int op,
                      uint32_t val,
                      struct l_timespec *timeout,
                      uint32_t *uaddr2,
                      uint32_t val3
                  );
          }
  241     AUE_NULL        STD {
                  int linux_sched_setaffinity(
                      l_pid_t pid,
                      l_uint len,
                      l_ulong *user_mask_ptr
                  );
          }
  242     AUE_NULL        STD {
                  int linux_sched_getaffinity(
                      l_pid_t pid,
                      l_uint len,
                      l_ulong *user_mask_ptr
                  );
          }
  243     AUE_NULL        STD {
                  int linux_set_thread_area(
                      struct l_user_desc *desc
                  );
          }
  244     AUE_NULL        UNIMPL  linux_get_thread_area
  245     AUE_NULL        UNIMPL  linux_io_setup
  246     AUE_NULL        UNIMPL  linux_io_destroy
  247     AUE_NULL        UNIMPL  linux_io_getevents
  248     AUE_NULL        UNIMPL  linux_io_submit
  249     AUE_NULL        UNIMPL  linux_io_cancel
  250     AUE_NULL        STD {
                  int linux_fadvise64(
                      int fd,
                      uint32_t offset1,
                      uint32_t offset2,
                      l_size_t len,
                      int advice
                  );
          }
  251     AUE_NULL        UNIMPL
  252     AUE_EXIT        STD {
                  int linux_exit_group(
                      int error_code
                  );
          }
  253     AUE_NULL        STD {
                  int linux_lookup_dcookie(void);
          }
  254     AUE_NULL        STD {
                  int linux_epoll_create(
                      l_int size
                  );
          }
  255     AUE_NULL        STD {
                  int linux_epoll_ctl(
                      l_int epfd,
                      l_int op,
                      l_int fd,
                      struct epoll_event *event
                  );
          }
  256     AUE_NULL        STD {
                  int linux_epoll_wait(
                      l_int epfd,
                      struct epoll_event *events,
                      l_int maxevents,
                      l_int timeout
                  );
          }
  257     AUE_NULL        STD {
                  int linux_remap_file_pages(void);
          }
  258     AUE_NULL        STD {
                  int linux_set_tid_address(
                      int *tidptr
                  );
          }
  259     AUE_NULL        STD {
                  int linux_timer_create(
                      clockid_t clock_id,
                      struct sigevent *evp,
                      l_timer_t *timerid
                  );
          }
  260     AUE_NULL        STD {
                  int linux_timer_settime(
                      l_timer_t timerid,
                      l_int flags,
                      const struct itimerspec *new,
                      struct itimerspec *old
                  );
          }
  261     AUE_NULL        STD {
                  int linux_timer_gettime(
                      l_timer_t timerid,
                      struct itimerspec *setting
                  );
          }
  262     AUE_NULL        STD {
                  int linux_timer_getoverrun(
                      l_timer_t timerid
                  );
          }
  263     AUE_NULL        STD {
                  int linux_timer_delete(
                      l_timer_t timerid
                  );
          }
  264     AUE_CLOCK_SETTIME       STD {
                  int linux_clock_settime(
                      clockid_t which,
                      struct l_timespec *tp
                  );
          }
  265     AUE_NULL        STD {
                  int linux_clock_gettime(
                      clockid_t which,
                      struct l_timespec *tp
                  );
          }
  266     AUE_NULL        STD {
                  int linux_clock_getres(
                      clockid_t which,
                      struct l_timespec *tp
                  );
          }
  267     AUE_NULL        STD {
                  int linux_clock_nanosleep(
                      clockid_t which,
                      int flags,
                      struct l_timespec *rqtp,
                      struct l_timespec *rmtp
                  );
          }
  268     AUE_STATFS      STD {
                  int linux_statfs64(
                      char *path,
                      size_t bufsize,
                      struct l_statfs64_buf *buf
                  );
          }
  269     AUE_FSTATFS     STD {
                  int linux_fstatfs64(
                      l_uint fd,
                      size_t bufsize,
                      struct l_statfs64_buf *buf
                  );
          }
  270     AUE_NULL        STD {
                  int linux_tgkill(
                      int tgid,
                      int pid,
                      int sig
                  );
          }
  271     AUE_UTIMES      STD {
                  int linux_utimes(
                      char *fname,
                      struct l_timeval *tptr
                  );
          }
  272     AUE_NULL        STD {
                  int linux_fadvise64_64(
                      int fd,
                      uint32_t offset1,
                      uint32_t offset2,
                      uint32_t len1,
                      uint32_t len2,
                      int advice
                  );
          }
  273     AUE_NULL        UNIMPL  vserver
  274     AUE_NULL        STD {
                  int linux_mbind(void);
          }
  275     AUE_NULL        STD {
                  int linux_get_mempolicy(void);
          }
  276     AUE_NULL        STD {
                  int linux_set_mempolicy(void);
          }
  ; Linux 2.6.6:
  277     AUE_NULL        STD {
                  int linux_mq_open(
                      const char *name,
                      l_int oflag,
                      l_mode_t mode,
                      struct mq_attr *attr
                  );
          }
  278     AUE_NULL        STD {
                  int linux_mq_unlink(
                      const char *name
                  );
          }
  279     AUE_NULL        STD {
                  int linux_mq_timedsend(
                      l_mqd_t mqd,
                      const char *msg_ptr,
                      l_size_t msg_len,
                      l_uint msg_prio,
                      const struct l_timespec *abs_timeout
                  );
          }
  280     AUE_NULL        STD {
                  int linux_mq_timedreceive(
                      l_mqd_t mqd,
                      char *msg_ptr,
                      l_size_t msg_len,
                      l_uint *msg_prio,
                      const struct l_timespec *abs_timeout
                  );
          }
  281     AUE_NULL        STD {
                  int linux_mq_notify(
                      l_mqd_t mqd,
                      const struct l_timespec *abs_timeout
                  );
          }
  282     AUE_NULL        STD {
                  int linux_mq_getsetattr(
                      l_mqd_t mqd,
                      const struct mq_attr *attr,
                      struct mq_attr *oattr
                  );
          }
  283     AUE_NULL        STD {
                  int linux_kexec_load(void);
          }
  284     AUE_WAIT6       STD {
                  int linux_waitid(
                      int idtype,
                      l_pid_t id,
                      l_siginfo_t *info,
                      int options,
                      struct l_rusage *rusage
                  );
          }
  285     AUE_NULL        UNIMPL
  ; Linux 2.6.11:
  286     AUE_NULL        STD {
                  int linux_add_key(void);
          }
  287     AUE_NULL        STD {
                  int linux_request_key(void);
          }
  288     AUE_NULL        STD {
                  int linux_keyctl(void);
          }
  ; Linux 2.6.13:
  289     AUE_NULL        STD {
                  int linux_ioprio_set(void);
          }
  290     AUE_NULL        STD {
                  int linux_ioprio_get(void);
          }
  291     AUE_NULL        STD {
                  int linux_inotify_init(void);
          }
  292     AUE_NULL        STD {
                  int linux_inotify_add_watch(void);
          }
  293     AUE_NULL        STD {
                  int linux_inotify_rm_watch(void);
          }
  ; Linux 2.6.16:
  294     AUE_NULL        STD {
                  int linux_migrate_pages(void);
          }
  295     AUE_OPEN_RWTC   STD {
                  int linux_openat(
                      l_int dfd,
                      const char *filename,
                      l_int flags,
                      l_int mode
                  );
          }
  296     AUE_MKDIRAT     STD {
                  int linux_mkdirat(
                      l_int dfd,
                      const char *pathname,
                      l_int mode
                  );
          }
  297     AUE_MKNODAT     STD {
                  int linux_mknodat(
                      l_int dfd,
                      const char *filename,
                      l_int mode,
                      l_uint dev
                  );
          }
  298     AUE_FCHOWNAT    STD {
                  int linux_fchownat(
                      l_int dfd,
                      const char *filename,
                      l_uid16_t uid,
                      l_gid16_t gid,
                      l_int flag
                  );
          }
  299     AUE_FUTIMESAT   STD {
                  int linux_futimesat(
                      l_int dfd,
                      char *filename,
                      struct l_timeval *utimes
                  );
          }
  300     AUE_FSTATAT     STD {
                  int linux_fstatat64(
                      l_int dfd,
                      char *pathname,
                      struct l_stat64 *statbuf,
                      l_int flag
                  );
          }
  301     AUE_UNLINKAT    STD {
                  int linux_unlinkat(
                      l_int dfd,
                      const char *pathname,
                      l_int flag
                  );
          }
  302     AUE_RENAMEAT    STD {
                  int linux_renameat(
                      l_int olddfd,
                      const char *oldname,
                      l_int newdfd,
                      const char *newname
                  );
          }
  303     AUE_LINKAT      STD {
                  int linux_linkat(
                      l_int olddfd,
                      const char *oldname,
                      l_int newdfd,
                      const char *newname,
                      l_int flag
                  );
          }
  304     AUE_SYMLINKAT   STD {
                  int linux_symlinkat(
                      const char *oldname,
                      l_int newdfd,
                      const char *newname
                  );
          }
  305     AUE_READLINKAT  STD {
                  int linux_readlinkat(
                      l_int dfd,
                      const char *path,
                      char *buf,
                      l_int bufsiz
                  );
          }
  306     AUE_FCHMODAT    STD {
                  int linux_fchmodat(
                      l_int dfd,
                      const char *filename,
                      l_mode_t mode
                  );
          }
  307     AUE_FACCESSAT   STD {
                  int linux_faccessat(
                      l_int dfd,
                      const char *filename,
                      l_int amode
                  );
          }
  308     AUE_SELECT      STD {
                  int linux_pselect6(
                      l_int nfds,
                      l_fd_set *readfds,
                      l_fd_set *writefds,
                      l_fd_set *exceptfds,
                      struct l_timespec *tsp,
                      l_uintptr_t *sig
                  );
          }
  309     AUE_POLL        STD {
                  int linux_ppoll(
                      struct pollfd *fds,
                      uint32_t nfds,
                      struct l_timespec *tsp,
                      l_sigset_t *sset,
                      l_size_t ssize
                  );
          }
  310     AUE_NULL        STD {
                  int linux_unshare(void);
          }
  ; Linux 2.6.17:
  311     AUE_NULL        STD {
                  int linux_set_robust_list(
                      struct linux_robust_list_head *head,
                      l_size_t len
                  );
          }
  312     AUE_NULL        STD {
                  int linux_get_robust_list(
                      l_int pid,
                      struct linux_robust_list_head **head,
                      l_size_t *len
                  );
          }
  313     AUE_NULL        STD {
                  int linux_splice(
                      int fd_in,
                      l_loff_t *off_in,
                      int fd_out,
                      l_loff_t *off_out,
                      l_size_t len,
                      l_uint flags
                  );
          }
  314     AUE_NULL        STD {
                  int linux_sync_file_range(
                      l_int fd,
                      uint32_t offset1,
                      uint32_t offset2,
                      uint32_t nbytes1,
                      uint32_t nbytes2,
                      unsigned int flags
                  );
          }
  315     AUE_NULL        STD {
                  int linux_tee(void);
          }
  316     AUE_NULL        STD {
                  int linux_vmsplice(void);
          }
  ; Linux 2.6.18:
  317     AUE_NULL        STD {
                  int linux_move_pages(void);
          }
  ; Linux 2.6.19:
  318     AUE_NULL        STD {
                  int linux_getcpu(
                      l_uint *cpu,
                      l_uint *node,
                      void *cache
                  );
          }
  319     AUE_NULL        STD {
                  int linux_epoll_pwait(
                      l_int epfd,
                      struct epoll_event *events,
                      l_int maxevents,
                      l_int timeout,
                      l_sigset_t *mask,
                      l_size_t sigsetsize
                  );
          }
  ; Linux 2.6.22:
  320     AUE_FUTIMESAT   STD {
                  int linux_utimensat(
                      l_int dfd,
                      const char *pathname,
                      const struct l_timespec *times,
                      l_int flags
                  );
          }
  321     AUE_NULL        STD {
                  int linux_signalfd(void);
          }
  322     AUE_NULL        STD {
                  int linux_timerfd_create(
                      l_int clockid,
                      l_int flags
                  );
          }
  323     AUE_NULL        STD {
                  int linux_eventfd(
                      l_uint initval
                  );
          }
  ; Linux 2.6.23:
  324     AUE_NULL        STD {
                  int linux_fallocate(
                      l_int fd,
                      l_int mode,
                      uint32_t offset1,
                      uint32_t offset2,
                      uint32_t len1,
                      uint32_t len2
                  );
          }
  ; Linux 2.6.25:
  325     AUE_NULL        STD {
                  int linux_timerfd_settime(
                      l_int fd,
                      l_int flags,
                      const struct l_itimerspec *new_value,
                      struct l_itimerspec *old_value
                  );
          }
  326     AUE_NULL        STD {
                  int linux_timerfd_gettime(
                      l_int fd,
                      struct l_itimerspec *old_value
                  );
          }
  ; Linux 2.6.27:
  327     AUE_NULL        STD {
                  int linux_signalfd4(void);
          }
  328     AUE_NULL        STD {
                  int linux_eventfd2(
                      l_uint initval,
                      l_int flags
                  );
          }
  329     AUE_NULL        STD {
                  int linux_epoll_create1(
                      l_int flags
                  );
          }
  330     AUE_NULL        STD {
                  int linux_dup3(
                      l_int oldfd,
                      l_int newfd,
                      l_int flags
                  );
          }
  331     AUE_NULL        STD {
                  int linux_pipe2(
                      l_int *pipefds,
                      l_int flags
                  );
          }
  332     AUE_NULL        STD {
                  int linux_inotify_init1(void);
          }
  ; Linux 2.6.30:
  333     AUE_NULL        STD {
                  int linux_preadv(
                      l_ulong fd,
                      struct iovec *vec,
                      l_ulong vlen,
                      l_ulong pos_l,
                      l_ulong pos_h
                  );
          }
  334     AUE_NULL        STD {
                  int linux_pwritev(
                      l_ulong fd,
                      struct iovec *vec,
                      l_ulong vlen,
                      l_ulong pos_l,
                      l_ulong pos_h
                  );
          }
  ; Linux 2.6.31:
  335     AUE_NULL        STD {
                  int linux_rt_tgsigqueueinfo(
                      l_pid_t tgid,
                      l_pid_t tid,
                      l_int sig,
                      l_siginfo_t *uinfo
                  );
          }
  336     AUE_NULL        STD {
                  int linux_perf_event_open(void);
          }
  ; Linux 2.6.33:
  337     AUE_NULL        STD {
                  int linux_recvmmsg(
                      l_int s,
                      struct l_mmsghdr *msg,
                      l_uint vlen,
                      l_uint flags,
                      struct l_timespec *timeout
                  );
          }
  338     AUE_NULL        STD {
                  int linux_fanotify_init(void);
          }
  339     AUE_NULL        STD {
                  int linux_fanotify_mark(void);
          }
  ; Linux 2.6.36:
  340     AUE_NULL        STD {
                  int linux_prlimit64(
                      l_pid_t pid,
                      l_uint resource,
                      struct rlimit *new,
                      struct rlimit *old
                  );
          }
  ; Linux 2.6.39:
  341     AUE_NULL        STD {
                  int linux_name_to_handle_at(
                      l_int dirfd,
                      const char *name,
                      struct l_file_handle *handle,
                      l_int *mnt_id,
                      l_int flags
                  );
          }
  342     AUE_NULL        STD {
                  int linux_open_by_handle_at(
                      l_int mountdirfd,
                      struct l_file_handle *handle,
                      l_int flags
                  );
          }
  343     AUE_NULL        STD {
                  int linux_clock_adjtime(void);
          }
  344     AUE_SYNC        STD {
                  int linux_syncfs(
                      l_int fd
                  );
          }
  ; Linux 3.0:
  345     AUE_NULL        STD {
                  int linux_sendmmsg(
                      l_int s,
                      struct l_mmsghdr *msg,
                      l_uint vlen,
                      l_uint flags
                  );
          }
  346     AUE_NULL        STD {
                  int linux_setns(void);
          }
  ; Linux 3.2 (glibc 2.15):
  347     AUE_NULL        STD {
                  int linux_process_vm_readv(
                      l_pid_t pid,
                      const struct iovec *lvec,
                      l_ulong liovcnt,
                      const struct iovec *rvec,
                      l_ulong riovcnt,
                      l_ulong flags
                  );
          }
  348     AUE_NULL        STD {
                  int linux_process_vm_writev(
                      l_pid_t pid,
                      const struct iovec *lvec,
                      l_ulong liovcnt,
                      const struct iovec *rvec,
                      l_ulong riovcnt,
                      l_ulong flags
                  );
          }
  ; Linux 3.5 (no glibc wrapper):
  349     AUE_NULL        STD {
                  int linux_kcmp(
                      l_pid_t pid1,
                      l_pid_t pid2,
                      l_int type,
                      l_ulong idx1,
                      l_ulong idx
                  );
          }
  ; Linux 3.8 (no glibc wrapper):
  350     AUE_NULL        STD {
                  int linux_finit_module(
                      l_int fd,
                      const char *uargs,
                      l_int flags
                  );
          }
  ; Linux 3.14:
  351     AUE_NULL        STD {
                  int linux_sched_setattr(
                      l_pid_t pid,
                      void *attr,
                      l_uint flags
                  );
          }
  352     AUE_NULL        STD {
                  int linux_sched_getattr(
                      l_pid_t pid,
                      void *attr,
                      l_uint size,
                      l_uint flags
                  );
          }
  ; Linux 3.15:
  353     AUE_NULL        STD {
                  int linux_renameat2(
                      l_int olddfd,
                      const char *oldname,
                      l_int newdfd,
                      const char *newname,
                      unsigned int flags
                  );
          }
  ; Linux 3.17:
  354     AUE_NULL        STD {
                  int linux_seccomp(
                      l_uint op,
                      l_uint flags,
                      const char *uargs
                  );
          }
  355     AUE_NULL        STD {
                  int linux_getrandom(
                      char *buf,
                      l_size_t count,
                      l_uint flags
                  );
          }
  356     AUE_NULL        STD {
                  int linux_memfd_create(
                      const char *uname_ptr,
                      l_uint flags
                  );
          }
  ; Linux 3.18:
  357     AUE_NULL        STD {
                  int linux_bpf(
                      l_int cmd,
                      void *attr,
                      l_uint size
                  );
          }
  ; Linux 3.19:
  358     AUE_NULL        STD {
                  int linux_execveat(
                      l_int dfd,
                      const char *filename,
                      const char **argv,
                      const char **envp,
                      l_int flags
                  );
          }
  ; Linux 4.3: sockets now direct system calls:
  359     AUE_SOCKET      STD {
                  int linux_socket(
                      l_int domain,
                      l_int type,
                      l_int protocol
                  );
          }
  360     AUE_SOCKETPAIR  STD {
                  int linux_socketpair(
                      l_int domain,
                      l_int type,
                      l_int protocol,
                      l_uintptr_t rsv
                  );
          }
  361     AUE_BIND        STD {
                  int linux_bind(
                      l_int s,
                      l_uintptr_t name,
                      l_int namelen
                  );
          }
  362     AUE_CONNECT     STD {
                  int linux_connect(
                      l_int s,
                      l_uintptr_t name,
                      l_int namelen
                  );
          }
  363     AUE_LISTEN      STD {
                  int linux_listen(
                      l_int s,
                      l_int backlog
                  );
          }
  364     AUE_ACCEPT      STD {
                  int linux_accept4(
                      l_int s,
                      l_uintptr_t addr,
                      l_uintptr_t namelen,
                      l_int flags
                  );
          }
  365     AUE_GETSOCKOPT  STD {
                  int linux_getsockopt(
                      l_int s,
                      l_int level,
                      l_int optname,
                      l_uintptr_t optval,
                      l_uintptr_t optlen
                  );
          }
  366     AUE_SETSOCKOPT  STD {
                  int linux_setsockopt(
                      l_int s,
                      l_int level,
                      l_int optname,
                      l_uintptr_t optval,
                      l_int optlen
                  );
          }
  367     AUE_GETSOCKNAME STD {
                  int linux_getsockname(
                      l_int s,
                      l_uintptr_t addr,
                      l_uintptr_t namelen
                  );
          }
  368     AUE_GETPEERNAME STD {
                  int linux_getpeername(
                      l_int s,
                      l_uintptr_t addr,
                      l_uintptr_t namelen
                  );
          }
  369     AUE_SENDTO      STD {
                  int linux_sendto(
                      l_int s,
                      l_uintptr_t msg,
                      l_int len,
                      l_int flags,
                      l_uintptr_t to,
                      l_int tolen
                  );
          }
  370     AUE_SENDMSG     STD {
                  int linux_sendmsg(
                      l_int s,
                      l_uintptr_t msg,
                      l_int flags
                  );
          }
  371     AUE_RECVFROM    STD {
                  int linux_recvfrom(
                      l_int s,
                      l_uintptr_t buf,
                      l_size_t len,
                      l_int flags,
                      l_uintptr_t from,
                      l_uintptr_t fromlen
                  );
          }
  372     AUE_RECVMSG     STD {
                  int linux_recvmsg(
                      l_int s,
                      l_uintptr_t msg,
                      l_int flags
                  );
          }
  373     AUE_NULL        STD {
                  int linux_shutdown(
                      l_int s,
                      l_int how
                  );
          }
  ; Linux 4.2:
  374     AUE_NULL        STD {
                  int linux_userfaultfd(
                      l_int flags
                  );
          }
  ; Linux 4.3:
  375     AUE_NULL        STD {
                  int linux_membarrier(
                      l_int cmd,
                      l_int flags
                  );
          }
  ; Linux 4.4:
  376     AUE_NULL        STD {
                  int linux_mlock2(
                      l_ulong start,
                      l_size_t len,
                      l_int flags
                  );
          }
  ; Linux 4.5:
  377     AUE_NULL        STD {
                  int linux_copy_file_range(
                      l_int fd_in,
                      l_loff_t *off_in,
                      l_int fd_out,
                      l_loff_t *off_out,
                      l_size_t len,
                      l_uint flags
                  );
          }
  ; Linux 4.6:
  378     AUE_NULL        STD {
                  int linux_preadv2(
                      l_ulong fd,
                      const struct iovec *vec,
                      l_ulong vlen,
                      l_ulong pos_l,
                      l_ulong pos_h,
                      l_int flags
                  );
          }
  379     AUE_NULL        STD {
                  int linux_pwritev2(
                      l_ulong fd,
                      const struct iovec *vec,
                      l_ulong vlen,
                      l_ulong pos_l,
                      l_ulong pos_h,
                      l_int flags
                  );
          }
  ; Linux 4.8:
  380     AUE_NULL        STD {
                  int linux_pkey_mprotect(
                      l_ulong start,
                      l_size_t len,
                      l_ulong prot,
                      l_int pkey
                  );
          }
  381     AUE_NULL        STD {
                  int linux_pkey_alloc(
                      l_ulong flags,
                      l_ulong init_val
                  );
          }
  382     AUE_NULL        STD {
                  int linux_pkey_free(
                      l_int pkey
                  );
          }
  ; Linux 4.11:
  383     AUE_NULL        STD {
                  int linux_statx(
                      l_int dirfd,
                      const char *pathname,
                      l_uint flags,
                      l_uint mask,
                      void *statxbuf
                  );
          }
  384     AUE_NULL        STD {
                  int linux_arch_prctl(
                      l_int option,
                      l_ulong arg2
                  );
          }
  ; Linux 4.18:
  385     AUE_NULL        STD {
                  int linux_io_pgetevents(void);
          }
  386     AUE_NULL        STD {
                  int linux_rseq(
                      struct linux_rseq *rseq,
                      uint32_t rseq_len,
                      l_int flags,
                      uint32_t sig
                  );
          }
  387-392 AUE_NULL        UNIMPL  nosys
  393     AUE_NULL        STD {
                  int linux_semget(
                      l_key_t key,
                      l_int nsems,
                      l_int semflg
                  );
          }
  394     AUE_NULL        STD {
                  int linux_semctl(
                      l_int semid,
                      l_int semnum,
                      l_int cmd,
                      union l_semun arg
                  );
          }
  395     AUE_NULL        STD {
                  int linux_shmget(
                      l_key_t key,
                      l_size_t size,
                      l_int shmflg
                  );
          }
  396     AUE_NULL        STD {
                  int linux_shmctl(
                      l_int shmid,
                      l_int cmd,
                      struct l_shmid_ds *buf
                  );
          }
  397     AUE_NULL        STD {
                  int linux_shmat(
                      l_int shmid,
                      char *shmaddr,
                      l_int shmflg
                  );
          }
  398     AUE_NULL        STD {
                  int linux_shmdt(
                      char *shmaddr
                  );
          }
  399     AUE_NULL        STD {
                  int linux_msgget(
                      l_key_t key,
                      l_int msgflg
                  );
          }
  400     AUE_NULL        STD {
                  int linux_msgsnd(
                      l_int msqid,
                      struct l_msgbuf *msgp,
                      l_size_t msgsz,
                      l_int msgflg
                  );
          }
  401     AUE_NULL        STD {
                  int linux_msgrcv(
                      l_int msqid,
                      struct l_msgbuf *msgp,
                      l_size_t msgsz,
                      l_long msgtyp,
                      l_int msgflg
                  );
          }
  402     AUE_NULL        STD {
                  int linux_msgctl(
                      l_int msqid,
                      l_int cmd,
                      struct l_msqid_ds *buf
                  );
          }
  ; Linux 5.0:
  403     AUE_NULL        STD {
                  int linux_clock_gettime64(
                      clockid_t which,
                      struct l_timespec64 *tp
                  );
          }
  404     AUE_NULL        STD {
                  int linux_clock_settime64(
                      clockid_t which,
                      struct l_timespec64 *tp
                  );
          }
  405     AUE_NULL        STD {
                  int linux_clock_adjtime64(void);
          }
  406     AUE_NULL        STD {
                  int linux_clock_getres_time64(
                      clockid_t which,
                      struct l_timespec64 *tp
                  );
          }
  407     AUE_NULL        STD {
                  int linux_clock_nanosleep_time64(
                      clockid_t which,
                      l_int flags,
                      struct l_timespec64 *rqtp,
                      struct l_timespec64 *rmtp
                  );
          }
  408     AUE_NULL        STD {
                  int linux_timer_gettime64(
                      l_timer_t timerid,
                      struct l_itimerspec64 *setting
                  );
          }
  409     AUE_NULL        STD {
                  int linux_timer_settime64(
                      l_timer_t timerid,
                      l_int flags,
                      const struct l_itimerspec64 *new,
                      struct l_itimerspec64 *old
                  );
          }
  410     AUE_NULL        STD {
                  int linux_timerfd_gettime64(
                      l_int fd,
                      struct l_itimerspec64 *old_value
                  );
          }
  411     AUE_NULL        STD {
                  int linux_timerfd_settime64(
                      l_int fd,
                      l_int flags,
                      const struct l_itimerspec64 *new_value,
                      struct l_itimerspec64 *old_value
                  );
          }
  412     AUE_NULL        STD {
                  int linux_utimensat_time64(
                      l_int dfd,
                      const char *pathname,
                      const struct l_timespec64 *times64,
                      l_int flags
                  );
          }
  413     AUE_NULL        STD {
                  int linux_pselect6_time64(
                      l_int nfds,
                      l_fd_set *readfds,
                      l_fd_set *writefds,
                      l_fd_set *exceptfds,
                      struct l_timespec64 *tsp,
                      l_uintptr_t *sig
                  );
          }
  414     AUE_NULL        STD {
                  int linux_ppoll_time64(
                      struct pollfd *fds,
                      uint32_t nfds,
                      struct l_timespec64 *tsp,
                      l_sigset_t *sset,
                      l_size_t ssize
                  );
          }
  415     AUE_NULL        UNIMPL  nosys
  416     AUE_NULL        STD {
                  int linux_io_pgetevents_time64(void);
          }
  417     AUE_NULL        STD {
                  int linux_recvmmsg_time64(
                      l_int s,
                      struct l_mmsghdr *msg,
                      l_uint vlen,
                      l_uint flags,
                      struct l_timespec64 *timeout
                  );
          }
  418     AUE_NULL        STD {
                  int linux_mq_timedsend_time64(void);
          }
  419     AUE_NULL        STD {
                  int linux_mq_timedreceive_time64(void);
          }
  420     AUE_NULL        STD {
                  int linux_semtimedop_time64(
                      l_int semid,
                      struct sembuf *tsops,
                      l_size_t nsops,
                      struct l_timespec64 *timeout
                  );
          }
  421     AUE_NULL        STD {
                  int linux_rt_sigtimedwait_time64(
                      l_sigset_t *mask,
                      l_siginfo_t *ptr,
                      struct l_timespec64 *timeout,
                      l_size_t sigsetsize
                  );
          }
  422     AUE_NULL        STD {
                  int linux_sys_futex_time64(
                      uint32_t *uaddr,
                      l_int op,
                      uint32_t val,
                      struct l_timespec64 *timeout,
                      uint32_t *uaddr2,
                      uint32_t val3
                  );
          }
  423     AUE_SCHED_RR_GET_INTERVAL       STD  {
                  int linux_sched_rr_get_interval_time64(
                      l_pid_t pid,
                      struct l_timespec64 *interval
                  );
          }
  424     AUE_NULL        STD {
                  int linux_pidfd_send_signal(
                      l_int pidfd,
                      l_int sig,
                      l_siginfo_t *info,
                      l_uint flags
                  );
          }
  425     AUE_NULL        STD {
                  int linux_io_uring_setup(void);
          }
  426     AUE_NULL        STD {
                  int linux_io_uring_enter(void);
          }
  427     AUE_NULL        STD {
                  int linux_io_uring_register(void);
          }
  428    AUE_NULL         STD {
                  int linux_open_tree(void);
          }
  429    AUE_NULL         STD {
                  int linux_move_mount(void);
          }
  430    AUE_NULL         STD {
                  int linux_fsopen(void);
          }
  431    AUE_NULL         STD {
                  int linux_fsconfig(void);
          }
  432    AUE_NULL         STD {
                  int linux_fsmount(void);
          }
  433    AUE_NULL         STD {
                  int linux_fspick(void);
          }
  434    AUE_NULL         STD {
                  int linux_pidfd_open(void);
          }
  435    AUE_NULL         STD {
                  int linux_clone3(
                      struct l_user_clone_args *uargs,
                      l_size_t usize
                  );
          }
  436    AUE_NULL         STD {
                  int linux_close_range(void);
          }
  437    AUE_NULL         STD {
                  int linux_openat2(void);
          }
  438    AUE_NULL         STD {
                  int linux_pidfd_getfd(void);
          }
  439    AUE_NULL         STD {
                  int linux_faccessat2(
                      l_int dfd,
                      const char *filename,
                      l_int amode,
                      l_int flags
                  );
          }
  440    AUE_NULL         STD {
                  int linux_process_madvise(void);
          }
  441    AUE_NULL         STD {
                  int linux_epoll_pwait2_64(
                      l_int epfd,
                      struct epoll_event *events,
                      l_int maxevents,
                      struct l_timespec64 *timeout,
                      l_sigset_t *mask,
                      l_size_t sigsetsize
                  );
          }
  442    AUE_NULL         STD {
                  int linux_mount_setattr(void);
          }
  ; please, keep this line at the end.
  443    AUE_NULL        UNIMPL  nosys
  ; vim: syntax=off

Cache object: 34d2d342a7adc95cfca53a6f9d5b4f84