ktls: Inline ktls_cleanup() into ktls_destroy().

[FreeBSD/FreeBSD.git] / sys / arm64 / linux / syscalls.master

 $FreeBSD$

; Linux ABI system call generic name/number map, based on Linux file
; include/uapi/asm-generic/unistd.h

#include <sys/param.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>
#include <compat/linux/linux_sysproto.h>
#include <arm64/linux/linux.h>
#include <arm64/linux/linux_proto.h>

; Isn't pretty, but there seems to be no other way to trap nosys
#define nosys   linux_nosys

0       AUE_NULL        UNIMPL  linux_io_setup
1       AUE_NULL        UNIMPL  linux_io_destroy
2       AUE_NULL        UNIMPL  linux_io_submit
3       AUE_NULL        UNIMPL  linux_io_cancel
4       AUE_NULL        UNIMPL  linux_io_getevents
5       AUE_NULL        STD     {
                int linux_setxattr(
                    const char *path,
                    const char *name,
                    const char *value,
                    l_size_t size,
                    l_int flags
                );
        }
6       AUE_NULL        STD     {
                int linux_lsetxattr(
                    const char *path,
                    const char *name,
                    const char *value,
                    l_size_t size,
                    l_int flags
                );
        }
7       AUE_NULL        STD     {
                int linux_fsetxattr(
                    l_int fd,
                    const char *name,
                    const char *value,
                    l_size_t size,
                    l_int flags
                );
        }
8       AUE_NULL        STD     {
                int linux_getxattr(
                    const char *path,
                    const char *name,
                    char *value,
                    l_size_t size
                );
        }
9       AUE_NULL        STD     {
                int linux_lgetxattr(
                    const char *path,
                    const char *name,
                    char *value,
                    l_size_t size
                );
        }
10      AUE_NULL        STD     {
                int linux_fgetxattr(
                    l_int fd,
                    const char *name,
                    char *value,
                    l_size_t size
                );
        }
11      AUE_NULL        STD     {
                int linux_listxattr(
                    const char *path,
                    const char *list,
                    l_size_t size
                );
        }
12      AUE_NULL        STD     {
                int linux_llistxattr(
                    const char *path,
                    const char *list,
                    l_size_t size
                );
        }
13      AUE_NULL        STD     {
                int linux_flistxattr(
                    l_int fd,
                    const char *list,
                    l_size_t size
                );
        }
14      AUE_NULL        STD     {
                int linux_removexattr(
                    const char *path,
                    const char *name
                );
        }
15      AUE_NULL        STD     {
                int linux_lremovexattr(
                    const char *path,
                    const char *name
                );
        }
16      AUE_NULL        STD     {
                int linux_fremovexattr(
                    l_int fd,
                    const char *name
                );
        }
17      AUE_GETCWD      STD     {
                int linux_getcwd(
                    char *buf,
                    l_ulong bufsize
                );
        }
18      AUE_NULL        STD     {
                 int linux_lookup_dcookie(void);
        }
19      AUE_NULL        STD     {
                int linux_eventfd2(
                    l_uint initval,
                    l_int flags
                );
        }
20      AUE_NULL        STD     {
                int linux_epoll_create1(
                    l_int flags
                );
        }
21      AUE_NULL        STD     {
                int linux_epoll_ctl(
                    l_int epfd,
                    l_int op,
                    l_int fd,
                    struct epoll_event *event
                );
        }
22      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
                );
        }
23      AUE_DUP         NOPROTO {
                int dup(
                    u_int fd
                );
        }
24      AUE_NULL        STD     {
                int linux_dup3(
                    l_int oldfd,
                    l_int newfd,
                    l_int flags
                );
        }
25      AUE_FCNTL       STD     {
                int linux_fcntl(
                    l_uint fd,
                    l_uint cmd,
                    l_ulong arg
                );
        }
26      AUE_NULL        STD     {
                int linux_inotify_init1(
                    l_int flags
                );
        }
27      AUE_NULL        STD     {
                int linux_inotify_add_watch(void);
        }
28      AUE_NULL        STD     {
                int linux_inotify_rm_watch(void);
        }
29      AUE_IOCTL       STD     {
                int linux_ioctl(
                    l_uint fd,
                    l_uint cmd,
                    l_ulong arg
                );
        }
30      AUE_NULL        STD     {
                int linux_ioprio_set(void);
        }
31      AUE_NULL        STD     {
                int linux_ioprio_get(void);
        }
32      AUE_FLOCK       NOPROTO {
                int flock(
                    int fd,
                    int how
                );
        }
33      AUE_MKNODAT     STD     {
                int linux_mknodat(
                    l_int dfd,
                    const char *filename,
                    l_int mode,
                    l_uint dev
                );
        }
34      AUE_MKDIRAT     STD     {
                int linux_mkdirat(
                    l_int dfd,
                    const char *pathname,
                    l_mode_t mode
                );
        }
