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