o Introduce private types for use in linux syscalls for two reasons:

   1. establish type independence for ease in porting and,
   2. provide a visual queue as to which syscalls have proper
      prototypes to further cleanup the i386/alpha split.
   Linuxulator types are prefixed by 'l_'. void and char have not
   been "virtualized".

o  Remove dummy functions for syscalls that are now truely
   unimplemented.

o  Rename syscalls so they match the names used in the Linux kernel.
   Also, provide more accurate prototypes. This generally improves
   cross-referencing and reduces head-scratching.

o  Provide seperate implementations for the 16-bit uid_t and gid_t
   based syscalls as Linux used to have. The new 32-bit uid_t and
   gid_t based syscalls now map to their FreeBSD equivalents.

o  Fix the linux_ipc syscall so that it doesn't force the shm*, sem*
   and msg* syscalls to have the same syscall. The prototypes for
   these syscalls now match the those used on Alpha. While here,
   add the same kludge for MSGRCV as is present in the Linux kernel.

o  Implement the following syscalls:
     linux_stat64, linux_lstat64 and linux_fstat64
     linux_sysctl

o  Added syscalls numbered 198 - 221. This include:
     - the 32-bit uid_t and gid_t bases syscalls
     - 64-bit file offset/size based syscalls

1 files changed, 215 insertions, 166 deletions

diff --git a/sys/i386/linux/syscalls.master b/sys/i386/linux/syscalls.master
index 4680a72..2e477eb 100644
--- a/sys/i386/linux/syscalls.master
+++ b/sys/i386/linux/syscalls.master
@@ -31,261 +31,310 @@
 
 ; #ifdef's, etc. may be included, and are copied to the output files.
 
-0	STD	LINUX	{ int linux_setup(void); }
+0	UNIMPL	LINUX	setup
 1	MNOPROTO LINUX	{ void sys_exit(int rval); } exit sys_exit_args void
 2	MSTD	LINUX	{ int linux_fork(void); }
 3	NOPROTO	LINUX	{ int read(int fd, char *buf, u_int nbyte); }
 4	NOPROTO	LINUX	{ int write(int fd, char *buf, u_int nbyte); }
-5	STD	LINUX	{ int linux_open(char *path, int flags, int mode); }
+5	STD	LINUX	{ int linux_open(char *path, l_int flags, \
+				l_int mode); }
 6	NOPROTO	LINUX	{ int close(int fd); }
-7	STD	LINUX	{ int linux_waitpid(int pid, int *status, \
-				int options); }
-8	STD	LINUX	{ int linux_creat(char *path, int mode); }
+7	STD	LINUX	{ 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, \
 				char **envp); }
 12	STD	LINUX	{ int linux_chdir(char *path); }
-13	STD	LINUX	{ int linux_time(linux_time_t *tm); }
-14	STD	LINUX	{ int linux_mknod(char *path, int mode, int dev); }
-15	STD	LINUX	{ int linux_chmod(char *path, int mode); }
-16	STD	LINUX	{ int linux_lchown(char *path, int uid, int gid); }
-17	STD	LINUX	{ int linux_break(char *nsize); }
+13	STD	LINUX	{ int linux_time(l_time_t *tm); }
+14	STD	LINUX	{ 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, \
+				l_gid16_t gid); }
+17	UNIMPL	LINUX	break
 18	STD	LINUX	{ int linux_stat(char *path, struct ostat *up); }
-19	STD	LINUX	{ int linux_lseek(int fdes, long off, int whence); }
-20	NOPROTO	LINUX	{ int getpid(void); }
+19	STD	LINUX	{ 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, \
-				char *filesystemtype, u_long rwflag, \
+				char *filesystemtype, l_ulong rwflag, \
 				void *data); }