35      AUE_UNLINKAT    STD     {
                int linux_unlinkat(
                    l_int dfd,
                    const char *pathname,
                    l_int flag
                );
        }
36      AUE_SYMLINKAT   STD     {
                int linux_symlinkat(
                    const char *oldname,
                    l_int newdfd,
                    const char *newname
                );
        }
37      AUE_LINKAT      STD     {
                int linux_linkat(
                    l_int olddfd,
                    const char *oldname,
                    l_int newdfd,
                    const char *newname,
                    l_int flag
                );
        }
38      AUE_RENAMEAT    STD     {
                int linux_renameat(
                    l_int olddfd,
                    const char *oldname,
                    l_int newdfd,
                    const char *newname
                );
        }
39      AUE_NULL        UNIMPL  linux_umount2
40      AUE_MOUNT       STD     {
                int linux_mount(
                    char *specialfile,
                    char *dir,
                    char *filesystemtype,
                    l_ulong rwflag,
                    void *data
                );
        }
41      AUE_PIVOT_ROOT  STD     {
                int linux_pivot_root(void);
        }
42      AUE_NULL        UNIMPL  nfsservctl
43      AUE_STATFS      STD     {
                int linux_statfs(
                    char *path,
                    struct l_statfs_buf *buf
                );
        }
44      AUE_FSTATFS     STD     {
                int linux_fstatfs(
                    l_uint fd,
                    struct l_statfs_buf *buf
                );
        }
45      AUE_TRUNCATE    STD     {
                int linux_truncate(
                    char *path,
                    l_ulong length
                );
        }
46      AUE_FTRUNCATE   STD     {
                int linux_ftruncate(
                    l_int fd,
                    l_long length
                );
        }
47      AUE_NULL        STD     {
                int linux_fallocate(
                    l_int fd,
                    l_int mode,
                    l_loff_t offset,
                    l_loff_t len
                );
        }
48      AUE_FACCESSAT   STD     {
                int linux_faccessat(
                    l_int dfd,
                    const char *filename,
                    l_int amode
                );
        }
49      AUE_CHDIR       STD     {
                int linux_chdir(
                    char *path
                );
        }
50      AUE_FCHDIR      NOPROTO {
                int fchdir(
                    int fd
                );
        }
51      AUE_CHROOT      NOPROTO {
                int chroot(
                    char *path
                );
        }
52      AUE_FCHMOD      NOPROTO {
                int fchmod(
                    int fd,
                    int mode
                );
        }
53      AUE_FCHMODAT    STD     {
                int linux_fchmodat(
                    l_int dfd,
                    const char *filename,
                    l_mode_t mode
                );
        }
54      AUE_FCHOWNAT    STD     {
                int linux_fchownat(
                    l_int dfd,
                    const char *filename,
                    l_uid_t uid,
                    l_gid_t gid,
                    l_int flag
                );
        }
55      AUE_FCHOWN      NOPROTO {
                int fchown(
                    int fd,
                    int uid,
                    int gid
                );
        }
56      AUE_OPEN_RWTC   STD     {
                int linux_openat(
                    l_int dfd,
                    const char *filename,
                    l_int flags,
                    l_mode_t mode
                );
        }
57      AUE_CLOSE       NOPROTO {
                int close(
                    int fd
                );
        }
58      AUE_NULL        STD     {
                int linux_vhangup(void);
        }
59      AUE_NULL        STD     {
                int linux_pipe2(
                    l_int *pipefds,
                    l_int flags
                );
        }
60      AUE_NULL        UNIMPL  linux_quotactl
61      AUE_GETDIRENTRIES       STD {
                int linux_getdents64(
                    l_uint fd,
                    void *dirent,
                    l_uint count
                );
        }
62      AUE_LSEEK       STD     {
                int linux_lseek(
                    l_uint fdes,
                    l_off_t off,
                    l_int whence
                );
        }
63      AUE_NULL        NOPROTO {
                int read(
                    int fd,
                    char *buf,
                    l_size_t nbyte
                );
        }
64      AUE_NULL        NOPROTO {
                int write(
                    int fd,
                    char *buf,
                    l_size_t nbyte
                );
        }
65      AUE_READV       NOPROTO {
                int readv(
                    int fd,
                    struct iovec *iovp,
                    u_int iovcnt
                );
        }
66      AUE_WRITEV      NOPROTO {
                int writev(
                    int fd,
                    struct iovec *iovp,
                    u_int iovcnt
                );
        }
67      AUE_PREAD       STD     {
                int linux_pread(
                    l_uint fd,
                    char *buf,
                    l_size_t nbyte,
                    l_loff_t offset
                );
        }
68      AUE_PWRITE      STD     {
                int linux_pwrite(
                    l_uint fd,
                    char *buf,
                    l_size_t nbyte,
                    l_loff_t offset
                );
        }
69      AUE_NULL        STD     {
                int linux_preadv(
                    l_ulong fd,
                    struct iovec *vec,
                    l_ulong vlen,
                    l_ulong pos_l,
                    l_ulong pos_h
                );
        }
