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