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