70      AUE_NULL        STD     {
                int linux_pwritev(
                    l_ulong fd,
                    struct iovec *vec,
                    l_ulong vlen,
                    l_ulong pos_l,
                    l_ulong pos_h
                );
        }
71      AUE_SENDFILE    STD     {
                int linux_sendfile(
                    l_int out,
                    l_int in,
                    l_off_t *offset,
                    l_size_t count
                );
        }
72      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
                );
        }
73      AUE_POLL        STD     {
                int linux_ppoll(
                    struct pollfd *fds,
                    l_uint nfds,
                    struct l_timespec *tsp,
                    l_sigset_t *sset,
                    l_size_t ssize
                );
        }
74      AUE_NULL        STD     {
                int linux_signalfd4(void);
        }
75      AUE_NULL        STD     {
                int linux_vmsplice(void);
        }
76      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
                );
        }
77      AUE_NULL        STD     {
                int linux_tee(void);
        }
78      AUE_READLINKAT  STD     {
                int linux_readlinkat(
                    l_int dfd,
                    const char *path,
                    char *buf,
                    l_int bufsiz
                );
        }
79      AUE_FSTATAT     STD     {
                int linux_newfstatat(
                    l_int dfd,
                    char *pathname,
                    struct l_stat64 *statbuf,
                    l_int flag
                );
        }
80      AUE_FSTAT       STD     {
                int linux_newfstat(
                    l_uint fd,
                    struct l_newstat *buf
                );
        }
81      AUE_NULL        UNIMPL  linux_sync
82      AUE_FSYNC       NOPROTO {
                int fsync(
                    int fd
                );
        }
83      AUE_NULL        STD     {
                int linux_fdatasync(
                    l_uint fd
                );
        }
84      AUE_NULL        STD     {
                int linux_sync_file_range(
                    l_int fd,
                    l_loff_t offset,
                    l_loff_t nbytes,
                    l_uint flags
                );
        }
85      AUE_NULL        STD     {
                int linux_timerfd_create(
                    l_int clockid,
                    l_int flags
                );
        }
86      AUE_NULL        STD     {
                int linux_timerfd_settime(
                    l_int fd,
                    l_int flags,
                    const struct l_itimerspec *new_value,
                    struct l_itimerspec *old_value
                );
        }
87      AUE_NULL        STD     {
                int linux_timerfd_gettime(
                    l_int fd,
                    struct l_itimerspec *old_value
                );
        }
88      AUE_FUTIMESAT   STD     {
                int linux_utimensat(
                    l_int dfd,
                    const char *pathname,
                    const struct l_timespec *times,
                    l_int flags
                );
        }
89      AUE_ACCT        NOPROTO {
                int acct(
                    char *path
                );
        }
90      AUE_CAPGET      STD     {
                int linux_capget(
                    struct l_user_cap_header *hdrp,
                    struct l_user_cap_data *datap
                );
        }
91      AUE_CAPSET      STD     {
                int linux_capset(
                    struct l_user_cap_header *hdrp,
                    struct l_user_cap_data *datap
                );
        }
92      AUE_PERSONALITY STD     {
                int linux_personality(
                    l_uint per
                );
        }
93      AUE_EXIT        STD     {
                int linux_exit(
                    u_int rval
                );
        }
94      AUE_EXIT        STD     {
                int linux_exit_group(
                    l_int error_code
                );
        }
95      AUE_WAIT6       STD     {
                int linux_waitid(
                    l_int idtype,
                    l_pid_t id,
                    l_siginfo_t *info,
                    l_int options,
                    struct rusage *rusage
                );
        }
96      AUE_NULL        STD     {
                int linux_set_tid_address(
                    l_int *tidptr
                );
        }
97      AUE_NULL        STD     {
                int linux_unshare(void);
        }
98      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
                );
        }
99      AUE_NULL        STD     {
                int linux_set_robust_list(
                    struct linux_robust_list_head *head,
                    l_size_t len
                );
        }
100     AUE_NULL        STD     {
                int linux_get_robust_list(
                    l_int pid,
                    struct linux_robust_list_head **head,
                    l_size_t *len
                );
        }
101     AUE_NULL        STD     {
                int linux_nanosleep(
                    const struct l_timespec *rqtp,
                    struct l_timespec *rmtp
                );
        }
102     AUE_GETITIMER   STD     {
                int linux_getitimer(
                    l_int which,
                    struct l_itimerval *itv
                );
        }
103     AUE_SETITIMER   STD     {
                int linux_setitimer(
                    l_int which,
                    struct l_itimerval *itv,
                    struct l_itimerval *oitv
                );
        }
104     AUE_NULL        STD     {
                int linux_kexec_load(void);
        }
105     AUE_NULL        STD     {
                int linux_init_module(void);
        }
106     AUE_NULL        STD     {
                int linux_delete_module(void);
        }
