$NetBSD: syscalls.master,v 1.79 2023/08/19 17:49:49 christos Exp $  

;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93

; Derived from NetBSD's sys/compat/linux/arch/powerpc/syscalls.master
; from Linux's arch/mips/kernel/syscalls.h

; NetBSD mips COMPAT_LINUX system call name/number "master" file.
; (See syscalls.conf to see what it is processed into.)
;
; Expect problems with
;  48 signal: undefined in Linux???
;  86 uselib: needs a.out
;
; Fields: number type [type-dependent ...]
;	number	system call number, must be in order
;	type	one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
;		the compatibility options defined in syscalls.conf.
;
; types:
;	STD	always included
;	OBSOL	obsolete, not included in system
;	UNIMPL	unimplemented, not included in system
;	NODEF	included, but don't define the syscall number
;	NOARGS	included, but don't define the syscall args structure
;	INDIR	included, but don't define the syscall args structure
;		and allow it to be "really" varargs.
;
; The compat options are defined in the syscalls.conf file, and the
; compat option name is prefixed to the syscall name.  Other than
; that, they're like NODEF (for 'compat' options), or STD (for
; 'libcompat' options).
;
; The type-dependent arguments are as follows:
; For STD, NODEF, NOARGS, and compat syscalls:
;	{ pseudo-proto } [alias]
; For other syscalls:
;	[comment]
;
; #ifdef's, etc. may be included, and are copied to the output files.
; #include's are copied to the syscall names and switch definition files only.

#include <sys/param.h>
#include <sys/poll.h>
#include <sys/systm.h>
#include <sys/signal.h>
#include <sys/mount.h>
#include <sys/syscallargs.h>

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_siginfo.h>
#include <compat/linux/common/linux_machdep.h>
#include <compat/linux/common/linux_mmap.h>
#include <compat/linux/common/linux_socketcall.h>

#include <compat/linux/linux_syscallargs.h>

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