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