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