$NetBSD: syscalls.master,v 1.72 2023/08/19 17:49:49 christos Exp $ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; NetBSD amd64 COMPAT_LINUX system call name/number "master" file. ; (See syscalls.conf to see what it is processed into.) ; ; Fields: number type [type-dependent ...] ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of ; the compatibility options defined in syscalls.conf. ; ; types: ; STD always included ; OBSOL obsolete, not included in system ; UNIMPL unimplemented, not included in system ; NODEF included, but don't define the syscall number ; NOARGS included, but don't define the syscall args structure ; INDIR included, but don't define the syscall args structure ; and allow it to be "really" varargs. ; ; The compat options are defined in the syscalls.conf file, and the ; compat option name is prefixed to the syscall name. Other than ; that, they're like NODEF (for 'compat' options), or STD (for ; 'libcompat' options). ; ; The type-dependent arguments are as follows: ; For STD, NODEF, NOARGS, and compat syscalls: ; { pseudo-proto } [alias] ; For other syscalls: ; [comment] ; ; #ifdef's, etc. may be included, and are copied to the output files. ; #include's are copied to the syscall names and switch definition files only. #if defined(_KERNEL_OPT) #include "opt_sysv.h" #include "opt_compat_43.h" #include "opt_compat_netbsd.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include %% 0 NOARGS { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } 1 NOARGS { ssize_t|sys||write(int fd, const void *buf, \ size_t nbyte); } 2 STD { int|linux_sys||open(const char *path, int flags, \ linux_umode_t mode); } 3 NOARGS { int|sys||close(int fd); } 4 STD { int|linux_sys||stat64(const char *path, \ struct linux_stat64 *sp); } 5 STD { int|linux_sys||fstat64(int fd, \ struct linux_stat64 *sp); } 6 STD { int|linux_sys||lstat64(const char *path, \ struct linux_stat64 *sp); } 7 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \ int timeout); } 8 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \ int whence); } 9 NOARGS { linux_off_t|linux_sys||mmap(unsigned long addr, \ size_t len, int prot, int flags, int fd, \ linux_off_t offset); } 10 STD { int|linux_sys||mprotect(const void *start, \ unsigned long len, int prot); } 11 NOARGS { int|sys||munmap(void *addr, size_t len); } 12 STD { int|linux_sys||brk(char *nsize); } 13 STD { int|linux_sys||rt_sigaction(int signum, \ const struct linux_sigaction *nsa, \ struct linux_sigaction *osa, \ size_t sigsetsize); } 14 STD { int|linux_sys||rt_sigprocmask(int how, \ const linux_sigset_t *set, \ linux_sigset_t *oset, \ size_t sigsetsize); } 15 NOARGS { int|linux_sys||rt_sigreturn(void); } 16 STD { int|linux_sys||ioctl(int fd, u_long com, \ void *data); } 17 STD { int|linux_sys||pread(int fd, char *buf, \ size_t nbyte, off_t offset); } 18 STD { int|linux_sys||pwrite(int fd, char *buf, \ size_t nbyte, off_t offset); } 19 NOARGS { ssize_t|sys||readv(int fd, \ const struct iovec *iovp, int iovcnt); } 20 NOARGS { ssize_t|sys||writev(int fd, \ const struct iovec *iovp, int iovcnt); } 21 NOARGS { int|sys||access(const char *path, int flags); } 22 STD { int|linux_sys||pipe(int *pfds); } 23 STD { int|linux_sys||select(int nfds, fd_set *readfds, \ fd_set *writefds, fd_set *exceptfds, \ struct timeval50 *timeout); } 24 STD { int|linux_sys||sched_yield(void); } 25 STD { void *|linux_sys||mremap(void *old_address, \ size_t old_size, size_t new_size, u_long flags); } 26 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 27 NOARGS { int|sys||mincore(void *addr, size_t len, char *vec); } 28 NOARGS { int|sys||madvise(void *addr, size_t len, int behav); } #ifdef SYSVSHM 29 NOARGS { int|linux_sys||shmget(key_t key, size_t size, \ int shmflg); } 30 NOARGS { int|sys||shmat(int shmid, void *shmaddr, int shmflg); } 31 NOARGS { int|linux_sys||shmctl(int shmid, int cmd, \ struct linux_shmid_ds *buf); } #else 29 UNIMPL shmget 30 UNIMPL shmat 31 UNIMPL shmctl #endif 32 NOARGS { int|sys||dup(int fd); } 33 NOARGS { int|sys||dup2(int from, int to); } 34 STD { int|linux_sys||pause(void); } 35 STD { int|linux_sys||nanosleep( \ const struct linux_timespec *rqtp, \ struct linux_timespec *rmtp); } 36 NOARGS { int|compat_50_sys||getitimer(int which, \ struct itimerval50 *itv); } 37 STD { int|linux_sys||alarm(unsigned int secs); } 38 NOARGS { int|compat_50_sys||setitimer(int which, \ struct itimerval50 *itv, \ struct itimerval50 *oitv); } 39 STD { pid_t|sys||getpid(void); } 40 UNIMPL sendfile 41 STD { int|linux_sys||socket(int domain, \ int type, int protocol); } 42 STD { int|linux_sys||connect(int s, \ const struct osockaddr *name, \ unsigned int namelen); } 43 STD { int|linux_sys||accept(int s, struct osockaddr *name, \ int *anamelen); } oaccept 44 STD { ssize_t|linux_sys||sendto(int s, void *msg, int len, \ int flags, struct osockaddr *to, int tolen); } 45 STD { ssize_t|linux_sys||recvfrom(int s, void *buf, \ size_t len, int flags, struct osockaddr *from, \ unsigned int *fromlenaddr); } 46 STD { int|linux_sys||sendmsg(int s, \ const struct linux_msghdr *msg, int flags); } 47 STD { ssize_t|linux_sys||recvmsg(int s, \ struct linux_msghdr *msg, int flags); } 48 NOARGS { int|sys||shutdown(int s, int how); } 49 STD { int|linux_sys||bind(int s, \ const struct osockaddr *name, \ unsigned int namelen); } 50 NOARGS { int|sys||listen(int s, int backlog); } 51 STD { int|linux_sys||getsockname(int fdec, void *asa, \ int *alen); } 52 STD { int|linux_sys||getpeername(int fdes, \ struct sockaddr *asa, unsigned int *alen); } 53 STD { int|linux_sys||socketpair(int domain, int type, \ int protocol, int *rsv); } 54 STD { int|linux_sys||setsockopt(int s, int level, \ int optname, void *optval, int optlen); } 55 STD { int|linux_sys||getsockopt(int s, int level, \ int optname, void *optval, int *optlen); } 56 STD { int|linux_sys||clone(int flags, void *stack, \ void *parent_tidptr, void *child_tidptr, void *tls); } 57 NOARGS { int|sys||fork(void); } 58 NOARGS { int|sys|14|vfork(void); } 59 NOARGS { int|sys||execve(const char *path, char **argp, \ char **envp); } 60 STD { int|linux_sys||exit(int rval); } 61 STD { int|linux_sys||wait4(int pid, int *status, \ int options, struct rusage50 *rusage); } 62 STD { int|linux_sys||kill(int pid, int signum); } 63 STD { int|linux_sys||uname(struct linux_utsname *up); } #ifdef SYSVSEM 64 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 65 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ size_t nsops); } 66 STD { int|linux_sys||semctl(int semid, int semnum, \ int cmd, union linux_semun arg); } #else 64 UNIMPL semget 65 UNIMPL semop 66 UNIMPL semctl #endif #ifdef SYSVSHM 67 NOARGS { int|sys||shmdt(const void *shmaddr); } #else 67 UNIMPL shmdt #endif #ifdef SYSVMSG 68 NOARGS { int|sys||msgget(key_t key, int msgflg); } 69 NOARGS { int|sys||msgsnd(int msqid, void *msgp, size_t msgsz, \ int msgflg); } 70 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ size_t msgsz, long msgtyp, int msgflg); } 71 NOARGS { int|linux_sys||msgctl(int msqid, int cmd, \ struct linux_msqid_ds *buf); } #else 68 UNIMPL msgget 69 UNIMPL msgsnd 70 UNIMPL msgrcv 71 UNIMPL msgctl #endif 72 STD { int|linux_sys||fcntl(int fd, int cmd, void *arg); } 73 NOARGS { int|sys||flock(int fd, int how); } 74 NOARGS { int|sys||fsync(int fd); } 75 STD { int|linux_sys||fdatasync(int fd); } 76 STD { int|linux_sys||truncate64(const char *path, \ off_t length); } 77 STD { int|linux_sys||ftruncate64(unsigned int fd, \ off_t length); } 78 STD { int|linux_sys||getdents(int fd, \ struct linux_dirent *dent, unsigned int count); } 79 NOARGS { int|sys||__getcwd(char *bufp, size_t length); } 80 NOARGS { int|sys||chdir(const char *path); } 81 NOARGS { int|sys||fchdir(int fd); } 82 NOARGS { int|sys||__posix_rename(const char *from, \ const char *to); } 83 NOARGS { int|sys||mkdir(const char *path, linux_umode_t mode); } 84 NOARGS { int|sys||rmdir(const char *path); } 85 STD { int|linux_sys||creat(const char *path, linux_umode_t mode); } 86 NOARGS { int|sys||link(const char *path, const char *link); } 87 STD { int|linux_sys||unlink(const char *path); } 88 NOARGS { int|sys||symlink(const char *path, const char *link); } 89 NOARGS { ssize_t|sys||readlink(const char *path, char *buf, \ int count); } 90 NOARGS { int|sys||chmod(const char *path, linux_umode_t mode); } 91 NOARGS { int|sys||fchmod(int fd, linux_umode_t mode); } 92 NOARGS { int|sys||__posix_chown(const char *path, uid_t uid, \ gid_t gid); } 93 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \ gid_t gid); } 94 NOARGS { int|sys||__posix_lchown(const char *path, uid_t uid, \ gid_t gid); } 95 NOARGS { int|sys||umask(int newmask); } 96 STD { int|linux_sys||gettimeofday(struct timeval50 *tp, \ struct timezone *tzp); } 97 STD { int|linux_sys||getrlimit(int which, \ struct rlimit *rlp); } 98 NOARGS { int|compat_50_sys||getrusage(int who, \ struct rusage50 *rusage); } 99 STD { int|linux_sys||sysinfo(struct linux_sysinfo *arg); } 100 STD { int|linux_sys||times(struct times *tms); } 101 STD { int|linux_sys||ptrace(long request, long pid, \ long addr, long data); } 102 NOARGS { uid_t|sys||getuid(void); } 103 UNIMPL syslog 104 NOARGS { gid_t|sys||getgid(void); } 105 NOARGS { int|sys||setuid(uid_t uid); } 106 NOARGS { int|sys||setgid(gid_t gid); } 107 NOARGS { uid_t|sys||geteuid(void); } 108 NOARGS { gid_t|sys||getegid(void); } 109 NOARGS { int|sys||setpgid(int pid, int pgid); } 110 STD { pid_t|sys||getppid(void); } 111 NOARGS { int|sys||getpgrp(void); } 112 NOARGS { int|sys||setsid(void); } 113 NOARGS { int|sys||setreuid(uid_t ruid, uid_t euid); } 114 NOARGS { int|sys||setregid(gid_t rgid, gid_t egid); } 115 NOARGS { int|sys||getgroups(int gidsetsize, gid_t *gidset); } 116 NOARGS { int|sys||setgroups(int gidsetsize, gid_t *gidset); } 117 STD { int|linux_sys||setresuid(uid_t ruid, uid_t euid, \ uid_t suid); } 118 STD { int|linux_sys||getresuid(uid_t *ruid, uid_t *euid, \ uid_t *suid); } 119 STD { int|linux_sys||setresgid(gid_t rgid, gid_t egid, \ gid_t sgid); } 120 STD { int|linux_sys||getresgid(gid_t *rgid, gid_t *egid, \ gid_t *sgid); } 121 NOARGS { pid_t|sys||getpgid(pid_t pid); } 122 STD { int|linux_sys||setfsuid(uid_t uid); } 123 STD { int|linux_sys||setfsgid(gid_t gid); } 124 NOARGS { pid_t|sys||getsid(pid_t pid); } 125 UNIMPL capget 126 UNIMPL capset 127 STD { int|linux_sys||rt_sigpending( \ linux_sigset_t *set, \ size_t sigsetsize); } 128 STD { int|linux_sys||rt_sigtimedwait( \ const linux_sigset_t *set, \ linux_siginfo_t *info, \ const struct linux_timespec *timeout); } 129 STD { int|linux_sys||rt_queueinfo(int pid, int signum, \ linux_siginfo_t *uinfo); } 130 STD { int|linux_sys||rt_sigsuspend(linux_sigset_t *unewset, \ size_t sigsetsize); } 131 STD { int|linux_sys||sigaltstack( \ const struct linux_sigaltstack *ss, \ struct linux_sigaltstack *oss); } 132 STD { int|linux_sys||utime(const char *path, \ struct linux_utimbuf *times); } 133 STD { int|linux_sys||mknod(const char *path, linux_umode_t mode, \ unsigned dev); } #ifdef EXEC_AOUT 134 STD { int|linux_sys||uselib(const char *path); } #else 134 UNIMPL sys_uselib #endif 135 STD { int|linux_sys||personality(unsigned long per); } 136 UNIMPL ustat 137 STD { int|linux_sys||statfs(const char *path, \ struct linux_statfs *sp); } 138 STD { int|linux_sys||fstatfs(int fd, \ struct linux_statfs *sp); } 139 UNIMPL sysfs 140 STD { int|linux_sys||getpriority(int which, int who); } 141 NOARGS { int|sys||setpriority(int which, int who, int prio); } 142 STD { int|linux_sys||sched_setparam(pid_t pid, \ const struct linux_sched_param *sp); } 143 STD { int|linux_sys||sched_getparam(pid_t pid, \ struct linux_sched_param *sp); } 144 STD { int|linux_sys||sched_setscheduler(pid_t pid, \ int policy, const struct linux_sched_param *sp); } 145 STD { int|linux_sys||sched_getscheduler(pid_t pid); } 146 STD { int|linux_sys||sched_get_priority_max(int policy); } 147 STD { int|linux_sys||sched_get_priority_min(int policy); } 148 UNIMPL sys_sched_rr_get_interval 149 NOARGS { int|sys||mlock(void *addr, size_t len); } 150 NOARGS { int|sys||munlock(void *addr, size_t len); } 151 NOARGS { int|sys||mlockall(int flags); } 152 NOARGS { int|sys||munlockall(void); } 153 UNIMPL vhangup 154 STD { int|linux_sys||modify_ldt(int func, void *ptr, \ size_t bytecount); } 155 UNIMPL pivot_root 156 STD { int|linux_sys||__sysctl(struct linux___sysctl *lsp); } 157 UNIMPL prctl 158 STD { int|linux_sys||arch_prctl(int code, \ unsigned long addr); } 159 UNIMPL adjtimex 160 STD { int|linux_sys||setrlimit(u_int which, \ struct rlimit *rlp); } 161 NOARGS { int|sys||chroot(char *path); } 162 NOARGS { int|sys||sync(void); } 163 NOARGS { int|sys||acct(char *path); } 164 STD { int|linux_sys||settimeofday(struct timeval50 *tp, \ struct timezone *tzp); } 165 UNIMPL mount 166 UNIMPL umount2 167 STD { int|linux_sys||swapon(char *name); } 168 STD { int|linux_sys||swapoff(const char *path); } 169 STD { int|linux_sys||reboot(int magic1, int magic2, \ int cmd, void *arg); } 170 NOARGS { int|compat_43_sys||sethostname(char *hostname, \ u_int len);} 171 STD { int|linux_sys||setdomainname(char *domainname, \ int len); } 172 STD { int|linux_sys||iopl(int level); } 173 STD { int|linux_sys||ioperm(unsigned int lo, \ unsigned int hi, int val); } 174 UNIMPL create_module 175 UNIMPL init_module 176 UNIMPL delete_module 177 UNIMPL get_kernel_syms 178 UNIMPL query_module 179 UNIMPL quotactl 180 UNIMPL nfsservctl 181 UNIMPL getpmsg 182 UNIMPL putpmsg 183 UNIMPL afs_syscall 184 UNIMPL tuxcall 185 UNIMPL security 186 STD { pid_t|linux_sys||gettid(void); } 187 STD { ssize_t|linux_sys||readahead(int fd, off_t offset, \ size_t count); } 188 STD { int|linux_sys||setxattr(char *path, char *name, \ void *value, size_t size, int flags); } 189 STD { int|linux_sys||lsetxattr(char *path, char *name, \ void *value, size_t size, int flags); } 190 STD { int|linux_sys||fsetxattr(int fd, char *name, \ void *value, size_t size, int flags); } 191 STD { ssize_t|linux_sys||getxattr(char *path, char *name, \ void *value, size_t size); } 192 STD { ssize_t|linux_sys||lgetxattr(char *path, char *name, \ void *value, size_t size); } 193 STD { ssize_t|linux_sys||fgetxattr(int fd, char *name, \ void *value, size_t size); } 194 STD { ssize_t|linux_sys||listxattr(char *path, char *list, \ size_t size); } 195 STD { ssize_t|linux_sys||llistxattr(char *path, char *list, \ size_t size); } 196 STD { ssize_t|linux_sys||flistxattr(int fd, char *list, \ size_t size); } 197 STD { int|linux_sys||removexattr(char *path, char *name); } 198 STD { int|linux_sys||lremovexattr(char *path, char *name); } 199 STD { int|linux_sys||fremovexattr(int fd, char *name); } 200 STD { int|linux_sys||tkill(int tid, int sig); } 201 STD { int|linux_sys||time(linux_time_t *t); } 202 STD { int|linux_sys||futex(int *uaddr, int op, int val, \ const struct linux_timespec *timeout, int *uaddr2, \ int val3); } 203 STD { int|linux_sys||sched_setaffinity(pid_t pid, \ unsigned int len, unsigned long *mask); } 204 STD { int|linux_sys||sched_getaffinity(pid_t pid, \ unsigned int len, unsigned long *mask); } 205 UNIMPL set_thread_area 206 UNIMPL io_setup 207 UNIMPL io_destroy 208 UNIMPL io_getevents 209 UNIMPL io_submit 210 UNIMPL io_cancel 211 UNIMPL get_thread_area 212 UNIMPL lookup_dcookie 213 STD { int|linux_sys||epoll_create(int size); } 214 UNIMPL epoll_ctl_old 215 UNIMPL epoll_wait_old 216 UNIMPL remap_file_pages 217 STD { int|linux_sys||getdents64(int fd, \ struct linux_dirent64 *dent, unsigned int count); } 218 STD { int|linux_sys||set_tid_address(int *tid); } 219 UNIMPL restart_syscall 220 UNIMPL semtimedop 221 STD { int|linux_sys||fadvise64(int fd, off_t offset, \ size_t len, int advice); } 222 STD { int|linux_sys||timer_create(clockid_t clockid, \ struct linux_sigevent *evp, timer_t *timerid); } 223 STD { int|linux_sys||timer_settime(timer_t timerid, \ int flags, const struct linux_itimerspec *tim, \ struct linux_itimerspec *otim); } 224 STD { int|linux_sys||timer_gettime(timer_t timerid, \ struct linux_itimerspec *tim); } 225 NOARGS { int|sys||timer_getoverrun(timer_t timerid); } 226 NOARGS { int|sys||timer_delete(timer_t timerid); } 227 STD { int|linux_sys||clock_settime(clockid_t which, \ struct linux_timespec *tp); } 228 STD { int|linux_sys||clock_gettime(clockid_t which, \ struct linux_timespec *tp); } 229 STD { int|linux_sys||clock_getres(clockid_t which, \ struct linux_timespec *tp); } 230 STD { int|linux_sys||clock_nanosleep(clockid_t which, \ int flags, struct linux_timespec *rqtp, \ struct linux_timespec *rmtp); } 231 STD { int|linux_sys||exit_group(int error_code); } 232 STD { int|linux_sys||epoll_wait(int epfd, \ struct linux_epoll_event *events, int maxevents, \ int timeout); } 233 STD { int|linux_sys||epoll_ctl(int epfd, int op, int fd, \ struct linux_epoll_event *event); } 234 STD { int|linux_sys||tgkill(int tgid, int tid, int sig); } 235 NOARGS { int|compat_50_sys||utimes(const char *path, \ const struct timeval50 *tptr); } 236 UNIMPL vserver 237 UNIMPL mbind 238 UNIMPL set_mempolicy 239 UNIMPL get_mempolicy 240 UNIMPL mq_open 241 UNIMPL mq_unlink 242 UNIMPL mq_timedsend 243 UNIMPL mq_timedreceive 244 UNIMPL mq_notify 245 UNIMPL mq_getsetattr 246 UNIMPL kexec_load 247 STD { int|linux_sys||waitid(int idtype, id_t id, \ linux_siginfo_t *infop, int options, \ struct rusage50 *rusage); } 248 UNIMPL add_key 249 UNIMPL request_key 250 UNIMPL keyctl 251 UNIMPL ioprio_set 252 UNIMPL ioprio_get 253 STD { int|linux_sys||inotify_init(void); } 254 STD { int|linux_sys||inotify_add_watch(int fd, \ const char *pathname, uint32_t mask); } 255 STD { int|linux_sys||inotify_rm_watch(int fd, int wd); } 256 UNIMPL migrate_pages 257 STD { int|linux_sys||openat(int fd, const char *path, \ int flags, ... linux_umode_t mode); } 258 NOARGS { int|sys||mkdirat(int fd, const char *path, \ linux_umode_t mode); } 259 STD { int|linux_sys||mknodat(int fd, const char *path, \ linux_umode_t mode, unsigned dev); } 260 STD { int|linux_sys||fchownat(int fd, const char *path, \ uid_t owner, gid_t group, int flag); } 261 UNIMPL futimesat 262 STD { int|linux_sys||fstatat64(int fd, const char *path, \ struct linux_stat *sp, int flag); } 263 STD { int|linux_sys||unlinkat(int fd, const char *path, \ int flag); } 264 NOARGS { int|sys||renameat(int fromfd, const char *from, \ int tofd, const char *to); } 265 STD { int|linux_sys||linkat(int fd1, const char *name1, \ int fd2, const char *name2, int flags); } 266 NOARGS { int|sys||symlinkat(const char *path1, int fd, \ const char *path2); } 267 NOARGS { ssize_t|sys||readlinkat(int fd, const char *path, \ char *buf, size_t bufsize); } 268 STD { int|linux_sys||fchmodat(int fd, const char *path, \ linux_umode_t mode); } 269 STD { int|linux_sys||faccessat(int fd, const char *path, \ int amode); } 270 STD { int|linux_sys||pselect6(int nfds, fd_set *readfds, \ fd_set *writefds, fd_set *exceptfds, \ struct linux_timespec *timeout, \ linux_sized_sigset_t *ss); } 271 STD { int|linux_sys||ppoll(struct pollfd *fds, u_int nfds, \ struct linux_timespec *timeout, \ linux_sigset_t *sigset); } 272 UNIMPL unshare ; ; The NetBSD native robust list calls have different ; argument names / types, but they are ABI-compatible ; with Linux. ; 273 NOARGS { int|sys||__futex_set_robust_list(void *head, \ size_t len); } 274 NOARGS { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ void **headp, size_t *lenp); } 275 UNIMPL splice 276 UNIMPL tee 277 UNIMPL sync_file_range 278 UNIMPL vmsplice 279 UNIMPL move_pages 280 STD { int|linux_sys||utimensat(int fd, const char *path, \ struct linux_timespec *times, int flag); } 281 STD { int|linux_sys||epoll_pwait(int epfd, \ struct linux_epoll_event *events, int maxevents, \ int timeout, const linux_sigset_t *sigmask); } 282 UNIMPL signalfd 283 STD { int|linux_sys||timerfd_create(clockid_t clock_id, \ int flags); } 284 STD { int|linux_sys||eventfd(unsigned int initval); } 285 STD { int|linux_sys||fallocate(int fd, int mode, \ off_t offset, off_t len); } 286 STD { int|linux_sys||timerfd_settime(int fd, int flags, \ const struct linux_itimerspec *tim, \ struct linux_itimerspec *otim); } 287 STD { int|linux_sys||timerfd_gettime(int fd, \ struct linux_itimerspec *tim); } 288 STD { int|linux_sys||accept4(int s, \ struct osockaddr *name, \ int *anamelen, int flags); } 289 UNIMPL signalfd4 290 STD { int|linux_sys||eventfd2(unsigned int initval, \ int flags); } 291 STD { int|linux_sys||epoll_create1(int flags); } 292 STD { int|linux_sys||dup3(int from, int to, int flags); } 293 STD { int|linux_sys||pipe2(int *pfds, int flags); } 294 STD { int|linux_sys||inotify_init1(int flags); } 295 STD { int|linux_sys||preadv(int fd, \ const struct iovec *iovp, int iovcnt, \ unsigned long off_lo, unsigned long off_hi); } 296 STD { int|linux_sys||pwritev(int fd, \ const struct iovcnt *iovp, int iovcnt, \ unsigned long off_lo, unsigned long off_hi); } 297 UNIMPL rt_tgsigqueueinfo 298 UNIMPL perf_counter_open 299 STD { int|linux_sys||recvmmsg(int s, \ struct linux_mmsghdr *msgvec, unsigned int vlen, \ unsigned int flags, struct timespec *timeout); } 300 UNIMPL fanotify_init 301 UNIMPL fanotify_mark 302 STD { int|linux_sys||prlimit64(pid_t pid, int which, \ struct rlimit *new_rlp, struct rlimit *old_rlp); } 303 UNIMPL name_to_handle_at 304 UNIMPL open_by_handle_at 305 UNIMPL clock_adjtime 306 UNIMPL syncfs 307 STD { int|linux_sys||sendmmsg(int s, \ struct linux_mmsghdr *msgvec, unsigned int vlen, \ unsigned int flags); } 308 UNIMPL setns 309 UNIMPL getcpu 310 UNIMPL process_vm_readv 311 UNIMPL process_vm_writev 312 UNIMPL kcmp 313 UNIMPL finit_module 314 UNIMPL sched_setattr 315 UNIMPL sched_getattr 316 UNIMPL renameat2 317 UNIMPL seccomp 318 NOARGS { ssize_t|sys||getrandom(void *buf, size_t buflen, \ unsigned int flags); } 319 STD { int|linux_sys||memfd_create(const char *name, \ unsigned int flags); } 320 UNIMPL kexec_file_load 321 UNIMPL bpf 322 UNIMPL execveat 323 UNIMPL userfaultfd 324 UNIMPL membarrier 325 UNIMPL mlock2 326 UNIMPL copy_file_range 327 UNIMPL preadv2 328 UNIMPL pwritev2 329 UNIMPL pkey_mprotect 330 UNIMPL pkey_alloc 331 UNIMPL pkey_free 332 STD { int|linux_sys||statx(int fd, const char *path, \ int flag, unsigned int mask, \ struct linux_statx *sp); } 333 UNIMPL io_pgetevents 334 UNIMPL rseq 335 UNIMPL 336 UNIMPL 337 UNIMPL 338 UNIMPL 339 UNIMPL 340 UNIMPL 341 UNIMPL 342 UNIMPL 343 UNIMPL 344 UNIMPL 345 UNIMPL 346 UNIMPL 347 UNIMPL 348 UNIMPL 349 UNIMPL 350 UNIMPL 351 UNIMPL 352 UNIMPL 353 UNIMPL 354 UNIMPL 355 UNIMPL 356 UNIMPL 357 UNIMPL 358 UNIMPL 359 UNIMPL 360 UNIMPL 361 UNIMPL 362 UNIMPL 363 UNIMPL 364 UNIMPL 365 UNIMPL 366 UNIMPL 367 UNIMPL 368 UNIMPL 369 UNIMPL 370 UNIMPL 371 UNIMPL 372 UNIMPL 373 UNIMPL 374 UNIMPL 375 UNIMPL 376 UNIMPL 377 UNIMPL 378 UNIMPL 379 UNIMPL 380 UNIMPL 381 UNIMPL 382 UNIMPL 383 UNIMPL 384 UNIMPL 385 UNIMPL 386 UNIMPL 387 UNIMPL 388 UNIMPL 389 UNIMPL 390 UNIMPL 391 UNIMPL 392 UNIMPL 393 UNIMPL 394 UNIMPL 395 UNIMPL 396 UNIMPL 397 UNIMPL 398 UNIMPL 399 UNIMPL 400 UNIMPL 401 UNIMPL 402 UNIMPL 403 UNIMPL 404 UNIMPL 405 UNIMPL 406 UNIMPL 407 UNIMPL 408 UNIMPL 409 UNIMPL 410 UNIMPL 411 UNIMPL 412 UNIMPL 413 UNIMPL 414 UNIMPL 415 UNIMPL 416 UNIMPL 417 UNIMPL 418 UNIMPL 419 UNIMPL 420 UNIMPL 421 UNIMPL 422 UNIMPL 423 UNIMPL 424 UNIMPL pidfd_send_signal 425 UNIMPL io_uring_setup 426 UNIMPL io_uring_enter 427 UNIMPL io_uring_register 428 UNIMPL open_tree 429 UNIMPL move_mount 430 UNIMPL fsopen 431 UNIMPL fsconfig 432 UNIMPL fsmount 433 UNIMPL fspick 434 UNIMPL pidfd_open 435 UNIMPL clone3 436 STD { int|linux_sys||close_range(unsigned int first, \ unsigned int last, unsigned int flags); } 437 UNIMPL openat2 438 UNIMPL pidfd_getfd 439 UNIMPL faccessat2 440 UNIMPL process_madvise 441 STD { int|linux_sys||epoll_pwait2(int epfd, \ struct linux_epoll_event *events, int maxevents, \ const struct linux_timespec *timeout, \ const linux_sigset_t *sigmask); } 442 UNIMPL mount_setattr 443 UNIMPL quotactl_fd 444 UNIMPL landlock_create_ruleset 445 UNIMPL landlock_add_rule 446 UNIMPL landlock_restrict_self 447 UNIMPL memfd_secret 448 UNIMPL process_mrelease 449 UNIMPL futex_waitv 450 UNIMPL set_mempolicy_home_node ; we want a "nosys" syscall, we'll just add an extra entry for it. 451 STD { int|linux_sys||nosys(void); }