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.138 2004/03/26 15:18:54 drochner Exp $ 2 3 ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 4 5 ; NetBSD system call name/number "master" file. 6 ; (See syscalls.conf to see what it is processed into.) 7 ; 8 ; Fields: number type [type-dependent ...] 9 ; number system call number, must be in order 10 ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of 11 ; the compatibility options defined in syscalls.conf. 12 ; 13 ; An optional field, MPSAFE, after the type field, indicates that 14 ; the system call is MP-safe. 15 ; 16 ; types: 17 ; STD always included 18 ; OBSOL obsolete, not included in system 19 ; UNIMPL unimplemented, not included in system 20 ; EXCL implemented, but not included in system 21 ; NODEF included, but don't define the syscall number 22 ; NOARGS included, but don't define the syscall args structure 23 ; INDIR included, but don't define the syscall args structure, 24 ; and allow it to be "really" varargs. 25 ; 26 ; The compat options are defined in the syscalls.conf file, and the 27 ; compat option name is prefixed to the syscall name. Other than 28 ; that, they're like NODEF (for 'compat' options), or STD (for 29 ; 'libcompat' options). 30 ; 31 ; The type-dependent arguments are as follows: 32 ; For STD, NODEF, NOARGS, and compat syscalls: 33 ; { pseudo-proto } [alias] 34 ; For other syscalls: 35 ; [comment] 36 ; 37 ; #ifdef's, etc. may be included, and are copied to the output files. 38 ; #include's are copied to the syscall names and switch definition files only. 39 40 #include "opt_ktrace.h" 41 #include "opt_nfsserver.h" 42 #include "opt_ntp.h" 43 #include "opt_compat_netbsd.h" 44 #include "opt_sysv.h" 45 #include "opt_compat_43.h" 46 #include "opt_posix.h" 47 48 #include "fs_lfs.h" 49 #include "fs_nfs.h" 50 51 #include <sys/param.h> 52 #include <sys/systm.h> 53 #include <sys/signal.h> 54 #include <sys/mount.h> 55 #include <sys/sa.h> 56 #include <sys/syscallargs.h> 57 58 %% 59 60 ; Reserved/unimplemented system calls in the range 0-150 inclusive 61 ; are reserved for use in future Berkeley releases. 62 ; Additional system calls implemented in vendor and other 63 ; redistributions should be placed in the reserved range at the end 64 ; of the current calls. 65 66 0 INDIR { int sys_syscall(int number, ...); } 67 1 STD { void sys_exit(int rval); } 68 2 STD { int sys_fork(void); } 69 3 STD { ssize_t sys_read(int fd, void *buf, size_t nbyte); } 70 4 STD { ssize_t sys_write(int fd, const void *buf, \ 71 size_t nbyte); } 72 5 STD { int sys_open(const char *path, \ 73 int flags, ... mode_t mode); } 74 6 STD { int sys_close(int fd); } 75 7 STD { int sys_wait4(int pid, int *status, int options, \ 76 struct rusage *rusage); } 77 8 COMPAT_43 { int sys_creat(const char *path, mode_t mode); } ocreat 78 9 STD { int sys_link(const char *path, const char *link); } 79 10 STD { int sys_unlink(const char *path); } 80 11 OBSOL execv 81 12 STD { int sys_chdir(const char *path); } 82 13 STD { int sys_fchdir(int fd); } 83 14 STD { int sys_mknod(const char *path, mode_t mode, \ 84 dev_t dev); } 85 15 STD { int sys_chmod(const char *path, mode_t mode); } 86 16 STD { int sys_chown(const char *path, uid_t uid, \ 87 gid_t gid); } 88 17 STD { int sys_obreak(char *nsize); } break 89 18 STD { int sys_getfsstat(struct statfs *buf, long bufsize, \ 90 int flags); } 91 19 COMPAT_43 { long sys_lseek(int fd, long offset, int whence); } \ 92 olseek 93 #ifdef COMPAT_43 94 20 STD { pid_t sys_getpid_with_ppid(void); } getpid 95 #else 96 20 STD MPSAFE { pid_t sys_getpid(void); } 97 #endif 98 21 STD { int sys_mount(const char *type, const char *path, \ 99 int flags, void *data); } 100 22 STD { int sys_unmount(const char *path, int flags); } 101 23 STD { int sys_setuid(uid_t uid); } 102 #ifdef COMPAT_43 103 24 STD { uid_t sys_getuid_with_euid(void); } getuid 104 #else 105 24 STD { uid_t sys_getuid(void); } 106 #endif 107 25 STD { uid_t sys_geteuid(void); } 108 26 STD { int sys_ptrace(int req, pid_t pid, caddr_t addr, \ 109 int data); } 110 27 STD { ssize_t sys_recvmsg(int s, struct msghdr *msg, \ 111 int flags); } 112 28 STD { ssize_t sys_sendmsg(int s, \ 113 const struct msghdr *msg, int flags); } 114 29 STD { ssize_t sys_recvfrom(int s, void *buf, size_t len, \ 115 int flags, struct sockaddr *from, \ 116 unsigned int *fromlenaddr); } 117 30 STD { int sys_accept(int s, struct sockaddr *name, \ 118 unsigned int *anamelen); } 119 31 STD { int sys_getpeername(int fdes, struct sockaddr *asa, \ 120 unsigned int *alen); } 121 32 STD { int sys_getsockname(int fdes, struct sockaddr *asa, \ 122 unsigned int *alen); } 123 33 STD { int sys_access(const char *path, int flags); } 124 34 STD { int sys_chflags(const char *path, u_long flags); } 125 35 STD { int sys_fchflags(int fd, u_long flags); } 126 36 STD { void sys_sync(void); } 127 37 STD { int sys_kill(int pid, int signum); } 128 38 COMPAT_43 { int sys_stat(const char *path, struct stat43 *ub); } \ 129 stat43 130 39 STD { pid_t sys_getppid(void); } 131 40 COMPAT_43 { int sys_lstat(const char *path, \ 132 struct stat43 *ub); } lstat43 133 41 STD { int sys_dup(int fd); } 134 42 STD { int sys_pipe(void); } 135 43 STD { gid_t sys_getegid(void); } 136 44 STD { int sys_profil(caddr_t samples, size_t size, \ 137 u_long offset, u_int scale); } 138 #if defined(KTRACE) || !defined(_KERNEL) 139 45 STD { int sys_ktrace(const char *fname, int ops, \ 140 int facs, int pid); } 141 #else 142 45 EXCL ktrace 143 #endif 144 46 COMPAT_13 { int sys_sigaction(int signum, \ 145 const struct sigaction13 *nsa, \ 146 struct sigaction13 *osa); } sigaction13 147 #ifdef COMPAT_43 148 47 STD { gid_t sys_getgid_with_egid(void); } getgid 149 #else 150 47 STD { gid_t sys_getgid(void); } 151 #endif 152 48 COMPAT_13 { int sys_sigprocmask(int how, \ 153 int mask); } sigprocmask13 154 49 STD { int sys___getlogin(char *namebuf, size_t namelen); } 155 50 STD { int sys___setlogin(const char *namebuf); } 156 51 STD { int sys_acct(const char *path); } 157 52 COMPAT_13 { int sys_sigpending(void); } sigpending13 158 53 COMPAT_13 { int sys_sigaltstack( \ 159 const struct sigaltstack13 *nss, \ 160 struct sigaltstack13 *oss); } sigaltstack13 161 54 STD { int sys_ioctl(int fd, \ 162 u_long com, ... void *data); } 163 55 COMPAT_12 { int sys_reboot(int opt); } oreboot 164 56 STD { int sys_revoke(const char *path); } 165 57 STD { int sys_symlink(const char *path, \ 166 const char *link); } 167 58 STD { int sys_readlink(const char *path, char *buf, \ 168 size_t count); } 169 59 STD { int sys_execve(const char *path, \ 170 char * const *argp, char * const *envp); } 171 60 STD { mode_t sys_umask(mode_t newmask); } 172 61 STD { int sys_chroot(const char *path); } 173 62 COMPAT_43 { int sys_fstat(int fd, struct stat43 *sb); } fstat43 174 63 COMPAT_43 { int sys_getkerninfo(int op, char *where, int *size, \ 175 int arg); } ogetkerninfo 176 64 COMPAT_43 { int sys_getpagesize(void); } ogetpagesize 177 65 COMPAT_12 { int sys_msync(caddr_t addr, size_t len); } 178 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? 179 66 STD { int sys_vfork(void); } 180 67 OBSOL vread 181 68 OBSOL vwrite 182 69 STD { int sys_sbrk(intptr_t incr); } 183 70 STD { int sys_sstk(int incr); } 184 71 COMPAT_43 { int sys_mmap(caddr_t addr, size_t len, int prot, \ 185 int flags, int fd, long pos); } ommap 186 72 STD { int sys_ovadvise(int anom); } vadvise 187 73 STD { int sys_munmap(void *addr, size_t len); } 188 74 STD { int sys_mprotect(void *addr, size_t len, \ 189 int prot); } 190 75 STD { int sys_madvise(void *addr, size_t len, \ 191 int behav); } 192 76 OBSOL vhangup 193 77 OBSOL vlimit 194 78 STD { int sys_mincore(void *addr, size_t len, \ 195 char *vec); } 196 79 STD { int sys_getgroups(int gidsetsize, \ 197 gid_t *gidset); } 198 80 STD { int sys_setgroups(int gidsetsize, \ 199 const gid_t *gidset); } 200 81 STD { int sys_getpgrp(void); } 201 82 STD { int sys_setpgid(int pid, int pgid); } 202 83 STD { int sys_setitimer(int which, \ 203 const struct itimerval *itv, \ 204 struct itimerval *oitv); } 205 84 COMPAT_43 { int sys_wait(void); } owait 206 85 COMPAT_12 { int sys_swapon(const char *name); } oswapon 207 86 STD { int sys_getitimer(int which, \ 208 struct itimerval *itv); } 209 87 COMPAT_43 { int sys_gethostname(char *hostname, u_int len); } \ 210 ogethostname 211 88 COMPAT_43 { int sys_sethostname(char *hostname, u_int len); } \ 212 osethostname 213 89 COMPAT_43 { int sys_getdtablesize(void); } ogetdtablesize 214 90 STD { int sys_dup2(int from, int to); } 215 91 UNIMPL getdopt 216 92 STD { int sys_fcntl(int fd, int cmd, ... void *arg); } 217 93 STD { int sys_select(int nd, fd_set *in, fd_set *ou, \ 218 fd_set *ex, struct timeval *tv); } 219 94 UNIMPL setdopt 220 95 STD { int sys_fsync(int fd); } 221 96 STD { int sys_setpriority(int which, int who, int prio); } 222 97 STD { int sys_socket(int domain, int type, int protocol); } 223 98 STD { int sys_connect(int s, const struct sockaddr *name, \ 224 unsigned int namelen); } 225 99 COMPAT_43 { int sys_accept(int s, caddr_t name, \ 226 int *anamelen); } oaccept 227 100 STD { int sys_getpriority(int which, int who); } 228 101 COMPAT_43 { int sys_send(int s, caddr_t buf, int len, \ 229 int flags); } osend 230 102 COMPAT_43 { int sys_recv(int s, caddr_t buf, int len, \ 231 int flags); } orecv 232 103 COMPAT_13 { int sys_sigreturn(struct sigcontext13 *sigcntxp); } \ 233 sigreturn13 234 104 STD { int sys_bind(int s, const struct sockaddr *name, \ 235 unsigned int namelen); } 236 105 STD { int sys_setsockopt(int s, int level, int name, \ 237 const void *val, unsigned int valsize); } 238 106 STD { int sys_listen(int s, int backlog); } 239 107 OBSOL vtimes 240 108 COMPAT_43 { int sys_sigvec(int signum, struct sigvec *nsv, \ 241 struct sigvec *osv); } osigvec 242 109 COMPAT_43 { int sys_sigblock(int mask); } osigblock 243 110 COMPAT_43 { int sys_sigsetmask(int mask); } osigsetmask 244 111 COMPAT_13 { int sys_sigsuspend(int mask); } sigsuspend13 245 112 COMPAT_43 { int sys_sigstack(struct sigstack *nss, \ 246 struct sigstack *oss); } osigstack 247 113 COMPAT_43 { int sys_recvmsg(int s, struct omsghdr *msg, \ 248 int flags); } orecvmsg 249 114 COMPAT_43 { int sys_sendmsg(int s, caddr_t msg, int flags); } \ 250 osendmsg 251 115 OBSOL vtrace 252 116 STD { int sys_gettimeofday(struct timeval *tp, \ 253 struct timezone *tzp); } 254 117 STD { int sys_getrusage(int who, struct rusage *rusage); } 255 118 STD { int sys_getsockopt(int s, int level, int name, \ 256 void *val, unsigned int *avalsize); } 257 119 OBSOL resuba 258 120 STD { ssize_t sys_readv(int fd, \ 259 const struct iovec *iovp, int iovcnt); } 260 121 STD { ssize_t sys_writev(int fd, \ 261 const struct iovec *iovp, int iovcnt); } 262 122 STD { int sys_settimeofday(const struct timeval *tv, \ 263 const struct timezone *tzp); } 264 123 STD { int sys_fchown(int fd, uid_t uid, gid_t gid); } 265 124 STD { int sys_fchmod(int fd, mode_t mode); } 266 125 COMPAT_43 { int sys_recvfrom(int s, caddr_t buf, size_t len, \ 267 int flags, caddr_t from, int *fromlenaddr); } \ 268 orecvfrom 269 126 STD { int sys_setreuid(uid_t ruid, uid_t euid); } 270 127 STD { int sys_setregid(gid_t rgid, gid_t egid); } 271 128 STD { int sys_rename(const char *from, const char *to); } 272 129 COMPAT_43 { int sys_truncate(const char *path, long length); } \ 273 otruncate 274 130 COMPAT_43 { int sys_ftruncate(int fd, long length); } oftruncate 275 131 STD { int sys_flock(int fd, int how); } 276 132 STD { int sys_mkfifo(const char *path, mode_t mode); } 277 133 STD { ssize_t sys_sendto(int s, const void *buf, \ 278 size_t len, int flags, const struct sockaddr *to, \ 279 unsigned int tolen); } 280 134 STD { int sys_shutdown(int s, int how); } 281 135 STD { int sys_socketpair(int domain, int type, \ 282 int protocol, int *rsv); } 283 136 STD { int sys_mkdir(const char *path, mode_t mode); } 284 137 STD { int sys_rmdir(const char *path); } 285 138 STD { int sys_utimes(const char *path, \ 286 const struct timeval *tptr); } 287 139 OBSOL 4.2 sigreturn 288 140 STD { int sys_adjtime(const struct timeval *delta, \ 289 struct timeval *olddelta); } 290 141 COMPAT_43 { int sys_getpeername(int fdes, caddr_t asa, \ 291 int *alen); } ogetpeername 292 142 COMPAT_43 { int32_t sys_gethostid(void); } ogethostid 293 143 COMPAT_43 { int sys_sethostid(int32_t hostid); } osethostid 294 144 COMPAT_43 { int sys_getrlimit(int which, \ 295 struct orlimit *rlp); } ogetrlimit 296 145 COMPAT_43 { int sys_setrlimit(int which, \ 297 const struct orlimit *rlp); } osetrlimit 298 146 COMPAT_43 { int sys_killpg(int pgid, int signum); } okillpg 299 147 STD { int sys_setsid(void); } 300 148 STD { int sys_quotactl(const char *path, int cmd, \ 301 int uid, caddr_t arg); } 302 149 COMPAT_43 { int sys_quota(void); } oquota 303 150 COMPAT_43 { int sys_getsockname(int fdec, caddr_t asa, \ 304 int *alen); } ogetsockname 305 306 ; Syscalls 151-180 inclusive are reserved for vendor-specific 307 ; system calls. (This includes various calls added for compatibity 308 ; with other Unix variants.) 309 ; Some of these calls are now supported by BSD... 310 151 UNIMPL 311 152 UNIMPL 312 153 UNIMPL 313 154 UNIMPL 314 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL) 315 155 STD { int sys_nfssvc(int flag, void *argp); } 316 #else 317 155 EXCL nfssvc 318 #endif 319 156 COMPAT_43 { int sys_getdirentries(int fd, char *buf, \ 320 u_int count, long *basep); } ogetdirentries 321 157 STD { int sys_statfs(const char *path, \ 322 struct statfs *buf); } 323 158 STD { int sys_fstatfs(int fd, struct statfs *buf); } 324 159 UNIMPL 325 160 UNIMPL 326 161 STD { int sys_getfh(const char *fname, fhandle_t *fhp); } 327 162 COMPAT_09 { int sys_getdomainname(char *domainname, int len); } \ 328 ogetdomainname 329 163 COMPAT_09 { int sys_setdomainname(char *domainname, int len); } \ 330 osetdomainname 331 164 COMPAT_09 { int sys_uname(struct outsname *name); } ouname 332 165 STD { int sys_sysarch(int op, void *parms); } 333 166 UNIMPL 334 167 UNIMPL 335 168 UNIMPL 336 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 337 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) 338 169 COMPAT_10 { int sys_semsys(int which, int a2, int a3, int a4, \ 339 int a5); } osemsys 340 #else 341 169 EXCL 1.0 semsys 342 #endif 343 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 344 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) 345 170 COMPAT_10 { int sys_msgsys(int which, int a2, int a3, int a4, \ 346 int a5, int a6); } omsgsys 347 #else 348 170 EXCL 1.0 msgsys 349 #endif 350 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 351 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) 352 171 COMPAT_10 { int sys_shmsys(int which, int a2, int a3, int a4); } \ 353 oshmsys 354 #else 355 171 EXCL 1.0 shmsys 356 #endif 357 172 UNIMPL 358 173 STD { ssize_t sys_pread(int fd, void *buf, \ 359 size_t nbyte, int pad, off_t offset); } 360 174 STD { ssize_t sys_pwrite(int fd, const void *buf, \ 361 size_t nbyte, int pad, off_t offset); } 362 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded. 363 175 STD { int sys_ntp_gettime(struct ntptimeval *ntvp); } 364 #if defined(NTP) || !defined(_KERNEL) 365 176 STD { int sys_ntp_adjtime(struct timex *tp); } 366 #else 367 176 EXCL ntp_adjtime 368 #endif 369 177 UNIMPL 370 178 UNIMPL 371 179 UNIMPL 372 180 UNIMPL 373 374 ; Syscalls 180-199 are used by/reserved for BSD 375 181 STD { int sys_setgid(gid_t gid); } 376 182 STD { int sys_setegid(gid_t egid); } 377 183 STD { int sys_seteuid(uid_t euid); } 378 #if defined(LFS) || !defined(_KERNEL) 379 184 STD { int sys_lfs_bmapv(fsid_t *fsidp, \ 380 struct block_info *blkiov, int blkcnt); } 381 185 STD { int sys_lfs_markv(fsid_t *fsidp, \ 382 struct block_info *blkiov, int blkcnt); } 383 186 STD { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); } 384 187 STD { int sys_lfs_segwait(fsid_t *fsidp, \ 385 struct timeval *tv); } 386 #else 387 184 EXCL lfs_bmapv 388 185 EXCL lfs_markv 389 186 EXCL lfs_segclean 390 187 EXCL lfs_segwait 391 #endif 392 188 COMPAT_12 { int sys_stat(const char *path, struct stat12 *ub); } \ 393 stat12 394 189 COMPAT_12 { int sys_fstat(int fd, struct stat12 *sb); } fstat12 395 190 COMPAT_12 { int sys_lstat(const char *path, \ 396 struct stat12 *ub); } lstat12 397 191 STD { long sys_pathconf(const char *path, int name); } 398 192 STD { long sys_fpathconf(int fd, int name); } 399 193 UNIMPL 400 194 STD { int sys_getrlimit(int which, \ 401 struct rlimit *rlp); } 402 195 STD { int sys_setrlimit(int which, \ 403 const struct rlimit *rlp); } 404 196 COMPAT_12 { int sys_getdirentries(int fd, char *buf, \ 405 u_int count, long *basep); } 406 197 STD { void *sys_mmap(void *addr, size_t len, int prot, \ 407 int flags, int fd, long pad, off_t pos); } 408 198 INDIR { quad_t sys___syscall(quad_t num, ...); } 409 199 STD { off_t sys_lseek(int fd, int pad, off_t offset, \ 410 int whence); } 411 200 STD { 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 { int sys___sysctl(int *name, u_int namelen, \ 415 void *old, size_t *oldlenp, 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 ; 521 ; Syscall 246 is free for any use 522 ; 523 246 UNIMPL 524 #if defined(P1003_1B_SEMAPHORE) || (!defined(_KERNEL) && defined(_LIBC)) 525 247 STD { int sys__ksem_init(unsigned int value, semid_t *idp); } 526 248 STD { int sys__ksem_open(const char *name, int oflag, \ 527 mode_t mode, unsigned int value, semid_t *idp); } 528 249 STD { int sys__ksem_unlink(const char *name); } 529 250 STD { int sys__ksem_close(semid_t id); } 530 251 STD { int sys__ksem_post(semid_t id); } 531 252 STD { int sys__ksem_wait(semid_t id); } 532 253 STD { int sys__ksem_trywait(semid_t id); } 533 254 STD { int sys__ksem_getvalue(semid_t id, \ 534 unsigned int *value); } 535 255 STD { int sys__ksem_destroy(semid_t id); } 536 256 UNIMPL sys__ksem_timedwait 537 #else 538 247 EXCL sys__ksem_init 539 248 EXCL sys__ksem_open 540 249 EXCL sys__ksem_unlink 541 250 EXCL sys__ksem_close 542 251 EXCL sys__ksem_post 543 252 EXCL sys__ksem_wait 544 253 EXCL sys__ksem_trywait 545 254 EXCL sys__ksem_getvalue 546 255 EXCL sys__ksem_destroy 547 256 UNIMPL sys__ksem_timedwait 548 #endif 549 257 UNIMPL sys_mq_open 550 258 UNIMPL sys_mq_close 551 259 UNIMPL sys_mq_unlink 552 260 UNIMPL sys_mq_getattr 553 261 UNIMPL sys_mq_setattr 554 262 UNIMPL sys_mq_notify 555 263 UNIMPL sys_mq_send 556 264 UNIMPL sys_mq_receive 557 265 UNIMPL sys_mq_timedsend 558 266 UNIMPL sys_mq_timedreceive 559 267 UNIMPL 560 268 UNIMPL 561 269 UNIMPL 562 270 STD { int sys___posix_rename(const char *from, \ 563 const char *to); } 564 271 STD { int sys_swapctl(int cmd, const void *arg, int misc); } 565 272 STD { int sys_getdents(int fd, char *buf, size_t count); } 566 273 STD { int sys_minherit(void *addr, size_t len, \ 567 int inherit); } 568 274 STD { int sys_lchmod(const char *path, mode_t mode); } 569 275 STD { int sys_lchown(const char *path, uid_t uid, \ 570 gid_t gid); } 571 276 STD { int sys_lutimes(const char *path, \ 572 const struct timeval *tptr); } 573 277 STD { int sys___msync13(void *addr, size_t len, int flags); } 574 278 STD { int sys___stat13(const char *path, struct stat *ub); } 575 279 STD { int sys___fstat13(int fd, struct stat *sb); } 576 280 STD { int sys___lstat13(const char *path, struct stat *ub); } 577 281 STD { int sys___sigaltstack14( \ 578 const struct sigaltstack *nss, \ 579 struct sigaltstack *oss); } 580 282 STD { int sys___vfork14(void); } 581 283 STD { int sys___posix_chown(const char *path, uid_t uid, \ 582 gid_t gid); } 583 284 STD { int sys___posix_fchown(int fd, uid_t uid, \ 584 gid_t gid); } 585 285 STD { int sys___posix_lchown(const char *path, uid_t uid, \ 586 gid_t gid); } 587 286 STD { pid_t sys_getsid(pid_t pid); } 588 287 STD { pid_t sys___clone(int flags, void *stack); } 589 #if defined(KTRACE) || !defined(_KERNEL) 590 288 STD { int sys_fktrace(const int fd, int ops, \ 591 int facs, int pid); } 592 #else 593 288 EXCL ktrace 594 #endif 595 289 STD { ssize_t sys_preadv(int fd, \ 596 const struct iovec *iovp, int iovcnt, \ 597 int pad, off_t offset); } 598 290 STD { ssize_t sys_pwritev(int fd, \ 599 const struct iovec *iovp, int iovcnt, \ 600 int pad, off_t offset); } 601 291 COMPAT_16 { int sys___sigaction14(int signum, \ 602 const struct sigaction *nsa, \ 603 struct sigaction *osa); } 604 292 STD { int sys___sigpending14(sigset_t *set); } 605 293 STD { int sys___sigprocmask14(int how, \ 606 const sigset_t *set, \ 607 sigset_t *oset); } 608 294 STD { int sys___sigsuspend14(const sigset_t *set); } 609 295 COMPAT_16 { int sys___sigreturn14(struct sigcontext *sigcntxp); } 610 296 STD { int sys___getcwd(char *bufp, size_t length); } 611 297 STD { int sys_fchroot(int fd); } 612 298 STD { int sys_fhopen(const fhandle_t *fhp, int flags); } 613 299 STD { int sys_fhstat(const fhandle_t *fhp, \ 614 struct stat *sb); } 615 300 STD { int sys_fhstatfs(const fhandle_t *fhp, \ 616 struct statfs *buf); } 617 #if defined(SYSVSEM) || !defined(_KERNEL) 618 301 STD { int sys_____semctl13(int semid, int semnum, int cmd, \ 619 ... union __semun *arg); } 620 #else 621 301 EXCL ____semctl13 622 #endif 623 #if defined(SYSVMSG) || !defined(_KERNEL) 624 302 STD { int sys___msgctl13(int msqid, int cmd, \ 625 struct msqid_ds *buf); } 626 #else 627 302 EXCL __msgctl13 628 #endif 629 #if defined(SYSVSHM) || !defined(_KERNEL) 630 303 STD { int sys___shmctl13(int shmid, int cmd, \ 631 struct shmid_ds *buf); } 632 #else 633 303 EXCL __shmctl13 634 #endif 635 304 STD { int sys_lchflags(const char *path, u_long flags); } 636 305 STD { int sys_issetugid(void); } 637 306 STD { int sys_utrace(const char *label, void *addr, \ 638 size_t len); } 639 307 STD { int sys_getcontext(struct __ucontext *ucp); } 640 308 STD { int sys_setcontext(const struct __ucontext *ucp); } 641 309 STD { int sys__lwp_create(const struct __ucontext *ucp, \ 642 u_long flags, lwpid_t *new_lwp); } 643 310 STD { int sys__lwp_exit(void); } 644 311 STD { lwpid_t sys__lwp_self(void); } 645 312 STD { int sys__lwp_wait(lwpid_t wait_for, \ 646 lwpid_t *departed); } 647 313 STD { int sys__lwp_suspend(lwpid_t target); } 648 314 STD { int sys__lwp_continue(lwpid_t target); } 649 315 STD { int sys__lwp_wakeup(lwpid_t target); } 650 316 STD { void *sys__lwp_getprivate(void); } 651 317 STD { void sys__lwp_setprivate(void *ptr); } 652 ; Syscalls 318-329 reserved for remaining Solaris-compatible LWP calls. 653 318 UNIMPL 654 319 UNIMPL 655 320 UNIMPL 656 321 UNIMPL 657 322 UNIMPL 658 323 UNIMPL 659 324 UNIMPL 660 325 UNIMPL 661 326 UNIMPL 662 327 UNIMPL 663 328 UNIMPL 664 329 UNIMPL 665 ; Scheduler activation syscalls 666 330 STD { int sys_sa_register(sa_upcall_t new, \ 667 sa_upcall_t *old, int flags, \ 668 ssize_t stackinfo_offset); } 669 331 STD { int sys_sa_stacks(int num, stack_t *stacks); } 670 332 STD { int sys_sa_enable(void); } 671 333 STD { int sys_sa_setconcurrency(int concurrency); } 672 334 STD { int sys_sa_yield(void); } 673 335 STD { int sys_sa_preempt(int sa_id); } 674 336 OBSOL sys_sa_unblockyield 675 ; 676 ; Syscalls 337-339 are reserved for other scheduler activation syscalls. 677 ; 678 337 UNIMPL 679 338 UNIMPL 680 339 UNIMPL 681 340 STD { int sys___sigaction_sigtramp(int signum, \ 682 const struct sigaction *nsa, \ 683 struct sigaction *osa, \ 684 const void *tramp, int vers); } 685 341 STD { int sys_pmc_get_info(int ctr, int op, void *args); } 686 342 STD { int sys_pmc_control(int ctr, int op, void *args); } 687 343 STD { int sys_rasctl(caddr_t addr, size_t len, int op); } 688 344 STD { int sys_kqueue(void); } 689 345 STD { int sys_kevent(int fd, \ 690 const struct kevent *changelist, size_t nchanges, \ 691 struct kevent *eventlist, size_t nevents, \ 692 const struct timespec *timeout); } 693 ; 694 ; Syscalls 346-353 are reserved for the IEEE Std1003.1b scheduling syscalls 695 ; 696 346 UNIMPL sys_sched_setparam 697 347 UNIMPL sys_sched_getparam 698 348 UNIMPL sys_sched_setscheduler 699 349 UNIMPL sys_sched_getscheduler 700 350 UNIMPL sys_sched_yield 701 351 UNIMPL sys_sched_get_priority_max 702 352 UNIMPL sys_sched_get_priority_min 703 353 UNIMPL sys_sched_rr_get_interval 704 705 354 STD { int sys_fsync_range(int fd, int flags, off_t start, \ 706 off_t length); } 707 355 STD { int sys_uuidgen(struct uuid *store, int count); }
Cache object: b04b5d3923f3c1bd39a6054d5972f9ef
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]