-22	STD	LINUX	{ int linux_umount(char *path); }
-23	NOPROTO	LINUX	{ int setuid(uid_t uid); }
-24	NOPROTO	LINUX	{ int getuid(void); }
+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(void); }
-27	STD	LINUX	{ int linux_alarm(unsigned int secs); }
-28	STD	LINUX	{ int linux_fstat(int fd, struct ostat *up); }
+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, \
-				struct linux_utimbuf *times); }
-31	STD	LINUX	{ int linux_stty(void); }
-32	STD	LINUX	{ int linux_gtty(void); }
-33	STD	LINUX	{ int linux_access(char *path, int flags); }
-34	STD	LINUX	{ int linux_nice(int inc); }
-35	STD	LINUX	{ int linux_ftime(void); }
+				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(int pid, int signum); }
+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, int mode); }
+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(int *pipefds); }
-43	STD	LINUX	{ int linux_times(struct linux_times_argv *buf); }
-44	STD	LINUX	{ int linux_prof(void); }
-45	STD	LINUX	{ int linux_brk(char *dsend); }
-46	NOPROTO	LINUX	{ int setgid(gid_t gid); }
-47	NOPROTO	LINUX	{ int getgid(void); }
-48	STD	LINUX	{ int linux_signal(int sig, linux_handler_t handler); }
-49	NOPROTO	LINUX	{ int geteuid(void); }
-50	NOPROTO	LINUX	{ int getegid(void); }
+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_umount2(char *path, int flags); }
-53	STD	LINUX	{ int linux_lock(void); }
-54	STD	LINUX	{ int linux_ioctl(int fd, u_long cmd, int arg); }
-55	STD	LINUX	{ int linux_fcntl(int fd, int cmd, int arg); }
-56	STD	LINUX	{ int linux_mpx(void); }
+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, \
+				l_ulong arg); }
+55	STD	LINUX	{ 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	STD	LINUX	{ int linux_ulimit(void); }
+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(linux_dev_t dev, \
-				struct linux_ustat *ubuf); }
+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	NOPROTO	LINUX	{ int getppid(void); }
 65	NOPROTO	LINUX	{ int getpgrp(void); }
 66	NOPROTO	LINUX	{ int setsid(void); }
-67	STD	LINUX	{ int linux_sigaction(int sig, \
-				linux_osigaction_t *nsa, \
-				linux_osigaction_t *osa); }
-68	STD	LINUX	{ int linux_siggetmask(void); }
-69	STD	LINUX	{ int linux_sigsetmask(linux_osigset_t mask); }
-70	NOPROTO	LINUX	{ int setreuid(int ruid, int euid); }
-71	NOPROTO	LINUX	{ int setregid(int rgid, int egid); }
-72	STD	LINUX	{ int linux_sigsuspend(int restart, \
-				linux_osigset_t oldmask, \
-				linux_osigset_t mask); }
-73	STD	LINUX	{ int linux_sigpending(linux_osigset_t *mask); }
+67	STD	LINUX	{ 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, \
+				l_uid16_t euid); }
+71	STD	LINUX	{ int linux_setregid16(l_gid16_t rgid, \
+				l_gid16_t egid); }
+72	STD	LINUX	{ int linux_sigsuspend(l_int hist0, l_int hist1, \
+				l_osigset_t mask); }
+73	STD	LINUX	{ int linux_sigpending(l_osigset_t *mask); }
 74	MNOPROTO LINUX	{ int osethostname(char *hostname, u_int len); } \
 			    osethostname sethostname_args int
-75	STD	LINUX	{ int linux_setrlimit(u_int resource, \
-				struct ogetrlimit *rlim); }
-76	STD	LINUX	{ int linux_getrlimit(u_int resource, \
-				struct ogetrlimit *rlim); }
+75	STD	LINUX	{ int linux_setrlimit(l_uint resource, \
+				struct l_rlimit *rlim); }
+76	STD	LINUX	{ 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, \
 				struct timezone *tzp); }
 79	MNOPROTO LINUX	{ int settimeofday(struct timeval *tp, \
 				struct timezone *tzp); }
-80	STD	LINUX	{ int linux_getgroups(u_int gidsetsize, \
-				linux_gid_t *gidset); }
-81	STD	LINUX	{ int linux_setgroups(u_int gidsetsize, \
-				linux_gid_t *gidset); }
-82	STD	LINUX	{ int linux_select(struct linux_select_argv *ptr); }
+80	STD	LINUX	{ int linux_getgroups16(l_uint gidsetsize, \
+				l_gid16_t *gidset); }
+81	STD	LINUX	{ int linux_setgroups16(l_uint gidsetsize, \
+				l_gid16_t *gidset); }
+82	STD	LINUX	{ int linux_old_select(struct l_old_select_argv \
+				*ptr); }
 83	STD	LINUX	{ int linux_symlink(char *path, char *to); }
 84	NOPROTO	LINUX	{ int ostat(char *path, struct ostat *up); }
 85	STD	LINUX	{ int linux_readlink(char *name, char *buf, \
-				int count); }
+				l_int count); }
 86	STD	LINUX	{ int linux_uselib(char *library); }
 87	NOPROTO	LINUX	{ int swapon(char *name); }
