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