1 ; $OpenBSD: syscalls.master,v 1.90 2008/03/16 19:42:57 otto Exp $
2 ; $NetBSD: syscalls.master,v 1.32 1996/04/23 10:24:21 mycroft Exp $
3
4 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94
5
6 ; OpenBSD system call name/number "master" file.
7 ; (See syscalls.conf to see what it is processed into.)
8 ;
9 ; Fields: number type [type-dependent ...]
10 ; number system call number, must be in order
11 ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
12 ; the compatibility options defined in syscalls.conf.
13 ;
14 ; types:
15 ; STD always included
16 ; OBSOL obsolete, not included in system
17 ; UNIMPL unimplemented, not included in system
18 ; NODEF included, but don't define the syscall number
19 ; NOARGS included, but don't define the syscall args structure
20 ; INDIR included, but don't define the syscall args structure,
21 ; and allow it to be "really" varargs.
22 ;
23 ; The compat options are defined in the syscalls.conf file, and the
24 ; compat option name is prefixed to the syscall name. Other than
25 ; that, they're like NODEF (for 'compat' options), or STD (for
26 ; 'libcompat' options).
27 ;
28 ; The type-dependent arguments are as follows:
29 ; For STD, NODEF, NOARGS, and compat syscalls:
30 ; { pseudo-proto } [alias]
31 ; For other syscalls:
32 ; [comment]
33 ;
34 ; #ifdef's, etc. may be included, and are copied to the output files.
35 ; #include's are copied to the syscall switch definition file only.
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/signal.h>
40 #include <sys/mount.h>
41 #include <sys/syscallargs.h>
42 #include <sys/poll.h>
43 #include <sys/event.h>
44 #include <xfs/xfs_pioctl.h>
45
46 ; Reserved/unimplemented system calls in the range 0-150 inclusive
47 ; are reserved for use in future Berkeley releases.
48 ; Additional system calls implemented in vendor and other
49 ; redistributions should be placed in the reserved range at the end
50 ; of the current calls.
51
52 0 INDIR { int sys_syscall(int number, ...); }
53 1 STD { void sys_exit(int rval); }
54 2 STD { int sys_fork(void); }
55 3 STD { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
56 4 STD { ssize_t sys_write(int fd, const void *buf, \
57 size_t nbyte); }
58 5 STD { int sys_open(const char *path, \
59 int flags, ... mode_t mode); }
60 6 STD { int sys_close(int fd); }
61 7 STD { pid_t sys_wait4(pid_t pid, int *status, int options, \
62 struct rusage *rusage); }
63 8 COMPAT_43 { int sys_creat(const char *path, mode_t mode); } ocreat
64 9 STD { int sys_link(const char *path, const char *link); }
65 10 STD { int sys_unlink(const char *path); }
66 11 OBSOL execv
67 12 STD { int sys_chdir(const char *path); }
68 13 STD { int sys_fchdir(int fd); }
69 14 STD { int sys_mknod(const char *path, mode_t mode, \
70 dev_t dev); }
71 15 STD { int sys_chmod(const char *path, mode_t mode); }
72 16 STD { int sys_chown(const char *path, uid_t uid, \
73 gid_t gid); }
74 17 STD { int sys_obreak(char *nsize); } break
75 18 COMPAT_25 { int sys_getfsstat(struct statfs *buf, long bufsize, \
76 int flags); } ogetfsstat
77 19 COMPAT_43 { long sys_lseek(int fd, long offset, int whence); } \
78 olseek
79 20 STD NOLOCK { pid_t sys_getpid(void); }
80 21 STD { int sys_mount(const char *type, const char *path, \
81 int flags, void *data); }
82 22 STD { int sys_unmount(const char *path, int flags); }
83 23 STD { int sys_setuid(uid_t uid); }
84 24 STD { uid_t sys_getuid(void); }
85 25 STD { uid_t sys_geteuid(void); }
86 #ifdef PTRACE
87 26 STD { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
88 int data); }
89 #else
90 26 UNIMPL ptrace
91 #endif
92 27 STD { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
93 int flags); }
94 28 STD { ssize_t sys_sendmsg(int s, \
95 const struct msghdr *msg, int flags); }
96 29 STD { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
97 int flags, struct sockaddr *from, \
98 socklen_t *fromlenaddr); }
99 30 STD { int sys_accept(int s, struct sockaddr *name, \
100 socklen_t *anamelen); }
101 31 STD { int sys_getpeername(int fdes, struct sockaddr *asa, \
102 socklen_t *alen); }
103 32 STD { int sys_getsockname(int fdes, struct sockaddr *asa, \
104 socklen_t *alen); }
105 33 STD { int sys_access(const char *path, int flags); }
106 34 STD { int sys_chflags(const char *path, u_int flags); }
107 35 STD { int sys_fchflags(int fd, u_int flags); }
108 36 STD { void sys_sync(void); }
109 37 STD { int sys_kill(int pid, int signum); }
110 38 COMPAT_43 { int sys_stat(const char *path, struct stat43 *ub); } \
111 stat43
112 39 STD { pid_t sys_getppid(void); }
113 40 COMPAT_43 { int sys_lstat(char *path, \
114 struct stat43 *ub); } lstat43
115 41 STD { int sys_dup(int fd); }
116 42 STD { int sys_opipe(void); }
117 43 STD { gid_t sys_getegid(void); }
118 44 STD { int sys_profil(caddr_t samples, size_t size, \
119 u_long offset, u_int scale); }
120 #ifdef KTRACE
121 45 STD { int sys_ktrace(const char *fname, int ops, \
122 int facs, pid_t pid); }
123 #else
124 45 UNIMPL ktrace
125 #endif
126 46 STD { int sys_sigaction(int signum, \
127 const struct sigaction *nsa, \
128 struct sigaction *osa); }
129 47 STD { gid_t sys_getgid(void); }
130 48 STD { int sys_sigprocmask(int how, sigset_t mask); }
131 49 STD { int sys_getlogin(char *namebuf, u_int namelen); }
132 50 STD { int sys_setlogin(const char *namebuf); }
133 #ifdef ACCOUNTING
134 51 STD { int sys_acct(const char *path); }
135 #else
136 51 UNIMPL acct
137 #endif
138 52 STD { int sys_sigpending(void); }
139 53 STD { int sys_osigaltstack(const struct osigaltstack *nss, \
140 struct osigaltstack *oss); }
141 54 STD { int sys_ioctl(int fd, \
142 u_long com, ... void *data); }
143 55 STD { int sys_reboot(int opt); }
144 56 STD { int sys_revoke(const char *path); }
145 57 STD { int sys_symlink(const char *path, \
146 const char *link); }
147 58 STD { int sys_readlink(const char *path, char *buf, \
148 size_t count); }
149 59 STD { int sys_execve(const char *path, \
150 char * const *argp, char * const *envp); }
151 60 STD { mode_t sys_umask(mode_t newmask); }
152 61 STD { int sys_chroot(const char *path); }
153 62 COMPAT_43 { int sys_fstat(int fd, struct stat43 *sb); } fstat43
154 63 COMPAT_43 { int sys_getkerninfo(int op, char *where, int *size, \
155 int arg); } ogetkerninfo
156 64 COMPAT_43 { int sys_getpagesize(void); } ogetpagesize
157 65 COMPAT_25 { int sys_omsync(caddr_t addr, size_t len); }
158 66 STD { int sys_vfork(void); }
159 67 OBSOL vread
160 68 OBSOL vwrite
161 69 STD { int sys_sbrk(int incr); }
162 70 STD { int sys_sstk(int incr); }
163 71 COMPAT_43 { int sys_mmap(caddr_t addr, size_t len, int prot, \
164 int flags, int fd, long pos); } ommap
165 72 OBSOL vadvise
166 73 STD { int sys_munmap(void *addr, size_t len); }
167 74 STD { int sys_mprotect(void *addr, size_t len, \
168 int prot); }
169 75 STD { int sys_madvise(void *addr, size_t len, \
170 int behav); }
171 76 OBSOL vhangup
172 77 OBSOL vlimit
173 78 STD { int sys_mincore(void *addr, size_t len, \
174 char *vec); }
175 79 STD { int sys_getgroups(int gidsetsize, \
176 gid_t *gidset); }
177 80 STD { int sys_setgroups(int gidsetsize, \
178 const gid_t *gidset); }
179 81 STD { int sys_getpgrp(void); }
180 82 STD { int sys_setpgid(pid_t pid, int pgid); }
181 83 STD { int sys_setitimer(int which, \
182 const struct itimerval *itv, \
183 struct itimerval *oitv); }
184 84 COMPAT_43 { int sys_wait(void); } owait
185 85 COMPAT_25 { int sys_swapon(const char *name); }
186 86 STD { int sys_getitimer(int which, \
187 struct itimerval *itv); }
188 87 COMPAT_43 { int sys_gethostname(char *hostname, u_int len); } \
189 ogethostname
190 88 COMPAT_43 { int sys_sethostname(char *hostname, u_int len); } \
191 osethostname
192 89 COMPAT_43 { int sys_getdtablesize(void); } ogetdtablesize
193 90 STD { int sys_dup2(int from, int to); }
194 91 UNIMPL getdopt
195 92 STD { int sys_fcntl(int fd, int cmd, ... void *arg); }
196 93 STD { int sys_select(int nd, fd_set *in, fd_set *ou, \
197 fd_set *ex, struct timeval *tv); }
198 94 UNIMPL setdopt
199 95 STD { int sys_fsync(int fd); }
200 96 STD { int sys_setpriority(int which, id_t who, int prio); }
201 97 STD { int sys_socket(int domain, int type, int protocol); }
202 98 STD { int sys_connect(int s, const struct sockaddr *name, \
203 socklen_t namelen); }
204 99 COMPAT_43 { int sys_accept(int s, caddr_t name, \
205 int *anamelen); } oaccept
206 100 STD { int sys_getpriority(int which, id_t who); }
207 101 COMPAT_43 { int sys_send(int s, caddr_t buf, int len, \
208 int flags); } osend
209 102 COMPAT_43 { int sys_recv(int s, caddr_t buf, int len, \
210 int flags); } orecv
211 103 STD { int sys_sigreturn(struct sigcontext *sigcntxp); }
212 104 STD { int sys_bind(int s, const struct sockaddr *name, \
213 socklen_t namelen); }
214 105 STD { int sys_setsockopt(int s, int level, int name, \
215 const void *val, socklen_t valsize); }
216 106 STD { int sys_listen(int s, int backlog); }
217 107 OBSOL vtimes
218 108 COMPAT_43 { int sys_sigvec(int signum, struct sigvec *nsv, \
219 struct sigvec *osv); } osigvec
220 109 COMPAT_43 { int sys_sigblock(int mask); } osigblock
221 110 COMPAT_43 { int sys_sigsetmask(int mask); } osigsetmask
222 111 STD { int sys_sigsuspend(int mask); }
223 112 COMPAT_43 { int sys_sigstack(struct sigstack *nss, \
224 struct sigstack *oss); } osigstack
225 113 COMPAT_43 { int sys_recvmsg(int s, struct omsghdr *msg, \
226 int flags); } orecvmsg
227 114 COMPAT_43 { int sys_sendmsg(int s, caddr_t msg, int flags); } \
228 osendmsg
229 115 OBSOL vtrace
230 116 STD { int sys_gettimeofday(struct timeval *tp, \
231 struct timezone *tzp); }
232 117 STD { int sys_getrusage(int who, struct rusage *rusage); }
233 118 STD { int sys_getsockopt(int s, int level, int name, \
234 void *val, socklen_t *avalsize); }
235 119 OBSOL resuba
236 120 STD { ssize_t sys_readv(int fd, \
237 const struct iovec *iovp, int iovcnt); }
238 121 STD { ssize_t sys_writev(int fd, \
239 const struct iovec *iovp, int iovcnt); }
240 122 STD { int sys_settimeofday(const struct timeval *tv, \
241 const struct timezone *tzp); }
242 123 STD { int sys_fchown(int fd, uid_t uid, gid_t gid); }
243 124 STD { int sys_fchmod(int fd, mode_t mode); }
244 125 COMPAT_43 { int sys_recvfrom(int s, caddr_t buf, size_t len, \
245 int flags, caddr_t from, int *fromlenaddr); } \
246 orecvfrom
247 126 STD { int sys_setreuid(uid_t ruid, uid_t euid); }
248 127 STD { int sys_setregid(gid_t rgid, gid_t egid); }
249 128 STD { int sys_rename(const char *from, const char *to); }
250 129 COMPAT_43 { int sys_truncate(const char *path, long length); } \
251 otruncate
252 130 COMPAT_43 { int sys_ftruncate(int fd, long length); } oftruncate
253 131 STD { int sys_flock(int fd, int how); }
254 132 STD { int sys_mkfifo(const char *path, mode_t mode); }
255 133 STD { ssize_t sys_sendto(int s, const void *buf, \
256 size_t len, int flags, const struct sockaddr *to, \
257 socklen_t tolen); }
258 134 STD { int sys_shutdown(int s, int how); }
259 135 STD { int sys_socketpair(int domain, int type, \
260 int protocol, int *rsv); }
261 136 STD { int sys_mkdir(const char *path, mode_t mode); }
262 137 STD { int sys_rmdir(const char *path); }
263 138 STD { int sys_utimes(const char *path, \
264 const struct timeval *tptr); }
265 139 OBSOL 4.2 sigreturn
266 140 STD { int sys_adjtime(const struct timeval *delta, \
267 struct timeval *olddelta); }
268 141 COMPAT_43 { int sys_getpeername(int fdes, caddr_t asa, \
269 socklen_t *alen); } ogetpeername
270 142 COMPAT_43 { int32_t sys_gethostid(void); } ogethostid
271 143 COMPAT_43 { int sys_sethostid(int32_t hostid); } osethostid
272 144 COMPAT_43 { int sys_getrlimit(int which, \
273 struct ogetrlimit *rlp); } ogetrlimit
274 145 COMPAT_43 { int sys_setrlimit(int which, \
275 struct ogetrlimit *rlp); } osetrlimit
276 146 COMPAT_43 { int sys_killpg(int pgid, int signum); } okillpg
277 147 STD { int sys_setsid(void); }
278 148 STD { int sys_quotactl(const char *path, int cmd, \
279 int uid, char *arg); }
280 149 COMPAT_43 { int sys_quota(void); } oquota
281 150 COMPAT_43 { int sys_getsockname(int fdec, caddr_t asa, \
282 int *alen); } ogetsockname
283
284 ; Syscalls 151-180 inclusive are reserved for vendor-specific
285 ; system calls. (This includes various calls added for compatibity
286 ; with other Unix variants.)
287 ; Some of these calls are now supported by BSD...
288 151 UNIMPL
289 152 UNIMPL
290 153 UNIMPL
291 154 UNIMPL
292 #if defined(NFSCLIENT) || defined(NFSSERVER)
293 155 STD { int sys_nfssvc(int flag, void *argp); }
294 #else
295 155 UNIMPL
296 #endif
297 156 COMPAT_43 { int sys_getdirentries(int fd, char *buf, \
298 int count, long *basep); } ogetdirentries
299 157 COMPAT_25 { int sys_statfs(const char *path, \
300 struct ostatfs *buf); } ostatfs
301 158 COMPAT_25 { int sys_fstatfs(int fd, struct ostatfs *buf); } \
302 ostatfs
303 159 UNIMPL
304 160 UNIMPL
305 161 STD { int sys_getfh(const char *fname, fhandle_t *fhp); }
306 162 COMPAT_09 { int sys_getdomainname(char *domainname, int len); } \
307 ogetdomainname
308 163 COMPAT_09 { int sys_setdomainname(char *domainname, int len); } \
309 osetdomainname
310 164 UNIMPL ouname
311 165 STD { int sys_sysarch(int op, void *parms); }
312 166 UNIMPL
313 167 UNIMPL
314 168 UNIMPL
315 #if defined(SYSVSEM) && !defined(__LP64__)
316 169 COMPAT_10 { int sys_semsys(int which, int a2, int a3, int a4, \
317 int a5); } osemsys
318 #else
319 169 UNIMPL 1.0 semsys
320 #endif
321 #if defined(SYSVMSG) && !defined(__LP64__)
322 170 COMPAT_10 { int sys_msgsys(int which, int a2, int a3, int a4, \
323 int a5, int a6); } omsgsys
324 #else
325 170 UNIMPL 1.0 msgsys
326 #endif
327 #if defined(SYSVSHM) && !defined(__LP64__)
328 171 COMPAT_10 { int sys_shmsys(int which, int a2, int a3, int a4); } \
329 oshmsys
330 #else
331 171 UNIMPL 1.0 shmsys
332 #endif
333 172 UNIMPL
334 173 STD { ssize_t sys_pread(int fd, void *buf, \
335 size_t nbyte, int pad, off_t offset); }
336 174 STD { ssize_t sys_pwrite(int fd, const void *buf, \
337 size_t nbyte, int pad, off_t offset); }
338 175 UNIMPL ntp_gettime
339 176 UNIMPL ntp_adjtime
340 177 UNIMPL
341 178 UNIMPL
342 179 UNIMPL
343 180 UNIMPL
344
345 ; Syscalls 181-199 are used by/reserved for BSD
346 181 STD { int sys_setgid(gid_t gid); }
347 182 STD { int sys_setegid(gid_t egid); }
348 183 STD { int sys_seteuid(uid_t euid); }
349 #ifdef LFS
350 184 STD { int lfs_bmapv(fsid_t *fsidp, \
351 struct block_info *blkiov, int blkcnt); }
352 185 STD { int lfs_markv(fsid_t *fsidp, \
353 struct block_info *blkiov, int blkcnt); }
354 186 STD { int lfs_segclean(fsid_t *fsidp, u_long segment); }
355 187 STD { int lfs_segwait(fsid_t *fsidp, struct timeval *tv); }
356 #else
357 184 UNIMPL
358 185 UNIMPL
359 186 UNIMPL
360 187 UNIMPL
361 #endif
362 188 COMPAT_35 { int sys_stat(const char *path, struct stat35 *ub); } \
363 stat35
364 189 COMPAT_35 { int sys_fstat(int fd, struct stat35 *sb); } \
365 fstat35
366 190 COMPAT_35 { int sys_lstat(const char *path, \
367 struct stat35 *ub); } lstat35
368 191 STD { long sys_pathconf(const char *path, int name); }
369 192 STD { long sys_fpathconf(int fd, int name); }
370 193 STD { int sys_swapctl(int cmd, const void *arg, int misc); }
371 194 STD { int sys_getrlimit(int which, \
372 struct rlimit *rlp); }
373 195 STD { int sys_setrlimit(int which, \
374 const struct rlimit *rlp); }
375 196 STD { int sys_getdirentries(int fd, char *buf, \
376 int count, long *basep); }
377 197 STD { void *sys_mmap(void *addr, size_t len, int prot, \
378 int flags, int fd, long pad, off_t pos); }
379 198 INDIR { quad_t sys___syscall(quad_t num, ...); }
380 199 STD { off_t sys_lseek(int fd, int pad, off_t offset, \
381 int whence); }
382 200 STD { int sys_truncate(const char *path, int pad, \
383 off_t length); }
384 201 STD { int sys_ftruncate(int fd, int pad, off_t length); }
385 202 STD { int sys___sysctl(int *name, u_int namelen, \
386 void *old, size_t *oldlenp, void *new, \
387 size_t newlen); }
388 203 STD { int sys_mlock(const void *addr, size_t len); }
389 204 STD { int sys_munlock(const void *addr, size_t len); }
390 205 UNIMPL sys_undelete
391 206 STD { int sys_futimes(int fd, \
392 const struct timeval *tptr); }
393 207 STD { pid_t sys_getpgid(pid_t pid); }
394 208 STD { int sys_xfspioctl(int operation, char *a_pathP, \
395 int a_opcode, struct ViceIoctl *a_paramsP, \
396 int a_followSymlinks); }
397 209 UNIMPL
398 ;
399 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
400 ;
401 #ifdef LKM
402 210 NODEF { int sys_lkmnosys(void); }
403 211 NODEF { int sys_lkmnosys(void); }
404 212 NODEF { int sys_lkmnosys(void); }
405 213 NODEF { int sys_lkmnosys(void); }
406 214 NODEF { int sys_lkmnosys(void); }
407 215 NODEF { int sys_lkmnosys(void); }
408 216 NODEF { int sys_lkmnosys(void); }
409 217 NODEF { int sys_lkmnosys(void); }
410 218 NODEF { int sys_lkmnosys(void); }
411 219 NODEF { int sys_lkmnosys(void); }
412 #else /* !LKM */
413 210 UNIMPL
414 211 UNIMPL
415 212 UNIMPL
416 213 UNIMPL
417 214 UNIMPL
418 215 UNIMPL
419 216 UNIMPL
420 217 UNIMPL
421 218 UNIMPL
422 219 UNIMPL
423 #endif /* !LKM */
424 ; System calls 220-240 are reserved for use by OpenBSD
425 #ifdef SYSVSEM
426 220 COMPAT_23 { int sys___semctl(int semid, int semnum, int cmd, \
427 union semun *arg); } semctl23
428 221 STD { int sys_semget(key_t key, int nsems, int semflg); }
429 222 COMPAT_35 { int sys_semop(int semid, struct sembuf *sops, \
430 u_int nsops); }
431 223 OBSOL sys_semconfig
432 #else
433 220 UNIMPL semctl
434 221 UNIMPL semget
435 222 UNIMPL semop
436 223 UNIMPL semconfig
437 #endif
438 #ifdef SYSVMSG
439 224 COMPAT_23 { int sys_msgctl(int msqid, int cmd, \
440 struct omsqid_ds *buf); } msgctl23
441 225 STD { int sys_msgget(key_t key, int msgflg); }
442 226 STD { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
443 int msgflg); }
444 227 STD { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
445 long msgtyp, int msgflg); }
446 #else
447 224 UNIMPL msgctl
448 225 UNIMPL msgget
449 226 UNIMPL msgsnd
450 227 UNIMPL msgrcv
451 #endif
452 #ifdef SYSVSHM
453 228 STD { void *sys_shmat(int shmid, const void *shmaddr, \
454 int shmflg); }
455 229 COMPAT_23 { int sys_shmctl(int shmid, int cmd, \
456 struct oshmid_ds *buf); } shmctl23
457 230 STD { int sys_shmdt(const void *shmaddr); }
458 231 COMPAT_35 { int sys_shmget(key_t key, int size, int shmflg); }
459 #else
460 228 UNIMPL shmat
461 229 UNIMPL shmctl
462 230 UNIMPL shmdt
463 231 UNIMPL shmget
464 #endif
465 232 STD { int sys_clock_gettime(clockid_t clock_id, \
466 struct timespec *tp); }
467 233 STD { int sys_clock_settime(clockid_t clock_id, \
468 const struct timespec *tp); }
469 234 STD { int sys_clock_getres(clockid_t clock_id, \
470 struct timespec *tp); }
471 235 UNIMPL timer_create
472 236 UNIMPL timer_delete
473 237 UNIMPL timer_settime
474 238 UNIMPL timer_gettime
475 239 UNIMPL timer_getoverrun
476 ;
477 ; System calls 240-249 are reserved for other IEEE Std1003.1b syscalls
478 ;
479 240 STD { int sys_nanosleep(const struct timespec *rqtp, \
480 struct timespec *rmtp); }
481 241 UNIMPL
482 242 UNIMPL
483 243 UNIMPL
484 244 UNIMPL
485 245 UNIMPL
486 246 UNIMPL
487 247 UNIMPL
488 248 UNIMPL
489 249 UNIMPL
490 250 STD { int sys_minherit(void *addr, size_t len, \
491 int inherit); }
492 251 STD { int sys_rfork(int flags); }
493 252 STD { int sys_poll(struct pollfd *fds, \
494 u_int nfds, int timeout); }
495 253 STD { int sys_issetugid(void); }
496 254 STD { int sys_lchown(const char *path, uid_t uid, gid_t gid); }
497 255 STD { pid_t sys_getsid(pid_t pid); }
498 256 STD { int sys_msync(void *addr, size_t len, int flags); }
499 #ifdef SYSVSEM
500 257 COMPAT_35 { int sys___semctl(int semid, int semnum, int cmd, \
501 union semun *arg); } semctl35
502 #else
503 257 UNIMPL
504 #endif
505 #ifdef SYSVSHM
506 258 COMPAT_35 { int sys_shmctl(int shmid, int cmd, \
507 struct shmid_ds35 *buf); } shmctl35
508 #else
509 258 UNIMPL
510 #endif
511 #ifdef SYSVMSG
512 259 COMPAT_35 { int sys_msgctl(int msqid, int cmd, \
513 struct msqid_ds35 *buf); } msgctl35
514 #else
515 259 UNIMPL
516 #endif
517 260 COMPAT_O43 { int sys_getfsstat(struct o43statfs *buf, size_t bufsize, \
518 int flags); }
519 261 COMPAT_O43 { int sys_statfs(const char *path, \
520 struct o43statfs *buf); }
521 262 COMPAT_O43 { int sys_fstatfs(int fd, struct o43statfs *buf); }
522 263 STD { int sys_pipe(int *fdp); }
523 264 STD { int sys_fhopen(const fhandle_t *fhp, int flags); }
524 265 COMPAT_35 { int sys_fhstat(const fhandle_t *fhp, \
525 struct stat35 *sb); }
526 266 COMPAT_O43 { int sys_fhstatfs(const fhandle_t *fhp, \
527 struct o43statfs *buf); }
528 267 STD { ssize_t sys_preadv(int fd, \
529 const struct iovec *iovp, int iovcnt, \
530 int pad, off_t offset); }
531 268 STD { ssize_t sys_pwritev(int fd, \
532 const struct iovec *iovp, int iovcnt, \
533 int pad, off_t offset); }
534 269 STD { int sys_kqueue(void); }
535 270 STD { int sys_kevent(int fd, \
536 const struct kevent *changelist, int nchanges, \
537 struct kevent *eventlist, int nevents, \
538 const struct timespec *timeout); }
539 271 STD { int sys_mlockall(int flags); }
540 272 STD { int sys_munlockall(void); }
541 273 STD { int sys_getpeereid(int fdes, uid_t *euid, gid_t *egid); }
542 274 UNIMPL sys_extattrctl
543 275 UNIMPL sys_extattr_set_file
544 276 UNIMPL sys_extattr_get_file
545 277 UNIMPL sys_extattr_delete_file
546 278 UNIMPL sys_extattr_set_fd
547 279 UNIMPL sys_extattr_get_fd
548 280 UNIMPL sys_extattr_delete_fd
549 281 STD { int sys_getresuid(uid_t *ruid, uid_t *euid, \
550 uid_t *suid); }
551 282 STD { int sys_setresuid(uid_t ruid, uid_t euid, \
552 uid_t suid); }
553 283 STD { int sys_getresgid(gid_t *rgid, gid_t *egid, \
554 gid_t *sgid); }
555 284 STD { int sys_setresgid(gid_t rgid, gid_t egid, \
556 gid_t sgid); }
557 285 OBSOL sys_omquery
558 286 STD { void *sys_mquery(void *addr, size_t len, int prot, \
559 int flags, int fd, long pad, off_t pos); }
560 287 STD { int sys_closefrom(int fd); }
561 288 STD { int sys_sigaltstack(const struct sigaltstack *nss, \
562 struct sigaltstack *oss); }
563 #ifdef SYSVSHM
564 289 STD { int sys_shmget(key_t key, size_t size, int shmflg); }
565 #else
566 289 UNIMPL shmget
567 #endif
568 #ifdef SYSVSEM
569 290 STD { int sys_semop(int semid, struct sembuf *sops, \
570 size_t nsops); }
571 #else
572 290 UNIMPL semop
573 #endif
574 291 STD { int sys_stat(const char *path, struct stat *ub); }
575 292 STD { int sys_fstat(int fd, struct stat *sb); }
576 293 STD { int sys_lstat(const char *path, struct stat *ub); }
577 294 STD { int sys_fhstat(const fhandle_t *fhp, \
578 struct stat *sb); }
579 #ifdef SYSVSEM
580 295 STD { int sys___semctl(int semid, int semnum, int cmd, \
581 union semun *arg); }
582 #else
583 295 UNIMPL
584 #endif
585 #ifdef SYSVSHM
586 296 STD { int sys_shmctl(int shmid, int cmd, \
587 struct shmid_ds *buf); }
588 #else
589 296 UNIMPL
590 #endif
591 #ifdef SYSVMSG
592 297 STD { int sys_msgctl(int msqid, int cmd, \
593 struct msqid_ds *buf); }
594 #else
595 297 UNIMPL
596 #endif
597 298 STD { int sys_sched_yield(void); }
598 #ifdef RTHREADS
599 299 STD { pid_t sys_getthrid(void); }
600 300 STD { int sys_thrsleep(void *ident, int timeout, void *lock); }
601 301 STD { int sys_thrwakeup(void *ident, int n); }
602 302 STD { int sys_threxit(int rval); }
603 303 STD { int sys_thrsigdivert(sigset_t sigmask); }
604 #else
605 299 UNIMPL
606 300 UNIMPL
607 301 UNIMPL
608 302 UNIMPL
609 303 UNIMPL
610 #endif
611 304 STD { int sys___getcwd(char *buf, size_t len); }
612 305 STD { int sys_adjfreq(const int64_t *freq, \
613 int64_t *oldfreq); }
614 306 STD { int sys_getfsstat(struct statfs *buf, size_t bufsize, \
615 int flags); }
616 307 STD { int sys_statfs(const char *path, \
617 struct statfs *buf); }
618 308 STD { int sys_fstatfs(int fd, struct statfs *buf); }
619 309 STD { int sys_fhstatfs(const fhandle_t *fhp, \
620 struct statfs *buf); }
Cache object: a3bdf1b2162301fc4bc4b39fe9703578
|