syscalls.master revision 1.6
1 $NetBSD: syscalls.master,v 1.6 2023/07/28 19:01:10 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_machdep.h> 57 #include <compat/linux/common/linux_mmap.h> 58 #include <compat/linux/common/linux_ipc.h> 59 #include <compat/linux/common/linux_msg.h> 60 #include <compat/linux/common/linux_sem.h> 61 #include <compat/linux/common/linux_shm.h> 62 #include <compat/linux/common/linux_signal.h> 63 #include <compat/linux/common/linux_siginfo.h> 64 #include <compat/linux/common/linux_machdep.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 UNIMPL waitid 220 96 STD { int|linux_sys||set_tid_address(int *tid); } 221 97 UNIMPL unshare 222 98 STD { int|linux_sys||futex(int *uaddr, int op, int val, \ 223 const struct linux_timespec *timeout, int *uaddr2, \ 224 int val3); } 225 ; 226 ; The NetBSD native robust list calls have different 227 ; argument names / types, but they are ABI-compatible 228 ; with Linux. 229 ; 230 99 NOARGS { int|sys||__futex_set_robust_list(void *head, \ 231 size_t len); } 232 100 NOARGS { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ 233 void **headp, size_t *lenp); } 234 101 STD { int|linux_sys||nanosleep( \ 235 const struct linux_timespec *rqtp, \ 236 struct linux_timespec *rmtp); } 237 102 NOARGS { int|compat_50_sys||getitimer(int which, \ 238 struct itimerval50 *itv); } 239 103 NOARGS { int|compat_50_sys||setitimer(int which, \ 240 struct itimerval50 *itv, \ 241 struct itimerval50 *oitv); } 242 104 UNIMPL kexec_load 243 105 UNIMPL init_module 244 106 UNIMPL delete_module 245 107 STD { int|linux_sys||timer_create(clockid_t clockid, \ 246 struct linux_sigevent *evp, timer_t *timerid); } 247 108 STD { int|linux_sys||timer_gettime(timer_t timerid, \ 248 struct linux_itimerspec *tim); } 249 109 NOARGS { int|sys||timer_getoverrun(timer_t timerid); } 250 110 STD { int|linux_sys||timer_settime(timer_t timerid, \ 251 int flags, const struct linux_itimerspec *tim, \ 252 struct linux_itimerspec *otim); } 253 111 NOARGS { int|sys||timer_delete(timer_t timerid); } 254 112 STD { int|linux_sys||clock_settime(clockid_t which, \ 255 struct linux_timespec *tp); } 256 113 STD { int|linux_sys||clock_gettime(clockid_t which, \ 257 struct linux_timespec *tp); } 258 114 STD { int|linux_sys||clock_getres(clockid_t which, \ 259 struct linux_timespec *tp); } 260 115 STD { int|linux_sys||clock_nanosleep(clockid_t which, \ 261 int flags, struct linux_timespec *rqtp, \ 262 struct linux_timespec *rmtp); } 263 116 UNIMPL syslog 264 117 STD { int|linux_sys||ptrace(long request, long pid, \ 265 long addr, long data); } 266 118 STD { int|linux_sys||sched_setparam(pid_t pid, \ 267 const struct linux_sched_param *sp); } 268 119 STD { int|linux_sys||sched_setscheduler(pid_t pid, \ 269 int policy, const struct linux_sched_param *sp); } 270 120 STD { int|linux_sys||sched_getscheduler(pid_t pid); } 271 121 STD { int|linux_sys||sched_getparam(pid_t pid, \ 272 struct linux_sched_param *sp); } 273 122 STD { int|linux_sys||sched_setaffinity(pid_t pid, \ 274 unsigned int len, unsigned long *mask); } 275 123 STD { int|linux_sys||sched_getaffinity(pid_t pid, \ 276 unsigned int len, unsigned long *mask); } 277 124 STD { int|linux_sys||sched_yield(void); } 278 125 STD { int|linux_sys||sched_get_priority_max(int policy); } 279 126 STD { int|linux_sys||sched_get_priority_min(int policy); } 280 127 UNIMPL sys_sched_rr_get_interval 281 128 UNIMPL restart_syscall 282 129 STD { int|linux_sys||kill(int pid, int signum); } 283 130 STD { int|linux_sys||tkill(int tid, int sig); } 284 131 STD { int|linux_sys||tgkill(int tgid, int tid, int sig); } 285 132 STD { int|linux_sys||sigaltstack( \ 286 const struct linux_sigaltstack *ss, \ 287 struct linux_sigaltstack *oss); } 288 133 STD { int|linux_sys||rt_sigsuspend(linux_sigset_t *unewset, \ 289 size_t sigsetsize); } 290 134 STD { int|linux_sys||rt_sigaction(int signum, \ 291 const struct linux_sigaction *nsa, \ 292 struct linux_sigaction *osa, \ 293 size_t sigsetsize); } 294 135 STD { int|linux_sys||rt_sigprocmask(int how, \ 295 const linux_sigset_t *set, \ 296 linux_sigset_t *oset, \ 297 size_t sigsetsize); } 298 136 STD { int|linux_sys||rt_sigpending( \ 299 linux_sigset_t *set, \ 300 size_t sigsetsize); } 301 137 STD { int|linux_sys||rt_sigtimedwait( \ 302 const linux_sigset_t *set, \ 303 linux_siginfo_t *info, \ 304 const struct linux_timespec *timeout); } 305 138 UNIMPL rt_sigqueueinfo 306 139 NOARGS { int|linux_sys||rt_sigreturn(void); } 307 140 NOARGS { int|sys||setpriority(int which, int who, int prio); } 308 141 STD { int|linux_sys||getpriority(int which, int who); } 309 142 STD { int|linux_sys||reboot(int magic1, int magic2, \ 310 int cmd, void *arg); } 311 143 NOARGS { int|sys||setregid(gid_t rgid, gid_t egid); } 312 144 NOARGS { int|sys||setgid(gid_t gid); } 313 145 NOARGS { int|sys||setreuid(uid_t ruid, uid_t euid); } 314 146 NOARGS { int|sys||setuid(uid_t uid); } 315 147 STD { int|linux_sys||setresuid(uid_t ruid, uid_t euid, \ 316 uid_t suid); } 317 148 STD { int|linux_sys||getresuid(uid_t *ruid, uid_t *euid, \ 318 uid_t *suid); } 319 149 STD { int|linux_sys||setresgid(gid_t rgid, gid_t egid, \ 320 gid_t sgid); } 321 150 STD { int|linux_sys||getresgid(gid_t *rgid, gid_t *egid, \ 322 gid_t *sgid); } 323 151 STD { int|linux_sys||setfsuid(uid_t uid); } 324 152 STD { int|linux_sys||setfsgid(gid_t gid); } 325 153 STD { int|linux_sys||times(struct times *tms); } 326 154 NOARGS { int|sys||setpgid(int pid, int pgid); } 327 155 NOARGS { pid_t|sys||getpgid(pid_t pid); } 328 156 NOARGS { pid_t|sys||getsid(pid_t pid); } 329 157 NOARGS { int|sys||setsid(void); } 330 158 NOARGS { int|sys||getgroups(int gidsetsize, gid_t *gidset); } 331 159 NOARGS { int|sys||setgroups(int gidsetsize, gid_t *gidset); } 332 160 STD { int|linux_sys||uname(struct linux_utsname *up); } 333 161 NOARGS { int|compat_43_sys||sethostname(char *hostname, \ 334 u_int len);} 335 162 STD { int|linux_sys||setdomainname(char *domainname, \ 336 int len); } 337 163 STD { int|linux_sys||getrlimit(int which, \ 338 struct rlimit *rlp); } 339 164 STD { int|linux_sys||setrlimit(u_int which, \ 340 struct rlimit *rlp); } 341 165 NOARGS { int|compat_50_sys||getrusage(int who, \ 342 struct rusage50 *rusage); } 343 166 NOARGS { int|sys||umask(int newmask); } 344 167 UNIMPL prctl 345 168 UNIMPL getcpu 346 169 STD { int|linux_sys||gettimeofday(struct timeval50 *tp, \ 347 struct timezone *tzp); } 348 170 STD { int|linux_sys||settimeofday(struct timeval50 *tp, \ 349 struct timezone *tzp); } 350 171 UNIMPL adjtimex 351 172 STD { pid_t|sys||getpid(void); } 352 173 STD { pid_t|sys||getppid(void); } 353 174 NOARGS { uid_t|sys||getuid(void); } 354 175 NOARGS { uid_t|sys||geteuid(void); } 355 176 NOARGS { gid_t|sys||getgid(void); } 356 177 NOARGS { gid_t|sys||getegid(void); } 357 178 STD { pid_t|linux_sys||gettid(void); } 358 179 STD { int|linux_sys||sysinfo(struct linux_sysinfo *arg); } 359 180 UNIMPL mq_open 360 181 UNIMPL mq_unlink 361 182 UNIMPL mq_timedsend 362 183 UNIMPL mq_timedreceive 363 184 UNIMPL mq_notify 364 185 UNIMPL mq_getsetattr 365 #ifdef SYSVMSG 366 186 NOARGS { int|sys||msgget(key_t key, int msgflg); } 367 187 NOARGS { int|linux_sys||msgctl(int msqid, int cmd, \ 368 struct linux_msqid_ds *buf); } 369 188 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 370 size_t msgsz, long msgtyp, int msgflg); } 371 189 NOARGS { int|sys||msgsnd(int msqid, void *msgp, size_t msgsz, \ 372 int msgflg); } 373 #else 374 186 UNIMPL msgget 375 187 UNIMPL msgctl 376 188 UNIMPL msgrcv 377 189 UNIMPL msgsnd 378 #endif 379 #ifdef SYSVSEM 380 190 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 381 191 STD { int|linux_sys||semctl(int semid, int semnum, \ 382 int cmd, union linux_semun arg); } 383 192 UNIMPL semtimedop 384 193 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ 385 size_t nsops); } 386 #else 387 190 UNIMPL semget 388 191 UNIMPL semctl 389 192 UNIMPL semtimedop 390 193 UNIMPL semop 391 #endif 392 #ifdef SYSVSEM 393 194 NOARGS { int|linux_sys||shmget(key_t key, size_t size, \ 394 int shmflg); } 395 195 NOARGS { int|linux_sys||shmctl(int shmid, int cmd, \ 396 struct linux_shmid_ds *buf); } 397 196 NOARGS { int|sys||shmat(int shmid, void *shmaddr, int shmflg); } 398 197 NOARGS { int|sys||shmdt(const void *shmaddr); } 399 #else 400 194 UNIMPL shmget 401 195 UNIMPL shmctl 402 196 UNIMPL shmat 403 197 UNIMPL shmdt 404 #endif 405 198 STD { int|linux_sys||socket(int domain, \ 406 int type, int protocol); } 407 199 STD { int|linux_sys||socketpair(int domain, int type, \ 408 int protocol, int *rsv); } 409 200 STD { int|linux_sys||bind(int s, \ 410 const struct osockaddr *name, \ 411 unsigned int namelen); } 412 201 NOARGS { int|sys||listen(int s, int backlog); } 413 202 STD { int|linux_sys||accept(int s, struct osockaddr *name, \ 414 int *anamelen); } oaccept 415 203 STD { int|linux_sys||connect(int s, \ 416 const struct osockaddr *name, \ 417 unsigned int namelen); } 418 204 STD { int|linux_sys||getsockname(int fdec, void *asa, \ 419 int *alen); } 420 205 STD { int|linux_sys||getpeername(int fdes, \ 421 struct sockaddr *asa, unsigned int *alen); } 422 206 STD { ssize_t|linux_sys||sendto(int s, void *msg, int len, \ 423 int flags, struct osockaddr *to, int tolen); } 424 207 STD { ssize_t|linux_sys||recvfrom(int s, void *buf, \ 425 size_t len, int flags, struct osockaddr *from, \ 426 unsigned int *fromlenaddr); } 427 208 STD { int|linux_sys||setsockopt(int s, int level, \ 428 int optname, void *optval, int optlen); } 429 209 STD { int|linux_sys||getsockopt(int s, int level, \ 430 int optname, void *optval, int *optlen); } 431 210 NOARGS { int|sys||shutdown(int s, int how); } 432 211 STD { int|linux_sys||sendmsg(int s, \ 433 const struct linux_msghdr *msg, int flags); } 434 212 STD { ssize_t|linux_sys||recvmsg(int s, \ 435 struct linux_msghdr *msg, int flags); } 436 213 UNIMPL readahead 437 214 STD { int|linux_sys||brk(char *nsize); } 438 215 NOARGS { int|sys||munmap(void *addr, size_t len); } 439 216 STD { void *|linux_sys||mremap(void *old_address, \ 440 size_t old_size, size_t new_size, u_long flags); } 441 217 UNIMPL add_key 442 218 UNIMPL request_key 443 219 UNIMPL keyctl 444 220 STD { int|linux_sys||clone(int flags, void *stack, \ 445 void *parent_tidptr, void *child_tidptr, void *tls); } 446 221 NOARGS { int|sys||execve(const char *path, char **argp, \ 447 char **envp); } 448 222 NOARGS { linux_off_t|linux_sys||mmap(unsigned long addr, \ 449 size_t len, int prot, int flags, int fd, \ 450 linux_off_t offset); } 451 223 STD { int|linux_sys||fadvise64(int fd, off_t offset, \ 452 size_t len, int advice); } 453 224 STD { int|linux_sys||swapon(char *name); } 454 225 STD { int|linux_sys||swapoff(const char *path); } 455 226 STD { int|linux_sys||mprotect(const void *start, \ 456 unsigned long len, int prot); } 457 227 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 458 228 NOARGS { int|sys||mlock(void *addr, size_t len); } 459 229 NOARGS { int|sys||munlock(void *addr, size_t len); } 460 230 NOARGS { int|sys||mlockall(int flags); } 461 231 NOARGS { int|sys||munlockall(void); } 462 232 NOARGS { int|sys||mincore(void *addr, size_t len, char *vec); } 463 233 NOARGS { int|sys||madvise(void *addr, size_t len, int behav); } 464 234 UNIMPL remap_file_pages 465 235 UNIMPL mbind 466 236 UNIMPL get_mempolicy 467 237 UNIMPL set_mempolicy 468 238 UNIMPL migrate_pages 469 239 UNIMPL move_pages 470 240 UNIMPL rt_tgsigqueueinfo 471 241 UNIMPL perf_event_open 472 242 STD { int|linux_sys||accept4(int s, \ 473 struct osockaddr *name, \ 474 int *anamelen, int flags); } 475 243 STD { int|linux_sys||recvmmsg(int s, \ 476 struct linux_mmsghdr *msgvec, unsigned int vlen, \ 477 unsigned int flags, struct timespec *timeout); } 478 244 UNIMPL arch_specific_syscall 479 245 UNIMPL 480 246 UNIMPL 481 247 UNIMPL 482 248 UNIMPL 483 249 UNIMPL 484 250 UNIMPL 485 251 UNIMPL 486 252 UNIMPL 487 253 UNIMPL 488 254 UNIMPL 489 255 UNIMPL 490 256 UNIMPL 491 257 UNIMPL 492 258 UNIMPL 493 259 UNIMPL 494 260 STD { int|linux_sys||wait4(int pid, int *status, \ 495 int options, struct rusage50 *rusage); } 496 261 STD { int|linux_sys||prlimit64(pid_t pid, int which, \ 497 struct rlimit *new_rlp, struct rlimit *old_rlp); } 498 262 UNIMPL fanotify_init 499 263 UNIMPL fanotify_mark 500 264 UNIMPL name_to_handle_at 501 265 UNIMPL open_by_handle_at 502 266 UNIMPL clock_adjtime 503 267 UNIMPL syncfs 504 268 UNIMPL setns 505 269 STD { int|linux_sys||sendmmsg(int s, \ 506 struct linux_mmsghdr *msgvec, unsigned int vlen, \ 507 unsigned int flags); } 508 270 UNIMPL process_vm_readv 509 271 UNIMPL process_vm_writev 510 272 UNIMPL kcmp 511 273 UNIMPL finit_module 512 274 UNIMPL sched_setattr 513 275 UNIMPL sched_getattr 514 276 UNIMPL renameat2 515 277 UNIMPL seccomp 516 278 NOARGS { ssize_t|sys||getrandom(void *buf, size_t buflen, \ 517 unsigned int flags); } 518 279 STD { int|linux_sys||memfd_create(const char *name, \ 519 unsigned int flags); } 520 280 UNIMPL bpf 521 281 UNIMPL execveat 522 282 UNIMPL userfaultfd 523 283 UNIMPL membarrier 524 284 UNIMPL mlock2 525 285 UNIMPL copy_file_range 526 286 UNIMPL preadv2 527 287 UNIMPL pwritev2 528 288 UNIMPL pkey_mprotect 529 289 UNIMPL pkey_alloc 530 290 UNIMPL pkey_free 531 291 STD { int|linux_sys||statx(int fd, const char *path, \ 532 int flag, unsigned int mask, \ 533 struct linux_statx *sp); } 534 292 UNIMPL io_pgetevents 535 293 UNIMPL rseq 536 294 UNIMPL kexec_file_load 537 295 UNIMPL 538 296 UNIMPL 539 297 UNIMPL 540 298 UNIMPL 541 299 UNIMPL 542 300 UNIMPL 543 301 UNIMPL 544 302 UNIMPL 545 303 UNIMPL 546 304 UNIMPL 547 305 UNIMPL 548 306 UNIMPL 549 307 UNIMPL 550 308 UNIMPL 551 309 UNIMPL 552 310 UNIMPL 553 311 UNIMPL 554 312 UNIMPL 555 313 UNIMPL 556 314 UNIMPL 557 315 UNIMPL 558 316 UNIMPL 559 317 UNIMPL 560 318 UNIMPL 561 319 UNIMPL 562 320 UNIMPL 563 321 UNIMPL 564 322 UNIMPL 565 323 UNIMPL 566 324 UNIMPL 567 325 UNIMPL 568 326 UNIMPL 569 327 UNIMPL 570 328 UNIMPL 571 329 UNIMPL 572 330 UNIMPL 573 331 UNIMPL 574 332 UNIMPL 575 333 UNIMPL 576 334 UNIMPL 577 335 UNIMPL 578 336 UNIMPL 579 337 UNIMPL 580 338 UNIMPL 581 339 UNIMPL 582 340 UNIMPL 583 341 UNIMPL 584 342 UNIMPL 585 343 UNIMPL 586 344 UNIMPL 587 345 UNIMPL 588 346 UNIMPL 589 347 UNIMPL 590 348 UNIMPL 591 349 UNIMPL 592 350 UNIMPL 593 351 UNIMPL 594 352 UNIMPL 595 353 UNIMPL 596 354 UNIMPL 597 355 UNIMPL 598 356 UNIMPL 599 357 UNIMPL 600 358 UNIMPL 601 359 UNIMPL 602 360 UNIMPL 603 361 UNIMPL 604 362 UNIMPL 605 363 UNIMPL 606 364 UNIMPL 607 365 UNIMPL 608 366 UNIMPL 609 367 UNIMPL 610 368 UNIMPL 611 369 UNIMPL 612 370 UNIMPL 613 371 UNIMPL 614 372 UNIMPL 615 373 UNIMPL 616 374 UNIMPL 617 375 UNIMPL 618 376 UNIMPL 619 377 UNIMPL 620 378 UNIMPL 621 379 UNIMPL 622 380 UNIMPL 623 381 UNIMPL 624 382 UNIMPL 625 383 UNIMPL 626 384 UNIMPL 627 385 UNIMPL 628 386 UNIMPL 629 387 UNIMPL 630 388 UNIMPL 631 389 UNIMPL 632 390 UNIMPL 633 391 UNIMPL 634 392 UNIMPL 635 393 UNIMPL 636 394 UNIMPL 637 395 UNIMPL 638 396 UNIMPL 639 397 UNIMPL 640 398 UNIMPL 641 399 UNIMPL 642 400 UNIMPL 643 401 UNIMPL 644 402 UNIMPL 645 403 UNIMPL 646 404 UNIMPL 647 405 UNIMPL 648 406 UNIMPL 649 407 UNIMPL 650 408 UNIMPL 651 409 UNIMPL 652 410 UNIMPL 653 411 UNIMPL 654 412 UNIMPL 655 413 UNIMPL 656 414 UNIMPL 657 415 UNIMPL 658 416 UNIMPL 659 417 UNIMPL 660 418 UNIMPL 661 419 UNIMPL 662 420 UNIMPL 663 421 UNIMPL 664 422 UNIMPL 665 423 UNIMPL 666 424 UNIMPL pidfd_send_signal 667 425 UNIMPL io_uring_setup 668 426 UNIMPL io_uring_enter 669 427 UNIMPL io_uring_register 670 428 UNIMPL open_tree 671 429 UNIMPL move_mount 672 430 UNIMPL fsopen 673 431 UNIMPL fsconfig 674 432 UNIMPL fsmount 675 433 UNIMPL fspick 676 434 UNIMPL pidfd_open 677 435 UNIMPL clone3 678 436 UNIMPL 679 437 UNIMPL openat2 680 438 UNIMPL pidfd_getfd 681 439 UNIMPL faccessat2 682 683 ; we want a "nosys" syscall, we'll just add an extra entry for it. 684 440 STD { int|linux_sys||nosys(void); } 685 441 STD { int|linux_sys||epoll_pwait2(int epfd, \ 686 struct linux_epoll_event *events, int maxevents, \ 687 const struct linux_timespec *timeout, \ 688 const linux_sigset_t *sigmask); } 689
Indexes created Thu Oct 02 01:09:59 GMT 2025