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