From 948bb6a23548088615acb8d979b7aa5398b73f72 Mon Sep 17 00:00:00 2001 From: Sascha Wildner Date: Tue, 26 Nov 2013 19:24:37 +0100 Subject: [PATCH] Remove the header file. Nothing includes it, nor are the HIDE_BSD() and HIDE_POSIX() macros actually defined anywhere. Also, remove support for the associated POSIX, BSD and NOHIDE keywords from the syscalls.master files. It makes the patch quite large due to touching most lines in the syscalls.master files but it results in zero changes in the generated files. --- Makefile_upgrade.inc | 1 + share/man/man9/syscall.9 | 6 +- sys/emulation/linux/i386/syscalls.conf | 2 - sys/emulation/linux/i386/syscalls.master | 687 +++++++------- sys/kern/Makefile.misc | 4 - sys/kern/makesyscalls.sh | 36 +- sys/kern/syscalls.master | 1078 +++++++++++----------- sys/sys/syscall-hide.h | 369 -------- test/debug/chkincludes | 11 - usr.bin/truss/i386.conf | 2 - usr.bin/truss/i386linux.conf | 2 - 11 files changed, 890 insertions(+), 1308 deletions(-) delete mode 100644 sys/sys/syscall-hide.h diff --git a/Makefile_upgrade.inc b/Makefile_upgrade.inc index aee83afea8..e41426a6ca 100644 --- a/Makefile_upgrade.inc +++ b/Makefile_upgrade.inc @@ -2354,6 +2354,7 @@ TO_REMOVE+=/usr/share/vi/catalog/sv_SE.ISO_8859-15 TO_REMOVE+=/usr/share/man/cat9/idr_init1.9.gz TO_REMOVE+=/usr/share/man/man9/idr_init1.9.gz TO_REMOVE+=/boot/kernel/radeon.ko +TO_REMOVE+=/usr/include/sys/syscall-hide.h .if ${MACHINE_ARCH} == "x86_64" TO_REMOVE+=/usr/sbin/stlstats diff --git a/share/man/man9/syscall.9 b/share/man/man9/syscall.9 index 8b939d8cd0..11e86ab153 100644 --- a/share/man/man9/syscall.9 +++ b/share/man/man9/syscall.9 @@ -56,14 +56,12 @@ system call. Lines may be split by the means of back slashing the end of the line. Each line is a set of fields separated by whitespace: .Pp -.D1 Cd number type namespace ... +.D1 Cd number type ... .Pp Where: -.Bl -tag -width namespace -compact +.Bl -tag -width number -compact .It number is the system call number; -.It namespace -is one of POSIX, BSD, NOHIDE; .It type is one of: .Bl -tag -width NOPROTO -compact diff --git a/sys/emulation/linux/i386/syscalls.conf b/sys/emulation/linux/i386/syscalls.conf index 1edea4d8c5..b641dfa4b7 100644 --- a/sys/emulation/linux/i386/syscalls.conf +++ b/sys/emulation/linux/i386/syscalls.conf @@ -1,5 +1,4 @@ # $FreeBSD: src/sys/i386/linux/syscalls.conf,v 1.5 1999/08/28 00:45:25 peter Exp $ -# $DragonFly: src/sys/emulation/linux/i386/syscalls.conf,v 1.4 2004/11/14 01:41:41 dillon Exp $ sysnames="/dev/null" sysproto="linux_proto.h" sysunion="linux_union.h" @@ -7,7 +6,6 @@ sysproto_h=_LINUX_SYSPROTO_H_ syshdr="linux_syscall.h" syssw="linux_sysent.c" sysmk="/dev/null" -syshide="/dev/null" sysargs="/dev/null" syscallprefix="LINUX_SYS_" switchname="linux_sysent" diff --git a/sys/emulation/linux/i386/syscalls.master b/sys/emulation/linux/i386/syscalls.master index a5e945107f..9fff31ba3b 100644 --- a/sys/emulation/linux/i386/syscalls.master +++ b/sys/emulation/linux/i386/syscalls.master @@ -6,7 +6,6 @@ ; 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 @@ -36,454 +35,454 @@ ; #ifdef's, etc. may be included, and are copied to the output files. -0 UNIMPL LINUX setup -1 NOPROTO LINUX { void exit(int rval); } -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, l_int flags, \ +0 UNIMPL setup +1 NOPROTO { void exit(int rval); } +2 STD { int linux_fork(void); } +3 NOPROTO { int read(int fd, char *buf, u_int nbyte); } +4 NOPROTO { int write(int fd, char *buf, u_int nbyte); } +5 STD { int linux_open(char *path, l_int flags, \ l_int mode); } -6 NOPROTO LINUX { int close(int fd); } -7 STD LINUX { int linux_waitpid(l_pid_t pid, l_int *status, \ +6 NOPROTO { int close(int fd); } +7 STD { int linux_waitpid(l_pid_t pid, l_int *status, \ l_int options); } -8 STD LINUX { int linux_creat(char *path, l_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, \ +8 STD { int linux_creat(char *path, l_int mode); } +9 STD { int linux_link(char *path, char *to); } +10 STD { int linux_unlink(char *path); } +11 STD { int linux_execve(char *path, char **argp, \ char **envp); } -12 STD LINUX { int linux_chdir(char *path); } -13 STD LINUX { int linux_time(l_time_t *tm); } -14 STD LINUX { int linux_mknod(char *path, l_int mode, \ +12 STD { int linux_chdir(char *path); } +13 STD { int linux_time(l_time_t *tm); } +14 STD { int linux_mknod(char *path, l_int mode, \ l_dev_t dev); } -15 STD LINUX { int linux_chmod(char *path, l_mode_t mode); } -16 STD LINUX { int linux_lchown16(char *path, l_uid16_t uid, \ +15 STD { int linux_chmod(char *path, l_mode_t mode); } +16 STD { int linux_lchown16(char *path, l_uid16_t uid, \ l_gid16_t gid); } -17 UNIMPL LINUX break -18 STD LINUX { int linux_stat(char *path, struct ostat *statbuf); } -19 STD LINUX { int linux_lseek(l_uint fdes, l_off_t off, \ +17 UNIMPL break +18 STD { int linux_stat(char *path, struct ostat *statbuf); } +19 STD { int linux_lseek(l_uint fdes, l_off_t off, \ l_int whence); } -20 STD LINUX { int linux_getpid(void); } -21 STD LINUX { int linux_mount(char *specialfile, char *dir, \ +20 STD { int linux_getpid(void); } +21 STD { int linux_mount(char *specialfile, char *dir, \ char *filesystemtype, l_ulong rwflag, \ void *data); } -22 STD LINUX { int linux_oldumount(char *path); } -23 STD LINUX { int linux_setuid16(l_uid16_t uid); } -24 STD LINUX { int linux_getuid16(void); } -25 STD LINUX { int linux_stime(void); } -26 STD LINUX { int linux_ptrace(l_long req, l_long pid, l_long addr, \ - l_long data); } -27 STD LINUX { int linux_alarm(l_uint secs); } -28 STD LINUX { int linux_fstat(l_uint fd, struct ostat *up); } -29 STD LINUX { int linux_pause(void); } -30 STD LINUX { int linux_utime(char *fname, \ +22 STD { int linux_oldumount(char *path); } +23 STD { int linux_setuid16(l_uid16_t uid); } +24 STD { int linux_getuid16(void); } +25 STD { int linux_stime(void); } +26 STD { int linux_ptrace(l_long req, l_long pid, l_long addr, \ + l_long data); } +27 STD { int linux_alarm(l_uint secs); } +28 STD { int linux_fstat(l_uint fd, struct ostat *up); } +29 STD { int linux_pause(void); } +30 STD { int linux_utime(char *fname, \ struct l_utimbuf *times); } -31 UNIMPL LINUX stty -32 UNIMPL LINUX gtty -33 STD LINUX { int linux_access(char *path, l_int flags); } -34 STD LINUX { int linux_nice(l_int inc); } -35 UNIMPL LINUX ftime -36 NOPROTO LINUX { int sync(void); } -37 STD LINUX { int linux_kill(l_int pid, l_int signum); } -38 STD LINUX { int linux_rename(char *from, char *to); } -39 STD LINUX { int linux_mkdir(char *path, l_int mode); } -40 STD LINUX { int linux_rmdir(char *path); } -41 NOPROTO LINUX { int dup(u_int fd); } -42 STD LINUX { int linux_pipe(l_ulong *pipefds); } -43 STD LINUX { int linux_times(struct l_times_argv *buf); } -44 UNIMPL LINUX prof -45 STD LINUX { int linux_brk(l_ulong dsend); } -46 STD LINUX { int linux_setgid16(l_gid16_t gid); } -47 STD LINUX { int linux_getgid16(void); } -48 STD LINUX { int linux_signal(l_int sig, l_handler_t handler); } -49 STD LINUX { int linux_geteuid16(void); } -50 STD LINUX { int linux_getegid16(void); } -51 NOPROTO LINUX { int acct(char *path); } -52 STD LINUX { int linux_umount(char *path, l_int flags); } -53 UNIMPL LINUX lock -54 STD LINUX { int linux_ioctl(l_uint fd, l_uint cmd, \ +31 UNIMPL stty +32 UNIMPL gtty +33 STD { int linux_access(char *path, l_int flags); } +34 STD { int linux_nice(l_int inc); } +35 UNIMPL ftime +36 NOPROTO { int sync(void); } +37 STD { int linux_kill(l_int pid, l_int signum); } +38 STD { int linux_rename(char *from, char *to); } +39 STD { int linux_mkdir(char *path, l_int mode); } +40 STD { int linux_rmdir(char *path); } +41 NOPROTO { int dup(u_int fd); } +42 STD { int linux_pipe(l_ulong *pipefds); } +43 STD { int linux_times(struct l_times_argv *buf); } +44 UNIMPL prof +45 STD { int linux_brk(l_ulong dsend); } +46 STD { int linux_setgid16(l_gid16_t gid); } +47 STD { int linux_getgid16(void); } +48 STD { int linux_signal(l_int sig, l_handler_t handler); } +49 STD { int linux_geteuid16(void); } +50 STD { int linux_getegid16(void); } +51 NOPROTO { int acct(char *path); } +52 STD { int linux_umount(char *path, l_int flags); } +53 UNIMPL lock +54 STD { int linux_ioctl(l_uint fd, l_uint cmd, \ l_ulong arg); } -55 STD LINUX { int linux_fcntl(l_uint fd, l_uint cmd, \ +55 STD { int linux_fcntl(l_uint fd, l_uint cmd, \ l_ulong arg); } -56 UNIMPL LINUX mpx -57 NOPROTO LINUX { int setpgid(int pid, int pgid); } -58 UNIMPL LINUX ulimit -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(l_dev_t dev, struct l_ustat *ubuf); } -63 NOPROTO LINUX { int dup2(u_int from, u_int to); } -64 STD LINUX { int linux_getppid(void); } -65 NOPROTO LINUX { int getpgrp(void); } -66 NOPROTO LINUX { int setsid(void); } -67 STD LINUX { int linux_sigaction(l_int sig, l_osigaction_t *nsa, \ +56 UNIMPL mpx +57 NOPROTO { int setpgid(int pid, int pgid); } +58 UNIMPL ulimit +59 STD { int linux_olduname(void); } +60 NOPROTO { int umask(int newmask); } +61 NOPROTO { int chroot(char *path); } +62 STD { int linux_ustat(l_dev_t dev, struct l_ustat *ubuf); } +63 NOPROTO { int dup2(u_int from, u_int to); } +64 STD { int linux_getppid(void); } +65 NOPROTO { int getpgrp(void); } +66 NOPROTO { int setsid(void); } +67 STD { int linux_sigaction(l_int sig, l_osigaction_t *nsa, \ l_osigaction_t *osa); } -68 STD LINUX { int linux_sgetmask(void); } -69 STD LINUX { int linux_ssetmask(l_osigset_t mask); } -70 STD LINUX { int linux_setreuid16(l_uid16_t ruid, \ +68 STD { int linux_sgetmask(void); } +69 STD { int linux_ssetmask(l_osigset_t mask); } +70 STD { int linux_setreuid16(l_uid16_t ruid, \ l_uid16_t euid); } -71 STD LINUX { int linux_setregid16(l_gid16_t rgid, \ +71 STD { int linux_setregid16(l_gid16_t rgid, \ l_gid16_t egid); } -72 STD LINUX { int linux_sigsuspend(l_int hist0, l_int hist1, \ +72 STD { int linux_sigsuspend(l_int hist0, l_int hist1, \ l_osigset_t mask); } -73 STD LINUX { int linux_sigpending(l_osigset_t *mask); } -74 STD LINUX { int linux_sethostname(char *hostname, u_int len); } -75 STD LINUX { int linux_setrlimit(l_uint resource, \ +73 STD { int linux_sigpending(l_osigset_t *mask); } +74 STD { int linux_sethostname(char *hostname, u_int len); } +75 STD { int linux_setrlimit(l_uint resource, \ struct l_rlimit *rlim); } -76 STD LINUX { int linux_old_getrlimit(l_uint resource, \ +76 STD { int linux_old_getrlimit(l_uint resource, \ struct l_rlimit *rlim); } -77 NOPROTO LINUX { int getrusage(int who, struct rusage *rusage); } -78 NOPROTO LINUX { int gettimeofday(struct timeval *tp, \ +77 NOPROTO { int getrusage(int who, struct rusage *rusage); } +78 NOPROTO { int gettimeofday(struct timeval *tp, \ struct timezone *tzp); } -79 NOPROTO LINUX { int settimeofday(struct timeval *tp, \ +79 NOPROTO { int settimeofday(struct timeval *tp, \ struct timezone *tzp); } -80 STD LINUX { int linux_getgroups16(l_uint gidsetsize, \ +80 STD { int linux_getgroups16(l_uint gidsetsize, \ l_gid16_t *gidset); } -81 STD LINUX { int linux_setgroups16(l_uint gidsetsize, \ +81 STD { int linux_setgroups16(l_uint gidsetsize, \ l_gid16_t *gidset); } -82 STD LINUX { int linux_old_select(struct l_old_select_argv \ +82 STD { int linux_old_select(struct l_old_select_argv \ *ptr); } -83 STD LINUX { int linux_symlink(char *path, char *to); } -84 STD LINUX { int linux_ostat(char *path, struct ostat *statbuf); } -85 STD LINUX { int linux_readlink(char *name, char *buf, \ +83 STD { int linux_symlink(char *path, char *to); } +84 STD { int linux_ostat(char *path, struct ostat *statbuf); } +85 STD { int linux_readlink(char *name, char *buf, \ l_int count); } -86 STD LINUX { int linux_uselib(char *library); } -87 NOPROTO LINUX { int swapon(char *name); } -88 STD LINUX { int linux_reboot(l_int magic1, l_int magic2, \ +86 STD { int linux_uselib(char *library); } +87 NOPROTO { int swapon(char *name); } +88 STD { int linux_reboot(l_int magic1, l_int magic2, \ l_uint cmd, void *arg); } -89 STD LINUX { int linux_readdir(l_uint fd, struct l_dirent *dent, \ +89 STD { int linux_readdir(l_uint fd, struct l_dirent *dent, \ l_uint count); } -90 STD LINUX { int linux_mmap(struct l_mmap_argv *ptr); } -91 NOPROTO LINUX { int munmap(caddr_t addr, int len); } -92 STD LINUX { int linux_truncate(char *path, l_ulong length); } -93 STD LINUX { int linux_ftruncate(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 UNIMPL LINUX profil -99 STD LINUX { int linux_statfs(char *path, \ +90 STD { int linux_mmap(struct l_mmap_argv *ptr); } +91 NOPROTO { int munmap(caddr_t addr, int len); } +92 STD { int linux_truncate(char *path, l_ulong length); } +93 STD { int linux_ftruncate(int fd, long length); } +94 NOPROTO { int fchmod(int fd, int mode); } +95 NOPROTO { int fchown(int fd, int uid, int gid); } +96 NOPROTO { int getpriority(int which, int who); } +97 NOPROTO { int setpriority(int which, int who, int prio); } +98 UNIMPL profil +99 STD { int linux_statfs(char *path, \ struct l_statfs_buf *buf); } -100 STD LINUX { int linux_fstatfs(l_uint fd, \ +100 STD { int linux_fstatfs(l_uint fd, \ struct l_statfs_buf *buf); } -101 STD LINUX { int linux_ioperm(l_ulong start, l_ulong length, \ +101 STD { int linux_ioperm(l_ulong start, l_ulong length, \ l_int enable); } -102 STD LINUX { int linux_socketcall(l_int what, l_ulong args); } -103 STD LINUX { int linux_syslog(l_int type, char *buf, l_int len); } -104 STD LINUX { int linux_setitimer(l_int which, \ +102 STD { int linux_socketcall(l_int what, l_ulong args); } +103 STD { int linux_syslog(l_int type, char *buf, l_int len); } +104 STD { int linux_setitimer(l_int which, \ struct l_itimerval *itv, \ struct l_itimerval *oitv); } -105 STD LINUX { int linux_getitimer(l_int which, \ +105 STD { int linux_getitimer(l_int which, \ struct l_itimerval *itv); } -106 STD LINUX { int linux_newstat(char *path, \ +106 STD { int linux_newstat(char *path, \ struct l_newstat *buf); } -107 STD LINUX { int linux_newlstat(char *path, \ +107 STD { int linux_newlstat(char *path, \ struct l_newstat *buf); } -108 STD LINUX { int linux_newfstat(l_uint fd, \ +108 STD { int linux_newfstat(l_uint fd, \ struct l_newstat *buf); } -109 STD LINUX { int linux_uname(void); } -110 STD LINUX { int linux_iopl(l_ulong level); } -111 STD LINUX { int linux_vhangup(void); } -112 UNIMPL LINUX idle -113 STD LINUX { int linux_vm86old(void); } -114 STD LINUX { int linux_wait4(l_pid_t pid, l_uint *status, \ +109 STD { int linux_uname(void); } +110 STD { int linux_iopl(l_ulong level); } +111 STD { int linux_vhangup(void); } +112 UNIMPL idle +113 STD { int linux_vm86old(void); } +114 STD { int linux_wait4(l_pid_t pid, l_uint *status, \ l_int options, struct l_rusage *rusage); } -115 STD LINUX { int linux_swapoff(void); } -116 STD LINUX { int linux_sysinfo(struct l_sysinfo *info); } -117 STD LINUX { int linux_ipc(l_uint what, l_int arg1, l_int arg2, \ +115 STD { int linux_swapoff(void); } +116 STD { int linux_sysinfo(struct l_sysinfo *info); } +117 STD { int linux_ipc(l_uint what, l_int arg1, l_int arg2, \ l_int arg3, void *ptr, l_long arg5); } -118 NOPROTO LINUX { int fsync(int fd); } -119 STD LINUX { int linux_sigreturn(struct l_sigframe *sfp); } -120 STD LINUX { int linux_clone(l_int flags, void *stack, \ +118 NOPROTO { int fsync(int fd); } +119 STD { int linux_sigreturn(struct l_sigframe *sfp); } +120 STD { int linux_clone(l_int flags, void *stack, \ void *parent_tidptr, int dummy, void *child_tidptr); } -121 NOPROTO LINUX { int setdomainname(char *name, int len); } -122 STD LINUX { int linux_newuname(struct l_new_utsname *buf); } -123 STD LINUX { int linux_modify_ldt(l_int func, void *ptr, \ +121 NOPROTO { int setdomainname(char *name, int len); } +122 STD { int linux_newuname(struct l_new_utsname *buf); } +123 STD { int linux_modify_ldt(l_int func, void *ptr, \ l_ulong 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(l_int how, l_osigset_t *mask, \ +124 STD { int linux_adjtimex(void); } +125 NOPROTO { int mprotect(caddr_t addr, int len, int prot); } +126 STD { int linux_sigprocmask(l_int how, l_osigset_t *mask, \ l_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 NOPROTO LINUX { int getpgid(int pid); } -133 NOPROTO LINUX { int fchdir(int fd); } -134 STD LINUX { int linux_bdflush(void); } -135 STD LINUX { int linux_sysfs(l_int option, l_ulong arg1, \ +127 STD { int linux_create_module(void); } +128 STD { int linux_init_module(void); } +129 STD { int linux_delete_module(void); } +130 STD { int linux_get_kernel_syms(void); } +131 STD { int linux_quotactl(void); } +132 NOPROTO { int getpgid(int pid); } +133 NOPROTO { int fchdir(int fd); } +134 STD { int linux_bdflush(void); } +135 STD { int linux_sysfs(l_int option, l_ulong arg1, \ l_ulong arg2); } -136 STD LINUX { int linux_personality(l_ulong per); } -137 UNIMPL LINUX afs_syscall -138 STD LINUX { int linux_setfsuid16(l_uid16_t uid); } -139 STD LINUX { int linux_setfsgid16(l_gid16_t gid); } -140 STD LINUX { int linux_llseek(l_int fd, l_ulong ohigh, \ +136 STD { int linux_personality(l_ulong per); } +137 UNIMPL afs_syscall +138 STD { int linux_setfsuid16(l_uid16_t uid); } +139 STD { int linux_setfsgid16(l_gid16_t gid); } +140 STD { int linux_llseek(l_int fd, l_ulong ohigh, \ l_ulong olow, l_loff_t *res, l_uint whence); } -141 STD LINUX { int linux_getdents(l_uint fd, void *dent, \ +141 STD { int linux_getdents(l_uint fd, void *dent, \ l_uint count); } -142 STD LINUX { int linux_select(l_int nfds, l_fd_set *readfds, \ +142 STD { int linux_select(l_int nfds, l_fd_set *readfds, \ l_fd_set *writefds, l_fd_set *exceptfds, \ struct l_timeval *timeout); } -143 NOPROTO LINUX { int flock(int fd, int how); } -144 STD LINUX { int linux_msync(l_ulong addr, l_size_t len, \ +143 NOPROTO { int flock(int fd, int how); } +144 STD { int linux_msync(l_ulong addr, l_size_t len, \ l_int fl); } -145 NOPROTO LINUX { int readv(int fd, struct iovec *iovp, \ +145 NOPROTO { int readv(int fd, struct iovec *iovp, \ u_int iovcnt); } -146 NOPROTO LINUX { int writev(int fd, struct iovec *iovp, \ +146 NOPROTO { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } -147 STD LINUX { int linux_getsid(l_pid_t pid); } -148 STD LINUX { int linux_fdatasync(l_uint fd); } -149 STD LINUX { int linux_sysctl(struct l___sysctl_args *args); } -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(l_pid_t pid, \ - l_int policy, struct l_sched_param *param); } -157 STD POSIX { int linux_sched_getscheduler(l_pid_t pid); } -158 NOPROTO POSIX { int sched_yield(void); } -159 STD POSIX { int linux_sched_get_priority_max(l_int policy); } -160 STD POSIX { int linux_sched_get_priority_min(l_int policy); } -161 NOPROTO POSIX { int sched_rr_get_interval(l_pid_t pid, \ - struct l_timespec *interval); } -162 NOPROTO POSIX { int nanosleep(const struct timespec *rqtp, \ +147 STD { int linux_getsid(l_pid_t pid); } +148 STD { int linux_fdatasync(l_uint fd); } +149 STD { int linux_sysctl(struct l___sysctl_args *args); } +150 NOPROTO { int mlock(const void *addr, size_t len); } +151 NOPROTO { int munlock(const void *addr, size_t len); } +152 NOPROTO { int mlockall(int how); } +153 NOPROTO { int munlockall(void); } +154 NOPROTO { int sched_setparam(pid_t pid, \ + const struct sched_param *param); } +155 NOPROTO { int sched_getparam(pid_t pid, \ + struct sched_param *param); } +156 STD { int linux_sched_setscheduler(l_pid_t pid, \ + l_int policy, struct l_sched_param *param); } +157 STD { int linux_sched_getscheduler(l_pid_t pid); } +158 NOPROTO { int sched_yield(void); } +159 STD { int linux_sched_get_priority_max(l_int policy); } +160 STD { int linux_sched_get_priority_min(l_int policy); } +161 NOPROTO { int sched_rr_get_interval(l_pid_t pid, \ + struct l_timespec *interval); } +162 NOPROTO { int nanosleep(const struct timespec *rqtp, \ struct timespec *rmtp); } -163 STD LINUX { int linux_mremap(l_ulong addr, l_ulong old_len, \ +163 STD { int linux_mremap(l_ulong addr, l_ulong old_len, \ l_ulong new_len, l_ulong flags, \ l_ulong new_addr); } -164 STD LINUX { int linux_setresuid16(l_uid16_t ruid, \ +164 STD { int linux_setresuid16(l_uid16_t ruid, \ l_uid16_t euid, l_uid16_t suid); } -165 STD LINUX { int linux_getresuid16(l_uid16_t *ruid, \ +165 STD { int linux_getresuid16(l_uid16_t *ruid, \ l_uid16_t *euid, l_uid16_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, \ +166 STD { int linux_vm86(void); } +167 STD { int linux_query_module(void); } +168 NOPROTO { int poll(struct pollfd*, unsigned int nfds, \ long timeout); } -169 STD LINUX { int linux_nfsservctl(void); } -170 STD LINUX { int linux_setresgid16(l_gid16_t rgid, \ +169 STD { int linux_nfsservctl(void); } +170 STD { int linux_setresgid16(l_gid16_t rgid, \ l_gid16_t egid, l_gid16_t sgid); } -171 STD LINUX { int linux_getresgid16(l_gid16_t *rgid, \ +171 STD { int linux_getresgid16(l_gid16_t *rgid, \ l_gid16_t *egid, l_gid16_t *sgid); } -172 STD LINUX { int linux_prctl(void); } -173 STD LINUX { int linux_rt_sigreturn(struct l_ucontext *ucp); } -174 STD LINUX { int linux_rt_sigaction(l_int sig, \ +172 STD { int linux_prctl(void); } +173 STD { int linux_rt_sigreturn(struct l_ucontext *ucp); } +174 STD { int linux_rt_sigaction(l_int sig, \ l_sigaction_t *act, l_sigaction_t *oact, \ l_size_t sigsetsize); } -175 STD LINUX { int linux_rt_sigprocmask(l_int how, \ +175 STD { int linux_rt_sigprocmask(l_int how, \ l_sigset_t *mask, l_sigset_t *omask, \ l_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(l_sigset_t *newset, \ +176 STD { int linux_rt_sigpending(void); } +177 STD { int linux_rt_sigtimedwait(void); } +178 STD { int linux_rt_sigqueueinfo(void); } +179 STD { int linux_rt_sigsuspend(l_sigset_t *newset, \ l_size_t sigsetsize); } -180 STD LINUX { int linux_pread(l_uint fd, char *buf, \ +180 STD { int linux_pread(l_uint fd, char *buf, \ l_size_t nbyte, l_loff_t offset); } -181 STD LINUX { int linux_pwrite(l_uint fd, char *buf, \ +181 STD { int linux_pwrite(l_uint fd, char *buf, \ l_size_t nbyte, l_loff_t offset); } -182 STD LINUX { int linux_chown16(char *path, l_uid16_t uid, \ +182 STD { int linux_chown16(char *path, l_uid16_t uid, \ l_gid16_t gid); } -183 STD LINUX { int linux_getcwd(char *buf, l_ulong bufsize); } -184 STD LINUX { int linux_capget(void); } -185 STD LINUX { int linux_capset(void); } -186 STD LINUX { int linux_sigaltstack(l_stack_t *uss, \ +183 STD { int linux_getcwd(char *buf, l_ulong bufsize); } +184 STD { int linux_capget(void); } +185 STD { int linux_capset(void); } +186 STD { int linux_sigaltstack(l_stack_t *uss, \ l_stack_t *uoss); } -187 STD LINUX { int linux_sendfile(void); } -188 UNIMPL LINUX getpmsg -189 UNIMPL LINUX putpmsg -190 STD LINUX { int linux_vfork(void); } -191 STD LINUX { int linux_getrlimit(l_uint resource, \ +187 STD { int linux_sendfile(void); } +188 UNIMPL getpmsg +189 UNIMPL putpmsg +190 STD { int linux_vfork(void); } +191 STD { int linux_getrlimit(l_uint resource, \ struct l_rlimit *rlim); } -192 STD LINUX { int linux_mmap2(l_ulong addr, l_ulong len, \ +192 STD { int linux_mmap2(l_ulong addr, l_ulong len, \ l_ulong prot, l_ulong flags, l_ulong fd, \ l_ulong pgoff); } -193 STD LINUX { int linux_truncate64(char *path, l_loff_t length); } -194 STD LINUX { int linux_ftruncate64(l_uint fd, l_loff_t length); } -195 STD LINUX { int linux_stat64(char *filename, \ +193 STD { int linux_truncate64(char *path, l_loff_t length); } +194 STD { int linux_ftruncate64(l_uint fd, l_loff_t length); } +195 STD { int linux_stat64(char *filename, \ struct l_stat64 *statbuf, l_long flags); } -196 STD LINUX { int linux_lstat64(char *filename, \ +196 STD { int linux_lstat64(char *filename, \ struct l_stat64 *statbuf, l_long flags); } -197 STD LINUX { int linux_fstat64(l_ulong fd, \ +197 STD { int linux_fstat64(l_ulong fd, \ struct l_stat64 *statbuf, l_long flags); } -198 STD LINUX { int linux_lchown(char *path, l_uid_t uid, \ +198 STD { int linux_lchown(char *path, l_uid_t uid, \ l_gid_t gid); } -199 STD POSIX { int linux_getuid(void); } -200 STD POSIX { int linux_getgid(void); } -201 NOPROTO POSIX { int geteuid(void); } -202 NOPROTO POSIX { int getegid(void); } -203 NOPROTO LINUX { int setreuid(uid_t ruid, uid_t euid); } -204 NOPROTO LINUX { int setregid(gid_t rgid, gid_t egid); } -205 STD LINUX { int linux_getgroups(l_int gidsetsize, \ +199 STD { int linux_getuid(void); } +200 STD { int linux_getgid(void); } +201 NOPROTO { int geteuid(void); } +202 NOPROTO { int getegid(void); } +203 NOPROTO { int setreuid(uid_t ruid, uid_t euid); } +204 NOPROTO { int setregid(gid_t rgid, gid_t egid); } +205 STD { int linux_getgroups(l_int gidsetsize, \ l_gid_t *grouplist); } -206 STD LINUX { int linux_setgroups(l_int gidsetsize, \ +206 STD { int linux_setgroups(l_int gidsetsize, \ l_gid_t *grouplist); } -207 NODEF LINUX fchown fchown fchown_args int -208 NOPROTO LINUX { int setresuid(uid_t ruid, uid_t euid, uid_t suid); } -209 NOPROTO LINUX { int getresuid(uid_t *ruid, uid_t *euid, \ +207 NODEF fchown fchown fchown_args int +208 NOPROTO { int setresuid(uid_t ruid, uid_t euid, uid_t suid); } +209 NOPROTO { int getresuid(uid_t *ruid, uid_t *euid, \ uid_t *suid); } -210 NOPROTO LINUX { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); } -211 NOPROTO LINUX { int getresgid(gid_t *rgid, gid_t *egid, \ +210 NOPROTO { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); } +211 NOPROTO { int getresgid(gid_t *rgid, gid_t *egid, \ gid_t *sgid); } -212 STD LINUX { int linux_chown(char *path, l_uid_t uid, \ +212 STD { int linux_chown(char *path, l_uid_t uid, \ l_gid_t gid); } -213 NOPROTO LINUX { int setuid(uid_t uid); } -214 NOPROTO LINUX { int setgid(gid_t gid); } -215 STD LINUX { int linux_setfsuid(l_uid_t uid); } -216 STD LINUX { int linux_setfsgid(l_gid_t gid); } -217 STD LINUX { int linux_pivot_root(char *new_root, \ +213 NOPROTO { int setuid(uid_t uid); } +214 NOPROTO { int setgid(gid_t gid); } +215 STD { int linux_setfsuid(l_uid_t uid); } +216 STD { int linux_setfsgid(l_gid_t gid); } +217 STD { int linux_pivot_root(char *new_root, \ char *put_old); } -218 STD LINUX { int linux_mincore(l_ulong start, l_size_t len, \ +218 STD { int linux_mincore(l_ulong start, l_size_t len, \ u_char *vec); } -219 STD LINUX { int linux_madvise(void); } -220 STD LINUX { int linux_getdents64(l_uint fd, void *dirent, \ +219 STD { int linux_madvise(void); } +220 STD { int linux_getdents64(l_uint fd, void *dirent, \ l_uint count); } -221 STD LINUX { int linux_fcntl64(l_uint fd, l_uint cmd, \ +221 STD { int linux_fcntl64(l_uint fd, l_uint cmd, \ l_ulong arg); } -222 UNIMPL LINUX none -223 UNIMPL LINUX none -224 STD LINUX { int linux_gettid(void); } -225 UNIMPL LINUX linux_readahead -226 STD LINUX { int linux_setxattr(void); } -227 STD LINUX { int linux_lsetxattr(void); } -228 STD LINUX { int linux_fsetxattr(void); } -229 STD LINUX { int linux_getxattr(void); } -230 STD LINUX { int linux_lgetxattr(void); } -231 STD LINUX { int linux_fgetxattr(void); } -232 STD LINUX { int linux_listxattr(void); } -233 STD LINUX { int linux_llistxattr(void); } -234 STD LINUX { int linux_flistxattr(void); } -235 STD LINUX { int linux_removexattr(void); } -236 STD LINUX { int linux_lremovexattr(void); } -237 STD LINUX { int linux_fremovexattr(void); } -238 STD LINUX { int linux_tkill(int tid, int sig); } -239 UNIMPL LINUX linux_sendfile64 -240 STD LINUX { int linux_sys_futex(void *uaddr, int op, int val, \ +222 UNIMPL none +223 UNIMPL none +224 STD { int linux_gettid(void); } +225 UNIMPL linux_readahead +226 STD { int linux_setxattr(void); } +227 STD { int linux_lsetxattr(void); } +228 STD { int linux_fsetxattr(void); } +229 STD { int linux_getxattr(void); } +230 STD { int linux_lgetxattr(void); } +231 STD { int linux_fgetxattr(void); } +232 STD { int linux_listxattr(void); } +233 STD { int linux_llistxattr(void); } +234 STD { int linux_flistxattr(void); } +235 STD { int linux_removexattr(void); } +236 STD { int linux_lremovexattr(void); } +237 STD { int linux_fremovexattr(void); } +238 STD { int linux_tkill(int tid, int sig); } +239 UNIMPL linux_sendfile64 +240 STD { int linux_sys_futex(void *uaddr, int op, int val, \ struct l_timespec *timeout, void *uaddr2, int val3); } -241 STD LINUX { int linux_sched_setaffinity(l_pid_t pid, l_uint len, \ +241 STD { int linux_sched_setaffinity(l_pid_t pid, l_uint len, \ l_ulong *user_mask_ptr); } -242 STD LINUX { int linux_sched_getaffinity(l_pid_t pid, l_uint len, \ +242 STD { int linux_sched_getaffinity(l_pid_t pid, l_uint len, \ l_ulong *user_mask_ptr); } -243 STD LINUX { int linux_set_thread_area(struct l_user_desc *desc); } -244 STD LINUX { int linux_get_thread_area(struct l_user_desc *desc); } -245 UNIMPL LINUX linux_io_setup -246 UNIMPL LINUX linux_io_destroy -247 UNIMPL LINUX linux_io_getevents -248 UNIMPL LINUX linux_io_submit -249 UNIMPL LINUX linux_io_cancel -250 STD LINUX { int linux_fadvise64(void); } -251 UNIMPL LINUX -252 STD LINUX { void linux_exit_group(int rval); } -253 UNIMPL LINUX linux_lookup_dcookie -254 STD LINUX { int linux_epoll_create(l_int size); } -255 STD LINUX { int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \ +243 STD { int linux_set_thread_area(struct l_user_desc *desc); } +244 STD { int linux_get_thread_area(struct l_user_desc *desc); } +245 UNIMPL linux_io_setup +246 UNIMPL linux_io_destroy +247 UNIMPL linux_io_getevents +248 UNIMPL linux_io_submit +249 UNIMPL linux_io_cancel +250 STD { int linux_fadvise64(void); } +251 UNIMPL +252 STD { void linux_exit_group(int rval); } +253 UNIMPL linux_lookup_dcookie +254 STD { int linux_epoll_create(l_int size); } +255 STD { int linux_epoll_ctl(l_int epfd, l_int op, l_int fd, \ struct linux_epoll_event *event); } -256 STD LINUX { int linux_epoll_wait(l_int epfd, struct linux_epoll_event *events, \ +256 STD { int linux_epoll_wait(l_int epfd, struct linux_epoll_event *events, \ l_int maxevents, l_int timeout); } -257 UNIMPL LINUX linux_remap_file_pages -258 STD LINUX { int linux_set_tid_address(int *tidptr); } -259 UNIMPL LINUX linux_timer_create -260 UNIMPL LINUX linux_timer_settime -261 UNIMPL LINUX linux_timer_gettime -262 UNIMPL LINUX linux_timer_getoverrun -263 UNIMPL LINUX linux_timer_delete -264 STD LINUX { int linux_clock_settime(clockid_t which, struct l_timespec *tp); } -265 STD LINUX { int linux_clock_gettime(clockid_t which, struct l_timespec *tp); } -266 STD LINUX { int linux_clock_getres(clockid_t which, struct l_timespec *tp); } -267 STD LINUX { int linux_clock_nanosleep(clockid_t which, int flags, \ +257 UNIMPL linux_remap_file_pages +258 STD { int linux_set_tid_address(int *tidptr); } +259 UNIMPL linux_timer_create +260 UNIMPL linux_timer_settime +261 UNIMPL linux_timer_gettime +262 UNIMPL linux_timer_getoverrun +263 UNIMPL linux_timer_delete +264 STD { int linux_clock_settime(clockid_t which, struct l_timespec *tp); } +265 STD { int linux_clock_gettime(clockid_t which, struct l_timespec *tp); } +266 STD { int linux_clock_getres(clockid_t which, struct l_timespec *tp); } +267 STD { int linux_clock_nanosleep(clockid_t which, int flags, \ struct l_timespec *rqtp, struct l_timespec *rmtp); } -268 STD LINUX { int linux_statfs64(void); } -269 STD LINUX { int linux_fstatfs64(void); } -270 STD LINUX { int linux_tgkill(int tgid, int pid, int sig); } -271 STD LINUX { int linux_utimes(char *fname, \ +268 STD { int linux_statfs64(void); } +269 STD { int linux_fstatfs64(void); } +270 STD { int linux_tgkill(int tgid, int pid, int sig); } +271 STD { int linux_utimes(char *fname, \ struct l_timeval *tptr); } -272 STD LINUX { int linux_fadvise64_64(void); } -273 UNIMPL LINUX /* sys_vserver */ -274 STD LINUX { int linux_mbind(void); } -275 STD LINUX { int linux_get_mempolicy(void); } -276 STD LINUX { int linux_set_mempolicy(void); } -277 STD LINUX { int linux_mq_open(const char *name, int oflag, mode_t mode, \ +272 STD { int linux_fadvise64_64(void); } +273 UNIMPL /* sys_vserver */ +274 STD { int linux_mbind(void); } +275 STD { int linux_get_mempolicy(void); } +276 STD { int linux_set_mempolicy(void); } +277 STD { int linux_mq_open(const char *name, int oflag, mode_t mode, \ struct mq_attr *attr); } -278 NOPROTO LINUX { int mq_unlink(const char *name); } -279 NOPROTO LINUX { int mq_timedsend(l_mqd_t mqd, const char *msg_ptr, \ +278 NOPROTO { int mq_unlink(const char *name); } +279 NOPROTO { int mq_timedsend(l_mqd_t mqd, const char *msg_ptr, \ size_t msg_len, unsigned int msg_prio, const struct \ l_timespec *abs_timeout); } -280 NOPROTO LINUX { int mq_timedreceive(l_mqd_t mqd, char *msg_ptr, \ +280 NOPROTO { int mq_timedreceive(l_mqd_t mqd, char *msg_ptr, \ size_t msg_len, unsigned int msg_prio, const struct \ l_timespec *abs_timeout); } -281 NOPROTO LINUX { int mq_notify(l_mqd_t mqd, const struct sigevent *notification); } -282 STD LINUX { int linux_mq_getsetattr(l_mqd_t mqd, const struct mq_attr *attr, \ +281 NOPROTO { int mq_notify(l_mqd_t mqd, const struct sigevent *notification); } +282 STD { int linux_mq_getsetattr(l_mqd_t mqd, const struct mq_attr *attr, \ struct mq_attr *oattr); } -283 STD LINUX { int linux_kexec_load(void); } -284 STD LINUX { int linux_waitid(void); } -285 UNIMPL LINUX /* available */ -286 STD LINUX { int linux_add_key(void); } -287 STD LINUX { int linux_request_key(void); } -288 STD LINUX { int linux_keyctl(void); } -289 STD LINUX { int linux_ioprio_set(void); } -290 STD LINUX { int linux_ioprio_get(void); } -291 STD LINUX { int linux_inotify_init(void); } -292 STD LINUX { int linux_inotify_add_watch(void); } -293 STD LINUX { int linux_inotify_rm_watch(void); } -294 STD LINUX { int linux_migrate_pages(void); } -295 STD LINUX { int linux_openat(l_int dfd, char *path, \ +283 STD { int linux_kexec_load(void); } +284 STD { int linux_waitid(void); } +285 UNIMPL /* available */ +286 STD { int linux_add_key(void); } +287 STD { int linux_request_key(void); } +288 STD { int linux_keyctl(void); } +289 STD { int linux_ioprio_set(void); } +290 STD { int linux_ioprio_get(void); } +291 STD { int linux_inotify_init(void); } +292 STD { int linux_inotify_add_watch(void); } +293 STD { int linux_inotify_rm_watch(void); } +294 STD { int linux_migrate_pages(void); } +295 STD { int linux_openat(l_int dfd, char *path, \ l_int flags, l_int mode); } -296 STD LINUX { int linux_mkdirat(l_int dfd, char *path, \ +296 STD { int linux_mkdirat(l_int dfd, char *path, \ l_int mode); } -297 STD LINUX { int linux_mknodat(l_int dfd, char *path, \ +297 STD { int linux_mknodat(l_int dfd, char *path, \ l_int mode, l_uint dev); } -298 STD LINUX { int linux_fchownat(l_int dfd, char *filename, \ +298 STD { int linux_fchownat(l_int dfd, char *filename, \ l_uid16_t uid, l_gid16_t gid, l_int flag); } -299 STD LINUX { int linux_futimesat(l_int dfd, char *fname, \ +299 STD { int linux_futimesat(l_int dfd, char *fname, \ struct l_timeval *tptr); } -300 STD LINUX { int linux_fstatat64(l_int dfd, char *path, \ +300 STD { int linux_fstatat64(l_int dfd, char *path, \ struct l_stat64 *statbuf, l_int flag); } -301 STD LINUX { int linux_unlinkat(l_int dfd, char *path, \ +301 STD { int linux_unlinkat(l_int dfd, char *path, \ l_int flag); } -302 STD LINUX { int linux_renameat(l_int olddfd, char *from, \ +302 STD { int linux_renameat(l_int olddfd, char *from, \ l_int newdfd, char *to); } -303 STD LINUX { int linux_linkat(l_int olddfd, char *path, \ +303 STD { int linux_linkat(l_int olddfd, char *path, \ l_int newdfd, char *to, l_int flags); } -304 STD LINUX { int linux_symlinkat(char *path, l_int newdfd, \ +304 STD { int linux_symlinkat(char *path, l_int newdfd, \ char *to); } -305 STD LINUX { int linux_readlinkat(l_int dfd, char *path, \ +305 STD { int linux_readlinkat(l_int dfd, char *path, \ char *buf, l_int count); } -306 STD LINUX { int linux_fchmodat(l_int dfd, char *filename, \ +306 STD { int linux_fchmodat(l_int dfd, char *filename, \ l_mode_t mode); } -307 STD LINUX { int linux_faccessat(l_int dfd, char *filename, l_int mode); } -308 STD LINUX { int linux_pselect6(void); } -309 STD LINUX { int linux_ppoll(void); } -310 STD LINUX { int linux_unshare(void); } -311 STD LINUX { int linux_set_robust_list(struct linux_robust_list_head *head, \ +307 STD { int linux_faccessat(l_int dfd, char *filename, l_int mode); } +308 STD { int linux_pselect6(void); } +309 STD { int linux_ppoll(void); } +310 STD { int linux_unshare(void); } +311 STD { int linux_set_robust_list(struct linux_robust_list_head *head, \ l_size_t len); } -312 STD LINUX { int linux_get_robust_list(l_int pid, struct linux_robust_list_head **head, \ +312 STD { int linux_get_robust_list(l_int pid, struct linux_robust_list_head **head, \ l_size_t *len); } -313 STD LINUX { int linux_splice(void); } -314 STD LINUX { int linux_sync_file_range(void); } -315 STD LINUX { int linux_tee(void); } -316 STD LINUX { int linux_vmsplice(void); } -317 STD LINUX { int linux_move_pages(void); } -318 STD LINUX { int linux_getcpu(l_uint *pcpu, l_uint *pnode, void *ptcache); } -319 STD LINUX { int linux_epoll_pwait(void); } -320 STD LINUX { int linux_utimensat(l_int dfd, char *fname, \ +313 STD { int linux_splice(void); } +314 STD { int linux_sync_file_range(void); } +315 STD { int linux_tee(void); } +316 STD { int linux_vmsplice(void); } +317 STD { int linux_move_pages(void); } +318 STD { int linux_getcpu(l_uint *pcpu, l_uint *pnode, void *ptcache); } +319 STD { int linux_epoll_pwait(void); } +320 STD { int linux_utimensat(l_int dfd, char *fname, \ struct l_timespec *tptr, l_int flag); } -321 STD LINUX { int linux_signalfd(void); } -322 STD LINUX { int linux_timerfd(void); } -323 STD LINUX { int linux_eventfd(void); } -324 UNIMPL LINUX linux_fallocate -325 UNIMPL LINUX linux_timerfd_settime -326 UNIMPL LINUX linux_timerfd_gettime -327 UNIMPL LINUX linux_signalfd4 -328 UNIMPL LINUX linux_eventfd2 -329 UNIMPL LINUX linux_epoll_create1 -330 UNIMPL LINUX linux_dup3 -331 STD LINUX { int linux_pipe2(l_ulong *pipefds, l_int flags); } -332 UNIMPL LINUX linux_inotify_init1 -333 UNIMPL LINUX linux_preadv -334 UNIMPL LINUX linux_pwritev -335 UNIMPL LINUX linux_rt_tgsigqueueinfo -336 UNIMPL LINUX linux_perf_event_open -337 UNIMPL LINUX linux_recvmmsg +321 STD { int linux_signalfd(void); } +322 STD { int linux_timerfd(void); } +323 STD { int linux_eventfd(void); } +324 UNIMPL linux_fallocate +325 UNIMPL linux_timerfd_settime +326 UNIMPL linux_timerfd_gettime +327 UNIMPL linux_signalfd4 +328 UNIMPL linux_eventfd2 +329 UNIMPL linux_epoll_create1 +330 UNIMPL linux_dup3 +331 STD { int linux_pipe2(l_ulong *pipefds, l_int flags); } +332 UNIMPL linux_inotify_init1 +333 UNIMPL linux_preadv +334 UNIMPL linux_pwritev +335 UNIMPL linux_rt_tgsigqueueinfo +336 UNIMPL linux_perf_event_open +337 UNIMPL linux_recvmmsg diff --git a/sys/kern/Makefile.misc b/sys/kern/Makefile.misc index 4bb12725f3..f0b8693cc3 100644 --- a/sys/kern/Makefile.misc +++ b/sys/kern/Makefile.misc @@ -1,5 +1,3 @@ -# $DragonFly: src/sys/kern/Makefile.misc,v 1.7 2007/01/19 07:23:42 dillon Exp $ -# # Makefile for kernel tags files, init_sysent, etc. TAGARCH= i386 # luna68k news3400 pmax sparc tahoe vax @@ -10,13 +8,11 @@ all: sysent: ${.CURDIR}/init_sysent.c ${.CURDIR}/init_sysent.c ${.CURDIR}/syscalls.c \ -${.CURDIR}/../sys/syscall.h ${.CURDIR}/../sys/syscall-hide.h \ ${.CURDIR}/../sys/syscall.mk ${.CURDIR}/../sys/sysproto.h \ ${.CURDIR}/../sys/sysunion.h: ${.CURDIR}/makesyscalls.sh ${.CURDIR}/syscalls.master -mv -f ${.CURDIR}/init_sysent.c ${.CURDIR}/init_sysent.c.bak -mv -f ${.CURDIR}/syscalls.c ${.CURDIR}/syscalls.c.bak -mv -f ${.CURDIR}/../sys/syscall.h ${.CURDIR}/../sys/syscall.h.bak - -mv -f ${.CURDIR}/../sys/syscall-hide.h ${.CURDIR}/../sys/syscall-hide.h.bak -mv -f ${.CURDIR}/../sys/syscall.mk ${.CURDIR}/../sys/syscall.mk.bak -mv -f ${.CURDIR}/../sys/sysproto.h ${.CURDIR}/../sys/sysproto.h.bak -mv -f ${.CURDIR}/../sys/sysunion.h ${.CURDIR}/../sys/sysunion.h.bak diff --git a/sys/kern/makesyscalls.sh b/sys/kern/makesyscalls.sh index 121a842a0a..efcdd85746 100644 --- a/sys/kern/makesyscalls.sh +++ b/sys/kern/makesyscalls.sh @@ -17,7 +17,6 @@ sysproto_h=_SYS_SYSPROTO_H_ syshdr="../sys/syscall.h" sysmk="../sys/syscall.mk" syssw="init_sysent.c" -syshide="../sys/syscall-hide.h" syscallprefix="SYS_" switchname="sysent" namesname="syscallnames" @@ -78,7 +77,6 @@ s/\$//g sysmk = \"$sysmk\" compat = \"$compat\" compatdf12 = \"$compatdf12\" - syshide = \"$syshide\" syscallprefix = \"$syscallprefix\" switchname = \"$switchname\" namesname = \"$namesname\" @@ -124,11 +122,6 @@ s/\$//g printf "# by running make sysent in the same directory.\n" > sysmk printf "MIASM = " > sysmk - printf "/*\n * System call hiders.\n *\n" > syshide - printf " * DO NOT EDIT-- To regenerate this file, edit syscalls.master followed\n" > syshide - printf " * by running make sysent in the same directory.\n" > syshide - printf " */\n\n" > syshide - printf "/*\n * Union of syscall args for messaging.\n *\n" > sysun printf " * DO NOT EDIT-- To regenerate this file, edit syscalls.master followed\n" > sysun printf " * by running make sysent in the same directory.\n" > sysun @@ -160,7 +153,6 @@ s/\$//g print > syscompat print > syscompatdf12 print > sysnames - print > syshide print > sysun savesyscall = syscall next @@ -173,7 +165,6 @@ s/\$//g print > syscompat print > syscompatdf12 print > sysnames - print > syshide syscall = savesyscall next } @@ -185,7 +176,6 @@ s/\$//g print > syscompat print > syscompatdf12 print > sysnames - print > syshide next } syscall != $1 { @@ -209,7 +199,7 @@ s/\$//g exit 1 } function parseline() { - f=4 # toss number and type + f=3 # toss number and type argc= 0; argssize = "0" if ($NF != "}") { @@ -224,8 +214,8 @@ s/\$//g end=NF } if ($2 == "NODEF") { - funcname=$4 - argssize = "AS(" $6 ")" + funcname=$3 + argssize = "AS(" $5 ")" return } if ($f != "{") @@ -289,9 +279,9 @@ s/\$//g if (argc != 0) argssize = "AS(" argalias ")" } - { comment = $4 - if (NF < 7) - for (i = 5; i <= NF; i++) + { comment = $3 + if (NF < 6) + for (i = 4; i <= NF; i++) comment = comment " " $i } $2 == "STD" || $2 == "NODEF" || $2 == "NOARGS" || $2 == "NOPROTO" \ @@ -352,8 +342,6 @@ s/\$//g funcalias, syscall) > syshdr printf(" \\\n\t%s.o", funcalias) > sysmk } - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, funcname) > syshide syscall++ next } @@ -394,8 +382,6 @@ s/\$//g funcalias, syscall, funcalias) > sysnames printf("\t\t\t\t/* %d is old %s */\n", syscall, funcalias) > syshdr - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, funcname) > syshide syscall++ next } @@ -436,8 +422,6 @@ s/\$//g funcalias, syscall, funcalias) > sysnames printf("\t\t\t\t/* %d is old %s */\n", syscall, funcalias) > syshdr - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, funcname) > syshide syscall++ next } @@ -455,8 +439,6 @@ s/\$//g printf("#define\t%s%s\t%d\t/* compatibility; still used by libc */\n", syscallprefix, funcalias, syscall) > syshdr printf(" \\\n\t%s.o", funcalias) > sysmk - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, funcname) > syshide syscall++ next } @@ -465,11 +447,9 @@ s/\$//g align_sysent_comment(37) printf("/* %d = obsolete %s */\n", syscall, comment) > sysent printf("\t\"obs_%s\",\t\t\t/* %d = obsolete %s */\n", - $4, syscall, comment) > sysnames + $3, syscall, comment) > sysnames printf("\t\t\t\t/* %d is obsolete %s */\n", syscall, comment) > syshdr - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, $4) > syshide syscall++ next } @@ -478,8 +458,6 @@ s/\$//g syscall, comment) > sysent printf("\t\"#%d\",\t\t\t/* %d = %s */\n", syscall, syscall, comment) > sysnames - if ($3 != "NOHIDE") - printf("HIDE_%s(%s)\n", $3, $4) > syshide syscall++ next } diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index ea198db3c8..e3b91492fc 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -3,14 +3,12 @@ ; ; System call name/number master file. ; Processed to create kern/init_sysent.c, kern/syscalls.c, sys/syscall.h, -; sys/syscall.mk, sys/syscall-hide.h, sys/sysproto.h and -; sys/sysunion.h +; sys/syscall.mk, sys/sysproto.h and sys/sysunion.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, CPT_NOA, LIBCOMPAT, ; NODEF, NOARGS, NOPROTO, NOIMPL -; namespc one of POSIX, BSD, NOHIDE ; name pseudo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different @@ -47,707 +45,705 @@ ; 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 exit(int rval); } -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); } +0 STD { int nosys(void); } syscall nosys_args int +1 STD { void exit(int rval); } +2 STD { int fork(void); } +3 STD { ssize_t read(int fd, void *buf, size_t nbyte); } +4 STD { ssize_t write(int fd, const void *buf, size_t nbyte); } +5 STD { 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, \ +6 STD { int close(int fd); } +7 STD { 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, \ +8 COMPAT { int creat(char *path, int mode); } +9 STD { int link(char *path, char *link); } +10 STD { int unlink(char *path); } +11 OBSOL execv +12 STD { int chdir(char *path); } +13 STD { int fchdir(int fd); } +14 STD { int mknod(char *path, int mode, int dev); } +15 STD { int chmod(char *path, int mode); } +16 STD { int chown(char *path, int uid, int gid); } +17 STD { int obreak(char *nsize); } break obreak_args int +18 STD { 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, \ +19 COMPAT { long lseek(int fd, long offset, int whence); } +20 STD { pid_t getpid(void); } +21 STD { int mount(char *type, char *path, int flags, \ caddr_t data); } ; 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 STD POSIX { uid_t getuid(void); } -25 STD POSIX { uid_t geteuid(void); } -26 STD BSD { int ptrace(int req, pid_t pid, caddr_t addr, \ +22 STD { int unmount(char *path, int flags); } +23 STD { int setuid(uid_t uid); } +24 STD { uid_t getuid(void); } +25 STD { uid_t geteuid(void); } +26 STD { 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, \ +27 STD { int recvmsg(int s, struct msghdr *msg, int flags); } +28 STD { int sendmsg(int s, caddr_t msg, int flags); } +29 STD { 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, \ +30 STD { int accept(int s, caddr_t name, int *anamelen); } +31 STD { int getpeername(int fdes, caddr_t asa, int *alen); } +32 STD { int getsockname(int fdes, caddr_t asa, int *alen); } +33 STD { int access(char *path, int flags); } +34 STD { int chflags(char *path, int flags); } +35 STD { int fchflags(int fd, int flags); } +36 STD { int sync(void); } +37 STD { int kill(int pid, int signum); } +38 COMPAT { int stat(char *path, struct ostat *ub); } +39 STD { pid_t getppid(void); } +40 COMPAT { int lstat(char *path, struct ostat *ub); } +41 STD { int dup(u_int fd); } +42 STD { int pipe(void); } +43 STD { gid_t getegid(void); } +44 STD { 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, \ +45 STD { int ktrace(const char *fname, int ops, int facs, \ int pid); } -46 OBSOL NOHIDE freebsd3_sigaction -47 STD POSIX { gid_t getgid(void); } -48 OBSOL NOHIDE freebsd3_sigprocmask +46 OBSOL freebsd3_sigaction +47 STD { gid_t getgid(void); } +48 OBSOL freebsd3_sigprocmask ; 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 OBSOL NOHIDE freebsd3_sigpending -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 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, \ +49 STD { int getlogin(char *namebuf, u_int namelen); } +50 STD { int setlogin(char *namebuf); } +51 STD { int acct(char *path); } +52 OBSOL freebsd3_sigpending +53 STD { int sigaltstack(stack_t *ss, stack_t *oss); } +54 STD { int ioctl(int fd, u_long com, caddr_t data); } +55 STD { int reboot(int opt); } +56 STD { int revoke(char *path); } +57 STD { int symlink(char *path, char *link); } +58 STD { int readlink(char *path, char *buf, int count); } +59 STD { int execve(char *fname, char **argv, char **envv); } +60 STD { int umask(int newmask); } umask umask_args int +61 STD { int chroot(char *path); } +62 COMPAT { int fstat(int fd, struct ostat *sb); } +63 COMPAT { int getkerninfo(int op, char *where, size_t *size, \ int arg); } getkerninfo getkerninfo_args int -64 COMPAT BSD { int getpagesize(void); } \ +64 COMPAT { int getpagesize(void); } \ getpagesize getpagesize_args int -65 STD BSD { int msync(void *addr, size_t len, int flags); } -66 STD BSD { pid_t 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, \ +65 STD { int msync(void *addr, size_t len, int flags); } +66 STD { pid_t vfork(void); } +67 OBSOL vread +68 OBSOL vwrite +69 STD { int sbrk(int incr); } +70 STD { int sstk(int incr); } +71 COMPAT { int mmap(void *addr, int len, int prot, \ int flags, int fd, long pos); } -72 COMPAT BSD { int vadvise(int anom); } vadvise ovadvise_args int -73 STD BSD { int munmap(void *addr, size_t len); } -74 STD BSD { int mprotect(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, \ +72 COMPAT { int vadvise(int anom); } vadvise ovadvise_args int +73 STD { int munmap(void *addr, size_t len); } +74 STD { int mprotect(void *addr, size_t len, int prot); } +75 STD { int madvise(void *addr, size_t len, int behav); } +76 OBSOL vhangup +77 OBSOL vlimit +78 STD { 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 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, \ +79 STD { int getgroups(u_int gidsetsize, gid_t *gidset); } +80 STD { int setgroups(u_int gidsetsize, gid_t *gidset); } +81 STD { int getpgrp(void); } +82 STD { int setpgid(int pid, int pgid); } +83 STD { 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); } \ +84 COMPAT { int wait(void); } +85 STD { int swapon(char *name); } +86 STD { int getitimer(u_int which, struct itimerval *itv); } +87 COMPAT { int gethostname(char *hostname, u_int len); } \ gethostname gethostname_args int -88 COMPAT BSD { int sethostname(char *hostname, u_int len); } \ +88 COMPAT { 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); } +89 STD { int getdtablesize(void); } +90 STD { int dup2(u_int from, u_int to); } +91 UNIMPL getdopt +92 STD { 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, \ +93 STD { 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); } \ +94 UNIMPL setdopt +95 STD { int fsync(int fd); } +96 STD { int setpriority(int which, int who, int prio); } +97 STD { int socket(int domain, int type, int protocol); } +98 STD { int connect(int s, caddr_t name, int namelen); } +99 CPT_NOA { 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 OBSOL NOHIDE freebsd3_sigreturn -104 STD BSD { int bind(int s, caddr_t name, int namelen); } -105 STD BSD { int setsockopt(int s, int level, int name, \ +100 STD { int getpriority(int which, int who); } +101 COMPAT { int send(int s, caddr_t buf, int len, int flags); } +102 COMPAT { int recv(int s, caddr_t buf, int len, int flags); } +103 OBSOL freebsd3_sigreturn +104 STD { int bind(int s, caddr_t name, int namelen); } +105 STD { 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, \ +106 STD { int listen(int s, int backlog); } +107 OBSOL vtimes +108 COMPAT { 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 OBSOL NOHIDE freebsd3_sigsuspend +109 COMPAT { int sigblock(int mask); } +110 COMPAT { int sigsetmask(int mask); } +111 OBSOL freebsd3_sigsuspend ; 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, \ +112 COMPAT { 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, \ +113 COMPAT { int recvmsg(int s, struct omsghdr *msg, int flags); } +114 COMPAT { int sendmsg(int s, caddr_t msg, int flags); } +115 OBSOL vtrace +116 STD { 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, \ +117 STD { int getrusage(int who, struct rusage *rusage); } +118 STD { 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, \ +119 UNIMPL resuba (BSD/OS 2.x) +120 STD { int readv(int fd, struct iovec *iovp, u_int iovcnt); } +121 STD { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } -122 STD BSD { int settimeofday(struct timeval *tv, \ +122 STD { 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, \ +123 STD { int fchown(int fd, int uid, int gid); } +124 STD { int fchmod(int fd, int mode); } +125 CPT_NOA { 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, \ +126 STD { int setreuid(int ruid, int euid); } +127 STD { int setregid(int rgid, int egid); } +128 STD { int rename(char *from, char *to); } +129 COMPAT { int truncate(char *path, long length); } +130 COMPAT { int ftruncate(int fd, long length); } +131 STD { int flock(int fd, int how); } +132 STD { int mkfifo(char *path, int mode); } +133 STD { 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, \ +134 STD { int shutdown(int s, int how); } +135 STD { 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, \ +136 STD { int mkdir(char *path, int mode); } +137 STD { int rmdir(char *path); } +138 STD { int utimes(char *path, struct timeval *tptr); } +139 OBSOL 4.2 sigreturn +140 STD { 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 orlimit *rlp); } -145 COMPAT BSD { int setrlimit(u_int which, struct orlimit *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, \ +141 COMPAT { int getpeername(int fdes, caddr_t asa, int *alen); } +142 COMPAT { long gethostid(void); } +143 COMPAT { int sethostid(long hostid); } +144 COMPAT { int getrlimit(u_int which, struct orlimit *rlp); } +145 COMPAT { int setrlimit(u_int which, struct orlimit *rlp); } +146 COMPAT { int killpg(int pgid, int signum); } +147 STD { int setsid(void); } +148 STD { 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); }\ +149 COMPAT { int quota(void); } +150 CPT_NOA { 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 +151 UNIMPL sem_lock (BSD/OS 2.x) +152 UNIMPL sem_wakeup (BSD/OS 2.x) +153 UNIMPL asyncdaemon (BSD/OS 2.x) +154 UNIMPL 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, \ +155 NOIMPL { int nfssvc(int flag, caddr_t argp); } +156 COMPAT { 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 +157 STD { int statfs(char *path, struct statfs *buf); } +158 STD { int fstatfs(int fd, struct statfs *buf); } +159 UNIMPL nosys +160 UNIMPL 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, \ +161 STD { int getfh(char *fname, struct fhandle *fhp); } +162 STD { int getdomainname(char *domainname, int len); } +163 STD { int setdomainname(char *domainname, int len); } +164 STD { int uname(struct utsname *name); } +165 STD { int sysarch(int op, char *parms); } +166 STD { 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, \ +167 UNIMPL nosys +168 UNIMPL nosys +169 STD { 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, \ +170 STD { 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); } +171 STD { 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 extpread(int fd, void *buf, \ +172 UNIMPL nosys +173 STD { ssize_t extpread(int fd, void *buf, \ size_t nbyte, int flags, off_t offset); } -174 STD POSIX { ssize_t extpwrite(int fd, const void *buf, \ +174 STD { ssize_t extpwrite(int fd, const void *buf, \ size_t nbyte, int flags, 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 +175 UNIMPL nosys +176 STD { int ntp_adjtime(struct timex *tp); } +177 UNIMPL sfork (BSD/OS 2.x) +178 UNIMPL getdescriptor (BSD/OS 2.x) +179 UNIMPL setdescriptor (BSD/OS 2.x) +180 UNIMPL 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 COMPAT_DF12 POSIX { int stat(const char *path, struct dfbsd12_stat *ub); } -189 COMPAT_DF12 POSIX { int fstat(int fd, struct dfbsd12_stat *sb); } -190 COMPAT_DF12 POSIX { int lstat(const char *path, struct dfbsd12_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, \ +181 STD { int setgid(gid_t gid); } +182 STD { int setegid(gid_t egid); } +183 STD { int seteuid(uid_t euid); } +184 UNIMPL lfs_bmapv +185 UNIMPL lfs_markv +186 UNIMPL lfs_segclean +187 UNIMPL lfs_segwait +188 COMPAT_DF12 { int stat(const char *path, struct dfbsd12_stat *ub); } +189 COMPAT_DF12 { int fstat(int fd, struct dfbsd12_stat *sb); } +190 COMPAT_DF12 { int lstat(const char *path, struct dfbsd12_stat *ub); } +191 STD { int pathconf(char *path, int name); } +192 STD { int fpathconf(int fd, int name); } +193 UNIMPL nosys +194 STD { int getrlimit(u_int which, \ struct rlimit *rlp); } \ getrlimit __getrlimit_args int -195 STD BSD { int setrlimit(u_int which, \ +195 STD { int setrlimit(u_int which, \ struct rlimit *rlp); } \ setrlimit __setrlimit_args int -196 COMPAT_DF12 BSD { int getdirentries(int fd, char *buf, \ +196 COMPAT_DF12 { 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, \ +197 STD { 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, \ +198 STD { int nosys(void); } __syscall __syscall_args int +199 STD { 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, \ +200 STD { int truncate(char *path, int pad, off_t length); } +201 STD { int ftruncate(int fd, int pad, off_t length); } +202 STD { 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, \ +203 STD { int mlock(const void *addr, size_t len); } +204 STD { int munlock(const void *addr, size_t len); } +205 STD { int undelete(char *path); } +206 STD { int futimes(int fd, struct timeval *tptr); } +207 STD { int getpgid(pid_t pid); } +208 UNIMPL newreboot (NetBSD) +209 STD { int poll(struct pollfd *fds, u_int nfds, \ int timeout); } ; ; The following are reserved for loadable syscalls ; ; 210 is used by the Checkpoint Module -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 +210 NODEF lkmnosys lkmnosys nosys_args int +211 NODEF lkmnosys lkmnosys nosys_args int +212 NODEF lkmnosys lkmnosys nosys_args int +213 NODEF lkmnosys lkmnosys nosys_args int +214 NODEF lkmnosys lkmnosys nosys_args int +215 NODEF lkmnosys lkmnosys nosys_args int +216 NODEF lkmnosys lkmnosys nosys_args int +217 NODEF lkmnosys lkmnosys nosys_args int +218 NODEF lkmnosys lkmnosys nosys_args int +219 NODEF 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, \ +220 STD { 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, \ +221 STD { int semget(key_t key, int nsems, int semflg); } +222 STD { int semop(int semid, struct sembuf *sops, \ u_int nsops); } -223 UNIMPL NOHIDE semconfig -224 STD BSD { int msgctl(int msqid, int cmd, \ +223 UNIMPL semconfig +224 STD { 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, \ +225 STD { int msgget(key_t key, int msgflg); } +226 STD { int msgsnd(int msqid, void *msgp, size_t msgsz, \ int msgflg); } -227 STD BSD { int msgrcv(int msqid, void *msgp, size_t msgsz, \ +227 STD { int msgrcv(int msqid, void *msgp, size_t msgsz, \ long msgtyp, int msgflg); } -228 STD BSD { caddr_t shmat(int shmid, const void *shmaddr, \ +228 STD { caddr_t shmat(int shmid, const void *shmaddr, \ int shmflg); } -229 STD BSD { int shmctl(int shmid, int cmd, \ +229 STD { int shmctl(int shmid, int cmd, \ struct shmid_ds *buf); } -230 STD BSD { int shmdt(const void *shmaddr); } -231 STD BSD { int shmget(key_t key, size_t size, int shmflg); } +230 STD { int shmdt(const void *shmaddr); } +231 STD { int shmget(key_t key, size_t size, int shmflg); } ; -232 STD POSIX { int clock_gettime(clockid_t clock_id, \ +232 STD { int clock_gettime(clockid_t clock_id, \ struct timespec *tp); } -233 STD POSIX { int clock_settime(clockid_t clock_id, \ +233 STD { int clock_settime(clockid_t clock_id, \ const struct timespec *tp); } -234 STD POSIX { int clock_getres(clockid_t clock_id, \ +234 STD { 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, \ +235 UNIMPL timer_create +236 UNIMPL timer_delete +237 UNIMPL timer_settime +238 UNIMPL timer_gettime +239 UNIMPL timer_getoverrun +240 STD { 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 +241 UNIMPL nosys +242 UNIMPL nosys +243 UNIMPL nosys +244 UNIMPL nosys +245 UNIMPL nosys +246 UNIMPL nosys +247 UNIMPL nosys +248 UNIMPL nosys +249 UNIMPL 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, \ +250 STD { int minherit(void *addr, size_t len, int inherit); } +251 STD { int rfork(int flags); } +252 STD { 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 COMPAT_DF12 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 OBSOL BSD { int nstat(char *path, struct nstat *ub); } -279 OBSOL NOHIDE { int nfstat(int fd, struct nstat *sb); } -280 OBSOL NOHIDE { 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 +253 STD { int issetugid(void); } +254 STD { int lchown(char *path, int uid, int gid); } +255 UNIMPL nosys +256 UNIMPL nosys +257 UNIMPL nosys +258 UNIMPL nosys +259 UNIMPL nosys +260 UNIMPL nosys +261 UNIMPL nosys +262 UNIMPL nosys +263 UNIMPL nosys +264 UNIMPL nosys +265 UNIMPL nosys +266 UNIMPL nosys +267 UNIMPL nosys +268 UNIMPL nosys +269 UNIMPL nosys +270 UNIMPL nosys +271 UNIMPL nosys +272 COMPAT_DF12 { int getdents(int fd, char *buf, size_t count); } +273 UNIMPL nosys +274 STD { int lchmod(char *path, mode_t mode); } +275 NOPROTO { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int +276 STD { int lutimes(char *path, struct timeval *tptr); } +277 NOPROTO { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int +278 OBSOL { int nstat(char *path, struct nstat *ub); } +279 OBSOL { int nfstat(int fd, struct nstat *sb); } +280 OBSOL { int nlstat(char *path, struct nstat *ub); } +281 UNIMPL nosys +282 UNIMPL nosys +283 UNIMPL nosys +284 UNIMPL nosys +285 UNIMPL nosys +286 UNIMPL nosys +287 UNIMPL nosys +288 UNIMPL nosys ; 289 and 290 from NetBSD (OpenBSD: 267 and 268) -289 STD BSD { ssize_t extpreadv(int fd, struct iovec *iovp, \ +289 STD { ssize_t extpreadv(int fd, struct iovec *iovp, \ u_int iovcnt, int flags, off_t offset); } -290 STD BSD { ssize_t extpwritev(int fd, struct iovec *iovp,\ +290 STD { ssize_t extpwritev(int fd, struct iovec *iovp,\ u_int iovcnt, int flags, off_t offset); } -291 UNIMPL NOHIDE nosys -292 UNIMPL NOHIDE nosys -293 UNIMPL NOHIDE nosys -294 UNIMPL NOHIDE nosys -295 UNIMPL NOHIDE nosys -296 UNIMPL NOHIDE nosys +291 UNIMPL nosys +292 UNIMPL nosys +293 UNIMPL nosys +294 UNIMPL nosys +295 UNIMPL nosys +296 UNIMPL 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 COMPAT_DF12 POSIX { int fhstat(const struct fhandle *u_fhp, struct dfbsd12_stat *sb); } +297 STD { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); } +298 STD { int fhopen(const struct fhandle *u_fhp, int flags); } +299 COMPAT_DF12 { int fhstat(const struct fhandle *u_fhp, struct dfbsd12_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 UNIMPL BSD thr_sleep -323 UNIMPL BSD thr_wakeup -324 STD BSD { int mlockall(int how); } -325 STD BSD { int munlockall(void); } -326 STD BSD { int __getcwd(u_char *buf, u_int buflen); } +300 STD { int modnext(int modid); } +301 STD { int modstat(int modid, struct module_stat* stat); } +302 STD { int modfnext(int modid); } +303 STD { int modfind(const char *name); } +304 STD { int kldload(const char *file); } +305 STD { int kldunload(int fileid); } +306 STD { int kldfind(const char *file); } +307 STD { int kldnext(int fileid); } +308 STD { int kldstat(int fileid, struct kld_file_stat* stat); } +309 STD { int kldfirstmod(int fileid); } +310 STD { int getsid(pid_t pid); } +311 STD { int setresuid(uid_t ruid, uid_t euid, uid_t suid); } +312 STD { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); } +313 OBSOL signanosleep +314 STD { int aio_return(struct aiocb *aiocbp); } +315 STD { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); } +316 STD { int aio_cancel(int fd, struct aiocb *aiocbp); } +317 STD { int aio_error(struct aiocb *aiocbp); } +318 STD { int aio_read(struct aiocb *aiocbp); } +319 STD { int aio_write(struct aiocb *aiocbp); } +320 STD { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); } +321 STD { int yield(void); } +322 UNIMPL thr_sleep +323 UNIMPL thr_wakeup +324 STD { int mlockall(int how); } +325 STD { int munlockall(void); } +326 STD { 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); } +327 STD { int sched_setparam (pid_t pid, const struct sched_param *param); } +328 STD { 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); } +329 STD { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); } +330 STD { 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 OBSOL NOHIDE freebsd4_sendfile -337 STD BSD { int kldsym(int fileid, int cmd, void *data); } -338 STD BSD { int jail(struct jail *jail); } -339 UNIMPL BSD pioctl -340 STD POSIX { int sigprocmask(int how, const sigset_t *set, \ +331 STD { int sched_yield (void); } +332 STD { int sched_get_priority_max (int policy); } +333 STD { int sched_get_priority_min (int policy); } +334 STD { int sched_rr_get_interval (pid_t pid, struct timespec *interval); } +335 STD { int utrace(const void *addr, size_t len); } +336 OBSOL freebsd4_sendfile +337 STD { int kldsym(int fileid, int cmd, void *data); } +338 STD { int jail(struct jail *jail); } +339 UNIMPL pioctl +340 STD { 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, \ +341 STD { int sigsuspend(const sigset_t *sigmask); } +342 STD { 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 STD POSIX { int sigtimedwait(const sigset_t *set,\ +343 STD { int sigpending(sigset_t *set); } +344 STD { int sigreturn(ucontext_t *sigcntxp); } +345 STD { int sigtimedwait(const sigset_t *set,\ siginfo_t *info, const struct timespec *timeout); } -346 STD POSIX { int sigwaitinfo(const sigset_t *set,\ +346 STD { int sigwaitinfo(const sigset_t *set,\ siginfo_t *info); } -347 STD BSD { int __acl_get_file(const char *path, \ +347 STD { int __acl_get_file(const char *path, \ acl_type_t type, struct acl *aclp); } -348 STD BSD { int __acl_set_file(const char *path, \ +348 STD { 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, \ +349 STD { 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, \ +350 STD { int __acl_set_fd(int filedes, acl_type_t type, \ struct acl *aclp); } -351 STD BSD { int __acl_delete_file(const char *path, \ +351 STD { 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, \ +352 STD { int __acl_delete_fd(int filedes, acl_type_t type); } +353 STD { 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, \ +354 STD { int __acl_aclcheck_fd(int filedes, acl_type_t type, \ struct acl *aclp); } -355 STD BSD { int extattrctl(const char *path, int cmd, \ +355 STD { int extattrctl(const char *path, int cmd, \ const char *filename, int attrnamespace, \ const char *attrname); } -356 STD BSD { int extattr_set_file(const char *path, \ +356 STD { int extattr_set_file(const char *path, \ int attrnamespace, const char *attrname, \ void *data, size_t nbytes); } -357 STD BSD { int extattr_get_file(const char *path, \ +357 STD { int extattr_get_file(const char *path, \ int attrnamespace, const char *attrname, \ void *data, size_t nbytes); } -358 STD BSD { int extattr_delete_file(const char *path, \ +358 STD { int extattr_delete_file(const char *path, \ int attrnamespace, 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, \ +359 STD { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); } +360 STD { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); } +361 STD { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); } +362 STD { int kqueue(void); } +363 STD { int kevent(int fd, \ const struct kevent *changelist, int nchanges, \ struct kevent *eventlist, int nevents, \ const struct timespec *timeout); } -364 STD BSD { int sctp_peeloff(int sd, caddr_t name ); } +364 STD { int sctp_peeloff(int sd, caddr_t name ); } ; 365-392 used by FreeBSD-current -365 UNIMPL NOHIDE nosys -366 UNIMPL NOHIDE nosys -367 UNIMPL NOHIDE nosys -368 UNIMPL NOHIDE nosys -369 UNIMPL NOHIDE nosys -370 UNIMPL NOHIDE nosys -371 UNIMPL NOHIDE nosys -372 UNIMPL NOHIDE nosys -373 UNIMPL NOHIDE nosys -374 UNIMPL NOHIDE nosys -375 UNIMPL NOHIDE nosys -376 UNIMPL NOHIDE nosys -377 UNIMPL NOHIDE nosys -378 UNIMPL NOHIDE nosys -379 UNIMPL NOHIDE nosys -380 UNIMPL NOHIDE nosys -381 UNIMPL NOHIDE nosys -382 UNIMPL NOHIDE nosys -383 UNIMPL NOHIDE nosys -384 UNIMPL NOHIDE nosys -385 UNIMPL NOHIDE nosys -386 UNIMPL NOHIDE nosys -387 UNIMPL NOHIDE nosys -388 UNIMPL NOHIDE nosys -389 UNIMPL NOHIDE nosys -390 UNIMPL NOHIDE nosys -391 STD BSD { int lchflags(char *path, int flags); } -392 STD BSD { int uuidgen(struct uuid *store, int count); } -393 STD BSD { int sendfile(int fd, int s, off_t offset, size_t nbytes, \ +365 UNIMPL nosys +366 UNIMPL nosys +367 UNIMPL nosys +368 UNIMPL nosys +369 UNIMPL nosys +370 UNIMPL nosys +371 UNIMPL nosys +372 UNIMPL nosys +373 UNIMPL nosys +374 UNIMPL nosys +375 UNIMPL nosys +376 UNIMPL nosys +377 UNIMPL nosys +378 UNIMPL nosys +379 UNIMPL nosys +380 UNIMPL nosys +381 UNIMPL nosys +382 UNIMPL nosys +383 UNIMPL nosys +384 UNIMPL nosys +385 UNIMPL nosys +386 UNIMPL nosys +387 UNIMPL nosys +388 UNIMPL nosys +389 UNIMPL nosys +390 UNIMPL nosys +391 STD { int lchflags(char *path, int flags); } +392 STD { int uuidgen(struct uuid *store, int count); } +393 STD { int sendfile(int fd, int s, off_t offset, size_t nbytes, \ struct sf_hdtr *hdtr, off_t *sbytes, int flags); } ; 394-439 used by FreeBSD-current -394 UNIMPL NOHIDE nosys -395 UNIMPL NOHIDE nosys -396 UNIMPL NOHIDE nosys -397 UNIMPL NOHIDE nosys -398 UNIMPL NOHIDE nosys -399 UNIMPL NOHIDE nosys -400 UNIMPL NOHIDE nosys -401 UNIMPL NOHIDE nosys -402 UNIMPL NOHIDE nosys -403 UNIMPL NOHIDE nosys -404 UNIMPL NOHIDE nosys -405 UNIMPL NOHIDE nosys -406 UNIMPL NOHIDE nosys -407 UNIMPL NOHIDE nosys -408 UNIMPL NOHIDE nosys -409 UNIMPL NOHIDE nosys -410 UNIMPL NOHIDE nosys -411 UNIMPL NOHIDE nosys -412 UNIMPL NOHIDE nosys -413 UNIMPL NOHIDE nosys -414 UNIMPL NOHIDE nosys -415 UNIMPL NOHIDE nosys -416 UNIMPL NOHIDE nosys -417 UNIMPL NOHIDE nosys -418 UNIMPL NOHIDE nosys -419 UNIMPL NOHIDE nosys -420 UNIMPL NOHIDE nosys -421 UNIMPL NOHIDE nosys -422 UNIMPL NOHIDE nosys -423 UNIMPL NOHIDE nosys -424 UNIMPL NOHIDE nosys -425 UNIMPL NOHIDE nosys -426 UNIMPL NOHIDE nosys -427 UNIMPL NOHIDE nosys -428 UNIMPL NOHIDE nosys -429 UNIMPL NOHIDE nosys -430 UNIMPL NOHIDE nosys -431 UNIMPL NOHIDE nosys -432 UNIMPL NOHIDE nosys -433 UNIMPL NOHIDE nosys -434 UNIMPL NOHIDE nosys -435 UNIMPL NOHIDE nosys -436 UNIMPL NOHIDE nosys -437 UNIMPL NOHIDE nosys -438 UNIMPL NOHIDE nosys -439 UNIMPL NOHIDE nosys +394 UNIMPL nosys +395 UNIMPL nosys +396 UNIMPL nosys +397 UNIMPL nosys +398 UNIMPL nosys +399 UNIMPL nosys +400 UNIMPL nosys +401 UNIMPL nosys +402 UNIMPL nosys +403 UNIMPL nosys +404 UNIMPL nosys +405 UNIMPL nosys +406 UNIMPL nosys +407 UNIMPL nosys +408 UNIMPL nosys +409 UNIMPL nosys +410 UNIMPL nosys +411 UNIMPL nosys +412 UNIMPL nosys +413 UNIMPL nosys +414 UNIMPL nosys +415 UNIMPL nosys +416 UNIMPL nosys +417 UNIMPL nosys +418 UNIMPL nosys +419 UNIMPL nosys +420 UNIMPL nosys +421 UNIMPL nosys +422 UNIMPL nosys +423 UNIMPL nosys +424 UNIMPL nosys +425 UNIMPL nosys +426 UNIMPL nosys +427 UNIMPL nosys +428 UNIMPL nosys +429 UNIMPL nosys +430 UNIMPL nosys +431 UNIMPL nosys +432 UNIMPL nosys +433 UNIMPL nosys +434 UNIMPL nosys +435 UNIMPL nosys +436 UNIMPL nosys +437 UNIMPL nosys +438 UNIMPL nosys +439 UNIMPL nosys ; 440-449 reserved for FreeBSD-5.x growth -440 UNIMPL NOHIDE nosys -441 UNIMPL NOHIDE nosys -442 UNIMPL NOHIDE nosys -443 UNIMPL NOHIDE nosys -444 UNIMPL NOHIDE nosys -445 UNIMPL NOHIDE nosys -446 UNIMPL NOHIDE nosys -447 UNIMPL NOHIDE nosys -448 UNIMPL NOHIDE nosys -449 UNIMPL NOHIDE nosys +440 UNIMPL nosys +441 UNIMPL nosys +442 UNIMPL nosys +443 UNIMPL nosys +444 UNIMPL nosys +445 UNIMPL nosys +446 UNIMPL nosys +447 UNIMPL nosys +448 UNIMPL nosys +449 UNIMPL nosys ; 450 DragonFly system calls -450 STD BSD { int varsym_set(int level, const char *name, const char *data); } -451 STD BSD { int varsym_get(int mask, const char *wild, char *buf, int bufsize); } -452 STD BSD { int varsym_list(int level, char *buf, int maxsize, int *marker); } -453 OBSOL BSD upc_register -454 OBSOL BSD upc_control -455 OBSOL BSD caps_sys_service -456 OBSOL BSD caps_sys_client -457 OBSOL BSD caps_sys_close -458 OBSOL BSD caps_sys_put -459 OBSOL BSD caps_sys_reply -460 OBSOL BSD caps_sys_get -461 OBSOL BSD caps_sys_wait -462 OBSOL BSD caps_sys_abort -463 OBSOL BSD caps_sys_getgen -464 OBSOL BSD caps_sys_setgen -465 STD BSD { int exec_sys_register(void *entry); } -466 STD BSD { int exec_sys_unregister(int id); } -467 STD BSD { int sys_checkpoint(int type, int fd, pid_t pid, int retval); } -468 STD BSD { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); } -469 STD BSD { int umtx_sleep(volatile const int *ptr, int value, int timeout); } -470 STD BSD { int umtx_wakeup(volatile const int *ptr, int count); } -471 STD BSD { int jail_attach(int jid); } -472 STD BSD { int set_tls_area(int which, struct tls_info *info, size_t infosize); } -473 STD BSD { int get_tls_area(int which, struct tls_info *info, size_t infosize); } -474 STD BSD { int closefrom(int fd); } -475 STD POSIX { int stat(const char *path, struct stat *ub); } -476 STD POSIX { int fstat(int fd, struct stat *sb); } -477 STD POSIX { int lstat(const char *path, struct stat *ub); } -478 STD BSD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); } -479 STD BSD { int getdirentries(int fd, char *buf, u_int count, \ +450 STD { int varsym_set(int level, const char *name, const char *data); } +451 STD { int varsym_get(int mask, const char *wild, char *buf, int bufsize); } +452 STD { int varsym_list(int level, char *buf, int maxsize, int *marker); } +453 OBSOL upc_register +454 OBSOL upc_control +455 OBSOL caps_sys_service +456 OBSOL caps_sys_client +457 OBSOL caps_sys_close +458 OBSOL caps_sys_put +459 OBSOL caps_sys_reply +460 OBSOL caps_sys_get +461 OBSOL caps_sys_wait +462 OBSOL caps_sys_abort +463 OBSOL caps_sys_getgen +464 OBSOL caps_sys_setgen +465 STD { int exec_sys_register(void *entry); } +466 STD { int exec_sys_unregister(int id); } +467 STD { int sys_checkpoint(int type, int fd, pid_t pid, int retval); } +468 STD { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); } +469 STD { int umtx_sleep(volatile const int *ptr, int value, int timeout); } +470 STD { int umtx_wakeup(volatile const int *ptr, int count); } +471 STD { int jail_attach(int jid); } +472 STD { int set_tls_area(int which, struct tls_info *info, size_t infosize); } +473 STD { int get_tls_area(int which, struct tls_info *info, size_t infosize); } +474 STD { int closefrom(int fd); } +475 STD { int stat(const char *path, struct stat *ub); } +476 STD { int fstat(int fd, struct stat *sb); } +477 STD { int lstat(const char *path, struct stat *ub); } +478 STD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); } +479 STD { int getdirentries(int fd, char *buf, u_int count, \ long *basep); } -480 STD BSD { int getdents(int fd, char *buf, size_t count); } -481 STD BSD { int usched_set(pid_t pid, int cmd, void *data, \ +480 STD { int getdents(int fd, char *buf, size_t count); } +481 STD { int usched_set(pid_t pid, int cmd, void *data, \ int bytes); } -482 STD BSD { int extaccept(int s, int flags, caddr_t name, int *anamelen); } -483 STD BSD { int extconnect(int s, int flags, caddr_t name, int namelen); } -484 OBSOL BSD syslink -485 STD BSD { int mcontrol(void *addr, size_t len, int behav, off_t value); } -486 STD BSD { int vmspace_create(void *id, int type, void *data); } -487 STD BSD { int vmspace_destroy(void *id); } -488 STD BSD { int vmspace_ctl(void *id, int cmd, \ +482 STD { int extaccept(int s, int flags, caddr_t name, int *anamelen); } +483 STD { int extconnect(int s, int flags, caddr_t name, int namelen); } +484 OBSOL syslink +485 STD { int mcontrol(void *addr, size_t len, int behav, off_t value); } +486 STD { int vmspace_create(void *id, int type, void *data); } +487 STD { int vmspace_destroy(void *id); } +488 STD { int vmspace_ctl(void *id, int cmd, \ struct trapframe *tframe, \ struct vextframe *vframe); } -489 STD BSD { int vmspace_mmap(void *id, void *addr, size_t len, \ +489 STD { int vmspace_mmap(void *id, void *addr, size_t len, \ int prot, int flags, int fd, \ off_t offset); } -490 STD BSD { int vmspace_munmap(void *id, void *addr, \ +490 STD { int vmspace_munmap(void *id, void *addr, \ size_t len); } -491 STD BSD { int vmspace_mcontrol(void *id, void *addr, \ +491 STD { int vmspace_mcontrol(void *id, void *addr, \ size_t len, int behav, off_t value); } -492 STD BSD { ssize_t vmspace_pread(void *id, void *buf, \ +492 STD { ssize_t vmspace_pread(void *id, void *buf, \ size_t nbyte, int flags, off_t offset); } -493 STD BSD { ssize_t vmspace_pwrite(void *id, const void *buf, \ +493 STD { ssize_t vmspace_pwrite(void *id, const void *buf, \ size_t nbyte, int flags, off_t offset); } -494 STD BSD { void extexit(int how, int status, void *addr); } -495 STD BSD { int lwp_create(struct lwp_params *params); } -496 STD BSD { lwpid_t lwp_gettid(void); } -497 STD BSD { int lwp_kill(pid_t pid, lwpid_t tid, int signum); } -498 STD BSD { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); } -499 STD BSD { int pselect(int nd, fd_set *in, fd_set *ou, \ +494 STD { void extexit(int how, int status, void *addr); } +495 STD { int lwp_create(struct lwp_params *params); } +496 STD { lwpid_t lwp_gettid(void); } +497 STD { int lwp_kill(pid_t pid, lwpid_t tid, int signum); } +498 STD { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); } +499 STD { int pselect(int nd, fd_set *in, fd_set *ou, \ fd_set *ex, const struct timespec *ts, \ const sigset_t *sigmask); } -500 STD BSD { int statvfs(const char *path, struct statvfs *buf); } -501 STD BSD { int fstatvfs(int fd, struct statvfs *buf); } -502 STD BSD { int fhstatvfs(const struct fhandle *u_fhp, struct statvfs *buf); } -503 STD BSD { int getvfsstat(struct statfs *buf, \ +500 STD { int statvfs(const char *path, struct statvfs *buf); } +501 STD { int fstatvfs(int fd, struct statvfs *buf); } +502 STD { int fhstatvfs(const struct fhandle *u_fhp, struct statvfs *buf); } +503 STD { int getvfsstat(struct statfs *buf, \ struct statvfs *vbuf, long vbufsize, int flags); } -504 STD POSIX { int openat(int fd, char *path, int flags, int mode); } +504 STD { int openat(int fd, char *path, int flags, int mode); } ; XXX should be { int openat(int fd, const char *path, int flags, ...);} ; but we're not ready for `const' or varargs. ; XXX man page says `mode_t mode'. -505 STD POSIX { int fstatat(int fd, char *path, \ +505 STD { int fstatat(int fd, char *path, \ struct stat *sb, int flags); } -506 STD POSIX { int fchmodat(int fd, char *path, int mode, \ +506 STD { int fchmodat(int fd, char *path, int mode, \ int flags); } -507 STD POSIX { int fchownat(int fd, char *path, int uid, int gid, \ +507 STD { int fchownat(int fd, char *path, int uid, int gid, \ int flags); } -508 STD POSIX { int unlinkat(int fd, char *path, int flags); } -509 STD POSIX { int faccessat(int fd, char *path, int amode, \ +508 STD { int unlinkat(int fd, char *path, int flags); } +509 STD { int faccessat(int fd, char *path, int amode, \ int flags); } ; POSIX message queues system calls -510 STD POSIX { mqd_t mq_open(const char * name, int oflag, \ +510 STD { mqd_t mq_open(const char * name, int oflag, \ mode_t mode, struct mq_attr *attr); } -511 STD POSIX { int mq_close(mqd_t mqdes); } -512 STD POSIX { int mq_unlink(const char *name); } -513 STD POSIX { int mq_getattr(mqd_t mqdes, \ +511 STD { int mq_close(mqd_t mqdes); } +512 STD { int mq_unlink(const char *name); } +513 STD { int mq_getattr(mqd_t mqdes, \ struct mq_attr *mqstat); } -514 STD POSIX { int mq_setattr(mqd_t mqdes, \ +514 STD { int mq_setattr(mqd_t mqdes, \ const struct mq_attr *mqstat, \ struct mq_attr *omqstat); } -515 STD POSIX { int mq_notify(mqd_t mqdes, \ +515 STD { int mq_notify(mqd_t mqdes, \ const struct sigevent *notification); } -516 STD POSIX { int mq_send(mqd_t mqdes, const char *msg_ptr, \ +516 STD { int mq_send(mqd_t mqdes, const char *msg_ptr, \ size_t msg_len, unsigned msg_prio); } -517 STD POSIX { ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, \ +517 STD { ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, \ size_t msg_len, unsigned *msg_prio); } -518 STD POSIX { int mq_timedsend(mqd_t mqdes, \ +518 STD { int mq_timedsend(mqd_t mqdes, \ const char *msg_ptr, size_t msg_len, \ unsigned msg_prio, \ const struct timespec *abs_timeout); } -519 STD POSIX { ssize_t mq_timedreceive(mqd_t mqdes, \ +519 STD { ssize_t mq_timedreceive(mqd_t mqdes, \ char *msg_ptr, size_t msg_len, unsigned *msg_prio, \ const struct timespec *abs_timeout); } -520 STD BSD { int ioprio_set(int which, int who, int prio); } -521 STD BSD { int ioprio_get(int which, int who); } -522 STD BSD { int chroot_kernel(char *path); } -523 STD POSIX { int renameat(int oldfd, char *old, int newfd, \ +520 STD { int ioprio_set(int which, int who, int prio); } +521 STD { int ioprio_get(int which, int who); } +522 STD { int chroot_kernel(char *path); } +523 STD { int renameat(int oldfd, char *old, int newfd, \ char *new); } -524 STD POSIX { int mkdirat(int fd, char *path, mode_t mode); } -525 STD POSIX { int mkfifoat(int fd, char *path, mode_t mode); } -526 STD POSIX { int mknodat(int fd, char *path, mode_t mode, \ +524 STD { int mkdirat(int fd, char *path, mode_t mode); } +525 STD { int mkfifoat(int fd, char *path, mode_t mode); } +526 STD { int mknodat(int fd, char *path, mode_t mode, \ dev_t dev); } -527 STD POSIX { int readlinkat(int fd, char *path, char *buf, \ +527 STD { int readlinkat(int fd, char *path, char *buf, \ size_t bufsize); } -528 STD POSIX { int symlinkat(char *path1, int fd, char *path2); } -529 STD BSD { int swapoff(char *name); } -530 STD BSD { int vquotactl(const char *path, \ +528 STD { int symlinkat(char *path1, int fd, char *path2); } +529 STD { int swapoff(char *name); } +530 STD { int vquotactl(const char *path, \ struct plistref *pref); } -531 STD POSIX { int linkat(int fd1, char *path1, int fd2, \ +531 STD { int linkat(int fd1, char *path1, int fd2, \ char *path2, int flags); } -532 STD BSD { int eaccess(char *path, int flags); } -533 STD BSD { int lpathconf(char *path, int name); } -534 STD BSD { int vmm_guest_ctl(int op, struct vmm_guest_options *options); } -535 STD BSD { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); } +532 STD { int eaccess(char *path, int flags); } +533 STD { int lpathconf(char *path, int name); } +534 STD { int vmm_guest_ctl(int op, struct vmm_guest_options *options); } +535 STD { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); } diff --git a/sys/sys/syscall-hide.h b/sys/sys/syscall-hide.h deleted file mode 100644 index 258534aa2b..0000000000 --- a/sys/sys/syscall-hide.h +++ /dev/null @@ -1,369 +0,0 @@ -/* - * System call hiders. - * - * DO NOT EDIT-- To regenerate this file, edit syscalls.master followed - * by running make sysent in the same directory. - */ - -#ifdef COMPAT_43 -#endif -HIDE_POSIX(fork) -HIDE_POSIX(read) -HIDE_POSIX(write) -HIDE_POSIX(open) -HIDE_POSIX(close) -HIDE_BSD(wait4) -HIDE_BSD(creat) -HIDE_POSIX(link) -HIDE_POSIX(unlink) -HIDE_POSIX(chdir) -HIDE_BSD(fchdir) -HIDE_POSIX(mknod) -HIDE_POSIX(chmod) -HIDE_POSIX(chown) -HIDE_BSD(obreak) -HIDE_BSD(getfsstat) -HIDE_POSIX(lseek) -HIDE_POSIX(getpid) -HIDE_BSD(mount) -HIDE_BSD(unmount) -HIDE_POSIX(setuid) -HIDE_POSIX(getuid) -HIDE_POSIX(geteuid) -HIDE_BSD(ptrace) -HIDE_BSD(recvmsg) -HIDE_BSD(sendmsg) -HIDE_BSD(recvfrom) -HIDE_BSD(accept) -HIDE_BSD(getpeername) -HIDE_BSD(getsockname) -HIDE_POSIX(access) -HIDE_BSD(chflags) -HIDE_BSD(fchflags) -HIDE_BSD(sync) -HIDE_POSIX(kill) -HIDE_POSIX(stat) -HIDE_POSIX(getppid) -HIDE_POSIX(lstat) -HIDE_POSIX(dup) -HIDE_POSIX(pipe) -HIDE_POSIX(getegid) -HIDE_BSD(profil) -HIDE_BSD(ktrace) -HIDE_POSIX(getgid) -HIDE_BSD(getlogin) -HIDE_BSD(setlogin) -HIDE_BSD(acct) -HIDE_BSD(sigaltstack) -HIDE_POSIX(ioctl) -HIDE_BSD(reboot) -HIDE_POSIX(revoke) -HIDE_POSIX(symlink) -HIDE_POSIX(readlink) -HIDE_POSIX(execve) -HIDE_POSIX(umask) -HIDE_BSD(chroot) -HIDE_POSIX(fstat) -HIDE_BSD(getkerninfo) -HIDE_BSD(getpagesize) -HIDE_BSD(msync) -HIDE_BSD(vfork) -HIDE_BSD(sbrk) -HIDE_BSD(sstk) -HIDE_BSD(mmap) -HIDE_BSD(vadvise) -HIDE_BSD(munmap) -HIDE_BSD(mprotect) -HIDE_BSD(madvise) -HIDE_BSD(mincore) -HIDE_POSIX(getgroups) -HIDE_POSIX(setgroups) -HIDE_POSIX(getpgrp) -HIDE_POSIX(setpgid) -HIDE_BSD(setitimer) -HIDE_BSD(wait) -HIDE_BSD(swapon) -HIDE_BSD(getitimer) -HIDE_BSD(gethostname) -HIDE_BSD(sethostname) -HIDE_BSD(getdtablesize) -HIDE_POSIX(dup2) -HIDE_BSD(getdopt) -HIDE_POSIX(fcntl) -HIDE_BSD(select) -HIDE_BSD(setdopt) -HIDE_POSIX(fsync) -HIDE_BSD(setpriority) -HIDE_BSD(socket) -HIDE_BSD(connect) -HIDE_BSD(accept) -HIDE_BSD(getpriority) -HIDE_BSD(send) -HIDE_BSD(recv) -HIDE_BSD(bind) -HIDE_BSD(setsockopt) -HIDE_BSD(listen) -HIDE_BSD(sigvec) -HIDE_BSD(sigblock) -HIDE_BSD(sigsetmask) -HIDE_BSD(sigstack) -HIDE_BSD(recvmsg) -HIDE_BSD(sendmsg) -HIDE_BSD(gettimeofday) -HIDE_BSD(getrusage) -HIDE_BSD(getsockopt) -HIDE_BSD(readv) -HIDE_BSD(writev) -HIDE_BSD(settimeofday) -HIDE_BSD(fchown) -HIDE_BSD(fchmod) -HIDE_BSD(recvfrom) -HIDE_BSD(setreuid) -HIDE_BSD(setregid) -HIDE_POSIX(rename) -HIDE_BSD(truncate) -HIDE_BSD(ftruncate) -HIDE_BSD(flock) -HIDE_POSIX(mkfifo) -HIDE_BSD(sendto) -HIDE_BSD(shutdown) -HIDE_BSD(socketpair) -HIDE_POSIX(mkdir) -HIDE_POSIX(rmdir) -HIDE_BSD(utimes) -HIDE_BSD(adjtime) -HIDE_BSD(getpeername) -HIDE_BSD(gethostid) -HIDE_BSD(sethostid) -HIDE_BSD(getrlimit) -HIDE_BSD(setrlimit) -HIDE_BSD(killpg) -HIDE_POSIX(setsid) -HIDE_BSD(quotactl) -HIDE_BSD(quota) -HIDE_BSD(getsockname) -HIDE_BSD(nfssvc) -HIDE_BSD(getdirentries) -HIDE_BSD(statfs) -HIDE_BSD(fstatfs) -HIDE_BSD(getfh) -HIDE_BSD(getdomainname) -HIDE_BSD(setdomainname) -HIDE_BSD(uname) -HIDE_BSD(sysarch) -HIDE_BSD(rtprio) -HIDE_BSD(semsys) -HIDE_BSD(msgsys) -HIDE_BSD(shmsys) -HIDE_POSIX(extpread) -HIDE_POSIX(extpwrite) -HIDE_BSD(ntp_adjtime) -HIDE_POSIX(setgid) -HIDE_BSD(setegid) -HIDE_BSD(seteuid) -HIDE_BSD(lfs_bmapv) -HIDE_BSD(lfs_markv) -HIDE_BSD(lfs_segclean) -HIDE_BSD(lfs_segwait) -HIDE_POSIX(stat) -HIDE_POSIX(fstat) -HIDE_POSIX(lstat) -HIDE_POSIX(pathconf) -HIDE_POSIX(fpathconf) -HIDE_BSD(getrlimit) -HIDE_BSD(setrlimit) -HIDE_BSD(getdirentries) -HIDE_BSD(mmap) -HIDE_POSIX(lseek) -HIDE_BSD(truncate) -HIDE_BSD(ftruncate) -HIDE_BSD(__sysctl) -HIDE_BSD(mlock) -HIDE_BSD(munlock) -HIDE_BSD(undelete) -HIDE_BSD(futimes) -HIDE_BSD(getpgid) -HIDE_BSD(poll) -HIDE_BSD(__semctl) -HIDE_BSD(semget) -HIDE_BSD(semop) -HIDE_BSD(msgctl) -HIDE_BSD(msgget) -HIDE_BSD(msgsnd) -HIDE_BSD(msgrcv) -HIDE_BSD(shmat) -HIDE_BSD(shmctl) -HIDE_BSD(shmdt) -HIDE_BSD(shmget) -HIDE_POSIX(clock_gettime) -HIDE_POSIX(clock_settime) -HIDE_POSIX(clock_getres) -HIDE_POSIX(nanosleep) -HIDE_BSD(minherit) -HIDE_BSD(rfork) -HIDE_BSD(openbsd_poll) -HIDE_BSD(issetugid) -HIDE_BSD(lchown) -HIDE_BSD(getdents) -HIDE_BSD(lchmod) -HIDE_BSD(lchown) -HIDE_BSD(lutimes) -HIDE_BSD(msync) -HIDE_BSD({) -HIDE_BSD(extpreadv) -HIDE_BSD(extpwritev) -HIDE_BSD(fhstatfs) -HIDE_BSD(fhopen) -HIDE_POSIX(fhstat) -HIDE_BSD(modnext) -HIDE_BSD(modstat) -HIDE_BSD(modfnext) -HIDE_BSD(modfind) -HIDE_BSD(kldload) -HIDE_BSD(kldunload) -HIDE_BSD(kldfind) -HIDE_BSD(kldnext) -HIDE_BSD(kldstat) -HIDE_BSD(kldfirstmod) -HIDE_BSD(getsid) -HIDE_BSD(setresuid) -HIDE_BSD(setresgid) -HIDE_BSD(aio_return) -HIDE_BSD(aio_suspend) -HIDE_BSD(aio_cancel) -HIDE_BSD(aio_error) -HIDE_BSD(aio_read) -HIDE_BSD(aio_write) -HIDE_BSD(lio_listio) -HIDE_BSD(yield) -HIDE_BSD(thr_sleep) -HIDE_BSD(thr_wakeup) -HIDE_BSD(mlockall) -HIDE_BSD(munlockall) -HIDE_BSD(__getcwd) -HIDE_POSIX(sched_setparam) -HIDE_POSIX(sched_getparam) -HIDE_POSIX(sched_setscheduler) -HIDE_POSIX(sched_getscheduler) -HIDE_POSIX(sched_yield) -HIDE_POSIX(sched_get_priority_max) -HIDE_POSIX(sched_get_priority_min) -HIDE_POSIX(sched_rr_get_interval) -HIDE_BSD(utrace) -HIDE_BSD(kldsym) -HIDE_BSD(jail) -HIDE_BSD(pioctl) -HIDE_POSIX(sigprocmask) -HIDE_POSIX(sigsuspend) -HIDE_POSIX(sigaction) -HIDE_POSIX(sigpending) -HIDE_BSD(sigreturn) -HIDE_POSIX(sigtimedwait) -HIDE_POSIX(sigwaitinfo) -HIDE_BSD(__acl_get_file) -HIDE_BSD(__acl_set_file) -HIDE_BSD(__acl_get_fd) -HIDE_BSD(__acl_set_fd) -HIDE_BSD(__acl_delete_file) -HIDE_BSD(__acl_delete_fd) -HIDE_BSD(__acl_aclcheck_file) -HIDE_BSD(__acl_aclcheck_fd) -HIDE_BSD(extattrctl) -HIDE_BSD(extattr_set_file) -HIDE_BSD(extattr_get_file) -HIDE_BSD(extattr_delete_file) -HIDE_BSD(aio_waitcomplete) -HIDE_BSD(getresuid) -HIDE_BSD(getresgid) -HIDE_BSD(kqueue) -HIDE_BSD(kevent) -HIDE_BSD(sctp_peeloff) -HIDE_BSD(lchflags) -HIDE_BSD(uuidgen) -HIDE_BSD(sendfile) -HIDE_BSD(varsym_set) -HIDE_BSD(varsym_get) -HIDE_BSD(varsym_list) -HIDE_BSD(upc_register) -HIDE_BSD(upc_control) -HIDE_BSD(caps_sys_service) -HIDE_BSD(caps_sys_client) -HIDE_BSD(caps_sys_close) -HIDE_BSD(caps_sys_put) -HIDE_BSD(caps_sys_reply) -HIDE_BSD(caps_sys_get) -HIDE_BSD(caps_sys_wait) -HIDE_BSD(caps_sys_abort) -HIDE_BSD(caps_sys_getgen) -HIDE_BSD(caps_sys_setgen) -HIDE_BSD(exec_sys_register) -HIDE_BSD(exec_sys_unregister) -HIDE_BSD(sys_checkpoint) -HIDE_BSD(mountctl) -HIDE_BSD(umtx_sleep) -HIDE_BSD(umtx_wakeup) -HIDE_BSD(jail_attach) -HIDE_BSD(set_tls_area) -HIDE_BSD(get_tls_area) -HIDE_BSD(closefrom) -HIDE_POSIX(stat) -HIDE_POSIX(fstat) -HIDE_POSIX(lstat) -HIDE_BSD(fhstat) -HIDE_BSD(getdirentries) -HIDE_BSD(getdents) -HIDE_BSD(usched_set) -HIDE_BSD(extaccept) -HIDE_BSD(extconnect) -HIDE_BSD(syslink) -HIDE_BSD(mcontrol) -HIDE_BSD(vmspace_create) -HIDE_BSD(vmspace_destroy) -HIDE_BSD(vmspace_ctl) -HIDE_BSD(vmspace_mmap) -HIDE_BSD(vmspace_munmap) -HIDE_BSD(vmspace_mcontrol) -HIDE_BSD(vmspace_pread) -HIDE_BSD(vmspace_pwrite) -HIDE_BSD(extexit) -HIDE_BSD(lwp_create) -HIDE_BSD(lwp_gettid) -HIDE_BSD(lwp_kill) -HIDE_BSD(lwp_rtprio) -HIDE_BSD(pselect) -HIDE_BSD(statvfs) -HIDE_BSD(fstatvfs) -HIDE_BSD(fhstatvfs) -HIDE_BSD(getvfsstat) -HIDE_POSIX(openat) -HIDE_POSIX(fstatat) -HIDE_POSIX(fchmodat) -HIDE_POSIX(fchownat) -HIDE_POSIX(unlinkat) -HIDE_POSIX(faccessat) -HIDE_POSIX(mq_open) -HIDE_POSIX(mq_close) -HIDE_POSIX(mq_unlink) -HIDE_POSIX(mq_getattr) -HIDE_POSIX(mq_setattr) -HIDE_POSIX(mq_notify) -HIDE_POSIX(mq_send) -HIDE_POSIX(mq_receive) -HIDE_POSIX(mq_timedsend) -HIDE_POSIX(mq_timedreceive) -HIDE_BSD(ioprio_set) -HIDE_BSD(ioprio_get) -HIDE_BSD(chroot_kernel) -HIDE_POSIX(renameat) -HIDE_POSIX(mkdirat) -HIDE_POSIX(mkfifoat) -HIDE_POSIX(mknodat) -HIDE_POSIX(readlinkat) -HIDE_POSIX(symlinkat) -HIDE_BSD(swapoff) -HIDE_BSD(vquotactl) -HIDE_POSIX(linkat) -HIDE_BSD(eaccess) -HIDE_BSD(lpathconf) -HIDE_BSD(vmm_guest_ctl) -HIDE_BSD(vmm_guest_sync_addr) diff --git a/test/debug/chkincludes b/test/debug/chkincludes index e41c4d2fcc..923af05551 100644 --- a/test/debug/chkincludes +++ b/test/debug/chkincludes @@ -6,8 +6,6 @@ # # The goal is that the only error reported should be a specific #error # indicating that particular support is not available. -# -# $DragonFly: src/test/debug/chkincludes,v 1.2 2006/10/24 17:09:46 swildner Exp $ cd /usr/src/sys set files = ( sys/*.h vm/*.h net*/*.h ddb/*.h i386/include/*.h ) @@ -36,9 +34,6 @@ echo "#define INET 1" > opt_inet.h ln -s /usr/src/sys/arch/i386/include machine foreach i ( $files ) - if ( "$i" == "sys/syscall-hide.h" ) then - continue - endif if ( "$i" == "sys/sysunion.h" ) then continue endif @@ -50,9 +45,6 @@ EOF cc -D_KERNEL -DKLD_MODULE -fno-builtin -I/usr/src/sys -I. -Wall -Wstrict-prototypes -c chkincl.c -o chkincl.o end foreach i ( $files ) - if ( "$i" == "sys/syscall-hide.h" ) then - continue - endif if ( "$i" == "sys/sysunion.h" ) then continue endif @@ -65,9 +57,6 @@ EOF end foreach i ( $files ) - if ( "$i" == "sys/syscall-hide.h" ) then - continue - endif if ( "$i" == "sys/sysunion.h" ) then continue endif diff --git a/usr.bin/truss/i386.conf b/usr.bin/truss/i386.conf index 03e3588ca2..3c505fd15c 100644 --- a/usr.bin/truss/i386.conf +++ b/usr.bin/truss/i386.conf @@ -1,4 +1,3 @@ -# $DragonFly: src/usr.bin/truss/i386.conf,v 1.3 2004/08/12 19:59:31 eirikn Exp $ sysnames="syscalls.h" sysproto="/dev/null" sysunion="/dev/null" @@ -6,7 +5,6 @@ sysproto_h="/dev/null" syshdr="/dev/null" sysmk="/dev/null" syssw="/dev/null" -syshide="/dev/null" sysargs="/dev/null" syscallprefix="SYS_" switchname="sysent" diff --git a/usr.bin/truss/i386linux.conf b/usr.bin/truss/i386linux.conf index 379c2cdd1d..4f66bbe7dd 100644 --- a/usr.bin/truss/i386linux.conf +++ b/usr.bin/truss/i386linux.conf @@ -1,4 +1,3 @@ -# $DragonFly: src/usr.bin/truss/i386linux.conf,v 1.3 2004/08/12 19:59:31 eirikn Exp $ sysnames="linux_syscalls.h" sysproto="/dev/null" sysunion="/dev/null" @@ -6,7 +5,6 @@ sysproto_h="/dev/null" syshdr="/dev/null" sysmk="/dev/null" syssw="/dev/null" -syshide="/dev/null" sysargs="/dev/null" syscallprefix="SYS_" switchname="sysent" -- 2.41.0