1 $NetBSD: syscalls.master,v 1.11 2004/05/08 14:31:59 kent Exp $
2 ; based on NetBSD: syscalls.master,v 1.128 2003/03/18 18:08:49 christos Exp
3
4 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
5
6 ; NetBSD system call name/number "master" file.
7 ; (See syscalls.conf to see what it is processed into.)
8 ;
9 ; Fields: number type [type-dependent ...]
10 ; number system call number, must be in order
11 ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
12 ; the compatibility options defined in syscalls.conf.
13 ;
14 ; An optional field, MPSAFE, after the type field, indicates that
15 ; the system call is MP-safe.
16 ;
17 ; types:
18 ; STD always included
19 ; OBSOL obsolete, not included in system
20 ; UNIMPL unimplemented, not included in system
21 ; EXCL implemented, but not included in system
22 ; NODEF included, but don't define the syscall number
23 ; NOARGS included, but don't define the syscall args structure
24 ; INDIR included, but don't define the syscall args structure,
25 ; and allow it to be "really" varargs.
26 ;
27 ; The compat options are defined in the syscalls.conf file, and the
28 ; compat option name is prefixed to the syscall name. Other than
29 ; that, they're like NODEF (for 'compat' options), or STD (for
30 ; 'libcompat' options).
31 ;
32 ; The type-dependent arguments are as follows:
33 ; For STD, NODEF, NOARGS, and compat syscalls:
34 ; { pseudo-proto } [alias]
35 ; For other syscalls:
36 ; [comment]
37 ;
38 ; #ifdef's, etc. may be included, and are copied to the output files.
39 ; #include's are copied to the syscall names and switch definition files only.
40
41 #if defined(_KERNEL_OPT)
42 #include "opt_ktrace.h"
43 #include "opt_nfsserver.h"
44 #include "opt_ntp.h"
45 #include "opt_compat_netbsd.h"
46 #include "opt_sysv.h"
47 #include "opt_compat_43.h"
48 #include "opt_posix.h"
49
50 #include "fs_lfs.h"
51 #include "fs_nfs.h"
52 #endif
53
54 #include <sys/param.h>
55 #include <sys/systm.h>
56 #include <sys/signal.h>
57 #include <sys/mount.h>
58 #include <sys/sa.h>
59 #include <sys/syscallargs.h>
60 #include <compat/pecoff/pecoff_syscallargs.h>
61
62 %%
63
64 ; Reserved/unimplemented system calls in the range 0-150 inclusive
65 ; are reserved for use in future Berkeley releases.
66 ; Additional system calls implemented in vendor and other
67 ; redistributions should be placed in the reserved range at the end
68 ; of the current calls.
69
70 0 INDIR { int sys_syscall(int number, ...); }
71 1 NOARGS { void sys_exit(int rval); }
72 2 NOARGS { int sys_fork(void); }
73 3 NOARGS { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
74 4 NOARGS { ssize_t sys_write(int fd, const void *buf, \
75 size_t nbyte); }
76 5 STD { int pecoff_sys_open(const char *path, \
77 int flags, ... mode_t mode); }
78 6 NOARGS { int sys_close(int fd); }
79 7 NOARGS { int sys_wait4(int pid, int *status, int options, \
80 struct rusage *rusage); }
81 8 EXCL { int sys_creat(const char *path, mode_t mode); } ocreat
82 9 STD { int pecoff_sys_link(const char *path, \
83 const char *link); }
84 10 STD { int pecoff_sys_unlink(const char *path); }
85 11 OBSOL execv
86 12 STD { int pecoff_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 STD { int pecoff_sys_chmod(const char *path, mode_t mode); }
91 16 STD { int pecoff_sys_chown(const char *path, uid_t uid, \
92 gid_t gid); }
93 17 NOARGS { int sys_obreak(char *nsize); } break
94 #ifdef COMPAT_20
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 19 EXCL { long sys_lseek(int fd, long offset, int whence); } \
101 olseek
102 #ifdef COMPAT_43
103 20 NOARGS { pid_t sys_getpid_with_ppid(void); } getpid
104 #else
105 20 NOARGS MPSAFE { pid_t sys_getpid(void); }
106 #endif
107 21 NOARGS { int sys_mount(const char *type, const char *path, \
108 int flags, void *data); }
109 22 STD { int pecoff_sys_unmount(const char *path, int flags); }
110 23 NOARGS { int sys_setuid(uid_t uid); }
111 #ifdef COMPAT_43
112 24 NOARGS { uid_t sys_getuid_with_euid(void); } getuid
113 #else
114 24 NOARGS { uid_t sys_getuid(void); }
115 #endif
116 25 NOARGS { uid_t sys_geteuid(void); }
117 26 NOARGS { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
118 int data); }
119 27 NOARGS { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
120 int flags); }
121 28 NOARGS { ssize_t sys_sendmsg(int s, \
122 const struct msghdr *msg, int flags); }
123 29 NOARGS { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
124 int flags, struct sockaddr *from, \
125 unsigned int *fromlenaddr); }
126 30 NOARGS { int sys_accept(int s, struct sockaddr *name, \
127 unsigned int *anamelen); }
128 31 NOARGS { int sys_getpeername(int fdes, struct sockaddr *asa, \
129 unsigned int *alen); }
130 32 NOARGS { int sys_getsockname(int fdes, struct sockaddr *asa, \
131 unsigned int *alen); }
132 33 STD { int pecoff_sys_access(const char *path, int flags); }
133 34 STD { int pecoff_sys_chflags(const char *path, \
134 u_long flags); }
135 35 NOARGS { int sys_fchflags(int fd, u_long flags); }
136 36 NOARGS { void sys_sync(void); }
137 37 NOARGS { int sys_kill(int pid, int signum); }
138 38 EXCL { int pecoff_compat_43_sys_stat(const char *path, \
139 struct stat43 *ub); } stat43
140 39 NOARGS { pid_t sys_getppid(void); }
141 40 EXCL { int pecoff_compat_43_sys_lstat(const char *path, \
142 struct stat43 *ub); } lstat43
143 41 NOARGS { int sys_dup(int fd); }
144 42 NOARGS { int sys_pipe(void); }
145 43 NOARGS { gid_t sys_getegid(void); }
146 44 NOARGS { int sys_profil(caddr_t samples, size_t size, \
147 u_long offset, u_int scale); }
148 #if defined(KTRACE) || !defined(_KERNEL)
149 45 NOARGS { int sys_ktrace(const char *fname, int ops, \
150 int facs, int pid); }
151 #else
152 45 EXCL ktrace
153 #endif
154 46 EXCL { int sys_sigaction(int signum, \
155 const struct sigaction13 *nsa, \
156 struct sigaction13 *osa); } sigaction13
157 #ifdef COMPAT_43
158 47 NOARGS { gid_t sys_getgid_with_egid(void); } getgid
159 #else
160 47 NOARGS { gid_t sys_getgid(void); }
161 #endif
162 48 EXCL { int sys_sigprocmask(int how, \
163 int mask); } sigprocmask13
164 49 NOARGS { int sys___getlogin(char *namebuf, size_t namelen); }
165 50 NOARGS { int sys___setlogin(const char *namebuf); }
166 51 NOARGS { int sys_acct(const char *path); }
167 52 EXCL { int sys_sigpending(void); } sigpending13
168 53 EXCL { int sys_sigaltstack( \
169 const struct sigaltstack13 *nss, \
170 struct sigaltstack13 *oss); } sigaltstack13
171 54 NOARGS { int sys_ioctl(int fd, \
172 u_long com, ... void *data); }
173 55 EXCL { int sys_reboot(int opt); } oreboot
174 56 STD { int pecoff_sys_revoke(const char *path); }
175 57 STD { int pecoff_sys_symlink(const char *path, \
176 const char *link); }
177 58 STD { int pecoff_sys_readlink(const char *path, char *buf, \
178 size_t count); }
179 59 STD { int pecoff_sys_execve(const char *path, \
180 char * const *argp, char * const *envp); }
181 60 NOARGS { mode_t sys_umask(mode_t newmask); }
182 61 STD { int pecoff_sys_chroot(const char *path); }
183 62 EXCL { int sys_fstat(int fd, struct stat43 *sb); } fstat43
184 63 EXCL { int sys_getkerninfo(int op, char *where, int *size, \
185 int arg); } ogetkerninfo
186 64 EXCL { int sys_getpagesize(void); } ogetpagesize
187 65 EXCL { int sys_msync(caddr_t addr, size_t len); }
188 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
189 66 NOARGS { int sys_vfork(void); }
190 67 OBSOL vread
191 68 OBSOL vwrite
192 69 NOARGS { int sys_sbrk(intptr_t incr); }
193 70 NOARGS { int sys_sstk(int incr); }
194 71 EXCL { int sys_mmap(caddr_t addr, size_t len, int prot, \
195 int flags, int fd, long pos); } ommap
196 72 NOARGS { int sys_ovadvise(int anom); } vadvise
197 73 NOARGS { int sys_munmap(void *addr, size_t len); }
198 74 NOARGS { int sys_mprotect(void *addr, size_t len, \
199 int prot); }
200 75 NOARGS { int sys_madvise(void *addr, size_t len, \
201 int behav); }
202 76 OBSOL vhangup
203 77 OBSOL vlimit
204 78 NOARGS { int sys_mincore(void *addr, size_t len, \
205 char *vec); }
206 79 NOARGS { int sys_getgroups(int gidsetsize, \
207 gid_t *gidset); }
208 80 NOARGS { int sys_setgroups(int gidsetsize, \
209 const gid_t *gidset); }
210 81 NOARGS { int sys_getpgrp(void); }
211 82 NOARGS { int sys_setpgid(int pid, int pgid); }
212 83 NOARGS { int sys_setitimer(int which, \
213 const struct itimerval *itv, \
214 struct itimerval *oitv); }
215 84 EXCL { int sys_wait(void); } owait
216 85 EXCL { int sys_swapon(const char *name); } oswapon
217 86 NOARGS { int sys_getitimer(int which, \
218 struct itimerval *itv); }
219 87 EXCL { int sys_gethostname(char *hostname, u_int len); } \
220 ogethostname
221 88 EXCL { int sys_sethostname(char *hostname, u_int len); } \
222 osethostname
223 89 EXCL { int sys_getdtablesize(void); } ogetdtablesize
224 90 NOARGS { int sys_dup2(int from, int to); }
225 91 UNIMPL getdopt
226 92 NOARGS { int sys_fcntl(int fd, int cmd, ... void *arg); }
227 93 NOARGS { int sys_select(int nd, fd_set *in, fd_set *ou, \
228 fd_set *ex, struct timeval *tv); }
229 94 UNIMPL setdopt
230 95 NOARGS { int sys_fsync(int fd); }
231 96 NOARGS { int sys_setpriority(int which, int who, int prio); }
232 97 NOARGS { int sys_socket(int domain, int type, int protocol); }
233 98 NOARGS { int sys_connect(int s, const struct sockaddr *name, \
234 unsigned int namelen); }
235 99 EXCL { int sys_accept(int s, caddr_t name, \
236 int *anamelen); } oaccept
237 100 NOARGS { int sys_getpriority(int which, int who); }
238 101 EXCL { int sys_send(int s, caddr_t buf, int len, \
239 int flags); } osend
240 102 EXCL { int sys_recv(int s, caddr_t buf, int len, \
241 int flags); } orecv
242 103 EXCL { int sys_sigreturn(struct sigcontext13 *sigcntxp); } \
243 sigreturn13
244 104 NOARGS { int sys_bind(int s, const struct sockaddr *name, \
245 unsigned int namelen); }
246 105 NOARGS { int sys_setsockopt(int s, int level, int name, \
247 const void *val, unsigned int valsize); }
248 106 NOARGS { int sys_listen(int s, int backlog); }
249 107 OBSOL vtimes
250 108 EXCL { int sys_sigvec(int signum, struct sigvec *nsv, \
251 struct sigvec *osv); } osigvec
252 109 EXCL { int sys_sigblock(int mask); } osigblock
253 110 EXCL { int sys_sigsetmask(int mask); } osigsetmask
254 111 EXCL { int sys_sigsuspend(int mask); } sigsuspend13
255 112 EXCL { int sys_sigstack(struct sigstack *nss, \
256 struct sigstack *oss); } osigstack
257 113 EXCL { int sys_recvmsg(int s, struct omsghdr *msg, \
258 int flags); } orecvmsg
259 114 EXCL { int sys_sendmsg(int s, caddr_t msg, int flags); } \
260 osendmsg
261 115 OBSOL vtrace
262 116 NOARGS { int sys_gettimeofday(struct timeval *tp, \
263 struct timezone *tzp); }
264 117 NOARGS { int sys_getrusage(int who, struct rusage *rusage); }
265 118 NOARGS { int sys_getsockopt(int s, int level, int name, \
266 void *val, unsigned int *avalsize); }
267 119 OBSOL resuba
268 120 NOARGS { ssize_t sys_readv(int fd, \
269 const struct iovec *iovp, int iovcnt); }
270 121 NOARGS { ssize_t sys_writev(int fd, \
271 const struct iovec *iovp, int iovcnt); }
272 122 NOARGS { int sys_settimeofday(const struct timeval *tv, \
273 const struct timezone *tzp); }
274 123 NOARGS { int sys_fchown(int fd, uid_t uid, gid_t gid); }
275 124 NOARGS { int sys_fchmod(int fd, mode_t mode); }
276 125 EXCL { int sys_recvfrom(int s, caddr_t buf, size_t len, \
277 int flags, caddr_t from, int *fromlenaddr); } \
278 orecvfrom
279 126 NOARGS { int sys_setreuid(uid_t ruid, uid_t euid); }
280 127 NOARGS { int sys_setregid(gid_t rgid, gid_t egid); }
281 128 STD { int pecoff_sys_rename(const char *from, \
282 const char *to); }
283 129 EXCL { int pecoff_compat_43_sys_truncate(const char *path, \
284 long length); } otruncate
285 130 EXCL { int sys_ftruncate(int fd, long length); } oftruncate
286 131 NOARGS { int sys_flock(int fd, int how); }
287 132 NOARGS { int sys_mkfifo(const char *path, mode_t mode); }
288 133 NOARGS { ssize_t sys_sendto(int s, const void *buf, \
289 size_t len, int flags, const struct sockaddr *to, \
290 unsigned int tolen); }
291 134 NOARGS { int sys_shutdown(int s, int how); }
292 135 NOARGS { int sys_socketpair(int domain, int type, \
293 int protocol, int *rsv); }
294 136 NOARGS { int sys_mkdir(const char *path, mode_t mode); }
295 137 STD { int pecoff_sys_rmdir(const char *path); }
296 138 STD { int pecoff_sys_utimes(const char *path, \
297 const struct timeval *tptr); }
298 139 OBSOL 4.2 sigreturn
299 140 NOARGS { int sys_adjtime(const struct timeval *delta, \
300 struct timeval *olddelta); }
301 141 EXCL { int sys_getpeername(int fdes, caddr_t asa, \
302 int *alen); } ogetpeername
303 142 EXCL { int32_t sys_gethostid(void); } ogethostid
304 143 EXCL { int sys_sethostid(int32_t hostid); } osethostid
305 144 EXCL { int sys_getrlimit(int which, \
306 struct orlimit *rlp); } ogetrlimit
307 145 EXCL { int sys_setrlimit(int which, \
308 const struct orlimit *rlp); } osetrlimit
309 146 EXCL { int sys_killpg(int pgid, int signum); } okillpg
310 147 NOARGS { int sys_setsid(void); }
311 148 NOARGS { int sys_quotactl(const char *path, int cmd, \
312 int uid, caddr_t arg); }
313 149 EXCL { int sys_quota(void); } oquota
314 150 EXCL { int sys_getsockname(int fdec, caddr_t asa, \
315 int *alen); } ogetsockname
316
317 ; Syscalls 151-180 inclusive are reserved for vendor-specific
318 ; system calls. (This includes various calls added for compatibity
319 ; with other Unix variants.)
320 ; Some of these calls are now supported by BSD...
321 151 UNIMPL
322 152 UNIMPL
323 153 UNIMPL
324 154 UNIMPL
325 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL)
326 155 NOARGS { int sys_nfssvc(int flag, void *argp); }
327 #else
328 155 EXCL nfssvc
329 #endif
330 156 EXCL { int sys_getdirentries(int fd, char *buf, \
331 u_int count, long *basep); } ogetdirentries
332 157 STD { int pecoff_sys_statfs(const char *path, \
333 struct statvfs12 *buf); }
334 #ifdef COMPAT_20
335 158 NOARGS { int compat_20_sys_fstatfs(int fd, \
336 struct statfs12 *buf); }
337 #else
338 158 EXCL compat_20_sys_fstatfs
339 #endif
340 159 UNIMPL
341 160 UNIMPL
342 161 STD { int pecoff_sys_getfh(const char *fname, \
343 fhandle_t *fhp); }
344 162 EXCL { int sys_getdomainname(char *domainname, int len); } \
345 ogetdomainname
346 163 EXCL { int sys_setdomainname(char *domainname, int len); } \
347 osetdomainname
348 164 EXCL { int sys_uname(struct outsname *name); } ouname
349 165 NOARGS { int sys_sysarch(int op, void *parms); }
350 166 UNIMPL
351 167 UNIMPL
352 168 UNIMPL
353 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
354 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64)
355 169 EXCL { int sys_semsys(int which, int a2, int a3, int a4, \
356 int a5); } osemsys
357 #else
358 169 EXCL 1.0 semsys
359 #endif
360 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
361 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64)
362 170 EXCL { int sys_msgsys(int which, int a2, int a3, int a4, \
363 int a5, int a6); } omsgsys
364 #else
365 170 EXCL 1.0 msgsys
366 #endif
367 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
368 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64)
369 171 EXCL { int sys_shmsys(int which, int a2, int a3, int a4); } \
370 oshmsys
371 #else
372 171 EXCL 1.0 shmsys
373 #endif
374 172 UNIMPL
375 173 NOARGS { ssize_t sys_pread(int fd, void *buf, \
376 size_t nbyte, int pad, off_t offset); }
377 174 NOARGS { ssize_t sys_pwrite(int fd, const void *buf, \
378 size_t nbyte, int pad, off_t offset); }
379 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
380 175 NOARGS { int sys_ntp_gettime(struct ntptimeval *ntvp); }
381 #if defined(NTP) || !defined(_KERNEL)
382 176 NOARGS { int sys_ntp_adjtime(struct timex *tp); }
383 #else
384 176 EXCL ntp_adjtime
385 #endif
386 177 UNIMPL
387 178 UNIMPL
388 179 UNIMPL
389 180 UNIMPL
390
391 ; Syscalls 180-199 are used by/reserved for BSD
392 181 NOARGS { int sys_setgid(gid_t gid); }
393 182 NOARGS { int sys_setegid(gid_t egid); }
394 183 NOARGS { int sys_seteuid(uid_t euid); }
395 #if defined(LFS) || !defined(_KERNEL)
396 184 NOARGS { int sys_lfs_bmapv(fsid_t *fsidp, \
397 struct block_info *blkiov, int blkcnt); }
398 185 NOARGS { int sys_lfs_markv(fsid_t *fsidp, \
399 struct block_info *blkiov, int blkcnt); }
400 186 NOARGS { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); }
401 187 NOARGS { int sys_lfs_segwait(fsid_t *fsidp, \
402 struct timeval *tv); }
403 #else
404 184 EXCL lfs_bmapv
405 185 EXCL lfs_markv
406 186 EXCL lfs_segclean
407 187 EXCL lfs_segwait
408 #endif
409 188 EXCL { int pecoff_compat_12_sys_stat(const char *path, \
410 struct stat12 *ub); } stat12
411 189 EXCL { int sys_fstat(int fd, struct stat12 *sb); } fstat12
412 190 EXCL { int pecoff_compat_12_sys_lstat(const char *path, \
413 struct stat12 *ub); } lstat12
414 191 STD { long pecoff_sys_pathconf(const char *path, int name); }
415 192 NOARGS { long sys_fpathconf(int fd, int name); }
416 193 UNIMPL
417 194 NOARGS { int sys_getrlimit(int which, \
418 struct rlimit *rlp); }
419 195 NOARGS { int sys_setrlimit(int which, \
420 const struct rlimit *rlp); }
421 196 EXCL { int sys_getdirentries(int fd, char *buf, \
422 u_int count, long *basep); }
423 197 NOARGS { void *sys_mmap(void *addr, size_t len, int prot, \
424 int flags, int fd, long pad, off_t pos); }
425 198 INDIR { quad_t sys___syscall(quad_t num, ...); }
426 199 NOARGS { off_t sys_lseek(int fd, int pad, off_t offset, \
427 int whence); }
428 200 STD { int pecoff_sys_truncate(const char *path, int pad, \
429 off_t length); }
430 201 NOARGS { int sys_ftruncate(int fd, int pad, off_t length); }
431 202 NOARGS { int sys___sysctl(int *name, u_int namelen, \
432 void *old, size_t *oldlenp, void *new, \
433 size_t newlen); }
434 203 NOARGS { int sys_mlock(const void *addr, size_t len); }
435 204 NOARGS { int sys_munlock(const void *addr, size_t len); }
436 205 STD { int pecoff_sys_undelete(const char *path); }
437 206 NOARGS { int sys_futimes(int fd, \
438 const struct timeval *tptr); }
439 207 NOARGS { pid_t sys_getpgid(pid_t pid); }
440 208 NOARGS { int sys_reboot(int opt, char *bootstr); }
441 209 NOARGS { int sys_poll(struct pollfd *fds, u_int nfds, \
442 int timeout); }
443 ;
444 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
445 ;
446 #if defined(LKM) || !defined(_KERNEL)
447 210 NODEF { int sys_lkmnosys(void); }
448 211 NODEF { int sys_lkmnosys(void); }
449 212 NODEF { int sys_lkmnosys(void); }
450 213 NODEF { int sys_lkmnosys(void); }
451 214 NODEF { int sys_lkmnosys(void); }
452 215 NODEF { int sys_lkmnosys(void); }
453 216 NODEF { int sys_lkmnosys(void); }
454 217 NODEF { int sys_lkmnosys(void); }
455 218 NODEF { int sys_lkmnosys(void); }
456 219 NODEF { int sys_lkmnosys(void); }
457 #else /* !LKM */
458 210 EXCL lkmnosys
459 211 EXCL lkmnosys
460 212 EXCL lkmnosys
461 213 EXCL lkmnosys
462 214 EXCL lkmnosys
463 215 EXCL lkmnosys
464 216 EXCL lkmnosys
465 217 EXCL lkmnosys
466 218 EXCL lkmnosys
467 219 EXCL lkmnosys
468 #endif /* !LKM */
469 ; System calls 220-300 are reserved for use by NetBSD
470 #if defined(SYSVSEM) || !defined(_KERNEL)
471 220 EXCL { int sys___semctl(int semid, int semnum, int cmd, \
472 union __semun *arg); }
473 221 NOARGS { int sys_semget(key_t key, int nsems, int semflg); }
474 222 NOARGS { int sys_semop(int semid, struct sembuf *sops, \
475 size_t nsops); }
476 223 NOARGS { int sys_semconfig(int flag); }
477 #else
478 220 EXCL compat_14_semctl
479 221 EXCL semget
480 222 EXCL semop
481 223 EXCL semconfig
482 #endif
483 #if defined(SYSVMSG) || !defined(_KERNEL)
484 224 EXCL { int sys_msgctl(int msqid, int cmd, \
485 struct msqid_ds14 *buf); }
486 225 NOARGS { int sys_msgget(key_t key, int msgflg); }
487 226 NOARGS { int sys_msgsnd(int msqid, const void *msgp, \
488 size_t msgsz, int msgflg); }
489 227 NOARGS { ssize_t sys_msgrcv(int msqid, void *msgp, \
490 size_t msgsz, long msgtyp, int msgflg); }
491 #else
492 224 EXCL compat_14_msgctl
493 225 EXCL msgget
494 226 EXCL msgsnd
495 227 EXCL msgrcv
496 #endif
497 #if defined(SYSVSHM) || !defined(_KERNEL)
498 228 NOARGS { void *sys_shmat(int shmid, const void *shmaddr, \
499 int shmflg); }
500 229 EXCL { int sys_shmctl(int shmid, int cmd, \
501 struct shmid_ds14 *buf); }
502 230 NOARGS { int sys_shmdt(const void *shmaddr); }
503 231 NOARGS { int sys_shmget(key_t key, size_t size, int shmflg); }
504 #else
505 228 EXCL shmat
506 229 EXCL compat_14_shmctl
507 230 EXCL shmdt
508 231 EXCL shmget
509 #endif
510 232 NOARGS { int sys_clock_gettime(clockid_t clock_id, \
511 struct timespec *tp); }
512 233 NOARGS { int sys_clock_settime(clockid_t clock_id, \
513 const struct timespec *tp); }
514 234 NOARGS { int sys_clock_getres(clockid_t clock_id, \
515 struct timespec *tp); }
516 235 NOARGS { int sys_timer_create(clockid_t clock_id, \
517 struct sigevent *evp, timer_t *timerid); }
518 236 NOARGS { int sys_timer_delete(timer_t timerid); }
519 237 NOARGS { int sys_timer_settime(timer_t timerid, int flags, \
520 const struct itimerspec *value, \
521 struct itimerspec *ovalue); }
522 238 NOARGS { int sys_timer_gettime(timer_t timerid, struct \
523 itimerspec *value); }
524 239 NOARGS { int sys_timer_getoverrun(timer_t timerid); }
525 ;
526 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
527 ;
528 240 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \
529 struct timespec *rmtp); }
530 241 NOARGS { int sys_fdatasync(int fd); }
531 242 NOARGS { int sys_mlockall(int flags); }
532 243 NOARGS { int sys_munlockall(void); }
533 244 NOARGS { int sys___sigtimedwait(const sigset_t *set, \
534 siginfo_t *info, \
535 struct timespec *timeout); }
536 245 UNIMPL sys_sigqueue
537 ;
538 ; Syscall 246 is free for any use
539 ;
540 246 UNIMPL
541 #if defined(P1003_1B_SEMAPHORE) || !defined(_KERNEL)
542 247 NOARGS { int sys__ksem_init(unsigned int value, semid_t *idp); }
543 248 NOARGS { int sys__ksem_open(const char *name, int oflag, \
544 mode_t mode, unsigned int value, semid_t *idp); }
545 249 NOARGS { int sys__ksem_unlink(const char *name); }
546 250 NOARGS { int sys__ksem_close(semid_t id); }
547 251 NOARGS { int sys__ksem_post(semid_t id); }
548 252 NOARGS { int sys__ksem_wait(semid_t id); }
549 253 NOARGS { int sys__ksem_trywait(semid_t id); }
550 254 NOARGS { int sys__ksem_getvalue(semid_t id, \
551 unsigned int *value); }
552 255 NOARGS { int sys__ksem_destroy(semid_t id); }
553 256 UNIMPL sys__ksem_timedwait
554 #else
555 247 EXCL sys__ksem_init
556 248 EXCL sys__ksem_open
557 249 EXCL sys__ksem_unlink
558 250 EXCL sys__ksem_close
559 251 EXCL sys__ksem_post
560 252 EXCL sys__ksem_wait
561 253 EXCL sys__ksem_trywait
562 254 EXCL sys__ksem_getvalue
563 255 EXCL sys__ksem_destroy
564 256 UNIMPL sys__ksem_timedwait
565 #endif
566 257 UNIMPL sys_mq_open
567 258 UNIMPL sys_mq_close
568 259 UNIMPL sys_mq_unlink
569 260 UNIMPL sys_mq_getattr
570 261 UNIMPL sys_mq_setattr
571 262 UNIMPL sys_mq_notify
572 263 UNIMPL sys_mq_send
573 264 UNIMPL sys_mq_receive
574 265 UNIMPL sys_mq_timedsend
575 266 UNIMPL sys_mq_timedreceive
576 267 UNIMPL
577 268 UNIMPL
578 269 UNIMPL
579 270 STD { int pecoff_sys___posix_rename(const char *from, \
580 const char *to); }
581 271 NOARGS { int sys_swapctl(int cmd, const void *arg, int misc); }
582 272 NOARGS { int sys_getdents(int fd, char *buf, size_t count); }
583 273 NOARGS { int sys_minherit(void *addr, size_t len, \
584 int inherit); }
585 274 STD { int pecoff_sys_lchmod(const char *path, mode_t mode); }
586 275 STD { int pecoff_sys_lchown(const char *path, uid_t uid, \
587 gid_t gid); }
588 276 STD { int pecoff_sys_lutimes(const char *path, \
589 const struct timeval *tptr); }
590 277 NOARGS { int sys___msync13(void *addr, size_t len, int flags); }
591 278 STD { int pecoff_sys___stat13(const char *path, \
592 struct stat *ub); }
593 279 NOARGS { int sys___fstat13(int fd, struct stat *sb); }
594 280 STD { int pecoff_sys___lstat13(const char *path, \
595 struct stat *ub); }
596 281 NOARGS { int sys___sigaltstack14( \
597 const struct sigaltstack *nss, \
598 struct sigaltstack *oss); }
599 282 NOARGS { int sys___vfork14(void); }
600 283 STD { int pecoff_sys___posix_chown(const char *path, \
601 uid_t uid, gid_t gid); }
602 284 NOARGS { int sys___posix_fchown(int fd, uid_t uid, \
603 gid_t gid); }
604 285 STD { int pecoff_sys___posix_lchown(const char *path, uid_t uid, \
605 gid_t gid); }
606 286 NOARGS { pid_t sys_getsid(pid_t pid); }
607 287 NOARGS { pid_t sys___clone(int flags, void *stack); }
608 #if defined(KTRACE) || !defined(_KERNEL)
609 288 NOARGS { int sys_fktrace(const int fd, int ops, \
610 int facs, int pid); }
611 #else
612 288 EXCL ktrace
613 #endif
614 289 NOARGS { ssize_t sys_preadv(int fd, \
615 const struct iovec *iovp, int iovcnt, \
616 int pad, off_t offset); }
617 290 NOARGS { ssize_t sys_pwritev(int fd, \
618 const struct iovec *iovp, int iovcnt, \
619 int pad, off_t offset); }
620 #ifdef COMPAT_16
621 291 NOARGS { int compat_16_sys___sigaction14(int signum, \
622 const struct sigaction *nsa, \
623 struct sigaction *osa); }
624 #else
625 291 EXCL compat_16_sys___sigaction14
626 #endif
627 292 NOARGS { int sys___sigpending14(sigset_t *set); }
628 293 NOARGS { int sys___sigprocmask14(int how, \
629 const sigset_t *set, \
630 sigset_t *oset); }
631 294 NOARGS { int sys___sigsuspend14(const sigset_t *set); }
632 295 NOARGS { int compat_16_sys___sigreturn14(struct sigcontext *sigcntxp); }
633 296 NOARGS { int sys___getcwd(char *bufp, size_t length); }
634 297 NOARGS { int sys_fchroot(int fd); }
635 298 NOARGS { int sys_fhopen(const fhandle_t *fhp, int flags); }
636 299 NOARGS { int sys_fhstat(const fhandle_t *fhp, \
637 struct stat *sb); }
638 #ifdef COMPAT_20
639 300 NOARGS { int compat_20_sys_fhstatfs(const fhandle_t *fhp, \
640 struct statfs12 *buf); }
641 #else
642 300 EXCL compat_20_sys_fhstatfs
643 #endif
644 #if defined(SYSVSEM) || !defined(_KERNEL)
645 301 NOARGS { int sys_____semctl13(int semid, int semnum, int cmd, \
646 ... union __semun *arg); }
647 #else
648 301 EXCL ____semctl13
649 #endif
650 #if defined(SYSVMSG) || !defined(_KERNEL)
651 302 NOARGS { int sys___msgctl13(int msqid, int cmd, \
652 struct msqid_ds *buf); }
653 #else
654 302 EXCL __msgctl13
655 #endif
656 #if defined(SYSVSHM) || !defined(_KERNEL)
657 303 NOARGS { int sys___shmctl13(int shmid, int cmd, \
658 struct shmid_ds *buf); }
659 #else
660 303 EXCL __shmctl13
661 #endif
662 304 STD { int pecoff_sys_lchflags(const char *path, u_long flags); }
663 305 NOARGS { int sys_issetugid(void); }
664 306 NOARGS { int sys_utrace(const char *label, void *addr, \
665 size_t len); }
666 307 NOARGS { int sys_getcontext(struct __ucontext *ucp); }
667 308 NOARGS { int sys_setcontext(const struct __ucontext *ucp); }
668 309 NOARGS { int sys__lwp_create(const struct __ucontext *ucp, \
669 u_long flags, lwpid_t *new_lwp); }
670 310 NOARGS { int sys__lwp_exit(void); }
671 311 NOARGS { lwpid_t sys__lwp_self(void); }
672 312 NOARGS { int sys__lwp_wait(lwpid_t wait_for, \
673 lwpid_t *departed); }
674 313 NOARGS { int sys__lwp_suspend(lwpid_t target); }
675 314 NOARGS { int sys__lwp_continue(lwpid_t target); }
676 315 NOARGS { int sys__lwp_wakeup(lwpid_t target); }
677 316 NOARGS { void *sys__lwp_getprivate(void); }
678 317 NOARGS { void sys__lwp_setprivate(void *ptr); }
679 ; Syscalls 318-329 reserved for remaining Solaris-compatible LWP calls.
680 318 UNIMPL
681 319 UNIMPL
682 320 UNIMPL
683 321 UNIMPL
684 322 UNIMPL
685 323 UNIMPL
686 324 UNIMPL
687 325 UNIMPL
688 326 UNIMPL
689 327 UNIMPL
690 328 UNIMPL
691 329 UNIMPL
692 ; Scheduler activation syscalls
693 330 NOARGS { int sys_sa_register(sa_upcall_t new, \
694 sa_upcall_t *old, int flags); }
695 331 NOARGS { int sys_sa_stacks(int num, stack_t *stacks); }
696 332 NOARGS { int sys_sa_enable(void); }
697 333 NOARGS { int sys_sa_setconcurrency(int concurrency); }
698 334 NOARGS { int sys_sa_yield(void); }
699 335 NOARGS { int sys_sa_preempt(int sa_id); }
700 ;
701 ; Syscalls 336-339 are reserved for other scheduler activation syscalls.
702 ;
703 336 UNIMPL
704 337 UNIMPL
705 338 UNIMPL
706 339 UNIMPL
707 340 NOARGS { int sys___sigaction_sigtramp(int signum, \
708 const struct sigaction *nsa, \
709 struct sigaction *osa, \
710 void *tramp, int vers); }
711 341 NOARGS { int sys_pmc_get_info(int ctr, int op, void *args); }
712 342 NOARGS { int sys_pmc_control(int ctr, int op, void *args); }
713 343 NOARGS { int sys_rasctl(caddr_t addr, size_t len, int op); }
714 344 NOARGS { int sys_kqueue(void); }
715 345 NOARGS { int sys_kevent(int fd, \
716 const struct kevent *changelist, size_t nchanges, \
717 struct kevent *eventlist, size_t nevents, \
718 const struct timespec *timeout); }
719 ;
720 ; Syscalls 346-353 are reserved for the IEEE Std1003.1b scheduling syscalls
721 ;
722 346 UNIMPL sys_sched_setparam
723 347 UNIMPL sys_sched_getparam
724 348 UNIMPL sys_sched_setscheduler
725 349 UNIMPL sys_sched_getscheduler
726 350 UNIMPL sys_sched_yield
727 351 UNIMPL sys_sched_get_priority_max
728 352 UNIMPL sys_sched_get_priority_min
729 353 UNIMPL sys_sched_rr_get_interval
730
731 354 NOARGS { int sys_fsync_range(int fd, int flags, off_t start, \
732 off_t length); }
733 355 NOARGS { int sys_uuidgen(struct uuid *store, int count); }
734 356 NOARGS { int sys_getvfsstat(struct statvfs *buf, \
735 size_t bufsize, int flags); }
736 357 NOARGS { int sys_statvfs1(const char *path, \
737 struct statvfs *buf, int flags); }
738 358 NOARGS { int sys_fstatvfs1(int fd, struct statvfs *buf, \
739 int flags); }
740 359 NOARGS { int sys_fhstatvfs1(const fhandle_t *fhp, \
741 struct statvfs *buf, int flags); }
Cache object: e5f6a04b87e0877f8700262e79116983
|