syscalls.master revision 1.10
1 $NetBSD: syscalls.master,v 1.10 2023/08/18 19:41:19 christos Exp $ 2 3 ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 4 5 ; Derived from sys/compat/linux/arch/*/syscalls.master 6 ; and from Linux include/uapi/asm-generic/unistd.h 7 8 ; NetBSD aarch64 COMPAT_LINUX system call name/number "master" file. 9 ; (See syscalls.conf to see what it is processed into.) 10 ; 11 ; Fields: number type [type-dependent ...] 12 ; number system call number, must be in order 13 ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of 14 ; the compatibility options defined in syscalls.conf. 15 ; 16 ; types: 17 ; STD always included 18 ; OBSOL obsolete, not included in system 19 ; UNIMPL unimplemented, not included in system 20 ; NODEF included, but don't define the syscall number 21 ; NOARGS included, but don't define the syscall args structure 22 ; INDIR included, but don't define the syscall args structure 23 ; and allow it to be "really" varargs. 24 ; 25 ; The compat options are defined in the syscalls.conf file, and the 26 ; compat option name is prefixed to the syscall name. Other than 27 ; that, they're like NODEF (for 'compat' options), or STD (for 28 ; 'libcompat' options). 29 ; 30 ; The type-dependent arguments are as follows: 31 ; For STD, NODEF, NOARGS, and compat syscalls: 32 ; { pseudo-proto } [alias] 33 ; For other syscalls: 34 ; [comment] 35 ; 36 ; #ifdef's, etc. may be included, and are copied to the output files. 37 ; #include's are copied to the syscall names and switch definition files only. 38 39 #if defined(_KERNEL_OPT) 40 #include "opt_sysv.h" 41 #include "opt_compat_43.h" 42 #include "opt_compat_netbsd.h" 43 #endif 44 45 #include <sys/param.h> 46 #include <sys/poll.h> 47 #include <sys/systm.h> 48 #include <sys/signal.h> 49 #include <sys/mount.h> 50 #include <sys/syscallargs.h> 51 #include <sys/time.h> 52 53 #include <compat/sys/time.h> 54 55 #include <compat/linux/common/linux_types.h> 56 #include <compat/linux/common/linux_ipc.h> 57 #include <compat/linux/common/linux_machdep.h> 58 #include <compat/linux/common/linux_misc.h> 59 #include <compat/linux/common/linux_mmap.h> 60 #include <compat/linux/common/linux_msg.h> 61 #include <compat/linux/common/linux_sem.h> 62 #include <compat/linux/common/linux_shm.h> 63 #include <compat/linux/common/linux_siginfo.h> 64 #include <compat/linux/common/linux_signal.h> 65 66 #include <compat/linux/linux_syscallargs.h> 67 68 %% 69 70 0 UNIMPL io_setup 71 1 UNIMPL io_destroy 72 2 UNIMPL io_submit 73 3 UNIMPL io_cancel 74 4 UNIMPL io_getevents 75 5 STD { int|linux_sys||setxattr(char *path, char *name, \ 76 void *value, size_t size, int flags); } 77 6 STD { int|linux_sys||lsetxattr(char *path, char *name, \ 78 void *value, size_t size, int flags); } 79 7 STD { int|linux_sys||fsetxattr(int fd, char *name, \ 80 void *value, size_t size, int flags); } 81 8 STD { ssize_t|linux_sys||getxattr(char *path, char *name, \ 82 void *value, size_t size); } 83 9 STD { ssize_t|linux_sys||lgetxattr(char *path, char *name, \ 84 void *value, size_t size); } 85 10 STD { ssize_t|linux_sys||fgetxattr(int fd, char *name, \ 86 void *value, size_t size); } 87 11 STD { ssize_t|linux_sys||listxattr(char *path, char *list, \ 88 size_t size); } 89 12 STD { ssize_t|linux_sys||llistxattr(char *path, char *list, \ 90 size_t size); } 91 13 STD { ssize_t|linux_sys||flistxattr(int fd, char *list, \ 92 size_t size); } 93 14 STD { int|linux_sys||removexattr(char *path, char *name); } 94 15 STD { int|linux_sys||lremovexattr(char *path, char *name); } 95 16 STD { int|linux_sys||fremovexattr(int fd, char *name); } 96 17 NOARGS { int|sys||__getcwd(char *bufp, size_t length); } 97 18 UNIMPL lookup_dcookie 98 19 STD { int|linux_sys||eventfd2(unsigned int initval, \ 99 int flags); } 100 20 STD { int|linux_sys||epoll_create1(int flags); } 101 21 STD { int|linux_sys||epoll_ctl(int epfd, int op, int fd, \ 102 struct linux_epoll_event *event); } 103 22 STD { int|linux_sys||epoll_pwait(int epfd, \ 104 struct linux_epoll_event *events, int maxevents, \ 105 int timeout, const linux_sigset_t *sigmask); } 106 23 NOARGS { int|sys||dup(int fd); } 107 24 STD { int|linux_sys||dup3(int from, int to, int flags); } 108 25 STD { int|linux_sys||fcntl(int fd, int cmd, void *arg); } 109 26 UNIMPL inotify_init1 110 27 UNIMPL inotify_add_watch 111 28 UNIMPL inotify_rm_watch 112 29 STD { int|linux_sys||ioctl(int fd, u_long com, \ 113 void *data); } 114 30 UNIMPL ioprio_set 115 31 UNIMPL ioprio_get 116 32 NOARGS { int|sys||flock(int fd, int how); } 117 33 STD { int|linux_sys||mknodat(int fd, const char *path, \ 118 linux_umode_t mode, unsigned dev); } 119 34 NOARGS { int|sys||mkdirat(int fd, const char *path, \ 120 linux_umode_t mode); } 121 35 STD { int|linux_sys||unlinkat(int fd, const char *path, \ 122 int flag); } 123 36 NOARGS { int|sys||symlinkat(const char *path1, int fd, \ 124 const char *path2); } 125 37 STD { int|linux_sys||linkat(int fd1, const char *name1, \ 126 int fd2, const char *name2, int flags); } 127 38 NOARGS { int|sys||renameat(int fromfd, const char *from, \ 128 int tofd, const char *to); } 129 39 UNIMPL umount2 130 40 UNIMPL mount 131 41 UNIMPL pivot_root 132 42 UNIMPL nfsservctl 133 43 STD { int|linux_sys||statfs(const char *path, \ 134 struct linux_statfs *sp); } 135 44 STD { int|linux_sys||fstatfs(int fd, \ 136 struct linux_statfs *sp); } 137 45 STD { int|linux_sys||truncate64(const char *path, \ 138 off_t length); } 139 46 STD { int|linux_sys||ftruncate64(unsigned int fd, \ 140 off_t length); } 141 47 STD { int|linux_sys||fallocate(int fd, int mode, \ 142 off_t offset, off_t len); } 143 48 STD { int|linux_sys||faccessat(int fd, const char *path, \ 144 int amode); } 145 49 NOARGS { int|sys||chdir(const char *path); } 146 50 NOARGS { int|sys||fchdir(int fd); } 147 51 NOARGS { int|sys||chroot(char *path); } 148 52 NOARGS { int|sys||fchmod(int fd, linux_umode_t mode); } 149 53 STD { int|linux_sys||fchmodat(int fd, const char *path, \ 150 linux_umode_t mode); } 151 54 STD { int|linux_sys||fchownat(int fd, const char *path, \ 152 uid_t owner, gid_t group, int flag); } 153 55 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \ 154 gid_t gid); } 155 56 STD { int|linux_sys||openat(int fd, const char *path, \ 156 int flags, ... linux_umode_t mode); } 157 57 NOARGS { int|sys||close(int fd); } 158 58 UNIMPL vhangup 159 59 STD { int|linux_sys||pipe2(int *pfds, int flags); } 160 60 UNIMPL quotactl 161 61 STD { int|linux_sys||getdents64(int fd, \ 162 struct linux_dirent64 *dent, unsigned int count); } 163 62 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \ 164 int whence); } 165 63 NOARGS { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } 166 64 NOARGS { ssize_t|sys||write(int fd, const void *buf, \ 167 size_t nbyte); } 168 65 NOARGS { ssize_t|sys||readv(int fd, \ 169 const struct iovec *iovp, int iovcnt); } 170 66 NOARGS { ssize_t|sys||writev(int fd, \ 171 const struct iovec *iovp, int iovcnt); } 172 67 STD { int|linux_sys||pread(int fd, char *buf, \ 173 size_t nbyte, off_t offset); } 174 68 STD { int|linux_sys||pwrite(int fd, char *buf, \ 175 size_t nbyte, off_t offset); } 176 69 STD { int|linux_sys||preadv(int fd, \ 177 const struct iovec *iovp, int iovcnt, \ 178 unsigned long off_lo, unsigned long off_hi); } 179 70 STD { int|linux_sys||pwritev(int fd, \ 180 const struct iovcnt *iovp, int iovcnt, \ 181 unsigned long off_lo, unsigned long off_hi); } 182 71 UNIMPL sendfile 183 72 STD { int|linux_sys||pselect6(int nfds, fd_set *readfds, \ 184 fd_set *writefds, fd_set *exceptfds, \ 185 struct linux_timespec *timeout, \ 186 linux_sized_sigset_t *ss); } 187 73 STD { int|linux_sys||ppoll(struct pollfd *fds, u_int nfds, \ 188 struct linux_timespec *timeout, \ 189 linux_sigset_t *sigset); } 190 74 UNIMPL signalfd4 191 75 UNIMPL vmsplice 192 76 UNIMPL splice 193 77 UNIMPL tee 194 78 NOARGS { ssize_t|sys||readlinkat(int fd, const char *path, \ 195 char *buf, size_t bufsize); } 196 79 STD { int|linux_sys||fstatat64(int fd, const char *path, \ 197 struct linux_stat *sp, int flag); } 198 80 STD { int|linux_sys||fstat64(int fd, \ 199 struct linux_stat *sp); } 200 81 NOARGS { int|sys||sync(void); } 201 82 NOARGS { int|sys||fsync(int fd); } 202 83 STD { int|linux_sys||fdatasync(int fd); } 203 84 UNIMPL sync_file_range 204 85 STD { int|linux_sys||timerfd_create(clockid_t clock_id, \ 205 int flags); } 206 86 STD { int|linux_sys||timerfd_settime(int fd, int flags, \ 207 const struct linux_itimerspec *tim, \ 208 struct linux_itimerspec *otim); } 209 87 STD { int|linux_sys||timerfd_gettime(int fd, \ 210 struct linux_itimerspec *tim); } 211 88 STD { int|linux_sys||utimensat(int fd, const char *path, \ 212 struct linux_timespec *times, int flag); } 213 89 NOARGS { int|sys||acct(char *path); } 214 90 UNIMPL capget 215 91 UNIMPL capset 216 92 STD { int|linux_sys||personality(unsigned long per); } 217 93 STD { int|linux_sys||exit(int rval); } 218 94 STD { int|linux_sys||exit_group(int error_code); } 219 95 STD { int|linux_sys||waitid(int idtype, id_t id, \ 220 linux_siginfo_t *infop, int options, \ 221 struct rusage50 *rusage); } 222 96 STD { int|linux_sys||set_tid_address(int *tid); } 223 97 UNIMPL unshare 224 98 STD { int|linux_sys||futex(int *uaddr, int op, int val, \ 225 const struct linux_timespec *timeout, int *uaddr2, \ 226 int val3); } 227 ; 228 ; The NetBSD native robust list calls have different 229 ; argument names / types, but they are ABI-compatible 230 ; with Linux. 231 ; 232 99 NOARGS { int|sys||__futex_set_robust_list(void *head, \ 233 size_t len); } 234 100 NOARGS { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ 235 void **headp, size_t *lenp); } 236 101 STD { int|linux_sys||nanosleep( \ 237 const struct linux_timespec *rqtp, \ 238 struct linux_timespec *rmtp); } 239 102 NOARGS { int|compat_50_sys||getitimer(int which, \ 240 struct itimerval50 *itv); } 241 103 NOARGS { int|compat_50_sys||setitimer(int which, \ 242 struct itimerval50 *itv, \ 243 struct itimerval50 *oitv); } 244 104 UNIMPL kexec_load 245 105 UNIMPL init_module 246 106 UNIMPL delete_module 247 107 STD { int|linux_sys||timer_create(clockid_t clockid, \ 248 struct linux_sigevent *evp, timer_t *timerid); } 249 108 STD { int|linux_sys||timer_gettime(timer_t timerid, \ 250 struct linux_itimerspec *tim); } 251 109 NOARGS { int|sys||timer_getoverrun(timer_t timerid); } 252 110 STD { int|linux_sys||timer_settime(timer_t timerid, \ 253 int flags, const struct linux_itimerspec *tim, \ 254 struct linux_itimerspec *otim); } 255 111 NOARGS { int|sys||timer_delete(timer_t timerid); } 256 112 STD { int|linux_sys||clock_settime(clockid_t which, \ 257 struct linux_timespec *tp); } 258 113 STD { int|linux_sys||clock_gettime(clockid_t which, \ 259 struct linux_timespec *tp); } 260 114 STD { int|linux_sys||clock_getres(clockid_t which, \ 261 struct linux_timespec *tp); } 262 115 STD { int|linux_sys||clock_nanosleep(clockid_t which, \ 263 int flags, struct linux_timespec *rqtp, \ 264 struct linux_timespec *rmtp); } 265 116 UNIMPL syslog 266 117 STD { int|linux_sys||ptrace(long request, long pid, \ 267 long addr, long data); } 268 118 STD { int|linux_sys||sched_setparam(pid_t pid, \ 269 const struct linux_sched_param *sp); } 270 119 STD { int|linux_sys||sched_setscheduler(pid_t pid, \ 271 int policy, const struct linux_sched_param *sp); } 272 120 STD { int|linux_sys||sched_getscheduler(pid_t pid); } 273 121 STD { int|linux_sys||sched_getparam(pid_t pid, \ 274 struct linux_sched_param *sp); } 275 122 STD { int|linux_sys||sched_setaffinity(pid_t pid, \ 276 unsigned int len, unsigned long *mask); } 277 123 STD { int|linux_sys||sched_getaffinity(pid_t pid, \ 278 unsigned int len, unsigned long *mask); } 279 124 STD { int|linux_sys||sched_yield(void); } 280 125 STD { int|linux_sys||sched_get_priority_max(int policy); } 281 126 STD { int|linux_sys||sched_get_priority_min(int policy); } 282 127 UNIMPL sys_sched_rr_get_interval 283 128 UNIMPL restart_syscall 284 129 STD { int|linux_sys||kill(int pid, int signum); } 285 130 STD { int|linux_sys||tkill(int tid, int sig); } 286 131 STD { int|linux_sys||tgkill(int tgid, int tid, int sig); } 287 132 STD { int|linux_sys||sigaltstack( \ 288 const struct linux_sigaltstack *ss, \ 289 struct linux_sigaltstack *oss); } 290 133 STD { int|linux_sys||rt_sigsuspend(linux_sigset_t *unewset, \ 291 size_t sigsetsize); } 292 134 STD { int|linux_sys||rt_sigaction(int signum, \ 293 const struct linux_sigaction *nsa, \ 294 struct linux_sigaction *osa, \ 295 size_t sigsetsize); } 296 135 STD { int|linux_sys||rt_sigprocmask(int how, \ 297 const linux_sigset_t *set, \ 298 linux_sigset_t *oset, \ 299 size_t sigsetsize); } 300 136 STD { int|linux_sys||rt_sigpending( \ 301 linux_sigset_t *set, \ 302 size_t sigsetsize); } 303 137 STD { int|linux_sys||rt_sigtimedwait( \ 304 const linux_sigset_t *set, \ 305 linux_siginfo_t *info, \ 306 const struct linux_timespec *timeout); } 307 138 UNIMPL rt_sigqueueinfo 308 139 NOARGS { int|linux_sys||rt_sigreturn(void); } 309 140 NOARGS { int|sys||setpriority(int which, int who, int prio); } 310 141 STD { int|linux_sys||getpriority(int which, int who); } 311 142 STD { int|linux_sys||reboot(int magic1, int magic2, \ 312 int cmd, void *arg); } 313 143 NOARGS { int|sys||setregid(gid_t rgid, gid_t egid); } 314 144 NOARGS { int|sys||setgid(gid_t gid); } 315 145 NOARGS { int|sys||setreuid(uid_t ruid, uid_t euid); } 316 146 NOARGS { int|sys||setuid(uid_t uid); } 317 147 STD { int|linux_sys||setresuid(uid_t ruid, uid_t euid, \ 318 uid_t suid); } 319 148 STD { int|linux_sys||getresuid(uid_t *ruid, uid_t *euid, \ 320 uid_t *suid); } 321 149 STD { int|linux_sys||setresgid(gid_t rgid, gid_t egid, \ 322 gid_t sgid); } 323 150 STD { int|linux_sys||getresgid(gid_t *rgid, gid_t *egid, \ 324 gid_t *sgid); } 325 151 STD { int|linux_sys||setfsuid(uid_t uid); } 326 152 STD { int|linux_sys||setfsgid(gid_t gid); } 327 153 STD { int|linux_sys||times(struct times *tms); } 328 154 NOARGS { int|sys||setpgid(int pid, int pgid); } 329 155 NOARGS { pid_t|sys||getpgid(pid_t pid); } 330 156 NOARGS { pid_t|sys||getsid(pid_t pid); } 331 157 NOARGS { int|sys||setsid(void); } 332 158 NOARGS { int|sys||getgroups(int gidsetsize, gid_t *gidset); } 333 159 NOARGS { int|sys||setgroups(int gidsetsize, gid_t *gidset); } 334 160 STD { int|linux_sys||uname(struct linux_utsname *up); } 335 161 NOARGS { int|compat_43_sys||sethostname(char *hostname, \ 336 u_int len);} 337 162 STD { int|linux_sys||setdomainname(char *domainname, \ 338 int len); } 339 163 STD { int|linux_sys||getrlimit(int which, \ 340 struct rlimit *rlp); } 341 164 STD { int|linux_sys||setrlimit(u_int which, \ 342 struct rlimit *rlp); } 343 165 NOARGS { int|compat_50_sys||getrusage(int who, \ 344 struct rusage50 *rusage); } 345 166 NOARGS { int|sys||umask(int newmask); } 346 167 UNIMPL prctl 347 168 UNIMPL getcpu 348 169 STD { int|linux_sys||gettimeofday(struct timeval50 *tp, \ 349 struct timezone *tzp); } 350 170 STD { int|linux_sys||settimeofday(struct timeval50 *tp, \ 351 struct timezone *tzp); } 352 171 UNIMPL adjtimex 353 172 STD { pid_t|sys||getpid(void); } 354 173 STD { pid_t|sys||getppid(void); } 355 174 NOARGS { uid_t|sys||getuid(void); } 356 175 NOARGS { uid_t|sys||geteuid(void); } 357 176 NOARGS { gid_t|sys||getgid(void); } 358 177 NOARGS { gid_t|sys||getegid(void); } 359 178 STD { pid_t|linux_sys||gettid(void); } 360 179 STD { int|linux_sys||sysinfo(struct linux_sysinfo *arg); } 361 180 UNIMPL mq_open 362 181 UNIMPL mq_unlink 363 182 UNIMPL mq_timedsend 364 183 UNIMPL mq_timedreceive 365 184 UNIMPL mq_notify 366 185 UNIMPL mq_getsetattr 367 #ifdef SYSVMSG 368 186 NOARGS { int|sys||msgget(key_t key, int msgflg); } 369 187 NOARGS { int|linux_sys||msgctl(int msqid, int cmd, \ 370 struct linux_msqid_ds *buf); } 371 188 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 372 size_t msgsz, long msgtyp, int msgflg); } 373 189 NOARGS { int|sys||msgsnd(int msqid, void *msgp, size_t msgsz, \ 374 int msgflg); } 375 #else 376 186 UNIMPL msgget 377 187 UNIMPL msgctl 378 188 UNIMPL msgrcv 379 189 UNIMPL msgsnd 380 #endif 381 #ifdef SYSVSEM 382 190 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 383 191 STD { int|linux_sys||semctl(int semid, int semnum, \ 384 int cmd, union linux_semun arg); } 385 192 UNIMPL semtimedop 386 193 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ 387 size_t nsops); } 388 #else 389 190 UNIMPL semget 390 191 UNIMPL semctl 391 192 UNIMPL semtimedop 392 193 UNIMPL semop 393 #endif 394 #ifdef SYSVSEM 395 194 NOARGS { int|linux_sys||shmget(key_t key, size_t size, \ 396 int shmflg); } 397 195 NOARGS { int|linux_sys||shmctl(int shmid, int cmd, \ 398 struct linux_shmid_ds *buf); } 399 196 NOARGS { int|sys||shmat(int shmid, void *shmaddr, int shmflg); } 400 197 NOARGS { int|sys||shmdt(const void *shmaddr); } 401 #else 402 194 UNIMPL shmget 403 195 UNIMPL shmctl 404 196 UNIMPL shmat 405 197 UNIMPL shmdt 406 #endif 407 198 STD { int|linux_sys||socket(int domain, \ 408 int type, int protocol); } 409 199 STD { int|linux_sys||socketpair(int domain, int type, \ 410 int protocol, int *rsv); } 411 200 STD { int|linux_sys||bind(int s, \ 412 const struct osockaddr *name, \ 413 unsigned int namelen); } 414 201 NOARGS { int|sys||listen(int s, int backlog); } 415 202 STD { int|linux_sys||accept(int s, struct osockaddr *name, \ 416 int *anamelen); } oaccept 417 203 STD { int|linux_sys||connect(int s, \ 418 const struct osockaddr *name, \ 419 unsigned int namelen); } 420 204 STD { int|linux_sys||getsockname(int fdec, void *asa, \ 421 int *alen); } 422 205 STD { int|linux_sys||getpeername(int fdes, \ 423 struct sockaddr *asa, unsigned int *alen); } 424 206 STD { ssize_t|linux_sys||sendto(int s, void *msg, int len, \ 425 int flags, struct osockaddr *to, int tolen); } 426 207 STD { ssize_t|linux_sys||recvfrom(int s, void *buf, \ 427 size_t len, int flags, struct osockaddr *from, \ 428 unsigned int *fromlenaddr); } 429 208 STD { int|linux_sys||setsockopt(int s, int level, \ 430 int optname, void *optval, int optlen); } 431 209 STD { int|linux_sys||getsockopt(int s, int level, \ 432 int optname, void *optval, int *optlen); } 433 210 NOARGS { int|sys||shutdown(int s, int how); } 434 211 STD { int|linux_sys||sendmsg(int s, \ 435 const struct linux_msghdr *msg, int flags); } 436 212 STD { ssize_t|linux_sys||recvmsg(int s, \ 437 struct linux_msghdr *msg, int flags); } 438 213 STD { ssize_t|linux_sys||readahead(int fd, off_t offset, \ 439 size_t count); } 440 214 STD { int|linux_sys||brk(char *nsize); } 441 215 NOARGS { int|sys||munmap(void *addr, size_t len); } 442 216 STD { void *|linux_sys||mremap(void *old_address, \ 443 size_t old_size, size_t new_size, u_long flags); } 444 217 UNIMPL add_key 445 218 UNIMPL request_key 446 219 UNIMPL keyctl 447 220 STD { int|linux_sys||clone(int flags, void *stack, \ 448 void *parent_tidptr, void *child_tidptr, void *tls); } 449 221 NOARGS { int|sys||execve(const char *path, char **argp, \ 450 char **envp); } 451 222 NOARGS { linux_off_t|linux_sys||mmap(unsigned long addr, \ 452 size_t len, int prot, int flags, int fd, \ 453 linux_off_t offset); } 454 223 STD { int|linux_sys||fadvise64(int fd, off_t offset, \ 455 size_t len, int advice); } 456 224 STD { int|linux_sys||swapon(char *name); } 457 225 STD { int|linux_sys||swapoff(const char *path); } 458 226 STD { int|linux_sys||mprotect(const void *start, \ 459 unsigned long len, int prot); } 460 227 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 461 228 NOARGS { int|sys||mlock(void *addr, size_t len); } 462 229 NOARGS { int|sys||munlock(void *addr, size_t len); } 463 230 NOARGS { int|sys||mlockall(int flags); } 464 231 NOARGS { int|sys||munlockall(void); } 465 232 NOARGS { int|sys||mincore(void *addr, size_t len, char *vec); } 466 233 NOARGS { int|sys||madvise(void *addr, size_t len, int behav); } 467 234 UNIMPL remap_file_pages 468 235 UNIMPL mbind 469 236 UNIMPL get_mempolicy 470 237 UNIMPL set_mempolicy 471 238 UNIMPL migrate_pages 472 239 UNIMPL move_pages 473 240 UNIMPL rt_tgsigqueueinfo 474 241 UNIMPL perf_event_open 475 242 STD { int|linux_sys||accept4(int s, \ 476 struct osockaddr *name, \ 477 int *anamelen, int flags); } 478 243 STD { int|linux_sys||recvmmsg(int s, \ 479 struct linux_mmsghdr *msgvec, unsigned int vlen, \ 480 unsigned int flags, struct timespec *timeout); } 481 244 UNIMPL arch_specific_syscall 482 245 UNIMPL 483 246 UNIMPL 484 247 UNIMPL 485 248 UNIMPL 486 249 UNIMPL 487 250 UNIMPL 488 251 UNIMPL 489 252 UNIMPL 490 253 UNIMPL 491 254 UNIMPL 492 255 UNIMPL 493 256 UNIMPL 494 257 UNIMPL 495 258 UNIMPL 496 259 UNIMPL 497 260 STD { int|linux_sys||wait4(int pid, int *status, \ 498 int options, struct rusage50 *rusage); } 499 261 STD { int|linux_sys||prlimit64(pid_t pid, int which, \ 500 struct rlimit *new_rlp, struct rlimit *old_rlp); } 501 262 UNIMPL fanotify_init 502 263 UNIMPL fanotify_mark 503 264 UNIMPL name_to_handle_at 504 265 UNIMPL open_by_handle_at 505 266 UNIMPL clock_adjtime 506 267 UNIMPL syncfs 507 268 UNIMPL setns 508 269 STD { int|linux_sys||sendmmsg(int s, \ 509 struct linux_mmsghdr *msgvec, unsigned int vlen, \ 510 unsigned int flags); } 511 270 UNIMPL process_vm_readv 512 271 UNIMPL process_vm_writev 513 272 UNIMPL kcmp 514 273 UNIMPL finit_module 515 274 UNIMPL sched_setattr 516 275 UNIMPL sched_getattr 517 276 UNIMPL renameat2 518 277 UNIMPL seccomp 519 278 NOARGS { ssize_t|sys||getrandom(void *buf, size_t buflen, \ 520 unsigned int flags); } 521 279 STD { int|linux_sys||memfd_create(const char *name, \ 522 unsigned int flags); } 523 280 UNIMPL bpf 524 281 UNIMPL execveat 525 282 UNIMPL userfaultfd 526 283 UNIMPL membarrier 527 284 UNIMPL mlock2 528 285 UNIMPL copy_file_range 529 286 UNIMPL preadv2 530 287 UNIMPL pwritev2 531 288 UNIMPL pkey_mprotect 532 289 UNIMPL pkey_alloc 533 290 UNIMPL pkey_free 534 291 STD { int|linux_sys||statx(int fd, const char *path, \ 535 int flag, unsigned int mask, \ 536 struct linux_statx *sp); } 537 292 UNIMPL io_pgetevents 538 293 UNIMPL rseq 539 294 UNIMPL kexec_file_load 540 295 UNIMPL 541 296 UNIMPL 542 297 UNIMPL 543 298 UNIMPL 544 299 UNIMPL 545 300 UNIMPL 546 301 UNIMPL 547 302 UNIMPL 548 303 UNIMPL 549 304 UNIMPL 550 305 UNIMPL 551 306 UNIMPL 552 307 UNIMPL 553 308 UNIMPL 554 309 UNIMPL 555 310 UNIMPL 556 311 UNIMPL 557 312 UNIMPL 558 313 UNIMPL 559 314 UNIMPL 560 315 UNIMPL 561 316 UNIMPL 562 317 UNIMPL 563 318 UNIMPL 564 319 UNIMPL 565 320 UNIMPL 566 321 UNIMPL 567 322 UNIMPL 568 323 UNIMPL 569 324 UNIMPL 570 325 UNIMPL 571 326 UNIMPL 572 327 UNIMPL 573 328 UNIMPL 574 329 UNIMPL 575 330 UNIMPL 576 331 UNIMPL 577 332 UNIMPL 578 333 UNIMPL 579 334 UNIMPL 580 335 UNIMPL 581 336 UNIMPL 582 337 UNIMPL 583 338 UNIMPL 584 339 UNIMPL 585 340 UNIMPL 586 341 UNIMPL 587 342 UNIMPL 588 343 UNIMPL 589 344 UNIMPL 590 345 UNIMPL 591 346 UNIMPL 592 347 UNIMPL 593 348 UNIMPL 594 349 UNIMPL 595 350 UNIMPL 596 351 UNIMPL 597 352 UNIMPL 598 353 UNIMPL 599 354 UNIMPL 600 355 UNIMPL 601 356 UNIMPL 602 357 UNIMPL 603 358 UNIMPL 604 359 UNIMPL 605 360 UNIMPL 606 361 UNIMPL 607 362 UNIMPL 608 363 UNIMPL 609 364 UNIMPL 610 365 UNIMPL 611 366 UNIMPL 612 367 UNIMPL 613 368 UNIMPL 614 369 UNIMPL 615 370 UNIMPL 616 371 UNIMPL 617 372 UNIMPL 618 373 UNIMPL 619 374 UNIMPL 620 375 UNIMPL 621 376 UNIMPL 622 377 UNIMPL 623 378 UNIMPL 624 379 UNIMPL 625 380 UNIMPL 626 381 UNIMPL 627 382 UNIMPL 628 383 UNIMPL 629 384 UNIMPL 630 385 UNIMPL 631 386 UNIMPL 632 387 UNIMPL 633 388 UNIMPL 634 389 UNIMPL 635 390 UNIMPL 636 391 UNIMPL 637 392 UNIMPL 638 393 UNIMPL 639 394 UNIMPL 640 395 UNIMPL 641 396 UNIMPL 642 397 UNIMPL 643 398 UNIMPL 644 399 UNIMPL 645 400 UNIMPL 646 401 UNIMPL 647 402 UNIMPL 648 403 UNIMPL 649 404 UNIMPL 650 405 UNIMPL 651 406 UNIMPL 652 407 UNIMPL 653 408 UNIMPL 654 409 UNIMPL 655 410 UNIMPL 656 411 UNIMPL 657 412 UNIMPL 658 413 UNIMPL 659 414 UNIMPL 660 415 UNIMPL 661 416 UNIMPL 662 417 UNIMPL 663 418 UNIMPL 664 419 UNIMPL 665 420 UNIMPL 666 421 UNIMPL 667 422 UNIMPL 668 423 UNIMPL 669 424 UNIMPL pidfd_send_signal 670 425 UNIMPL io_uring_setup 671 426 UNIMPL io_uring_enter 672 427 UNIMPL io_uring_register 673 428 UNIMPL open_tree 674 429 UNIMPL move_mount 675 430 UNIMPL fsopen 676 431 UNIMPL fsconfig 677 432 UNIMPL fsmount 678 433 UNIMPL fspick 679 434 UNIMPL pidfd_open 680 435 UNIMPL clone3 681 436 STD { int|linux_sys||close_range(unsigned int first, \ 682 unsigned int last, unsigned int flags); } 683 437 UNIMPL openat2 684 438 UNIMPL pidfd_getfd 685 439 UNIMPL faccessat2 686 687 ; we want a "nosys" syscall, we'll just add an extra entry for it. 688 440 STD { int|linux_sys||nosys(void); } 689 441 STD { int|linux_sys||epoll_pwait2(int epfd, \ 690 struct linux_epoll_event *events, int maxevents, \ 691 const struct linux_timespec *timeout, \ 692 const linux_sigset_t *sigmask); } 693
Indexes created Thu Oct 02 01:09:59 GMT 2025