syscalls.master revision 1.26.14.3
1 $NetBSD: syscalls.master,v 1.26.14.3 2009/01/17 13:28:40 mjf 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/sched.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 NOARGS INDIR { int|sys||syscall(int code, \ 66 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); } 67 1 NOARGS { void|sys||exit(int rval); } 68 2 NOARGS { int|sys||fork(void); } 69 3 NOARGS { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } 70 4 NOARGS { ssize_t|sys||write(int fd, const void *buf, \ 71 size_t nbyte); } 72 5 NOARGS { int|sys||open(const char *path, int flags, \ 73 ... mode_t mode); } 74 6 NOARGS { int|sys||close(int fd); } 75 7 NOARGS { int|compat_50_sys||wait4(int pid, int *status, \ 76 int options, struct rusage50 *rusage); } 77 #if defined(COMPAT_43) || !defined(_KERNEL) 78 8 NOARGS { int|compat_43_sys||creat(const char *path, \ 79 mode_t mode); } ocreat 80 #else 81 8 EXCL compat_43_sys_creat 82 #endif 83 9 NOARGS { int|sys||link(const char *path, const char *link); } 84 10 NOARGS { int|sys||unlink(const char *path); } 85 11 OBSOL execv 86 12 NOARGS { int|sys||chdir(const char *path); } 87 13 NOARGS { int|sys||fchdir(int fd); } 88 14 NOARGS { int|compat_50_sys||mknod(const char *path, \ 89 mode_t mode, dev_t dev); } 90 15 NOARGS { int|sys||chmod(const char *path, mode_t mode); } 91 16 NOARGS { int|sys||chown(const char *path, uid_t uid, \ 92 gid_t gid); } 93 17 NOARGS { int|sys||obreak(char *nsize); } break 94 #if defined(COMPAT_20) || !defined(_KERNEL) 95 18 NOARGS { int|compat_20_sys||getfsstat(struct statfs12 *buf, \ 96 long bufsize, int flags); } 97 #else 98 18 EXCL compat_20_sys_getfsstat 99 #endif 100 #if defined(COMPAT_43) || !defined(_KERNEL) 101 19 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \ 102 int whence); } olseek 103 #else 104 19 EXCL compat_43_sys_lseek 105 #endif 106 20 NOARGS { pid_t|sys||getpid(void); } 107 21 NOARGS { int|compat_40_sys||mount(const char *type, \ 108 const char *path, int flags, void *data); } 109 22 NOARGS { int|sys||unmount(const char *path, int flags); } 110 23 NOARGS { int|sys||setuid(uid_t uid); } 111 24 NOARGS { uid_t|sys||getuid(void); } 112 25 NOARGS { uid_t|sys||geteuid(void); } 113 26 NOARGS { int|sys||ptrace(int req, pid_t pid, void *addr, \ 114 int data); } 115 27 NOARGS { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \ 116 int flags); } 117 28 NOARGS { ssize_t|sys||sendmsg(int s, \ 118 const struct msghdr *msg, int flags); } 119 29 NOARGS { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \ 120 int flags, struct sockaddr *from, \ 121 unsigned int *fromlenaddr); } 122 30 NOARGS { int|sys||accept(int s, struct sockaddr *name, \ 123 unsigned int *anamelen); } 124 31 NOARGS { int|sys||getpeername(int fdes, struct sockaddr *asa, \ 125 unsigned int *alen); } 126 32 NOARGS { int|sys||getsockname(int fdes, struct sockaddr *asa, \ 127 unsigned int *alen); } 128 33 NOARGS { int|sys||access(const char *path, int flags); } 129 34 NOARGS { int|sys||chflags(const char *path, u_long flags); } 130 35 NOARGS { int|sys||fchflags(int fd, u_long flags); } 131 36 NOARGS { void|sys||sync(void); } 132 37 NOARGS { int|sys||kill(int pid, int signum); } 133 #if defined(COMPAT_43) || !defined(_KERNEL) 134 38 STD { int|aoutm68k_compat_43_sys||stat(const char *path, \ 135 struct aoutm68k_stat43 *ub); } stat43 136 #else 137 38 EXCL aoutm68k_compat_43_sys_stat 138 #endif 139 39 NOARGS { pid_t|sys||getppid(void); } 140 #if defined(COMPAT_43) || !defined(_KERNEL) 141 40 STD { int|aoutm68k_compat_43_sys||lstat(const char *path, \ 142 struct aoutm68k_stat43 *ub); } lstat43 143 #else 144 40 EXCL aoutm68k_compat_43_sys_lstat 145 #endif 146 41 NOARGS { int|sys||dup(int fd); } 147 42 NOARGS { int|sys||pipe(void); } 148 43 NOARGS { gid_t|sys||getegid(void); } 149 44 NOARGS { int|sys||profil(void *samples, size_t size, \ 150 u_long offset, u_int scale); } 151 #if defined(KTRACE) || !defined(_KERNEL) 152 45 NOARGS { int|sys||ktrace(const char *fname, int ops, \ 153 int facs, int pid); } 154 #else 155 45 EXCL ktrace 156 #endif 157 #if defined(COMPAT_13) || !defined(_KERNEL) 158 46 NOARGS { int|compat_13_sys||sigaction(int signum, \ 159 const struct sigaction13 *nsa, \ 160 struct sigaction13 *osa); } sigaction13 161 #else 162 46 EXCL compat_13_sys_sigaction 163 #endif 164 47 NOARGS { gid_t|sys||getgid(void); } 165 #if defined(COMPAT_13) || !defined(_KERNEL) 166 48 NOARGS { int|compat_13_sys||sigprocmask(int how, \ 167 int mask); } sigprocmask13 168 #else 169 48 EXCL compat_13_sys_sigprocmask 170 #endif 171 49 NOARGS { int|sys||__getlogin(char *namebuf, size_t namelen); } 172 50 NOARGS { int|sys||__setlogin(const char *namebuf); } 173 51 NOARGS { int|sys||acct(const char *path); } 174 #if defined(COMPAT_13) || !defined(_KERNEL) 175 52 NOARGS { int|compat_13_sys||sigpending(void); } sigpending13 176 53 NOARGS { int|compat_13_sys||sigaltstack( \ 177 const struct sigaltstack13 *nss, \ 178 struct sigaltstack13 *oss); } sigaltstack13 179 #else 180 52 EXCL compat_13_sys_sigpending 181 53 EXCL compat_13_sys_sigaltstack 182 #endif 183 54 NOARGS { int|sys||ioctl(int fd, u_long com, ... void *data); } 184 #if defined(COMPAT_12) || !defined(_KERNEL) 185 55 NOARGS { int|compat_12_sys||reboot(int opt); } oreboot 186 #else 187 55 EXCL compat_12_sys_reboot 188 #endif 189 56 NOARGS { int|sys||revoke(const char *path); } 190 57 NOARGS { int|sys||symlink(const char *path, \ 191 const char *link); } 192 58 NOARGS { int|sys||readlink(const char *path, \ 193 char *buf, size_t count); } 194 59 NOARGS { int|sys||execve(const char *path, \ 195 char * const *argp, char * const *envp); } 196 60 NOARGS { mode_t|sys||umask(mode_t newmask); } 197 61 NOARGS { int|sys||chroot(const char *path); } 198 #if defined(COMPAT_43) || !defined(_KERNEL) 199 62 STD { int|aoutm68k_compat_43_sys||fstat(int fd, \ 200 struct aoutm68k_stat43 *sb); } fstat43 201 63 NOARGS { int|compat_43_sys||getkerninfo(int op, char *where, \ 202 int *size, int arg); } ogetkerninfo 203 64 NOARGS { int|compat_43_sys||getpagesize(void); } ogetpagesize 204 #else 205 62 EXCL aoutm68k_compat_43_sys_fstat 206 63 EXCL compat_43_sys_getkerninfo 207 64 EXCL compat_43_sys_getpagesize 208 #endif 209 #if defined(COMPAT_12) || !defined(_KERNEL) 210 65 NOARGS { int|compat_12_sys||msync(void *addr, size_t len); } 211 #else 212 65 EXCL compat_12_sys_msync 213 #endif 214 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? 215 66 NOARGS { int|sys||vfork(void); } 216 67 OBSOL vread 217 68 OBSOL vwrite 218 69 NOARGS { int|sys||sbrk(intptr_t incr); } 219 70 NOARGS { int|sys||sstk(int incr); } 220 #if defined(COMPAT_43) || !defined(_KERNEL) 221 71 NOARGS { int|compat_43_sys||mmap(void *addr, size_t len, \ 222 int prot, int flags, int fd, long pos); } ommap 223 #else 224 71 EXCL compat_43_sys_mmap 225 #endif 226 72 NOARGS { int|sys||ovadvise(int anom); } vadvise 227 73 NOARGS { int|sys||munmap(void *addr, size_t len); } 228 74 NOARGS { int|sys||mprotect(void *addr, size_t len, \ 229 int prot); } 230 75 NOARGS { int|sys||madvise(void *addr, size_t len, \ 231 int behav); } 232 76 OBSOL vhangup 233 77 OBSOL vlimit 234 78 NOARGS { int|sys||mincore(void *addr, size_t len, \ 235 char *vec); } 236 79 NOARGS { int|sys||getgroups(int gidsetsize, \ 237 gid_t *gidset); } 238 80 NOARGS { int|sys||setgroups(int gidsetsize, \ 239 const gid_t *gidset); } 240 81 NOARGS { int|sys||getpgrp(void); } 241 82 NOARGS { int|sys||setpgid(int pid, int pgid); } 242 83 NOARGS { int|compat_50_sys||setitimer(int which, \ 243 const struct itimerval50 *itv, \ 244 struct itimerval50 *oitv); } 245 #if defined(COMPAT_43) || !defined(_KERNEL) 246 84 NOARGS { int|compat_43_sys||wait(void); } owait 247 #else 248 84 EXCL compat_43_sys_wait 249 #endif 250 #if defined(COMPAT_12) || !defined(_KERNEL) 251 85 NOARGS { int|compat_12_sys||swapon(const char *name); } oswapon 252 #else 253 85 EXCL compat_12_sys_swapon 254 #endif 255 86 NOARGS { int|compat_50_sys||getitimer(int which, \ 256 struct itimerval50 *itv); } 257 #if defined(COMPAT_43) || !defined(_KERNEL) 258 87 NOARGS { int|compat_43_sys||gethostname(char *hostname, \ 259 u_int len); } ogethostname 260 88 NOARGS { int|compat_43_sys||sethostname(char *hostname, \ 261 u_int len); } osethostname 262 89 NOARGS { int|compat_43_sys||getdtablesize(void); } \ 263 ogetdtablesize 264 #else 265 87 EXCL compat_43_sys_gethostname 266 88 EXCL compat_43_sys_sethostname 267 89 EXCL compat_43_sys_getdtablesize 268 #endif 269 90 NOARGS { int|sys||dup2(int from, int to); } 270 91 UNIMPL getdopt 271 92 NOARGS { int|sys||fcntl(int fd, int cmd, ... void *arg); } 272 93 NOARGS { int|compat_50_sys||select(int nd, fd_set *in, \ 273 fd_set *ou, fd_set *ex, struct timeval50 *tv); } 274 94 UNIMPL setdopt 275 95 NOARGS { int|sys||fsync(int fd); } 276 96 NOARGS { int|sys||setpriority(int which, int who, int prio); } 277 97 NOARGS { int|compat_30_sys||socket(int domain, int type, int protocol); } 278 98 NOARGS { int|sys||connect(int s, const struct sockaddr *name, \ 279 int namelen); } 280 #if defined(COMPAT_43) || !defined(_KERNEL) 281 99 NOARGS { int|compat_43_sys||accept(int s, void *name, \ 282 int *anamelen); } oaccept 283 #else 284 99 EXCL compat_43_sys_accept 285 #endif 286 100 NOARGS { int|sys||getpriority(int which, int who); } 287 #if defined(COMPAT_43) || !defined(_KERNEL) 288 101 NOARGS { int|compat_43_sys||send(int s, void *buf, int len, \ 289 int flags); } osend 290 102 NOARGS { int|compat_43_sys||recv(int s, void *buf, int len, \ 291 int flags); } orecv 292 #else 293 101 EXCL compat_43_sys_send 294 102 EXCL compat_43_sys_recv 295 #endif 296 #if defined(COMPAT_13) || !defined(_KERNEL) 297 103 NOARGS { int|compat_13_sys||sigreturn( \ 298 struct sigcontext13 *sigcntxp); } sigreturn13 299 #else 300 103 EXCL compat_13_sys_sigreturn 301 #endif 302 104 NOARGS { int|sys||bind(int s, const struct sockaddr *name, \ 303 int namelen); } 304 105 NOARGS { int|sys||setsockopt(int s, int level, int name, \ 305 const void *val, int valsize); } 306 106 NOARGS { int|sys||listen(int s, int backlog); } 307 107 OBSOL vtimes 308 #if defined(COMPAT_43) || !defined(_KERNEL) 309 108 NOARGS { int|compat_43_sys||sigvec(int signum, \ 310 struct sigvec *nsv, struct sigvec *osv); } osigvec 311 109 NOARGS { int|compat_43_sys||sigblock(int mask); } osigblock 312 110 NOARGS { int|compat_43_sys||sigsetmask(int mask); } osigsetmask 313 #else 314 108 EXCL compat_43_sys_sigvec 315 109 EXCL compat_43_sys_sigblock 316 110 EXCL compat_43_sys_sigsetmask 317 #endif 318 #if defined(COMPAT_13) || !defined(_KERNEL) 319 111 NOARGS { int|compat_13_sys||sigsuspend(int mask); } sigsuspend13 320 #else 321 111 EXCL compat_13_sys_sigsuspend 322 #endif 323 #if defined(COMPAT_43) || !defined(_KERNEL) 324 112 NOARGS { int|compat_43_sys||sigstack(struct sigstack *nss, \ 325 struct sigstack *oss); } osigstack 326 113 NOARGS { int|compat_43_sys||recvmsg(int s, \ 327 struct omsghdr *msg, int flags); } orecvmsg 328 114 NOARGS { int|compat_43_sys||sendmsg(int s, void *msg, \ 329 int flags); } osendmsg 330 #else 331 112 EXCL compat_43_sys_sigstack 332 113 EXCL compat_43_sys_recvmesg 333 114 EXCL compat_43_sys_sendmesg 334 #endif 335 115 OBSOL vtrace 336 116 NOARGS { int|compat_50_sys||gettimeofday(struct timeval50 *tp, \ 337 struct timezone *tzp); } 338 117 NOARGS { int|compat_50_sys||getrusage(int who, \ 339 struct rusage50 *rusage); } 340 118 NOARGS { int|sys||getsockopt(int s, int level, int name, \ 341 void *val, int *avalsize); } 342 119 OBSOL resuba 343 120 NOARGS { ssize_t|sys||readv(int fd, \ 344 const struct iovec *iovp, int iovcnt); } 345 121 NOARGS { ssize_t|sys||writev(int fd, \ 346 const struct iovec *iovp, int iovcnt); } 347 122 NOARGS { int|compat_50_sys||settimeofday( \ 348 const struct timeval50 *tv, \ 349 const struct timezone *tzp); } 350 123 NOARGS { int|sys||fchown(int fd, uid_t uid, gid_t gid); } 351 124 NOARGS { int|sys||fchmod(int fd, mode_t mode); } 352 #if defined(COMPAT_43) || !defined(_KERNEL) 353 125 NOARGS { int|compat_43_sys||recvfrom(int s, void *buf, \ 354 size_t len, int flags, void *from, \ 355 int *fromlenaddr); } orecvfrom 356 #else 357 125 EXCL compat_43_sys_recvfrom 358 #endif 359 126 NOARGS { int|sys||setreuid(uid_t ruid, uid_t euid); } 360 127 NOARGS { int|sys||setregid(gid_t rgid, gid_t egid); } 361 128 NOARGS { int|sys||rename(const char *from, const char *to); } 362 #if defined(COMPAT_43) || !defined(_KERNEL) 363 129 NOARGS { int|compat_43_sys||truncate(const char *path, \ 364 long length); } otruncate 365 130 NOARGS { int|compat_43_sys||ftruncate(int fd, long length); } \ 366 oftruncate 367 #else 368 129 EXCL compat_43_sys_truncate 369 130 EXCL compat_43_sys_ftruncate 370 #endif 371 131 NOARGS { int|sys||flock(int fd, int how); } 372 132 NOARGS { int|sys||mkfifo(const char *path, mode_t mode); } 373 133 NOARGS { ssize_t|sys||sendto(int s, const void *buf, \ 374 size_t len, int flags, const struct sockaddr *to, \ 375 int tolen); } 376 134 NOARGS { int|sys||shutdown(int s, int how); } 377 135 NOARGS { int|sys||socketpair(int domain, int type, \ 378 int protocol, int *rsv); } 379 136 NOARGS { int|sys||mkdir(const char *path, mode_t mode); } 380 137 NOARGS { int|sys||rmdir(const char *path); } 381 138 NOARGS { int|compat_50_sys||utimes(const char *path, \ 382 const struct timeval50 *tptr); } 383 139 OBSOL 4.2 sigreturn 384 140 NOARGS { int|compat_50_sys||adjtime( \ 385 const struct timeval50 *delta, \ 386 struct timeval50 *olddelta); } 387 #if defined(COMPAT_43) || !defined(_KERNEL) 388 141 NOARGS { int|compat_43_sys||getpeername(int fdes, void *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, void *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, void *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(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 sys_ntp_gettime 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|compat_50_sys||lfs_segwait(fsid_t *fsidp, \ 518 struct timeval50 *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 NOARGS INDIR { quad_t|sys||__syscall(quad_t code, \ 553 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); } 554 199 NOARGS { off_t|sys||lseek(int fd, int pad, off_t offset, \ 555 int whence); } 556 200 NOARGS { int|sys||truncate(const char *path, int pad, \ 557 off_t length); } 558 201 NOARGS { int|sys||ftruncate(int fd, int pad, off_t length); } 559 202 NOARGS { int|sys||__sysctl(int *name, u_int namelen, \ 560 void *old, size_t *oldlenp, void *new, \ 561 size_t newlen); } 562 203 NOARGS { int|sys||mlock(const void *addr, size_t len); } 563 204 NOARGS { int|sys||munlock(const void *addr, size_t len); } 564 205 NOARGS { int|sys||undelete(const char *path); } 565 206 NOARGS { int|compat_50_sys||futimes(int fd, \ 566 const struct timeval50 *tptr); } 567 207 NOARGS { pid_t|sys||getpgid(pid_t pid); } 568 208 NOARGS { int|sys||reboot(int opt, char *bootstr); } 569 209 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \ 570 int timeout); } 571 210 UNIMPL 572 211 UNIMPL 573 212 UNIMPL 574 213 UNIMPL 575 214 UNIMPL 576 215 UNIMPL 577 216 UNIMPL 578 217 UNIMPL 579 218 UNIMPL 580 219 UNIMPL 581 ; System calls 220-300 are reserved for use by NetBSD 582 #if defined(SYSVSEM) || !defined(_KERNEL) 583 #if defined(COMPAT_14) || !defined(_KERNEL) 584 220 NOARGS { int|compat_14_sys||__semctl(int semid, \ 585 int semnum, int cmd, union __semun *arg); } 586 #else 587 220 EXCL compat_14_semctl 588 #endif 589 221 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 590 222 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ 591 size_t nsops); } 592 223 NOARGS { int|sys||semconfig(int flag); } 593 #else 594 220 EXCL compat_14_semctl 595 221 EXCL semget 596 222 EXCL semop 597 223 EXCL semconfig 598 #endif 599 #if defined(SYSVMSG) || !defined(_KERNEL) 600 #if defined(COMPAT_14) || !defined(_KERNEL) 601 224 NOARGS { int|compat_14_sys||msgctl(int msqid, int cmd, \ 602 struct msqid_ds14 *buf); } 603 #else 604 224 EXCL compat_14_sys_msgctl 605 #endif 606 225 NOARGS { int|sys||msgget(key_t key, int msgflg); } 607 226 NOARGS { int|sys||msgsnd(int msqid, const void *msgp, \ 608 size_t msgsz, int msgflg); } 609 227 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 610 size_t msgsz, long msgtyp, int msgflg); } 611 #else 612 224 EXCL compat_14_msgctl 613 225 EXCL msgget 614 226 EXCL msgsnd 615 227 EXCL msgrcv 616 #endif 617 #if defined(SYSVSHM) || !defined(_KERNEL) 618 228 NOARGS { void *|sys||shmat(int shmid, const void *shmaddr, \ 619 int shmflg); } 620 #if defined(COMPAT_14) || !defined(_KERNEL) 621 229 NOARGS { int|compat_14_sys||shmctl(int shmid, int cmd, \ 622 struct shmid_ds14 *buf); } 623 #else 624 229 EXCL compat_14_sys_shmctl 625 #endif 626 230 NOARGS { int|sys||shmdt(const void *shmaddr); } 627 231 NOARGS { int|sys||shmget(key_t key, size_t size, int shmflg); } 628 #else 629 228 EXCL shmat 630 229 EXCL compat_14_shmctl 631 230 EXCL shmdt 632 231 EXCL shmget 633 #endif 634 232 NOARGS { int|compat_50_sys||clock_gettime(clockid_t clock_id, \ 635 struct timespec50 *tp); } 636 233 NOARGS { int|compat_50_sys||clock_settime(clockid_t clock_id, \ 637 const struct timespec50 *tp); } 638 234 NOARGS { int|compat_50_sys||clock_getres(clockid_t clock_id, \ 639 struct timespec50 *tp); } 640 235 UNIMPL timer_create 641 236 UNIMPL timer_delete 642 237 UNIMPL timer_settime 643 238 UNIMPL timer_gettime 644 239 UNIMPL timer_getoverrun 645 ; 646 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls 647 ; 648 240 NOARGS { int|compat_50_sys||nanosleep( \ 649 const struct timespec50 *rqtp, \ 650 struct timespec50 *rmtp); } 651 241 NOARGS { int|sys||fdatasync(int fd); } 652 242 NOARGS { int|sys||mlockall(int flags); } 653 243 NOARGS { int|sys||munlockall(void); } 654 244 UNIMPL 655 245 UNIMPL 656 246 UNIMPL 657 247 UNIMPL 658 248 UNIMPL 659 249 UNIMPL 660 250 UNIMPL 661 251 UNIMPL 662 252 UNIMPL 663 253 UNIMPL 664 254 UNIMPL 665 255 UNIMPL 666 256 UNIMPL 667 257 UNIMPL 668 258 UNIMPL 669 259 UNIMPL 670 260 UNIMPL 671 261 UNIMPL 672 262 UNIMPL 673 263 UNIMPL 674 264 UNIMPL 675 265 UNIMPL 676 266 UNIMPL 677 267 UNIMPL 678 268 UNIMPL 679 269 UNIMPL 680 270 NOARGS { int|sys||__posix_rename(const char *from, \ 681 const char *to); } 682 271 NOARGS { int|sys||swapctl(int cmd, const void *arg, int misc); } 683 #if defined(COMPAT_30) || !defined(_KERNEL) 684 272 NOARGS { int|compat_30_sys||getdents(int fd, char *buf, size_t count); } 685 #else 686 272 EXCL compat_30_sys_getdents 687 #endif 688 273 NOARGS { int|sys||minherit(void *addr, size_t len, \ 689 int inherit); } 690 274 NOARGS { int|sys||lchmod(const char *path, mode_t mode); } 691 275 NOARGS { int|sys||lchown(const char *path, uid_t uid, \ 692 gid_t gid); } 693 276 NOARGS { int|compat_50_sys||lutimes(const char *path, \ 694 const struct timeval50 *tptr); } 695 277 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 696 278 STD { int|aoutm68k_sys|13|stat(const char *path, \ 697 struct aoutm68k_stat *ub); } 698 279 STD { int|aoutm68k_sys|13|fstat(int fd, \ 699 struct aoutm68k_stat *sb); } 700 280 STD { int|aoutm68k_sys|13|lstat(const char *path, \ 701 struct aoutm68k_stat *ub); } 702 281 NOARGS { int|sys|14|sigaltstack( \ 703 const struct sigaltstack *nss, \ 704 struct sigaltstack *oss); } 705 282 NOARGS { int|sys|14|vfork(void); } 706 283 NOARGS { int|sys||__posix_chown(const char *path, uid_t uid, \ 707 gid_t gid); } 708 284 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \ 709 gid_t gid); } 710 285 NOARGS { int|sys||__posix_lchown(const char *path, uid_t uid, \ 711 gid_t gid); } 712 286 NOARGS { pid_t|sys||getsid(pid_t pid); } 713 287 UNIMPL 714 #if defined(KTRACE) || !defined(_KERNEL) 715 288 NOARGS { int|sys||fktrace(const int fd, int ops, \ 716 int facs, int pid); } 717 #else 718 288 EXCL ktrace 719 #endif 720 289 NOARGS { ssize_t|sys||preadv(int fd, \ 721 const struct iovec *iovp, int iovcnt, \ 722 int pad, off_t offset); } 723 290 NOARGS { ssize_t|sys||pwritev(int fd, \ 724 const struct iovec *iovp, int iovcnt, \ 725 int pad, off_t offset); } 726 #if defined(COMPAT_16) || !defined(_KERNEL) 727 291 NOARGS { int|compat_16_sys|14|sigaction(int signum, \ 728 const struct sigaction *nsa, \ 729 struct sigaction *osa); } 730 #else 731 291 EXCL compat_16_sys___sigaction14 732 #endif 733 292 NOARGS { int|sys|14|sigpending(sigset_t *set); } 734 293 NOARGS { int|sys|14|sigprocmask(int how, \ 735 const sigset_t *set, \ 736 sigset_t *oset); } 737 294 NOARGS { int|sys|14|sigsuspend(const sigset_t *set); } 738 #if defined(COMPAT_16) || !defined(_KERNEL) 739 295 NOARGS { int|compat_16_sys|14|sigreturn(\ 740 struct sigcontext *sigcntxp); } 741 #else 742 295 EXCL compat_16_sys___sigreturn14 743 #endif 744 296 NOARGS { int|sys||__getcwd(char *bufp, size_t length); } 745 297 NOARGS { int|sys||fchroot(int fd); } 746 298 NOARGS { int|compat_30_sys||fhopen(const \ 747 struct compat_30_fhandle *fhp, int flags); } 748 299 STD { int|aoutm68k_sys||fhstat(const struct \ 749 compat_30_fhandle *fhp, \ 750 struct aoutm68k_stat *sb); } 751 #if defined(COMPAT_20) || !defined(_KERNEL) 752 300 NOARGS { int|compat_20_sys||fhstatfs(const struct \ 753 compat_30-fhandle *fhp, \ 754 struct statfs12 *buf); } 755 #else 756 300 EXCL compat_20_sys_fhstatfs 757 #endif 758 #if defined(SYSVSEM) || !defined(_KERNEL) 759 301 NOARGS { int|compat_50_sys|13|__semctl(int semid, \ 760 int semnum, int cmd, ... union __semun *arg); } 761 #else 762 301 EXCL ____semctl13 763 #endif 764 #if defined(SYSVMSG) || !defined(_KERNEL) 765 302 NOARGS { int|compat_50_sys|13|msgctl(int msqid, int cmd, \ 766 struct msqid_ds *buf); } 767 #else 768 302 EXCL __msgctl13 769 #endif 770 #if defined(SYSVSHM) || !defined(_KERNEL) 771 303 NOARGS { int|compat_50_sys|13|shmctl(int shmid, int cmd, \ 772 struct shmid_ds *buf); } 773 #else 774 303 EXCL __shmctl13 775 #endif 776 304 NOARGS { int|sys||lchflags(const char *path, u_long flags); } 777 305 NOARGS { int|sys||issetugid(void); } 778 306 NOARGS { int|sys||getcontext(struct __ucontext *ucp); } 779 307 NOARGS { int|sys||setcontext(const struct __ucontext *ucp); } 780
Indexes created Wed Oct 22 13:09:56 GMT 2025