107     AUE_NULL        STD     {
                int linux_timer_create(
                    clockid_t clock_id,
                    struct sigevent *evp,
                    l_timer_t *timerid
                );
        }
108     AUE_NULL        STD     {
                int linux_timer_gettime(
                    l_timer_t timerid,
                    struct itimerspec *setting
                );
        }
109     AUE_NULL        STD     {
                int linux_timer_getoverrun(
                    l_timer_t timerid
                );
        }
110     AUE_NULL        STD     {
                int linux_timer_settime(
                    l_timer_t timerid,
                    l_int flags,
                    const struct itimerspec *new,
                    struct itimerspec *old
                );
        }
111     AUE_NULL        STD     {
                int linux_timer_delete(
                    l_timer_t timerid
                );
        }
112     AUE_CLOCK_SETTIME       STD     {
                int linux_clock_settime(
                    clockid_t which,
                    struct l_timespec *tp
                );
        }
113     AUE_NULL        STD     {
                int linux_clock_gettime(
                    clockid_t which,
                    struct l_timespec *tp
                );
        }
114     AUE_NULL        STD     {
                int linux_clock_getres(
                    clockid_t which,
                    struct l_timespec *tp
                );
        }
115     AUE_NULL        STD     {
                int linux_clock_nanosleep(
                    clockid_t which,
                    l_int flags,
                    struct l_timespec *rqtp,
                    struct l_timespec *rmtp
                );
        }
116     AUE_NULL        STD     {
                int linux_syslog(
                    l_int type,
                    char *buf,
                    l_int len
                );
        }
117     AUE_PTRACE      STD     {
                int linux_ptrace(
                    l_long req,
                    l_long pid,
                    l_ulong addr,
                    l_ulong data
                );
        }
118     AUE_SCHED_SETPARAM      STD     {
                int linux_sched_setparam(
                    l_pid_t pid,
                    struct sched_param *param
                );
        }
119     AUE_SCHED_SETSCHEDULER  STD {
                int linux_sched_setscheduler(
                    l_pid_t pid,
                    l_int policy,
                    struct sched_param *param
                );
        }
120     AUE_SCHED_GETSCHEDULER  STD {
                int linux_sched_getscheduler(
                    l_pid_t pid
                );
        }
121     AUE_SCHED_GETPARAM      STD     {
                int linux_sched_getparam(
                    l_pid_t pid,
                    struct sched_param *param
                );
        }
122     AUE_NULL        STD     {
                int linux_sched_setaffinity(
                    l_pid_t pid,
                    l_uint len,
                    l_ulong *user_mask_ptr
                );
        }
123     AUE_NULL        STD     {
                int linux_sched_getaffinity(
                    l_pid_t pid,
                    l_uint len,
                    l_ulong *user_mask_ptr
                );
        }
124     AUE_NULL        NOPROTO {
                int sched_yield(void);
        }
125     AUE_SCHED_GET_PRIORITY_MAX      STD {
                int linux_sched_get_priority_max(
                    l_int policy
                );
        }
126     AUE_SCHED_GET_PRIORITY_MIN      STD {
                int linux_sched_get_priority_min(
                    l_int policy
                );
        }
127     AUE_SCHED_RR_GET_INTERVAL       STD {
                int linux_sched_rr_get_interval(
                    l_pid_t pid,
                    struct l_timespec *interval
                );
        }
128     AUE_NULL        UNIMPL  restart_syscall
129     AUE_KILL        STD     {
                int linux_kill(
                    l_pid_t pid,
                    l_int signum
                );
        }
130     AUE_NULL        STD     {
                int linux_tkill(
                    l_pid_t tid,
                    l_int sig
                );
        }
131     AUE_NULL        STD     {
                int linux_tgkill(
                    l_pid_t tgid,
                    l_pid_t pid,
                    l_int sig
                );
        }
132     AUE_NULL        STD     {
                int linux_sigaltstack(
                    l_stack_t *uss,
                    l_stack_t *uoss
                );
        }
133     AUE_NULL        STD     {
                int linux_rt_sigsuspend(
                    l_sigset_t *newset,
                    l_size_t sigsetsize
                );
        }
134     AUE_NULL        STD     {
                int linux_rt_sigaction(
                    l_int sig,
                    l_sigaction_t *act,
                    l_sigaction_t *oact,
                    l_size_t sigsetsize
                );
        }
135     AUE_NULL        STD     {
                int linux_rt_sigprocmask(
                    l_int how,
                    l_sigset_t *mask,
                    l_sigset_t *omask,
                    l_size_t sigsetsize
                );
        }
136     AUE_NULL        STD     {
                int linux_rt_sigpending(
                    l_sigset_t *set,
                    l_size_t sigsetsize
                );
        }
137     AUE_NULL        STD     {
                int linux_rt_sigtimedwait(
                    l_sigset_t *mask,
                    l_siginfo_t *ptr,
                    struct l_timespec *timeout,
                    l_size_t sigsetsize
                );
        }
