Index: head/sys/alpha/linux/syscalls.master =================================================================== --- head/sys/alpha/linux/syscalls.master (revision 64000) +++ head/sys/alpha/linux/syscalls.master (revision 64001) @@ -1,289 +1,289 @@ $FreeBSD$ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; System call name/number master file (or rather, slave, from LINUX). ; Processed to created linux_sysent.c, linux_syscalls.c and linux_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only #include "opt_compat.h" #include #include #include #include #include ; #ifdef's, etc. may be included, and are copied to the output files. 0 STD LINUX { int linux_setup(void); } -1 NOPROTO LINUX { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO LINUX { void sys_exit(int rval); } exit sys_exit_args void 2 STD LINUX { int linux_fork(void); } 3 NOPROTO LINUX { int read(int fd, char *buf, u_int nbyte); } 4 NOPROTO LINUX { int write(int fd, char *buf, u_int nbyte); } 5 STD LINUX { int linux_open(char *path, int flags, int mode); } 6 NOPROTO LINUX { int close(int fd); } 7 STD LINUX { int linux_waitpid(int pid, int *status, \ int options); } 8 STD LINUX { int linux_creat(char *path, int mode); } 9 STD LINUX { int linux_link(char *path, char *to); } 10 STD LINUX { int linux_unlink(char *path); } 11 STD LINUX { int linux_execve(char *path, char **argp, \ char **envp); } 12 STD LINUX { int linux_chdir(char *path); } 13 STD LINUX { int linux_time(linux_time_t *tm); } 14 STD LINUX { int linux_mknod(char *path, int mode, int dev); } 15 STD LINUX { int linux_chmod(char *path, int mode); } 16 STD LINUX { int linux_lchown(char *path, int uid, int gid); } 17 STD LINUX { int linux_break(char *nsize); } 18 STD LINUX { int linux_stat(char *path, struct ostat *up); } 19 STD LINUX { int linux_lseek(int fdes, long off, int whence); } 20 NOPROTO LINUX { int getpid(void); } 21 STD LINUX { int linux_mount(void); } 22 STD LINUX { int linux_umount(void); } 23 NOPROTO LINUX { int setuid(uid_t uid); } 24 NOPROTO LINUX { int getuid(void); } 25 STD LINUX { int linux_stime(void); } 26 STD LINUX { int linux_ptrace(void); } 27 STD LINUX { int linux_alarm(unsigned int secs); } 28 STD LINUX { int linux_fstat(int fd, struct ostat *up); } 29 STD LINUX { int linux_pause(void); } 30 STD LINUX { int linux_utime(char *fname, \ struct linux_utimbuf *times); } 31 STD LINUX { int linux_stty(void); } 32 STD LINUX { int linux_gtty(void); } 33 STD LINUX { int linux_access(char *path, int flags); } 34 STD LINUX { int linux_nice(int inc); } 35 STD LINUX { int linux_ftime(void); } 36 NOPROTO LINUX { int sync(void); } 37 STD LINUX { int linux_kill(int pid, int signum); } 38 STD LINUX { int linux_rename(char *from, char *to); } 39 STD LINUX { int linux_mkdir(char *path, int mode); } 40 STD LINUX { int linux_rmdir(char *path); } 41 NOPROTO LINUX { int dup(u_int fd); } 42 STD LINUX { int linux_pipe(int *pipefds); } 43 STD LINUX { int linux_times(struct linux_times_argv *buf); } 44 STD LINUX { int linux_prof(void); } 45 STD LINUX { int linux_brk(char *dsend); } 46 NOPROTO LINUX { int setgid(gid_t gid); } 47 NOPROTO LINUX { int getgid(void); } 48 STD LINUX { int linux_signal(int sig, linux_handler_t handler); } 49 NOPROTO LINUX { int geteuid(void); } 50 NOPROTO LINUX { int getegid(void); } 51 NOPROTO LINUX { int acct(char *path); } 52 STD LINUX { int linux_umount2(void); } 53 STD LINUX { int linux_lock(void); } 54 STD LINUX { int linux_ioctl(int fd, u_long cmd, int arg); } 55 STD LINUX { int linux_fcntl(int fd, int cmd, int arg); } 56 STD LINUX { int linux_mpx(void); } 57 NOPROTO LINUX { int setpgid(int pid, int pgid); } 58 STD LINUX { int linux_ulimit(void); } 59 STD LINUX { int linux_olduname(void); } 60 NOPROTO LINUX { int umask(int newmask); } 61 NOPROTO LINUX { int chroot(char *path); } 62 STD LINUX { int linux_ustat(linux_dev_t dev, \ struct linux_ustat *ubuf); } 63 NOPROTO LINUX { int dup2(u_int from, u_int to); } 64 NOPROTO LINUX { int getppid(void); } 65 NOPROTO LINUX { int getpgrp(void); } 66 NOPROTO LINUX { int setsid(void); } 67 STD LINUX { int linux_sigaction(int sig, \ linux_osigaction_t *nsa, \ linux_osigaction_t *osa); } 68 STD LINUX { int linux_siggetmask(void); } 69 STD LINUX { int linux_sigsetmask(linux_osigset_t mask); } 70 NOPROTO LINUX { int setreuid(int ruid, int euid); } 71 NOPROTO LINUX { int setregid(int rgid, int egid); } 72 STD LINUX { int linux_sigsuspend(int restart, \ linux_osigset_t oldmask, \ linux_osigset_t mask); } 73 STD LINUX { int linux_sigpending(linux_osigset_t *mask); } 74 NOPROTO LINUX { int osethostname(char *hostname, u_int len); } \ osethostname sethostname_args int 75 STD LINUX { int linux_setrlimit(u_int resource, \ struct ogetrlimit *rlim); } 76 STD LINUX { int linux_getrlimit(u_int resource, \ struct ogetrlimit *rlim); } 77 NOPROTO LINUX { int getrusage(int who, struct rusage *rusage); } 78 NOPROTO LINUX { int gettimeofday(struct timeval *tp, \ struct timezone *tzp); } 79 NOPROTO LINUX { int settimeofday(struct timeval *tp, \ struct timezone *tzp); } 80 STD LINUX { int linux_getgroups(u_int gidsetsize, \ linux_gid_t *gidset); } 81 STD LINUX { int linux_setgroups(u_int gidsetsize, \ linux_gid_t *gidset); } 82 STD LINUX { int linux_select(struct linux_select_argv *ptr); } 83 STD LINUX { int linux_symlink(char *path, char *to); } 84 NOPROTO LINUX { int ostat(char *path, struct ostat *up); } 85 STD LINUX { int linux_readlink(char *name, char *buf, \ int count); } 86 STD LINUX { int linux_uselib(char *library); } 87 NOPROTO LINUX { int swapon(char *name); } 88 NOPROTO LINUX { int reboot(int opt); } 89 STD LINUX { int linux_readdir(int fd, \ struct linux_dirent *dent, \ unsigned int count); } 90 STD LINUX { int linux_mmap(struct linux_mmap_argv *ptr); } 91 NOPROTO LINUX { int munmap(caddr_t addr, int len); } 92 STD LINUX { int linux_truncate(char *path, long length); } 93 NOPROTO LINUX { int oftruncate(int fd, long length); } 94 NOPROTO LINUX { int fchmod(int fd, int mode); } 95 NOPROTO LINUX { int fchown(int fd, int uid, int gid); } 96 NOPROTO LINUX { int getpriority(int which, int who); } 97 NOPROTO LINUX { int setpriority(int which, int who, int prio); } 98 NOPROTO LINUX { int profil(caddr_t samples, u_int size, \ u_int offset, u_int scale); } 99 STD LINUX { int linux_statfs(char *path, \ struct linux_statfs_buf *buf); } 100 STD LINUX { int linux_fstatfs(int fd, \ struct linux_statfs_buf *buf); } 101 STD LINUX { int linux_ioperm(unsigned int start, \ unsigned int length, int enable); } 102 STD LINUX { int linux_socketcall(int what, void *args); } 103 STD LINUX { int linux_ksyslog(int what); } 104 STD LINUX { int linux_setitimer(u_int which, \ struct itimerval *itv, \ struct itimerval *oitv); } 105 STD LINUX { int linux_getitimer(u_int which, \ struct itimerval *itv); } 106 STD LINUX { int linux_newstat(char *path, \ struct linux_newstat *buf); } 107 STD LINUX { int linux_newlstat(char *path, \ struct linux_newstat *buf); } 108 STD LINUX { int linux_newfstat(int fd, \ struct linux_newstat *buf); } 109 STD LINUX { int linux_uname(void); } 110 STD LINUX { int linux_iopl(int level); } 111 STD LINUX { int linux_vhangup(void); } 112 STD LINUX { int linux_idle(void); } 113 STD LINUX { int linux_vm86old(void); } 114 STD LINUX { int linux_wait4(int pid, int *status, \ int options, struct rusage *rusage); } 115 STD LINUX { int linux_swapoff(void); } 116 STD LINUX { int linux_sysinfo(void); } 117 STD LINUX { int linux_ipc(int what, int arg1, int arg2, \ int arg3, caddr_t ptr); } 118 NOPROTO LINUX { int fsync(int fd); } 119 STD LINUX { int linux_sigreturn(struct linux_sigcontext *scp); } 120 STD LINUX { int linux_clone(int flags, void *stack); } 121 NOPROTO LINUX { int setdomainname(char *name, int len); } 122 STD LINUX { int linux_newuname(struct linux_new_utsname *buf); } 123 STD LINUX { int linux_modify_ldt(int func, void *ptr, \ size_t bytecount); } 124 STD LINUX { int linux_adjtimex(void); } 125 NOPROTO LINUX { int mprotect(caddr_t addr, int len, int prot); } 126 STD LINUX { int linux_sigprocmask(int how, \ linux_osigset_t *mask, \ linux_osigset_t *omask); } 127 STD LINUX { int linux_create_module(void); } 128 STD LINUX { int linux_init_module(void); } 129 STD LINUX { int linux_delete_module(void); } 130 STD LINUX { int linux_get_kernel_syms(void); } 131 STD LINUX { int linux_quotactl(void); } 132 STD LINUX { int linux_getpgid(int pid); } 133 NOPROTO LINUX { int fchdir(int fd); } 134 STD LINUX { int linux_bdflush(void); } 135 STD LINUX { int linux_sysfs(int option, u_long arg1, \ u_long arg2); } 136 STD LINUX { int linux_personality(int per); } 137 STD LINUX { int linux_afs_syscall(void); } 138 STD LINUX { int linux_setfsuid(linux_uid_t uid); } 139 STD LINUX { int linux_setfsgid(linux_gid_t gid); } 140 STD LINUX { int linux_llseek(int fd, u_int32_t ohigh, \ u_int32_t olow, caddr_t res, int whence); } 141 STD LINUX { int linux_getdents(int fd, void *dent, \ unsigned count); } 142 STD LINUX { int linux_newselect(int nfds, fd_set *readfds, \ fd_set *writefds, fd_set *exceptfds, \ struct timeval *timeout); } 143 NOPROTO LINUX { int flock(int fd, int how); } 144 STD LINUX { int linux_msync(caddr_t addr, int len, int fl); } 145 NOPROTO LINUX { int readv(int fd, struct iovec *iovp, \ u_int iovcnt); } 146 NOPROTO LINUX { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 147 STD LINUX { int linux_getsid(linux_pid_t pid); } 148 STD LINUX { int linux_fdatasync(int fd); } 149 STD LINUX { int linux_sysctl(void); } 150 NOPROTO BSD { int mlock(const void *addr, size_t len); } 151 NOPROTO BSD { int munlock(const void *addr, size_t len); } 152 NOPROTO BSD { int mlockall(int how); } 153 NOPROTO BSD { int munlockall(void); } 154 NOPROTO POSIX { int sched_setparam (pid_t pid, \ const struct sched_param *param); } 155 NOPROTO POSIX { int sched_getparam (pid_t pid, \ struct sched_param *param); } 156 STD POSIX { int linux_sched_setscheduler(pid_t pid, int policy, \ const struct sched_param *param); } 157 STD POSIX { int linux_sched_getscheduler(pid_t pid); } 158 NOPROTO POSIX { int sched_yield (void); } 159 NOPROTO POSIX { int sched_get_priority_max (int policy); } 160 NOPROTO POSIX { int sched_get_priority_min (int policy); } 161 NOPROTO POSIX { int sched_rr_get_interval (pid_t pid, \ struct timespec *interval); } 162 NOPROTO POSIX { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 163 STD LINUX { int linux_mremap(caddr_t addr, int old_len, \ int new_len, int flags); } 164 NOPROTO LINUX { int setresuid(int ruid, int euid, int suid); } 165 STD LINUX { int linux_getresuid(linux_uid_t *ruid, \ linux_uid_t *euid, linux_uid_t *suid); } 166 STD LINUX { int linux_vm86(void); } 167 STD LINUX { int linux_query_module(void); } 168 NOPROTO LINUX { int poll(struct pollfd*, unsigned int nfds, \ long timeout); } 169 STD LINUX { int linux_nfsservctl(void); } 170 NOPROTO LINUX { int setresgid(int rgid, int egid, int sgid); } 171 STD LINUX { int linux_getresgid(linux_gid_t *rgid, \ linux_gid_t *egid, linux_gid_t *sgid); } 172 STD LINUX { int linux_prctl(void); } 173 STD LINUX { int linux_rt_sigreturn(void); } 174 STD LINUX { int linux_rt_sigaction(int sig, \ linux_sigaction_t *act, \ linux_sigaction_t *oact, \ size_t sigsetsize); } 175 STD LINUX { int linux_rt_sigprocmask(int how, \ linux_sigset_t *mask, linux_sigset_t *omask, \ size_t sigsetsize); } 176 STD LINUX { int linux_rt_sigpending(void); } 177 STD LINUX { int linux_rt_sigtimedwait(void); } 178 STD LINUX { int linux_rt_sigqueueinfo(void); } 179 STD LINUX { int linux_rt_sigsuspend(linux_sigset_t *newset, \ size_t sigsetsize); } 180 STD LINUX { int linux_pread(int fd, char *buf, size_t nbyte, \ off_t offset); } 181 STD LINUX { int linux_pwrite(int fd, const char *buf, \ size_t nbyte, off_t offset); } 182 STD LINUX { int linux_chown(char *path, int uid, int gid); } 183 STD LINUX { int linux_getcwd(char *buf, unsigned long bufsize); } 184 STD LINUX { int linux_capget(void); } 185 STD LINUX { int linux_capset(void); } 186 STD LINUX { int linux_sigaltstack(const linux_stack_t *uss, \ linux_stack_t *uoss); } 187 STD LINUX { int linux_sendfile(void); } 188 STD LINUX { int linux_getpmsg(void); } 189 STD LINUX { int linux_putpmsg(void); } 190 STD LINUX { int linux_vfork(void); } 191 STD LINUX { int linux_ugetrlimit(void); } 192 STD LINUX { int linux_mmap2(void); } 193 STD LINUX { int linux_truncate64(void); } 194 STD LINUX { int linux_ftruncate64(void); } 195 STD LINUX { int linux_stat64(void); } 196 STD LINUX { int linux_lstat64(void); } 197 STD LINUX { int linux_fstat64(void); } Index: head/sys/alpha/osf1/syscalls.master =================================================================== --- head/sys/alpha/osf1/syscalls.master (revision 64000) +++ head/sys/alpha/osf1/syscalls.master (revision 64001) @@ -1,391 +1,391 @@ ; $FreeBSD$ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; System call name/number master file (or rather, slave, from OSF1). ; Processed to created osf1_sysent.c, osf1_syscalls.c and osf1_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only #include "opt_compat.h" #include #include #include #include #include #include 0 NOPROTO OSF1 { int nosys(void); } -1 NOPROTO OSF1 { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO OSF1 { void sys_exit(int rval); } exit sys_exit_args void 2 NOPROTO OSF1 { int fork(void); } 3 NOPROTO OSF1 { ssize_t read(int fd, char *buf, ssize_t nbyte); } 4 NOPROTO OSF1 { ssize_t write(int fd, char *buf, ssize_t nbyte); } 5 UNIMPL OSF1 old open 6 NOPROTO OSF1 { int close(int fd); } 7 STD OSF1 { int osf1_wait4(int pid, int *status, int options, \ struct osf1_rusage *rusage); } 8 UNIMPL OSF1 old creat 9 NOPROTO OSF1 { int link(char *path, char *link); } 10 NOPROTO OSF1 { int unlink(char *path); } 11 UNIMPL OSF1 execv 12 NOPROTO OSF1 { int chdir(char *path); } 13 NOPROTO OSF1 { int fchdir(int fd); } 14 STD OSF1 { int osf1_mknod(char *path, int mode, int dev); } 15 NOPROTO OSF1 { int chmod(char *path, int mode); } 16 NOPROTO OSF1 { int chown(char *path, int uid, int gid); } 17 NOPROTO OSF1 { int obreak(char *nsize); } 18 STD OSF1 { int osf1_getfsstat(struct osf1_statfs *buf, \ long bufsize, int flags); } 19 STD OSF1 { off_t osf1_lseek(int fd, off_t offset, \ int whence); } 20 NOPROTO OSF1 { pid_t getpid(void); } 21 STD OSF1 { int osf1_mount(int type, char *path, int flags, \ caddr_t data); } 22 STD OSF1 { int osf1_unmount(char *path, int flags); } 23 STD OSF1 { int osf1_setuid(uid_t uid); } 24 NOPROTO OSF1 { uid_t getuid(void); } 25 UNIMPL OSF1 exec_with_loader 26 UNIMPL OSF1 ptrace 27 UNIMPL OSF1 recvmsg 28 UNIMPL OSF1 sendmsg 29 NOPROTO OSF1 { int recvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } 30 NOPROTO OSF1 { int accept(int s, caddr_t name, int *anamelen); } 31 NOPROTO OSF1 { int getpeername(int fdes, caddr_t asa, int *alen); } 32 NOPROTO OSF1 { int getsockname(int fdes, caddr_t asa, int *alen); } 33 STD OSF1 { int osf1_access(char *path, int flags); } 34 UNIMPL OSF1 chflags 35 UNIMPL OSF1 fchflags 36 NOPROTO OSF1 { int sync(void); } 37 STD OSF1 { int osf1_kill(int pid, int signum); } 38 UNIMPL OSF1 old stat 39 NOPROTO OSF1 { int setpgid(int pid, int pgid); } 40 UNIMPL OSF1 old lstat 41 NOPROTO OSF1 { int dup(u_int fd); } 42 NOPROTO OSF1 { int pipe(void); } 43 STD OSF1 { int osf1_set_program_attributes( \ vm_offset_t text_start, vm_offset_t text_len,\ vm_offset_t bss_start, vm_offset_t bss_len); } 44 UNIMPL OSF1 profil 45 STD OSF1 { int osf1_open(char *path, int flags, int mode); } 46 OBSOL OSF1 sigaction 47 NOPROTO OSF1 { gid_t getgid(void); } 48 STD OSF1 { int osf1_sigprocmask(int how, osf1_sigset_t mask); } 49 NOPROTO OSF1 { int getlogin(char *namebuf, u_int namelen); } 50 NOPROTO OSF1 { int setlogin(char *namebuf); } 51 NOPROTO OSF1 { int acct(char *path); } 52 STD OSF1 { int osf1_sigpending(struct proc *p, \ osf1_sigset_t *mask ); } 53 STD OSF1 { int osf1_classcntl(int opcode, int arg1, \ int arg2, int arg3); } 54 STD OSF1 { int osf1_ioctl(int fd, int com, caddr_t data); } 55 STD OSF1 { int osf1_reboot(int opt); } 56 NOPROTO OSF1 { int revoke(char *path); } 57 NOPROTO OSF1 { int symlink(char *path, char *link); } 58 NOPROTO OSF1 { int readlink(char *path, char *buf, int count); } 59 STD OSF1 { int osf1_execve(char *path, char **argp, \ char **envp); } 60 NOPROTO OSF1 { int umask(int newmask); } 61 NOPROTO OSF1 { int chroot(char *path); } 62 UNIMPL OSF1 old fstat 63 NOPROTO OSF1 { int getpgrp(void); } 64 NOPROTO OSF1 { int ogetpagesize(void); } 65 UNIMPL OSF1 mremap 66 NOPROTO OSF1 { int vfork(void); } 67 STD OSF1 { int osf1_stat(char *path, struct osf1_stat *ub); } 68 STD OSF1 { int osf1_lstat(char *path, \ struct osf1_stat *ub); } 69 UNIMPL OSF1 sbrk 70 UNIMPL OSF1 sstk 71 STD OSF1 { caddr_t osf1_mmap(caddr_t addr, size_t len, \ int prot, int flags, int fd, off_t pos); } 72 UNIMPL OSF1 ovadvise 73 NOPROTO OSF1 { int munmap(caddr_t addr, size_t len); } 74 NOPROTO OSF1 { int mprotect(void *addr, size_t len, int prot); } ; XXX 75 STD OSF1 { int osf1_madvise(void); } 76 UNIMPL OSF1 old vhangup 77 UNIMPL OSF1 kmodcall 78 UNIMPL OSF1 mincore 79 NOPROTO OSF1 { int getgroups(u_int gidsetsize, gid_t *gidset); } 80 NOPROTO OSF1 { int setgroups(u_int gidsetsize, gid_t *gidset); } 81 UNIMPL OSF1 old getpgrp ; OSF/1 setpgrp(); identical in function to setpgid(). XXX 82 STD OSF1 { int osf1_setpgrp(int pid, int pgid); } 83 STD OSF1 { int osf1_setitimer(u_int which, struct itimerval *itv, \ struct itimerval *oitv); } 84 UNIMPL OSF1 old wait 85 STD OSF1 { int osf1_table(long id, long index, void *addr, \ long nel, u_long lel); } 86 STD OSF1 { int osf1_getitimer(u_int which, struct itimerval *itv); } 87 NOPROTO OSF1 { int ogethostname(char *hostname, u_int len); } \ ogethostname gethostname_args int 88 NOPROTO OSF1 { int osethostname(char *hostname, u_int len); } \ osethostname sethostname_args int 89 NOPROTO OSF1 { int getdtablesize(void); } 90 NOPROTO OSF1 { int dup2(u_int from, u_int to); } 91 STD OSF1 { int osf1_fstat(int fd, void *sb); } 92 STD OSF1 { int osf1_fcntl(int fd, int cmd, void *arg); } 93 STD OSF1 { int osf1_select(u_int nd, fd_set *in, fd_set *ou, \ fd_set *ex, struct timeval *tv); } 94 NOPROTO OSF1 { int poll(struct pollfd *fds, u_int nfds, \ int timeout); } 95 NOPROTO OSF1 { int fsync(int fd); } 96 NOPROTO OSF1 { int setpriority(int which, int who, int prio); } 97 STD OSF1 { int osf1_socket(int domain, int type, \ int protocol); } 98 NOPROTO OSF1 { int connect(int s, caddr_t name, int namelen); } 99 NOPROTO OSF1 { int oaccept(int s, caddr_t name, int *anamelen); } \ oaccept accept_args int 100 NOPROTO OSF1 { int getpriority(int which, int who); } 101 NOPROTO OSF1 { int osend(int s, caddr_t buf, int len, \ int flags); } 102 NOPROTO OSF1 { int orecv(int s, caddr_t buf, int len, \ int flags); } 103 STD OSF1 { int osf1_sigreturn(struct osigcontext *sigcntxp); } 104 NOPROTO OSF1 { int bind(int s, caddr_t name, int namelen); } 105 NOPROTO OSF1 { int setsockopt(int s, int level, int name, \ caddr_t val, int valsize); } 106 NOPROTO OSF1 { int listen(int s, int backlog); } 107 UNIMPL OSF1 plock 108 UNIMPL OSF1 old sigvec 109 UNIMPL OSF1 old sigblock 110 UNIMPL OSF1 old sigsetmask 111 STD OSF1 { int osf1_sigsuspend(osf1_sigset_t ss); } 112 STD OSF1 { int osf1_osigstack(struct sigstack *nss, \ struct sigstack *oss); } 113 UNIMPL OSF1 old recvmsg 114 UNIMPL OSF1 old sendmsg 115 UNIMPL OSF1 vtrace 116 STD OSF1 { int osf1_gettimeofday(struct timeval *tp, \ struct timezone *tzp); } ; XXX 117 STD OSF1 { int osf1_getrusage(long who, void *rusage); } 118 NOPROTO OSF1 { int getsockopt(int s, int level, int name, \ caddr_t val, int *avalsize); } 119 UNIMPL OSF1 120 STD OSF1 { int osf1_readv(int fd, struct osf1_iovec *iovp, \ u_int iovcnt); } 121 STD OSF1 { int osf1_writev(int fd, struct osf1_iovec *iovp, \ u_int iovcnt); } 122 NOPROTO OSF1 { int settimeofday(struct timeval *tv, \ struct timezone *tzp); } 123 NOPROTO OSF1 { int fchown(int fd, int uid, int gid); } 124 NOPROTO OSF1 { int fchmod(int fd, int mode); } 125 NOPROTO OSF1 { int orecvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } \ orecvfrom recvfrom_args int 126 NOPROTO OSF1 { int setreuid(int ruid, int euid); } 127 NOPROTO OSF1 { int setregid(int rgid, int egid); } 128 NOPROTO OSF1 { int rename(const char *from, \ const char *to); } 129 STD OSF1 { int osf1_truncate(char *path, off_t length); } 130 STD OSF1 { int osf1_ftruncate(int fd, off_t length); } 131 NOPROTO OSF1 { int flock(int fd, int how); } 132 STD OSF1 { int osf1_setgid(gid_t gid); } 133 STD OSF1 { int osf1_sendto(int s, caddr_t buf, size_t len, \ int flags, struct sockaddr *to, int tolen); } 134 NOPROTO OSF1 { int shutdown(int s, int how); } 135 UNIMPL OSF1 socketpair 136 NOPROTO OSF1 { int mkdir(char *path, int mode); } 137 NOPROTO OSF1 { int rmdir(char *path); } 138 NOPROTO OSF1 { int utimes(char *path, struct timeval *tptr); } 139 OBSOL OSF1 4.2 sigreturn 140 UNIMPL OSF1 adjtime 141 NOPROTO OSF1 { int ogetpeername(int fdes, caddr_t asa, int *alen); } 142 NOPROTO OSF1 { int32_t ogethostid(void); } 143 NOPROTO OSF1 { int osethostid(int32_t hostid); } 144 STD OSF1 { int osf1_getrlimit(u_int which, \ struct rlimit *rlp); } 145 STD OSF1 { int osf1_setrlimit(u_int which, \ struct rlimit *rlp); } 146 UNIMPL OSF1 old killpg 147 NOPROTO OSF1 { int setsid(void); } 148 UNIMPL OSF1 quotactl 149 NOPROTO OSF1 { int oquota(void); } 150 NOPROTO OSF1 { int ogetsockname(int fdec, caddr_t asa, int *alen);} \ ogetsockname getsockname_args int 151 UNIMPL OSF1 152 UNIMPL OSF1 153 UNIMPL OSF1 154 UNIMPL OSF1 155 UNIMPL OSF1 156 STD OSF1 { int osf1_sigaction(long signum, \ struct osf1_sigaction *nsa, \ struct osf1_sigaction *osa, \ void *sigtramp); } 157 UNIMPL OSF1 158 UNIMPL OSF1 nfssvc 159 NOPROTO OSF1 { int ogetdirentries(int fd, char *buf, \ u_int count, long *basep); } 160 STD OSF1 { int osf1_statfs(char *path, \ struct osf1_statfs *buf, int len); } 161 STD OSF1 { int osf1_fstatfs(int fd, \ struct osf1_statfs *buf, int len); } 162 UNIMPL OSF1 163 UNIMPL OSF1 async_daemon 164 UNIMPL OSF1 getfh 165 NOPROTO OSF1 { int getdomainname(char *domainname, int len); } 166 NOPROTO OSF1 { int setdomainname(char *domainname, int len); } 167 UNIMPL OSF1 168 UNIMPL OSF1 169 UNIMPL OSF1 exportfs 170 UNIMPL OSF1 171 UNIMPL OSF1 172 UNIMPL OSF1 alt msgctl 173 UNIMPL OSF1 alt msgget 174 UNIMPL OSF1 alt msgrcv 175 UNIMPL OSF1 alt msgsnd 176 UNIMPL OSF1 alt semctl 177 UNIMPL OSF1 alt semget 178 UNIMPL OSF1 alt semop 179 UNIMPL OSF1 alt uname 180 UNIMPL OSF1 181 UNIMPL OSF1 alt plock 182 UNIMPL OSF1 lockf 183 UNIMPL OSF1 184 UNIMPL OSF1 getmnt 185 UNIMPL OSF1 186 UNIMPL OSF1 unmount 187 UNIMPL OSF1 alt sigpending 188 UNIMPL OSF1 alt setsid 189 UNIMPL OSF1 190 UNIMPL OSF1 191 UNIMPL OSF1 192 UNIMPL OSF1 193 UNIMPL OSF1 194 UNIMPL OSF1 195 UNIMPL OSF1 196 UNIMPL OSF1 197 UNIMPL OSF1 198 UNIMPL OSF1 199 UNIMPL OSF1 swapon 200 NOPROTO OSF1 { int msgctl(int msqid, int cmd, \ struct msqid_ds *buf); } 201 NOPROTO OSF1 { int msgget(key_t key, int msgflg); } 202 NOPROTO OSF1 { int msgrcv(int msqid, void *msgp, size_t msgsz, \ long msgtyp, int msgflg); } 203 NOPROTO OSF1 { int msgsnd(int msqid, void *msgp, size_t msgsz, \ int msgflg); } 204 NOPROTO OSF1 { int __semctl(int semid, int semnum, int cmd, \ union semun *arg); } 205 NOPROTO OSF1 { int semget(key_t key, int nsems, int semflg); } 206 NOPROTO OSF1 { int semop(int semid, struct sembuf *sops, \ u_int nsops); } 207 NOPROTO OSF1 { int uname(struct utsname *name); } 208 NOPROTO OSF1 { int lchown(char *path, int uid, \ int gid); } 209 NOPROTO OSF1 { int shmat(int shmid, void *shmaddr, int shmflg); } 210 NOPROTO OSF1 { int shmctl(int shmid, int cmd, \ struct shmid_ds *buf); } 211 NOPROTO OSF1 { int shmdt(void *shmaddr); } 212 NOPROTO OSF1 { int shmget(key_t key, int size, int shmflg); } 213 UNIMPL OSF1 mvalid 214 UNIMPL OSF1 getaddressconf 215 UNIMPL OSF1 msleep 216 UNIMPL OSF1 mwakeup 217 STD OSF1 { int osf1_msync(caddr_t addr, size_t len, \ int flags); } 218 STD OSF1 {int osf1_signal(int signum, void *handler); } 219 UNIMPL OSF1 utc gettime 220 UNIMPL OSF1 utc adjtime 221 UNIMPL OSF1 222 UNIMPL OSF1 security 223 UNIMPL OSF1 kloadcall 224 UNIMPL OSF1 225 UNIMPL OSF1 226 UNIMPL OSF1 227 UNIMPL OSF1 228 UNIMPL OSF1 229 UNIMPL OSF1 230 UNIMPL OSF1 231 UNIMPL OSF1 232 UNIMPL OSF1 233 NOPROTO OSF1 { pid_t getpgid(pid_t pid); } 234 NOPROTO OSF1 { pid_t getsid(pid_t pid); } 235 STD OSF1 { int osf1_sigaltstack(struct osf1_sigaltstack *nss, \ struct osf1_sigaltstack *oss); } 236 UNIMPL OSF1 waitid 237 UNIMPL OSF1 priocntlset 238 UNIMPL OSF1 sigsendset 239 UNIMPL OSF1 240 UNIMPL OSF1 msfs_syscall 241 STD OSF1 { int osf1_sysinfo(int cmd, char *buf, long count); } 242 UNIMPL OSF1 uadmin 243 UNIMPL OSF1 fuser 244 STD OSF1 { int osf1_proplist_syscall(void); } 245 STD OSF1 { int osf1_ntpadjtime(void *tp); } 246 STD OSF1 { int osf1_ntpgettime(void *tp); } 247 STD OSF1 { int osf1_pathconf(char *path, int name); } 248 STD OSF1 { int osf1_fpathconf(int fd, int name); } 249 UNIMPL OSF1 250 STD OSF1 { int osf1_uswitch(long cmd, long mask); } 251 STD OSF1 { int osf1_usleep_thread(struct timeval *sleep, \ struct timeval *slept); } 252 UNIMPL OSF1 audcntl 253 UNIMPL OSF1 audgen 254 UNIMPL OSF1 sysfs 255 UNIMPL OSF1 256 STD OSF1 { int osf1_getsysinfo(u_long op, caddr_t buffer, \ u_long nbytes, caddr_t arg, u_long flag); } 257 STD OSF1 { int osf1_setsysinfo(u_long op, caddr_t buffer, \ u_long nbytes, caddr_t arg, u_long flag); } 258 UNIMPL OSF1 afs_syscall 259 UNIMPL OSF1 swapctl 260 UNIMPL OSF1 memcntl 261 UNIMPL OSF1 262 UNIMPL OSF1 263 UNIMPL OSF1 264 UNIMPL OSF1 265 UNIMPL OSF1 266 UNIMPL OSF1 267 UNIMPL OSF1 268 UNIMPL OSF1 269 UNIMPL OSF1 270 UNIMPL OSF1 271 UNIMPL OSF1 272 UNIMPL OSF1 273 UNIMPL OSF1 274 UNIMPL OSF1 275 UNIMPL OSF1 276 UNIMPL OSF1 277 UNIMPL OSF1 278 UNIMPL OSF1 279 UNIMPL OSF1 280 UNIMPL OSF1 281 UNIMPL OSF1 282 UNIMPL OSF1 283 UNIMPL OSF1 284 UNIMPL OSF1 285 UNIMPL OSF1 286 UNIMPL OSF1 287 UNIMPL OSF1 288 UNIMPL OSF1 289 UNIMPL OSF1 290 UNIMPL OSF1 291 UNIMPL OSF1 292 UNIMPL OSF1 293 UNIMPL OSF1 294 UNIMPL OSF1 295 UNIMPL OSF1 296 UNIMPL OSF1 297 UNIMPL OSF1 298 UNIMPL OSF1 299 UNIMPL OSF1 300 UNIMPL OSF1 Index: head/sys/compat/svr4/syscalls.master =================================================================== --- head/sys/compat/svr4/syscalls.master (revision 64000) +++ head/sys/compat/svr4/syscalls.master (revision 64001) @@ -1,366 +1,366 @@ $FreeBSD$ ; from: @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; ; System call name/number master file (or rather, slave, from SVR4). ; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only ; #ifdef's, etc. may be included, and are copied to the output files. #include #include #include #include #include #include #include #include 0 UNIMPL SVR4 unused -1 NOPROTO POSIX { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO POSIX { void sys_exit(int rval); } exit sys_exit_args void 2 NOPROTO POSIX { int fork(void); } 3 NOPROTO POSIX { int read(int fd, char *buf, u_int nbyte); } 4 NOPROTO SVR4 { int write(int fd, char *buf, u_int nbyte); } 5 STD SVR4 { int svr4_sys_open(char *path, int flags, int mode); } 6 NOPROTO SVR4 { int close(int fd); } 7 STD SVR4 { int svr4_sys_wait(int *status); } 8 STD SVR4 { int svr4_sys_creat(char *path, int mode); } 9 NOPROTO SVR4 { int link(char *path, char *link); } 10 NOPROTO SVR4 { int unlink(char *path); } 11 STD SVR4 { int svr4_sys_execv(char *path, char **argp); } 12 NOPROTO SVR4 { int chdir(char *path); } 13 STD SVR4 { int svr4_sys_time(time_t *t); } 14 STD SVR4 { int svr4_sys_mknod(char* path, int mode, int dev); } 15 NOPROTO SVR4 { int chmod(char *path, int mode); } 16 NOPROTO SVR4 { int chown(char *path, uid_t uid, gid_t gid); } 17 STD SVR4 { int svr4_sys_break(caddr_t nsize); } 18 STD SVR4 { int svr4_sys_stat(char* path, \ struct svr4_stat* ub); } 19 NOPROTO SVR4 { int lseek(int filedes, off_t *offset, int whence); } 20 NOPROTO SVR4 { pid_t getpid(void); } 21 UNIMPL SVR4 old_mount 22 UNIMPL SVR4 sysv_umount 23 NOPROTO SVR4 { int setuid(uid_t uid); } 24 NOPROTO SVR4 { uid_t getuid(void); } 25 UNIMPL SVR4 stime 26 UNIMPL SVR4 ptrace 27 STD SVR4 { int svr4_sys_alarm(unsigned sec); } 28 STD SVR4 { int svr4_sys_fstat(int fd, struct svr4_stat *sb); } 29 STD SVR4 { int svr4_sys_pause(void); } 30 STD SVR4 { int svr4_sys_utime(char *path, \ struct svr4_utimbuf *ubuf); } 31 UNIMPL SVR4 stty 32 UNIMPL SVR4 gtty 33 STD SVR4 { int svr4_sys_access(char *path, int flags); } 34 STD SVR4 { int svr4_sys_nice(int prio); } 35 UNIMPL SVR4 statfs 36 NOPROTO SVR4 { int sync(void); } 37 STD SVR4 { int svr4_sys_kill(int pid, int signum); } 38 UNIMPL SVR4 fstatfs 39 STD SVR4 { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); } 40 UNIMPL SVR4 xenix 41 NOPROTO SVR4 { int dup(u_int fd); } 42 NOPROTO SVR4 { int pipe(void); } 43 STD SVR4 { int svr4_sys_times(struct tms *tp); } 44 UNIMPL SVR4 profil 45 UNIMPL SVR4 plock 46 NOPROTO SVR4 { int setgid(gid_t gid); } 47 NOPROTO SVR4 { gid_t getgid(void); } 48 STD SVR4 { int svr4_sys_signal(int signum, \ svr4_sig_t handler); } #if defined(NOTYET) 49 STD SVR4 { int svr4_sys_msgsys(int what, int a2, int a3, \ int a4, int a5); } #else 49 UNIMPL SVR4 msgsys #endif 50 STD SVR4 { int svr4_sys_sysarch(int op, void *a1); } 51 UNIMPL SVR4 acct 52 UNIMPL SVR4 shmsys 53 UNIMPL SVR4 semsys 54 STD SVR4 { int svr4_sys_ioctl(int fd, u_long com, \ caddr_t data); } 55 UNIMPL SVR4 uadmin 56 UNIMPL SVR4 exch 57 STD SVR4 { int svr4_sys_utssys(void *a1, void *a2, int sel, \ void *a3); } 58 NOPROTO SVR4 { int fsync(int fd); } 59 STD SVR4 { int svr4_sys_execve(char *path, char **argp, \ char **envp); } 60 NOPROTO SVR4 { int umask(int newmask); } 61 NOPROTO SVR4 { int chroot(char *path); } 62 STD SVR4 { int svr4_sys_fcntl(int fd, int cmd, char *arg); } 63 STD SVR4 { int svr4_sys_ulimit(int cmd, long newlimit); } 64 UNIMPL SVR4 reserved 65 UNIMPL SVR4 reserved 66 UNIMPL SVR4 reserved 67 UNIMPL SVR4 reserved 68 UNIMPL SVR4 reserved 69 UNIMPL SVR4 reserved 70 UNIMPL SVR4 advfs 71 UNIMPL SVR4 unadvfs 72 UNIMPL SVR4 rmount 73 UNIMPL SVR4 rumount 74 UNIMPL SVR4 rfstart 75 UNIMPL SVR4 sigret 76 UNIMPL SVR4 rdebug 77 UNIMPL SVR4 rfstop 78 UNIMPL SVR4 rfsys 79 NOPROTO SVR4 { int rmdir(char *path); } 80 NOPROTO SVR4 { int mkdir(char *path, int mode); } 81 STD SVR4 { int svr4_sys_getdents(int fd, char *buf, \ int nbytes); } 82 UNIMPL SVR4 libattach 83 UNIMPL SVR4 libdetach 84 UNIMPL SVR4 sysfs 85 STD SVR4 { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \ struct svr4_strbuf *dat, int *flags); } 86 STD SVR4 { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \ struct svr4_strbuf *dat, int flags); } 87 STD SVR4 { int svr4_sys_poll(struct pollfd *fds, unsigned int nfds, \ int timeout); } 88 STD SVR4 { int svr4_sys_lstat(char *path, \ struct svr4_stat *ub); } 89 NOPROTO SVR4 { int symlink(char *path, char *link); } 90 NOPROTO SVR4 { int readlink(char *path, char *buf, int count); } 91 NOPROTO SVR4 { int getgroups(u_int gidsetsize, gid_t *gidset); } 92 NOPROTO SVR4 { int setgroups(u_int gidsetsize, gid_t *gidset); } 93 NOPROTO SVR4 { int fchmod(int fd, int mode); } 94 NOPROTO SVR4 { int fchown(int fd, int uid, int gid); } 95 STD SVR4 { int svr4_sys_sigprocmask(int how, \ svr4_sigset_t *set, svr4_sigset_t *oset); } 96 STD SVR4 { int svr4_sys_sigsuspend(svr4_sigset_t *ss); } 97 STD SVR4 { int svr4_sys_sigaltstack( \ struct svr4_sigaltstack *nss, \ struct svr4_sigaltstack *oss); } 98 STD SVR4 { int svr4_sys_sigaction(int signum, \ struct svr4_sigaction *nsa, \ struct svr4_sigaction *osa); } 99 STD SVR4 { int svr4_sys_sigpending(int what, \ svr4_sigset_t *mask); } 100 STD SVR4 { int svr4_sys_context(int func, \ struct svr4_ucontext *uc); } 101 UNIMPL SVR4 evsys 102 UNIMPL SVR4 evtrapret 103 STD SVR4 { int svr4_sys_statvfs(char *path, \ struct svr4_statvfs *fs); } 104 STD SVR4 { int svr4_sys_fstatvfs(int fd, \ struct svr4_statvfs *fs); } 105 UNIMPL SVR4 whoknows 106 UNIMPL SVR4 nfssvc 107 STD SVR4 { int svr4_sys_waitsys(int grp, int id, \ union svr4_siginfo *info, int options); } 108 UNIMPL SVR4 sigsendsys 109 STD SVR4 { int svr4_sys_hrtsys(int cmd, int fun, int sub, \ void *rv1, void *rv2); } 110 UNIMPL SVR4 acancel 111 UNIMPL SVR4 async 112 UNIMPL SVR4 priocntlsys 113 STD SVR4 { int svr4_sys_pathconf(char *path, int name); } 114 UNIMPL SVR4 mincore 115 STD SVR4 { caddr_t svr4_sys_mmap( caddr_t addr, svr4_size_t len, \ int prot, int flags, int fd, svr4_off_t pos); } 116 NOPROTO SVR4 { int mprotect(void *addr, int len, int prot); } 117 NOPROTO SVR4 { int munmap(void *addr, int len); } 118 STD SVR4 { int svr4_sys_fpathconf(int fd, int name); } 119 NOPROTO SVR4 { int vfork(void); } 120 NOPROTO SVR4 { int fchdir(int fd); } 121 NOPROTO SVR4 { int readv(int fd, struct iovec *iovp, \ u_int iovcnt); } 122 NOPROTO SVR4 { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 123 STD SVR4 { int svr4_sys_xstat(int two, char *path, \ struct svr4_xstat *ub); } 124 STD SVR4 { int svr4_sys_lxstat(int two, char *path, \ struct svr4_xstat *ub); } 125 STD SVR4 { int svr4_sys_fxstat(int two, int fd, \ struct svr4_xstat *sb); } 126 STD SVR4 { int svr4_sys_xmknod(int two, char *path, \ svr4_mode_t mode, svr4_dev_t dev); } 127 UNIMPL SVR4 clocal 128 STD SVR4 { int svr4_sys_setrlimit(int which, \ const struct svr4_rlimit *rlp); } 129 STD SVR4 { int svr4_sys_getrlimit(int which, \ struct svr4_rlimit *rlp); } 130 NOPROTO SVR4 { int lchown(char *path, uid_t uid, gid_t gid); } 131 STD SVR4 { int svr4_sys_memcntl(void * addr, \ svr4_size_t len, int cmd, void * arg, \ int attr, int mask); } 132 UNIMPL SVR4 getpmsg 133 UNIMPL SVR4 putpmsg 134 NOPROTO SVR4 { int rename(char *from, char *to); } 135 STD SVR4 { int svr4_sys_uname(struct svr4_utsname* name, \ int dummy); } 136 NOPROTO SVR4 { int setegid(gid_t egid); } 137 STD SVR4 { int svr4_sys_sysconfig(int name); } 138 NOPROTO SVR4 { int adjtime(struct timeval *delta, \ struct timeval *olddelta); } 139 STD SVR4 { long svr4_sys_systeminfo(int what, char *buf, \ long len); } 140 UNIMPL SVR4 notused 141 NOPROTO SVR4 { int seteuid(uid_t euid); } 142 UNIMPL SVR4 vtrace ; fork1 143 UNIMPL SVR4 { int fork(void); } 144 UNIMPL SVR4 sigtimedwait 145 UNIMPL SVR4 lwp_info 146 UNIMPL SVR4 yield 147 UNIMPL SVR4 lwp_sema_wait 148 UNIMPL SVR4 lwp_sema_post 149 UNIMPL SVR4 lwp_sema_trywait 150 UNIMPL SVR4 notused 151 UNIMPL SVR4 notused 152 UNIMPL SVR4 modctl 153 STD SVR4 { int svr4_sys_fchroot(int fd); } 154 STD SVR4 { int svr4_sys_utimes(char *path, \ struct timeval *tptr); } 155 STD SVR4 { int svr4_sys_vhangup(void); } 156 STD SVR4 { int svr4_sys_gettimeofday(struct timeval *tp); } 157 NOPROTO SVR4 { int getitimer(u_int which, struct itimerval *itv); } 158 NOPROTO SVR4 { int setitimer(u_int which, struct itimerval *itv, \ struct itimerval *oitv); } 159 UNIMPL SVR4 lwp_create 160 UNIMPL SVR4 lwp_exit 161 UNIMPL SVR4 lwp_suspend 162 UNIMPL SVR4 lwp_continue 163 UNIMPL SVR4 lwp_kill 164 UNIMPL SVR4 lwp_self 165 UNIMPL SVR4 lwp_getprivate 166 UNIMPL SVR4 lwp_setprivate 167 UNIMPL SVR4 lwp_wait 168 UNIMPL SVR4 lwp_mutex_unlock 169 UNIMPL SVR4 lwp_mutex_lock 170 UNIMPL SVR4 lwp_cond_wait 171 UNIMPL SVR4 lwp_cond_signal 172 UNIMPL SVR4 lwp_cond_broadcast 173 UNIMPL SVR4 { ssize_t svr4_sys_pread(int fd, void *buf, \ size_t nbyte, svr4_off_t off); } 174 UNIMPL SVR4 { ssize_t svr4_sys_pwrite(int fd, const void *buf, \ size_t nbyte, svr4_off_t off); } 175 STD SVR4 { svr4_off64_t svr4_sys_llseek(int fd, long offset1, \ long offset2, int whence); } 176 UNIMPL SVR4 inst_sync 177 UNIMPL SVR4 whoknows 178 UNIMPL SVR4 kaio 179 UNIMPL SVR4 whoknows 180 UNIMPL SVR4 whoknows 181 UNIMPL SVR4 whoknows 182 UNIMPL SVR4 whoknows 183 UNIMPL SVR4 whoknows 184 UNIMPL SVR4 tsolsys 185 STD SVR4 { int svr4_sys_acl(char *path, int cmd, int num, \ struct svr4_aclent *buf); } 186 STD SVR4 { int svr4_sys_auditsys(int code, int a1, int a2, \ int a3, int a4, int a5); } 187 UNIMPL SVR4 processor_bind 188 UNIMPL SVR4 processor_info 189 UNIMPL SVR4 p_online 190 UNIMPL SVR4 sigqueue 191 UNIMPL SVR4 clock_gettime 192 UNIMPL SVR4 clock_settime 193 UNIMPL SVR4 clock_getres 194 UNIMPL SVR4 timer_create 195 UNIMPL SVR4 timer_delete 196 UNIMPL SVR4 timer_settime 197 UNIMPL SVR4 timer_gettime 198 UNIMPL SVR4 timer_overrun 199 NOPROTO SVR4 { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 200 STD SVR4 { int svr4_sys_facl(int fd, int cmd, int num, \ struct svr4_aclent *buf); } 201 UNIMPL SVR4 door 202 NOPROTO SVR4 { int setreuid(int ruid, int euid); } 203 NOPROTO SVR4 { int setregid(int rgid, int egid); } 204 UNIMPL SVR4 install_utrap 205 UNIMPL SVR4 signotify 206 UNIMPL SVR4 schedctl 207 UNIMPL SVR4 pset 208 UNIMPL SVR4 whoknows 209 STD SVR4 { int svr4_sys_resolvepath(const char *path, \ char *buf, size_t bufsiz); } 210 UNIMPL SVR4 signotifywait 211 UNIMPL SVR4 lwp_sigredirect 212 UNIMPL SVR4 lwp_alarm 213 STD SVR4 { int svr4_sys_getdents64(int fd, \ struct svr4_dirent64 *dp, \ int nbytes); } ;213 UNIMPL SVR4 getdents64 214 STD SVR4 { caddr_t svr4_sys_mmap64(void *addr, \ svr4_size_t len, int prot, int flags, int fd, \ svr4_off64_t pos); } 215 STD SVR4 { int svr4_sys_stat64(char *path, \ struct svr4_stat64 *sb); } 216 STD SVR4 { int svr4_sys_lstat64(char *path, \ struct svr4_stat64 *sb); } 217 STD SVR4 { int svr4_sys_fstat64(int fd, \ struct svr4_stat64 *sb); } 218 STD SVR4 { int svr4_sys_statvfs64(char *path, \ struct svr4_statvfs64 *fs); } 219 STD SVR4 { int svr4_sys_fstatvfs64(int fd, \ struct svr4_statvfs64 *fs); } 220 STD SVR4 { int svr4_sys_setrlimit64(int which, \ const struct svr4_rlimit64 *rlp); } 221 STD SVR4 { int svr4_sys_getrlimit64(int which, \ struct svr4_rlimit64 *rlp); } 222 UNIMPL SVR4 pread64 223 UNIMPL SVR4 pwrite64 224 STD SVR4 { int svr4_sys_creat64(char *path, int mode); } 225 STD SVR4 { int svr4_sys_open64(char *path, int flags, \ int mode); } 226 UNIMPL SVR4 rpcsys 227 UNIMPL SVR4 whoknows 228 UNIMPL SVR4 whoknows 229 UNIMPL SVR4 whoknows 230 STD SVR4 { int svr4_sys_socket(int domain, int type, \ int protocol); } 231 NOPROTO SVR4 { int socketpair(int domain, int type, \ int protocol, int *rsv); } 232 NOPROTO SVR4 { int bind(int s, const struct sockaddr *name, \ int namelen); } 233 NOPROTO SVR4 { int listen(int s, int backlog); } 234 NOPROTO SVR4 { int accept(int s, struct sockaddr *name, \ int *anamelen); } 235 NOPROTO SVR4 { int connect(int s, const struct sockaddr *name, \ int namelen); } 236 NOPROTO SVR4 { int shutdown(int s, int how); } 237 STD SVR4 { int svr4_sys_recv(int s, caddr_t buf, int len, int flags); } 238 NOPROTO SVR4 { ssize_t recvfrom(int s, void *buf, size_t len, \ int flags, struct sockaddr *from, \ int *fromlenaddr); } 239 NOPROTO SVR4 { ssize_t recvmsg(int s, struct msghdr *msg, \ int flags); } 240 STD SVR4 { int svr4_sys_send(int s, caddr_t buf, int len, int flags); } 241 NOPROTO SVR4 { ssize_t sendmsg(int s, const struct msghdr *msg, \ int flags); } 242 STD SVR4 { ssize_t svr4_sys_sendto(int s, void *buf, \ size_t len, int flags, \ struct sockaddr *to, int tolen); } 243 NOPROTO SVR4 { int getpeername(int fdes, struct sockaddr *asa, \ int *alen); } 244 NOPROTO SVR4 { int getsockname(int fdes, struct sockaddr *asa, \ int *alen); } 245 NOPROTO SVR4 { int getsockopt(int s, int level, int name, \ void *val, int *avalsize); } 246 NOPROTO SVR4 { int setsockopt(int s, int level, int name, \ const void *val, int valsize); } 247 UNIMPL SVR4 sockconfig 248 UNIMPL SVR4 { int ntp_gettime(struct ntptimeval *ntvp); } 249 UNIMPL SVR4 { int ntp_adjtime(struct timex *tp); } Index: head/sys/i386/ibcs2/syscalls.master =================================================================== --- head/sys/i386/ibcs2/syscalls.master (revision 64000) +++ head/sys/i386/ibcs2/syscalls.master (revision 64001) @@ -1,179 +1,179 @@ $FreeBSD$ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; System call name/number master file (or rather, slave, from IBCS2). ; Processed to created ibcs2_sysent.c, ibcs2_syscalls.c and ibcs2_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, SVR3, SCO, NOHIDE ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only #include #include #include #include #include #include ; #ifdef's, etc. may be included, and are copied to the output files. 0 NOPROTO NOHIDE { int nosys(void); } syscall nosys_args int -1 NOPROTO NOHIDE { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO NOHIDE { void sys_exit(int rval); } exit sys_exit_args void 2 NOPROTO POSIX { int fork(void); } 3 STD POSIX { int ibcs2_read(int fd, char *buf, u_int nbytes); } 4 NOPROTO POSIX { int write(int fd, char *buf, u_int nbytes); } 5 STD POSIX { int ibcs2_open(char *path, int flags, int mode); } 6 NOPROTO POSIX { int close(int fd); } 7 STD SVR3 { int ibcs2_wait(int a1, int a2, int a3); } 8 STD SVR3 { int ibcs2_creat(char *path, int mode); } 9 NOPROTO POSIX { int link(char *path, char *link); } 10 STD POSIX { int ibcs2_unlink(char *path); } 11 STD NOHIDE { int ibcs2_execv(char *path, char **argp); } 12 STD POSIX { int ibcs2_chdir(char *path); } 13 STD SVR3 { int ibcs2_time(ibcs2_time_t *tp); } 14 STD SVR3 { int ibcs2_mknod(char* path, int mode, int dev); } 15 STD SVR3 { int ibcs2_chmod(char *path, int mode); } 16 STD SVR3 { int ibcs2_chown(char *path, int uid, int gid); } 17 NOPROTO SVR3 { int obreak(caddr_t nsize); } 18 STD SVR3 { int ibcs2_stat(char* path, struct ibcs2_stat *st); } 19 STD POSIX { long ibcs2_lseek(int fd, long offset, int whence); } 20 NOPROTO POSIX { pid_t getpid(void); } 21 STD SVR3 { int ibcs2_mount(char *special, char *dir, int flags,\ int fstype, char *data, int len); } 22 STD SVR3 { int ibcs2_umount(char *name); } 23 STD POSIX { int ibcs2_setuid(int uid); } 24 NOPROTO SVR3 { uid_t getuid(void); } 25 STD SVR3 { int ibcs2_stime(long *timep); } 26 NOPROTO SVR3 { int ptrace(int req, pid_t pid, caddr_t addr, \ int data); } 27 STD SVR3 { int ibcs2_alarm(unsigned sec); } 28 STD SVR3 { int ibcs2_fstat(int fd, struct ibcs2_stat *st); } 29 STD SVR3 { int ibcs2_pause(void); } 30 STD SVR3 { int ibcs2_utime(char *path, \ struct ibcs2_utimbuf *buf); } 31 STD SCO { int ibcs2_stty(int fd, struct sgttyb *buf); } 32 STD SCO { int ibcs2_gtty(int fd, struct sgttyb *buf); } 33 STD POSIX { int ibcs2_access(char *path, int flags); } 34 STD SVR3 { int ibcs2_nice(int incr); } 35 STD SVR3 { int ibcs2_statfs(char *path, \ struct ibcs2_statfs *buf, \ int len, int fstype); } 36 NOPROTO SVR3 { int sync(void); } 37 STD POSIX { int ibcs2_kill(int pid, int signo); } 38 STD SVR3 { int ibcs2_fstatfs(int fd, struct ibcs2_statfs *buf, \ int len, int fstype); } 39 STD SVR3 { int ibcs2_pgrpsys(int type, caddr_t dummy, int pid, \ int pgid); } 40 STD SCO { int ibcs2_xenix(int a1, int a2, int a3, int a4, \ int a5); } 41 NOPROTO POSIX { int dup(u_int fd); } 42 NOPROTO POSIX { int pipe(void); } 43 STD SVR3 { int ibcs2_times(struct tms *tp); } 44 NOPROTO SVR3 { int profil(caddr_t samples, u_int size, \ u_int offset, u_int scale); } 45 STD SVR3 { int ibcs2_plock(int cmd); } 46 STD SVR3 { int ibcs2_setgid(int gid); } 47 NOPROTO SVR3 { gid_t getgid(void); } 48 STD SVR3 { int ibcs2_sigsys(int sig, ibcs2_sig_t fp); } 49 STD SVR3 { int ibcs2_msgsys(int which, int a2, int a3, int a4, \ int a5, int a6); } 50 STD SVR3 { int ibcs2_sysi86(int cmd, int *arg); } 51 UNIMPL SVR3 ibcs2_acct 52 STD SVR3 { int ibcs2_shmsys(int which, int a2, int a3, int a4); } 53 STD SVR3 { int ibcs2_semsys(int which, int a2, int a3, int a4, \ int a5); } 54 STD SVR3 { int ibcs2_ioctl(int fd, int cmd, caddr_t data); } 55 STD SVR3 { int ibcs2_uadmin(int cmd, int func, caddr_t data); } 56 UNIMPL SVR3 nosys 57 STD SVR3 { int ibcs2_utssys(int a1, int a2, int flag); } 58 NOPROTO POSIX { int fsync(int fd); } 59 STD SVR3 { int ibcs2_execve(char *path, char **argp, \ char **envp); } 60 NOPROTO SVR3 { int umask(int newmask); } 61 NOPROTO SVR3 { int chroot(char *path); } 62 STD SVR3 { int ibcs2_fcntl(int fd, int cmd, char *arg); } 63 STD SVR3 { long ibcs2_ulimit(int cmd, int newlimit); } 64 UNIMPL SVR3 reserved for unix/pc 65 UNIMPL SVR3 reserved for unix/pc 66 UNIMPL SVR3 reserved for unix/pc 67 UNIMPL SVR3 reserved for unix/pc 68 UNIMPL SVR3 reserved for unix/pc 69 UNIMPL SVR3 reserved for unix/pc 70 OBSOL SVR3 rfs_advfs 71 OBSOL SVR3 rfs_unadvfs 72 OBSOL SVR3 rfs_rmount 73 OBSOL SVR3 rfs_rumount 74 OBSOL SVR3 rfs_rfstart 75 OBSOL SVR3 rfs_sigret 76 OBSOL SVR3 rfs_rdebug 77 OBSOL SVR3 rfs_rfstop 78 UNIMPL SVR3 rfs_rfsys 79 STD SVR3 { int ibcs2_rmdir(char *path); } 80 STD SVR3 { int ibcs2_mkdir(char *path, int mode); } 81 STD SVR3 { int ibcs2_getdents(int fd, char *buf, int nbytes); } 82 UNIMPL SVR3 nosys 83 UNIMPL SVR3 nosys 84 STD SVR3 { int ibcs2_sysfs(int cmd, caddr_t d1, char *buf); } 85 STD SVR3 { int ibcs2_getmsg(int fd, struct ibcs2_stropts *ctl, \ struct ibcs2_stropts *dat, \ int *flags); } 86 STD SVR3 { int ibcs2_putmsg(int fd, struct ibcs2_stropts *ctl, \ struct ibcs2_stropts *dat, \ int flags); } 87 STD SVR3 { int ibcs2_poll(struct ibcs2_poll *fds, long nfds, \ int timeout); } 88 UNIMPL SVR3 nosys 89 STD SVR3 { int ibcs2_secure(int cmd, int a1, int a2, int a3, \ int a4, int a5); } 90 STD SVR3 { int ibcs2_symlink(char *path, char *link); } 91 STD SVR3 { int ibcs2_lstat(char *path, struct ibcs2_stat *st); } 92 STD SVR3 { int ibcs2_readlink(char *path, char *buf, int count); } 93 UNIMPL NOHIDE nosys 94 UNIMPL NOHIDE nosys 95 UNIMPL NOHIDE nosys 96 UNIMPL NOHIDE nosys 97 UNIMPL NOHIDE nosys 98 UNIMPL NOHIDE nosys 99 UNIMPL NOHIDE nosys 100 UNIMPL NOHIDE nosys 101 UNIMPL NOHIDE nosys 102 UNIMPL NOHIDE nosys 103 NOPROTO POSIX { int sigreturn(struct sigcontext *sigcntxp); } 104 UNIMPL NOHIDE nosys 105 STD SCO { int ibcs2_isc(void); } 106 UNIMPL NOHIDE nosys 107 UNIMPL NOHIDE nosys 108 UNIMPL NOHIDE nosys 109 UNIMPL NOHIDE nosys 110 UNIMPL NOHIDE nosys 111 UNIMPL NOHIDE nosys 112 UNIMPL NOHIDE nosys 113 UNIMPL NOHIDE nosys 114 UNIMPL NOHIDE nosys 115 UNIMPL NOHIDE nosys 116 UNIMPL NOHIDE nosys 117 UNIMPL NOHIDE nosys 118 UNIMPL NOHIDE nosys 119 UNIMPL NOHIDE nosys 120 UNIMPL NOHIDE nosys 121 UNIMPL NOHIDE nosys 122 UNIMPL NOHIDE nosys 123 UNIMPL NOHIDE nosys 124 UNIMPL NOHIDE nosys 125 UNIMPL NOHIDE nosys 126 UNIMPL NOHIDE nosys 127 UNIMPL NOHIDE nosys Index: head/sys/i386/linux/syscalls.master =================================================================== --- head/sys/i386/linux/syscalls.master (revision 64000) +++ head/sys/i386/linux/syscalls.master (revision 64001) @@ -1,289 +1,289 @@ $FreeBSD$ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; System call name/number master file (or rather, slave, from LINUX). ; Processed to created linux_sysent.c, linux_syscalls.c and linux_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only #include "opt_compat.h" #include #include #include #include #include ; #ifdef's, etc. may be included, and are copied to the output files. 0 STD LINUX { int linux_setup(void); } -1 NOPROTO LINUX { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO LINUX { void sys_exit(int rval); } exit sys_exit_args void 2 STD LINUX { int linux_fork(void); } 3 NOPROTO LINUX { int read(int fd, char *buf, u_int nbyte); } 4 NOPROTO LINUX { int write(int fd, char *buf, u_int nbyte); } 5 STD LINUX { int linux_open(char *path, int flags, int mode); } 6 NOPROTO LINUX { int close(int fd); } 7 STD LINUX { int linux_waitpid(int pid, int *status, \ int options); } 8 STD LINUX { int linux_creat(char *path, int mode); } 9 STD LINUX { int linux_link(char *path, char *to); } 10 STD LINUX { int linux_unlink(char *path); } 11 STD LINUX { int linux_execve(char *path, char **argp, \ char **envp); } 12 STD LINUX { int linux_chdir(char *path); } 13 STD LINUX { int linux_time(linux_time_t *tm); } 14 STD LINUX { int linux_mknod(char *path, int mode, int dev); } 15 STD LINUX { int linux_chmod(char *path, int mode); } 16 STD LINUX { int linux_lchown(char *path, int uid, int gid); } 17 STD LINUX { int linux_break(char *nsize); } 18 STD LINUX { int linux_stat(char *path, struct ostat *up); } 19 STD LINUX { int linux_lseek(int fdes, long off, int whence); } 20 NOPROTO LINUX { int getpid(void); } 21 STD LINUX { int linux_mount(void); } 22 STD LINUX { int linux_umount(void); } 23 NOPROTO LINUX { int setuid(uid_t uid); } 24 NOPROTO LINUX { int getuid(void); } 25 STD LINUX { int linux_stime(void); } 26 STD LINUX { int linux_ptrace(void); } 27 STD LINUX { int linux_alarm(unsigned int secs); } 28 STD LINUX { int linux_fstat(int fd, struct ostat *up); } 29 STD LINUX { int linux_pause(void); } 30 STD LINUX { int linux_utime(char *fname, \ struct linux_utimbuf *times); } 31 STD LINUX { int linux_stty(void); } 32 STD LINUX { int linux_gtty(void); } 33 STD LINUX { int linux_access(char *path, int flags); } 34 STD LINUX { int linux_nice(int inc); } 35 STD LINUX { int linux_ftime(void); } 36 NOPROTO LINUX { int sync(void); } 37 STD LINUX { int linux_kill(int pid, int signum); } 38 STD LINUX { int linux_rename(char *from, char *to); } 39 STD LINUX { int linux_mkdir(char *path, int mode); } 40 STD LINUX { int linux_rmdir(char *path); } 41 NOPROTO LINUX { int dup(u_int fd); } 42 STD LINUX { int linux_pipe(int *pipefds); } 43 STD LINUX { int linux_times(struct linux_times_argv *buf); } 44 STD LINUX { int linux_prof(void); } 45 STD LINUX { int linux_brk(char *dsend); } 46 NOPROTO LINUX { int setgid(gid_t gid); } 47 NOPROTO LINUX { int getgid(void); } 48 STD LINUX { int linux_signal(int sig, linux_handler_t handler); } 49 NOPROTO LINUX { int geteuid(void); } 50 NOPROTO LINUX { int getegid(void); } 51 NOPROTO LINUX { int acct(char *path); } 52 STD LINUX { int linux_umount2(void); } 53 STD LINUX { int linux_lock(void); } 54 STD LINUX { int linux_ioctl(int fd, u_long cmd, int arg); } 55 STD LINUX { int linux_fcntl(int fd, int cmd, int arg); } 56 STD LINUX { int linux_mpx(void); } 57 NOPROTO LINUX { int setpgid(int pid, int pgid); } 58 STD LINUX { int linux_ulimit(void); } 59 STD LINUX { int linux_olduname(void); } 60 NOPROTO LINUX { int umask(int newmask); } 61 NOPROTO LINUX { int chroot(char *path); } 62 STD LINUX { int linux_ustat(linux_dev_t dev, \ struct linux_ustat *ubuf); } 63 NOPROTO LINUX { int dup2(u_int from, u_int to); } 64 NOPROTO LINUX { int getppid(void); } 65 NOPROTO LINUX { int getpgrp(void); } 66 NOPROTO LINUX { int setsid(void); } 67 STD LINUX { int linux_sigaction(int sig, \ linux_osigaction_t *nsa, \ linux_osigaction_t *osa); } 68 STD LINUX { int linux_siggetmask(void); } 69 STD LINUX { int linux_sigsetmask(linux_osigset_t mask); } 70 NOPROTO LINUX { int setreuid(int ruid, int euid); } 71 NOPROTO LINUX { int setregid(int rgid, int egid); } 72 STD LINUX { int linux_sigsuspend(int restart, \ linux_osigset_t oldmask, \ linux_osigset_t mask); } 73 STD LINUX { int linux_sigpending(linux_osigset_t *mask); } 74 NOPROTO LINUX { int osethostname(char *hostname, u_int len); } \ osethostname sethostname_args int 75 STD LINUX { int linux_setrlimit(u_int resource, \ struct ogetrlimit *rlim); } 76 STD LINUX { int linux_getrlimit(u_int resource, \ struct ogetrlimit *rlim); } 77 NOPROTO LINUX { int getrusage(int who, struct rusage *rusage); } 78 NOPROTO LINUX { int gettimeofday(struct timeval *tp, \ struct timezone *tzp); } 79 NOPROTO LINUX { int settimeofday(struct timeval *tp, \ struct timezone *tzp); } 80 STD LINUX { int linux_getgroups(u_int gidsetsize, \ linux_gid_t *gidset); } 81 STD LINUX { int linux_setgroups(u_int gidsetsize, \ linux_gid_t *gidset); } 82 STD LINUX { int linux_select(struct linux_select_argv *ptr); } 83 STD LINUX { int linux_symlink(char *path, char *to); } 84 NOPROTO LINUX { int ostat(char *path, struct ostat *up); } 85 STD LINUX { int linux_readlink(char *name, char *buf, \ int count); } 86 STD LINUX { int linux_uselib(char *library); } 87 NOPROTO LINUX { int swapon(char *name); } 88 NOPROTO LINUX { int reboot(int opt); } 89 STD LINUX { int linux_readdir(int fd, \ struct linux_dirent *dent, \ unsigned int count); } 90 STD LINUX { int linux_mmap(struct linux_mmap_argv *ptr); } 91 NOPROTO LINUX { int munmap(caddr_t addr, int len); } 92 STD LINUX { int linux_truncate(char *path, long length); } 93 NOPROTO LINUX { int oftruncate(int fd, long length); } 94 NOPROTO LINUX { int fchmod(int fd, int mode); } 95 NOPROTO LINUX { int fchown(int fd, int uid, int gid); } 96 NOPROTO LINUX { int getpriority(int which, int who); } 97 NOPROTO LINUX { int setpriority(int which, int who, int prio); } 98 NOPROTO LINUX { int profil(caddr_t samples, u_int size, \ u_int offset, u_int scale); } 99 STD LINUX { int linux_statfs(char *path, \ struct linux_statfs_buf *buf); } 100 STD LINUX { int linux_fstatfs(int fd, \ struct linux_statfs_buf *buf); } 101 STD LINUX { int linux_ioperm(unsigned int start, \ unsigned int length, int enable); } 102 STD LINUX { int linux_socketcall(int what, void *args); } 103 STD LINUX { int linux_ksyslog(int what); } 104 STD LINUX { int linux_setitimer(u_int which, \ struct itimerval *itv, \ struct itimerval *oitv); } 105 STD LINUX { int linux_getitimer(u_int which, \ struct itimerval *itv); } 106 STD LINUX { int linux_newstat(char *path, \ struct linux_newstat *buf); } 107 STD LINUX { int linux_newlstat(char *path, \ struct linux_newstat *buf); } 108 STD LINUX { int linux_newfstat(int fd, \ struct linux_newstat *buf); } 109 STD LINUX { int linux_uname(void); } 110 STD LINUX { int linux_iopl(int level); } 111 STD LINUX { int linux_vhangup(void); } 112 STD LINUX { int linux_idle(void); } 113 STD LINUX { int linux_vm86old(void); } 114 STD LINUX { int linux_wait4(int pid, int *status, \ int options, struct rusage *rusage); } 115 STD LINUX { int linux_swapoff(void); } 116 STD LINUX { int linux_sysinfo(void); } 117 STD LINUX { int linux_ipc(int what, int arg1, int arg2, \ int arg3, caddr_t ptr); } 118 NOPROTO LINUX { int fsync(int fd); } 119 STD LINUX { int linux_sigreturn(struct linux_sigcontext *scp); } 120 STD LINUX { int linux_clone(int flags, void *stack); } 121 NOPROTO LINUX { int setdomainname(char *name, int len); } 122 STD LINUX { int linux_newuname(struct linux_new_utsname *buf); } 123 STD LINUX { int linux_modify_ldt(int func, void *ptr, \ size_t bytecount); } 124 STD LINUX { int linux_adjtimex(void); } 125 NOPROTO LINUX { int mprotect(caddr_t addr, int len, int prot); } 126 STD LINUX { int linux_sigprocmask(int how, \ linux_osigset_t *mask, \ linux_osigset_t *omask); } 127 STD LINUX { int linux_create_module(void); } 128 STD LINUX { int linux_init_module(void); } 129 STD LINUX { int linux_delete_module(void); } 130 STD LINUX { int linux_get_kernel_syms(void); } 131 STD LINUX { int linux_quotactl(void); } 132 STD LINUX { int linux_getpgid(int pid); } 133 NOPROTO LINUX { int fchdir(int fd); } 134 STD LINUX { int linux_bdflush(void); } 135 STD LINUX { int linux_sysfs(int option, u_long arg1, \ u_long arg2); } 136 STD LINUX { int linux_personality(int per); } 137 STD LINUX { int linux_afs_syscall(void); } 138 STD LINUX { int linux_setfsuid(linux_uid_t uid); } 139 STD LINUX { int linux_setfsgid(linux_gid_t gid); } 140 STD LINUX { int linux_llseek(int fd, u_int32_t ohigh, \ u_int32_t olow, caddr_t res, int whence); } 141 STD LINUX { int linux_getdents(int fd, void *dent, \ unsigned count); } 142 STD LINUX { int linux_newselect(int nfds, fd_set *readfds, \ fd_set *writefds, fd_set *exceptfds, \ struct timeval *timeout); } 143 NOPROTO LINUX { int flock(int fd, int how); } 144 STD LINUX { int linux_msync(caddr_t addr, int len, int fl); } 145 NOPROTO LINUX { int readv(int fd, struct iovec *iovp, \ u_int iovcnt); } 146 NOPROTO LINUX { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 147 STD LINUX { int linux_getsid(linux_pid_t pid); } 148 STD LINUX { int linux_fdatasync(int fd); } 149 STD LINUX { int linux_sysctl(void); } 150 NOPROTO BSD { int mlock(const void *addr, size_t len); } 151 NOPROTO BSD { int munlock(const void *addr, size_t len); } 152 NOPROTO BSD { int mlockall(int how); } 153 NOPROTO BSD { int munlockall(void); } 154 NOPROTO POSIX { int sched_setparam (pid_t pid, \ const struct sched_param *param); } 155 NOPROTO POSIX { int sched_getparam (pid_t pid, \ struct sched_param *param); } 156 STD POSIX { int linux_sched_setscheduler(pid_t pid, int policy, \ const struct sched_param *param); } 157 STD POSIX { int linux_sched_getscheduler(pid_t pid); } 158 NOPROTO POSIX { int sched_yield (void); } 159 NOPROTO POSIX { int sched_get_priority_max (int policy); } 160 NOPROTO POSIX { int sched_get_priority_min (int policy); } 161 NOPROTO POSIX { int sched_rr_get_interval (pid_t pid, \ struct timespec *interval); } 162 NOPROTO POSIX { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 163 STD LINUX { int linux_mremap(caddr_t addr, int old_len, \ int new_len, int flags); } 164 NOPROTO LINUX { int setresuid(int ruid, int euid, int suid); } 165 STD LINUX { int linux_getresuid(linux_uid_t *ruid, \ linux_uid_t *euid, linux_uid_t *suid); } 166 STD LINUX { int linux_vm86(void); } 167 STD LINUX { int linux_query_module(void); } 168 NOPROTO LINUX { int poll(struct pollfd*, unsigned int nfds, \ long timeout); } 169 STD LINUX { int linux_nfsservctl(void); } 170 NOPROTO LINUX { int setresgid(int rgid, int egid, int sgid); } 171 STD LINUX { int linux_getresgid(linux_gid_t *rgid, \ linux_gid_t *egid, linux_gid_t *sgid); } 172 STD LINUX { int linux_prctl(void); } 173 STD LINUX { int linux_rt_sigreturn(void); } 174 STD LINUX { int linux_rt_sigaction(int sig, \ linux_sigaction_t *act, \ linux_sigaction_t *oact, \ size_t sigsetsize); } 175 STD LINUX { int linux_rt_sigprocmask(int how, \ linux_sigset_t *mask, linux_sigset_t *omask, \ size_t sigsetsize); } 176 STD LINUX { int linux_rt_sigpending(void); } 177 STD LINUX { int linux_rt_sigtimedwait(void); } 178 STD LINUX { int linux_rt_sigqueueinfo(void); } 179 STD LINUX { int linux_rt_sigsuspend(linux_sigset_t *newset, \ size_t sigsetsize); } 180 STD LINUX { int linux_pread(int fd, char *buf, size_t nbyte, \ off_t offset); } 181 STD LINUX { int linux_pwrite(int fd, const char *buf, \ size_t nbyte, off_t offset); } 182 STD LINUX { int linux_chown(char *path, int uid, int gid); } 183 STD LINUX { int linux_getcwd(char *buf, unsigned long bufsize); } 184 STD LINUX { int linux_capget(void); } 185 STD LINUX { int linux_capset(void); } 186 STD LINUX { int linux_sigaltstack(const linux_stack_t *uss, \ linux_stack_t *uoss); } 187 STD LINUX { int linux_sendfile(void); } 188 STD LINUX { int linux_getpmsg(void); } 189 STD LINUX { int linux_putpmsg(void); } 190 STD LINUX { int linux_vfork(void); } 191 STD LINUX { int linux_ugetrlimit(void); } 192 STD LINUX { int linux_mmap2(void); } 193 STD LINUX { int linux_truncate64(void); } 194 STD LINUX { int linux_ftruncate64(void); } 195 STD LINUX { int linux_stat64(void); } 196 STD LINUX { int linux_lstat64(void); } 197 STD LINUX { int linux_fstat64(void); } Index: head/sys/kern/syscalls.master =================================================================== --- head/sys/kern/syscalls.master (revision 64000) +++ head/sys/kern/syscalls.master (revision 64001) @@ -1,528 +1,528 @@ $FreeBSD$ ; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94 ; ; System call name/number master file. ; Processed to created init_sysent.c, syscalls.c and syscall.h. ; Columns: number [MPSAFE] type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; MPSAFE optional field, specifies that syscall does not want the ; BGL grabbed automatically (it is SMP safe). ; type one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT, ; NODEF, NOARGS, NOPROTO, NOIMPL ; namespc one of POSIX, BSD, NOHIDE ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only ; #ifdef's, etc. may be included, and are copied to the output files. #include #include #include ; 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 STD NOHIDE { int nosys(void); } syscall nosys_args int -1 STD NOHIDE { void sys_exit(int rval); } sys_exit sys_exit_args void +1 STD NOHIDE { void sys_exit(int rval); } exit sys_exit_args void 2 STD POSIX { int fork(void); } 3 STD POSIX { ssize_t read(int fd, void *buf, size_t nbyte); } 4 STD POSIX { ssize_t write(int fd, const void *buf, size_t nbyte); } 5 STD POSIX { int open(char *path, int flags, int mode); } ; XXX should be { int open(const char *path, int flags, ...); } ; but we're not ready for `const' or varargs. ; XXX man page says `mode_t mode'. 6 STD POSIX { int close(int fd); } 7 STD BSD { int wait4(int pid, int *status, int options, \ struct rusage *rusage); } wait4 wait_args int 8 COMPAT BSD { int creat(char *path, int mode); } 9 STD POSIX { int link(char *path, char *link); } 10 STD POSIX { int unlink(char *path); } 11 OBSOL NOHIDE execv 12 STD POSIX { int chdir(char *path); } 13 STD BSD { int fchdir(int fd); } 14 STD POSIX { int mknod(char *path, int mode, int dev); } 15 STD POSIX { int chmod(char *path, int mode); } 16 STD POSIX { int chown(char *path, int uid, int gid); } 17 STD BSD { int obreak(char *nsize); } break obreak_args int 18 STD BSD { int getfsstat(struct statfs *buf, long bufsize, \ int flags); } 19 COMPAT POSIX { long lseek(int fd, long offset, int whence); } 20 STD POSIX { pid_t getpid(void); } 21 STD BSD { int mount(char *type, char *path, int flags, \ caddr_t data); } ; XXX 4.4lite2 uses `char *type' but we're not ready for that. ; XXX `path' should have type `const char *' but we're not ready for that. 22 STD BSD { int unmount(char *path, int flags); } 23 STD POSIX { int setuid(uid_t uid); } 24 MPSAFE STD POSIX { uid_t getuid(void); } 25 MPSAFE STD POSIX { uid_t geteuid(void); } 26 STD BSD { int ptrace(int req, pid_t pid, caddr_t addr, \ int data); } 27 STD BSD { int recvmsg(int s, struct msghdr *msg, int flags); } 28 STD BSD { int sendmsg(int s, caddr_t msg, int flags); } 29 STD BSD { int recvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } 30 STD BSD { int accept(int s, caddr_t name, int *anamelen); } 31 STD BSD { int getpeername(int fdes, caddr_t asa, int *alen); } 32 STD BSD { int getsockname(int fdes, caddr_t asa, int *alen); } 33 STD POSIX { int access(char *path, int flags); } 34 STD BSD { int chflags(char *path, int flags); } 35 STD BSD { int fchflags(int fd, int flags); } 36 STD BSD { int sync(void); } 37 STD POSIX { int kill(int pid, int signum); } 38 COMPAT POSIX { int stat(char *path, struct ostat *ub); } 39 STD POSIX { pid_t getppid(void); } 40 COMPAT POSIX { int lstat(char *path, struct ostat *ub); } 41 STD POSIX { int dup(u_int fd); } 42 STD POSIX { int pipe(void); } 43 STD POSIX { gid_t getegid(void); } 44 STD BSD { int profil(caddr_t samples, size_t size, \ size_t offset, u_int scale); } 45 STD BSD { int ktrace(const char *fname, int ops, int facs, \ int pid); } 46 COMPAT POSIX { int sigaction(int signum, struct osigaction *nsa, \ struct osigaction *osa); } 47 MPSAFE STD POSIX { gid_t getgid(void); } 48 MPSAFE COMPAT POSIX { int sigprocmask(int how, osigset_t mask); } ; XXX note nonstandard (bogus) calling convention - the libc stub passes ; us the mask, not a pointer to it, and we return the old mask as the ; (int) return value. 49 STD BSD { int getlogin(char *namebuf, u_int namelen); } 50 STD BSD { int setlogin(char *namebuf); } 51 STD BSD { int acct(char *path); } 52 COMPAT POSIX { int sigpending(void); } 53 STD BSD { int sigaltstack(stack_t *ss, stack_t *oss); } 54 STD POSIX { int ioctl(int fd, u_long com, caddr_t data); } 55 STD BSD { int reboot(int opt); } 56 STD POSIX { int revoke(char *path); } 57 STD POSIX { int symlink(char *path, char *link); } 58 STD POSIX { int readlink(char *path, char *buf, int count); } 59 STD POSIX { int execve(char *fname, char **argv, char **envv); } 60 MPSAFE STD POSIX { int umask(int newmask); } umask umask_args int 61 STD BSD { int chroot(char *path); } 62 COMPAT POSIX { int fstat(int fd, struct ostat *sb); } 63 COMPAT BSD { int getkerninfo(int op, char *where, size_t *size, \ int arg); } getkerninfo getkerninfo_args int 64 COMPAT BSD { int getpagesize(void); } \ getpagesize getpagesize_args int 65 STD BSD { int msync(void *addr, size_t len, int flags); } 66 STD BSD { int vfork(void); } 67 OBSOL NOHIDE vread 68 OBSOL NOHIDE vwrite 69 STD BSD { int sbrk(int incr); } 70 STD BSD { int sstk(int incr); } 71 COMPAT BSD { int mmap(void *addr, int len, int prot, \ int flags, int fd, long pos); } 72 STD BSD { int ovadvise(int anom); } vadvise ovadvise_args int 73 STD BSD { int munmap(void *addr, size_t len); } 74 STD BSD { int mprotect(const void *addr, size_t len, int prot); } 75 STD BSD { int madvise(void *addr, size_t len, int behav); } 76 OBSOL NOHIDE vhangup 77 OBSOL NOHIDE vlimit 78 STD BSD { int mincore(const void *addr, size_t len, \ char *vec); } 79 STD POSIX { int getgroups(u_int gidsetsize, gid_t *gidset); } 80 STD POSIX { int setgroups(u_int gidsetsize, gid_t *gidset); } 81 MPSAFE STD POSIX { int getpgrp(void); } 82 STD POSIX { int setpgid(int pid, int pgid); } 83 STD BSD { int setitimer(u_int which, struct itimerval *itv, \ struct itimerval *oitv); } 84 COMPAT BSD { int wait(void); } 85 STD BSD { int swapon(char *name); } 86 STD BSD { int getitimer(u_int which, struct itimerval *itv); } 87 COMPAT BSD { int gethostname(char *hostname, u_int len); } \ gethostname gethostname_args int 88 COMPAT BSD { int sethostname(char *hostname, u_int len); } \ sethostname sethostname_args int 89 STD BSD { int getdtablesize(void); } 90 STD POSIX { int dup2(u_int from, u_int to); } 91 UNIMPL BSD getdopt 92 STD POSIX { int fcntl(int fd, int cmd, long arg); } ; XXX should be { int fcntl(int fd, int cmd, ...); } ; but we're not ready for varargs. ; XXX man page says `int arg' too. 93 STD BSD { int select(int nd, fd_set *in, fd_set *ou, \ fd_set *ex, struct timeval *tv); } 94 UNIMPL BSD setdopt 95 STD POSIX { int fsync(int fd); } 96 STD BSD { int setpriority(int which, int who, int prio); } 97 STD BSD { int socket(int domain, int type, int protocol); } 98 STD BSD { int connect(int s, caddr_t name, int namelen); } 99 CPT_NOA BSD { int accept(int s, caddr_t name, int *anamelen); } \ accept accept_args int 100 STD BSD { int getpriority(int which, int who); } 101 COMPAT BSD { int send(int s, caddr_t buf, int len, int flags); } 102 COMPAT BSD { int recv(int s, caddr_t buf, int len, int flags); } 103 COMPAT BSD { int sigreturn(struct osigcontext *sigcntxp); } 104 STD BSD { int bind(int s, caddr_t name, int namelen); } 105 STD BSD { int setsockopt(int s, int level, int name, \ caddr_t val, int valsize); } 106 STD BSD { int listen(int s, int backlog); } 107 OBSOL NOHIDE vtimes 108 COMPAT BSD { int sigvec(int signum, struct sigvec *nsv, \ struct sigvec *osv); } 109 COMPAT BSD { int sigblock(int mask); } 110 COMPAT BSD { int sigsetmask(int mask); } 111 COMPAT POSIX { int sigsuspend(osigset_t mask); } ; XXX note nonstandard (bogus) calling convention - the libc stub passes ; us the mask, not a pointer to it. 112 COMPAT BSD { int sigstack(struct sigstack *nss, \ struct sigstack *oss); } 113 COMPAT BSD { int recvmsg(int s, struct omsghdr *msg, int flags); } 114 COMPAT BSD { int sendmsg(int s, caddr_t msg, int flags); } 115 OBSOL NOHIDE vtrace 116 STD BSD { int gettimeofday(struct timeval *tp, \ struct timezone *tzp); } 117 STD BSD { int getrusage(int who, struct rusage *rusage); } 118 STD BSD { int getsockopt(int s, int level, int name, \ caddr_t val, int *avalsize); } 119 UNIMPL NOHIDE resuba (BSD/OS 2.x) 120 STD BSD { int readv(int fd, struct iovec *iovp, u_int iovcnt); } 121 STD BSD { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 122 STD BSD { int settimeofday(struct timeval *tv, \ struct timezone *tzp); } 123 STD BSD { int fchown(int fd, int uid, int gid); } 124 STD BSD { int fchmod(int fd, int mode); } 125 CPT_NOA BSD { int recvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } \ recvfrom recvfrom_args int 126 STD BSD { int setreuid(int ruid, int euid); } 127 STD BSD { int setregid(int rgid, int egid); } 128 STD POSIX { int rename(char *from, char *to); } 129 COMPAT BSD { int truncate(char *path, long length); } 130 COMPAT BSD { int ftruncate(int fd, long length); } 131 STD BSD { int flock(int fd, int how); } 132 STD POSIX { int mkfifo(char *path, int mode); } 133 STD BSD { int sendto(int s, caddr_t buf, size_t len, \ int flags, caddr_t to, int tolen); } 134 STD BSD { int shutdown(int s, int how); } 135 STD BSD { int socketpair(int domain, int type, int protocol, \ int *rsv); } 136 STD POSIX { int mkdir(char *path, int mode); } 137 STD POSIX { int rmdir(char *path); } 138 STD BSD { int utimes(char *path, struct timeval *tptr); } 139 OBSOL NOHIDE 4.2 sigreturn 140 STD BSD { int adjtime(struct timeval *delta, \ struct timeval *olddelta); } 141 COMPAT BSD { int getpeername(int fdes, caddr_t asa, int *alen); } 142 COMPAT BSD { long gethostid(void); } 143 COMPAT BSD { int sethostid(long hostid); } 144 COMPAT BSD { int getrlimit(u_int which, struct ogetrlimit *rlp); } 145 COMPAT BSD { int setrlimit(u_int which, struct ogetrlimit *rlp); } 146 COMPAT BSD { int killpg(int pgid, int signum); } 147 STD POSIX { int setsid(void); } 148 STD BSD { int quotactl(char *path, int cmd, int uid, \ caddr_t arg); } 149 COMPAT BSD { int quota(void); } 150 CPT_NOA BSD { int getsockname(int fdec, caddr_t asa, int *alen); }\ getsockname getsockname_args int ; 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 NOHIDE sem_lock (BSD/OS 2.x) 152 UNIMPL NOHIDE sem_wakeup (BSD/OS 2.x) 153 UNIMPL NOHIDE asyncdaemon (BSD/OS 2.x) 154 UNIMPL NOHIDE nosys ; 155 is initialized by the NFS code, if present. 155 NOIMPL BSD { int nfssvc(int flag, caddr_t argp); } 156 COMPAT BSD { int getdirentries(int fd, char *buf, u_int count, \ long *basep); } 157 STD BSD { int statfs(char *path, struct statfs *buf); } 158 STD BSD { int fstatfs(int fd, struct statfs *buf); } 159 UNIMPL NOHIDE nosys 160 UNIMPL NOHIDE nosys ; 161 is initialized by the NFS code, if present. 161 STD BSD { int getfh(char *fname, struct fhandle *fhp); } 162 STD BSD { int getdomainname(char *domainname, int len); } 163 STD BSD { int setdomainname(char *domainname, int len); } 164 STD BSD { int uname(struct utsname *name); } 165 STD BSD { int sysarch(int op, char *parms); } 166 STD BSD { int rtprio(int function, pid_t pid, \ struct rtprio *rtp); } 167 UNIMPL NOHIDE nosys 168 UNIMPL NOHIDE nosys 169 STD BSD { int semsys(int which, int a2, int a3, int a4, \ int a5); } ; XXX should be { int semsys(int which, ...); } 170 STD BSD { int msgsys(int which, int a2, int a3, int a4, \ int a5, int a6); } ; XXX should be { int msgsys(int which, ...); } 171 STD BSD { int shmsys(int which, int a2, int a3, int a4); } ; XXX should be { int shmsys(int which, ...); } 172 UNIMPL NOHIDE nosys 173 STD POSIX { ssize_t pread(int fd, void *buf, size_t nbyte, \ int pad, off_t offset); } 174 STD POSIX { ssize_t pwrite(int fd, const void *buf, \ size_t nbyte, int pad, off_t offset); } 175 UNIMPL NOHIDE nosys 176 STD BSD { int ntp_adjtime(struct timex *tp); } 177 UNIMPL NOHIDE sfork (BSD/OS 2.x) 178 UNIMPL NOHIDE getdescriptor (BSD/OS 2.x) 179 UNIMPL NOHIDE setdescriptor (BSD/OS 2.x) 180 UNIMPL NOHIDE nosys ; Syscalls 181-199 are used by/reserved for BSD 181 STD POSIX { int setgid(gid_t gid); } 182 STD BSD { int setegid(gid_t egid); } 183 STD BSD { int seteuid(uid_t euid); } 184 UNIMPL BSD lfs_bmapv 185 UNIMPL BSD lfs_markv 186 UNIMPL BSD lfs_segclean 187 UNIMPL BSD lfs_segwait 188 STD POSIX { int stat(char *path, struct stat *ub); } 189 STD POSIX { int fstat(int fd, struct stat *sb); } 190 STD POSIX { int lstat(char *path, struct stat *ub); } 191 STD POSIX { int pathconf(char *path, int name); } 192 STD POSIX { int fpathconf(int fd, int name); } 193 UNIMPL NOHIDE nosys 194 STD BSD { int getrlimit(u_int which, \ struct orlimit *rlp); } \ getrlimit __getrlimit_args int 195 STD BSD { int setrlimit(u_int which, \ struct orlimit *rlp); } \ setrlimit __setrlimit_args int 196 STD BSD { int getdirentries(int fd, char *buf, u_int count, \ long *basep); } 197 STD BSD { caddr_t mmap(caddr_t addr, size_t len, int prot, \ int flags, int fd, int pad, off_t pos); } 198 STD NOHIDE { int nosys(void); } __syscall __syscall_args int 199 STD POSIX { off_t lseek(int fd, int pad, off_t offset, \ int whence); } 200 STD BSD { int truncate(char *path, int pad, off_t length); } 201 STD BSD { int ftruncate(int fd, int pad, off_t length); } 202 STD BSD { int __sysctl(int *name, u_int namelen, void *old, \ size_t *oldlenp, void *new, size_t newlen); } \ __sysctl sysctl_args int ; properly, __sysctl should be a NOHIDE, but making an exception ; here allows to avoid one in libc/sys/Makefile.inc. 203 STD BSD { int mlock(const void *addr, size_t len); } 204 STD BSD { int munlock(const void *addr, size_t len); } 205 STD BSD { int undelete(char *path); } 206 STD BSD { int futimes(int fd, struct timeval *tptr); } 207 STD BSD { int getpgid(pid_t pid); } 208 UNIMPL NOHIDE newreboot (NetBSD) 209 STD BSD { int poll(struct pollfd *fds, u_int nfds, \ int timeout); } ; ; The following are reserved for loadable syscalls ; 210 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 211 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 212 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 213 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 214 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 215 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 216 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 217 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 218 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 219 NODEF NOHIDE lkmnosys lkmnosys nosys_args int ; ; The following were introduced with NetBSD/4.4Lite-2 ; 220 STD BSD { int __semctl(int semid, int semnum, int cmd, \ union semun *arg); } 221 STD BSD { int semget(key_t key, int nsems, int semflg); } 222 STD BSD { int semop(int semid, struct sembuf *sops, \ u_int nsops); } 223 UNIMPL NOHIDE semconfig 224 STD BSD { int msgctl(int msqid, int cmd, \ struct msqid_ds *buf); } 225 STD BSD { int msgget(key_t key, int msgflg); } 226 STD BSD { int msgsnd(int msqid, void *msgp, size_t msgsz, \ int msgflg); } 227 STD BSD { int msgrcv(int msqid, void *msgp, size_t msgsz, \ long msgtyp, int msgflg); } 228 STD BSD { int shmat(int shmid, void *shmaddr, int shmflg); } 229 STD BSD { int shmctl(int shmid, int cmd, \ struct shmid_ds *buf); } 230 STD BSD { int shmdt(void *shmaddr); } 231 STD BSD { int shmget(key_t key, int size, int shmflg); } ; 232 STD POSIX { int clock_gettime(clockid_t clock_id, \ struct timespec *tp); } 233 STD POSIX { int clock_settime(clockid_t clock_id, \ const struct timespec *tp); } 234 STD POSIX { int clock_getres(clockid_t clock_id, \ struct timespec *tp); } 235 UNIMPL NOHIDE timer_create 236 UNIMPL NOHIDE timer_delete 237 UNIMPL NOHIDE timer_settime 238 UNIMPL NOHIDE timer_gettime 239 UNIMPL NOHIDE timer_getoverrun 240 STD POSIX { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 241 UNIMPL NOHIDE nosys 242 UNIMPL NOHIDE nosys 243 UNIMPL NOHIDE nosys 244 UNIMPL NOHIDE nosys 245 UNIMPL NOHIDE nosys 246 UNIMPL NOHIDE nosys 247 UNIMPL NOHIDE nosys 248 UNIMPL NOHIDE nosys 249 UNIMPL NOHIDE nosys ; syscall numbers initially used in OpenBSD 250 STD BSD { int minherit(void *addr, size_t len, int inherit); } 251 STD BSD { int rfork(int flags); } 252 STD BSD { int openbsd_poll(struct pollfd *fds, u_int nfds, \ int timeout); } 253 STD BSD { int issetugid(void); } 254 STD BSD { int lchown(char *path, int uid, int gid); } 255 UNIMPL NOHIDE nosys 256 UNIMPL NOHIDE nosys 257 UNIMPL NOHIDE nosys 258 UNIMPL NOHIDE nosys 259 UNIMPL NOHIDE nosys 260 UNIMPL NOHIDE nosys 261 UNIMPL NOHIDE nosys 262 UNIMPL NOHIDE nosys 263 UNIMPL NOHIDE nosys 264 UNIMPL NOHIDE nosys 265 UNIMPL NOHIDE nosys 266 UNIMPL NOHIDE nosys 267 UNIMPL NOHIDE nosys 268 UNIMPL NOHIDE nosys 269 UNIMPL NOHIDE nosys 270 UNIMPL NOHIDE nosys 271 UNIMPL NOHIDE nosys 272 STD BSD { int getdents(int fd, char *buf, size_t count); } 273 UNIMPL NOHIDE nosys 274 STD BSD { int lchmod(char *path, mode_t mode); } 275 NOPROTO BSD { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int 276 STD BSD { int lutimes(char *path, struct timeval *tptr); } 277 NOPROTO BSD { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int 278 STD BSD { int nstat(char *path, struct nstat *ub); } 279 STD BSD { int nfstat(int fd, struct nstat *sb); } 280 STD BSD { int nlstat(char *path, struct nstat *ub); } 281 UNIMPL NOHIDE nosys 282 UNIMPL NOHIDE nosys 283 UNIMPL NOHIDE nosys 284 UNIMPL NOHIDE nosys 285 UNIMPL NOHIDE nosys 286 UNIMPL NOHIDE nosys 287 UNIMPL NOHIDE nosys 288 UNIMPL NOHIDE nosys 289 UNIMPL NOHIDE nosys 290 UNIMPL NOHIDE nosys 291 UNIMPL NOHIDE nosys 292 UNIMPL NOHIDE nosys 293 UNIMPL NOHIDE nosys 294 UNIMPL NOHIDE nosys 295 UNIMPL NOHIDE nosys 296 UNIMPL NOHIDE nosys ; XXX 297 is 300 in NetBSD 297 STD BSD { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); } 298 STD BSD { int fhopen(const struct fhandle *u_fhp, int flags); } 299 STD BSD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); } ; syscall numbers for FreeBSD 300 STD BSD { int modnext(int modid); } 301 STD BSD { int modstat(int modid, struct module_stat* stat); } 302 STD BSD { int modfnext(int modid); } 303 STD BSD { int modfind(const char *name); } 304 STD BSD { int kldload(const char *file); } 305 STD BSD { int kldunload(int fileid); } 306 STD BSD { int kldfind(const char *file); } 307 STD BSD { int kldnext(int fileid); } 308 STD BSD { int kldstat(int fileid, struct kld_file_stat* stat); } 309 STD BSD { int kldfirstmod(int fileid); } 310 STD BSD { int getsid(pid_t pid); } 311 STD BSD { int setresuid(uid_t ruid, uid_t euid, uid_t suid); } 312 STD BSD { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); } 313 OBSOL NOHIDE signanosleep 314 STD BSD { int aio_return(struct aiocb *aiocbp); } 315 STD BSD { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); } 316 STD BSD { int aio_cancel(int fd, struct aiocb *aiocbp); } 317 STD BSD { int aio_error(struct aiocb *aiocbp); } 318 STD BSD { int aio_read(struct aiocb *aiocbp); } 319 STD BSD { int aio_write(struct aiocb *aiocbp); } 320 STD BSD { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); } 321 STD BSD { int yield(void); } 322 STD BSD { int thr_sleep(const struct timespec *timeout); } 323 STD BSD { int thr_wakeup(pid_t pid); } 324 STD BSD { int mlockall(int how); } 325 STD BSD { int munlockall(void); } 326 STD BSD { int __getcwd(u_char *buf, u_int buflen); } 327 STD POSIX { int sched_setparam (pid_t pid, const struct sched_param *param); } 328 STD POSIX { int sched_getparam (pid_t pid, struct sched_param *param); } 329 STD POSIX { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); } 330 STD POSIX { int sched_getscheduler (pid_t pid); } 331 STD POSIX { int sched_yield (void); } 332 STD POSIX { int sched_get_priority_max (int policy); } 333 STD POSIX { int sched_get_priority_min (int policy); } 334 STD POSIX { int sched_rr_get_interval (pid_t pid, struct timespec *interval); } 335 STD BSD { int utrace(const void *addr, size_t len); } 336 STD BSD { int sendfile(int fd, int s, off_t offset, size_t nbytes, \ struct sf_hdtr *hdtr, off_t *sbytes, int flags); } 337 STD BSD { int kldsym(int fileid, int cmd, void *data); } 338 STD BSD { int jail(struct jail *jail); } 339 UNIMPL BSD pioctl 340 MPSAFE STD POSIX { int sigprocmask(int how, const sigset_t *set, \ sigset_t *oset); } 341 STD POSIX { int sigsuspend(const sigset_t *sigmask); } 342 STD POSIX { int sigaction(int sig, const struct sigaction *act, \ struct sigaction *oact); } 343 STD POSIX { int sigpending(sigset_t *set); } 344 STD BSD { int sigreturn(ucontext_t *sigcntxp); } 345 UNIMPL NOHIDE sigtimedwait 346 UNIMPL NOHIDE sigwaitinfo 347 STD BSD { int __acl_get_file(const char *path, \ acl_type_t type, struct acl *aclp); } 348 STD BSD { int __acl_set_file(const char *path, \ acl_type_t type, struct acl *aclp); } 349 STD BSD { int __acl_get_fd(int filedes, acl_type_t type, \ struct acl *aclp); } 350 STD BSD { int __acl_set_fd(int filedes, acl_type_t type, \ struct acl *aclp); } 351 STD BSD { int __acl_delete_file(const char *path, \ acl_type_t type); } 352 STD BSD { int __acl_delete_fd(int filedes, acl_type_t type); } 353 STD BSD { int __acl_aclcheck_file(const char *path, \ acl_type_t type, struct acl *aclp); } 354 STD BSD { int __acl_aclcheck_fd(int filedes, acl_type_t type, \ struct acl *aclp); } 355 STD BSD { int extattrctl(const char *path, int cmd, \ const char *attrname, char *arg); } 356 STD BSD { int extattr_set_file(const char *path, \ const char *attrname, struct iovec *iovp, \ unsigned iovcnt); } 357 STD BSD { int extattr_get_file(const char *path, \ const char *attrname, struct iovec *iovp, \ unsigned iovcnt); } 358 STD BSD { int extattr_delete_file(const char *path, \ const char *attrname); } 359 STD BSD { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); } 360 STD BSD { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); } 361 STD BSD { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); } 362 STD BSD { int kqueue(void); } 363 STD BSD { int kevent(int fd, \ const struct kevent *changelist, int nchanges, \ struct kevent *eventlist, int nevents, \ const struct timespec *timeout); } 364 STD BSD { int __cap_get_proc(struct cap *cap_p); } 365 STD BSD { int __cap_set_proc(struct cap *cap_p); } 366 STD BSD { int __cap_get_fd(int fd, struct cap *cap_p); } 367 STD BSD { int __cap_get_file(const char *path_p, struct cap *cap_p); } 368 STD BSD { int __cap_set_fd(int fd, struct cap *cap_p); } 369 STD BSD { int __cap_set_file(const char *path_p, struct cap *cap_p); } Index: head/sys/svr4/syscalls.master =================================================================== --- head/sys/svr4/syscalls.master (revision 64000) +++ head/sys/svr4/syscalls.master (revision 64001) @@ -1,366 +1,366 @@ $FreeBSD$ ; from: @(#)syscalls.master 8.1 (Berkeley) 7/19/93 ; ; System call name/number master file (or rather, slave, from SVR4). ; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only ; #ifdef's, etc. may be included, and are copied to the output files. #include #include #include #include #include #include #include #include 0 UNIMPL SVR4 unused -1 NOPROTO POSIX { void sys_exit(int rval); } sys_exit sys_exit_args void +1 NOPROTO POSIX { void sys_exit(int rval); } exit sys_exit_args void 2 NOPROTO POSIX { int fork(void); } 3 NOPROTO POSIX { int read(int fd, char *buf, u_int nbyte); } 4 NOPROTO SVR4 { int write(int fd, char *buf, u_int nbyte); } 5 STD SVR4 { int svr4_sys_open(char *path, int flags, int mode); } 6 NOPROTO SVR4 { int close(int fd); } 7 STD SVR4 { int svr4_sys_wait(int *status); } 8 STD SVR4 { int svr4_sys_creat(char *path, int mode); } 9 NOPROTO SVR4 { int link(char *path, char *link); } 10 NOPROTO SVR4 { int unlink(char *path); } 11 STD SVR4 { int svr4_sys_execv(char *path, char **argp); } 12 NOPROTO SVR4 { int chdir(char *path); } 13 STD SVR4 { int svr4_sys_time(time_t *t); } 14 STD SVR4 { int svr4_sys_mknod(char* path, int mode, int dev); } 15 NOPROTO SVR4 { int chmod(char *path, int mode); } 16 NOPROTO SVR4 { int chown(char *path, uid_t uid, gid_t gid); } 17 STD SVR4 { int svr4_sys_break(caddr_t nsize); } 18 STD SVR4 { int svr4_sys_stat(char* path, \ struct svr4_stat* ub); } 19 NOPROTO SVR4 { int lseek(int filedes, off_t *offset, int whence); } 20 NOPROTO SVR4 { pid_t getpid(void); } 21 UNIMPL SVR4 old_mount 22 UNIMPL SVR4 sysv_umount 23 NOPROTO SVR4 { int setuid(uid_t uid); } 24 NOPROTO SVR4 { uid_t getuid(void); } 25 UNIMPL SVR4 stime 26 UNIMPL SVR4 ptrace 27 STD SVR4 { int svr4_sys_alarm(unsigned sec); } 28 STD SVR4 { int svr4_sys_fstat(int fd, struct svr4_stat *sb); } 29 STD SVR4 { int svr4_sys_pause(void); } 30 STD SVR4 { int svr4_sys_utime(char *path, \ struct svr4_utimbuf *ubuf); } 31 UNIMPL SVR4 stty 32 UNIMPL SVR4 gtty 33 STD SVR4 { int svr4_sys_access(char *path, int flags); } 34 STD SVR4 { int svr4_sys_nice(int prio); } 35 UNIMPL SVR4 statfs 36 NOPROTO SVR4 { int sync(void); } 37 STD SVR4 { int svr4_sys_kill(int pid, int signum); } 38 UNIMPL SVR4 fstatfs 39 STD SVR4 { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); } 40 UNIMPL SVR4 xenix 41 NOPROTO SVR4 { int dup(u_int fd); } 42 NOPROTO SVR4 { int pipe(void); } 43 STD SVR4 { int svr4_sys_times(struct tms *tp); } 44 UNIMPL SVR4 profil 45 UNIMPL SVR4 plock 46 NOPROTO SVR4 { int setgid(gid_t gid); } 47 NOPROTO SVR4 { gid_t getgid(void); } 48 STD SVR4 { int svr4_sys_signal(int signum, \ svr4_sig_t handler); } #if defined(NOTYET) 49 STD SVR4 { int svr4_sys_msgsys(int what, int a2, int a3, \ int a4, int a5); } #else 49 UNIMPL SVR4 msgsys #endif 50 STD SVR4 { int svr4_sys_sysarch(int op, void *a1); } 51 UNIMPL SVR4 acct 52 UNIMPL SVR4 shmsys 53 UNIMPL SVR4 semsys 54 STD SVR4 { int svr4_sys_ioctl(int fd, u_long com, \ caddr_t data); } 55 UNIMPL SVR4 uadmin 56 UNIMPL SVR4 exch 57 STD SVR4 { int svr4_sys_utssys(void *a1, void *a2, int sel, \ void *a3); } 58 NOPROTO SVR4 { int fsync(int fd); } 59 STD SVR4 { int svr4_sys_execve(char *path, char **argp, \ char **envp); } 60 NOPROTO SVR4 { int umask(int newmask); } 61 NOPROTO SVR4 { int chroot(char *path); } 62 STD SVR4 { int svr4_sys_fcntl(int fd, int cmd, char *arg); } 63 STD SVR4 { int svr4_sys_ulimit(int cmd, long newlimit); } 64 UNIMPL SVR4 reserved 65 UNIMPL SVR4 reserved 66 UNIMPL SVR4 reserved 67 UNIMPL SVR4 reserved 68 UNIMPL SVR4 reserved 69 UNIMPL SVR4 reserved 70 UNIMPL SVR4 advfs 71 UNIMPL SVR4 unadvfs 72 UNIMPL SVR4 rmount 73 UNIMPL SVR4 rumount 74 UNIMPL SVR4 rfstart 75 UNIMPL SVR4 sigret 76 UNIMPL SVR4 rdebug 77 UNIMPL SVR4 rfstop 78 UNIMPL SVR4 rfsys 79 NOPROTO SVR4 { int rmdir(char *path); } 80 NOPROTO SVR4 { int mkdir(char *path, int mode); } 81 STD SVR4 { int svr4_sys_getdents(int fd, char *buf, \ int nbytes); } 82 UNIMPL SVR4 libattach 83 UNIMPL SVR4 libdetach 84 UNIMPL SVR4 sysfs 85 STD SVR4 { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \ struct svr4_strbuf *dat, int *flags); } 86 STD SVR4 { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \ struct svr4_strbuf *dat, int flags); } 87 STD SVR4 { int svr4_sys_poll(struct pollfd *fds, unsigned int nfds, \ int timeout); } 88 STD SVR4 { int svr4_sys_lstat(char *path, \ struct svr4_stat *ub); } 89 NOPROTO SVR4 { int symlink(char *path, char *link); } 90 NOPROTO SVR4 { int readlink(char *path, char *buf, int count); } 91 NOPROTO SVR4 { int getgroups(u_int gidsetsize, gid_t *gidset); } 92 NOPROTO SVR4 { int setgroups(u_int gidsetsize, gid_t *gidset); } 93 NOPROTO SVR4 { int fchmod(int fd, int mode); } 94 NOPROTO SVR4 { int fchown(int fd, int uid, int gid); } 95 STD SVR4 { int svr4_sys_sigprocmask(int how, \ svr4_sigset_t *set, svr4_sigset_t *oset); } 96 STD SVR4 { int svr4_sys_sigsuspend(svr4_sigset_t *ss); } 97 STD SVR4 { int svr4_sys_sigaltstack( \ struct svr4_sigaltstack *nss, \ struct svr4_sigaltstack *oss); } 98 STD SVR4 { int svr4_sys_sigaction(int signum, \ struct svr4_sigaction *nsa, \ struct svr4_sigaction *osa); } 99 STD SVR4 { int svr4_sys_sigpending(int what, \ svr4_sigset_t *mask); } 100 STD SVR4 { int svr4_sys_context(int func, \ struct svr4_ucontext *uc); } 101 UNIMPL SVR4 evsys 102 UNIMPL SVR4 evtrapret 103 STD SVR4 { int svr4_sys_statvfs(char *path, \ struct svr4_statvfs *fs); } 104 STD SVR4 { int svr4_sys_fstatvfs(int fd, \ struct svr4_statvfs *fs); } 105 UNIMPL SVR4 whoknows 106 UNIMPL SVR4 nfssvc 107 STD SVR4 { int svr4_sys_waitsys(int grp, int id, \ union svr4_siginfo *info, int options); } 108 UNIMPL SVR4 sigsendsys 109 STD SVR4 { int svr4_sys_hrtsys(int cmd, int fun, int sub, \ void *rv1, void *rv2); } 110 UNIMPL SVR4 acancel 111 UNIMPL SVR4 async 112 UNIMPL SVR4 priocntlsys 113 STD SVR4 { int svr4_sys_pathconf(char *path, int name); } 114 UNIMPL SVR4 mincore 115 STD SVR4 { caddr_t svr4_sys_mmap( caddr_t addr, svr4_size_t len, \ int prot, int flags, int fd, svr4_off_t pos); } 116 NOPROTO SVR4 { int mprotect(void *addr, int len, int prot); } 117 NOPROTO SVR4 { int munmap(void *addr, int len); } 118 STD SVR4 { int svr4_sys_fpathconf(int fd, int name); } 119 NOPROTO SVR4 { int vfork(void); } 120 NOPROTO SVR4 { int fchdir(int fd); } 121 NOPROTO SVR4 { int readv(int fd, struct iovec *iovp, \ u_int iovcnt); } 122 NOPROTO SVR4 { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 123 STD SVR4 { int svr4_sys_xstat(int two, char *path, \ struct svr4_xstat *ub); } 124 STD SVR4 { int svr4_sys_lxstat(int two, char *path, \ struct svr4_xstat *ub); } 125 STD SVR4 { int svr4_sys_fxstat(int two, int fd, \ struct svr4_xstat *sb); } 126 STD SVR4 { int svr4_sys_xmknod(int two, char *path, \ svr4_mode_t mode, svr4_dev_t dev); } 127 UNIMPL SVR4 clocal 128 STD SVR4 { int svr4_sys_setrlimit(int which, \ const struct svr4_rlimit *rlp); } 129 STD SVR4 { int svr4_sys_getrlimit(int which, \ struct svr4_rlimit *rlp); } 130 NOPROTO SVR4 { int lchown(char *path, uid_t uid, gid_t gid); } 131 STD SVR4 { int svr4_sys_memcntl(void * addr, \ svr4_size_t len, int cmd, void * arg, \ int attr, int mask); } 132 UNIMPL SVR4 getpmsg 133 UNIMPL SVR4 putpmsg 134 NOPROTO SVR4 { int rename(char *from, char *to); } 135 STD SVR4 { int svr4_sys_uname(struct svr4_utsname* name, \ int dummy); } 136 NOPROTO SVR4 { int setegid(gid_t egid); } 137 STD SVR4 { int svr4_sys_sysconfig(int name); } 138 NOPROTO SVR4 { int adjtime(struct timeval *delta, \ struct timeval *olddelta); } 139 STD SVR4 { long svr4_sys_systeminfo(int what, char *buf, \ long len); } 140 UNIMPL SVR4 notused 141 NOPROTO SVR4 { int seteuid(uid_t euid); } 142 UNIMPL SVR4 vtrace ; fork1 143 UNIMPL SVR4 { int fork(void); } 144 UNIMPL SVR4 sigtimedwait 145 UNIMPL SVR4 lwp_info 146 UNIMPL SVR4 yield 147 UNIMPL SVR4 lwp_sema_wait 148 UNIMPL SVR4 lwp_sema_post 149 UNIMPL SVR4 lwp_sema_trywait 150 UNIMPL SVR4 notused 151 UNIMPL SVR4 notused 152 UNIMPL SVR4 modctl 153 STD SVR4 { int svr4_sys_fchroot(int fd); } 154 STD SVR4 { int svr4_sys_utimes(char *path, \ struct timeval *tptr); } 155 STD SVR4 { int svr4_sys_vhangup(void); } 156 STD SVR4 { int svr4_sys_gettimeofday(struct timeval *tp); } 157 NOPROTO SVR4 { int getitimer(u_int which, struct itimerval *itv); } 158 NOPROTO SVR4 { int setitimer(u_int which, struct itimerval *itv, \ struct itimerval *oitv); } 159 UNIMPL SVR4 lwp_create 160 UNIMPL SVR4 lwp_exit 161 UNIMPL SVR4 lwp_suspend 162 UNIMPL SVR4 lwp_continue 163 UNIMPL SVR4 lwp_kill 164 UNIMPL SVR4 lwp_self 165 UNIMPL SVR4 lwp_getprivate 166 UNIMPL SVR4 lwp_setprivate 167 UNIMPL SVR4 lwp_wait 168 UNIMPL SVR4 lwp_mutex_unlock 169 UNIMPL SVR4 lwp_mutex_lock 170 UNIMPL SVR4 lwp_cond_wait 171 UNIMPL SVR4 lwp_cond_signal 172 UNIMPL SVR4 lwp_cond_broadcast 173 UNIMPL SVR4 { ssize_t svr4_sys_pread(int fd, void *buf, \ size_t nbyte, svr4_off_t off); } 174 UNIMPL SVR4 { ssize_t svr4_sys_pwrite(int fd, const void *buf, \ size_t nbyte, svr4_off_t off); } 175 STD SVR4 { svr4_off64_t svr4_sys_llseek(int fd, long offset1, \ long offset2, int whence); } 176 UNIMPL SVR4 inst_sync 177 UNIMPL SVR4 whoknows 178 UNIMPL SVR4 kaio 179 UNIMPL SVR4 whoknows 180 UNIMPL SVR4 whoknows 181 UNIMPL SVR4 whoknows 182 UNIMPL SVR4 whoknows 183 UNIMPL SVR4 whoknows 184 UNIMPL SVR4 tsolsys 185 STD SVR4 { int svr4_sys_acl(char *path, int cmd, int num, \ struct svr4_aclent *buf); } 186 STD SVR4 { int svr4_sys_auditsys(int code, int a1, int a2, \ int a3, int a4, int a5); } 187 UNIMPL SVR4 processor_bind 188 UNIMPL SVR4 processor_info 189 UNIMPL SVR4 p_online 190 UNIMPL SVR4 sigqueue 191 UNIMPL SVR4 clock_gettime 192 UNIMPL SVR4 clock_settime 193 UNIMPL SVR4 clock_getres 194 UNIMPL SVR4 timer_create 195 UNIMPL SVR4 timer_delete 196 UNIMPL SVR4 timer_settime 197 UNIMPL SVR4 timer_gettime 198 UNIMPL SVR4 timer_overrun 199 NOPROTO SVR4 { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } 200 STD SVR4 { int svr4_sys_facl(int fd, int cmd, int num, \ struct svr4_aclent *buf); } 201 UNIMPL SVR4 door 202 NOPROTO SVR4 { int setreuid(int ruid, int euid); } 203 NOPROTO SVR4 { int setregid(int rgid, int egid); } 204 UNIMPL SVR4 install_utrap 205 UNIMPL SVR4 signotify 206 UNIMPL SVR4 schedctl 207 UNIMPL SVR4 pset 208 UNIMPL SVR4 whoknows 209 STD SVR4 { int svr4_sys_resolvepath(const char *path, \ char *buf, size_t bufsiz); } 210 UNIMPL SVR4 signotifywait 211 UNIMPL SVR4 lwp_sigredirect 212 UNIMPL SVR4 lwp_alarm 213 STD SVR4 { int svr4_sys_getdents64(int fd, \ struct svr4_dirent64 *dp, \ int nbytes); } ;213 UNIMPL SVR4 getdents64 214 STD SVR4 { caddr_t svr4_sys_mmap64(void *addr, \ svr4_size_t len, int prot, int flags, int fd, \ svr4_off64_t pos); } 215 STD SVR4 { int svr4_sys_stat64(char *path, \ struct svr4_stat64 *sb); } 216 STD SVR4 { int svr4_sys_lstat64(char *path, \ struct svr4_stat64 *sb); } 217 STD SVR4 { int svr4_sys_fstat64(int fd, \ struct svr4_stat64 *sb); } 218 STD SVR4 { int svr4_sys_statvfs64(char *path, \ struct svr4_statvfs64 *fs); } 219 STD SVR4 { int svr4_sys_fstatvfs64(int fd, \ struct svr4_statvfs64 *fs); } 220 STD SVR4 { int svr4_sys_setrlimit64(int which, \ const struct svr4_rlimit64 *rlp); } 221 STD SVR4 { int svr4_sys_getrlimit64(int which, \ struct svr4_rlimit64 *rlp); } 222 UNIMPL SVR4 pread64 223 UNIMPL SVR4 pwrite64 224 STD SVR4 { int svr4_sys_creat64(char *path, int mode); } 225 STD SVR4 { int svr4_sys_open64(char *path, int flags, \ int mode); } 226 UNIMPL SVR4 rpcsys 227 UNIMPL SVR4 whoknows 228 UNIMPL SVR4 whoknows 229 UNIMPL SVR4 whoknows 230 STD SVR4 { int svr4_sys_socket(int domain, int type, \ int protocol); } 231 NOPROTO SVR4 { int socketpair(int domain, int type, \ int protocol, int *rsv); } 232 NOPROTO SVR4 { int bind(int s, const struct sockaddr *name, \ int namelen); } 233 NOPROTO SVR4 { int listen(int s, int backlog); } 234 NOPROTO SVR4 { int accept(int s, struct sockaddr *name, \ int *anamelen); } 235 NOPROTO SVR4 { int connect(int s, const struct sockaddr *name, \ int namelen); } 236 NOPROTO SVR4 { int shutdown(int s, int how); } 237 STD SVR4 { int svr4_sys_recv(int s, caddr_t buf, int len, int flags); } 238 NOPROTO SVR4 { ssize_t recvfrom(int s, void *buf, size_t len, \ int flags, struct sockaddr *from, \ int *fromlenaddr); } 239 NOPROTO SVR4 { ssize_t recvmsg(int s, struct msghdr *msg, \ int flags); } 240 STD SVR4 { int svr4_sys_send(int s, caddr_t buf, int len, int flags); } 241 NOPROTO SVR4 { ssize_t sendmsg(int s, const struct msghdr *msg, \ int flags); } 242 STD SVR4 { ssize_t svr4_sys_sendto(int s, void *buf, \ size_t len, int flags, \ struct sockaddr *to, int tolen); } 243 NOPROTO SVR4 { int getpeername(int fdes, struct sockaddr *asa, \ int *alen); } 244 NOPROTO SVR4 { int getsockname(int fdes, struct sockaddr *asa, \ int *alen); } 245 NOPROTO SVR4 { int getsockopt(int s, int level, int name, \ void *val, int *avalsize); } 246 NOPROTO SVR4 { int setsockopt(int s, int level, int name, \ const void *val, int valsize); } 247 UNIMPL SVR4 sockconfig 248 UNIMPL SVR4 { int ntp_gettime(struct ntptimeval *ntvp); } 249 UNIMPL SVR4 { int ntp_adjtime(struct timex *tp); }