Fix manpage links.
[dragonfly.git] / sys / kern / syscalls.master
1  $DragonFly: src/sys/kern/syscalls.master,v 1.24 2005/07/23 23:26:50 joerg Exp $
2
3 ; @(#)syscalls.master   8.2 (Berkeley) 1/13/94
4 ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
5 ;
6 ; System call name/number master file.
7 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
8
9 ; Columns: number [MPSAFE] type nargs namespc name alt{name,tag,rtyp}/comments
10 ;       number  system call number, must be in order
11 ;   MPSAFE      optional field, specifies that syscall does not want the
12 ;               BGL grabbed automatically (it is SMP safe).
13 ;       type    one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
14 ;               NODEF, NOARGS, NOPROTO, NOIMPL
15 ;       namespc one of POSIX, BSD, NOHIDE
16 ;       name    psuedo-prototype of syscall routine
17 ;               If one of the following alts is different, then all appear:
18 ;       altname name of system call if different
19 ;       alttag  name of args struct tag if different from [o]`name'"_args"
20 ;       altrtyp return type if not int (bogus - syscalls always return int)
21 ;               for UNIMPL/OBSOL, name continues with comments
22
23 ; types:
24 ;       STD     always included
25 ;       COMPAT  included on COMPAT #ifdef
26 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
27 ;       OBSOL   obsolete, not included in system, only specifies name
28 ;       UNIMPL  not implemented, placeholder only
29
30 ; #ifdef's, etc. may be included, and are copied to the output files.
31
32 #include <sys/param.h>
33 #include <sys/sysent.h>
34 #include <sys/sysproto.h>
35
36 ; Reserved/unimplemented system calls in the range 0-150 inclusive
37 ; are reserved for use in future Berkeley releases.
38 ; Additional system calls implemented in vendor and other
39 ; redistributions should be placed in the reserved range at the end
40 ; of the current calls.
41
42 0       STD     NOHIDE  { int nosys(void); } syscall nosys_args int
43 1       STD     NOHIDE  { void sys_exit(int rval); } exit sys_exit_args void
44 2       STD     POSIX   { int fork(void); }
45 3       STD     POSIX   { ssize_t read(int fd, void *buf, size_t nbyte); }
46 4       STD     POSIX   { ssize_t write(int fd, const void *buf, size_t nbyte); }
47 5       STD     POSIX   { int open(char *path, int flags, int mode); }
48 ; XXX should be         { int open(const char *path, int flags, ...); }
49 ; but we're not ready for `const' or varargs.
50 ; XXX man page says `mode_t mode'.
51 6       STD     POSIX   { int close(int fd); }
52 7       STD     BSD     { int wait4(int pid, int *status, int options, \
53                             struct rusage *rusage); } wait4 wait_args int
54 8       COMPAT  BSD     { int creat(char *path, int mode); }
55 9       STD     POSIX   { int link(char *path, char *link); }
56 10      STD     POSIX   { int unlink(char *path); }
57 11      OBSOL   NOHIDE  execv
58 12      STD     POSIX   { int chdir(char *path); }
59 13      STD     BSD     { int fchdir(int fd); }
60 14      STD     POSIX   { int mknod(char *path, int mode, int dev); }
61 15      STD     POSIX   { int chmod(char *path, int mode); }
62 16      STD     POSIX   { int chown(char *path, int uid, int gid); }
63 17      STD     BSD     { int obreak(char *nsize); } break obreak_args int
64 18      STD     BSD     { int getfsstat(struct statfs *buf, long bufsize, \
65                             int flags); }
66 19      COMPAT  POSIX   { long lseek(int fd, long offset, int whence); }
67 20      STD     POSIX   { pid_t getpid(void); }
68 21      STD     BSD     { int mount(char *type, char *path, int flags, \
69                             caddr_t data); }
70 ; XXX `path' should have type `const char *' but we're not ready for that.
71 22      STD     BSD     { int unmount(char *path, int flags); }
72 23      STD     POSIX   { int setuid(uid_t uid); }
73 24      MPSAFE  STD     POSIX   { uid_t getuid(void); }
74 25      MPSAFE  STD     POSIX   { uid_t geteuid(void); }
75 26      STD     BSD     { int ptrace(int req, pid_t pid, caddr_t addr, \
76                             int data); }
77 27      STD     BSD     { int recvmsg(int s, struct msghdr *msg, int flags); }
78 28      STD     BSD     { int sendmsg(int s, caddr_t msg, int flags); }
79 29      STD     BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
80                             int flags, caddr_t from, int *fromlenaddr); }
81 30      STD     BSD     { int accept(int s, caddr_t name, int *anamelen); }
82 31      STD     BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
83 32      STD     BSD     { int getsockname(int fdes, caddr_t asa, int *alen); }
84 33      STD     POSIX   { int access(char *path, int flags); }
85 34      STD     BSD     { int chflags(char *path, int flags); }
86 35      STD     BSD     { int fchflags(int fd, int flags); }
87 36      STD     BSD     { int sync(void); }
88 37      STD     POSIX   { int kill(int pid, int signum); }
89 38      COMPAT  POSIX   { int stat(char *path, struct ostat *ub); }
90 39      STD     POSIX   { pid_t getppid(void); }
91 40      COMPAT  POSIX   { int lstat(char *path, struct ostat *ub); }
92 41      STD     POSIX   { int dup(u_int fd); }
93 42      STD     POSIX   { int pipe(void); }
94 43      STD     POSIX   { gid_t getegid(void); }
95 44      STD     BSD     { int profil(caddr_t samples, size_t size, \
96                             size_t offset, u_int scale); }
97 45      STD     BSD     { int ktrace(const char *fname, int ops, int facs, \
98                             int pid); }
99 46      OBSOL   NOHIDE  freebsd3_sigaction
100 47      MPSAFE  STD     POSIX   { gid_t getgid(void); }
101 48      OBSOL   NOHIDE  freebsd3_sigprocmask
102 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
103 ; us the mask, not a pointer to it, and we return the old mask as the
104 ; (int) return value.
105 49      STD     BSD     { int getlogin(char *namebuf, u_int namelen); }
106 50      STD     BSD     { int setlogin(char *namebuf); }
107 51      STD     BSD     { int acct(char *path); }
108 52      OBSOL   NOHIDE  freebsd3_sigpending
109 53      STD     BSD     { int sigaltstack(stack_t *ss, stack_t *oss); }
110 54      STD     POSIX   { int ioctl(int fd, u_long com, caddr_t data); }
111 55      STD     BSD     { int reboot(int opt); }
112 56      STD     POSIX   { int revoke(char *path); }
113 57      STD     POSIX   { int symlink(char *path, char *link); }
114 58      STD     POSIX   { int readlink(char *path, char *buf, int count); }
115 59      STD     POSIX   { int execve(char *fname, char **argv, char **envv); }
116 60      MPSAFE  STD     POSIX   { int umask(int newmask); } umask umask_args int
117 61      STD     BSD     { int chroot(char *path); }
118 62      COMPAT  POSIX   { int fstat(int fd, struct ostat *sb); }
119 63      COMPAT  BSD     { int getkerninfo(int op, char *where, size_t *size, \
120                             int arg); } getkerninfo getkerninfo_args int
121 64      COMPAT  BSD     { int getpagesize(void); } \
122                             getpagesize getpagesize_args int
123 65      STD     BSD     { int msync(void *addr, size_t len, int flags); }
124 66      STD     BSD     { int vfork(void); }
125 67      OBSOL   NOHIDE  vread
126 68      OBSOL   NOHIDE  vwrite
127 69      STD     BSD     { int sbrk(int incr); }
128 70      STD     BSD     { int sstk(int incr); }
129 71      COMPAT  BSD     { int mmap(void *addr, int len, int prot, \
130                             int flags, int fd, long pos); }
131 72      STD     BSD     { int ovadvise(int anom); } vadvise ovadvise_args int
132 73      STD     BSD     { int munmap(void *addr, size_t len); }
133 74      STD     BSD     { int mprotect(const void *addr, size_t len, int prot); }
134 75      STD     BSD     { int madvise(void *addr, size_t len, int behav); }
135 76      OBSOL   NOHIDE  vhangup
136 77      OBSOL   NOHIDE  vlimit
137 78      STD     BSD     { int mincore(const void *addr, size_t len, \
138                             char *vec); }
139 79      STD     POSIX   { int getgroups(u_int gidsetsize, gid_t *gidset); }
140 80      STD     POSIX   { int setgroups(u_int gidsetsize, gid_t *gidset); }
141 81      MPSAFE  STD     POSIX   { int getpgrp(void); }
142 82      STD     POSIX   { int setpgid(int pid, int pgid); }
143 83      STD     BSD     { int setitimer(u_int which, struct itimerval *itv, \
144                             struct itimerval *oitv); }
145 84      COMPAT  BSD     { int wait(void); }
146 85      STD     BSD     { int swapon(char *name); }
147 86      STD     BSD     { int getitimer(u_int which, struct itimerval *itv); }
148 87      COMPAT  BSD     { int gethostname(char *hostname, u_int len); } \
149                             gethostname gethostname_args int
150 88      COMPAT  BSD     { int sethostname(char *hostname, u_int len); } \
151                             sethostname sethostname_args int
152 89      STD     BSD     { int getdtablesize(void); }
153 90      STD     POSIX   { int dup2(u_int from, u_int to); }
154 91      UNIMPL  BSD     getdopt
155 92      STD     POSIX   { int fcntl(int fd, int cmd, long arg); }
156 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
157 ; but we're not ready for varargs.
158 ; XXX man page says `int arg' too.
159 93      STD     BSD     { int select(int nd, fd_set *in, fd_set *ou, \
160                             fd_set *ex, struct timeval *tv); }
161 94      UNIMPL  BSD     setdopt
162 95      STD     POSIX   { int fsync(int fd); }
163 96      STD     BSD     { int setpriority(int which, int who, int prio); }
164 97      STD     BSD     { int socket(int domain, int type, int protocol); }
165 98      STD     BSD     { int connect(int s, caddr_t name, int namelen); }
166 99      CPT_NOA BSD     { int accept(int s, caddr_t name, int *anamelen); } \
167                             accept accept_args int
168 100     STD     BSD     { int getpriority(int which, int who); }
169 101     COMPAT  BSD     { int send(int s, caddr_t buf, int len, int flags); }
170 102     COMPAT  BSD     { int recv(int s, caddr_t buf, int len, int flags); }
171 103     OBSOL   NOHIDE  freebsd3_sigreturn
172 104     STD     BSD     { int bind(int s, caddr_t name, int namelen); }
173 105     STD     BSD     { int setsockopt(int s, int level, int name, \
174                             caddr_t val, int valsize); }
175 106     STD     BSD     { int listen(int s, int backlog); }
176 107     OBSOL   NOHIDE  vtimes
177 108     COMPAT  BSD     { int sigvec(int signum, struct sigvec *nsv, \
178                             struct sigvec *osv); }
179 109     COMPAT  BSD     { int sigblock(int mask); }
180 110     COMPAT  BSD     { int sigsetmask(int mask); }
181 111     OBSOL   NOHIDE  freebsd3_sigsuspend
182 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
183 ; us the mask, not a pointer to it.
184 112     COMPAT  BSD     { int sigstack(struct sigstack *nss, \
185                             struct sigstack *oss); }
186 113     COMPAT  BSD     { int recvmsg(int s, struct omsghdr *msg, int flags); }
187 114     COMPAT  BSD     { int sendmsg(int s, caddr_t msg, int flags); }
188 115     OBSOL   NOHIDE  vtrace
189 116     MPSAFE  STD     BSD     { int gettimeofday(struct timeval *tp, \
190                             struct timezone *tzp); }
191 117     STD     BSD     { int getrusage(int who, struct rusage *rusage); }
192 118     STD     BSD     { int getsockopt(int s, int level, int name, \
193                             caddr_t val, int *avalsize); }
194 119     UNIMPL  NOHIDE  resuba (BSD/OS 2.x)
195 120     STD     BSD     { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
196 121     STD     BSD     { int writev(int fd, struct iovec *iovp, \
197                             u_int iovcnt); }
198 122     STD     BSD     { int settimeofday(struct timeval *tv, \
199                             struct timezone *tzp); }
200 123     STD     BSD     { int fchown(int fd, int uid, int gid); }
201 124     STD     BSD     { int fchmod(int fd, int mode); }
202 125     CPT_NOA BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
203                             int flags, caddr_t from, int *fromlenaddr); } \
204                             recvfrom recvfrom_args int
205 126     STD     BSD     { int setreuid(int ruid, int euid); }
206 127     STD     BSD     { int setregid(int rgid, int egid); }
207 128     STD     POSIX   { int rename(char *from, char *to); }
208 129     COMPAT  BSD     { int truncate(char *path, long length); }
209 130     COMPAT  BSD     { int ftruncate(int fd, long length); }
210 131     STD     BSD     { int flock(int fd, int how); }
211 132     STD     POSIX   { int mkfifo(char *path, int mode); }
212 133     STD     BSD     { int sendto(int s, caddr_t buf, size_t len, \
213                             int flags, caddr_t to, int tolen); }
214 134     STD     BSD     { int shutdown(int s, int how); }
215 135     STD     BSD     { int socketpair(int domain, int type, int protocol, \
216                             int *rsv); }
217 136     STD     POSIX   { int mkdir(char *path, int mode); }
218 137     STD     POSIX   { int rmdir(char *path); }
219 138     STD     BSD     { int utimes(char *path, struct timeval *tptr); }
220 139     OBSOL   NOHIDE  4.2 sigreturn
221 140     STD     BSD     { int adjtime(struct timeval *delta, \
222                             struct timeval *olddelta); }
223 141     COMPAT  BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
224 142     COMPAT  BSD     { long gethostid(void); }
225 143     COMPAT  BSD     { int sethostid(long hostid); }
226 144     COMPAT  BSD     { int getrlimit(u_int which, struct orlimit *rlp); }
227 145     COMPAT  BSD     { int setrlimit(u_int which, struct orlimit *rlp); }
228 146     COMPAT  BSD     { int killpg(int pgid, int signum); }
229 147     STD     POSIX   { int setsid(void); }
230 148     STD     BSD     { int quotactl(char *path, int cmd, int uid, \
231                             caddr_t arg); }
232 149     COMPAT  BSD     { int quota(void); }
233 150     CPT_NOA BSD     { int getsockname(int fdec, caddr_t asa, int *alen); }\
234                             getsockname getsockname_args int
235
236 ; Syscalls 151-180 inclusive are reserved for vendor-specific
237 ; system calls.  (This includes various calls added for compatibity
238 ; with other Unix variants.)
239 ; Some of these calls are now supported by BSD...
240 151     UNIMPL  NOHIDE  sem_lock (BSD/OS 2.x)
241 152     UNIMPL  NOHIDE  sem_wakeup (BSD/OS 2.x)
242 153     UNIMPL  NOHIDE  asyncdaemon (BSD/OS 2.x)
243 154     UNIMPL  NOHIDE  nosys
244 ; 155 is initialized by the NFS code, if present.
245 155     NOIMPL  BSD     { int nfssvc(int flag, caddr_t argp); }
246 156     COMPAT  BSD     { int getdirentries(int fd, char *buf, u_int count, \
247                             long *basep); }
248 157     STD     BSD     { int statfs(char *path, struct statfs *buf); }
249 158     STD     BSD     { int fstatfs(int fd, struct statfs *buf); }
250 159     UNIMPL  NOHIDE  nosys
251 160     UNIMPL  NOHIDE  nosys
252 ; 161 is initialized by the NFS code, if present.
253 161     STD     BSD     { int getfh(char *fname, struct fhandle *fhp); }
254 162     STD     BSD     { int getdomainname(char *domainname, int len); }
255 163     STD     BSD     { int setdomainname(char *domainname, int len); }
256 164     STD     BSD     { int uname(struct utsname *name); }
257 165     STD     BSD     { int sysarch(int op, char *parms); }
258 166     STD     BSD     { int rtprio(int function, pid_t pid, \
259                             struct rtprio *rtp); }
260 167     UNIMPL  NOHIDE  nosys
261 168     UNIMPL  NOHIDE  nosys
262 169     STD     BSD     { int semsys(int which, int a2, int a3, int a4, \
263                             int a5); }
264 ; XXX should be         { int semsys(int which, ...); }
265 170     STD     BSD     { int msgsys(int which, int a2, int a3, int a4, \
266                             int a5, int a6); }
267 ; XXX should be         { int msgsys(int which, ...); }
268 171     STD     BSD     { int shmsys(int which, int a2, int a3, int a4); }
269 ; XXX should be         { int shmsys(int which, ...); }
270 172     UNIMPL  NOHIDE  nosys
271 173     STD     POSIX   { ssize_t pread(int fd, void *buf, size_t nbyte, \
272                             int pad, off_t offset); }
273 174     STD     POSIX   { ssize_t pwrite(int fd, const void *buf, \
274                             size_t nbyte, int pad, off_t offset); }
275 175     UNIMPL  NOHIDE  nosys
276 176     STD     BSD     { int ntp_adjtime(struct timex *tp); }
277 177     UNIMPL  NOHIDE  sfork (BSD/OS 2.x)
278 178     UNIMPL  NOHIDE  getdescriptor (BSD/OS 2.x)
279 179     UNIMPL  NOHIDE  setdescriptor (BSD/OS 2.x)
280 180     UNIMPL  NOHIDE  nosys
281
282 ; Syscalls 181-199 are used by/reserved for BSD
283 181     STD     POSIX   { int setgid(gid_t gid); }
284 182     STD     BSD     { int setegid(gid_t egid); }
285 183     STD     BSD     { int seteuid(uid_t euid); }
286 184     UNIMPL  BSD     lfs_bmapv
287 185     UNIMPL  BSD     lfs_markv
288 186     UNIMPL  BSD     lfs_segclean
289 187     UNIMPL  BSD     lfs_segwait
290 188     STD     POSIX   { int stat(char *path, struct stat *ub); }
291 189     STD     POSIX   { int fstat(int fd, struct stat *sb); }
292 190     STD     POSIX   { int lstat(char *path, struct stat *ub); }
293 191     STD     POSIX   { int pathconf(char *path, int name); }
294 192     STD     POSIX   { int fpathconf(int fd, int name); }
295 193     UNIMPL  NOHIDE  nosys
296 194     STD     BSD     { int getrlimit(u_int which, \
297                             struct rlimit *rlp); } \
298                             getrlimit __getrlimit_args int
299 195     STD     BSD     { int setrlimit(u_int which, \
300                             struct rlimit *rlp); } \
301                             setrlimit __setrlimit_args int
302 196     STD     BSD     { int getdirentries(int fd, char *buf, u_int count, \
303                             long *basep); }
304 197     STD     BSD     { caddr_t mmap(caddr_t addr, size_t len, int prot, \
305                             int flags, int fd, int pad, off_t pos); }
306 198     STD     NOHIDE  { int nosys(void); } __syscall __syscall_args int
307 199     STD     POSIX   { off_t lseek(int fd, int pad, off_t offset, \
308                             int whence); }
309 200     STD     BSD     { int truncate(char *path, int pad, off_t length); }
310 201     STD     BSD     { int ftruncate(int fd, int pad, off_t length); }
311 202     STD     BSD     { int __sysctl(int *name, u_int namelen, void *old, \
312                             size_t *oldlenp, void *new, size_t newlen); } \
313                             __sysctl sysctl_args int
314 ; properly, __sysctl should be a NOHIDE, but making an exception
315 ; here allows to avoid one in libc/sys/Makefile.inc.
316 203     STD     BSD     { int mlock(const void *addr, size_t len); }
317 204     STD     BSD     { int munlock(const void *addr, size_t len); }
318 205     STD     BSD     { int undelete(char *path); }
319 206     STD     BSD     { int futimes(int fd, struct timeval *tptr); }
320 207     STD     BSD     { int getpgid(pid_t pid); }
321 208     UNIMPL  NOHIDE  newreboot (NetBSD)
322 209     STD     BSD     { int poll(struct pollfd *fds, u_int nfds, \
323                             int timeout); }
324
325 ;
326 ; The following are reserved for loadable syscalls
327 ;
328 ; 210 is used by the Checkpoint Module
329 210     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
330 211     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
331 212     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
332 213     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
333 214     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
334 215     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
335 216     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
336 217     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
337 218     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
338 219     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
339
340 ;
341 ; The following were introduced with NetBSD/4.4Lite-2
342 ;
343 220     STD     BSD     { int __semctl(int semid, int semnum, int cmd, \
344                             union semun *arg); }
345 221     STD     BSD     { int semget(key_t key, int nsems, int semflg); }
346 222     STD     BSD     { int semop(int semid, struct sembuf *sops, \
347                             u_int nsops); }
348 223     UNIMPL  NOHIDE  semconfig
349 224     STD     BSD     { int msgctl(int msqid, int cmd, \
350                             struct msqid_ds *buf); }
351 225     STD     BSD     { int msgget(key_t key, int msgflg); }
352 226     STD     BSD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
353                             int msgflg); }
354 227     STD     BSD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
355                             long msgtyp, int msgflg); }
356 228     STD     BSD     { int shmat(int shmid, void *shmaddr, int shmflg); }
357 229     STD     BSD     { int shmctl(int shmid, int cmd, \
358                             struct shmid_ds *buf); }
359 230     STD     BSD     { int shmdt(void *shmaddr); }
360 231     STD     BSD     { int shmget(key_t key, int size, int shmflg); }
361 ;
362 232     STD     POSIX   { int clock_gettime(clockid_t clock_id, \
363                             struct timespec *tp); }
364 233     STD     POSIX   { int clock_settime(clockid_t clock_id, \
365                             const struct timespec *tp); }
366 234     STD     POSIX   { int clock_getres(clockid_t clock_id, \
367                             struct timespec *tp); }
368 235     UNIMPL  NOHIDE  timer_create
369 236     UNIMPL  NOHIDE  timer_delete
370 237     UNIMPL  NOHIDE  timer_settime
371 238     UNIMPL  NOHIDE  timer_gettime
372 239     UNIMPL  NOHIDE  timer_getoverrun
373 240     STD     POSIX   { int nanosleep(const struct timespec *rqtp, \
374                             struct timespec *rmtp); }
375 241     UNIMPL  NOHIDE  nosys
376 242     UNIMPL  NOHIDE  nosys
377 243     UNIMPL  NOHIDE  nosys
378 244     UNIMPL  NOHIDE  nosys
379 245     UNIMPL  NOHIDE  nosys
380 246     UNIMPL  NOHIDE  nosys
381 247     UNIMPL  NOHIDE  nosys
382 248     UNIMPL  NOHIDE  nosys
383 249     UNIMPL  NOHIDE  nosys
384 ; syscall numbers initially used in OpenBSD
385 250     STD     BSD     { int minherit(void *addr, size_t len, int inherit); }
386 251     STD     BSD     { int rfork(int flags); }
387 252     STD     BSD     { int openbsd_poll(struct pollfd *fds, u_int nfds, \
388                             int timeout); }
389 253     STD     BSD     { int issetugid(void); }
390 254     STD     BSD     { int lchown(char *path, int uid, int gid); }
391 255     UNIMPL  NOHIDE  nosys
392 256     UNIMPL  NOHIDE  nosys
393 257     UNIMPL  NOHIDE  nosys
394 258     UNIMPL  NOHIDE  nosys
395 259     UNIMPL  NOHIDE  nosys
396 260     UNIMPL  NOHIDE  nosys
397 261     UNIMPL  NOHIDE  nosys
398 262     UNIMPL  NOHIDE  nosys
399 263     UNIMPL  NOHIDE  nosys
400 264     UNIMPL  NOHIDE  nosys
401 265     UNIMPL  NOHIDE  nosys
402 266     UNIMPL  NOHIDE  nosys
403 267     UNIMPL  NOHIDE  nosys
404 268     UNIMPL  NOHIDE  nosys
405 269     UNIMPL  NOHIDE  nosys
406 270     UNIMPL  NOHIDE  nosys
407 271     UNIMPL  NOHIDE  nosys
408 272     STD     BSD     { int getdents(int fd, char *buf, size_t count); }
409 273     UNIMPL  NOHIDE  nosys
410 274     STD     BSD     { int lchmod(char *path, mode_t mode); }
411 275     NOPROTO BSD     { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
412 276     STD     BSD     { int lutimes(char *path, struct timeval *tptr); }
413 277     NOPROTO BSD     { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
414 278     OBSOL   BSD     { int nstat(char *path, struct nstat *ub); }
415 279     OBSOL   NOHIDE  { int nfstat(int fd, struct nstat *sb); }
416 280     OBSOL   NOHIDE  { int nlstat(char *path, struct nstat *ub); }
417 281     UNIMPL  NOHIDE  nosys
418 282     UNIMPL  NOHIDE  nosys
419 283     UNIMPL  NOHIDE  nosys
420 284     UNIMPL  NOHIDE  nosys
421 285     UNIMPL  NOHIDE  nosys
422 286     UNIMPL  NOHIDE  nosys
423 287     UNIMPL  NOHIDE  nosys
424 288     UNIMPL  NOHIDE  nosys
425 289     UNIMPL  NOHIDE  nosys
426 290     UNIMPL  NOHIDE  nosys
427 291     UNIMPL  NOHIDE  nosys
428 292     UNIMPL  NOHIDE  nosys
429 293     UNIMPL  NOHIDE  nosys
430 294     UNIMPL  NOHIDE  nosys
431 295     UNIMPL  NOHIDE  nosys
432 296     UNIMPL  NOHIDE  nosys
433 ; XXX 297 is 300 in NetBSD 
434 297     STD     BSD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
435 298     STD     BSD     { int fhopen(const struct fhandle *u_fhp, int flags); }
436 299     STD     BSD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
437 ; syscall numbers for FreeBSD
438 300     STD     BSD     { int modnext(int modid); }
439 301     STD     BSD     { int modstat(int modid, struct module_stat* stat); }
440 302     STD     BSD     { int modfnext(int modid); }
441 303     STD     BSD     { int modfind(const char *name); }
442 304     STD     BSD     { int kldload(const char *file); }
443 305     STD     BSD     { int kldunload(int fileid); }
444 306     STD     BSD     { int kldfind(const char *file); }
445 307     STD     BSD     { int kldnext(int fileid); }
446 308     STD     BSD     { int kldstat(int fileid, struct kld_file_stat* stat); }
447 309     STD     BSD     { int kldfirstmod(int fileid); }
448 310     STD     BSD     { int getsid(pid_t pid); }
449 311     STD     BSD     { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
450 312     STD     BSD     { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
451 313     OBSOL   NOHIDE  signanosleep
452 314     STD     BSD     { int aio_return(struct aiocb *aiocbp); }
453 315     STD     BSD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
454 316     STD     BSD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
455 317     STD     BSD     { int aio_error(struct aiocb *aiocbp); }
456 318     STD     BSD     { int aio_read(struct aiocb *aiocbp); }
457 319     STD     BSD     { int aio_write(struct aiocb *aiocbp); }
458 320     STD     BSD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
459 321     STD     BSD     { int yield(void); }
460 322     STD     BSD     { int thr_sleep(const struct timespec *timeout); }
461 323     STD     BSD     { int thr_wakeup(pid_t pid); }
462 324     STD     BSD     { int mlockall(int how); }
463 325     STD     BSD     { int munlockall(void); }
464 326     STD     BSD     { int __getcwd(u_char *buf, u_int buflen); }
465
466 327     STD     POSIX   { int sched_setparam (pid_t pid, const struct sched_param *param); }
467 328     STD     POSIX   { int sched_getparam (pid_t pid, struct sched_param *param); }
468
469 329     STD     POSIX   { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
470 330     STD     POSIX   { int sched_getscheduler (pid_t pid); }
471
472 331     STD     POSIX   { int sched_yield (void); }
473 332     STD     POSIX   { int sched_get_priority_max (int policy); }
474 333     STD     POSIX   { int sched_get_priority_min (int policy); }
475 334     STD     POSIX   { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
476 335     STD     BSD     { int utrace(const void *addr, size_t len); }
477 336     OBSOL   NOHIDE  freebsd4_sendfile
478 337     STD     BSD     { int kldsym(int fileid, int cmd, void *data); }
479 338     STD     BSD     { int jail(struct jail *jail); }
480 339     UNIMPL  BSD     pioctl
481 340     MPSAFE  STD     POSIX   { int sigprocmask(int how, const sigset_t *set, \
482                             sigset_t *oset); }
483 341     STD     POSIX   { int sigsuspend(const sigset_t *sigmask); }
484 342     STD     POSIX   { int sigaction(int sig, const struct sigaction *act, \
485                             struct sigaction *oact); }
486 343     STD     POSIX   { int sigpending(sigset_t *set); }
487 344     STD     BSD     { int sigreturn(ucontext_t *sigcntxp); }
488 345     STD     POSIX   { int sigtimedwait(const sigset_t *set,\
489                              siginfo_t *info, const struct timespec *timeout); }
490 346     STD     POSIX   { int sigwaitinfo(const sigset_t *set,\
491                              siginfo_t *info); }
492 347     STD     BSD     { int __acl_get_file(const char *path, \
493                             acl_type_t type, struct acl *aclp); }
494 348     STD     BSD     { int __acl_set_file(const char *path, \
495                             acl_type_t type, struct acl *aclp); }
496 349     STD     BSD     { int __acl_get_fd(int filedes, acl_type_t type, \
497                             struct acl *aclp); }
498 350     STD     BSD     { int __acl_set_fd(int filedes, acl_type_t type, \
499                             struct acl *aclp); }
500 351     STD     BSD     { int __acl_delete_file(const char *path, \
501                             acl_type_t type); }
502 352     STD     BSD     { int __acl_delete_fd(int filedes, acl_type_t type); }
503 353     STD     BSD     { int __acl_aclcheck_file(const char *path, \
504                             acl_type_t type, struct acl *aclp); }
505 354     STD     BSD     { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
506                             struct acl *aclp); }
507 355     STD     BSD     { int extattrctl(const char *path, int cmd, \
508                             const char *attrname, char *arg); }
509 356     STD     BSD     { int extattr_set_file(const char *path, \
510                             const char *attrname, struct iovec *iovp, \
511                             unsigned iovcnt); }
512 357     STD     BSD     { int extattr_get_file(const char *path, \
513                             const char *attrname, struct iovec *iovp, \
514                             unsigned iovcnt); }
515 358     STD     BSD     { int extattr_delete_file(const char *path, \
516                             const char *attrname); }
517 359     STD     BSD     { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
518 360     STD     BSD     { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
519 361     STD     BSD     { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
520 362     STD     BSD     { int kqueue(void); }
521 363     STD     BSD     { int kevent(int fd, \
522                             const struct kevent *changelist, int nchanges, \
523                             struct kevent *eventlist, int nevents, \
524                             const struct timespec *timeout); }
525 364     STD     BSD     { int sctp_peeloff(int sd, caddr_t name ); }
526 ; 365-392 used by FreeBSD-current
527 365     UNIMPL  NOHIDE  nosys
528 366     UNIMPL  NOHIDE  nosys
529 367     UNIMPL  NOHIDE  nosys
530 368     UNIMPL  NOHIDE  nosys
531 369     UNIMPL  NOHIDE  nosys
532 370     UNIMPL  NOHIDE  nosys
533 371     UNIMPL  NOHIDE  nosys
534 372     UNIMPL  NOHIDE  nosys
535 373     UNIMPL  NOHIDE  nosys
536 374     UNIMPL  NOHIDE  nosys
537 375     UNIMPL  NOHIDE  nosys
538 376     UNIMPL  NOHIDE  nosys
539 377     UNIMPL  NOHIDE  nosys
540 378     UNIMPL  NOHIDE  nosys
541 379     UNIMPL  NOHIDE  nosys
542 380     UNIMPL  NOHIDE  nosys
543 381     UNIMPL  NOHIDE  nosys
544 382     UNIMPL  NOHIDE  nosys
545 383     UNIMPL  NOHIDE  nosys
546 384     UNIMPL  NOHIDE  nosys
547 385     UNIMPL  NOHIDE  nosys
548 386     UNIMPL  NOHIDE  nosys
549 387     UNIMPL  NOHIDE  nosys
550 388     UNIMPL  NOHIDE  nosys
551 389     UNIMPL  NOHIDE  nosys
552 390     UNIMPL  NOHIDE  nosys
553 391     UNIMPL  NOHIDE  nosys
554 392     UNIMPL  NOHIDE  nosys
555 393     STD     BSD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
556                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
557 ; 394-439 used by FreeBSD-current
558 394     UNIMPL  NOHIDE  nosys
559 395     UNIMPL  NOHIDE  nosys
560 396     UNIMPL  NOHIDE  nosys
561 397     UNIMPL  NOHIDE  nosys
562 398     UNIMPL  NOHIDE  nosys
563 399     UNIMPL  NOHIDE  nosys
564 400     UNIMPL  NOHIDE  nosys
565 401     UNIMPL  NOHIDE  nosys
566 402     UNIMPL  NOHIDE  nosys
567 403     UNIMPL  NOHIDE  nosys
568 404     UNIMPL  NOHIDE  nosys
569 405     UNIMPL  NOHIDE  nosys
570 406     UNIMPL  NOHIDE  nosys
571 407     UNIMPL  NOHIDE  nosys
572 408     UNIMPL  NOHIDE  nosys
573 409     UNIMPL  NOHIDE  nosys
574 410     UNIMPL  NOHIDE  nosys
575 411     UNIMPL  NOHIDE  nosys
576 412     UNIMPL  NOHIDE  nosys
577 413     UNIMPL  NOHIDE  nosys
578 414     UNIMPL  NOHIDE  nosys
579 415     UNIMPL  NOHIDE  nosys
580 416     UNIMPL  NOHIDE  nosys
581 417     UNIMPL  NOHIDE  nosys
582 418     UNIMPL  NOHIDE  nosys
583 419     UNIMPL  NOHIDE  nosys
584 420     UNIMPL  NOHIDE  nosys
585 421     UNIMPL  NOHIDE  nosys
586 422     UNIMPL  NOHIDE  nosys
587 423     UNIMPL  NOHIDE  nosys
588 424     UNIMPL  NOHIDE  nosys
589 425     UNIMPL  NOHIDE  nosys
590 426     UNIMPL  NOHIDE  nosys
591 427     UNIMPL  NOHIDE  nosys
592 428     UNIMPL  NOHIDE  nosys
593 429     UNIMPL  NOHIDE  nosys
594 430     UNIMPL  NOHIDE  nosys
595 431     UNIMPL  NOHIDE  nosys
596 432     UNIMPL  NOHIDE  nosys
597 433     UNIMPL  NOHIDE  nosys
598 434     UNIMPL  NOHIDE  nosys
599 435     UNIMPL  NOHIDE  nosys
600 436     UNIMPL  NOHIDE  nosys
601 437     UNIMPL  NOHIDE  nosys
602 438     UNIMPL  NOHIDE  nosys
603 439     UNIMPL  NOHIDE  nosys
604 ; 440-449 reserved for FreeBSD-5.x growth
605 440     UNIMPL  NOHIDE  nosys
606 441     UNIMPL  NOHIDE  nosys
607 442     UNIMPL  NOHIDE  nosys
608 443     UNIMPL  NOHIDE  nosys
609 444     UNIMPL  NOHIDE  nosys
610 445     UNIMPL  NOHIDE  nosys
611 446     UNIMPL  NOHIDE  nosys
612 447     UNIMPL  NOHIDE  nosys
613 448     UNIMPL  NOHIDE  nosys
614 449     UNIMPL  NOHIDE  nosys
615 ; 450 DragonFly system calls
616 450     STD     BSD     { int varsym_set(int level, const char *name, const char *data); }
617 451     STD     BSD     { int varsym_get(int mask, const char *wild, char *buf, int bufsize); }
618 452     STD     BSD     { int varsym_list(int level, char *buf, int maxsize, int *marker); }
619 453     STD     BSD     { int upc_register(struct upcall *upc, void *ctxfunc, void *func, void *data); }
620 454     STD     BSD     { int upc_control(int cmd, int upcid, void *data); }
621 455     STD     BSD     { int caps_sys_service(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
622 456     STD     BSD     { int caps_sys_client(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
623 457     STD     BSD     { int caps_sys_close(int portid); }
624 458     STD     BSD     { off_t caps_sys_put(int portid, void *msg, int msgsize); }
625 459     STD     BSD     { int caps_sys_reply(int portid, void *msg, int msgsize, off_t msgcid); }
626 460     STD     BSD     { int caps_sys_get(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
627 461     STD     BSD     { int caps_sys_wait(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
628 462     STD     BSD     { int caps_sys_abort(int portid, off_t msgcid, int flags); }
629 463     STD     BSD     { off_t caps_sys_getgen(int portid); }
630 464     STD     BSD     { int caps_sys_setgen(int portid, off_t gen); }
631 465     STD     BSD     { int exec_sys_register(void *entry); }
632 466     STD     BSD     { int exec_sys_unregister(int id); }
633 467     STD     BSD     { int sys_checkpoint(int type, int fd, pid_t pid, int retval); }
634 468     STD     BSD     { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); }
635 469     STD     BSD     { int umtx_sleep(volatile const int *ptr, int value, int timeout); }
636 470     STD     BSD     { int umtx_wakeup(volatile const int *ptr, int count); }
637 471     STD     BSD     { int jail_attach(int jid); }
638 472     STD     BSD     { int sys_set_tls_area(int which, struct tls_info *info, size_t infosize); }
639 473     STD     BSD     { int sys_get_tls_area(int which, struct tls_info *info, size_t infosize); }
640 474     STD     BSD     { int closefrom(int fd); }
641