138     AUE_NULL        STD     {
                int linux_rt_sigqueueinfo(
                    l_pid_t pid,
                    l_int sig,
                    l_siginfo_t *info
                );
        }
139     AUE_NULL        STD     {
                int linux_rt_sigreturn(void);
        }
140     AUE_SETPRIORITY NOPROTO {
                int setpriority(
                    int which,
                    int who,
                    int prio
                );
        }
141     AUE_GETPRIORITY STD     {
                int linux_getpriority(
                    l_int which,
                    l_int who
                );
        }
142     AUE_REBOOT      STD     {
                int linux_reboot(
                    l_int magic1,
                    l_int magic2,
                    l_uint cmd,
                    void *arg
                );
        }
143     AUE_SETREGID    NOPROTO {
                int setregid(
                    gid_t rgid,
                    gid_t egid
                );
        }
144     AUE_SETGID      NOPROTO {
                int setgid(
                    gid_t gid
                );
        }
145     AUE_SETREUID    NOPROTO {
                int setreuid(
                    uid_t ruid,
                    uid_t euid
                );
        }
146     AUE_SETUID      NOPROTO {
                int setuid(
                    uid_t uid
                );
        }
147     AUE_SETRESUID   NOPROTO {
                int setresuid(
                    uid_t ruid,
                    uid_t euid,
                    uid_t suid
                );
        }
148     AUE_GETRESUID   NOPROTO {
                int getresuid(
                    uid_t *ruid,
                    uid_t *euid,
                    uid_t *suid
                );
        }
149     AUE_SETRESGID   NOPROTO {
                int setresgid(
                    gid_t rgid,
                    gid_t egid,
                    gid_t sgid
                );
        }
150     AUE_GETRESGID   NOPROTO {
                int getresgid(
                    gid_t *rgid,
                    gid_t *egid,
                    gid_t *sgid
                );
        }
151     AUE_SETFSUID    STD     {
                int linux_setfsuid(
                    l_uid_t uid
                );
        }
152     AUE_SETFSGID    STD     {
                int linux_setfsgid(
                    l_gid_t gid
                );
        }
153     AUE_NULL        STD     {
                int linux_times(
                    struct l_times_argv *buf
                );
        }
154     AUE_SETPGRP     NOPROTO {
                int setpgid(
                    int pid,
                    int pgid
                );
        }
155     AUE_GETPGID     NOPROTO {
                int getpgid(
                    int pid
                );
        }
156     AUE_GETSID      STD     {
                int linux_getsid(
                    l_pid_t pid
                );
        }
157     AUE_SETSID      NOPROTO {
                int setsid(void);
        }
158     AUE_GETGROUPS   STD     {
                int linux_getgroups(
                    l_int gidsetsize,
                    l_gid_t *grouplist
                );
        }
159     AUE_SETGROUPS   STD     {
                int linux_setgroups(
                    l_int gidsetsize,
                    l_gid_t *grouplist
                );
        }
160     AUE_NULL        STD     {
                int linux_newuname(
                    struct l_new_utsname *buf
                );
        }
161     AUE_SYSCTL      STD     {
                int linux_sethostname(
                    char *hostname,
                    l_uint len
                );
        }
162     AUE_SYSCTL      STD     {
                int linux_setdomainname(
                    char *name,
                    l_int len
                );
        }
163     AUE_GETRLIMIT   STD     {
                int linux_getrlimit(
                    l_uint resource,
                    struct l_rlimit *rlim
                );
        }
164     AUE_SETRLIMIT   STD     {
                int linux_setrlimit(
                    l_uint resource,
                    struct l_rlimit *rlim
                );
        }
165     AUE_GETRUSAGE   NOPROTO {
                int getrusage(
                    int who,
                    struct rusage *rusage
                );
        }
166     AUE_UMASK       NOPROTO {
                int umask(
                    int newmask
                );
        }
167     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
                );
        }
168     AUE_NULL        STD     {
                int linux_getcpu(
                    l_uint *cpu,
                    l_uint *node,
                    void *cache
                );
        }
169     AUE_NULL        NOPROTO {
                int gettimeofday(
                    struct l_timeval *tp,
                    struct timezone *tzp
                );
        }
170     AUE_SETTIMEOFDAY        NOPROTO {
                int settimeofday(
                    struct l_timeval *tv,
                    struct timezone *tzp
                );
        }
171     AUE_ADJTIME     STD     {
                int linux_adjtimex(void);
        }
172     AUE_GETPID      STD     {
                int linux_getpid(void);
        }
173     AUE_GETPPID     STD     {
                int linux_getppid(void);
        }
174     AUE_GETUID      STD     {
                int linux_getuid(void);
        }
175     AUE_GETEUID     NOPROTO {
                int geteuid(void);
        }
176     AUE_GETGID      STD     {
                int linux_getgid(void);
        }
177     AUE_GETEGID     NOPROTO {
                int getegid(void);
        }
