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