sys/arm64/linux/syscalls.master

   1  $FreeBSD$
   2
   3 ; Linux ABI system call generic name/number map, based on Linux file
   4 ; include/uapi/asm-generic/unistd.h
   5
   6 #include <sys/param.h>
   7 #include <sys/sysent.h>
   8 #include <sys/sysproto.h>
   9 #include <compat/linux/linux_sysproto.h>
  10 #include <arm64/linux/linux.h>
  11 #include <arm64/linux/linux_proto.h>
  12
  13 ; Isn't pretty, but there seems to be no other way to trap nosys
  14 #define nosys   linux_nosys
  15
  16 0       AUE_NULL        UNIMPL  linux_io_setup
  17 1       AUE_NULL        UNIMPL  linux_io_destroy
  18 2       AUE_NULL        UNIMPL  linux_io_submit
  19 3       AUE_NULL        UNIMPL  linux_io_cancel
  20 4       AUE_NULL        UNIMPL  linux_io_getevents
  21 5       AUE_NULL        STD     { int linux_setxattr(void); }
  22 6       AUE_NULL        STD     { int linux_lsetxattr(void); }
  23 7       AUE_NULL        STD     { int linux_fsetxattr(void); }
  24 8       AUE_NULL        STD     { int linux_getxattr(void); }
  25 9       AUE_NULL        STD     { int linux_lgetxattr(void); }
  26 10      AUE_NULL        STD     { int linux_fgetxattr(void); }
  27 11      AUE_NULL        STD     { int linux_listxattr(void); }
  28 12      AUE_NULL        STD     { int linux_llistxattr(void); }
  29 13      AUE_NULL        STD     { int linux_flistxattr(void); }
  30 14      AUE_NULL        STD     { int linux_removexattr(void); }
  31 15      AUE_NULL        STD     { int linux_lremovexattr(void); }
  32 16      AUE_NULL        STD     { int linux_fremovexattr(void); }
  33 17      AUE_GETCWD      STD     { int linux_getcwd(char *buf, \
  34                                     l_ulong bufsize); }
  35 18      AUE_NULL        STD     { int linux_lookup_dcookie(void); }
  36 19      AUE_NULL        STD     { int linux_eventfd2(l_uint initval, \
  37                                     l_int flags); }
  38 20      AUE_NULL        STD     { int linux_epoll_create1(l_int flags); }
  39 21      AUE_NULL        STD     { int linux_epoll_ctl(l_int epfd, l_int op, \
  40                                     l_int fd, struct epoll_event *event); }
  41 22      AUE_NULL        STD     { int linux_epoll_pwait(l_int epfd, \
  42                                     struct epoll_event *events, \
  43                                     l_int maxevents, l_int timeout, \
  44                                     l_sigset_t *mask, l_size_t sigsetsize); }
  45 23      AUE_DUP         NOPROTO { int dup(u_int fd); }
  46 24      AUE_NULL        STD     { int linux_dup3(l_int oldfd, l_int newfd, \
  47                                     l_int flags); }
  48 25      AUE_FCNTL       STD     { int linux_fcntl(l_uint fd, l_uint cmd, \
  49                                     l_ulong arg); }
  50 26      AUE_NULL        STD     { int linux_inotify_init1(l_int flags); }
  51 27      AUE_NULL        STD     { int linux_inotify_add_watch(void); }
  52 28      AUE_NULL        STD     { int linux_inotify_rm_watch(void); }
  53 29      AUE_IOCTL       STD     { int linux_ioctl(l_uint fd, l_uint cmd, \
  54                                     uintptr_t arg); }
  55 30      AUE_NULL        STD     { int linux_ioprio_set(void); }
  56 31      AUE_NULL        STD     { int linux_ioprio_get(void); }
  57 32      AUE_FLOCK       NOPROTO { int flock(int fd, int how); }
  58 33      AUE_MKNODAT     STD     { int linux_mknodat(l_int dfd, \
  59                                     const char *filename, l_int mode, \
  60                                     l_uint dev); }
  61 34      AUE_MKDIRAT     STD     { int linux_mkdirat(l_int dfd, \
  62                                     const char *pathname, l_int mode); }
  63 35      AUE_UNLINKAT    STD     { int linux_unlinkat(l_int dfd, \
  64                                     const char *pathname, l_int flag); }
  65 36      AUE_SYMLINKAT   STD     { int linux_symlinkat(const char *oldname, \
  66                                     l_int newdfd, const char *newname); }
  67 37      AUE_LINKAT      STD     { int linux_linkat(l_int olddfd, \
  68                                     const char *oldname, l_int newdfd, \
  69                                     const char *newname, l_int flag); }
  70 38      AUE_RENAMEAT    STD     { int linux_renameat(l_int olddfd, \
  71                                     const char *oldname, l_int newdfd, \
  72                                     const char *newname); }
  73 39      AUE_NULL        UNIMPL  linux_umount2
  74 40      AUE_MOUNT       STD     { int linux_mount(char *specialfile, \
  75                                     char *dir, char *filesystemtype, \
  76                                     l_ulong rwflag, void *data); }
  77 41      AUE_PIVOT_ROOT  STD     { int linux_pivot_root(void); }
  78 42      AUE_NULL        UNIMPL  nfsservctl
  79 43      AUE_STATFS      STD     { int linux_statfs(char *path, \
  80                                     struct l_statfs_buf *buf); }
  81 44      AUE_FSTATFS     STD     { int linux_fstatfs(l_uint fd, \
  82                                     struct l_statfs_buf *buf); }
  83 45      AUE_TRUNCATE    STD     { int linux_truncate(char *path, \
  84                                     l_ulong length); }
  85 46      AUE_FTRUNCATE   STD     { int linux_ftruncate(l_int fd, \
  86                                     l_long length); }
  87 47      AUE_NULL        STD     { int linux_fallocate(l_int fd, l_int mode, \
  88                                     l_loff_t offset, l_loff_t len); }
  89 48      AUE_FACCESSAT   STD     { int linux_faccessat(l_int dfd, \
  90                                     const char *filename, l_int amode); }
  91 49      AUE_CHDIR       STD     { int linux_chdir(char *path); }
  92 50      AUE_FCHDIR      NOPROTO { int fchdir(int fd); }
  93 51      AUE_CHROOT      NOPROTO { int chroot(char *path); }
  94 52      AUE_FCHMOD      NOPROTO { int fchmod(int fd, int mode); }
  95 53      AUE_FCHMODAT    STD     { int linux_fchmodat(l_int dfd, \
  96                                     const char *filename, l_mode_t mode); }
  97 54      AUE_FCHOWNAT    STD     { int linux_fchownat(l_int dfd, \
  98                                     const char *filename, l_uid_t uid, \
  99                                     l_gid_t gid, l_int flag); }
 100 55      AUE_FCHOWN      NOPROTO { int fchown(int fd, int uid, int gid); }
 101 56      AUE_OPEN_RWTC   STD     { int linux_openat(l_int dfd, \
 102                                     const char *filename, l_int flags, \
 103                                     l_int mode); }
 104 57      AUE_CLOSE       NOPROTO { int close(int fd); }
 105 58      AUE_NULL        STD     { int linux_vhangup(void); }
 106 59      AUE_NULL        STD     { int linux_pipe2(l_int *pipefds, \
 107                                     l_int flags); }
 108 60      AUE_NULL        UNIMPL  linux_quotactl
 109 61      AUE_GETDIRENTRIES       STD { int linux_getdents64(l_uint fd, \
 110                                     void *dirent, l_uint count); }
 111 62      AUE_LSEEK       STD     { int linux_lseek(l_uint fdes, l_off_t off, \
 112                                     l_int whence); }
 113 63      AUE_NULL        NOPROTO { int read(int fd, char *buf, \
 114                                     u_int nbyte); }
 115 64      AUE_NULL        NOPROTO { int write(int fd, char *buf, \
 116                                     u_int nbyte); }
 117 65      AUE_READV       NOPROTO { int readv(int fd, struct iovec *iovp, \
 118                                     u_int iovcnt); }
 119 66      AUE_WRITEV      NOPROTO { int writev(int fd, struct iovec *iovp, \
 120                                     u_int iovcnt); }
 121 67      AUE_PREAD       STD     { int linux_pread(l_uint fd, char *buf, \
 122                                     l_size_t nbyte, l_loff_t offset); }
 123 68      AUE_PWRITE      STD     { int linux_pwrite(l_uint fd, char *buf, \
 124                                     l_size_t nbyte, l_loff_t offset); }
 125 69      AUE_NULL        STD     { int linux_preadv(l_ulong fd, \
 126                                     struct iovec *vec, l_ulong vlen, \
 127                                     l_ulong pos_l, l_ulong pos_h); }
 128 70      AUE_NULL        STD     { int linux_pwritev(l_ulong fd, \
 129                                     struct iovec *vec, l_ulong vlen, \
 130                                     l_ulong pos_l, l_ulong pos_h); }
 131 71      AUE_SENDFILE    STD     { int linux_sendfile(l_int out, l_int in, \
 132                                     l_long *offset, l_size_t count); }
 133 72      AUE_SELECT      STD     { int linux_pselect6(l_int nfds, \
 134                                     l_fd_set *readfds, l_fd_set *writefds, \
 135                                     l_fd_set *exceptfds, \
 136                                     struct l_timespec *tsp, l_uintptr_t *sig); }
 137 73      AUE_POLL        STD     { int linux_ppoll(struct pollfd *fds, \
 138                                     uint32_t nfds, struct l_timespec *tsp, \
 139                                     l_sigset_t *sset, l_size_t ssize); }
 140 74      AUE_NULL        STD     { int linux_signalfd4(void); }
 141 75      AUE_NULL        STD     { int linux_vmsplice(void); }
 142 76      AUE_NULL        STD     { int linux_splice(void); }
 143 77      AUE_NULL        STD     { int linux_tee(void); }
 144 78      AUE_READLINKAT  STD     { int linux_readlinkat(l_int dfd, \
 145                                     const char *path, char *buf, \
 146                                     l_int bufsiz); }
 147 79      AUE_FSTATAT     STD     { int linux_newfstatat(l_int dfd, \
 148                                     char *pathname, struct l_stat64 *statbuf, \
 149                                     l_int flag); }
 150 80      AUE_FSTAT       STD     { int linux_newfstat(l_uint fd, \
 151                                     struct l_newstat *buf); }
 152 81      AUE_NULL        UNIMPL  linux_sync
 153 82      AUE_FSYNC       NOPROTO { int fsync(int fd); }
 154 83      AUE_NULL        STD     { int linux_fdatasync(l_uint fd); }
 155 84      AUE_NULL        STD     { int linux_sync_file_range(void); }
 156 85      AUE_NULL        STD     { int linux_timerfd_create(l_int clockid, \
 157                                     l_int flags); }
 158 86      AUE_NULL        STD     { int linux_timerfd_settime(l_int fd, \
 159                                     l_int flags, \
 160                                     const struct l_itimerspec *new_value, \
 161                                     struct l_itimerspec *old_value); }
 162 87      AUE_NULL        STD     { int linux_timerfd_gettime(l_int fd, \
 163                                     struct l_itimerspec *old_value); }
 164 88      AUE_FUTIMESAT   STD     { int linux_utimensat(l_int dfd, \
 165                                     const char *pathname, \
 166                                     const struct l_timespec *times, \
 167                                     l_int flags); }
 168 89      AUE_ACCT        NOPROTO { int acct(char *path); }
 169 90      AUE_CAPGET      STD     { int linux_capget( \
 170                                     struct l_user_cap_header *hdrp, \
 171                                     struct l_user_cap_data *datap); }
 172 91      AUE_CAPSET      STD     { int linux_capset( \
 173                                     struct l_user_cap_header *hdrp, \
 174                                     struct l_user_cap_data *datap); }
 175 92      AUE_PERSONALITY STD     { int linux_personality(l_uint per); }
 176 93      AUE_EXIT        STD     { int linux_exit(int rval); }
 177 94      AUE_EXIT        STD     { int linux_exit_group(int error_code); }
 178 95      AUE_WAIT6       STD     { int linux_waitid(l_int idtype, l_pid_t id, \
 179                                     l_siginfo_t *info, l_int options, \
 180                                     struct rusage *rusage); }
 181 96      AUE_NULL        STD     { int linux_set_tid_address(int *tidptr); }
 182 97      AUE_NULL        STD     { int linux_unshare(void); }
 183 98      AUE_NULL        STD     { int linux_sys_futex(void *uaddr, int op, \
 184                                     int val, struct l_timespec *timeout, \
 185                                     void *uaddr2, int val3); }
 186 99      AUE_NULL        STD     { int linux_set_robust_list( \
 187                                     struct linux_robust_list_head *head, \
 188                                     l_size_t len); }
 189 100     AUE_NULL        STD     { int linux_get_robust_list(l_int pid, \
 190                                     struct linux_robust_list_head **head, \
 191                                     l_size_t *len); }
 192 101     AUE_NULL        STD     { int linux_nanosleep( \
 193                                     const struct l_timespec *rqtp, \
 194                                     struct l_timespec *rmtp); }
 195 102     AUE_GETITIMER   STD     { int linux_getitimer(l_int which, \
 196                                     struct l_itimerval *itv); }
 197 103     AUE_SETITIMER   STD     { int linux_setitimer(l_int which, \
 198                                     struct l_itimerval *itv, \
 199                                     struct l_itimerval *oitv); }
 200 104     AUE_NULL        STD     { int linux_kexec_load(void); }
 201 105     AUE_NULL        STD     { int linux_init_module(void); }
 202 106     AUE_NULL        STD     { int linux_delete_module(void); }
 203 107     AUE_NULL        STD     { int linux_timer_create(clockid_t clock_id, \
 204                                     struct sigevent *evp, l_timer_t *timerid); }
 205 108     AUE_NULL        STD     { int linux_timer_gettime(l_timer_t timerid, \
 206                                     struct itimerspec *setting); }
 207 109     AUE_NULL        STD     { int linux_timer_getoverrun( \
 208                                     l_timer_t timerid); }
 209 110     AUE_NULL        STD     { int linux_timer_settime(l_timer_t timerid, \
 210                                     l_int flags, const struct itimerspec *new, \
 211                                     struct itimerspec *old); }
 212 111     AUE_NULL        STD     { int linux_timer_delete(l_timer_t timerid); }
 213 112     AUE_CLOCK_SETTIME       STD     { int linux_clock_settime( \
 214                                     clockid_t which, struct l_timespec *tp); }
 215 113     AUE_NULL        STD     { int linux_clock_gettime(clockid_t which, \
 216                                     struct l_timespec *tp); }
 217 114     AUE_NULL        STD     { int linux_clock_getres(clockid_t which, \
 218                                     struct l_timespec *tp); }
 219 115     AUE_NULL        STD     { int linux_clock_nanosleep(clockid_t which, \
 220                                     int flags, struct l_timespec *rqtp, \
 221                                     struct l_timespec *rmtp); }
 222 116     AUE_NULL        STD     { int linux_syslog(l_int type, char *buf, \
 223                                     l_int len); }
 224 117     AUE_PTRACE      STD     { int linux_ptrace(l_long req, l_long pid, \
 225                                     l_ulong addr, l_ulong data); }
 226 118     AUE_SCHED_SETPARAM      STD     { int linux_sched_setparam( \
 227                                     l_pid_t pid, struct sched_param *param); }
 228 119     AUE_SCHED_SETSCHEDULER  STD { int linux_sched_setscheduler( \
 229                                     l_pid_t pid, l_int policy, \
 230                                     struct sched_param *param); }
 231 120     AUE_SCHED_GETSCHEDULER  STD { int linux_sched_getscheduler( \
 232                                     l_pid_t pid); }
 233 121     AUE_SCHED_GETPARAM      STD     { int linux_sched_getparam( \
 234                                     l_pid_t pid, struct sched_param *param); }
 235 122     AUE_NULL        STD     { int linux_sched_setaffinity(l_pid_t pid, \
 236                                     l_uint len, l_ulong *user_mask_ptr); }
 237 123     AUE_NULL        STD     { int linux_sched_getaffinity(l_pid_t pid, \
 238                                     l_uint len, l_ulong *user_mask_ptr); }
 239 124     AUE_NULL        NOPROTO { int sched_yield(void); }
 240 125     AUE_SCHED_GET_PRIORITY_MAX      STD { int linux_sched_get_priority_max(\
 241                                     l_int policy); }
 242 126     AUE_SCHED_GET_PRIORITY_MIN      STD { int linux_sched_get_priority_min(\
 243                                     l_int policy); }
 244 127     AUE_SCHED_RR_GET_INTERVAL       STD { int linux_sched_rr_get_interval( \
 245                                     l_pid_t pid, struct l_timespec *interval); }
 246 128     AUE_NULL        UNIMPL  restart_syscall
 247 129     AUE_KILL        STD     { int linux_kill(l_int pid, l_int signum); }
 248 130     AUE_NULL        STD     { int linux_tkill(l_int tid, l_int sig); }
 249 131     AUE_NULL        STD     { int linux_tgkill(l_int tgid, l_int pid, \
 250                                     l_int sig); }
 251 132     AUE_NULL        STD     { int linux_sigaltstack(l_stack_t *uss, \
 252                                     l_stack_t *uoss); }
 253 133     AUE_NULL        STD     { int linux_rt_sigsuspend( \
 254                                     l_sigset_t *newset, \
 255                                     l_size_t sigsetsize); }
 256 134     AUE_NULL        STD     { int linux_rt_sigaction(l_int sig, \
 257                                     l_sigaction_t *act, l_sigaction_t *oact, \
 258                                     l_size_t sigsetsize); }
 259 135     AUE_NULL        STD     { int linux_rt_sigprocmask(l_int how, \
 260                                     l_sigset_t *mask, l_sigset_t *omask, \
 261                                     l_size_t sigsetsize); }
 262 136     AUE_NULL        STD     { int linux_rt_sigpending(l_sigset_t *set, \
 263                                     l_size_t sigsetsize); }
 264 137     AUE_NULL        STD     { int linux_rt_sigtimedwait(l_sigset_t *mask, \
 265                                     l_siginfo_t *ptr, \
 266                                     struct l_timeval *timeout, \
 267                                     l_size_t sigsetsize); }
 268 138     AUE_NULL        STD     { int linux_rt_sigqueueinfo(l_pid_t pid, \
 269                                     l_int sig, l_siginfo_t *info); }
 270 139     AUE_NULL        STD     { int linux_rt_sigreturn( \
 271                                     struct l_ucontext *ucp); }
 272 140     AUE_SETPRIORITY NOPROTO { int setpriority(int which, int who, \
 273                                     int prio); }
 274 141     AUE_GETPRIORITY STD     { int linux_getpriority(l_int which, \
 275                                     l_int who); }
 276 142     AUE_REBOOT      STD     { int linux_reboot(l_int magic1, \
 277                                     l_int magic2, l_uint cmd, void *arg); }
 278 143     AUE_SETREGID    NOPROTO { int setregid(gid_t rgid, gid_t egid); }
 279 144     AUE_SETGID      NOPROTO { int setgid(gid_t gid); }
 280 145     AUE_SETREUID    NOPROTO { int setreuid(uid_t ruid, uid_t euid); }
 281 146     AUE_SETUID      NOPROTO { int setuid(uid_t uid); }
 282 147     AUE_SETRESUID   NOPROTO { int setresuid(uid_t ruid, uid_t euid, \
 283                                     uid_t suid); }
 284 148     AUE_GETRESUID   NOPROTO { int getresuid(uid_t *ruid, uid_t *euid, \
 285                                     uid_t *suid); }
 286 149     AUE_SETRESGID   NOPROTO { int setresgid(gid_t rgid, gid_t egid, \
 287                                     gid_t sgid); }
 288 150     AUE_GETRESGID   NOPROTO { int getresgid(gid_t *rgid, gid_t *egid, \
 289                                     gid_t *sgid); }
 290 151     AUE_SETFSUID    STD     { int linux_setfsuid(l_uid_t uid); }
 291 152     AUE_SETFSGID    STD     { int linux_setfsgid(l_gid_t gid); }
 292 153     AUE_NULL        STD     { int linux_times(struct l_times_argv *buf); }
 293 154     AUE_SETPGRP     NOPROTO { int setpgid(int pid, int pgid); }
 294 155     AUE_GETPGID     NOPROTO { int getpgid(int pid); }
 295 156     AUE_GETSID      STD     { int linux_getsid(l_pid_t pid); }
 296 157     AUE_SETSID      NOPROTO { int setsid(void); }
 297 158     AUE_GETGROUPS   STD     { int linux_getgroups(l_int gidsetsize, \
 298                                     l_gid_t *grouplist); }
 299 159     AUE_SETGROUPS   STD     { int linux_setgroups(l_int gidsetsize, \
 300                                     l_gid_t *grouplist); }
 301 160     AUE_NULL        STD     { int linux_newuname( \
 302                                     struct l_new_utsname *buf); }
 303 161     AUE_SYSCTL      STD     { int linux_sethostname(char *hostname, \
 304                                     l_uint len); }
 305 162     AUE_SYSCTL      STD     { int linux_setdomainname(char *name, \
 306                                     l_int len); }
 307 163     AUE_GETRLIMIT   STD     { int linux_getrlimit(l_uint resource, \
 308                                     struct l_rlimit *rlim); }
 309 164     AUE_SETRLIMIT   STD     { int linux_setrlimit(l_uint resource, \
 310                                     struct l_rlimit *rlim); }
 311 165     AUE_GETRUSAGE   NOPROTO { int getrusage(int who, \
 312                                     struct rusage *rusage); }
 313 166     AUE_UMASK       NOPROTO { int umask(int newmask); }
 314 167     AUE_PRCTL       STD     { int linux_prctl(l_int option, \
 315                                     l_uintptr_t arg2, l_uintptr_t arg3, \
 316                                     l_uintptr_t arg4, l_uintptr_t arg5); }
 317 168     AUE_NULL        STD     { int linux_getcpu(l_uint *cpu, l_uint *node, \
 318                                     void *cache); }
 319 169     AUE_NULL        NOPROTO { int gettimeofday(struct l_timeval *tp, \
 320                                     struct timezone *tzp); }
 321 170     AUE_SETTIMEOFDAY        NOPROTO { int settimeofday( \
 322                                     struct l_timeval *tv, \
 323                                     struct timezone *tzp); }
 324 171     AUE_ADJTIME     STD     { int linux_adjtimex(void); }
 325 172     AUE_GETPID      STD     { int linux_getpid(void); }
 326 173     AUE_GETPPID     STD     { int linux_getppid(void); }
 327 174     AUE_GETUID      STD     { int linux_getuid(void); }
 328 175     AUE_GETEUID     NOPROTO { int geteuid(void); }
 329 176     AUE_GETGID      STD     { int linux_getgid(void); }
 330 177     AUE_GETEGID     NOPROTO { int getegid(void); }
 331 178     AUE_NULL        STD     { int linux_gettid(void); }
 332 179     AUE_NULL        STD     { int linux_sysinfo(struct l_sysinfo *info); }
 333 180     AUE_NULL        STD     { int linux_mq_open(void); }
 334 181     AUE_NULL        STD     { int linux_mq_unlink(void); }
 335 182     AUE_NULL        STD     { int linux_mq_timedsend(void); }
 336 183     AUE_NULL        STD     { int linux_mq_timedreceive(void); }
 337 184     AUE_NULL        STD     { int linux_mq_notify(void); }
 338 185     AUE_NULL        STD     { int linux_mq_getsetattr(void); }
 339 186     AUE_NULL        STD     { int linux_msgget(l_key_t key, l_int msgflg); }
 340 187     AUE_NULL        STD     { int linux_msgctl(l_int msqid, l_int cmd, \
 341                                     struct l_msqid_ds *buf); }
 342 188     AUE_NULL        STD     { int linux_msgrcv(l_int msqid, \
 343                                     struct l_msgbuf *msgp, l_size_t msgsz, \
 344                                     l_long msgtyp, l_int msgflg); }
 345 189     AUE_NULL        STD     { int linux_msgsnd(l_int msqid, \
 346                                     struct l_msgbuf *msgp, l_size_t msgsz, \
 347                                     l_int msgflg); }
 348 190     AUE_NULL        STD     { int linux_semget(l_key_t key, \
 349                                     l_int nsems, l_int semflg); }
 350 191     AUE_NULL        STD     { int linux_semctl(l_int semid, \
 351                                     l_int semnum, l_int cmd, \
 352                                     union l_semun arg); }
 353 192     AUE_NULL        STD     { int linux_semtimedop(void); }
 354 193     AUE_NULL        STD     { int linux_semop(l_int semid, \
 355                                     struct l_sembuf *tsops, l_uint nsops); }
 356 194     AUE_NULL        STD     { int linux_shmget(l_key_t key, l_size_t size, \
 357                                     l_int shmflg); }
 358 195     AUE_NULL        STD     { int linux_shmctl(l_int shmid, l_int cmd, \
 359                                     struct l_shmid_ds *buf); }
 360 196     AUE_NULL        STD     { int linux_shmat(l_int shmid, char *shmaddr, \
 361                                     l_int shmflg); }
 362 197     AUE_NULL        STD     { int linux_shmdt(char *shmaddr); }
 363 198     AUE_SOCKET      STD     { int linux_socket(l_int domain, l_int type, \
 364                                     l_int protocol); }
 365 199     AUE_SOCKETPAIR  STD     { int linux_socketpair(l_int domain, \
 366                                     l_int type, l_int protocol, \
 367                                     l_uintptr_t rsv); }
 368 200     AUE_BIND        STD     { int linux_bind(l_int s, l_uintptr_t name, \
 369                                     l_int namelen); }
 370 201     AUE_LISTEN      STD     { int linux_listen(l_int s, l_int backlog); }
 371 202     AUE_ACCEPT      STD     { int linux_accept(l_int s, l_uintptr_t addr, \
 372                                     l_uintptr_t namelen); }
 373 203     AUE_CONNECT     STD     { int linux_connect(l_int s, l_uintptr_t name, \
 374                                     l_int namelen); }
 375 204     AUE_GETSOCKNAME STD     { int linux_getsockname(l_int s, \
 376                                     l_uintptr_t addr, l_uintptr_t namelen); }
 377 205     AUE_GETPEERNAME STD     { int linux_getpeername(l_int s, \
 378                                     l_uintptr_t addr, l_uintptr_t namelen); }
 379 206     AUE_SENDTO      STD     { int linux_sendto(l_int s, l_uintptr_t msg, \
 380                                     l_int len, l_int flags, l_uintptr_t to, \
 381                                     l_int tolen); }
 382 207     AUE_RECVFROM    STD     { int linux_recvfrom(l_int s, l_uintptr_t buf, \
 383                                     l_size_t len, l_int flags, \
 384                                     l_uintptr_t from, l_uintptr_t fromlen); }
 385 208     AUE_SETSOCKOPT  STD     { int linux_setsockopt(l_int s, l_int level, \
 386                                     l_int optname, l_uintptr_t optval, \
 387                                     l_int optlen); }
 388 209     AUE_GETSOCKOPT  STD     { int linux_getsockopt(l_int s, l_int level, \
 389                                     l_int optname, l_uintptr_t optval, \
 390                                     l_uintptr_t optlen); }
 391 210     AUE_NULL        STD     { int linux_shutdown(l_int s, l_int how); }
 392 211     AUE_SENDMSG     STD     { int linux_sendmsg(l_int s, l_uintptr_t msg, \
 393                                     l_int flags); }
 394 212     AUE_RECVMSG     STD     { int linux_recvmsg(l_int s, l_uintptr_t msg, \
 395                                     l_int flags); }
 396 213     AUE_NULL        UNIMPL  linux_readahead
 397 214     AUE_NULL        STD     { int linux_brk(l_ulong dsend); }
 398 215     AUE_MUNMAP      NOPROTO { int munmap(caddr_t addr, int len); }
 399 216     AUE_NULL        STD     { int linux_mremap(l_ulong addr, \
 400                                     l_ulong old_len, l_ulong new_len, \
 401                                     l_ulong flags, l_ulong new_addr); }
 402 217     AUE_NULL        STD     { int linux_add_key(void); }
 403 218     AUE_NULL        STD     { int linux_request_key(void); }
 404 219     AUE_NULL        STD     { int linux_keyctl(void); }
 405 220     AUE_RFORK       STD     { int linux_clone(l_int flags, void *stack, \
 406                                     void *parent_tidptr, void *tls, \
 407                                     void *child_tidptr); }
 408 221     AUE_EXECVE      STD     { int linux_execve(char *path, char **argp, \
 409                                     char **envp); }
 410 222     AUE_MMAP        STD     { int linux_mmap2(l_ulong addr, l_ulong len, \
 411                                     l_ulong prot, l_ulong flags, l_ulong fd, \
 412                                     l_ulong pgoff); }
 413 223     AUE_NULL        STD     { int linux_fadvise64(l_int fd, \
 414                                     l_loff_t offset, l_size_t len, \
 415                                     l_int advice); }
 416 224     AUE_SWAPON      NOPROTO { int swapon(char *name); }
 417 225     AUE_SWAPOFF     STD     { int linux_swapoff(void); }
 418 226     AUE_MPROTECT    STD     { int linux_mprotect(caddr_t addr, l_int len, \
 419                                     l_int prot); }
 420 227     AUE_MSYNC       STD     { int linux_msync(l_ulong addr, \
 421                                     l_size_t len, l_int fl); }
 422 228     AUE_MLOCK       NOPROTO { int mlock(const void *addr, size_t len); }
 423 229     AUE_MUNLOCK     NOPROTO { int munlock(const void *addr, size_t len); }
 424 230     AUE_MLOCKALL    NOPROTO { int mlockall(int how); }
 425 231     AUE_MUNLOCKALL  NOPROTO { int munlockall(void); }
 426 232     AUE_MINCORE     STD     { int linux_mincore(l_ulong start, \
 427                                     l_size_t len, u_char *vec); }
 428 233     AUE_MADVISE     NOPROTO { int madvise(void *addr, size_t len, \
 429                                     int behav); }
 430 234     AUE_NULL        STD     { int linux_remap_file_pages(void); }
 431 235     AUE_NULL        STD     { int linux_mbind(void); }
 432 236     AUE_NULL        STD     { int linux_get_mempolicy(void); }
 433 237     AUE_NULL        STD     { int linux_set_mempolicy(void); }
 434 238     AUE_NULL        STD     { int linux_migrate_pages(void); }
 435 239     AUE_NULL        STD     { int linux_move_pages(void); }
 436 240     AUE_NULL        STD     { int linux_rt_tgsigqueueinfo(l_pid_t tgid, \
 437                                     l_pid_t tid, l_int sig, \
 438                                     l_siginfo_t *uinfo); }
 439 241     AUE_NULL        STD     { int linux_perf_event_open(void); }
 440 242     AUE_ACCEPT      STD     { int linux_accept4(l_int s, l_uintptr_t addr, \
 441                                     l_uintptr_t namelen, int flags); }
 442 243     AUE_NULL        STD     { int linux_recvmmsg(l_int s, \
 443                                     struct l_mmsghdr *msg, l_uint vlen, \
 444                                     l_uint flags, struct l_timespec *timeout); }
 445 244-259 AUE_NULL        UNIMPL  unimpl_md_syscall
 446 260     AUE_WAIT4       STD     { int linux_wait4(l_pid_t pid, \
 447                                     l_int *status, l_int options, \
 448                                     struct rusage *rusage); }
 449 261     AUE_NULL        STD     { int linux_prlimit64(l_pid_t pid, \
 450                                     l_uint resource, struct rlimit *new, \
 451                                     struct rlimit *old); }
 452 262     AUE_NULL        STD     { int linux_fanotify_init(void); }
 453 263     AUE_NULL        STD     { int linux_fanotify_mark(void); }
 454 264     AUE_NULL        STD     { int linux_name_to_handle_at(void); }
 455 265     AUE_NULL        STD     { int linux_open_by_handle_at(void); }
 456 266     AUE_NULL        STD     { int linux_clock_adjtime(void); }
 457 267     AUE_SYNC        STD     { int linux_syncfs(l_int fd); }
 458 268     AUE_NULL        STD     { int linux_setns(l_int fd, l_int nstype); }
 459 269     AUE_NULL        STD     { int linux_sendmmsg(l_int s, \
 460                                     struct l_mmsghdr *msg, l_uint vlen, \
 461                                     l_uint flags); }
 462 270     AUE_NULL        STD     { int linux_process_vm_readv(l_pid_t pid, \
 463                                     const struct iovec *lvec, l_ulong liovcnt, \
 464                                     const struct iovec *rvec, l_ulong riovcnt, \
 465                                     l_ulong flags); }
 466 271     AUE_NULL        STD     { int linux_process_vm_writev(l_pid_t pid, \
 467                                     const struct iovec *lvec, l_ulong liovcnt, \
 468                                     const struct iovec *rvec, l_ulong riovcnt, \
 469                                     l_ulong flags); }
 470 272     AUE_NULL        STD     { int linux_kcmp(l_pid_t pid1, l_pid_t pid2, \
 471                                     l_int type, l_ulong idx1, l_ulong idx); }
 472 273     AUE_NULL        STD     { int linux_finit_module(l_int fd, \
 473                                     const char *uargs, l_int flags); }
 474 274     AUE_NULL        STD     { int linux_sched_setattr(l_pid_t pid, \
 475                                     void *attr, l_uint flags); }
 476 275     AUE_NULL        STD     { int linux_sched_getattr(l_pid_t pid, \
 477                                     void *attr, l_uint size, l_uint flags); }
 478 276     AUE_NULL        STD     { int linux_renameat2(l_int oldfd, \
 479                                     const char *oldname, l_int newfd, \
 480                                     const char *newname, unsigned int flags); }
 481 277     AUE_NULL        STD     { int linux_seccomp(l_uint op, l_uint flags, \
 482                                     const char *uargs); }
 483 278     AUE_NULL        STD     { int linux_getrandom(char *buf, \
 484                                     l_size_t count, l_uint flags); }
 485 279     AUE_NULL        STD     { int linux_memfd_create( \
 486                                     const char *uname_ptr, l_uint flags); }
 487 280     AUE_NULL        STD     { int linux_bpf(l_int cmd, void *attr, \
 488                                     l_uint size); }
 489 281     AUE_NULL        STD     { int linux_execveat(l_int dfd, \
 490                                     const char *filename, const char **argv, \
 491                                     const char **envp, l_int flags); }
 492 282     AUE_NULL        STD     { int linux_userfaultfd(l_int flags); }
 493 283     AUE_NULL        STD     { int linux_membarrier(l_int cmd, \
 494                                     l_int flags); }
 495 284     AUE_NULL        STD     { int linux_mlock2(l_ulong start, \
 496                                     l_size_t len, l_int flags); }
 497 285     AUE_NULL        STD     { int linux_copy_file_range(l_int fd_in, \
 498                                     l_loff_t *off_in, l_int fd_out, \
 499                                     l_loff_t *off_out, l_size_t len, \
 500                                     l_uint flags); }
 501 286     AUE_NULL        STD     { int linux_preadv2(l_ulong fd, \
 502                                     const struct iovec *vec, l_ulong vlen, \
 503                                     l_ulong pos_l, l_ulong pos_h, \
 504                                     l_int flags); }
 505 287     AUE_NULL        STD     { int linux_pwritev2(l_ulong fd, \
 506                                     const struct iovec *vec, l_ulong vlen, \
 507                                     l_ulong pos_l, l_ulong pos_h, \
 508                                     l_int flags); }
 509 288     AUE_NULL        STD     { int linux_pkey_mprotect(l_ulong start, \
 510                                     l_size_t len, l_ulong prot, l_int pkey); }
 511 289     AUE_NULL        STD     { int linux_pkey_alloc(l_ulong flags, \
 512                                     l_ulong init_val); }
 513 290     AUE_NULL        STD     { int linux_pkey_free(l_int pkey); }
 514
 515 ; please, keep this line at the end.
 516 291     AUE_NULL        UNIMPL  nosys
 517
 518 ; vim: syntax=off