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