xref: /src/sys/compat/freebsd/syscalls.master

	$NetBSD: syscalls.master,v 1.67 2013/11/07 19:37:18 njoly Exp $

;	from: @(#)syscalls.master	8.2 (Berkeley) 1/13/94

; NetBSD COMPAT_FREEBSD system call name/number "master" file.
; (See syscalls.conf to see what it is processed into.)
;
; 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
;
; 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.

#if defined(_KERNEL_OPT)
#include "opt_ktrace.h"
#include "opt_ntp.h"
#include "opt_sysv.h"
#include "opt_compat_43.h"
#endif

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

#include <compat/sys/signal.h>
#include <compat/sys/time.h>

#include <compat/freebsd/freebsd_syscallargs.h>

#include <machine/freebsd_machdep.h>

%%

; Reserved/unimplemented system calls in the range 0-150 inclusive
; are reserved for use in future Berkeley releases.
; Additional system calls implemented in vendor and other
; redistributions should be placed in the reserved range at the end
; of the current calls.

0	NOARGS		{ int|sys||nosys(void); } syscall
1	NOARGS		{ int|sys||exit(int rval); }
2	NOARGS		{ int|sys||fork(void); }
3	NOARGS		{ int|sys||read(int fd, char *buf, u_int nbyte); }
4	NOARGS		{ int|sys||write(int fd, char *buf, u_int nbyte); }
5	NOARGS		{ int|sys||open(const char *path, int flags, int mode); }
6	NOARGS		{ int|sys||close(int fd); }
7	NOARGS		{ int|compat_50_sys||wait4(int pid, int *status, \
			    int options, struct rusage50 *rusage); }
8	NOARGS		{ int|compat_43_sys||creat(const char *path, \
			    int mode); } ocreat
9	NOARGS		{ int|sys||link(const char *path, const char *link); }
10	NOARGS		{ int|sys||unlink(const char *path); }
11	OBSOL		execv
12	NOARGS		{ int|sys||chdir(const char *path); }
13	NOARGS		{ int|sys||fchdir(int fd); }
14	NOARGS		{ int|compat_50_sys||mknod(const char *path, int mode, int dev); }
15	NOARGS		{ int|sys||chmod(const char *path, int mode); }
16	NOARGS		{ int|sys||chown(const char *path, int uid, int gid); }
17	NOARGS		{ int|sys||obreak(char *nsize); } break
18	NOARGS		{ int|compat_20_sys||getfsstat(struct statfs12 *buf, \
			    long bufsize, int flags); }
19	NOARGS		{ long|compat_43_sys||lseek(int fd, long offset, \
			    int whence); } olseek
20	NOARGS		{ pid_t|sys||getpid_with_ppid(void); }
21	STD		{ int|freebsd_sys||mount(int type, const char *path, \
			    int flags, void *data); }
22	NOARGS		{ int|sys||unmount(const char *path, int flags); }
23	NOARGS		{ int|sys||setuid(uid_t uid); }
24	NOARGS		{ uid_t|sys||getuid_with_euid(void); }
25	NOARGS		{ uid_t|sys||geteuid(void); }
26	STD		{ int|freebsd_sys||ptrace(int req, pid_t pid, \
			    void *addr, int data); }
27	NOARGS		{ int|sys||recvmsg(int s, struct msghdr *msg, \
			    int flags); }
28	NOARGS		{ int|sys||sendmsg(int s, void *msg, int flags); }
29	NOARGS		{ int|sys||recvfrom(int s, void *buf, size_t len, \
			    int flags, void *from, int *fromlenaddr); }
30	NOARGS		{ int|sys||accept(int s, void *name, int *anamelen); }
31	NOARGS		{ int|sys||getpeername(int fdes, void *asa, \
			    int *alen); }
32	NOARGS		{ int|sys||getsockname(int fdes, void *asa, \
			    int *alen); }
33	NOARGS		{ int|sys||access(const char *path, int flags); }
34	NOARGS		{ int|sys||chflags(const char *path, int flags); }
35	NOARGS		{ int|sys||fchflags(int fd, int flags); }
36	NOARGS		{ int|sys||sync(void); }
37	NOARGS		{ int|sys||kill(int pid, int signum); }
38	NOARGS		{ int|compat_43_sys||stat(const char *path, \
			    struct stat43 *ub); } stat43
39	NOARGS		{ pid_t|sys||getppid(void); }
40	NOARGS		{ int|compat_43_sys||lstat(const char *path, \
			    struct stat43 *ub); } lstat43
41	NOARGS		{ int|sys||dup(int fd); }
42	NOARGS		{ int|sys||pipe(void); }
43	NOARGS		{ gid_t|sys||getegid(void); }
44	NOARGS		{ int|sys||profil(void *samples, u_int size, \
			    u_int offset, u_int scale); }
#ifdef KTRACE
45	NOARGS		{ int|sys||ktrace(char *fname, int ops, int facs, \
			    int pid); }
#else
45	EXCL		ktrace
#endif
46	NOARGS		{ int|compat_13_sys||sigaction(int signum, \
			    const struct sigaction13 *nsa, \
			    struct sigaction13 *osa); }
47	NOARGS		{ gid_t|sys||getgid_with_egid(void); }
48	NOARGS		{ int|compat_13_sys||sigprocmask(int how, \
			    int mask); }
49	NOARGS		{ int|sys||__getlogin(char *namebuf, u_int namelen); }
50	NOARGS		{ int|sys||__setlogin(char *namebuf); }
51	NOARGS		{ int|sys||acct(char *path); }
52	NOARGS		{ int|compat_13_sys||sigpending(void); }
53	NOARGS		{ int|compat_13_sys||sigaltstack( \
			    const struct sigaltstack13 *nss, \
			    struct sigaltstack13 *oss); }
54	STD		{ int|freebsd_sys||ioctl(int fd, u_long com, \
			    void *data); }
55	NOARGS		{ int|sys||reboot(int opt); } oreboot
56	NOARGS		{ int|sys||revoke(const char *path); }
57	NOARGS		{ int|sys||symlink(const char *path, const char *link); }
58	NOARGS		{ int|sys||readlink(const char *path, \
			    char *buf, int count); }
59	NOARGS		{ int|sys||execve(const char *path, \
			    char **argp, char **envp); }
60	NOARGS		{ int|sys||umask(int newmask); }
61	NOARGS		{ int|sys||chroot(const char *path); }
62	NOARGS		{ int|compat_43_sys||fstat(int fd, struct stat43 *sb); } \
			    fstat43
63	NOARGS		{ int|compat_43_sys||getkerninfo(int op, char *where, \
			    int *size, int arg); } ogetkerninfo
64	NOARGS		{ int|compat_43_sys||getpagesize(void); } ogetpagesize
65	STD		{ int|freebsd_sys||msync(void *addr, size_t len, \
			    int flags); }
66	NOARGS		{ int|sys||vfork(void); }
67	OBSOL		vread
68	OBSOL		vwrite
69	NOARGS		{ int|sys||sbrk(intptr_t incr); }
70	NOARGS		{ int|sys||sstk(int incr); }
71	NOARGS		{ int|compat_43_sys||mmap(void *addr, size_t len, \
			    int prot, int flags, int fd, long pos); } ommap
72	NOARGS		{ int|sys||ovadvise(int anom); } vadvise
73	NOARGS		{ int|sys||munmap(void *addr, size_t len); }
74	NOARGS		{ int|sys||mprotect(void *addr, size_t len, \
			    int prot); }
75	NOARGS		{ int|sys||madvise(void *addr, size_t len, \
			    int behav); }
76	OBSOL		vhangup
77	OBSOL		vlimit
78	NOARGS		{ int|sys||mincore(void *addr, size_t len, char *vec); }
79	NOARGS		{ int|sys||getgroups(u_int gidsetsize, gid_t *gidset); }
80	NOARGS		{ int|sys||setgroups(u_int gidsetsize, gid_t *gidset); }
81	NOARGS		{ int|sys||getpgrp(void); }
82	NOARGS		{ int|sys||setpgid(int pid, int pgid); }
83	NOARGS		{ int|compat_50_sys||setitimer(u_int which, \
			    struct itimerval50 *itv, struct itimerval50 *oitv); }
84	NOARGS		{ int|compat_43_sys||wait(void); } owait
85	NOARGS		{ int|compat_12_sys||swapon(char *name); }
86	NOARGS		{ int|compat_50_sys||getitimer(u_int which, \
			    struct itimerval50 *itv); }
87	NOARGS		{ int|compat_43_sys||gethostname(char *hostname, \
			    u_int len); } ogethostname
88	NOARGS		{ int|compat_43_sys||sethostname(char *hostname, \
			    u_int len); } osethostname
89	NOARGS		{ int|compat_43_sys||getdtablesize(void); } \
			    ogetdtablesize
90	NOARGS		{ int|sys||dup2(int from, int to); }
91	UNIMPL		getdopt
92	NOARGS		{ int|sys||fcntl(int fd, int cmd, void *arg); }
93	NOARGS		{ int|compat_50_sys||select(u_int nd, fd_set *in, \
			    fd_set *ou, fd_set *ex, struct timeval50 *tv); }
94	UNIMPL		setdopt
95	NOARGS		{ int|sys||fsync(int fd); }
96	NOARGS		{ int|sys||setpriority(int which, int who, int prio); }
97	NOARGS		{ int|compat_30_sys||socket(int domain, int type, int protocol); }
98	NOARGS		{ int|sys||connect(int s, void *name, int namelen); }
99	NOARGS		{ int|compat_43_sys||accept(int s, void *name, \
			    int *anamelen); } oaccept
100	NOARGS		{ int|sys||getpriority(int which, int who); }
101	NOARGS		{ int|compat_43_sys||send(int s, void *buf, int len, \
			    int flags); } osend
102	NOARGS		{ int|compat_43_sys||recv(int s, void *buf, int len, \
			    int flags); } orecv
103	STD		{ int|freebsd_sys||sigreturn( \
			    struct freebsd_sigcontext *scp); }
104	NOARGS		{ int|sys||bind(int s, void *name, int namelen); }
105	NOARGS		{ int|sys||setsockopt(int s, int level, int name, \
			    void *val, int valsize); }
106	NOARGS		{ int|sys||listen(int s, int backlog); }
107	OBSOL		vtimes
108	NOARGS		{ int|compat_43_sys||sigvec(int signum, \
			    struct sigvec *nsv, struct sigvec *osv); } osigvec
109	NOARGS		{ int|compat_43_sys||sigblock(int mask); } osigblock
110	NOARGS		{ int|compat_43_sys||sigsetmask(int mask); } osigsetmask
111	NOARGS		{ int|compat_13_sys||sigsuspend(int mask); }
112	NOARGS		{ int|compat_43_sys||sigstack(struct sigstack *nss, \
			    struct sigstack *oss); } osigstack
113	NOARGS		{ int|compat_43_sys||recvmsg(int s, \
			    struct omsghdr *msg, int flags); } orecvmsg
114	NOARGS		{ int|compat_43_sys||sendmsg(int s, void *msg, \
			    int flags); } osendmsg
#ifdef TRACE
115	NOARGS		{ int|sys||vtrace(int request, int value); }
#else
115	OBSOL		vtrace
#endif
116	NOARGS		{ int|compat_50_sys||gettimeofday(struct timeval50 *tp, \
			    struct timezone *tzp); }
117	NOARGS		{ int|compat_50_sys||getrusage(int who, \
			    struct rusage50 *rusage); }
118	NOARGS		{ int|sys||getsockopt(int s, int level, int name, \
			    void *val, int *avalsize); }
119	OBSOL		resuba
120	NOARGS		{ int|sys||readv(int fd, struct iovec *iovp, \
			    u_int iovcnt); }
121	NOARGS		{ int|sys||writev(int fd, struct iovec *iovp, \
			    u_int iovcnt); }
122	NOARGS		{ int|compat_50_sys||settimeofday(struct timeval50 *tv, \
			    struct timezone50 *tzp); }
123	NOARGS		{ int|sys||fchown(int fd, int uid, int gid); }
124	NOARGS		{ int|sys||fchmod(int fd, int mode); }
125	NOARGS		{ int|compat_43_sys||recvfrom(int s, void *buf, \
			    size_t len, int flags, void *from, \
			    int *fromlenaddr); } orecvfrom
126	NOARGS		{ int|sys||setreuid(int ruid, int euid); }
127	NOARGS		{ int|sys||setregid(int rgid, int egid); }
128	NOARGS		{ int|sys||rename(const char *from, const char *to); }
129	NOARGS		{ int|compat_43_sys||truncate(const char *path, \
			    long length); } otruncate
130	NOARGS		{ int|compat_43_sys||ftruncate(int fd, long length); } \
			    oftruncate
131	NOARGS		{ int|sys||flock(int fd, int how); }
132	NOARGS		{ int|sys||mkfifo(const char *path, int mode); }
133	NOARGS		{ int|sys||sendto(int s, void *buf, size_t len, \
			    int flags, void *to, int tolen); }
134	NOARGS		{ int|sys||shutdown(int s, int how); }
135	NOARGS		{ int|sys||socketpair(int domain, int type, \
			    int protocol, int *rsv); }
136	NOARGS		{ int|sys||mkdir(const char *path, int mode); }
137	NOARGS		{ int|sys||rmdir(const char *path); }
138	NOARGS		{ int|compat_50_sys||utimes(char *path, \
			    struct timeval50 *tptr); }
139	OBSOL		4.2 sigreturn
140	NOARGS		{ int|compat_50_sys||adjtime(struct timeval50 *delta, \
			    struct timeval50 *olddelta); }
141	NOARGS		{ int|compat_43_sys||getpeername(int fdes, void *asa, \
			    int *alen); } ogetpeername
142	NOARGS		{ int32_t|compat_43_sys||gethostid(void); } ogethostid
143	NOARGS		{ int|compat_43_sys||sethostid(int32_t hostid); } \
			    osethostid
144	NOARGS		{ int|compat_43_sys||getrlimit(u_int which, \
			    struct orlimit *rlp); } ogetrlimit
145	NOARGS		{ int|compat_43_sys||setrlimit(u_int which, \
			    struct orlimit *rlp); } osetrlimit
146	NOARGS		{ int|compat_43_sys||killpg(int pgid, int signum); } \
			    okillpg
147	NOARGS		{ int|sys||setsid(void); }
148	NOARGS		{ int|compat_50_sys||quotactl(char *path, int cmd, \
			    int uid, void *arg); }
149	NOARGS		{ int|compat_43_sys||quota(void); } oquota
150	NOARGS		{ int|compat_43_sys||getsockname(int fdec, void *asa, \
			    int *alen); } ogetsockname

; Syscalls 151-180 inclusive are reserved for vendor-specific
; system calls.  (This includes various calls added for compatibity
; with other Unix variants.)
; Some of these calls are now supported by BSD...
151	UNIMPL		sem_lock
152	UNIMPL		sem_wakeup
153	UNIMPL		asyncdaemon
154	UNIMPL
155	UNIMPL		nfssvc
156	NOARGS		{ int|compat_43_sys||getdirentries(int fd, char *buf, \
			    u_int count, long *basep); } ogetdirentries
157	NOARGS		{ int|compat_20_sys||statfs(const char *path, \
			    struct statfs12 *buf); }
158	NOARGS		{ int|compat_20_sys||fstatfs(int fd, \
			    struct statfs12 *buf); }
159	UNIMPL
160	UNIMPL
161	NOARGS		{ int|compat_30_sys||getfh(const char *fname, \
			    struct compat_30_fhandle *fhp); }
162	NOARGS		{ int|compat_09_sys||getdomainname(char *domainname, \
			    int len); }
163	NOARGS		{ int|compat_09_sys||setdomainname(char *domainname, \
			    int len); }
164	NOARGS		{ int|compat_09_sys||uname(struct outsname *name); }
165	NOARGS		{ int|sys||sysarch(int op, char *parms); }
166	STD		{ int|freebsd_sys||rtprio(int function, pid_t pid, \
			    struct freebsd_rtprio *rtp); }
167	UNIMPL
168	UNIMPL
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if defined(SYSVSEM) && !defined(_LP64)
169	STD		{ int|freebsd_sys||semsys(int which, int a2, int a3, \
			    int a4, int a5); }
#else
169	UNIMPL		1.0 semsys
#endif
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if defined(SYSVMSG) && !defined(_LP64)
170	STD		{ int|freebsd_sys||msgsys(int which, int a2, int a3, \
			    int a4, int a5, int a6); }
#else
170	UNIMPL		1.0 msgsys
#endif
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if defined(SYSVSHM) && !defined(_LP64)
171	STD		{ int|freebsd_sys||shmsys(int which, int a2, int a3, \
			    int a4); }
#else
171	UNIMPL		1.0 shmsys
#endif
172	UNIMPL
173	NOARGS		{ ssize_t|sys||pread(int fd, void *buf, \
			    size_t nbyte, int pad, off_t offset); }
174	NOARGS		{ ssize_t|sys||pwrite(int fd, const void *buf, \
			    size_t nbyte, int pad, off_t offset); }
175	UNIMPL
#ifdef NTP
176	STD		{ int|freebsd||ntp_adjtime(struct freebsd_timex *tp); }
#else
176     EXCL            ntp_adjtime
#endif
177	UNIMPL		sfork
178	UNIMPL		getdescriptor
179	UNIMPL		setdescriptor
180	UNIMPL

; Syscalls 180-199 are used by/reserved for BSD
181	NOARGS		{ int|sys||setgid(gid_t gid); }
182	NOARGS		{ int|sys||setegid(gid_t egid); }
183	NOARGS		{ int|sys||seteuid(uid_t euid); }
184	UNIMPL
185	UNIMPL
186	UNIMPL
187	UNIMPL
188	NOARGS		{ int|compat_12_sys||stat(const char *path, \
			    struct stat12 *ub); }
189	NOARGS		{ int|compat_12_sys||fstat(int fd, \
			    struct stat12 *sb); }
190	NOARGS		{ int|compat_12_sys||lstat(const char *path, \
			    struct stat12 *ub); }
191	NOARGS		{ int|sys||pathconf(const char *path, int name); }
192	NOARGS		{ int|sys||fpathconf(int fd, int name); }
193	UNIMPL
194	NOARGS		{ int|sys||getrlimit(u_int which, struct rlimit *rlp); }
195	NOARGS		{ int|sys||setrlimit(u_int which, struct rlimit *rlp); }
196	NOARGS		{ int|compat_12_sys||getdirentries(int fd, char *buf, \
			    u_int count, long *basep); }
197	STD		{ void *|freebsd_sys||mmap(void *addr, size_t len, \
			    int prot, int flags, int fd, long pad, off_t pos); }
198	NOARGS		{ int|sys||nosys(void); } __syscall
199	NOARGS		{ off_t|sys||lseek(int fd, int pad, off_t offset, \
			    int whence); }
200	NOARGS		{ int|sys||truncate(const char *path, int pad, \
			    off_t length); }
201	NOARGS		{ int|sys||ftruncate(int fd, int pad, off_t length); }
202	STD		{ int|freebsd_sys||sysctl(int *name, u_int namelen, \
			    void *old, size_t *oldlenp, void *new, \
			    size_t newlen); }
203	NOARGS		{ int|sys||mlock(void *addr, size_t len); }
204	NOARGS		{ int|sys||munlock(void *addr, size_t len); }
#ifdef FREEBSD_BASED_ON_44LITE_R2
205	STD		{ int|freebsd_sys||undelete(char *path); }
#else
205	UNIMPL		undelete
#endif
206	NOARGS		{ int|compat_50_sys||futimes(int fd, \
			    const struct timeval50 *tptr); }
207	NOARGS		{ pid_t|sys||getpgid(pid_t pid); }
#if 0
208	NOARGS		{ int|sys||reboot(int opt, char *bootstr); }
#else
208	UNIMPL		newreboot
#endif
209	NOARGS		{ int|sys||poll(struct pollfd *fds, u_int nfds, \
			    int timeout); }
;
; Syscalls 210-219 are reserved for dynamically loaded syscalls
;
210	UNIMPL
211	UNIMPL
212	UNIMPL
213	UNIMPL
214	UNIMPL
215	UNIMPL
216	UNIMPL
217	UNIMPL
218	UNIMPL
219	UNIMPL
;
; Syscalls 220-239 are reserved for syscalls imported from NetBSD
;
#ifdef SYSVSEM
220	NOARGS		{ int|compat_14_sys||__semctl(int semid, int semnum, \
			    int cmd, union __semun *arg); }
221	NOARGS		{ int|sys||semget(key_t key, int nsems, int semflg); }
222	NOARGS		{ int|sys||semop(int semid, struct sembuf *sops, \
			    u_int nsops); }
223	NOARGS		{ int|sys||semconfig(int flag); }
#else
220	UNIMPL		semctl
221	UNIMPL		semget
222	UNIMPL		semop
223	UNIMPL		semconfig
#endif
#ifdef SYSVMSG
224	NOARGS		{ int|compat_14_sys||msgctl(int msqid, int cmd, \
			    struct msqid14_ds *buf); }
225	NOARGS		{ int|sys||msgget(key_t key, int msgflg); }
226	NOARGS		{ int|sys||msgsnd(int msqid, void *msgp, size_t msgsz, \
			    int msgflg); }
227	NOARGS		{ int|sys||msgrcv(int msqid, void *msgp, size_t msgsz, \
			    long msgtyp, int msgflg); }
#else
224	UNIMPL		msgctl
225	UNIMPL		msgget
226	UNIMPL		msgsnd
227	UNIMPL		msgrcv
#endif
#ifdef SYSVSHM
228	NOARGS		{ int|sys||shmat(int shmid, void *shmaddr, int shmflg); }
229	NOARGS		{ int|compat_14_sys||shmctl(int shmid, int cmd, \
			    struct shmid_ds14 *buf); }
230	NOARGS		{ int|sys||shmdt(void *shmaddr); }
231	NOARGS		{ int|sys||shmget(key_t key, int size, int shmflg); }
#else
228	UNIMPL		shmat
229	UNIMPL		shmctl
230	UNIMPL		shmdt
231	UNIMPL		shmget
#endif
;
; XXXX
232	NOARGS		{ int|compat_50_sys||clock_gettime(clockid_t clock_id, \
			    struct timespec50 *tp); }
233	NOARGS		{ int|compat_50_sys||clock_settime(clockid_t clock_id, \
			    const struct timespec50 *tp); }
234	NOARGS		{ int|compat_50_sys||clock_getres(clockid_t clock_id, \
			    struct timespec50 *tp); }
235	UNIMPL		timer_create
236	UNIMPL		timer_delete
237	UNIMPL		timer_settime
238	UNIMPL		timer_gettime
239	UNIMPL		timer_getoverrun
240	NOARGS		{ int|compat_50_sys||nanosleep( \
			    const struct timespec50 *rqtp, \
			    struct timespec50 *rmtp); }
241	UNIMPL
242	UNIMPL
243	UNIMPL
244	UNIMPL
245	UNIMPL
246	UNIMPL
247	UNIMPL
248	UNIMPL
249	UNIMPL
; syscall numbers initially used in OpenBSD
250	NOARGS		{ int|sys||minherit(void *addr, size_t len, \
			    int inherit); }
251	STD		{ int|freebsd_sys||rfork(int flags); }
252	UNIMPL		openbsd_poll
253	NOARGS		{ int|sys||issetugid(void); }
254	NOARGS		{ int|sys||lchown(const char *path, int uid, int gid); }
255	UNIMPL
256	UNIMPL
257	UNIMPL
258	UNIMPL
259	UNIMPL
260	UNIMPL
261	UNIMPL
262	UNIMPL
263	UNIMPL
264	UNIMPL
265	UNIMPL
266	UNIMPL
267	UNIMPL
268	UNIMPL
269	UNIMPL
270	UNIMPL
271	UNIMPL
272	NOARGS		{ int|compat_30_sys||getdents(int fd, char *buf, size_t count); }
273	UNIMPL
274	NOARGS		{ int|sys||lchmod(const char *path, mode_t mode); }
275	NOARGS		{ int|sys||lchown(const char *path, uid_t uid, \
			    gid_t gid); } netbsd_lchown
276	NOARGS		{ int|compat_50_sys||lutimes(const char *path, \
			    const struct timeval50 *tptr); }
277	NOARGS		{ int|sys|13|msync(void *addr, size_t len, int flags); }
278	NOARGS		{ int|compat_30_sys|13|stat(const char *path, struct stat13 *ub); }
279	NOARGS		{ int|compat_30_sys|13|fstat(int fd, struct stat13 *sb); }
280	NOARGS		{ int|compat_30_sys|13|lstat(const char *path, struct stat13 *ub);}
281	UNIMPL
282	UNIMPL
283	UNIMPL
284	UNIMPL
285	UNIMPL
286	UNIMPL
287	UNIMPL
288	UNIMPL
289	UNIMPL
290	UNIMPL
291	UNIMPL
292	UNIMPL
293	UNIMPL
294	UNIMPL
295	UNIMPL
296	UNIMPL
297	NOARGS		{ int|compat_20_sys||fhstatfs(const struct	\
			    compat_30_fhandle *fhp, \
			    struct statfs12 *buf); }
298	NOARGS		{ int|compat_30_sys||fhopen(const	\
			    struct compat_30_fhandle *fhp, int flags); }
299	NOARGS		{ int|compat_30_sys||fhstat(const 	\
			    struct cocmpat_30_fhandlez *fhp, 	\
			    struct stat13 *sb); }
; syscall numbers for FreeBSD
300	UNIMPL		modnext
301	UNIMPL		modstat
302	UNIMPL		modfnext
303	UNIMPL		modfind
304	UNIMPL		kldload
305	UNIMPL		kldunload
306	UNIMPL		kldfind
307	UNIMPL		kldnext
308	UNIMPL		kldstat
309	UNIMPL		kldfirstmod
310	NOARGS		{ pid_t|sys||getsid(pid_t pid); }
311	UNIMPL		setresuid
312	UNIMPL		setresgid
313	UNIMPL		signanosleep
314	UNIMPL		aio_return
315	UNIMPL		aio_suspend
316	UNIMPL		aio_cancel
317	UNIMPL		aio_error
318	UNIMPL		aio_read
319	UNIMPL		aio_write
320	UNIMPL		lio_listio
321	NOARGS		{ void|freebsd_sys||yield(void); }
322	UNIMPL		thr_sleep
323	UNIMPL		thr_wakeup
324	NOARGS		{ int|sys||mlockall(int flags); }
325	NOARGS		{ int|sys||munlockall(void); }
326	NOARGS		{ int|sys||__getcwd(char *bufp, size_t length); }
327	STD		{ int|freebsd_sys||sched_setparam(pid_t pid, \
			    const struct freebsd_sched_param *sp); }
328	STD		{ int|freebsd_sys||sched_getparam(pid_t pid, \
			    struct freebsd_sched_param *sp); }
329	STD		{ int|freebsd_sys||sched_setscheduler(pid_t pid, \
			    int policy, const struct sched_param *sp); }
330	STD		{ int|freebsd_sys||sched_getscheduler(pid_t pid); }
331	STD		{ int|freebsd_sys||sched_yield(void); }
332	STD		{ int|freebsd_sys||sched_get_priority_max(int policy); }
333	STD		{ int|freebsd_sys||sched_get_priority_min(int policy); }
334	UNIMPL		sched_rr_get_interval
335	STD		{ int|freebsd_sys||utrace(void *addr, size_t len); }
336	UNIMPL		sendfile
337	UNIMPL		kldsym
338	UNIMPL		jail
339	UNIMPL		pioctl
340	NOARGS		{ int|sys|14|sigprocmask(int how, \
			    const sigset_t *set, \
			    sigset_t *oset); }
341	NOARGS		{ int|sys|14|sigsuspend(const sigset_t *set); }
342	STD		{ int|freebsd_sys||sigaction4(int signum, \
			    const struct freebsd_sigaction4 *nsa, \
			    struct freebsd_sigaction4 *osa); }
343	NOARGS		{ int|sys|14|sigpending(const sigset_t *set); }
344	UNIMPL		4.0 sigreturn
345	UNIMPL		sigtimedwait
346	UNIMPL		sigwaitinfo
347	UNIMPL		__acl_get_file
348	UNIMPL		__acl_set_file
349	UNIMPL		__acl_get_fd
350	UNIMPL		__acl_set_fd
351	UNIMPL		__acl_delete_file
352	UNIMPL		__acl_delete_fd
353	UNIMPL		__acl_aclcheck_file
354	UNIMPL		__acl_aclcheck_fd
355	UNIMPL		extattrctl
356	UNIMPL		extattr_set_file
357	UNIMPL		extattr_get_file
358	UNIMPL		extattr_delete_file
359	UNIMPL		aio_waitcomplete
360	UNIMPL		getresuid
361	UNIMPL		getresgid
362	UNIMPL		kqueue
363	UNIMPL		kevent
364	UNIMPL		__cap_get_proc
365	UNIMPL		__cap_set_proc
366	UNIMPL		__cap_get_fd
367	UNIMPL		__cap_get_file
368	UNIMPL		__cap_set_fd
369	UNIMPL		__cap_set_file
370	UNIMPL		lkmressym
371	UNIMPL		extattr_set_fd
372	UNIMPL		extattr_get_fd
373	UNIMPL		extattr_delete_fd
374	UNIMPL		__setugid
375	UNIMPL		nfsclnt
376	UNIMPL		eaccess
377	UNIMPL		afs_syscall
378	UNIMPL		nmount
379	UNIMPL		kse_exit
380	UNIMPL		kse_wakeup
381	UNIMPL		kse_create
382	UNIMPL		kse_thr_interrupt
383	UNIMPL		kse_release
384	UNIMPL		__mac_get_proc
385	UNIMPL		__mac_set_proc
386	UNIMPL		__mac_get_fd
387	UNIMPL		__mac_get_file
388	UNIMPL		__mac_set_fd
389	UNIMPL		__mac_set_file
390	UNIMPL		kenv
391	NOARGS		{ int|sys||lchflags(const char *path, u_long flags); }
392	NOARGS		{ int|sys||uuidgen(struct uuid *store, int count); }
393	UNIMPL		sendfile
394	UNIMPL		mac_syscall
395	UNIMPL		getfsstat
396	UNIMPL		statfs
397	UNIMPL		fsstatfs
398	UNIMPL		fhstatfs
399	UNIMPL		nosys
400	NOARGS		{ int|sys||_ksem_close(intptr_t id); }
401	NOARGS		{ int|sys||_ksem_post(intptr_t id); }
402	NOARGS		{ int|sys||_ksem_wait(intptr_t id); }
403	NOARGS		{ int|sys||_ksem_trywait(intptr_t id); }
404	UNIMPL		ksem_init
405	UNIMPL		ksem_open
406	NOARGS		{ int|sys||_ksem_unlink(const char *name); }
407	NOARGS		{ int|sys||_ksem_getvalue(intptr_t id, \
			    unsigned int *value); }
408	NOARGS		{ int|sys||_ksem_destroy(intptr_t id); }
409	UNIMPL		__mac_get_pid
410	UNIMPL		__mac_get_link
411	UNIMPL		__mac_set_link
412	UNIMPL		extattr_set_link
413	UNIMPL		extattr_get_link
414	UNIMPL		extattr_delete_link
415	UNIMPL		__mac_execve
416	UNIMPL		sigaction
417	UNIMPL		sigreturn
418	UNIMPL		__xstat
419	UNIMPL		__xfstat
420	UNIMPL		__xlstat
421	UNIMPL		getcontext
422	UNIMPL		setcontext
423	UNIMPL		swapcontext
424	UNIMPL		swapoff
425	UNIMPL		__acl_get_link
426	UNIMPL		__acl_set_link
427	UNIMPL		__acl_delete_link
428	UNIMPL		__acl_aclcheck_link
429	UNIMPL		sigwait
430	UNIMPL		thr_create
431	UNIMPL		thr_exit
432	UNIMPL		thr_self
433	UNIMPL		thr_kill
434	UNIMPL		_umtx_lock
435	UNIMPL		_umtx_unlock
436	UNIMPL		jail_attach
437	UNIMPL		extattr_list_fd
438	UNIMPL		extattr_list_file
439	UNIMPL		extattr_list_link