Remove the <sys/syscall-hide.h> header file.
authorSascha Wildner <saw@online.de>
Tue, 26 Nov 2013 18:24:37 +0000 (19:24 +0100)
committerSascha Wildner <saw@online.de>
Tue, 26 Nov 2013 18:27:35 +0000 (19:27 +0100)
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
share/man/man9/syscall.9
sys/emulation/linux/i386/syscalls.conf
sys/emulation/linux/i386/syscalls.master
sys/kern/Makefile.misc
sys/kern/makesyscalls.sh
sys/kern/syscalls.master
sys/sys/syscall-hide.h [deleted file]
test/debug/chkincludes
usr.bin/truss/i386.conf
usr.bin/truss/i386linux.conf

index aee83af..e41426a 100644 (file)
@@ -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
index 8b939d8..11e86ab 100644 (file)
@@ -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
index 1edea4d..b641dfa 100644 (file)
@@ -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"
index a5e9451..9fff31b 100644 (file)
@@ -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
 
 ; #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
index 4bb1272..f0b8693 100644 (file)
@@ -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
index 121a842..efcdd85 100644 (file)
@@ -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
        }
index ea198db..e3b9149 100644 (file)
@@ -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
 ; 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 (file)
index 258534a..0000000
+++ /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)
index e41c4d2..923af05 100644 (file)
@@ -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
index 03e3588..3c505fd 100644 (file)
@@ -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"
index 379c2cd..4f66bbe 100644 (file)
@@ -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"