1 $NetBSD: syscalls.master,v 1.28 2008/06/21 19:58:27 he Exp $
2
3 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
4
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.
36
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"
44
45 #include "fs_lfs.h"
46 #include "fs_nfs.h"
47 #endif
48
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>
56
57 %%
58
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.
64
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 sys_wait4(int pid, int *status, int options, \
76 struct rusage *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 sys_mknod(const char *path, mode_t mode, \
89 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 sys_setitimer(int which, \
243 const struct itimerval *itv, \
244 struct itimerval *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 sys_getitimer(int which, \
256 struct itimerval *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 sys_select(int nd, fd_set *in, fd_set *ou, \
273 fd_set *ex, struct timeval *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 sys_gettimeofday(struct timeval *tp, \
337 struct timezone *tzp); }
338 117 NOARGS { int sys_getrusage(int who, struct rusage *rusage); }
339 118 NOARGS { int sys_getsockopt(int s, int level, int name, \
340 void *val, int *avalsize); }
341 119 OBSOL resuba
342 120 NOARGS { ssize_t sys_readv(int fd, \
343 const struct iovec *iovp, int iovcnt); }
344 121 NOARGS { ssize_t sys_writev(int fd, \
345 const struct iovec *iovp, int iovcnt); }
346 122 NOARGS { int sys_settimeofday(const struct timeval *tv, \
347 const struct timezone *tzp); }
348 123 NOARGS { int sys_fchown(int fd, uid_t uid, gid_t gid); }
349 124 NOARGS { int sys_fchmod(int fd, mode_t mode); }
350 #if defined(COMPAT_43) || !defined(_KERNEL)
351 125 NOARGS { int compat_43_sys_recvfrom(int s, void *buf, \
352 size_t len, int flags, void *from, \
353 int *fromlenaddr); } orecvfrom
354 #else
355 125 EXCL compat_43_sys_recvfrom
356 #endif
357 126 NOARGS { int sys_setreuid(uid_t ruid, uid_t euid); }
358 127 NOARGS { int sys_setregid(gid_t rgid, gid_t egid); }
359 128 NOARGS { int sys_rename(const char *from, const char *to); }
360 #if defined(COMPAT_43) || !defined(_KERNEL)
361 129 NOARGS { int compat_43_sys_truncate(const char *path, \
362 long length); } otruncate
363 130 NOARGS { int compat_43_sys_ftruncate(int fd, long length); } \
364 oftruncate
365 #else
366 129 EXCL compat_43_sys_truncate
367 130 EXCL compat_43_sys_ftruncate
368 #endif
369 131 NOARGS { int sys_flock(int fd, int how); }
370 132 NOARGS { int sys_mkfifo(const char *path, mode_t mode); }
371 133 NOARGS { ssize_t sys_sendto(int s, const void *buf, \
372 size_t len, int flags, const struct sockaddr *to, \
373 int tolen); }
374 134 NOARGS { int sys_shutdown(int s, int how); }
375 135 NOARGS { int sys_socketpair(int domain, int type, \
376 int protocol, int *rsv); }
377 136 NOARGS { int sys_mkdir(const char *path, mode_t mode); }
378 137 NOARGS { int sys_rmdir(const char *path); }
379 138 NOARGS { int sys_utimes(const char *path, \
380 const struct timeval *tptr); }
381 139 OBSOL 4.2 sigreturn
382 140 NOARGS { int sys_adjtime(const struct timeval *delta, \
383 struct timeval *olddelta); }
384 #if defined(COMPAT_43) || !defined(_KERNEL)
385 141 NOARGS { int compat_43_sys_getpeername(int fdes, void *asa, \
386 int *alen); } ogetpeername
387 142 NOARGS { int32_t compat_43_sys_gethostid(void); } ogethostid
388 143 NOARGS { int compat_43_sys_sethostid(int32_t hostid); } \
389 osethostid
390 144 NOARGS { int compat_43_sys_getrlimit(int which, \
391 struct orlimit *rlp); } ogetrlimit
392 145 NOARGS { int compat_43_sys_setrlimit(int which, \
393 const struct orlimit *rlp); } osetrlimit
394 146 NOARGS { int compat_43_sys_killpg(int pgid, int signum); } \
395 okillpg
396 #else
397 141 EXCL compat_43_sys_getpeername
398 142 EXCL compat_43_sys_gethostid
399 143 EXCL compat_43_sys_sethostid
400 144 EXCL compat_43_sys_getrlimit
401 145 EXCL compat_43_sys_setrlimit
402 146 EXCL compat_43_sys_killpg
403 #endif
404 147 NOARGS { int sys_setsid(void); }
405 148 NOARGS { int sys_quotactl(const char *path, \
406 int cmd, int uid, void *arg); }
407 #if defined(COMPAT_43) || !defined(_KERNEL)
408 149 NOARGS { int compat_43_sys_quota(void); } oquota
409 150 NOARGS { int compat_43_sys_getsockname(int fdec, void *asa, \
410 int *alen); } ogetsockname
411 #else
412 149 EXCL compat_43_sys_quota
413 150 EXCL compat_43_sys_getsockname
414 #endif
415
416 ; Syscalls 151-180 inclusive are reserved for vendor-specific
417 ; system calls. (This includes various calls added for compatibity
418 ; with other Unix variants.)
419 ; Some of these calls are now supported by BSD...
420 151 UNIMPL
421 152 UNIMPL
422 153 UNIMPL
423 154 UNIMPL
424 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL)
425 155 NOARGS { int sys_nfssvc(int flag, void *argp); }
426 #else
427 155 EXCL nfssvc
428 #endif
429 #if defined(COMPAT_43) || !defined(_KERNEL)
430 156 NOARGS { int compat_43_sys_getdirentries(int fd, char *buf, \
431 u_int count, long *basep); } ogetdirentries
432 #else
433 156 EXCL compat_43_sys_getdirentries
434 #endif
435 #if defined(COMPAT_20) || !defined(_KERNEL)
436 157 NOARGS { int compat_20_sys_statfs(const char *path, \
437 struct statfs12 *buf); }
438 #else
439 157 EXCL compat_20_sys_statfs
440 #endif
441 #if defined(COMPAT_20) || !defined(_KERNEL)
442 158 NOARGS { int compat_20_sys_fstatfs(int fd, \
443 struct statfs12 *buf); }
444 #else
445 158 EXCL compat_20_sys_statfs
446 #endif
447 159 UNIMPL
448 160 UNIMPL
449 161 NOARGS { int compat_30_sys_getfh(const char *fname, \
450 struct compat_30_fhandle *fhp); }
451 #if defined(COMPAT_09) || !defined(_KERNEL)
452 162 NOARGS { int compat_09_sys_getdomainname(char *domainname, \
453 int len); } ogetdomainname
454 163 NOARGS { int compat_09_sys_setdomainname(char *domainname, \
455 int len); } osetdomainname
456 164 NOARGS { int compat_09_sys_uname(struct outsname *name); } \
457 ouname
458 #else
459 162 EXCL compat_09_sys_getdomainname
460 163 EXCL compat_09_sys_setdomainname
461 164 EXCL compat_09_sys_uname
462 #endif
463 165 NOARGS { int sys_sysarch(int op, void *parms); }
464 166 UNIMPL
465 167 UNIMPL
466 168 UNIMPL
467 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
468 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
469 169 NOARGS { int compat_10_sys_semsys(int which, int a2, int a3, \
470 int a4, int a5); } osemsys
471 #else
472 169 EXCL 1.0 semsys
473 #endif
474 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
475 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
476 170 NOARGS { int compat_10_sys_msgsys(int which, int a2, int a3, \
477 int a4, int a5, int a6); } omsgsys
478 #else
479 170 EXCL 1.0 msgsys
480 #endif
481 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
482 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10)
483 171 NOARGS { int compat_10_sys_shmsys(int which, int a2, int a3, \
484 int a4); } oshmsys
485 #else
486 171 EXCL 1.0 shmsys
487 #endif
488 172 UNIMPL
489 173 NOARGS { ssize_t sys_pread(int fd, void *buf, \
490 size_t nbyte, int pad, off_t offset); }
491 174 NOARGS { ssize_t sys_pwrite(int fd, const void *buf, \
492 size_t nbyte, int pad, off_t offset); }
493 175 UNIMPL { int sys_ntp_gettime(struct ntptimeval *ntvp); }
494 #if defined(NTP) || !defined(_KERNEL)
495 176 NOARGS { int sys_ntp_adjtime(struct timex *tp); }
496 #else
497 176 EXCL ntp_adjtime
498 #endif
499 177 UNIMPL
500 178 UNIMPL
501 179 UNIMPL
502 180 UNIMPL
503
504 ; Syscalls 180-199 are used by/reserved for BSD
505 181 NOARGS { int sys_setgid(gid_t gid); }
506 182 NOARGS { int sys_setegid(gid_t egid); }
507 183 NOARGS { int sys_seteuid(uid_t euid); }
508 #if defined(LFS) || !defined(_KERNEL)
509 184 NOARGS { int sys_lfs_bmapv(fsid_t *fsidp, \
510 struct block_info *blkiov, int blkcnt); }
511 185 NOARGS { int sys_lfs_markv(fsid_t *fsidp, \
512 struct block_info *blkiov, int blkcnt); }
513 186 NOARGS { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); }
514 187 NOARGS { int sys_lfs_segwait(fsid_t *fsidp, \
515 struct timeval *tv); }
516 #else
517 184 EXCL lfs_bmapv
518 185 EXCL lfs_markv
519 186 EXCL lfs_segclean
520 187 EXCL lfs_segwait
521 #endif
522 #if defined(COMPAT_12) || !defined(_KERNEL)
523 188 STD { int aoutm68k_compat_12_sys_stat(const char *path, \
524 struct aoutm68k_stat12 *ub); } stat12
525 189 STD { int aoutm68k_compat_12_sys_fstat(int fd, \
526 struct aoutm68k_stat12 *sb); } fstat12
527 190 STD { int aoutm68k_compat_12_sys_lstat(const char *path, \
528 struct aoutm68k_stat12 *ub); } lstat12
529 #else
530 188 EXCL aoutm68k_compat_12_sys_stat
531 189 EXCL aoutm68k_compat_12_sys_fstat
532 190 EXCL aoutm68k_compat_12_sys_lstat
533 #endif
534 191 NOARGS { long sys_pathconf(const char *path, int name); }
535 192 NOARGS { long sys_fpathconf(int fd, int name); }
536 193 UNIMPL
537 194 NOARGS { int sys_getrlimit(int which, \
538 struct rlimit *rlp); }
539 195 NOARGS { int sys_setrlimit(int which, \
540 const struct rlimit *rlp); }
541 #if defined(COMPAT_12) || !defined(_KERNEL)
542 196 NOARGS { int compat_12_sys_getdirentries(int fd, char *buf, \
543 u_int count, long *basep); }
544 #else
545 196 EXCL compat_12_sys_getdirentries
546 #endif
547 197 NOARGS { void *sys_mmap(void *addr, size_t len, int prot, \
548 int flags, int fd, long pad, off_t pos); }
549 198 NOARGS INDIR { quad_t sys___syscall(quad_t code, \
550 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); }
551 199 NOARGS { off_t sys_lseek(int fd, int pad, off_t offset, \
552 int whence); }
553 200 NOARGS { int sys_truncate(const char *path, int pad, \
554 off_t length); }
555 201 NOARGS { int sys_ftruncate(int fd, int pad, off_t length); }
556 202 NOARGS { int sys___sysctl(int *name, u_int namelen, \
557 void *old, size_t *oldlenp, void *new, \
558 size_t newlen); }
559 203 NOARGS { int sys_mlock(const void *addr, size_t len); }
560 204 NOARGS { int sys_munlock(const void *addr, size_t len); }
561 205 NOARGS { int sys_undelete(const char *path); }
562 206 NOARGS { int sys_futimes(int fd, \
563 const struct timeval *tptr); }
564 207 NOARGS { pid_t sys_getpgid(pid_t pid); }
565 208 NOARGS { int sys_reboot(int opt, char *bootstr); }
566 209 NOARGS { int sys_poll(struct pollfd *fds, u_int nfds, \
567 int timeout); }
568 ;
569 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
570 ;
571 #if defined(LKM) || !defined(_KERNEL)
572 210 NODEF { int sys_lkmnosys(void); }
573 211 NODEF { int sys_lkmnosys(void); }
574 212 NODEF { int sys_lkmnosys(void); }
575 213 NODEF { int sys_lkmnosys(void); }
576 214 NODEF { int sys_lkmnosys(void); }
577 215 NODEF { int sys_lkmnosys(void); }
578 216 NODEF { int sys_lkmnosys(void); }
579 217 NODEF { int sys_lkmnosys(void); }
580 218 NODEF { int sys_lkmnosys(void); }
581 219 NODEF { int sys_lkmnosys(void); }
582 #else /* !LKM */
583 210 EXCL lkmnosys
584 211 EXCL lkmnosys
585 212 EXCL lkmnosys
586 213 EXCL lkmnosys
587 214 EXCL lkmnosys
588 215 EXCL lkmnosys
589 216 EXCL lkmnosys
590 217 EXCL lkmnosys
591 218 EXCL lkmnosys
592 219 EXCL lkmnosys
593 #endif /* !LKM */
594 ; System calls 220-300 are reserved for use by NetBSD
595 #if defined(SYSVSEM) || !defined(_KERNEL)
596 #if defined(COMPAT_14) || !defined(_KERNEL)
597 220 NOARGS { int compat_14_sys___semctl(int semid, \
598 int semnum, int cmd, union __semun *arg); }
599 #else
600 220 EXCL compat_14_semctl
601 #endif
602 221 NOARGS { int sys_semget(key_t key, int nsems, int semflg); }
603 222 NOARGS { int sys_semop(int semid, struct sembuf *sops, \
604 size_t nsops); }
605 223 NOARGS { int sys_semconfig(int flag); }
606 #else
607 220 EXCL compat_14_semctl
608 221 EXCL semget
609 222 EXCL semop
610 223 EXCL semconfig
611 #endif
612 #if defined(SYSVMSG) || !defined(_KERNEL)
613 #if defined(COMPAT_14) || !defined(_KERNEL)
614 224 NOARGS { int compat_14_sys_msgctl(int msqid, int cmd, \
615 struct msqid_ds14 *buf); }
616 #else
617 224 EXCL compat_14_sys_msgctl
618 #endif
619 225 NOARGS { int sys_msgget(key_t key, int msgflg); }
620 226 NOARGS { int sys_msgsnd(int msqid, const void *msgp, \
621 size_t msgsz, int msgflg); }
622 227 NOARGS { ssize_t sys_msgrcv(int msqid, void *msgp, \
623 size_t msgsz, long msgtyp, int msgflg); }
624 #else
625 224 EXCL compat_14_msgctl
626 225 EXCL msgget
627 226 EXCL msgsnd
628 227 EXCL msgrcv
629 #endif
630 #if defined(SYSVSHM) || !defined(_KERNEL)
631 228 NOARGS { void *sys_shmat(int shmid, const void *shmaddr, \
632 int shmflg); }
633 #if defined(COMPAT_14) || !defined(_KERNEL)
634 229 NOARGS { int compat_14_sys_shmctl(int shmid, int cmd, \
635 struct shmid_ds14 *buf); }
636 #else
637 229 EXCL compat_14_sys_shmctl
638 #endif
639 230 NOARGS { int sys_shmdt(const void *shmaddr); }
640 231 NOARGS { int sys_shmget(key_t key, size_t size, int shmflg); }
641 #else
642 228 EXCL shmat
643 229 EXCL compat_14_shmctl
644 230 EXCL shmdt
645 231 EXCL shmget
646 #endif
647 232 NOARGS { int sys_clock_gettime(clockid_t clock_id, \
648 struct timespec *tp); }
649 233 NOARGS { int sys_clock_settime(clockid_t clock_id, \
650 const struct timespec *tp); }
651 234 NOARGS { int sys_clock_getres(clockid_t clock_id, \
652 struct timespec *tp); }
653 235 UNIMPL timer_create
654 236 UNIMPL timer_delete
655 237 UNIMPL timer_settime
656 238 UNIMPL timer_gettime
657 239 UNIMPL timer_getoverrun
658 ;
659 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
660 ;
661 240 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \
662 struct timespec *rmtp); }
663 241 NOARGS { int sys_fdatasync(int fd); }
664 242 NOARGS { int sys_mlockall(int flags); }
665 243 NOARGS { int sys_munlockall(void); }
666 244 UNIMPL
667 245 UNIMPL
668 246 UNIMPL
669 247 UNIMPL
670 248 UNIMPL
671 249 UNIMPL
672 250 UNIMPL
673 251 UNIMPL
674 252 UNIMPL
675 253 UNIMPL
676 254 UNIMPL
677 255 UNIMPL
678 256 UNIMPL
679 257 UNIMPL
680 258 UNIMPL
681 259 UNIMPL
682 260 UNIMPL
683 261 UNIMPL
684 262 UNIMPL
685 263 UNIMPL
686 264 UNIMPL
687 265 UNIMPL
688 266 UNIMPL
689 267 UNIMPL
690 268 UNIMPL
691 269 UNIMPL
692 270 NOARGS { int sys___posix_rename(const char *from, \
693 const char *to); }
694 271 NOARGS { int sys_swapctl(int cmd, const void *arg, int misc); }
695 #if defined(COMPAT_30) || !defined(_KERNEL)
696 272 NOARGS { int compat_30_sys_getdents(int fd, char *buf, size_t count); }
697 #else
698 272 EXCL compat_30_sys_getdents
699 #endif
700 273 NOARGS { int sys_minherit(void *addr, size_t len, \
701 int inherit); }
702 274 NOARGS { int sys_lchmod(const char *path, mode_t mode); }
703 275 NOARGS { int sys_lchown(const char *path, uid_t uid, \
704 gid_t gid); }
705 276 NOARGS { int sys_lutimes(const char *path, \
706 const struct timeval *tptr); }
707 277 NOARGS { int sys___msync13(void *addr, size_t len, int flags); }
708 278 STD { int aoutm68k_sys___stat13(const char *path, \
709 struct aoutm68k_stat *ub); }
710 279 STD { int aoutm68k_sys___fstat13(int fd, \
711 struct aoutm68k_stat *sb); }
712 280 STD { int aoutm68k_sys___lstat13(const char *path, \
713 struct aoutm68k_stat *ub); }
714 281 NOARGS { int sys___sigaltstack14( \
715 const struct sigaltstack *nss, \
716 struct sigaltstack *oss); }
717 282 NOARGS { int sys___vfork14(void); }
718 283 NOARGS { int sys___posix_chown(const char *path, uid_t uid, \
719 gid_t gid); }
720 284 NOARGS { int sys___posix_fchown(int fd, uid_t uid, \
721 gid_t gid); }
722 285 NOARGS { int sys___posix_lchown(const char *path, uid_t uid, \
723 gid_t gid); }
724 286 NOARGS { pid_t sys_getsid(pid_t pid); }
725 287 UNIMPL
726 #if defined(KTRACE) || !defined(_KERNEL)
727 288 NOARGS { int sys_fktrace(const int fd, int ops, \
728 int facs, int pid); }
729 #else
730 288 EXCL ktrace
731 #endif
732 289 NOARGS { ssize_t sys_preadv(int fd, \
733 const struct iovec *iovp, int iovcnt, \
734 int pad, off_t offset); }
735 290 NOARGS { ssize_t sys_pwritev(int fd, \
736 const struct iovec *iovp, int iovcnt, \
737 int pad, off_t offset); }
738 #if defined(COMPAT_16) || !defined(_KERNEL)
739 291 NOARGS { int compat_16_sys___sigaction14(int signum, \
740 const struct sigaction *nsa, \
741 struct sigaction *osa); }
742 #else
743 291 EXCL compat_16_sys___sigaction14
744 #endif
745 292 NOARGS { int sys___sigpending14(sigset_t *set); }
746 293 NOARGS { int sys___sigprocmask14(int how, \
747 const sigset_t *set, \
748 sigset_t *oset); }
749 294 NOARGS { int sys___sigsuspend14(const sigset_t *set); }
750 #if defined(COMPAT_16) || !defined(_KERNEL)
751 295 NOARGS { int compat_16_sys___sigreturn14(\
752 struct sigcontext *sigcntxp); }
753 #else
754 295 EXCL compat_16_sys___sigreturn14
755 #endif
756 296 NOARGS { int sys___getcwd(char *bufp, size_t length); }
757 297 NOARGS { int sys_fchroot(int fd); }
758 298 NOARGS { int compat_30_sys_fhopen(const \
759 struct compat_30_fhandle *fhp, int flags); }
760 299 STD { int aoutm68k_sys_fhstat(const struct \
761 compat_30_fhandle *fhp, \
762 struct aoutm68k_stat *sb); }
763 #if defined(COMPAT_20) || !defined(_KERNEL)
764 300 NOARGS { int compat_20_sys_fhstatfs(const struct \
765 compat_30-fhandle *fhp, \
766 struct statfs12 *buf); }
767 #else
768 300 EXCL compat_20_sys_fhstatfs
769 #endif
770 #if defined(SYSVSEM) || !defined(_KERNEL)
771 301 NOARGS { int sys_____semctl13(int semid, int semnum, int cmd, \
772 ... union __semun *arg); }
773 #else
774 301 EXCL ____semctl13
775 #endif
776 #if defined(SYSVMSG) || !defined(_KERNEL)
777 302 NOARGS { int sys___msgctl13(int msqid, int cmd, \
778 struct msqid_ds *buf); }
779 #else
780 302 EXCL __msgctl13
781 #endif
782 #if defined(SYSVSHM) || !defined(_KERNEL)
783 303 NOARGS { int sys___shmctl13(int shmid, int cmd, \
784 struct shmid_ds *buf); }
785 #else
786 303 EXCL __shmctl13
787 #endif
788 304 NOARGS { int sys_lchflags(const char *path, u_long flags); }
789 305 NOARGS { int sys_issetugid(void); }
790 306 NOARGS { int sys_getcontext(struct __ucontext *ucp); }
791 307 NOARGS { int sys_setcontext(const struct __ucontext *ucp); }
Cache object: ac7aaf96d9cd2568ef01ca71e75b9693
|