-88	STD	LINUX	{ int linux_reboot(int magic1, int magic2, int opt); }
-89	STD	LINUX	{ int linux_readdir(int fd, \
-				struct linux_dirent *dent, \
-				unsigned int count); }
-90	STD	LINUX	{ int linux_mmap(struct linux_mmap_argv *ptr); }
+88	STD	LINUX	{ 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, \
+				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, long length); }
+92	STD	LINUX	{ int linux_truncate(char *path, l_ulong length); }
 93	NOPROTO	LINUX	{ int oftruncate(int fd, long length); }
 94	NOPROTO	LINUX	{ int fchmod(int fd, int mode); }
 95	NOPROTO	LINUX	{ int fchown(int fd, int uid, int gid); }
 96	NOPROTO	LINUX	{ int getpriority(int which, int who); }
 97	NOPROTO	LINUX	{ int setpriority(int which, int who, int prio); }
-98	MNOPROTO LINUX	{ int profil(caddr_t samples, u_int size, \
-				u_int offset, u_int scale); }
+98	UNIMPL	LINUX	profil
 99	STD	LINUX	{ int linux_statfs(char *path, \
-				struct linux_statfs_buf *buf); }
-100	STD	LINUX	{ int linux_fstatfs(int fd, \
-				struct linux_statfs_buf *buf); }
-101	STD	LINUX	{ int linux_ioperm(unsigned int start, \
-				unsigned int length, int enable); }
-102	STD	LINUX	{ int linux_socketcall(int what, void *args); }
-103	STD	LINUX	{ int linux_ksyslog(int what); }
-104	STD	LINUX	{ int linux_setitimer(u_int which, \
-				struct itimerval *itv, \
-				struct itimerval *oitv); }
-105	STD	LINUX	{ int linux_getitimer(u_int which, \
-				struct itimerval *itv); }
+				struct l_statfs_buf *buf); }
+100	STD	LINUX	{ int linux_fstatfs(l_uint fd, \
+				struct l_statfs_buf *buf); }
+101	STD	LINUX	{ 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, \
+				struct l_itimerval *itv, \
+				struct l_itimerval *oitv); }
+105	STD	LINUX	{ int linux_getitimer(l_int which, \
+				struct l_itimerval *itv); }
 106	STD	LINUX	{ int linux_newstat(char *path, \
-				struct linux_newstat *buf); }
+				struct l_newstat *buf); }
 107	STD	LINUX	{ int linux_newlstat(char *path, \
-				struct linux_newstat *buf); }
-108	STD	LINUX	{ int linux_newfstat(int fd, \
-				struct linux_newstat *buf); }
+				struct l_newstat *buf); }
+108	STD	LINUX	{ int linux_newfstat(l_uint fd, \
+				struct l_newstat *buf); }
 109	STD	LINUX	{ int linux_uname(void); }
-110	STD	LINUX	{ int linux_iopl(int level); }
+110	STD	LINUX	{ int linux_iopl(l_ulong level); }
 111	STD	LINUX	{ int linux_vhangup(void); }
-112	STD	LINUX	{ int linux_idle(void); }
+112	UNIMPL	LINUX	idle
 113	STD	LINUX	{ int linux_vm86old(void); }
-114	STD	LINUX	{ int linux_wait4(int pid, int *status, \
-				int options, struct rusage *rusage); }
+114	STD	LINUX	{ 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 sysinfo *info); }
-117	STD	LINUX	{ int linux_ipc(int what, int arg1, int arg2, \
-				int arg3, caddr_t ptr); }
+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, \
+				l_int arg3, void *ptr, l_long arg5); }
 118	NOPROTO	LINUX	{ int fsync(int fd); }
-119	STD	LINUX	{ int linux_sigreturn(struct linux_sigframe *sfp); }
-120	STD	LINUX	{ int linux_clone(int flags, void *stack); }
+119	STD	LINUX	{ int linux_sigreturn(struct l_sigframe *sfp); }
+120	STD	LINUX	{ int linux_clone(l_int flags, void *stack); }
 121	MNOPROTO LINUX	{ int setdomainname(char *name, int len); }