178     AUE_NULL        STD     {
                int linux_gettid(void);
        }
179     AUE_NULL        STD     {
                int linux_sysinfo(
                    struct l_sysinfo *info
                );
        }
180     AUE_NULL        STD     {
                int linux_mq_open(
                    const char *name,
                    l_int oflag,
                    l_mode_t mode,
                    struct mq_attr *attr
                );
        }
181     AUE_NULL        STD     {
                int linux_mq_unlink(
                    const char *name
                );
        }
182     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
                );
        }
183     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
                );
        }
184     AUE_NULL        STD     {
                int linux_mq_notify(
                    l_mqd_t mqd,
                    const struct l_timespec *abs_timeout
                );
        }
185     AUE_NULL        STD     {
                int linux_mq_getsetattr(
                    l_mqd_t mqd,
                    const struct mq_attr *attr,
                    struct mq_attr *oattr
                );
        }
186     AUE_NULL        STD     {
                int linux_msgget(
                    l_key_t key,
                    l_int msgflg
                );
        }
187     AUE_NULL        STD     {
                int linux_msgctl(
                    l_int msqid,
                    l_int cmd,
                    struct l_msqid_ds *buf
                );
        }
188     AUE_NULL        STD     {
                int linux_msgrcv(
                    l_int msqid,
                    struct l_msgbuf *msgp,
                    l_size_t msgsz,
                    l_long msgtyp,
                    l_int msgflg
                );
        }
189     AUE_NULL        STD     {
                int linux_msgsnd(
                    l_int msqid,
                    struct l_msgbuf *msgp,
                    l_size_t msgsz,
                    l_int msgflg
                );
        }
190     AUE_NULL        STD     {
                int linux_semget(
                    l_key_t key,
                    l_int nsems,
                    l_int semflg
                );
        }
191     AUE_NULL        STD     {
                int linux_semctl(
                    l_int semid,
                    l_int semnum,
                    l_int cmd,
                    union l_semun arg
                );
        }
192     AUE_NULL        STD     {
                int linux_semtimedop(
                    l_int semid,
                    struct sembuf *tsops,
                    l_size_t nsops,
                    struct l_timespec *timeout
                );
        }
193     AUE_NULL        NOPROTO {
                int semop(
                    l_int semid,
                    struct sembuf *sops,
                    l_size_t nsops
                );
        }
194     AUE_NULL        STD     {
                int linux_shmget(
                    l_key_t key,
                    l_size_t size,
                    l_int shmflg
                );
        }
195     AUE_NULL        STD     {
                int linux_shmctl(
                    l_int shmid,
                    l_int cmd,
                    struct l_shmid_ds *buf
                );
        }
196     AUE_NULL        STD     {
                int linux_shmat(
                    l_int shmid,
                    char *shmaddr,
                    l_int shmflg
                );
        }
197     AUE_NULL        STD     {
                int linux_shmdt(
                    char *shmaddr
                );
        }
198     AUE_SOCKET      STD     {
                int linux_socket(
                    l_int domain,
                    l_int type,
                    l_int protocol
                );
        }
199     AUE_SOCKETPAIR  STD     {
                int linux_socketpair(
                    l_int domain,
                    l_int type,
                    l_int protocol,
                    l_uintptr_t rsv
                );
        }
200     AUE_BIND        STD     {
                int linux_bind(
                    l_int s,
                    l_uintptr_t name,
                    l_int namelen
                );
        }
201     AUE_LISTEN      STD     {
                int linux_listen(
                    l_int s,
                    l_int backlog
                );
        }
202     AUE_ACCEPT      STD     {
                int linux_accept(
                    l_int s,
                    l_uintptr_t addr,
                    l_uintptr_t namelen
                );
        }
203     AUE_CONNECT     STD     {
                int linux_connect(
                    l_int s,
                    l_uintptr_t name,
                    l_int namelen
                );
        }
204     AUE_GETSOCKNAME STD     {
                int linux_getsockname(
                    l_int s,
                    l_uintptr_t addr,
                    l_uintptr_t namelen
                );
        }
205     AUE_GETPEERNAME STD     {
                int linux_getpeername(
                    l_int s,
                    l_uintptr_t addr,
                    l_uintptr_t namelen
                );
        }
206     AUE_SENDTO      STD     {
                int linux_sendto(
                    l_int s,
                    l_uintptr_t msg,
                    l_size_t len,
                    l_uint flags,
                    l_uintptr_t to,
                    l_int tolen
                );
        }
207     AUE_RECVFROM    STD     {
                int linux_recvfrom(
                    l_int s,
                    l_uintptr_t buf,
                    l_size_t len,
                    l_uint flags,
                    l_uintptr_t from,
                    l_uintptr_t fromlen
                );
        }
208     AUE_SETSOCKOPT  STD     {
                int linux_setsockopt(
                    l_int s,
                    l_int level,
                    l_int optname,
                    l_uintptr_t optval,
                    l_int optlen
                );
        }
