| blob | d3e48e5146920d86540f1add2b724b197726622a |
1 $NetBSD: syscalls.master,v 1.32 2009/01/13 21:06:47 pooka Exp $
3 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
5 ; NetBSD 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 ; EXCL implemented, but not included in system
18 ; NODEF included, but don't define the syscall number
19 ; NOARGS included, but don't define the syscall args structure
20 ; INDIR included, but don't define the syscall args structure,
21 ; and allow it to be "really" varargs.
22 ;
23 ; The compat options are defined in the syscalls.conf file, and the
24 ; compat option name is prefixed to the syscall name. Other than
25 ; that, they're like NODEF (for 'compat' options), or STD (for
26 ; 'libcompat' options).
27 ;
28 ; The type-dependent arguments are as follows:
29 ; For STD, NODEF, NOARGS, and compat syscalls:
30 ; { pseudo-proto } [alias]
31 ; For other syscalls:
32 ; [comment]
33 ;
34 ; #ifdef's, etc. may be included, and are copied to the output files.
35 ; #include's are copied to the syscall names and switch definition files only.
37 #if defined(_KERNEL_OPT)
38 #include "opt_ktrace.h"
39 #include "opt_nfsserver.h"
40 #include "opt_ntp.h"
41 #include "opt_compat_netbsd.h"
42 #include "opt_sysv.h"
43 #include "opt_compat_43.h"
45 #include "fs_lfs.h"
46 #include "fs_nfs.h"
47 #endif
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/signal.h>
52 #include <sys/mount.h>
53 #include <sys/sched.h>
54 #include <sys/syscallargs.h>
55 #include <compat/aoutm68k/aoutm68k_syscallargs.h>
57 %%
59 ; Reserved/unimplemented system calls in the range 0-150 inclusive
60 ; are reserved for use in future Berkeley releases.
61 ; Additional system calls implemented in vendor and other
62 ; redistributions should be placed in the reserved range at the end
63 ; of the current calls.
65 0 NOARGS INDIR { int|sys||syscall(int code, \
66 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); }
67 1 NOARGS { void|sys||exit(int rval); }
68 2 NOARGS { int|sys||fork(void); }
69 3 NOARGS { ssize_t|sys||read(int fd, void *buf, size_t nbyte); }
70 4 NOARGS { ssize_t|sys||write(int fd, const void *buf, \
71 size_t nbyte); }
72 5 NOARGS { int|sys||open(const char *path, int flags, \
73 ... mode_t mode); }
74 6 NOARGS { int|sys||close(int fd); }
75 7 NOARGS { int|compat_50_sys||wait4(int pid, int *status, \
76 int options, struct rusage50 *rusage); }
77 #if defined(COMPAT_43) || !defined(_KERNEL)
78 8 NOARGS { int|compat_43_sys||creat(const char *path, \
79 mode_t mode); } ocreat
80 #else
81 8 EXCL compat_43_sys_creat
82 #endif
83 9 NOARGS { int|sys||link(const char *path, const char *link); }
84 10 NOARGS { int|sys||unlink(const char *path); }
85 11 OBSOL execv
86 12 NOARGS { int|sys||chdir(const char *path); }
87 13 NOARGS { int|sys||fchdir(int fd); }
88 14 NOARGS { int|compat_50_sys||mknod(const char *path, \
89 mode_t mode, dev_t dev); }
90 15 NOARGS { int|sys||chmod(const char *path, mode_t mode); }
91 16 NOARGS { int|sys||chown(const char *path, uid_t uid, \
92 gid_t gid); }
93 17 NOARGS { int|sys||obreak(char *nsize); } break
94 #if defined(COMPAT_20) || !defined(_KERNEL)
95 18 NOARGS { int|compat_20_sys||getfsstat(struct statfs12 *buf, \
96 long bufsize, int flags); }
97 #else
98 18 EXCL compat_20_sys_getfsstat
99 #endif
100 #if defined(COMPAT_43) || !defined(_KERNEL)
101 19 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \
102 int whence); } olseek
103 #else
104 19 EXCL compat_43_sys_lseek
105 #endif
106 20 NOARGS { pid_t|sys||getpid(void); }
107 21 NOARGS { int|compat_40_sys||mount(const char *type, \
108 const char *path, int flags, void *data); }
109 22 NOARGS { int|sys||unmount(const char *path, int flags); }
110 23 NOARGS { int|sys||setuid(uid_t uid); }
111 24 NOARGS { uid_t|sys||getuid(void); }
112 25 NOARGS { uid_t|sys||geteuid(void); }
113 26 NOARGS { int|sys||ptrace(int req, pid_t pid, void *addr, \
114 int data); }
115 27 NOARGS { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \
116 int flags); }
117 28 NOARGS { ssize_t|sys||sendmsg(int s, \
118 const struct msghdr *msg, int flags); }
119 29 NOARGS { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \
120 int flags, struct sockaddr *from, \
121 unsigned int *fromlenaddr); }
122 30 NOARGS { int|sys||accept(int s, struct sockaddr *name, \
123 unsigned int *anamelen); }
124 31 NOARGS { int|sys||getpeername(int fdes, struct sockaddr *asa, \
125 unsigned int *alen); }
126 32 NOARGS { int|sys||getsockname(int fdes, struct sockaddr *asa, \
127 unsigned int *alen); }
128 33 NOARGS { int|sys||access(const char *path, int flags); }
129 34 NOARGS { int|sys||chflags(const char *path, u_long flags); }
130 35 NOARGS { int|sys||fchflags(int fd, u_long flags); }
131 36 NOARGS { void|sys||sync(void); }
132 37 NOARGS { int|sys||kill(int pid, int signum); }
133 #if defined(COMPAT_43) || !defined(_KERNEL)
134 38 STD { int|aoutm68k_compat_43_sys||stat(const char *path, \
135 struct aoutm68k_stat43 *ub); } stat43
136 #else
137 38 EXCL aoutm68k_compat_43_sys_stat
138 #endif
139 39 NOARGS { pid_t|sys||getppid(void); }
140 #if defined(COMPAT_43) || !defined(_KERNEL)
141 40 STD { int|aoutm68k_compat_43_sys||lstat(const char *path, \
142 struct aoutm68k_stat43 *ub); } lstat43
143 #else
144 40 EXCL aoutm68k_compat_43_sys_lstat
145 #endif
146 41 NOARGS { int|sys||dup(int fd); }
147 42 NOARGS { int|sys||pipe(void); }
148 43 NOARGS { gid_t|sys||getegid(void); }
149 44 NOARGS { int|sys||profil(void *samples, size_t size, \
150 u_long offset, u_int scale); }
151 #if defined(KTRACE) || !defined(_KERNEL)
152 45 NOARGS { int|sys||ktrace(const char *fname, int ops, \
153 int facs, int pid); }
154 #else
155 45 EXCL ktrace
156 #endif
157 #if defined(COMPAT_13) || !defined(_KERNEL)
158 46 NOARGS { int|compat_13_sys||sigaction(int signum, \
159 const struct sigaction13 *nsa, \
160 struct sigaction13 *osa); } sigaction13
161 #else
162 46 EXCL compat_13_sys_sigaction
163 #endif
164 47 NOARGS { gid_t|sys||getgid(void); }
165 #if defined(COMPAT_13) || !defined(_KERNEL)
166 48 NOARGS { int|compat_13_sys||sigprocmask(int how, \
167 int mask); } sigprocmask13
168 #else
169 48 EXCL compat_13_sys_sigprocmask
170 #endif
171 49 NOARGS { int|sys||__getlogin(char *namebuf, size_t namelen); }
172 50 NOARGS { int|sys||__setlogin(const char *namebuf); }
173 51 NOARGS { int|sys||acct(const char *path); }
174 #if defined(COMPAT_13) || !defined(_KERNEL)
175 52 NOARGS { int|compat_13_sys||sigpending(void); } sigpending13
176 53 NOARGS { int|compat_13_sys||sigaltstack( \
177 const struct sigaltstack13 *nss, \
178 struct sigaltstack13 *oss); } sigaltstack13
179 #else
180 52 EXCL compat_13_sys_sigpending
181 53 EXCL compat_13_sys_sigaltstack
182 #endif
183 54 NOARGS { int|sys||ioctl(int fd, u_long com, ... void *data); }
184 #if defined(COMPAT_12) || !defined(_KERNEL)
185 55 NOARGS { int|compat_12_sys||reboot(int opt); } oreboot
186 #else
187 55 EXCL compat_12_sys_reboot
188 #endif
189 56 NOARGS { int|sys||revoke(const char *path); }
190 57 NOARGS { int|sys||symlink(const char *path, \
191 const char *link); }
192 58 NOARGS { int|sys||readlink(const char *path, \
193 char *buf, size_t count); }
194 59 NOARGS { int|sys||execve(const char *path, \
195 char * const *argp, char * const *envp); }
196 60 NOARGS { mode_t|sys||umask(mode_t newmask); }
197 61 NOARGS { int|sys||chroot(const char *path); }
198 #if defined(COMPAT_43) || !defined(_KERNEL)
199 62 STD { int|aoutm68k_compat_43_sys||fstat(int fd, \
200 struct aoutm68k_stat43 *sb); } fstat43
201 63 NOARGS { int|compat_43_sys||getkerninfo(int op, char *where, \
202 int *size, int arg); } ogetkerninfo
203 64 NOARGS { int|compat_43_sys||getpagesize(void); } ogetpagesize
204 #else
205 62 EXCL aoutm68k_compat_43_sys_fstat
206 63 EXCL compat_43_sys_getkerninfo
207 64 EXCL compat_43_sys_getpagesize
208 #endif
209 #if defined(COMPAT_12) || !defined(_KERNEL)
210 65 NOARGS { int|compat_12_sys||msync(void *addr, size_t len); }
211 #else
212 65 EXCL compat_12_sys_msync
213 #endif
214 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
215 66 NOARGS { int|sys||vfork(void); }
216 67 OBSOL vread
217 68 OBSOL vwrite
218 69 NOARGS { int|sys||sbrk(intptr_t incr); }
219 70 NOARGS { int|sys||sstk(int incr); }
220 #if defined(COMPAT_43) || !defined(_KERNEL)
221 71 NOARGS { int|compat_43_sys||mmap(void *addr, size_t len, \
222 int prot, int flags, int fd, long pos); } ommap
223 #else
224 71 EXCL compat_43_sys_mmap
225 #endif
226 72 NOARGS { int|sys||ovadvise(int anom); } vadvise
227 73 NOARGS { int|sys||munmap(void *addr, size_t len); }
228 74 NOARGS { int|sys||mprotect(void *addr, size_t len, \
229 int prot); }
230 75 NOARGS { int|sys||madvise(void *addr, size_t len, \
231 int behav); }
232 76 OBSOL vhangup
233 77 OBSOL vlimit
234 78 NOARGS { int|sys||mincore(void *addr, size_t len, \
235 char *vec); }
236 79 NOARGS { int|sys||getgroups(int gidsetsize, \
237 gid_t *gidset); }
238 80 NOARGS { int|sys||setgroups(int gidsetsize, \
239 const gid_t *gidset); }
240 81 NOARGS { int|sys||getpgrp(void); }
241 82 NOARGS { int|sys||setpgid(int pid, int pgid); }
242 83 NOARGS { int|compat_50_sys||setitimer(int which, \
243 const struct itimerval50 *itv, \
244 struct itimerval50 *oitv); }
245 #if defined(COMPAT_43) || !defined(_KERNEL)
246 84 NOARGS { int|compat_43_sys||wait(void); } owait
247 #else
248 84 EXCL compat_43_sys_wait
249 #endif
250 #if defined(COMPAT_12) || !defined(_KERNEL)
251 85 NOARGS { int|compat_12_sys||swapon(const char *name); } oswapon
252 #else
253 85 EXCL compat_12_sys_swapon
254 #endif
255 86 NOARGS { int|compat_50_sys||getitimer(int which, \
256 struct itimerval50 *itv); }
257 #if defined(COMPAT_43) || !defined(_KERNEL)
258 87 NOARGS { int|compat_43_sys||gethostname(char *hostname, \
259 u_int len); } ogethostname
260 88 NOARGS { int|compat_43_sys||sethostname(char *hostname, \
261 u_int len); } osethostname
262 89 NOARGS { int|compat_43_sys||getdtablesize(void); } \
263 ogetdtablesize
264 #else
265 87 EXCL compat_43_sys_gethostname
266 88 EXCL compat_43_sys_sethostname
267 89 EXCL compat_43_sys_getdtablesize
268 #endif
269 90 NOARGS { int|sys||dup2(int from, int to); }
270 91 UNIMPL getdopt
271 92 NOARGS { int|sys||fcntl(int fd, int cmd, ... void *arg); }
272 93 NOARGS { int|compat_50_sys||select(int nd, fd_set *in, \
273 fd_set *ou, fd_set *ex, struct timeval50 *tv); }
274 94 UNIMPL setdopt
275 95 NOARGS { int|sys||fsync(int fd); }
276 96 NOARGS { int|sys||setpriority(int which, int who, int prio); }
277 97 NOARGS { int|compat_30_sys||socket(int domain, int type, int protocol); }
278 98 NOARGS { int|sys||connect(int s, const struct sockaddr *name, \
279 int namelen); }
280 #if defined(COMPAT_43) || !defined(_KERNEL)
281 99 NOARGS { int|compat_43_sys||accept(int s, void *name, \
282 int *anamelen); } oaccept
283 #else
284 99 EXCL compat_43_sys_accept
285 #endif
286 100 NOARGS { int|sys||getpriority(int which, int who); }
287 #if defined(COMPAT_43) || !defined(_KERNEL)
288 101 NOARGS { int|compat_43_sys||send(int s, void *buf, int len, \
289 int flags); } osend
290 102 NOARGS { int|compat_43_sys||recv(int s, void *buf, int len, \
291 int flags); } orecv
292 #else
293 101 EXCL compat_43_sys_send
294 102 EXCL compat_43_sys_recv
295 #endif
296 #if defined(COMPAT_13) || !defined(_KERNEL)
297 103 NOARGS { int|compat_13_sys||sigreturn( \
298 struct sigcontext13 *sigcntxp); } sigreturn13
299 #else
300 103 EXCL compat_13_sys_sigreturn
301 #endif
302 104 NOARGS { int|sys||bind(int s, const struct sockaddr *name, \
303 int namelen); }
304 105 NOARGS { int|sys||setsockopt(int s, int level, int name, \
305 const void *val, int valsize); }
306 106 NOARGS { int|sys||listen(int s, int backlog); }
307 107 OBSOL vtimes
308 #if defined(COMPAT_43) || !defined(_KERNEL)
309 108 NOARGS { int|compat_43_sys||sigvec(int signum, \
310 struct sigvec *nsv, struct sigvec *osv); } osigvec
311 109 NOARGS { int|compat_43_sys||sigblock(int mask); } osigblock
312 110 NOARGS { int|compat_43_sys||sigsetmask(int mask); } osigsetmask
313 #else
314 108 EXCL compat_43_sys_sigvec
315 109 EXCL compat_43_sys_sigblock
316 110 EXCL compat_43_sys_sigsetmask
317 #endif
318 #if defined(COMPAT_13) || !defined(_KERNEL)
319 111 NOARGS { int|compat_13_sys||sigsuspend(int mask); } sigsuspend13
320 #else
321 111 EXCL compat_13_sys_sigsuspend
322 #endif
323 #if defined(COMPAT_43) || !defined(_KERNEL)
324 112 NOARGS { int|compat_43_sys||sigstack(struct sigstack *nss, \
325 struct sigstack *oss); } osigstack
326 113 NOARGS { int|compat_43_sys||recvmsg(int s, \
327 struct omsghdr *msg, int flags); } orecvmsg
328 114 NOARGS { int|compat_43_sys||sendmsg(int s, void *msg, \
329 int flags); } osendmsg
330 #else
331 112 EXCL compat_43_sys_sigstack
332 113 EXCL compat_43_sys_recvmesg
333 114 EXCL compat_43_sys_sendmesg
334 #endif
335 115 OBSOL vtrace
336 116 NOARGS { int|compat_50_sys||gettimeofday(struct timeval50 *tp, \
337 struct timezone *tzp); }
338 117 NOARGS { int|compat_50_sys||getrusage(int who, \
339 struct rusage50 *rusage); }
340 118 NOARGS { int|sys||getsockopt(int s, int level, int name, \
341 void *val, int *avalsize); }
342 119 OBSOL resuba
343 120 NOARGS { ssize_t|sys||readv(int fd, \
344 const struct iovec *iovp, int iovcnt); }
345 121 NOARGS { ssize_t|sys||writev(int fd, \
346 const struct iovec *iovp, int iovcnt); }
347 122 NOARGS { int|compat_50_sys||settimeofday( \
348 const struct timeval50 *tv, \
349 const struct timezone *tzp); }
350 123 NOARGS { int|sys||fchown(int fd, uid_t uid, gid_t gid); }
351 124 NOARGS { int|sys||fchmod(int fd, mode_t mode); }
352 #if defined(COMPAT_43) || !defined(_KERNEL)
353 125 NOARGS { int|compat_43_sys||recvfrom(int s, void *buf, \
354 size_t len, int flags, void *from, \
355 int *fromlenaddr); } orecvfrom
356 #else
357 125 EXCL compat_43_sys_recvfrom
358 #endif
359 126 NOARGS { int|sys||setreuid(uid_t ruid, uid_t euid); }
360 127 NOARGS { int|sys||setregid(gid_t rgid, gid_t egid); }
361 128 NOARGS { int|sys||rename(const char *from, const char *to); }
362 #if defined(COMPAT_43) || !defined(_KERNEL)
363 129 NOARGS { int|compat_43_sys||truncate(const char *path, \
364 long length); } otruncate
365 130 NOARGS { int|compat_43_sys||ftruncate(int fd, long length); } \
366 oftruncate
367 #else
368 129 EXCL compat_43_sys_truncate
369 130 EXCL compat_43_sys_ftruncate
370 #endif
371 131 NOARGS { int|sys||flock(int fd, int how); }
372 132 NOARGS { int|sys||mkfifo(const char *path, mode_t mode); }
373 133 NOARGS { ssize_t|sys||sendto(int s, const void *buf, \
374 size_t len, int flags, const struct sockaddr *to, \
375 int tolen); }
376 134 NOARGS { int|sys||shutdown(int s, int how); }
377 135 NOARGS { int|sys||socketpair(int domain, int type, \
378 int protocol, int *rsv); }
379 136 NOARGS { int|sys||mkdir(const char *path, mode_t mode); }
380 137 NOARGS { int|sys||rmdir(const char *path); }
381 138 NOARGS { int|compat_50_sys||utimes(const char *path, \
382 const struct timeval50 *tptr); }
383 139 OBSOL 4.2 sigreturn
384 140 NOARGS { int|compat_50_sys||adjtime( \
385 const struct timeval50 *delta, \
386 struct timeval50 *olddelta); }
387 #if defined(COMPAT_43) || !defined(_KERNEL)
388 141 NOARGS { int|compat_43_sys||getpeername(int fdes, void *asa, \
389 int *alen); } ogetpeername
390 142 NOARGS { int32_t|compat_43_sys||gethostid(void); } ogethostid
391 143 NOARGS { int|compat_43_sys||sethostid(int32_t hostid); } \
392 osethostid
393 144 NOARGS { int|compat_43_sys||getrlimit(int which, \
394 struct orlimit *rlp); } ogetrlimit
395 145 NOARGS { int|compat_43_sys||setrlimit(int which, \
396 const struct orlimit *rlp); } osetrlimit
397 146 NOARGS { int|compat_43_sys||killpg(int pgid, int signum); } \
398 okillpg
399 #else
400 141 EXCL compat_43_sys_getpeername
401 142 EXCL compat_43_sys_gethostid
402 143 EXCL compat_43_sys_sethostid
403 144 EXCL compat_43_sys_getrlimit
404 145 EXCL compat_43_sys_setrlimit
405 146 EXCL compat_43_sys_killpg
406 #endif
407 147 NOARGS { int|sys||setsid(void); }
408 148 NOARGS { int|sys||quotactl(const char *path, \
409 int cmd, int uid, void *arg); }
410 #if defined(COMPAT_43) || !defined(_KERNEL)
411 149 NOARGS { int|compat_43_sys||quota(void); } oquota
412 150 NOARGS { int|compat_43_sys||getsockname(int fdec, void *asa, \
413 int *alen); } ogetsockname
414 #else
415 149 EXCL compat_43_sys_quota
416 150 EXCL compat_43_sys_getsockname
417 #endif
419 ; Syscalls 151-180 inclusive are reserved for vendor-specific
420 ; system calls. (This includes various calls added for compatibity
421 ; with other Unix variants.)
422 ; Some of these calls are now supported by BSD...
423 151 UNIMPL
424 152 UNIMPL
425 153 UNIMPL
426 154 UNIMPL
427 #if defined(NFSSERVER) || !defined(_KERNEL)
428 155 NOARGS { int|sys||nfssvc(int flag, void *argp); }
429 #else
430 155 EXCL nfssvc
431 #endif
432 #if defined(COMPAT_43) || !defined(_KERNEL)
433 156 NOARGS { int|compat_43_sys||getdirentries(int fd, char *buf, \
434 u_int count, long *basep); } ogetdirentries
435 #else
436 156 EXCL compat_43_sys_getdirentries
437 #endif
438 #if defined(COMPAT_20) || !defined(_KERNEL)
439 157 NOARGS { int|compat_20_sys||statfs(const char *path, \
440 struct statfs12 *buf); }
441 #else
442 157 EXCL compat_20_sys_statfs
443 #endif
444 #if defined(COMPAT_20) || !defined(_KERNEL)
445 158 NOARGS { int|compat_20_sys||fstatfs(int fd, \
446 struct statfs12 *buf); }
447 #else
448 158 EXCL compat_20_sys_statfs
449 #endif
450 159 UNIMPL
451 160 UNIMPL
452 161 NOARGS { int|compat_30_sys||getfh(const char *fname, \
453 struct compat_30_fhandle *fhp); }
454 #if defined(COMPAT_09) || !defined(_KERNEL)
455 162 NOARGS { int|compat_09_sys||getdomainname(char *domainname, \
456 int len); } ogetdomainname
457 163 NOARGS { int|compat_09_sys||setdomainname(char *domainname, \
458 int len); } osetdomainname
459 164 NOARGS { int|compat_09_sys||uname(struct outsname *name); } \
460 ouname
461 #else
462 162 EXCL compat_09_sys_getdomainname
463 163 EXCL compat_09_sys_setdomainname
464 164 EXCL compat_09_sys_uname
465 #endif
466 165 NOARGS { int|sys||sysarch(int op, void *parms); }
467 166 UNIMPL
468 167 UNIMPL
469 168 UNIMPL
470 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
471 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
472 169 NOARGS { int|compat_10_sys||semsys(int which, int a2, int a3, \
473 int a4, int a5); } osemsys
474 #else
475 169 EXCL 1.0 semsys
476 #endif
477 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
478 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
479 170 NOARGS { int|compat_10_sys||msgsys(int which, int a2, int a3, \
480 int a4, int a5, int a6); } omsgsys
481 #else
482 170 EXCL 1.0 msgsys
483 #endif
484 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
485 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
486 171 NOARGS { int|compat_10_sys||shmsys(int which, int a2, int a3, \
487 int a4); } oshmsys
488 #else
489 171 EXCL 1.0 shmsys
490 #endif
491 172 UNIMPL
492 173 NOARGS { ssize_t|sys||pread(int fd, void *buf, \
493 size_t nbyte, int pad, off_t offset); }
494 174 NOARGS { ssize_t|sys||pwrite(int fd, const void *buf, \
495 size_t nbyte, int pad, off_t offset); }
496 175 UNIMPL sys_ntp_gettime
497 #if defined(NTP) || !defined(_KERNEL)
498 176 NOARGS { int|sys||ntp_adjtime(struct timex *tp); }
499 #else
500 176 EXCL ntp_adjtime
501 #endif
502 177 UNIMPL
503 178 UNIMPL
504 179 UNIMPL
505 180 UNIMPL
507 ; Syscalls 180-199 are used by/reserved for BSD
508 181 NOARGS { int|sys||setgid(gid_t gid); }
509 182 NOARGS { int|sys||setegid(gid_t egid); }
510 183 NOARGS { int|sys||seteuid(uid_t euid); }
511 #if defined(LFS) || !defined(_KERNEL)
512 184 NOARGS { int|sys||lfs_bmapv(fsid_t *fsidp, \
513 struct block_info *blkiov, int blkcnt); }
514 185 NOARGS { int|sys||lfs_markv(fsid_t *fsidp, \
515 struct block_info *blkiov, int blkcnt); }
516 186 NOARGS { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); }
517 187 NOARGS { int|compat_50_sys||lfs_segwait(fsid_t *fsidp, \
518 struct timeval50 *tv); }
519 #else
520 184 EXCL lfs_bmapv
521 185 EXCL lfs_markv
522 186 EXCL lfs_segclean
523 187 EXCL lfs_segwait
524 #endif
525 #if defined(COMPAT_12) || !defined(_KERNEL)
526 188 STD { int|aoutm68k_compat_12_sys||stat(const char *path, \
527 struct aoutm68k_stat12 *ub); } stat12
528 189 STD { int|aoutm68k_compat_12_sys||fstat(int fd, \
529 struct aoutm68k_stat12 *sb); } fstat12
530 190 STD { int|aoutm68k_compat_12_sys||lstat(const char *path, \
531 struct aoutm68k_stat12 *ub); } lstat12
532 #else
533 188 EXCL aoutm68k_compat_12_sys_stat
534 189 EXCL aoutm68k_compat_12_sys_fstat
535 190 EXCL aoutm68k_compat_12_sys_lstat
536 #endif
537 191 NOARGS { long|sys||pathconf(const char *path, int name); }
538 192 NOARGS { long|sys||fpathconf(int fd, int name); }
539 193 UNIMPL
540 194 NOARGS { int|sys||getrlimit(int which, \
541 struct rlimit *rlp); }
542 195 NOARGS { int|sys||setrlimit(int which, \
543 const struct rlimit *rlp); }
544 #if defined(COMPAT_12) || !defined(_KERNEL)
545 196 NOARGS { int|compat_12_sys||getdirentries(int fd, char *buf, \
546 u_int count, long *basep); }
547 #else
548 196 EXCL compat_12_sys_getdirentries
549 #endif
550 197 NOARGS { void *|sys||mmap(void *addr, size_t len, int prot, \
551 int flags, int fd, long pad, off_t pos); }
552 198 NOARGS INDIR { quad_t|sys||__syscall(quad_t code, \
553 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); }
554 199 NOARGS { off_t|sys||lseek(int fd, int pad, off_t offset, \
555 int whence); }
556 200 NOARGS { int|sys||truncate(const char *path, int pad, \
557 off_t length); }
558 201 NOARGS { int|sys||ftruncate(int fd, int pad, off_t length); }
559 202 NOARGS { int|sys||__sysctl(int *name, u_int namelen, \
560 void *old, size_t *oldlenp, void *new, \
561 size_t newlen); }
562 203 NOARGS { int|sys||mlock(const void *addr, size_t len); }
563 204 NOARGS { int|sys||munlock(const void *addr, size_t len); }
564 205 NOARGS { int|sys||undelete(const char *path); }
565 206 NOARGS { int|compat_50_sys||futimes(int fd, \
566 const struct timeval50 *tptr); }
567 207 NOARGS { pid_t|sys||getpgid(pid_t pid); }
568 208 NOARGS { int|sys||reboot(int opt, char *bootstr); }
569 209 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \
570 int timeout); }
571 210 UNIMPL
572 211 UNIMPL
573 212 UNIMPL
574 213 UNIMPL
575 214 UNIMPL
576 215 UNIMPL
577 216 UNIMPL
578 217 UNIMPL
579 218 UNIMPL
580 219 UNIMPL
581 ; System calls 220-300 are reserved for use by NetBSD
582 #if defined(SYSVSEM) || !defined(_KERNEL)
583 #if defined(COMPAT_14) || !defined(_KERNEL)
584 220 NOARGS { int|compat_14_sys||__semctl(int semid, \
585 int semnum, int cmd, union __semun *arg); }
586 #else
587 220 EXCL compat_14_semctl
588 #endif
589 221 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); }
590 222 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \
591 size_t nsops); }
592 223 NOARGS { int|sys||semconfig(int flag); }
593 #else
594 220 EXCL compat_14_semctl
595 221 EXCL semget
596 222 EXCL semop
597 223 EXCL semconfig
598 #endif
599 #if defined(SYSVMSG) || !defined(_KERNEL)
600 #if defined(COMPAT_14) || !defined(_KERNEL)
601 224 NOARGS { int|compat_14_sys||msgctl(int msqid, int cmd, \
602 struct msqid_ds14 *buf); }
603 #else
604 224 EXCL compat_14_sys_msgctl
605 #endif
606 225 NOARGS { int|sys||msgget(key_t key, int msgflg); }
607 226 NOARGS { int|sys||msgsnd(int msqid, const void *msgp, \
608 size_t msgsz, int msgflg); }
609 227 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \
610 size_t msgsz, long msgtyp, int msgflg); }
611 #else
612 224 EXCL compat_14_msgctl
613 225 EXCL msgget
614 226 EXCL msgsnd
615 227 EXCL msgrcv
616 #endif
617 #if defined(SYSVSHM) || !defined(_KERNEL)
618 228 NOARGS { void *|sys||shmat(int shmid, const void *shmaddr, \
619 int shmflg); }
620 #if defined(COMPAT_14) || !defined(_KERNEL)
621 229 NOARGS { int|compat_14_sys||shmctl(int shmid, int cmd, \
622 struct shmid_ds14 *buf); }
623 #else
624 229 EXCL compat_14_sys_shmctl
625 #endif
626 230 NOARGS { int|sys||shmdt(const void *shmaddr); }
627 231 NOARGS { int|sys||shmget(key_t key, size_t size, int shmflg); }
628 #else
629 228 EXCL shmat
630 229 EXCL compat_14_shmctl
631 230 EXCL shmdt
632 231 EXCL shmget
633 #endif
634 232 NOARGS { int|compat_50_sys||clock_gettime(clockid_t clock_id, \
635 struct timespec50 *tp); }
636 233 NOARGS { int|compat_50_sys||clock_settime(clockid_t clock_id, \
637 const struct timespec50 *tp); }
638 234 NOARGS { int|compat_50_sys||clock_getres(clockid_t clock_id, \
639 struct timespec50 *tp); }
640 235 UNIMPL timer_create
641 236 UNIMPL timer_delete
642 237 UNIMPL timer_settime
643 238 UNIMPL timer_gettime
644 239 UNIMPL timer_getoverrun
645 ;
646 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
647 ;
648 240 NOARGS { int|compat_50_sys||nanosleep( \
649 const struct timespec50 *rqtp, \
650 struct timespec50 *rmtp); }
651 241 NOARGS { int|sys||fdatasync(int fd); }
652 242 NOARGS { int|sys||mlockall(int flags); }
653 243 NOARGS { int|sys||munlockall(void); }
654 244 UNIMPL
655 245 UNIMPL
656 246 UNIMPL
657 247 UNIMPL
658 248 UNIMPL
659 249 UNIMPL
660 250 UNIMPL
661 251 UNIMPL
662 252 UNIMPL
663 253 UNIMPL
664 254 UNIMPL
665 255 UNIMPL
666 256 UNIMPL
667 257 UNIMPL
668 258 UNIMPL
669 259 UNIMPL
670 260 UNIMPL
671 261 UNIMPL
672 262 UNIMPL
673 263 UNIMPL
674 264 UNIMPL
675 265 UNIMPL
676 266 UNIMPL
677 267 UNIMPL
678 268 UNIMPL
679 269 UNIMPL
680 270 NOARGS { int|sys||__posix_rename(const char *from, \
681 const char *to); }
682 271 NOARGS { int|sys||swapctl(int cmd, const void *arg, int misc); }
683 #if defined(COMPAT_30) || !defined(_KERNEL)
684 272 NOARGS { int|compat_30_sys||getdents(int fd, char *buf, size_t count); }
685 #else
686 272 EXCL compat_30_sys_getdents
687 #endif
688 273 NOARGS { int|sys||minherit(void *addr, size_t len, \
689 int inherit); }
690 274 NOARGS { int|sys||lchmod(const char *path, mode_t mode); }
691 275 NOARGS { int|sys||lchown(const char *path, uid_t uid, \
692 gid_t gid); }
693 276 NOARGS { int|compat_50_sys||lutimes(const char *path, \
694 const struct timeval50 *tptr); }
695 277 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); }
696 278 STD { int|aoutm68k_sys|13|stat(const char *path, \
697 struct aoutm68k_stat *ub); }
698 279 STD { int|aoutm68k_sys|13|fstat(int fd, \
699 struct aoutm68k_stat *sb); }
700 280 STD { int|aoutm68k_sys|13|lstat(const char *path, \
701 struct aoutm68k_stat *ub); }
702 281 NOARGS { int|sys|14|sigaltstack( \
703 const struct sigaltstack *nss, \
704 struct sigaltstack *oss); }
705 282 NOARGS { int|sys|14|vfork(void); }
706 283 NOARGS { int|sys||__posix_chown(const char *path, uid_t uid, \
707 gid_t gid); }
708 284 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \
709 gid_t gid); }
710 285 NOARGS { int|sys||__posix_lchown(const char *path, uid_t uid, \
711 gid_t gid); }
712 286 NOARGS { pid_t|sys||getsid(pid_t pid); }
713 287 UNIMPL
714 #if defined(KTRACE) || !defined(_KERNEL)
715 288 NOARGS { int|sys||fktrace(const int fd, int ops, \
716 int facs, int pid); }
717 #else
718 288 EXCL ktrace
719 #endif
720 289 NOARGS { ssize_t|sys||preadv(int fd, \
721 const struct iovec *iovp, int iovcnt, \
722 int pad, off_t offset); }
723 290 NOARGS { ssize_t|sys||pwritev(int fd, \
724 const struct iovec *iovp, int iovcnt, \
725 int pad, off_t offset); }
726 #if defined(COMPAT_16) || !defined(_KERNEL)
727 291 NOARGS { int|compat_16_sys|14|sigaction(int signum, \
728 const struct sigaction *nsa, \
729 struct sigaction *osa); }
730 #else
731 291 EXCL compat_16_sys___sigaction14
732 #endif
733 292 NOARGS { int|sys|14|sigpending(sigset_t *set); }
734 293 NOARGS { int|sys|14|sigprocmask(int how, \
735 const sigset_t *set, \
736 sigset_t *oset); }
737 294 NOARGS { int|sys|14|sigsuspend(const sigset_t *set); }
738 #if defined(COMPAT_16) || !defined(_KERNEL)
739 295 NOARGS { int|compat_16_sys|14|sigreturn(\
740 struct sigcontext *sigcntxp); }
741 #else
742 295 EXCL compat_16_sys___sigreturn14
743 #endif
744 296 NOARGS { int|sys||__getcwd(char *bufp, size_t length); }
745 297 NOARGS { int|sys||fchroot(int fd); }
746 298 NOARGS { int|compat_30_sys||fhopen(const \
747 struct compat_30_fhandle *fhp, int flags); }
748 299 STD { int|aoutm68k_sys||fhstat(const struct \
749 compat_30_fhandle *fhp, \
750 struct aoutm68k_stat *sb); }
751 #if defined(COMPAT_20) || !defined(_KERNEL)
752 300 NOARGS { int|compat_20_sys||fhstatfs(const struct \
753 compat_30-fhandle *fhp, \
754 struct statfs12 *buf); }
755 #else
756 300 EXCL compat_20_sys_fhstatfs
757 #endif
758 #if defined(SYSVSEM) || !defined(_KERNEL)
759 301 NOARGS { int|compat_50_sys|13|__semctl(int semid, \
760 int semnum, int cmd, ... union __semun *arg); }
761 #else
762 301 EXCL ____semctl13
763 #endif
764 #if defined(SYSVMSG) || !defined(_KERNEL)
765 302 NOARGS { int|compat_50_sys|13|msgctl(int msqid, int cmd, \
766 struct msqid_ds *buf); }
767 #else
768 302 EXCL __msgctl13
769 #endif
770 #if defined(SYSVSHM) || !defined(_KERNEL)
771 303 NOARGS { int|compat_50_sys|13|shmctl(int shmid, int cmd, \
772 struct shmid_ds *buf); }
773 #else
774 303 EXCL __shmctl13
775 #endif
776 304 NOARGS { int|sys||lchflags(const char *path, u_long flags); }
777 305 NOARGS { int|sys||issetugid(void); }
778 306 NOARGS { int|sys||getcontext(struct __ucontext *ucp); }
779 307 NOARGS { int|sys||setcontext(const struct __ucontext *ucp); }