syscalls.master revision 1.42
1 $NetBSD: syscalls.master,v 1.42 2019/01/27 02:08:39 pgoyette 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 #endif 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/signal.h> 49 #include <sys/mount.h> 50 #include <sys/sched.h> 51 #include <sys/syscallargs.h> 52 #include <compat/aoutm68k/aoutm68k_syscallargs.h> 53 54 %% 55 56 ; Reserved/unimplemented system calls in the range 0-150 inclusive 57 ; are reserved for use in future Berkeley releases. 58 ; Additional system calls implemented in vendor and other 59 ; redistributions should be placed in the reserved range at the end 60 ; of the current calls. 61 62 0 NOARGS INDIR { int|sys||syscall(int code, \ 63 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); } 64 1 NOARGS { void|sys||exit(int rval); } 65 2 NOARGS { int|sys||fork(void); } 66 3 NOARGS { ssize_t|sys||read(int fd, void *buf, size_t nbyte); } 67 4 NOARGS { ssize_t|sys||write(int fd, const void *buf, \ 68 size_t nbyte); } 69 5 NOARGS { int|sys||open(const char *path, int flags, \ 70 ... mode_t mode); } 71 6 NOARGS { int|sys||close(int fd); } 72 7 NOARGS { int|compat_50_sys||wait4(int pid, int *status, \ 73 int options, struct rusage50 *rusage); } 74 #if defined(COMPAT_43) || !defined(_KERNEL) 75 8 NOARGS { int|compat_43_sys||creat(const char *path, \ 76 mode_t mode); } ocreat 77 #else 78 8 EXCL compat_43_sys_creat 79 #endif 80 9 NOARGS { int|sys||link(const char *path, const char *link); } 81 10 NOARGS { int|sys||unlink(const char *path); } 82 11 OBSOL execv 83 12 NOARGS { int|sys||chdir(const char *path); } 84 13 NOARGS { int|sys||fchdir(int fd); } 85 14 NOARGS { int|compat_50_sys||mknod(const char *path, \ 86 mode_t mode, dev_t dev); } 87 15 NOARGS { int|sys||chmod(const char *path, mode_t mode); } 88 16 NOARGS { int|sys||chown(const char *path, uid_t uid, \ 89 gid_t gid); } 90 17 NOARGS { int|sys||obreak(char *nsize); } break 91 #if defined(COMPAT_20) || !defined(_KERNEL) 92 18 NOARGS { int|compat_20_sys||getfsstat(struct statfs12 *buf, \ 93 long bufsize, int flags); } 94 #else 95 18 EXCL compat_20_sys_getfsstat 96 #endif 97 #if defined(COMPAT_43) || !defined(_KERNEL) 98 19 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \ 99 int whence); } olseek 100 #else 101 19 EXCL compat_43_sys_lseek 102 #endif 103 20 NOARGS { pid_t|sys||getpid(void); } 104 21 NOARGS { int|compat_40_sys||mount(const char *type, \ 105 const char *path, int flags, void *data); } 106 22 NOARGS { int|sys||unmount(const char *path, int flags); } 107 23 NOARGS { int|sys||setuid(uid_t uid); } 108 24 NOARGS { uid_t|sys||getuid(void); } 109 25 NOARGS { uid_t|sys||geteuid(void); } 110 26 NOARGS { int|sys||ptrace(int req, pid_t pid, void *addr, \ 111 int data); } 112 27 NOARGS { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \ 113 int flags); } 114 28 NOARGS { ssize_t|sys||sendmsg(int s, \ 115 const struct msghdr *msg, int flags); } 116 29 NOARGS { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \ 117 int flags, struct sockaddr *from, \ 118 unsigned int *fromlenaddr); } 119 30 NOARGS { int|sys||accept(int s, struct sockaddr *name, \ 120 unsigned int *anamelen); } 121 31 NOARGS { int|sys||getpeername(int fdes, struct sockaddr *asa, \ 122 unsigned int *alen); } 123 32 NOARGS { int|sys||getsockname(int fdes, struct sockaddr *asa, \ 124 unsigned int *alen); } 125 33 NOARGS { int|sys||access(const char *path, int flags); } 126 34 NOARGS { int|sys||chflags(const char *path, u_long flags); } 127 35 NOARGS { int|sys||fchflags(int fd, u_long flags); } 128 36 NOARGS { void|sys||sync(void); } 129 37 NOARGS { int|sys||kill(int pid, int signum); } 130 #if defined(COMPAT_43) || !defined(_KERNEL) 131 38 STD { int|aoutm68k_compat_43_sys||stat(const char *path, \ 132 struct aoutm68k_stat43 *ub); } stat43 133 #else 134 38 EXCL aoutm68k_compat_43_sys_stat 135 #endif 136 39 NOARGS { pid_t|sys||getppid(void); } 137 #if defined(COMPAT_43) || !defined(_KERNEL) 138 40 STD { int|aoutm68k_compat_43_sys||lstat(const char *path, \ 139 struct aoutm68k_stat43 *ub); } lstat43 140 #else 141 40 EXCL aoutm68k_compat_43_sys_lstat 142 #endif 143 41 NOARGS { int|sys||dup(int fd); } 144 42 NOARGS { int|sys||pipe(void); } 145 43 NOARGS { gid_t|sys||getegid(void); } 146 44 NOARGS { int|sys||profil(void *samples, size_t size, \ 147 u_long offset, u_int scale); } 148 #if defined(KTRACE) || !defined(_KERNEL) 149 45 NOARGS { int|sys||ktrace(const char *fname, int ops, \ 150 int facs, int pid); } 151 #else 152 45 EXCL ktrace 153 #endif 154 #if defined(COMPAT_13) || !defined(_KERNEL) 155 46 NOARGS { int|compat_13_sys||sigaction(int signum, \ 156 const struct sigaction13 *nsa, \ 157 struct sigaction13 *osa); } sigaction13 158 #else 159 46 EXCL compat_13_sys_sigaction 160 #endif 161 47 NOARGS { gid_t|sys||getgid(void); } 162 #if defined(COMPAT_13) || !defined(_KERNEL) 163 48 NOARGS { int|compat_13_sys||sigprocmask(int how, \ 164 int mask); } sigprocmask13 165 #else 166 48 EXCL compat_13_sys_sigprocmask 167 #endif 168 49 NOARGS { int|sys||__getlogin(char *namebuf, size_t namelen); } 169 50 NOARGS { int|sys||__setlogin(const char *namebuf); } 170 51 NOARGS { int|sys||acct(const char *path); } 171 #if defined(COMPAT_13) || !defined(_KERNEL) 172 52 NOARGS { int|compat_13_sys||sigpending(void); } sigpending13 173 53 NOARGS { int|compat_13_sys||sigaltstack( \ 174 const struct sigaltstack13 *nss, \ 175 struct sigaltstack13 *oss); } sigaltstack13 176 #else 177 52 EXCL compat_13_sys_sigpending 178 53 EXCL compat_13_sys_sigaltstack 179 #endif 180 54 NOARGS { int|sys||ioctl(int fd, u_long com, ... void *data); } 181 #if defined(COMPAT_12) || !defined(_KERNEL) 182 55 NOARGS { int|compat_12_sys||reboot(int opt); } oreboot 183 #else 184 55 EXCL compat_12_sys_reboot 185 #endif 186 56 NOARGS { int|sys||revoke(const char *path); } 187 57 NOARGS { int|sys||symlink(const char *path, \ 188 const char *link); } 189 58 NOARGS { int|sys||readlink(const char *path, \ 190 char *buf, size_t count); } 191 59 NOARGS { int|sys||execve(const char *path, \ 192 char * const *argp, char * const *envp); } 193 60 NOARGS { mode_t|sys||umask(mode_t newmask); } 194 61 NOARGS { int|sys||chroot(const char *path); } 195 #if defined(COMPAT_43) || !defined(_KERNEL) 196 62 STD { int|aoutm68k_compat_43_sys||fstat(int fd, \ 197 struct aoutm68k_stat43 *sb); } fstat43 198 63 NOARGS { int|compat_43_sys||getkerninfo(int op, char *where, \ 199 int *size, int arg); } ogetkerninfo 200 64 NOARGS { int|compat_43_sys||getpagesize(void); } ogetpagesize 201 #else 202 62 EXCL aoutm68k_compat_43_sys_fstat 203 63 EXCL compat_43_sys_getkerninfo 204 64 EXCL compat_43_sys_getpagesize 205 #endif 206 #if defined(COMPAT_12) || !defined(_KERNEL) 207 65 NOARGS { int|compat_12_sys||msync(void *addr, size_t len); } 208 #else 209 65 EXCL compat_12_sys_msync 210 #endif 211 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)? 212 66 NOARGS { int|sys||vfork(void); } 213 67 OBSOL vread 214 68 OBSOL vwrite 215 69 OBSOL sbrk 216 70 OBSOL sstk 217 #if defined(COMPAT_43) || !defined(_KERNEL) 218 71 NOARGS { int|compat_43_sys||mmap(void *addr, size_t len, \ 219 int prot, int flags, int fd, long pos); } ommap 220 #else 221 71 EXCL compat_43_sys_mmap 222 #endif 223 72 NOARGS { int|sys||ovadvise(int anom); } vadvise 224 73 NOARGS { int|sys||munmap(void *addr, size_t len); } 225 74 NOARGS { int|sys||mprotect(void *addr, size_t len, \ 226 int prot); } 227 75 NOARGS { int|sys||madvise(void *addr, size_t len, \ 228 int behav); } 229 76 OBSOL vhangup 230 77 OBSOL vlimit 231 78 NOARGS { int|sys||mincore(void *addr, size_t len, \ 232 char *vec); } 233 79 NOARGS { int|sys||getgroups(int gidsetsize, \ 234 gid_t *gidset); } 235 80 NOARGS { int|sys||setgroups(int gidsetsize, \ 236 const gid_t *gidset); } 237 81 NOARGS { int|sys||getpgrp(void); } 238 82 NOARGS { int|sys||setpgid(int pid, int pgid); } 239 83 NOARGS { int|compat_50_sys||setitimer(int which, \ 240 const struct itimerval50 *itv, \ 241 struct itimerval50 *oitv); } 242 #if defined(COMPAT_43) || !defined(_KERNEL) 243 84 NOARGS { int|compat_43_sys||wait(void); } owait 244 #else 245 84 EXCL compat_43_sys_wait 246 #endif 247 #if defined(COMPAT_12) || !defined(_KERNEL) 248 85 NOARGS { int|compat_12_sys||swapon(const char *name); } oswapon 249 #else 250 85 EXCL compat_12_sys_swapon 251 #endif 252 86 NOARGS { int|compat_50_sys||getitimer(int which, \ 253 struct itimerval50 *itv); } 254 #if defined(COMPAT_43) || !defined(_KERNEL) 255 87 NOARGS { int|compat_43_sys||gethostname(char *hostname, \ 256 u_int len); } ogethostname 257 88 NOARGS { int|compat_43_sys||sethostname(char *hostname, \ 258 u_int len); } osethostname 259 89 NOARGS { int|compat_43_sys||getdtablesize(void); } \ 260 ogetdtablesize 261 #else 262 87 EXCL compat_43_sys_gethostname 263 88 EXCL compat_43_sys_sethostname 264 89 EXCL compat_43_sys_getdtablesize 265 #endif 266 90 NOARGS { int|sys||dup2(int from, int to); } 267 91 UNIMPL getdopt 268 92 NOARGS { int|sys||fcntl(int fd, int cmd, ... void *arg); } 269 93 NOARGS { int|compat_50_sys||select(int nd, fd_set *in, \ 270 fd_set *ou, fd_set *ex, struct timeval50 *tv); } 271 94 UNIMPL setdopt 272 95 NOARGS { int|sys||fsync(int fd); } 273 96 NOARGS { int|sys||setpriority(int which, int who, int prio); } 274 #if defined(COMPAT_30) || !defined(_KERNEL) 275 97 NOARGS { int|compat_30_sys||socket(int domain, int type, int protocol); } 276 #else 277 97 EXCL compat_30_sys_socket 278 #endif 279 98 NOARGS { int|sys||connect(int s, const struct sockaddr *name, \ 280 int namelen); } 281 #if defined(COMPAT_43) || !defined(_KERNEL) 282 99 NOARGS { int|compat_43_sys||accept(int s, void *name, \ 283 int *anamelen); } oaccept 284 #else 285 99 EXCL compat_43_sys_accept 286 #endif 287 100 NOARGS { int|sys||getpriority(int which, int who); } 288 #if defined(COMPAT_43) || !defined(_KERNEL) 289 101 NOARGS { int|compat_43_sys||send(int s, void *buf, int len, \ 290 int flags); } osend 291 102 NOARGS { int|compat_43_sys||recv(int s, void *buf, int len, \ 292 int flags); } orecv 293 #else 294 101 EXCL compat_43_sys_send 295 102 EXCL compat_43_sys_recv 296 #endif 297 #if defined(COMPAT_13) || !defined(_KERNEL) 298 103 NOARGS { int|compat_13_sys||sigreturn( \ 299 struct sigcontext13 *sigcntxp); } sigreturn13 300 #else 301 103 EXCL compat_13_sys_sigreturn 302 #endif 303 104 NOARGS { int|sys||bind(int s, const struct sockaddr *name, \ 304 int namelen); } 305 105 NOARGS { int|sys||setsockopt(int s, int level, int name, \ 306 const void *val, int valsize); } 307 106 NOARGS { int|sys||listen(int s, int backlog); } 308 107 OBSOL vtimes 309 #if defined(COMPAT_43) || !defined(_KERNEL) 310 108 NOARGS { int|compat_43_sys||sigvec(int signum, \ 311 struct sigvec *nsv, struct sigvec *osv); } osigvec 312 109 NOARGS { int|compat_43_sys||sigblock(int mask); } osigblock 313 110 NOARGS { int|compat_43_sys||sigsetmask(int mask); } osigsetmask 314 #else 315 108 EXCL compat_43_sys_sigvec 316 109 EXCL compat_43_sys_sigblock 317 110 EXCL compat_43_sys_sigsetmask 318 #endif 319 #if defined(COMPAT_13) || !defined(_KERNEL) 320 111 NOARGS { int|compat_13_sys||sigsuspend(int mask); } sigsuspend13 321 #else 322 111 EXCL compat_13_sys_sigsuspend 323 #endif 324 #if defined(COMPAT_43) || !defined(_KERNEL) 325 112 NOARGS { int|compat_43_sys||sigstack(struct sigstack *nss, \ 326 struct sigstack *oss); } osigstack 327 113 NOARGS { int|compat_43_sys||recvmsg(int s, \ 328 struct omsghdr *msg, int flags); } orecvmsg 329 114 NOARGS { int|compat_43_sys||sendmsg(int s, void *msg, \ 330 int flags); } osendmsg 331 #else 332 112 EXCL compat_43_sys_sigstack 333 113 EXCL compat_43_sys_recvmesg 334 114 EXCL compat_43_sys_sendmesg 335 #endif 336 115 OBSOL vtrace 337 116 NOARGS { int|compat_50_sys||gettimeofday(struct timeval50 *tp, \ 338 struct timezone *tzp); } 339 117 NOARGS { int|compat_50_sys||getrusage(int who, \ 340 struct rusage50 *rusage); } 341 118 NOARGS { int|sys||getsockopt(int s, int level, int name, \ 342 void *val, int *avalsize); } 343 119 OBSOL resuba 344 120 NOARGS { ssize_t|sys||readv(int fd, \ 345 const struct iovec *iovp, int iovcnt); } 346 121 NOARGS { ssize_t|sys||writev(int fd, \ 347 const struct iovec *iovp, int iovcnt); } 348 122 NOARGS { int|compat_50_sys||settimeofday( \ 349 const struct timeval50 *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, void *buf, \ 355 size_t len, int flags, void *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|compat_50_sys||utimes(const char *path, \ 383 const struct timeval50 *tptr); } 384 139 OBSOL 4.2 sigreturn 385 140 NOARGS { int|compat_50_sys||adjtime( \ 386 const struct timeval50 *delta, \ 387 struct timeval50 *olddelta); } 388 #if defined(COMPAT_43) || !defined(_KERNEL) 389 141 NOARGS { int|compat_43_sys||getpeername(int fdes, void *asa, \ 390 int *alen); } ogetpeername 391 142 NOARGS { int32_t|compat_43_sys||gethostid(void); } ogethostid 392 143 NOARGS { int|compat_43_sys||sethostid(int32_t hostid); } \ 393 osethostid 394 144 NOARGS { int|compat_43_sys||getrlimit(int which, \ 395 struct orlimit *rlp); } ogetrlimit 396 145 NOARGS { int|compat_43_sys||setrlimit(int which, \ 397 const struct orlimit *rlp); } osetrlimit 398 146 NOARGS { int|compat_43_sys||killpg(int pgid, int signum); } \ 399 okillpg 400 #else 401 141 EXCL compat_43_sys_getpeername 402 142 EXCL compat_43_sys_gethostid 403 143 EXCL compat_43_sys_sethostid 404 144 EXCL compat_43_sys_getrlimit 405 145 EXCL compat_43_sys_setrlimit 406 146 EXCL compat_43_sys_killpg 407 #endif 408 147 NOARGS { int|sys||setsid(void); } 409 148 NOARGS { int|compat_50_sys||quotactl(const char *path, \ 410 int cmd, int uid, void *arg); } 411 #if defined(COMPAT_43) || !defined(_KERNEL) 412 149 NOARGS { int|compat_43_sys||quota(void); } oquota 413 150 NOARGS { int|compat_43_sys||getsockname(int fdec, void *asa, \ 414 int *alen); } ogetsockname 415 #else 416 149 EXCL compat_43_sys_quota 417 150 EXCL compat_43_sys_getsockname 418 #endif 419 420 ; Syscalls 151-180 inclusive are reserved for vendor-specific 421 ; system calls. (This includes various calls added for compatibity 422 ; with other Unix variants.) 423 ; Some of these calls are now supported by BSD... 424 151 UNIMPL 425 152 UNIMPL 426 153 UNIMPL 427 154 UNIMPL 428 155 EXCL nfssvc 429 #if defined(COMPAT_43) || !defined(_KERNEL) 430 156 NOARGS { int|compat_43_sys||getdirentries(int fd, char *buf, \ 431 u_int count, long *basep); } ogetdirentries 432 #else 433 156 EXCL compat_43_sys_getdirentries 434 #endif 435 #if defined(COMPAT_20) || !defined(_KERNEL) 436 157 NOARGS { int|compat_20_sys||statfs(const char *path, \ 437 struct statfs12 *buf); } 438 #else 439 157 EXCL compat_20_sys_statfs 440 #endif 441 #if defined(COMPAT_20) || !defined(_KERNEL) 442 158 NOARGS { int|compat_20_sys||fstatfs(int fd, \ 443 struct statfs12 *buf); } 444 #else 445 158 EXCL compat_20_sys_statfs 446 #endif 447 159 UNIMPL 448 160 UNIMPL 449 #if defined(COMPAT_30) || !defined(_KERNEL) 450 161 NOARGS { int|compat_30_sys||getfh(const char *fname, \ 451 struct compat_30_fhandle *fhp); } 452 #else 453 161 EXCL compat_30_sys_getfh 454 #endif 455 #if defined(COMPAT_09) || !defined(_KERNEL) 456 162 NOARGS { int|compat_09_sys||getdomainname(char *domainname, \ 457 int len); } ogetdomainname 458 163 NOARGS { int|compat_09_sys||setdomainname(char *domainname, \ 459 int len); } osetdomainname 460 164 NOARGS { int|compat_09_sys||uname(struct outsname *name); } \ 461 ouname 462 #else 463 162 EXCL compat_09_sys_getdomainname 464 163 EXCL compat_09_sys_setdomainname 465 164 EXCL compat_09_sys_uname 466 #endif 467 165 NOARGS { int|sys||sysarch(int op, void *parms); } 468 166 UNIMPL 469 167 UNIMPL 470 168 UNIMPL 471 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 472 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 473 169 NOARGS { int|compat_10_sys||semsys(int which, int a2, int a3, \ 474 int a4, int a5); } osemsys 475 #else 476 169 EXCL 1.0 semsys 477 #endif 478 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 479 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 480 170 NOARGS { int|compat_10_sys||msgsys(int which, int a2, int a3, \ 481 int a4, int a5, int a6); } omsgsys 482 #else 483 170 EXCL 1.0 msgsys 484 #endif 485 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 486 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 487 171 NOARGS { int|compat_10_sys||shmsys(int which, int a2, int a3, \ 488 int a4); } oshmsys 489 #else 490 171 EXCL 1.0 shmsys 491 #endif 492 172 UNIMPL 493 173 NOARGS { ssize_t|sys||pread(int fd, void *buf, \ 494 size_t nbyte, int pad, off_t offset); } 495 174 NOARGS { ssize_t|sys||pwrite(int fd, const void *buf, \ 496 size_t nbyte, int pad, off_t offset); } 497 175 UNIMPL sys_ntp_gettime 498 #if defined(NTP) || !defined(_KERNEL) 499 176 NOARGS { int|sys||ntp_adjtime(struct timex *tp); } 500 #else 501 176 EXCL ntp_adjtime 502 #endif 503 177 UNIMPL 504 178 UNIMPL 505 179 UNIMPL 506 180 UNIMPL 507 508 ; Syscalls 180-199 are used by/reserved for BSD 509 181 NOARGS { int|sys||setgid(gid_t gid); } 510 182 NOARGS { int|sys||setegid(gid_t egid); } 511 183 NOARGS { int|sys||seteuid(uid_t euid); } 512 184 EXCL lfs_bmapv 513 185 EXCL lfs_markv 514 186 EXCL lfs_segclean 515 187 EXCL lfs_segwait 516 #if defined(COMPAT_12) || !defined(_KERNEL) 517 188 STD { int|aoutm68k_compat_12_sys||stat(const char *path, \ 518 struct aoutm68k_stat12 *ub); } stat12 519 189 STD { int|aoutm68k_compat_12_sys||fstat(int fd, \ 520 struct aoutm68k_stat12 *sb); } fstat12 521 190 STD { int|aoutm68k_compat_12_sys||lstat(const char *path, \ 522 struct aoutm68k_stat12 *ub); } lstat12 523 #else 524 188 EXCL aoutm68k_compat_12_sys_stat 525 189 EXCL aoutm68k_compat_12_sys_fstat 526 190 EXCL aoutm68k_compat_12_sys_lstat 527 #endif 528 191 NOARGS { long|sys||pathconf(const char *path, int name); } 529 192 NOARGS { long|sys||fpathconf(int fd, int name); } 530 193 UNIMPL 531 194 NOARGS { int|sys||getrlimit(int which, \ 532 struct rlimit *rlp); } 533 195 NOARGS { int|sys||setrlimit(int which, \ 534 const struct rlimit *rlp); } 535 #if defined(COMPAT_12) || !defined(_KERNEL) 536 196 NOARGS { int|compat_12_sys||getdirentries(int fd, char *buf, \ 537 u_int count, long *basep); } 538 #else 539 196 EXCL compat_12_sys_getdirentries 540 #endif 541 197 NOARGS { void *|sys||mmap(void *addr, size_t len, int prot, \ 542 int flags, int fd, long pad, off_t pos); } 543 198 NOARGS INDIR { quad_t|sys||__syscall(quad_t code, \ 544 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); } 545 199 NOARGS { off_t|sys||lseek(int fd, int pad, off_t offset, \ 546 int whence); } 547 200 NOARGS { int|sys||truncate(const char *path, int pad, \ 548 off_t length); } 549 201 NOARGS { int|sys||ftruncate(int fd, int pad, off_t length); } 550 202 NOARGS { int|sys||__sysctl(int *name, u_int namelen, \ 551 void *old, size_t *oldlenp, void *new, \ 552 size_t newlen); } 553 203 NOARGS { int|sys||mlock(const void *addr, size_t len); } 554 204 NOARGS { int|sys||munlock(const void *addr, size_t len); } 555 205 NOARGS { int|sys||undelete(const char *path); } 556 206 NOARGS { int|compat_50_sys||futimes(int fd, \ 557 const struct timeval50 *tptr); } 558 207 NOARGS { pid_t|sys||getpgid(pid_t pid); } 559 208 NOARGS { int|sys||reboot(int opt, char *bootstr); } 560 209 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \ 561 int timeout); } 562 210 UNIMPL 563 211 UNIMPL 564 212 UNIMPL 565 213 UNIMPL 566 214 UNIMPL 567 215 UNIMPL 568 216 UNIMPL 569 217 UNIMPL 570 218 UNIMPL 571 219 UNIMPL 572 ; System calls 220-300 are reserved for use by NetBSD 573 #if defined(SYSVSEM) || !defined(_KERNEL) 574 #if defined(COMPAT_14) || !defined(_KERNEL) 575 220 NOARGS { int|compat_14_sys||__semctl(int semid, \ 576 int semnum, int cmd, union __semun *arg); } 577 #else 578 220 EXCL compat_14_semctl 579 #endif 580 221 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 581 222 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ 582 size_t nsops); } 583 223 NOARGS { int|sys||semconfig(int flag); } 584 #else 585 220 EXCL compat_14_semctl 586 221 EXCL semget 587 222 EXCL semop 588 223 EXCL semconfig 589 #endif 590 #if defined(SYSVMSG) || !defined(_KERNEL) 591 #if defined(COMPAT_14) || !defined(_KERNEL) 592 224 NOARGS { int|compat_14_sys||msgctl(int msqid, int cmd, \ 593 struct msqid_ds14 *buf); } 594 #else 595 224 EXCL compat_14_sys_msgctl 596 #endif 597 225 NOARGS { int|sys||msgget(key_t key, int msgflg); } 598 226 NOARGS { int|sys||msgsnd(int msqid, const void *msgp, \ 599 size_t msgsz, int msgflg); } 600 227 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 601 size_t msgsz, long msgtyp, int msgflg); } 602 #else 603 224 EXCL compat_14_msgctl 604 225 EXCL msgget 605 226 EXCL msgsnd 606 227 EXCL msgrcv 607 #endif 608 #if defined(SYSVSHM) || !defined(_KERNEL) 609 228 NOARGS { void *|sys||shmat(int shmid, const void *shmaddr, \ 610 int shmflg); } 611 #if defined(COMPAT_14) || !defined(_KERNEL) 612 229 NOARGS { int|compat_14_sys||shmctl(int shmid, int cmd, \ 613 struct shmid_ds14 *buf); } 614 #else 615 229 EXCL compat_14_sys_shmctl 616 #endif 617 230 NOARGS { int|sys||shmdt(const void *shmaddr); } 618 231 NOARGS { int|sys||shmget(key_t key, size_t size, int shmflg); } 619 #else 620 228 EXCL shmat 621 229 EXCL compat_14_shmctl 622 230 EXCL shmdt 623 231 EXCL shmget 624 #endif 625 232 NOARGS { int|compat_50_sys||clock_gettime(clockid_t clock_id, \ 626 struct timespec50 *tp); } 627 233 NOARGS { int|compat_50_sys||clock_settime(clockid_t clock_id, \ 628 const struct timespec50 *tp); } 629 234 NOARGS { int|compat_50_sys||clock_getres(clockid_t clock_id, \ 630 struct timespec50 *tp); } 631 235 UNIMPL timer_create 632 236 UNIMPL timer_delete 633 237 UNIMPL timer_settime 634 238 UNIMPL timer_gettime 635 239 UNIMPL timer_getoverrun 636 ; 637 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls 638 ; 639 240 NOARGS { int|compat_50_sys||nanosleep( \ 640 const struct timespec50 *rqtp, \ 641 struct timespec50 *rmtp); } 642 241 NOARGS { int|sys||fdatasync(int fd); } 643 242 NOARGS { int|sys||mlockall(int flags); } 644 243 NOARGS { int|sys||munlockall(void); } 645 244 UNIMPL 646 245 UNIMPL 647 246 UNIMPL 648 247 UNIMPL 649 248 UNIMPL 650 249 UNIMPL 651 250 UNIMPL 652 251 UNIMPL 653 252 UNIMPL 654 253 UNIMPL 655 254 UNIMPL 656 255 UNIMPL 657 256 UNIMPL 658 257 UNIMPL 659 258 UNIMPL 660 259 UNIMPL 661 260 UNIMPL 662 261 UNIMPL 663 262 UNIMPL 664 263 UNIMPL 665 264 UNIMPL 666 265 UNIMPL 667 266 UNIMPL 668 267 UNIMPL 669 268 UNIMPL 670 269 UNIMPL 671 270 NOARGS { int|sys||__posix_rename(const char *from, \ 672 const char *to); } 673 271 NOARGS { int|sys||swapctl(int cmd, const void *arg, int misc); } 674 #if defined(COMPAT_30) || !defined(_KERNEL) 675 272 NOARGS { int|compat_30_sys||getdents(int fd, char *buf, size_t count); } 676 #else 677 272 EXCL compat_30_sys_getdents 678 #endif 679 273 NOARGS { int|sys||minherit(void *addr, size_t len, \ 680 int inherit); } 681 274 NOARGS { int|sys||lchmod(const char *path, mode_t mode); } 682 275 NOARGS { int|sys||lchown(const char *path, uid_t uid, \ 683 gid_t gid); } 684 276 NOARGS { int|compat_50_sys||lutimes(const char *path, \ 685 const struct timeval50 *tptr); } 686 277 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 687 278 STD { int|aoutm68k_sys|13|stat(const char *path, \ 688 struct aoutm68k_stat *ub); } 689 279 STD { int|aoutm68k_sys|13|fstat(int fd, \ 690 struct aoutm68k_stat *sb); } 691 280 STD { int|aoutm68k_sys|13|lstat(const char *path, \ 692 struct aoutm68k_stat *ub); } 693 281 NOARGS { int|sys|14|sigaltstack( \ 694 const struct sigaltstack *nss, \ 695 struct sigaltstack *oss); } 696 282 NOARGS { int|sys|14|vfork(void); } 697 283 NOARGS { int|sys||__posix_chown(const char *path, uid_t uid, \ 698 gid_t gid); } 699 284 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \ 700 gid_t gid); } 701 285 NOARGS { int|sys||__posix_lchown(const char *path, uid_t uid, \ 702 gid_t gid); } 703 286 NOARGS { pid_t|sys||getsid(pid_t pid); } 704 287 UNIMPL 705 #if defined(KTRACE) || !defined(_KERNEL) 706 288 NOARGS { int|sys||fktrace(const int fd, int ops, \ 707 int facs, int pid); } 708 #else 709 288 EXCL ktrace 710 #endif 711 289 NOARGS { ssize_t|sys||preadv(int fd, \ 712 const struct iovec *iovp, int iovcnt, \ 713 int pad, off_t offset); } 714 290 NOARGS { ssize_t|sys||pwritev(int fd, \ 715 const struct iovec *iovp, int iovcnt, \ 716 int pad, off_t offset); } 717 #if defined(COMPAT_16) || !defined(_KERNEL) 718 291 NOARGS { int|compat_16_sys|14|sigaction(int signum, \ 719 const struct sigaction *nsa, \ 720 struct sigaction *osa); } 721 #else 722 291 EXCL compat_16_sys___sigaction14 723 #endif 724 292 NOARGS { int|sys|14|sigpending(sigset_t *set); } 725 293 NOARGS { int|sys|14|sigprocmask(int how, \ 726 const sigset_t *set, \ 727 sigset_t *oset); } 728 294 NOARGS { int|sys|14|sigsuspend(const sigset_t *set); } 729 #if defined(COMPAT_16) || !defined(_KERNEL) 730 295 NOARGS { int|compat_16_sys|14|sigreturn(\ 731 struct sigcontext *sigcntxp); } 732 #else 733 295 EXCL compat_16_sys___sigreturn14 734 #endif 735 296 NOARGS { int|sys||__getcwd(char *bufp, size_t length); } 736 297 NOARGS { int|sys||fchroot(int fd); } 737 #if defined(COMPAT_30) || ! defined(_KERNEL) 738 298 NOARGS { int|compat_30_sys||fhopen(const \ 739 struct compat_30_fhandle *fhp, int flags); } 740 #else 741 298 EXCL compat_30_sys_fhopen 742 #endif 743 299 STD { int|aoutm68k_sys||fhstat(const struct \ 744 compat_30_fhandle *fhp, \ 745 struct aoutm68k_stat *sb); } 746 #if defined(COMPAT_20) || !defined(_KERNEL) 747 300 NOARGS { int|compat_20_sys||fhstatfs(const struct \ 748 compat_30-fhandle *fhp, \ 749 struct statfs12 *buf); } 750 #else 751 300 EXCL compat_20_sys_fhstatfs 752 #endif 753 #if defined(SYSVSEM) || !defined(_KERNEL) 754 301 NOARGS { int|compat_50_sys|13|__semctl(int semid, \ 755 int semnum, int cmd, ... union __semun *arg); } 756 #else 757 301 EXCL ____semctl13 758 #endif 759 #if defined(SYSVMSG) || !defined(_KERNEL) 760 302 NOARGS { int|compat_50_sys|13|msgctl(int msqid, int cmd, \ 761 struct msqid_ds *buf); } 762 #else 763 302 EXCL __msgctl13 764 #endif 765 #if defined(SYSVSHM) || !defined(_KERNEL) 766 303 NOARGS { int|compat_50_sys|13|shmctl(int shmid, int cmd, \ 767 struct shmid_ds *buf); } 768 #else 769 303 EXCL __shmctl13 770 #endif 771 304 NOARGS { int|sys||lchflags(const char *path, u_long flags); } 772 305 NOARGS { int|sys||issetugid(void); } 773 306 NOARGS { int|sys||getcontext(struct __ucontext *ucp); } 774 307 NOARGS { int|sys||setcontext(const struct __ucontext *ucp); } 775
Indexes created Thu Oct 02 01:09:59 GMT 2025