209     AUE_GETSOCKOPT  STD     {
                int linux_getsockopt(
                    l_int s,
                    l_int level,
                    l_int optname,
                    l_uintptr_t optval,
                    l_uintptr_t optlen
                );
        }
210     AUE_NULL        STD     {
                int linux_shutdown(
                    l_int s,
                    l_int how
                );
        }
211     AUE_SENDMSG     STD     {
                int linux_sendmsg(
                    l_int s,
                    l_uintptr_t msg,
                    l_uint flags
                );
        }
212     AUE_RECVMSG     STD     {
                int linux_recvmsg(
                    l_int s,
                    l_uintptr_t msg,
                    l_uint flags
                );
        }
213     AUE_NULL        UNIMPL  linux_readahead
214     AUE_NULL        STD     {
                int linux_brk(
                    l_ulong dsend
                );
        }
215     AUE_MUNMAP      NOPROTO {
                int munmap(
                    void *addr,
                    l_size_t len
                );
        }
216     AUE_NULL        STD     {
                int linux_mremap(
                    l_ulong addr,
                    l_ulong old_len,
                    l_ulong new_len,
                    l_ulong flags,
                    l_ulong new_addr
                );
        }
217     AUE_NULL        STD     {
                int linux_add_key(void);
        }
218     AUE_NULL        STD     {
                int linux_request_key(void);
        }
219     AUE_NULL        STD     {
                int linux_keyctl(void);
        }
220     AUE_RFORK       STD     {
                int linux_clone(
                    l_ulong flags,
                    l_ulong stack,
                    l_int *parent_tidptr,
                    l_ulong tls,
                    l_int *child_tidptr
                );
        }
221     AUE_EXECVE      STD     {
                int linux_execve(
                    char *path,
                    char **argp,
                    char **envp
                );
        }
222     AUE_MMAP        STD     {
                int linux_mmap2(
                    l_ulong addr,
                    l_ulong len,
                    l_ulong prot,
                    l_ulong flags,
                    l_ulong fd,
                    l_ulong pgoff
                );
        }
223     AUE_NULL        STD     {
                int linux_fadvise64(
                    l_int fd,
                    l_loff_t offset,
                    l_size_t len,
                    l_int advice
                );
        }
224     AUE_SWAPON      NOPROTO {
                int swapon(
                    char *name
                );
        }
225     AUE_SWAPOFF     STD     {
                int linux_swapoff(void);
        }
226     AUE_MPROTECT    STD     {
                int linux_mprotect(
                    l_ulong addr,
                    l_size_t len,
                    l_ulong prot
                );
        }
227     AUE_MSYNC       STD     {
                int linux_msync(
                    l_ulong addr,
                    l_size_t len,
                    l_int fl
                );
        }
228     AUE_MLOCK       NOPROTO {
                int mlock(
                    const void *addr,
                    size_t len
                );
        }
229     AUE_MUNLOCK     NOPROTO {
                int munlock(
                    const void *addr,
                    size_t len
                );
        }
230     AUE_MLOCKALL    NOPROTO {
                int mlockall(
                    int how
                );
        }
231     AUE_MUNLOCKALL  NOPROTO {
                int munlockall(void);
        }
232     AUE_MINCORE     STD     {
                int linux_mincore(
                    l_ulong start,
                    l_size_t len,
                    u_char *vec
                );
        }
233     AUE_MADVISE     STD     {
                int linux_madvise(
                    l_ulong addr,
                    l_size_t len,
                    l_int behav
                );
        }
234     AUE_NULL        STD     {
                int linux_remap_file_pages(void);
        }
235     AUE_NULL        STD     {
                int linux_mbind(void);
        }
236     AUE_NULL        STD     {
                int linux_get_mempolicy(void);
        }
237     AUE_NULL        STD     {
                int linux_set_mempolicy(void);
        }
238     AUE_NULL        STD     {
                int linux_migrate_pages(void);
        }
239     AUE_NULL        STD     {
                int linux_move_pages(void);
        }
240     AUE_NULL        STD     {
                int linux_rt_tgsigqueueinfo(
                    l_pid_t tgid,
                    l_pid_t tid,
                    l_int sig,
                    l_siginfo_t *uinfo
                );
        }
241     AUE_NULL        STD     {
                int linux_perf_event_open(void);
        }
242     AUE_ACCEPT      STD     {
                int linux_accept4(
                    l_int s,
                    l_uintptr_t addr,
                    l_uintptr_t namelen,
                    l_int flags
                );
        }
243     AUE_NULL        STD     {
                int linux_recvmmsg(
                    l_int s,
                    struct l_mmsghdr *msg,
                    l_uint vlen,
                    l_uint flags,
                    struct l_timespec *timeout
                );
        }
244-259 AUE_NULL        UNIMPL  unimpl_md_syscall
260     AUE_WAIT4       STD     {
                int linux_wait4(
                    l_pid_t pid,
                    l_int *status,
                    l_int options,
                    struct rusage *rusage
                );
        }