-122	STD	LINUX	{ int linux_newuname(struct linux_new_utsname *buf); }
-123	STD	LINUX	{ int linux_modify_ldt(int func, void *ptr, \
-				size_t bytecount); }
+122	STD	LINUX	{ int linux_newuname(struct l_new_utsname *buf); }
+123	STD	LINUX	{ 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(int how, \
-				linux_osigset_t *mask, \
-				linux_osigset_t *omask); }
+126	STD	LINUX	{ 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	STD	LINUX	{ int linux_getpgid(int pid); }
+132	STD	LINUX	{ int linux_getpgid(l_pid_t pid); }
 133	NOPROTO	LINUX	{ int fchdir(int fd); }
 134	STD	LINUX	{ int linux_bdflush(void); }
-135	STD	LINUX	{ int linux_sysfs(int option, u_long arg1, \
-				u_long arg2); }
-136	STD	LINUX	{ int linux_personality(int per); }
-137	STD	LINUX	{ int linux_afs_syscall(void); }
-138	STD	LINUX	{ int linux_setfsuid(linux_uid_t uid); }
-139	STD	LINUX	{ int linux_setfsgid(linux_gid_t gid); }
-140	STD	LINUX	{ int linux_llseek(int fd, u_int32_t ohigh, \
-				u_int32_t olow, caddr_t res, int whence); }
-141	STD	LINUX	{ int linux_getdents(int fd, void *dent, \
-				unsigned count); }
-142	STD	LINUX	{ int linux_newselect(int nfds, fd_set *readfds, \
-				fd_set *writefds, fd_set *exceptfds, \
-				struct timeval *timeout); }
+135	STD	LINUX	{ 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, \
+				l_ulong olow, l_loff_t *res, l_uint whence); }
+141	STD	LINUX	{ int linux_getdents(l_uint fd, void *dent, \
+				l_uint count); }
+142	STD	LINUX	{ 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(caddr_t addr, int len, int fl); }
+144	STD	LINUX	{ int linux_msync(l_ulong addr, l_size_t len, \
+				l_int fl); }
 145	NOPROTO	LINUX	{ int readv(int fd, struct iovec *iovp, \
 				u_int iovcnt); }
 146	NOPROTO	LINUX	{ int writev(int fd, struct iovec *iovp, \
 				u_int iovcnt); }
-147	STD	LINUX	{ int linux_getsid(linux_pid_t pid); }
-148	STD	LINUX	{ int linux_fdatasync(int fd); }
-149	STD	LINUX	{ int linux_sysctl(void); }
+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, \
+154	NOPROTO	POSIX	{ int sched_setparam(pid_t pid, \
 				const struct sched_param *param); }
-155	NOPROTO	POSIX	{ int sched_getparam (pid_t pid, \
+155	NOPROTO	POSIX	{ int sched_getparam(pid_t pid, \
 				struct sched_param *param); }
-156	STD	POSIX	{ int linux_sched_setscheduler(pid_t pid, int policy, \
-				const struct sched_param *param); }
-157	STD	POSIX	{ int linux_sched_getscheduler(pid_t pid); }
-158	NOPROTO	POSIX	{ int sched_yield (void); }
-159	STD	POSIX	{ int linux_sched_get_priority_max(int policy); }
-160	STD	POSIX	{ int linux_sched_get_priority_min(int policy); }
-161	NOPROTO	POSIX	{ int sched_rr_get_interval (pid_t pid, \
-				struct timespec *interval); }
+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	MNOPROTO POSIX	{ int nanosleep(const struct timespec *rqtp, \
 				struct timespec *rmtp); }
-163	STD	LINUX	{ int linux_mremap(caddr_t addr, int old_len, \
-				int new_len, int flags); }
-164	NOPROTO	LINUX	{ int setresuid(int ruid, int euid, int suid); }
-165	STD	LINUX	{ int linux_getresuid(linux_uid_t *ruid, \
-				linux_uid_t *euid, linux_uid_t *suid); }
+163	STD	LINUX	{ 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, \
+				l_uid16_t euid, l_uid16_t suid); }
+165	STD	LINUX	{ 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, \
 				long timeout); }
 169	STD	LINUX	{ int linux_nfsservctl(void); }
