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