diff options
Diffstat (limited to 'sys/compat/netbsd/syscalls.master')
| -rw-r--r-- | sys/compat/netbsd/syscalls.master | 622 |
1 files changed, 622 insertions, 0 deletions
diff --git a/sys/compat/netbsd/syscalls.master b/sys/compat/netbsd/syscalls.master new file mode 100644 index 00000000000..8ffacbb99e8 --- /dev/null +++ b/sys/compat/netbsd/syscalls.master @@ -0,0 +1,622 @@ +; $OpenBSD: syscalls.master,v 1.1 1999/09/12 14:15:17 kstailey Exp $ + +; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 + +; OpenBSD COMPAT_FREEBSD system call name/number "master" file. +; (See syscalls.conf to see what it is processed into.) +; +; Fields: number type [type-dependent ...] +; number system call number, must be in order +; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of +; the compatibility options defined in syscalls.conf. +; +; types: +; STD always included +; OBSOL obsolete, not included in system +; UNIMPL unimplemented, not included in system +; NODEF included, but don't define the syscall number +; NOARGS included, but don't define the syscall args structure +; INDIR included, but don't define the syscall args structure, +; and allow it to be "really" varargs. +; +; The compat options are defined in the syscalls.conf file, and the +; compat option name is prefixed to the syscall name. Other than +; that, they're like NODEF (for 'compat' options), or STD (for +; 'libcompat' options). +; +; The type-dependent arguments are as follows: +; For STD, NODEF, NOARGS, and compat syscalls: +; { pseudo-proto } [alias] +; For other syscalls: +; [comment] +; +; #ifdef's, etc. may be included, and are copied to the output files. +; #include's are copied to the syscall switch definition file only. + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/signal.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <sys/poll.h> + +#include <compat/netbsd/netbsd_types.h> +#include <compat/netbsd/netbsd_stat.h> +#include <compat/netbsd/netbsd_syscallargs.h> + +#include <machine/netbsd_machdep.h> + +; Reserved/unimplemented system calls in the range 0-150 inclusive +; are reserved for use in future Berkeley releases. +; Additional system calls implemented in vendor and other +; redistributions should be placed in the reserved range at the end +; of the current calls. + +0 INDIR { int sys_syscall(int number, ...); } +1 NOARGS { void sys_exit(int rval); } +2 NOARGS { int sys_fork(void); } +3 NOARGS { ssize_t sys_read(int fd, void *buf, size_t nbyte); } +4 NOARGS { ssize_t sys_write(int fd, const void *buf, \ + size_t nbyte); } +; XXX int mode vs. mode_t mode +5 NOARGS { int sys_open(const char *path, \ + int flags, ... int mode); } +6 NOARGS { int sys_close(int fd); } +7 NOARGS { int sys_wait4(int pid, int *status, int options, \ + struct rusage *rusage); } +; XXX int mode vs. mode_t mode +8 NOARGS { int compat_43_sys_creat(char *path, \ + int mode); } ocreat +9 NOARGS { int sys_link(const char *path, const char *link); } +10 NOARGS { int sys_unlink(const char *path); } +11 OBSOL execv +12 NOARGS { int sys_chdir(const char *path); } +13 NOARGS { int sys_fchdir(int fd); } +; XXX int mode vs. mode_t mode +14 NOARGS { int sys_mknod(const char *path, int mode, \ + dev_t dev); } +; XXX int mode vs. mode_t mode +15 NOARGS { int sys_chmod(const char *path, int mode); } +16 NOARGS { int sys_chown(const char *path, uid_t uid, \ + gid_t gid); } +17 NOARGS { int sys_obreak(char *nsize); } break +18 NOARGS { int sys_ogetfsstat(struct statfs *buf, long bufsize, \ + int flags); } +19 NOARGS { long sys_lseek(int fd, long offset, int whence); } \ + olseek +20 NOARGS { pid_t sys_getpid(void); } +21 NOARGS { int sys_mount(const char *type, const char *path, \ + int flags, void *data); } +22 NOARGS { int sys_unmount(const char *path, int flags); } +23 NOARGS { int sys_setuid(uid_t uid); } +24 NOARGS { uid_t sys_getuid(void); } +25 NOARGS { uid_t sys_geteuid(void); } +26 NOARGS { int sys_ptrace(int req, pid_t pid, caddr_t addr, \ + int data); } +27 NOARGS { ssize_t sys_recvmsg(int s, struct msghdr *msg, \ + int flags); } +28 NOARGS { ssize_t sys_sendmsg(int s, \ + const struct msghdr *msg, int flags); } +; XXX unsigned int *fromlenaddr vs. socklen_t *fromlenaddr +29 NOARGS { ssize_t sys_recvfrom(int s, void *buf, size_t len, \ + int flags, struct sockaddr *from, \ + socklen_t *fromlenaddr); } +; XXX unsigned int *fromlenaddr vs. socklen_t *fromlenaddr +30 NOARGS { int sys_accept(int s, struct sockaddr *name, \ + socklen_t *anamelen); } +; XXX unsigned int *alen vs. int *alen +31 NOARGS { int sys_getpeername(int fdes, struct sockaddr *asa, \ + int *alen); } +32 NOARGS { int sys_getsockname(int fdes, struct sockaddr *asa, \ + socklen_t *alen); } +33 NOARGS { int sys_access(const char *path, int flags); } +; XXX u_long flags vs. u_int flags +34 NOARGS { int sys_chflags(const char *path, u_int flags); } +; XXX u_long flags vs. u_int flags +35 NOARGS { int sys_fchflags(int fd, u_int flags); } +36 NOARGS { void sys_sync(void); } +37 NOARGS { int sys_kill(int pid, int signum); } +; XXX struct stat43 *ub vs. struct ostat *ub +38 NOARGS { int sys_stat(const char *path, struct ostat *ub); } \ + ostat +39 NOARGS { pid_t sys_getppid(void); } +; XXX struct stat43 *ub vs. struct ostat *ub +40 NOARGS { int sys_lstat(char *path, \ + struct ostat *ub); } olstat +41 NOARGS { int sys_dup(int fd); } +42 NOARGS { int sys_opipe(void); } +43 NOARGS { gid_t sys_getegid(void); } +44 NOARGS { int sys_profil(caddr_t samples, size_t size, \ + u_long offset, u_int scale); } +#ifdef KTRACE +45 NOARGS { int sys_ktrace(const char *fname, int ops, \ + int facs, pid_t pid); } +#else +45 UNIMPL ktrace +#endif +46 NOARGS { int sys_sigaction(int signum, \ + const struct sigaction *nsa, \ + struct sigaction *osa); } +47 NOARGS { gid_t sys_getgid(void); } +48 NOARGS { int sys_sigprocmask(int how, sigset_t mask); } +49 NOARGS { int sys_getlogin(char *namebuf, u_int namelen); } +50 NOARGS { int sys_setlogin(const char *namebuf); } +51 NOARGS { int sys_acct(const char *path); } +52 NOARGS { int sys_sigpending(void); } +53 NOARGS { int sys_sigaltstack(const struct sigaltstack *nss, \ + struct sigaltstack *oss); } +54 NOARGS { int sys_ioctl(int fd, \ + u_long com, ... void *data); } +55 NOARGS { int sys_reboot(int opt); } +56 NOARGS { int sys_revoke(const char *path); } +57 NOARGS { int sys_symlink(const char *path, \ + const char *link); } +58 NOARGS { int sys_readlink(const char *path, char *buf, \ + size_t count); } +59 NOARGS { int sys_execve(const char *path, \ + char * const *argp, char * const *envp); } +60 NOARGS { int sys_umask(int newmask); } +61 NOARGS { int sys_chroot(const char *path); } +62 NOARGS { int sys_fstat(int fd, struct ostat *sb); } ofstat +63 NOARGS { int compat_43_sys_getkerninfo(int op, char *where, \ + int *size, int arg); } ogetkerninfo +64 NOARGS { int compat_43_sys_getpagesize(void); } ogetpagesize +65 NOARGS { int sys_omsync(caddr_t addr, size_t len); } +66 NOARGS { int sys_vfork(void); } +67 OBSOL vread +68 OBSOL vwrite +69 NOARGS { int sys_sbrk(int incr); } +70 NOARGS { int sys_sstk(int incr); } +71 NOARGS { int sys_mmap(caddr_t addr, size_t len, int prot, \ + int flags, int fd, long pos); } ommap +72 NOARGS { int sys_ovadvise(int anom); } vadvise +73 NOARGS { int sys_munmap(void *addr, size_t len); } +74 NOARGS { int sys_mprotect(void *addr, size_t len, \ + int prot); } +75 NOARGS { int sys_madvise(void *addr, size_t len, \ + int behav); } +76 OBSOL vhangup +77 OBSOL vlimit +78 NOARGS { int sys_mincore(void *addr, size_t len, \ + char *vec); } +79 NOARGS { int sys_getgroups(int gidsetsize, \ + gid_t *gidset); } +80 NOARGS { int sys_setgroups(int gidsetsize, \ + const gid_t *gidset); } +81 NOARGS { int sys_getpgrp(void); } +82 NOARGS { int sys_setpgid(pid_t pid, int pgid); } +83 NOARGS { int sys_setitimer(int which, \ + const struct itimerval *itv, \ + struct itimerval *oitv); } +84 NOARGS { int compat_43_sys_wait(void); } owait +85 NOARGS { int sys_swapon(const char *name); } +86 NOARGS { int sys_getitimer(int which, \ + struct itimerval *itv); } +87 NOARGS { int compat_43_sys_gethostname(char *hostname, \ + u_int len); } ogethostname +88 NOARGS { int compat_43_sys_sethostname(char *hostname, \ + u_int len); } osethostname +89 NOARGS { int compat_43_sys_getdtablesize(void); } \ + ogetdtablesize +90 NOARGS { int sys_dup2(int from, int to); } +91 UNIMPL getdopt +92 NOARGS { int sys_fcntl(int fd, int cmd, ... void *arg); } +93 NOARGS { int sys_select(int nd, fd_set *in, fd_set *ou, \ + fd_set *ex, struct timeval *tv); } +94 UNIMPL setdopt +95 NOARGS { int sys_fsync(int fd); } +96 NOARGS { int sys_setpriority(int which, int who, int prio); } +97 NOARGS { int sys_socket(int domain, int type, int protocol); } +98 NOARGS { int sys_connect(int s, const struct sockaddr *name, \ + socklen_t namelen); } +99 NOARGS { int sys_accept(int s, caddr_t name, \ + int *anamelen); } oaccept +100 NOARGS { int sys_getpriority(int which, int who); } +101 NOARGS { int compat_43_sys_send(int s, caddr_t buf, int len, \ + int flags); } osend +102 NOARGS { int compat_43_sys_recv(int s, caddr_t buf, int len, \ + int flags); } orecv +103 NOARGS { int sys_sigreturn(struct sigcontext *sigcntxp); } +104 NOARGS { int sys_bind(int s, const struct sockaddr *name, \ + socklen_t namelen); } +105 NOARGS { int sys_setsockopt(int s, int level, int name, \ + const void *val, socklen_t valsize); } +106 NOARGS { int sys_listen(int s, int backlog); } +107 OBSOL vtimes +108 NOARGS { int compat_43_sys_sigvec(int signum, \ + struct sigvec *nsv, struct sigvec *osv); } osigvec +109 NOARGS { int compat_43_sys_sigblock(int mask); } osigblock +110 NOARGS { int compat_43_sys_sigsetmask(int mask); } osigsetmask +111 NOARGS { int sys_sigsuspend(int mask); } +112 NOARGS { int compat_43_sys_sigstack(struct sigstack *nss, \ + struct sigstack *oss); } osigstack +113 NOARGS { int compat_43_sys_recvmsg(int s, \ + struct omsghdr *msg, int flags); } orecvmsg +114 NOARGS { int compat_43_sys_sendmsg(int s, caddr_t msg, \ + int flags); } osendmsg +#ifdef TRACE +115 NOARGS { int sys_vtrace(int request, int value); } +#else +115 OBSOL vtrace +#endif +116 NOARGS { int sys_gettimeofday(struct timeval *tp, \ + struct timezone *tzp); } +117 NOARGS { int sys_getrusage(int who, struct rusage *rusage); } +118 NOARGS { int sys_getsockopt(int s, int level, int name, \ + void *val, socklen_t *avalsize); } +119 OBSOL resuba +120 NOARGS { ssize_t sys_readv(int fd, \ + const struct iovec *iovp, int iovcnt); } +121 NOARGS { ssize_t sys_writev(int fd, \ + const struct iovec *iovp, int iovcnt); } +122 NOARGS { int sys_settimeofday(const struct timeval *tv, \ + const struct timezone *tzp); } +123 NOARGS { int sys_fchown(int fd, uid_t uid, gid_t gid); } +124 NOARGS { int sys_fchmod(int fd, int mode); } +125 NOARGS { int compat_43_sys_recvfrom(int s, caddr_t buf, \ + size_t len, int flags, caddr_t from, \ + int *fromlenaddr); } orecvfrom +126 NOARGS { int compat_43_sys_setreuid(int ruid, int euid); } \ + osetreuid +127 NOARGS { int compat_43_sys_setregid(int rgid, int egid); } \ + osetregid +128 NOARGS { int sys_rename(const char *from, const char *to); } +129 NOARGS { int compat_43_sys_truncate(char *path, \ + long length); } otruncate +130 NOARGS { int compat_43_sys_ftruncate(int fd, long length); } \ + oftruncate +131 NOARGS { int sys_flock(int fd, int how); } +132 NOARGS { int sys_mkfifo(const char *path, int mode); } +133 NOARGS { ssize_t sys_sendto(int s, const void *buf, \ + size_t len, int flags, const struct sockaddr *to, \ + socklen_t tolen); } +134 NOARGS { int sys_shutdown(int s, int how); } +135 NOARGS { int sys_socketpair(int domain, int type, \ + int protocol, int *rsv); } +136 NOARGS { int sys_mkdir(const char *path, int mode); } +137 NOARGS { int sys_rmdir(const char *path); } +138 NOARGS { int sys_utimes(const char *path, \ + const struct timeval *tptr); } +139 OBSOL 4.2 sigreturn +140 NOARGS { int sys_adjtime(const struct timeval *delta, \ + struct timeval *olddelta); } +141 NOARGS { int compat_43_sys_getpeername(int fdes, caddr_t asa, \ + int *alen); } ogetpeername +142 NOARGS { int32_t compat_43_sys_gethostid(void); } ogethostid +143 NOARGS { int compat_43_sys_sethostid(int32_t hostid); } \ + osethostid +144 NOARGS { int compat_43_sys_getrlimit(u_int which, \ + struct ogetrlimit *rlp); } ogetrlimit +145 NOARGS { int compat_43_sys_setrlimit(u_int which, \ + struct ogetrlimit *rlp); } osetrlimit +146 NOARGS { int compat_43_sys_killpg(int pgid, int signum); } \ + okillpg +147 NOARGS { int sys_setsid(void); } +148 NOARGS { int sys_quotactl(const char *path, int cmd, \ + int uid, char *arg); } +149 NOARGS { int compat_43_sys_quota(void); } oquota +150 NOARGS { int compat_43_sys_getsockname(int fdec, caddr_t asa, \ + int *alen); } ogetsockname + +; Syscalls 151-180 inclusive are reserved for vendor-specific +; system calls. (This includes various calls added for compatibity +; with other Unix variants.) +; Some of these calls are now supported by BSD... +151 UNIMPL +152 UNIMPL +153 UNIMPL +154 UNIMPL +#if defined(NFSCLIENT) || defined(NFSSERVER) +155 NOARGS { int sys_nfssvc(int flag, void *argp); } +#else +155 UNIMPL +#endif +156 NOARGS { int compat_43_sys_getdirentries(int fd, char *buf, \ + u_int count, long *basep); } ogetdirentries +157 NOARGS { int sys_ostatfs(char *path, struct ostatfs *buf); } +158 NOARGS { int sys_ofstatfs(int fd, struct ostatfs *buf); } +159 UNIMPL +160 UNIMPL +#if defined(NFSCLIENT) || defined(NFSSERVER) +161 NOARGS { int sys_getfh(const char *fname, fhandle_t *fhp); } +#else +161 UNIMPL getfh +#endif +162 NOARGS { int compat_09_sys_getdomainname(char *domainname, \ + int len); } ogetdomainname +163 NOARGS { int compat_09_sys_setdomainname(char *domainname, \ + int len); } osetdomainname +164 NOARGS { int compat_09_sys_uname(struct outsname *name); } \ + ouname +165 NOARGS { int sys_sysarch(int op, char *parms); } +166 UNIMPL +167 UNIMPL +168 UNIMPL +; XXX more generally, never on machines where sizeof(void *) != sizeof(int) +#if defined(SYSVSEM) && !defined(alpha) +169 NOARGS { int sys_semsys(int which, int a2, int a3, int a4, \ + int a5); } osemsys +#else +169 UNIMPL 1.0 semsys +#endif +; XXX more generally, never on machines where sizeof(void *) != sizeof(int) +#if defined(SYSVMSG) && !defined(alpha) +170 NOARGS { int sys_msgsys(int which, int a2, int a3, int a4, \ + int a5, int a6); } omsgsys +#else +170 UNIMPL 1.0 msgsys +#endif +; XXX more generally, never on machines where sizeof(void *) != sizeof(int) +#if defined(SYSVSHM) && !defined(alpha) +171 NOARGS { int compat_10_sys_shmsys(int which, int a2, int a3, \ + int a4); } +#else +171 UNIMPL 1.0 shmsys +#endif +172 UNIMPL +173 UNIMPL +174 UNIMPL +#ifdef NTP +175 NOARGS { int sys_ntp_gettime(struct ntptimeval *ntvp); } +176 NOARGS { int sys_ntp_adjtime(struct timex *tp); } +#else +175 UNIMPL ntp_gettime +176 UNIMPL ntp_adjtime +#endif +177 UNIMPL +178 UNIMPL +179 UNIMPL +180 UNIMPL + +; Syscalls 181-199 are used by/reserved for BSD +181 NOARGS { int sys_setgid(gid_t gid); } +182 NOARGS { int sys_setegid(gid_t egid); } +183 NOARGS { int sys_seteuid(uid_t euid); } +#ifdef LFS +184 NOARGS { int lfs_bmapv(fsid_t *fsidp, \ + struct block_info *blkiov, int blkcnt); } +185 NOARGS { int lfs_markv(fsid_t *fsidp, \ + struct block_info *blkiov, int blkcnt); } +186 NOARGS { int lfs_segclean(fsid_t *fsidp, u_long segment); } +187 NOARGS { int lfs_segwait(fsid_t *fsidp, struct timeval *tv); } +#else +184 UNIMPL +185 UNIMPL +186 UNIMPL +187 UNIMPL +#endif +188 NOARGS { int sys_stat(const char *path, struct stat *ub); } +189 NOARGS { int sys_fstat(int fd, struct stat12 *sb); } +190 NOARGS { int sys_lstat(const char *path, struct stat *ub); } +191 NOARGS { long sys_pathconf(const char *path, int name); } +192 NOARGS { long sys_fpathconf(int fd, int name); } +193 NOARGS { int sys_swapctl(int cmd, const void *arg, int misc); } +194 NOARGS { int sys_getrlimit(int which, \ + struct rlimit *rlp); } +195 NOARGS { int sys_setrlimit(int which, \ + const struct rlimit *rlp); } +196 NOARGS { int sys_getdirentries(int fd, char *buf, \ + int count, long *basep); } +197 NOARGS { void *sys_mmap(void *addr, size_t len, int prot, \ + int flags, int fd, long pad, off_t pos); } +198 INDIR { quad_t sys___syscall(quad_t num, ...); } +199 NOARGS { off_t sys_lseek(int fd, int pad, off_t offset, \ + int whence); } +200 NOARGS { int sys_truncate(const char *path, int pad, \ + off_t length); } +201 NOARGS { int sys_ftruncate(int fd, int pad, off_t length); } +202 NOARGS { int sys___sysctl(int *name, u_int namelen, \ + void *old, size_t *oldlenp, void *new, \ + size_t newlen); } +203 NOARGS { int sys_mlock(const void *addr, size_t len); } +204 NOARGS { int sys_munlock(const void *addr, size_t len); } +205 NOARGS { int sys_undelete(const char *path); } +206 NOARGS { int sys_futimes(int fd, \ + const struct timeval *tptr); } +207 NOARGS { int sys_getpgid(pid_t pid); } +208 NOARGS { int sys_xfspioctl(int operation, char *a_pathP, \ + int a_opcode, struct ViceIoctl *a_paramsP, \ + int a_followSymlinks); } +; XXX u_int nfds vs. unsigned long nfds +209 NOARGS { int sys_poll(struct pollfd *fds, \ + unsigned long nfds, int timeout); } +; +; Syscalls 210-219 are reserved for dynamically loaded syscalls +; +#ifdef LKM +210 NODEF { int sys_lkmnosys(void); } +211 NODEF { int sys_lkmnosys(void); } +212 NODEF { int sys_lkmnosys(void); } +213 NODEF { int sys_lkmnosys(void); } +214 NODEF { int sys_lkmnosys(void); } +215 NODEF { int sys_lkmnosys(void); } +216 NODEF { int sys_lkmnosys(void); } +217 NODEF { int sys_lkmnosys(void); } +218 NODEF { int sys_lkmnosys(void); } +219 NODEF { int sys_lkmnosys(void); } +#else /* !LKM */ +210 UNIMPL +211 UNIMPL +212 UNIMPL +213 UNIMPL +214 UNIMPL +215 UNIMPL +216 UNIMPL +217 UNIMPL +218 UNIMPL +219 UNIMPL +#endif /* !LKM */ +; System calls 220-240 are reserved for use by OpenBSD +#ifdef SYSVSEM +220 NOARGS { int sys___osemctl(int semid, int semnum, int cmd, \ + union semun *arg); } +221 NOARGS { int sys_semget(key_t key, int nsems, int semflg); } +222 NOARGS { int sys_semop(int semid, struct sembuf *sops, \ + u_int nsops); } +223 NOARGS { int sys_semconfig(int flag); } +#else +220 UNIMPL semctl +221 UNIMPL semget +222 UNIMPL semop +223 UNIMPL semconfig +#endif +#ifdef SYSVMSG +224 NOARGS { int sys_omsgctl(int msqid, int cmd, \ + struct omsqid_ds *buf); } +225 NOARGS { int sys_msgget(key_t key, int msgflg); } +226 NOARGS { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \ + int msgflg); } +227 NOARGS { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \ + long msgtyp, int msgflg); } +#else +224 UNIMPL msgctl +225 UNIMPL msgget +226 UNIMPL msgsnd +227 UNIMPL msgrcv +#endif +#ifdef SYSVSHM +228 NOARGS { void *sys_shmat(int shmid, const void *shmaddr, \ + int shmflg); } +229 NOARGS { int sys_oshmctl(int shmid, int cmd, \ + struct oshmid_ds *buf); } +230 NOARGS { int sys_shmdt(const void *shmaddr); } +231 NOARGS { int sys_shmget(key_t key, int size, int shmflg); } +#else +228 UNIMPL shmat +229 UNIMPL shmctl +230 UNIMPL shmdt +231 UNIMPL shmget +#endif +232 NOARGS { int sys_clock_gettime(clockid_t clock_id, \ + struct timespec *tp); } +233 NOARGS { int sys_clock_settime(clockid_t clock_id, \ + const struct timespec *tp); } +234 NOARGS { int sys_clock_getres(clockid_t clock_id, \ + struct timespec *tp); } +235 UNIMPL timer_create +236 UNIMPL timer_delete +237 UNIMPL timer_settime +238 UNIMPL timer_gettime +239 UNIMPL timer_getoverrun +; +; System calls 240-249 are reserved for other IEEE Std1003.1b syscalls +; +240 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \ + struct timespec *rmtp); } +241 UNIMPL +;241 STD { int sys_fdatasync(int fd); } +242 UNIMPL +243 UNIMPL +244 UNIMPL +245 UNIMPL +246 UNIMPL +247 UNIMPL +248 UNIMPL +249 UNIMPL +250 UNIMPL +251 UNIMPL +252 UNIMPL +253 UNIMPL +254 UNIMPL +255 UNIMPL +256 UNIMPL +#ifdef SYSVSEM +257 NOARGS { int sys___semctl(int semid, int semnum, int cmd, \ + union semun *arg); } +#else +257 UNIMPL +#endif +#ifdef SYSVSHM +258 NOARGS { int sys_shmctl(int shmid, int cmd, \ + struct shmid_ds *buf); } +#else +258 UNIMPL +#endif +#ifdef SYSVMSG +259 NOARGS { int sys_msgctl(int msqid, int cmd, \ + struct msqid_ds *buf); } +#else +259 UNIMPL +#endif +260 UNIMPL +261 UNIMPL +262 UNIMPL +263 UNIMPL +264 UNIMPL +265 UNIMPL +266 UNIMPL +267 UNIMPL +268 UNIMPL +269 UNIMPL +270 UNIMPL +;270 STD { int sys___posix_rename(const char *from, \ +; const char *to); } +271 UNIMPL +;271 STD { int sys_swapctl(int cmd, const void *arg, int misc); } +272 UNIMPL +;272 STD { int sys_getdents(int fd, char *buf, size_t count); } +273 NOARGS { int sys_minherit(void *addr, size_t len, \ + int inherit); } +274 UNIMPL +;274 STD { int sys_lchmod(const char *path, mode_t mode); } +275 NOARGS { int sys_lchown(const char *path, uid_t uid, \ + gid_t gid); } +276 UNIMPL +;276 STD { int sys_lutimes(const char *path, \ +; const struct timeval *tptr); } +277 NOARGS { int sys_msync(void *addr, size_t len, int flags); } +278 STD { int netbsd_sys___stat13(const char *path, \ + struct netbsd_stat *ub); } +279 STD { int netbsd_sys___fstat13(int fd, \ + struct netbsd_stat *ub); } +280 STD { int netbsd_sys___lstat13(const char *path, \ + struct netbsd_stat *ub); } +281 UNIMPL +;281 STD { int sys___sigaltstack14( \ +; const struct sigaltstack *nss, \ +; struct sigaltstack *oss); } +282 UNIMPL +;282 STD { int sys___vfork14(void); } +283 UNIMPL +;283 STD { int sys___posix_chown(const char *path, uid_t uid, \ +; gid_t gid); } +284 UNIMPL +;284 STD { int sys___posix_fchown(int fd, uid_t uid, \ +; gid_t gid); } +285 UNIMPL +;285 STD { int sys___posix_lchown(const char *path, uid_t uid, \ +; gid_t gid); } +286 NOARGS { int sys_getsid(pid_t pid); } +287 UNIMPL +#ifdef KTRACE +288 UNIMPL +;288 STD { int sys_fktrace(const int fd, int ops, \ +; int facs, int pid); } +#else +288 UNIMPL +#endif +289 UNIMPL +;289 STD { ssize_t sys_preadv(int fd, \ +; const struct iovec *iovp, int iovcnt, \ +; int pad, off_t offset); } +290 UNIMPL +;290 STD { ssize_t sys_pwritev(int fd, \ +; const struct iovec *iovp, int iovcnt, \ +; int pad, off_t offset); } +291 UNIMPL +;291 STD { int netbsd_sys___sigaction14(int signum, \ +; const struct sigaction *nsa, \ +; struct sigaction *osa); } +292 UNIMPL +;292 STD { int sys___sigpending14(sigset_t *set); } +293 UNIMPL +;293 STD { int sys___sigprocmask14(int how, \ +; const sigset_t *set, \ +; sigset_t *oset); } +294 UNIMPL +;294 STD { int sys___sigsuspend14(const sigset_t *set); } +295 UNIMPL +;295 STD { int sys___sigreturn14(struct sigcontext *sigcntxp); } +296 STD { int netbsd_sys___getcwd(char *bufp, size_t length); } +297 UNIMPL +;297 STD { int sys_fchroot(int fd); } |