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.309 2021/11/01 05:07:17 thorpej 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 ; MODULAR modname :attempt to autoload system call module if not present 16 ; RUMP: generate rump syscall entry point 17 ; 18 ; types: 19 ; STD always included 20 ; OBSOL obsolete, not included in system 21 ; IGNORED syscall is a null op, but always succeeds 22 ; UNIMPL unimplemented, not included in system 23 ; EXCL implemented, but not included in system 24 ; NODEF included, but don't define the syscall number 25 ; NOARGS included, but don't define the syscall args structure 26 ; INDIR included, but don't define the syscall args structure, 27 ; and allow it to be "really" varargs. 28 ; NOERR included, syscall does not set errno 29 ; EXTERN implemented, but as 3rd party module 30 ; 31 ; arguments: 32 ; PAD argument not part of the C interface, used only for padding 33 ; 34 ; The compat options are defined in the syscalls.conf file, and the 35 ; compat option name is prefixed to the syscall name. Other than 36 ; that, they're like NODEF (for 'compat' options), or STD (for 37 ; 'libcompat' options). 38 ; 39 ; The type-dependent arguments are as follows: 40 ; For STD, NODEF, NOARGS, and compat syscalls: 41 ; { return_type|prefix|compat(optional)|basename(pseudo-proto); } [alias] 42 ; For other syscalls: 43 ; [comment] 44 ; 45 ; #ifdef's, etc. may be included, and are copied to the output files. 46 ; #include's are copied to the syscall names and switch definition files only. 47 48 #ifdef _KERNEL_OPT 49 #include "opt_modular.h" 50 #include "opt_ntp.h" 51 #include "opt_sysv.h" 52 #endif 53 54 #include <sys/param.h> 55 #include <sys/systm.h> 56 #include <sys/signal.h> 57 #include <sys/socket.h> 58 #include <sys/mount.h> 59 #include <sys/sched.h> 60 #include <sys/idtype.h> 61 #include <sys/syscallargs.h> 62 #include <sys/acl.h> 63 64 %% 65 66 ; Reserved/unimplemented system calls in the range 0-150 inclusive 67 ; are reserved for use in future Berkeley releases. 68 ; Additional system calls implemented in vendor and other 69 ; redistributions should be placed in the reserved range at the end 70 ; of the current calls. 71 72 0 INDIR { int|sys||syscall(int code, \ 73 ... register_t args[SYS_MAXSYSARGS]); } 74 1 STD { void|sys||exit(int rval); } 75 2 STD { int|sys||fork(void); } 76 3 STD RUMP { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } 77 4 STD RUMP { ssize_t|sys||write(int fd, const void *buf, \ 78 size_t nbyte); } 79 5 STD RUMP { int|sys||open(const char *path, \ 80 int flags, ... mode_t mode); } 81 6 STD RUMP { int|sys||close(int fd); } 82 7 COMPAT_50 MODULAR compat_50 { int|sys||wait4(pid_t pid, int *status, \ 83 int options, struct rusage50 *rusage); } 84 8 COMPAT_43 MODULAR compat_43 \ 85 { int|sys||creat(const char *path, mode_t mode); } ocreat 86 9 STD RUMP { int|sys||link(const char *path, const char *link); } 87 10 STD RUMP { int|sys||unlink(const char *path); } 88 11 OBSOL execv 89 12 STD RUMP { int|sys||chdir(const char *path); } 90 13 STD RUMP { int|sys||fchdir(int fd); } 91 14 COMPAT_50 MODULAR compat_50 RUMP \ 92 { int|sys||mknod(const char *path, mode_t mode, uint32_t dev); } 93 15 STD RUMP { int|sys||chmod(const char *path, mode_t mode); } 94 16 STD RUMP { int|sys||chown(const char *path, uid_t uid, \ 95 gid_t gid); } 96 17 STD { int|sys||obreak(char *nsize); } break 97 18 COMPAT_20 MODULAR compat_20 { int|sys||getfsstat(struct statfs12 *buf, \ 98 long bufsize, int flags); } 99 19 COMPAT_43 MODULAR compat_43 \ 100 { long|sys||lseek(int fd, long offset, int whence); }\ 101 olseek 102 20 NOERR RUMP { pid_t|sys||getpid_with_ppid(void); } getpid 103 21 COMPAT_40 MODULAR compat_40 \ 104 { int|sys||mount(const char *type, const char *path, \ 105 int flags, void *data); } 106 22 STD RUMP { int|sys||unmount(const char *path, int flags); } 107 23 STD RUMP { int|sys||setuid(uid_t uid); } 108 24 NOERR RUMP { uid_t|sys||getuid_with_euid(void); } getuid 109 25 NOERR RUMP { uid_t|sys||geteuid(void); } 110 26 STD MODULAR ptrace \ 111 { int|sys||ptrace(int req, pid_t pid, void *addr, \ 112 int data); } 113 27 STD RUMP { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \ 114 int flags); } 115 28 STD RUMP { ssize_t|sys||sendmsg(int s, \ 116 const struct msghdr *msg, int flags); } 117 29 STD RUMP { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \ 118 int flags, struct sockaddr *from, \ 119 socklen_t *fromlenaddr); } 120 30 STD RUMP { int|sys||accept(int s, struct sockaddr *name, \ 121 socklen_t *anamelen); } 122 31 STD RUMP { int|sys||getpeername(int fdes, struct sockaddr *asa, \ 123 socklen_t *alen); } 124 32 STD RUMP { int|sys||getsockname(int fdes, struct sockaddr *asa, \ 125 socklen_t *alen); } 126 33 STD RUMP { int|sys||access(const char *path, int flags); } 127 34 STD RUMP { int|sys||chflags(const char *path, u_long flags); } 128 35 STD RUMP { int|sys||fchflags(int fd, u_long flags); } 129 36 NOERR RUMP { void|sys||sync(void); } 130 37 STD { int|sys||kill(pid_t pid, int signum); } 131 38 COMPAT_43 MODULAR compat_43 \ 132 { int|sys||stat(const char *path, struct stat43 *ub); } stat43 133 39 NOERR RUMP { pid_t|sys||getppid(void); } 134 40 COMPAT_43 MODULAR compat_43 \ 135 { int|sys||lstat(const char *path, \ 136 struct stat43 *ub); } lstat43 137 41 STD RUMP { int|sys||dup(int fd); } 138 42 STD RUMP { int|sys||pipe(void); } 139 43 NOERR RUMP { gid_t|sys||getegid(void); } 140 44 STD { int|sys||profil(char *samples, size_t size, \ 141 u_long offset, u_int scale); } 142 45 STD RUMP { int|sys||ktrace(const char *fname, int ops, \ 143 int facs, pid_t pid); } 144 46 COMPAT_13 MODULAR compat_13 { int|sys||sigaction(int signum, \ 145 const struct sigaction13 *nsa, \ 146 struct sigaction13 *osa); } sigaction13 147 47 NOERR RUMP { gid_t|sys||getgid_with_egid(void); } getgid 148 48 COMPAT_13 MODULAR compat_13 { int|sys||sigprocmask(int how, \ 149 int mask); } sigprocmask13 150 49 STD RUMP { int|sys||__getlogin(char *namebuf, size_t namelen); } 151 50 STD RUMP { int|sys||__setlogin(const char *namebuf); } 152 51 STD { int|sys||acct(const char *path); } 153 52 COMPAT_13 MODULAR compat_13 { int|sys||sigpending(void); } sigpending13 154 53 COMPAT_13 MODULAR compat_13 { int|sys||sigaltstack( \ 155 const struct sigaltstack13 *nss, \ 156 struct sigaltstack13 *oss); } sigaltstack13 157 54 STD RUMP { int|sys||ioctl(int fd, \ 158 u_long com, ... void *data); } 159 55 COMPAT_12 MODULAR compat_12 { int|sys||reboot(int opt); } oreboot 160 56 STD RUMP { int|sys||revoke(const char *path); } 161 57 STD RUMP { int|sys||symlink(const char *path, \ 162 const char *link); } 163 58 STD RUMP { ssize_t|sys||readlink(const char *path, char *buf, \ 164 size_t count); } 165 59 STD { int|sys||execve(const char *path, \ 166 char * const *argp, char * const *envp); } 167 60 STD RUMP { mode_t|sys||umask(mode_t newmask); } 168 61 STD RUMP { int|sys||chroot(const char *path); } 169 62 COMPAT_43 MODULAR compat_43 \ 170 { int|sys||fstat(int fd, struct stat43 *sb); } fstat43 171 63 COMPAT_43 MODULAR compat_43 \ 172 { int|sys||getkerninfo(int op, char *where, int *size, \ 173 int arg); } ogetkerninfo 174 64 COMPAT_43 MODULAR compat_43 \ 175 { int|sys||getpagesize(void); } ogetpagesize 176 65 COMPAT_12 MODULAR compat_12 { int|sys||msync(void *addr, size_t len); } 177 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? 178 66 STD { int|sys||vfork(void); } 179 67 OBSOL vread 180 68 OBSOL vwrite 181 69 OBSOL sbrk 182 70 OBSOL sstk 183 71 COMPAT_43 MODULAR compat_43 \ 184 { int|sys||mmap(void *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 RUMP { int|sys||getgroups(int gidsetsize, \ 197 gid_t *gidset); } 198 80 STD RUMP { int|sys||setgroups(int gidsetsize, \ 199 const gid_t *gidset); } 200 81 STD RUMP { int|sys||getpgrp(void); } 201 82 STD RUMP { int|sys||setpgid(pid_t pid, pid_t pgid); } 202 83 COMPAT_50 MODULAR compat_50 { int|sys||setitimer(int which, \ 203 const struct itimerval50 *itv, \ 204 struct itimerval50 *oitv); } 205 84 COMPAT_43 MODULAR compat_43 { int|sys||wait(void); } owait 206 85 COMPAT_12 MODULAR compat_12 { int|sys||swapon(const char *name); } \ 207 oswapon 208 86 COMPAT_50 MODULAR compat_50 { int|sys||getitimer(int which, \ 209 struct itimerval50 *itv); } 210 87 COMPAT_43 MODULAR compat_43 \ 211 { int|sys||gethostname(char *hostname, u_int len); } \ 212 ogethostname 213 88 COMPAT_43 MODULAR compat_43 \ 214 { int|sys||sethostname(char *hostname, u_int len); } \ 215 osethostname 216 89 COMPAT_43 MODULAR compat_43 \ 217 { int|sys||getdtablesize(void); } ogetdtablesize 218 90 STD RUMP { int|sys||dup2(int from, int to); } 219 91 STD RUMP { ssize_t|sys||getrandom(void *buf, size_t buflen, \ 220 unsigned int flags); } 221 92 STD RUMP { int|sys||fcntl(int fd, int cmd, ... void *arg); } 222 93 COMPAT_50 MODULAR compat_50 RUMP \ 223 { int|sys||select(int nd, fd_set *in, fd_set *ou, \ 224 fd_set *ex, struct timeval50 *tv); } 225 94 UNIMPL setdopt 226 95 STD RUMP { int|sys||fsync(int fd); } 227 96 STD { int|sys||setpriority(int which, id_t who, int prio); } 228 97 COMPAT_30 MODULAR compat_30 \ 229 { int|sys||socket(int domain, int type, int protocol); } 230 98 STD RUMP { int|sys||connect(int s, const struct sockaddr *name, \ 231 socklen_t namelen); } 232 99 COMPAT_43 MODULAR compat_43 \ 233 { int|sys||accept(int s, void *name, \ 234 socklen_t *anamelen); } oaccept 235 100 STD { int|sys||getpriority(int which, id_t who); } 236 101 COMPAT_43 MODULAR compat_43 { int|sys||send(int s, void *buf, int len, \ 237 int flags); } osend 238 102 COMPAT_43 MODULAR compat_43 { int|sys||recv(int s, void *buf, int len, \ 239 int flags); } orecv 240 103 COMPAT_13 MODULAR compat_13 \ 241 { int|sys||sigreturn(struct sigcontext13 *sigcntxp); } \ 242 sigreturn13 243 104 STD RUMP { int|sys||bind(int s, const struct sockaddr *name, \ 244 socklen_t namelen); } 245 105 STD RUMP { int|sys||setsockopt(int s, int level, int name, \ 246 const void *val, socklen_t valsize); } 247 106 STD RUMP { int|sys||listen(int s, int backlog); } 248 107 OBSOL vtimes 249 108 COMPAT_43 MODULAR compat_43 \ 250 { int|sys||sigvec(int signum, struct sigvec *nsv, \ 251 struct sigvec *osv); } osigvec 252 109 COMPAT_43 MODULAR compat { int|sys||sigblock(int mask); } osigblock 253 110 COMPAT_43 MODULAR compat { int|sys||sigsetmask(int mask); } osigsetmask 254 111 COMPAT_13 MODULAR compat { int|sys||sigsuspend(int mask); } sigsuspend13 255 112 COMPAT_43 MODULAR compat_43 { int|sys||sigstack(struct sigstack *nss, \ 256 struct sigstack *oss); } osigstack 257 113 COMPAT_43 MODULAR compat_43 \ 258 { int|sys||recvmsg(int s, struct omsghdr *msg, \ 259 int flags); } orecvmsg 260 114 COMPAT_43 MODULAR compat_43 \ 261 { int|sys||sendmsg(int s, void *msg, int flags); } osendmsg 262 115 OBSOL vtrace 263 116 COMPAT_50 MODULAR compat_50 \ 264 { int|sys||gettimeofday(struct timeval50 *tp, void *tzp); } 265 117 COMPAT_50 MODULAR compat_50 \ 266 { int|sys||getrusage(int who, struct rusage50 *rusage); } 267 118 STD RUMP { int|sys||getsockopt(int s, int level, int name, \ 268 void *val, socklen_t *avalsize); } 269 119 OBSOL resuba 270 120 STD RUMP { ssize_t|sys||readv(int fd, \ 271 const struct iovec *iovp, int iovcnt); } 272 121 STD RUMP { ssize_t|sys||writev(int fd, \ 273 const struct iovec *iovp, int iovcnt); } 274 122 COMPAT_50 MODULAR compat_50 \ 275 { int|sys||settimeofday(const struct timeval50 *tv, \ 276 const void *tzp); } 277 123 STD RUMP { int|sys||fchown(int fd, uid_t uid, gid_t gid); } 278 124 STD RUMP { int|sys||fchmod(int fd, mode_t mode); } 279 125 COMPAT_43 MODULAR compat_43 \ 280 { int|sys||recvfrom(int s, void *buf, size_t len, \ 281 int flags, void *from, socklen_t *fromlenaddr); } \ 282 orecvfrom 283 126 STD RUMP { int|sys||setreuid(uid_t ruid, uid_t euid); } 284 127 STD RUMP { int|sys||setregid(gid_t rgid, gid_t egid); } 285 128 STD RUMP { int|sys||rename(const char *from, const char *to); } 286 129 COMPAT_43 MODULAR compat_43 \ 287 { int|sys||truncate(const char *path, long length); } otruncate 288 130 COMPAT_43 MODULAR compat_43 \ 289 { int|sys||ftruncate(int fd, long length); } oftruncate 290 131 STD RUMP { int|sys||flock(int fd, int how); } 291 132 STD RUMP { int|sys||mkfifo(const char *path, mode_t mode); } 292 133 STD RUMP { ssize_t|sys||sendto(int s, const void *buf, \ 293 size_t len, int flags, const struct sockaddr *to, \ 294 socklen_t tolen); } 295 134 STD RUMP { int|sys||shutdown(int s, int how); } 296 135 STD RUMP { int|sys||socketpair(int domain, int type, \ 297 int protocol, int *rsv); } 298 136 STD RUMP { int|sys||mkdir(const char *path, mode_t mode); } 299 137 STD RUMP { int|sys||rmdir(const char *path); } 300 138 COMPAT_50 MODULAR compat_50 RUMP { int|sys||utimes(const char *path, \ 301 const struct timeval50 *tptr); } 302 139 OBSOL 4.2 sigreturn 303 140 COMPAT_50 MODULAR compat_50 \ 304 { int|sys||adjtime(const struct timeval50 *delta, \ 305 struct timeval50 *olddelta); } 306 141 COMPAT_43 MODULAR compat_43 \ 307 { int|sys||getpeername(int fdes, void *asa, \ 308 socklen_t *alen); } ogetpeername 309 142 COMPAT_43 MODULAR compat_43 \ 310 { int32_t|sys||gethostid(void); } ogethostid 311 143 COMPAT_43 MODULAR compat_43 \ 312 { int|sys||sethostid(int32_t hostid); } osethostid 313 144 COMPAT_43 MODULAR compat_43 \ 314 { int|sys||getrlimit(int which, \ 315 struct orlimit *rlp); } ogetrlimit 316 145 COMPAT_43 MODULAR compat_43 { int|sys||setrlimit(int which, \ 317 const struct orlimit *rlp); } osetrlimit 318 146 COMPAT_43 MODULAR compat_43 \ 319 { int|sys||killpg(int pgid, int signum); } okillpg 320 147 STD RUMP { int|sys||setsid(void); } 321 148 COMPAT_50 MODULAR compat_50_quota \ 322 { int|sys||quotactl(const char *path, \ 323 int cmd, int uid, void *arg); } 324 149 COMPAT_43 MODULAR compat_43 { int|sys||quota(void); } oquota 325 150 COMPAT_43 MODULAR compat_43 { int|sys||getsockname(int fdec, \ 326 void *asa, socklen_t *alen); } ogetsockname 327 328 ; Syscalls 151-180 inclusive are reserved for vendor-specific 329 ; system calls. (This includes various calls added for compatibity 330 ; with other Unix variants.) 331 ; Some of these calls are now supported by BSD... 332 151 UNIMPL 333 152 UNIMPL 334 153 UNIMPL 335 154 UNIMPL 336 155 STD MODULAR nfsserver RUMP { int|sys||nfssvc(int flag, void *argp); } 337 156 COMPAT_43 MODULAR compat_43 \ 338 { int|sys||getdirentries(int fd, char *buf, \ 339 u_int count, long *basep); } ogetdirentries 340 157 COMPAT_20 MODULAR compat_20 { int|sys||statfs(const char *path, \ 341 struct statfs12 *buf); } 342 158 COMPAT_20 MODULAR compat_20 \ 343 { int|sys||fstatfs(int fd, struct statfs12 *buf); } 344 159 UNIMPL 345 160 UNIMPL 346 161 COMPAT_30 MODULAR compat_30 { int|sys||getfh(const char *fname, \ 347 struct compat_30_fhandle *fhp); } 348 162 COMPAT_09 MODULAR compat_09 \ 349 { int|sys||getdomainname(char *domainname, int len); } \ 350 ogetdomainname 351 163 COMPAT_09 MODULAR compat_09 \ 352 { int|sys||setdomainname(char *domainname, int len); } \ 353 osetdomainname 354 164 COMPAT_09 MODULAR compat \ 355 { int|sys||uname(struct outsname *name); } ouname 356 165 STD { int|sys||sysarch(int op, void *parms); } 357 166 STD { int|sys||__futex(int *uaddr, int op, int val, \ 358 const struct timespec *timeout, \ 359 int *uaddr2, int val2, int val3); } 360 167 STD { int|sys||__futex_set_robust_list(void *head, \ 361 size_t len); } 362 168 STD { int|sys||__futex_get_robust_list(lwpid_t lwpid, \ 363 void **headp, size_t *lenp); } 364 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 365 #if !defined(_LP64) 366 169 COMPAT_10 MODULAR compat_sysv_10 \ 367 { int|sys||semsys(int which, int a2, int a3, int a4, \ 368 int a5); } osemsys 369 #else 370 169 EXCL 1.0 semsys 371 #endif 372 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 373 #if !defined(_LP64) 374 170 COMPAT_10 MODULAR compat_sysv_10 \ 375 { int|sys||msgsys(int which, int a2, int a3, int a4, \ 376 int a5, int a6); } omsgsys 377 #else 378 170 EXCL 1.0 msgsys 379 #endif 380 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 381 #if !defined(_LP64) 382 171 COMPAT_10 MODULAR compat_sysv_10 \ 383 { int|sys||shmsys(int which, int a2, int a3, int a4); } \ 384 oshmsys 385 #else 386 171 EXCL 1.0 shmsys 387 #endif 388 172 UNIMPL 389 173 STD RUMP { ssize_t|sys||pread(int fd, void *buf, \ 390 size_t nbyte, int PAD, off_t offset); } 391 174 STD RUMP { ssize_t|sys||pwrite(int fd, const void *buf, \ 392 size_t nbyte, int PAD, off_t offset); } 393 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded. 394 175 COMPAT_30 MODULAR compat_30 \ 395 { int|sys||ntp_gettime(struct ntptimeval30 *ntvp); } 396 #if defined(NTP) || !defined(_KERNEL_OPT) 397 176 STD { int|sys||ntp_adjtime(struct timex *tp); } 398 #else 399 176 EXCL ntp_adjtime 400 #endif 401 177 STD { int|sys||timerfd_create(clockid_t clock_id, \ 402 int flags); } 403 178 STD { int|sys||timerfd_settime(int fd, int flags, \ 404 const struct itimerspec *new_value, \ 405 struct itimerspec *old_value); } 406 179 STD { int|sys||timerfd_gettime(int fd, \ 407 struct itimerspec *curr_value); } 408 180 UNIMPL 409 410 ; Syscalls 180-199 are used by/reserved for BSD 411 181 STD RUMP { int|sys||setgid(gid_t gid); } 412 182 STD RUMP { int|sys||setegid(gid_t egid); } 413 183 STD RUMP { int|sys||seteuid(uid_t euid); } 414 184 STD MODULAR lfs { int|sys||lfs_bmapv(fsid_t *fsidp, \ 415 struct block_info *blkiov, int blkcnt); } 416 185 STD MODULAR lfs { int|sys||lfs_markv(fsid_t *fsidp, \ 417 struct block_info *blkiov, int blkcnt); } 418 186 STD MODULAR lfs { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); } 419 187 COMPAT_50 MODULAR compat_50 { int|sys||lfs_segwait(fsid_t *fsidp, \ 420 struct timeval50 *tv); } 421 188 COMPAT_12 MODULAR compat_12 \ 422 { int|sys||stat(const char *path, struct stat12 *ub); } stat12 423 189 COMPAT_12 MODULAR compat_12 \ 424 { int|sys||fstat(int fd, struct stat12 *sb); } fstat12 425 190 COMPAT_12 MODULAR compat_12 { int|sys||lstat(const char *path, \ 426 struct stat12 *ub); } lstat12 427 191 STD RUMP { long|sys||pathconf(const char *path, int name); } 428 192 STD RUMP { long|sys||fpathconf(int fd, int name); } 429 193 STD RUMP { int|sys||getsockopt2(int s, int level, int name, \ 430 void *val, socklen_t *avalsize); } 431 194 STD RUMP { int|sys||getrlimit(int which, \ 432 struct rlimit *rlp); } 433 195 STD RUMP { int|sys||setrlimit(int which, \ 434 const struct rlimit *rlp); } 435 196 COMPAT_12 MODULAR compat_12 \ 436 { int|sys||getdirentries(int fd, char *buf, \ 437 u_int count, long *basep); } 438 197 STD { void *|sys||mmap(void *addr, size_t len, int prot, \ 439 int flags, int fd, long PAD, off_t pos); } 440 198 INDIR { quad_t|sys||__syscall(quad_t code, \ 441 ... register_t args[SYS_MAXSYSARGS]); } 442 199 STD RUMP { off_t|sys||lseek(int fd, int PAD, off_t offset, \ 443 int whence); } 444 200 STD RUMP { int|sys||truncate(const char *path, int PAD, \ 445 off_t length); } 446 201 STD RUMP { int|sys||ftruncate(int fd, int PAD, off_t length); } 447 202 STD RUMP { int|sys||__sysctl(const int *name, u_int namelen, \ 448 void *oldv, size_t *oldlenp, const void *newv, \ 449 size_t newlen); } 450 203 STD { int|sys||mlock(const void *addr, size_t len); } 451 204 STD { int|sys||munlock(const void *addr, size_t len); } 452 205 STD { int|sys||undelete(const char *path); } 453 206 COMPAT_50 MODULAR compat_50 RUMP { int|sys||futimes(int fd, \ 454 const struct timeval50 *tptr); } 455 207 STD RUMP { pid_t|sys||getpgid(pid_t pid); } 456 208 STD RUMP { int|sys||reboot(int opt, char *bootstr); } 457 209 STD RUMP { int|sys||poll(struct pollfd *fds, u_int nfds, \ 458 int timeout); } 459 ; 460 ; Syscalls 210-219 are reserved for dynamically loaded syscalls 461 ; 462 210 EXTERN MODULAR openafs { int|sys||afssys(long id, long a1, long a2, \ 463 long a3, long a4, long a5, long a6); } 464 211 UNIMPL 465 212 UNIMPL 466 213 UNIMPL 467 214 UNIMPL 468 215 UNIMPL 469 216 UNIMPL 470 217 UNIMPL 471 218 UNIMPL 472 219 UNIMPL 473 ; System calls 220-300 are reserved for use by NetBSD 474 220 COMPAT_14 MODULAR compat_sysv_14 \ 475 { int|sys||__semctl(int semid, int semnum, int cmd, \ 476 union __semun *arg); } 477 221 STD MODULAR sysv_ipc { int|sys||semget(key_t key, int nsems, \ 478 int semflg); } 479 222 STD MODULAR sysv_ipc { int|sys||semop(int semid, struct sembuf *sops, \ 480 size_t nsops); } 481 223 STD MODULAR sysv_ipc { int|sys||semconfig(int flag); } 482 224 COMPAT_14 MODULAR compat_sysv_14 { int|sys||msgctl(int msqid, int cmd, \ 483 struct msqid_ds14 *buf); } 484 225 STD MODULAR sysv_ipc { int|sys||msgget(key_t key, int msgflg); } 485 226 STD MODULAR sysv_ipc { int|sys||msgsnd(int msqid, const void *msgp, \ 486 size_t msgsz, int msgflg); } 487 227 STD MODULAR sysv_ipc { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 488 size_t msgsz, long msgtyp, int msgflg); } 489 228 STD MODULAR sysv_ipc { void *|sys||shmat(int shmid, \ 490 const void *shmaddr, int shmflg); } 491 229 COMPAT_14 MODULAR compat_sysv_14 { int|sys||shmctl(int shmid, int cmd, \ 492 struct shmid_ds14 *buf); } 493 230 STD MODULAR sysv_ipc { int|sys||shmdt(const void *shmaddr); } 494 231 STD MODULAR sysv_ipc { int|sys||shmget(key_t key, size_t size, \ 495 int shmflg); } 496 232 COMPAT_50 MODULAR compat_50 \ 497 { int|sys||clock_gettime(clockid_t clock_id, \ 498 struct timespec50 *tp); } 499 233 COMPAT_50 MODULAR compat_50 \ 500 { int|sys||clock_settime(clockid_t clock_id, \ 501 const struct timespec50 *tp); } 502 234 COMPAT_50 MODULAR compat_50 \ 503 { int|sys||clock_getres(clockid_t clock_id, \ 504 struct timespec50 *tp); } 505 235 STD RUMP { int|sys||timer_create(clockid_t clock_id, \ 506 struct sigevent *evp, timer_t *timerid); } 507 236 STD RUMP { int|sys||timer_delete(timer_t timerid); } 508 237 COMPAT_50 MODULAR compat_50 { int|sys||timer_settime(timer_t timerid, \ 509 int flags, const struct itimerspec50 *value, \ 510 struct itimerspec50 *ovalue); } 511 238 COMPAT_50 MODULAR compat_50 { int|sys||timer_gettime(timer_t timerid, \ 512 struct itimerspec50 *value); } 513 239 STD RUMP { int|sys||timer_getoverrun(timer_t timerid); } 514 ; 515 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls 516 ; 517 240 COMPAT_50 MODULAR compat_50 \ 518 { int|sys||nanosleep(const struct timespec50 *rqtp, \ 519 struct timespec50 *rmtp); } 520 241 STD RUMP { int|sys||fdatasync(int fd); } 521 242 STD { int|sys||mlockall(int flags); } 522 243 STD { int|sys||munlockall(void); } 523 244 COMPAT_50 MODULAR compat_50 \ 524 { int|sys||__sigtimedwait(const sigset_t *set, \ 525 siginfo_t *info, struct timespec50 *timeout); } 526 245 STD { int|sys||sigqueueinfo(pid_t pid, \ 527 const siginfo_t *info); } 528 246 STD RUMP { int|sys||modctl(int cmd, void *arg); } 529 247 STD MODULAR ksem RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); } 530 248 STD MODULAR ksem RUMP { int|sys||_ksem_open(const char *name, int oflag, \ 531 mode_t mode, unsigned int value, intptr_t *idp); } 532 249 STD MODULAR ksem RUMP { int|sys||_ksem_unlink(const char *name); } 533 250 STD MODULAR ksem RUMP { int|sys||_ksem_close(intptr_t id); } 534 251 STD MODULAR ksem RUMP { int|sys||_ksem_post(intptr_t id); } 535 252 STD MODULAR ksem RUMP { int|sys||_ksem_wait(intptr_t id); } 536 253 STD MODULAR ksem RUMP { int|sys||_ksem_trywait(intptr_t id); } 537 254 STD MODULAR ksem RUMP { int|sys||_ksem_getvalue(intptr_t id, \ 538 unsigned int *value); } 539 255 STD MODULAR ksem RUMP { int|sys||_ksem_destroy(intptr_t id); } 540 256 STD MODULAR ksem RUMP { int|sys||_ksem_timedwait(intptr_t id, \ 541 const struct timespec *abstime); } 542 257 STD MODULAR mqueue \ 543 { mqd_t|sys||mq_open(const char * name, int oflag, \ 544 mode_t mode, struct mq_attr *attr); } 545 258 STD MODULAR mqueue { int|sys||mq_close(mqd_t mqdes); } 546 259 STD MODULAR mqueue { int|sys||mq_unlink(const char *name); } 547 260 STD MODULAR mqueue \ 548 { int|sys||mq_getattr(mqd_t mqdes, \ 549 struct mq_attr *mqstat); } 550 261 STD MODULAR mqueue \ 551 { int|sys||mq_setattr(mqd_t mqdes, \ 552 const struct mq_attr *mqstat, \ 553 struct mq_attr *omqstat); } 554 262 STD MODULAR mqueue \ 555 { int|sys||mq_notify(mqd_t mqdes, \ 556 const struct sigevent *notification); } 557 263 STD MODULAR mqueue \ 558 { int|sys||mq_send(mqd_t mqdes, const char *msg_ptr, \ 559 size_t msg_len, unsigned msg_prio); } 560 264 STD MODULAR mqueue \ 561 { ssize_t|sys||mq_receive(mqd_t mqdes, char *msg_ptr, \ 562 size_t msg_len, unsigned *msg_prio); } 563 265 COMPAT_50 MODULAR compat_50 \ 564 { int|sys||mq_timedsend(mqd_t mqdes, \ 565 const char *msg_ptr, size_t msg_len, \ 566 unsigned msg_prio, \ 567 const struct timespec50 *abs_timeout); } 568 266 COMPAT_50 MODULAR compat_50 \ 569 { ssize_t|sys||mq_timedreceive(mqd_t mqdes, \ 570 char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ 571 const struct timespec50 *abs_timeout); } 572 267 STD { int|sys||eventfd(unsigned int val, int flags); } 573 268 UNIMPL 574 269 UNIMPL 575 270 STD RUMP { int|sys||__posix_rename(const char *from, \ 576 const char *to); } 577 271 STD { int|sys||swapctl(int cmd, void *arg, int misc); } 578 272 COMPAT_30 MODULAR compat_30 \ 579 { int|sys||getdents(int fd, char *buf, size_t count); } 580 273 STD { int|sys||minherit(void *addr, size_t len, \ 581 int inherit); } 582 274 STD RUMP { int|sys||lchmod(const char *path, mode_t mode); } 583 275 STD RUMP { int|sys||lchown(const char *path, uid_t uid, \ 584 gid_t gid); } 585 276 COMPAT_50 MODULAR compat_50 RUMP { int|sys||lutimes(const char *path, \ 586 const struct timeval50 *tptr); } 587 277 STD { int|sys|13|msync(void *addr, size_t len, int flags); } 588 278 COMPAT_30 MODULAR compat_30 \ 589 { int|sys|13|stat(const char *path, struct stat13 *ub); } 590 279 COMPAT_30 MODULAR compat_30 \ 591 { int|sys|13|fstat(int fd, struct stat13 *sb); } 592 280 COMPAT_30 MODULAR compat_30 \ 593 { int|sys|13|lstat(const char *path, struct stat13 *ub); } 594 281 STD { int|sys|14|sigaltstack(const stack_t *nss, \ 595 stack_t *oss); } 596 282 STD { int|sys|14|vfork(void); } 597 283 STD RUMP { int|sys||__posix_chown(const char *path, uid_t uid, \ 598 gid_t gid); } 599 284 STD RUMP { int|sys||__posix_fchown(int fd, uid_t uid, \ 600 gid_t gid); } 601 285 STD RUMP { int|sys||__posix_lchown(const char *path, uid_t uid, \ 602 gid_t gid); } 603 286 STD RUMP { pid_t|sys||getsid(pid_t pid); } 604 287 STD { pid_t|sys||__clone(int flags, void *stack); } 605 288 STD RUMP { int|sys||fktrace(int fd, int ops, \ 606 int facs, pid_t pid); } 607 289 STD RUMP { ssize_t|sys||preadv(int fd, \ 608 const struct iovec *iovp, int iovcnt, \ 609 int PAD, off_t offset); } 610 290 STD RUMP { ssize_t|sys||pwritev(int fd, \ 611 const struct iovec *iovp, int iovcnt, \ 612 int PAD, off_t offset); } 613 291 COMPAT_16 MODULAR compat_16 { int|sys|14|sigaction(int signum, \ 614 const struct sigaction *nsa, \ 615 struct sigaction *osa); } 616 292 STD { int|sys|14|sigpending(sigset_t *set); } 617 293 STD { int|sys|14|sigprocmask(int how, \ 618 const sigset_t *set, \ 619 sigset_t *oset); } 620 294 STD { int|sys|14|sigsuspend(const sigset_t *set); } 621 295 COMPAT_16 MODULAR compat_16 \ 622 { int|sys|14|sigreturn(struct sigcontext *sigcntxp); } 623 296 STD RUMP { int|sys||__getcwd(char *bufp, size_t length); } 624 297 STD RUMP { int|sys||fchroot(int fd); } 625 298 COMPAT_30 MODULAR compat_30 \ 626 { int|sys||fhopen(const struct compat_30_fhandle *fhp, int flags); } 627 299 COMPAT_30 MODULAR compat_30 \ 628 { int|sys||fhstat(const struct compat_30_fhandle *fhp, \ 629 struct stat13 *sb); } 630 300 COMPAT_20 MODULAR compat_20 \ 631 { int|sys||fhstatfs(const struct compat_30_fhandle *fhp, \ 632 struct statfs12 *buf); } 633 301 COMPAT_50 MODULAR compat_sysv_50 \ 634 { int|sys|13|__semctl(int semid, int semnum, int cmd, \ 635 ... union __semun *arg); } 636 302 COMPAT_50 MODULAR compat_sysv_50 \ 637 { int|sys|13|msgctl(int msqid, int cmd, struct msqid_ds *buf); } 638 303 COMPAT_50 MODULAR compat_sysv_50 \ 639 { int|sys|13|shmctl(int shmid, int cmd, \ 640 struct shmid_ds13 *buf); } 641 304 STD RUMP { int|sys||lchflags(const char *path, u_long flags); } 642 305 NOERR RUMP { int|sys||issetugid(void); } 643 306 STD RUMP { int|sys||utrace(const char *label, void *addr, \ 644 size_t len); } 645 307 STD { int|sys||getcontext(struct __ucontext *ucp); } 646 308 STD { int|sys||setcontext(const struct __ucontext *ucp); } 647 309 STD { int|sys||_lwp_create(const struct __ucontext *ucp, \ 648 u_long flags, lwpid_t *new_lwp); } 649 310 STD { int|sys||_lwp_exit(void); } 650 311 STD { lwpid_t|sys||_lwp_self(void); } 651 312 STD { int|sys||_lwp_wait(lwpid_t wait_for, \ 652 lwpid_t *departed); } 653 313 STD { int|sys||_lwp_suspend(lwpid_t target); } 654 314 STD { int|sys||_lwp_continue(lwpid_t target); } 655 315 STD { int|sys||_lwp_wakeup(lwpid_t target); } 656 316 STD { void *|sys||_lwp_getprivate(void); } 657 317 STD { void|sys||_lwp_setprivate(void *ptr); } 658 318 STD { int|sys||_lwp_kill(lwpid_t target, int signo); } 659 319 STD { int|sys||_lwp_detach(lwpid_t target); } 660 320 COMPAT_50 MODULAR compat_50 \ 661 { int|sys||_lwp_park(const struct timespec50 *ts, \ 662 lwpid_t unpark, const void *hint, \ 663 const void *unparkhint); } 664 321 STD { int|sys||_lwp_unpark(lwpid_t target, const void *hint); } 665 322 STD { ssize_t|sys||_lwp_unpark_all(const lwpid_t *targets, \ 666 size_t ntargets, const void *hint); } 667 323 STD { int|sys||_lwp_setname(lwpid_t target, \ 668 const char *name); } 669 324 STD { int|sys||_lwp_getname(lwpid_t target, \ 670 char *name, size_t len); } 671 325 STD { int|sys||_lwp_ctl(int features, \ 672 struct lwpctl **address); } 673 ; Syscalls 326-339 reserved for LWP syscalls. 674 326 UNIMPL 675 327 UNIMPL 676 328 UNIMPL 677 329 UNIMPL 678 ; SA system calls. 679 330 COMPAT_60 MODULAR compat_60 \ 680 { int|sys||sa_register(void *newv, void **oldv, \ 681 int flags, ssize_t stackinfo_offset); } 682 331 COMPAT_60 MODULAR compat_60 \ 683 { int|sys||sa_stacks(int num, stack_t *stacks); } 684 332 COMPAT_60 MODULAR compat_60 \ 685 { int|sys||sa_enable(void); } 686 333 COMPAT_60 MODULAR compat_60 \ 687 { int|sys||sa_setconcurrency(int concurrency); } 688 334 COMPAT_60 MODULAR compat_60 \ 689 { int|sys||sa_yield(void); } 690 335 COMPAT_60 MODULAR compat_60 \ 691 { int|sys||sa_preempt(int sa_id); } 692 336 OBSOL sys_sa_unblockyield 693 ; 694 ; Syscalls 337-339 are reserved for other scheduler activation syscalls. 695 ; 696 337 UNIMPL 697 338 UNIMPL 698 339 UNIMPL 699 340 STD { int|sys||__sigaction_sigtramp(int signum, \ 700 const struct sigaction *nsa, \ 701 struct sigaction *osa, \ 702 const void *tramp, int vers); } 703 341 OBSOL sys_pmc_get_info 704 342 OBSOL sys_pmc_control 705 343 STD { int|sys||rasctl(void *addr, size_t len, int op); } 706 344 STD RUMP { int|sys||kqueue(void); } 707 345 COMPAT_50 MODULAR compat_50 RUMP { int|sys||kevent(int fd, \ 708 const struct kevent *changelist, size_t nchanges, \ 709 struct kevent *eventlist, size_t nevents, \ 710 const struct timespec50 *timeout); } 711 712 ; Scheduling system calls. 713 346 STD { int|sys||_sched_setparam(pid_t pid, lwpid_t lid, \ 714 int policy, const struct sched_param *params); } 715 347 STD { int|sys||_sched_getparam(pid_t pid, lwpid_t lid, \ 716 int *policy, struct sched_param *params); } 717 348 STD { int|sys||_sched_setaffinity(pid_t pid, lwpid_t lid, \ 718 size_t size, const cpuset_t *cpuset); } 719 349 STD { int|sys||_sched_getaffinity(pid_t pid, lwpid_t lid, \ 720 size_t size, cpuset_t *cpuset); } 721 350 STD { int|sys||sched_yield(void); } 722 351 STD { int|sys||_sched_protect(int priority); } 723 352 UNIMPL 724 353 UNIMPL 725 726 354 STD RUMP { int|sys||fsync_range(int fd, int flags, off_t start, \ 727 off_t length); } 728 355 STD { int|sys||uuidgen(struct uuid *store, int count); } 729 356 COMPAT_90 MODULAR compat_90 { \ 730 int|sys||getvfsstat(struct statvfs90 *buf, \ 731 size_t bufsize, int flags); } 732 357 COMPAT_90 MODULAR compat_90 { int|sys||statvfs1(const char *path, \ 733 struct statvfs90 *buf, int flags); } 734 358 COMPAT_90 MODULAR compat_90 { int|sys||fstatvfs1(int fd, \ 735 struct statvfs90 *buf, int flags); } 736 359 COMPAT_30 MODULAR compat_30 { int|sys||fhstatvfs1( \ 737 const struct compat_30_fhandle *fhp, \ 738 struct statvfs90 *buf, int flags); } 739 360 STD RUMP { int|sys||extattrctl(const char *path, int cmd, \ 740 const char *filename, int attrnamespace, \ 741 const char *attrname); } 742 361 STD RUMP { int|sys||extattr_set_file(const char *path, \ 743 int attrnamespace, const char *attrname, \ 744 const void *data, size_t nbytes); } 745 362 STD RUMP { ssize_t|sys||extattr_get_file(const char *path, \ 746 int attrnamespace, const char *attrname, \ 747 void *data, size_t nbytes); } 748 363 STD RUMP { int|sys||extattr_delete_file(const char *path, \ 749 int attrnamespace, const char *attrname); } 750 364 STD RUMP { int|sys||extattr_set_fd(int fd, \ 751 int attrnamespace, const char *attrname, \ 752 const void *data, size_t nbytes); } 753 365 STD RUMP { ssize_t|sys||extattr_get_fd(int fd, \ 754 int attrnamespace, const char *attrname, \ 755 void *data, size_t nbytes); } 756 366 STD RUMP { int|sys||extattr_delete_fd(int fd, \ 757 int attrnamespace, const char *attrname); } 758 367 STD RUMP { int|sys||extattr_set_link(const char *path, \ 759 int attrnamespace, const char *attrname, \ 760 const void *data, size_t nbytes); } 761 368 STD RUMP { ssize_t|sys||extattr_get_link(const char *path, \ 762 int attrnamespace, const char *attrname, \ 763 void *data, size_t nbytes); } 764 369 STD RUMP { int|sys||extattr_delete_link(const char *path, \ 765 int attrnamespace, const char *attrname); } 766 370 STD RUMP { ssize_t|sys||extattr_list_fd(int fd, \ 767 int attrnamespace, void *data, size_t nbytes); } 768 371 STD RUMP { ssize_t|sys||extattr_list_file(const char *path, \ 769 int attrnamespace, void *data, size_t nbytes); } 770 372 STD RUMP { ssize_t|sys||extattr_list_link(const char *path, \ 771 int attrnamespace, void *data, size_t nbytes); } 772 373 COMPAT_50 MODULAR compat_50 RUMP \ 773 { int|sys||pselect(int nd, fd_set *in, fd_set *ou, \ 774 fd_set *ex, const struct timespec50 *ts, \ 775 const sigset_t *mask); } 776 374 COMPAT_50 MODULAR compat_50 RUMP \ 777 { int|sys||pollts(struct pollfd *fds, u_int nfds, \ 778 const struct timespec50 *ts, const sigset_t *mask); } 779 375 STD RUMP { int|sys||setxattr(const char *path, \ 780 const char *name, const void *value, size_t size, \ 781 int flags); } 782 376 STD RUMP { int|sys||lsetxattr(const char *path, \ 783 const char *name, const void *value, size_t size, \ 784 int flags); } 785 377 STD RUMP { int|sys||fsetxattr(int fd, \ 786 const char *name, const void *value, size_t size, \ 787 int flags); } 788 378 STD RUMP { int|sys||getxattr(const char *path, \ 789 const char *name, void *value, size_t size); } 790 379 STD RUMP { int|sys||lgetxattr(const char *path, \ 791 const char *name, void *value, size_t size); } 792 380 STD RUMP { int|sys||fgetxattr(int fd, \ 793 const char *name, void *value, size_t size); } 794 381 STD RUMP { int|sys||listxattr(const char *path, \ 795 char *list, size_t size); } 796 382 STD RUMP { int|sys||llistxattr(const char *path, \ 797 char *list, size_t size); } 798 383 STD RUMP { int|sys||flistxattr(int fd, \ 799 char *list, size_t size); } 800 384 STD RUMP { int|sys||removexattr(const char *path, \ 801 const char *name); } 802 385 STD RUMP { int|sys||lremovexattr(const char *path, \ 803 const char *name); } 804 386 STD RUMP { int|sys||fremovexattr(int fd, \ 805 const char *name); } 806 387 COMPAT_50 MODULAR compat_50 RUMP \ 807 { int|sys|30|stat(const char *path, struct stat30 *ub); } 808 388 COMPAT_50 MODULAR compat_50 RUMP \ 809 { int|sys|30|fstat(int fd, struct stat30 *sb); } 810 389 COMPAT_50 MODULAR compat_50 RUMP \ 811 { int|sys|30|lstat(const char *path, struct stat30 *ub); } 812 390 STD RUMP { int|sys|30|getdents(int fd, char *buf, size_t count); } 813 391 IGNORED old posix_fadvise 814 392 COMPAT_30 MODULAR compat_30 \ 815 { int|sys|30|fhstat(const struct compat_30_fhandle \ 816 *fhp, struct stat30 *sb); } 817 393 COMPAT_50 MODULAR compat_30 \ 818 { int|sys|30|ntp_gettime(struct ntptimeval50 *ntvp); } 819 394 STD RUMP { int|sys|30|socket(int domain, int type, int protocol); } 820 395 STD RUMP { int|sys|30|getfh(const char *fname, void *fhp, \ 821 size_t *fh_size); } 822 396 STD RUMP { int|sys|40|fhopen(const void *fhp, size_t fh_size,\ 823 int flags); } 824 397 COMPAT_90 MODULAR compat_90 { \ 825 int|sys||fhstatvfs1(const void *fhp, \ 826 size_t fh_size, struct statvfs90 *buf, int flags); } 827 398 COMPAT_50 MODULAR compat_50 RUMP { int|sys|40|fhstat(const void *fhp, \ 828 size_t fh_size, struct stat30 *sb); } 829 830 ; Asynchronous I/O system calls 831 399 STD MODULAR aio RUMP \ 832 { int|sys||aio_cancel(int fildes, struct aiocb *aiocbp); } 833 400 STD MODULAR aio RUMP \ 834 { int|sys||aio_error(const struct aiocb *aiocbp); } 835 401 STD MODULAR aio RUMP \ 836 { int|sys||aio_fsync(int op, struct aiocb *aiocbp); } 837 402 STD MODULAR aio RUMP \ 838 { int|sys||aio_read(struct aiocb *aiocbp); } 839 403 STD MODULAR aio RUMP \ 840 { int|sys||aio_return(struct aiocb *aiocbp); } 841 404 COMPAT_50 MODULAR compat \ 842 { int|sys||aio_suspend(const struct aiocb *const *list, \ 843 int nent, const struct timespec50 *timeout); } 844 405 STD MODULAR aio RUMP \ 845 { int|sys||aio_write(struct aiocb *aiocbp); } 846 406 STD MODULAR aio RUMP \ 847 { int|sys||lio_listio(int mode, struct aiocb *const *list, \ 848 int nent, struct sigevent *sig); } 849 850 407 UNIMPL 851 408 UNIMPL 852 409 UNIMPL 853 854 410 STD RUMP { int|sys|50|mount(const char *type, \ 855 const char *path, int flags, void *data, \ 856 size_t data_len); } 857 411 STD { void *|sys||mremap(void *old_address, \ 858 size_t old_size, void *new_address, \ 859 size_t new_size, int flags); } 860 861 ; Processor-sets system calls 862 412 STD { int|sys||pset_create(psetid_t *psid); } 863 413 STD { int|sys||pset_destroy(psetid_t psid); } 864 414 STD { int|sys||pset_assign(psetid_t psid, cpuid_t cpuid, \ 865 psetid_t *opsid); } 866 415 STD { int|sys||_pset_bind(idtype_t idtype, id_t first_id, \ 867 id_t second_id, psetid_t psid, psetid_t *opsid); } 868 416 NOERR RUMP { int|sys|50|posix_fadvise(int fd, int PAD, \ 869 off_t offset, off_t len, int advice); } 870 417 STD RUMP { int|sys|50|select(int nd, fd_set *in, fd_set *ou, \ 871 fd_set *ex, struct timeval *tv); } 872 418 STD RUMP { int|sys|50|gettimeofday(struct timeval *tp, \ 873 void *tzp); } 874 419 STD RUMP { int|sys|50|settimeofday(const struct timeval *tv, \ 875 const void *tzp); } 876 420 STD RUMP { int|sys|50|utimes(const char *path, \ 877 const struct timeval *tptr); } 878 421 STD RUMP { int|sys|50|adjtime(const struct timeval *delta, \ 879 struct timeval *olddelta); } 880 422 STD MODULAR lfs { int|sys|50|lfs_segwait(fsid_t *fsidp, \ 881 struct timeval *tv); } 882 423 STD RUMP { int|sys|50|futimes(int fd, \ 883 const struct timeval *tptr); } 884 424 STD RUMP { int|sys|50|lutimes(const char *path, \ 885 const struct timeval *tptr); } 886 425 STD RUMP { int|sys|50|setitimer(int which, \ 887 const struct itimerval *itv, \ 888 struct itimerval *oitv); } 889 426 STD RUMP { int|sys|50|getitimer(int which, \ 890 struct itimerval *itv); } 891 427 STD RUMP { int|sys|50|clock_gettime(clockid_t clock_id, \ 892 struct timespec *tp); } 893 428 STD RUMP { int|sys|50|clock_settime(clockid_t clock_id, \ 894 const struct timespec *tp); } 895 429 STD RUMP { int|sys|50|clock_getres(clockid_t clock_id, \ 896 struct timespec *tp); } 897 430 STD RUMP { int|sys|50|nanosleep(const struct timespec *rqtp, \ 898 struct timespec *rmtp); } 899 431 STD { int|sys|50|__sigtimedwait(const sigset_t *set, \ 900 siginfo_t *info, \ 901 struct timespec *timeout); } 902 432 STD MODULAR mqueue \ 903 { int|sys|50|mq_timedsend(mqd_t mqdes, \ 904 const char *msg_ptr, size_t msg_len, \ 905 unsigned msg_prio, \ 906 const struct timespec *abs_timeout); } 907 433 STD MODULAR mqueue \ 908 { ssize_t|sys|50|mq_timedreceive(mqd_t mqdes, \ 909 char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ 910 const struct timespec *abs_timeout); } 911 434 COMPAT_60 MODULAR compat_60 \ 912 { int|sys||_lwp_park(const struct timespec *ts, \ 913 lwpid_t unpark, const void *hint, \ 914 const void *unparkhint); } 915 435 STD RUMP { int|sys|50|kevent(int fd, \ 916 const struct kevent *changelist, size_t nchanges, \ 917 struct kevent *eventlist, size_t nevents, \ 918 const struct timespec *timeout); } 919 436 STD RUMP { int|sys|50|pselect(int nd, fd_set *in, fd_set *ou, \ 920 fd_set *ex, const struct timespec *ts, \ 921 const sigset_t *mask); } 922 437 STD RUMP { int|sys|50|pollts(struct pollfd *fds, u_int nfds, \ 923 const struct timespec *ts, const sigset_t *mask); } 924 438 STD MODULAR aio RUMP { int|sys|50|aio_suspend( \ 925 const struct aiocb *const *list, \ 926 int nent, const struct timespec *timeout); } 927 439 STD RUMP { int|sys|50|stat(const char *path, struct stat *ub); } 928 440 STD RUMP { int|sys|50|fstat(int fd, struct stat *sb); } 929 441 STD RUMP { int|sys|50|lstat(const char *path, struct stat *ub); } 930 442 STD MODULAR sysv_ipc { int|sys|50|__semctl(int semid, int semnum, \ 931 int cmd, ... union __semun *arg); } 932 443 STD MODULAR sysv_ipc { int|sys|50|shmctl(int shmid, int cmd, \ 933 struct shmid_ds *buf); } 934 444 STD MODULAR sysv_ipc { int|sys|50|msgctl(int msqid, int cmd, \ 935 struct msqid_ds *buf); } 936 445 STD { int|sys|50|getrusage(int who, struct rusage *rusage); } 937 446 STD RUMP { int|sys|50|timer_settime(timer_t timerid, \ 938 int flags, const struct itimerspec *value, \ 939 struct itimerspec *ovalue); } 940 447 STD RUMP { int|sys|50|timer_gettime(timer_t timerid, struct \ 941 itimerspec *value); } 942 #if defined(NTP) || !defined(_KERNEL_OPT) 943 448 STD { int|sys|50|ntp_gettime(struct ntptimeval *ntvp); } 944 #else 945 448 EXCL ___ntp_gettime50 946 #endif 947 449 STD { int|sys|50|wait4(pid_t pid, int *status, \ 948 int options, struct rusage *rusage); } 949 450 STD RUMP { int|sys|50|mknod(const char *path, mode_t mode, \ 950 dev_t dev); } 951 451 STD RUMP { int|sys|50|fhstat(const void *fhp, \ 952 size_t fh_size, struct stat *sb); } 953 ; 452 only ever appeared in 5.99.x and can be reused after netbsd-7 954 452 OBSOL 5.99 quotactl 955 453 STD RUMP { int|sys||pipe2(int *fildes, int flags); } 956 454 STD RUMP { int|sys||dup3(int from, int to, int flags); } 957 455 STD RUMP { int|sys||kqueue1(int flags); } 958 456 STD RUMP { int|sys||paccept(int s, struct sockaddr *name, \ 959 socklen_t *anamelen, const sigset_t *mask, \ 960 int flags); } 961 457 STD RUMP { int|sys||linkat(int fd1, const char *name1, \ 962 int fd2, const char *name2, int flags); } 963 458 STD RUMP { int|sys||renameat(int fromfd, const char *from, \ 964 int tofd, const char *to); } 965 459 STD RUMP { int|sys||mkfifoat(int fd, const char *path, \ 966 mode_t mode); } 967 460 STD RUMP { int|sys||mknodat(int fd, const char *path, \ 968 mode_t mode, int PAD, dev_t dev); } 969 461 STD RUMP { int|sys||mkdirat(int fd, const char *path, \ 970 mode_t mode); } 971 462 STD RUMP { int|sys||faccessat(int fd, const char *path, \ 972 int amode, int flag); } 973 463 STD RUMP { int|sys||fchmodat(int fd, const char *path, \ 974 mode_t mode, int flag); } 975 464 STD RUMP { int|sys||fchownat(int fd, const char *path, \ 976 uid_t owner, gid_t group, int flag); } 977 465 STD { int|sys||fexecve(int fd, \ 978 char * const *argp, char * const *envp); } 979 466 STD RUMP { int|sys||fstatat(int fd, const char *path, \ 980 struct stat *buf, int flag); } 981 467 STD RUMP { int|sys||utimensat(int fd, const char *path, \ 982 const struct timespec *tptr, int flag); } 983 468 STD RUMP { int|sys||openat(int fd, const char *path, \ 984 int oflags, ... mode_t mode); } 985 469 STD RUMP { ssize_t|sys||readlinkat(int fd, const char *path, \ 986 char *buf, size_t bufsize); } 987 470 STD RUMP { int|sys||symlinkat(const char *path1, int fd, \ 988 const char *path2); } 989 471 STD RUMP { int|sys||unlinkat(int fd, const char *path, \ 990 int flag); } 991 472 STD RUMP { int|sys||futimens(int fd, \ 992 const struct timespec *tptr); } 993 473 STD RUMP { int|sys||__quotactl(const char *path, \ 994 struct quotactl_args *args); } 995 474 NOERR { int|sys||posix_spawn(pid_t *pid, const char *path, \ 996 const struct posix_spawn_file_actions *file_actions, \ 997 const struct posix_spawnattr *attrp, \ 998 char *const *argv, char *const *envp); } 999 475 STD RUMP { int|sys||recvmmsg(int s, struct mmsghdr *mmsg, \ 1000 unsigned int vlen, unsigned int flags, \ 1001 struct timespec *timeout); } 1002 476 STD RUMP { int|sys||sendmmsg(int s, struct mmsghdr *mmsg, \ 1003 unsigned int vlen, unsigned int flags); } 1004 477 NOERR RUMP { int|sys||clock_nanosleep(clockid_t clock_id, \ 1005 int flags, const struct timespec *rqtp, \ 1006 struct timespec *rmtp); } 1007 478 STD { int|sys|60|_lwp_park(clockid_t clock_id, int flags, \ 1008 struct timespec *ts, lwpid_t unpark, \ 1009 const void *hint, const void *unparkhint); } 1010 479 NOERR RUMP { int|sys||posix_fallocate(int fd, int PAD, off_t pos, \ 1011 off_t len); } 1012 480 STD RUMP { int|sys||fdiscard(int fd, int PAD, off_t pos, \ 1013 off_t len); } 1014 481 STD { int|sys||wait6(idtype_t idtype, id_t id, \ 1015 int *status, int options, struct wrusage *wru, \ 1016 siginfo_t *info); } 1017 482 STD RUMP { int|sys||clock_getcpuclockid2(idtype_t idtype, \ 1018 id_t id, clockid_t *clock_id); } 1019 483 STD RUMP { int|sys|90|getvfsstat(struct statvfs *buf, \ 1020 size_t bufsize, int flags); } 1021 484 STD RUMP { int|sys|90|statvfs1(const char *path, \ 1022 struct statvfs *buf, int flags); } 1023 485 STD RUMP { int|sys|90|fstatvfs1(int fd, \ 1024 struct statvfs *buf, int flags); } 1025 486 STD RUMP { int|sys|90|fhstatvfs1(const void *fhp, \ 1026 size_t fh_size, struct statvfs *buf, int flags); } 1027 487 STD { int|sys||__acl_get_link(const char *path, \ 1028 acl_type_t type, struct acl *aclp); } 1029 488 STD { int|sys||__acl_set_link(const char *path, \ 1030 acl_type_t type, struct acl *aclp); } 1031 489 STD { int|sys||__acl_delete_link(const char *path, \ 1032 acl_type_t type); } 1033 490 STD { int|sys||__acl_aclcheck_link(const char *path, \ 1034 acl_type_t type, struct acl *aclp); } 1035 491 STD { int|sys||__acl_get_file(const char *path, \ 1036 acl_type_t type, struct acl *aclp); } 1037 492 STD { int|sys||__acl_set_file(const char *path, \ 1038 acl_type_t type, struct acl *aclp); } 1039 493 STD { int|sys||__acl_get_fd(int filedes, acl_type_t type, \ 1040 struct acl *aclp); } 1041 494 STD { int|sys||__acl_set_fd(int filedes, acl_type_t type, \ 1042 struct acl *aclp); } 1043 495 STD { int|sys||__acl_delete_file(const char *path, \ 1044 acl_type_t type); } 1045 496 STD { int|sys||__acl_delete_fd(int filedes, \ 1046 acl_type_t type); } 1047 497 STD { int|sys||__acl_aclcheck_file(const char *path, \ 1048 acl_type_t type, struct acl *aclp); } 1049 498 STD { int|sys||__acl_aclcheck_fd(int filedes, \ 1050 acl_type_t type, struct acl *aclp); } 1051 499 STD RUMP { long|sys||lpathconf(const char *path, int name); }
Cache object: 72e31b234524b9091618e07b3657916f
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]