261     AUE_NULL        STD     {
                int linux_prlimit64(
                    l_pid_t pid,
                    l_uint resource,
                    struct rlimit *new,
                    struct rlimit *old
                );
        }
262     AUE_NULL        STD     {
                int linux_fanotify_init(void);
        }
263     AUE_NULL        STD     {
                int linux_fanotify_mark(void);
        }
264     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
                );
        }
265     AUE_NULL        STD     {
                int linux_open_by_handle_at(
                    l_int mountdirfd,
                    struct l_file_handle *handle,
                    l_int flags
                );
        }
266     AUE_NULL        STD     {
                int linux_clock_adjtime(void);
        }
267     AUE_SYNC        STD     {
                int linux_syncfs(
                    l_int fd
                );
        }
268     AUE_NULL        STD     {
                int linux_setns(
                    l_int fd,
                    l_int nstype
                );
        }
269     AUE_NULL        STD     {
                int linux_sendmmsg(
                    l_int s,
                    struct l_mmsghdr *msg,
                    l_uint vlen,
                    l_uint flags
                );
        }
270     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
                );
        }
271     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
                );
        }
272     AUE_NULL        STD     {
                int linux_kcmp(
                    l_pid_t pid1,
                    l_pid_t pid2,
                    l_int type,
                    l_ulong idx1,
                    l_ulong idx
                );
        }
273     AUE_NULL        STD     {
                int linux_finit_module(
                    l_int fd,
                    const char *uargs,
                    l_int flags
                );
        }
274     AUE_NULL        STD     {
                int linux_sched_setattr(
                    l_pid_t pid,
                    void *attr,
                    l_uint flags
                );
        }
275     AUE_NULL        STD     {
                int linux_sched_getattr(
                    l_pid_t pid,
                    void *attr,
                    l_uint size,
                    l_uint flags
                );
        }
276     AUE_NULL        STD     {
                int linux_renameat2(
                    l_int olddfd,
                    const char *oldname,
                    l_int newdfd,
                    const char *newname,
                    l_uint flags
                );
        }
277     AUE_NULL        STD     {
                int linux_seccomp(
                    l_uint op,
                    l_uint flags,
                    const char *uargs
                );
        }
278     AUE_NULL        STD     {
                int linux_getrandom(
                    char *buf,
                    l_size_t count,
                    l_uint flags
                );
        }
279     AUE_NULL        STD     {
                int linux_memfd_create(
                    const char *uname_ptr,
                    l_uint flags
                );
        }
280     AUE_NULL        STD     {
                int linux_bpf(
                    l_int cmd,
                    void *attr,
                    l_uint size
                );
        }
281     AUE_NULL        STD     {
                int linux_execveat(
                    l_int dfd,
                    const char *filename,
                    const char **argv,
                    const char **envp,
                    l_int flags
                );
        }
282     AUE_NULL        STD     {
                int linux_userfaultfd(
                    l_int flags
                );
        }
283     AUE_NULL        STD     {
                int linux_membarrier(
                    l_int cmd,
                    l_int flags
                );
        }
284     AUE_NULL        STD     {
                int linux_mlock2(
                    l_ulong start,
                    l_size_t len,
                    l_int flags
                );
        }
285     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
                );
        }
286     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
                );
        }
287     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
                );
        }
288     AUE_NULL        STD     {
                int linux_pkey_mprotect(
                    l_ulong start,
                    l_size_t len,
                    l_ulong prot,
                    l_int pkey
                );
        }
289     AUE_NULL        STD     {
                int linux_pkey_alloc(
                    l_ulong flags,
                    l_ulong init_val
                );
        }
290     AUE_NULL        STD     {
                int linux_pkey_free(
                    l_int pkey
                );
        }
; Linux 4.11:
291    AUE_NULL         STD {
                int linux_statx(
                    l_int dirfd,
                    const char *pathname,
                    l_uint flags,
                    l_uint mask,
                    void *statxbuf
                );
        }
; Linux 4.18:
292    AUE_NULL         STD {
                int linux_io_pgetevents(void);
        }
293    AUE_NULL         STD {
                int linux_rseq(
                    struct linux_rseq *rseq,
                    uint32_t rseq_len,
                    l_int flags,
                    uint32_t sig
                );
        }
294    AUE_NULL         STD {
                int linux_kexec_file_load(void);
        }
295-423 AUE_NULL        UNIMPL  unimpl_md_syscall
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(
                    l_int epfd,
                    struct epoll_event *events,
                    l_int maxevents,
                    struct l_timespec *timeout,
                    l_sigset_t *mask,
                    l_size_t sigsetsize
                );
        }
442    AUE_NULL         STD {
                int linux_mount_setattr(void);
        }
; please, keep this line at the end.
443    AUE_NULL        UNIMPL  nosys
; vim: syntax=off