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