syscalls.master revision 1.17
1 $NetBSD: syscalls.master,v 1.17 2006/06/26 21:23:57 mrg 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 ; types: 14 ; STD always included 15 ; OBSOL obsolete, not included in system 16 ; UNIMPL unimplemented, not included in system 17 ; EXCL implemented, but not included in system 18 ; NODEF included, but don't define the syscall number 19 ; NOARGS included, but don't define the syscall args structure 20 ; INDIR included, but don't define the syscall args structure, 21 ; and allow it to be "really" varargs. 22 ; 23 ; The compat options are defined in the syscalls.conf file, and the 24 ; compat option name is prefixed to the syscall name. Other than 25 ; that, they're like NODEF (for 'compat' options), or STD (for 26 ; 'libcompat' options). 27 ; 28 ; The type-dependent arguments are as follows: 29 ; For STD, NODEF, NOARGS, and compat syscalls: 30 ; { pseudo-proto } [alias] 31 ; For other syscalls: 32 ; [comment] 33 ; 34 ; #ifdef's, etc. may be included, and are copied to the output files. 35 ; #include's are copied to the syscall names and switch definition files only. 36 37 #if defined(_KERNEL_OPT) 38 #include "opt_ktrace.h" 39 #include "opt_nfsserver.h" 40 #include "opt_ntp.h" 41 #include "opt_compat_netbsd.h" 42 #include "opt_sysv.h" 43 #include "opt_compat_43.h" 44 45 #include "fs_lfs.h" 46 #include "fs_nfs.h" 47 #endif 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/signal.h> 52 #include <sys/mount.h> 53 #include <sys/sa.h> 54 #include <sys/syscallargs.h> 55 #include <compat/aoutm68k/aoutm68k_syscallargs.h> 56 57 %% 58 59 ; Reserved/unimplemented system calls in the range 0-150 inclusive 60 ; are reserved for use in future Berkeley releases. 61 ; Additional system calls implemented in vendor and other 62 ; redistributions should be placed in the reserved range at the end 63 ; of the current calls. 64 65 0 INDIR { int sys_syscall(int number, ...); } 66 1 NOARGS { void sys_exit(int rval); } 67 2 NOARGS { int sys_fork(void); } 68 3 NOARGS { ssize_t sys_read(int fd, void *buf, size_t nbyte); } 69 4 NOARGS { ssize_t sys_write(int fd, const void *buf, \ 70 size_t nbyte); } 71 5 NOARGS { int sys_open(const char *path, int flags, \ 72 ... mode_t mode); } 73 6 NOARGS { int sys_close(int fd); } 74 7 NOARGS { int sys_wait4(int pid, int *status, int options, \ 75 struct rusage *rusage); } 76 #if defined(COMPAT_43) || !defined(_KERNEL) 77 8 NOARGS { int compat_43_sys_creat(const char *path, \ 78 mode_t mode); } ocreat 79 #else 80 8 EXCL compat_43_sys_creat 81 #endif 82 9 NOARGS { int sys_link(const char *path, const char *link); } 83 10 NOARGS { int sys_unlink(const char *path); } 84 11 OBSOL execv 85 12 NOARGS { int sys_chdir(const char *path); } 86 13 NOARGS { int sys_fchdir(int fd); } 87 14 NOARGS { int sys_mknod(const char *path, mode_t mode, \ 88 dev_t dev); } 89 15 NOARGS { int sys_chmod(const char *path, mode_t mode); } 90 16 NOARGS { int sys_chown(const char *path, uid_t uid, \ 91 gid_t gid); } 92 17 NOARGS { int sys_obreak(char *nsize); } break 93 #if defined(COMPAT_20) || !defined(_KERNEL) 94 18 NOARGS { int compat_20_sys_getfsstat(struct statfs12 *buf, \ 95 long bufsize, int flags); } 96 #else 97 18 EXCL compat_20_sys_getfsstat 98 #endif 99 #if defined(COMPAT_43) || !defined(_KERNEL) 100 19 NOARGS { long compat_43_sys_lseek(int fd, long offset, \ 101 int whence); } olseek 102 #else 103 19 EXCL compat_43_sys_lseek 104 #endif 105 20 NOARGS MPSAFE { pid_t sys_getpid(void); } 106 21 NOARGS { int sys_mount(const char *type, \ 107 const char *path, int flags, void *data); } 108 22 NOARGS { int sys_unmount(const char *path, int flags); } 109 23 NOARGS { int sys_setuid(uid_t uid); } 110 24 NOARGS { uid_t sys_getuid(void); } 111 25 NOARGS { uid_t sys_geteuid(void); } 112 26 NOARGS { int sys_ptrace(int req, pid_t pid, caddr_t addr, \ 113 int data); } 114 27 NOARGS { ssize_t sys_recvmsg(int s, struct msghdr *msg, \ 115 int flags); } 116 28 NOARGS { ssize_t sys_sendmsg(int s, \ 117 const struct msghdr *msg, int flags); } 118 29 NOARGS { ssize_t sys_recvfrom(int s, void *buf, size_t len, \ 119 int flags, struct sockaddr *from, \ 120 unsigned int *fromlenaddr); } 121 30 NOARGS { int sys_accept(int s, struct sockaddr *name, \ 122 unsigned int *anamelen); } 123 31 NOARGS { int sys_getpeername(int fdes, struct sockaddr *asa, \ 124 unsigned int *alen); } 125 32 NOARGS { int sys_getsockname(int fdes, struct sockaddr *asa, \ 126 unsigned int *alen); } 127 33 NOARGS { int sys_access(const char *path, int flags); } 128 34 NOARGS { int sys_chflags(const char *path, u_long flags); } 129 35 NOARGS { int sys_fchflags(int fd, u_long flags); } 130 36 NOARGS { void sys_sync(void); } 131 37 NOARGS { int sys_kill(int pid, int signum); } 132 #if defined(COMPAT_43) || !defined(_KERNEL) 133 38 STD { int aoutm68k_compat_43_sys_stat(const char *path, \ 134 struct aoutm68k_stat43 *ub); } stat43 135 #else 136 38 EXCL aoutm68k_compat_43_sys_stat 137 #endif 138 39 NOARGS { pid_t sys_getppid(void); } 139 #if defined(COMPAT_43) || !defined(_KERNEL) 140 40 STD { int aoutm68k_compat_43_sys_lstat(const char *path, \ 141 struct aoutm68k_stat43 *ub); } lstat43 142 #else 143 40 EXCL aoutm68k_compat_43_sys_lstat 144 #endif 145 41 NOARGS { int sys_dup(int fd); } 146 42 NOARGS { int sys_pipe(void); } 147 43 NOARGS { gid_t sys_getegid(void); } 148 44 NOARGS { int sys_profil(caddr_t samples, size_t size, \ 149 u_long offset, u_int scale); } 150 #if defined(KTRACE) || !defined(_KERNEL) 151 45 NOARGS { int sys_ktrace(const char *fname, int ops, \ 152 int facs, int pid); } 153 #else 154 45 EXCL ktrace 155 #endif 156 #if defined(COMPAT_13) || !defined(_KERNEL) 157 46 NOARGS { int compat_13_sys_sigaction(int signum, \ 158 const struct sigaction13 *nsa, \ 159 struct sigaction13 *osa); } sigaction13 160 #else 161 46 EXCL compat_13_sys_sigaction 162 #endif 163 47 NOARGS { gid_t sys_getgid(void); } 164 #if defined(COMPAT_13) || !defined(_KERNEL) 165 48 NOARGS { int compat_13_sys_sigprocmask(int how, \ 166 int mask); } sigprocmask13 167 #else 168 48 EXCL compat_13_sys_sigprocmask 169 #endif 170 49 NOARGS { int sys___getlogin(char *namebuf, size_t namelen); } 171 50 NOARGS { int sys___setlogin(const char *namebuf); } 172 51 NOARGS { int sys_acct(const char *path); } 173 #if defined(COMPAT_13) || !defined(_KERNEL) 174 52 NOARGS { int compat_13_sys_sigpending(void); } sigpending13 175 53 NOARGS { int compat_13_sys_sigaltstack( \ 176 const struct sigaltstack13 *nss, \ 177 struct sigaltstack13 *oss); } sigaltstack13 178 #else 179 52 EXCL compat_13_sys_sigpending 180 53 EXCL compat_13_sys_sigaltstack 181 #endif 182 54 NOARGS { int sys_ioctl(int fd, u_long com, ... void *data); } 183 #if defined(COMPAT_12) || !defined(_KERNEL) 184 55 NOARGS { int compat_12_sys_reboot(int opt); } oreboot 185 #else 186 55 EXCL compat_12_sys_reboot 187 #endif 188 56 NOARGS { int sys_revoke(const char *path); } 189 57 NOARGS { int sys_symlink(const char *path, \ 190 const char *link); } 191 58 NOARGS { int sys_readlink(const char *path, \ 192 char *buf, size_t count); } 193 59 NOARGS { int sys_execve(const char *path, \ 194 char * const *argp, char * const *envp); } 195 60 NOARGS { mode_t sys_umask(mode_t newmask); } 196 61 NOARGS { int sys_chroot(const char *path); } 197 #if defined(COMPAT_43) || !defined(_KERNEL) 198 62 STD { int aoutm68k_compat_43_sys_fstat(int fd, \ 199 struct aoutm68k_stat43 *sb); } fstat43 200 63 NOARGS { int compat_43_sys_getkerninfo(int op, char *where, \ 201 int *size, int arg); } ogetkerninfo 202 64 NOARGS { int compat_43_sys_getpagesize(void); } ogetpagesize 203 #else 204 62 EXCL aoutm68k_compat_43_sys_fstat 205 63 EXCL compat_43_sys_getkerninfo 206 64 EXCL compat_43_sys_getpagesize 207 #endif 208 #if defined(COMPAT_12) || !defined(_KERNEL) 209 65 NOARGS { int compat_12_sys_msync(caddr_t addr, size_t len); } 210 #else 211 65 EXCL compat_12_sys_msync 212 #endif 213 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? 214 66 NOARGS { int sys_vfork(void); } 215 67 OBSOL vread 216 68 OBSOL vwrite 217 69 NOARGS { int sys_sbrk(intptr_t incr); } 218 70 NOARGS { int sys_sstk(int incr); } 219 #if defined(COMPAT_43) || !defined(_KERNEL) 220 71 NOARGS { int compat_43_sys_mmap(caddr_t addr, size_t len, \ 221 int prot, int flags, int fd, long pos); } ommap 222 #else 223 71 EXCL compat_43_sys_mmap 224 #endif 225 72 NOARGS { int sys_ovadvise(int anom); } vadvise 226 73 NOARGS { int sys_munmap(void *addr, size_t len); } 227 74 NOARGS { int sys_mprotect(void *addr, size_t len, \ 228 int prot); } 229 75 NOARGS { int sys_madvise(void *addr, size_t len, \ 230 int behav); } 231 76 OBSOL vhangup 232 77 OBSOL vlimit 233 78 NOARGS { int sys_mincore(caddr_t addr, size_t len, \ 234 char *vec); } 235 79 NOARGS { int sys_getgroups(int gidsetsize, \ 236 gid_t *gidset); } 237 80 NOARGS { int sys_setgroups(int gidsetsize, \ 238 const gid_t *gidset); } 239 81 NOARGS { int sys_getpgrp(void); } 240 82 NOARGS { int sys_setpgid(int pid, int pgid); } 241 83 NOARGS { int sys_setitimer(int which, \ 242 const struct itimerval *itv, \ 243 struct itimerval *oitv); } 244 #if defined(COMPAT_43) || !defined(_KERNEL) 245 84 NOARGS { int compat_43_sys_wait(void); } owait 246 #else 247 84 EXCL compat_43_sys_wait 248 #endif 249 #if defined(COMPAT_12) || !defined(_KERNEL) 250 85 NOARGS { int compat_12_sys_swapon(const char *name); } oswapon 251 #else 252 85 EXCL compat_12_sys_swapon 253 #endif 254 86 NOARGS { int sys_getitimer(int which, \ 255 struct itimerval *itv); } 256 #if defined(COMPAT_43) || !defined(_KERNEL) 257 87 NOARGS { int compat_43_sys_gethostname(char *hostname, \ 258 u_int len); } ogethostname 259 88 NOARGS { int compat_43_sys_sethostname(char *hostname, \ 260 u_int len); } osethostname 261 89 NOARGS { int compat_43_sys_getdtablesize(void); } \ 262 ogetdtablesize 263 #else 264 87 EXCL compat_43_sys_gethostname 265 88 EXCL compat_43_sys_sethostname 266 89 EXCL compat_43_sys_getdtablesize 267 #endif 268 90 NOARGS { int sys_dup2(int from, int to); } 269 91 UNIMPL getdopt 270 92 NOARGS { int sys_fcntl(int fd, int cmd, ... void *arg); } 271 93 NOARGS { int sys_select(int nd, fd_set *in, fd_set *ou, \ 272 fd_set *ex, struct timeval *tv); } 273 94 UNIMPL setdopt 274 95 NOARGS { int sys_fsync(int fd); } 275 96 NOARGS { int sys_setpriority(int which, int who, int prio); } 276 97 NOARGS { int compat_30_sys_socket(int domain, int type, int protocol); } 277 98 NOARGS { int sys_connect(int s, const struct sockaddr *name, \ 278 int namelen); } 279 #if defined(COMPAT_43) || !defined(_KERNEL) 280 99 NOARGS { int compat_43_sys_accept(int s, caddr_t name, \ 281 int *anamelen); } oaccept 282 #else 283 99 EXCL compat_43_sys_accept 284 #endif 285 100 NOARGS { int sys_getpriority(int which, int who); } 286 #if defined(COMPAT_43) || !defined(_KERNEL) 287 101 NOARGS { int compat_43_sys_send(int s, caddr_t buf, int len, \ 288 int flags); } osend 289 102 NOARGS { int compat_43_sys_recv(int s, caddr_t buf, int len, \ 290 int flags); } orecv 291 #else 292 101 EXCL compat_43_sys_send 293 102 EXCL compat_43_sys_recv 294 #endif 295 #if defined(COMPAT_13) || !defined(_KERNEL) 296 103 NOARGS { int compat_13_sys_sigreturn( \ 297 struct sigcontext13 *sigcntxp); } sigreturn13 298 #else 299 103 EXCL compat_13_sys_sigreturn 300 #endif 301 104 NOARGS { int sys_bind(int s, const struct sockaddr *name, \ 302 int namelen); } 303 105 NOARGS { int sys_setsockopt(int s, int level, int name, \ 304 const void *val, int valsize); } 305 106 NOARGS { int sys_listen(int s, int backlog); } 306 107 OBSOL vtimes 307 #if defined(COMPAT_43) || !defined(_KERNEL) 308 108 NOARGS { int compat_43_sys_sigvec(int signum, \ 309 struct sigvec *nsv, struct sigvec *osv); } osigvec 310 109 NOARGS { int compat_43_sys_sigblock(int mask); } osigblock 311 110 NOARGS { int compat_43_sys_sigsetmask(int mask); } osigsetmask 312 #else 313 108 EXCL compat_43_sys_sigvec 314 109 EXCL compat_43_sys_sigblock 315 110 EXCL compat_43_sys_sigsetmask 316 #endif 317 #if defined(COMPAT_13) || !defined(_KERNEL) 318 111 NOARGS { int compat_13_sys_sigsuspend(int mask); } sigsuspend13 319 #else 320 111 EXCL compat_13_sys_sigsuspend 321 #endif 322 #if defined(COMPAT_43) || !defined(_KERNEL) 323 112 NOARGS { int compat_43_sys_sigstack(struct sigstack *nss, \ 324 struct sigstack *oss); } osigstack 325 113 NOARGS { int compat_43_sys_recvmsg(int s, \ 326 struct omsghdr *msg, int flags); } orecvmsg 327 114 NOARGS { int compat_43_sys_sendmsg(int s, caddr_t msg, \ 328 int flags); } osendmsg 329 #else 330 112 EXCL compat_43_sys_sigstack 331 113 EXCL compat_43_sys_recvmesg 332 114 EXCL compat_43_sys_sendmesg 333 #endif 334 115 OBSOL vtrace 335 116 NOARGS { int sys_gettimeofday(struct timeval *tp, \ 336 struct timezone *tzp); } 337 117 NOARGS { int sys_getrusage(int who, struct rusage *rusage); } 338 118 NOARGS { int sys_getsockopt(int s, int level, int name, \ 339 void *val, int *avalsize); } 340 119 OBSOL resuba 341 120 NOARGS { ssize_t sys_readv(int fd, \ 342 const struct iovec *iovp, int iovcnt); } 343 121 NOARGS { ssize_t sys_writev(int fd, \ 344 const struct iovec *iovp, int iovcnt); } 345 122 NOARGS { int sys_settimeofday(const struct timeval *tv, \ 346 const struct timezone *tzp); } 347 123 NOARGS { int sys_fchown(int fd, uid_t uid, gid_t gid); } 348 124 NOARGS { int sys_fchmod(int fd, mode_t mode); } 349 #if defined(COMPAT_43) || !defined(_KERNEL) 350 125 NOARGS { int compat_43_sys_recvfrom(int s, caddr_t buf, \ 351 size_t len, int flags, caddr_t from, \ 352 int *fromlenaddr); } orecvfrom 353 #else 354 125 EXCL compat_43_sys_recvfrom 355 #endif 356 126 NOARGS { int sys_setreuid(uid_t ruid, uid_t euid); } 357 127 NOARGS { int sys_setregid(gid_t rgid, gid_t egid); } 358 128 NOARGS { int sys_rename(const char *from, const char *to); } 359 #if defined(COMPAT_43) || !defined(_KERNEL) 360 129 NOARGS { int compat_43_sys_truncate(const char *path, \ 361 long length); } otruncate 362 130 NOARGS { int compat_43_sys_ftruncate(int fd, long length); } \ 363 oftruncate 364 #else 365 129 EXCL compat_43_sys_truncate 366 130 EXCL compat_43_sys_ftruncate 367 #endif 368 131 NOARGS { int sys_flock(int fd, int how); } 369 132 NOARGS { int sys_mkfifo(const char *path, mode_t mode); } 370 133 NOARGS { ssize_t sys_sendto(int s, const void *buf, \ 371 size_t len, int flags, const struct sockaddr *to, \ 372 int tolen); } 373 134 NOARGS { int sys_shutdown(int s, int how); } 374 135 NOARGS { int sys_socketpair(int domain, int type, \ 375 int protocol, int *rsv); } 376 136 NOARGS { int sys_mkdir(const char *path, mode_t mode); } 377 137 NOARGS { int sys_rmdir(const char *path); } 378 138 NOARGS { int sys_utimes(const char *path, \ 379 const struct timeval *tptr); } 380 139 OBSOL 4.2 sigreturn 381 140 NOARGS { int sys_adjtime(const struct timeval *delta, \ 382 struct timeval *olddelta); } 383 #if defined(COMPAT_43) || !defined(_KERNEL) 384 141 NOARGS { int compat_43_sys_getpeername(int fdes, caddr_t asa, \ 385 int *alen); } ogetpeername 386 142 NOARGS { int32_t compat_43_sys_gethostid(void); } ogethostid 387 143 NOARGS { int compat_43_sys_sethostid(int32_t hostid); } \ 388 osethostid 389 144 NOARGS { int compat_43_sys_getrlimit(int which, \ 390 struct orlimit *rlp); } ogetrlimit 391 145 NOARGS { int compat_43_sys_setrlimit(int which, \ 392 const struct orlimit *rlp); } osetrlimit 393 146 NOARGS { int compat_43_sys_killpg(int pgid, int signum); } \ 394 okillpg 395 #else 396 141 EXCL compat_43_sys_getpeername 397 142 EXCL compat_43_sys_gethostid 398 143 EXCL compat_43_sys_sethostid 399 144 EXCL compat_43_sys_getrlimit 400 145 EXCL compat_43_sys_setrlimit 401 146 EXCL compat_43_sys_killpg 402 #endif 403 147 NOARGS { int sys_setsid(void); } 404 148 NOARGS { int sys_quotactl(const char *path, \ 405 int cmd, int uid, caddr_t arg); } 406 #if defined(COMPAT_43) || !defined(_KERNEL) 407 149 NOARGS { int compat_43_sys_quota(void); } oquota 408 150 NOARGS { int compat_43_sys_getsockname(int fdec, caddr_t asa, \ 409 int *alen); } ogetsockname 410 #else 411 149 EXCL compat_43_sys_quota 412 150 EXCL compat_43_sys_getsockname 413 #endif 414 415 ; Syscalls 151-180 inclusive are reserved for vendor-specific 416 ; system calls. (This includes various calls added for compatibity 417 ; with other Unix variants.) 418 ; Some of these calls are now supported by BSD... 419 151 UNIMPL 420 152 UNIMPL 421 153 UNIMPL 422 154 UNIMPL 423 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL) 424 155 NOARGS { int sys_nfssvc(int flag, void *argp); } 425 #else 426 155 EXCL nfssvc 427 #endif 428 #if defined(COMPAT_43) || !defined(_KERNEL) 429 156 NOARGS { int compat_43_sys_getdirentries(int fd, char *buf, \ 430 u_int count, long *basep); } ogetdirentries 431 #else 432 156 EXCL compat_43_sys_getdirentries 433 #endif 434 #if defined(COMPAT_20) || !defined(_KERNEL) 435 157 NOARGS { int compat_20_sys_statfs(const char *path, \ 436 struct statfs12 *buf); } 437 #else 438 157 EXCL compat_20_sys_statfs 439 #endif 440 #if defined(COMPAT_20) || !defined(_KERNEL) 441 158 NOARGS { int compat_20_sys_fstatfs(int fd, \ 442 struct statfs12 *buf); } 443 #else 444 158 EXCL compat_20_sys_statfs 445 #endif 446 159 UNIMPL 447 160 UNIMPL 448 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL) 449 161 NOARGS { int sys_getfh(const char *fname, fhandle_t *fhp); } 450 #else 451 161 EXCL getfh 452 #endif 453 #if defined(COMPAT_09) || !defined(_KERNEL) 454 162 NOARGS { int compat_09_sys_getdomainname(char *domainname, \ 455 int len); } ogetdomainname 456 163 NOARGS { int compat_09_sys_setdomainname(char *domainname, \ 457 int len); } osetdomainname 458 164 NOARGS { int compat_09_sys_uname(struct outsname *name); } \ 459 ouname 460 #else 461 162 EXCL compat_09_sys_getdomainname 462 163 EXCL compat_09_sys_setdomainname 463 164 EXCL compat_09_sys_uname 464 #endif 465 165 NOARGS { int sys_sysarch(int op, void *parms); } 466 166 UNIMPL 467 167 UNIMPL 468 168 UNIMPL 469 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 470 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 471 169 NOARGS { int compat_10_sys_semsys(int which, int a2, int a3, \ 472 int a4, int a5); } osemsys 473 #else 474 169 EXCL 1.0 semsys 475 #endif 476 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 477 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 478 170 NOARGS { int compat_10_sys_msgsys(int which, int a2, int a3, \ 479 int a4, int a5, int a6); } omsgsys 480 #else 481 170 EXCL 1.0 msgsys 482 #endif 483 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 484 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 485 171 NOARGS { int compat_10_sys_shmsys(int which, int a2, int a3, \ 486 int a4); } oshmsys 487 #else 488 171 EXCL 1.0 shmsys 489 #endif 490 172 UNIMPL 491 173 NOARGS { ssize_t sys_pread(int fd, void *buf, \ 492 size_t nbyte, int pad, off_t offset); } 493 174 NOARGS { ssize_t sys_pwrite(int fd, const void *buf, \ 494 size_t nbyte, int pad, off_t offset); } 495 175 UNIMPL { int sys_ntp_gettime(struct ntptimeval *ntvp); } 496 #if defined(NTP) || !defined(_KERNEL) 497 176 NOARGS { int sys_ntp_adjtime(struct timex *tp); } 498 #else 499 176 EXCL ntp_adjtime 500 #endif 501 177 UNIMPL 502 178 UNIMPL 503 179 UNIMPL 504 180 UNIMPL 505 506 ; Syscalls 180-199 are used by/reserved for BSD 507 181 NOARGS { int sys_setgid(gid_t gid); } 508 182 NOARGS { int sys_setegid(gid_t egid); } 509 183 NOARGS { int sys_seteuid(uid_t euid); } 510 #if defined(LFS) || !defined(_KERNEL) 511 184 NOARGS { int sys_lfs_bmapv(fsid_t *fsidp, \ 512 struct block_info *blkiov, int blkcnt); } 513 185 NOARGS { int sys_lfs_markv(fsid_t *fsidp, \ 514 struct block_info *blkiov, int blkcnt); } 515 186 NOARGS { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); } 516 187 NOARGS { int sys_lfs_segwait(fsid_t *fsidp, \ 517 struct timeval *tv); } 518 #else 519 184 EXCL lfs_bmapv 520 185 EXCL lfs_markv 521 186 EXCL lfs_segclean 522 187 EXCL lfs_segwait 523 #endif 524 #if defined(COMPAT_12) || !defined(_KERNEL) 525 188 STD { int aoutm68k_compat_12_sys_stat(const char *path, \ 526 struct aoutm68k_stat12 *ub); } stat12 527 189 STD { int aoutm68k_compat_12_sys_fstat(int fd, \ 528 struct aoutm68k_stat12 *sb); } fstat12 529 190 STD { int aoutm68k_compat_12_sys_lstat(const char *path, \ 530 struct aoutm68k_stat12 *ub); } lstat12 531 #else 532 188 EXCL aoutm68k_compat_12_sys_stat 533 189 EXCL aoutm68k_compat_12_sys_fstat 534 190 EXCL aoutm68k_compat_12_sys_lstat 535 #endif 536 191 NOARGS { long sys_pathconf(const char *path, int name); } 537 192 NOARGS { long sys_fpathconf(int fd, int name); } 538 193 UNIMPL 539 194 NOARGS { int sys_getrlimit(int which, \ 540 struct rlimit *rlp); } 541 195 NOARGS { int sys_setrlimit(int which, \ 542 const struct rlimit *rlp); } 543 #if defined(COMPAT_12) || !defined(_KERNEL) 544 196 NOARGS { int compat_12_sys_getdirentries(int fd, char *buf, \ 545 u_int count, long *basep); } 546 #else 547 196 EXCL compat_12_sys_getdirentries 548 #endif 549 197 NOARGS { void *sys_mmap(void *addr, size_t len, int prot, \ 550 int flags, int fd, long pad, off_t pos); } 551 198 INDIR { quad_t sys___syscall(quad_t num, ...); } 552 199 NOARGS { off_t sys_lseek(int fd, int pad, off_t offset, \ 553 int whence); } 554 200 NOARGS { int sys_truncate(const char *path, int pad, \ 555 off_t length); } 556 201 NOARGS { int sys_ftruncate(int fd, int pad, off_t length); } 557 202 NOARGS { int sys___sysctl(int *name, u_int namelen, \ 558 void *old, size_t *oldlenp, void *new, \ 559 size_t newlen); } 560 203 NOARGS { int sys_mlock(const void *addr, size_t len); } 561 204 NOARGS { int sys_munlock(const void *addr, size_t len); } 562 205 NOARGS { int sys_undelete(const char *path); } 563 206 NOARGS { int sys_futimes(int fd, \ 564 const struct timeval *tptr); } 565 207 NOARGS { pid_t sys_getpgid(pid_t pid); } 566 208 NOARGS { int sys_reboot(int opt, char *bootstr); } 567 209 NOARGS { int sys_poll(struct pollfd *fds, u_int nfds, \ 568 int timeout); } 569 ; 570 ; Syscalls 210-219 are reserved for dynamically loaded syscalls 571 ; 572 #if defined(LKM) || !defined(_KERNEL) 573 210 NODEF { int sys_lkmnosys(void); } 574 211 NODEF { int sys_lkmnosys(void); } 575 212 NODEF { int sys_lkmnosys(void); } 576 213 NODEF { int sys_lkmnosys(void); } 577 214 NODEF { int sys_lkmnosys(void); } 578 215 NODEF { int sys_lkmnosys(void); } 579 216 NODEF { int sys_lkmnosys(void); } 580 217 NODEF { int sys_lkmnosys(void); } 581 218 NODEF { int sys_lkmnosys(void); } 582 219 NODEF { int sys_lkmnosys(void); } 583 #else /* !LKM */ 584 210 EXCL lkmnosys 585 211 EXCL lkmnosys 586 212 EXCL lkmnosys 587 213 EXCL lkmnosys 588 214 EXCL lkmnosys 589 215 EXCL lkmnosys 590 216 EXCL lkmnosys 591 217 EXCL lkmnosys 592 218 EXCL lkmnosys 593 219 EXCL lkmnosys 594 #endif /* !LKM */ 595 ; System calls 220-300 are reserved for use by NetBSD 596 #if defined(SYSVSEM) || !defined(_KERNEL) 597 #if defined(COMPAT_14) || !defined(_KERNEL) 598 220 NOARGS { int compat_14_sys___semctl(int semid, \ 599 int semnum, int cmd, union __semun *arg); } 600 #else 601 220 EXCL compat_14_semctl 602 #endif 603 221 NOARGS { int sys_semget(key_t key, int nsems, int semflg); } 604 222 NOARGS { int sys_semop(int semid, struct sembuf *sops, \ 605 size_t nsops); } 606 223 NOARGS { int sys_semconfig(int flag); } 607 #else 608 220 EXCL compat_14_semctl 609 221 EXCL semget 610 222 EXCL semop 611 223 EXCL semconfig 612 #endif 613 #if defined(SYSVMSG) || !defined(_KERNEL) 614 #if defined(COMPAT_14) || !defined(_KERNEL) 615 224 NOARGS { int compat_14_sys_msgctl(int msqid, int cmd, \ 616 struct msqid_ds14 *buf); } 617 #else 618 224 EXCL compat_14_sys_msgctl 619 #endif 620 225 NOARGS { int sys_msgget(key_t key, int msgflg); } 621 226 NOARGS { int sys_msgsnd(int msqid, const void *msgp, \ 622 size_t msgsz, int msgflg); } 623 227 NOARGS { ssize_t sys_msgrcv(int msqid, void *msgp, \ 624 size_t msgsz, long msgtyp, int msgflg); } 625 #else 626 224 EXCL compat_14_msgctl 627 225 EXCL msgget 628 226 EXCL msgsnd 629 227 EXCL msgrcv 630 #endif 631 #if defined(SYSVSHM) || !defined(_KERNEL) 632 228 NOARGS { void *sys_shmat(int shmid, const void *shmaddr, \ 633 int shmflg); } 634 #if defined(COMPAT_14) || !defined(_KERNEL) 635 229 NOARGS { int compat_14_sys_shmctl(int shmid, int cmd, \ 636 struct shmid_ds14 *buf); } 637 #else 638 229 EXCL compat_14_sys_shmctl 639 #endif 640 230 NOARGS { int sys_shmdt(const void *shmaddr); } 641 231 NOARGS { int sys_shmget(key_t key, size_t size, int shmflg); } 642 #else 643 228 EXCL shmat 644 229 EXCL compat_14_shmctl 645 230 EXCL shmdt 646 231 EXCL shmget 647 #endif 648 232 NOARGS { int sys_clock_gettime(clockid_t clock_id, \ 649 struct timespec *tp); } 650 233 NOARGS { int sys_clock_settime(clockid_t clock_id, \ 651 const struct timespec *tp); } 652 234 NOARGS { int sys_clock_getres(clockid_t clock_id, \ 653 struct timespec *tp); } 654 235 UNIMPL timer_create 655 236 UNIMPL timer_delete 656 237 UNIMPL timer_settime 657 238 UNIMPL timer_gettime 658 239 UNIMPL timer_getoverrun 659 ; 660 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls 661 ; 662 240 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \ 663 struct timespec *rmtp); } 664 241 NOARGS { int sys_fdatasync(int fd); } 665 242 NOARGS { int sys_mlockall(int flags); } 666 243 NOARGS { int sys_munlockall(void); } 667 244 UNIMPL 668 245 UNIMPL 669 246 UNIMPL 670 247 UNIMPL 671 248 UNIMPL 672 249 UNIMPL 673 250 UNIMPL 674 251 UNIMPL 675 252 UNIMPL 676 253 UNIMPL 677 254 UNIMPL 678 255 UNIMPL 679 256 UNIMPL 680 257 UNIMPL 681 258 UNIMPL 682 259 UNIMPL 683 260 UNIMPL 684 261 UNIMPL 685 262 UNIMPL 686 263 UNIMPL 687 264 UNIMPL 688 265 UNIMPL 689 266 UNIMPL 690 267 UNIMPL 691 268 UNIMPL 692 269 UNIMPL 693 270 NOARGS { int sys___posix_rename(const char *from, \ 694 const char *to); } 695 271 NOARGS { int sys_swapctl(int cmd, const void *arg, int misc); } 696 #if defined(COMPAT_30) || !defined(_KERNEL) 697 272 NOARGS { int compat_30_sys_getdents(int fd, char *buf, size_t count); } 698 #else 699 272 EXCL compat_30_sys_getdents 700 #endif 701 273 NOARGS { int sys_minherit(void *addr, size_t len, \ 702 int inherit); } 703 274 NOARGS { int sys_lchmod(const char *path, mode_t mode); } 704 275 NOARGS { int sys_lchown(const char *path, uid_t uid, \ 705 gid_t gid); } 706 276 NOARGS { int sys_lutimes(const char *path, \ 707 const struct timeval *tptr); } 708 277 NOARGS { int sys___msync13(void *addr, size_t len, int flags); } 709 278 STD { int aoutm68k_sys___stat13(const char *path, \ 710 struct aoutm68k_stat *ub); } 711 279 STD { int aoutm68k_sys___fstat13(int fd, \ 712 struct aoutm68k_stat *sb); } 713 280 STD { int aoutm68k_sys___lstat13(const char *path, \ 714 struct aoutm68k_stat *ub); } 715 281 NOARGS { int sys___sigaltstack14( \ 716 const struct sigaltstack *nss, \ 717 struct sigaltstack *oss); } 718 282 NOARGS { int sys___vfork14(void); } 719 283 NOARGS { int sys___posix_chown(const char *path, uid_t uid, \ 720 gid_t gid); } 721 284 NOARGS { int sys___posix_fchown(int fd, uid_t uid, \ 722 gid_t gid); } 723 285 NOARGS { int sys___posix_lchown(const char *path, uid_t uid, \ 724 gid_t gid); } 725 286 NOARGS { pid_t sys_getsid(pid_t pid); } 726 287 UNIMPL 727 #if defined(KTRACE) || !defined(_KERNEL) 728 288 NOARGS { int sys_fktrace(const int fd, int ops, \ 729 int facs, int pid); } 730 #else 731 288 EXCL ktrace 732 #endif 733 289 NOARGS { ssize_t sys_preadv(int fd, \ 734 const struct iovec *iovp, int iovcnt, \ 735 int pad, off_t offset); } 736 290 NOARGS { ssize_t sys_pwritev(int fd, \ 737 const struct iovec *iovp, int iovcnt, \ 738 int pad, off_t offset); } 739 #if defined(COMPAT_16) || !defined(_KERNEL) 740 291 NOARGS { int compat_16_sys___sigaction14(int signum, \ 741 const struct sigaction *nsa, \ 742 struct sigaction *osa); } 743 #else 744 291 EXCL compat_16_sys___sigaction14 745 #endif 746 292 NOARGS { int sys___sigpending14(sigset_t *set); } 747 293 NOARGS { int sys___sigprocmask14(int how, \ 748 const sigset_t *set, \ 749 sigset_t *oset); } 750 294 NOARGS { int sys___sigsuspend14(const sigset_t *set); } 751 #if defined(COMPAT_16) || !defined(_KERNEL) 752 295 NOARGS { int compat_16_sys___sigreturn14(\ 753 struct sigcontext *sigcntxp); } 754 #else 755 295 EXCL compat_16_sys___sigreturn14 756 #endif 757 296 NOARGS { int sys___getcwd(char *bufp, size_t length); } 758 297 NOARGS { int sys_fchroot(int fd); } 759 298 NOARGS { int sys_fhopen(const fhandle_t *fhp, int flags); } 760 299 STD { int aoutm68k_sys_fhstat(const fhandle_t *fhp, \ 761 struct aoutm68k_stat *sb); } 762 #if defined(COMPAT_20) || !defined(_KERNEL) 763 300 NOARGS { int compat_20_sys_fhstatfs(const fhandle_t *fhp, \ 764 struct statfs12 *buf); } 765 #else 766 300 EXCL compat_20_sys_fhstatfs 767 #endif 768 #if defined(SYSVSEM) || !defined(_KERNEL) 769 301 NOARGS { int sys_____semctl13(int semid, int semnum, int cmd, \ 770 ... union __semun *arg); } 771 #else 772 301 EXCL ____semctl13 773 #endif 774 #if defined(SYSVMSG) || !defined(_KERNEL) 775 302 NOARGS { int sys___msgctl13(int msqid, int cmd, \ 776 struct msqid_ds *buf); } 777 #else 778 302 EXCL __msgctl13 779 #endif 780 #if defined(SYSVSHM) || !defined(_KERNEL) 781 303 NOARGS { int sys___shmctl13(int shmid, int cmd, \ 782 struct shmid_ds *buf); } 783 #else 784 303 EXCL __shmctl13 785 #endif 786 304 NOARGS { int sys_lchflags(const char *path, u_long flags); } 787 305 NOARGS { int sys_issetugid(void); } 788 306 NOARGS { int sys_getcontext(struct __ucontext *ucp); } 789 307 NOARGS { int sys_setcontext(const struct __ucontext *ucp); } 790
Indexes created Wed Oct 01 07:09:59 GMT 2025