syscalls.master revision 1.41
1 $NetBSD: syscalls.master,v 1.41 2018/01/06 16:41:23 kamil 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 97 NOARGS { int|compat_30_sys||socket(int domain, int type, int protocol); } 275 98 NOARGS { int|sys||connect(int s, const struct sockaddr *name, \ 276 int namelen); } 277 #if defined(COMPAT_43) || !defined(_KERNEL) 278 99 NOARGS { int|compat_43_sys||accept(int s, void *name, \ 279 int *anamelen); } oaccept 280 #else 281 99 EXCL compat_43_sys_accept 282 #endif 283 100 NOARGS { int|sys||getpriority(int which, int who); } 284 #if defined(COMPAT_43) || !defined(_KERNEL) 285 101 NOARGS { int|compat_43_sys||send(int s, void *buf, int len, \ 286 int flags); } osend 287 102 NOARGS { int|compat_43_sys||recv(int s, void *buf, int len, \ 288 int flags); } orecv 289 #else 290 101 EXCL compat_43_sys_send 291 102 EXCL compat_43_sys_recv 292 #endif 293 #if defined(COMPAT_13) || !defined(_KERNEL) 294 103 NOARGS { int|compat_13_sys||sigreturn( \ 295 struct sigcontext13 *sigcntxp); } sigreturn13 296 #else 297 103 EXCL compat_13_sys_sigreturn 298 #endif 299 104 NOARGS { int|sys||bind(int s, const struct sockaddr *name, \ 300 int namelen); } 301 105 NOARGS { int|sys||setsockopt(int s, int level, int name, \ 302 const void *val, int valsize); } 303 106 NOARGS { int|sys||listen(int s, int backlog); } 304 107 OBSOL vtimes 305 #if defined(COMPAT_43) || !defined(_KERNEL) 306 108 NOARGS { int|compat_43_sys||sigvec(int signum, \ 307 struct sigvec *nsv, struct sigvec *osv); } osigvec 308 109 NOARGS { int|compat_43_sys||sigblock(int mask); } osigblock 309 110 NOARGS { int|compat_43_sys||sigsetmask(int mask); } osigsetmask 310 #else 311 108 EXCL compat_43_sys_sigvec 312 109 EXCL compat_43_sys_sigblock 313 110 EXCL compat_43_sys_sigsetmask 314 #endif 315 #if defined(COMPAT_13) || !defined(_KERNEL) 316 111 NOARGS { int|compat_13_sys||sigsuspend(int mask); } sigsuspend13 317 #else 318 111 EXCL compat_13_sys_sigsuspend 319 #endif 320 #if defined(COMPAT_43) || !defined(_KERNEL) 321 112 NOARGS { int|compat_43_sys||sigstack(struct sigstack *nss, \ 322 struct sigstack *oss); } osigstack 323 113 NOARGS { int|compat_43_sys||recvmsg(int s, \ 324 struct omsghdr *msg, int flags); } orecvmsg 325 114 NOARGS { int|compat_43_sys||sendmsg(int s, void *msg, \ 326 int flags); } osendmsg 327 #else 328 112 EXCL compat_43_sys_sigstack 329 113 EXCL compat_43_sys_recvmesg 330 114 EXCL compat_43_sys_sendmesg 331 #endif 332 115 OBSOL vtrace 333 116 NOARGS { int|compat_50_sys||gettimeofday(struct timeval50 *tp, \ 334 struct timezone *tzp); } 335 117 NOARGS { int|compat_50_sys||getrusage(int who, \ 336 struct rusage50 *rusage); } 337 118 NOARGS { int|sys||getsockopt(int s, int level, int name, \ 338 void *val, int *avalsize); } 339 119 OBSOL resuba 340 120 NOARGS { ssize_t|sys||readv(int fd, \ 341 const struct iovec *iovp, int iovcnt); } 342 121 NOARGS { ssize_t|sys||writev(int fd, \ 343 const struct iovec *iovp, int iovcnt); } 344 122 NOARGS { int|compat_50_sys||settimeofday( \ 345 const struct timeval50 *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, void *buf, \ 351 size_t len, int flags, void *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|compat_50_sys||utimes(const char *path, \ 379 const struct timeval50 *tptr); } 380 139 OBSOL 4.2 sigreturn 381 140 NOARGS { int|compat_50_sys||adjtime( \ 382 const struct timeval50 *delta, \ 383 struct timeval50 *olddelta); } 384 #if defined(COMPAT_43) || !defined(_KERNEL) 385 141 NOARGS { int|compat_43_sys||getpeername(int fdes, void *asa, \ 386 int *alen); } ogetpeername 387 142 NOARGS { int32_t|compat_43_sys||gethostid(void); } ogethostid 388 143 NOARGS { int|compat_43_sys||sethostid(int32_t hostid); } \ 389 osethostid 390 144 NOARGS { int|compat_43_sys||getrlimit(int which, \ 391 struct orlimit *rlp); } ogetrlimit 392 145 NOARGS { int|compat_43_sys||setrlimit(int which, \ 393 const struct orlimit *rlp); } osetrlimit 394 146 NOARGS { int|compat_43_sys||killpg(int pgid, int signum); } \ 395 okillpg 396 #else 397 141 EXCL compat_43_sys_getpeername 398 142 EXCL compat_43_sys_gethostid 399 143 EXCL compat_43_sys_sethostid 400 144 EXCL compat_43_sys_getrlimit 401 145 EXCL compat_43_sys_setrlimit 402 146 EXCL compat_43_sys_killpg 403 #endif 404 147 NOARGS { int|sys||setsid(void); } 405 148 NOARGS { int|compat_50_sys||quotactl(const char *path, \ 406 int cmd, int uid, void *arg); } 407 #if defined(COMPAT_43) || !defined(_KERNEL) 408 149 NOARGS { int|compat_43_sys||quota(void); } oquota 409 150 NOARGS { int|compat_43_sys||getsockname(int fdec, void *asa, \ 410 int *alen); } ogetsockname 411 #else 412 149 EXCL compat_43_sys_quota 413 150 EXCL compat_43_sys_getsockname 414 #endif 415 416 ; Syscalls 151-180 inclusive are reserved for vendor-specific 417 ; system calls. (This includes various calls added for compatibity 418 ; with other Unix variants.) 419 ; Some of these calls are now supported by BSD... 420 151 UNIMPL 421 152 UNIMPL 422 153 UNIMPL 423 154 UNIMPL 424 155 EXCL nfssvc 425 #if defined(COMPAT_43) || !defined(_KERNEL) 426 156 NOARGS { int|compat_43_sys||getdirentries(int fd, char *buf, \ 427 u_int count, long *basep); } ogetdirentries 428 #else 429 156 EXCL compat_43_sys_getdirentries 430 #endif 431 #if defined(COMPAT_20) || !defined(_KERNEL) 432 157 NOARGS { int|compat_20_sys||statfs(const char *path, \ 433 struct statfs12 *buf); } 434 #else 435 157 EXCL compat_20_sys_statfs 436 #endif 437 #if defined(COMPAT_20) || !defined(_KERNEL) 438 158 NOARGS { int|compat_20_sys||fstatfs(int fd, \ 439 struct statfs12 *buf); } 440 #else 441 158 EXCL compat_20_sys_statfs 442 #endif 443 159 UNIMPL 444 160 UNIMPL 445 161 NOARGS { int|compat_30_sys||getfh(const char *fname, \ 446 struct compat_30_fhandle *fhp); } 447 #if defined(COMPAT_09) || !defined(_KERNEL) 448 162 NOARGS { int|compat_09_sys||getdomainname(char *domainname, \ 449 int len); } ogetdomainname 450 163 NOARGS { int|compat_09_sys||setdomainname(char *domainname, \ 451 int len); } osetdomainname 452 164 NOARGS { int|compat_09_sys||uname(struct outsname *name); } \ 453 ouname 454 #else 455 162 EXCL compat_09_sys_getdomainname 456 163 EXCL compat_09_sys_setdomainname 457 164 EXCL compat_09_sys_uname 458 #endif 459 165 NOARGS { int|sys||sysarch(int op, void *parms); } 460 166 UNIMPL 461 167 UNIMPL 462 168 UNIMPL 463 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 464 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 465 169 NOARGS { int|compat_10_sys||semsys(int which, int a2, int a3, \ 466 int a4, int a5); } osemsys 467 #else 468 169 EXCL 1.0 semsys 469 #endif 470 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 471 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 472 170 NOARGS { int|compat_10_sys||msgsys(int which, int a2, int a3, \ 473 int a4, int a5, int a6); } omsgsys 474 #else 475 170 EXCL 1.0 msgsys 476 #endif 477 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int) 478 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64) && defined(COMPAT_10) 479 171 NOARGS { int|compat_10_sys||shmsys(int which, int a2, int a3, \ 480 int a4); } oshmsys 481 #else 482 171 EXCL 1.0 shmsys 483 #endif 484 172 UNIMPL 485 173 NOARGS { ssize_t|sys||pread(int fd, void *buf, \ 486 size_t nbyte, int pad, off_t offset); } 487 174 NOARGS { ssize_t|sys||pwrite(int fd, const void *buf, \ 488 size_t nbyte, int pad, off_t offset); } 489 175 UNIMPL sys_ntp_gettime 490 #if defined(NTP) || !defined(_KERNEL) 491 176 NOARGS { int|sys||ntp_adjtime(struct timex *tp); } 492 #else 493 176 EXCL ntp_adjtime 494 #endif 495 177 UNIMPL 496 178 UNIMPL 497 179 UNIMPL 498 180 UNIMPL 499 500 ; Syscalls 180-199 are used by/reserved for BSD 501 181 NOARGS { int|sys||setgid(gid_t gid); } 502 182 NOARGS { int|sys||setegid(gid_t egid); } 503 183 NOARGS { int|sys||seteuid(uid_t euid); } 504 184 EXCL lfs_bmapv 505 185 EXCL lfs_markv 506 186 EXCL lfs_segclean 507 187 EXCL lfs_segwait 508 #if defined(COMPAT_12) || !defined(_KERNEL) 509 188 STD { int|aoutm68k_compat_12_sys||stat(const char *path, \ 510 struct aoutm68k_stat12 *ub); } stat12 511 189 STD { int|aoutm68k_compat_12_sys||fstat(int fd, \ 512 struct aoutm68k_stat12 *sb); } fstat12 513 190 STD { int|aoutm68k_compat_12_sys||lstat(const char *path, \ 514 struct aoutm68k_stat12 *ub); } lstat12 515 #else 516 188 EXCL aoutm68k_compat_12_sys_stat 517 189 EXCL aoutm68k_compat_12_sys_fstat 518 190 EXCL aoutm68k_compat_12_sys_lstat 519 #endif 520 191 NOARGS { long|sys||pathconf(const char *path, int name); } 521 192 NOARGS { long|sys||fpathconf(int fd, int name); } 522 193 UNIMPL 523 194 NOARGS { int|sys||getrlimit(int which, \ 524 struct rlimit *rlp); } 525 195 NOARGS { int|sys||setrlimit(int which, \ 526 const struct rlimit *rlp); } 527 #if defined(COMPAT_12) || !defined(_KERNEL) 528 196 NOARGS { int|compat_12_sys||getdirentries(int fd, char *buf, \ 529 u_int count, long *basep); } 530 #else 531 196 EXCL compat_12_sys_getdirentries 532 #endif 533 197 NOARGS { void *|sys||mmap(void *addr, size_t len, int prot, \ 534 int flags, int fd, long pad, off_t pos); } 535 198 NOARGS INDIR { quad_t|sys||__syscall(quad_t code, \ 536 ... register32_t args[AOUTM68K_SYS_MAXSYSARGS]); } 537 199 NOARGS { off_t|sys||lseek(int fd, int pad, off_t offset, \ 538 int whence); } 539 200 NOARGS { int|sys||truncate(const char *path, int pad, \ 540 off_t length); } 541 201 NOARGS { int|sys||ftruncate(int fd, int pad, off_t length); } 542 202 NOARGS { int|sys||__sysctl(int *name, u_int namelen, \ 543 void *old, size_t *oldlenp, void *new, \ 544 size_t newlen); } 545 203 NOARGS { int|sys||mlock(const void *addr, size_t len); } 546 204 NOARGS { int|sys||munlock(const void *addr, size_t len); } 547 205 NOARGS { int|sys||undelete(const char *path); } 548 206 NOARGS { int|compat_50_sys||futimes(int fd, \ 549 const struct timeval50 *tptr); } 550 207 NOARGS { pid_t|sys||getpgid(pid_t pid); } 551 208 NOARGS { int|sys||reboot(int opt, char *bootstr); } 552 209 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \ 553 int timeout); } 554 210 UNIMPL 555 211 UNIMPL 556 212 UNIMPL 557 213 UNIMPL 558 214 UNIMPL 559 215 UNIMPL 560 216 UNIMPL 561 217 UNIMPL 562 218 UNIMPL 563 219 UNIMPL 564 ; System calls 220-300 are reserved for use by NetBSD 565 #if defined(SYSVSEM) || !defined(_KERNEL) 566 #if defined(COMPAT_14) || !defined(_KERNEL) 567 220 NOARGS { int|compat_14_sys||__semctl(int semid, \ 568 int semnum, int cmd, union __semun *arg); } 569 #else 570 220 EXCL compat_14_semctl 571 #endif 572 221 NOARGS { int|sys||semget(key_t key, int nsems, int semflg); } 573 222 NOARGS { int|sys||semop(int semid, struct sembuf *sops, \ 574 size_t nsops); } 575 223 NOARGS { int|sys||semconfig(int flag); } 576 #else 577 220 EXCL compat_14_semctl 578 221 EXCL semget 579 222 EXCL semop 580 223 EXCL semconfig 581 #endif 582 #if defined(SYSVMSG) || !defined(_KERNEL) 583 #if defined(COMPAT_14) || !defined(_KERNEL) 584 224 NOARGS { int|compat_14_sys||msgctl(int msqid, int cmd, \ 585 struct msqid_ds14 *buf); } 586 #else 587 224 EXCL compat_14_sys_msgctl 588 #endif 589 225 NOARGS { int|sys||msgget(key_t key, int msgflg); } 590 226 NOARGS { int|sys||msgsnd(int msqid, const void *msgp, \ 591 size_t msgsz, int msgflg); } 592 227 NOARGS { ssize_t|sys||msgrcv(int msqid, void *msgp, \ 593 size_t msgsz, long msgtyp, int msgflg); } 594 #else 595 224 EXCL compat_14_msgctl 596 225 EXCL msgget 597 226 EXCL msgsnd 598 227 EXCL msgrcv 599 #endif 600 #if defined(SYSVSHM) || !defined(_KERNEL) 601 228 NOARGS { void *|sys||shmat(int shmid, const void *shmaddr, \ 602 int shmflg); } 603 #if defined(COMPAT_14) || !defined(_KERNEL) 604 229 NOARGS { int|compat_14_sys||shmctl(int shmid, int cmd, \ 605 struct shmid_ds14 *buf); } 606 #else 607 229 EXCL compat_14_sys_shmctl 608 #endif 609 230 NOARGS { int|sys||shmdt(const void *shmaddr); } 610 231 NOARGS { int|sys||shmget(key_t key, size_t size, int shmflg); } 611 #else 612 228 EXCL shmat 613 229 EXCL compat_14_shmctl 614 230 EXCL shmdt 615 231 EXCL shmget 616 #endif 617 232 NOARGS { int|compat_50_sys||clock_gettime(clockid_t clock_id, \ 618 struct timespec50 *tp); } 619 233 NOARGS { int|compat_50_sys||clock_settime(clockid_t clock_id, \ 620 const struct timespec50 *tp); } 621 234 NOARGS { int|compat_50_sys||clock_getres(clockid_t clock_id, \ 622 struct timespec50 *tp); } 623 235 UNIMPL timer_create 624 236 UNIMPL timer_delete 625 237 UNIMPL timer_settime 626 238 UNIMPL timer_gettime 627 239 UNIMPL timer_getoverrun 628 ; 629 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls 630 ; 631 240 NOARGS { int|compat_50_sys||nanosleep( \ 632 const struct timespec50 *rqtp, \ 633 struct timespec50 *rmtp); } 634 241 NOARGS { int|sys||fdatasync(int fd); } 635 242 NOARGS { int|sys||mlockall(int flags); } 636 243 NOARGS { int|sys||munlockall(void); } 637 244 UNIMPL 638 245 UNIMPL 639 246 UNIMPL 640 247 UNIMPL 641 248 UNIMPL 642 249 UNIMPL 643 250 UNIMPL 644 251 UNIMPL 645 252 UNIMPL 646 253 UNIMPL 647 254 UNIMPL 648 255 UNIMPL 649 256 UNIMPL 650 257 UNIMPL 651 258 UNIMPL 652 259 UNIMPL 653 260 UNIMPL 654 261 UNIMPL 655 262 UNIMPL 656 263 UNIMPL 657 264 UNIMPL 658 265 UNIMPL 659 266 UNIMPL 660 267 UNIMPL 661 268 UNIMPL 662 269 UNIMPL 663 270 NOARGS { int|sys||__posix_rename(const char *from, \ 664 const char *to); } 665 271 NOARGS { int|sys||swapctl(int cmd, const void *arg, int misc); } 666 #if defined(COMPAT_30) || !defined(_KERNEL) 667 272 NOARGS { int|compat_30_sys||getdents(int fd, char *buf, size_t count); } 668 #else 669 272 EXCL compat_30_sys_getdents 670 #endif 671 273 NOARGS { int|sys||minherit(void *addr, size_t len, \ 672 int inherit); } 673 274 NOARGS { int|sys||lchmod(const char *path, mode_t mode); } 674 275 NOARGS { int|sys||lchown(const char *path, uid_t uid, \ 675 gid_t gid); } 676 276 NOARGS { int|compat_50_sys||lutimes(const char *path, \ 677 const struct timeval50 *tptr); } 678 277 NOARGS { int|sys|13|msync(void *addr, size_t len, int flags); } 679 278 STD { int|aoutm68k_sys|13|stat(const char *path, \ 680 struct aoutm68k_stat *ub); } 681 279 STD { int|aoutm68k_sys|13|fstat(int fd, \ 682 struct aoutm68k_stat *sb); } 683 280 STD { int|aoutm68k_sys|13|lstat(const char *path, \ 684 struct aoutm68k_stat *ub); } 685 281 NOARGS { int|sys|14|sigaltstack( \ 686 const struct sigaltstack *nss, \ 687 struct sigaltstack *oss); } 688 282 NOARGS { int|sys|14|vfork(void); } 689 283 NOARGS { int|sys||__posix_chown(const char *path, uid_t uid, \ 690 gid_t gid); } 691 284 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \ 692 gid_t gid); } 693 285 NOARGS { int|sys||__posix_lchown(const char *path, uid_t uid, \ 694 gid_t gid); } 695 286 NOARGS { pid_t|sys||getsid(pid_t pid); } 696 287 UNIMPL 697 #if defined(KTRACE) || !defined(_KERNEL) 698 288 NOARGS { int|sys||fktrace(const int fd, int ops, \ 699 int facs, int pid); } 700 #else 701 288 EXCL ktrace 702 #endif 703 289 NOARGS { ssize_t|sys||preadv(int fd, \ 704 const struct iovec *iovp, int iovcnt, \ 705 int pad, off_t offset); } 706 290 NOARGS { ssize_t|sys||pwritev(int fd, \ 707 const struct iovec *iovp, int iovcnt, \ 708 int pad, off_t offset); } 709 #if defined(COMPAT_16) || !defined(_KERNEL) 710 291 NOARGS { int|compat_16_sys|14|sigaction(int signum, \ 711 const struct sigaction *nsa, \ 712 struct sigaction *osa); } 713 #else 714 291 EXCL compat_16_sys___sigaction14 715 #endif 716 292 NOARGS { int|sys|14|sigpending(sigset_t *set); } 717 293 NOARGS { int|sys|14|sigprocmask(int how, \ 718 const sigset_t *set, \ 719 sigset_t *oset); } 720 294 NOARGS { int|sys|14|sigsuspend(const sigset_t *set); } 721 #if defined(COMPAT_16) || !defined(_KERNEL) 722 295 NOARGS { int|compat_16_sys|14|sigreturn(\ 723 struct sigcontext *sigcntxp); } 724 #else 725 295 EXCL compat_16_sys___sigreturn14 726 #endif 727 296 NOARGS { int|sys||__getcwd(char *bufp, size_t length); } 728 297 NOARGS { int|sys||fchroot(int fd); } 729 298 NOARGS { int|compat_30_sys||fhopen(const \ 730 struct compat_30_fhandle *fhp, int flags); } 731 299 STD { int|aoutm68k_sys||fhstat(const struct \ 732 compat_30_fhandle *fhp, \ 733 struct aoutm68k_stat *sb); } 734 #if defined(COMPAT_20) || !defined(_KERNEL) 735 300 NOARGS { int|compat_20_sys||fhstatfs(const struct \ 736 compat_30-fhandle *fhp, \ 737 struct statfs12 *buf); } 738 #else 739 300 EXCL compat_20_sys_fhstatfs 740 #endif 741 #if defined(SYSVSEM) || !defined(_KERNEL) 742 301 NOARGS { int|compat_50_sys|13|__semctl(int semid, \ 743 int semnum, int cmd, ... union __semun *arg); } 744 #else 745 301 EXCL ____semctl13 746 #endif 747 #if defined(SYSVMSG) || !defined(_KERNEL) 748 302 NOARGS { int|compat_50_sys|13|msgctl(int msqid, int cmd, \ 749 struct msqid_ds *buf); } 750 #else 751 302 EXCL __msgctl13 752 #endif 753 #if defined(SYSVSHM) || !defined(_KERNEL) 754 303 NOARGS { int|compat_50_sys|13|shmctl(int shmid, int cmd, \ 755 struct shmid_ds *buf); } 756 #else 757 303 EXCL __shmctl13 758 #endif 759 304 NOARGS { int|sys||lchflags(const char *path, u_long flags); } 760 305 NOARGS { int|sys||issetugid(void); } 761 306 NOARGS { int|sys||getcontext(struct __ucontext *ucp); } 762 307 NOARGS { int|sys||setcontext(const struct __ucontext *ucp); } 763
Indexes created Tue Sep 30 17:09:57 GMT 2025