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