-170	NOPROTO	LINUX	{ int setresgid(int rgid, int egid, int sgid); }
-171	STD	LINUX	{ int linux_getresgid(linux_gid_t *rgid, \
-				linux_gid_t *egid, linux_gid_t *sgid); }
+170	STD	LINUX	{ 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, \
+				l_gid16_t *egid, l_gid16_t *sgid); }
 172	STD	LINUX	{ int linux_prctl(void); }
-173	STD	LINUX	{ int linux_rt_sigreturn(struct linux_ucontext *ucp); }
-174	STD	LINUX	{ int linux_rt_sigaction(int sig, \
-				linux_sigaction_t *act, \
-				linux_sigaction_t *oact, \
-				size_t sigsetsize); }
-175	STD	LINUX	{ int linux_rt_sigprocmask(int how, \
-				linux_sigset_t *mask, linux_sigset_t *omask, \
-				size_t sigsetsize); }
+173	STD	LINUX	{ int linux_rt_sigreturn(struct l_ucontext *ucp); }
+174	STD	LINUX	{ 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, \
+				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(linux_sigset_t *newset, \
-				size_t sigsetsize); }
-180	STD	LINUX	{ int linux_pread(int fd, char *buf, size_t nbyte, \
-				off_t offset); }
-181	STD	LINUX	{ int linux_pwrite(int fd, const char *buf, \
-				size_t nbyte, off_t offset); }
-182	STD	LINUX	{ int linux_chown(char *path, int uid, int gid); }
-183	STD	LINUX	{ int linux_getcwd(char *buf, unsigned long bufsize); }
+179	STD	LINUX	{ int linux_rt_sigsuspend(l_sigset_t *newset, \
+				l_size_t sigsetsize); }
+180	STD	LINUX	{ 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, \
+				l_size_t nbyte, l_loff_t offset); }
+182	STD	LINUX	{ 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(const linux_stack_t *uss, \
-				linux_stack_t *uoss); }
+186	STD	LINUX	{ int linux_sigaltstack(l_stack_t *uss, \
+				l_stack_t *uoss); }
 187	STD	LINUX	{ int linux_sendfile(void); }
-188	STD	LINUX	{ int linux_getpmsg(void); }
-189	STD	LINUX	{ int linux_putpmsg(void); }
+188	UNIMPL	LINUX	getpmsg
+189	UNIMPL	LINUX	putpmsg
 190	MSTD	LINUX	{ int linux_vfork(void); }
-191	STD	LINUX	{ int linux_ugetrlimit(void); }
-192	STD	LINUX	{ int linux_mmap2(void); }
-193	STD	LINUX	{ int linux_truncate64(void); }
-194	STD	LINUX	{ int linux_ftruncate64(void); }
-195	STD	LINUX	{ int linux_stat64(void); }
-196	STD	LINUX	{ int linux_lstat64(void); }
-197	STD	LINUX	{ int linux_fstat64(void); }
+191	STD	LINUX	{ int linux_getrlimit(l_uint resource, \
+				struct l_rlimit *rlim); }
+192	STD	LINUX	{ 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, \
+				struct l_stat64 *statbuf, l_long flags); }
+196	STD	LINUX	{ int linux_lstat64(char *filename, \
+				struct l_stat64 *statbuf, l_long flags); }
+197	STD	LINUX	{ int linux_fstat64(l_ulong fd, \
+				struct l_stat64 *statbuf, l_long flags); }
+198	STD	LINUX	{ int linux_lchown(char *filename, l_uid_t user, \
+				l_gid_t group); }
+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, \
+				l_gid_t *grouplist); }
+206	STD	LINUX	{ int linux_setgroups(l_int gidsetsize, \
+				l_gid_t *grouplist); }
+207	STD	LINUX	{ int linux_fchown(l_uint fd, l_uid_t user, \
+				l_gid_t group); }
+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, \
+				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, \
+				gid_t *sgid); }
+212	STD	LINUX	{ int linux_chown(char *filename, l_uid_t user, \
+				l_gid_t group); }
+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, \
+				char *put_old); }
+218	STD	LINUX	{ 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, \
+				l_uint count); }
+221	STD	LINUX	{ int linux_fcntl64(l_uint fd, l_uint cmd, \
+				l_ulong arg); }