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