| blob | f43e56def614455b8b15ea67f90bf9c5a6ab199e |
1 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
2 ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
3 ;
4 ; System call name/number master file.
5 ; Processed to create kern/init_sysent.c, kern/syscalls.c, sys/syscall.h,
6 ; sys/syscall.mk, sys/sysproto.h and sys/sysunion.h
8 ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments
9 ; number system call number, must be in order
10 ; type one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
11 ; NODEF, NOARGS, NOPROTO, NOIMPL
12 ; name pseudo-prototype of syscall routine
13 ; If one of the following alts is different, then all appear:
14 ; altname name of system call if different
15 ; alttag name of args struct tag if different from [o]`name'"_args"
16 ; altrtyp return type if not int (bogus - syscalls always return int)
17 ; for UNIMPL/OBSOL, name continues with comments
18 ;
19 ; NOTE: All system calls are now called without the MP lock. Those
20 ; that need the MP lock will acquire it.
22 ; types:
23 ; STD always included
24 ; COMPAT included on COMPAT #ifdef
25 ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
26 ; OBSOL obsolete, not included in system, only specifies name
27 ; UNIMPL not implemented, placeholder only
29 ; #ifdef's, etc. may be included, and are copied to the output files.
31 #include <sys/param.h>
32 #include <sys/sysent.h>
33 #include <sys/sysproto.h>
34 #include <sys/statvfs.h>
35 #include <machine/cpumask.h>
37 ; Reserved/unimplemented system calls in the range 0-150 inclusive
38 ; are reserved for use in future Berkeley releases.
39 ; Additional system calls implemented in vendor and other
40 ; redistributions should be placed in the reserved range at the end
41 ; of the current calls.
43 0 STD { int nosys(void); } syscall nosys_args int
44 1 STD { void exit(int rval); }
45 2 STD { int fork(void); }
46 3 STD { ssize_t read(int fd, void *buf, size_t nbyte); }
47 4 STD { ssize_t write(int fd, const void *buf, size_t nbyte); }
48 5 STD { int open(char *path, int flags, int mode); }
49 ; XXX should be { int open(const char *path, int flags, ...); }
50 ; but we're not ready for `const' or varargs.
51 ; XXX man page says `mode_t mode'.
52 6 STD { int close(int fd); }
53 7 STD { int wait4(int pid, int *status, int options, \
54 struct rusage *rusage); } wait4 wait_args int
55 8 OBSOL 4.3 creat
56 9 STD { int link(char *path, char *link); }
57 10 STD { int unlink(char *path); }
58 11 OBSOL execv
59 12 STD { int chdir(char *path); }
60 13 STD { int fchdir(int fd); }
61 14 STD { int mknod(char *path, int mode, int dev); }
62 15 STD { int chmod(char *path, int mode); }
63 16 STD { int chown(char *path, int uid, int gid); }
64 17 STD { int obreak(char *nsize); } break obreak_args int
65 18 STD { int getfsstat(struct statfs *buf, long bufsize, \
66 int flags); }
67 19 COMPAT { long lseek(int fd, long offset, int whence); }
68 20 STD { pid_t getpid(void); }
69 21 STD { int mount(char *type, char *path, int flags, \
70 caddr_t data); }
71 ; XXX `path' should have type `const char *' but we're not ready for that.
72 22 STD { int unmount(char *path, int flags); }
73 23 STD { int setuid(uid_t uid); }
74 24 STD { uid_t getuid(void); }
75 25 STD { uid_t geteuid(void); }
76 26 STD { int ptrace(int req, pid_t pid, caddr_t addr, \
77 int data); }
78 27 STD { int recvmsg(int s, struct msghdr *msg, int flags); }
79 28 STD { int sendmsg(int s, caddr_t msg, int flags); }
80 29 STD { int recvfrom(int s, caddr_t buf, size_t len, \
81 int flags, caddr_t from, int *fromlenaddr); }
82 30 STD { int accept(int s, caddr_t name, int *anamelen); }
83 31 STD { int getpeername(int fdes, caddr_t asa, int *alen); }
84 32 STD { int getsockname(int fdes, caddr_t asa, int *alen); }
85 33 STD { int access(char *path, int flags); }
86 34 STD { int chflags(char *path, int flags); }
87 35 STD { int fchflags(int fd, int flags); }
88 36 STD { int sync(void); }
89 37 STD { int kill(int pid, int signum); }
90 38 COMPAT { int stat(char *path, struct ostat *ub); }
91 39 STD { pid_t getppid(void); }
92 40 COMPAT { int lstat(char *path, struct ostat *ub); }
93 41 STD { int dup(int fd); }
94 42 STD { int pipe(void); }
95 43 STD { gid_t getegid(void); }
96 44 STD { int profil(caddr_t samples, size_t size, \
97 size_t offset, u_int scale); }
98 45 STD { int ktrace(const char *fname, int ops, int facs, \
99 int pid); }
100 46 OBSOL freebsd3_sigaction
101 47 STD { gid_t getgid(void); }
102 48 OBSOL freebsd3_sigprocmask
103 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
104 ; us the mask, not a pointer to it, and we return the old mask as the
105 ; (int) return value.
106 49 STD { int getlogin(char *namebuf, u_int namelen); }
107 50 STD { int setlogin(char *namebuf); }
108 51 STD { int acct(char *path); }
109 52 OBSOL freebsd3_sigpending
110 53 STD { int sigaltstack(stack_t *ss, stack_t *oss); }
111 54 STD { int ioctl(int fd, u_long com, caddr_t data); }
112 55 STD { int reboot(int opt); }
113 56 STD { int revoke(char *path); }
114 57 STD { int symlink(char *path, char *link); }
115 58 STD { int readlink(char *path, char *buf, int count); }
116 59 STD { int execve(char *fname, char **argv, char **envv); }
117 60 STD { int umask(int newmask); } umask umask_args int
118 61 STD { int chroot(char *path); }
119 62 COMPAT { int fstat(int fd, struct ostat *sb); }
120 63 COMPAT { int getkerninfo(int op, char *where, size_t *size, \
121 int arg); } getkerninfo getkerninfo_args int
122 64 COMPAT { int getpagesize(void); } \
123 getpagesize getpagesize_args int
124 65 STD { int msync(void *addr, size_t len, int flags); }
125 66 STD { pid_t vfork(void); }
126 67 OBSOL vread
127 68 OBSOL vwrite
128 69 STD { int sbrk(int incr); }
129 70 STD { int sstk(int incr); }
130 71 COMPAT { int mmap(void *addr, int len, int prot, \
131 int flags, int fd, long pos); }
132 72 COMPAT { int vadvise(int anom); } vadvise ovadvise_args int
133 73 STD { int munmap(void *addr, size_t len); }
134 74 STD { int mprotect(void *addr, size_t len, int prot); }
135 75 STD { int madvise(void *addr, size_t len, int behav); }
136 76 OBSOL vhangup
137 77 OBSOL vlimit
138 78 STD { int mincore(const void *addr, size_t len, \
139 char *vec); }
140 79 STD { int getgroups(u_int gidsetsize, gid_t *gidset); }
141 80 STD { int setgroups(u_int gidsetsize, gid_t *gidset); }
142 81 STD { int getpgrp(void); }
143 82 STD { int setpgid(int pid, int pgid); }
144 83 STD { int setitimer(u_int which, struct itimerval *itv, \
145 struct itimerval *oitv); }
146 84 COMPAT { int wait(void); }
147 85 STD { int swapon(char *name); }
148 86 STD { int getitimer(u_int which, struct itimerval *itv); }
149 87 COMPAT { int gethostname(char *hostname, u_int len); } \
150 gethostname gethostname_args int
151 88 COMPAT { int sethostname(char *hostname, u_int len); } \
152 sethostname sethostname_args int
153 89 STD { int getdtablesize(void); }
154 90 STD { int dup2(int from, int to); }
155 91 UNIMPL getdopt
156 92 STD { int fcntl(int fd, int cmd, long arg); }
157 ; XXX should be { int fcntl(int fd, int cmd, ...); }
158 ; but we're not ready for varargs.
159 ; XXX man page says `int arg' too.
160 93 STD { int select(int nd, fd_set *in, fd_set *ou, \
161 fd_set *ex, struct timeval *tv); }
162 94 UNIMPL setdopt
163 95 STD { int fsync(int fd); }
164 96 STD { int setpriority(int which, int who, int prio); }
165 97 STD { int socket(int domain, int type, int protocol); }
166 98 STD { int connect(int s, caddr_t name, int namelen); }
167 99 CPT_NOA { int accept(int s, caddr_t name, int *anamelen); } \
168 accept accept_args int
169 100 STD { int getpriority(int which, int who); }
170 101 COMPAT { int send(int s, caddr_t buf, int len, int flags); }
171 102 COMPAT { int recv(int s, caddr_t buf, int len, int flags); }
172 103 OBSOL freebsd3_sigreturn
173 104 STD { int bind(int s, caddr_t name, int namelen); }
174 105 STD { int setsockopt(int s, int level, int name, \
175 caddr_t val, int valsize); }
176 106 STD { int listen(int s, int backlog); }
177 107 OBSOL vtimes
178 108 OBSOL 4.3 sigvec
179 109 OBSOL 4.3 sigblock
180 110 OBSOL 4.3 sigsetmask
181 111 OBSOL freebsd3_sigsuspend
182 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
183 ; us the mask, not a pointer to it.
184 112 COMPAT { int sigstack(struct sigstack *nss, \
185 struct sigstack *oss); }
186 113 COMPAT { int recvmsg(int s, struct omsghdr *msg, int flags); }
187 114 COMPAT { int sendmsg(int s, caddr_t msg, int flags); }
188 115 OBSOL vtrace
189 116 STD { int gettimeofday(struct timeval *tp, \
190 struct timezone *tzp); }
191 117 STD { int getrusage(int who, struct rusage *rusage); }
192 118 STD { int getsockopt(int s, int level, int name, \
193 caddr_t val, int *avalsize); }
194 119 UNIMPL resuba (BSD/OS 2.x)
195 120 STD { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
196 121 STD { int writev(int fd, struct iovec *iovp, \
197 u_int iovcnt); }
198 122 STD { int settimeofday(struct timeval *tv, \
199 struct timezone *tzp); }
200 123 STD { int fchown(int fd, int uid, int gid); }
201 124 STD { int fchmod(int fd, int mode); }
202 125 CPT_NOA { int recvfrom(int s, caddr_t buf, size_t len, \
203 int flags, caddr_t from, int *fromlenaddr); } \
204 recvfrom recvfrom_args int
205 126 STD { int setreuid(int ruid, int euid); }
206 127 STD { int setregid(int rgid, int egid); }
207 128 STD { int rename(char *from, char *to); }
208 129 COMPAT { int truncate(char *path, long length); }
209 130 COMPAT { int ftruncate(int fd, long length); }
210 131 STD { int flock(int fd, int how); }
211 132 STD { int mkfifo(char *path, int mode); }
212 133 STD { int sendto(int s, caddr_t buf, size_t len, \
213 int flags, caddr_t to, int tolen); }
214 134 STD { int shutdown(int s, int how); }
215 135 STD { int socketpair(int domain, int type, int protocol, \
216 int *rsv); }
217 136 STD { int mkdir(char *path, int mode); }
218 137 STD { int rmdir(char *path); }
219 138 STD { int utimes(char *path, struct timeval *tptr); }
220 139 OBSOL 4.2 sigreturn
221 140 STD { int adjtime(struct timeval *delta, \
222 struct timeval *olddelta); }
223 141 COMPAT { int getpeername(int fdes, caddr_t asa, int *alen); }
224 142 OBSOL 4.3 gethostid
225 143 OBSOL 4.3 sethostid
226 144 COMPAT { int getrlimit(u_int which, struct orlimit *rlp); }
227 145 COMPAT { int setrlimit(u_int which, struct orlimit *rlp); }
228 146 OBSOL 4.3 killpg
229 147 STD { int setsid(void); }
230 148 STD { int quotactl(char *path, int cmd, int uid, \
231 caddr_t arg); }
232 149 COMPAT { int quota(void); }
233 150 CPT_NOA { int getsockname(int fdec, caddr_t asa, int *alen); }\
234 getsockname getsockname_args int
236 ; Syscalls 151-180 inclusive are reserved for vendor-specific
237 ; system calls. (This includes various calls added for compatibity
238 ; with other Unix variants.)
239 ; Some of these calls are now supported by BSD...
240 151 UNIMPL sem_lock (BSD/OS 2.x)
241 152 UNIMPL sem_wakeup (BSD/OS 2.x)
242 153 UNIMPL asyncdaemon (BSD/OS 2.x)
243 154 UNIMPL nosys
244 ; 155 is initialized by the NFS code, if present.
245 155 NOIMPL { int nfssvc(int flag, caddr_t argp); }
246 156 COMPAT { int getdirentries(int fd, char *buf, u_int count, \
247 long *basep); }
248 157 STD { int statfs(char *path, struct statfs *buf); }
249 158 STD { int fstatfs(int fd, struct statfs *buf); }
250 159 UNIMPL nosys
251 160 UNIMPL nosys
252 ; 161 is initialized by the NFS code, if present.
253 161 STD { int getfh(char *fname, struct fhandle *fhp); }
254 162 STD { int getdomainname(char *domainname, int len); }
255 163 STD { int setdomainname(char *domainname, int len); }
256 164 STD { int uname(struct utsname *name); }
257 165 STD { int sysarch(int op, char *parms); }
258 166 STD { int rtprio(int function, pid_t pid, \
259 struct rtprio *rtp); }
260 167 UNIMPL nosys
261 168 UNIMPL nosys
262 169 OBSOL semsys
263 170 OBSOL msgsys
264 171 OBSOL shmsys
265 172 UNIMPL nosys
266 173 STD { ssize_t extpread(int fd, void *buf, \
267 size_t nbyte, int flags, off_t offset); }
268 174 STD { ssize_t extpwrite(int fd, const void *buf, \
269 size_t nbyte, int flags, off_t offset); }
270 175 UNIMPL nosys
271 176 STD { int ntp_adjtime(struct timex *tp); }
272 177 UNIMPL sfork (BSD/OS 2.x)
273 178 UNIMPL getdescriptor (BSD/OS 2.x)
274 179 UNIMPL setdescriptor (BSD/OS 2.x)
275 180 UNIMPL nosys
277 ; Syscalls 181-199 are used by/reserved for BSD
278 181 STD { int setgid(gid_t gid); }
279 182 STD { int setegid(gid_t egid); }
280 183 STD { int seteuid(uid_t euid); }
281 184 UNIMPL lfs_bmapv
282 185 UNIMPL lfs_markv
283 186 UNIMPL lfs_segclean
284 187 UNIMPL lfs_segwait
285 188 UNIMPL nosys
286 189 UNIMPL nosys
287 190 UNIMPL nosys
288 191 STD { int pathconf(char *path, int name); }
289 192 STD { int fpathconf(int fd, int name); }
290 193 UNIMPL nosys
291 194 STD { int getrlimit(u_int which, \
292 struct rlimit *rlp); } \
293 getrlimit __getrlimit_args int
294 195 STD { int setrlimit(u_int which, \
295 struct rlimit *rlp); } \
296 setrlimit __setrlimit_args int
297 196 UNIMPL nosys
298 197 STD { caddr_t mmap(caddr_t addr, size_t len, int prot, \
299 int flags, int fd, int pad, off_t pos); }
300 198 STD { int nosys(void); } __syscall __syscall_args int
301 199 STD { off_t lseek(int fd, int pad, off_t offset, \
302 int whence); }
303 200 STD { int truncate(char *path, int pad, off_t length); }
304 201 STD { int ftruncate(int fd, int pad, off_t length); }
305 202 STD { int __sysctl(int *name, u_int namelen, void *old, \
306 size_t *oldlenp, void *new, size_t newlen); } \
307 __sysctl sysctl_args int
308 203 STD { int mlock(const void *addr, size_t len); }
309 204 STD { int munlock(const void *addr, size_t len); }
310 205 STD { int undelete(char *path); }
311 206 STD { int futimes(int fd, struct timeval *tptr); }
312 207 STD { int getpgid(pid_t pid); }
313 208 UNIMPL newreboot (NetBSD)
314 209 STD { int poll(struct pollfd *fds, u_int nfds, \
315 int timeout); }
317 ;
318 ; The following are reserved for loadable syscalls
319 ;
320 ; 210 is used by the Checkpoint Module
321 210 NODEF lkmnosys lkmnosys nosys_args int
322 211 NODEF lkmnosys lkmnosys nosys_args int
323 212 NODEF lkmnosys lkmnosys nosys_args int
324 213 NODEF lkmnosys lkmnosys nosys_args int
325 214 NODEF lkmnosys lkmnosys nosys_args int
326 215 NODEF lkmnosys lkmnosys nosys_args int
327 216 NODEF lkmnosys lkmnosys nosys_args int
328 217 NODEF lkmnosys lkmnosys nosys_args int
329 218 NODEF lkmnosys lkmnosys nosys_args int
330 219 NODEF lkmnosys lkmnosys nosys_args int
332 ;
333 ; The following were introduced with NetBSD/4.4Lite-2
334 ;
335 220 STD { int __semctl(int semid, int semnum, int cmd, \
336 union semun *arg); }
337 221 STD { int semget(key_t key, int nsems, int semflg); }
338 222 STD { int semop(int semid, struct sembuf *sops, \
339 u_int nsops); }
340 223 UNIMPL semconfig
341 224 STD { int msgctl(int msqid, int cmd, \
342 struct msqid_ds *buf); }
343 225 STD { int msgget(key_t key, int msgflg); }
344 226 STD { int msgsnd(int msqid, const void *msgp, size_t msgsz, \
345 int msgflg); }
346 227 STD { int msgrcv(int msqid, void *msgp, size_t msgsz, \
347 long msgtyp, int msgflg); }
348 228 STD { caddr_t shmat(int shmid, const void *shmaddr, \
349 int shmflg); }
350 229 STD { int shmctl(int shmid, int cmd, \
351 struct shmid_ds *buf); }
352 230 STD { int shmdt(const void *shmaddr); }
353 231 STD { int shmget(key_t key, size_t size, int shmflg); }
354 ;
355 232 STD { int clock_gettime(clockid_t clock_id, \
356 struct timespec *tp); }
357 233 STD { int clock_settime(clockid_t clock_id, \
358 const struct timespec *tp); }
359 234 STD { int clock_getres(clockid_t clock_id, \
360 struct timespec *tp); }
361 235 UNIMPL timer_create
362 236 UNIMPL timer_delete
363 237 UNIMPL timer_settime
364 238 UNIMPL timer_gettime
365 239 UNIMPL timer_getoverrun
366 240 STD { int nanosleep(const struct timespec *rqtp, \
367 struct timespec *rmtp); }
368 241 UNIMPL nosys
369 242 UNIMPL nosys
370 243 UNIMPL nosys
371 244 UNIMPL nosys
372 245 UNIMPL nosys
373 246 UNIMPL nosys
374 247 UNIMPL nosys
375 248 UNIMPL nosys
376 249 UNIMPL nosys
377 ; syscall numbers initially used in OpenBSD
378 250 STD { int minherit(void *addr, size_t len, int inherit); }
379 251 STD { int rfork(int flags); }
380 252 STD { int openbsd_poll(struct pollfd *fds, u_int nfds, \
381 int timeout); }
382 253 STD { int issetugid(void); }
383 254 STD { int lchown(char *path, int uid, int gid); }
384 255 UNIMPL nosys
385 256 UNIMPL nosys
386 257 UNIMPL nosys
387 258 UNIMPL nosys
388 259 UNIMPL nosys
389 260 UNIMPL nosys
390 261 UNIMPL nosys
391 262 UNIMPL nosys
392 263 UNIMPL nosys
393 264 UNIMPL nosys
394 265 UNIMPL nosys
395 266 UNIMPL nosys
396 267 UNIMPL nosys
397 268 UNIMPL nosys
398 269 UNIMPL nosys
399 270 UNIMPL nosys
400 271 UNIMPL nosys
401 272 UNIMPL nosys
402 273 UNIMPL nosys
403 274 STD { int lchmod(char *path, mode_t mode); }
404 275 NOPROTO { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
405 276 STD { int lutimes(char *path, struct timeval *tptr); }
406 277 NOPROTO { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
407 278 OBSOL nstat
408 279 OBSOL nfstat
409 280 OBSOL nlstat
410 281 UNIMPL nosys
411 282 UNIMPL nosys
412 283 UNIMPL nosys
413 284 UNIMPL nosys
414 285 UNIMPL nosys
415 286 UNIMPL nosys
416 287 UNIMPL nosys
417 288 UNIMPL nosys
418 ; 289 and 290 from NetBSD (OpenBSD: 267 and 268)
419 289 STD { ssize_t extpreadv(int fd, const struct iovec *iovp, \
420 int iovcnt, int flags, off_t offset); }
421 290 STD { ssize_t extpwritev(int fd, const struct iovec *iovp, \
422 int iovcnt, int flags, off_t offset); }
423 291 UNIMPL nosys
424 292 UNIMPL nosys
425 293 UNIMPL nosys
426 294 UNIMPL nosys
427 295 UNIMPL nosys
428 296 UNIMPL nosys
429 ; XXX 297 is 300 in NetBSD
430 297 STD { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
431 298 STD { int fhopen(const struct fhandle *u_fhp, int flags); }
432 299 UNIMPL nosys
433 ; syscall numbers for FreeBSD
434 300 STD { int modnext(int modid); }
435 301 STD { int modstat(int modid, struct module_stat* stat); }
436 302 STD { int modfnext(int modid); }
437 303 STD { int modfind(const char *name); }
438 304 STD { int kldload(const char *file); }
439 305 STD { int kldunload(int fileid); }
440 306 STD { int kldfind(const char *file); }
441 307 STD { int kldnext(int fileid); }
442 308 STD { int kldstat(int fileid, struct kld_file_stat* stat); }
443 309 STD { int kldfirstmod(int fileid); }
444 310 STD { int getsid(pid_t pid); }
445 311 STD { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
446 312 STD { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
447 313 OBSOL signanosleep
448 314 STD { int aio_return(struct aiocb *aiocbp); }
449 315 STD { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
450 316 STD { int aio_cancel(int fd, struct aiocb *aiocbp); }
451 317 STD { int aio_error(struct aiocb *aiocbp); }
452 318 STD { int aio_read(struct aiocb *aiocbp); }
453 319 STD { int aio_write(struct aiocb *aiocbp); }
454 320 STD { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
455 321 STD { int yield(void); }
456 322 UNIMPL thr_sleep
457 323 UNIMPL thr_wakeup
458 324 STD { int mlockall(int how); }
459 325 STD { int munlockall(void); }
460 326 STD { int __getcwd(u_char *buf, u_int buflen); }
462 327 STD { int sched_setparam (pid_t pid, const struct sched_param *param); }
463 328 STD { int sched_getparam (pid_t pid, struct sched_param *param); }
465 329 STD { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
466 330 STD { int sched_getscheduler (pid_t pid); }
468 331 STD { int sched_yield (void); }
469 332 STD { int sched_get_priority_max (int policy); }
470 333 STD { int sched_get_priority_min (int policy); }
471 334 STD { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
472 335 STD { int utrace(const void *addr, size_t len); }
473 336 OBSOL freebsd4_sendfile
474 337 STD { int kldsym(int fileid, int cmd, void *data); }
475 338 STD { int jail(struct jail *jail); }
476 339 UNIMPL pioctl
477 340 STD { int sigprocmask(int how, const sigset_t *set, \
478 sigset_t *oset); }
479 341 STD { int sigsuspend(const sigset_t *sigmask); }
480 342 STD { int sigaction(int sig, const struct sigaction *act, \
481 struct sigaction *oact); }
482 343 STD { int sigpending(sigset_t *set); }
483 344 STD { int sigreturn(ucontext_t *sigcntxp); }
484 345 STD { int sigtimedwait(const sigset_t *set,\
485 siginfo_t *info, const struct timespec *timeout); }
486 346 STD { int sigwaitinfo(const sigset_t *set,\
487 siginfo_t *info); }
488 347 STD { int __acl_get_file(const char *path, \
489 acl_type_t type, struct acl *aclp); }
490 348 STD { int __acl_set_file(const char *path, \
491 acl_type_t type, struct acl *aclp); }
492 349 STD { int __acl_get_fd(int filedes, acl_type_t type, \
493 struct acl *aclp); }
494 350 STD { int __acl_set_fd(int filedes, acl_type_t type, \
495 struct acl *aclp); }
496 351 STD { int __acl_delete_file(const char *path, \
497 acl_type_t type); }
498 352 STD { int __acl_delete_fd(int filedes, acl_type_t type); }
499 353 STD { int __acl_aclcheck_file(const char *path, \
500 acl_type_t type, struct acl *aclp); }
501 354 STD { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
502 struct acl *aclp); }
503 355 STD { int extattrctl(const char *path, int cmd, \
504 const char *filename, int attrnamespace, \
505 const char *attrname); }
506 356 STD { int extattr_set_file(const char *path, \
507 int attrnamespace, const char *attrname, \
508 void *data, size_t nbytes); }
509 357 STD { int extattr_get_file(const char *path, \
510 int attrnamespace, const char *attrname, \
511 void *data, size_t nbytes); }
512 358 STD { int extattr_delete_file(const char *path, \
513 int attrnamespace, const char *attrname); }
514 359 STD { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
515 360 STD { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
516 361 STD { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
517 362 STD { int kqueue(void); }
518 363 STD { int kevent(int fd, \
519 const struct kevent *changelist, int nchanges, \
520 struct kevent *eventlist, int nevents, \
521 const struct timespec *timeout); }
522 364 UNIMPL sctp_peeloff
523 ; 365-392 used by FreeBSD-current
524 365 UNIMPL nosys
525 366 UNIMPL nosys
526 367 UNIMPL nosys
527 368 UNIMPL nosys
528 369 UNIMPL nosys
529 370 UNIMPL nosys
530 371 UNIMPL nosys
531 372 UNIMPL nosys
532 373 UNIMPL nosys
533 374 UNIMPL nosys
534 375 UNIMPL nosys
535 376 UNIMPL nosys
536 377 UNIMPL nosys
537 378 UNIMPL nosys
538 379 UNIMPL nosys
539 380 UNIMPL nosys
540 381 UNIMPL nosys
541 382 UNIMPL nosys
542 383 UNIMPL nosys
543 384 UNIMPL nosys
544 385 UNIMPL nosys
545 386 UNIMPL nosys
546 387 UNIMPL nosys
547 388 UNIMPL nosys
548 389 UNIMPL nosys
549 390 STD { int kenv(int what, const char *name, char *value, int len); }
550 391 STD { int lchflags(char *path, int flags); }
551 392 STD { int uuidgen(struct uuid *store, int count); }
552 393 STD { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
553 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
554 ; 394-439 used by FreeBSD-current
555 394 UNIMPL nosys
556 395 UNIMPL nosys
557 396 UNIMPL nosys
558 397 UNIMPL nosys
559 398 UNIMPL nosys
560 399 UNIMPL nosys
561 400 UNIMPL nosys
562 401 UNIMPL nosys
563 402 UNIMPL nosys
564 403 UNIMPL nosys
565 404 UNIMPL nosys
566 405 UNIMPL nosys
567 406 UNIMPL nosys
568 407 UNIMPL nosys
569 408 UNIMPL nosys
570 409 UNIMPL nosys
571 410 UNIMPL nosys
572 411 UNIMPL nosys
573 412 UNIMPL nosys
574 413 UNIMPL nosys
575 414 UNIMPL nosys
576 415 UNIMPL nosys
577 416 UNIMPL nosys
578 417 UNIMPL nosys
579 418 UNIMPL nosys
580 419 UNIMPL nosys
581 420 UNIMPL nosys
582 421 UNIMPL nosys
583 422 UNIMPL nosys
584 423 UNIMPL nosys
585 424 UNIMPL nosys
586 425 UNIMPL nosys
587 426 UNIMPL nosys
588 427 UNIMPL nosys
589 428 UNIMPL nosys
590 429 UNIMPL nosys
591 430 UNIMPL nosys
592 431 UNIMPL nosys
593 432 UNIMPL nosys
594 433 UNIMPL nosys
595 434 UNIMPL nosys
596 435 UNIMPL nosys
597 436 UNIMPL nosys
598 437 UNIMPL nosys
599 438 UNIMPL nosys
600 439 UNIMPL nosys
601 ; 440-449 reserved for FreeBSD-5.x growth
602 440 UNIMPL nosys
603 441 UNIMPL nosys
604 442 UNIMPL nosys
605 443 UNIMPL nosys
606 444 UNIMPL nosys
607 445 UNIMPL nosys
608 446 UNIMPL nosys
609 447 UNIMPL nosys
610 448 UNIMPL nosys
611 449 UNIMPL nosys
612 ; 450 DragonFly system calls
613 450 STD { int varsym_set(int level, const char *name, const char *data); }
614 451 STD { int varsym_get(int mask, const char *wild, char *buf, int bufsize); }
615 452 STD { int varsym_list(int level, char *buf, int maxsize, int *marker); }
616 453 OBSOL upc_register
617 454 OBSOL upc_control
618 455 OBSOL caps_sys_service
619 456 OBSOL caps_sys_client
620 457 OBSOL caps_sys_close
621 458 OBSOL caps_sys_put
622 459 OBSOL caps_sys_reply
623 460 OBSOL caps_sys_get
624 461 OBSOL caps_sys_wait
625 462 OBSOL caps_sys_abort
626 463 OBSOL caps_sys_getgen
627 464 OBSOL caps_sys_setgen
628 465 STD { int exec_sys_register(void *entry); }
629 466 STD { int exec_sys_unregister(int id); }
630 467 STD { int sys_checkpoint(int type, int fd, pid_t pid, int retval); }
631 468 STD { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); }
632 469 STD { int umtx_sleep(volatile const int *ptr, int value, int timeout); }
633 470 STD { int umtx_wakeup(volatile const int *ptr, int count); }
634 471 STD { int jail_attach(int jid); }
635 472 STD { int set_tls_area(int which, struct tls_info *info, size_t infosize); }
636 473 STD { int get_tls_area(int which, struct tls_info *info, size_t infosize); }
637 474 STD { int closefrom(int fd); }
638 475 STD { int stat(const char *path, struct stat *ub); }
639 476 STD { int fstat(int fd, struct stat *sb); }
640 477 STD { int lstat(const char *path, struct stat *ub); }
641 478 STD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
642 479 STD { int getdirentries(int fd, char *buf, u_int count, \
643 long *basep); }
644 480 STD { int getdents(int fd, char *buf, size_t count); }
645 481 STD { int usched_set(pid_t pid, int cmd, void *data, \
646 int bytes); }
647 482 STD { int extaccept(int s, int flags, caddr_t name, int *anamelen); }
648 483 STD { int extconnect(int s, int flags, caddr_t name, int namelen); }
649 484 OBSOL syslink
650 485 STD { int mcontrol(void *addr, size_t len, int behav, off_t value); }
651 486 STD { int vmspace_create(void *id, int type, void *data); }
652 487 STD { int vmspace_destroy(void *id); }
653 488 STD { int vmspace_ctl(void *id, int cmd, \
654 struct trapframe *tframe, \
655 struct vextframe *vframe); }
656 489 STD { int vmspace_mmap(void *id, void *addr, size_t len, \
657 int prot, int flags, int fd, \
658 off_t offset); }
659 490 STD { int vmspace_munmap(void *id, void *addr, \
660 size_t len); }
661 491 STD { int vmspace_mcontrol(void *id, void *addr, \
662 size_t len, int behav, off_t value); }
663 492 STD { ssize_t vmspace_pread(void *id, void *buf, \
664 size_t nbyte, int flags, off_t offset); }
665 493 STD { ssize_t vmspace_pwrite(void *id, const void *buf, \
666 size_t nbyte, int flags, off_t offset); }
667 494 STD { void extexit(int how, int status, void *addr); }
668 495 STD { int lwp_create(struct lwp_params *params); }
669 496 STD { lwpid_t lwp_gettid(void); }
670 497 STD { int lwp_kill(pid_t pid, lwpid_t tid, int signum); }
671 498 STD { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); }
672 499 STD { int pselect(int nd, fd_set *in, fd_set *ou, \
673 fd_set *ex, const struct timespec *ts, \
674 const sigset_t *sigmask); }
675 500 STD { int statvfs(const char *path, struct statvfs *buf); }
676 501 STD { int fstatvfs(int fd, struct statvfs *buf); }
677 502 STD { int fhstatvfs(const struct fhandle *u_fhp, struct statvfs *buf); }
678 503 STD { int getvfsstat(struct statfs *buf, \
679 struct statvfs *vbuf, long vbufsize, int flags); }
680 504 STD { int openat(int fd, char *path, int flags, int mode); }
681 ; XXX should be { int openat(int fd, const char *path, int flags, ...);}
682 ; but we're not ready for `const' or varargs.
683 ; XXX man page says `mode_t mode'.
684 505 STD { int fstatat(int fd, char *path, \
685 struct stat *sb, int flags); }
686 506 STD { int fchmodat(int fd, char *path, int mode, \
687 int flags); }
688 507 STD { int fchownat(int fd, char *path, int uid, int gid, \
689 int flags); }
690 508 STD { int unlinkat(int fd, char *path, int flags); }
691 509 STD { int faccessat(int fd, char *path, int amode, \
692 int flags); }
694 ; POSIX message queues system calls
695 510 STD { mqd_t mq_open(const char * name, int oflag, \
696 mode_t mode, struct mq_attr *attr); }
697 511 STD { int mq_close(mqd_t mqdes); }
698 512 STD { int mq_unlink(const char *name); }
699 513 STD { int mq_getattr(mqd_t mqdes, \
700 struct mq_attr *mqstat); }
701 514 STD { int mq_setattr(mqd_t mqdes, \
702 const struct mq_attr *mqstat, \
703 struct mq_attr *omqstat); }
704 515 STD { int mq_notify(mqd_t mqdes, \
705 const struct sigevent *notification); }
706 516 STD { int mq_send(mqd_t mqdes, const char *msg_ptr, \
707 size_t msg_len, unsigned msg_prio); }
708 517 STD { ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, \
709 size_t msg_len, unsigned *msg_prio); }
710 518 STD { int mq_timedsend(mqd_t mqdes, \
711 const char *msg_ptr, size_t msg_len, \
712 unsigned msg_prio, \
713 const struct timespec *abs_timeout); }
714 519 STD { ssize_t mq_timedreceive(mqd_t mqdes, \
715 char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
716 const struct timespec *abs_timeout); }
717 520 STD { int ioprio_set(int which, int who, int prio); }
718 521 STD { int ioprio_get(int which, int who); }
719 522 STD { int chroot_kernel(char *path); }
720 523 STD { int renameat(int oldfd, char *old, int newfd, \
721 char *new); }
722 524 STD { int mkdirat(int fd, char *path, mode_t mode); }
723 525 STD { int mkfifoat(int fd, char *path, mode_t mode); }
724 526 STD { int mknodat(int fd, char *path, mode_t mode, \
725 dev_t dev); }
726 527 STD { int readlinkat(int fd, char *path, char *buf, \
727 size_t bufsize); }
728 528 STD { int symlinkat(char *path1, int fd, char *path2); }
729 529 STD { int swapoff(char *name); }
730 530 STD { int vquotactl(const char *path, \
731 struct plistref *pref); }
732 531 STD { int linkat(int fd1, char *path1, int fd2, \
733 char *path2, int flags); }
734 532 STD { int eaccess(char *path, int flags); }
735 533 STD { int lpathconf(char *path, int name); }
736 534 STD { int vmm_guest_ctl(int op, struct vmm_guest_options *options); }
737 535 STD { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); }
738 536 STD { int procctl(idtype_t idtype, id_t id, int cmd, void *data); }
739 537 STD { int chflagsat(int fd, const char *path, int flags, int atflags);}
740 538 STD { int pipe2(int *fildes, int flags); }
741 539 STD { int utimensat(int fd, const char *path, const struct timespec *ts, int flags); }
742 540 STD { int futimens(int fd, const struct timespec *ts); }
743 541 STD { int accept4(int s, caddr_t name, int *anamelen, int flags); }
744 542 STD { int lwp_setname(lwpid_t tid, const char *name); }
745 543 STD { int ppoll(struct pollfd *fds, u_int nfds, \
746 const struct timespec *ts, const sigset_t *sigmask); }
747 544 STD { int lwp_setaffinity(pid_t pid, lwpid_t tid, const cpumask_t *mask); }
748 545 STD { int lwp_getaffinity(pid_t pid, lwpid_t tid, cpumask_t *mask); }
749 546 STD { int lwp_create2(struct lwp_params *params, const cpumask_t *mask); }
750 547 STD { int getcpuclockid(pid_t pid, lwpid_t lwp_id, clockid_t *clock_id); }