- [2.4.2x, 2.6.x] don't recursively crash in die() on CHRP/PReP machines

[packages/kernel.git] / linux-abi-2.6.8.1.patch

diff -Nru linux-2.6.7/abi/cxenix/Makefile linux-2.6.7-abi/abi/cxenix/Makefile
--- linux-2.6.7/abi/cxenix/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-cxenix-objs	:= sysent.o misc.o stubs.o signal.o pathconf.o utsname.o
+
+obj-$(CONFIG_ABI_SCO)	+= abi-cxenix.o
+
+abi-cxenix.o: $(abi-cxenix-objs)
+	$(LD) -r -o $@ $(abi-cxenix-objs)
diff -Nru linux-2.6.7/abi/cxenix/misc.c linux-2.6.7-abi/abi/cxenix/misc.c
--- linux-2.6.7/abi/cxenix/misc.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/misc.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,296 @@
+/*
+ * misc.c - misc cxenix() subcalls
+ *
+ * Copyright (c) 1993,1994 Drew Sullivan
+ * Copyright (c) 1994-1996 Mike Jagdis
+ */
+
+#ident "%W% %G%"
+
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+#include <linux/fcntl.h>
+#include <linux/time.h>
+#include <linux/signal.h>
+#include <linux/syscalls.h>
+#include <linux/termios.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+#include <abi/util/sysent.h>
+#include <abi/svr4/sigaction.h>
+
+
+struct timeb {
+	time_t	time;
+	u_short	millitm;
+	short	timezone;
+	short	dstflag;
+};
+
+enum {
+	XF_UNLCK =	0,
+	XF_WRLCK =	1,
+	XF_RDLCK =	3,
+};
+
+struct ibcs_flock {
+	short l_type;
+	short l_whence;
+	off_t l_start;
+	off_t l_len;
+	short l_sysid;
+	short l_pid;
+};
+
+
+/*
+ * locking() requires mandatory locking. Processes that attempt to
+ * read or write a region locked with locking() are required to block.
+ * You need to build a kernel with mandatory locking support and set
+ * the permissions on the required file to setgid, no group execute.
+ */
+int
+xnx_locking(int fd, int mode, unsigned long size)
+{
+	struct flock fl;
+	mm_segment_t old_fs;
+	int error;
+
+	if ((mode < 0 || mode > 7) && mode != 20) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API,
+				"unsupported locking() mode=0x%x\n", mode);
+#endif
+		return -EINVAL;
+	}
+
+	/*
+	 * Modes 5, 6 & 7 are very like the fcntl mechanism but
+	 * we can't just punt to that because the type values are
+	 * different.
+	 */
+	if (mode > 4 && mode < 8) {
+		struct ibcs_flock *ifl = (struct ibcs_flock *)size;
+		short t;
+
+		error = verify_area(VERIFY_READ, ifl, sizeof(*ifl));
+		if (error)
+			return error;
+
+		get_user(t, &ifl->l_type);
+		switch (t) {
+			case XF_UNLCK:	t = F_UNLCK; break;
+			case XF_WRLCK:	t = F_WRLCK; break;
+			case XF_RDLCK:	t = F_RDLCK; break;
+			default:	return -EINVAL;
+		}
+		put_user(t, &ifl->l_type);
+
+		error = sys_fcntl(fd, mode, (u_long)ifl);
+
+		get_user(t, &ifl->l_type);
+		switch (t) {
+			case F_UNLCK:	t = XF_UNLCK; break;
+			case F_WRLCK:	t = XF_WRLCK; break;
+			case F_RDLCK:	t = XF_RDLCK; break;
+		}
+		put_user(t, &ifl->l_type);
+
+		get_user(t, &ifl->l_sysid);
+		put_user(t, &ifl->l_pid);
+		put_user(0, &ifl->l_sysid);
+		return error;
+	}
+
+	fl.l_type = (mode == 0 ? F_UNLCK
+			: ((mode <= 2 || mode == 20) ? F_WRLCK
+			: F_RDLCK));
+	fl.l_whence = 1;
+	fl.l_start = 0;
+	fl.l_len = size;
+
+	old_fs = get_fs();
+	set_fs (get_ds());
+	error = sys_fcntl(fd, (mode == 5) ? F_GETLK
+			: (!(mode % 2) ? F_SETLK : F_SETLKW), (u_long)&fl);
+	set_fs(old_fs);
+	return error;
+}
+
+
+/* Check if input is available */
+int
+xnx_rdchk(int fd)
+{
+	int error, nbytes;
+	mm_segment_t old_fs;
+
+	old_fs = get_fs();
+	set_fs (get_ds());
+	error = sys_ioctl(fd, FIONREAD, (long)&nbytes);
+	set_fs(old_fs);
+
+	if (error < 0) return error;
+	return nbytes ? 1 : 0;
+}
+
+/*
+ * Linux has a stub sys_ftime. Perhaps this should be there? On the other
+ * hand it's an old call that probably shouldn't be used by most modern
+ * applications so perhaps it's better here where it needn't bloat the
+ * base kernel.
+ */
+int
+xnx_ftime(struct timeb *tp)
+{
+	struct timeval tv;
+	struct timezone tz;
+	int error;
+	mm_segment_t old_fs;
+
+	error = verify_area(VERIFY_WRITE, tp, sizeof(struct timeb));
+	if (error)
+		return error;
+
+	old_fs = get_fs();
+	set_fs (get_ds());
+	error = sys_gettimeofday(&tv, &tz);
+	set_fs(old_fs);
+	if (error)
+		return error;
+
+	put_user(tv.tv_sec, &tp->time);
+	put_user((unsigned short)(tv.tv_usec/1000), &tp->millitm);
+	put_user((short)tz.tz_minuteswest, &tp->timezone);
+	put_user((short)tz.tz_dsttime, &tp->dstflag);
+
+	return 0;
+}
+
+#define USE_NEW_NAP_CODE
+
+#ifndef USE_NEW_NAP_CODE
+static __inline __sighandler_t
+sigaction(int sig, __sighandler_t handler)
+{
+	struct k_sigaction *k = &current->sighand->action[sig-1];
+	__sighandler_t old_handler;
+
+	spin_lock(&current->sighand->siglock);
+	old_handler = k->sa.sa_handler;
+	k->sa.sa_handler = handler;
+	spin_unlock(&current->sighand->siglock);
+
+	return old_handler;
+}
+#endif
+
+/* go to sleep for period milliseconds */
+/* - returns either an EINTR error or returns the elapsed time */
+/* Note:
+   for SCO OpenServer 5.0.6 the original nap was fixed so that it
+   no longer waits a minimum of 2 tick (20ms) 
+   but fewer time with a 10 ms granularity */
+long
+xnx_nap(long period)
+{
+#ifdef USE_NEW_NAP_CODE
+	// Hz means the number of jiffies per second.
+	// the below code needs HZ to be 1 <= HZ <= 1000
+	// in order to work correctly in any case.
+#if HZ > 1000
+#error this code only works with HZ <= 1000
+#endif
+	struct timeval tv1, tv2;
+	struct timezone tz;
+	mm_segment_t oldfs;
+	long period_s; // seconds part
+	long period_ms_hz; // milli seconds part, scaled to a base of HZ
+	long period_j; // jiffies
+
+	if (!period)
+		return 0; // zereo request, zero reply
+
+	oldfs = get_fs();
+	set_fs(get_ds());
+	sys_gettimeofday(&tv1, &tz);
+
+	period_s = period / 1000;
+	period_ms_hz = (period - period_s * 1000) * HZ;
+	period_j = period_s * HZ + period_ms_hz / 1000;
+	// take care of rounding errors, round up
+	if (period > period_j * (1000 / HZ)) period_j++;
+
+	set_current_state(TASK_INTERRUPTIBLE);
+	schedule_timeout (period_j);
+	
+	sys_gettimeofday(&tv2, &tz);
+	set_fs(oldfs);
+
+	if (signal_pending(current))
+		return -EINTR; // interrupted
+	return (tv2.tv_sec - tv1.tv_sec) * 1000
+		+ (tv2.tv_usec - tv1.tv_usec + 500) / 1000;
+#else
+	__sighandler_t old_handler;
+	struct itimerval it;
+	struct timeval tv1, tv2;
+	struct timezone tz;
+	mm_segment_t oldfs;
+
+	if (!period)
+		return 0;
+
+	it.it_interval.tv_sec = 0;
+	it.it_interval.tv_usec = 0;
+	it.it_value.tv_sec = 0;
+	it.it_value.tv_usec = period * 1000;
+
+	oldfs = get_fs();
+	set_fs(get_ds());
+
+	sys_gettimeofday(&tv1, &tz);
+	old_handler = sigaction(SIGALRM, SIG_DFL); // SIG_DFL -> terminate
+	sys_setitimer(ITIMER_REAL, &it, NULL);
+	sys_pause();
+	sigaction(SIGALRM, old_handler);
+	sys_gettimeofday(&tv2, &tz);
+	set_fs(oldfs);
+
+	deactivate_signal(current, SIGALRM);
+
+	if (signal_pending(current))
+		return -EINTR;
+	return ((tv2.tv_sec - tv1.tv_sec) * 1000000
+			+ (tv2.tv_usec - tv1.tv_usec)) / 1000;
+#endif
+}
+
+/*
+ * eaccess() checks access to the given path using the effective
+ * uid/gid rather than the real uid/gid.
+ */
+int
+xnx_eaccess(char *path, int mode)
+{
+	uid_t		ouid;
+	gid_t		ogid;
+	int		err;
+
+	ouid = current->uid;
+	ogid = current->gid;
+	current->uid = current->euid;
+	current->gid = current->egid;
+
+	err = sys_access(path, mode);
+
+	current->uid = ouid;
+	current->gid = ogid;
+
+	return err;
+}
diff -Nru linux-2.6.7/abi/cxenix/pathconf.c linux-2.6.7-abi/abi/cxenix/pathconf.c
--- linux-2.6.7/abi/cxenix/pathconf.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/pathconf.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,140 @@
+/*
+ * pathconf.c - support for xenix pathconf
+ *
+ * Copyright (c) 1993,1994 Drew Sullivan
+ * Copyright (c) 1994-1996 Mike Jagdis
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+#include <linux/statfs.h>
+#include <asm/uaccess.h>
+
+
+enum {
+	_PC_LINK_MAX =		0,
+	_PC_MAX_CANON =		1,
+	_PC_MAX_INPUT =		2,
+	_PC_NAME_MAX =		3,
+	_PC_PATH_MAX =		4,
+	_PC_PIPE_BUF =		5,
+	_PC_CHOWN_RESTRICTED =	6,
+	_PC_NO_TRUNC =		7,
+	_PC_VDISABLE =		8,
+};
+
+static int
+xnx_name_max(char *path)
+{
+	struct statfs		stf;
+	mm_segment_t		fs;
+	char			*p;
+	int			error;
+
+	p = getname(path);
+	if (IS_ERR(p))
+		return PTR_ERR(p);
+	
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_statfs(p, &stf);
+	set_fs(fs);
+
+	putname(p);
+	if (error)
+		return (error);
+	return (stf.f_namelen);
+}
+
+int
+xnx_pathconf(char *path, int name)
+{
+	switch (name) {
+	case _PC_LINK_MAX:
+		/*
+		 * Although Linux headers define values on a per
+		 * filesystem basis there is no way to access
+		 * these without hard coding fs information here
+		 * so for now we use a bogus value.
+		 */
+		return LINK_MAX;
+	case _PC_MAX_CANON:
+		return MAX_CANON;
+	case _PC_MAX_INPUT:
+		return MAX_INPUT;
+	case _PC_PATH_MAX:
+		return PATH_MAX;
+	case _PC_PIPE_BUF:
+		return PIPE_BUF;
+	case _PC_CHOWN_RESTRICTED:
+		/*
+		 * We should really think about this and tell
+		 * the truth.
+		 */
+		return 0;
+	case _PC_NO_TRUNC:
+		/* Not sure... It could be fs dependent? */
+		return 1;
+	case _PC_VDISABLE:
+		return 1;
+	case _PC_NAME_MAX:
+		return xnx_name_max(path);
+	}
+	return -EINVAL;
+}
+
+int
+xnx_fpathconf(int fildes, int name)
+{
+	switch (name) {
+	case _PC_LINK_MAX:
+		/*
+		 * Although Linux headers define values on a per
+		 * filesystem basis there is no way to access
+		 * these without hard coding fs information here
+		 * so for now we use a bogus value.
+		 */
+		return LINK_MAX;
+	case _PC_MAX_CANON:
+		return MAX_CANON;
+	case _PC_MAX_INPUT:
+		return MAX_INPUT;
+	case _PC_PATH_MAX:
+		return PATH_MAX;
+	case _PC_PIPE_BUF:
+		return PIPE_BUF;
+	case _PC_CHOWN_RESTRICTED:
+		/*
+		 * We should really think about this and tell
+		 * the truth.
+		 */
+		return 0;
+	case _PC_NO_TRUNC:
+		/* Not sure... It could be fs dependent? */
+		return 1;
+	case _PC_VDISABLE:
+		return 1;
+	case _PC_NAME_MAX:
+		{
+			struct statfs buf;
+			int error;
+			mm_segment_t old_fs;
+
+			old_fs = get_fs();
+			set_fs (get_ds());
+			error = sys_fstatfs(fildes, &buf);
+			set_fs(old_fs);
+			if (!error)
+				return buf.f_namelen;
+			return error;
+		}
+	}
+
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/cxenix/signal.c linux-2.6.7-abi/abi/cxenix/signal.c
--- linux-2.6.7/abi/cxenix/signal.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/signal.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,89 @@
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/personality.h>
+#include <linux/sched.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <asm/uaccess.h>
+
+#include <abi/cxenix/signal.h>
+#include <abi/signal.h>
+
+#include <abi/util/map.h>
+#include <abi/util/sysent.h>
+
+
+int
+xnx_sigaction(int sco_signum, const struct sco_sigaction *action,
+		struct sco_sigaction *oldaction)
+{
+	struct sco_sigaction	new_sa, old_sa;
+	struct sigaction	nsa, osa;
+	mm_segment_t		fs;
+	int			error, signo;
+
+	if (sco_signum >= NSIGNALS)
+		return -EINVAL;
+	signo = current_thread_info()->exec_domain->signal_map[sco_signum];
+
+	if (oldaction) {
+		error = verify_area(VERIFY_WRITE, oldaction,
+				sizeof(struct sco_sigaction));
+		if (error)
+			return (error);
+	}
+
+	if (action) {
+		error = copy_from_user(&new_sa, action,
+				sizeof(struct sco_sigaction));
+		if (error)
+			return -EFAULT;
+		nsa.sa_restorer = NULL;
+		nsa.sa_handler = new_sa.sa_handler;
+		nsa.sa_mask = map_sigvec_to_kernel(new_sa.sa_mask,
+			current_thread_info()->exec_domain->signal_map);
+		nsa.sa_flags = SA_NOMASK;
+		if (new_sa.sa_flags & SCO_SA_NOCLDSTOP)
+			nsa.sa_flags |= SA_NOCLDSTOP;
+	}
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigaction(signo, action ? &nsa : NULL,
+			oldaction ? &osa : NULL, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error || !oldaction)
+		return (error);
+
+	old_sa.sa_handler = osa.sa_handler;
+	old_sa.sa_mask = map_sigvec_from_kernel(osa.sa_mask,
+			current_thread_info()->exec_domain->signal_invmap);
+	old_sa.sa_flags = 0;
+	if (osa.sa_flags & SA_NOCLDSTOP)
+		old_sa.sa_flags |= SCO_SA_NOCLDSTOP;
+
+	if (copy_to_user(oldaction, &old_sa, sizeof(struct sco_sigaction)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+xnx_sigpending(u_long *setp)
+{
+	sigset_t		lxpending;
+	u_long			pending;
+
+	spin_lock_irq(&current->sighand->siglock);
+	sigandsets(&lxpending, &current->blocked, &current->pending.signal);
+	spin_unlock_irq(&current->sighand->siglock);
+
+	pending = map_sigvec_from_kernel(lxpending,
+			current_thread_info()->exec_domain->signal_invmap);
+			 
+	if (copy_to_user(setp, &pending, sizeof(u_long)))
+		return -EFAULT;
+	return 0;
+}
diff -Nru linux-2.6.7/abi/cxenix/stubs.c linux-2.6.7-abi/abi/cxenix/stubs.c
--- linux-2.6.7/abi/cxenix/stubs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/stubs.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,123 @@
+/*
+ * stubs.c - stubs for unimplemented cxenix subcalls
+ *
+ * Copyright (c) 1993,1994 Drew Sullivan.
+ * Copyright (c) 1994-1996 Mike Jagdis.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/ptrace.h>
+
+#include <abi/cxenix/sysent.h>
+
+
+int
+xnx_creatsem(char *sem_name, int mode)
+{
+	return -EPERM;
+}
+
+int
+xnx_opensem(char *sem_name)
+{
+	return -EPERM;
+}
+
+int
+xnx_sigsem(int sem_num)
+{
+	return -EPERM;
+}
+
+int
+xnx_waitsem(int sem_num)
+{
+	return -EPERM;
+}
+
+int
+xnx_nbwaitsem(int sem_num)
+{
+	return -EPERM;
+}
+
+
+int
+xnx_sdget(char *path, int flags, long size, int mode)
+{
+	return -EPERM;
+}
+
+int
+xnx_sdfree(char* addr)
+{
+	return -EPERM;
+}
+
+int
+xnx_sdenter(char *addr, int flags)
+{
+	return -EPERM;
+}
+
+int
+xnx_sdleave(char *addr)
+{
+	return -EPERM;
+}
+
+int
+xnx_sdgetv(char *addr)
+{
+	return -EPERM;
+}
+
+int
+xnx_sdwaitv(char *addr, int vnum)
+{
+	return -EPERM;
+}
+
+
+/*
+ * This allows processes to be allowed to exceed available swap. The man
+ * page isn't too clear  - it seems to suggest Xenix supports physical
+ * memory > swap but this doesn't make sense to me? It almost certainly
+ * isn't useful for Linux to actually do anything with this - just lie.
+ */
+enum {
+	XNX_PRHUGEX =	1,
+	XNX_PRNORMEX =	2,
+};
+
+int
+xnx_proctl(int pid, int command, char *arg)
+{
+	return 0;
+}
+
+int
+xnx_execseg(excode_t oldaddr, unsigned size)
+{
+	return -EPERM;
+}
+
+
+int
+xnx_unexecseg(excode_t addr)
+{
+	return -EPERM;
+}
+
+/*
+ * This allows running adb without executing any programs, but disassembly
+ * will work fine with that lie.
+ */
+int
+xnx_paccess(int pid, int cmd, int offset, int count, char *ptr)
+{
+	return 0;
+}
diff -Nru linux-2.6.7/abi/cxenix/sysent.c linux-2.6.7-abi/abi/cxenix/sysent.c
--- linux-2.6.7/abi/cxenix/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/sysent.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,96 @@
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/personality.h>
+#include <linux/sched.h>
+#include <linux/ptrace.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/cxenix/sysent.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+
+
+MODULE_DESCRIPTION("Xenix/OpenServer cxenix call support");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+static struct sysent cxenix_table[] = {
+/*   0 */	{ 0,			Ukn,	"syscall",	""	},
+/*   1 */	{ xnx_locking,		3,	"locking",	"ddd"	},
+/*   2 */	{ xnx_creatsem,		2,	"creatsem",	"sd"	},
+/*   3 */	{ xnx_opensem,		1,	"opensem",	"s"	},
+/*   4 */	{ xnx_sigsem,		1,	"sigsem",	"d"	},
+/*   5 */	{ xnx_waitsem,		1,	"waitsem",	"d"	},
+/*   6 */	{ xnx_nbwaitsem,	1,	"nbwaitsem",	"d"	},
+/*   7 */	{ xnx_rdchk,		1,	"rdchk",	"d"	},
+/*   8 */	{ 0,			Ukn,	"stkgro",	""	},
+/*   9 */	{ 0,			Ukn,	"?",		""	},
+/*  10 */	{ sys_ftruncate,	2,	"chsize",	"dd"	},
+/*  11 */	{ xnx_ftime,		1,	"ftime",	"x"	},
+/*  12 */	{ xnx_nap,		1,	"nap",		"d"	},
+/*  13 */	{ xnx_sdget,		4,	"sdget",	"sddd"	},
+/*  14 */	{ xnx_sdfree,		1,	"sdfree",	"x"	},
+/*  15 */	{ xnx_sdenter,		2,	"sdenter",	"xd"	},
+/*  16 */	{ xnx_sdleave,		1,	"sdleave",       "x"	},
+/*  17 */	{ xnx_sdgetv,		1,	"sdgetv",	"x"	},
+/*  18 */	{ xnx_sdwaitv,		2,	"sdwaitv",	"xd"	},
+/*  19 */	{ 0,			Ukn,	"brkctl",	""	},
+/*  20 */	{ 0,			Ukn,	"?",		""	},
+/*  21 */	{ 0,			2,	"sco-getcwd?",	"dx"	},
+/*  22 */	{ 0,			Ukn,	"?",		""	},
+/*  23 */	{ 0,			Ukn,	"?",		""	},
+/*  24 */	{ 0,			Ukn,	"?",		""	},
+/*  25 */	{ 0,			Ukn,	"?",		""	},
+/*  26 */	{ 0,			Ukn,	"?",		""	},
+/*  27 */	{ 0,			Ukn,	"?",		""	},
+/*  28 */	{ 0,			Ukn,	"?",		""	},
+/*  29 */	{ 0,			Ukn,	"?",		""	},
+/*  30 */	{ 0,			Ukn,	"?",		""	},
+/*  31 */	{ 0,			Ukn,	"?",		""	},
+/*  32 */	{ xnx_proctl,		3,	"proctl",	"ddx"	},
+/*  33 */	{ xnx_execseg,		2,	"execseg",	"xd"	},
+/*  34 */	{ xnx_unexecseg,	1,	"unexecseg",	"x"	},
+/*  35 */	{ 0,			Ukn,	"?",		""	},
+/*  36 */	{ sys_select,		5,	"select",	"dxxxx"	},
+/*  37 */	{ xnx_eaccess,		2,	"eaccess",	"so"	},
+/*  38 */	{ xnx_paccess,		5,	"paccess",	"dddds"	},
+/*  39 */	{ xnx_sigaction,	3,	"sigaction",	"dxx"	},
+/*  40 */	{ abi_sigprocmask,	3,	"sigprocmask",	"dxx"	},
+/*  41 */	{ xnx_sigpending,	1,	"sigpending",	"x"	},
+/*  42 */	{ abi_sigsuspend,	Spl,	"sigsuspend",	"x"	},
+/*  43 */	{ sys_getgroups16,	2,	"getgroups",	"dx"	},
+/*  44 */	{ sys_setgroups16,	2,	"setgroups",	"dx"	},
+/*  45 */	{ ibcs_sysconf,		1,	"sysconf",	"d"	},
+/*  46 */	{ xnx_pathconf,		2,	"pathconf",	"sd"	},
+/*  47 */	{ xnx_fpathconf,	2,	"fpathconf",	"dd"	},
+/*  48 */	{ sys_rename,		2,	"rename",	"ss"	},
+/*  49 */	{ 0,			Ukn,	"?",		""	},
+/*  50 */	{ xnx_utsname,		1,	"utsname",	"x"	},
+/*  51 */	{ 0,			Ukn,	"?",		""	},
+/*  52 */	{ 0,			Ukn,	"?",		""	},
+/*  53 */	{ 0,			Ukn,	"?",		""	},
+/*  54 */	{ 0,			Ukn,	"?",		""	},
+/*  55 */	{ sys_getitimer,	2,	"getitimer",	"dx"	},
+/*  56 */	{ sys_setitimer,	3,	"setitimer",	"dxx"	}
+};
+
+
+void cxenix(struct pt_regs *regs)
+{
+	int sysno = regs->eax >> 8;
+
+	if (sysno >= ARRAY_SIZE(cxenix_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &cxenix_table[sysno], 1);
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(cxenix);
+#endif
diff -Nru linux-2.6.7/abi/cxenix/utsname.c linux-2.6.7-abi/abi/cxenix/utsname.c
--- linux-2.6.7/abi/cxenix/utsname.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/cxenix/utsname.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,89 @@
+/*
+ * utsname.c - support for the utsname subcall of cxenix
+ *
+ * Copyright (C) 1994 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/personality.h>
+#include <linux/utsname.h>
+#include <linux/eisa.h>
+#include <asm/uaccess.h>
+
+
+static char	sco_serial[10] = "public";
+
+struct xnx_utsname {
+	char	sysname[9];
+	char	nodename[9];
+	char	release[16];
+	char	kernelid[20];
+	char	machine[9];
+	char	bustype[9];
+	char	sysserial[10];
+	u_short	sysorigin;
+	u_short	sysoem;
+	char	numusers[9];
+	u_short	numcpu;
+};
+
+#define set_utsfield(to, from, dotchop) \
+	{ \
+		char *p; \
+		int i, len = (sizeof(to) > sizeof(from) ? sizeof(from) : sizeof(to)); \
+		__copy_to_user(to, from, len); \
+		if (dotchop) \
+			for (p=from,i=0; *p && *p != '.' && --len; p++,i++); \
+		else \
+			i = len - 1; \
+		__put_user('\0', to+i); \
+	}
+
+
+int
+xnx_utsname(u_long addr)
+{
+	struct xnx_utsname	*utp = (struct xnx_utsname *)addr;
+	int			error;
+
+	/*
+	 * This shouldn't be invoked by anything that isn't running
+	 * in the SCO personality. I can envisage a program that uses
+	 * this to test if utp is running on SCO or not. It probably
+	 * won't happen but let's make sure utp doesn't anyway...
+	 */
+	if (!is_cur_personality(PER_SCOSVR3))
+		return -ENOSYS;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, utp, sizeof (struct xnx_utsname));
+	if (!error) {
+		if (abi_fake_utsname) {
+			set_utsfield(utp->sysname, "SCO_SV", 0);
+			set_utsfield(utp->nodename, system_utsname.nodename, 1);
+			set_utsfield(utp->release, "3.2v5.0.0\0", 0);
+		} else {
+			set_utsfield(utp->sysname, system_utsname.nodename, 1);
+			set_utsfield(utp->nodename, system_utsname.nodename, 1);
+			set_utsfield(utp->release, system_utsname.release, 0);
+		}
+		set_utsfield(utp->kernelid, system_utsname.version, 0);
+		set_utsfield(utp->machine, system_utsname.machine, 0);
+		if (EISA_bus) {
+			set_utsfield(utp->bustype, "EISA", 0);
+		} else {
+			set_utsfield(utp->bustype, "ISA", 0);
+		}
+		set_utsfield(utp->sysserial, sco_serial, 0);
+		__put_user(0xffff, &utp->sysorigin);
+		__put_user(0xffff, &utp->sysoem);
+		set_utsfield(utp->numusers, "unlim", 0);
+		__put_user(1, &utp->numcpu);
+	}
+	up_read(&uts_sem);
+
+	return (error);
+}
diff -Nru linux-2.6.7/abi/ibcs/Makefile linux-2.6.7-abi/abi/ibcs/Makefile
--- linux-2.6.7/abi/ibcs/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/ibcs/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-ibcs-objs	:= sysent.o
+
+obj-$(CONFIG_ABI_IBCS)		+= abi-ibcs.o
+
+abi-ibcs.o: $(abi-ibcs-objs)
+	$(LD) -r -o $@ $(abi-ibcs-objs)
diff -Nru linux-2.6.7/abi/ibcs/sysent.c linux-2.6.7-abi/abi/ibcs/sysent.c
--- linux-2.6.7/abi/ibcs/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/ibcs/sysent.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SVR4 personality switch.
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/highuid.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/signal.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+#include <abi/util/socket.h>
+
+MODULE_DESCRIPTION("iBCS2/iABI4 personality");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+/*
+ * We could remove some of the long identity mapped runs but at the
+ * expense of extra comparisons for each mapping at run time...
+ */
+static u_char ibcs_err_table[] = {
+/*   0 -   9 */   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+/*  10 -  19 */  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+/*  20 -  29 */  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+/*  30 -  39 */  30,  31,  32,  33,  34,  45,  78,  46,  89,  93,
+/*  40 -  49 */  90,  90,  35,  36,  37,  38,  39,  40,  41,  42,
+/*  50 -  59 */  43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+/*  60 -  69 */  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+/*  70 -  79 */  70,  71,  74,  76,  77,  79,  80,  81,  82,  83,
+/*  80 -  89 */  84,  85,  86,  87,  88,  91,  92,  94,  95,  96,
+/*  90 -  99 */  97,  98,  99, 120, 121, 122, 123, 124, 125, 126,
+/* 100 - 109 */ 127, 128, 129, 130, 131, 132, 133, 134, 143, 144,
+/* 110 - 119 */ 145, 146, 147, 148, 149, 150,  22, 135, 137, 138,
+/* 120 - 122 */ 139, 140,  28
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+/* 512 - 514 */ EINTR, EINTR, EINTR
+};
+
+struct map_segment ibcs_err_map[] = {
+	{ 0,	0+sizeof(ibcs_err_table)-1,	ibcs_err_table },
+	{ 512,  512+sizeof(lnx_err_table)-1,	lnx_err_table },
+	{ -1 }
+};
+
+static long linux_to_ibcs_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,    IBCS_SIGINT,    IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,   IBCS_SIGABRT,   -1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,   IBCS_SIGUSR1,   IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,   IBCS_SIGALRM,   IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,   IBCS_SIGCONT,   IBCS_SIGSTOP,
+/* 20 - 23 */	IBCS_SIGTSTP,	IBCS_SIGTTIN,   IBCS_SIGTTOU,   IBCS_SIGURG,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,  IBCS_SIGVTALRM, IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	IBCS_SIGIO,     IBCS_SIGPWR,    -1,
+/*	32 */	-1
+};
+
+static long ibcs_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,         SIGINT,         SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,        SIGIOT,         SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,        SIGUNUSED,      SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,        SIGALRM,        SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,        SIGCHLD,        SIGPWR,
+/* 20 - 23 */	SIGWINCH,	SIGURG,         SIGPOLL,        SIGSTOP,
+/* 24 - 27 */	SIGTSTP,	SIGCONT,        SIGTTIN,        SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,        SIGXCPU,        SIGXFSZ,
+/*	32 */	-1
+};
+
+static char ibcs_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment ibcs_socktype_map[] = {
+	{ 1, 6, ibcs_socktype },
+	{ -1 }
+};
+
+static struct map_segment ibcs_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+static struct map_segment ibcs_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent ibcs_syscall_table[] = {
+   { abi_syscall,	Fast,	"syscall",	""	}, /*    0 */
+   { sys_exit,		1,	"exit",		"d"	}, /*    1 */
+   { abi_fork,		Spl,	"fork",		""	}, /*    2 */
+   { abi_read,		3,	"read",		"dpd"	}, /*    3 */
+   { sys_write,		3,	"write",	"dpd"	}, /*    4 */
+   { svr4_open,		3,	"open",		"soo"	}, /*    5 */
+   { sys_close,		1,	"close",	"d"	}, /*    6 */
+   { abi_wait,		Spl,	"wait",		"xxx"	}, /*    7 */
+   { sys_creat,		2,	"creat",	"so"	}, /*    8 */
+   { sys_link,		2,	"link",		"ss"	}, /*    9 */
+   { sys_unlink,	1,	"unlink",	"s"	}, /*   10 */
+   { abi_exec,		Spl,	"exec",		"sxx"	}, /*   11 */
+   { sys_chdir,		1,	"chdir",	"s"	}, /*   12 */
+   { abi_time,		0,	"time",		""	}, /*   13 */
+   { svr4_mknod,	3,	"mknod",	"soo"	}, /*   14 */
+   { sys_chmod,		2,	"chmod",	"so"	}, /*   15 */
+   { sys_chown,		3,	"chown",	"sdd"	}, /*   16 */
+   { abi_brk,		1,	"brk/break",	"x"	}, /*   17 */
+   { svr4_stat,		2,	"stat",		"sp"	}, /*   18 */
+   { sys_lseek,		3,	"seek/lseek",	"ddd"	}, /*   19 */
+   { abi_getpid,	Spl,	"getpid",	""	}, /*   20 */
+   { 0,			Ukn,	"mount",	""	}, /*   21 */
+   { sys_umount,	1,	"umount",	"s"	}, /*   22 */
+   { sys_setuid,	1,	"setuid",	"d"	}, /*   23 */
+   { abi_getuid,	Spl,	"getuid",	""	}, /*   24 */
+   { sys_stime,		1,	"stime",	"d"	}, /*   25 */
+   { 0,			Ukn,	"ptrace",	""	}, /*   26 */
+   { sys_alarm,		1,	"alarm",	"d"	}, /*   27 */
+   { svr4_fstat,	2,	"fstat",	"dp"	}, /*   28 */
+   { sys_pause,		0,	"pause",	""	}, /*   29 */
+   { sys_utime,		2,	"utime",	"xx"	}, /*   30 */
+   { 0,			Ukn,	"stty",		""	}, /*   31 */
+   { 0,			Ukn,	"gtty",		""	}, /*   32 */
+   { sys_access,	2,	"access",	"so"	}, /*   33 */
+   { sys_nice,		1,	"nice",		"d"	}, /*   34 */
+   { svr4_statfs,	4,	"statfs",	"spdd"	}, /*   35 */
+   { sys_sync,		0,	"sync",		""	}, /*   36 */
+   { abi_kill,		2,	"kill",		"dd"	}, /*   37 */
+   { svr4_fstatfs,	4,	"fstatfs",	"dpdd"	}, /*   38 */
+   { abi_procids,	Spl,	"procids",	"d"	}, /*   39 */
+   { 0,			Ukn,	"cxenix",	""	}, /*   40 */
+   { sys_dup,		1,	"dup",		"d"	}, /*   41 */
+   { abi_pipe,		Spl,	"pipe",		""	}, /*   42 */
+   { sys_times,		1,	"times",	"p"	}, /*   43 */
+   { 0,			Ukn,	"prof",		""	}, /*   44 */
+   { 0,			Ukn,	"lock/plock",	""	}, /*   45 */
+   { sys_setgid,	1,	"setgid",	"d"	}, /*   46 */
+   { abi_getgid,	Spl,	"getgid",	""	}, /*   47 */
+   { abi_sigfunc,	Fast,	"sigfunc",	"xxx"	}, /*   48 */
+   { svr4_msgsys,	Spl,	"msgsys",	"dxddd"	}, /*   49 */
+   { svr4_sysi86,	3,	"sysi86",	"d"	}, /*   50 */
+   { sys_acct,		1,	"acct/sysacct",	"x"	}, /*   51 */
+   { svr4_shmsys,	Fast,	"shmsys",	"ddxo"	}, /*   52 */
+   { svr4_semsys,	Spl,	"semsys",	"dddx"	}, /*   53 */
+   { svr4_ioctl,	Spl,	"ioctl",	"dxx"	}, /*   54 */
+   { 0,			3,	"uadmin",	"xxx"	}, /*   55 */
+   { 0,			Ukn,	"?",		""	}, /*   56 */
+   { v7_utsname,	1,	"utsys",	"x"	}, /*   57 */
+   { sys_fsync,		1,	"fsync",	"d"	}, /*   58 */
+   { abi_exec,		Spl,	"execv",	"spp"	}, /*   59 */
+   { sys_umask,		1,	"umask",	"o"	}, /*   60 */
+   { sys_chroot,	1,	"chroot",	"s"	}, /*   61 */
+   { svr4_fcntl,	3,	"fcntl",	"dxx"	}, /*   62 */
+   { svr4_ulimit,	2,	"ulimit",	"xx"	}, /*   63 */
+   { 0,			Ukn,	"?",		""	}, /*   64 */
+   { 0,			Ukn,	"?",		""	}, /*   65 */
+   { 0,			Ukn,	"?",		""	}, /*   66 */
+   { 0,			Ukn,	"?",		""	}, /*   67 */
+   { 0,			Ukn,	"?",		""	}, /*   68 */
+   { 0,			Ukn,	"?",		""	}, /*   69 */
+   { 0,			Ukn,	"advfs",	""	}, /*   70 */
+   { 0,			Ukn,	"unadvfs",	""	}, /*   71 */
+   { 0,			Ukn,	"rmount",	""	}, /*   72 */
+   { 0,			Ukn,	"rumount",	""	}, /*   73 */
+   { 0,			Ukn,	"rfstart",	""	}, /*   74 */
+   { 0,			Ukn,	"?",		""	}, /*   75 */
+   { 0,			Ukn,	"rdebug",	""	}, /*   76 */
+   { 0,			Ukn,	"rfstop",	""	}, /*   77 */
+   { 0,			Ukn,	"rfsys",	""	}, /*   78 */
+   { sys_rmdir,		1,	"rmdir",	"s"	}, /*   79 */
+   { abi_mkdir,		2,	"mkdir",	"so"	}, /*   80 */
+   { svr4_getdents,	3,	"getdents",	"dxd"	}, /*   81 */
+   { 0,			Ukn,	"libattach",	""	}, /*   82 */
+   { 0,			Ukn,	"libdetach",	""	}, /*   83 */
+   { svr4_sysfs,	3,	"sysfs",	"dxx"	}, /*   84 */
+   { svr4_getmsg,	Spl,	"getmsg",	"dxxx"	}, /*   85 */
+   { svr4_putmsg,	Spl,	"putmsg",	"dxxd"	}, /*   86 */
+   { sys_poll,		3,	"poll",		"xdd"	}, /*   87 */
+   { svr4_lstat,	2,	"lstat",	"sp"	}, /*   88 */
+   { sys_symlink,	2,	"symlink",	"ss"	}, /*   89 */
+   { sys_readlink,	3,	"readlink",	"spd"	}, /*   90 */
+   { sys_setgroups,	2,	"setgroups",	"dp"	}, /*   91 */
+   { sys_getgroups,	2,	"getgroups",	"dp"	}, /*   92 */
+   { sys_fchmod,	2,	"fchmod",	"do"	}, /*   93 */
+   { sys_fchown,	3,	"fchown",	"ddd"	}, /*   94 */
+   { abi_sigprocmask,	3,	"sigprocmask",	"dxx"	}, /*   95 */
+   { abi_sigsuspend,	Spl,	"sigsuspend",	"x"	}, /*   96 */
+   { 0,			2,	"sigaltstack",	"xx"	}, /*   97 */
+   { abi_sigaction,	3,	"sigaction",	"dxx"	}, /*   98 */
+   { svr4_sigpending,	2,	"sigpending",	"dp"	}, /*   99 */
+   { svr4_context,	Spl,	"context",	""	}, /*   100 */
+   { 0,			Ukn,	"evsys",	""	}, /*   101 */
+   { 0,			Ukn,	"evtrapret",	""	}, /*   102 */
+   { svr4_statvfs,	2,	"statvfs",	"sp"	}, /*   103 */
+   { svr4_fstatvfs,	2,	"fstatvfs",	"dp"	}, /*   104 */
+   { 0,			Ukn,	"sysisc",	""	}, /*   105 */
+   { 0,			Ukn,	"nfssys",	""	}, /*   106 */
+   { 0,			4,	"waitid",	"ddxd"	}, /*   107 */
+   { 0,			3,	"sigsendsys",	"ddd"	}, /*   108 */
+   { svr4_hrtsys,	Spl,	"hrtsys",	"xxx"	}, /*   109 */
+   { 0,			3,	"acancel",	"dxd"	}, /*   110 */
+   { 0,			Ukn,	"async",	""	}, /*   111 */
+   { 0,			Ukn,	"priocntlsys",	""	}, /*   112 */
+   { svr4_pathconf,	2,	"pathconf",	"sd"	}, /*   113 */
+   { 0,			3,	"mincore",	"xdx"	}, /*   114 */
+   { svr4_mmap,		6,	"mmap",		"xxxxdx"},/*   115 */
+   { sys_mprotect,	3,	"mprotect",	"xdx"	},/*   116 */
+   { sys_munmap,	2,	"munmap",	"xd"	},/*   117 */
+   { svr4_fpathconf,	2,	"fpathconf",	"dd"	}, /*   118 */
+   { abi_fork,		Spl,	"vfork",	""	}, /*   119 */
+   { sys_fchdir,	1,	"fchdir",	"d"	}, /*   120 */
+   { sys_readv,		3,	"readv",	"dxd"	}, /*   121 */
+   { sys_writev,	3,	"writev",	"dxd"	}, /*   122 */
+   { svr4_xstat,	3,	"xstat",	"dsx"	}, /*   123 */
+   { svr4_lxstat,     	3,	"lxstat",	"dsx"	}, /*   124 */
+   { svr4_fxstat,	3,	"fxstat",	"ddx"	}, /*   125 */
+   { svr4_xmknod,	4,	"xmknod",	"dsox"	}, /*   126 */
+   { 0,			Ukn,	"syslocal",	"d"	}, /*   127 */
+   { svr4_getrlimit,	2,	"setrlimit",	"dx"	}, /*   128 */
+   { svr4_setrlimit,	2,	"getrlimit",	"dx"	}, /*   129 */
+   { 0,			3,	"lchown",	"sdd"	}, /*   130 */
+   { 0,			Ukn,	"memcntl",	""	}, /*   131 */
+#if defined(CONFIG_ABI_XTI)
+   { svr4_getpmsg,	5,	"getpmsg",	"dxxxx"	}, /*   132 */
+   { svr4_putpmsg,	5,	"putpmsg",	"dxxdd"	}, /*   133 */
+#else
+   { 0,			5,	"getpmsg",	"dxxxx"	}, /*   132 */
+   { 0,			5,	"putpmsg",	"dxxdd"	}, /*   133 */
+#endif
+   { sys_rename,	2,	"rename",	"ss"	}, /*   134 */
+   { abi_utsname,	1,	"uname",	"x"	}, /*   135 */
+   { svr4_setegid,	1,	"setegid",	"d"	}, /*   136 */
+   { svr4_sysconfig,	1,	"sysconfig",	"d"	}, /*   137 */
+   { 0,			Ukn,	"adjtime",	""	}, /*   138 */
+   { svr4_sysinfo,	3,	"systeminfo",	"dsd"	}, /*   139 */
+   { socksys_syscall,	1,	"socksys",	"x"	}, /*   140 */
+   { svr4_seteuid,	1,	"seteuid",	"d"	}, /*   141 */
+   { 0,			Ukn,	"?",		""	}, /*   142 */
+   { 0,			Ukn,	"?",		""	}, /*   143 */
+   { 0,			2,	"secsys",	"dx"	}, /*	144 */
+   { 0,			4,	"filepriv",	"sdxd"	}, /*	145 */
+   { 0,			3,	"procpriv",	"dxd"	}, /*	146 */
+   { 0,			3,	"devstat",	"sdx"	}, /*	147 */
+   { 0,			5,	"aclipc",	"ddddx"	}, /*	148 */
+   { 0,			3,	"fdevstat",	"ddx"	}, /*	149 */
+   { 0,			3,	"flvlfile",	"ddx"	}, /*	150 */
+   { 0,			3,	"lvlfile",	"sdx"	}, /*	151 */
+   { 0,			Ukn,	"?",		""	}, /*	152 */
+   { 0,			2,	"lvlequal",	"xx"	}, /*	153 */
+   { 0,			2,	"lvlproc",	"dx"	}, /*	154 */
+   { 0,			Ukn,	"?",		""	}, /*	155 */
+   { 0,			4,	"lvlipc",	"dddx"	}, /*	156 */
+   { 0,			4,	"acl",		"sddx"	}, /*	157 */
+   { 0,			Ukn,	"auditevt",	""	}, /*	158 */
+   { 0,			Ukn,	"auditctl",	""	}, /*	159 */
+   { 0,			Ukn,	"auditdmp",	""	}, /*	160 */
+   { 0,			Ukn,	"auditlog",	""	}, /*	161 */
+   { 0,			Ukn,	"auditbuf",	""	}, /*	162 */
+   { 0,			2,	"lvldom",	"xx"	}, /*	163 */
+   { 0,			Ukn,	"lvlvfs",	""	}, /*	164 */
+   { 0,			2,	"mkmld",	"so"	}, /*	165 */
+   { 0,			Ukn,	"mlddone",	""	}, /*	166 */
+   { 0,			2,	"secadvise",	"xx"	}, /*	167 */
+   { 0,			Ukn,	"online",	""	}, /*	168 */
+   { sys_setitimer,	3,	"setitimer",	"dxx"	}, /*	169 */
+   { sys_getitimer,	2,	"getitimer",	"dx"	}, /*	170 */
+   { sys_gettimeofday,	2,	"gettimeofday",	"xx"	}, /*	171 */
+   { sys_settimeofday,	2,	"settimeofday",	"xx"	}, /*	172 */
+   { 0,			Ukn,	"lwpcreate",	""	}, /*	173 */
+   { 0,			Ukn,	"lwpexit",	""	}, /*	174 */
+   { 0,			Ukn,	"lwpwait",	""	}, /*	175 */
+   { 0,			Ukn,	"lwpself",	""	}, /*	176 */
+   { 0,			Ukn, 	"lwpinfo",	""	}, /*	177 */
+   { 0,			Ukn,	"lwpprivate",	""	}, /*	178 */
+   { 0,			Ukn,	"processorbind",""	}, /*	179 */
+   { 0,			Ukn,	"processorexbind",""	}, /*	180 */
+   { 0,			Ukn,	"",		""	}, /*	181 */
+   { 0,			Ukn,	"sync_mailbox",	""	}, /*	182 */
+   { 0,			Ukn,	"prepblock",	""	}, /*	183 */
+   { 0,			Ukn,	"block",	""	}, /*	184 */
+   { 0,			Ukn,	"rdblock",	""	}, /*	185 */
+   { 0,			Ukn,	"unblock",	""	}, /*	186 */
+   { 0,			Ukn,	"cancelblock",	""	}, /*	187 */
+   { 0,			Ukn,	"?",		""	}, /*	188 */
+   { 0,			Ukn,	"pread",	""	}, /*	189 */
+   { 0,			Ukn,	"pwrite",	""	}, /*	190 */
+   { sys_truncate,	2,	"truncate",	"sd"	}, /*	191 */
+   { sys_ftruncate,	2,	"ftruncate",	"dd"	}, /*	192 */
+   { 0,			Ukn,	"lwpkill",	""	}, /*	193 */
+   { 0,			Ukn,	"sigwait",	""	}, /*	194 */
+   { 0,			Ukn,	"fork1",	""	}, /*	195 */
+   { 0,			Ukn,	"forkall",	""	}, /*	196 */
+   { 0,			Ukn,	"modload",	""	}, /*	197 */
+   { 0,			Ukn,	"moduload",	""	}, /*	198 */
+   { 0,			Ukn,	"modpath",	""	}, /*	199 */
+   { 0,			Ukn,	"modstat",	""	}, /*	200 */
+   { 0,			Ukn,	"modadm",	""	}, /*	201 */
+   { 0,			Ukn,	"getksym",	""	}, /*	202 */
+   { 0,			Ukn,	"lwpsuspend",	""	}, /*	203 */
+   { 0,			Ukn,	"lwpcontinue",	""	}, /*	204 */
+   { 0,			Ukn,	"?",		""	}, /*	205 */
+   { 0,			Ukn,	"?",		""	}, /*	206 */
+   { 0,			Ukn,	"?",		""	}, /*	207 */
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	}
+};
+
+static void
+ibcs_lcall7(int segment, struct pt_regs *regs)
+{
+	int sysno = regs->eax & 0xff;
+	
+	if (sysno >= ARRAY_SIZE(ibcs_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &ibcs_syscall_table[regs->eax & 0xff], 1);
+}
+
+static struct exec_domain ibcs_exec_domain = {
+	name:		"iBCS2/iABI4",
+	handler:	ibcs_lcall7,
+	pers_low:	1 /* PER_SVR4 */,
+	pers_high:	2 /* PER_SVR3 */,
+	signal_map:	ibcs_to_linux_signals,
+	signal_invmap:	linux_to_ibcs_signals,
+	err_map:	ibcs_err_map,
+	socktype_map:	ibcs_socktype_map,
+	sockopt_map:	ibcs_sockopt_map,
+	af_map:		ibcs_af_map,
+	module:		THIS_MODULE
+};
+
+static int __init
+ibcs_init(void)
+{
+	return register_exec_domain(&ibcs_exec_domain);
+}
+
+
+static void __exit
+ibcs_exit(void)
+{
+	unregister_exec_domain(&ibcs_exec_domain);
+}
+
+module_init(ibcs_init);
+module_exit(ibcs_exit);
diff -Nru linux-2.6.7/abi/isc/Makefile linux-2.6.7-abi/abi/isc/Makefile
--- linux-2.6.7/abi/isc/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/isc/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-isc-objs	:= sysent.o
+
+obj-$(CONFIG_ABI_ISC)		+= abi-isc.o
+
+abi-isc.o: $(abi-isc-objs)
+	$(LD) -r -o $@ $(abi-isc-objs)
diff -Nru linux-2.6.7/abi/isc/sysent.c linux-2.6.7-abi/abi/isc/sysent.c
--- linux-2.6.7/abi/isc/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/isc/sysent.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,460 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * ISC personality switch.
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/signal.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+#include <abi/util/socket.h>
+
+MODULE_DESCRIPTION("ISC personality");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+/* forward */
+static int isc_setostype(int);
+
+/*
+ * We could remove some of the long identity mapped runs but at the
+ * expense of extra comparisons for each mapping at run time...
+ */
+static u_char isc_err_table[] = {
+/*   0 -   9 */   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+/*  10 -  19 */  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+/*  20 -  29 */  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+/*  30 -  39 */  30,  31,  32,  33,  34,  45,  78,  46,  89,  93,
+/*  40 -  49 */  90,  90,  35,  36,  37,  38,  39,  40,  41,  42,
+/*  50 -  59 */  43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+/*  60 -  69 */  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+/*  70 -  79 */  70,  71,  74,  76,  77,  79,  80,  81,  82,  83,
+/*  80 -  89 */  84,  85,  86,  87,  88,  91,  92,  94,  95,  96,
+/*  90 -  99 */  97,  98,  99, 120, 121, 122, 123, 124, 125, 126,
+/* 100 - 109 */ 127, 128, 129, 130, 131, 132, 133, 134, 143, 144,
+/* 110 - 119 */ 145, 146, 147, 148, 149, 150,  22, 135, 137, 138,
+/* 120 - 122 */ 139, 140,  28
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+/* 512 - 514 */ EINTR, EINTR, EINTR
+};
+
+struct map_segment isc_err_map[] = {
+	{ 0,	0+sizeof(isc_err_table)-1,	isc_err_table },
+	{ 512,  512+sizeof(lnx_err_table)-1,	lnx_err_table },
+	{ -1 }
+};
+
+/*
+ * ISC's error mapping is a little different.
+ */
+static long linux_to_isc_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,	IBCS_SIGINT,	IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,	IBCS_SIGABRT,	-1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,	IBCS_SIGUSR1,	IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,	IBCS_SIGALRM,	IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,	ISC_SIGCONT,	ISC_SIGSTOP,
+/* 20 - 23 */	ISC_SIGTSTP,	IBCS_SIGTTIN,	IBCS_SIGTTOU,	IBCS_SIGUSR1,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,	IBCS_SIGVTALRM,	IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	IBCS_SIGIO,	IBCS_SIGPWR,	-1,
+/*	32 */	-1
+};
+
+static long isc_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,		SIGINT,		SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,	SIGIOT,		SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,	SIGUNUSED,	SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,	SIGALRM,	SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,	SIGCHLD,	SIGPWR,
+/* 20 - 23 */	SIGWINCH,	-1,		SIGPOLL,	SIGCONT,
+/* 24 - 27 */	SIGSTOP,	SIGTSTP,	SIGTTIN,	SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,	SIGXCPU,	SIGXFSZ,
+/*	32 */	-1
+};
+
+static char isc_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment isc_socktype_map[] = {
+	{ 1, 6, isc_socktype },
+	{ -1 }
+};
+
+static struct map_segment isc_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+static struct map_segment isc_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent sysisc_table[] = {
+/*   0 */	{ 0,			Ukn,	"sysisc0",	""	},
+/*   1 */	{ isc_setostype,	1,	"setostype",	"d"	},
+/*   2 */	{ sys_rename,		2,	"rename",	"ss"	},
+/*   3 */	{ abi_sigaction,	3,	"sigaction",	"dxx"	},
+/*   4 */	{ abi_sigprocmask,	3,	"sicprocmask",	"dxx"	},
+/*   5 */	{ 0,			1,	"sigpending",	"x"	},
+/*   6 */	{ sys_getgroups16,	2,	"getgroups",	"dp"	},
+/*   7 */	{ sys_setgroups16,	2,	"setgroups",	"dp"	},
+/*   8 */	{ 0,			Ukn,	"pathconf",	""	},
+/*   9 */	{ 0,			Ukn,	"fpathconf",	""	},
+/*  10 */	{ ibcs_sysconf,		1,	"sysconf",	"d"	},
+/*  11 */	{ sys_waitpid,		3,	"waitpid",	"dxx"	},
+/*  12 */	{ sys_setsid,		0,	"setsid",	""	},
+/*  13 */	{ sys_setpgid,		2,	"setpgid",	"dd"	},
+/*  14 */	{ 0,			Ukn,	"adduser",	""	},
+/*  15 */	{ 0,			Ukn,	"setuser",	""	},
+/*  16 */	{ 0,			Ukn,	"sysisc16",	""	},
+/*  17 */	{ abi_sigsuspend,	Spl,	"sigsuspend",	"x"	},
+/*  18 */	{ sys_symlink,		2,	"symlink",	"ss"	},
+/*  19 */	{ sys_readlink,		3,	"readlink",	"spd"	},
+/*  20 */	{ 0,			Ukn,	"getmajor",	""	}
+};
+
+static void
+isc_sysisc(struct pt_regs *regs)
+{
+	int sysno;
+
+	__get_user(sysno, ((unsigned long *)regs->esp)+1);
+	
+	if (sysno >= ARRAY_SIZE(sysisc_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &sysisc_table[sysno], 2);
+}
+
+static int                                                                             
+isc_setostype(int arg1)
+{
+        return 0;
+}
+
+static struct sysent isc_syscall_table[] = {
+   { abi_syscall,	Fast,	"syscall",	""	}, /*    0 */
+   { sys_exit,		1,	"exit",		"d"	}, /*    1 */
+   { abi_fork,		Spl,	"fork",		""	}, /*    2 */
+   { abi_read,		3,	"read",		"dpd"	}, /*    3 */
+   { sys_write,		3,	"write",	"dpd"	}, /*    4 */
+   { svr4_open,		3,	"open",		"soo"	}, /*    5 */
+   { sys_close,		1,	"close",	"d"	}, /*    6 */
+   { abi_wait,		Spl,	"wait",		"xxx"	}, /*    7 */
+   { sys_creat,		2,	"creat",	"so"	}, /*    8 */
+   { sys_link,		2,	"link",		"ss"	}, /*    9 */
+   { sys_unlink,	1,	"unlink",	"s"	}, /*   10 */
+   { abi_exec,		Spl,	"exec",		"sxx"	}, /*   11 */
+   { sys_chdir,		1,	"chdir",	"s"	}, /*   12 */
+   { abi_time,		0,	"time",		""	}, /*   13 */
+   { svr4_mknod,	3,	"mknod",	"soo"	}, /*   14 */
+   { sys_chmod,		2,	"chmod",	"so"	}, /*   15 */
+   { sys_chown,		3,	"chown",	"sdd"	}, /*   16 */
+   { abi_brk,		1,	"brk/break",	"x"	}, /*   17 */
+   { svr4_stat,		2,	"stat",		"sp"	}, /*   18 */
+   { sys_lseek,		3,	"seek/lseek",	"ddd"	}, /*   19 */
+   { abi_getpid,	Spl,	"getpid",	""	}, /*   20 */
+   { 0,			Ukn,	"mount",	""	}, /*   21 */
+   { sys_umount,	1,	"umount",	"s"	}, /*   22 */
+   { sys_setuid,	1,	"setuid",	"d"	}, /*   23 */
+   { abi_getuid,	Spl,	"getuid",	""	}, /*   24 */
+   { sys_stime,		1,	"stime",	"d"	}, /*   25 */
+   { 0,			Ukn,	"ptrace",	""	}, /*   26 */
+   { sys_alarm,		1,	"alarm",	"d"	}, /*   27 */
+   { svr4_fstat,	2,	"fstat",	"dp"	}, /*   28 */
+   { sys_pause,		0,	"pause",	""	}, /*   29 */
+   { sys_utime,		2,	"utime",	"xx"	}, /*   30 */
+   { 0,			Ukn,	"stty",		""	}, /*   31 */
+   { 0,			Ukn,	"gtty",		""	}, /*   32 */
+   { sys_access,	2,	"access",	"so"	}, /*   33 */
+   { sys_nice,		1,	"nice",		"d"	}, /*   34 */
+   { svr4_statfs,	4,	"statfs",	"spdd"	}, /*   35 */
+   { sys_sync,		0,	"sync",		""	}, /*   36 */
+   { abi_kill,		2,	"kill",		"dd"	}, /*   37 */
+   { svr4_fstatfs,	4,	"fstatfs",	"dpdd"	}, /*   38 */
+   { abi_procids,	Spl,	"procids",	"d"	}, /*   39 */
+   { 0,			Ukn,	"cxenix",	""	}, /*   40 */
+   { sys_dup,		1,	"dup",		"d"	}, /*   41 */
+   { abi_pipe,		Spl,	"pipe",		""	}, /*   42 */
+   { sys_times,		1,	"times",	"p"	}, /*   43 */
+   { 0,			Ukn,	"prof",		""	}, /*   44 */
+   { 0,			Ukn,	"lock/plock",	""	}, /*   45 */
+   { sys_setgid,	1,	"setgid",	"d"	}, /*   46 */
+   { abi_getgid,	Spl,	"getgid",	""	}, /*   47 */
+   { abi_sigfunc,	Fast,	"sigfunc",	"xxx"	}, /*   48 */
+   { svr4_msgsys,	Spl,	"msgsys",	"dxddd"	}, /*   49 */
+   { svr4_sysi86,	3,	"sysi86",	"d"	}, /*   50 */
+   { sys_acct,		1,	"acct/sysacct",	"x"	}, /*   51 */
+   { svr4_shmsys,	Fast,	"shmsys",	"ddxo"	}, /*   52 */
+   { svr4_semsys,	Spl,	"semsys",	"dddx"	}, /*   53 */
+   { svr4_ioctl,	Spl,	"ioctl",	"dxx"	}, /*   54 */
+   { 0,			3,	"uadmin",	"xxx"	}, /*   55 */
+   { 0,			Ukn,	"?",		""	}, /*   56 */
+   { v7_utsname,	1,	"utsys",	"x"	}, /*   57 */
+   { sys_fsync,		1,	"fsync",	"d"	}, /*   58 */
+   { abi_exec,		Spl,	"execv",	"spp"	}, /*   59 */
+   { sys_umask,		1,	"umask",	"o"	}, /*   60 */
+   { sys_chroot,	1,	"chroot",	"s"	}, /*   61 */
+   { svr4_fcntl,	3,	"fcntl",	"dxx"	}, /*   62 */
+   { svr4_ulimit,	2,	"ulimit",	"xx"	}, /*   63 */
+   { 0,			Ukn,	"?",		""	}, /*   64 */
+   { 0,			Ukn,	"?",		""	}, /*   65 */
+   { 0,			Ukn,	"?",		""	}, /*   66 */
+   { 0,			Ukn,	"?",		""	}, /*   67 */
+   { 0,			Ukn,	"?",		""	}, /*   68 */
+   { 0,			Ukn,	"?",		""	}, /*   69 */
+   { 0,			Ukn,	"advfs",	""	}, /*   70 */
+   { 0,			Ukn,	"unadvfs",	""	}, /*   71 */
+   { 0,			Ukn,	"rmount",	""	}, /*   72 */
+   { 0,			Ukn,	"rumount",	""	}, /*   73 */
+   { 0,			Ukn,	"rfstart",	""	}, /*   74 */
+   { 0,			Ukn,	"?",		""	}, /*   75 */
+   { 0,			Ukn,	"rdebug",	""	}, /*   76 */
+   { 0,			Ukn,	"rfstop",	""	}, /*   77 */
+   { 0,			Ukn,	"rfsys",	""	}, /*   78 */
+   { sys_rmdir,		1,	"rmdir",	"s"	}, /*   79 */
+   { abi_mkdir,		2,	"mkdir",	"so"	}, /*   80 */
+   { svr4_getdents,	3,	"getdents",	"dxd"	}, /*   81 */
+   { 0,			Ukn,	"libattach",	""	}, /*   82 */
+   { 0,			Ukn,	"libdetach",	""	}, /*   83 */
+   { svr4_sysfs,	3,	"sysfs",	"dxx"	}, /*   84 */
+   { svr4_getmsg,	Spl,	"getmsg",	"dxxx"	}, /*   85 */
+   { svr4_putmsg,	Spl,	"putmsg",	"dxxd"	}, /*   86 */
+   { sys_poll,		3,	"poll",		"xdd"	}, /*   87 */
+   { svr4_lstat,	2,	"lstat",	"sp"	}, /*   88 */
+   { sys_symlink,	2,	"symlink",	"ss"	}, /*   89 */
+   { sys_readlink,	3,	"readlink",	"spd"	}, /*   90 */
+   { sys_setgroups,	2,	"setgroups",	"dp"	}, /*   91 */
+   { sys_getgroups,	2,	"getgroups",	"dp"	}, /*   92 */
+   { sys_fchmod,	2,	"fchmod",	"do"	}, /*   93 */
+   { sys_fchown,	3,	"fchown",	"ddd"	}, /*   94 */
+   { abi_sigprocmask,	3,	"sigprocmask",	"dxx"	}, /*   95 */
+   { abi_sigsuspend,	Spl,	"sigsuspend",	"x"	}, /*   96 */
+   { 0,			2,	"sigaltstack",	"xx"	}, /*   97 */
+   { abi_sigaction,	3,	"sigaction",	"dxx"	}, /*   98 */
+   { svr4_sigpending,	2,	"sigpending",	"dp"	}, /*   99 */
+   { svr4_context,	Spl,	"context",	""	}, /*   100 */
+   { 0,			Ukn,	"evsys",	""	}, /*   101 */
+   { 0,			Ukn,	"evtrapret",	""	}, /*   102 */
+   { svr4_statvfs,	2,	"statvfs",	"sp"	}, /*   103 */
+   { svr4_fstatvfs,	2,	"fstatvfs",	"dp"	}, /*   104 */
+   { isc_sysisc,	Fast,	"sysisc",	""	}, /*   105 */
+   { 0,			Ukn,	"nfssys",	""	}, /*   106 */
+   { 0,			4,	"waitid",	"ddxd"	}, /*   107 */
+   { 0,			3,	"sigsendsys",	"ddd"	}, /*   108 */
+   { svr4_hrtsys,	Spl,	"hrtsys",	"xxx"	}, /*   109 */
+   { 0,			3,	"acancel",	"dxd"	}, /*   110 */
+   { 0,			Ukn,	"async",	""	}, /*   111 */
+   { 0,			Ukn,	"priocntlsys",	""	}, /*   112 */
+   { svr4_pathconf,	2,	"pathconf",	"sd"	}, /*   113 */
+   { 0,			3,	"mincore",	"xdx"	}, /*   114 */
+   { svr4_mmap,		6,	"mmap",		"xxxxdx"},/*   115 */
+   { sys_mprotect,	3,	"mprotect",	"xdx"	},/*   116 */
+   { sys_munmap,	2,	"munmap",	"xd"	},/*   117 */
+   { svr4_fpathconf,	2,	"fpathconf",	"dd"	}, /*   118 */
+   { abi_fork,		Spl,	"vfork",	""	}, /*   119 */
+   { sys_fchdir,	1,	"fchdir",	"d"	}, /*   120 */
+   { sys_readv,		3,	"readv",	"dxd"	}, /*   121 */
+   { sys_writev,	3,	"writev",	"dxd"	}, /*   122 */
+   { svr4_xstat,	3,	"xstat",	"dsx"	}, /*   123 */
+   { svr4_lxstat,     	3,	"lxstat",	"dsx"	}, /*   124 */
+   { svr4_fxstat,	3,	"fxstat",	"ddx"	}, /*   125 */
+   { svr4_xmknod,	4,	"xmknod",	"dsox"	}, /*   126 */
+   { 0,			Ukn,	"syslocal",	"d"	}, /*   127 */
+   { svr4_getrlimit,	2,	"setrlimit",	"dx"	}, /*   128 */
+   { svr4_setrlimit,	2,	"getrlimit",	"dx"	}, /*   129 */
+   { 0,			3,	"lchown",	"sdd"	}, /*   130 */
+   { 0,			Ukn,	"memcntl",	""	}, /*   131 */
+#if defined(CONFIG_ABI_XTI)
+   { svr4_getpmsg,	5,	"getpmsg",	"dxxxx"	}, /*   132 */
+   { svr4_putpmsg,	5,	"putpmsg",	"dxxdd"	}, /*   133 */
+#else
+   { 0,			5,	"getpmsg",	"dxxxx"	}, /*   132 */
+   { 0,			5,	"putpmsg",	"dxxdd"	}, /*   133 */
+#endif
+   { sys_rename,	2,	"rename",	"ss"	}, /*   134 */
+   { abi_utsname,	1,	"uname",	"x"	}, /*   135 */
+   { svr4_setegid,	1,	"setegid",	"d"	}, /*   136 */
+   { svr4_sysconfig,	1,	"sysconfig",	"d"	}, /*   137 */
+   { 0,			Ukn,	"adjtime",	""	}, /*   138 */
+   { svr4_sysinfo,	3,	"systeminfo",	"dsd"	}, /*   139 */
+   { socksys_syscall,	1,	"socksys",	"x"	}, /*   140 */
+   { svr4_seteuid,	1,	"seteuid",	"d"	}, /*   141 */
+   { 0,			Ukn,	"?",		""	}, /*   142 */
+   { 0,			Ukn,	"?",		""	}, /*   143 */
+   { 0,			2,	"secsys",	"dx"	}, /*	144 */
+   { 0,			4,	"filepriv",	"sdxd"	}, /*	145 */
+   { 0,			3,	"procpriv",	"dxd"	}, /*	146 */
+   { 0,			3,	"devstat",	"sdx"	}, /*	147 */
+   { 0,			5,	"aclipc",	"ddddx"	}, /*	148 */
+   { 0,			3,	"fdevstat",	"ddx"	}, /*	149 */
+   { 0,			3,	"flvlfile",	"ddx"	}, /*	150 */
+   { 0,			3,	"lvlfile",	"sdx"	}, /*	151 */
+   { 0,			Ukn,	"?",		""	}, /*	152 */
+   { 0,			2,	"lvlequal",	"xx"	}, /*	153 */
+   { 0,			2,	"lvlproc",	"dx"	}, /*	154 */
+   { 0,			Ukn,	"?",		""	}, /*	155 */
+   { 0,			4,	"lvlipc",	"dddx"	}, /*	156 */
+   { 0,			4,	"acl",		"sddx"	}, /*	157 */
+   { 0,			Ukn,	"auditevt",	""	}, /*	158 */
+   { 0,			Ukn,	"auditctl",	""	}, /*	159 */
+   { 0,			Ukn,	"auditdmp",	""	}, /*	160 */
+   { 0,			Ukn,	"auditlog",	""	}, /*	161 */
+   { 0,			Ukn,	"auditbuf",	""	}, /*	162 */
+   { 0,			2,	"lvldom",	"xx"	}, /*	163 */
+   { 0,			Ukn,	"lvlvfs",	""	}, /*	164 */
+   { 0,			2,	"mkmld",	"so"	}, /*	165 */
+   { 0,			Ukn,	"mlddone",	""	}, /*	166 */
+   { 0,			2,	"secadvise",	"xx"	}, /*	167 */
+   { 0,			Ukn,	"online",	""	}, /*	168 */
+   { sys_setitimer,	3,	"setitimer",	"dxx"	}, /*	169 */
+   { sys_getitimer,	2,	"getitimer",	"dx"	}, /*	170 */
+   { sys_gettimeofday,	2,	"gettimeofday",	"xx"	}, /*	171 */
+   { sys_settimeofday,	2,	"settimeofday",	"xx"	}, /*	172 */
+   { 0,			Ukn,	"lwpcreate",	""	}, /*	173 */
+   { 0,			Ukn,	"lwpexit",	""	}, /*	174 */
+   { 0,			Ukn,	"lwpwait",	""	}, /*	175 */
+   { 0,			Ukn,	"lwpself",	""	}, /*	176 */
+   { 0,			Ukn, 	"lwpinfo",	""	}, /*	177 */
+   { 0,			Ukn,	"lwpprivate",	""	}, /*	178 */
+   { 0,			Ukn,	"processorbind",""	}, /*	179 */
+   { 0,			Ukn,	"processorexbind",""	}, /*	180 */
+   { 0,			Ukn,	"",		""	}, /*	181 */
+   { 0,			Ukn,	"sync_mailbox",	""	}, /*	182 */
+   { 0,			Ukn,	"prepblock",	""	}, /*	183 */
+   { 0,			Ukn,	"block",	""	}, /*	184 */
+   { 0,			Ukn,	"rdblock",	""	}, /*	185 */
+   { 0,			Ukn,	"unblock",	""	}, /*	186 */
+   { 0,			Ukn,	"cancelblock",	""	}, /*	187 */
+   { 0,			Ukn,	"?",		""	}, /*	188 */
+   { 0,			Ukn,	"pread",	""	}, /*	189 */
+   { 0,			Ukn,	"pwrite",	""	}, /*	190 */
+   { sys_truncate,	2,	"truncate",	"sd"	}, /*	191 */
+   { sys_ftruncate,	2,	"ftruncate",	"dd"	}, /*	192 */
+   { 0,			Ukn,	"lwpkill",	""	}, /*	193 */
+   { 0,			Ukn,	"sigwait",	""	}, /*	194 */
+   { 0,			Ukn,	"fork1",	""	}, /*	195 */
+   { 0,			Ukn,	"forkall",	""	}, /*	196 */
+   { 0,			Ukn,	"modload",	""	}, /*	197 */
+   { 0,			Ukn,	"moduload",	""	}, /*	198 */
+   { 0,			Ukn,	"modpath",	""	}, /*	199 */
+   { 0,			Ukn,	"modstat",	""	}, /*	200 */
+   { 0,			Ukn,	"modadm",	""	}, /*	201 */
+   { 0,			Ukn,	"getksym",	""	}, /*	202 */
+   { 0,			Ukn,	"lwpsuspend",	""	}, /*	203 */
+   { 0,			Ukn,	"lwpcontinue",	""	}, /*	204 */
+   { 0,			Ukn,	"?",		""	}, /*	205 */
+   { 0,			Ukn,	"?",		""	}, /*	206 */
+   { 0,			Ukn,	"?",		""	}, /*	207 */
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	},
+   { 0,			Ukn,	"?",		""	}
+};
+
+static void
+isc_lcall7(int segment, struct pt_regs *regs)
+{
+	int sysno = regs->eax & 0xff;
+	
+	if (sysno >= ARRAY_SIZE(isc_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &isc_syscall_table[sysno], 1);
+}
+
+static struct exec_domain isc_exec_domain = {
+	name:		"ISC",
+	handler:	isc_lcall7,
+	pers_low:	5 /* PER_ISCR4 */,
+	pers_high:	5 /* PER_ISCR4 */,
+	signal_map:	isc_to_linux_signals,
+	signal_invmap:	linux_to_isc_signals,
+	err_map:	isc_err_map,
+	socktype_map:	isc_socktype_map,
+	sockopt_map:	isc_sockopt_map,
+	af_map:		isc_af_map,
+	module:		THIS_MODULE
+};
+
+static int __init
+isc_init(void)
+{
+	return register_exec_domain(&isc_exec_domain);
+}
+
+
+static void __exit
+isc_exit(void)
+{
+	unregister_exec_domain(&isc_exec_domain);
+}
+
+module_init(isc_init);
+module_exit(isc_exit);
diff -Nru linux-2.6.7/abi/Kconfig linux-2.6.7-abi/abi/Kconfig
--- linux-2.6.7/abi/Kconfig	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/Kconfig	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,166 @@
+#
+# Linux-ABI configuration
+#
+
+# this file gets source'ed into the kernel file formats menu entry
+# via ./fs/Kconfig.binfmt
+
+config ABI
+        bool "Extended Linux-ABI support (alien binarys and syscalls)"
+	depends on X86=y
+        default n
+        help
+          Support for a few alien syscall interfaces. This allows you to run
+          a binary that got build for other Unix compatible platforms.
+
+
+config ABI_SVR4
+        tristate "SVR3/SVR4 family syscall support for x86 binarys"
+	depends on X86=y
+        depends on ABI
+        default n
+
+
+comment "SVR3/SVR4 based syscall support for x86: (please check one or more)"
+        depends on ABI_SVR4
+
+config ABI_IBCS
+        tristate "iBCS2/iABI4 syscall support"
+        depends on ABI_SVR4
+
+config ABI_ISC
+        tristate "ISC syscall support"
+        depends on ABI_SVR4
+
+config ABI_SCO
+        tristate "SCO OpenServer 5/SCO Unix 3.x/Xenix syscall support"
+        depends on ABI_SVR4
+
+config ABI_SOLARIS
+        tristate "Solaris 2.x syscall support" 
+        depends on ABI_SVR4
+
+config ABI_UW7
+        tristate "UnixWare 7.x syscall support"
+        depends on ABI_SVR4
+
+config ABI_WYSE
+        tristate "Wyse V/386 syscall support"
+        depends on ABI_SVR4
+
+
+comment "SVR3/SVR4 related binary format support for x86:"
+        depends on ABI_SVR4
+
+config BINFMT_COFF
+        tristate "COFF binary support (SVR3)"
+        depends on ABI_SVR4
+
+config BINFMT_XOUT
+        tristate "x.out binary support (Xenix)"
+        depends on ABI_SVR4
+
+config BINFMT_XOUT_X286
+        bool "x.out segmented binary support (Xenix/80286)"
+        depends on BINFMT_XOUT
+
+
+config ABI_LATE_PROBING
+        bool
+        prompt "Late probing of personality trough syscall handler"
+        depends on ABI
+        default y
+        help
+          There is a minor general uncertainty on identification of binary 
+          formats. It might happen that  statically linked SVr4 binary could
+          be falsely assigned to a Linux personality. Solaris/x86 binarys 
+          are another sample for a falsely assigned Linux personality.
+          If this option is set the lcall handler for Linux will switch
+          to SVr4 personality as soon as lcall 0x07 is used, or it will
+          switch to Solaris personality when lcall 0x27 is used.
+          Since this on-the-fly personality switching is a one way path
+          a malicious program might make use of exactly that ability.
+          For system consistency reasons personality detection should go
+          that way. The better solution is to improve the personality
+          detection code at load time in contrast to runtime detection.
+          At present load time probing is not perfect, so better say yes.
+
+config ABI_TRACE
+        bool
+        prompt "Include prints for syscall tracking via ABI_TRACE ioctl"
+        depends on ABI
+        default y
+        help
+          This option allows to control the inclusion of code that prints
+          kernel messages for tracking special syscalls events like errors.
+          Typically this messages further have to be enabled via the 
+          ABI_TRACE ioctl. This option will not remove the ioctl interface
+          but will only remove the backend coding which produces the prints.
+          You can disable thise option if you want to reduce the kernel size
+          or have other concerns, e.g. code size or possible message floods.
+
+# --- internal options, values will get derived from prior settings ---
+
+# the abi-util (./abi/util) codebase
+# does currently only contain code for the ABI_TRACE coding
+# and has to be present as soon as the SVR4 code is present.
+config ABI_UTIL
+        tristate
+        depends on ABI_TRACE
+        default y if ABI_SVR4=y
+        default m if ABI_SVR4=m
+        default n
+
+config ABI_SPX 
+        bool
+        depends on ABI!=n
+        default y
+
+config ABI_XTI
+        bool
+        depends on ABI!=n
+        default y
+
+config ABI_TLI_OPTMGMT
+        bool
+        depends on ABI!=n
+        default y
+
+config ABI_XTI_OPTMGMT
+        bool
+        depends on ABI!=n
+        default n
+
+# there are syscall interfaces which do get statically linked
+config ABI_SYSCALL_STATICS
+        bool
+        default y if ABI_UW7=y || ABI_SOLARIS=y || ABI_IBCS=y || ABI_ISC=y || ABI_SCO=y || ABI_WYSE=y
+        default n
+
+# there are syscall interfaces which do get build as module
+config ABI_SYSCALL_MODULES
+        bool
+        default y if ABI_UW7=m || ABI_SOLARIS=m || ABI_IBCS=m || ABI_ISC=m || ABI_SCO=m || ABI_WYSE=m
+        default n
+
+# the LCALL7 code for SVR4 family support must _not_ be a module
+# when there is at least a single, statically bound syscall driver.
+# if there are only modules, then the LCALL code can be a module as well.
+# if there is no module at all then we dont need the LCALL7 code.
+config ABI_LCALL7
+        tristate
+        default y if ABI_SYSCALL_STATICS=y
+        default m if ABI_SYSCALL_MODULES=y
+        default n
+
+# notes:
+# * only a static SVR4 core coding will allow static syscall drivers,
+# * setting a syscall driver to modules will be the only way to allow
+#   this single module to plug into SVR4 core coding.
+# * there is no generic "register my entrypoints" request for modules
+#   in the curent codebase. (this might be a TODO)
+# * the exported LCALL7 syms will only be usefull to syscall driver modules.
+# * LCALL7 is only usefull if there are syscall drivers (static or module).
+# * an "empty" SVR4 might be usefull for debugging and non-x86 targets.
+
+### EOF ###
diff -Nru linux-2.6.7/abi/Makefile linux-2.6.7-abi/abi/Makefile
--- linux-2.6.7/abi/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,8 @@
+obj-$(CONFIG_ABI)               += util/
+obj-$(CONFIG_ABI_SVR4)          += svr4/
+obj-$(CONFIG_ABI_SCO)           += sco/ cxenix/
+obj-$(CONFIG_ABI_WYSE)          += wyse/
+obj-$(CONFIG_ABI_UW7)           += uw7/
+obj-$(CONFIG_ABI_SOLARIS)       += solaris/
+obj-$(CONFIG_ABI_IBCS)          += ibcs/
+obj-$(CONFIG_ABI_ISC)           += isc/
diff -Nru linux-2.6.7/abi/sco/ioctl.c linux-2.6.7-abi/abi/sco/ioctl.c
--- linux-2.6.7/abi/sco/ioctl.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/ioctl.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,184 @@
+/*
+ * ioctl.c - SCO Unix ioctl(2) switch
+ *
+ * Copyright (C) 1991, 1992  Linus Torvalds
+ * 
+ * Written by Drew Sullivan.
+ * Rewritten by Mike Jagdis.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/ptrace.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/sco/ioctl.h>
+#include <abi/svr4/ioctl.h>
+
+
+/*
+ * do_ioctl() is a meta mapper, that is
+ * it looks up the class of the ioctl and then
+ * dispatchs to lower level routines to handle the
+ * mapping of the actual ioctls
+ */
+static int
+do_ioctl(struct pt_regs *regs, int fd, unsigned long ioctl_num, void *arg)
+{
+	unsigned int class = ioctl_num >> 8;
+	char class_str[4];
+
+	switch (class) {
+
+	/*
+	 * SCO ioctls on the pseudo NFS device probably.
+	 */
+	case 0:
+		return abi_ioctl_socksys(fd, ioctl_num, arg);
+
+	/*
+	 * SCO console keyboard stuff?
+	 */
+	case 'A':
+		return -EINVAL;
+
+	case 'm':
+		return sco_tape_ioctl(fd, ioctl_num, arg);
+
+	case 't':
+		return bsd_ioctl_termios(fd, ioctl_num, arg);
+
+	case 'f':
+		return svr4_fil_ioctl(fd, ioctl_num, arg);
+
+	/*
+	 * Xenix ioctl compatibility.
+	 */
+	case 'T':
+		return svr4_term_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	case ('i' << 16) | ('X' << 8):	/* iBCS2 POSIX */
+	case 'x':			/* Pre-iBCS2 POSIX */
+		return sco_term_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	case 'C':
+	case 'c':
+		return svr4_console_ioctl(fd, ioctl_num, arg);
+
+	case ('i' << 16) | ('C' << 8):	/* iBCS2 POSIX */
+		return svr4_video_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	/*
+	 * These aren't implemented and are never likely to be as they
+	 * are specific to drivers for obscure hardware. (For those
+	 * that don't know they're the JERQ ioctls. Says it all
+	 * really!)
+	 */
+	case 'j':
+		return -EINVAL;
+
+	/*
+	 * The 'S' set could also be display mode switch
+	 * ioctls in a SCO 3.2.x x<4 environment. It should
+	 * depend on the descriptor they are applied to.
+	 * According to ISC the Xenix STREAMS ioctls had the
+	 * high bit set on the command to differentiate them
+	 * from mode switch ioctls. Yuk, yuk, yuk...
+	 */
+	case 'S':
+		return svr4_stream_ioctl(regs, fd, ioctl_num & 0x7F, arg);
+
+	/*
+	 * These are STREAMS socket module ioctls.
+	 */
+	case 'I':
+#if defined(CONFIG_ABI_XTI)
+		return svr4_sockmod_ioctl(fd, ioctl_num & 0xFF, arg);
+#else
+		return -EINVAL;
+#endif
+
+	/*
+	 * These are SCO <vtkd.h> ioctls - see vtkd.h
+	 */
+	case 'v':
+	case 'K':
+		return sco_vtkbd_ioctl(fd, ioctl_num, arg);
+
+	/*
+	 * SCO channel mapping. I can't find any documentation
+	 * for this. These are the LD?MAP ioctls defined in
+	 * sys/termio.h and sys/emap.h. They are used by mapchan.
+	 */
+	case 'D':
+		return -EINVAL;
+	}
+
+	/*
+	 * If we haven't handled it yet it must be a BSD style ioctl
+	 * with a (possible) argument description in the high word of
+	 * the opcode.
+	 */
+	switch (class & 0xff) {
+
+	/*
+	 * From SVR4 as specified in sys/iocomm.h.
+	 */
+	case 'f':
+		return svr4_fil_ioctl(fd, ioctl_num, arg);
+
+	/*
+	 * BSD or V7 terminal ioctls.
+	 */
+	case 't':
+		return bsd_ioctl_termios(fd, ioctl_num, arg);
+
+	/*
+	 * SVR3 streams based socket TCP/IP ioctls.
+	 *
+	 * These are handed over to the standard ioctl
+	 * handler since /dev/socksys is an emulated device
+	 * and front ends any sockets created through it.
+	 * Note that 'S' ioctls without the BSDish argument
+	 * type in the high bytes are STREAMS ioctls and 'I'
+	 * ioctls without the BSDish type in the high bytes
+	 * are the STREAMS socket module ioctls. (see above).
+	 */
+	case 'S':
+	case 'R':
+	case 'I':
+		return abi_ioctl_socksys(fd, ioctl_num, arg);
+	}
+
+	/*
+	 * If nothing has handled it yet someone may have to do some
+	 * more work...
+	 */
+	class_str[0] = class & 0xFF0000 ? (char)((class >> 16) & 0xFF) : '.';
+	class_str[1] = class & 0x00FF00 ? (char)((class >>  8) & 0xFF) : '.';
+	class_str[2] = class & 0x0000FF ? (char)((class      ) & 0xFF) : '.';
+	class_str[3] = 0;
+
+	printk(KERN_DEBUG "sco: ioctl(%d, %lx[%s], 0x%p) unsupported\n",
+		fd, ioctl_num, class_str, arg);
+
+	return -EINVAL;
+}
+
+int
+sco_ioctl(struct pt_regs *regs)
+{
+	u_int			num;
+	int			fd;
+	caddr_t			data;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	num = (u_int)get_syscall_parameter(regs, 1);
+	data = (caddr_t)get_syscall_parameter(regs, 2);
+
+	return do_ioctl(regs, fd, num, data);
+}
diff -Nru linux-2.6.7/abi/sco/Makefile linux-2.6.7-abi/abi/sco/Makefile
--- linux-2.6.7/abi/sco/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,12 @@
+
+abi-sco-objs	:= sysent.o misc.o mmap.o ptrace.o secureware.o \
+		   stat.o statvfs.o
+
+# various ioctl emulation stuff
+abi-sco-objs	+= ioctl.o termios.o tapeio.o vtkbd.o
+
+
+obj-$(CONFIG_ABI_SCO)		+= abi-sco.o
+
+abi-sco.o: $(abi-sco-objs)
+	$(LD) -r -o $@ $(abi-sco-objs)
diff -Nru linux-2.6.7/abi/sco/misc.c linux-2.6.7-abi/abi/sco/misc.c
--- linux-2.6.7/abi/sco/misc.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/misc.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Misc SCO syscalls.
+ */
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/stat.h>
+#include <linux/syscalls.h>
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sysent.h>
+
+
+int
+sco_lseek(int fd, u_long offset, int whence)
+{
+	int			error;
+
+	error = sys_lseek(fd, offset, whence);
+	if (error == -ESPIPE) {
+		struct file	*fp = fget(fd);
+		struct inode	*ip;
+		
+		if (fp == NULL)
+			goto out;
+		ip = fp->f_dentry->d_inode;
+		if (ip && (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode)))
+			error = 0;
+		fput(fp);
+	}
+out:
+	return (error);
+}
+
+int
+sco_fcntl(int fd, u_int cmd, u_long arg)
+{
+	/*
+	 * This could be SCO's get highest fd open if the fd we
+	 * are called on is -1 otherwise it could be F_CHKFL.
+	 */
+	if (fd == -1 && cmd == 8) {
+		struct files_struct *files = current->files;
+		int rval;
+
+                /* compare to ./fs/open.c: get_unused_fd */
+		spin_lock(&files->file_lock);
+		rval = find_first_zero_bit(files->open_fds->fds_bits, files->max_fdset);
+		spin_unlock(&files->file_lock);
+
+		return rval;
+	}
+
+	return svr4_fcntl(fd, cmd, arg);
+}
+
+int
+sco_sysi86(int cmd, void *arg1, int arg2)
+{
+	switch (cmd) {
+	case 114 /*SI86GETFEATURES*/ :
+		/*
+		 * No, I don't know what these feature flags actually
+		 * _mean_. This vector just matches SCO OS 5.0.0.
+		 */
+#define OSR5_FEATURES	"\001\001\001\001\001\001\001\001\002\001\001\001"
+		arg2 = max(arg2, 12);
+		if (copy_to_user(arg1, OSR5_FEATURES, arg2))
+			return -EFAULT;
+		return arg2;
+	default:
+		return svr4_sysi86(cmd, arg1, arg2);
+	}
+}
diff -Nru linux-2.6.7/abi/sco/mmap.c linux-2.6.7-abi/abi/sco/mmap.c
--- linux-2.6.7/abi/sco/mmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/mmap.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Support for mmap on SCO OpenServer 5.
+ */
+#include <linux/mm.h>
+#include <linux/errno.h>
+#include <linux/file.h>
+#include <linux/mman.h>
+#include <asm/uaccess.h>
+
+#include <abi/sco/mman.h>
+#include <abi/sco/types.h>
+
+#include <abi/util/trace.h>
+
+
+int
+sco_mmap(u_long addr, size_t len, int prot, int flags, int fd, sco_off_t off)
+{
+	struct file *file;
+	u_long mapaddr;
+
+	if (flags & SCO_MAP_UNIMPL) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_UNIMPL,
+		    "unsupported mmap flags: 0x%x\n", flags & SCO_MAP_UNIMPL);
+#endif
+		flags &= ~SCO_MAP_UNIMPL;
+	}
+
+	file = fget(fd);
+	if (!file)
+		return -EBADF;
+	
+	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+	down_write(&current->mm->mmap_sem);
+	mapaddr = do_mmap(file, addr, len, prot, flags | MAP_FIXED, off);
+	up_write(&current->mm->mmap_sem);
+
+	fput(file);
+
+	if (mapaddr == addr)
+		return 0;
+	return mapaddr;
+}
diff -Nru linux-2.6.7/abi/sco/ptrace.c linux-2.6.7-abi/abi/sco/ptrace.c
--- linux-2.6.7/abi/sco/ptrace.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/ptrace.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,112 @@
+/*
+ * ptrace.c - SCO OpenServer ptrace(2) support.
+ *
+ * Copyright (c) 1995 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+/*
+ * This file is nearly identical to abi/wyse/ptrace.c, please keep it in sync.
+ */
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/personality.h>
+#include <linux/user.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+
+#include <asm/uaccess.h>
+
+#include <abi/signal.h>
+#include <abi/util/trace.h>
+
+
+#define NREGS	19
+#define U(X)	((unsigned long)&((struct user *)0)->X)
+
+static unsigned long sco_to_linux_reg[NREGS] = {
+	U(regs.gs),	U(regs.fs),	U(regs.es),	U(regs.ds),
+	U(regs.edi),	U(regs.esi),
+	U(regs.ebp),
+	U(regs.esp	/* ESP */),
+	U(regs.ebx),	U(regs.edx),	U(regs.ecx),	U(regs.eax),
+	U(signal	/* Trap */),
+	U(reserved	/* ERR */),
+	U(regs.eip),	U(regs.cs),	U(regs.eflags),
+	U(regs.esp),	U(regs.ss)
+};
+
+#if defined(CONFIG_ABI_TRACE)
+static const char *regnam[] = {
+	"EBX", "ECX", "EDX", "ESI", "EDI", "EBP", "EAX",
+	"DS", "ES", "FS", "GS", "ORIG_EAX", "EIP", "CS",
+	"EFL", "UESP", "SS"
+};
+#endif
+
+int
+sco_ptrace(int req, int pid, u_long addr, u_long data)
+{
+	u_long			res;
+
+	/*
+	 * Slight variations between iBCS and Linux codes.
+	 */
+	if (req == PTRACE_ATTACH)
+		req = 10;
+	else if (req == PTRACE_DETACH)
+		req = 11;
+
+	if (req == 3 || req == 6) {
+		/* get offset of u_ar0 */
+		if (addr == 0x1200)
+			return 0x4000;
+
+		/* remap access to the registers. */
+		if ((addr & 0xff00) == 0x4000) { /* Registers */
+			addr = (addr & 0xff) >> 2;
+			if (addr > NREGS)
+				return -EIO;
+			addr = sco_to_linux_reg[addr];
+			if (addr == -1)
+				return -EIO;
+		}
+	}
+
+	if (req == 7 && data > 0) {
+		if (data > NSIGNALS)
+			return -EIO;
+		data = current_thread_info()->exec_domain->signal_map[data];
+	}
+
+	if (req == 1 || req == 2 || req == 3) {
+		mm_segment_t	old_fs = get_fs();
+		int		error;
+
+		set_fs(get_ds());
+		error = sys_ptrace(req, pid, addr, (long)&res);
+		set_fs(old_fs);
+
+		if (error)
+			return (error);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	if (req == 3 || req == 6) {
+		abi_trace(ABI_TRACE_API, "%ld [%s] = 0x%08lx\n",
+			addr >> 2, (addr >> 2) < ARRAY_SIZE(regnam) ?
+				regnam[addr >> 2] : "???",
+			req == 3 ? res : data);
+	}
+#endif
+
+	if (req == 1 || req == 2 || req == 3)
+		return (res);
+
+	return sys_ptrace(req, pid, addr, data);
+}
diff -Nru linux-2.6.7/abi/sco/secureware.c linux-2.6.7-abi/abi/sco/secureware.c
--- linux-2.6.7/abi/sco/secureware.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/secureware.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1994 Mike Jagdis.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+
+/*
+ * SecureWare, Inc. provided the C2 security subsystem used on SCO Unix.
+ * This is not that package. This does not even attempt to emulate
+ * that package. This emulates just enough of the "obvious" bits to
+ * allow some programs to get a bit further. It is not useful to
+ * try to implement C2 security in an emulator. Nor is it particularly
+ * useful to run SCO's secure admin programs on Linux anyway...
+ */
+enum {
+	SW_GETLUID =	0x01,
+	SW_SETLUID =	0x02,
+};
+
+int
+sw_security(int cmd, void *p1, void *p2, void *p3, void *p4, void *p5)
+{
+	switch (cmd) {
+	case SW_GETLUID:
+		/*
+		 * We want the login user id. We don't have it
+		 * specifically so we'll just use the real uid
+		 * instead - it should be good enough.
+		 */
+		return (current->uid);
+	case SW_SETLUID:
+		/*
+		 * Strictly we should only be able to call setluid()
+		 * once but we can't enforce that. We have the choice
+		 * between having it always succeed or always fail.
+		 * Since setluid() should only ever be invoked by
+		 * things like login processes we always fail it.
+		 */
+		return -EPERM;
+	}
+
+	printk(KERN_ERR "%s: unsupported security call cmd=%d\n", __FILE__, cmd);
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/sco/stat.c linux-2.6.7-abi/abi/sco/stat.c
--- linux-2.6.7/abi/sco/stat.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/stat.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * aint32_t with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SCO OpenServer xstat/fxstat/lxstat support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <asm/uaccess.h>
+
+#include <abi/sco/types.h>
+#include <abi/sco/stat.h>
+#include <abi/svr4/stat.h>
+
+#include <abi/util/trace.h>
+#include <abi/util/stat.h>
+
+
+enum {SVR4_stat = 1, SCO_xstat = 51};
+
+static int
+report_sco_xstat(struct kstat *stp, struct sco_xstat *bufp)
+{
+	struct sco_xstat buf;
+
+	memset(&buf, 0, sizeof(struct sco_xstat));
+
+	buf.st_dev	= linux_to_sco_dev_t(stp->dev);
+	buf.st_ino	= linux_to_sco_ino_t(stp->ino);
+	buf.st_mode	= stp->mode;
+	buf.st_nlink	= stp->nlink;
+	buf.st_uid	= linux_to_sco_uid_t(stp->uid);
+	buf.st_gid	= linux_to_sco_gid_t(stp->gid);
+	buf.st_rdev	= linux_to_sco_dev_t(stp->rdev);
+
+	if (stp->size > MAX_NON_LFS)
+		return -EOVERFLOW;	/* XXX: what to return for SCO?? */
+
+	buf.st_size	= stp->size;
+	
+	buf.st_atime	= stp->atime.tv_sec;
+	buf.st_mtime	= stp->mtime.tv_sec;
+	buf.st_ctime 	= stp->ctime.tv_sec;
+	
+	buf.st_blksize	= stp->blksize;
+	buf.st_blocks	= stp->blocks;
+
+	strcpy(buf.st_fstype, "ext2");
+
+	buf.st_sco_flags = 0; /* 1 if remote */
+
+	if (copy_to_user(bufp, &buf, sizeof(struct sco_xstat)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+sco_xstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_stat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SCO_xstat:
+		return report_sco_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "xstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+sco_lxstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_lstat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SCO_xstat:
+		return report_sco_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "lxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+sco_fxstat(int vers, int fd, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_fstat(fd, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SCO_xstat:
+		return report_sco_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "fxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/sco/statvfs.c linux-2.6.7-abi/abi/sco/statvfs.c
--- linux-2.6.7/abi/sco/statvfs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/statvfs.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SCO OpenServer statvfs/fstatvfs support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <linux/vfs.h>
+#include <linux/mount.h>
+#include <linux/namei.h>
+#include <asm/uaccess.h>
+
+#include <abi/sco/types.h>
+
+
+static int
+report_statvfs(struct vfsmount *mnt, struct inode *ip, struct sco_statvfs *bufp)
+{
+	struct sco_statvfs buf;
+	struct kstatfs s;
+	int error;
+
+	error = vfs_statfs(mnt->mnt_sb, &s);
+	if (error)
+		return error;
+
+	memset(&buf, 0, sizeof(struct sco_statvfs));
+
+	buf.f_bsize	= s.f_bsize; 
+	buf.f_frsize	= s.f_bsize;
+	buf.f_blocks	= s.f_blocks;
+	buf.f_bfree	= s.f_bfree;
+	buf.f_bavail	= s.f_bavail;
+	buf.f_files	= s.f_files;
+	buf.f_free	= s.f_ffree;
+	buf.f_favail	= s.f_ffree; /* SCO addition in the middle! */
+	buf.f_sid	= ip->i_sb->s_dev;
+
+	/*
+	 * Get the name of the filesystem.
+	 *
+	 * Sadly, some code "in the wild" actually checks the name
+	 * against a hard coded list to see if it is a "real" fs or not.
+	 *
+	 * I believe Informix Dynamic Server for SCO is one such.
+	 */
+	if (strncmp(ip->i_sb->s_type->name, "ext2", 4) == 0)
+		strcpy(buf.f_basetype, "HTFS");
+	else
+		strcpy(buf.f_basetype, ip->i_sb->s_type->name);
+
+	/* Check for a few flags statvfs wants but statfs doesn't have. */
+	if (IS_RDONLY(ip))
+		buf.f_flag |= 1;
+	if (mnt->mnt_flags & MNT_NOSUID)
+		buf.f_flag |= 2;
+
+	buf.f_namemax	= s.f_namelen;
+
+	if (copy_to_user(bufp, &buf, sizeof(struct sco_statvfs)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+sco_statvfs(char *filename, struct sco_statvfs *bufp)
+{
+	struct nameidata nd;
+	int error;
+
+	error = user_path_walk(filename, &nd);
+	if (!error) {
+		error = report_statvfs(nd.mnt, nd.dentry->d_inode, bufp);
+		path_release(&nd);
+	}
+	return error;
+}
+
+int
+sco_fstatvfs(int fd, struct sco_statvfs *bufp)
+{
+	struct file *fp;
+	int error = -EBADF;
+
+	fp = fget(fd);
+	if (fp) {
+		error = report_statvfs(fp->f_vfsmnt,
+				fp->f_dentry->d_inode, bufp);
+		fput(fp);
+	}
+	return error;
+}
diff -Nru linux-2.6.7/abi/sco/sysent.c linux-2.6.7-abi/abi/sco/sysent.c
--- linux-2.6.7/abi/sco/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/sysent.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SCO Unix 3.x personality switch
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/personality.h>
+#include <linux/types.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/sco/signal.h>
+#include <abi/sco/sysent.h>
+#include <abi/svr4/sysent.h>
+#include <abi/cxenix/sysent.h>
+
+#include <abi/signal.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/map.h>
+#include <abi/util/sysent.h>
+#include <abi/util/socket.h>
+
+
+MODULE_DESCRIPTION("OpenServer/Xenix personality");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+static u_char sco_err_table[] = {
+/*   0 -   9 */   0,   1,   2,    3,   4,   5,   6,   7,   8,   9,
+/*  10 -  19 */   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+/*  20 -  29 */   20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+/*  30 -  39 */   30,  31,  32,  33,  34,  45,  78,  46,  89, 145,
+/*  40 -  49 */  150,  90,  35,  36,  37,  38,  39,  40,  41,  42,
+/*  50 -  59 */   43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+/*  60 -  69 */   60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+/*  70 -  79 */   70,  71,  74,  76,  77,  79,  80,  81,  82,  83,
+/*  80 -  89 */   84,  85,  86,  87,  88, 152, 153,  22,  93,  94,
+/*  90 -  99 */   95,  96, 118,  97,  98,  99, 100, 101, 102, 103,
+/* 100 - 109 */  104, 105, 106, 107, 108,  63, 110, 111, 112, 113,
+/* 110 - 119 */  114, 115, 116, 117,  92,  91, 151, 135, 137, 138,
+/* 120 - 122 */  139, 140, 28
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+/* 512 - 514 */	EINTR, EINTR, EINTR
+};
+
+static struct map_segment sco_err_map[] = {
+	{ 0,	0+sizeof(sco_err_table)-1,	sco_err_table },
+	{ 512,	512+sizeof(lnx_err_table)-1,	lnx_err_table },
+	{ -1 }
+};
+
+/* XXX: move to signal.h */
+#define SCO__SIGSTKFLT	SCO_SIGTERM /* Stack fault */
+
+static long linux_to_sco_signals[NSIGNALS + 1] = {
+/*  0 -  3 */	0,		SCO_SIGHUP,	SCO_SIGINT,	SCO_SIGQUIT,
+/*  4 -  7 */	SCO_SIGILL,	SCO_SIGTRAP,	SCO_SIGABRT,	SCO_SIGBUS,
+/*  8 - 11 */	SCO_SIGFPE,	SCO_SIGKILL,	SCO_SIGUSR1,	SCO_SIGSEGV,
+/* 12 - 15 */	SCO_SIGUSR2,	SCO_SIGPIPE,	SCO_SIGALRM,	SCO_SIGTERM,
+/* 16 - 19 */	SCO__SIGSTKFLT,	SCO_SIGCLD,	SCO_SIGCONT,	SCO_SIGSTOP,
+/* 20 - 23 */	SCO_SIGTSTP,	SCO_SIGTTIN,	SCO_SIGTTOU,	SCO_SIGURG,
+/* 24 - 27 */	SCO_SIGXCPU,	SCO_SIGXFSZ,	SCO_SIGVTALRM,	SCO_SIGPROF,
+/* 28 - 31 */	SCO_SIGWINCH,	SCO_SIGPOLL,	SCO_SIGPWR,	SCO_SIGSYS,
+/*      32 */	-1
+};
+
+static long linux_to_xenix_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,	IBCS_SIGINT,	IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,	IBCS_SIGABRT,	-1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,	IBCS_SIGUSR1,	IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,	IBCS_SIGALRM,	IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,	IBCS_SIGCONT,	IBCS_SIGSTOP,
+/* 20 - 23 */	IBCS_SIGTSTP,	IBCS_SIGTTIN,	IBCS_SIGTTOU,	IBCS_SIGUSR1,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,	IBCS_SIGVTALRM,	IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	20 /*SIGIO*/,	IBCS_SIGPWR,	-1,
+/*      32 */	-1
+};
+
+static long sco_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,		SIGINT,		SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,	SIGIOT,		SIGABRT,
+/*  8 - 11 */	SIGFPE,		SIGKILL,	SIGBUS,		SIGSEGV,
+/* 12 - 15 */	SIGSYS,		SIGPIPE,	SIGALRM,	SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,	SIGCHLD,	SIGPWR,
+/* 20 - 23 */	SIGWINCH,	SIGURG,		SIGPOLL,	SIGSTOP,
+/* 24 - 27 */	SIGTSTP,	SIGCONT,	SIGTTIN,	SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,	SIGXCPU,	SIGXFSZ,
+/*      32 */	-1
+};
+
+static long xenix_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,		SIGINT,		SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,	SIGIOT,		SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,	SIGUNUSED,	SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,	SIGALRM,	SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,	SIGCHLD,	SIGPWR,
+/* 20 - 23 */	SIGPOLL,	-1,		-1,		-1,
+/* 24 - 27 */	-1,		-1,		-1,		-1,
+/* 28 - 31 */	-1,		-1,		-1,		-1,
+/*      32 */	-1
+};
+
+static char sco_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment sco_socktype_map[] = {
+	{ 1, 6, sco_socktype },
+	{ -1 }
+};
+
+static struct map_segment sco_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+/*
+ * The first three entries (AF_UNSPEC, AF_UNIX and AF_INET)
+ * are identity mapped. All others aren't available under
+ * Linux, nor are Linux's AF_AX25 and AF_IPX available from
+ * SCO as far as I know.
+ */
+static struct map_segment sco_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent sco_syscall_table[] = {
+/*   0 */	{ abi_syscall,		Fast,	"syscall",	""	},
+/*   1 */	{ sys_exit,		1,	"exit",		"d"	},
+/*   2 */	{ abi_fork,		Spl,	"fork",		""	},
+/*   3 */	{ abi_read,		3,	"read",		"dpd"	},
+/*   4 */	{ sys_write,		3,	"write",	"dpd"	},
+/*   5 */	{ svr4_open,		3,	"open",		"soo"	},
+/*   6 */	{ sys_close,		1,	"close",	"d"	},
+/*   7 */	{ abi_wait,		Spl,	"wait",		"xxx"	},
+/*   8 */	{ sys_creat,		2,	"creat",	"so"	},
+/*   9 */	{ sys_link,		2,	"link",		"ss"	},
+/*  10 */	{ sys_unlink,		1,	"unlink",	"s"	},
+/*  11 */	{ abi_exec,		Spl,	"exec",		"sxx"	},
+/*  12 */	{ sys_chdir,		1,	"chdir",	"s"	},
+/*  13 */	{ abi_time,		0,	"time",		""	},
+/*  14 */	{ svr4_mknod,		3,	"mknod",	"soo"	},
+/*  15 */	{ sys_chmod,		2,	"chmod",	"so"	},
+/*  16 */	{ sys_chown,		3,	"chown",	"sdd"	},
+/*  17 */	{ abi_brk,		1,	"brk/break",	"x"	},
+/*  18 */	{ svr4_stat,		2,	"stat",		"sp"	},
+/*  19 */	{ sco_lseek,		3,	"seek/lseek",	"ddd"	},
+/*  20 */	{ abi_getpid,		Spl,	"getpid",	""	},
+/*  21 */	{ 0,			Ukn,	"mount",	""	},
+/*  22 */	{ sys_umount,		1,	"umount",	"s"	},
+/*  23 */	{ sys_setuid,		1,	"setuid",	"d"	},
+/*  24 */	{ abi_getuid,		Spl,	"getuid",	""	},
+/*  25 */	{ sys_stime,		1,	"stime",	"d"	},
+/*  26 */	{ sco_ptrace,		4,	"ptrace",	"xdxx"	},
+/*  27 */	{ sys_alarm,		1,	"alarm",	"d"	},
+/*  28 */	{ svr4_fstat,		2,	"fstat",	"dp"	},
+/*  29 */	{ sys_pause,		0,	"pause",	""	},
+/*  30 */	{ sys_utime,		2,	"utime",	"xx"	},
+/*  31 */	{ 0,			Ukn,	"stty",		""	},
+/*  32 */	{ 0,			Ukn,	"gtty",		""	},
+/*  33 */	{ sys_access,		2,	"access",	"so"	},
+/*  34 */	{ sys_nice,		1,	"nice",		"d"	},
+/*  35 */	{ svr4_statfs,		4,	"statfs",	"spdd"	},
+/*  36 */	{ sys_sync,		0,	"sync",		""	},
+/*  37 */	{ abi_kill,		2,	"kill",		"dd"	},
+/*  38 */	{ svr4_fstatfs,		4,	"fstatfs",	"dpdd"	},
+/*  39 */	{ abi_procids,		Spl,	"procids",	"d"	},
+/*  40 */	{ cxenix,		Fast,	"cxenix",	""	},
+/*  41 */	{ sys_dup,		1,	"dup",		"d"	},
+/*  42 */	{ abi_pipe,		Spl,	"pipe",		""	},
+/*  43 */	{ sys_times,		1,	"times",	"p"	},
+/*  44 */	{ 0	,		Ukn,	"prof",		""	},
+/*  45 */	{ 0,			Ukn,	"lock/plock",	""	},
+/*  46 */	{ sys_setgid,		1,	"setgid",	"d"	},
+/*  47 */	{ abi_getgid,		Spl,	"getgid",	""	},
+/*  48 */	{ abi_sigfunc,		Fast,	"sigfunc",	"xxx"	},
+/*  49 */	{ svr4_msgsys,		Spl,	"msgsys",	"dxddd"	},
+/*  50 */	{ sco_sysi86,		3,	"sysi86/sys3b",	"d"	},
+/*  51 */	{ sys_acct,		1,	"acct/sysacct",	"x"	},
+/*  52 */	{ svr4_shmsys,		Fast,	"shmsys",	"ddxo"	},
+/*  53 */	{ svr4_semsys,		Spl,	"semsys",	"dddx"	},
+/*  54 */	{ sco_ioctl,		Spl,	"ioctl",	"dxx"	},
+/*  55 */	{ 0,			3,	"uadmin",	"xxx"	},
+/*  56 */	{ 0,			Ukn,	"?",		""	},
+/*  57 */	{ v7_utsname,		1,	"utsys",	"x"	},
+/*  58 */	{ sys_fsync,		1,	"fsync",	"d"	},
+/*  59 */	{ abi_exec,		Spl,	"execv",	"spp"	},
+/*  60 */	{ sys_umask,		1,	"umask",	"o"	},
+/*  61 */	{ sys_chroot,		1,	"chroot",	"s"	},
+/*  62 */	{ sco_fcntl,		3,	"fcntl",	"dxx"	},
+/*  63 */	{ svr4_ulimit,		2,	"ulimit",	"xx"	},
+/*  64 */	{ 0,			Ukn,	"?",		""	},
+/*  65 */	{ 0,			Ukn,	"?",		""	},
+/*  66 */	{ 0,			Ukn,	"?",		""	},
+/*  67 */	{ 0,			Ukn,	"?",		""	},
+/*  68 */	{ 0,			Ukn,	"?",		""	},
+/*  69 */	{ 0,			Ukn,	"?",		""	},
+/*  70 */	{ 0,			Ukn,	"advfs",	""	},
+/*  71 */	{ 0,			Ukn,	"unadvfs",	""	},
+/*  72 */	{ 0,			Ukn,	"rmount",	""	},
+/*  73 */	{ 0,			Ukn,	"rumount",	""	},
+/*  74 */	{ 0,			Ukn,	"rfstart",	""	},
+/*  75 */	{ 0,			Ukn,	"?",		""	},
+/*  76 */	{ 0,			Ukn,	"rdebug",	""	},
+/*  77 */	{ 0,			Ukn,	"rfstop",	""	},
+/*  78 */	{ 0,			Ukn,	"rfsys",	""	},
+/*  79 */	{ sys_rmdir,		1,	"rmdir",	"s"	},
+/*  80 */	{ abi_mkdir,		2,	"mkdir",	"so"	},
+/*  81 */	{ svr4_getdents,	3,	"getdents",	"dxd"	},
+/*  82 */	{ 0,			Ukn,	"libattach",	""	},
+/*  83 */	{ 0,			Ukn,	"libdetach",	""	},
+/*  84 */	{ svr4_sysfs,		3,	"sysfs",	"dxx"	},
+/*  85 */	{ svr4_getmsg,		Spl,	"getmsg",	"dxxx"	},
+/*  86 */	{ svr4_putmsg,		Spl,	"putmsg",	"dxxd"	},
+/*  87 */	{ sys_poll,		3,	"poll",		"xdd"	},
+/*  88 */	{ 0,			Ukn,	"nosys88",	""	},
+/*  89 */	{ sw_security,		6,	"security",	"dxxxxx"},
+/*  90 */	{ sys_symlink,		2,	"symlink",	"ss"	},
+/*  91 */	{ svr4_lstat,		2,	"lstat",	"sp"	},
+/*  92 */	{ sys_readlink,		3,	"readlink",	"spd"	},
+
+	/*
+	 * Ok, this is where the good-old SCO calls end.
+	 * Everything from here onwards is OSR5-specific.
+	 *
+	 * In fact OSR5 documents only the following calls:
+	 *
+	 *   o readv (121)
+	 *   o writev (122)
+	 *   o xstat (123)
+	 *   o lxstat (124)
+	 *   o fxstat (125)
+	 *   o clocal (127)
+	 *   o gettimeofday (171)
+	 *   o settimeofday (172)
+	 *
+	 * Everything else is guesswork (from AVR4/iABI4), even though
+	 * the OSR5 ELF libs use at least some of those... (e.g. mmap).
+	 */
+
+/*  93 */	{ 0,			Ukn,	"?",		""	},
+/*  94 */	{ 0,			Ukn,	"?",		""	},
+/*  95 */	{ abi_sigprocmask,	3,	"sigprocmask",	"dxx"	},
+/*  96 */	{ abi_sigsuspend,	Spl,	"sigsuspend",	"x"	},
+/*  97 */	{ 0,			2,	"sigaltstack",	"xx"	},
+/*  98 */	{ abi_sigaction,	3,	"sigaction",	"dxx"	},
+/*  99 */	{ svr4_sigpending,	2,	"sigpending",	"dp"	},
+/* 100 */	{ svr4_context,		Spl,	"context",	""	},
+/* 101 */	{ 0,			Ukn,	"evsys",	""	},
+/* 102 */	{ 0,			Ukn,	"evtrapret",	""	},
+/* 103 */	{ sco_statvfs,		2,	"statvfs",	"sp"	},
+/* 104 */	{ sco_fstatvfs,		2,	"fstatvfs",	"dp"	},
+/* 105 */	{ 0,			Ukn,	"unimp (sysisc)",""	},
+/* 106 */	{ 0,			Ukn,	"nfssys",	""	},
+/* 107 */	{ 0,			4,	"waitid",	"ddxd"	},
+/* 108 */	{ 0,			3,	"sigsendsys",	"ddd"	},
+/* 109 */	{ svr4_hrtsys,		Spl,	"hrtsys",	"xxx"	},
+/* 110 */	{ 0,			3,	"acancel",	"dxd"	},
+/* 111 */	{ 0,			Ukn,	"async",	""	},
+/* 112 */	{ 0,			Ukn,	"priocntlsys",	""	},
+/* 113 */	{ svr4_pathconf,	2,	"pathconf",	"sd"	},
+/* 114 */	{ sys_mincore,		3,	"mincore",	"xdx"	},
+/* 115 */	{ sco_mmap,		6,	"mmap",		"xxxxdx"},
+/* 116 */	{ sys_mprotect,		3,	"mprotect",	"xdx"	},
+/* 117 */	{ sys_munmap,		2,	"munmap",	"xd"	},
+/* 118 */	{ svr4_fpathconf,	2,	"fpathconf",	"dd"	},
+/* 119 */	{ abi_fork,		Spl,	"vfork",	""	},
+/* 120 */	{ sys_fchdir,		1,	"fchdir",	"d"	},
+/* 121 */	{ sys_readv,		3,	"readv",	"dxd"	},
+/* 122 */	{ sys_writev,		3,	"writev",	"dxd"	},
+/* 123 */	{ sco_xstat,		3,	"xstat",	"dsx"	},
+/* 124 */	{ sco_lxstat,     	3,	"lxstat",	"dsx"	},
+/* 125 */	{ sco_fxstat,		3,	"fxstat",	"ddx"	},
+/* 126 */	{ svr4_xmknod,		4,	"xmknod",	"dsox"	},
+/* 127 */	{ 0,			Ukn,	"syslocal",	"d"	},
+/* 128 */	{ svr4_getrlimit,	2,	"setrlimit",	"dx"	},
+/* 129 */	{ svr4_setrlimit,	2,	"getrlimit",	"dx"	},
+/* 130 */	{ 0,			Ukn,	"?",		""	},
+/* 131 */	{ 0,			Ukn,	"?",		""	},
+/* 132 */	{ 0,			Ukn,	"?",		""	},
+/* 133 */	{ 0,			Ukn,	"?",		""	},
+/* 134 */	{ 0,			Ukn,	"?",		""	},
+/* 135 */	{ 0,			Ukn,	"?",		""	},
+/* 136 */	{ 0,			Ukn,	"?",		""	},
+/* 137 */	{ 0,			Ukn,	"?",		""	},
+/* 138 */	{ 0,			Ukn,	"?",		""	},
+/* 139 */	{ 0,			Ukn,	"?",		""	},
+/* 140 */	{ socksys_syscall,	1,	"socksys",	"x"	},
+/* 141 */	{ 0,			Ukn,	"?",		""	},
+/* 142 */	{ 0,			Ukn,	"?",		""	},
+/* 143 */	{ 0,			Ukn,	"?",		""	},
+
+	/*
+	 * The next three are used when an OSR5 app is launched by
+	 * a UnixWare libc.
+	 *
+	 * These aren't supported by the UW7 personality either, but
+	 * adding the names here makes the traces look saner.
+	 */
+
+/* 144 */	{ 0,			2,	"uw7-secsys",	"dx"	},
+/* 145 */	{ 0,			4,	"uw7-filepriv",	"sdxd"	},
+/* 146 */	{ 0,			3,	"uw7-procpriv",	"dxd"	},
+
+/* 147 */	{ 0,			Ukn,	"?",		""	},
+/* 148 */	{ 0,			Ukn,	"?",		""	},
+/* 149 */	{ 0,			Ukn,	"?",		""	},
+/* 150 */	{ 0,			Ukn,	"?",		""	},
+/* 151 */	{ 0,			Ukn,	"?",		""	},
+/* 152 */	{ 0,			Ukn,	"?",		""	},
+/* 153 */	{ 0,			Ukn,	"?",		""	},
+/* 154 */	{ 0,			Ukn,	"?",		""	},
+/* 155 */	{ 0,			Ukn,	"?",		""	},
+/* 156 */	{ 0,			Ukn,	"?",		""	},
+/* 157 */	{ 0,			Ukn,	"?",		""	},
+/* 158 */	{ 0,			Ukn,	"?",		""	},
+/* 159 */	{ 0,			Ukn,	"?",		""	},
+/* 160 */	{ 0,			Ukn,	"?",		""	},
+/* 161 */	{ 0,			Ukn,	"?",		""	},
+/* 162 */	{ 0,			Ukn,	"?",		""	},
+/* 163 */	{ 0,			Ukn,	"?",		""	},
+/* 164 */	{ 0,			Ukn,	"?",		""	},
+/* 165 */	{ 0,			Ukn,	"?",		""	},
+/* 166 */	{ 0,			Ukn,	"?",		""	},
+/* 167 */	{ 0,			Ukn,	"?",		""	},
+/* 168 */	{ 0,			Ukn,	"?",		""	},
+/* 169 */	{ 0,			Ukn,	"?",		""	},
+/* 170 */	{ 0,			Ukn,	"?",		""	},
+/* 171 */	{ sys_gettimeofday,	2,	"gettimeofday",  "xx"	},
+/* 172 */	{ sys_settimeofday,	2,	"settimeofday",  "xx"	},
+};
+
+static void
+sco_lcall7(int segment, struct pt_regs *regs)
+{
+	int sysno = regs->eax & 0xff;
+	
+	if (sysno >= ARRAY_SIZE(sco_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &sco_syscall_table[sysno], 1);
+}
+
+
+static struct exec_domain sco_exec_domain = {
+	name:		"OpenServer",
+	handler:	sco_lcall7,
+	pers_low:	3 /* PER_SCOSVR3, PER_OSR5 */,
+	pers_high:	3 /* PER_SCOSVR3, PER_OSR5 */,
+	signal_map:	sco_to_linux_signals,
+	signal_invmap:	linux_to_sco_signals,
+	err_map:	sco_err_map,
+	socktype_map:	sco_socktype_map,
+	sockopt_map:	sco_sockopt_map,
+	af_map:		sco_af_map,
+	module:		THIS_MODULE
+};
+
+static struct exec_domain xenix_exec_domain = {
+	name:		"Xenix",
+	handler:	sco_lcall7,
+	pers_low:	7 /* PER_XENIX */,
+	pers_high:	7 /* PER_XENIX */,
+	signal_map:	xenix_to_linux_signals,
+	signal_invmap:	linux_to_xenix_signals,
+	err_map:	sco_err_map,
+	socktype_map:	sco_socktype_map,
+	sockopt_map:	sco_sockopt_map,
+	af_map:		sco_af_map,
+	module:		THIS_MODULE
+};
+
+
+static int __init
+sco_module_init(void)
+{
+        int		err;
+
+        err = register_exec_domain(&sco_exec_domain);
+        if (err) {
+                return err;
+        }
+
+        err = register_exec_domain(&xenix_exec_domain);
+        if (err) {
+                unregister_exec_domain(&sco_exec_domain);
+                return err;
+        }
+
+        return err;
+}
+
+static void __exit
+sco_module_exit(void)
+{
+	unregister_exec_domain(&xenix_exec_domain);
+	unregister_exec_domain(&sco_exec_domain);
+}
+
+module_init(sco_module_init);
+module_exit(sco_module_exit);
diff -Nru linux-2.6.7/abi/sco/tapeio.c linux-2.6.7-abi/abi/sco/tapeio.c
--- linux-2.6.7/abi/sco/tapeio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/tapeio.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,112 @@
+#ident "%W% %G%"
+
+#include <linux/kernel.h>
+#include <linux/mtio.h>
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+
+#include <asm/uaccess.h>
+
+
+int
+sco_tape_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	struct mtop		mtop;
+	mm_segment_t		fs;
+	int			error;
+
+	mtop.mt_count = 1;
+
+	switch (cmd & 0xff) {
+	case 1:  /* MT_RESET */
+		mtop.mt_op = MTRESET;
+		break;
+
+	case 2:  /* MT_RETEN */
+		mtop.mt_op = MTRETEN;
+		break;
+
+	case 3:  /* MT_REWIND */
+		mtop.mt_op = MTREW;
+		break;
+
+	case 4:  /* MT_ERASE */
+	case 23:  /* HP_ERASE */
+		mtop.mt_op = MTERASE;
+		break;
+
+	case 6:  /* MT_RFM */
+		mtop.mt_op = MTFSF;
+		break;
+
+	case 7:  /* MT_WFM */
+		mtop.mt_op = MTWEOF;
+		break;
+
+	case 8:  /* MT_LOAD */
+		mtop.mt_op = MTLOAD;
+		break;
+
+	case 9:  /* MT_UNLOAD */
+		mtop.mt_op = MTOFFL;
+		break;
+
+	case 19:  /* MT_RSM */
+		mtop.mt_op = MTFSS;
+		break;
+
+	case 20:  /* MT_WSM */
+		mtop.mt_op = MTWSM;
+		break;
+
+	case 21:  /* MT_EOD */
+		mtop.mt_op = MTEOM;
+		break;
+
+	case 24:  /* MT_SETBLK */
+		mtop.mt_op = MTSETBLK;
+		mtop.mt_count = (int)data;
+		break;
+
+	case 25:  /* MT_LOCK */
+		mtop.mt_op = MTLOCK;
+		break;
+
+	case 26:  /* MT_UNLOCK */
+		mtop.mt_op = MTUNLOCK;
+		break;
+
+
+#if 0
+/*
+	The following function codes are just copied from the SCO
+	include file.
+*/
+
+	case 0:  /* MT_STATUS */
+	case 5:  /* MT_AMOUNT */
+	case 10:  /* MT_DSTATUS */
+	case 11:  /* MT_FORMAT */
+	case 12:  /* MT_GETHDR */
+	case 13:  /* MT_PUTHDR */
+	case 14:  /* MT_GETNEWBB */
+	case 15:  /* MT_PUTNEWBB */
+	case 16:  /* MT_GETVTBL */
+	case 17:  /* MT_PUTVTBL */
+	case 18:  /* MT_SERVO */
+	case 22:  /* MT_FORMPART */
+	case 38:  /* MT_SETANSI */
+	case 64:  /* MT_REPORT */
+#endif
+	default:
+		printk (KERN_ERR "abi: SCO tape ioctl func=%d arg=%x unsupported\n",
+			cmd & 0xff, (int)data);
+		return -EINVAL;
+	}
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, MTIOCTOP, (long)&mtop);
+	set_fs(fs);
+	return (error);
+}
diff -Nru linux-2.6.7/abi/sco/termios.c linux-2.6.7-abi/abi/sco/termios.c
--- linux-2.6.7/abi/sco/termios.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/termios.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 1991, 1992  Linus Torvalds
+ * 
+ * Written by Drew Sullivan.
+ * Rewritten by Mike Jagdis.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/termios.h>
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/ioctl.h>
+#include <abi/svr4/termios.h>
+
+
+#define SCO_NCCS (SVR_NCC+5)
+
+struct sco_termios {
+	u_int16_t	c_iflag;
+	u_int16_t	c_oflag;
+	u_int16_t	c_cflag;
+	u_int16_t	c_lflag;
+	char		c_line;
+	u_char		c_cc[SCO_NCCS];
+	char		c_ispeed;
+	char		c_ospeed;
+};
+
+static int
+sco_to_linux_termios(int fd, int op, struct sco_termios *it)
+{
+	struct termios		t;
+	mm_segment_t		old_fs;
+	u_short			lflag, r;
+	char			sco_cc[SCO_NCCS];
+	int			error;
+
+	error = verify_area(VERIFY_READ, it, sizeof(struct sco_termios));
+	if (error)
+		return (error);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(old_fs);
+
+	if (error)
+		return (error);
+
+	__get_user(t.c_iflag, &it->c_iflag);
+	t.c_iflag &= ~0100000; /* DOSMODE */
+
+	__get_user(t.c_oflag, &it->c_oflag);
+
+	__get_user(t.c_cflag, &it->c_cflag);
+	if (t.c_cflag & 0100000) /* CRTSFL - SCO only? */
+		t.c_cflag |= CRTSCTS;
+	t.c_cflag &= ~0170000; /* LOBLK|CTSFLOW|RTSFLOW|CRTSFL */
+
+	lflag = t.c_lflag;
+	t.c_lflag &= ~0100777;
+	__get_user(r, &it->c_lflag);
+	t.c_lflag |= r;
+
+	if ((t.c_lflag & 0100000))
+		sys_ioctl(fd, TIOCEXCL, 0);
+	else
+		sys_ioctl(fd, TIOCNXCL, 0);
+
+	t.c_lflag &= ~0100000;
+	t.c_lflag |= (t.c_lflag & 0000400) << 7; /* Move IEXTEN */
+	t.c_lflag &= ~0000400;
+	t.c_lflag |= (t.c_lflag & 0001000) >> 1; /* Move TOSTOP */
+	t.c_lflag &= ~0001000;
+	t.c_lflag |= (lflag & 0001000); /* Restore ECHOCTL */
+
+	__get_user(t.c_line, &it->c_line); /* XXX Map this? */
+
+	copy_from_user(sco_cc, &it->c_cc, SCO_NCCS);
+	t.c_cc[0] = sco_cc[0];
+	t.c_cc[1] = sco_cc[1];
+	t.c_cc[2] = sco_cc[2];
+	t.c_cc[3] = sco_cc[3];
+	t.c_cc[7] = sco_cc[7];
+	t.c_cc[8] = sco_cc[11];
+	t.c_cc[9] = sco_cc[12];
+	t.c_cc[10] = sco_cc[10];
+	t.c_cc[16] = sco_cc[6];
+	if (t.c_lflag & ICANON) {
+		t.c_cc[4] = sco_cc[4];
+		t.c_cc[11] = sco_cc[5];
+	} else {
+		t.c_cc[4] = sco_cc[8];
+		t.c_cc[5] = sco_cc[5];
+		t.c_cc[6] = sco_cc[4];
+		t.c_cc[11] = sco_cc[9];
+	}
+
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(old_fs);
+
+	return (error);
+}
+
+static int
+linux_to_sco_termios(int fd, int op, struct sco_termios *it)
+{
+	struct termios		t;
+	char			sco_cc[SCO_NCCS];
+	mm_segment_t		old_fs;
+	int			error;
+
+	error = verify_area(VERIFY_WRITE, it, sizeof(struct sco_termios));
+	if (error)
+		return (error);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(old_fs);
+	if (error)
+		return (error);
+
+	put_user(t.c_iflag & 0017777, &it->c_iflag);
+
+	put_user(t.c_oflag & 0177777, &it->c_oflag);
+
+	if (t.c_cflag & CRTSCTS)
+		t.c_cflag |= 0100000; /* CRTSFL - SCO only? */
+	put_user(t.c_cflag & 0177777, &it->c_cflag);
+
+	t.c_lflag &= ~0001000;
+	t.c_lflag |= (t.c_lflag & 0000400) << 1;
+	t.c_lflag &= ~0000400;
+	t.c_lflag |= (t.c_lflag & 0100000) >> 7;
+	t.c_lflag &= ~0100000;
+	put_user(t.c_lflag & 0001777, &it->c_lflag);
+
+	put_user(t.c_line, &it->c_line); /* XXX Map this? */
+
+	sco_cc[0] = t.c_cc[0];
+	sco_cc[1] = t.c_cc[1];
+	sco_cc[2] = t.c_cc[2];
+	sco_cc[3] = t.c_cc[3];
+	sco_cc[6] = t.c_cc[16];
+	sco_cc[7] = t.c_cc[7];
+	sco_cc[8] = t.c_cc[4];
+	sco_cc[9] = t.c_cc[11];
+	sco_cc[10] = t.c_cc[10];
+	sco_cc[11] = t.c_cc[8];
+	sco_cc[12] = t.c_cc[9];
+	if (t.c_lflag & ICANON) {
+		sco_cc[4] = t.c_cc[4];
+		sco_cc[5] = t.c_cc[11];
+	} else {
+		sco_cc[4] = t.c_cc[6];
+		sco_cc[5] = t.c_cc[5];
+	}
+
+	copy_to_user(&it->c_cc, sco_cc, SCO_NCCS);
+
+	return (error);
+}
+
+int
+sco_term_ioctl(int fd, unsigned int func, void *arg)
+{
+	switch(func) {
+	case 1:	/* XCGETA */
+		return linux_to_sco_termios(fd, TCGETS, arg);
+	case 2: /* XCSETA */
+		return sco_to_linux_termios(fd, TCSETS, arg);
+	case 3: /* XCSETAW */
+		return sco_to_linux_termios(fd, TCSETSW, arg);
+	case 4: /* XCSETAF */
+		return sco_to_linux_termios(fd, TCSETSF, arg);
+	}
+	printk(KERN_ERR "iBCS: SCO termios ioctl %d unsupported\n", func);
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/sco/vtkbd.c linux-2.6.7-abi/abi/sco/vtkbd.c
--- linux-2.6.7/abi/sco/vtkbd.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/sco/vtkbd.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,88 @@
+/*
+ * This provides internal emulation support for the SCO <sys/vtkd.h> on
+ * the multiscreen console. More or less, this involves translating the
+ * input ioctl()'s into a similar Linux ioctl()'s.
+ *
+ * Not emulated SCO multiscreen functions:
+ *   None.
+ *
+ * Not emulated SCO keyboard functions:
+ *   KIOCDOSMODE		set DOSMODE
+ *   KIOCNONDOSMODE		unset DOSMODE
+ *   KDDISPINFO			get display start and size
+ *   KDGKBSTATE			get state of keyboard shift keys
+ *
+ * Written by Scott Michel, scottm@intime.com
+ * (c) 1994 Scott Michel as part of the Linux iBCS-2 emulator project.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/vt.h>
+#include <linux/kd.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+
+static struct {
+	int	in;		/* only lower 8 bits */
+	int	out;		/* Linux version */
+} trantab[] = {
+#ifdef KDDISPTYPE
+	{ 1,  KDDISPTYPE   },
+#endif
+	{ 2,  KDMAPDISP    },
+	{ 3,  KDUNMAPDISP  },
+	{ 6,  KDGKBMODE    },
+	{ 7,  KDSKBMODE    },
+	{ 8,  KDMKTONE     },
+	{ 9,  KDGETMODE    },
+	{ 10, KDSETMODE    },
+	{ 11, KDADDIO      },
+	{ 12, KDDELIO      },
+	{ 60, KDENABIO     },
+	{ 61, KDDISABIO    },
+#ifdef KIOCINFO
+	{ 62, KIOCINFO     },
+#endif
+	{ 63, KIOCSOUND    },
+	{ 64, KDGKBTYPE    },
+	{ 65, KDGETLED     },
+	{ 66, KDSETLED     },
+};
+
+
+int
+sco_vtkbd_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	u_int			gen = (cmd >> 8) & 0xff;
+	u_int			spec = cmd & 0xff;
+	int			newf, i;
+
+	switch (gen) {
+	case 'V':
+		/*
+		 * Could make this translation process table based, but, why
+		 * waste the valuable kernel space ?
+		 */
+
+		newf = (spec == 1 ? VT_OPENQRY :
+			(spec == 2 ? VT_SETMODE :
+			 (spec == 3 ? VT_GETMODE :
+			  (spec == 4 ? VT_RELDISP :
+			   (spec == 5 ? VT_ACTIVATE : -1)))));
+		if (newf != -1)
+			return sys_ioctl(fd, newf, (long)data);
+		break;
+	case 'K':
+		for (i = 0; i < ARRAY_SIZE(trantab); i++) {
+			if (spec == trantab[i].in)
+				return sys_ioctl(fd, trantab[i].out, (long)data);
+		}
+		/* FALLTHROUGH */
+	}
+	printk(KERN_ERR "%s: vtkd ioctl 0x%02x unsupported\n", __FILE__, cmd);
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/solaris/lfs.c linux-2.6.7-abi/abi/solaris/lfs.c
--- linux-2.6.7/abi/solaris/lfs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/lfs.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,235 @@
+/*
+ * Solaris Large File Summit support
+ */
+
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/stat.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/mman.h>
+#include <linux/net.h>
+#include <linux/socket.h>
+#include <linux/un.h>
+#include <linux/dirent.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/map.h>
+#include <abi/svr4/sysent.h>
+
+
+int
+sol_open64(const char *fname, int flag, int mode)
+{
+	u_long args[3];
+	int error, fd;
+	struct file *file;
+	mm_segment_t old_fs;
+	char *p;
+	struct sockaddr_un addr;
+
+	fd = sys_open(fname, map_flags(flag, fl_svr4_to_linux) | O_LARGEFILE, mode);
+	if (fd < 0)
+		return fd;
+
+	/* Sometimes a program may open a pathname which it expects
+	 * to be a named pipe (or STREAMS named pipe) when the
+	 * Linux domain equivalent is a Unix domain socket. (e.g.
+	 * UnixWare uses a STREAMS named pipe /dev/X/Nserver.0 for
+	 * X :0 but Linux uses a Unix domain socket /tmp/.X11-unix/X0)
+	 * It isn't enough just to make the symlink because you cannot
+	 * open() a socket and read/write it. If we spot the error we can
+	 * switch to socket(), connect() and things will likely work
+	 * as expected however.
+	 */
+	file = fget(fd);
+	if (!file)
+		return fd; /* Huh?!? */
+	if (!S_ISSOCK(file->f_dentry->d_inode->i_mode)) {
+		fput(file);
+		return fd;
+	}
+	fput(file);
+
+	sys_close(fd);
+	args[0] = AF_UNIX;
+	args[1] = SOCK_STREAM;
+	args[2] = 0;
+	old_fs = get_fs();
+	set_fs(get_ds());
+	fd = sys_socketcall(SYS_SOCKET, args);
+	set_fs(old_fs);
+	if (fd < 0)
+		return fd;
+
+	p = getname(fname);
+	if (IS_ERR(p)) {
+		sys_close(fd);
+		return PTR_ERR(p);
+	}
+	if (strlen(p) >= UNIX_PATH_MAX) {
+		putname(p);
+		sys_close(fd);
+		return -E2BIG;
+	}
+	addr.sun_family = AF_UNIX;
+	strcpy(addr.sun_path, p);
+	putname(p);
+
+	args[0] = fd;
+	args[1] = (int)&addr;
+	args[2] = sizeof(struct sockaddr_un);
+	set_fs(get_ds());
+	error = sys_socketcall(SYS_CONNECT, args);
+	set_fs(old_fs);
+	if (error) {
+		sys_close(fd);
+		return error;
+	}
+
+	return fd;
+}
+
+
+struct sol_dirent64 {
+	unsigned long long d_ino;
+	unsigned long long d_off;
+	unsigned short d_reclen;
+	char d_name[1];
+};
+
+
+/* If/when the readdir function is changed to read multiple entries
+ * at once this should be updated to take advantage of the fact.
+ *
+ * N.B. For Linux the reclen in a dirent is the number of characters
+ * in the filename, for SCO (at least) reclen is the total size of
+ * the particular dirent rounded up to the next multiple of 4. The SCO
+ * behaviour is faithfully emulated here.
+ *
+ * XXXX
+ * We don't truncate long filenames at all when copying. If we meet a
+ * long filename and the buffer supplied by the application simply isn't
+ * big enough to hold it we'll return without filling the buffer (i.e
+ * return 0). The application will see this as a (premature) end of
+ * directory. Is there a work around for this at all???
+ */
+int
+sol_getdents64(int fd, char *buf, int nbytes)
+{
+	int error, here, posn, reclen;
+	struct file *file;
+	struct old_linux_dirent *d;
+	mm_segment_t old_fs;
+
+	error = verify_area(VERIFY_WRITE, buf, nbytes);
+	if (error)
+		return error;
+
+	/* Check the file handle here. This is so we can access the current
+	 * position in the file structure safely without a tedious call
+	 * to sys_lseek that does nothing useful.
+	 */
+	file = fget(fd);
+	if (!file)
+		return -EBADF;
+
+	d = (struct old_linux_dirent *)__get_free_page(GFP_KERNEL);
+	if (!d) {
+		fput(file);
+		return -ENOMEM;
+	}
+
+	error = posn = reclen = 0;
+	while (posn + reclen < nbytes) {
+                int string_size;
+		struct sol_dirent64 tmpbuf;
+		/* Save the current position and get another dirent */
+		here = file->f_pos;
+		old_fs = get_fs();
+		set_fs (get_ds());
+		error = old_readdir(fd, d, 1);
+		set_fs(old_fs);
+		if (error <= 0)
+			break;
+
+		/* If it'll fit in the buffer save it.
+		 * Otherwise back up so it is read next time around.
+		 * Oh, if we're at the beginning of the buffer there's
+		 * no chance that this entry will ever fit so don't
+		 * copy it and don't back off - we'll just pretend it
+		 * isn't here...
+		 */
+		string_size = d->d_namlen + 1; /* chars in d_name + trailing zero */
+		reclen = (sizeof(long long) /* d_ino */
+			+ sizeof(long long) /* d_offset */
+			+ sizeof(unsigned short) /* d_namlen */
+			+ string_size
+			+ 3) & (~3); /* align to a 4 byte boundary */
+		if (posn + reclen <= nbytes) {
+			tmpbuf.d_off = file->f_pos;
+			tmpbuf.d_ino = d->d_ino;
+			tmpbuf.d_off = file->f_pos;
+			tmpbuf.d_reclen = reclen;
+			copy_to_user(buf+posn, &tmpbuf, 
+				     sizeof(struct sol_dirent64) -1);
+		        copy_to_user(buf+posn+sizeof(struct sol_dirent64)-2,
+				     &d->d_name, string_size);
+			posn += reclen;
+		} else if (posn) {
+			sys_lseek(fd, here, 0);
+		} /* else posn == 0 */
+	}
+
+	/* Loose the intermediate buffer. */
+	free_page((unsigned long)d);
+
+	fput(file);
+
+	/* If we've put something in the buffer return the byte count
+	 * otherwise return the error status.
+	 */
+	return ((posn > 0) ? posn : error);
+}
+
+
+int
+sol_mmap64(u_int addr, u_int len, int prot, int flags,
+           int fd, u_int off_hi, u_int off)
+{
+	loff_t			off64 = (off | ((loff_t)off_hi << 32));
+	u_long			pgoff = (off64 >> PAGE_SHIFT);
+	struct file		*file = NULL;
+	int			error;
+
+	if ((off64 + PAGE_ALIGN(len)) < off64)
+		return -EINVAL;
+
+	if (!(off64 & ~PAGE_MASK))
+		return -EINVAL;
+
+	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+	if (!(flags & MAP_ANONYMOUS)) {
+		if (!(file = fget(fd)))
+			return -EBADF;
+	}
+
+	if (!(flags & 0x80000000) && addr)
+		flags |= MAP_FIXED;
+	else
+		flags &= 0x7fffffff;
+
+	down_write(&current->mm->mmap_sem);
+	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
+	up_write(&current->mm->mmap_sem);
+
+	if (file)
+		fput(file);
+	return (error);
+}
diff -Nru linux-2.6.7/abi/solaris/Makefile linux-2.6.7-abi/abi/solaris/Makefile
--- linux-2.6.7/abi/solaris/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-solaris-objs:= lfs.o solarisx86.o socket.o stat.o sysent.o
+
+obj-$(CONFIG_ABI_SOLARIS)	+= abi-solaris.o
+
+abi-solaris.o: $(abi-solaris-objs)
+	$(LD) -r -o $@ $(abi-solaris-objs)
diff -Nru linux-2.6.7/abi/solaris/socket.c linux-2.6.7-abi/abi/solaris/socket.c
--- linux-2.6.7/abi/solaris/socket.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/socket.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,496 @@
+/*
+ * socket.c: Socket syscall emulation for Solaris 2.6+
+ *
+ * Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)
+ *
+ * 1999-08-19 Fixed socketpair code 
+ *            Jason Rappleye (rappleye@ccr.buffalo.edu)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/net.h>
+#include <linux/socket.h>
+#include <linux/file.h>
+#include <linux/syscalls.h>
+
+#include <asm/uaccess.h>
+#include <asm/string.h>
+
+#define SOCK_SOL_STREAM		2
+#define SOCK_SOL_DGRAM		1
+#define SOCK_SOL_RAW		4
+#define SOCK_SOL_RDM		5
+#define SOCK_SOL_SEQPACKET	6
+
+#define SOL_SO_SNDLOWAT		0x1003
+#define SOL_SO_RCVLOWAT		0x1004
+#define SOL_SO_SNDTIMEO		0x1005
+#define SOL_SO_RCVTIMEO		0x1006
+#define SOL_SO_STATE		0x2000
+
+#define SOL_SS_NDELAY		0x040
+#define SOL_SS_NONBLOCK		0x080
+#define SOL_SS_ASYNC		0x100
+
+#define SO_STATE		0x000e
+
+
+/*
+ * 64 bit vs 32bit issues.
+ */
+#if BITS_PER_LONG == 32
+#  define sys32_getsockopt	sys_getsockopt
+#  define A(ptr)		((void *)(ptr))
+#  define __kernel_size_t32	__kernel_size_t
+#endif
+
+
+int sunos_setsockopt(int fd, int level, int optname, u32 optval,
+				int optlen)
+{
+	int tr_opt = optname;
+	int ret;
+
+	if (level == SOL_IP) {
+		/* Multicast socketopts (ttl, membership) */
+		if (tr_opt >=2 && tr_opt <= 6)
+			tr_opt += 30;
+	}
+	ret = sys_setsockopt(fd, level, tr_opt, (char *)A(optval), optlen);
+	return ret;
+}
+
+int sunos_getsockopt(int fd, int level, int optname,
+				u32 optval, u32 optlen)
+{
+	int tr_opt = optname;
+	int ret;
+
+	if (level == SOL_IP) {
+		/* Multicast socketopts (ttl, membership) */
+		if (tr_opt >=2 && tr_opt <= 6)
+			tr_opt += 30;
+	}
+	ret = sys32_getsockopt(fd, level, tr_opt, (char *)optval, (int *)optlen);
+	return ret;
+}
+
+static int socket_check(int family, int type)
+{
+	if (family != PF_UNIX && family != PF_INET)
+		return -ESOCKTNOSUPPORT;
+	switch (type) {
+	case SOCK_SOL_STREAM:
+		type = SOCK_STREAM;
+		break;
+	case SOCK_SOL_DGRAM:
+		type = SOCK_DGRAM;
+		break;
+	case SOCK_SOL_RAW:
+		type = SOCK_RAW;
+		break;
+	case SOCK_SOL_RDM:
+		type = SOCK_RDM;
+		break;
+	case SOCK_SOL_SEQPACKET:
+		type = SOCK_SEQPACKET;
+		break;
+	default:
+		return -EINVAL;
+	}
+	return type;
+}
+
+static int solaris_to_linux_sockopt(int optname) 
+{
+	switch (optname) {
+	case SOL_SO_SNDLOWAT:
+		optname = SO_SNDLOWAT;
+		break;
+	case SOL_SO_RCVLOWAT:
+		optname = SO_RCVLOWAT;
+		break;
+	case SOL_SO_SNDTIMEO:
+		optname = SO_SNDTIMEO;
+		break;
+	case SOL_SO_RCVTIMEO:
+		optname = SO_RCVTIMEO;
+		break;
+	case SOL_SO_STATE:
+		optname = SO_STATE;
+		break;
+	};
+	
+	return optname;
+}
+	
+int solaris_socket(int family, int type, int protocol)
+{
+	type = socket_check (family, type);
+	if (type < 0)
+		return type;
+	return sys_socket(family, type, protocol);
+}
+
+int solaris_socketpair(int *usockvec)
+{
+	/* solaris socketpair really only takes one arg at the syscall
+	 * level, int * usockvec. The libs apparently take care of 
+	 * making sure that family==AF_UNIX and type==SOCK_STREAM. The 
+	 * pointer we really want ends up residing in the first (and
+	 * supposedly only) argument.
+	 */
+
+	return sys_socketpair(AF_UNIX, SOCK_STREAM, 0, (int *)usockvec);
+}
+
+int solaris_bind(int fd, struct sockaddr *addr, int addrlen)
+{
+	return sys_bind(fd, addr, addrlen);
+}
+
+int solaris_setsockopt(int fd, int level, int optname, u32 optval, int optlen)
+{
+	optname = solaris_to_linux_sockopt(optname);
+	if (optname < 0)
+		return optname;
+	if (optname == SO_STATE)
+		return 0;
+
+	return sunos_setsockopt(fd, level, optname, optval, optlen);
+}
+
+int solaris_getsockopt(int fd, int level, int optname, u32 optval, u32 optlen)
+{
+	optname = solaris_to_linux_sockopt(optname);
+	if (optname < 0)
+		return optname;
+
+	if (optname == SO_STATE)
+		optname = SOL_SO_STATE;
+
+	return sunos_getsockopt(fd, level, optname, optval, optlen);
+}
+
+int solaris_connect(int fd, struct sockaddr *addr, int addrlen)
+{
+	return sys_connect(fd, addr, addrlen);
+}
+
+int solaris_accept(int fd, struct sockaddr *addr, int *addrlen)
+{
+	return sys_accept(fd, addr, addrlen);
+}
+
+int solaris_listen(int fd, int backlog)
+{
+	return sys_listen(fd, backlog);
+}
+
+int solaris_shutdown(int fd, int how)
+{
+	return sys_shutdown(fd, how);
+}
+
+#define MSG_SOL_OOB		0x1
+#define MSG_SOL_PEEK		0x2
+#define MSG_SOL_DONTROUTE	0x4
+#define MSG_SOL_EOR		0x8
+#define MSG_SOL_CTRUNC		0x10
+#define MSG_SOL_TRUNC		0x20
+#define MSG_SOL_WAITALL		0x40
+#define MSG_SOL_DONTWAIT	0x80
+
+static int solaris_to_linux_msgflags(int flags)
+{
+	int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
+	
+	if (flags & MSG_SOL_EOR) fl |= MSG_EOR;
+	if (flags & MSG_SOL_CTRUNC) fl |= MSG_CTRUNC;
+	if (flags & MSG_SOL_TRUNC) fl |= MSG_TRUNC;
+	if (flags & MSG_SOL_WAITALL) fl |= MSG_WAITALL;
+	if (flags & MSG_SOL_DONTWAIT) fl |= MSG_DONTWAIT;
+	return fl;
+}
+
+static int linux_to_solaris_msgflags(int flags)
+{
+	int fl = flags & (MSG_OOB|MSG_PEEK|MSG_DONTROUTE);
+	
+	if (flags & MSG_EOR) fl |= MSG_SOL_EOR;
+	if (flags & MSG_CTRUNC) fl |= MSG_SOL_CTRUNC;
+	if (flags & MSG_TRUNC) fl |= MSG_SOL_TRUNC;
+	if (flags & MSG_WAITALL) fl |= MSG_SOL_WAITALL;
+	if (flags & MSG_DONTWAIT) fl |= MSG_SOL_DONTWAIT;
+	return fl;
+}
+
+int solaris_recvfrom(int s, char *buf, int len, int flags, u32 from, u32 fromlen)
+{
+	return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(from), (int *)A(fromlen));
+}
+
+int solaris_recv(int s, char *buf, int len, int flags)
+{
+	return sys_recvfrom(s, buf, len, solaris_to_linux_msgflags(flags), NULL, NULL);
+}
+
+int solaris_sendto(int s, char *buf, int len, int flags, u32 to, u32 tolen)
+{
+	return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), (struct sockaddr *)A(to), (int)A(tolen));
+}
+
+int solaris_send(int s, char *buf, int len, int flags)
+{
+	return sys_sendto(s, buf, len, solaris_to_linux_msgflags(flags), NULL, 0);
+}
+
+int solaris_getpeername(int fd, struct sockaddr *addr, int *addrlen)
+{
+	return sys_getpeername(fd, addr, addrlen);
+}
+
+int solaris_getsockname(int fd, struct sockaddr *addr, int *addrlen)
+{
+	return sys_getsockname(fd, addr, addrlen);
+}
+
+/* XXX This really belongs in some header file... -DaveM */
+#define MAX_SOCK_ADDR	128		/* 108 for Unix domain - 
+					   16 for IP, 16 for IPX,
+					   24 for IPv6,
+					   about 80 for AX.25 */
+
+struct sol_nmsghdr {
+	u32		msg_name;
+	int		msg_namelen;
+	u32		msg_iov;
+	u32		msg_iovlen;
+	u32		msg_control;
+	u32		msg_controllen;
+	u32		msg_flags;
+};
+
+struct sol_cmsghdr {
+	u32		cmsg_len;
+	int		cmsg_level;
+	int		cmsg_type;
+	unsigned char	cmsg_data[0];
+};
+
+struct iovec32 {
+	u32		iov_base;
+	u32 iov_len;
+};
+
+static inline int iov_from_user32_to_kern(struct iovec *kiov,
+					  struct iovec32 *uiov32,
+					  int niov)
+{
+	int tot_len = 0;
+
+	while(niov > 0) {
+		u32 len, buf;
+
+		if(get_user(len, &uiov32->iov_len) ||
+		   get_user(buf, &uiov32->iov_base)) {
+			tot_len = -EFAULT;
+			break;
+		}
+		tot_len += len;
+		kiov->iov_base = (void *)A(buf);
+		kiov->iov_len = (__kernel_size_t) len;
+		uiov32++;
+		kiov++;
+		niov--;
+	}
+	return tot_len;
+}
+
+static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg,
+					     struct sol_nmsghdr *umsg)
+{
+	u32 tmp1, tmp2, tmp3;
+	int err;
+
+	err = get_user(tmp1, &umsg->msg_name);
+	err |= __get_user(tmp2, &umsg->msg_iov);
+	err |= __get_user(tmp3, &umsg->msg_control);
+	if (err)
+		return -EFAULT;
+
+	kmsg->msg_name = (void *)A(tmp1);
+	kmsg->msg_iov = (struct iovec *)A(tmp2);
+	kmsg->msg_control = (void *)A(tmp3);
+
+	err = get_user(kmsg->msg_namelen, &umsg->msg_namelen);
+	err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen);
+	err |= get_user(kmsg->msg_flags, &umsg->msg_flags);
+	
+	kmsg->msg_flags = solaris_to_linux_msgflags(kmsg->msg_flags);
+	
+	return err;
+}
+
+/* I've named the args so it is easy to tell whose space the pointers are in. */
+static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov,
+			  char *kern_address, int mode)
+{
+	int tot_len;
+
+	if(kern_msg->msg_namelen) {
+		if(mode==VERIFY_READ) {
+			int err = move_addr_to_kernel(kern_msg->msg_name,
+						      kern_msg->msg_namelen,
+						      kern_address);
+			if(err < 0)
+				return err;
+		}
+		kern_msg->msg_name = kern_address;
+	} else
+		kern_msg->msg_name = NULL;
+
+	if(kern_msg->msg_iovlen > UIO_FASTIOV) {
+		kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
+				   GFP_KERNEL);
+		if(!kern_iov)
+			return -ENOMEM;
+	}
+
+	tot_len = iov_from_user32_to_kern(kern_iov,
+					  (struct iovec32 *)kern_msg->msg_iov,
+					  kern_msg->msg_iovlen);
+	if(tot_len >= 0)
+		kern_msg->msg_iov = kern_iov;
+	else if(kern_msg->msg_iovlen > UIO_FASTIOV)
+		kfree(kern_iov);
+
+	return tot_len;
+}
+
+int solaris_sendmsg(int fd, struct sol_nmsghdr *user_msg, unsigned user_flags)
+{
+	struct socket *sock;
+	char address[MAX_SOCK_ADDR];
+	struct iovec iov[UIO_FASTIOV];
+	unsigned char ctl[sizeof(struct cmsghdr) + 20];
+	unsigned char *ctl_buf = ctl;
+	struct msghdr kern_msg;
+	int err, total_len;
+
+	if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
+		return -EFAULT;
+	if(kern_msg.msg_iovlen > UIO_MAXIOV)
+		return -EINVAL;
+	err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ);
+	if (err < 0)
+		goto out;
+	total_len = err;
+
+	if(kern_msg.msg_controllen) {
+		struct sol_cmsghdr *ucmsg = (struct sol_cmsghdr *)kern_msg.msg_control;
+		unsigned long *kcmsg;
+		__kernel_size_t32 cmlen;
+
+		if(kern_msg.msg_controllen > sizeof(ctl) &&
+		   kern_msg.msg_controllen <= 256) {
+			err = -ENOBUFS;
+			ctl_buf = kmalloc(kern_msg.msg_controllen, GFP_KERNEL);
+			if(!ctl_buf)
+				goto out_freeiov;
+		}
+		__get_user(cmlen, &ucmsg->cmsg_len);
+		kcmsg = (unsigned long *) ctl_buf;
+		*kcmsg++ = (unsigned long)cmlen;
+		err = -EFAULT;
+		if(copy_from_user(kcmsg, &ucmsg->cmsg_level,
+				  kern_msg.msg_controllen - sizeof(__kernel_size_t32)))
+			goto out_freectl;
+		kern_msg.msg_control = ctl_buf;
+	}
+	kern_msg.msg_flags = solaris_to_linux_msgflags(user_flags);
+
+	lock_kernel();
+	sock = sockfd_lookup(fd, &err);
+	if (sock != NULL) {
+		if (sock->file->f_flags & O_NONBLOCK)
+			kern_msg.msg_flags |= MSG_DONTWAIT;
+		err = sock_sendmsg(sock, &kern_msg, total_len);
+		sockfd_put(sock);
+	}
+	unlock_kernel();
+
+out_freectl:
+	/* N.B. Use kfree here, as kern_msg.msg_controllen might change? */
+	if(ctl_buf != ctl)
+		kfree(ctl_buf);
+out_freeiov:
+	if(kern_msg.msg_iov != iov)
+		kfree(kern_msg.msg_iov);
+out:
+	return err;
+}
+
+int solaris_recvmsg(int fd, struct sol_nmsghdr *user_msg, unsigned user_flags)
+{
+	struct iovec iovstack[UIO_FASTIOV];
+	struct msghdr kern_msg;
+	char addr[MAX_SOCK_ADDR];
+	struct socket *sock;
+	struct iovec *iov = iovstack;
+	struct sockaddr *uaddr;
+	int *uaddr_len;
+	unsigned long cmsg_ptr;
+	int err, total_len, len = 0;
+
+	if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
+		return -EFAULT;
+	if(kern_msg.msg_iovlen > UIO_MAXIOV)
+		return -EINVAL;
+
+	uaddr = kern_msg.msg_name;
+	uaddr_len = &user_msg->msg_namelen;
+	err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE);
+	if (err < 0)
+		goto out;
+	total_len = err;
+
+	cmsg_ptr = (unsigned long) kern_msg.msg_control;
+	kern_msg.msg_flags = 0;
+
+	lock_kernel();
+	sock = sockfd_lookup(fd, &err);
+	if (sock != NULL) {
+		if (sock->file->f_flags & O_NONBLOCK)
+			user_flags |= MSG_DONTWAIT;
+		err = sock_recvmsg(sock, &kern_msg, total_len, user_flags);
+		if(err >= 0)
+			len = err;
+		sockfd_put(sock);
+	}
+	unlock_kernel();
+
+	if(uaddr != NULL && err >= 0)
+		err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len);
+	if(err >= 0) {
+		err = __put_user(linux_to_solaris_msgflags(kern_msg.msg_flags), &user_msg->msg_flags);
+		if(!err) {
+			/* XXX Convert cmsg back into userspace 32-bit format... */
+			err = __put_user((unsigned long)kern_msg.msg_control - cmsg_ptr,
+					 &user_msg->msg_controllen);
+		}
+	}
+
+	if(kern_msg.msg_iov != iov)
+		kfree(kern_msg.msg_iov);
+out:
+	if(err < 0)
+		return err;
+	return len;
+}
diff -Nru linux-2.6.7/abi/solaris/solarisx86.c linux-2.6.7-abi/abi/solaris/solarisx86.c
--- linux-2.6.7/abi/solaris/solarisx86.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/solarisx86.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,84 @@
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/socket.h>
+#include <linux/file.h>
+#include <linux/mm.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sigset.h>
+
+
+int sol_llseek(struct pt_regs * regs) 
+{
+	unsigned int fd;
+	unsigned long offset_high, offset_low;
+	unsigned origin;
+	long long res;
+	unsigned int rvalue;
+	mm_segment_t old_fs;
+	struct inode *inode;
+	struct file *file;
+	get_user(fd, ((unsigned int *)regs->esp)+1);
+	get_user(offset_low, ((unsigned long *)regs->esp)+2);
+	get_user(offset_high, ((unsigned long *)regs->esp)+3);
+	get_user(origin, ((unsigned int *)regs->esp)+4);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	rvalue = sys_llseek(fd,offset_high,offset_low,&res,origin);
+	set_fs(old_fs);
+
+	if ( rvalue < -ENOIOCTLCMD) {
+		regs->edx = (res >> 32);
+		rvalue = (res & 0xffffffff);
+	}
+	else if (rvalue == -ESPIPE) {
+		/* Solaris allows you to seek on a pipe */
+		file = fget(fd);
+		if (file) {
+			inode = file->f_dentry->d_inode;
+			if (inode && (S_ISCHR(inode->i_mode) 
+				      || S_ISBLK(inode->i_mode))) {
+				rvalue = 0;
+				regs->edx = 0;
+			}
+			fput(file);
+		}
+	}
+
+	return rvalue;
+}
+
+int sol_memcntl(unsigned addr, unsigned len, int cmd, unsigned arg, 
+		 int attr, int mask) 
+{
+	//	printk("ibcs_memcntl being ignored\n");
+	return 0; 
+}
+
+
+enum {
+	GETACL = 1,
+	SETACL = 2,
+	GETACLCNT = 3
+};
+
+int sol_acl(char *pathp, int cmd, int nentries, void *aclbufp)
+{
+	switch (cmd) {
+	case GETACLCNT:
+		return 0;
+		
+	case GETACL:
+		return -EIO;
+
+	case SETACL:
+		return -EPERM;
+		
+	default:
+		return -EINVAL;
+	}
+}
diff -Nru linux-2.6.7/abi/solaris/stat.c linux-2.6.7-abi/abi/solaris/stat.c
--- linux-2.6.7/abi/solaris/stat.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/stat.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * aint32_t with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Solaris 2 stat64 & friends support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <asm/uaccess.h>
+
+#include <abi/solaris/types.h>
+#include <abi/solaris/stat.h>
+
+#include <abi/util/trace.h>
+#include <abi/util/stat.h>
+
+
+int
+report_sol_stat64(struct kstat *stp, struct sol_stat64 *bufp)
+{
+	struct sol_stat64 buf;
+
+	memset(&buf, 0, sizeof(struct sol_stat64));
+
+
+	buf.st_dev	= linux_to_sol_dev_t(stp->dev);
+	buf.st_ino	= linux_to_sol_ino_t(stp->ino);
+	buf.st_mode	= stp->mode;
+	buf.st_nlink	= stp->nlink;
+	buf.st_uid	= linux_to_sol_uid_t(stp->uid);
+	buf.st_gid	= linux_to_sol_gid_t(stp->gid);
+	buf.st_rdev	= linux_to_sol_dev_t(stp->rdev);
+	buf.st_size	= stp->size;
+	
+	buf.st_atime	= stp->atime.tv_sec;
+	buf.st_mtime	= stp->mtime.tv_sec;
+	buf.st_ctime	= stp->ctime.tv_sec;
+	
+	buf.st_blksize	= stp->blksize;
+	buf.st_blocks	= stp->blocks;
+
+	strcpy(buf.st_fstype, "ext2");
+
+	if (copy_to_user(bufp, &buf, sizeof(struct sol_stat64)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+sol_stat64(char *filename, struct sol_stat64 *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_stat(filename, &st);
+	if (!error)
+		error = report_sol_stat64(&st, bufp);
+	return error;
+}
+
+int
+sol_lstat64(char *filename, struct sol_stat64 *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_lstat(filename, &st);
+	if (!error)
+		error = report_sol_stat64(&st, bufp);
+	return error;
+}
+
+int
+sol_fstat64(int fd, struct sol_stat64 *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_fstat(fd, &st);
+	if (!error)
+		error = report_sol_stat64(&st, bufp);
+	return error;
+}
diff -Nru linux-2.6.7/abi/solaris/sysent.c linux-2.6.7-abi/abi/solaris/sysent.c
--- linux-2.6.7/abi/solaris/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/solaris/sysent.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Solaris sysent and error tables.
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/signal.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/solaris/sysent.h>
+#include <abi/util/socket.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+
+/* kernel module specifications */
+#ifndef EXPORT_NO_SYMBOLS                                                       
+#define EXPORT_NO_SYMBOLS                                                       
+#endif
+
+MODULE_DESCRIPTION("Solaris personality");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+EXPORT_NO_SYMBOLS;
+
+
+/* XXX kill this one */
+#define ITR(trace, name, args)  ,name,args
+
+
+/*
+ * We could remove some of the long identity mapped runs but at the
+ * expense of extra comparisons for each mapping at run time...
+ */
+static u_char solaris_err_table[] = {
+/*   0 -   9 */   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+/*  10 -  19 */  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+/*  20 -  29 */  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+/*  30 -  39 */  30,  31,  32,  33,  34,  45,  78,  46,  89,  93,
+/*  40 -  49 */  90,  90,  35,  36,  37,  38,  39,  40,  41,  42,
+/*  50 -  59 */  43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+/*  60 -  69 */  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+/*  70 -  79 */  70,  71,  74,  76,  77,  79,  80,  81,  82,  83,
+/*  80 -  89 */  84,  85,  86,  87,  88,  91,  92,  94,  95,  96,
+/*  90 -  99 */  97,  98,  99, 120, 121, 122, 123, 124, 125, 126,
+/* 100 - 109 */ 127, 128, 129, 130, 131, 132, 133, 134, 143, 144,
+/* 110 - 119 */ 145, 146, 147, 148, 149, 150,  22, 135, 137, 138,
+/* 120 - 122 */ 139, 140,  28
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+/* 512 - 514 */ EINTR, EINTR, EINTR
+};
+
+struct map_segment solaris_err_map[] = {
+	{ 0,	0+sizeof(solaris_err_table)-1,	solaris_err_table },
+	{ 512,  512+sizeof(lnx_err_table)-1,	lnx_err_table },
+	{ -1 }
+};
+
+static long linux_to_solaris_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,    IBCS_SIGINT,    IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,   IBCS_SIGABRT,   -1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,   IBCS_SIGUSR1,   IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,   IBCS_SIGALRM,   IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,   IBCS_SIGCONT,   IBCS_SIGSTOP,
+/* 20 - 23 */	IBCS_SIGTSTP,	IBCS_SIGTTIN,   IBCS_SIGTTOU,   IBCS_SIGURG,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,  IBCS_SIGVTALRM, IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	IBCS_SIGIO,     IBCS_SIGPWR,    -1,
+/*	32 */	-1
+};
+
+static long solaris_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,         SIGINT,         SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,        SIGIOT,         SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,        SIGUNUSED,      SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,        SIGALRM,        SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,        SIGCHLD,        SIGPWR,
+/* 20 - 23 */	SIGWINCH,	SIGURG,         SIGPOLL,        SIGSTOP,
+/* 24 - 27 */	SIGTSTP,	SIGCONT,        SIGTTIN,        SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,        SIGXCPU,        SIGXFSZ,
+/*	32 */	-1
+};
+
+static char solaris_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment solaris_socktype_map[] = {
+	{ 1, 6, solaris_socktype },
+	{ -1 }
+};
+
+static struct map_segment solaris_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+static struct map_segment solaris_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent solaris_syscall_table[] = {
+   { abi_syscall,	Fast	ITR(0, "syscall",	"")	}, /*    0 */
+   { sys_exit,		1	ITR(0, "exit",		"d")	}, /*    1 */
+   { abi_fork,		Spl	ITR(0, "fork",		"")	}, /*    2 */
+   { abi_read,		3	ITR(0, "read",		"dpd")	}, /*    3 */
+   { sys_write,		3	ITR(0, "write",		"dpd")	}, /*    4 */
+   { svr4_open,		3	ITR(0, "open",		"soo")	}, /*    5 */
+   { sys_close,		1	ITR(0, "close",		"d")	}, /*    6 */
+   { abi_wait,		Spl	ITR(0, "wait",		"xxx")	}, /*    7 */
+   { sys_creat,		2	ITR(0, "creat",		"so")	}, /*    8 */
+   { sys_link,		2	ITR(0, "link",		"ss")	}, /*    9 */
+   { sys_unlink,	1	ITR(0, "unlink",	"s")	}, /*   10 */
+   { abi_exec,		Spl	ITR(0, "exec",		"sxx")	}, /*   11 */
+   { sys_chdir,		1	ITR(0, "chdir",		"s")	}, /*   12 */
+   { abi_time,		0	ITR(0, "time",		"")	}, /*   13 */
+   { svr4_mknod,	3	ITR(0, "mknod",		"soo")	}, /*   14 */
+   { sys_chmod,		2	ITR(0, "chmod",		"so")	}, /*   15 */
+   { sys_chown,		3	ITR(0, "chown",		"sdd")	}, /*   16 */
+   { abi_brk,		1	ITR(0, "brk/break",	"x")	}, /*   17 */
+   { svr4_stat,		2	ITR(0, "stat",		"sp")	}, /*   18 */
+   { sys_lseek,		3	ITR(0, "seek/lseek",	"ddd")	}, /*   19 */
+   { abi_getpid,	Spl	ITR(0, "getpid",	"")	}, /*   20 */
+   { 0,			Ukn	ITR(1, "mount",		"")	}, /*   21 */
+   { sys_umount,	1	ITR(0, "umount",	"s")	}, /*   22 */
+   { sys_setuid,	1	ITR(0, "setuid",	"d")	}, /*   23 */
+   { abi_getuid,	Spl	ITR(0, "getuid",	"")	}, /*   24 */
+   { sys_stime,		1	ITR(0, "stime",		"d")	}, /*   25 */
+   { 0,			Ukn	ITR(0, "ptrace",	"")	}, /*   26 */
+   { sys_alarm,		1	ITR(0, "alarm",		"d")	}, /*   27 */
+   { svr4_fstat,	2	ITR(0, "fstat",		"dp")	}, /*   28 */
+   { sys_pause,		0	ITR(0, "pause",		"")	}, /*   29 */
+   { sys_utime,		2	ITR(0, "utime",		"xx")	}, /*   30 */
+   { 0,			Ukn	ITR(0, "stty",		"")	}, /*   31 */
+   { 0,			Ukn	ITR(1, "gtty",		"")	}, /*   32 */
+   { sys_access,	2	ITR(0, "access",	"so")	}, /*   33 */
+   { sys_nice,		1	ITR(0, "nice",		"d")	}, /*   34 */
+   { svr4_statfs,	4	ITR(0, "statfs",	"spdd")	}, /*   35 */
+   { sys_sync,		0	ITR(0, "sync",		"")	}, /*   36 */
+   { abi_kill,		2	ITR(0, "kill",		"dd")	}, /*   37 */
+   { svr4_fstatfs,	4	ITR(0, "fstatfs",	"dpdd")	}, /*   38 */
+   { abi_procids,	Spl	ITR(0, "procids",	"d")	}, /*   39 */
+   { 0,			Ukn	ITR(0, "cxenix",	"")	}, /*   40 */
+   { sys_dup,		1	ITR(0, "dup",		"d")	}, /*   41 */
+   { abi_pipe,		Spl	ITR(0, "pipe",		"")	}, /*   42 */
+   { sys_times,		1	ITR(0, "times",		"p")	}, /*   43 */
+   { 0,			0	ITR(0, "prof",		"")	}, /*   44 */
+   { 0,			Ukn	ITR(1, "lock/plock",	"")	}, /*   45 */
+   { sys_setgid,	1	ITR(0, "setgid",	"d")	}, /*   46 */
+   { abi_getgid,	Spl	ITR(0, "getgid",	"")	}, /*   47 */
+   { abi_sigfunc,	Fast	ITR(0, "sigfunc",	"xxx")	}, /*   48 */
+   { svr4_msgsys,	Spl	ITR(0, "msgsys",	"dxddd")}, /*   49 */
+   { svr4_sysi86,	3	ITR(0, "sysi86/sys3b",	"d")	}, /*   50 */
+   { sys_acct,		1	ITR(0, "acct/sysacct",	"x")	}, /*   51 */
+   { svr4_shmsys,	Fast	ITR(0, "shmsys",	"ddxo")}, /*   52 */
+   { svr4_semsys,	Spl	ITR(0, "semsys",	"dddx")}, /*   53 */
+   { svr4_ioctl,	Spl	ITR(0, "ioctl",		"dxx")	}, /*   54 */
+   { 0,			3	ITR(0, "uadmin",	"xxx")	}, /*   55 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   56 */
+   { v7_utsname,	1	ITR(0, "utsys",		"x")	}, /*   57 */
+   { sys_fsync,		1	ITR(0, "fsync",		"d")	}, /*   58 */
+   { abi_exec,		Spl	ITR(0, "execv",		"spp")	}, /*   59 */
+   { sys_umask,		1	ITR(0, "umask",		"o")	}, /*   60 */
+   { sys_chroot,	1	ITR(0, "chroot",	"s")	}, /*   61 */
+   { svr4_fcntl,	3	ITR(0, "fcntl",		"dxx")	}, /*   62 */
+   { svr4_ulimit,	2	ITR(0, "ulimit",	"xx")	}, /*   63 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   64 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   65 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   66 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   67 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   68 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   69 */
+   { 0,			Ukn	ITR(1, "advfs",		"")	}, /*   70 */
+   { 0,			Ukn	ITR(1, "unadvfs",	"")	}, /*   71 */
+   { 0,			Ukn	ITR(1, "rmount",	"")	}, /*   72 */
+   { 0,			Ukn	ITR(1, "rumount",	"")	}, /*   73 */
+   { 0,			Ukn	ITR(1, "rfstart",	"")	}, /*   74 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*   75 */
+   { 0,			Ukn	ITR(1, "rdebug",	"")	}, /*   76 */
+   { 0,			Ukn	ITR(1, "rfstop",	"")	}, /*   77 */
+   { 0,			Ukn	ITR(1, "rfsys",		"")	}, /*   78 */
+   { sys_rmdir,		1	ITR(0, "rmdir",		"s")	}, /*   79 */
+   { abi_mkdir,		2	ITR(0, "mkdir",		"so")	}, /*   80 */
+   { svr4_getdents,	3	ITR(0, "getdents",	"dxd")	}, /*   81 */
+   { 0,			Ukn	ITR(1, "libattach",	"")	}, /*   82 */
+   { 0,			Ukn	ITR(1, "libdetach",	"")	}, /*   83 */
+   { svr4_sysfs,	3	ITR(0, "sysfs",		"dxx")	}, /*   84 */
+   { svr4_getmsg,	Spl	ITR(0, "getmsg",	"dxxx")	}, /*   85 */
+   { svr4_putmsg,	Spl	ITR(0, "putmsg",	"dxxd")	}, /*   86 */
+   { sys_poll,		3	ITR(0, "poll",		"xdd")	}, /*   87 */
+   { svr4_lstat,	2	ITR(0, "lstat",		"sp")	}, /*   88 */
+   { sys_symlink,	2	ITR(0, "symlink",	"ss")	}, /*   89 */
+   { sys_readlink,	3	ITR(0, "readlink",	"spd")	}, /*   90 */
+   { sys_setgroups,	2	ITR(0, "setgroups",	"dp")	}, /*   91 */
+   { sys_getgroups,	2	ITR(0, "getgroups",	"dp")	}, /*   92 */
+   { sys_fchmod,	2	ITR(0, "fchmod",	"do")	}, /*   93 */
+   { sys_fchown,	3	ITR(0, "fchown",	"ddd")	}, /*   94 */
+   { abi_sigprocmask,	3	ITR(0, "sigprocmask",	"dxx")	}, /*   95 */
+   { abi_sigsuspend,	Spl	ITR(0, "sigsuspend",	"x")	}, /*   96 */
+   { 0,			2	ITR(1, "sigaltstack",	"xx")	}, /*   97 */
+   { abi_sigaction,	3	ITR(0, "sigaction",	"dxx")	}, /*   98 */
+   { svr4_sigpending,	2	ITR(1, "sigpending",	"dp")	}, /*   99 */
+   { svr4_context,	Spl	ITR(0, "context",	"")	}, /*   100 */
+   { 0,			Ukn	ITR(1, "evsys",		"")	}, /*   101 */
+   { 0,			Ukn	ITR(1, "evtrapret",	"")	}, /*   102 */
+   { svr4_statvfs,	2	ITR(0, "statvfs",	"sp")	}, /*   103 */
+   { svr4_fstatvfs,	2	ITR(0, "fstatvfs",	"dp")	}, /*   104 */
+   { 0,			Ukn	ITR(0, "sysisc",	"")	}, /*   105 */
+   { 0,			Ukn	ITR(1, "nfssys",	"")	}, /*   106 */
+   { 0,			4	ITR(0, "waitid",	"ddxd")	}, /*   107 */
+   { 0,			3	ITR(1, "sigsendsys",	"ddd")	}, /*   108 */
+   { svr4_hrtsys,	Spl	ITR(0, "hrtsys",	"xxx")	}, /*   109 */
+   { 0,			3	ITR(1, "acancel",	"dxd")	}, /*   110 */
+   { 0,			Ukn	ITR(1, "async",		"")	}, /*   111 */
+   { 0,			Ukn	ITR(1, "priocntlsys",	"")	}, /*   112 */
+   { svr4_pathconf,	2	ITR(1, "pathconf",	"sd")	}, /*   113 */
+   { 0,			3	ITR(1, "mincore",	"xdx")	}, /*   114 */
+   { svr4_mmap,		6	ITR(0, "mmap",		"xxxxdx") },/*   115 */
+   { sys_mprotect,	3	ITR(0, "mprotect",	"xdx")  },/*   116 */
+   { sys_munmap,	2	ITR(0, "munmap",	"xd")   },/*   117 */
+   { svr4_fpathconf,	2	ITR(1, "fpathconf",	"dd")	}, /*   118 */
+   { abi_fork,		Spl	ITR(0, "vfork",		"")	}, /*   119 */
+   { sys_fchdir,	1	ITR(0, "fchdir",	"d")	}, /*   120 */
+   { sys_readv,		3	ITR(0, "readv",		"dxd")	}, /*   121 */
+   { sys_writev,	3	ITR(0, "writev",	"dxd")	}, /*   122 */
+   { svr4_xstat,	3	ITR(0, "xstat",		"dsx")	}, /*   123 */
+   { svr4_lxstat,     	3	ITR(0, "lxstat",	"dsx")	}, /*   124 */
+   { svr4_fxstat,	3	ITR(0, "fxstat",	"ddx")	}, /*   125 */
+   { svr4_xmknod,	4	ITR(0, "xmknod",	"dsox")}, /*   126 */
+   { 0,			Spl	ITR(0, "syslocal",	"d")	}, /*   127 */
+   { svr4_getrlimit,	2	ITR(0, "setrlimit",	"dx")	}, /*   128 */
+   { svr4_setrlimit,	2	ITR(0, "getrlimit",	"dx")	}, /*   129 */
+   { 0,			3	ITR(1, "lchown",	"sdd")	}, /*   130 */
+   { 0,			Ukn	ITR(1, "memcntl",	"")	}, /*   131 */
+#ifdef CONFIG_ABI_XTI
+   { svr4_getpmsg,	5	ITR(0, "getpmsg",	"dxxxx")}, /*   132 */
+   { svr4_putpmsg,	5	ITR(0, "putpmsg",	"dxxdd")}, /*   133 */
+#else
+   { 0,			5	ITR(0, "getpmsg",	"dxxxx")}, /*   132 */
+   { 0,			5	ITR(0, "putpmsg",	"dxxdd")}, /*   133 */
+#endif
+   { sys_rename,	2	ITR(0, "rename",	"ss")	}, /*   134 */
+   { abi_utsname,	1	ITR(0, "uname",		"x")	}, /*   135 */
+   { svr4_setegid,	1	ITR(1, "setegid",	"d")	}, /*   136 */
+   { svr4_sysconfig,	1	ITR(0, "sysconfig",	"d")	}, /*   137 */
+   { 0,			Ukn	ITR(1, "adjtime",	"")	}, /*   138 */
+   { svr4_sysinfo,	3	ITR(0, "systeminfo",	"dsd")	}, /*   139 */
+   { socksys_syscall,	1	ITR(0, "socksys_syscall","x")	}, /*   140 */
+   { svr4_seteuid,	1	ITR(1, "seteuid",	"d")	}, /*   141 */
+   { 0,			Ukn	ITR(1, "vtrace",       	"")	}, /*   142 */
+   { 0,			Ukn	ITR(1, "fork1",		"")	}, /*   143 */
+   { 0,			Ukn	ITR(1, "sigtimedwait",	"")	}, /*	144 */
+   { 0,			Ukn	ITR(1, "lwp_info",	"")	}, /*	145 */
+   { 0,			Ukn	ITR(1, "yield",		"")	}, /*	146 */
+   { 0,			Ukn	ITR(1, "lwp_sema_wait",	"")	}, /*	147 */
+   { 0,			Ukn	ITR(1, "lwp_sema_post",	"")	}, /*	148 */
+   { 0,			Ukn	ITR(1, "lwp_sema_trywait","")	}, /*	149 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	150 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	151 */
+   { 0,			Ukn	ITR(1, "modctl",       	"")	}, /*	152 */
+   { 0,			Ukn	ITR(1, "fchroot",	"")	}, /*	153 */
+   { 0,			Ukn	ITR(1, "utimes",	"")	}, /*	154 */
+   { 0,			Ukn	ITR(1, "vhangup",      	"")	}, /*	155 */
+   { sys_gettimeofday,	2	ITR(0, "gettimeofday",	"xx")	}, /*	156 */
+   { sys_getitimer,	2	ITR(0, "getitimer",    	"dx")	}, /*	157 */
+   { sys_setitimer,	3	ITR(0, "setitimer",	"dxx")	}, /*	158 */
+   { 0,			Ukn	ITR(1, "lwp_create",	"")	}, /*	159 */
+   { 0,			Ukn	ITR(1, "lwp_exit",	"")	}, /*	160 */
+   { 0,			Ukn	ITR(1, "lwp_suspend",	"")	}, /*	161 */
+   { 0,			Ukn	ITR(1, "lwp_continue",	"")	}, /*	162 */
+   { 0,			Ukn	ITR(1, "lwp_kill",	"")	}, /*	163 */
+   { 0,			Ukn	ITR(1, "lwp_self",	"")	}, /*	164 */
+   { 0,			Ukn	ITR(1, "lwp_setprivate","")	}, /*	165 */
+   { 0,			Ukn	ITR(1, "lwp_getprivate","")	}, /*	166 */
+   { 0,			Ukn	ITR(1, "lwp_wait",	"")	}, /*	167 */
+   { 0,			Ukn	ITR(1, "lwp_mutex_unlock","")	}, /*	168 */
+   { 0,			Ukn	ITR(1, "lwp_mutex_lock","")	}, /*	169 */
+   { 0,			Ukn	ITR(1, "lwp_cond_wait",	"")	}, /*	170 */
+   { 0,			Ukn	ITR(1, "lwp_cond_signal","")	}, /*	171 */
+   { 0,			Ukn	ITR(1, "lwp_cond_broadcast","")	}, /*	172 */
+   { sys_pread64,	-4	ITR(1, "pread",		"dpdd")	}, /*	173 */
+   { sys_pwrite64,	-4	ITR(1, "pwrite",	"dpdd")	}, /*	174 */
+   { sol_llseek,      	Spl	ITR(1, "llseek",	"dxxd")	}, /*	175 */
+   { 0,			Ukn	ITR(1, "inst_sync",	"")	}, /*	176 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	177 */
+   { 0,			Ukn	ITR(1, "kaio",		"")	}, /*	178 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	179 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	180 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	181 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	182 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /*	183 */
+   { 0,			Ukn	ITR(1, "tsolsys",      	"")	}, /*	184 */
+   { sol_acl,		4	ITR(1, "acl",		"sddp")	}, /*	185 */
+   { 0,			Ukn	ITR(1, "auditsys",	"")	}, /*	186 */
+   { 0,			Ukn	ITR(1, "processor_bind","")	}, /*	187 */
+   { 0,			Ukn	ITR(1, "processor_info","")	}, /*	188 */
+   { 0,			Ukn	ITR(1, "p_online",     	"")	}, /*	189 */
+   { 0,			Ukn	ITR(1, "sigqueue",	"")	}, /*	190 */
+   { 0,			Ukn	ITR(1, "clock_gettime",	"")	}, /*	191 */
+   { 0,			Ukn	ITR(1, "clock_settime",	"")	}, /*	192 */
+   { 0,			Ukn	ITR(1, "clock_getres",	"")	}, /*	193 */
+   { 0,			Ukn	ITR(1, "timer_create",	"")	}, /*	194 */
+   { 0,			Ukn	ITR(1, "timer_delete",	"")	}, /*	195 */
+   { 0,			Ukn	ITR(1, "timer_settime",	"")	}, /*	196 */
+   { 0,			Ukn	ITR(1, "timer_gettime",	"")	}, /*	197 */
+   { 0,			Ukn	ITR(1, "timer_getoverrun","")	}, /*	198 */
+   { sys_nanosleep,	2	ITR(1, "nanosleep",	"pp")	}, /*	199 */
+   { 0,			Ukn	ITR(1, "modstat",	"")	}, /*	200 */
+   { 0,			Ukn	ITR(1, "facl",		"")	}, /*	201 */
+   { sys_setreuid,	2	ITR(1, "setreuid",	"dd")	}, /*	202 */
+   { sys_setregid,	2	ITR(1, "setregid",	"dd")	}, /*	203 */
+   { 0,			Ukn	ITR(1, "install_utrap",	"")	}, /*	204 */
+   { 0,			Ukn	ITR(1, "signotify",	"")	}, /*	205 */
+   { 0,			Ukn	ITR(1, "schedctl",	"")	}, /*	206 */
+   { 0,			Ukn	ITR(1, "pset",		"")	}, /*	207 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 208 */
+   { 0,			Ukn	ITR(1, "resolvepath",	"")	}, /* 209 */
+   { 0,			Ukn	ITR(1, "signotifywait",	"")	}, /* 210 */
+   { 0,			Ukn	ITR(1, "lwp_sigredirect","")	}, /* 211 */
+   { 0,			Ukn	ITR(1, "lwp_alarm",	"")	}, /* 212 */
+   { sol_getdents64,	3  	ITR(0, "getdents64", 	"dxd")	}, /* 213 */
+   { sol_mmap64,	7	ITR(1, "mmap64",      "pxdddxx")}, /*214 */
+   { sol_stat64,      	2	ITR(0, "stat64",       	"sp")	}, /* 215 */
+   { sol_lstat64,	2	ITR(0, "lstat64",	"sp")	}, /* 216 */
+   { sol_fstat64,	2	ITR(0, "fstat64",       "dp")	}, /* 217 */
+   { 0,			Ukn	ITR(1, "statvfs64",	"")	}, /* 218 */
+   { 0,			Ukn	ITR(1, "fstatvfs64",	"")	}, /* 219 */
+   { 0,			Ukn	ITR(1, "setrlimit64",	"")	}, /* 220 */
+   { 0,			Ukn	ITR(1, "getrlimit64",	"")	}, /* 221 */
+   { 0,			Ukn	ITR(1, "pread64",	"")	}, /* 222 */
+   { 0,			Ukn	ITR(1, "pwrite64",	"")	}, /* 223 */
+   { 0,			Ukn	ITR(1, "creat64",	"")	}, /* 224 */
+   { sol_open64,      	3	ITR(0, "open64",       	"soo")	}, /* 225 */
+   { 0,			Ukn	ITR(1, "rpcsys",	"")	}, /* 226 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 227 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 228 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 229 */
+   { solaris_socket,	3	ITR(1, "so_socket",	"ddd")	}, /* 230 */
+   { solaris_socketpair,1	ITR(1, "so_socketpair",	"dddx")	}, /* 231 */
+   { solaris_bind,	3	ITR(1, "bind",		"dxd")	}, /* 232 */
+   { solaris_listen,	2	ITR(1, "listen",	"dd")	}, /* 233 */
+   { solaris_accept,	3	ITR(1, "accept",	"dxx")	}, /* 234 */
+   { solaris_connect,	3	ITR(1, "connect",	"dxd")	}, /* 235 */
+   { solaris_shutdown,	2	ITR(1, "shutdown",	"dd")	}, /* 236 */
+   { solaris_recv,	4	ITR(1, "recv",		"dxdd")	}, /* 237 */
+   { solaris_recvfrom,	6	ITR(1, "recvfrom",     "dxddxd")}, /* 238 */
+   { solaris_recvmsg,	3	ITR(1, "recvmsg",	"dxd")	}, /* 239 */
+   { solaris_send,	4	ITR(1, "send",		"dxdd")	}, /* 240 */
+   { solaris_sendmsg,  	3	ITR(0, "sendmsg",      	"dxd")	}, /* 241 */
+   { solaris_sendto,	6	ITR(1, "sendto",       "dxddxd")}, /* 242 */
+   { solaris_getpeername,3	ITR(1, "getpeername",	"dxx")	}, /* 243 */
+   { solaris_getsockname,3	ITR(1, "getsockname",	"dxx")	}, /* 244 */
+   { solaris_getsockopt,5	ITR(1, "getsockopt",	"dddxx")}, /* 245 */
+   { solaris_setsockopt,5	ITR(1, "setsockopt",	"dddxd")}, /* 246 */
+   { 0,			Ukn	ITR(1, "sockconfig",	"")	}, /* 247 */
+   { 0,			Ukn	ITR(1, "ntp_gettime",	"")	}, /* 248 */
+   { 0,     	 	Ukn	ITR(0, "ntp_adjtime",  	"")	}, /* 249 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 250 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 251 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 252 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 253 */
+   { 0,			Ukn	ITR(1, "?",		"")	}, /* 254 */
+   { 0,			Ukn	ITR(1, "?",		"")	}  /* 255 */
+};
+
+static void solaris_lcall7(int segment, struct pt_regs * regs)
+{
+	int sysno = regs->eax & 0xff;
+
+	if (sysno >= ARRAY_SIZE(solaris_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &solaris_syscall_table[sysno], 1);
+}
+
+static struct exec_domain solaris_exec_domain = {
+	name:		"Solaris",
+	handler:	solaris_lcall7,
+	pers_low:	13 /* PER_SOLARIS */,
+	pers_high:	13 /* PER_SOLARIS */,
+	signal_map:	solaris_to_linux_signals,
+	signal_invmap:	linux_to_solaris_signals,
+	err_map:	solaris_err_map,
+	socktype_map:	solaris_socktype_map,
+	sockopt_map:	solaris_sockopt_map,
+	af_map:		solaris_af_map,
+	module:		THIS_MODULE,
+};
+
+
+static void __exit solaris_cleanup(void)
+{
+	unregister_exec_domain(&solaris_exec_domain);
+}
+
+static int __init solaris_init(void)
+{
+	return register_exec_domain(&solaris_exec_domain);
+}
+
+module_init(solaris_init);
+module_exit(solaris_cleanup);
diff -Nru linux-2.6.7/abi/svr4/consio.c linux-2.6.7-abi/abi/svr4/consio.c
--- linux-2.6.7/abi/svr4/consio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/consio.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,53 @@
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/module.h>
+
+
+int
+svr4_console_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	switch (cmd) {
+	case 0x6301: /* CONS_CURRENT: Get display adapter type */
+	case 0x6302: /* CONS_GET: Get display mode setting */
+		/*
+		 * Always error so the application never tries
+		 * anything overly fancy on the console.
+		 */
+		return -EINVAL;
+	case 0x4304: /* _TTYDEVTYPE */
+		/* If on console then 1, if pseudo tty then 2 */
+		return 2;
+	}
+
+	printk(KERN_ERR "iBCS: console ioctl %d unsupported\n", cmd);
+	return -EINVAL;
+}
+
+int
+svr4_video_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	switch (cmd) {
+	case 1: /* MAP_CLASS */
+		/* Get video memory map & IO privilege */
+                break;
+
+	/* This doesn't agree with my SCO 3.2.4 ???? */
+	case 4: /* C_IOC */
+		/* see /etc/conf/pack.d/cn/class.h on any SCO unix box :-) */
+                break;
+
+        default:
+                break;
+	}
+
+	printk(KERN_ERR "iBCS: video ioctl %d unsupported\n", cmd);
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_console_ioctl);
+EXPORT_SYMBOL(svr4_video_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/fcntl.c linux-2.6.7-abi/abi/svr4/fcntl.c
--- linux-2.6.7/abi/svr4/fcntl.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/fcntl.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2002 Caldera Deutschland GmbH.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "@(#)fcntl.c 1.1 02/23/02"
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/fcntl.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/syscalls.h>
+#include <linux/module.h>
+
+#include <asm/uaccess.h>
+#include <asm/ioctls.h>
+
+#include <abi/svr4/types.h>
+#include <abi/util/trace.h>
+#include <abi/util/map.h>
+
+
+struct svr4_flock {
+	int16_t	    l_type;	/* numbers don't match */
+	int16_t	    l_whence;
+	svr4_off_t  l_start;
+	svr4_off_t  l_len;	/* 0 means to end of file */
+	int16_t	    l_sysid;
+	int16_t	    l_pid;
+};
+
+
+/*
+ * ISC (at least) assumes O_CREAT if O_TRUNC is given.
+ * This is emulated here but is it correct for SVR4 in general?
+ */
+unsigned short fl_svr4_to_linux[] = {
+	0x0001, 0x0002, 0x0800, 0x0400, 0x1000, 0x0000, 0x0000, 0x0800,
+	0x0040, 0x0240, 0x0080, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+unsigned short fl_linux_to_svr4[] = {
+	0x0001, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0400,
+	0x0800, 0x0200, 0x0008, 0x0004, 0x0010, 0x0000, 0x0000, 0x0000
+};
+
+static inline int svr4_fcntl_flock(int fd, unsigned int cmd, unsigned long arg)
+{
+	struct svr4_flock fl, *flp = (struct svr4_flock *)arg;
+	struct flock l_fl;
+	mm_segment_t fs;
+	int rval;
+
+	/*
+	 * We are not supposed to fail once the lock is set,
+	 * thus we check the userspace pointer for writeaccess now.
+	 */
+	rval = verify_area(VERIFY_WRITE, flp, sizeof(struct svr4_flock));
+	if (rval)
+		return -EFAULT;
+
+	rval = copy_from_user(&fl, flp, sizeof(struct svr4_flock));
+	if (rval)
+		return -EFAULT;
+
+	l_fl.l_type = fl.l_type - 1;
+	l_fl.l_whence = fl.l_whence;
+	l_fl.l_start = fl.l_start;
+	l_fl.l_len = fl.l_len;
+	l_fl.l_pid = fl.l_pid;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API,
+		"lock l_type: %d l_whence: %d "
+		"l_start: %u l_len: %u "
+		"l_sysid: %d l_pid: %d\n",
+		fl.l_type, fl.l_whence,
+		fl.l_start, fl.l_len,
+		fl.l_sysid, fl.l_pid);
+#endif
+
+	fs = get_fs();
+	set_fs(get_ds());
+	rval = sys_fcntl(fd, cmd, (unsigned long)&l_fl);
+	set_fs(fs);
+
+	if (rval)
+		return rval;
+
+	fl.l_type = l_fl.l_type + 1;
+	fl.l_whence = l_fl.l_whence;
+	fl.l_start = l_fl.l_start;
+	fl.l_len = l_fl.l_len;
+	fl.l_sysid = 0;
+	fl.l_pid = l_fl.l_pid;
+
+	__copy_to_user(flp, &fl, sizeof(struct svr4_flock));
+	return 0;
+}
+
+int svr4_fcntl(int fd, unsigned int cmd, unsigned long arg)
+{
+	int rval;
+
+	switch (cmd) {
+	case 0: /* F_DUPFD */
+	case 1: /* F_GETFD */
+	case 2: /* F_SETFD */
+		return sys_fcntl(fd, cmd, arg);
+	case 3: /* F_GETFL */
+		rval = sys_fcntl(fd, cmd, arg);
+		return map_flags(rval, fl_linux_to_svr4);
+	case 4: /* F_SETFL */
+		arg = map_flags(arg, fl_svr4_to_linux);
+		return sys_fcntl(fd, cmd, arg);
+	case 14: /* F_GETLK SVR4 */
+		cmd = 5;
+		/*FALLTHROUGH*/
+	case 5: /* F_GETLK */
+	case 6: /* F_SETLK */
+	case 7: /* F_SETLKW */
+		return svr4_fcntl_flock(fd, cmd, arg);
+	case 10: /* F_ALLOCSP */
+		/* Extend allocation for specified portion of file. */
+		return 0;
+	case 11: /* F_FREESP */
+		/* Free a portion of a file. */
+		return 0;
+
+	/*
+	 * These are intended to support the Xenix chsize() and
+	 * rdchk() system calls. I don't know if these may be
+	 * generated by applications or not.
+	 */
+	case 0x6000: /* F_CHSIZE */
+		return sys_ftruncate(fd, arg);
+	case 0x6001: /* F_RDCHK */
+	    {
+		mm_segment_t fs;
+		int nbytes;
+ 
+		fs = get_fs();
+		set_fs(get_ds());
+		rval = sys_ioctl(fd, FIONREAD, (long)&nbytes);
+		set_fs(fs);
+
+		if (rval < 0)
+			return rval;
+		return (nbytes ? 1 : 0);
+	    }
+
+	case  8: /* F_CHKFL */
+	    /*FALLTHROUGH*/
+
+	/*
+	 * These are made from the Xenix locking() system call.
+	 * According to available documentation these would
+	 * never be generated by an application - only by the
+	 * kernel Xenix support.
+	 */
+	case 0x6300: /* F_LK_UNLCK */
+	case 0x7200: /* F_LK_LOCK */
+	case 0x6200: /* F_LK_NBLCK */
+	case 0x7100: /* F_LK_RLCK */
+	case 0x6100: /* F_LK_NBRLCK */
+	    /*FALLTHROUGH*/
+
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API,
+			"unsupported fcntl 0x%x, arg 0x%lx\n", cmd, arg);
+#endif
+		return -EINVAL;
+	}
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(fl_svr4_to_linux);
+EXPORT_SYMBOL(svr4_fcntl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/filio.c linux-2.6.7-abi/abi/svr4/filio.c
--- linux-2.6.7/abi/svr4/filio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/filio.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SVR4 file ioctls.
+ */
+
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/sockios.h>
+#include <linux/syscalls.h>
+#include <linux/module.h>
+
+#include <asm/uaccess.h>
+#include <asm/ioctls.h>
+
+#include <abi/ioctl.h>
+
+
+int
+svr4_fil_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	switch (cmd) {
+	/* FIOCLEX */
+	case BSD__IOV('f', 1):
+	case BSD__IO('f', 1):
+		FD_SET(fd, current->files->close_on_exec);
+		return 0;
+
+	/* FIONCLEX */
+	case BSD__IOV('f', 2):
+	case BSD__IO('f', 2):
+		FD_CLR(fd, current->files->close_on_exec);
+		return 0;
+
+	case BSD__IOV('f', 3):
+	case BSD__IO('f', 3): {
+		int		error, nbytes;
+		mm_segment_t	fs;
+
+		fs = get_fs();
+		set_fs(get_ds());
+		error = sys_ioctl(fd, FIONREAD, (long)&nbytes);
+		set_fs(fs);
+		
+		return (error <= 0 ? error : nbytes);
+	}
+
+	/* FGETOWN */
+	case BSD__IOW('f', 123, int):
+		return sys_ioctl(fd, FIOGETOWN, (long)data);
+
+	/* FSETOWN */
+	case BSD__IOW('f', 124, int):
+		return sys_ioctl(fd, FIOSETOWN, (long)data);
+
+	/* FIOASYNC */
+	case BSD__IOW('f', 125, int):
+		return sys_ioctl(fd, FIOASYNC, (long)data);
+
+	/* FIONBIO */
+	case BSD__IOW('f', 126, int):
+		return sys_ioctl(fd, FIONBIO, (long)data);
+
+	/* FIONREAD */
+	case BSD__IOR('f', 127, int):
+		return sys_ioctl(fd, FIONREAD, (long)data);
+	}
+
+	printk(KERN_ERR "%s: file ioctl 0x%08x unsupported\n", __FUNCTION__, cmd);
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_fil_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/hrtsys.c linux-2.6.7-abi/abi/svr4/hrtsys.c
--- linux-2.6.7/abi/svr4/hrtsys.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/hrtsys.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 1994 Eric Youngdale.
+ *
+ * The hrtsys interface is used by SVR4, and is effectively a way of doing
+ * itimer.  I do not know why this is used instead of the regular itimer
+ * stuff, but it appears to be related to bsd programs/functionality.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/util/trace.h>
+
+
+struct hrt_time_t {
+	unsigned long secs;
+	unsigned long sub_sec; /* Less than one second. */
+	unsigned long resolution; /* Resolution of timer */
+};
+
+struct hrtcmd {
+	int cmd;
+	int clk;
+	struct hrt_time_t interval;
+	struct hrt_time_t tod;
+	int flags;
+	int error;
+	int reserved[3];
+};
+
+static int
+ibcs_hrtcntl (struct pt_regs * regs)
+{
+	unsigned int param[4];
+	struct timeval * tv;
+	int i, error;
+	
+	for (i=0; i<4; i++)
+		param[i] = get_syscall_parameter (regs, 1+i);
+
+	if (param[0] != 1 || param[1] != 1 || param[2] != 0)
+		return -EINVAL;
+
+	tv = (struct timeval *) param[3];
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "hrtcntl(0x%lx)\n", (u_long)tv);
+#endif
+
+	error = verify_area(VERIFY_WRITE, (char *) tv,sizeof *tv);
+	if (error)
+		return error;
+
+	return sys_gettimeofday(tv, NULL);
+}
+
+static int
+ibcs_hrtalarm (struct pt_regs * regs)
+{
+	struct itimerval get_buffer;
+	struct hrtcmd * hcmd;
+	int i, error, cmd, retval, which;
+	mm_segment_t old_fs = get_fs();
+
+	i = get_syscall_parameter (regs, 2);
+	if(i != 1)
+		return -EINVAL;
+
+	hcmd = (struct hrtcmd *) get_syscall_parameter (regs, 1);
+
+	error = verify_area (VERIFY_WRITE, (char *) hcmd,sizeof *hcmd);
+	if (error)
+		return error;
+
+	get_user (cmd, ((unsigned long *) hcmd));
+
+	/* Now figure out which clock we want to fiddle with */
+	get_user (which, ((unsigned long *) hcmd)+1);
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "hrtalarm(0x%lx %d)\n",
+			(u_long)cmd, which);
+#endif
+
+	switch (which) {
+		case 4:
+			which = 2;
+			break;
+		case 2:
+			which = 1;
+			break;
+		case 1:
+			which = 0;
+			break;
+		default:
+			return -EINVAL;
+	};
+	
+	switch (cmd) {
+		case 0xc:
+			if(({long r; get_user(r, ((unsigned long *) hcmd)+4); r;}) != 1000000)
+				return -EINVAL;
+			copy_from_user(&get_buffer.it_value, ((unsigned long *) hcmd)+2,
+				sizeof(struct timeval));
+			memset(&get_buffer.it_interval, 0, sizeof(struct timeval));
+			set_fs(get_ds());
+			retval = sys_setitimer(which, &get_buffer, NULL);
+			set_fs(old_fs);
+			break;
+		case 0xd:
+			set_fs(get_ds());
+			retval = sys_getitimer(which, &get_buffer);
+			set_fs(old_fs);
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_API, "hrtalarm(d %lx) %lx %lx %lx %lx\n",
+					(u_long)hcmd,
+					get_buffer.it_interval.tv_sec,
+					get_buffer.it_interval.tv_usec,
+					get_buffer.it_value.tv_sec,
+					get_buffer.it_value.tv_usec);
+#endif
+
+			put_user(1000000, &hcmd->interval.resolution);
+			copy_to_user(((unsigned long *) hcmd)+2, &get_buffer.it_interval,
+				sizeof(get_buffer));
+			retval = 1;
+			break;
+		case 0xf:
+			if(({long r; get_user(r, ((unsigned long *) hcmd)+4); r;}) != 1000000)
+				return -EINVAL;
+			if(({long r; get_user(r, ((unsigned long *) hcmd)+7); r;}) != 1000000)
+				return -EINVAL;
+			copy_from_user(&get_buffer.it_value, &hcmd->tod,
+				sizeof(struct timeval));
+			copy_from_user(&get_buffer.it_interval, &hcmd->interval,
+				sizeof(struct timeval));
+			set_fs(get_ds());
+			retval = sys_setitimer(which, &get_buffer, NULL);
+			set_fs(old_fs);
+			break;
+		case 0x10:
+			memset(&get_buffer, 0, sizeof(get_buffer));
+			set_fs(get_ds());
+			retval = sys_setitimer(which, &get_buffer, NULL);
+			set_fs(old_fs);
+			break;
+		default:
+			retval = -EINVAL;
+	};
+
+	return retval;
+}
+
+int
+svr4_hrtsys (struct pt_regs * regs)
+{
+	int func, retval;
+	
+	func  = get_syscall_parameter (regs, 0);
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "hrtsys(%d)\n", func);
+#endif
+
+	switch (func) {
+		case 0:
+			retval = ibcs_hrtcntl(regs);
+			break;
+		case 1:
+			retval = ibcs_hrtalarm(regs);
+			break;
+		case 2:
+		case 3:
+		default:
+			retval = -EINVAL;
+	}
+
+	return retval;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_hrtsys);
+#endif
diff -Nru linux-2.6.7/abi/svr4/ioctl.c linux-2.6.7-abi/abi/svr4/ioctl.c
--- linux-2.6.7/abi/svr4/ioctl.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/ioctl.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 1991, 1992  Linus Torvalds
+ * 
+ * Written by Drew Sullivan.
+ * Rewritten by Mike Jagdis.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/svr4/ioctl.h>
+
+
+/*
+ * __svr4_ioctl() is a meta mapper, that is
+ * it looks up the class of the ioctl and then
+ * dispatchs to lower level routines to handle the
+ * mapping of the actual ioctls
+ */
+int
+__svr4_ioctl(struct pt_regs *regs, int fd, unsigned long ioctl_num, void *arg)
+{
+	unsigned int class = ioctl_num >> 8;
+	char class_str[4];
+
+	switch (class) {
+
+	/*
+	 * SCO ioctls on the pseudo NFS device probably.
+	 */
+	case 0:
+		return abi_ioctl_socksys(fd, ioctl_num, arg);
+
+	/*
+	 * SCO console keyboard stuff?
+	 */
+	case 'A':
+		return -EINVAL;
+
+	case 't':
+		return svr4_tape_ioctl(fd, ioctl_num, arg);
+
+	case 'f':
+		return svr4_fil_ioctl(fd, ioctl_num, arg);
+
+	/*
+	 * Xenix ioctl compatibility.
+	 */
+	case 'T':
+		return svr4_term_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	case 'C':
+	case 'c':
+		return svr4_console_ioctl(fd, ioctl_num, arg);
+
+	case ('i' << 16) | ('C' << 8):	/* iBCS2 POSIX */
+		return svr4_video_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	/*
+	 * SCO 3.2.2 uses ('X'<<8)|1 for access to the video map
+	 * and the 'X' set is also used for synchronous comm
+	 * lines (I think?). SVR4 uses it for tty extensions to
+	 * support hardware flow control and external clocks.
+	 */
+	case 'X':
+		return svr4_termiox_ioctl(fd, ioctl_num & 0xFF, arg);
+
+	/*
+	 * These aren't implemented and are never likely to be as they
+	 * are specific to drivers for obscure hardware. (For those
+	 * that don't know they're the JERQ ioctls. Says it all
+	 * really!)
+	 */
+	case 'j':
+		return -EINVAL;
+
+	/*
+	 * The 'S' set could also be display mode switch
+	 * ioctls in a SCO 3.2.x x<4 environment. It should
+	 * depend on the descriptor they are applied to.
+	 * According to ISC the Xenix STREAMS ioctls had the
+	 * high bit set on the command to differentiate them
+	 * from mode switch ioctls. Yuk, yuk, yuk...
+	 */
+	case 'S':
+		return svr4_stream_ioctl(regs, fd, ioctl_num & 0x7F, arg);
+
+	/*
+	 * These are STREAMS socket module ioctls.
+	 */
+	case 'I':
+#if defined(CONFIG_ABI_XTI)
+		return svr4_sockmod_ioctl(fd, ioctl_num & 0xFF, arg);
+#else
+		return -EINVAL;
+#endif
+
+	/*
+	 * EUC ioctls. These are something to do with chararcter
+	 * code set conversions in SVR4. If we don't support
+	 * them the correct thing to do is to return EINVAL.
+	 */
+	case 'E' | 0x80:
+		return -EINVAL;
+
+	/*
+	 * SCO channel mapping. I can't find any documentation
+	 * for this. These are the LD?MAP ioctls defined in
+	 * sys/termio.h and sys/emap.h. They are used by mapchan.
+	 */
+	case 'D':
+		return -EINVAL;
+	}
+
+	/*
+	 * If we haven't handled it yet it must be a BSD style ioctl
+	 * with a (possible) argument description in the high word of
+	 * the opcode.
+	 */
+	switch (class & 0xff) {
+
+	/*
+	 * From SVR4 as specified in sys/iocomm.h.
+	 */
+	case 'f':
+		return svr4_fil_ioctl(fd, ioctl_num, arg);
+
+	/*
+	 * BSD or V7 terminal ioctls.
+	 */
+	case 't':
+		return bsd_ioctl_termios(fd, ioctl_num, arg);
+
+	/*
+	 * "Traditional" BSD and Wyse V/386 3.2.1A TCP/IP ioctls.
+	 */
+	case 's':
+	case 'r':
+	case 'i':
+		return abi_ioctl_socksys(fd, ioctl_num, arg);
+
+	/*
+	 * SVR3 streams based socket TCP/IP ioctls.
+	 *
+	 * These are handed over to the standard ioctl
+	 * handler since /dev/socksys is an emulated device
+	 * and front ends any sockets created through it.
+	 * Note that 'S' ioctls without the BSDish argument
+	 * type in the high bytes are STREAMS ioctls and 'I'
+	 * ioctls without the BSDish type in the high bytes
+	 * are the STREAMS socket module ioctls. (see above).
+	 */
+	case 'S':
+	case 'R':
+	case 'I':
+		return abi_ioctl_socksys(fd, ioctl_num, arg);
+	}
+
+	/*
+	 * If nothing has handled it yet someone may have to do some
+	 * more work...
+	 */
+	class_str[0] = class & 0xFF0000 ? (char)((class >> 16) & 0xFF) : '.';
+	class_str[1] = class & 0x00FF00 ? (char)((class >>  8) & 0xFF) : '.';
+	class_str[2] = class & 0x0000FF ? (char)((class      ) & 0xFF) : '.';
+	class_str[3] = 0;
+
+	printk(KERN_DEBUG "svr4: ioctl(%d, %lx[%s], 0x%p) unsupported\n",
+		fd, ioctl_num, class_str, arg);
+
+	return -EINVAL;
+}
+
+int
+svr4_ioctl(struct pt_regs * regs)
+{
+	u_int			num;
+	int			fd;
+	caddr_t			data;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	num = (u_int)get_syscall_parameter(regs, 1);
+	data = (caddr_t)get_syscall_parameter(regs, 2);
+
+	return __svr4_ioctl(regs, fd, num, data);
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(__svr4_ioctl);
+EXPORT_SYMBOL(svr4_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/ipc.c linux-2.6.7-abi/abi/svr4/ipc.c
--- linux-2.6.7/abi/svr4/ipc.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/ipc.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,713 @@
+/*
+ * Copyright (C) 1994	Mike Jagdis (jaggy@purplet.demon.co.uk)
+ * Copyright (C) 2001   Christoph Hellwig (hch@caldera.de)
+ *
+ * Massive work over with a fine tooth comb, lots of rewriting. There
+ * were a *lot* of bugs in this - mismatched structs that weren't
+ * mapped, wrong pointers etc. I've tested this version with the
+ * demo programs from the Wyse V/386 IPC documentation which exercise
+ * all the functions. I don't have any major IPC using applications
+ * to test it with - as far as I know...
+ *
+ * Again rewritten for Linux 2.4 - Linux 2.4 changes a lot of structures
+ * and the cruft this file relied on has simply changed...
+ *
+ * Original copyright etc. follows:
+ *
+ * Copyright (C) 1993,1994  Joe Portman (baron@hebron.connected.com)
+ *	First stab at ibcs shm, sem and msg handlers
+ *
+ * NOTE:
+ * Please contact the author above before blindly making changes
+ * to this file. You will break things.
+ *
+ * 04-15-1994 JLP III
+ *	Still no msgsys, but IPC_STAT now works for shm calls
+ *	Corrected argument order for sys_ipc calls, to accomodate Mike's
+ *	changes, so that we can just call sys_ipc instead of the internal
+ *	sys_* calls for ipc functions.
+ *	Cleaned up translation of perm structures
+ *	tstshm for Oracle now works.
+ *
+ * 04-23-1994 JLP III
+ *	Added in msgsys calls, Tested and working
+ *	Added translation for IPC_SET portions of all xxxctl functions.
+ *	Added SHM_LOCK and SHM_UNLOCK to shmsys
+ *
+ * 04-28-1994 JLP III
+ *	Special thanks to Brad Pepers for adding in the GETALL and SETALL
+ *	case of semaphores. (pepersb@cuug.ab.ca)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/personality.h>
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+#include <linux/ipc.h>
+#include <linux/sem.h>
+#include <linux/shm.h>
+#include <linux/msg.h>
+
+#include <asm/uaccess.h>
+#include <asm/ipc.h>
+
+#include <abi/svr4/ipc.h>
+#include <abi/util/trace.h>
+#include <abi/util/errno.h>
+
+
+static __inline__ void
+ip_to_lp(struct ibcs2_ipc_perm *ip, struct ipc_perm *lp)
+{
+	lp->uid = ip->uid;
+	lp->gid = ip->gid;
+	lp->cuid = ip->cuid;
+	lp->cgid = ip->cgid;
+	lp->mode = ip->mode;
+	lp->seq = ip->seq;
+	lp->key = ip->key;
+}
+
+static __inline__ void
+lp_to_ip(struct ipc_perm *lp, struct ibcs2_ipc_perm *ip)
+{
+	ip->uid = lp->uid;
+	ip->gid = lp->gid;
+	ip->cuid = lp->cuid;
+	ip->cgid = lp->cgid;
+	ip->mode = lp->mode;
+	ip->seq = lp->seq;
+	ip->key = lp->key;
+}
+
+static __inline__ void
+ip_to_lp_l(struct abi4_ipc_perm *ip, struct ipc_perm *lp)
+{
+	lp->uid = ip->uid;
+	lp->gid = ip->gid;
+	lp->cuid = ip->cuid;
+	lp->cgid = ip->cgid;
+	lp->mode = ip->mode;
+	lp->seq = ip->seq;
+	lp->key = ip->key;
+}
+
+static __inline__ void
+lp_to_ip_l(struct ipc_perm *lp, struct abi4_ipc_perm *ip)
+{
+	ip->uid = lp->uid;
+	ip->gid = lp->gid;
+	ip->cuid = lp->cuid;
+	ip->cgid = lp->cgid;
+	ip->mode = lp->mode;
+	ip->seq = lp->seq;
+	ip->key = lp->key;
+}
+
+static void
+isem_to_lsem(struct ibcs2_semid_ds *is, struct semid_ds *ls)
+{
+	ip_to_lp(&is->sem_perm, &ls->sem_perm);
+
+	ls->sem_base = is->sem_base;
+	ls->sem_nsems = is->sem_nsems;
+	ls->sem_otime = is->sem_otime;
+	ls->sem_ctime = is->sem_ctime;
+}
+
+static void
+lsem_to_isem(struct semid_ds *ls, struct ibcs2_semid_ds *is)
+{
+	lp_to_ip(&ls->sem_perm, &is->sem_perm);
+
+	is->sem_base = ls->sem_base;
+	is->sem_nsems = ls->sem_nsems;
+	is->sem_otime = ls->sem_otime;
+	is->sem_ctime = ls->sem_ctime;
+}
+
+static void
+isem_to_lsem_l(struct abi4_semid_ds *is, struct semid_ds *ls)
+{
+	ip_to_lp_l(&is->sem_perm, &ls->sem_perm);
+
+	ls->sem_base = is->sem_base;
+	ls->sem_nsems = is->sem_nsems;
+	ls->sem_otime = is->sem_otime;
+	ls->sem_ctime = is->sem_ctime;
+}
+
+static void
+lsem_to_isem_l(struct semid_ds *ls, struct abi4_semid_ds *is)
+{
+	memset(is, 0, sizeof(*is));
+
+	lp_to_ip_l(&ls->sem_perm, &is->sem_perm);
+
+	is->sem_base = ls->sem_base;
+	is->sem_nsems = ls->sem_nsems;
+	is->sem_otime = ls->sem_otime;
+	is->sem_ctime = ls->sem_ctime;
+}
+
+static int
+__ibcs2_semctl(int first, int second, int third, union semun *fourth)
+{
+	struct ibcs2_semid_ds	is, *isp;
+	struct semid_ds		ls;
+	union semun		lsemun;
+	mm_segment_t		fs;
+	int			err;
+
+	err = get_user(isp, (struct ibcs2_semid_ds **)&fourth->buf);
+	if (err)
+		return (err);
+
+	err = copy_from_user(&is, isp, sizeof(is)) ? -EFAULT : 0;
+	if (err)
+		return (err);
+
+	isem_to_lsem(&is, &ls);
+	lsemun.buf = &ls;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	err = sys_ipc(SEMCTL, first, second, third, &lsemun,0);
+	set_fs(fs);
+
+	if (err < 0)
+		return (err);
+	
+	lsem_to_isem(&ls, &is);
+	return copy_to_user(isp, &is, sizeof(is)) ? -EFAULT : 0;
+}
+
+static int
+__abi4_semctl(int first, int second, int third, union semun *fourth)
+{
+	struct abi4_semid_ds	is, *isp;
+	struct semid_ds		ls;
+	union semun		lsemun;
+	mm_segment_t		fs;
+	int			err;
+
+	err = get_user(isp, (struct abi4_semid_ds **)&fourth->buf);
+	if (err)
+		return (err);
+
+	err = copy_from_user(&is, isp, sizeof(is)) ? -EFAULT : 0;
+	if (err)
+		return (err);
+
+	isem_to_lsem_l(&is, &ls);
+	lsemun.buf = &ls;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	err = sys_ipc(SEMCTL, first, second, third, &lsemun,0);
+	set_fs(fs);
+
+	if (err < 0)
+		return (err);
+
+	lsem_to_isem_l(&ls, &is);
+	return copy_to_user(isp, &is, sizeof(is)) ? -EFAULT : 0;
+}
+
+static int
+svr4_semctl(int arg1, int arg2, int arg3, union semun *arg4)
+{
+	int			cmd = svr4sem2linux[arg3];
+
+	switch (arg3) {
+	case SVR4_SEM_SETALL:
+	case SVR4_SEM_GETALL:
+		return __ibcs2_semctl(arg1, 0, cmd, arg4);
+	case SVR4_IPC_RMID:
+	case SVR4_IPC_RMID_L:
+	case SVR4_SEM_SETVAL:
+	case SVR4_SEM_GETVAL:
+	case SVR4_SEM_GETPID:
+	case SVR4_SEM_GETNCNT:
+	case SVR4_SEM_GETZCNT:
+		return  sys_ipc(SEMCTL, arg1, arg2, cmd, arg4, 0);
+	case SVR4_IPC_SET:
+	case SVR4_IPC_STAT:
+		return __ibcs2_semctl(arg1, arg2, cmd, arg4);
+	case SVR4_IPC_STAT_L:
+	case SVR4_IPC_SET_L:
+		return __abi4_semctl(arg1, arg2, cmd, arg4);
+	}
+	
+	__abi_trace("semctl: unsupported command %d\n", arg3);
+	return -EINVAL;
+}
+
+static int
+svr4_semget(int arg1, int arg2, int arg3)
+{
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "semget(%d, %d, %o)\n", arg1, arg2, arg3);
+#endif
+	return sys_semget(arg1, arg2, arg3);
+
+}
+
+static int
+svr4_semop(int arg1, struct sembuf *arg2, int arg3)
+{
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_API)) {
+		struct sembuf	tmp, *tp = arg2;
+		int		i;
+
+		for (i = 0; i < arg3; i++) {
+			copy_from_user (&tmp, tp, sizeof(tmp));
+			__abi_trace("semop(%d, %d, 0%o)\n",
+					tmp.sem_num, tmp.sem_op,
+					tmp.sem_flg);
+			tp++;
+		}
+	}
+#endif
+
+	return sys_semop(arg1, arg2, arg3);
+}
+
+int
+svr4_semsys(struct pt_regs *regp)
+{
+	int			which, arg1, arg2, arg3;
+	union semun		*arg4;
+
+	which = get_syscall_parameter(regp, 0);
+	arg1 = get_syscall_parameter(regp, 1);
+	arg2 = get_syscall_parameter(regp, 2);
+	arg3 = get_syscall_parameter(regp, 3);
+	
+	/*
+	 * XXX - The value for arg4 depends on how union
+	 * passing is implement on this architecture and
+	 * compiler. The following is *only* known to be
+	 * right for Intel (the default else case).
+	 */
+#ifdef __sparc__
+	arg4 = (union semun *)get_syscall_parameter(regp, 4);
+#else
+	arg4 = (union semun *)(((u_long *)regp->esp) + (5));
+#endif
+	
+	switch (which) {
+	case SVR4_semctl:
+		return svr4_semctl(arg1, arg2, arg3, arg4);
+	case SVR4_semget:
+		return svr4_semget(arg1, arg2, arg3);
+	case SVR4_semop:
+		return svr4_semop(arg1, (struct sembuf *)arg2, arg3);
+	}
+
+	return -EINVAL;
+}
+
+static void
+ishm_to_lshm(struct ibcs2_shmid_ds *is, struct shmid_ds *ls)
+{
+	ip_to_lp(&is->shm_perm, &ls->shm_perm);
+	ls->shm_segsz = is->shm_segsz;
+	ls->shm_lpid = is->shm_lpid;
+	ls->shm_cpid = is->shm_cpid;
+	ls->shm_nattch = is->shm_nattch;
+	ls->shm_atime = is->shm_atime;
+	ls->shm_dtime = is->shm_dtime;
+	ls->shm_ctime = is->shm_ctime;
+}
+
+static void
+lshm_to_ishm(struct shmid_ds *ls, struct ibcs2_shmid_ds *is)
+{
+	lp_to_ip(&ls->shm_perm, &is->shm_perm);
+	is->shm_segsz = ls->shm_segsz;
+	is->shm_lpid = ls->shm_lpid;
+	is->shm_cpid = ls->shm_cpid;
+	is->shm_nattch = ls->shm_nattch;
+	is->shm_atime = ls->shm_atime;
+	is->shm_dtime = ls->shm_dtime;
+	is->shm_ctime = ls->shm_ctime;
+}
+
+static void
+ishm_to_lshm_l(struct abi4_shmid_ds *is, struct shmid_ds *ls)
+{
+	ip_to_lp_l(&is->shm_perm, &ls->shm_perm);
+	ls->shm_segsz = is->shm_segsz;
+	ls->shm_lpid = is->shm_lpid;
+	ls->shm_cpid = is->shm_cpid;
+	ls->shm_nattch = is->shm_nattch;
+	ls->shm_atime = is->shm_atime;
+	ls->shm_dtime = is->shm_dtime;
+	ls->shm_ctime = is->shm_ctime;
+}
+
+static void
+lshm_to_ishm_l(struct shmid_ds *ls, struct abi4_shmid_ds *is)
+{
+	memset(is, 0, sizeof(*is));
+	lp_to_ip_l(&ls->shm_perm, &is->shm_perm);
+	is->shm_segsz = ls->shm_segsz;
+	is->shm_lpid = ls->shm_lpid;
+	is->shm_cpid = ls->shm_cpid;
+	is->shm_nattch = ls->shm_nattch;
+	is->shm_atime = ls->shm_atime;
+	is->shm_dtime = ls->shm_dtime;
+	is->shm_ctime = ls->shm_ctime;
+}
+
+static int
+svr4_shmdt(struct pt_regs *regp)
+{
+	caddr_t			addr = (caddr_t)get_syscall_parameter(regp, 1);
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "shmdt(%p)\n", addr);
+#endif
+	return sys_shmdt(addr);
+}
+
+static int
+svr4_shmctl(int arg1, int cmd, char *arg3)
+{
+	struct ibcs2_shmid_ds	is;
+	struct abi4_shmid_ds	is4;
+	struct shmid_ds		ls;
+	mm_segment_t		fs;
+	int			err;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "shmctl(%d, %x, %p)\n", arg1, cmd, arg3);
+#endif
+
+	switch (cmd) {
+	case SVR4_SHM_LOCK:
+		return sys_shmctl(arg1, SHM_LOCK, (struct shmid_ds *)arg3);
+	case SVR4_SHM_UNLOCK:
+		return sys_shmctl(arg1, SHM_UNLOCK, (struct shmid_ds *)arg3);
+	case SVR4_IPC_SET: 
+		err = copy_from_user(&is, arg3, sizeof(is)) ? -EFAULT : 0;
+		if (err)
+			break;
+		ishm_to_lshm(&is, &ls);
+
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_shmctl(arg1, IPC_SET, &ls);
+		set_fs(fs);
+
+		if (err < 0)
+			break;
+		lshm_to_ishm(&ls, &is);
+		err = copy_to_user(arg3, &is, sizeof(is)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_SET_L:
+		err = copy_from_user(&is4, arg3, sizeof(is4)) ? -EFAULT : 0;
+		if (err)
+			break;
+		ishm_to_lshm_l(&is4, &ls);
+
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_shmctl(arg1, IPC_SET, &ls);
+		set_fs(fs);
+	
+		if (err < 0)
+			break;
+		lshm_to_ishm_l(&ls, &is4);
+		err = copy_to_user(arg3, &is4, sizeof(is4)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_RMID:
+	case SVR4_IPC_RMID_L:
+		return sys_shmctl(arg1, IPC_RMID, (struct shmid_ds *)arg3);
+	case SVR4_IPC_STAT:
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_shmctl(arg1, IPC_STAT, &ls);
+		set_fs(fs);
+
+		if (err < 0)
+			break;
+
+		lshm_to_ishm(&ls, &is);
+		err = copy_to_user(arg3, &is, sizeof(is)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_STAT_L:
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_shmctl(arg1, IPC_STAT, &ls);
+		set_fs(fs);
+		if (err < 0)
+			break;
+
+		lshm_to_ishm_l(&ls, &is4);
+		err = copy_to_user((char *)arg3, &is4, sizeof(is4)) ? -EFAULT : 0;
+		break;
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		__abi_trace("shmctl: unsupported command %d\n", cmd);
+#endif
+		err = -EINVAL;
+	}
+
+	return (err);
+}
+
+int
+svr4_shmsys(struct pt_regs *regp)
+{
+	int			arg1, arg2, arg3, cmd, err = 0;
+	u_long			raddr;
+	mm_segment_t		fs;
+
+	cmd = get_syscall_parameter(regp, 0);
+	if (cmd == SVR4_shmdt) {
+		err = svr4_shmdt(regp);
+		goto out;
+	}
+	
+	arg1 = get_syscall_parameter(regp, 1);
+	arg2 = get_syscall_parameter(regp, 2);
+	arg3 = get_syscall_parameter(regp, 3);
+
+	switch (cmd) {
+	case SVR4_shmat:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "shmat(%d, %x, %o)\n", arg1, arg2, arg3);
+#endif
+
+		fs = get_fs();
+		set_fs(get_ds());
+		err = do_shmat(arg1, (caddr_t)arg2, arg3, &raddr);
+		set_fs(fs);
+		if (err >= 0)
+			err = (int)raddr;
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "shmat returns %x\n", err);
+#endif
+		break;
+	case SVR4_shmget:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "shmget(%d, %x, %o)\n", arg1, arg2, arg3);
+#endif
+		err = sys_shmget(arg1, arg2, arg3);
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "shmget returns %d\n", err);
+#endif
+		break;
+	case SVR4_shmctl:
+		err = svr4_shmctl(arg1, arg2, (char *)arg3);
+		break;
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		__abi_trace("shmsys: unsupported command: %x\n", cmd);
+#endif
+		err = -EINVAL;
+	}
+
+out:
+	if (err < 0 && err > -255) {
+	        set_error(regp, iABI_errors(-err));
+		abi_trace(ABI_TRACE_API, "Error %d\n", get_result(regp));
+		return 0;
+	}
+
+	clear_error(regp);
+	set_result(regp, err);
+	return 0;
+}
+
+static void
+imsq_to_lmsq(struct ibcs2_msqid_ds * im, struct msqid_ds * lm)
+{
+	ip_to_lp(&im->msg_perm, &lm->msg_perm);
+	lm->msg_first = im->msg_first;
+	lm->msg_last = im->msg_last;
+	lm->msg_cbytes = im->msg_cbytes;
+	lm->msg_qnum = im->msg_qnum;
+	lm->msg_qbytes = im->msg_qbytes;
+	lm->msg_lspid = im->msg_lspid;
+	lm->msg_lrpid = im->msg_lrpid;
+	lm->msg_stime = im->msg_stime;
+	lm->msg_rtime = im->msg_rtime;
+	lm->msg_ctime = im->msg_ctime;
+}
+
+static void
+lmsq_to_imsq(struct msqid_ds *lm, struct ibcs2_msqid_ds *im)
+{
+	lp_to_ip(&lm->msg_perm, &im->msg_perm);
+	im->msg_first = lm->msg_first;
+	im->msg_last = lm->msg_last;
+	im->msg_cbytes = lm->msg_cbytes;
+	im->msg_qnum = lm->msg_qnum;
+	im->msg_qbytes = lm->msg_qbytes;
+	im->msg_lspid = lm->msg_lspid;
+	im->msg_lrpid = lm->msg_lrpid;
+	im->msg_stime = lm->msg_stime;
+	im->msg_rtime = lm->msg_rtime;
+	im->msg_ctime = lm->msg_ctime;
+}
+
+static void
+imsq_to_lmsq_l(struct abi4_msqid_ds *im, struct msqid_ds *lm)
+{
+	ip_to_lp_l(&im->msg_perm, &lm->msg_perm);
+	lm->msg_first = im->msg_first;
+	lm->msg_last = im->msg_last;
+	lm->msg_cbytes = im->msg_cbytes;
+	lm->msg_qnum = im->msg_qnum;
+	lm->msg_qbytes = im->msg_qbytes;
+	lm->msg_lspid = im->msg_lspid;
+	lm->msg_lrpid = im->msg_lrpid;
+	lm->msg_stime = im->msg_stime;
+	lm->msg_rtime = im->msg_rtime;
+	lm->msg_ctime = im->msg_ctime;
+}
+
+static void
+lmsq_to_imsq_l(struct msqid_ds *lm, struct abi4_msqid_ds *im)
+{
+	memset(im, 0, sizeof(*im));
+	lp_to_ip_l(&lm->msg_perm, &im->msg_perm);
+	im->msg_first = lm->msg_first;
+	im->msg_last = lm->msg_last;
+	im->msg_cbytes = lm->msg_cbytes;
+	im->msg_qnum = lm->msg_qnum;
+	im->msg_qbytes = lm->msg_qbytes;
+	im->msg_lspid = lm->msg_lspid;
+	im->msg_lrpid = lm->msg_lrpid;
+	im->msg_stime = lm->msg_stime;
+	im->msg_rtime = lm->msg_rtime;
+	im->msg_ctime = lm->msg_ctime;
+}
+
+static int
+svr4_msgctl(int arg1, int cmd, char *arg3)
+{
+	struct ibcs2_msqid_ds	im;
+	struct abi4_msqid_ds	im4;
+	struct msqid_ds		lm;
+	mm_segment_t		fs;
+	int			err;
+
+	switch (cmd) {
+	case SVR4_IPC_SET:
+		err = copy_from_user(&im, arg3, sizeof(im)) ? -EFAULT : 0;
+		if (err)
+			break;
+		
+		imsq_to_lmsq(&im, &lm);
+
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_msgctl(arg1, IPC_SET, &lm);
+		set_fs(fs);
+
+		lmsq_to_imsq(&lm, &im);
+		err = copy_to_user(arg3, &im, sizeof(im)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_SET_L:
+		err = copy_from_user(&im4, arg3, sizeof(im4)) ? -EFAULT : 0;
+		if (err)
+			break;
+		imsq_to_lmsq_l(&im4, &lm);
+
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_msgctl(arg1, IPC_SET, &lm);
+		set_fs(fs);
+
+		lmsq_to_imsq_l(&lm, &im4);
+		err = copy_to_user(arg3, &im4, sizeof(im4)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_RMID:
+	case SVR4_IPC_RMID_L:
+		return sys_msgctl(arg1, IPC_RMID, (struct msqid_ds *)arg3);
+	case SVR4_IPC_STAT:
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_msgctl(arg1, IPC_STAT, &lm);
+		set_fs(fs);
+
+		if (err < 0)
+			break;
+
+		lmsq_to_imsq(&lm, &im);
+		err = copy_to_user(arg3, &im, sizeof(im)) ? -EFAULT : 0;
+		break;
+	case SVR4_IPC_STAT_L:
+		fs = get_fs();
+		set_fs(get_ds());
+		err = sys_msgctl(arg1, IPC_STAT, &lm);
+		set_fs(fs);
+
+		if (err < 0)
+			break;
+
+		lmsq_to_imsq_l(&lm, &im4);
+		err = copy_to_user(arg3, &im4, sizeof(im4)) ? -EFAULT : 0;
+		break;
+	default:
+		__abi_trace("msgctl: unsupported command: %x\n", cmd);
+		err = -EINVAL;
+	}
+
+	return (err);
+}
+
+int
+svr4_msgsys(struct pt_regs *regp)
+{
+	int			err, cmd, arg1, arg2, arg3, arg4, arg5;
+
+	/*
+	 * Special handling as msgrcv is ugly.
+	 */
+	cmd = get_syscall_parameter(regp, 0);
+	arg1 = get_syscall_parameter(regp, 1);
+	arg2 = get_syscall_parameter(regp, 2);
+
+	switch (cmd) {
+	case SVR4_msgget:
+		return sys_msgget((key_t)arg1, arg2);
+	case SVR4_msgctl:
+		arg3 = get_syscall_parameter(regp, 3);
+		return svr4_msgctl(arg1, arg2, (caddr_t)arg3);
+	case SVR4_msgrcv:
+		arg3 = get_syscall_parameter(regp, 3);
+		arg4 = get_syscall_parameter(regp, 4);
+		arg5 = get_syscall_parameter(regp, 5);
+		return sys_msgrcv(arg1, (struct msgbuf *)arg2, arg3, arg4, arg5);
+	case SVR4_msgsnd:
+		arg3 = get_syscall_parameter(regp, 3);
+		arg4 = get_syscall_parameter(regp, 4);
+		err = sys_msgsnd(arg1, (struct msgbuf *)arg2, arg3, arg4);
+		return ((err > 0) ? 0 : err);
+	}
+
+	__abi_trace("msgsys: unsupported command: %x\n", cmd);
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_msgsys);
+EXPORT_SYMBOL(svr4_semsys);
+EXPORT_SYMBOL(svr4_shmsys);
+#endif
diff -Nru linux-2.6.7/abi/svr4/Makefile linux-2.6.7-abi/abi/svr4/Makefile
--- linux-2.6.7/abi/svr4/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/Makefile	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,20 @@
+
+svr4-y		:= hrtsys.o ioctl.o ipc.o mmap.o open.o svr4.o sysconf.o \
+		   sysfs.o sysinfo.o sysi86.o ulimit.o utsname.o stream.o \
+		   stat.o socksys.o signal.o misc.o socket.o statvfs.o \
+		   fcntl.o
+
+# emulations for all kinds of weird ioctls...
+svr4-y		+= filio.o termios.o consio.o tapeio.o sockio.o
+
+# networking 
+svr4-$(CONFIG_ABI_XTI)	+= timod.o xti.o
+svr4-$(CONFIG_ABI_SPX)	+= timod.o
+
+abi-svr4-objs	+= $(sort $(svr4-y))
+
+
+obj-$(CONFIG_ABI_SVR4)	+= abi-svr4.o
+
+abi-svr4.o: $(abi-svr4-objs)
+	$(LD) -r -o $@ $(abi-svr4-objs)
diff -Nru linux-2.6.7/abi/svr4/misc.c linux-2.6.7-abi/abi/svr4/misc.c
--- linux-2.6.7/abi/svr4/misc.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/misc.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,659 @@
+/*
+ * Copyright (C) 1993  Linus Torvalds
+ * Copyright (C) 2001  Caldera Deutschland GmbH
+ *
+ * Modified by Eric Youngdale to include all ibcs syscalls.
+ * Re-written by Drew Sullivan to handle lots more of the syscalls correctly.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/gfp.h>
+#include <linux/stat.h>
+#include <linux/stddef.h>
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+#include <linux/fcntl.h>
+#include <linux/time.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+
+#include <linux/fs.h>
+#include <linux/sys.h>
+#include <linux/slab.h>
+#include <linux/file.h>
+#include <linux/dirent.h>
+
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+#include <abi/signal.h>
+#include <abi/util/trace.h>
+
+#include <abi/svr4/types.h>
+
+
+MODULE_DESCRIPTION("common code for SVR3/SVR4 based personalities");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+int
+abi_time(void)
+{
+	return sys_time(0);
+}
+
+int
+abi_brk(unsigned long brk)
+{
+	unsigned long newbrk = PAGE_ALIGN(brk), oldbrk, sysbrk;
+
+	down_read(&current->mm->mmap_sem);
+	if (!brk)
+		goto report;
+	oldbrk = PAGE_ALIGN(current->mm->brk);
+	up_read(&current->mm->mmap_sem);
+
+	if (newbrk != oldbrk) {
+		sysbrk = sys_brk(brk);
+		if (PAGE_ALIGN(sysbrk) != newbrk)
+			return -ENOMEM;
+	}
+	return 0;
+
+report:
+	/* return non-pagealigned old brk value */
+	oldbrk = current->mm->brk;
+	up_read(&current->mm->mmap_sem);
+	return oldbrk;
+}
+
+/*
+ * UNIX wants a 0-edx after fork and may have set
+ * the carry flag before calling fork.
+ */
+int
+abi_fork(struct pt_regs *regs)
+{
+	int		retval;
+
+	regs->eflags &= ~1;
+	retval = do_fork(SIGCHLD, regs->esp, regs, 0,
+                /* parent_tidptr */NULL, /* child_tidptr */NULL);
+	regs->edx = 0;
+	return retval;
+}
+
+/*
+ * Unlike Linux, UNIX does not use C calling conventions
+ * for pipe().
+ */
+int
+abi_pipe(struct pt_regs *regs)
+{
+	int		filedes[2], retval;
+
+	retval = do_pipe(filedes);
+	if (retval == 0) {
+		retval = filedes[0];
+		regs->edx = filedes[1];
+	}
+	return retval;
+}
+
+/*
+ * Note the double value return in eax and edx.
+ */
+int
+abi_getpid(struct pt_regs *regs)
+{
+	regs->edx = current->parent->pid;
+	return current->pid;
+}
+
+/*
+ * Note the double value return in eax and edx.
+ */
+int
+abi_getuid(struct pt_regs *regs)
+{
+	regs->edx = current->euid;
+	return current->uid;
+}
+
+/*
+ * Note the double value return in eax and edx.
+ */
+int
+abi_getgid(struct pt_regs *regs)
+{
+	regs->edx = current->egid;
+	return current->gid;
+}
+
+
+
+enum {
+	FLAG_ZF	= 0x0040,
+	FLAG_PF	= 0x0004,
+	FLAG_SF	= 0x0080,
+	FLAG_OF	= 0x0800,
+};
+
+#define MAGIC_WAITPID_FLAG (FLAG_ZF | FLAG_PF | FLAG_SF | FLAG_OF)
+
+int
+abi_wait(struct pt_regs * regs)
+{
+	mm_segment_t		fs;
+	long			result, kopt = 0;
+	int			loc, opt;
+	pid_t			pid;
+
+	/*
+	 * Xenix wait() puts status to edx and returns pid.
+	 *
+	 * XXX	xenix should get it's own syyent table so we can
+	 * XXX	rip this cruft out.
+	 */
+	if (is_cur_personality(PER_XENIX)) {
+		fs = get_fs();
+		set_fs(get_ds());
+		result = sys_wait4(-1, &loc, 0, NULL);
+		set_fs(fs);
+
+		regs->edx = loc;
+		return result;
+	}
+
+	/*
+	 * if ZF,PF,SF,and OF are set then it is waitpid
+	 */
+	if ((regs->eflags & MAGIC_WAITPID_FLAG) == MAGIC_WAITPID_FLAG) {
+		get_user(pid, ((u_long *)regs->esp)+1);
+		get_user(loc, ((u_long *)regs->esp)+2);
+		get_user(opt, ((u_long *)regs->esp)+3);
+
+		/*
+		 * Now translate the options from the SVr4 numbers
+		 */
+		if (opt & 0100)
+			kopt |= WNOHANG;
+		if (opt & 4)
+			kopt |= WUNTRACED;
+
+		result = sys_wait4(pid, (u_int *)loc, kopt, NULL);
+	} else {
+		get_user(loc, ((u_long *)regs->esp)+1);
+		result = sys_wait4(-1, (u_int *)loc, WUNTRACED, NULL);
+	}
+
+	if (result < 0 || !loc)
+		return result;
+
+	get_user(regs->edx, (u_long *)loc);
+	if ((regs->edx & 0xff) == 0x7f) {
+		int		sig;
+
+		sig = (regs->edx >> 8) & 0xff;
+		if (sig < NSIGNALS)
+			sig = current_thread_info()->exec_domain->signal_map[sig];
+		regs->edx = (regs->edx & (~0xff00)) | (sig << 8);
+		put_user(regs->edx, (u_long *)loc);
+	} else if (regs->edx && regs->edx == (regs->edx & 0xff)) {
+		if ((regs->edx & 0x7f) < NSIGNALS)
+			regs->edx = current_thread_info()->exec_domain->signal_map[regs->edx & 0x7f];
+		put_user(regs->edx, (u_long *)loc);
+	}
+	return result;
+}
+
+#if defined(CONFIG_ABI_TRACE)
+/*
+ * Trace arguments of exec().
+ *
+ * We show up to twenty arguments and enviroment variables.
+ * This could as well be sysctl configurable.
+ */
+static void
+trace_exec(struct pt_regs *regs, char *pgm, char **argv, char **envp)
+{
+	char			**v, *p = NULL, *q = NULL;
+	int			i;
+
+	q = getname(pgm);
+	if (IS_ERR(q)) {
+		__abi_trace("\tpgm: %p pointer error %ld\n", pgm, PTR_ERR(q));
+	} else {
+		__abi_trace("\tpgm: %p \"%s\"\n", pgm, q);
+		putname(q);
+	}
+
+	for (i = 0, v = argv; v && i < 20; v++, i++) {
+		if (get_user(p, v) || !p)
+			break;
+
+		q = getname(p);
+		if (IS_ERR(q)) {
+			__abi_trace("\targ: %p pointer error %ld\n",
+					p, PTR_ERR(q));
+		} else {
+			__abi_trace("\targ: %p \"%s\"\n", p, q);
+			putname(q);
+		}
+	}
+
+	if (v && p)
+		__abi_trace("\targ: ...\n");
+
+	for (i = 0, v = envp; v && i < 20; v++, i++) {
+		if (get_user(p, v) || !p)
+			break;
+
+		q = getname(p);
+		if (IS_ERR(q)) {
+			__abi_trace("\tenv: %p pointer error %ld\n",
+					p, PTR_ERR(q));
+		} else {
+			__abi_trace("\tenv: %p \"%s\"\n", p, q);
+			putname(q);
+		}
+	}
+
+	if (v && p)
+		__abi_trace("\tenv: ...\n");
+}
+#endif
+
+/*
+ * Execute a new program.
+ *
+ * The difference from the native version is that we
+ * optionally trace the arguments.
+ */
+int
+abi_exec(struct pt_regs *regs)
+{
+	char		*pgm, **argv, **envp;
+	char		*filename;
+	int		error;
+
+	get_user((u_long)pgm, ((u_long *)regs->esp)+1);
+	get_user((u_long)argv, ((u_long *)regs->esp)+2);
+	get_user((u_long)envp, ((u_long *)regs->esp)+3);
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_API))
+		trace_exec(regs, pgm, argv, envp);
+#endif
+
+	filename = getname(pgm);
+	if (!IS_ERR(filename)) {
+		error = do_execve(filename, argv, envp, regs);
+		putname (filename);
+        } else
+		error = PTR_ERR(filename);
+	return error;
+}
+
+/*
+ * Yet another crufy SysV multiplexed syscall.
+ * This time it's all the process group and session handling.
+ *
+ * NOTE: we return EPERM on get_user failures as EFAULT is not
+ * a valid return value for theses calls.
+ */
+int
+abi_procids(struct pt_regs *regs)
+{
+	int			offset = 0, op;
+
+	if (get_user(op, ((u_long *)regs->esp)+1))
+		return -EPERM;
+
+	/* Remap op codes for current personality if necessary. */
+	switch (get_cur_personality_id()) {
+	case (PERID_SVR3):
+	case (PERID_SCOSVR3):
+	case (PERID_WYSEV386):
+	case (PERID_XENIX):
+		/*
+		 * SCO at least uses an interesting library to
+		 * syscall mapping that leaves an extra return
+		 * address between the op code and the arguments.
+		 *
+		 * WTF does SCO at least mean?
+		 * Could someone please verify this with another
+		 * SVR3 derivate as I have none.
+		 * 					--hch
+		 */
+		offset = 1;
+
+		if (op < 0 || op > 5)
+			return -EINVAL;
+		op = "\000\001\005\003\377\377"[op];
+	}
+
+	switch (op) {
+	case 0: /* getpgrp */
+		return process_group(current);
+
+	case 1: /* setpgrp */
+		sys_setpgid(0, 0);
+		return process_group(current);
+
+	case 2: /* getsid */
+	    {
+		pid_t		pid;
+
+		if (get_user(pid, ((u_long *)regs->esp)+2 + offset))
+			return -EPERM;
+		return sys_getsid(pid);
+	    }
+
+	case 3: /* setsid */
+		return sys_setsid();
+
+	case 4: /* getpgid */
+	    {
+		pid_t		pid;
+		
+		if (get_user(pid, ((u_long *)regs->esp)+2 + offset))
+			return -EPERM;
+		return sys_getpgid(pid);
+	    }
+
+	case 5: /* setpgid */
+	    {
+		pid_t		pid, pgid;
+
+		if (get_user(pid, ((u_long *)regs->esp)+2 + offset))
+			return -EPERM;
+		if (get_user(pgid, ((u_long *)regs->esp)+3 + offset))
+			return -EPERM;
+		return sys_setpgid(pid, pgid);
+	    }
+	}
+
+	return -EINVAL;
+}
+
+
+/*
+ * Stupid bloody thing is trying to read a directory.
+ *
+ * Some old programs expect this to work. It works on SCO.
+ * To emulate it we have to map a dirent to a direct. This
+ * involves shrinking a long inode to a short. Fortunately
+ * nothing this archaic is likely to care about anything
+ * but the filenames of entries with non-zero inodes.
+ */
+int
+abi_read_dir(int fd, char *buf, int count)
+{
+	struct file		*fp;
+	struct old_linux_dirent	*de;
+	mm_segment_t		fs;
+	int			error, here;
+	int			posn = 0, reclen = 0;
+
+
+	fp = fget(fd);
+	if (!fp)
+		return -EBADF;
+
+	error = -ENOMEM;
+	de = (struct old_linux_dirent *)__get_free_page(GFP_KERNEL);
+	if (!de)
+		goto out_fput;
+
+	error = 0;
+	while (posn + reclen < count) {
+		char		*p;
+
+		/*
+		 * Save the current position and get another dirent
+		 */
+		here = fp->f_pos;
+
+		fs = get_fs();
+		set_fs (get_ds());
+		error = old_readdir(fd, de, 1);
+		set_fs(fs);
+
+		if (error <= 0)
+			break;
+
+		/*
+		 * If it'll fit in the buffer save it.
+		 * Otherwise back up so it is read next time around.
+		 * Oh, if we're at the beginning of the buffer there's
+		 * no chance that this entry will ever fit so don't
+		 * copy it and don't back off - we'll just pretend it
+		 * isn't here...
+		 */
+
+		/*
+		 * SCO (at least) handles long filenames by breaking
+		 * them up in to 14 character chunks of which all
+		 * but the last have the inode set to 0xffff.
+		 * Those chunks will get aligned to a 4 byte boundary
+		 * thus leaving two bytes in each entry for other purposes.
+		 *
+		 * Well, that's SCO E(A)FS.
+		 * HTFS and DTFS should handle it better.
+		 * 					--hch
+		 */
+		reclen = 16 * ((de->d_namlen + 13) / 14);
+		if (posn + reclen > count) {
+			if (posn)
+				sys_lseek(fd, here, 0);
+			continue;
+		}
+
+		p = de->d_name;
+
+		/*
+		 * Put all but the last chunk.
+		 */
+		while (de->d_namlen > 14) {
+			put_user(0xffff, (u_short *)(buf+posn));
+			posn += 2;
+			if (copy_to_user(buf+posn, p, 14))
+				goto out_fault;
+			posn += 14;
+			p += 14;
+			de->d_namlen -= 14;
+		}
+
+		/*
+		 * Put the last chunk. Note the we have to fold a
+		 * long inode number down to a short avoiding
+		 * giving a zero inode number since that indicates
+		 * an unused directory slot. Note also that the
+		 * folding used here must match that used in stat()
+		 * or path finding programs that do read() on
+		 * directories will fail.
+		 */
+#if 0
+		/*
+		 * This appears to match what SCO does for
+		 * reads on a directory with long inodes.
+		 */
+		if ((u_long)de->d_ino > 0xfffe) {
+			if (put_user(0xfffe, buf+posn))
+				goto out_fault;
+		} else {
+			if (put_user((short)de->d_ino, buf+posn))
+				goto out_fault;
+		}
+#else
+		/*
+		 * This attempts to match the way stat and
+		 * getdents fold long inodes to shorts.
+		 */
+		if ((u_long)de->d_ino & 0xffff ) {
+			if (put_user((u_long)de->d_ino & 0xffff, buf+posn))
+				goto out_fault;
+		} else {
+			if (put_user(0xfffe, buf+posn))
+				goto out_fault;
+		}
+#endif
+		posn += 2;
+		if (copy_to_user(buf+posn, p, de->d_namlen))
+			goto out_fault;
+
+		/*
+		 * Ensure that filenames that don't fill the array
+		 * completely are null filled.
+		 */
+		for (; de->d_namlen < 14; de->d_namlen++) {
+			if (put_user('\0', buf+posn+de->d_namlen))
+				goto out_fault;
+		}
+		posn += 14;
+	}
+
+	free_page((u_long)de);
+	fput(fp);
+
+	/*
+	 * If we've put something in the buffer return the byte count
+	 * otherwise return the error status.
+	 */
+	return (posn ? posn : error);
+
+out_fault:
+	error = -EFAULT;
+	free_page((u_long)de);
+out_fput:
+	fput(fp);
+	return error;
+}
+
+/*
+ * We could use Linux read if there wouldn't be the
+ * read on directory issue..
+ */
+int
+abi_read(int fd, char *buf, int count)
+{
+	int		error;
+
+	error = sys_read(fd, buf, count);
+	if (error == -EISDIR)
+		error = abi_read_dir(fd, buf, count);
+	return error;
+}
+
+/*
+ * Linux doesn't allow trailing slashes in mkdir.
+ * Old UNIX apps expect it work anyway, so we have
+ * to get rid of them here.
+ */
+int
+abi_mkdir(const char *fname, int mode)
+{
+	mm_segment_t		fs;
+	char			*tmp, *p;
+	int			error;
+
+	tmp = getname(fname);
+	if (IS_ERR(tmp))
+		return PTR_ERR(tmp);
+
+	for (p = tmp; *p; p++);
+		p--;
+	if (*p == '/')
+		*p = '\0';
+	
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_mkdir(tmp, mode);
+	set_fs(fs);
+	
+	putname(tmp);
+	return error;
+}
+
+/*
+ * Unlike UNIX Linux doesn't allow to create
+ * directories using mknod.
+ */
+int
+svr4_mknod(char *filename, svr4_o_mode_t mode, svr4_o_dev_t dev)
+{
+	if ((mode & 0017000) == 0040000)
+		return abi_mkdir(filename, mode);
+	return sys_mknod(filename, mode, dev);
+}
+
+static int
+svr4_do_xmknod(char *filename, svr4_mode_t mode, svr4_dev_t dev)
+{
+	u_int minor = (dev & 0x3ffff), major = (dev >> 18);
+
+	if (minor > 0xff || major > 0xff)
+		return -EINVAL;
+	return svr4_mknod(filename, mode, ((major << 8) | minor));
+}
+
+
+enum {SVR4_mknod = 1, SVR4_xmknod = 2};
+
+int
+svr4_xmknod(int vers, char *filename, svr4_mode_t mode, svr4_dev_t dev)
+{
+	switch (vers) {
+	case SVR4_mknod:
+		return svr4_mknod(filename, mode, dev);
+	case SVR4_xmknod:
+		return svr4_do_xmknod(filename, mode, dev);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "xmknod version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+abi_kill(int pid, int sig)
+{
+	int insig, outsig;
+
+	insig = (sig & 0xff);
+	outsig = current_thread_info()->exec_domain->signal_map[insig];
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SIGNAL, "kill: %d -> %d\n", insig, outsig);
+#endif
+
+	return sys_kill(pid, outsig);
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(abi_brk);
+EXPORT_SYMBOL(abi_exec);
+EXPORT_SYMBOL(abi_fork);
+EXPORT_SYMBOL(abi_getgid);
+EXPORT_SYMBOL(abi_getpid);
+EXPORT_SYMBOL(abi_getuid);
+EXPORT_SYMBOL(abi_kill);
+EXPORT_SYMBOL(abi_mkdir);
+EXPORT_SYMBOL(abi_pipe);
+EXPORT_SYMBOL(abi_procids);
+EXPORT_SYMBOL(abi_read);
+EXPORT_SYMBOL(abi_time);
+EXPORT_SYMBOL(abi_wait);
+EXPORT_SYMBOL(svr4_mknod);
+EXPORT_SYMBOL(svr4_xmknod);
+#endif
diff -Nru linux-2.6.7/abi/svr4/mmap.c linux-2.6.7-abi/abi/svr4/mmap.c
--- linux-2.6.7/abi/svr4/mmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/mmap.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Support for mmap on SVR4 and derivates.
+ */
+#include <linux/mm.h>
+#include <linux/errno.h>
+#include <linux/file.h>
+#include <linux/mman.h>
+#include <linux/module.h>
+
+#include <asm/uaccess.h>
+
+#include <abi/svr4/mman.h>
+#include <abi/svr4/types.h>
+
+#include <abi/util/trace.h>
+
+
+u_long
+svr4_mmap(u_long addr, size_t len, int prot, int flags, int fd, svr4_off_t off)
+{
+	struct file *file = NULL;
+	u_long mapaddr;
+
+	if (flags & SVR4_MAP_UNIMPL) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_UNIMPL,
+		    "unsupported mmap flags: 0x%x\n", flags & SVR4_MAP_UNIMPL);
+#endif
+		flags &= ~SVR4_MAP_UNIMPL;
+	}
+
+	if (!(flags & SVR4_MAP_ANONYMOUS)) {
+		file = fget(fd);
+		if (!file)
+			goto Ebadfd;
+
+		flags &= ~SVR4_MAP_ANONYMOUS;
+		flags |= MAP_ANONYMOUS;
+	}
+
+	down_write(&current->mm->mmap_sem);
+	mapaddr = do_mmap(file, addr, len, prot, flags, off);
+	up_write(&current->mm->mmap_sem);
+
+	if (file)
+		fput(file);
+	return mapaddr;
+Ebadfd:
+	return -EBADFD;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_mmap);
+#endif
diff -Nru linux-2.6.7/abi/svr4/open.c linux-2.6.7-abi/abi/svr4/open.c
--- linux-2.6.7/abi/svr4/open.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/open.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 1993  Joe Portman (baron@hebron.connected.com)
+ * Copyright (c) 1993, 1994  Drew Sullivan (re-worked for iBCS2)
+ * Copyright (c) 2000  Christoph Hellwig (rewrote lookup-related code)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <linux/vfs.h>
+#include <linux/types.h>
+#include <linux/utime.h>
+#include <linux/errno.h>
+#include <linux/fcntl.h>
+#include <linux/stat.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/signal.h>
+#include <linux/tty.h>
+#include <linux/time.h>
+#include <linux/slab.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <linux/un.h>
+#include <linux/file.h>
+#include <linux/dirent.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/namei.h>
+
+#include <asm/uaccess.h>
+#include <asm/bitops.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/svr4/statfs.h>
+#include <abi/svr4/sysent.h>
+
+#include <abi/util/trace.h>
+#include <abi/util/map.h>
+
+
+static int
+copy_kstatfs(struct svr4_statfs *buf, struct kstatfs *st)
+{
+	struct svr4_statfs ibcsstat;
+
+	ibcsstat.f_type = st->f_type;
+	ibcsstat.f_bsize = st->f_bsize;
+	ibcsstat.f_frsize = 0;
+	ibcsstat.f_blocks = st->f_blocks;
+	ibcsstat.f_bfree = st->f_bfree;
+	ibcsstat.f_files = st->f_files;
+	ibcsstat.f_ffree = st->f_ffree;
+	memset(ibcsstat.f_fname, 0, sizeof(ibcsstat.f_fname));
+	memset(ibcsstat.f_fpack, 0, sizeof(ibcsstat.f_fpack));
+	
+	/* Finally, copy it to the user's buffer */
+	return copy_to_user(buf, &ibcsstat, sizeof(struct svr4_statfs));
+}
+
+int svr4_statfs(const char * path, struct svr4_statfs * buf, int len, int fstype)
+{
+	struct svr4_statfs ibcsstat;
+
+	if (len > (int)sizeof(struct svr4_statfs))
+		return -EINVAL;
+	
+	if (!fstype) {
+		struct nameidata nd;
+		int error;
+
+		error = user_path_walk(path, &nd);
+		if (!error) {
+			struct kstatfs tmp;
+
+			error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
+			if (!error && copy_kstatfs(buf, &tmp))
+				error = -EFAULT;
+			path_release(&nd);
+		}
+	
+		return error;
+	}
+
+	/*
+	 * Linux can't stat unmounted filesystems so we
+	 * simply lie and claim 500MB of 8GB is free. Sorry.
+	 */
+	ibcsstat.f_bsize = 1024;
+	ibcsstat.f_frsize = 0;
+	ibcsstat.f_blocks = 8 * 1024 * 1024;	/* 8GB */
+	ibcsstat.f_bfree = 500 * 1024;		/* 100MB */
+	ibcsstat.f_files = 60000;
+	ibcsstat.f_ffree = 50000;
+	memset(ibcsstat.f_fname, 0, sizeof(ibcsstat.f_fname));
+	memset(ibcsstat.f_fpack, 0, sizeof(ibcsstat.f_fpack));
+
+	/* Finally, copy it to the user's buffer */
+	return copy_to_user(buf, &ibcsstat, len) ? -EFAULT : 0;
+}
+
+int svr4_fstatfs(unsigned int fd, struct svr4_statfs * buf, int len, int fstype)
+{
+	struct svr4_statfs ibcsstat;
+
+	if (len > (int)sizeof(struct svr4_statfs))
+		return -EINVAL;
+
+	if (!fstype) {
+		struct file * file;
+		struct kstatfs tmp;
+		int error;
+	
+		error = -EBADF;
+		file = fget(fd);
+		if (!file)
+			goto out;
+		error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp);
+		if (!error && copy_kstatfs(buf, &tmp))
+			error = -EFAULT;
+		fput(file);
+
+out:
+		return error;
+	}
+
+	/*
+	 * Linux can't stat unmounted filesystems so we
+	 * simply lie and claim 500MB of 8GB is free. Sorry.
+	 */
+	ibcsstat.f_bsize = 1024;
+	ibcsstat.f_frsize = 0;
+	ibcsstat.f_blocks = 8 * 1024 * 1024;	/* 8GB */
+	ibcsstat.f_bfree = 500 * 1024;		/* 100MB */
+	ibcsstat.f_files = 60000;
+	ibcsstat.f_ffree = 50000;
+	memset(ibcsstat.f_fname, 0, sizeof(ibcsstat.f_fname));
+	memset(ibcsstat.f_fpack, 0, sizeof(ibcsstat.f_fpack));
+
+	/* Finally, copy it to the user's buffer */
+	return copy_to_user(buf, &ibcsstat, len) ? -EFAULT : 0;
+}
+
+int svr4_open(const char *fname, int flag, int mode)
+{
+#ifdef __sparc__
+	return sys_open(fname, map_flags(flag, fl_svr4_to_linux), mode);
+#else
+	u_long args[3];
+	int error, fd;
+	struct file *file;
+	mm_segment_t old_fs;
+	char *p;
+	struct sockaddr_un addr;
+
+	fd = sys_open(fname, map_flags(flag, fl_svr4_to_linux), mode);
+	if (fd < 0)
+		return fd;
+
+	/* Sometimes a program may open a pathname which it expects
+	 * to be a named pipe (or STREAMS named pipe) when the
+	 * Linux domain equivalent is a Unix domain socket. (e.g.
+	 * UnixWare uses a STREAMS named pipe /dev/X/Nserver.0 for
+	 * X :0 but Linux uses a Unix domain socket /tmp/.X11-unix/X0)
+	 * It isn't enough just to make the symlink because you cannot
+	 * open() a socket and read/write it. If we spot the error we can
+	 * switch to socket(), connect() and things will likely work
+	 * as expected however.
+	 */
+	file = fget(fd);
+	if (!file)
+		return fd; /* Huh?!? */
+	if (!S_ISSOCK(file->f_dentry->d_inode->i_mode)) {
+		fput(file);
+		return fd;
+	}
+	fput(file);
+
+	sys_close(fd);
+	args[0] = AF_UNIX;
+	args[1] = SOCK_STREAM;
+	args[2] = 0;
+	old_fs = get_fs();
+	set_fs(get_ds());
+	fd = sys_socketcall(SYS_SOCKET, args);
+	set_fs(old_fs);
+	if (fd < 0)
+		return fd;
+
+	p = getname(fname);
+	if (IS_ERR(p)) {
+		sys_close(fd);
+		return PTR_ERR(p);
+	}
+	if (strlen(p) >= UNIX_PATH_MAX) {
+		putname(p);
+		sys_close(fd);
+		return -E2BIG;
+	}
+	addr.sun_family = AF_UNIX;
+	strcpy(addr.sun_path, p);
+	putname(p);
+
+	args[0] = fd;
+	args[1] = (int)&addr;
+	args[2] = sizeof(struct sockaddr_un);
+	set_fs(get_ds());
+	error = sys_socketcall(SYS_CONNECT, args);
+	set_fs(old_fs);
+	if (error) {
+		sys_close(fd);
+		return error;
+	}
+
+	return fd;
+#endif
+}
+
+#define NAME_OFFSET(de)	((int) ((de)->d_name - (char *) (de)))
+#define ROUND_UP(x)	(((x)+sizeof(long)-1) & ~(sizeof(long)-1))
+
+struct svr4_getdents_callback {
+	struct dirent * current_dir;
+	struct dirent * previous;
+	int count;
+	int error;
+};
+
+static int svr4_filldir(void * __buf, const char * name, int namlen,
+	loff_t offset, ino_t ino, unsigned int d_type)
+{
+	struct dirent * dirent;
+	struct svr4_getdents_callback * buf = (struct svr4_getdents_callback *) __buf;
+	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
+
+	buf->error = -EINVAL;   /* only used if we fail.. */
+	if (reclen > buf->count)
+		return -EINVAL;
+
+	dirent = buf->previous;
+	if (dirent)
+		put_user(offset, &dirent->d_off);
+	dirent = buf->current_dir;
+	buf->previous = dirent;
+	
+	if (is_cur_personality_flag(PERF_SHORT_INODE)) {
+		/* read() on a directory only handles
+		 * short inodes but cannot use 0 as that
+		 * indicates an empty directory slot.
+		 * Therefore stat() must also fold
+		 * inode numbers avoiding 0. Which in
+		 * turn means that getdents() must fold
+		 * inodes avoiding 0 - if the program
+		 * was built in a short inode environment.
+		 * If we have short inodes in the dirent
+		 * we also have a two byte pad so we
+		 * can let the high word fall in the pad.
+		 * This makes it a little more robust if
+		 * we guessed the inode size wrong.
+		 */
+		if (!((unsigned long)dirent->d_ino & 0xffff))
+			dirent->d_ino = 0xfffffffe;
+	}
+
+	put_user(ino, &dirent->d_ino);
+	put_user(reclen, &dirent->d_reclen);
+	copy_to_user(dirent->d_name, name, namlen);
+	put_user(0, dirent->d_name + namlen);
+	((char *) dirent) += reclen;
+	buf->current_dir = dirent;
+	buf->count -= reclen;
+	return 0;
+}
+			
+
+
+int svr4_getdents(int fd, char *dirent, int count)
+{
+	struct file * file;
+	struct dirent * lastdirent;
+	struct svr4_getdents_callback buf;
+	int error;
+
+	error = -EBADF;
+	file = fget(fd);
+	if (!file)
+		goto out;
+
+	buf.current_dir = (struct dirent *) dirent;
+	buf.previous = NULL;
+	buf.count = count;
+	buf.error = 0;
+	error = vfs_readdir(file, svr4_filldir, &buf);
+	if (error < 0)
+		goto out_putf;
+	error = buf.error;
+	lastdirent = buf.previous;
+	if (lastdirent) {
+		put_user(file->f_pos, &lastdirent->d_off);
+		error = count - buf.count;
+	}
+
+out_putf:
+	fput(file);
+
+out:
+	return error;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_fstatfs);
+EXPORT_SYMBOL(svr4_getdents);
+EXPORT_SYMBOL(svr4_open);
+EXPORT_SYMBOL(svr4_statfs);
+#endif
diff -Nru linux-2.6.7/abi/svr4/signal.c linux-2.6.7-abi/abi/svr4/signal.c
--- linux-2.6.7/abi/svr4/signal.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/signal.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,523 @@
+/*
+ * signal.c - signal emulation code
+ *
+ *  This module does not go through the normal processing routines for
+ *  ibcs. The reason for this is that for most events, the return is a
+ *  procedure address for the previous setting. This procedure address
+ *  may be negative which is not an error. Therefore, the return processing
+ *  for standard functions is skipped by declaring this routine as a "special"
+ *  module for the decoder and dealing with the register settings directly.
+ *
+ * Please consider this closely if you plan on changing this mode.
+ * -- Al Longyear
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/stddef.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+#include <linux/fcntl.h>
+#include <linux/personality.h>
+#include <linux/fs.h>
+#include <linux/sys.h>
+#include <linux/signal.h>
+#include <linux/syscalls.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/map.h>
+#include <abi/util/errno.h>
+#include <abi/util/trace.h>
+
+
+#define SIG_HOLD	((__sighandler_t)2)	/* hold signal */
+
+#include <abi/signal.h>
+#include <abi/svr4/sigaction.h>
+
+typedef void (*pfn) (void);     /* Completion function */
+
+/*
+ * Parameters to the signal functions have a common stack frame. This
+ * defines the stack frame.
+ */
+#define SIGNAL_NUMBER(regp)	get_syscall_parameter((regp), 0)
+#define HIDDEN_PARAM(regp)	(SIGNAL_NUMBER((regp)) & ~0xFF)
+#define SECOND_PARAM(regp)	get_syscall_parameter((regp), 1)
+#define THIRD_PARAM(regp)	((u_long)(regp)->edx)
+
+/* Return a mask that includes SIG only.  */
+#define __sigmask(sig)		(1 << ((sig) - 1))
+#define _S(nr)			(1 << ((nr) - 1))
+#define _BLOCKABLE		(~(_S(IBCS_SIGKILL) | _S(IBCS_SIGSTOP)))
+
+
+void
+deactivate_signal(struct task_struct *task, int signum)
+{
+	spin_lock_irq(&task->sighand->siglock);
+	sigdelset(&task->pending.signal, signum);
+	recalc_sigpending();
+	spin_unlock_irq(&task->sighand->siglock);
+}
+
+/*
+ *  Translate the signal number to the corresponding item for Linux.
+ */
+static __inline int
+abi_mapsig(int sig)
+{
+	if ((u_int)sig >= NSIGNALS)
+		return (-1);
+	return (current_thread_info()->exec_domain->signal_map[sig]);
+}
+
+/*
+ * Either we want this static or in a header...
+ */
+__inline int
+abi_signo(struct pt_regs *regp, int *sigp)
+{
+	int			value;
+	
+	value = abi_mapsig(SIGNAL_NUMBER(regp) & 0xFF);
+	if (value == -1) {
+		set_error(regp, iABI_errors(EINVAL));
+		return 0;
+	} else {
+		*sigp = value;
+		return 1;
+	}
+}
+
+/*
+ * Process the signal() function from iBCS
+ *
+ * This version appeared in "Advanced Programming in the Unix Environment"
+ * by W. Richard Stevens, page 298.
+ */
+void
+abi_sig_handler(struct pt_regs *regp, int sig,
+		__sighandler_t handler, int oneshot)
+{
+	struct sigaction	act, oact;
+	mm_segment_t		fs;
+	int			error;
+
+	sigemptyset(&act.sa_mask);
+	act.sa_restorer = NULL;
+	act.sa_handler = handler;
+	act.sa_flags = 0;
+
+	if (oneshot)
+		act.sa_flags |= SA_ONESHOT | SA_NOMASK;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigaction(sig, &act, &oact, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error < 0) {
+		set_error(regp, iABI_errors(-error));
+	} else {
+		set_result(regp, (int)oact.sa_handler);
+	}
+}
+
+/*
+ * Process the signal() function from iBCS
+ */
+int
+abi_signal(struct pt_regs *regp)
+{
+	__sighandler_t	vec;
+	int		sig;
+
+	if (abi_signo(regp, &sig)) {
+		vec = (__sighandler_t)SECOND_PARAM(regp);
+		abi_sig_handler(regp, sig, vec, 1);
+	}
+
+	return 0;
+}
+
+/*
+ * Process the SVR4 sigset function.
+ *
+ * This is basically the same as the signal() routine with the
+ * exception that it will accept a SIG_HOLD parameter.
+ *
+ * A SIG_HOLD will defer the processing of the signal until a sigrelse()
+ * function is called or the signal handler is set again using this function.
+ */
+int
+abi_sigset(struct pt_regs *regp)
+{
+	int		sig, error;
+	sigset_t	newmask, oldmask;
+	__sighandler_t	vec;
+	mm_segment_t	fs;
+	int		action;
+
+
+	if (abi_signo(regp, &sig) == 0)
+		return 0;
+
+	vec = (__sighandler_t)SECOND_PARAM(regp);
+	action = SIG_BLOCK;
+
+	if (vec != SIG_HOLD) {
+		action = SIG_UNBLOCK;
+		deactivate_signal(current, sig);
+		abi_sig_handler(regp, sig, vec, 0);
+	}
+
+	/*
+	 * Process the signal hold/unhold function.
+	 */
+	sigemptyset(&newmask);
+	sigaddset(&newmask, sig);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigprocmask(action, &newmask, &oldmask,
+		sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error < 0)
+		set_error(regp, iABI_errors(-error));
+
+	return 0;
+}
+
+/*
+ * Process the iBCS sighold function.
+ *
+ * Suspend the signal from future recognition.
+ */
+void
+abi_sighold(struct pt_regs *regp)
+{
+	sigset_t	newmask, oldmask;
+	int		error, sig;
+	mm_segment_t	fs;
+
+	if (!abi_signo(regp, &sig))
+		return;
+
+	sigemptyset(&newmask);
+	sigaddset(&newmask, sig);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigprocmask(SIG_BLOCK, &newmask,
+			&oldmask, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error < 0)
+		set_error(regp, iABI_errors(-error));
+}
+
+/*
+ * Process the iBCS sigrelse.
+ *
+ * Re-enable the signal processing from a previously suspended
+ * signal. This may have been done by calling the sighold() function
+ * or a longjmp() during the signal processing routine. If you do a
+ * longjmp() function then it is expected that you will call sigrelse
+ * or set the handler again using sigset before going on with the program.
+ */
+void
+abi_sigrelse(struct pt_regs *regp)
+{
+	sigset_t	newmask, oldmask;
+	int		error, sig;
+	mm_segment_t	fs;
+
+	if (!abi_signo(regp, &sig))
+		return;
+
+	sigemptyset(&newmask);
+	sigaddset(&newmask, sig);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigprocmask(SIG_UNBLOCK, &newmask,
+			&oldmask, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error < 0)
+		set_error(regp, iABI_errors(-error));
+}
+
+/*
+ * Process the iBCS sigignore
+ *
+ * This is basically a signal (...,SIG_IGN) call.
+ */
+void
+abi_sigignore(struct pt_regs *regp)
+{
+	struct sigaction	act, oact;
+	int			error, sig;
+	mm_segment_t		fs;
+
+	if (!abi_signo(regp, &sig))
+		return;
+
+	sigemptyset(&act.sa_mask);
+
+	act.sa_restorer = NULL;
+	act.sa_handler = SIG_IGN;
+	act.sa_flags   = 0;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigaction(sig, &act, &oact, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error < 0)
+		set_error(regp, iABI_errors(-error));
+}
+
+/*
+ * Process the iBCS sigpause
+ *
+ * Wait for the signal indicated to arrive before resuming the
+ * processing. I do not know if the signal is processed first using
+ * the normal event processing before the return. If someone can
+ * shed some light on this then please correct this code. I block
+ * the signal and look for it to show up in the pending list.
+ */
+void
+abi_sigpause(struct pt_regs *regs)
+{
+	old_sigset_t		newset;
+	int			error, sig;
+
+	if (!abi_signo(regs, &sig))
+		return;
+	newset = (~0UL) & (1UL << (sig-1));
+
+	if ((error = sys_sigsuspend(0, current->blocked.sig[0], newset) < 0))
+		set_error(regs, iABI_errors(-error));
+}
+
+/*
+ * This is the service routine for the syscall #48 (signal funcs).
+ *
+ * Examine the request code and branch on the request to the appropriate
+ * function.
+ */
+int
+abi_sigfunc(struct pt_regs *regp)
+{
+	int			sig_type = (int)HIDDEN_PARAM(regp);
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SIGNAL|ABI_TRACE_SIGNAL_F,
+		"sig%s(%ld, 0x%08lx, 0x%08lx)\n",
+			sig_type == 0 ? "nal"
+			: (sig_type == 0x100 ? "set"
+			: (sig_type == 0x200 ? "hold"
+			: (sig_type == 0x400 ? "relse"
+			: (sig_type == 0x800 ? "ignore"
+			: (sig_type == 0x1000 ? "pause"
+			: "???" ))))),
+			SIGNAL_NUMBER(regp) & 0xff,
+			SECOND_PARAM(regp),
+			THIRD_PARAM(regp));
+#endif
+
+	regp->eflags &= ~1;
+	regp->eax     = 0;
+
+	switch (sig_type) {
+	case 0x0000:
+		abi_signal(regp);
+		break;
+	case 0x0100:
+		abi_sigset(regp);
+		break;
+	case 0x0200:
+		abi_sighold(regp);
+		break;
+	case 0x0400:
+		abi_sigrelse(regp);
+		break;
+	case 0x0800:
+		abi_sigignore(regp);
+		break;
+	case 0x1000:
+		abi_sigpause(regp);
+		break;
+	default:
+		set_error(regp, EINVAL);
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_SIGNAL|ABI_TRACE_SIGNAL_F,
+				"sigfunc(%x, %ld, %lx, %lx) unsupported\n",
+				sig_type, SIGNAL_NUMBER(regp),
+				SECOND_PARAM(regp), THIRD_PARAM(regp));
+#endif
+		return 0;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SIGNAL|ABI_TRACE_SIGNAL_F,
+			"returns %d\n", get_result(regp));
+#endif
+	return 0;
+}
+
+/*
+ * This function is used to handle the sigaction call from SVr4 binaries.
+ *
+ * If anyone else uses this, this function needs to be modified since the
+ * order and size of the ibcs_sigaction structure is different in ibcs
+ * and the SVr4 ABI
+ */
+asmlinkage int
+abi_sigaction(int abi_signum, const struct abi_sigaction *action,
+		struct abi_sigaction *oldaction)
+{
+	struct abi_sigaction	new_sa, old_sa;
+	struct sigaction	nsa, osa;
+	mm_segment_t		fs;
+	int			error, signo;
+
+	signo = abi_mapsig(abi_signum);
+	if (signo == -1)
+		return -EINVAL;
+
+	if (oldaction) {
+		error = verify_area(VERIFY_WRITE, oldaction,
+				sizeof(struct abi_sigaction));
+		if (error)
+			return (-EFAULT);
+	}
+
+	if (action) {
+		error = copy_from_user(&new_sa, action,
+				sizeof(struct abi_sigaction));
+		if (error)
+			return (-EFAULT);
+		nsa.sa_restorer = NULL;
+		nsa.sa_handler = new_sa.sa_handler;
+		nsa.sa_mask = map_sigvec_to_kernel(new_sa.sa_mask,
+			current_thread_info()->exec_domain->signal_map);
+		if (new_sa.sa_flags & ABI_SA_ONSTACK)
+			nsa.sa_flags |= SA_ONSTACK;
+		if (new_sa.sa_flags & ABI_SA_RESTART)
+			nsa.sa_flags |= SA_RESTART;
+		if (new_sa.sa_flags & ABI_SA_NODEFER)
+			nsa.sa_flags |= SA_NODEFER;
+		if (new_sa.sa_flags & ABI_SA_RESETHAND)
+			nsa.sa_flags |= SA_RESETHAND;
+		if (new_sa.sa_flags & ABI_SA_NOCLDSTOP)
+			nsa.sa_flags |= SA_NOCLDSTOP;
+		if (new_sa.sa_flags & ABI_SA_NOCLDWAIT)
+			nsa.sa_flags |= SA_NOCLDWAIT;
+	}
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigaction(signo, action ? &nsa : NULL,
+			oldaction ? &osa : NULL, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (error || !oldaction)
+		return (error);
+
+	old_sa.sa_handler = osa.sa_handler;
+	old_sa.sa_mask = map_sigvec_from_kernel(osa.sa_mask,
+			current_thread_info()->exec_domain->signal_invmap);
+	old_sa.sa_flags = 0;
+	if (osa.sa_flags & SA_ONSTACK)
+		old_sa.sa_flags |= ABI_SA_ONSTACK;
+	if (osa.sa_flags & SA_RESTART)
+		old_sa.sa_flags |= ABI_SA_RESTART;
+	if (osa.sa_flags & SA_NODEFER)
+		old_sa.sa_flags |= ABI_SA_NODEFER;
+	if (osa.sa_flags & SA_RESETHAND)
+		old_sa.sa_flags |= ABI_SA_RESETHAND;
+	if (osa.sa_flags & SA_NOCLDSTOP)
+		old_sa.sa_flags |= ABI_SA_NOCLDSTOP;
+	if (osa.sa_flags & SA_NOCLDWAIT)
+		old_sa.sa_flags |= ABI_SA_NOCLDWAIT;
+	/*
+	 * We already did the verify_area at the beginning.
+	 */
+	__copy_to_user(oldaction, &old_sa, sizeof(struct abi_sigaction));
+	return 0;
+}
+
+
+static short int howcnv[] = {SIG_SETMASK, SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK};
+
+asmlinkage int
+abi_sigprocmask(int how, u_long *abinset, u_long *abioset)
+{
+	sigset_t		new_set, *nset = NULL;
+	sigset_t		old_set, *oset = NULL;
+	u_long			new_set_abi, old_set_abi;
+	mm_segment_t		fs;
+	int			error;
+
+	if (abinset) {
+		get_user(new_set_abi, abinset);
+		new_set = map_sigvec_to_kernel(new_set_abi,
+			current_thread_info()->exec_domain->signal_map);
+		nset = &new_set;
+	}
+
+	if (abioset)
+		oset = &old_set;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_rt_sigprocmask(howcnv[how], nset, oset, sizeof(sigset_t));
+	set_fs(fs);
+
+	if (!error && abioset) {
+		old_set_abi = map_sigvec_from_kernel(old_set,
+			current_thread_info()->exec_domain->signal_invmap);
+		put_user(old_set_abi, abioset);
+	}
+
+	return (error);
+}
+
+int
+abi_sigsuspend(struct pt_regs *regs)
+{
+	u_long			abi_mask, *abi_maskp;
+	old_sigset_t		mask;
+
+	abi_maskp = (u_long *)SIGNAL_NUMBER(regs);
+	if (get_user(abi_mask, abi_maskp))
+		return -EFAULT;
+
+	mask = map_bitvec(abi_mask, current_thread_info()->exec_domain->signal_map);
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SIGNAL,
+			"sigsuspend(mask = %lx)\n", mask);
+#endif
+	return sys_sigsuspend(0, current->blocked.sig[0], mask);
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(abi_sigaction);
+EXPORT_SYMBOL(abi_sigfunc);
+EXPORT_SYMBOL(abi_sigprocmask);
+EXPORT_SYMBOL(abi_sigsuspend);
+EXPORT_SYMBOL(deactivate_signal);
+#endif
diff -Nru linux-2.6.7/abi/svr4/socket.c linux-2.6.7-abi/abi/svr4/socket.c
--- linux-2.6.7/abi/svr4/socket.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/socket.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 1994,1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/net.h>
+#include <linux/personality.h>
+#include <linux/ptrace.h>
+#include <linux/socket.h>
+#include <linux/syscalls.h>
+#include <linux/types.h>
+#include <asm/uaccess.h>
+#include <asm/ioctls.h>
+
+#include <abi/util/map.h>
+#include <abi/util/trace.h>
+#include <abi/util/socket.h>
+
+
+int
+abi_do_setsockopt(unsigned long *sp)
+{
+	int error;
+	int level, optname;
+
+	error = verify_area(VERIFY_READ,
+			((unsigned long *)sp),
+			5*sizeof(long));
+	if (error)
+		return error;
+
+	get_user(level, ((unsigned long *)sp)+1);
+	get_user(optname, ((unsigned long *)sp)+2);
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_STREAMS|ABI_TRACE_SOCKSYS)) {
+		u_long optval, optlen;
+
+		get_user(optval, ((u_long *)sp) + 3);
+		get_user(optlen, ((u_long *)sp) + 4);
+		__abi_trace("setsockopt level=%d, optname=%d, "
+				"optval=0x%08lx, optlen=0x%08lx\n",
+				level, optname, optval, optlen);
+	}
+#endif
+
+	switch (level) {
+		case 0: /* IPPROTO_IP aka SOL_IP */
+			/* This is correct for the SCO family. Hopefully
+			 * it is correct for other SYSV...
+			 */
+			optname--;
+			if (optname == 0)
+				optname = 4;
+			if (optname > 4) {
+				optname += 24;
+				if (optname <= 33)
+					optname--;
+				if (optname < 32 || optname > 36)
+					return -EINVAL;
+			}
+			put_user(optname, ((unsigned long *)sp)+2);
+			break;
+
+		case 0xffff:
+			put_user(SOL_SOCKET, ((unsigned long *)sp)+1);
+			optname = map_value(current_thread_info()->exec_domain->sockopt_map, optname, 0);
+			put_user(optname, ((unsigned long *)sp)+2);
+
+			switch (optname) {
+				case SO_LINGER: {
+					unsigned long optlen;
+
+					/* SO_LINGER takes a struct linger
+					 * as the argument but some code
+					 * uses an int and expects to get
+					 * away without an error. Sigh...
+					 */
+					get_user(optlen, ((unsigned long *)sp)+4);
+					if (optlen == sizeof(int))
+						return 0;
+					break;
+				}
+
+				/* The following are not currently implemented
+				 * under Linux so we must fake them in
+				 * reasonable ways. (Only SO_PROTOTYPE is
+				 * documented in SCO's man page).
+				 */
+				case SO_PROTOTYPE:
+				case SO_ORDREL:
+				case SO_SNDTIMEO:
+				case SO_RCVTIMEO:
+					return -ENOPROTOOPT;
+
+				case SO_USELOOPBACK:
+				case SO_SNDLOWAT:
+				case SO_RCVLOWAT:
+					return 0;
+
+				/* The following are not currenty implemented
+				 * under Linux and probably aren't settable
+				 * anyway.
+				 */
+				case SO_IMASOCKET:
+					return -ENOPROTOOPT;
+			}
+
+		default:
+			/* FIXME: We assume everything else uses the
+			 * same level and option numbers. This is true
+			 * for IPPROTO_TCP(/SOL_TCP) and TCP_NDELAY
+			 * but is known to be incorrect for other
+			 * potential options :-(.
+			 */
+			break;
+	}
+
+	return sys_socketcall(SYS_SETSOCKOPT, sp);
+}
+
+int
+abi_do_getsockopt(unsigned long *sp)
+{
+	int error;
+	int level, optname;
+	char *optval;
+	long *optlen;
+
+	error = verify_area(VERIFY_READ,
+			((unsigned long *)sp),
+			5*sizeof(long));
+	if (error)
+		return error;
+
+	get_user((unsigned long) level, ((unsigned long *)sp)+1);
+	get_user((unsigned long) optname, ((unsigned long *)sp)+2);
+	get_user((unsigned long) optval, ((unsigned long *)sp)+3);
+	get_user((unsigned long) optlen, ((unsigned long *)sp)+4);
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_STREAMS|ABI_TRACE_SOCKSYS)) {
+		long l;
+
+		get_user(l, optlen);
+		__abi_trace("getsockopt level=%d, optname=%d, optval=0x%08lx, "
+				"optlen=0x%08lx[%ld]\n", level, optname,
+				(u_long)optval, (u_long)optlen, l);
+	}
+#endif
+
+	switch (level) {
+		case 0: /* IPPROTO_IP aka SOL_IP */
+			/* This is correct for the SCO family. Hopefully
+			 * it is correct for other SYSV...
+			 */
+			optname--;
+			if (optname == 0)
+				optname = 4;
+			if (optname > 4) {
+				optname += 24;
+				if (optname <= 33)
+					optname--;
+				if (optname < 32 || optname > 36)
+					return -EINVAL;
+			}
+			put_user(optname, ((unsigned long *)sp)+2);
+			break;
+
+		case 0xffff:
+			put_user(SOL_SOCKET, ((unsigned long *)sp)+1);
+			optname = map_value(current_thread_info()->exec_domain->sockopt_map, optname, 0);
+			put_user(optname, ((unsigned long *)sp)+2);
+
+			switch (optname) {
+				case SO_LINGER: {
+					long l;
+
+					/* SO_LINGER takes a struct linger
+					 * as the argument but some code
+					 * uses an int and expects to get
+					 * away without an error. Sigh...
+					 */
+					get_user(l, optlen);
+					if (l == sizeof(int)) {
+						put_user(0, (long *)optval);
+						return 0;
+					}
+					break;
+				}
+
+				/* The following are not currently implemented
+				 * under Linux so we must fake them in
+				 * reasonable ways. (Only SO_PROTOTYPE is
+				 * documented in SCO's man page).
+				 */
+				case SO_PROTOTYPE: {
+					unsigned long len;
+					error = get_user(len, optlen);
+					if (error)
+						return error;
+					if (len < sizeof(long))
+						return -EINVAL;
+
+					error = verify_area(VERIFY_WRITE,
+							(char *)optval,
+							sizeof(long));
+					if (!error) {
+						put_user(0, (long *)optval);
+						put_user(sizeof(long),
+							optlen);
+					}
+					return error;
+				}
+
+				case SO_ORDREL:
+				case SO_SNDTIMEO:
+				case SO_RCVTIMEO:
+					return -ENOPROTOOPT;
+
+				case SO_USELOOPBACK:
+				case SO_SNDLOWAT:
+				case SO_RCVLOWAT:
+				case SO_IMASOCKET: {
+					unsigned long len;
+					error = get_user(len, optlen);
+					if (error)
+						return error;
+					if (len < sizeof(long))
+						return -EINVAL;
+
+					error = verify_area(VERIFY_WRITE,
+							(char *)optval,
+							sizeof(long));
+					if (!error) {
+						put_user(1, (long *)optval);
+						put_user(sizeof(long),
+							optlen);
+					}
+					return error;
+				}
+			}
+
+		default:
+			/* FIXME: We assume everything else uses the
+			 * same level and option numbers. This is true
+			 * for IPPROTO_TCP(/SOL_TCP) and TCP_NDELAY
+			 * but is known to be incorrect for other
+			 * potential options :-(.
+			 */
+			break;
+	}
+
+	return sys_socketcall(SYS_GETSOCKOPT, sp);
+}
diff -Nru linux-2.6.7/abi/svr4/sockio.c linux-2.6.7-abi/abi/svr4/sockio.c
--- linux-2.6.7/abi/svr4/sockio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/sockio.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,307 @@
+/*	$Id$	*/
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/sockios.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+#include <asm/ioctls.h>
+
+#include <abi/stream.h>
+#include <abi/tli.h>
+#include <abi/socksys.h> /* for socksys_fdinit */
+
+#include <abi/svr4/ioctl.h>
+#include <abi/util/trace.h>
+
+
+/*
+ * Check if the inode belongs to /dev/socksys.
+ */
+#define IS_SOCKSYS(ip) (MAJOR((ip)->i_rdev) == SOCKSYS_MAJOR)
+
+
+static int
+i_nread(u_int fd, struct file *fp, struct inode *ip,
+		void *data, struct pt_regs *regs)
+{
+	int			error;
+
+	error = verify_area(VERIFY_WRITE, data, sizeof(u_long));
+	if (error)
+		goto fput;
+
+#if defined(CONFIG_ABI_XTI)
+	if (ip->i_sock) {
+		struct T_private *ti = Priv(fp);
+
+		if (IS_SOCKSYS(ip))
+			timod_update_socket(fd, fp, regs);
+
+		if (ti && ti->pfirst) {
+			put_user(ti->pfirst->length, (u_long *)data);
+			fput(fp);
+			return 1; /* at least 1... (FIXME) */
+		}
+	}
+#endif
+	fput(fp);
+
+	error = sys_ioctl(fd, TIOCINQ, (long)data);
+	if (error == -EINVAL)
+		return 0;
+	else if (error)
+		return error;
+
+	__get_user(error, (u_long *)data);
+	return !!error;
+fput:
+	fput(fp);
+	return error;
+}
+
+static int
+i_peek(u_int fd, struct file *fp, struct inode *ip,
+		void *data, struct pt_regs *regs)
+{
+#if !defined(CONFIG_ABI_XTI)
+	fput(fp);
+	return 0;
+#else
+	struct T_private	*ti = Priv(fp);
+	struct T_primsg		*tp;
+	struct strpeek		buf, *uap = data;
+	int			error = -EFAULT;
+
+	if (copy_from_user(&buf, uap, sizeof(buf)))
+		goto fput;
+
+	error = 0;
+	if (!ip->i_sock)
+		goto fput;
+	
+	if (IS_SOCKSYS(ip))
+		timod_update_socket(fd, fp, regs);
+
+	if (!ti || !ti->pfirst)
+		goto fput;
+	tp = ti->pfirst;
+			
+	error = -EFAULT;
+	if (!buf.flags || buf.flags == tp->pri) {
+		int	l;
+	
+
+			
+		if (buf.ctl.maxlen <= tp->length)
+			l = buf.ctl.maxlen;
+		else
+			l = tp->length;
+
+		if (copy_to_user(buf.ctl.buf,
+		    ((char *)&tp->type) + ti->offset, l))
+			goto fput;
+
+		if (put_user(l, &uap->ctl.len))
+			goto fput;
+
+		if (buf.dat.maxlen >= 0 && put_user(0, &uap->dat.len))
+			goto fput;
+
+		if (put_user(tp->pri, &uap->flags))
+			goto fput;
+
+		error = 1;
+	}
+fput:
+	fput(fp);
+	return error;
+#endif /* CONFIG_ABI_XTI */
+}
+
+static int
+i_str(u_int fd, struct file *fp, struct inode *ip,
+		void *data, struct pt_regs *regs)
+{
+	int			cmd;
+	/*
+	 * Unpack the ioctl data and forward as a normal
+	 * ioctl. Timeouts are not handled (yet?).
+	 */
+	struct strioctl {
+		int cmd, timeout, len;
+		char *data;
+	} it, *uap = data;
+
+	if (copy_from_user(&it, uap, sizeof(struct strioctl)))
+		return -EFAULT;
+	cmd = it.cmd >> 8;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS, "STREAMS I_STR ioctl(%d, 0x%08x, %p)\n",
+			fd, it.cmd, it.data);
+#endif
+	
+#ifdef CONFIG_ABI_XTI
+	if (cmd == 'T')
+		return timod_ioctl(regs, fd, it.cmd & 0xff, it.data, it.len,
+			&uap->len);
+#endif
+	return __svr4_ioctl(regs, fd, it.cmd, it.data);
+}
+
+int
+svr4_stream_ioctl(struct pt_regs *regs, int fd, u_int cmd, caddr_t data)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			error;
+
+	fp = fget(fd);
+	if (!fp)
+		return -EBADF;
+	ip = fp->f_dentry->d_inode;
+
+	/*
+	 * Special hack^H^Hndling for socksys fds
+	 */
+	if (ip->i_sock == 0 && IS_SOCKSYS(ip)) {
+		error = socksys_fdinit(fd, 0, NULL, NULL);
+		if (error < 0)
+			return error;
+		fput(fp);
+		fp = fget(fd);
+		if (!fp)
+			return -EBADF;
+		ip = fp->f_dentry->d_inode;
+	}
+
+	switch (cmd) {
+	case 001: /* I_NREAD */
+		return i_nread(fd, fp, ip, data, regs);
+
+	case 017: /* I_PEEK */
+		return i_peek(fd, fp, ip, data, regs);
+	}
+
+	fput(fp);
+
+	switch (cmd) {
+	case 010: /* I_STR */
+		return i_str(fd, fp, ip, data, regs);
+	case 002: { /* I_PUSH */
+		char *tmp;
+
+		/* Get the name anyway to validate it. */
+		tmp = getname(data);
+		if (IS_ERR(tmp))
+			return PTR_ERR(tmp);
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+				"%d STREAMS I_PUSH %s\n", fd, tmp);
+#endif
+
+		putname(tmp);
+		return 0;
+	}
+	case 003: /* I_POP */
+#if defined(CONFIG_ABI_TRACE)
+		  abi_trace(ABI_TRACE_STREAMS, "%d STREAMS I_POP\n", fd);
+#endif
+		  return 0;
+
+	case 005: /* I_FLUSH */
+		  return 0;
+
+	case 013: { /* I_FIND */
+		char *tmp;
+
+		/* Get the name anyway to validate it. */
+		tmp = getname(data);
+		if (IS_ERR(tmp))
+				return PTR_ERR(tmp);
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+				"%d STREAMS I_FIND %s\n", fd, tmp);
+#endif
+#ifdef CONFIG_ABI_XTI
+		if (!strcmp(tmp, "timod")) {
+			putname(tmp);
+			return 1;
+		}
+#endif
+		putname(tmp);
+		return 0;
+	}
+
+	/* FIXME: These are bogus. */
+	case 011: /* I_SETSIG */
+		return sys_ioctl(fd, FIOSETOWN, (long)current->pid);
+	case 012: /* I_GETSIG */
+		return sys_ioctl(fd, FIOGETOWN, (long)data);
+
+	case 020: /* I_FDINSERT */
+#ifdef CONFIG_ABI_XTI
+		return stream_fdinsert(regs, fd,
+				(struct strfdinsert *)data);
+#else
+		return -EINVAL;
+#endif
+
+	case 004: /* I_LOOK */
+	case 006: /* I_SRDOPT */
+	case 007: /* I_GRDOPT */
+	case 014: /* I_LINK */
+	case 015: /* I_UNLINK */
+	case 021: /* I_SENDFD */
+	case 022: /* I_RECVFD */
+	case 023: /* I_SWROPT */
+	case 040: /* I_SETCLTIME */
+		return 0; /* Lie... */
+	case 042: /* I_CANPUT */
+		/*
+		 * Arg is the priority band in question. We only
+		 * support one priority band so data must be 0.
+		 * If the band is writable we should return 1, if
+		 * the band is flow controlled we should return 0.
+		 */
+		if (data)
+			return -EINVAL;
+
+		/* FIXME: How can we test if a write would block? */
+		return 1;
+
+	case 024: /* I_GWROPT */
+	case 025: /* I_LIST */
+	case 026: /* I_PLINK */
+	case 027: /* I_PUNLINK */
+	case 030: /* I_SETEV */
+	case 031: /* I_GETEV */
+	case 032: /* I_STREV */
+	case 033: /* I_UNSTREV */
+	case 034: /* I_FLUSHBAND */
+	case 035: /* I_CKBAND */
+	case 036: /* I_GETBAND */
+	case 037: /* I_ATMARK */
+	case 041: /* I_GETCLTIME */
+			/* Unsupported - drop out. */
+                break;
+
+        default:
+                break;
+	}
+
+	printk(KERN_ERR "iBCS: STREAMS ioctl 0%o unsupported\n", cmd);
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_stream_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/socksys.c linux-2.6.7-abi/abi/svr4/socksys.c
--- linux-2.6.7/abi/svr4/socksys.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/socksys.c	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,1232 @@
+/*
+ * socksys.c - SVR4 /dev/socksys emulation
+ *
+ * Copyright (c) 1994-1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ * Copyright (c) 2001 Caldera Deutschland GmbH
+ * Copyright (c) 2001 Christoph Hellwig
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/fcntl.h>
+#include <linux/major.h>
+#include <linux/kernel.h>
+#include <linux/in.h>
+#include <linux/net.h>
+#include <linux/sched.h>
+#include <linux/signal.h>
+#include <linux/socket.h>
+#include <net/sock.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/un.h>
+#include <linux/utsname.h>
+#include <linux/time.h>
+#include <linux/termios.h>
+#include <linux/sys.h>
+#include <linux/file.h>
+#include <linux/poll.h>
+#include <linux/capability.h>
+#include <linux/personality.h>
+#include <linux/init.h>
+#include <linux/syscalls.h>
+#include <linux/namei.h>
+
+#include <asm/uaccess.h>
+
+#include <abi/stream.h>
+#include <abi/socksys.h>
+#include <abi/svr4/sockio.h>
+#include <abi/svr4/sysent.h>
+#include <abi/tli.h>
+
+#include <abi/util/map.h>
+#include <abi/util/trace.h>
+#include <abi/util/revalidate.h>
+
+
+/*
+ * External declarations.
+ */
+struct svr4_stat;
+
+/*
+ * Forward declarations.
+ */
+static int	socksys_open(struct inode *ip, struct file *fp);
+#if defined(CONFIG_ABI_XTI)
+static int	socksys_release(struct inode *ip, struct file *fp);
+static u_int	socksys_poll(struct file *fp, struct poll_table_struct *wait);
+#endif
+static int	socksys_read(struct file *fp, char *buf,
+			size_t count, loff_t *ppos);
+static int	socksys_write(struct file *fp, const char *buf,
+			size_t count, loff_t *ppos);
+
+/*
+ * The socksys socket file operations.
+ * This gets filled in on module initialization.
+ */
+static struct file_operations socksys_socket_fops = {
+	/* NOTHING */
+};
+
+/*
+ * File operations for the user-visible device files.
+ *
+ * While open the files are handled as sockets.
+ */
+static struct file_operations socksys_fops = {
+	owner:		THIS_MODULE,
+	open:		socksys_open,
+	read:		socksys_read,
+	write:		socksys_write,
+#ifdef CONFIG_ABI_XTI
+	poll:		socksys_poll,
+	release:	socksys_release,
+#endif
+};
+
+
+void
+inherit_socksys_funcs(u_int fd, int state)
+{
+	struct file		*fp;
+	struct inode		*ip;
+#ifdef CONFIG_ABI_XTI
+	struct T_private	*tp;
+#endif
+        struct socket           *sp;
+
+	fp = fget(fd);
+	if (fp == NULL)
+		return;
+	ip = fp->f_dentry->d_inode;
+
+	/*
+	 * SYSV sockets are BSD like with respect to ICMP errors
+	 * with UDP rather than RFC conforming. I think.
+	 */
+        sp = SOCKET_I(ip); /* inode -> socket */
+	if (sp->sk)
+                sock_set_flag(sp->sk, SOCK_BSDISM);
+
+	ip->i_mode = 0020000; /* S_IFCHR */
+	ip->i_rdev = MKDEV(SOCKSYS_MAJOR, 0);
+
+#ifdef CONFIG_ABI_XTI
+	tp = kmalloc(sizeof(struct T_private), GFP_KERNEL);
+	if (tp) {
+		tp->magic = XTI_MAGIC;
+		tp->state = state;
+		tp->offset = 0;
+		tp->pfirst = NULL;
+		tp->plast = NULL;
+	}
+	fp->private_data = tp;
+#endif
+
+	fp->f_op = &socksys_socket_fops;
+	fput(fp);
+}
+
+static int
+spx_connect(u_int fd, int spxnum)
+{
+	struct sockaddr_un	sun;
+	int			newfd, err;
+	mm_segment_t		fs;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+			"SPX: %u choose service %d\n", fd, spxnum);
+#endif
+
+	/*
+	 * Rather than use an explicit path to the X :0 server
+	 * socket we should use the given number to look up a path
+	 * name to use (we can't rely on servers registering their
+	 * sockets either - for one thing we don't emulate that yet
+	 * and for another thing different OS binaries do things in
+	 * different ways but all must interoperate).
+	 * I suggest putting the mapping in, say, /dev/spx.map/%d
+	 * where each file is a symlink containing the path of the
+	 * socket to use. Then we can just do a readlink() here to
+	 * get the pathname.
+	 *   Hey, this is what we do here now!
+	 */
+	sun.sun_family = AF_UNIX;
+	sprintf(sun.sun_path, "/dev/spx.map/%u", spxnum);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	err = sys_readlink(sun.sun_path, sun.sun_path, strlen(sun.sun_path));
+	set_fs(fs);
+
+	if (err == -ENOENT) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_SOCKSYS,
+			"SPX: %u no symlink \"%s\", try X :0\n",
+			fd, sun.sun_path);
+#endif
+		strcpy(sun.sun_path, "/tmp/.X11-unix/X0");
+	} else if (err < 0) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_SOCKSYS,
+			"SPX: readlink failed with %d\n", err);
+#endif
+		return (err);
+	} else
+		sun.sun_path[err] = '\0';
+
+	set_fs(get_ds());
+	newfd = sys_socket(AF_UNIX, SOCK_STREAM, 0);
+	set_fs(fs);
+
+	if (newfd < 0) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_SOCKSYS,
+			"SPX: %u got no UNIX domain socket (err=%d)\n",
+			fd, err);
+#endif
+		return (newfd);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+		"SPX: %u got a UNIX domain socket\n", fd);
+#endif
+
+	set_fs(get_ds());
+	err = sys_connect(newfd, (struct sockaddr *)&sun, sizeof(struct sockaddr_un));
+	set_fs(fs);
+
+	if (err) {
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_SOCKSYS,
+			"SPX: %u connect to \"%s\" failed (err = %d)\n",
+			fd, sun.sun_path, err);
+#endif
+		sys_close(newfd);
+		return (err);
+	} 
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+		"SPX: %u connect to \"%s\"\n",
+		fd, sun.sun_path);
+#endif
+	return (newfd);
+}
+
+/*
+ * XTI to Linux protocol table.
+ */
+static int inet_prot[16] = {
+	IPPROTO_ICMP,	IPPROTO_ICMP,
+	IPPROTO_IGMP,	IPPROTO_IPIP,
+	IPPROTO_TCP,	IPPROTO_EGP,
+	IPPROTO_PUP,	IPPROTO_UDP,
+	IPPROTO_IDP,	IPPROTO_RAW,
+};
+
+static int inet_type[16] = {
+	SOCK_RAW,	SOCK_RAW,
+	SOCK_RAW,	SOCK_RAW,
+	SOCK_STREAM,	SOCK_RAW,
+	SOCK_RAW,	SOCK_DGRAM,
+	SOCK_RAW,	SOCK_RAW,
+};
+
+
+static int
+xti_connect(struct file *fp, u_int fd, dev_t dev)
+{
+	int			family, type, prot = 0, i, s;
+	mm_segment_t		fs;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+		"XTI: %d get socket for transport end point "
+		"(dev = 0x%04x)\n", fd, dev);
+#endif
+	
+	switch ((family = ((MINOR(dev) >> 4) & 0x0f))) {
+	case AF_UNIX:
+		type = SOCK_STREAM;
+		break;
+	case AF_INET:
+		i = MINOR(dev) & 0x0f;
+		type = inet_type[i];
+		prot = inet_prot[i];
+		break;
+	default:
+		type = SOCK_RAW;
+		break;
+	}	
+
+	fput(fp);
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+		"XTI: %d socket %d %d %d\n",
+		fd, family, type, prot);
+#endif
+
+	fs = get_fs();
+	set_fs(get_ds());
+	s = sys_socket(family, type, prot);
+	set_fs(fs);
+
+	return (s);
+}
+
+int
+socksys_fdinit(int fd, int rw, const char *buf, int *count)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			sockfd, error = -EINVAL;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS, "socksys: fd=%d initializing\n", fd);
+#endif
+
+	fp = fget(fd);
+	if (!fp)
+		return -EBADF;
+	ip = fp->f_dentry->d_inode;
+
+	/*
+	 * Minor = 0 is the socksys device itself. No special handling
+	 *           will be needed as it is controlled by the application
+	 *           via ioctls.
+	 */
+	if (MINOR(ip->i_rdev) == 0)
+		goto fput;
+
+	/*
+	 * Minor = 1 is the spx device. This is the client side of a
+	 *           streams pipe to the X server. Under SCO and friends
+	 *           the library code messes around setting the connection
+	 *           up itself. We do it ourselves - this means we don't
+	 *           need to worry about the implementation of the server
+	 *           side (/dev/X0R - which must exist but can be a link
+	 *           to /dev/null) nor do we need to actually implement
+	 *           getmsg/putmsg.
+	 */
+	if (MINOR(ip->i_rdev) == 1) {
+		int unit = 1;
+
+		/*
+		 * It seems early spx implementations were just a
+		 * quick hack to get X to work. They only supported
+		 * one destination and connected automatically.
+		 * Later versions take a single byte write, the
+		 * value of the byte telling them which destination
+		 * to connect to. Hence this quick hack to work
+		 * with both. If the first write is a single byte
+		 * it's a connect request otherwise we auto-connect
+		 * to destination 1.
+		 */
+#if 0
+		if (rw == 1 && *count == 1) {
+			error = get_user(unit, buf);
+			if (error)
+				goto fput;
+			(*count)--;
+		}
+#endif
+
+		fput(fp);
+
+		sockfd = spx_connect(fd, unit);
+	} else {
+		/*
+		 * Otherwise the high 4 bits specify the address/protocol
+		 * family (AF_INET, AF_UNIX etc.) and the low 4 bits determine
+		 * the protocol (IPPROTO_IP, IPPROTO_UDP, IPPROTO_TCP etc.)
+		 * although not using a one-to-one mapping as the minor number
+		 * is not big enough to hold everything directly. The socket
+		 * type is inferrred from the protocol.
+		 */
+		sockfd = xti_connect(fp, fd, ip->i_rdev);
+	}
+
+	/*
+	 * Give up if we weren't able to allocate a socket.
+	 * There is no sense in plying our funny game without a new fd.
+	 */
+	if (sockfd < 0)
+		return sockfd;
+
+	/*
+	 * Redirect operations on the socket fd via our emulation
+	 * handlers then swap the socket fd and the original fd,
+	 * discarding the original fd.
+	 */
+	inherit_socksys_funcs(sockfd, TS_UNBND);
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS, "XTI: %d -> %d\n", fd, sockfd);
+#endif
+
+	sys_dup2(sockfd, fd);
+	sys_close(sockfd);
+	return 1;
+
+fput:
+	fput(fp);
+	return error;
+}
+
+static int
+socksys_open(struct inode *ip, struct file *fp)
+{
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS,
+		"socksys: fp=0x%p, ip=0x%p opening\n", fp, ip);
+#endif
+	return 0;
+}
+
+#ifdef CONFIG_ABI_XTI
+static int
+socksys_release(struct inode *ip, struct file *fp)
+{
+	int			error = 0;
+
+	/*
+	 * Not being a socket is not an error - it is probably
+	 * just the pseudo device transport provider.
+	 */
+	if (!ip || !ip->i_sock)
+		goto out;
+
+	if (fp->private_data) {
+		struct T_primsg	*it;
+
+		it = ((struct T_private *)fp->private_data)->pfirst;
+		while (it) {
+			struct T_primsg *tmp = it;
+			it = it->next;
+			kfree(tmp);
+		}
+		kfree(fp->private_data);
+	}
+	error = socket_file_ops.release(ip, fp);
+out:
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_SOCKSYS, "socksys: %p closed\n", fp);
+#endif
+	return error;
+}
+
+static u_int
+socksys_poll(struct file *fp, struct poll_table_struct *wait)
+{
+	struct inode		*ip = fp->f_dentry->d_inode;
+	u_int			mask = 0;
+
+	/*
+	 * If this is a timod transport end point and there
+	 * is a control message queued we have readable data.
+	 */
+	if (ip && ip->i_sock && MINOR(ip->i_rdev) != 1) {
+		if (Priv(fp) && Priv(fp)->pfirst) {
+			if (Priv(fp)->pfirst->pri == MSG_HIPRI)
+				mask |= POLLPRI;
+			else
+				mask |= POLLIN;
+		}
+	}
+
+	return (mask | socket_file_ops.poll(fp, wait));
+}
+#endif
+
+static int
+socksys_read(struct file *fp, char *buf, size_t count, loff_t *ppos)
+{
+	int			fd, error;
+
+	if (fp->f_dentry->d_inode->i_sock)
+		BUG();
+
+	for (fd = 0; fd < current->files->max_fdset; fd++) {
+		if (fcheck(fd) == fp) {
+			error = socksys_fdinit(fd, 0, NULL, NULL);
+			if (error < 0)
+				return error;
+			fput(fp);
+			fp = fget(fd);
+			return fp->f_op->read(fp, buf, count, ppos);
+		}
+	}
+
+	return -EINVAL;
+}
+
+static int
+socksys_write(struct file *fp, const char *buf, size_t count, loff_t *ppos)
+{
+	int			fd, error;
+
+	if (fp->f_dentry->d_inode->i_sock)
+		BUG();
+
+	for (fd = 0; fd < current->files->max_fdset; fd++) {
+		if (fcheck(fd) == fp) {
+			error = socksys_fdinit(fd, 1, buf, &count);
+			if (error < 0)
+				return error;
+			fput(fp);
+			fp = fget(fd);
+			if (count == 1)
+				return 1;
+			printk("count=%d\n", count);
+			return fp->f_op->write(fp, buf, count, ppos);
+		}
+	}
+
+	return -EINVAL;
+}
+
+
+/*
+ * Get a socket but replace the socket file
+ * operations with our own so we can do the
+ * right thing for ioctls.
+ */
+static int
+socksys_socket(u_long *sp)
+{
+	u_long			x;
+	int			fd;
+
+	get_user(x, ((u_long *)sp)+0);
+	put_user(map_value(current_thread_info()->exec_domain->af_map, x, 0), sp+0);
+	get_user(x, ((u_long *)sp)+1);
+	put_user(map_value(current_thread_info()->exec_domain->socktype_map, x, 0), sp+1);
+
+	fd = sys_socketcall(SYS_SOCKET, sp);
+	if (fd >= 0)
+		inherit_socksys_funcs(fd, TS_UNBND);
+	return fd;
+}
+
+static int
+socksys_accept(u_long *sp)
+{
+	int			fd;
+
+	fd = sys_socketcall(SYS_ACCEPT, sp);
+	if (fd >= 0)
+		inherit_socksys_funcs(fd, TS_DATA_XFER);
+	return fd;
+}
+
+static int
+socksys_getipdomain(u_long *sp)
+{
+	char			*name, *p;
+	int			error, len;
+
+	error = get_user((u_long)name, (char *)(sp+0));
+	if (error)
+		return error;
+	
+	get_user(len, sp+1);
+	if (error)
+		return error;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, name, len);
+	if (!error) {
+		--len;
+		for (p = system_utsname.nodename; *p && *p != '.'; p++)
+			;
+		if (*p == '.')
+			p++;
+		else
+			p = system_utsname.domainname;
+
+		if (strcmp(p, "(none)")) {
+			for (; *p && len > 0; p++,len--) {
+				__put_user(*p, name);
+				name++;
+			}
+		}
+		__put_user('\0', name);
+	}
+	up_read(&uts_sem);
+	return error;
+}
+
+static int
+socksys_setipdomain(u_long *sp)
+{
+	char			*name, *p;
+	int			error, len, togo;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	error = get_user((unsigned long) name, (char *)(sp+0));
+	if (error)
+		return error;
+
+	error = get_user(len, sp+1);
+	if (error)
+		return error;
+
+	down_write(&uts_sem);
+	togo = __NEW_UTS_LEN;
+	for (p = system_utsname.nodename; *p && *p != '.'; p++,togo--)
+		;
+	if (*p == '.')
+		p++,togo--;
+
+	error = -EINVAL;
+	if (len <= togo) {
+		while (len-- > 0) {
+			get_user(*p, name);
+			p++;
+			name++;
+		}
+		*p = '\0';
+		error = 0;
+	}
+	up_write(&uts_sem);
+	return error;
+}
+
+static int
+socksys_setreugid(int cmd, u_long *sp)
+{
+	uid_t			ruid, euid;
+	int			error;
+
+	error = get_user(ruid, sp+0);
+	if (error)
+		return error;
+
+	error = get_user(euid, sp+1);
+	if (error)
+		return error;
+	
+	return (cmd == SSYS_SO_SETREUID) ?
+		sys_setreuid16(ruid, euid) :
+		  sys_setregid16(ruid, euid);
+}
+
+/*
+ * Get a socketpair but replace the socket file
+ * operations with our own so we can do the
+ * right thing for ioctls.
+ */
+static int
+socksys_socketpair(u_long *sp)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	mm_segment_t		fs;
+	int			pairin[2], pairout[2];
+	int			error;
+
+	/*
+	 * The first two arguments are file descriptors
+	 * of sockets which have already been opened
+	 * and should now be connected back to back.
+	 */
+	error = get_user(pairin[0], sp+0);
+	if (!error)
+		error = get_user(pairin[1], sp+1);
+	if (error)
+		return error;
+
+	fp = fget(pairin[0]);
+	if (!fp)
+		return -EBADF;
+	ip = fp->f_dentry->d_inode;
+	
+	fput(fp); /* this looks boguos */
+	if (!ip || !ip->i_sock)
+		return -EBADF;
+
+
+	/*
+	 * XXX Do we need to close these here?
+	 * XXX If we fail to connect them should they be open?
+	 */
+	sys_close(pairin[0]);
+	sys_close(pairin[1]);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_socketpair(AF_UNIX, SOCKET_I(ip)->type, 0, pairout);
+	set_fs(fs);
+
+	if (error < 0)
+		return error;
+
+	if (pairout[0] != pairin[0]) {
+		sys_dup2(pairout[0], pairin[0]);
+		sys_close(pairout[0]);
+	}
+
+	if (pairout[1] != pairin[1]) {
+		sys_dup2(pairout[1], pairin[1]);
+		sys_close(pairout[1]);
+	}
+
+	inherit_socksys_funcs(pairin[0], TS_DATA_XFER);
+	inherit_socksys_funcs(pairin[1], TS_DATA_XFER);
+	return 0;
+}
+
+int
+socksys_syscall(u_long *sp)
+{
+	int error, cmd;
+
+	error = get_user(cmd, sp);
+	if (error)
+		return error;
+	sp++;
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_SOCKSYS)) {
+		u_long a0, a1, a2, a3, a4, a5;
+		static const char * const cmd_map[] = {
+			"", "accept", "bind", "connect", "getpeername",
+			"getsockname", "getsockopt", "listen", "recv",
+			"recvfrom", "send", "sendto", "setsockopt", "shutdown",
+			"socket", "select", "getipdomain", "setipdomain",
+			"adjtime", "setreuid", "setregid", "gettimeofday",
+			"settimeofday", "getitimer", "setitimer",
+			"recvmsg", "sendmsg", "sockpair"
+		};
+
+		get_user(a0, sp+0);
+		get_user(a1, sp+1);
+		get_user(a2, sp+2);
+		get_user(a3, sp+3);
+		get_user(a4, sp+4);
+		get_user(a5, sp+5);
+
+		__abi_trace("socksys: %s (%d) "
+				"<0x%lx,0x%lx,0x%lx,0x%lx,0x%lx,0x%lx>\n",
+				(cmd >= 0 &&
+				 cmd < sizeof(cmd_map) / sizeof(cmd_map[0]))
+				? cmd_map[cmd] : "???", cmd,
+				a0, a1, a2, a3, a4, a5);
+	}
+#endif
+
+	switch (cmd) {
+	case SSYS_SO_SOCKET:
+		return socksys_socket(sp);
+	case SSYS_SO_ACCEPT:
+		return socksys_accept(sp);
+	case SSYS_SO_BIND:
+		return sys_socketcall(SYS_BIND, sp);
+	case SSYS_SO_CONNECT:
+		return sys_socketcall(SYS_CONNECT, sp);
+	case SSYS_SO_GETPEERNAME:
+		return sys_socketcall(SYS_GETPEERNAME, sp);
+	case SSYS_SO_GETSOCKNAME:
+		return sys_socketcall(SYS_GETSOCKNAME, sp);
+	case SSYS_SO_GETSOCKOPT:
+		return abi_do_getsockopt((u_long *)sp);
+	case SSYS_SO_LISTEN:
+		return sys_socketcall(SYS_LISTEN, sp);
+	case SSYS_SO_RECV:
+		if ((error = sys_socketcall(SYS_RECV, sp)) == -EAGAIN)
+			return -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_RECVFROM:
+		if ((error = sys_socketcall(SYS_RECVFROM, sp)) == -EAGAIN)
+			return -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_SEND:
+		if ((error = sys_socketcall(SYS_SEND, sp)) == -EAGAIN)
+			error = -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_SENDTO:
+		if ((error = sys_socketcall(SYS_SENDTO, sp)) == -EAGAIN)
+			error = -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_SETSOCKOPT:
+		return abi_do_setsockopt(sp);
+	case SSYS_SO_SHUTDOWN:
+		return sys_socketcall(SYS_SHUTDOWN, sp);
+	case SSYS_SO_GETIPDOMAIN:
+		return socksys_getipdomain(sp);
+	case SSYS_SO_SETIPDOMAIN:
+		return socksys_setipdomain(sp);
+	case SSYS_SO_SETREUID:
+	case SSYS_SO_SETREGID:
+		return socksys_setreugid(cmd, sp);
+	case SSYS_SO_GETTIME:
+	case SSYS_SO_SETTIME:
+	{
+		struct timeval *tv;
+		struct timezone *tz;
+
+		error = get_user((unsigned long) tv, sp+0);
+		if (!error)
+			error = get_user((unsigned long) tz, sp+1);
+		if (error)
+			return error;
+		return (cmd == SSYS_SO_GETTIME)
+			? sys_gettimeofday(tv, tz)
+			: sys_settimeofday(tv, tz);
+	}
+
+	case SSYS_SO_GETITIMER:
+	{
+		int which;
+		struct itimerval *value;
+
+		error = get_user((unsigned long) which, sp+0);
+		if (!error)
+			error = get_user((unsigned long) value, sp+1);
+		if (error)
+			return error;
+		return sys_getitimer(which, value);
+	}
+	case SSYS_SO_SETITIMER:
+	{
+		int which;
+		struct itimerval *value, *ovalue;
+
+		error = get_user((unsigned long) which, sp+0);
+		if (!error)
+			error = get_user((unsigned long) value, sp+1);
+		if (!error)
+			error = get_user((unsigned long) ovalue, sp+2);
+		if (error)
+			return error;
+		return sys_setitimer(which, value, ovalue);
+	}
+
+#if BUGGY
+	case SSYS_SO_SELECT:
+		/*
+		 * This may be wrong? I don't know how to trigger
+		 * this case. Select seems to go via the Xenix
+		 * select entry point.
+		 */
+		return sys_select(sp);
+#endif
+
+	case SSYS_SO_ADJTIME:
+		return -EINVAL;
+
+	/*
+	 * These appear in SCO 3.2v5. I assume that the format of
+	 * a msghdr is identical with Linux. I have not checked.
+	 */
+	case SSYS_SO_RECVMSG:
+		if ((error = sys_socketcall(SYS_RECVMSG, sp)) == -EAGAIN)
+			error = -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_SENDMSG:
+		if ((error = sys_socketcall(SYS_SENDMSG, sp)) == -EAGAIN)
+			error = -EWOULDBLOCK;
+		return error;
+	case SSYS_SO_SOCKPAIR:
+		return socksys_socketpair(sp);
+	}
+
+	return -EINVAL;
+}
+
+static int
+socksys_getdomainname(caddr_t arg)
+{
+	struct domnam_args	dn;
+	char			*p;
+	int			error;
+
+	if (copy_from_user(&dn, arg, sizeof(struct domnam_args)))
+		return -EFAULT;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, dn.name, dn.namelen);
+	if (!error) {
+		--dn.namelen;
+		for (p = system_utsname.domainname; *p && dn.namelen > 0; p++) {
+			__put_user(*p, dn.name);
+			dn.name++;
+			dn.namelen--;
+		}
+		__put_user('\0', dn.name);
+	}
+	up_read(&uts_sem);
+	return error;
+}
+
+static int
+socksys_setdomainname(caddr_t arg)
+{
+	struct domnam_args	dn;
+
+	if (copy_from_user(&dn, arg, sizeof(struct domnam_args)))
+		return -EFAULT;
+	return sys_setdomainname(dn.name, dn.namelen);
+}
+
+/*
+ * I think this was used before symlinks were added
+ * to the base SCO OS?
+ */
+static int
+socksys_lstat(caddr_t arg)
+{
+	struct lstat_args	st;
+			
+	if (copy_from_user(&st, arg, sizeof(struct lstat_args)))
+		return -EFAULT;
+	return svr4_lstat(st.fname, st.statb);
+}
+
+static int
+socksys_getfh(caddr_t arg)
+{
+	struct getfh_args	gf;
+	struct nameidata	nd;
+	int			error;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (copy_from_user(&gf, arg, sizeof(struct getfh_args)))
+		return -EFAULT;
+
+	error = verify_area(VERIFY_WRITE, gf.fhp, sizeof(fhandle_t));
+	if (error)
+		return error;
+
+	error = user_path_walk(gf.fname, &nd);
+	if (error)
+		return error;
+
+	error = do_revalidate(nd.dentry);
+	if (!error) {
+		struct inode	*ip = nd.dentry->d_inode;
+
+		__put_user(ip->i_rdev, &gf.fhp->fh.fsid);
+		__put_user(ip->i_ino, &gf.fhp->fh.fno);
+		__put_user(0L, &gf.fhp->fh.fgen);
+		__put_user(ip->i_rdev, &gf.fhp->fh.ex_fsid);
+		__put_user(ip->i_ino, &gf.fhp->fh.ex_fno);
+		__put_user(0L, &gf.fhp->fh.ex_fgen);
+		error = 0;
+	}
+	path_release(&nd);
+	return error;
+}
+
+static int
+socksys_getpeername(int fd, caddr_t arg)
+{
+	struct sockaddr		uaddr;
+	int			addrlen;
+	mm_segment_t		fs;
+	int			error;
+
+	addrlen = sizeof(struct sockaddr);
+	
+	error = verify_area(VERIFY_WRITE, arg, addrlen);
+	if (error)
+		return error;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_getpeername(fd, &uaddr, &addrlen);
+	set_fs(fs);
+
+	if (error >= 0)
+		copy_to_user(arg, &uaddr, addrlen);
+	return error;
+}
+
+static int
+socksys_getsockname(int fd, caddr_t arg)
+{
+	struct sockaddr		uaddr;
+	int			addrlen;
+	mm_segment_t		fs;
+	int			error;
+
+	addrlen = sizeof(struct sockaddr);
+
+	error = verify_area(VERIFY_WRITE, arg, addrlen);
+	if (error)
+		return error;
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_getsockname(fd, &uaddr, &addrlen);
+	set_fs(fs);
+
+	if (error >= 0)
+		copy_to_user(arg, &uaddr, addrlen);
+	return error;
+}
+
+static int		
+socksys_gifonep(caddr_t data)
+{
+	return -EOPNOTSUPP;
+}
+
+static int
+socksys_sifonep(caddr_t data)
+{
+#if 0
+	struct svr4_ifreq	*ifr = (struct svr4_ifreq *)data;
+
+	printk("SIOCSIFONEP (spsize = %x, spthresh = %x) not supported\n",
+			ifr->svr4_ifr_onepacket.spsize,
+			ifr->svr4_ifr_onepacket.spthresh);
+#endif
+	return -EOPNOTSUPP;
+}
+
+int
+abi_ioctl_socksys(int fd, unsigned int cmd, caddr_t arg)
+{
+	int error;
+
+	switch (cmd) {
+	/*
+	 * Strictly the ip domain and nis domain are separate and
+	 * distinct under SCO but Linux only has the one domain.
+	 */
+	case NIOCGETDOMNAM:
+		return socksys_getdomainname(arg);
+	case NIOCSETDOMNAM:
+		return socksys_setdomainname(arg);
+	case NIOCLSTAT:
+		return socksys_lstat(arg);
+	case NIOCOLDGETFH:
+	case NIOCGETFH:
+		return socksys_getfh(arg);
+	case NIOCNFSD:
+	case NIOCASYNCD:
+	case NIOCCLNTHAND:
+	case NIOCEXPORTFS:
+		return -EINVAL;
+
+	case SSYS_SIOCSOCKSYS:		/* Pseudo socket syscall */
+	case SVR4_SIOCSOCKSYS:
+		return socksys_syscall((u_long *)arg);
+
+	case SSYS_SIOCSHIWAT:		/* set high watermark */
+	case SVR4_SIOCSHIWAT:
+	case SSYS_SIOCSLOWAT:		/* set low watermark */
+	case SVR4_SIOCSLOWAT:
+		/*
+		 * Linux doesn't support them but lie anyway
+		 * or some things take it as fatal (why?)
+		 *
+		 * FIXME: actually we can do this now...
+		 */
+		return 0;
+	case SSYS_SIOCGHIWAT:		/* get high watermark */
+	case SVR4_SIOCGHIWAT:
+	case SSYS_SIOCGLOWAT:		/* get low watermark */
+	case SVR4_SIOCGLOWAT:
+		/*
+		 * Linux doesn't support them but lie anyway
+		 * or some things take it as fatal (why?)
+		 *
+		 * FIXME: actually we can do this now...
+		 */
+		if ((error = verify_area(VERIFY_WRITE, arg, sizeof(u_long))))
+			return error;
+		put_user(0, (u_long *)arg);
+		return 0;
+	case SSYS_SIOCATMARK:		/* at oob mark? */
+	case SVR4_SIOCATMARK:
+		return sys_ioctl(fd, SIOCATMARK, (long)arg);
+
+	case SSYS_SIOCSPGRP:		/* set process group */
+	case SVR4_SIOCSPGRP:
+		return sys_ioctl(fd, SIOCSPGRP, (long)arg);
+	case SSYS_SIOCGPGRP:		/* get process group */
+	case SVR4_SIOCGPGRP:
+		return sys_ioctl(fd, SIOCGPGRP, (long)arg);
+
+	case FIONREAD:
+	case SSYS_FIONREAD:		/* BSD compatibilty */
+		error = sys_ioctl(fd, TIOCINQ, (long)arg);
+#if defined(CONFIG_ABI_TRACE)
+		if (!error && abi_traced(ABI_TRACE_SOCKSYS)) {
+			u_long n;
+
+			get_user(n, (u_long *)arg);
+			__abi_trace("socksys: %d FIONREAD "
+					"found %lu bytes ready\n",
+					fd, n);
+		}
+#endif
+		return error;
+	case SSYS_FIONBIO: 		/* BSD compatibilty */
+		return sys_ioctl(fd, FIONBIO, (long)arg);
+	case SSYS_FIOASYNC: 		/* BSD compatibilty */
+		return sys_ioctl(fd, FIOASYNC, (long)arg);
+	case SSYS_SIOCADDRT:		/* add route */
+	case SVR4_SIOCADDRT:
+		return sys_ioctl(fd, SIOCADDRT, (long)arg);
+	case SSYS_SIOCDELRT:		/* delete route */
+	case SVR4_SIOCDELRT:
+		return sys_ioctl(fd, SIOCDELRT, (long)arg);
+	case SSYS_SIOCSIFADDR:		/* set ifnet address */
+	case SVR4_SIOCSIFADDR:
+		return sys_ioctl(fd, SIOCSIFADDR, (long)arg);
+	case SSYS_SIOCGIFADDR:		/* get ifnet address */
+	case SVR4_SIOCGIFADDR:
+		return sys_ioctl(fd, SIOCGIFADDR, (long)arg);
+	case SSYS_SIOCSIFDSTADDR:	/* set p-p address */
+	case SVR4_SIOCSIFDSTADDR:
+		return sys_ioctl(fd, SIOCSIFDSTADDR, (long)arg);
+	case SSYS_SIOCGIFDSTADDR:	/* get p-p address */
+	case SVR4_SIOCGIFDSTADDR:
+		return sys_ioctl(fd, SIOCGIFDSTADDR, (long)arg);
+	case SSYS_SIOCSIFFLAGS:		/* set ifnet flags */
+	case SVR4_SIOCSIFFLAGS:
+		return sys_ioctl(fd, SIOCSIFFLAGS, (long)arg);
+	case SSYS_SIOCGIFFLAGS:		/* get ifnet flags */
+	case SVR4_SIOCGIFFLAGS:
+#if 0
+	case SVRX_SIOCGIFFLAGS:
+#endif
+		return sys_ioctl(fd, SIOCGIFFLAGS, (long)arg);
+	case SSYS_SIOCGIFCONF:		/* get ifnet list */
+	case SVR4_SIOCGIFCONF:
+#if 0
+	case SVRX_SIOCGIFCONF:
+#endif
+		return sys_ioctl(fd, SIOCGIFCONF, (long)arg);
+	case SSYS_SIOCGIFBRDADDR:	/* get broadcast addr */
+	case SVR4_SIOCGIFBRDADDR:
+		return sys_ioctl(fd, SIOCGIFBRDADDR, (long)arg);
+	case SSYS_SIOCSIFBRDADDR:	/* set broadcast addr */
+	case SVR4_SIOCSIFBRDADDR:
+		return sys_ioctl(fd, SIOCSIFBRDADDR, (long)arg);
+	case SSYS_SIOCGIFNETMASK:	/* get net addr mask */
+	case SVR4_SIOCGIFNETMASK:
+		return sys_ioctl(fd, SIOCGIFNETMASK, (long)arg);
+	case SSYS_SIOCSIFNETMASK:	/* set net addr mask */
+		return sys_ioctl(fd, SIOCSIFNETMASK, (long)arg);
+	case SSYS_SIOCGIFMETRIC:	/* get IF metric */
+	case SVR4_SIOCGIFMETRIC:
+		return sys_ioctl(fd, SIOCGIFMETRIC, (long)arg);
+	case SSYS_SIOCSIFMETRIC:	/* set IF metric */
+	case SVR4_SIOCSIFMETRIC:
+		return sys_ioctl(fd, SIOCSIFMETRIC, (long)arg);
+	case SSYS_SIOCSARP:		/* set arp entry */
+	case SVR4_SIOCSARP:
+		return sys_ioctl(fd, SIOCSARP, (long)arg);
+	case SSYS_SIOCGARP:		/* get arp entry */
+	case SVR4_SIOCGARP:
+		return sys_ioctl(fd, SIOCGARP, (long)arg);
+	case SSYS_SIOCDARP:		/* delete arp entry */
+	case SVR4_SIOCDARP:
+		return sys_ioctl(fd, SIOCDARP, (long)arg);
+	case SSYS_SIOCGENADDR:		/* Get ethernet addr */
+	case SVR4_SIOCGENADDR:
+		return sys_ioctl(fd, SIOCGIFHWADDR, (long)arg);
+	case SSYS_SIOCSIFMTU:		/* get if_mtu */
+	case SVR4_SIOCSIFMTU:
+		return sys_ioctl(fd, SIOCSIFMTU, (long)arg);
+	case SSYS_SIOCGIFMTU:		/* set if_mtu */
+	case SVR4_SIOCGIFMTU:
+		return sys_ioctl(fd, SIOCGIFMTU, (long)arg);
+
+	case SSYS_SIOCGETNAME:		/* getsockname */
+	case SVR4_SIOCGETNAME:
+		return socksys_getsockname(fd, arg);
+	case SSYS_SIOCGETPEER: 		/* getpeername */
+	case SVR4_SIOCGETPEER:
+		return socksys_getpeername(fd, arg);
+
+	case SSYS_IF_UNITSEL:		/* set unit number */
+	case SVR4_IF_UNITSEL:
+	case SSYS_SIOCXPROTO:		/* empty proto table */
+	case SVR4_SIOCXPROTO:
+
+	case SSYS_SIOCIFDETACH:		/* detach interface */
+	case SVR4_SIOCIFDETACH:
+	case SSYS_SIOCGENPSTATS:	/* get ENP stats */
+	case SVR4_SIOCGENPSTATS:
+
+	case SSYS_SIOCSIFNAME:		/* set interface name */
+	case SVR4_SIOCSIFNAME:
+
+	case SSYS_SIOCPROTO:		/* link proto */
+	case SVR4_SIOCPROTO:
+	case SSYS_SIOCX25XMT:
+	case SVR4_SIOCX25XMT:
+	case SSYS_SIOCX25RCV:
+	case SVR4_SIOCX25RCV:
+	case SSYS_SIOCX25TBL:
+	case SVR4_SIOCX25TBL:
+
+	case SSYS_SIOCGIFONEP:		/* get one-packet params */
+		return socksys_gifonep(arg);
+	case SSYS_SIOCSIFONEP:		/* set one-packet params */
+		return socksys_sifonep(arg);
+
+	default:
+		printk(KERN_DEBUG "%d iBCS: socksys: %d: ioctl 0x%x with argument 0x%p requested\n",
+			current->pid, fd, cmd, arg);
+		break;
+	}
+
+	return -EINVAL;
+}
+
+static int __init
+socksys_init(void)
+{
+	int ret;
+
+	if ((ret = register_chrdev(SOCKSYS_MAJOR, "socksys", &socksys_fops))) {
+		printk(KERN_ERR "abi: unable register socksys char major\n");
+		return (ret);
+	}
+
+	fops_get(&socket_file_ops);
+	socksys_socket_fops = socket_file_ops;
+#ifdef CONFIG_ABI_XTI
+	socksys_socket_fops.release = socksys_release;
+	socksys_socket_fops.poll = socksys_poll;
+#endif
+	return (0);
+}
+
+static void __exit
+socksys_exit(void)
+{
+	fops_put(&socket_file_ops);
+	unregister_chrdev(SOCKSYS_MAJOR, "socksys");
+}
+
+module_init(socksys_init);
+module_exit(socksys_exit);
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(abi_ioctl_socksys);
+EXPORT_SYMBOL(socksys_syscall);
+#endif
diff -Nru linux-2.6.7/abi/svr4/stat.c linux-2.6.7-abi/abi/svr4/stat.c
--- linux-2.6.7/abi/svr4/stat.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/stat.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SVR4 stat & friends support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/types.h>
+#include <abi/svr4/stat.h>
+
+#include <abi/util/stat.h>
+#include <abi/util/trace.h>
+
+
+enum {SVR4_stat = 1, SVR4_xstat = 2};
+
+int
+report_svr4_stat(struct kstat *stp, struct svr4_stat *bufp)
+{
+	struct svr4_stat buf;
+
+	memset(&buf, 0, sizeof(struct svr4_stat));
+
+
+	buf.st_dev	= linux_to_svr4_o_dev_t(stp->dev);
+	buf.st_ino	= linux_to_svr4_o_ino_t(stp->ino);
+	buf.st_mode	= stp->mode;
+	buf.st_nlink	= stp->nlink;
+	buf.st_uid	= linux_to_svr4_o_uid_t(stp->uid);
+	buf.st_gid	= linux_to_svr4_o_gid_t(stp->gid);
+	buf.st_rdev	= linux_to_svr4_o_dev_t(stp->rdev);
+
+	if (stp->size > MAX_NON_LFS)
+		return -EOVERFLOW;	/* XXX: what to return for SVR4?? */
+
+	buf.st_size	= stp->size;
+
+	buf.st_atime	= stp->atime.tv_sec;
+	buf.st_mtime	= stp->mtime.tv_sec;
+	buf.st_ctime 	= stp->ctime.tv_sec;
+
+	if (copy_to_user(bufp, &buf, sizeof(struct svr4_stat)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+report_svr4_xstat(struct kstat *stp, struct svr4_xstat *bufp)
+{
+	struct svr4_xstat buf;
+
+	memset(&buf, 0, sizeof(struct svr4_xstat));
+
+
+	buf.st_dev	= linux_to_svr4_dev_t(stp->dev);
+	buf.st_ino	= linux_to_svr4_ino_t(stp->ino);
+	buf.st_mode	= stp->mode;
+	buf.st_nlink	= stp->nlink;
+	buf.st_uid	= linux_to_svr4_uid_t(stp->uid);
+	buf.st_gid	= linux_to_svr4_gid_t(stp->gid);
+	buf.st_rdev	= linux_to_svr4_dev_t(stp->rdev);
+
+	if (stp->size > MAX_NON_LFS)
+		return -EOVERFLOW;	/* XXX: what to return for SVR4?? */
+
+	buf.st_size	= stp->size;
+
+	buf.st_atim.tv_sec = stp->atime.tv_sec;
+	buf.st_atim.tv_usec = stp->atime.tv_nsec / 1000;
+	buf.st_mtim.tv_sec = stp->mtime.tv_sec;
+	buf.st_mtim.tv_usec = stp->mtime.tv_nsec / 1000;
+	buf.st_ctim.tv_sec = stp->ctime.tv_sec;
+	buf.st_ctim.tv_usec = stp->ctime.tv_nsec / 1000;
+
+	buf.st_blksize	= stp->blksize;
+	buf.st_blocks	= stp->blocks;
+
+	if (copy_to_user(bufp, &buf, sizeof(struct svr4_xstat)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+svr4_stat(char *filename, struct svr4_stat *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_stat(filename, &st);
+	if (!error)
+		error = report_svr4_stat(&st, bufp);
+	return error;
+}
+
+int
+svr4_lstat(char *filename, struct svr4_stat *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_lstat(filename, &st);
+	if (!error)
+		error = report_svr4_stat(&st, bufp);
+	return error;
+}
+
+int
+svr4_fstat(int fd, struct svr4_stat *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_fstat(fd, &st);
+	if (!error)
+		error = report_svr4_stat(&st, bufp);
+	return error;
+}
+
+int
+svr4_xstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_stat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "xstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+svr4_lxstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_lstat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "lxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+svr4_fxstat(int vers, int fd, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_fstat(fd, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "fxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(report_svr4_stat);
+EXPORT_SYMBOL(report_svr4_xstat);
+EXPORT_SYMBOL(svr4_fstat);
+EXPORT_SYMBOL(svr4_fxstat);
+EXPORT_SYMBOL(svr4_lstat);
+EXPORT_SYMBOL(svr4_lxstat);
+EXPORT_SYMBOL(svr4_stat);
+EXPORT_SYMBOL(svr4_xstat);
+#endif
diff -Nru linux-2.6.7/abi/svr4/statvfs.c linux-2.6.7-abi/abi/svr4/statvfs.c
--- linux-2.6.7/abi/svr4/statvfs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/statvfs.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * SVR4 statvfs/fstatvfs support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/statfs.h>
+#include <linux/mount.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <linux/namei.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+
+struct svr4_statvfs {
+	u_int32_t  f_bsize;
+	u_int32_t  f_frsize;
+	u_int32_t  f_blocks;
+	u_int32_t  f_bfree;
+	u_int32_t  f_bavail;
+	u_int32_t  f_files;
+	u_int32_t  f_free;
+	u_int32_t  f_sid;
+	char	   f_basetype[16];
+	u_int32_t  f_flag;
+	u_int32_t  f_namemax;
+	char	   f_fstr[32];
+	u_int32_t  f_filler[16];
+};
+
+static int
+report_statvfs(struct vfsmount *mnt, struct inode *ip, struct svr4_statvfs *bufp)
+{
+	struct svr4_statvfs buf;
+	struct kstatfs s;
+	int error;
+
+	error = vfs_statfs(mnt->mnt_sb, &s);
+	if (error)
+		return error;
+
+	memset(&buf, 0, sizeof(struct svr4_statvfs));
+
+	buf.f_bsize	= s.f_bsize; 
+	buf.f_frsize	= s.f_bsize;
+	buf.f_blocks	= s.f_blocks;
+	buf.f_bfree	= s.f_bfree;
+	buf.f_bavail	= s.f_bavail;
+	buf.f_files	= s.f_files;
+	buf.f_free	= s.f_ffree;
+	buf.f_sid	= ip->i_sb->s_dev;
+
+	/* Get the name of the filesystem */
+	strcpy(buf.f_basetype, ip->i_sb->s_type->name);
+
+	/* Check for a few flags statvfs wants but statfs doesn't have. */
+	if (IS_RDONLY(ip))
+		buf.f_flag |= 1;
+	if (mnt->mnt_flags & MNT_NOSUID)
+		buf.f_flag |= 2;
+
+	buf.f_namemax	= s.f_namelen;
+
+	if (copy_to_user(bufp, &buf, sizeof(struct svr4_statvfs)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+svr4_statvfs(char *filename, struct svr4_statvfs *bufp)
+{
+	struct nameidata nd;
+	int error;
+
+	error = user_path_walk(filename, &nd);
+	if (!error) {
+		error = report_statvfs(nd.mnt, nd.dentry->d_inode, bufp);
+		path_release(&nd);
+	}
+	return error;
+}
+
+int
+svr4_fstatvfs(int fd, struct svr4_statvfs *bufp)
+{
+	struct file *fp;
+	int error = -EBADF;
+
+	fp = fget(fd);
+	if (fp) {
+		error = report_statvfs(fp->f_vfsmnt,
+				fp->f_dentry->d_inode, bufp);
+		fput(fp);
+	}
+	return error;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_statvfs);
+EXPORT_SYMBOL(svr4_fstatvfs);
+#endif
diff -Nru linux-2.6.7/abi/svr4/stream.c linux-2.6.7-abi/abi/svr4/stream.c
--- linux-2.6.7/abi/svr4/stream.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/stream.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,114 @@
+/*
+ * Copyright 1994,1995	Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/tli.h>
+
+
+#if !defined(CONFIG_ABI_XTI) && !defined(CONFIG_ABI_SPX)
+#  define timod_getmsg(fd, ino, is_pmsg, regs)	0
+#  define timod_putmsg(fd, ino, is_pmsg, regs)	0
+#endif
+
+/*
+ * Check if the inode belongs to /dev/spx.
+ */
+#define IS_SPX(ip) ((MAJOR((ip)->i_rdev) == 30 && MINOR((ip)->i_rdev) == 1))
+
+
+int
+svr4_getmsg(struct pt_regs *regs)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			fd;
+	int			error = -EBADF;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	fp = fget(fd);
+	if (fp) {
+		ip = fp->f_dentry->d_inode;
+		if (ip->i_sock)
+			error = timod_getmsg(fd, ip, 0, regs);
+		fput(fp);
+	}
+	return error;
+}
+
+int
+svr4_putmsg(struct pt_regs *regs)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			fd;
+	int			error = -EBADF;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	fp = fget(fd);
+	if (fp) {
+		ip = fp->f_dentry->d_inode;
+		if (ip->i_sock || IS_SPX(ip))
+			error = timod_putmsg(fd, ip, 0, regs);
+		fput(fp);
+	}
+	return error;
+}
+
+#ifdef CONFIG_ABI_XTI
+int
+svr4_getpmsg(struct pt_regs *regs)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			fd;
+	int			error = -EBADF;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	fp = fget(fd);
+	if (fp) {
+		ip = fp->f_dentry->d_inode;
+		if (ip->i_sock)
+			error = timod_getmsg(fd, ip, 1, regs);
+		fput(fp);
+	}
+	return error;
+}
+
+int
+svr4_putpmsg(struct pt_regs *regs)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			fd;
+	int			error = -EBADF;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	fp = fget(fd);
+	if (fp) {
+		ip = fp->f_dentry->d_inode;
+		if (ip->i_sock || IS_SPX(ip))
+			error = timod_putmsg(fd, ip, 1, regs);
+		fput(fp);
+	}
+	return error;
+}
+#endif /* CONFIG_ABI_XTI */
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_getmsg);
+EXPORT_SYMBOL(svr4_getpmsg);
+EXPORT_SYMBOL(svr4_putmsg);
+EXPORT_SYMBOL(svr4_putpmsg);
+#endif
diff -Nru linux-2.6.7/abi/svr4/svr4.c linux-2.6.7-abi/abi/svr4/svr4.c
--- linux-2.6.7/abi/svr4/svr4.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/svr4.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 1995	Mike Jagdis
+ */
+
+#ident "%W% %G%"
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/stddef.h>
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+#include <linux/fcntl.h>
+#include <linux/time.h>
+#include <linux/fs.h>
+#include <linux/statfs.h>
+#include <linux/sys.h>
+#include <linux/slab.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/svr4/sigset.h>
+#include <abi/svr4/siginfo.h>
+
+#include <abi/util/trace.h>
+
+
+/*
+ * Interactive SVR4's /bin/sh calls access(... 011) but Linux returns
+ * EINVAL if the access mode has any other bits than 007 set.
+ */
+
+int
+svr4_access(char *path, int mode)
+{
+	return sys_access(path, mode & 007);
+}
+
+
+enum {
+	SVR4_CLD_EXITED = 1,
+	SVR4_CLD_KILLED	= 2,
+	SVR4_CLD_DUMPED	= 3,
+	SVR4_CLD_TRAPPED = 4,
+	SVR4_CLD_STOPPED = 5,
+	SVR4_CLD_CONTINUED = 6
+};
+
+int
+svr4_waitid(int idtype, int id, struct svr4_siginfo *infop, int options)
+{
+	long result, kopt;
+	mm_segment_t old_fs;
+	int pid, status;
+
+	switch (idtype) {
+		case 0: /* P_PID */
+			pid = id;
+			break;
+
+		case 1: /* P_PGID */
+			pid = -id;
+			break;
+
+		case 7: /* P_ALL */
+			pid = -1;
+			break;
+
+		default:
+			return -EINVAL;
+	}
+
+	if (infop) {
+		result = verify_area(VERIFY_WRITE, infop,
+					sizeof(struct svr4_siginfo));
+		if (result)
+			return result;
+	}
+
+	kopt = 0;
+	if (options & 0100) kopt |= WNOHANG;
+	if (options & 4) kopt |= WUNTRACED;
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	result = sys_wait4(pid, &status, kopt, NULL);
+	set_fs(old_fs);
+	if (result < 0)
+		return result;
+
+	if (infop) {
+		unsigned long op, st;
+
+		put_user(current_thread_info()->exec_domain->signal_map[SIGCHLD],
+			&infop->si_signo);
+		put_user(result,
+			&infop->_data._proc._pid);
+
+		if ((status & 0xff) == 0) {
+			/* Normal exit. */
+			op = SVR4_CLD_EXITED;
+			st = status >> 8;
+		} else if ((status & 0xff) == 0x7f) {
+			/* Stopped. */
+			st = (status & 0xff00) >> 8;
+			op = (st == SIGSTOP || st == SIGTSTP)
+				? SVR4_CLD_STOPPED
+				: SVR4_CLD_CONTINUED;
+			st = current_thread_info()->exec_domain->signal_invmap[st];
+		} else {
+			st = (status & 0xff00) >> 8;
+			op = (status & 0200)
+				? SVR4_CLD_DUMPED
+				: SVR4_CLD_KILLED;
+			st = current_thread_info()->exec_domain->signal_invmap[st];
+		}
+		put_user(op, &infop->si_code);
+		put_user(st, &infop->_data._proc._pdata._cld._status);
+	}
+	return 0;
+}
+
+int
+svr4_seteuid(int uid)
+{
+	return sys_setreuid16(-1, uid);
+}
+
+int
+svr4_setegid(int gid)
+{
+	return sys_setregid16(-1, gid);
+}
+
+/* POSIX.1 names */
+#define _PC_LINK_MAX    1
+#define _PC_MAX_CANON   2
+#define _PC_MAX_INPUT   3
+#define _PC_NAME_MAX    4
+#define _PC_PATH_MAX    5
+#define _PC_PIPE_BUF    6
+#define _PC_NO_TRUNC    7
+#define _PC_VDISABLE    8
+#define _PC_CHOWN_RESTRICTED    9
+/* POSIX.4 names */
+#define _PC_ASYNC_IO    10
+#define _PC_PRIO_IO     11
+#define _PC_SYNC_IO     12
+
+int
+svr4_pathconf(char *path, int name)
+{
+	switch (name) {
+		case _PC_LINK_MAX:
+			/* Although Linux headers define values on a per
+			 * filesystem basis there is no way to access
+			 * these without hard coding fs information here
+			 * so for now we use a bogus value.
+			 */
+			return LINK_MAX;
+
+		case _PC_MAX_CANON:
+			return MAX_CANON;
+
+		case _PC_MAX_INPUT:
+			return MAX_INPUT;
+
+		case _PC_PATH_MAX:
+			return PATH_MAX;
+
+		case _PC_PIPE_BUF:
+			return PIPE_BUF;
+
+		case _PC_CHOWN_RESTRICTED:
+			/* We should really think about this and tell
+			 * the truth.
+			 */
+			return 0;
+
+		case _PC_NO_TRUNC:
+			/* Not sure... It could be fs dependent? */
+			return 1;
+
+		case _PC_VDISABLE:
+			return 1;
+
+		case _PC_NAME_MAX: {
+			struct statfs buf;
+			char *p;
+			int error;
+			mm_segment_t old_fs;
+
+			p = getname(path);
+			error = PTR_ERR(p);
+			if (!IS_ERR(p)) {
+				old_fs = get_fs();
+				set_fs (get_ds());
+				error = sys_statfs(p, &buf);
+				set_fs(old_fs);
+				putname(p);
+				if (!error)
+					return buf.f_namelen;
+			}
+			return error;
+		}
+	}
+
+	return -EINVAL;
+}
+
+int
+svr4_fpathconf(int fildes, int name)
+{
+	switch (name) {
+		case _PC_LINK_MAX:
+			/* Although Linux headers define values on a per
+			 * filesystem basis there is no way to access
+			 * these without hard coding fs information here
+			 * so for now we use a bogus value.
+			 */
+			return LINK_MAX;
+
+		case _PC_MAX_CANON:
+			return MAX_CANON;
+
+		case _PC_MAX_INPUT:
+			return MAX_INPUT;
+
+		case _PC_PATH_MAX:
+			return PATH_MAX;
+
+		case _PC_PIPE_BUF:
+			return PIPE_BUF;
+
+		case _PC_CHOWN_RESTRICTED:
+			/* We should really think about this and tell
+			 * the truth.
+			 */
+			return 0;
+
+		case _PC_NO_TRUNC:
+			/* Not sure... It could be fs dependent? */
+			return 1;
+
+		case _PC_VDISABLE:
+			return 1;
+
+		case _PC_NAME_MAX: {
+			struct statfs buf;
+			int error;
+			mm_segment_t old_fs;
+
+			old_fs = get_fs();
+			set_fs (get_ds());
+			error = sys_fstatfs(fildes, &buf);
+			set_fs(old_fs);
+			if (!error)
+				return buf.f_namelen;
+			return error;
+		}
+	}
+
+	return -EINVAL;
+}
+
+int
+svr4_sigpending(int which_routine, svr4_sigset_t *set)
+{
+	/* Solaris multiplexes on this one */
+	/* Which routine has the actual routine that should be called */
+
+	switch (which_routine){
+	case 1:			/* sigpending */
+		printk ("iBCS/Intel: sigpending not implemented\n");
+		return -EINVAL;
+		
+	case 2:			/* sigfillset */
+		set->setbits [0] = ~0;
+		set->setbits [1] = 0;
+		set->setbits [2] = 0;
+		set->setbits [3] = 0;
+		return 0;
+	}
+	return -EINVAL;
+}
+
+typedef void svr4_ucontext_t;
+
+static int
+svr4_setcontext(svr4_ucontext_t *c, struct pt_regs *regs)
+{
+	printk (KERN_DEBUG "Getting context\n");
+	return 0;
+}
+
+static int
+svr4_getcontext(svr4_ucontext_t *c, struct pt_regs *regs)
+{
+	printk (KERN_DEBUG "Setting context\n");
+	return 0;
+}
+
+int
+svr4_context(struct pt_regs *regs)
+{
+	int context_fn = get_syscall_parameter (regs, 0);
+	struct svr4_ucontext_t *uc = (void *) get_syscall_parameter (regs, 1);
+   
+	switch (context_fn){
+		case 0: /* getcontext */
+			return svr4_getcontext (uc, regs);
+
+		case 1: /* setcontext */
+			return svr4_setcontext (uc, regs);
+	}
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_context);
+EXPORT_SYMBOL(svr4_fpathconf);
+EXPORT_SYMBOL(svr4_pathconf);
+EXPORT_SYMBOL(svr4_setegid);
+EXPORT_SYMBOL(svr4_seteuid);
+EXPORT_SYMBOL(svr4_sigpending);
+EXPORT_SYMBOL(svr4_waitid);
+#endif
diff -Nru linux-2.6.7/abi/svr4/sysconf.c linux-2.6.7-abi/abi/svr4/sysconf.c
--- linux-2.6.7/abi/svr4/sysconf.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/sysconf.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,186 @@
+/*
+ * sysconf.c - sysv sysconf(2) and sysconfig(2) emulation
+ *
+ * Copyright (C) 1994	Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/stddef.h>
+#include <linux/limits.h>
+#include <linux/unistd.h>
+#include <linux/ptrace.h>
+#include <linux/fcntl.h>
+#include <linux/smp.h>
+#include <linux/swap.h>
+#include <linux/fs.h>
+#include <linux/sys.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+#include <abi/svr4/sysconf.h>
+#include <abi/util/trace.h>
+
+
+/* The sysconf() call is supposed to give applications access to various
+ * kernel parameters. According to SCO's man page this a POSIX mandated
+ * function. Perhaps it should be moved across as a native Linux call?
+ *
+ * N.B. SCO only has sysconf in the Xenix group. Therefore this is based
+ * on the Xenix spec. Is SVR4 the same? Wyse Unix V.3.2.1A doesn't have
+ * sysconf documented at all.
+ *
+ * N.B. 0-7 are required (by who?). Other values may be defined for
+ * various systems but there appears no guarantee that they match across
+ * platforms. Thus, unless we can identify what system the executable
+ * was compiled for, we probably prefer to have extensions fail. Hell,
+ * nothing important is going to use this obscure stuff anyway...
+ */
+#define _SC_ARG_MAX	0
+#define _SC_CHILD_MAX	1
+#define _SC_CLK_TCK	2
+#define _SC_NGROUPS_MAX	3
+#define _SC_OPEN_MAX	4
+#define _SC_JOB_CONTROL	5
+#define _SC_SAVED_IDS	6
+#define _SC_VERSION	7
+
+#define _SC_PAGESIZE		11
+#define _SCO_SC_PAGESIZE	34
+
+
+/* This is an SVR4 system call that is undocumented except for some
+ * hints in a header file. It appears to be a forerunner to the
+ * POSIX sysconf() call.
+ */
+int svr4_sysconfig(int name)
+{
+	switch (name) {
+		case _CONFIG_NGROUPS:
+			/* From limits.h */
+			return (NGROUPS_MAX);
+
+		case _CONFIG_CHILD_MAX:
+			/* From limits.h */
+			return (CHILD_MAX);
+
+		case _CONFIG_OPEN_FILES:
+			/* From limits.h */
+			return (OPEN_MAX);
+
+		case _CONFIG_POSIX_VER:
+			/* The version of the POSIX standard we conform
+			 * to. SCO defines _POSIX_VERSION as 198808L
+			 * sys/unistd.h. What are we? We are 199009L.
+			 */
+			return (199009L);
+
+		case _CONFIG_PAGESIZE:
+			return (PAGE_SIZE);
+
+		case _CONFIG_CLK_TCK:
+			return (HZ);
+
+		case _CONFIG_XOPEN_VER:
+			return 4;
+
+		case _CONFIG_NACLS_MAX:
+			return 0;
+
+		case _CONFIG_NPROC:
+			return 4000; /* max_threads */
+		
+		case _CONFIG_NENGINE:
+		case _CONFIG_NENGINE_ONLN:
+			return (num_online_cpus());
+
+		case _CONFIG_TOTAL_MEMORY:
+			return (max_mapnr << (PAGE_SHIFT-10));	
+
+		case _CONFIG_USEABLE_MEMORY:
+		case _CONFIG_GENERAL_MEMORY:
+			return (max_mapnr << (PAGE_SHIFT-10));
+/*			return ((unsigned long) (nr_free_pages()) << (PAGE_SHIFT-10)); */
+
+		case _CONFIG_DEDICATED_MEMORY:
+			return 0;
+
+		case _CONFIG_NCGS_CONF:
+		case _CONFIG_NCGS_ONLN:
+		case _CONFIG_MAX_ENG_PER_CG:
+			return 1; /* no NUMA-Q support on Linux yet */
+				  /* well, there is.  we lie anyway   --hch */
+
+		case _CONFIG_CACHE_LINE:
+			return 32; /* XXX is there a more accurate way? */
+
+		case _CONFIG_KERNEL_VM:
+			return -EINVAL;
+
+		case _CONFIG_ARG_MAX:
+			/* From limits.h */
+			return (ARG_MAX);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "unsupported sysconfig call %d\n", name);
+#endif
+	return -EINVAL;
+}
+
+
+int ibcs_sysconf(int name)
+{
+	switch (name) {
+		case _SC_ARG_MAX:
+			/* From limits.h */
+			return (ARG_MAX);
+
+		case _SC_CHILD_MAX:
+			/* From limits.h */
+			return (CHILD_MAX);
+
+		case _SC_CLK_TCK:
+			return (HZ);
+
+		case _SC_NGROUPS_MAX:
+			/* From limits.h */
+			return (NGROUPS_MAX);
+
+		case _SC_OPEN_MAX:
+			/* From limits.h */
+			return (OPEN_MAX);
+
+		case _SC_JOB_CONTROL:
+			return (1);
+
+		case _SC_SAVED_IDS:
+			return (1);
+
+		case _SC_PAGESIZE:
+		case _SCO_SC_PAGESIZE:
+			return PAGE_SIZE;
+
+		case _SC_VERSION:
+			/* The version of the POSIX standard we conform
+			 * to. SCO defines _POSIX_VERSION as 198808L
+			 * sys/unistd.h. What are we?
+			 */
+			return (198808L);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "unsupported sysconf call %d\n", name);
+#endif
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(ibcs_sysconf);
+EXPORT_SYMBOL(svr4_sysconfig);
+#endif
diff -Nru linux-2.6.7/abi/svr4/sysfs.c linux-2.6.7-abi/abi/svr4/sysfs.c
--- linux-2.6.7/abi/svr4/sysfs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/sysfs.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 1994  Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/personality.h>
+#include <linux/sched.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+
+/*
+ * The kernel sysfs() code is almost all we need but, apparently,
+ * the SCO (at least) sysfs() will also accept a "magic number"
+ * as an index argument and will return the name of the relevant
+ * file system. Since Linux doesn't have any concept of fs magic
+ * numbers outside the file system code themselves there is no
+ * clean way to do it in the kernel. There isn't a clean way to
+ * to it here either but it needs to be done somehow :-(.
+ */
+enum {
+	GETFSIND = 1,
+	GETFSTYP = 2,
+	GETNFSTYP = 3
+};
+
+int
+svr4_sysfs(int cmd, int arg1, int arg2)
+{
+	if (cmd == GETFSIND)
+		return sys_sysfs(cmd, arg1, arg2);
+
+	if (cmd == GETNFSTYP)
+		return sys_sysfs(cmd, arg1, arg2);
+
+	if (cmd == GETFSTYP) {
+		char *buf = (char *)arg2;
+		int error;
+
+		if (arg1 & 0x80000000)
+			arg1 &= 0x0000ffff;
+		if (arg1 >= 0 && arg1 < sys_sysfs(GETNFSTYP,0,0))
+			return sys_sysfs(cmd, arg1-1, arg2);
+
+		/*
+		 * Kludge alert! Hardcoded known magic numbers!
+		 */
+		switch (arg1) {
+		case 0xef53: case 0xffffef53:
+		case 0xef51: case 0xffffef51:
+			/*
+			 * Some SCO programs (i.e. Informix Dynamic
+			 * Server are using this to detect "real"
+			 * filesystems by checking type names :-(.
+			 * So we lie :-).
+			 */
+			if (is_cur_personality(PER_SCOSVR3))
+				error = copy_to_user(buf, "HTFS", 5);
+			else
+				error = copy_to_user(buf, "ext2", 5);
+			break;
+		case 0x137d:
+			error = copy_to_user(buf, "ext", 4);
+			break;
+		case 0x9660: case 0xffff9660:
+			error = copy_to_user(buf, "iso9660", 8);
+			break;
+		case 0x4d44:
+			error = copy_to_user(buf, "msdos", 6);
+			break;
+		case 0x6969:
+			error = copy_to_user(buf, "nfs", 4);
+			break;
+		case 0x9fa0: case 0xffff9fa0:
+			error = copy_to_user(buf, "proc", 5);
+			break;
+		case 0xf995e849:
+		case 0xe849: case 0xffffe849:
+			error = copy_to_user(buf, "hpfs", 5);
+			break;
+		case 0x137f: /* original */
+		case 0x138f: /* original + 30 char names */
+		case 0x2468: /* V2 */
+		case 0x2478: /* V2 + 30 char names */
+			error = copy_to_user(buf, "minix", 6);
+			break;
+		case 0x564c:
+			error = copy_to_user(buf, "ncpfs", 6);
+			break;
+		case 0x517b:
+			error = copy_to_user(buf, "smbfs", 6);
+			break;
+		case 0x00011954:
+			error = copy_to_user(buf, "ufs", 4);
+			break;
+		case 0x012fd16d: case 0xffffd16d:
+			error = copy_to_user(buf, "xiafs", 6);
+			break;
+		case 0x012ff7b3+1: case 0xfffff7b3+1:
+			error = copy_to_user(buf, "xenix", 6);
+			break;
+		case 0x012ff7b3+2: case 0xfffff7b3+2:
+		case 0x012ff7b3+3: case 0xfffff7b3+3:
+			error = copy_to_user(buf, "sysv", 5);
+			break;
+		case 0x012ff7b3+4: case 0xfffff7b3+4:
+			error = copy_to_user(buf, "coherent", 9);
+			break;
+		default:
+			error = copy_to_user(buf, "", 1);
+			break;
+		}
+
+		if (error)
+			return -EFAULT;
+		return 0;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "unsupported sysfs call %d\n", cmd);
+#endif
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_sysfs);
+#endif
diff -Nru linux-2.6.7/abi/svr4/sysi86.c linux-2.6.7-abi/abi/svr4/sysi86.c
--- linux-2.6.7/abi/svr4/sysi86.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/sysi86.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,180 @@
+/*
+ * Copyright 1994,1995	Mike Jagdis <jaggy@purplet.demon.co.uk>
+ * Copyright 2002 Caldera Deutschland GmbH
+ */
+
+#ident "%W% %G%"
+
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/ptrace.h>
+#include <linux/syscalls.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+
+
+/*
+ * The sysi86() call is used for machine specific functions. Only the
+ * most basic are implemented here.
+ */
+#define SI86SWPI        1       /* General swap functions. */
+#define SI86SYM         2       /* Get symbol table */
+#define SI86CONF        4       /* Get configuration table */
+#define SI86BOOT        5       /* Get timestamp and name of program
+				 * booted.
+				 */
+#define SI86DMM         7       /* Double-map data segment for
+				 * read/write/execute support
+				 */
+#define SI86AUTO        9       /* Was an auto-config boot done? */
+#define SI86EDT         10      /* Copy contents of EDT to user */
+#define SI86SWAP        12      /* Declare swap space */
+#define SI86FPHW        40      /* what (if any?) floating-point hardware */
+#  define FP_NO		0	/* No fp at all */
+#  define FP_SW		1	/* using emulator */
+#  define FP_HW		2	/* using hardware */
+#  define FP_287	2	/* using a 287 */
+#  define FP_387	3	/* using a 387 */
+#define GRNON		52	/* set green light to solid on state */
+#define GRNFLASH	53	/* start green light flashing */
+#define STIME 		54	/* set internal time */
+#define SETNAME		56	/* rename the system */
+#define RNVR 		58	/* read NVRAM */
+#define WNVR 		59	/* write NVRAM */
+#define RTODC		60	/* read time of day clock */
+#define CHKSER		61	/* check soft serial number */
+#define SI86NVPRT       62      /* print an xtra_nvr structure */
+#define SANUPD		63	/* sanity update of kernel buffers */
+#define SI86KSTR        64      /* make a copy of a kernel string */
+#define SI86MEM         65      /* return the memory size of system */
+#define SI86TODEMON     66      /* Transfer control to firmware.        */
+#define SI86CCDEMON     67      /* Control character access to demon.   */
+#define SI86CACHE       68      /* Turn cache on and off.               */
+#define SI86DELMEM      69      /* Delete available memory for testing. */
+#define SI86ADDMEM      70      /* Add back deleted memory.             */
+/* 71 through 74 reserved for VPIX */
+#define SI86V86         71      /* V86 system calls (see v86.h)         */
+#define	SI86SLTIME	72	/* Set local time correction		*/
+#define SI86DSCR        75      /* Set a segment or gate descriptor     */
+#define RDUBLK		76	/* Read U Block */
+/* #ifdef MERGE386 */
+/* NFA entry point */
+#define SI86NFA         77      /* make nfa_sys system call */
+#define SI86VM86	81
+#define SI86VMENABLE	82
+/* #endif MERGE386 */
+#define SI86VM86        81
+#define SI86VMENABLE    82
+#define SI86LIMUSER     91      /* liscense interface */
+#define SI86RDID        92      /* ROM BIOS Machid ID */
+#define SI86RDBOOT      93      /* Bootable Non-SCSI Hard Disk */
+/* Merged Product defines */
+#define SI86SHFIL	100	/* map a file into addr space of a proc */
+#define SI86PCHRGN	101	/* make globally visible change to a region */
+#define SI86BADVISE	102	/* badvise subcommand - see below for   */
+				/*	badvise subfunction definitions */
+#define SI86SHRGN	103	/* enable/disable XENIX small model shared */
+				/*	data context switching		   */ 
+#define	SI86CHIDT	104	/* set user level int 0xf0, ... 0xff handlers */
+#define	SI86EMULRDA	105	/* remove special emulator read access	*/
+#define SI86GETPIPE	106	/* return the pipe filesystem */
+#define SI86SETPIPE	107	/* set the pipe filesystem */
+#define SI86SETPIPE_NM	108	/* set the pipe filesystem -non mountable */
+#define SI86GETNPIPE	109	/* get # of pipe filesystems */
+#define SI86GETPIPE_ALL	110	/* get data on all of pipe filesystems */
+#define SI86POPPIPE	111	/* pop pipe file system off stack */
+#define SI86APM		112	/* get APM information passed by boot(HW) */
+#define SI86TIMECHG	113	/* get time before/after last timechange */
+#define SI86GETFEATURES	114	/* get os features vector */
+
+/* The SI86BADVISE command is used to set Xenix behaviour. */
+#define SI86B_SET		0x0100	/* Set badvise bits */
+#define SI86B_GET		0x0200	/* Get badvise bits */	
+#define	SI86B_LOCK		0x0001	/* XENIX advisory locking bit */
+#define SI86B_PRE_SV		0x0008	/* follow pre-System V x.out behavior */
+#define SI86B_XOUT		0x0010 	/* follow XENIX x.out behavior */
+#define SI86B_XSDSWTCH		0x0080	/* XENIX small model shared data */
+					/* context switching enabled */
+
+/*
+ *  The SI86DSCR subcommand of the sysi86() system call
+ *  sets a segment or gate descriptor in the kernel.
+ *  The following descriptor types are accepted:
+ *    - executable and data segments in the LDT at DPL 3
+ *    - a call gate in the GDT at DPL 3 that points to a segment in the LDT
+ *  The request structure declared below is used to pass the values
+ *  to be placed in the descriptor.  A pointer to the structure is
+ *  passed as the second argument of the system call.
+ *  If acc1 is zero, the descriptor is cleared.
+ */
+struct ssd {
+	uint32_t  sel;	/* descriptor selector */
+	uint32_t  bo;	/* segment base or gate offset */
+	uint32_t  ls;	/* segment limit or gate selector */
+	uint32_t  acc1;	/* access byte 5 */
+	uint32_t  acc2;	/* access bits in byte 6 or gate count */
+};
+
+
+int
+svr4_sysi86(int cmd, void *arg1, int arg2)
+{
+	switch (cmd) {
+	case SI86FPHW:
+		/*
+		 * If we remove the 'static' from the definition
+		 * of fpu_error in linux/init/main.c we can tell
+		 * whether we are using hardware or software at
+		 * least. For now let's lie...
+		 * (actually SCO Unix 3.4 gives me -1...)
+		 */
+		return put_user(FP_387, (unsigned long *)arg1);
+	case STIME:
+		/*
+		 * Set the system time. The argument is a long,
+		 * sys_stime() expects a pointer to a long...
+		 */
+		return sys_stime(arg1);
+	case SETNAME:
+		/*
+		 * The name is required to be string of no more
+		 * than 7 characters. We don't get passed the
+		 * length so we are depending upon the current
+		 * implementation of sys_sethostname() here.
+		 */
+		return sys_sethostname(arg1, 7);
+	case SI86MEM:
+	    {
+		/*
+		 * Returns the size of physical memory.
+		 */
+		struct sysinfo	i;
+
+		si_meminfo(&i);
+		return (i.totalram << PAGE_SHIFT);
+	    }
+	case SI86DSCR:
+	    {
+		struct ssd s;
+
+		if (copy_from_user(&s, arg1, sizeof(struct ssd)))
+			return -EFAULT;
+
+		printk("SI86DSCR(%x,%x,%x,%x,%x)\n",
+			 s.sel, s.bo, s.ls, s.acc1, s.acc2);
+		return -EINVAL;
+	    }
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "unsupported sysi86 subcall %d\n", cmd);
+#endif
+		return -EINVAL;
+	}
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_sysi86);
+#endif
diff -Nru linux-2.6.7/abi/svr4/sysinfo.c linux-2.6.7-abi/abi/svr4/sysinfo.c
--- linux-2.6.7/abi/svr4/sysinfo.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/sysinfo.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 1995	Eric Youngdale
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/compile.h>
+#include <linux/mm.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/utsname.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+
+
+#define __O_SI_SYSNAME          1       /* return name of operating system */
+#define __O_SI_HOSTNAME         2       /* return name of node */
+#define SI_RELEASE              3       /* return release of operating system */
+#define SI_VERSION              4       /* return version field of utsname */
+#define __O_SI_MACHINE          5       /* return kind of machine */
+#define __O_SI_ARCHITECTURE     6       /* return instruction set arch */
+#define SI_HW_SERIAL            7       /* return hardware serial number */
+#define __O_SI_HW_PROVIDER      8       /* return hardware manufacturer */
+#define SI_SRPC_DOMAIN          9       /* return secure RPC domain */
+#define SI_INITTAB_NAME         10      /* return name of inittab file used */
+#define SI_ARCHITECTURE         100     /* return instruction set arch */
+#define SI_BUSTYPES             101     /* return list of bus types */
+#define SI_HOSTNAME             102     /* return fully-qualified node name */
+#define SI_HW_PROVIDER          103     /* return hardware manufacturer */
+#define SI_KERNEL_STAMP         104     /* return kernel generation timestamp */
+#define SI_MACHINE              105     /* return kind of machine */
+#define SI_OS_BASE              106     /* return base operating system */
+#define SI_OS_PROVIDER          107     /* return operating system provider */
+#define SI_SYSNAME              108     /* return name of operating system */
+#define SI_USER_LIMIT           109     /* return maximum number of users */
+
+
+
+int svr4_sysinfo(int cmd, char * buf, long count)
+{
+	char * return_string;
+	static unsigned int serial_number = 0;
+	char buffer[16];
+	int error;
+	int slen;
+
+	return_string = NULL;
+
+	switch(cmd) {
+		case __O_SI_SYSNAME:
+		case SI_SYSNAME:
+			return_string = system_utsname.sysname;
+			break;
+		case __O_SI_HOSTNAME:
+		case SI_HOSTNAME:
+			return_string = system_utsname.nodename;
+			break;
+		case SI_VERSION:
+			return_string = "2";
+			break;
+		case SI_RELEASE:
+			return_string = system_utsname.release;
+			break;
+		case SI_MACHINE:
+		case __O_SI_MACHINE:
+			return_string = system_utsname.machine;
+			break;
+		case __O_SI_ARCHITECTURE:
+		case SI_ARCHITECTURE:
+			return_string = "IA32"; /* XXX: this seems wrong, the name ia32 is very new ... -- ch */
+			break;
+		case SI_BUSTYPES:
+			return_string = "PCI ISA";
+			break;
+		case __O_SI_HW_PROVIDER:
+		case SI_HW_PROVIDER:
+			return_string = "Generic AT";
+			break;
+		case SI_KERNEL_STAMP:
+			return_string = UTS_VERSION;
+			break;
+		case SI_INITTAB_NAME:
+			return_string = "/etc/inittab";
+			break;
+		case SI_HW_SERIAL:
+			if(serial_number == 0)
+				serial_number = 0xdeadbeef; 
+			sprintf(buffer,"%8.8x", serial_number);
+			return_string = buffer;
+			break;
+		case SI_OS_BASE:
+			return_string = "Linux";
+			break;
+		case SI_OS_PROVIDER:
+			return_string = "LBT"; /* someone's initials ? */
+			break;
+		case SI_SRPC_DOMAIN:
+			return_string = system_utsname.domainname;
+			break;
+		case SI_USER_LIMIT:
+			/* have you seen a Linux box with more than 500000 users? */
+			return_string = "500000";
+			break;
+		default:
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_API,
+					"unsupported sysinfo call %d\n", cmd);
+#endif
+		return -EINVAL;
+	}
+
+	if (!return_string)
+		return 0;
+
+	down_read(&uts_sem);
+	slen = (count < strlen(return_string) + 1 ? count : strlen(return_string) + 1);
+	error = copy_to_user(buf, return_string, slen);
+	up_read(&uts_sem);
+
+	return error ? -EFAULT : slen;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_sysinfo);
+#endif
diff -Nru linux-2.6.7/abi/svr4/tapeio.c linux-2.6.7-abi/abi/svr4/tapeio.c
--- linux-2.6.7/abi/svr4/tapeio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/tapeio.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,92 @@
+#ident "%W% %G%"
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/mtio.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+
+int
+svr4_tape_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	mm_segment_t		fs;
+	int			error;
+	struct mtop		mtop;
+
+	mtop.mt_count = 1;
+
+	switch (cmd & 0xff) {
+	case 1:		/* MT_RETEN */
+		mtop.mt_op = MTRETEN;
+		break;
+	case 2:		/* MT_REWIND */
+		mtop.mt_op = MTREW;
+		break;
+	case 3:		/* MT_ERASE */
+		mtop.mt_op = MTERASE;
+		break;
+	case 4:		/* MT_WFM */
+		mtop.mt_op = MTWEOF;
+		break;
+	case 5:		/* MT_RESET */
+		mtop.mt_op = MTRESET;
+		break;
+	case 7:		/* T_SFF */
+		mtop.mt_op = MTFSF;
+		break;
+	case 8:		/* T_SBF */
+		mtop.mt_op = MTBSF;
+		break;
+	case 9:		/* T_LOAD */
+		mtop.mt_op = MTLOAD;
+		break;
+	case 10:  /* MT_UNLOAD */
+		mtop.mt_op = MTOFFL;
+		break;
+	case 15:	/* T_WRBLKLEN */
+		mtop.mt_op = MTLOCK;
+		mtop.mt_count = (int)data;
+		break;
+	case 16:	/* T_PREVMV */
+		mtop.mt_op = MTLOCK;
+		break;
+	case 17:	/* T_ALLOMV */
+		mtop.mt_op = MTUNLOCK;
+		break;
+	case 20:	/* T_EOD */
+		mtop.mt_op = MTEOM;
+		mtop.mt_count = (int)data;
+		break;
+	case 21:	/* T_SSFB */
+		mtop.mt_op = MTBSFM;
+		mtop.mt_count = (int)data;
+		break;
+	case 22:	/* T_SSFF */
+		mtop.mt_op = MTFSFM;
+		mtop.mt_count = (int)data;
+		break;
+	case 24:	/* T_STD */
+		mtop.mt_op = MTSETDENSITY;
+		mtop.mt_count = (int)data;
+		break;
+
+#if 0
+	case 6:		/* T_STATUS */
+	case 14:	/* T_RDBLKLEN */
+	case 18:	/* T_SBB */
+	case 19:	/* T_SFB */
+	case 23:	/* T_STS */
+#endif
+	default:
+		printk (KERN_ERR "iBCS: SYSV tape ioctl func=%d arg=%x unsupported\n",
+				cmd & 0xff, (int)data);
+			return -EINVAL;
+	}
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, MTIOCTOP, (long)&mtop);
+	set_fs (fs);
+	return (error);
+}
diff -Nru linux-2.6.7/abi/svr4/termios.c linux-2.6.7-abi/abi/svr4/termios.c
--- linux-2.6.7/abi/svr4/termios.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/termios.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,982 @@
+#ident "%W% %G%"
+
+#include <linux/kernel.h>
+#include <linux/unistd.h>
+#include <linux/termios.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/ioctl.h>
+#include <abi/svr4/termios.h>
+
+
+static int
+svr_to_linux_termio(int fd, int op, struct svr_termio *it)
+{
+	struct termio		t;
+	mm_segment_t		fs;
+	char			eof;
+	u_short			lflag;
+	int			error;
+
+	error = verify_area(VERIFY_READ, it, sizeof(struct svr_termio));
+	if (error)
+		return (error);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETA, (long)&t);
+	set_fs(fs);
+
+	if (error)
+		return (error);
+
+	/* Save things we may need later. */
+	eof = t.c_cc[4];
+	lflag = t.c_lflag;
+
+	/* Copy the entire structure then fix up as necessary. */
+	copy_from_user(&t, it, sizeof(struct svr_termio));
+
+	/* If ICANON isn't set then we've been given VMIN in place
+	 * of VEOF.
+	 */
+	if (!(t.c_lflag & 0000002)) {
+		t.c_cc[6] = t.c_cc[4];
+		t.c_cc[4] = eof;
+	}
+
+	if (t.c_cflag & 0100000) /* CRTSFL - SCO only? */
+		t.c_cflag |= CRTSCTS;
+	t.c_cflag &= ~0170000; /* LOBLK|CTSFLOW|RTSFLOW|CRTSFL */
+
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(fs);
+
+	return (error);
+}
+
+static int
+linux_to_svr_termio(int fd, struct svr_termio *it)
+{
+	struct termio		t;
+	mm_segment_t		fs;
+	int			error;
+
+	error = verify_area(VERIFY_WRITE, it, sizeof(struct svr_termio));
+	if (error)
+		return (error);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETA, (long)&t);
+	set_fs(fs);
+
+	if (error)
+		return (error);
+
+	/* If ICANON isn't set then we substitute VEOF with VMIN. */
+	if (!(t.c_lflag & 0000002))
+		t.c_cc[4] = t.c_cc[6];
+
+	/* Copy to the user supplied structure. */
+	copy_to_user(it, &t, sizeof(struct svr_termio));
+
+	return (error);
+}
+
+static int
+svr4_to_linux_termios(int fd, int op, struct svr4_termios *it)
+{
+	struct termios		t;
+	mm_segment_t		fs;
+	u_short			lflag, r;
+	char			svr4_cc[SVR4_NCCS];
+	int			error;
+
+	error = verify_area(VERIFY_READ, it, sizeof(struct svr4_termios));
+	if (error)
+		return (error);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(fs);
+
+	if (error)
+		return (error);
+
+	__get_user(t.c_iflag, &it->c_iflag);
+	t.c_iflag &= ~0100000; /* DOSMODE */
+
+	__get_user(t.c_oflag, &it->c_oflag);
+	__get_user(t.c_cflag, &it->c_cflag);
+
+	if (t.c_cflag & 0100000) /* CRTSFL - SCO only? */
+		t.c_cflag |= CRTSCTS;
+
+	t.c_cflag &= ~0170000; /* LOBLK|CTSFLOW|RTSFLOW|CRTSFL */
+
+	lflag = t.c_lflag;
+	t.c_lflag &= ~0100777;
+	__get_user(r, &it->c_lflag);
+	t.c_lflag |= r;
+
+	if ((t.c_lflag & 0100000))
+		sys_ioctl(fd, TIOCEXCL, 0);
+	else
+		sys_ioctl(fd, TIOCNXCL, 0);
+
+	t.c_lflag &= ~0100000;
+	t.c_lflag |= (t.c_lflag & 0000400) << 7; /* Move IEXTEN */
+	t.c_lflag &= ~0000400;
+	t.c_lflag |= (t.c_lflag & 0001000) >> 1; /* Move TOSTOP */
+	t.c_lflag &= ~0001000;
+	t.c_lflag |= (lflag & 0001000); /* Restore ECHOCTL */
+
+	copy_from_user(svr4_cc, &it->c_cc, SVR4_NCCS);
+	t.c_cc[0] = svr4_cc[0];
+	t.c_cc[1] = svr4_cc[1];
+	t.c_cc[2] = svr4_cc[2];
+	t.c_cc[3] = svr4_cc[3];
+	t.c_cc[7] = svr4_cc[7];
+	t.c_cc[8] = svr4_cc[8];
+	t.c_cc[9] = svr4_cc[9];
+	t.c_cc[10] = svr4_cc[10];
+	t.c_cc[12] = svr4_cc[12];
+	t.c_cc[13] = svr4_cc[13];
+	t.c_cc[14] = svr4_cc[14];
+	t.c_cc[15] = svr4_cc[15];
+	t.c_cc[16] = svr4_cc[16];
+
+	if (t.c_lflag & ICANON) {
+		t.c_cc[4] = svr4_cc[4];
+		t.c_cc[11] = svr4_cc[5];
+	} else {
+		t.c_cc[5] = svr4_cc[5];
+		t.c_cc[6] = svr4_cc[4];
+		t.c_cc[11] = svr4_cc[6];
+	}
+
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(fs);
+
+	return (error);
+}
+
+static int
+linux_to_svr4_termios(int fd, int op, struct svr4_termios *it)
+{
+	struct termios		t;
+	char			svr4_cc[SVR4_NCCS];
+	mm_segment_t		fs;
+	int			error;
+
+	error = verify_area(VERIFY_WRITE, it, sizeof(struct svr4_termios));
+	if (error)
+		return (error);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(fs);
+
+	if (error)
+		return (error);
+
+	put_user(t.c_iflag & 0017777, &it->c_iflag);
+	put_user(t.c_oflag & 0177777, &it->c_oflag);
+
+	if (t.c_cflag & CRTSCTS)
+		t.c_cflag |= 0100000; /* CRTSFL - SCO only? */
+	put_user(t.c_cflag & 0177777, &it->c_cflag);
+
+	t.c_lflag &= ~0001000;
+	t.c_lflag |= (t.c_lflag & 0000400) << 1;
+	t.c_lflag &= ~0000400;
+	t.c_lflag |= (t.c_lflag & 0100000) >> 7;
+	t.c_lflag &= ~0100000;
+	put_user(t.c_lflag & 0001777, &it->c_lflag);
+
+	svr4_cc[0] = t.c_cc[0];
+	svr4_cc[1] = t.c_cc[1];
+	svr4_cc[2] = t.c_cc[2];
+	svr4_cc[3] = t.c_cc[3];
+	svr4_cc[6] = t.c_cc[16];
+	svr4_cc[7] = t.c_cc[7];
+	svr4_cc[8] = t.c_cc[8];
+	svr4_cc[9] = t.c_cc[9];
+	svr4_cc[10] = t.c_cc[10];
+	svr4_cc[11] = t.c_cc[10];
+	svr4_cc[12] = t.c_cc[12];
+	svr4_cc[13] = t.c_cc[13];
+	svr4_cc[14] = t.c_cc[14];
+	svr4_cc[15] = t.c_cc[15];
+
+	if (t.c_lflag & ICANON) {
+		svr4_cc[4] = t.c_cc[4];
+		svr4_cc[5] = t.c_cc[11];
+	} else {
+		svr4_cc[4] = t.c_cc[6];
+		svr4_cc[5] = t.c_cc[5];
+	}
+
+	copy_to_user(&it->c_cc, svr4_cc, SVR4_NCCS);
+
+	return (error);
+}
+
+int
+svr4_term_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	switch (cmd) {
+	case 1: /* TCGETA  (TIOC|1) */
+		return linux_to_svr_termio(fd,
+			(struct svr_termio *)data);
+	case 2: /* TCSETA  (TIOC|2) */
+		return svr_to_linux_termio(fd, TCSETA,
+			(struct svr_termio *)data);
+	case 3: /* TCSETAW (TIOC|3) */
+		return svr_to_linux_termio(fd, TCSETAW,
+			(struct svr_termio *)data);
+	case 4: /* TCSETAF (TIOC|4) */
+		return svr_to_linux_termio(fd, TCSETAF,
+			(struct svr_termio *)data);
+	case 5: /* TCSBRK  (TIOC|5) */
+		return sys_ioctl(fd, TCSBRK, (long)data);
+	case 6: /* TCXONC  (TIOC|6) */
+		return sys_ioctl(fd, TCXONC, (long)data);
+	case 7: /* TCFLSH  (TIOC|7) */
+		return sys_ioctl(fd, TCFLSH, (long)data);
+	/* This group appear in SVR4 but not SVR3 (SCO). */
+	case 8: /* TIOCKBON */
+	case 9: /* TIOCKBOF */
+	case 10: /* KBENABLED */
+		return -EINVAL;
+
+	/* This set is used by SVR4 for termios ioctls. */
+	case 13: /* TCGETS */
+		return linux_to_svr4_termios(fd, TCGETS,
+			(struct svr4_termios *)data);
+	case 14: /* TCSETS */
+		return svr4_to_linux_termios(fd, TCSETS,
+			(struct svr4_termios *)data);
+	case 15: /* TCSETSW */
+		return svr4_to_linux_termios(fd, TCSETSW,
+			(struct svr4_termios *)data);
+	case 16: /* TCSETSF */
+		return svr4_to_linux_termios(fd, TCSETSF,
+			(struct svr4_termios *)data);
+
+	/* These two are specific to ISC. */
+	case 20: /* TCSETPGRP  (TIOC|20) set pgrp of tty */
+		return sys_ioctl(fd, TIOCSPGRP, (long)data);
+	case 21: /* TCGETPGRP  (TIOC|21) get pgrp of tty */
+		return sys_ioctl(fd, TIOCGPGRP, (long)data);
+
+	case  34: /* TCGETSC (TIOC|34) ioctl for scancodes */
+		return 0x04; /* Translates scancode to ascii */
+	case  35: /* TCSETSC (TIOC|35) ioctl for scancodes */
+		return 0;
+
+	case 103: /* TIOCSWINSZ (TIOC|103) */
+		return sys_ioctl(fd, TIOCSWINSZ, (long)data);
+	case 104: /* TIOCGWINSZ (TIOC|104) */
+		return sys_ioctl(fd, TIOCGWINSZ, (long)data);
+
+	case 118: /* TIOCSPGRP  (TIOC|118) set pgrp of tty */
+		return sys_ioctl(fd, TIOCSPGRP, (long)data);
+	case 119: /* TIOCGPGRP  (TIOC|119) get pgrp of tty */
+		return sys_ioctl(fd, TIOCGPGRP, (long)data);
+
+	case  32: /* TCDSET  (TIOC|32) */
+	case  33: /* RTS_TOG (TIOC|33) 386 - "RTS" toggle define 8A1 protocol */
+
+	case 120: /* TIOSETSAK  (TIOC|120) set SAK sequence for tty */
+	case 121: /* TIOGETSAK  (TIOC|121) get SAK sequence for tty */
+		printk(KERN_ERR "iBCS: termio ioctl %d unimplemented\n", cmd);
+		return -EINVAL;
+	}
+
+	printk(KERN_ERR "iBCS: termio ioctl %d unsupported\n", cmd);
+	return -EINVAL;
+}
+
+struct termiox {
+	unsigned short x_hflag;
+	unsigned short x_cflag;
+	unsigned short x_rflag[5];
+	unsigned short x_sflag;
+};
+
+#define RTSXOFF 0x0001
+#define CTSXON	0x0002
+
+int
+svr4_termiox_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	struct termios		t;
+	struct termiox		tx;
+	mm_segment_t		fs;
+	int			error;
+
+	if (cmd < 1 || cmd > 4)
+		return -EINVAL;
+
+	error = verify_area(cmd == 1 ? VERIFY_WRITE : VERIFY_READ,
+			data, sizeof(struct termiox));
+	if (error)
+		return (error);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(fs);
+
+	if (error)
+		return (error);
+
+	if (cmd == 1) { /* TCGETX */
+		memset(&tx, '\0', sizeof(struct termiox));
+		if (t.c_cflag & CRTSCTS)
+			tx.x_hflag = RTSXOFF|CTSXON;
+		copy_to_user(data, &tx, sizeof(struct termiox));
+		return 0;
+	}
+
+	copy_from_user(&tx, data, sizeof(struct termiox));
+	if ((tx.x_hflag != 0 && tx.x_hflag != (RTSXOFF|CTSXON))
+	|| tx.x_cflag || tx.x_rflag[0] || tx.x_rflag[1]
+	|| tx.x_rflag[2] || tx.x_rflag[3] || tx.x_rflag[4]
+	|| tx.x_sflag)
+		return -EINVAL;
+
+	if (tx.x_hflag)
+		t.c_cflag |= CRTSCTS;
+	else
+		t.c_cflag &= (~CRTSCTS);
+
+	fs = get_fs();
+	set_fs(get_ds());
+	switch (cmd) {
+		case 2: /* TCSETX */
+			error = sys_ioctl(fd, TCSETS, (long)&t);
+			break;
+		case 3: /* TCSETXW */
+			error = sys_ioctl(fd, TCSETSW, (long)&t);
+			break;
+		case 4: /* TCSETXF */
+			error = sys_ioctl(fd, TCSETSF, (long)&t);
+			break;
+	}
+	set_fs(fs);
+	return (error);
+}
+
+#define BSD_NCCS 20
+struct bsd_termios {
+	unsigned long	c_iflag;
+	unsigned long	c_oflag;
+	unsigned long	c_cflag;
+	unsigned long	c_lflag;
+	unsigned char	c_cc[BSD_NCCS];
+	long		c_ispeed;
+	long		c_ospeed;
+};
+static unsigned long speed_map[] = {
+	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400,
+	4800, 9600, 19200, 38400
+};
+
+static unsigned long
+bsd_to_linux_speed(unsigned long s)
+{
+	unsigned int i;
+
+#ifdef B57600
+	if (s == 57600)
+		return B57600;
+#endif
+#ifdef B115200
+	if (s == 115200)
+		return B115200;
+#endif
+	
+	for (i=0; i<sizeof(speed_map)/sizeof(speed_map[0]); i++)
+		if (s <= speed_map[i])
+			return i;
+	return B38400;
+}
+
+static unsigned long
+linux_to_bsd_speed(unsigned long s)
+{
+#ifdef B57600
+	if (s == B57600)
+		return 57600;
+#endif
+#ifdef B115200
+	if (s == B115200)
+		return 115200;
+#endif
+	return speed_map[s];
+}
+
+
+
+
+static int
+bsd_to_linux_termios(int fd, int op, struct bsd_termios *it)
+{
+	struct termios t;
+	mm_segment_t old_fs;
+	unsigned long temp;
+	char bsd_cc[BSD_NCCS];
+	int error;
+
+	error = verify_area(VERIFY_READ, it, sizeof(struct bsd_termios));
+	if (error)
+		return error;
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(old_fs);
+	if (error)
+		return error;
+
+	__get_user(t.c_iflag, &it->c_iflag);
+	t.c_iflag = (t.c_iflag & ~0xc00)
+			| ((t.c_iflag & 0x400) << 1)
+			| ((t.c_iflag & 0x800) >> 1);
+
+	get_user(temp, &it->c_oflag);
+	t.c_oflag = (t.c_oflag & ~0x1805)
+			| (temp & 9)
+			| ((temp & 2) << 1)
+			| ((temp & 4) << 10)
+			| ((temp & 4) << 9);
+
+	get_user(temp, &it->c_cflag);
+	t.c_cflag = (t.c_cflag & ~0xfff)
+			| ((temp & 0xff00) >> 4);
+	if (t.c_cflag & 0x30000)
+		t.c_cflag |= 020000000000;
+	t.c_cflag |= bsd_to_linux_speed(({long s; get_user(s, &it->c_ospeed); s;}))
+		| (bsd_to_linux_speed(({long s; get_user(s, &it->c_ispeed); s;})) << 16);
+
+	get_user(temp, &it->c_lflag);
+	t.c_lflag = (t.c_lflag & ~0157663)
+			| ((temp & 1) << 12)
+			| ((temp & 0x46) << 3)
+			| ((temp & 0x420) << 5)
+			| ((temp & 0x180) >> 7)
+			| ((temp & 0x400000) >> 14)
+			| ((temp & 0x2800000) >> 11)
+			| ((temp & 0x80000000) >> 24);
+
+	copy_from_user(bsd_cc, &it->c_cc, BSD_NCCS);
+	t.c_cc[VEOF] = bsd_cc[0];
+	t.c_cc[VEOL] = bsd_cc[1];
+	t.c_cc[VEOL2] = bsd_cc[2];
+	t.c_cc[VERASE] = bsd_cc[3];
+	t.c_cc[VWERASE] = bsd_cc[4];
+	t.c_cc[VKILL] = bsd_cc[5];
+	t.c_cc[VREPRINT] = bsd_cc[6];
+	t.c_cc[VSWTC] = bsd_cc[7];
+	t.c_cc[VINTR] = bsd_cc[8];
+	t.c_cc[VQUIT] = bsd_cc[9];
+	t.c_cc[VSUSP] = bsd_cc[10];
+/*	t.c_cc[VDSUSP] = bsd_cc[11];*/
+	t.c_cc[VSTART] = bsd_cc[12];
+	t.c_cc[VSTOP] = bsd_cc[13];
+	t.c_cc[VLNEXT] = bsd_cc[14];
+	t.c_cc[VDISCARD] = bsd_cc[15];
+	t.c_cc[VMIN] = bsd_cc[16];
+	t.c_cc[VTIME] = bsd_cc[17];
+/*	t.c_cc[VSTATUS] = bsd_cc[18];*/
+
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(old_fs);
+
+	return error;
+}
+
+
+static int
+linux_to_bsd_termios(int fd, int op, struct bsd_termios *it)
+{
+	struct termios t;
+	char bsd_cc[BSD_NCCS];
+	mm_segment_t old_fs;
+	int error;
+
+	error = verify_area(VERIFY_WRITE, it, sizeof(struct bsd_termios));
+	if (error)
+		return error;
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, op, (long)&t);
+	set_fs(old_fs);
+	if (error)
+		return error;
+
+	put_user((t.c_iflag & 0777)
+			| ((t.c_iflag & 02000) >> 1)
+			| ((t.c_iflag & 010000) >> 2)
+			| ((t.c_iflag & 020000) >> 4),
+		&it->c_iflag);
+
+	put_user((t.c_oflag & 1)
+			| ((t.c_oflag & 04) >> 1)
+			| ((t.c_oflag & 014000) == 014000 ? 4 : 0),
+		&it->c_oflag);
+
+	put_user((t.c_cflag & ~020000007777)
+			| ((t.c_cflag & 0xff0) << 4)
+			| ((t.c_cflag & 020000000000) ? 0x30000 : 0),
+		&it->c_cflag);
+
+	put_user(linux_to_bsd_speed(t.c_cflag & CBAUD), &it->c_ospeed);
+	if ((t.c_cflag & CIBAUD) != 0)
+		put_user(linux_to_bsd_speed((t.c_cflag & CIBAUD) >> 16),
+			&it->c_ispeed);
+	else
+		put_user(linux_to_bsd_speed(t.c_cflag & CBAUD),
+			&it->c_ispeed);
+
+	put_user((t.c_lflag & 07777626010)
+			| ((t.c_lflag & 03) << 7)
+			| ((t.c_lflag & 01160) >> 3)
+			| ((t.c_lflag & 0400) << 14)
+			| ((t.c_lflag & 02000) >> 4)
+			| ((t.c_lflag & 04000) >> 11)
+			| ((t.c_lflag & 010000) << 11)
+			| ((t.c_lflag & 040000) << 15)
+			| ((t.c_lflag & 0100000) >> 5),
+		&it->c_lflag);
+
+	bsd_cc[0] = t.c_cc[VEOF];
+	bsd_cc[1] = t.c_cc[VEOL];
+	bsd_cc[2] = t.c_cc[VEOL2];
+	bsd_cc[3] = t.c_cc[VERASE];
+	bsd_cc[4] = t.c_cc[VWERASE];
+	bsd_cc[5] = t.c_cc[VKILL];
+	bsd_cc[6] = t.c_cc[VREPRINT];
+	bsd_cc[7] = t.c_cc[VSWTC];
+	bsd_cc[8] = t.c_cc[VINTR];
+	bsd_cc[9] = t.c_cc[VQUIT];
+	bsd_cc[10] = t.c_cc[VSUSP];
+	bsd_cc[11] = t.c_cc[VSUSP];
+	bsd_cc[12] = t.c_cc[VSTART];
+	bsd_cc[13] = t.c_cc[VSTOP];
+	bsd_cc[14] = t.c_cc[VLNEXT];
+	bsd_cc[15] = t.c_cc[VDISCARD];
+	bsd_cc[16] = t.c_cc[VMIN];
+	bsd_cc[17] = t.c_cc[VTIME];
+	bsd_cc[18] = 0; /* t.c_cc[VSTATUS]; */
+	bsd_cc[19] = 0;
+
+	copy_to_user(&it->c_cc, bsd_cc, BSD_NCCS);
+
+	return error;
+}
+
+
+
+
+struct v7_sgttyb {
+	unsigned char	sg_ispeed;
+	unsigned char	sg_ospeed;
+	unsigned char	sg_erase;
+	unsigned char	sg_kill;
+	int	sg_flags;
+};
+
+struct v7_tchars {
+	char	t_intrc;
+	char	t_quitc;
+	char	t_startc;
+	char	t_stopc;
+	char	t_eofc;
+	char	t_brkc;
+};
+
+struct v7_ltchars {
+	char	t_suspc;
+	char	t_dsuspc;
+	char	t_rprntc;
+	char	t_flushc;
+	char	t_werasc;
+	char	t_lnextc;
+};
+
+
+int bsd_ioctl_termios(int fd, unsigned int func, void *data)
+{
+	switch (func & 0xff) {
+		case 0:	 {				/* TIOCGETD */
+			unsigned long ldisc;
+			mm_segment_t old_fs;
+			int error;
+
+			error = verify_area(VERIFY_WRITE, data,
+					sizeof(unsigned short));
+			if (error)
+				return error;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TIOCGETD, (long)&ldisc);
+			set_fs(old_fs);
+			if (!error)
+				put_user(ldisc, (unsigned short *)data);
+			return error;
+		}
+		case 1: {				/* TIOCSETD */
+			unsigned long ldisc;
+			mm_segment_t old_fs;
+			int error;
+
+			error = verify_area(VERIFY_READ, data,
+					sizeof(unsigned short));
+			if (error)
+				return error;
+
+			get_user(ldisc, (unsigned short *)data);
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TIOCSETD, (long)&ldisc);
+			set_fs(old_fs);
+			return error;
+		}
+
+		case 2: {				/* TIOCHPCL */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			if (data)
+				t.c_cflag |= HUPCL;
+			else
+				t.c_cflag &= ~HUPCL;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCSETS, (long)&t);
+			set_fs(old_fs);
+			return error;
+		}
+
+		case 8: {				/* TIOCGETP */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_sgttyb sg;
+
+			error = verify_area(VERIFY_WRITE, data, sizeof(sg));
+			if (error)
+				return error;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			sg.sg_ispeed = sg.sg_ospeed = 0;
+			sg.sg_erase = t.c_cc[VERASE];
+			sg.sg_kill = t.c_cc[VKILL];
+			sg.sg_flags =
+				/* Old - became TANDEM instead.
+				 * ((t.c_cflag & HUPCL) >> 10)
+				 * |
+				 */
+/* O_ODDP */			((t.c_cflag & PARODD) >> 3)
+/* O_EVENP */			| ((t.c_cflag & PARENB) >> 1)
+/* LITOUT */			| ((t.c_cflag & OPOST) ? 0 : 0x200000)
+/* O_CRMOD */			| ((t.c_oflag & ONLCR) << 2)
+/* O_NL1|O_VTDELAY */		| (t.c_oflag & (NL1|VTDLY))
+/* O_TBDELAY */			| ((t.c_oflag & TABDLY) ? 02000 : 0)
+/* O_CRDELAY */			| ((t.c_oflag & CRDLY) << 3)
+/* O_BSDELAY */			| ((t.c_oflag & BSDLY) << 2)
+/* O_ECHO|O_LCASE */		| (t.c_lflag & (XCASE|ECHO))
+				| ((t.c_lflag & ICANON)
+/* O_CBREAK or O_RAW */		? 0 : ((t.c_lflag & ISIG) ? 0x02 : 0x20))
+				/* Incomplete... */
+				;
+
+			copy_to_user(data, &sg, sizeof(sg));
+			return 0;
+		}
+
+		case 9:					/* TIOCSETP */
+		case 10: {				/* TIOCSETN */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_sgttyb sg;
+
+			error = verify_area(VERIFY_READ, data, sizeof(sg));
+			if (error)
+				return error;
+			copy_from_user(&sg, data, sizeof(sg));
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			t.c_cc[VERASE] = sg.sg_erase;
+			t.c_cc[VKILL] = sg.sg_kill;
+			t.c_iflag = ICRNL | IXON;
+			t.c_oflag = 0;
+			t.c_lflag = ISIG | ICANON;
+			if (sg.sg_flags & 0x02)		/* O_CBREAK */
+				t.c_lflag &= (~ICANON);
+			if (sg.sg_flags & 0x08)		/* O_ECHO */
+				t.c_lflag |= ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
+			if (sg.sg_flags & 0x10)	/* O_CRMOD */
+				t.c_oflag |= OPOST|ONLCR;
+			if (sg.sg_flags & 0x20) {	/* O_RAW */
+				t.c_iflag = 0;
+				t.c_lflag &= ~(ISIG|ICANON);
+			}
+			if (sg.sg_flags & 0x200000)	/* LITOUT */
+				t.c_oflag &= (~OPOST);
+			if (!(t.c_lflag & ICANON)) {
+				t.c_cc[VMIN] = 1;
+				t.c_cc[VTIME] = 0;
+			}
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCSETS, (long)&t);
+			set_fs(old_fs);
+			return error;
+		}
+
+		case 17: {				/* TIOCSETC */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_tchars tc;
+
+			error = verify_area(VERIFY_READ, data, sizeof(tc));
+			if (error)
+				return error;
+			copy_from_user(&tc, data, sizeof(tc));
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			t.c_cc[VINTR] = tc.t_intrc;
+			t.c_cc[VQUIT] = tc.t_quitc;
+			t.c_cc[VSTART] = tc.t_startc;
+			t.c_cc[VSTOP] = tc.t_stopc;
+			t.c_cc[VEOF] = tc.t_eofc;
+			t.c_cc[VEOL2] = tc.t_brkc;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCSETS, (long)&t);
+			set_fs(old_fs);
+			return error;
+		}
+
+		case 18: {				/* TIOCGETC */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_tchars tc;
+
+			error = verify_area(VERIFY_WRITE, data, sizeof(tc));
+			if (error)
+				return error;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			tc.t_intrc = t.c_cc[VINTR];
+			tc.t_quitc = t.c_cc[VQUIT];
+			tc.t_startc = t.c_cc[VSTART];
+			tc.t_stopc = t.c_cc[VSTOP];
+			tc.t_eofc = t.c_cc[VEOF];
+			tc.t_brkc = t.c_cc[VEOL2];
+
+			copy_to_user(data, &tc, sizeof(tc));
+			return 0;
+		}
+
+		case 116: {				/* TIOCGLTC */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_ltchars tc;
+
+			error = verify_area(VERIFY_WRITE, data, sizeof(tc));
+			if (error)
+				return error;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			tc.t_suspc = t.c_cc[VSUSP];
+			tc.t_dsuspc = t.c_cc[VSUSP];
+			tc.t_rprntc = t.c_cc[VREPRINT];
+			tc.t_flushc = t.c_cc[VEOL2];
+			tc.t_werasc = t.c_cc[VWERASE];
+			tc.t_lnextc = t.c_cc[VLNEXT];
+
+			copy_to_user(data, &tc, sizeof(tc));
+			return 0;
+		}
+
+		case 117: {				/* TIOCSLTC */
+			int error;
+			mm_segment_t old_fs;
+			struct termios t;
+			struct v7_ltchars tc;
+
+			error = verify_area(VERIFY_READ, data, sizeof(tc));
+			if (error)
+				return error;
+			copy_from_user(&tc, data, sizeof(tc));
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCGETS, (long)&t);
+			set_fs(old_fs);
+			if (error)
+				return error;
+
+			t.c_cc[VSUSP] = tc.t_suspc;
+			t.c_cc[VEOL2] = tc.t_dsuspc;
+			t.c_cc[VREPRINT] = tc.t_rprntc;
+			t.c_cc[VEOL2] = tc.t_flushc;
+			t.c_cc[VWERASE] = tc.t_werasc;
+			t.c_cc[VLNEXT] = tc.t_lnextc;
+
+			old_fs = get_fs();
+			set_fs(get_ds());
+			error = sys_ioctl(fd, TCSETS, (long)&t);
+			set_fs(old_fs);
+			return error;
+		}
+
+		case 13:				/* TIOEXCL */
+			return sys_ioctl(fd, TIOCEXCL, (long)data);
+
+		case 14:				/* TIOCNXCL */
+			return sys_ioctl(fd, TIOCNXCL, (long)data);
+
+		case 16:				/* TIOCFLUSH */
+			return sys_ioctl(fd, TCFLSH, (long)data);
+			
+
+		/* ISC (maybe SVR4 in general?) has some extensions over
+		 * the sgtty stuff. So do later BSDs. Needless to say they
+		 * both have different extensions.
+		 */
+		case 20: /* TCSETPGRP  (TIOC|20) set pgrp of tty */
+			return bsd_to_linux_termios(fd, TCSETS, data);
+
+		case 21: /* TCGETPGRP  (TIOC|21) get pgrp of tty */
+			return bsd_to_linux_termios(fd, TCSETSW, data);
+
+		case 19:				/* TIOCGETA */
+			return linux_to_bsd_termios(fd, TCGETS, data);
+
+		case 22:				/* TIOCSETAF */
+ 			return bsd_to_linux_termios(fd, TCSETSF, data);
+
+		case 26:				/* TIOCGETD */
+			return sys_ioctl(fd, TIOCGETD, (long)data);
+
+		case 27:				/* TIOCSETD */
+			return sys_ioctl(fd, TIOCSETD, (long)data);
+
+		case 97:				/* TIOCSCTTY */
+			return sys_ioctl(fd, TIOCSCTTY, (long)data);
+
+		case 103:				/* TIOCSWINSZ */
+			return sys_ioctl(fd, TIOCSWINSZ, (long)data);
+
+		case 104:				/* TIOCGWINSZ */
+			return sys_ioctl(fd, TIOCGWINSZ, (long)data);
+
+		case 113:				/* TIOCNOTTY */
+			return sys_ioctl(fd, TIOCNOTTY, (long)data);
+
+		case 118:	 			/* TIOCSPGRP */
+			return sys_ioctl(fd, TIOCSPGRP, (long)data);
+
+		case 119:				/* TIOCGPGRP */
+			return sys_ioctl(fd, TIOCGPGRP, (long)data);
+
+		case 123:				/* TIOCSBRK */
+			return sys_ioctl(fd, TCSBRK, (long)data);
+
+		case 124:				/* TIOCLGET */
+		case 125:				/* TIOCLSET */
+			return 0;
+
+
+		case 3:					/* TIOCMODG */
+		case 4:					/* TIOCMODS */
+		case 94:				/* TIOCDRAIN */
+		case 95:				/* TIOCSIG */
+		case 96:				/* TIOCEXT */
+		case 98:				/* TIOCCONS */
+		case 102:				/* TIOCUCNTL */
+		case 105:				/* TIOCREMOTE */
+		case 106:				/* TIOCMGET */
+		case 107:				/* TIOCMBIC */
+		case 108:				/* TIOCMBIS */
+		case 109:				/* TIOCMSET */
+		case 110:				/* TIOCSTART */
+		case 111:				/* TIOCSTOP */
+		case 112:				/* TIOCPKT */
+		case 114:				/* TIOCSTI */
+		case 115:				/* TIOCOUTQ */
+		case 120:				/* TIOCCDTR */
+		case 121:				/* TIOCSDTR */
+		case 122:				/* TIOCCBRK */
+                        break;
+	}
+
+	printk(KERN_ERR "BSD/V7: terminal ioctl 0x%08lx unsupported\n",
+		(unsigned long)func);
+	return -EINVAL;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(bsd_ioctl_termios);
+EXPORT_SYMBOL(svr4_term_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/svr4/timod.c linux-2.6.7-abi/abi/svr4/timod.c
--- linux-2.6.7/abi/svr4/timod.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/timod.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,200 @@
+/*
+ * Copyright 1995, 1996  Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/fcntl.h>
+#include <linux/socket.h>
+#include <linux/in.h>
+#include <linux/un.h>
+#include <linux/file.h>
+#include <linux/personality.h>
+#include <linux/poll.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <net/sock.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/stream.h>
+#include <abi/tli.h>
+
+#include <abi/svr4/ioctl.h>
+#include <abi/util/trace.h>
+
+
+/*
+ * Check if the inode belongs to /dev/socksys.
+ */
+#define IS_SOCKSYS(ip) (MAJOR((ip)->i_rdev) == SOCKSYS_MAJOR)
+
+
+int
+timod_getmsg(int fd, struct inode *ip, int pmsg, struct pt_regs *regs)
+{
+	struct strbuf	ctl, *ctlp, dat, *datp;
+	int		flags, *flagsp, *bandp;
+	int		error;
+
+	ctlp = (struct strbuf *)get_syscall_parameter(regs, 1);
+	datp = (struct strbuf *)get_syscall_parameter(regs, 2);
+
+	if (pmsg) {
+		bandp = (int *)get_syscall_parameter(regs, 3);
+		flagsp = (int *)get_syscall_parameter(regs, 4);
+	} else
+		flagsp = (int *)get_syscall_parameter (regs, 3);
+
+	if (ctlp) {
+		if (copy_from_user(&ctl, ctlp, sizeof(ctl)))
+			return -EFAULT;
+		if ((error = put_user(-1, &ctlp->len)))
+			return error;
+	} else
+		ctl.maxlen = -1;
+
+	if (datp) {
+		if (copy_from_user(&dat, datp, sizeof(dat)))
+			return -EFAULT;
+		if ((error = put_user(-1, &datp->len)))
+			return error;
+	} else
+		dat.maxlen = -1;
+
+	if ((error = get_user(flags, flagsp)))
+		return error;
+
+#ifdef CONFIG_ABI_SPX
+	if (IS_SOCKSYS(ip) && MINOR(ip->i_rdev) == 1) {
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+			"SPX: getmsg offers descriptor %d\n", fd);
+#endif
+
+		if ((error = put_user(fd, ctl.buf)))
+			return error;
+		if ((error = put_user(4, &ctlp->len)))
+			return error;
+
+		return 0;
+	}
+#endif /* CONFIG_ABI_SPX */
+
+#ifdef CONFIG_ABI_XTI
+	if (flags == 0 || flags == MSG_HIPRI ||
+	    flags == MSG_ANY || flags == MSG_BAND) {
+		struct file	*fp;
+
+		fp = fget(fd);
+		error = do_getmsg(fd, regs, ctl.buf, ctl.maxlen, &ctlp->len,
+				dat.buf, dat.maxlen, &datp->len, &flags);
+		fput(fp);
+
+		if (error >= 0)
+			error = put_user(flags, flagsp);
+		return error;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS,
+			"XTI: getmsg flags value bad (%d) for %d\n",
+			flags, fd);
+#endif /* CONFIG_ABI_TRACE */
+#endif /* CONFIG_ABI_XTI */
+	return -EINVAL;
+}
+
+
+int
+timod_putmsg(int fd, struct inode *ip, int pmsg, struct pt_regs *regs)
+{
+	struct strbuf		ctl, *ctlp, dat, *datp;
+	int			flags, band;
+	int			error;
+
+	ctlp = (struct strbuf *)get_syscall_parameter(regs, 1);
+	datp = (struct strbuf *)get_syscall_parameter(regs, 2);
+	if (pmsg) {
+		band = get_syscall_parameter(regs, 3);
+		flags = get_syscall_parameter(regs, 4);
+	} else
+		flags = get_syscall_parameter(regs, 3);
+
+	if (ctlp) {
+		if (copy_from_user(&ctl, ctlp, sizeof(ctl)))
+			return -EFAULT;
+		if (ctl.len < 0 && flags)
+			return -EINVAL;
+	} else {
+		ctl.len = 0;
+		ctl.buf = NULL;
+	}
+
+	if (datp) {
+		if (copy_from_user(&dat, datp, sizeof(dat)))
+			return -EFAULT;
+	} else {
+		dat.len = 0;
+		dat.buf = NULL;
+	}
+
+#ifdef CONFIG_ABI_SPX
+	if (IS_SOCKSYS(ip) && MINOR(ip->i_rdev) == 1) {
+		int		newfd;
+
+		if (ctl.len != 4)
+			return -EIO;
+
+		error = get_user(newfd, ctl.buf);
+		if (error)
+			return error;
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+				"SPX: putmsg on %d dups descriptor %d\n",
+				fd, newfd);
+#endif
+		error = sys_dup2(newfd, fd);
+
+		return (error < 0 ? error : 0);
+	}
+#endif /* CONFIG_ABI_SPX */
+
+#ifdef CONFIG_ABI_XTI
+	return do_putmsg(fd, regs, ctl.buf, ctl.len,
+			dat.buf, dat.len, flags);
+#endif
+	return -EINVAL;
+}
+
+int
+stream_fdinsert(struct pt_regs *regs, int fd, struct strfdinsert *arg)
+{
+	struct strfdinsert	sfd;
+
+	if (copy_from_user(&sfd, arg, sizeof(sfd)))
+		return -EFAULT;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS,
+			"%u fdinsert: flags=%ld, fildes=%u, offset=%d\n",
+			fd, sfd.flags, sfd.fildes, sfd.offset);
+#endif
+#ifdef CONFIG_ABI_XTI
+	return do_putmsg(fd, regs, sfd.ctlbuf.buf, sfd.ctlbuf.len,
+			sfd.datbuf.buf, sfd.datbuf.len, sfd.fildes);
+#else
+	return -EINVAL;
+#endif
+}
diff -Nru linux-2.6.7/abi/svr4/ulimit.c linux-2.6.7-abi/abi/svr4/ulimit.c
--- linux-2.6.7/abi/svr4/ulimit.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/ulimit.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,154 @@
+/*
+ *  Copyright (C) 1993  Joe Portman (baron@hebron.connected.com)
+ *	 First stab at ulimit
+ *
+ *  April 9 1994, corrected file size passed to/from setrlimit/getrlimit
+ *    -- Graham Adams (gadams@ddrive.demon.co.uk)
+ *
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/unistd.h>
+#include <linux/fs.h>
+#include <linux/resource.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+
+
+/*
+ * Arguments to ulimit - it's one of the stupid multipled calls...
+ */
+#define U_GETFSIZE 	(1)		  /* get max file size in blocks */
+#define U_SETFSIZE 	(2)		  /* set max file size in blocks */
+#define U_GETMEMLIM	(3)		  /* get process size limit */
+#define U_GETMAXOPEN	(4)		  /* get max open files for this process */
+#define U_GTXTOFF		(64)		  /* get text offset */
+
+/*
+ * Define nominal block size parameters.
+ */
+#define ULIM_BLOCKSIZE_BITS   9           /* block size = 512 */
+#define ULIM_MAX_BLOCKSIZE (INT_MAX >> ULIM_BLOCKSIZE_BITS)
+
+
+int
+svr4_ulimit (int cmd, int val)
+{
+	switch (cmd) {
+	case U_GETFSIZE:
+		return (current->rlim[RLIMIT_FSIZE].rlim_cur) >> ULIM_BLOCKSIZE_BITS;
+
+	case U_SETFSIZE:
+		if ((val > ULIM_MAX_BLOCKSIZE) || (val < 0))
+			return -ERANGE;
+		val <<= ULIM_BLOCKSIZE_BITS;
+		if (val > current->rlim[RLIMIT_FSIZE].rlim_max) {
+			if (!capable(CAP_SYS_RESOURCE))
+				return -EPERM;
+			current->rlim[RLIMIT_FSIZE].rlim_max = val;
+		}
+		current->rlim[RLIMIT_FSIZE].rlim_cur = val;
+		return 0;
+
+	case U_GETMEMLIM:
+		return current->rlim[RLIMIT_DATA].rlim_cur;
+
+	case U_GETMAXOPEN:
+		return current->rlim[RLIMIT_NOFILE].rlim_cur;
+
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API, "unsupported ulimit call %d\n", cmd);
+#endif
+		return -EINVAL;
+	}
+}
+
+/*
+ * getrlimit/setrlimit args.
+ */
+#define U_RLIMIT_CPU	0
+#define U_RLIMIT_FSIZE	1
+#define U_RLIMIT_DATA	2
+#define U_RLIMIT_STACK	3
+#define U_RLIMIT_CORE	4
+#define U_RLIMIT_NOFILE	5
+#define U_RLIMIT_AS	6
+
+
+int
+svr4_getrlimit(int cmd, void *val)
+{
+	switch (cmd) {
+	case U_RLIMIT_CPU:
+		cmd = RLIMIT_CPU;
+		break;
+	case U_RLIMIT_FSIZE:
+		cmd = RLIMIT_FSIZE;
+		break;
+	case U_RLIMIT_DATA:
+		cmd = RLIMIT_DATA;
+		break;
+	case U_RLIMIT_STACK:
+		cmd = RLIMIT_STACK;
+		break;
+	case U_RLIMIT_CORE:
+		cmd = RLIMIT_CORE;
+		break;
+	case U_RLIMIT_NOFILE:
+		cmd = RLIMIT_NOFILE;
+		break;
+	case U_RLIMIT_AS:
+		cmd = RLIMIT_AS;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return sys_getrlimit(cmd, val);
+}
+
+int
+svr4_setrlimit(int cmd, void *val)
+{
+	switch (cmd) {
+	case U_RLIMIT_CPU:
+		cmd = RLIMIT_CPU;
+		break;
+	case U_RLIMIT_FSIZE:
+		cmd = RLIMIT_FSIZE;
+		break;
+	case U_RLIMIT_DATA:
+		cmd = RLIMIT_DATA;
+		break;
+	case U_RLIMIT_STACK:
+		cmd = RLIMIT_STACK;
+		break;
+	case U_RLIMIT_CORE:
+		cmd = RLIMIT_CORE;
+		break;
+	case U_RLIMIT_NOFILE:
+		cmd = RLIMIT_NOFILE;
+		break;
+	case U_RLIMIT_AS:
+		cmd = RLIMIT_AS;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return sys_getrlimit(cmd, val);
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_getrlimit);
+EXPORT_SYMBOL(svr4_setrlimit);
+EXPORT_SYMBOL(svr4_ulimit);
+#endif
diff -Nru linux-2.6.7/abi/svr4/utsname.c linux-2.6.7-abi/abi/svr4/utsname.c
--- linux-2.6.7/abi/svr4/utsname.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/utsname.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 1994 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ * Copyright (C) 1994 Eric Youngdale.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/utsname.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+
+struct v7_utsname {
+	char sysname[9];
+	char nodename[9];
+	char release[9];
+	char version[9];
+	char machine[9];
+};
+
+#define SVR4_NMLN 257
+struct svr4_utsname {
+	char sysname[SVR4_NMLN];
+	char nodename[SVR4_NMLN];
+	char release[SVR4_NMLN];
+	char version[SVR4_NMLN];
+	char machine[SVR4_NMLN];
+};
+
+
+#define set_utsfield(to, from, dotchop) \
+	{ \
+		char *p; \
+		int i, len = (sizeof(to) > sizeof(from) ? sizeof(from) : sizeof(to)); \
+		__copy_to_user(to, from, len); \
+		if (dotchop) \
+			for (p=from,i=0; *p && *p != '.' && --len; p++,i++); \
+		else \
+			i = len - 1; \
+		__put_user('\0', to+i); \
+	}
+
+
+int v7_utsname(unsigned long addr)
+{
+	int error;
+	struct v7_utsname *it = (struct v7_utsname *)addr;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, it, sizeof (struct v7_utsname));
+	if (!error) {
+		set_utsfield(it->sysname, system_utsname.nodename, 1);
+		set_utsfield(it->nodename, system_utsname.nodename, 1);
+		set_utsfield(it->release, system_utsname.release, 0);
+		set_utsfield(it->version, system_utsname.version, 0);
+		set_utsfield(it->machine, system_utsname.machine, 0);
+	}
+	up_read(&uts_sem);
+
+	return error;
+}
+
+int abi_utsname(unsigned long addr)
+{
+	int error;
+	struct svr4_utsname *it = (struct svr4_utsname *)addr;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, it, sizeof (struct svr4_utsname));
+	if (!error) {
+		set_utsfield(it->sysname, system_utsname.sysname, 0);
+		set_utsfield(it->nodename, system_utsname.nodename, 0);
+		set_utsfield(it->release, system_utsname.release, 0);
+		set_utsfield(it->version, system_utsname.version, 0);
+		set_utsfield(it->machine, system_utsname.machine, 0);
+	}
+	up_read(&uts_sem);
+
+	return error;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(abi_utsname);
+EXPORT_SYMBOL(v7_utsname);
+#endif
diff -Nru linux-2.6.7/abi/svr4/xti.c linux-2.6.7-abi/abi/svr4/xti.c
--- linux-2.6.7/abi/svr4/xti.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/svr4/xti.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,1572 @@
+/*
+ * Copyright 1995, 1996  Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/fcntl.h>
+#include <linux/socket.h>
+#include <linux/in.h>
+#include <linux/un.h>
+#include <linux/file.h>
+#include <linux/personality.h>
+#include <linux/poll.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <net/sock.h>
+
+#include <abi/stream.h>
+#include <abi/tli.h>
+
+#include <abi/socksys.h> /* for socksys_fdinit */
+
+#include <abi/svr4/sockio.h>
+#include <abi/util/trace.h>
+#include <abi/util/errno.h>
+
+
+/*
+ * This is because TLI and XTI options buffers are incompatible and there
+ * is no clear way to detect which format we are dealing with here.
+ * Existing systems appear to have TLI options management implemented
+ * but return TNOTSUPPORT for XTI requests.
+ */
+#if defined(CONFIG_ABI_XTI_OPTMGMT) && defined(CONFIG_ABI_TLI_OPTMGMT)
+# error "unable to support _both_ TLI and XTI option management"
+#endif
+
+
+#if defined(CONFIG_ABI_TRACE)
+static char *const xti_tab[] = {
+	"T_CONN_REQ", "T_CONN_RES",
+	"T_DISCON_REQ",	"T_DATA_REQ",
+	"T_EXDATA_REQ", "T_INFO_REQ",
+	"T_BIND_REQ", "T_UNBIND_REQ",
+	"T_UNITDATA_REQ", "T_OPTMGMT_REQ",
+	"T_ORDREL_REQ","T_CONN_IND",
+	"T_CONN_CON", "T_DISCON_IND",
+	"T_DATA_IND", "T_EXDATA_IND",
+	"T_INFO_ACK", "T_BIND_ACK",
+	"T_ERROR_ACK","T_OK_ACK",
+	"T_UNITDATA_IND", "T_UDERROR_IND",
+	"T_OPTMGMT_ACK", "T_ORDREL_IND"
+};
+static char xti_unknown[] = "<unknown>";
+
+static char *
+xti_prim(int n)
+{
+	if (n < 0 || n >= ARRAY_SIZE(xti_tab))
+		return xti_unknown;
+	return xti_tab[n];
+}
+#endif
+
+
+#define timod_mkctl(len) kmalloc(sizeof(struct T_primsg)-sizeof(long)+len, \
+					GFP_KERNEL)
+
+
+static void
+timod_socket_wakeup(struct file *fp)
+{
+	struct socket		*sock;
+
+	sock = SOCKET_I(fp->f_dentry->d_inode);
+	wake_up_interruptible(&sock->wait);
+
+	read_lock(&sock->sk->sk_callback_lock);
+	if (sock->fasync_list && !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
+		__kill_fasync(sock->fasync_list, SIGIO, POLL_IN);
+	read_unlock(&sock->sk->sk_callback_lock);
+}
+
+
+static void
+timod_ok(int fd, int prim)
+{
+	struct file		*fp;
+	struct T_primsg		*it;
+	struct T_ok_ack 	*ok;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS, "TI: %u ok ack prim=%d\n", fd, prim);
+#endif
+
+	fp = fcheck(fd);
+	it = timod_mkctl(sizeof(struct T_ok_ack));
+	if (!it)
+		return;
+
+	ok = (struct T_ok_ack *)&it->type;
+	ok->PRIM_type = T_OK_ACK;
+	ok->CORRECT_prim = prim;
+	
+	it->pri = MSG_HIPRI;
+	it->length = sizeof(struct T_ok_ack);
+	it->next = Priv(fp)->pfirst;
+
+	Priv(fp)->pfirst = it;
+	if (!Priv(fp)->plast)
+		Priv(fp)->plast = it;
+	timod_socket_wakeup(fp);
+}
+
+static void
+timod_error(int fd, int prim, int terr, int uerr)
+{
+	struct file		*fp;
+	struct T_primsg		*it;
+	struct T_error_ack	*err;
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS, "TI: %u error prim=%d, TLI=%d, UNIX=%d\n",
+			fd, prim, terr, uerr);
+#endif
+
+	fp = fcheck(fd);
+	it = timod_mkctl(sizeof(struct T_error_ack));
+	if (!it)
+		return;
+	
+	err = (struct T_error_ack *)&it->type;
+	err->PRIM_type = T_ERROR_ACK;
+	err->ERROR_prim = prim;
+	err->TLI_error = terr;
+	err->UNIX_error = iABI_errors(uerr);
+
+	it->pri = MSG_HIPRI;
+	it->length = sizeof(struct T_error_ack);
+	it->next = Priv(fp)->pfirst;
+	
+	Priv(fp)->pfirst = it;
+	if (!Priv(fp)->plast)
+		Priv(fp)->plast = it;
+	timod_socket_wakeup(fp);
+}
+
+
+#if defined(CONFIG_ABI_XTI_OPTMGMT) || defined(CONFIG_ABI_TLI_OPTMGMT)
+/*
+ * XXX: this function is a _horrible_ mess.
+ */
+static int
+timod_optmgmt(int fd, struct pt_regs * regs, int flag,
+	      char * opt_buf, int opt_len, int do_ret)
+{
+	struct file * fp = fcheck(fd);
+	char *ret_buf, *ret_base;
+	u_long old_esp, *tsp;
+	int is_tli, error, failed;
+	int ret_len, ret_space;
+
+	if (opt_buf && opt_len > 0) {
+		error = verify_area(VERIFY_READ, opt_buf, opt_len);
+		if (error)
+			return error;
+	}
+
+	/*
+	 * FIXME:
+	 *   We should be able to detect the difference between
+	 *   TLI and XTI requests at run time?
+	 */
+	is_tli = CONFIG_ABI_TLI_OPTMGMT;
+
+	if (!do_ret && (!opt_buf || opt_len <= 0))
+		return 0;
+
+	/*
+	 * Grab some space on the user stack to work with. We need 6 longs
+	 * to build an argument frame for [gs]etsockopt calls. We also
+	 * need space to build the return buffer. This will be at least
+	 * as big as the given options buffer but the given options
+	 * buffer may not include space for option values so we allow two
+	 * longs for each option multiple of the option header size
+	 * and hope that big options will not exhaust our space and
+	 * trash the stack.
+	 */
+	ret_space = 1024 + opt_len
+		+ 2*sizeof(long)*(opt_len / (is_tli ? sizeof(struct opthdr) : sizeof(struct t_opthdr)));
+	ret_buf = ret_base = (char *)(regs->esp - ret_space);
+	ret_len = 0;
+
+	old_esp = regs->esp;
+	regs->esp -= ret_space + 6*sizeof(long);
+	tsp = (unsigned long *)(regs->esp);
+	error = verify_area(VERIFY_WRITE, tsp, 6*sizeof(long));
+	if (error) {
+		regs->esp = old_esp;
+		return error;
+	}
+
+	failed = 0;
+
+#ifndef CONFIG_ABI_TLI_OPTMGMT
+	if (is_tli) {
+		printk(KERN_WARNING
+			"%d iBCS: TLI optmgmt requested but not supported\n",
+			current->pid);
+	}
+#else
+	if (is_tli)
+		while (opt_len >= sizeof(struct opthdr)) {
+		struct opthdr opt;
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS, "TLI optmgmt opt_len=%d, "
+				"ret_buf=0x%08lx, ret_len=%d, ret_space=%d\n",
+				opt_len, (unsigned long)ret_buf,
+				ret_len, ret_space);
+#endif
+
+		copy_from_user(&opt, opt_buf, sizeof(struct opthdr));
+
+		/* Idiot check... */
+		if (opt.len > opt_len) {
+			failed = TBADOPT;
+			break;
+		}
+
+		if (abi_traced(ABI_TRACE_STREAMS)) {
+			unsigned long v;
+			get_user(v, (unsigned long *)(opt_buf+sizeof(struct opthdr)));
+#if defined(CONFIG_ABI_TRACE)
+			__abi_trace("TLI optmgmt fd=%d, level=%ld, "
+					"name=%ld, value=%ld\n",
+					fd, opt.level, opt.name, v);
+#endif
+		}
+
+		/* Check writable space in the return buffer. */
+		error = verify_area(VERIFY_WRITE, ret_buf, sizeof(struct opthdr));
+		if (error) {
+			failed = TSYSERR;
+			break;
+		}
+
+		/* Flag values:
+		 * T_NEGOTIATE means try and set it.
+		 * T_DEFAULT means get the default value.
+		 *           (return the current for now)
+		 * T_CHECK means get the current value.
+		 */
+		error = 0;
+		if (flag == T_NEGOTIATE) {
+			put_user(fd, tsp);
+			put_user(opt.level, tsp+1);
+			put_user(opt.name, tsp+2);
+			put_user((int)(opt_buf+sizeof(struct opthdr)), tsp+3);
+			put_user(opt.len, tsp+4);
+			error = abi_do_setsockopt(tsp);
+
+			if (error) {
+#if defined(CONFIG_ABI_TRACE)
+				abi_trace(ABI_TRACE_STREAMS,
+					"setsockopt failed: %d\n", error);
+#endif
+				failed = TBADOPT;
+				break;
+			}
+		}
+		if (!error) {
+			int len;
+
+			put_user(fd, tsp);
+			put_user(opt.level, tsp+1);
+			put_user(opt.name, tsp+2);
+			put_user((int)(ret_buf+sizeof(struct opthdr)), tsp+3);
+			put_user((int)(tsp+5), tsp+4);
+			put_user(ret_space, tsp+5);
+			error = abi_do_getsockopt(tsp);
+
+			if (error) {
+#if defined(CONFIG_ABI_TRACE)
+				abi_trace(ABI_TRACE_STREAMS,
+					"getsockopt failed: %d\n", error);
+#endif
+				failed = TBADOPT;
+				break;
+			}
+
+			get_user(len, tsp+5);
+			copy_to_user(ret_buf, &opt, sizeof(opt));
+			put_user(len,
+				&((struct opthdr *)opt_buf)->len);
+			ret_space -= sizeof(struct opthdr) + len;
+			ret_len += sizeof(struct opthdr) + len;
+			ret_buf += sizeof(struct opthdr) + len;
+		}
+
+		opt_len -= sizeof(struct opthdr) + opt.len;
+		opt_buf += sizeof(struct opthdr) + opt.len;
+	}
+#endif /* CONFIG_ABI_TLI_OPTMGMT */
+#ifndef CONFIG_ABI_XTI_OPTMGMT
+	else {
+		printk(KERN_WARNING
+			"%d iBCS: XTI optmgmt requested but not supported\n",
+			current->pid);
+	}
+#else
+	else while (opt_len >= sizeof(struct t_opthdr)) {
+		struct t_opthdr opt;
+
+		copy_from_user(&opt, opt_buf, sizeof(struct t_opthdr));
+		if (opt.len > opt_len) {
+			failed = 1;
+			break;
+		}
+
+		if (abi_traced(ABI_TRACE_STREAMS)) {
+			unsigned long v;
+			get_user(v, (unsigned long *)(opt_buf+sizeof(struct t_opthdr)));
+#if defined(CONFIG_ABI_TRACE)
+			__abi_trace("XTI optmgmt fd=%d, level=%ld, "
+					"name=%ld, value=%ld\n",
+					fd, opt.level, opt.name, v);
+#endif
+		}
+
+		/* Check writable space in the return buffer. */
+		if (verify_area(VERIFY_WRITE, ret_buf, sizeof(struct t_opthdr))) {
+			failed = 1;
+			break;
+		}
+
+		/* Flag values:
+		 * T_NEGOTIATE means try and set it.
+		 * T_CHECK means see if we could set it.
+		 *         (so we just set it for now)
+		 * T_DEFAULT means get the default value.
+		 *           (return the current for now)
+		 * T_CURRENT means get the current value (SCO xti.h has
+		 * no T_CURRENT???).
+		 */
+		error = 0;
+		if (flag == T_NEGOTIATE || flag == T_CHECK) {
+			put_user(fd, tsp);
+			put_user(opt.level, tsp+1);
+			put_user(opt.name, tsp+2);
+			put_user((int)(opt_buf+sizeof(struct t_opthdr)), tsp+3);
+			put_user(opt.len-sizeof(struct t_opthdr), tsp+4);
+			error = abi_do_setsockopt(tsp);
+		}
+		if (!error) {
+			put_user(fd, tsp);
+			put_user(opt.level, tsp+1);
+			put_user(opt.name, tsp+2);
+			put_user((int)(ret_buf+sizeof(struct t_opthdr)), tsp+3);
+			put_user((int)(tsp+5), tsp+4);
+			put_user(ret_space, tsp+5);
+			error = abi_do_getsockopt(tsp);
+			if (!error) {
+				int len;
+				get_user(len, tsp+5);
+				/* FIXME: opt.status should be set... */
+				copy_to_user(ret_buf, &opt, sizeof(opt));
+				put_user(len+sizeof(struct t_opthdr),
+					&((struct t_opthdr *)opt_buf)->len);
+				ret_space -= sizeof(struct t_opthdr) + len;
+				ret_len += sizeof(struct t_opthdr) + len;
+				ret_buf += sizeof(struct t_opthdr) + len;
+			}
+		}
+
+		failed |= error;
+		opt_len -= opt.len;
+		opt_buf += opt.len;
+	}
+#endif /* CONFIG_ABI_XTI_OPTMGMT */
+
+#if 0
+	/* If there is left over data the supplied options buffer was
+	 * formatted incorrectly. But we might have done some work so
+	 * we must fall through and return an acknowledgement I think.
+	 */
+	if (opt_len) {
+		regs->esp = old_esp;
+		return -EINVAL;
+	}
+#endif
+
+	if (do_ret) {
+		struct T_primsg *it;
+
+		if (failed) {
+			timod_error(fd, T_OPTMGMT_REQ, failed, -error);
+			regs->esp = old_esp;
+			return 0;
+		}
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+			"optmgmt returns %d bytes, failed=%d\n",
+			ret_len, failed);
+#endif
+
+		/* Convert the return buffer in the user stack to a
+		 * T_OPTMGMT_ACK
+		 * message and queue it.
+		 */
+		it = timod_mkctl(sizeof(struct T_optmgmt_ack) + ret_len);
+		if (it) {
+			struct T_optmgmt_ack *ack
+				= (struct T_optmgmt_ack *)&it->type;
+			ack->PRIM_type = T_OPTMGMT_ACK;
+			ack->OPT_length = ret_len;
+			ack->OPT_offset = sizeof(struct T_optmgmt_ack);
+			ack->MGMT_flags = (failed ? T_FAILURE : flag);
+			copy_from_user(((char *)ack)+sizeof(struct T_optmgmt_ack),
+				ret_base, ret_len);
+			it->pri = MSG_HIPRI;
+			it->length = sizeof(struct T_optmgmt_ack) + ret_len;
+			it->next = Priv(fp)->pfirst;
+			Priv(fp)->pfirst = it;
+			if (!Priv(fp)->plast)
+				Priv(fp)->plast = it;
+			timod_socket_wakeup(fp);
+		}
+	}
+
+	regs->esp = old_esp;
+	return 0;
+}
+
+#else /* no CONFIG_ABI_XTI_OPTMGMT or CONFIG_ABI_TLI_OPTMGMT */
+
+static int
+timod_optmgmt(int fd, struct pt_regs * regs, int flag,
+	      char * opt_buf, int opt_len, int do_ret)
+{
+	return -EINVAL;
+}
+
+#endif /* CONFIG_ABI_XTI_OPTMGMT or CONFIG_ABI_TLI_OPTMGMT */
+
+#define T_PRIV(fp)	Priv(fp)
+
+int
+timod_update_socket(int fd, struct file * fp, struct pt_regs * regs)
+{
+	struct socket * sock;
+	struct T_private * priv;
+	struct T_primsg * it;
+	struct T_conn_ind * ind;
+	u_long old_esp, * tsp, alen;
+	u_short oldflags;
+	int error = 0;
+
+	sock = SOCKET_I(fp->f_dentry->d_inode);
+	priv = T_PRIV(fp);
+	
+	/*
+	 * If this a SOCK_STREAM and is in the TS_WRES_CIND state
+	 * we are supposed to be looking for an incoming connection.
+	 */
+	if (sock->type != SOCK_STREAM || priv->state != TS_WRES_CIND)
+		goto out;
+
+	old_esp = regs->esp;
+	regs->esp -= 1024;
+	tsp = (unsigned long *)regs->esp;
+	error = verify_area(VERIFY_WRITE, tsp,
+			3*sizeof(long)+sizeof(struct sockaddr));
+	if (error) {
+		regs->esp = old_esp;
+		goto out;
+	}
+
+	put_user(fd, tsp);
+	put_user((unsigned long)(tsp+4), tsp+1);
+	put_user((unsigned long)(tsp+3), tsp+2);
+	put_user(sizeof(struct sockaddr), tsp+3);
+
+	/*
+	 * We don't want to block in the accept(). Any
+	 * blocking necessary must be handled earlier.
+	 */
+	oldflags = fp->f_flags;
+	fp->f_flags |= O_NONBLOCK;
+	error = sys_socketcall(SYS_ACCEPT, tsp);
+	fp->f_flags = oldflags;
+
+	if (error < 0)
+		goto out_set;
+
+	/* The new fd needs to be fixed up
+	 * with the iBCS file functions and a
+	 * timod state block.
+	 */
+	inherit_socksys_funcs(error, TS_DATA_XFER);
+
+	/* Generate a T_CONN_IND and queue it. */
+	get_user(alen, tsp+3);
+	it = timod_mkctl(sizeof(struct T_conn_ind) + alen);
+	if (!it) {
+		/* Oops, just drop the connection I guess. */
+		sys_close(error);
+		goto out_set;
+	}
+		
+	ind = (struct T_conn_ind *)&it->type;
+	ind->PRIM_type = T_CONN_IND;
+	ind->SRC_length = alen;
+	ind->SRC_offset = sizeof(struct T_conn_ind);
+	ind->OPT_length = ind->OPT_offset = 0;
+	ind->SEQ_number = error;
+
+	copy_from_user(((char *)ind)+sizeof(struct T_conn_ind), tsp+4, alen);
+#if 0
+	it->pri = MSG_HIPRI;
+#endif
+	it->length = sizeof(struct T_conn_ind) + alen;
+	it->next = Priv(fp)->pfirst;
+	Priv(fp)->pfirst = it;
+	if (!Priv(fp)->plast)
+		Priv(fp)->plast = it;
+	timod_socket_wakeup(fp);
+
+out_set:
+	regs->esp = old_esp;
+out:
+	return (error);
+}
+
+
+int
+do_getmsg(int fd, struct pt_regs *regs, char *ctl_buf,
+	  int ctl_maxlen, int *ctl_len, char *dat_buf,
+	  int dat_maxlen, int *dat_len, int *flags_p)
+{
+	int error;
+	long old_esp;
+	unsigned long *tsp;
+	unsigned short oldflags;
+	struct T_unitdata_ind udi;
+	struct file *filep;
+
+	/*
+	 * It may not be obvious but we are always holding an fget(fd)
+	 * at this point so we can use fcheck(fd) rather than fget...fput.
+	 */
+	filep = fcheck(fd);
+
+	if (!Priv(filep) && Priv(filep)->magic != XTI_MAGIC) {
+		printk("putmsg on non-STREAMS fd %d by %s\n",fd, current->comm);
+		return -EINVAL;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS,
+			"getmsg %d, 0x%lx[%d], 0x%lx[%d], %x\n",
+			fd, (u_long)ctl_buf, ctl_maxlen,
+			(u_long)dat_buf, dat_maxlen, *flags_p);
+#endif
+
+	/*
+	 * We need some user space to build syscall argument vectors
+	 * later. Set it up now and page it in if necessary. This will
+	 * avoid (most?) potential blocking after the select().
+	 */
+	old_esp = regs->esp;
+	regs->esp -= 1024;
+	tsp = (unsigned long *)regs->esp;
+	error = verify_area(VERIFY_WRITE, tsp, 6*sizeof(long));
+	regs->esp = old_esp;
+	if (error)
+		return error;
+
+	/*
+	 * If the TEP is not non-blocking we must test for
+	 * something to do. We don't necessarily know what order
+	 * events will be happening on the socket so we have to
+	 * watch for evrything at once.
+	 * N.B. If we weren't asked for data we should only be looking
+	 * for connection requests. There are socket type issues to
+	 * consider here.
+	 */
+	if (!(filep->f_flags & O_NONBLOCK)) {
+                struct poll_wqueues wait_queue;
+		poll_table *wait;
+		unsigned long mask = (POLLIN | POLLRDNORM | POLLHUP | POLLERR);
+
+		if (*flags_p == MSG_HIPRI)
+			mask |= POLLPRI;
+
+		poll_initwait(&wait_queue);
+		wait = &wait_queue.pt;
+
+		/*
+		 * N.B. We need to be sure to recheck after a schedule()
+		 * so that when we proceed it is because there is
+		 * something to do and nothing else can get there
+		 * before us.
+		 */
+		while (!(filep->f_op->poll(filep, wait) & mask)
+				&& !signal_pending(current)) {
+			current->state = TASK_INTERRUPTIBLE;
+			wait = NULL;
+			schedule();
+		}
+
+		current->state = TASK_RUNNING;
+		poll_freewait(&wait_queue);
+
+		if (signal_pending(current))
+			return -EINTR;
+	}
+
+	if (ctl_maxlen >= 0 && !Priv(filep)->pfirst)
+		timod_update_socket(fd, filep, regs);
+
+	/*
+	 * If we were asked for a control part and there is an outstanding
+	 * message queued as a result of some other operation we'll
+	 * return that.
+	 */
+	if (ctl_maxlen >= 0 && Priv(filep)->pfirst) {
+		int l = ctl_maxlen <= Priv(filep)->pfirst->length
+				? ctl_maxlen : Priv(filep)->pfirst->length;
+		error = verify_area(VERIFY_WRITE, ctl_buf, l);
+		if (error)
+			return error;
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS,
+			"priority message %ld %s\n",
+			Priv(filep)->pfirst->type,
+			xti_prim(Priv(filep)->pfirst->type));
+#endif
+
+		copy_to_user(ctl_buf, ((char *)&Priv(filep)->pfirst->type)
+					+ Priv(filep)->offset, l);
+		put_user(l, ctl_len);
+		if (dat_maxlen >= 0)
+			put_user(0, dat_len);
+		*flags_p = Priv(filep)->pfirst->pri;
+		Priv(filep)->pfirst->length -= l;
+
+#if defined(CONFIG_ABI_TRACE)
+		if (abi_traced(ABI_TRACE_STREAMS) && ctl_buf && l > 0) {
+			int i = -1;
+
+			for (i = 0; i < l && i < 64; i += 4) {
+				u_long v;
+
+				get_user(v, (u_long *)(ctl_buf + i));
+				__abi_trace("ctl: 0x%08lx\n", v);
+			}
+			if (i != l)
+				__abi_trace("ctl: ...\n");
+		}
+#endif
+
+		if (Priv(filep)->pfirst->length) {
+			Priv(filep)->offset += l;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS,
+					"MORECTL %d bytes",
+					Priv(filep)->pfirst->length);
+#endif
+			return MORECTL;
+		} else {
+			struct T_primsg *it = Priv(filep)->pfirst;
+			Priv(filep)->pfirst = it->next;
+			if (!Priv(filep)->pfirst)
+				Priv(filep)->plast = NULL;
+			kfree(it);
+			Priv(filep)->offset = 0;
+			return 0;
+		}
+	}
+
+	*flags_p = 0;
+
+	/* If we weren't asked for data there is nothing more to do. */
+	if (dat_maxlen <= 0) {
+		if (dat_maxlen == 0)
+			put_user(0, dat_len);
+		if (ctl_maxlen >= 0)
+			put_user(0, ctl_len);
+		return -EAGAIN;
+	}
+
+	/* If the select() slept we may have had our temp space paged
+	 * out. The re-verify_area is only really needed for pre-486
+	 * chips which don't handle write faults from kernel mode.
+	 */
+	regs->esp = (unsigned long)tsp;
+	error = verify_area(VERIFY_WRITE, tsp, 6*sizeof(long));
+	if (error) {
+		regs->esp = old_esp;
+		return error;
+	}
+	put_user(fd, tsp);
+	put_user((unsigned long)dat_buf, tsp+1);
+	put_user((dat_maxlen < 0 ? 0 : dat_maxlen), tsp+2);
+	put_user(0, tsp+3);
+	if (ctl_maxlen > (int)sizeof(udi) && Priv(filep)->state == TS_IDLE) {
+		put_user((unsigned long)ctl_buf+sizeof(udi), tsp+4);
+		put_user(ctl_maxlen-sizeof(udi), ctl_len);
+		put_user((int)ctl_len, tsp+5);
+	} else {
+		put_user(0, tsp+4);
+		put_user(0, ctl_len);
+		put_user((int)ctl_len, tsp+5);
+	}
+
+	/* We don't want to block in the recvfrom(). Any blocking is
+	 * handled by the select stuff above.
+	 */
+	oldflags = filep->f_flags;
+	filep->f_flags |= O_NONBLOCK;
+	error = sys_socketcall(SYS_RECVFROM, tsp);
+	filep->f_flags = oldflags;
+
+	regs->esp = old_esp;
+	if (error < 0)
+		return error;
+	if (error
+	&& ctl_maxlen > (int)sizeof(udi)
+	&& Priv(filep)->state == TS_IDLE) {
+		udi.PRIM_type = T_UNITDATA_IND;
+		get_user(udi.SRC_length, ctl_len);
+		udi.SRC_offset = sizeof(udi);
+		udi.OPT_length = udi.OPT_offset = 0;
+		copy_to_user(ctl_buf, &udi, (int)sizeof(udi));
+		put_user(sizeof(udi)+udi.SRC_length, ctl_len);
+#if 0
+#if defined(CONFIG_ABI_TRACE)
+		if (abi_traced(ABI_TRACE_STREAMS) &&
+		    ctl_buf && udi.SRC_length > 0) {
+			char * buf = ctl_buf + sizeof(udi);
+			int i = -1;
+
+			for (i = 0; i < udi.SRC_length &&
+			     i < 64; i += 4) {
+				u_long v;
+
+				get_user(v, (u_long *)(buf+i));
+				__abi_trace("dat: 0x%08lx\n", v);
+			}
+			if (i != udi.SRC_length)
+				__abi_trace("dat: ...\n");
+		}
+#endif
+#endif
+	} else {
+		put_user(0, ctl_len);
+	}
+	put_user(error, dat_len);
+
+	return 0;
+}
+
+
+int
+do_putmsg(int fd, struct pt_regs *regs, char *ctl_buf, int ctl_len,
+	char *dat_buf, int dat_len, int flags)
+{
+	struct file *filep;
+	int error, terror;
+	unsigned long cmd;
+
+	/* It may not be obvious but we are always holding an fget(fd)
+	 * at this point so we can use fcheck(fd) rather than fget...fput.
+	 */
+	filep = fcheck(fd);
+
+	if (!Priv(filep) && Priv(filep)->magic != XTI_MAGIC) {
+		printk("putmsg on non-STREAMS fd %d by %s\n",fd, current->comm);
+		return -EINVAL;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_STREAMS)) {
+		u_long v;
+		__abi_trace("putmsg %d, 0x%lx[%d], 0x%lx[%d], %x\n",
+			fd, (u_long)ctl_buf, ctl_len,
+			(u_long)dat_buf, dat_len, flags);
+
+		get_user(v, ctl_buf);
+		__abi_trace("putmsg prim: %ld %s\n", v, xti_prim(v));
+
+		if (ctl_buf && ctl_len > 0) {
+			int i = -1;
+
+			for (i = 0; i < ctl_len && i < 64; i += 4) {
+				u_long v;
+
+				get_user(v, (u_long *)(ctl_buf + i));
+				__abi_trace("ctl: 0x%08lx\n", v);
+			}
+			if (i != ctl_len)
+				__abi_trace("ctl: ...\n");
+		}
+
+		if (dat_buf && dat_len > 0) {
+			int i = -1;
+
+			for (i = 0; i < dat_len && i < 64; i += 4) {
+				u_long v;
+
+				get_user(v, (u_long *)(dat_buf + i));
+				__abi_trace("dat: 0x%08lx\n", v);
+			}
+			if (i != dat_len)
+				__abi_trace("dat: ...");
+		}
+	}
+#endif
+
+	error = get_user(cmd, (unsigned long *)ctl_buf);
+	if (error)
+		return error;
+
+	switch (cmd) {
+		case T_BIND_REQ: {
+			struct T_bind_req req;
+			long old_esp;
+			unsigned long *tsp;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u bind req\n", fd);
+#endif
+			error = verify_area(VERIFY_READ, ctl_buf, sizeof(req));
+			if (error)
+				return error;
+
+			if (Priv(filep)->state != TS_UNBND) {
+				timod_error(fd, T_BIND_REQ, TOUTSTATE, 0);
+				return 0;
+			}
+
+			old_esp = regs->esp;
+			regs->esp -= 1024;
+			tsp = (unsigned long *)(regs->esp);
+			error = verify_area(VERIFY_WRITE, tsp, 3*sizeof(long));
+			if (error) {
+				timod_error(fd, T_BIND_REQ, TSYSERR, -error);
+				regs->esp = old_esp;
+				return 0;
+			}
+
+			copy_from_user(&req, ctl_buf, sizeof(req));
+			if (req.ADDR_offset && req.ADDR_length) {
+				struct sockaddr_in *sin;
+				unsigned short family;
+
+#if 1				/* Wheee... Kludge time... */
+				sin = (struct sockaddr_in *)(ctl_buf
+					+ req.ADDR_offset);
+				get_user(family, &sin->sin_family);
+
+				/* Sybase seems to have set up the address
+				 * struct with sa->sa_family = htons(AF_?)
+				 * which is bollocks. I have no idea why it
+				 * apparently works on SCO?!?
+				 */
+				if (family && !(family & 0x00ff))
+					put_user(ntohs(family), &sin->sin_family);
+#endif
+
+				put_user(fd, tsp);
+				put_user((unsigned long)ctl_buf
+						+ req.ADDR_offset, tsp+1);
+				/* For TLI/XTI the length may be the 8 *used*
+				 * bytes, for (IP?) sockets it must be the 16
+				 * *total* bytes in a sockaddr_in.
+				 */
+				put_user(req.ADDR_length == 8
+					? 16 : req.ADDR_length,
+					tsp+2);
+				error = sys_socketcall(SYS_BIND, tsp);
+
+				if (!error) {
+					if (req.CONIND_number) {
+
+#if defined(CONFIG_ABI_TRACE)
+						abi_trace(ABI_TRACE_STREAMS,
+							"%u listen backlog=%lu\n",
+							fd, req.CONIND_number);
+#endif
+
+						put_user(fd, tsp);
+						put_user(req.CONIND_number, tsp+1);
+						sys_socketcall(SYS_LISTEN, tsp);
+						Priv(filep)->state = TS_WRES_CIND;
+					} else {
+						Priv(filep)->state = TS_IDLE;
+					}
+				}
+			} else {
+				error = 0;
+			}
+
+			regs->esp = old_esp;
+
+			if (!error) {
+				struct T_primsg *it;
+				it = timod_mkctl(ctl_len);
+				if (it) {
+					struct T_bind_ack *ack = (struct T_bind_ack *)&it->type;
+					copy_from_user(ack, ctl_buf, ctl_len);
+					ack->PRIM_type = T_BIND_ACK;
+					it->pri = MSG_HIPRI;
+					it->length = ctl_len;
+					it->next = NULL;
+					timod_ok(fd, T_BIND_REQ);
+					Priv(filep)->plast->next = it;
+					Priv(filep)->plast = it;
+					return 0;
+				}
+			}
+			switch (error) {
+				case -EINVAL:
+					terror = TOUTSTATE;
+					error = 0;
+					break;
+				case -EACCES:
+					terror = TACCES;
+					error = 0;
+					break;
+				case -EADDRNOTAVAIL:
+				case -EADDRINUSE:
+					terror = TNOADDR;
+					error = 0;
+					break;
+				default:
+					terror = TSYSERR;
+					break;
+			}
+			timod_error(fd, T_BIND_REQ, terror, -error);
+			return 0;
+		}
+		case T_CONN_RES: {
+			struct T_conn_res *res = (struct T_conn_res *)ctl_buf;
+			unsigned int conn_fd;
+
+			error = get_user(conn_fd, &res->SEQ_number);
+			if (error)
+				return error;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS,
+					"%u accept: conn fd=%u, use fd=%u\n",
+					fd, conn_fd, flags);
+#endif
+
+			if (conn_fd != flags) {
+				error = sys_dup2(conn_fd, flags);
+				sys_close(conn_fd);
+				if (error < 0)
+					return error;
+			}
+			timod_ok(fd, T_CONN_RES);
+			return 0;
+		}
+		case T_CONN_REQ: {
+			struct T_conn_req req;
+			long old_esp;
+			unsigned short oldflags;
+			unsigned long *tsp;
+			struct T_primsg *it;
+			struct sockaddr_in *sin;
+			unsigned short family;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u connect req\n", fd);
+#endif
+			error = verify_area(VERIFY_READ, ctl_buf, sizeof(req));
+			if (error)
+				return error;
+
+			if (Priv(filep)->state != TS_UNBND
+			&& Priv(filep)->state != TS_IDLE) {
+				timod_error(fd, T_CONN_REQ, TOUTSTATE, 0);
+				return 0;
+			}
+
+			old_esp = regs->esp;
+			regs->esp -= 1024;
+			tsp = (unsigned long *)(regs->esp);
+			error = verify_area(VERIFY_WRITE, tsp, 3*sizeof(long));
+			if (error) {
+				timod_error(fd, T_CONN_REQ, TSYSERR, -error);
+				regs->esp = old_esp;
+				return 0;
+			}
+			copy_from_user(&req, ctl_buf, sizeof(req));
+			put_user(fd, tsp);
+			put_user((unsigned long)ctl_buf + req.DEST_offset, tsp+1);
+			/* For TLI/XTI the length may be the 8 *used*
+			 * bytes, for (IP?) sockets it must be the 16
+			 * *total* bytes in a sockaddr_in.
+			 */
+			put_user(req.DEST_length == 8
+				? 16 : req.DEST_length,
+				tsp+2);
+
+#if 1			/* Wheee... Kludge time... */
+			sin = (struct sockaddr_in *)(ctl_buf
+				+ req.DEST_offset);
+			get_user(family, &sin->sin_family);
+
+			/* Sybase seems to have set up the address
+			 * struct with sa->sa_family = htons(AF_?)
+			 * which is bollocks. I have no idea why it
+			 * apparently works on SCO?!?
+			 */
+			if (family && !(family & 0x00ff)) {
+				family = ntohs(family);
+				put_user(family, &sin->sin_family);
+			}
+
+			/* Sheesh... ISC telnet seems to give the port
+			 * number low byte first as I expected but the
+			 * X programs seem to be giving high byte first.
+			 * One is broken of course but clearly both
+			 * should work. No, I don't understand this
+			 * either but I can at least try...
+			 * A better solution would be for you to change
+			 * the definition of xserver0 in ISC's /etc/services
+			 * but then it wouldn't work out of the box...
+			 */
+			if (is_cur_personality(PER_SVR4) && family == AF_INET) {
+				get_user(family, &sin->sin_port);
+				if (family == 0x1770)
+					put_user(htons(family),
+						&sin->sin_port);
+			}
+#endif
+			/* FIXME: We should honour non-blocking mode
+			 * here but that means that the select probe
+			 * needs to know that if select returns ok and
+			 * we are in T_OUTCON we have a connection
+			 * completion. This isn't so bad but the real
+			 * problem is that the connection acknowledgement
+			 * is supposed to contain the destination
+			 * address.
+			 */
+			oldflags = filep->f_flags;
+			filep->f_flags &= ~O_NONBLOCK;
+			error = sys_socketcall(SYS_CONNECT, tsp);
+			filep->f_flags = oldflags;
+			regs->esp = old_esp;
+
+			if (!error) {
+				struct T_conn_con *con;
+
+				it = timod_mkctl(ctl_len);
+				if (!it)
+					return -ENOMEM;
+				it->length = ctl_len;
+				con = (struct T_conn_con *)&it->type;
+				copy_from_user(con, ctl_buf, ctl_len);
+				con->PRIM_type = T_CONN_CON;
+				Priv(filep)->state = TS_DATA_XFER;
+			} else {
+				struct T_discon_ind *dis;
+
+#if defined(CONFIG_ABI_TRACE)
+				abi_trace(ABI_TRACE_STREAMS,
+						"%u connect failed (errno=%d)\n",
+						fd, error);
+#endif
+
+				it = timod_mkctl(sizeof(struct T_discon_ind));
+				if (!it)
+					return -ENOMEM;
+				it->length = sizeof(struct T_discon_ind);
+				dis = (struct T_discon_ind *)&it->type;
+				dis->PRIM_type = T_DISCON_IND;
+				dis->DISCON_reason = iABI_errors(-error);
+				dis->SEQ_number = 0;
+			}
+			timod_ok(fd, T_CONN_REQ);
+			it->pri = 0;
+			it->next = NULL;
+			Priv(filep)->plast->next = it;
+			Priv(filep)->plast = it;
+			return 0;
+		}
+
+		case T_DISCON_REQ: {
+			struct T_discon_req *req;
+
+			req = (struct T_discon_req *)ctl_buf;
+			error = get_user(fd, &req->SEQ_number);
+			if (error)
+				return error;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "disconnect %u\n", fd);
+#endif
+			/* Fall through... */
+		}
+		case T_ORDREL_REQ: {
+			sys_close(fd);
+			return 0;
+		}
+
+		case T_DATA_REQ: {
+			long old_esp;
+			unsigned long *tsp;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u data req\n", fd);
+#endif
+
+			if (Priv(filep)->state != TS_DATA_XFER) {
+				return 0;
+			}
+
+			old_esp = regs->esp;
+			regs->esp -= 1024;
+			tsp = (unsigned long *)(regs->esp);
+			error = verify_area(VERIFY_WRITE, tsp, 6*sizeof(long));
+			if (error) {
+				regs->esp = old_esp;
+				return 0;
+			}
+			put_user(fd, tsp);
+			put_user((unsigned long)dat_buf, tsp+1);
+			put_user(dat_len, tsp+2);
+			put_user(0, tsp+3);
+			error = sys_socketcall(SYS_SEND, tsp);
+			regs->esp = old_esp;
+			return error;
+		}
+
+		case T_UNITDATA_REQ: {
+			struct T_unitdata_req req;
+			long old_esp;
+			unsigned long *tsp;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u unitdata req\n", fd);
+#endif
+			error = verify_area(VERIFY_READ, ctl_buf, sizeof(req));
+			if (error)
+				return error;
+
+			if (Priv(filep)->state != TS_IDLE
+			&& Priv(filep)->state != TS_DATA_XFER) {
+				timod_error(fd, T_UNITDATA_REQ, TOUTSTATE, 0);
+				return 0;
+			}
+
+			old_esp = regs->esp;
+			regs->esp -= 1024;
+			tsp = (unsigned long *)(regs->esp);
+			error = verify_area(VERIFY_WRITE, tsp, 6*sizeof(long));
+			if (error) {
+				timod_error(fd, T_UNITDATA_REQ, TSYSERR, -error);
+				regs->esp = old_esp;
+				return 0;
+			}
+			put_user(fd, tsp);
+			put_user((unsigned long)dat_buf, tsp+1);
+			put_user(dat_len, tsp+2);
+			put_user(0, tsp+3);
+			copy_from_user(&req, ctl_buf, sizeof(req));
+			if (req.DEST_length > 0) {
+				put_user((unsigned long)(ctl_buf+req.DEST_offset), tsp+4);
+				put_user(req.DEST_length, tsp+5);
+				error = sys_socketcall(SYS_SENDTO, tsp);
+				regs->esp = old_esp;
+				return error;
+			}
+			error = sys_socketcall(SYS_SEND, tsp);
+			regs->esp = old_esp;
+			return error;
+		}
+
+		case T_UNBIND_REQ:
+			Priv(filep)->state = TS_UNBND;
+			timod_ok(fd, T_UNBIND_REQ);
+			return 0;
+
+		case T_OPTMGMT_REQ: {
+			struct T_optmgmt_req req;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u optmgmt req\n", fd);
+#endif
+			error = verify_area(VERIFY_READ, ctl_buf, sizeof(req));
+			if (error)
+				return error;
+			copy_from_user(&req, ctl_buf, sizeof(req));
+
+			return timod_optmgmt(fd, regs, req.MGMT_flags,
+					req.OPT_offset > 0
+						? ctl_buf+req.OPT_offset
+						: NULL,
+					req.OPT_length,
+					1);
+		}
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+      if (abi_traced(ABI_TRACE_STREAMS))
+      {
+
+	if (ctl_buf && ctl_len > 0) {
+		int		i;
+
+		for (i = 0; i < ctl_len && i < 32; i += 4) {
+			u_long	v;
+
+			get_user(v, (u_long *)(ctl_buf + i));
+			__abi_trace("ctl: 0x%08lx\n", v);
+		}
+		if (i != ctl_len)
+			__abi_trace("ctl: ...\n");
+	}
+	if (dat_buf && dat_len > 0) {
+		int		i;
+		for (i = 0; i < dat_len && i < 32; i += 4) {
+			u_long	v;
+
+			get_user(v, (u_long *)(dat_buf + i));
+			__abi_trace("dat: 0x%08lx\n", v);
+		}
+		if (i != dat_len)
+			__abi_trace("dat: ...\n");
+	}
+      }
+#endif
+	return -EINVAL;
+}
+
+/* this function needs to be cleaned up badly.  --hch */
+int
+timod_ioctl(struct pt_regs *regs,
+	int fd, unsigned int func, void *arg, int len, int *len_p)
+{
+	struct file *filep;
+	struct inode *ino;
+	int error;
+
+	func &= 0xff;
+	
+	filep = fget(fd);
+	if (!filep)
+		return TBADF;
+
+	error = verify_area(VERIFY_WRITE, len_p, sizeof(int));
+	if (error) {
+		fput(filep);
+		return (-error << 8) | TSYSERR;
+	}
+
+	ino = filep->f_dentry->d_inode;
+
+	/* SCO/SVR3 starts at 100, ISC/SVR4 starts at 140. */
+	switch (func >= 140 ? func-140 : func-100) {
+		case 0: /* TI_GETINFO */
+		{
+			struct T_info_ack it;
+			unsigned long v;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u getinfo\n", fd);
+#endif
+			/* The pre-SVR4 T_info_ack structure didn't have
+			 * the PROVIDER_flag on the end.
+			 */
+			error = verify_area(VERIFY_WRITE, arg,
+				func == 140
+				? sizeof(struct T_info_ack)
+				: sizeof(struct T_info_ack)-sizeof(long));
+			if (error) {
+				fput(filep);
+				return (-error << 8) | TSYSERR;
+			}
+
+			__get_user(v, &((struct T_info_req *)arg)->PRIM_type);
+			if (v != T_INFO_REQ) {
+				fput(filep);
+				return (EINVAL << 8) | TSYSERR;
+			}
+
+			it.PRIM_type = T_INFO_ACK;
+			it.CURRENT_state = Priv(filep)->state;
+			it.CDATA_size = -2;
+			it.DDATA_size = -2;
+			it.OPT_size = -1;
+			it.TIDU_size = 16384;
+			switch ((MINOR(ino->i_rdev)>>4) & 0x0f) {
+				case AF_UNIX:
+					it.ADDR_size = sizeof(struct sockaddr_un);
+					break;
+				case AF_INET:
+					it.ADDR_size = sizeof(struct sockaddr_in);
+					break;
+				default:
+					/* Uh... dunno... play safe(?) */
+					it.ADDR_size = 1024;
+					break;
+			}
+			switch (SOCKET_I(ino)->type) {
+				case SOCK_STREAM:
+					it.ETSDU_size = 1;
+					it.TSDU_size = 0;
+					it.SERV_type = 2;
+					break;
+				default:
+					it.ETSDU_size = -2;
+					it.TSDU_size = 16384;
+					it.SERV_type = 3;
+					break;
+			}
+
+			fput(filep);
+
+			/* The pre-SVR4 T_info_ack structure didn't have
+			 * the PROVIDER_flag on the end.
+			 */
+			if (func == 140) {
+				it.PROVIDER_flag = 0;
+				copy_to_user(arg, &it, sizeof(it));
+				put_user(sizeof(it), len_p);
+				return 0;
+			}
+			copy_to_user(arg, &it, sizeof(it)-sizeof(long));
+			put_user(sizeof(it)-sizeof(long), len_p);
+			return 0;
+		}
+
+		case 2: /* TI_BIND */
+		{
+			int i;
+			long prim;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u bind\n", fd);
+#endif
+			error = do_putmsg(fd, regs, arg, len,
+					NULL, -1, 0);
+			if (error) {
+				fput(filep);
+				return (-error << 8) | TSYSERR;
+			}
+
+			/* Get the response. This should be either
+			 * T_OK_ACK or T_ERROR_ACK.
+			 */
+			i = MSG_HIPRI;
+			error = do_getmsg(fd, regs,
+					arg, len, len_p,
+					NULL, -1, NULL,
+					&i);
+			if (error) {
+				fput(filep);
+				return (-error << 8) | TSYSERR;
+			}
+
+			get_user(prim, (unsigned long *)arg);
+			if (prim == T_ERROR_ACK) {
+				unsigned long a, b;
+				fput(filep);
+				get_user(a, ((unsigned long *)arg)+3);
+				get_user(b, ((unsigned long *)arg)+2);
+				return (a << 8) | b;
+			}
+			if (prim != T_OK_ACK) {
+				fput(filep);
+				return TBADSEQ;
+			}
+
+			/* Get the response to the bind request. */
+			i = MSG_HIPRI;
+			error = do_getmsg(fd, regs,
+					arg, len, len_p,
+					NULL, -1, NULL,
+					&i);
+			fput(filep);
+			if (error)
+				return (-error << 8) | TSYSERR;
+
+			return 0;
+		}
+
+		case 3: /* TI_UNBIND */
+			if (Priv(filep)->state != TS_IDLE) {
+				fput(filep);
+				return TOUTSTATE;
+			}
+			Priv(filep)->state = TS_UNBND;
+			fput(filep);
+			return 0;
+
+		case 1: { /* TI_OPTMGMT */
+#if defined(CONFIG_ABI_XTI_OPTMGMT) || defined(CONFIG_ABI_TLI_OPTMGMT)
+			int i;
+			long prim;
+
+#if defined(CONFIG_ABI_TRACE)
+			abi_trace(ABI_TRACE_STREAMS, "%u optmgmt\n", fd);
+#endif
+			error = do_putmsg(fd, regs, arg, len,
+					NULL, -1, 0);
+			if (error) {
+				fput(filep);
+				return (-error << 8) | TSYSERR;
+			}
+
+			/* Get the response to the optmgmt request. */
+			i = MSG_HIPRI;
+			error = do_getmsg(fd, regs,
+					arg, len, len_p,
+					NULL, -1, NULL,
+					&i);
+			if (error > 0) {
+				/* If there is excess data in the response
+				 * our buffer is too small which implies
+				 * the application is broken. SO_LINGER
+				 * is a common fault. Because it works
+				 * on other systems we attempt to recover
+				 * by discarding the excess.
+				 */
+				struct T_primsg *it = Priv(filep)->pfirst;
+				Priv(filep)->pfirst = it->next;
+				if (!Priv(filep)->pfirst)
+					Priv(filep)->plast = NULL;
+				kfree(it);
+				Priv(filep)->offset = 0;
+
+#if defined(CONFIG_ABI_TRACE)
+				abi_trace(ABI_TRACE_STREAMS,
+						"excess discarded\n");
+#endif
+			}
+
+			fput(filep);
+
+			if (error < 0)
+				return (-error << 8) | TSYSERR;
+
+			__get_user(prim, (unsigned long *)arg);
+			if (prim == T_ERROR_ACK) {
+				unsigned long a, b;
+				__get_user(a, ((unsigned long *)arg)+3);
+				__get_user(b, ((unsigned long *)arg)+2);
+				return (a << 8) | b;
+			}
+
+			return 0;
+#else /* no CONFIG_ABI_XTI_OPTMGMT or CONFIG_ABI_TLI_OPTMGMT */
+			fput(filep);
+			return TNOTSUPPORT;
+#endif /* CONFIG_ABI_XTI_OPTMGMT or CONFIG_ABI_TLI_OPTMGMT */
+		}
+
+		case 4: /* TI_GETMYNAME */
+		case 5: /* TI_SETPEERNAME */
+		case 6: /* TI_GETMYNAME */
+		case 7: /* TI_SETPEERNAME */
+                        break;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS,
+			"STREAMS timod op %d not supported\n", func);
+#endif
+	fput(filep);
+	return TNOTSUPPORT;
+}
+
+
+int
+svr4_sockmod_ioctl(int fd, u_int cmd, caddr_t data)
+{
+	struct file		*fp;
+	struct inode		*ip;
+	int			error;
+
+	fp = fget(fd);
+	if (!fp)
+		return (TBADF);
+
+	ip = fp->f_dentry->d_inode;
+	if (MAJOR(ip->i_rdev) == SOCKSYS_MAJOR) {
+		error = socksys_fdinit(fd, 0, NULL, NULL);
+		if (error < 0)
+			return -error;
+		fput(fp);
+		fp = fget(fd);
+		if (!fp)
+			return TBADF;
+		ip = fp->f_dentry->d_inode;
+	}
+
+	switch (cmd) {
+	case 101: { /* SI_GETUDATA */
+		struct {
+			int tidusize, addrsize, optsize, etsdusize;
+			int servtype, so_state, so_options;
+		} *it = (void *)data;
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_STREAMS, "%u getudata\n", fd);
+#endif
+		error = verify_area(VERIFY_WRITE, it, sizeof(*it));
+		if (error) {
+			fput(fp);
+			return (-error << 8) | TSYSERR;
+		}
+
+		__put_user(16384, &it->tidusize);
+		__put_user(sizeof(struct sockaddr), &it->addrsize);
+		__put_user(-1, &it->optsize);
+		__put_user(0, &it->so_state);
+		__put_user(0, &it->so_options);
+
+		switch (SOCKET_I(ip)->type) {
+		case SOCK_STREAM:
+			__put_user(1, &it->etsdusize);
+			__put_user(2, &it->servtype);
+			break;
+		default:
+			__put_user(-2, &it->etsdusize);
+			__put_user(3, &it->servtype);
+			break;
+		}
+		fput(fp);
+		return 0;
+	}
+
+	case 102: /* SI_SHUTDOWN */
+	case 103: /* SI_LISTEN */
+	case 104: /* SI_SETMYNAME */
+	case 105: /* SI_SETPEERNAME */
+	case 106: /* SI_GETINTRANSIT */
+	case 107: /* SI_TCL_LINK */
+	case 108: /* SI_TCL_UNLINK */
+                break;
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_STREAMS,
+			"STREAMS sockmod op %d not supported\n", cmd);
+#endif
+	fput(fp);
+	return TNOTSUPPORT;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(svr4_sockmod_ioctl);
+#endif
diff -Nru linux-2.6.7/abi/util/Makefile linux-2.6.7-abi/abi/util/Makefile
--- linux-2.6.7/abi/util/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/util/Makefile	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-util-objs	:= stat.o plist.o
+
+obj-$(CONFIG_ABI_UTIL)	+= abi-util.o
+
+abi-util.o: $(abi-util-objs)
+	$(LD) -r -o $@ $(abi-util-objs)
diff -Nru linux-2.6.7/abi/util/plist.c linux-2.6.7-abi/abi/util/plist.c
--- linux-2.6.7/abi/util/plist.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/util/plist.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,69 @@
+#ident "%W% %G%"
+
+#include <linux/string.h>
+#include <linux/fs.h>
+#include <linux/slab.h> /* needed by putname macro */
+#include <linux/sched.h> /* needed by current-> in __abi_trace() macro */
+#include <linux/module.h>
+
+#include <abi/util/trace.h>
+
+
+#if defined(CONFIG_ABI_TRACE)
+static void
+print_string(char *buf, char *str)
+{
+	char *tmp;
+
+	tmp = getname(str);
+	if (!IS_ERR(tmp)) {
+		/* we are debugging, we don't need to see it all */
+		tmp[80] = '\0';
+		sprintf(buf, "\"%s\"", tmp);
+		putname(tmp);
+	}
+}
+
+void plist(char *name, char *args, int *list)
+{
+	char buf[512], *p = buf;
+
+	buf[0] = '\0';
+	while (*args) {
+		switch (*args++) {
+		case 'd':
+			sprintf(p, "%d", *list++);
+			break;
+		case 'o':
+			sprintf(p, "0%o", *list++);
+			break;
+		case 'p':
+			sprintf(p, "%p", (void *)(*list++));
+			break;
+		case '?': 
+		case 'x':
+			sprintf(p, "0x%x", *list++);
+			break;
+		case 's':
+			print_string(p, (char *)(*list++));
+			break;
+		default:
+			sprintf(p, "?%c%c?", '%', args[-1]);
+			break;
+		}
+
+		while (*p)
+			++p;
+		if (*args) {
+			*p++ = ',';
+			*p++ = ' ';
+			*p = '\0';
+		}
+	}
+	__abi_trace("%s(%s)\n", name, buf);
+}
+
+#if CONFIG_ABI_LCALL7 == m
+EXPORT_SYMBOL(plist);
+#endif
+#endif /* CONFIG_ABI_TRACE */
diff -Nru linux-2.6.7/abi/util/stat.c linux-2.6.7-abi/abi/util/stat.c
--- linux-2.6.7/abi/util/stat.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/util/stat.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,146 @@
+/*
+ * Mostly ripped from Al Viro's stat-a-AC9-10 patch, 2001 Christoph Hellwig.
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>		/* needed to shut up modprobe */
+#include <linux/fs.h>
+#include <linux/stat.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/namei.h>
+
+#include <abi/util/revalidate.h>
+#include <abi/util/stat.h>
+
+
+MODULE_DESCRIPTION("Linux-ABI helper routines");
+MODULE_AUTHOR("Christoph Hellwig, ripped from kernel sources/patches");
+MODULE_LICENSE("GPL");
+
+#if 0 /* LINUXABI_OBSOLETE */
+int getattr_full(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	struct inode *inode = dentry->d_inode;
+	stat->dev = inode->i_rdev;
+	stat->ino = inode->i_ino;
+	stat->mode = inode->i_mode;
+	stat->nlink = inode->i_nlink;
+	stat->uid = inode->i_uid;
+	stat->gid = inode->i_gid;
+	stat->rdev = inode->i_rdev;
+	stat->atime = inode->i_atime;
+	stat->mtime = inode->i_mtime;
+	stat->ctime = inode->i_ctime;
+	stat->size = inode->i_size;
+	stat->blocks = inode->i_blocks;
+	stat->blksize = inode->i_blksize;
+	return 0;
+}
+
+/*
+ * Use minix fs values for the number of direct and indirect blocks.  The
+ * count is now exact for the minix fs except that it counts zero blocks.
+ * Everything is in units of BLOCK_SIZE until the assignment to
+ * stat->blksize.
+ */
+int getattr_minix(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	struct inode *inode = dentry->d_inode;
+	unsigned int blocks, indirect;
+
+	stat->dev = inode->i_rdev;
+	stat->ino = inode->i_ino;
+	stat->mode = inode->i_mode;
+	stat->nlink = inode->i_nlink;
+	stat->uid = inode->i_uid;
+	stat->gid = inode->i_gid;
+	stat->rdev = inode->i_rdev;
+	stat->atime = inode->i_atime;
+	stat->mtime = inode->i_mtime;
+	stat->ctime = inode->i_ctime;
+	stat->size = inode->i_size;
+#define D_B	7
+#define I_B	(BLOCK_SIZE / sizeof(unsigned short))
+
+	blocks = (stat->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
+	if (blocks > D_B) {
+		indirect = (blocks - D_B + I_B - 1) / I_B;
+		blocks += indirect;
+		if (indirect > 1) {
+			indirect = (indirect - 1 + I_B - 1) / I_B;
+			blocks += indirect;
+			if (indirect > 1)
+				blocks++;
+		}
+	}
+	stat->blocks = (BLOCK_SIZE / 512) * blocks;
+	stat->blksize = BLOCK_SIZE;
+	return 0;
+}
+
+int vfs_stat(char *filename, struct kstat *stat)
+{
+	struct nameidata nd;
+	int error;
+
+	error = user_path_walk(filename, &nd);
+	if (error)
+		return error;
+
+	error = do_revalidate(nd.dentry);
+	if (!error) {
+		struct inode *inode = nd.dentry->d_inode;
+		if (!inode->i_blksize)
+			error = getattr_minix(nd.mnt, nd.dentry, stat);
+		else
+			error = getattr_full(nd.mnt, nd.dentry, stat);
+		path_release(&nd);
+	}
+
+	return error;
+}
+
+int vfs_lstat(char *filename, struct kstat *stat)
+{
+	struct nameidata nd;
+	int error;
+
+	error = user_path_walk_link(filename, &nd);
+	if (error)
+		return error;
+
+	error = do_revalidate(nd.dentry);
+	if (!error) {
+		struct inode *inode = nd.dentry->d_inode;
+		if (!inode->i_blksize)
+			error = getattr_minix(nd.mnt, nd.dentry, stat);
+		else
+			error = getattr_full(nd.mnt, nd.dentry, stat);
+		path_release(&nd);
+	}
+
+	return error;
+}
+
+int vfs_fstat(int fd, struct kstat *stat)
+{
+	struct file *file = fget(fd);
+	int error;
+
+	if (!file)
+		return -EBADF;
+
+	error = do_revalidate(file->f_dentry);
+	if (!error) {
+		struct inode *inode = file->f_dentry->d_inode;
+		if (!inode->i_blksize)
+			error = getattr_minix(file->f_vfsmnt, file->f_dentry, stat);
+		else
+			error = getattr_full(file->f_vfsmnt, file->f_dentry, stat);
+		fput(file);
+	}
+	return error;
+}
+#endif
diff -Nru linux-2.6.7/abi/uw7/access.c linux-2.6.7-abi/abi/uw7/access.c
--- linux-2.6.7/abi/uw7/access.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/access.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,75 @@
+/*
+ *      abi/uw7/access.c - support for UnixWare access(2) system call.
+ *
+ *      We handle the non-POSIX EFF_ONLY_OK/EX_OK flags.
+ *      This software is under GPL.
+ */ 
+
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/syscalls.h>
+#include <linux/dcache.h>
+#include <linux/namei.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/revalidate.h>
+
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(x...)	printk(x)
+#else
+#define DBG(x...)
+#endif
+
+#define UW7_R_OK	004
+#define UW7_W_OK	002
+#define UW7_X_OK	001
+#define UW7_F_OK	000
+#define UW7_EFF_ONLY_OK	010
+#define UW7_EX_OK	020
+
+#define UW7_MODE_MSK	(UW7_R_OK|UW7_W_OK|UW7_X_OK|UW7_F_OK|UW7_EFF_ONLY_OK|UW7_EX_OK)
+
+int uw7_access(char * filename, int mode)
+{
+	struct nameidata nd;
+	int error;
+
+	DBG(KERN_ERR "UW7[%d]: access(%p,%o)\n", current->pid, filename, mode);
+
+	if (mode & ~UW7_MODE_MSK)
+		return -EINVAL;
+
+	if (mode & UW7_EX_OK) {
+		error = user_path_walk(filename, &nd);
+		if (!error) {
+			error = do_revalidate(nd.dentry);
+			if (error) {
+				path_release(&nd);
+				return -EIO;
+			}
+			if (!S_ISREG(nd.dentry->d_inode->i_mode)) {
+				path_release(&nd);
+				return -EACCES;
+			}
+			path_release(&nd);
+		}
+		mode &= ~UW7_EX_OK;
+		mode |= UW7_X_OK;
+	}
+	if (mode & UW7_EFF_ONLY_OK) {
+		uid_t old_uid = current->uid, old_gid = current->gid;
+
+		current->uid = current->euid;
+		current->gid = current->egid;
+		mode &= ~UW7_EFF_ONLY_OK;
+        	error =  sys_access(filename, mode);
+		current->uid = old_uid;
+		current->gid = old_gid;
+	} else
+        	error = sys_access(filename, mode);
+
+	return error;
+}
diff -Nru linux-2.6.7/abi/uw7/context.c linux-2.6.7-abi/abi/uw7/context.c
--- linux-2.6.7/abi/uw7/context.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/context.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,98 @@
+/*
+ *     abi/uw7/context.c
+ *
+ *  This software is under GPL
+ */
+
+
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+#include <abi/uw7/context.h>
+
+
+int
+uw7_sigaltstack(const uw7_stack_t *uw7_ss, uw7_stack_t *uw7_oss)
+{
+	stack_t ss, oss, *ssp = NULL, *ossp = NULL;
+	int error;
+	mm_segment_t old_fs;
+
+	if (uw7_ss) {
+		error = verify_area(VERIFY_READ, uw7_ss, sizeof(uw7_stack_t));
+		if (error)
+			return error;
+		__get_user(ss.ss_sp, &uw7_ss->ss_sp);
+		__get_user(ss.ss_size, &uw7_ss->ss_size);
+		__get_user(ss.ss_flags, &uw7_ss->ss_flags);
+		ssp = &ss;
+	}
+
+	if (uw7_oss) {
+		error = verify_area(VERIFY_WRITE, uw7_oss, sizeof(uw7_stack_t));
+		if (error)
+			return error;
+		__get_user(oss.ss_sp, &uw7_oss->ss_sp);
+		__get_user(oss.ss_size, &uw7_oss->ss_size);
+		__get_user(oss.ss_flags, &uw7_oss->ss_flags);
+		ossp = &oss;
+	}
+	
+	old_fs = get_fs();
+	set_fs(get_ds());	
+	error = sys_sigaltstack(ssp, ossp);
+	set_fs(old_fs);
+
+	if (ossp) {
+		__put_user(ossp->ss_sp, &uw7_oss->ss_sp);
+		__put_user(ossp->ss_size, &uw7_oss->ss_size);
+		__put_user(ossp->ss_flags, &uw7_oss->ss_flags);
+	}
+	return error;
+}
+
+static int
+getcontext(uw7_context_t * uc, struct pt_regs * regs)
+{
+	uw7_context_t tmp = { 0 };
+
+	return copy_to_user(uc, &tmp, sizeof(uw7_context_t)) ? -EFAULT : 0;
+}
+
+static int
+getxcontext(uw7_context_t * uc, struct pt_regs * regs)
+{
+	return 0;
+}
+
+static int
+setcontext(uw7_context_t * uc, struct pt_regs * regs)
+{
+	if (!uc) /* SVR4 says setcontext(NULL) => exit(0) */
+		sys_exit(0);
+	return 0;
+}
+
+int
+uw7_context(struct pt_regs * regs)
+{
+	int fcn = get_syscall_parameter(regs, 0);
+	uw7_context_t * uc = (uw7_context_t *) get_syscall_parameter(regs, 1);
+
+	switch (fcn) {
+		case UW7_GETCONTEXT:
+			return getcontext(uc, regs);
+
+		case UW7_GETXCONTEXT:
+			return getxcontext(uc, regs);
+
+		case UW7_SETCONTEXT:
+			return setcontext(uc, regs);
+	}
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/uw7/ioctl.c linux-2.6.7-abi/abi/uw7/ioctl.c
--- linux-2.6.7/abi/uw7/ioctl.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/ioctl.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,220 @@
+/*
+ *   abi/uw7/ioctl.c - Support for UnixWare 7.x ioctl(2) system call.
+ *
+ *  This module provides a function uw7_ioctl() which is called indirectly
+ *  via uw7_funcs[] array, see abi/uw7/funcs.c.
+ *  This software is under GPL
+ */ 
+
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/syscalls.h>
+#include <linux/termios.h>
+#include <asm/uaccess.h>
+
+#include <asm/abi_machdep.h>
+
+#include <abi/uw7/termbits.h>
+#include <abi/uw7/termios.h>
+#include <abi/svr4/ioctl.h>
+
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(x...)	printk(x)
+#else
+#define DBG(x...)
+#endif
+
+
+static int tioc_tcgets(int fd, struct uw7_termios * tios);
+static int tioc_tcsets(int fd, int lnx_cmd, struct uw7_termios * tios);
+static int ioctl_T(int fd, unsigned int cmd, void * arg);
+
+
+int uw7_ioctl(struct pt_regs * regs)
+{
+	int fd;
+	unsigned int cmd, class;
+	void * arg;
+
+	fd = (int)get_syscall_parameter(regs, 0);
+	cmd = (unsigned int)get_syscall_parameter(regs, 1);
+	arg = (void *)get_syscall_parameter(regs, 2);
+	class = cmd >> 8;
+
+	switch (class) {
+	case 'T':
+		return ioctl_T(fd, cmd, arg);
+	default:
+		return __svr4_ioctl(regs, fd, cmd, arg);
+	}
+}
+
+static int tioc_tcsets(int fd, int lnx_cmd, struct uw7_termios * tios)
+{
+	struct termios t;
+	struct uw7_termios tmp = {0, };
+	mm_segment_t old_fs;
+	int error;
+
+	DBG(KERN_ERR "UW7[%d]: tioc_tcsets(%d,%x,%p)\n", 
+		current->pid, fd, lnx_cmd, tios);
+
+	error = verify_area(VERIFY_READ, tios, sizeof(struct uw7_termios));
+	if (error)
+		return error;
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(old_fs);
+	if (error)
+		return error;
+	
+	if (copy_from_user(&tmp, tios, sizeof(struct uw7_termios)))
+		return -EFAULT;
+	t.c_iflag = tmp.c_iflag & ~UW7_DOSMODE;
+	t.c_oflag = tmp.c_oflag;
+	t.c_cflag = tmp.c_cflag;
+	t.c_lflag = tmp.c_lflag & ~UW7_DEFECHO;
+	if (tmp.c_lflag & UW7_FLUSHO)
+		t.c_lflag |= FLUSHO;
+	else
+		t.c_lflag &= ~FLUSHO;
+
+	DBG(KERN_ERR 
+		"UW7[%d]: iflag: %lx->%lx, oflag: %lx->%lx, cflag: %lx->%lx, lflag: %lx->%lx\n",
+		current->pid, tmp.c_iflag, t.c_iflag, tmp.c_oflag, t.c_oflag, 
+		tmp.c_cflag, t.c_cflag, tmp.c_lflag, t.c_lflag);
+
+	t.c_cc[VINTR] = tmp.c_cc[UW7_VINTR];
+	t.c_cc[VQUIT] = tmp.c_cc[UW7_VQUIT];
+	t.c_cc[VERASE] = tmp.c_cc[UW7_VERASE];
+	t.c_cc[VKILL] = tmp.c_cc[UW7_VKILL];
+	t.c_cc[VEOL2] = tmp.c_cc[UW7_VEOL2];
+	t.c_cc[VSWTC] = tmp.c_cc[UW7_VSWTCH];
+	t.c_cc[VSTART] = tmp.c_cc[UW7_VSTART];
+	t.c_cc[VSTOP] = tmp.c_cc[UW7_VSTOP];
+	t.c_cc[VSUSP] = tmp.c_cc[UW7_VSUSP];
+	t.c_cc[VREPRINT] = tmp.c_cc[UW7_VREPRINT];
+	t.c_cc[VDISCARD] = tmp.c_cc[UW7_VDISCARD];
+	t.c_cc[VWERASE] = tmp.c_cc[UW7_VWERASE];
+	t.c_cc[VLNEXT] = tmp.c_cc[UW7_VLNEXT];
+	if (t.c_lflag & ICANON) {
+		t.c_cc[VEOF] = tmp.c_cc[UW7_VEOF];
+		t.c_cc[VEOL] = tmp.c_cc[UW7_VEOL];
+	} else {
+		t.c_cc[VMIN] = tmp.c_cc[UW7_VMIN];
+		t.c_cc[VTIME] = tmp.c_cc[UW7_VTIME];
+		t.c_cc[VEOL] = tmp.c_cc[UW7_VEOL2];
+	}
+
+	
+	DBG(KERN_ERR 
+		"UW7[%d]: "
+		"VINTR: %x->%x, VQUIT: %x->%x, VERASE: %x->%x, VKILL: %x->%x\n"
+		"VEOL2: %x->%x\n",
+		current->pid, tmp.c_cc[UW7_VINTR], t.c_cc[VINTR], 
+		tmp.c_cc[UW7_VQUIT], t.c_cc[VQUIT], 
+		tmp.c_cc[UW7_VERASE], t.c_cc[VERASE], 
+		tmp.c_cc[UW7_VKILL], t.c_cc[VKILL], 
+		tmp.c_cc[UW7_VEOL2], t.c_cc[VEOL2]);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, lnx_cmd, (long)&t);
+	set_fs(old_fs);
+	return error;
+}
+
+static int tioc_tcgets(int fd, struct uw7_termios * tios)
+{
+	struct termios t;
+	struct uw7_termios tmp = { 0 };
+	mm_segment_t old_fs;
+	int error;	
+
+	DBG(KERN_ERR "UW7[%d]: tioc_tcgets(%d,%p)\n", current->pid, fd, tios);
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_ioctl(fd, TCGETS, (long)&t);
+	set_fs(old_fs);
+	if (error)
+		return error;
+	
+	tmp.c_iflag = UW7_IFLAG_MSK & (t.c_iflag & ~UW7_DOSMODE);
+	tmp.c_oflag = UW7_OFLAG_MSK & t.c_oflag;
+	tmp.c_cflag = UW7_CFLAG_MSK & t.c_cflag;
+	tmp.c_lflag = UW7_LFLAG_MSK & (t.c_lflag & ~UW7_DEFECHO);
+	if (t.c_lflag & FLUSHO)
+		tmp.c_lflag |= UW7_FLUSHO;
+	else
+		tmp.c_lflag &= ~UW7_FLUSHO;
+
+	DBG(KERN_ERR 
+		"UW7[%d]: iflag: %lx->%lx, oflag: %lx->%lx, cflag: %lx->%lx, lflag: %lx->%lx\n",
+		current->pid, tmp.c_iflag, t.c_iflag, tmp.c_oflag, t.c_oflag, 
+		tmp.c_cflag, t.c_cflag, tmp.c_lflag, t.c_lflag);
+
+	if (t.c_lflag & ICANON) {
+		tmp.c_cc[UW7_VEOF] = t.c_cc[VEOF];
+		tmp.c_cc[UW7_VEOL] = t.c_cc[VEOL];
+	} else {
+		tmp.c_cc[UW7_VMIN] = t.c_cc[VMIN];
+		tmp.c_cc[UW7_VTIME] = t.c_cc[VTIME];
+	}
+
+	tmp.c_cc[UW7_VINTR] = t.c_cc[VINTR];
+	tmp.c_cc[UW7_VQUIT] = t.c_cc[VQUIT];
+	tmp.c_cc[UW7_VERASE] = t.c_cc[VERASE];
+	tmp.c_cc[UW7_VKILL] = t.c_cc[VKILL];
+	tmp.c_cc[UW7_VEOL2] = t.c_cc[VEOL2];
+	tmp.c_cc[UW7_VSWTCH] = t.c_cc[VSWTC];
+	tmp.c_cc[UW7_VSTART] = t.c_cc[VSTART];
+	tmp.c_cc[UW7_VSTOP] = t.c_cc[VSTOP];
+	tmp.c_cc[UW7_VSUSP] = tmp.c_cc[UW7_VDSUSP] = t.c_cc[VSUSP];
+	tmp.c_cc[UW7_VREPRINT] = t.c_cc[VREPRINT];
+	tmp.c_cc[UW7_VDISCARD] = t.c_cc[VDISCARD];
+	tmp.c_cc[UW7_VWERASE] = t.c_cc[VWERASE];
+	tmp.c_cc[UW7_VLNEXT] = t.c_cc[VLNEXT];
+	
+	return copy_to_user(tios, &tmp, sizeof(struct uw7_termios)) ? -EFAULT : 0;
+}
+
+static int ioctl_T(int fd, unsigned int cmd, void * arg)
+{
+	DBG(KERN_ERR "ioctl_T(%d,%x,%p)\n", fd, cmd, arg);
+
+	switch (cmd) {
+		case UW7_TCSBRK:
+			return sys_ioctl(fd, TCSBRK, (long)arg);
+
+		case UW7_TCXONC:
+			return sys_ioctl(fd, TCXONC, (long)arg);
+
+		case UW7_TCFLSH:
+			return sys_ioctl(fd, TCFLSH, (long)arg);
+
+		case UW7_TIOCSWINSZ:
+			return sys_ioctl(fd, TIOCSWINSZ, (long)arg);
+
+		case UW7_TIOCGWINSZ:
+			return sys_ioctl(fd, TIOCGWINSZ, (long)arg);
+
+		case UW7_TCGETS: 
+			return tioc_tcgets(fd, arg);
+
+		case UW7_TCSETS:
+			return tioc_tcsets(fd, TCSETS, arg);
+
+		case UW7_TCSETSW:
+			return tioc_tcsets(fd, TCSETSW, arg);
+
+		case UW7_TCSETSF:
+			return tioc_tcsets(fd, TCSETSF, arg);
+	}
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/uw7/lfs.c linux-2.6.7-abi/abi/uw7/lfs.c
--- linux-2.6.7/abi/uw7/lfs.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/lfs.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 1999 Tigran Aivazian.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Support for the UnixWare 7.x LFS (Large File Summit) syscalls.
+ */
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/statfs.h>
+#include <linux/kernel.h>
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
+#include <linux/namei.h>
+#include <asm/uaccess.h>
+
+#include <abi/uw7/resource.h>
+#include <abi/uw7/statvfs.h>
+
+
+/*
+ * The UnixWare 7 truncate64/fruncate64 syscalls are the same as in
+ * Linux, but we can't easily handle long long syscall parameters for
+ * lcall7, thus we have to fake two 32bit arguments instead.
+ *
+ * XXX: if do_sys_truncate/do_sys_ftruncate in fs/open.c were exported
+ *	we could get rid of one function call.
+ */
+int
+uw7_truncate64(const char *filename, u_int len, u_int len_hi)
+{
+	return sys_truncate64(filename, (len | (loff_t)len_hi << 32));
+}
+
+int
+uw7_ftruncate64(int fd, u_int len, u_int len_hi)
+{
+	return sys_ftruncate64(fd, (len | (loff_t)len_hi << 32));
+}
+
+/*
+ * The SVR4 statvfs is basically our statfs, but of course only
+ * basically ....
+ */
+static int
+cp_uw7_statvfs64(struct super_block *sbp, struct kstatfs *srcp,
+		struct uw7_statvfs64 *dstp)
+{
+	struct uw7_statvfs64	tmp;
+
+	memset(&tmp, 0, sizeof(struct uw7_statvfs64));
+
+	tmp.f_bsize  = srcp->f_bsize;
+	tmp.f_frsize = srcp->f_bsize;
+	tmp.f_blocks = srcp->f_blocks;
+	tmp.f_bfree  = srcp->f_bfree;
+	tmp.f_bavail = srcp->f_bavail;
+	tmp.f_files  = srcp->f_files;
+	tmp.f_ffree  = srcp->f_ffree;
+	tmp.f_favail = srcp->f_ffree;
+	tmp.f_fsid   = sbp->s_dev;
+
+	strcpy(tmp.f_basetype, sbp->s_type->name);
+
+	tmp.f_namemax = srcp->f_namelen;
+
+	if (copy_to_user(dstp, &tmp, sizeof(struct uw7_statvfs64)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+uw7_statvfs64(char *filename, struct uw7_statvfs64 *stvfsp)
+{
+	struct nameidata	nd;
+	int			error;
+
+	error = user_path_walk(filename, &nd);
+	if (!error) {
+		struct super_block	*sbp = nd.dentry->d_inode->i_sb;
+		struct kstatfs		tmp;
+
+		error = vfs_statfs(sbp, &tmp);
+		if (!error && cp_uw7_statvfs64(sbp, &tmp, stvfsp))
+			error = -EFAULT;
+		path_release(&nd);
+	}
+
+	return (error);
+}
+
+
+int
+uw7_fstatvfs64(int fd, struct uw7_statvfs64 *stvfsp)
+{
+	struct file		*fp;
+	int			error = -EBADF;
+
+	fp = fget(fd);
+	if (fp) {
+		struct super_block	*sbp = fp->f_dentry->d_inode->i_sb;
+		struct kstatfs		tmp;
+
+		error = vfs_statfs(sbp, &tmp);
+		if (!error && cp_uw7_statvfs64(sbp, &tmp, stvfsp))
+			error = -EFAULT;
+		fput(fp);
+	}
+
+	return (error);
+}
+
+static __inline__ int
+uw7_rlim64_to_user(int resource, struct uw7_rlim64 *rlimp)
+{
+	struct rlimit		*lxrlim = current->rlim + resource;
+	struct uw7_rlim64	rlim;
+
+	rlim.rlim_cur = lxrlim->rlim_cur;
+	rlim.rlim_max = lxrlim->rlim_max;
+
+	if (copy_to_user(rlimp, &rlim, sizeof(struct uw7_rlim64)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+uw7_getrlimit64(int resource, struct uw7_rlim64 *rlimp)
+{
+	if (resource > ARRAY_SIZE(uw7_to_linux_rlimit))
+		return -EINVAL;
+
+	return (uw7_rlim64_to_user(uw7_to_linux_rlimit[resource], rlimp));
+}
+
+static __inline__ int
+uw7_check_rlimit64(int resource, const struct uw7_rlim64 *rlimp,
+		   struct rlimit *lxrlimp)
+{
+	if ((rlimp->rlim_cur > RLIM_INFINITY) ||
+	    (rlimp->rlim_max > RLIM_INFINITY))
+		return -EPERM;  /* XXX: actually this is wrong */
+
+	if (((rlimp->rlim_cur > lxrlimp->rlim_max) ||
+	     (rlimp->rlim_max > lxrlimp->rlim_max)) &&
+	      !capable(CAP_SYS_RESOURCE))
+		return -EPERM;
+
+	if (resource == RLIMIT_NOFILE && 
+	    (rlimp->rlim_cur > NR_OPEN || rlimp->rlim_max > NR_OPEN))
+		return -EPERM;
+
+	return 0;
+}
+
+int
+uw7_setrlimit64(int resource, const struct uw7_rlim64 *rlimp)
+{
+	struct rlimit		*lxrlim = current->rlim + resource;
+	struct uw7_rlim64	rlim;
+
+	if (resource > ARRAY_SIZE(uw7_to_linux_rlimit))
+		return -EINVAL;
+	if (copy_from_user(&rlim, rlimp, sizeof(struct uw7_rlim64)))
+		return -EFAULT;
+	if (uw7_check_rlimit64(resource, &rlim, lxrlim))
+		return -EPERM;
+
+	/* XXX: this is non-atomic. */
+	lxrlim->rlim_cur = rlim.rlim_cur;
+	lxrlim->rlim_max = rlim.rlim_max;
+
+	return 0;
+}
+
+/*
+ * 64bit lseek for UnixWare.
+ */
+int
+uw7_lseek64(int fd, u_int off, u_int off_hi, int orig)
+{
+	loff_t			result;
+	int			err;
+
+	if (off_hi == (u_int)-1)
+		off_hi = 0;
+	
+	err  = sys_llseek(fd, (off_t) off_hi, off, &result, orig);
+	if (err)
+		return err;
+	return (long)result; /* XXX: how does UnixWare return large results? */
+}
+
+/*
+ * The UnixWare 7 pread64/pwrite64 syscalls are the same as in Linux,
+ * but we can't easily handle long long syscall parameters for lcall7,
+ * thus we have to fake two 32bit arguments instead.
+ */
+ssize_t
+uw7_pread64(int fd, char *bufp, int count, u_int pos, u_int pos_hi)
+{
+	return sys_pread64(fd, bufp, count, (pos | (loff_t)pos_hi << 32));
+}
+
+ssize_t
+uw7_pwrite64(int fd, char *bufp, int count, u_int pos, u_int pos_hi)
+{
+	return sys_pwrite64(fd, bufp, count, (pos | (loff_t)pos_hi << 32));
+}
+
+/*
+ * Unlike Linux UnixWare 7 does not simply add O_LARGEFILE to flags in
+ * libc, so we have to do it.
+ * We call sys_open directly as sys_creat is just yet another wrapper.
+ */
+#define UW7_CREAT64_FLAGS \
+	(O_LARGEFILE | O_CREAT | O_WRONLY | O_TRUNC)
+int
+uw7_creat64(const char *filename, int mode)
+{
+	return sys_open(filename, UW7_CREAT64_FLAGS, mode);
+}
diff -Nru linux-2.6.7/abi/uw7/mac.c linux-2.6.7-abi/abi/uw7/mac.c
--- linux-2.6.7/abi/uw7/mac.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/mac.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,41 @@
+/*
+ *   abi/uw7/mac.c - mldmode(2) and friends.
+ *
+ *  This software is under GPL
+ */
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(x...)	printk(x)
+#else
+#define DBG(x...)
+#endif
+
+#define UW7_MLD_REAL	1
+#define UW7_MLD_VIRT	0
+#define UW7_MLD_QUERY	2
+
+int uw7_mldmode(int mldmode)
+{
+	switch (mldmode) {
+		case UW7_MLD_REAL:
+			DBG(KERN_ERR "UW7[%d]: mldmode(MLD_REAL)\n", current->pid);
+			break;
+
+		case UW7_MLD_VIRT:
+			DBG(KERN_ERR "UW7[%d]: mldmode(MLD_VIRT)\n", current->pid);
+			break;
+
+		case UW7_MLD_QUERY:
+			DBG(KERN_ERR "UW7[%d]: mldmode(MLD_QUERY)\n", current->pid);
+			return UW7_MLD_REAL;
+
+		default:
+			return -EINVAL;
+	}
+	return 0;
+}
diff -Nru linux-2.6.7/abi/uw7/Makefile linux-2.6.7-abi/abi/uw7/Makefile
--- linux-2.6.7/abi/uw7/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/Makefile	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,8 @@
+
+abi-uw7-objs	:= access.o context.o ioctl.o lfs.o mac.o \
+		   misc.o mmap.o stat.o sysent.o
+
+obj-$(CONFIG_ABI_UW7)	+= abi-uw7.o
+
+abi-uw7.o: $(abi-uw7-objs)
+	$(LD) -r -o $@ $(abi-uw7-objs)
diff -Nru linux-2.6.7/abi/uw7/misc.c linux-2.6.7-abi/abi/uw7/misc.c
--- linux-2.6.7/abi/uw7/misc.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/misc.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,66 @@
+/*
+ *   abi/uw7/misc.c - various UW7 system calls.
+ *
+ *  This software is under GPL
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/syscalls.h>
+#include <asm/uaccess.h>
+
+
+int uw7_sleep(int seconds)
+{
+	struct timespec t;
+	mm_segment_t old_fs;
+	int error;
+
+	t.tv_sec = seconds;
+	t.tv_nsec = 0;
+	old_fs = get_fs();
+	set_fs(get_ds());
+	error = sys_nanosleep(&t, NULL);
+	set_fs(old_fs);
+	return error;
+}
+
+#define UW7_MAXUID      60002
+
+int uw7_seteuid(int uid)
+{
+	if (uid < 0 || uid > UW7_MAXUID)
+		return -EINVAL;
+	return sys_setreuid16(-1, uid);
+}
+
+int uw7_setegid(int gid)
+{
+	if (gid < 0 || gid > UW7_MAXUID)
+		return -EINVAL;
+	return sys_setreuid16(-1, gid);
+}
+
+/* can't call sys_pread64() directly because off is 32bit on UW7 */
+int uw7_pread(unsigned int fd, char * buf, int count, long off)
+{
+	return sys_pread64(fd, buf, count, (loff_t)off);
+}
+
+/* can't call sys_pwrite64() directly because off is 32bit on UW7 */
+int uw7_pwrite(unsigned int fd, char * buf, int count, long off)
+{
+	return sys_pwrite64(fd, buf, count, (loff_t)off);
+}
+
+int uw7_stty(int fd, int cmd)
+{
+	return -EIO;
+}
+
+int uw7_gtty(int fd, int cmd)
+{
+	return -EIO;
+}
diff -Nru linux-2.6.7/abi/uw7/mmap.c linux-2.6.7-abi/abi/uw7/mmap.c
--- linux-2.6.7/abi/uw7/mmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/mmap.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1999 Tigran Aivazian.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Support for mmap on UnixWare 7.
+ */
+#include <linux/mm.h>
+#include <linux/errno.h>
+#include <linux/file.h>
+#include <linux/mman.h>
+
+#include <asm/uaccess.h>
+
+
+/* the other MAP_XXX values are the same as on Linux/i386 */
+#define UW7_MAP_ANONYMOUS	0x100
+
+int
+uw7_mmap64(u_long addr, size_t len, int prot, int flags,
+	   int fd, u_int off, u_int off_hi)
+{
+	loff_t			off64 = (off | ((loff_t)off_hi << 32));
+	u_long			pgoff = (off64 >> PAGE_SHIFT);
+	int			error = -EBADF;
+	struct file		*fp = NULL;
+
+	if ((off64 + PAGE_ALIGN(len)) < off64)
+		return -EINVAL;
+
+	if (!(off64 & ~PAGE_MASK))
+		return -EINVAL;
+
+	if (flags & UW7_MAP_ANONYMOUS) {
+		flags |= MAP_ANONYMOUS;
+		flags &= ~UW7_MAP_ANONYMOUS;
+	}
+
+	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+	if (!(flags & MAP_ANONYMOUS)) {
+		if (!(fp = fget(fd)))
+			goto out;
+	}
+	
+	down_write(&current->mm->mmap_sem);
+	error = do_mmap_pgoff(fp, addr, len, prot, flags, pgoff);
+	up_write(&current->mm->mmap_sem);
+
+	if (fp)
+		fput(fp);
+out:
+	return (error);
+}
diff -Nru linux-2.6.7/abi/uw7/stat.c linux-2.6.7-abi/abi/uw7/stat.c
--- linux-2.6.7/abi/uw7/stat.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/stat.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * aint32_t with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * UnixWare 7.x xstat support.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/string.h>
+#include <asm/uaccess.h>
+
+#include <abi/uw7/types.h>
+#include <abi/uw7/stat.h>
+#include <abi/svr4/stat.h>
+
+#include <abi/util/trace.h>
+#include <abi/util/stat.h>
+
+
+enum {SVR4_stat = 1, SVR4_xstat = 2, UW7_stat64 = 4};
+
+int
+report_uw7_stat64(struct kstat *stp, struct uw7_stat64 *bufp)
+{
+	struct uw7_stat64 buf;
+
+	memset(&buf, 0, sizeof(struct uw7_stat64));
+
+	buf.st_dev	= linux_to_uw7_dev_t(stp->dev);
+	buf.st_ino	= linux_to_uw7_ino_t(stp->ino);
+	buf.st_mode	= stp->mode;
+	buf.st_nlink	= stp->nlink;
+	buf.st_uid	= linux_to_uw7_uid_t(stp->uid);
+	buf.st_gid	= linux_to_uw7_gid_t(stp->gid);
+	buf.st_rdev	= linux_to_uw7_dev_t(stp->rdev);
+	buf.st_size	= stp->size;
+
+	buf.st_atime.tv_sec = stp->atime.tv_sec;
+	buf.st_mtime.tv_sec = stp->mtime.tv_sec;
+	buf.st_ctime.tv_sec = stp->ctime.tv_sec;
+
+	buf.st_blksize	= stp->blksize;
+	buf.st_blocks	= stp->blocks;
+
+	strcpy(buf.st_fstype, "ext2");
+
+	if (copy_to_user(bufp, &buf, sizeof(struct uw7_stat64)))
+		return -EFAULT;
+	return 0;
+}
+
+int
+uw7_xstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_stat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	case UW7_stat64:
+		return report_uw7_stat64(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "xstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+uw7_lxstat(int vers, char *filename, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_lstat(filename, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	case UW7_stat64:
+		return report_uw7_stat64(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "lxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
+
+int
+uw7_fxstat(int vers, int fd, void *bufp)
+{
+	struct kstat st;
+	int error;
+
+	error = vfs_fstat(fd, &st);
+	if (error)
+		return error;
+
+	switch (vers) {
+	case SVR4_stat:
+		return report_svr4_stat(&st, bufp);
+	case SVR4_xstat:
+		return report_svr4_xstat(&st, bufp);
+	case UW7_stat64:
+		return report_uw7_stat64(&st, bufp);
+	}
+	
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_API, "fxstat version %d not supported\n", vers);
+#endif
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/abi/uw7/sysent.c linux-2.6.7-abi/abi/uw7/sysent.c
--- linux-2.6.7/abi/uw7/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/uw7/sysent.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) 1999 Tigran Aivazian.
+ * Copyright (c) 2000, 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#ident "%W% %G%"
+
+/*
+ * UnixWare 7/OpenUnix 8 personality switch.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/signal.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/uw7/sysent.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+#include <abi/util/socket.h>
+
+MODULE_DESCRIPTION("UnixWare7/OpenUnix8 personality");
+MODULE_AUTHOR("Tigran Aivazian, Christoph Hellwig");
+MODULE_LICENSE("GPL");
+
+
+/*
+ * We could remove some of the long identity mapped runs but at the
+ * expense of extra comparisons for each mapping at run time...
+ */
+static u_char uw7_err_table[] = {
+/*   0 -   9 */   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+/*  10 -  19 */  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+/*  20 -  29 */  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+/*  30 -  39 */  30,  31,  32,  33,  34,  45,  78,  46,  89,  93,
+/*  40 -  49 */  90,  90,  35,  36,  37,  38,  39,  40,  41,  42,
+/*  50 -  59 */  43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+/*  60 -  69 */  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+/*  70 -  79 */  70,  71,  74,  76,  77,  79,  80,  81,  82,  83,
+/*  80 -  89 */  84,  85,  86,  87,  88,  91,  92,  94,  95,  96,
+/*  90 -  99 */  97,  98,  99, 120, 121, 122, 123, 124, 125, 126,
+/* 100 - 109 */ 127, 128, 129, 130, 131, 132, 133, 134, 143, 144,
+/* 110 - 119 */ 145, 146, 147, 148, 149, 150,  22, 135, 137, 138,
+/* 120 - 122 */ 139, 140,  28
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+/* 512 - 514 */ EINTR, EINTR, EINTR
+};
+
+struct map_segment uw7_err_map[] = {
+	{ 0,	0+sizeof(uw7_err_table)-1,	uw7_err_table },
+	{ 512,  512+sizeof(lnx_err_table)-1,	lnx_err_table },
+	{ -1 }
+};
+
+static long linux_to_uw7_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,    IBCS_SIGINT,    IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,   IBCS_SIGABRT,   -1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,   IBCS_SIGUSR1,   IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,   IBCS_SIGALRM,   IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,   IBCS_SIGCONT,   IBCS_SIGSTOP,
+/* 20 - 23 */	IBCS_SIGTSTP,	IBCS_SIGTTIN,   IBCS_SIGTTOU,   IBCS_SIGURG,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,  IBCS_SIGVTALRM, IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	IBCS_SIGIO,     IBCS_SIGPWR,    -1,
+/*	32 */	-1
+};
+
+static long uw7_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,         SIGINT,         SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,        SIGIOT,         SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,        SIGUNUSED,      SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,        SIGALRM,        SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,        SIGCHLD,        SIGPWR,
+/* 20 - 23 */	SIGWINCH,	SIGURG,         SIGPOLL,        SIGSTOP,
+/* 24 - 27 */	SIGTSTP,	SIGCONT,        SIGTTIN,        SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,        SIGXCPU,        SIGXFSZ,
+/*	32 */	-1
+};
+
+static char uw7_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment uw7_socktype_map[] = {
+	{ 1, 6, uw7_socktype },
+	{ -1 }
+};
+
+static struct map_segment uw7_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+static struct map_segment uw7_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent uw7_syscall_table[] = {
+/*   0 */	{ abi_syscall,		Fast,	"syscall",	""	},
+/*   2 */	{ sys_exit,		1,	"exit",		"d"	},
+/*   3 */	{ abi_fork,		Spl,	"fork",		""	},
+/*   4 */	{ abi_read,		3,	"read",		"dpd"	},
+/*   5 */	{ sys_write,		3,	"write",	"dpd"	},
+/*   6 */	{ svr4_open,		3,	"open",		"soo"	},
+/*   7 */	{ sys_close,		1,	"close",	"d"	},
+/*   8 */	{ abi_wait,		Spl,	"wait",		"xxx"	},
+/*   9 */	{ sys_creat,		2,	"creat",	"so"	},
+/*  10 */	{ sys_link,		2,	"link",		"ss"	},
+/*  11 */	{ sys_unlink,		1,	"unlink",	"s"	},
+/*  12 */	{ abi_exec,		Spl,	"exec",		"sxx"	},
+/*  13 */	{ sys_chdir,		1,	"chdir",	"s"	},
+/*  14 */	{ abi_time,		0,	"time",		""	},
+/*  15 */	{ svr4_mknod,		3,	"mknod",	"soo"	},
+/*  16 */	{ sys_chmod,		2,	"chmod",	"so"	},
+/*  17 */	{ sys_chown,		3,	"chown",	"sdd"	},
+/*  18 */	{ abi_brk,		1,	"brk/break",	"x"	},
+/*  19 */	{ svr4_stat,		2,	"stat",		"sp"	},
+/*  21 */	{ sys_lseek,		3,	"seek/lseek",	"ddd"	},
+/*  20 */	{ abi_getpid,		Spl,	"getpid",	""	},
+/*  21 */	{ 0,			Ukn,	"mount",	""	},
+/*  22 */	{ sys_umount,		1,	"umount",	"s"	},
+/*  23 */	{ sys_setuid,		1,	"setuid",	"d"	},
+/*  24 */	{ abi_getuid,		Spl,	"getuid",	""	},
+/*  25 */	{ sys_stime,		1,	"stime",	"d"	},
+/*  26 */	{ 0,			4,	"ptrace",	""	},
+/*  27 */	{ sys_alarm,		1,	"alarm",	"d"	},
+/*  28 */	{ svr4_fstat,		2,	"fstat",	"dp"	},
+/*  21 */	{ sys_pause,		0,	"pause",	""	},
+/*  30 */	{ sys_utime,		2,	"utime",	"xx"	},
+/*  31 */	{ uw7_stty,		2,	"stty",		"dd"	},
+/*  32 */	{ uw7_gtty,		2,	"gtty",		"dd"	},
+/*  33 */	{ uw7_access,		2,	"access",	"so"	},
+/*  34 */	{ sys_nice,		1,	"nice",		"d"	},
+/*  35 */	{ svr4_statfs,		4,	"statfs",	"spdd"	},
+/*  36 */	{ sys_sync,		0,	"sync",		""	},
+/*  37 */	{ abi_kill,		2,	"kill",		"dd"	},
+/*  38 */	{ svr4_fstatfs,		4,	"fstatfs",	"dpdd"	},
+/*  39 */	{ abi_procids,		Spl,	"procids",	"d"	},
+/*  40 */	{ 0,			Ukn,	"cxenix",	""	},
+/*  41 */	{ sys_dup,		1,	"dup",		"d"	},
+/*  42 */	{ abi_pipe,		Spl,	"pipe",		""	},
+/*  43 */	{ sys_times,		1,	"times",	"p"	},
+/*  44 */	{ 0,			4,	"",		""	},
+/*  45 */	{ 0,			Ukn,	"plock",	""	},
+/*  46 */	{ sys_setgid,		1,	"setgid",	"d"	},
+/*  47 */	{ abi_getgid,		Spl,	"getgid",	""	},
+/*  48 */	{ abi_sigfunc,		Fast,	"sigfunc",	"xxx"	},
+/*  49 */	{ svr4_msgsys,		Spl,	"msgsys",	"dxddd"	},
+/*  50 */	{ svr4_sysi86,		3,	"sysi86/sys3b",	"d"	},
+/*  51 */	{ sys_acct,		1,	"acct/sysacct",	"x"	},
+/*  52 */	{ svr4_shmsys,		Fast,	"shmsys",	"ddxo"	},
+/*  53 */	{ svr4_semsys,		Spl,	"semsys",	"dddx"	},
+/*  54 */	{ uw7_ioctl,		Spl,	"ioctl",	"dxx"	},
+/*  55 */	{ 0,			3,	"uadmin",	"xxx"	},
+/*  56 */	{ 0,			Ukn,	"unimpl/exch",	""	},
+/*  57 */	{ v7_utsname,		1,	"utsys",	"x"	},
+/*  58 */	{ sys_fsync,		1,	"fsync",	"d"	},
+/*  59 */	{ abi_exec,		Spl,	"execv",	"spp"	},
+/*  60 */	{ sys_umask,		1,	"umask",	"o"	},
+/*  61 */	{ sys_chroot,		1,	"chroot",	"s"	},
+/*  62 */	{ svr4_fcntl,		3,	"fcntl",	"dxx"	},
+/*  63 */	{ svr4_ulimit,		2,	"ulimit",	"xx"	},
+   
+/*
+ *	64-69 were reserved for the UNIX PC, and are now use for NUMA calls.
+ */
+/*  64 */	{ 0,			Ukn,	"cg_ids",	""	},
+/*  65 */	{ 0,			Ukn,	"cg_processors",""	},
+/*  66 */	{ 0,			Ukn,	"cg_info",	""	},
+/*  67 */	{ 0,			Ukn,	"cg_bind",	""	},
+/*  68 */	{ 0,			Ukn,	"cg_current",	""	},
+/*  69 */	{ 0,			Ukn,	"cg_memloc",	""	},
+/*  70 */	{ 0,			Ukn,	"unimpl/advfs",	""	},
+/*  71 */	{ 0,			Ukn,	"unimpl/unadvfs",""	},
+/*  72 */	{ 0,			Ukn,	"unimpl/rmount",""	},
+/*  73 */	{ 0,			Ukn,	"unimpl/rumount",""	},
+/*  74 */	{ 0,			Ukn,	"unimpl/rfstart",""	},
+/*  75 */	{ 0,			Ukn,	"unimpl 75",	""	},
+/*  76 */	{ 0,			Ukn,	"unimpl/rdebug",""	},
+/*  77 */	{ 0,			Ukn,	"unimpl/rfstop",""	},
+/*  78 */	{ 0,			Ukn,	"rfsys",	""	},
+/*  89 */	{ sys_rmdir,		1,	"rmdir",	"s"	},
+/*  80 */	{ sys_mkdir,		2,	"mkdir",	"so"	},
+/*  81 */	{ svr4_getdents,	3,	"getdents",	"dxd"	},
+/*  82 */	{ 0,			Ukn,	"unimpl/libattach",""	},
+/*  83 */	{ 0,			Ukn,	"unimpl/libdetach",""	},
+/*  84 */	{ svr4_sysfs,		3,	"sysfs",	"dxx"	},
+/*  85 */	{ svr4_getmsg,		Spl,	"getmsg",	"dxxx"	},
+/*  86 */	{ svr4_putmsg,		Spl,	"putmsg",	"dxxd"	},
+/*  87 */	{ sys_poll,		3,	"poll",		"xdd"	},
+/*  88 */	{ svr4_lstat,		2,	"lstat",	"sp"	},
+/*  89 */	{ sys_symlink,		2,	"symlink",	"ss"	},
+/*  90 */	{ sys_readlink,		3,	"readlink",	"spd"	},
+/*  91 */	{ sys_setgroups,	2,	"setgroups",	"dp"	},
+/*  92 */	{ sys_getgroups,	2,	"getgroups",	"dp"	},
+/*  93 */	{ sys_fchmod,		2,	"fchmod",	"do"	},
+/*  94 */	{ sys_fchown,		3,	"fchown",	"ddd"	},
+/*  95 */	{ abi_sigprocmask,	3,	"sigprocmask",	"dxx"	},
+/*  96 */	{ abi_sigsuspend,	Spl,	"sigsuspend",	"x"	},
+/*  97 */	{ uw7_sigaltstack,	2,	"sigaltstack",	"xx"	},
+/*  98 */	{ abi_sigaction,	3,	"sigaction",	"dxx"	},
+/*  99 */	{ svr4_sigpending,	2,	"sigpending",	"dp"	},
+/* 100 */	{ uw7_context,		Spl,	"ucontext",	""	},
+/* 101 */	{ 0,			Ukn,	"evsys",	""	},
+/* 102 */	{ 0,			Ukn,	"evtrapret",	""	},
+/* 103 */	{ svr4_statvfs,		2,	"statvfs",	"sp"	},
+/* 104 */	{ svr4_fstatvfs,	2,	"fstatvfs",	"dp"	},
+/* 105 */	{ 0,			Ukn,	"reserved 105",	""	},
+/* 106 */	{ 0,			Ukn,	"nfssys",	""	},
+/* 107 */	{ svr4_waitid,		4,	"waitid",	"ddxd"	},
+/* 108 */	{ 0,			3,	"sigsendsys",	"ddd"	},
+/* 109 */	{ svr4_hrtsys,		Spl,	"hrtsys",	"xxx"	},
+/* 110 */	{ 0,			3,	"acancel",	"dxd"	},
+/* 111 */	{ 0,			Ukn,	"async",	""	},
+/* 112 */	{ 0,			Ukn,	"priocntlsys",	""	},
+/* 113 */	{ svr4_pathconf,	2,	"pathconf",	"sd"	},
+/* 114 */	{ 0,			3,	"mincore",	"xdx"	},
+/* 115 */	{ svr4_mmap,		6,	"mmap",		"xxxxdx"},
+/* 116 */	{ sys_mprotect,		3,	"mprotect",	"xdx"	},
+/* 117 */	{ sys_munmap,		2,	"munmap",	"xd"	},
+/* 118 */	{ svr4_fpathconf,	2,	"fpathconf",	"dd"	},
+/* 119 */	{ abi_fork,		Spl,	"vfork",	""	},
+/* 120 */	{ sys_fchdir,		1,	"fchdir",	"d"	},
+/* 121 */	{ sys_readv,		3,	"readv",	"dxd"	},
+/* 122 */	{ sys_writev,		3,	"writev",	"dxd"	},
+/* 123 */	{ uw7_xstat,		3,	"xstat",	"dsx"	},
+/* 124 */	{ uw7_lxstat,     	3,	"lxstat",	"dsx"	},
+/* 125 */	{ uw7_fxstat,		3,	"fxstat",	"ddx"	},
+/* 126 */	{ svr4_xmknod,		4,	"xmknod",	"dsox"	},
+/* 127 */	{ 0,			Spl,	"syslocal",	"d"	},
+/* 128 */	{ svr4_getrlimit,	2,	"setrlimit",	"dx"	},
+/* 129 */	{ svr4_setrlimit,	2,	"getrlimit",	"dx"	},
+/* 130 */	{ sys_lchown,		3,	"lchown",	"sdd"	},
+/* 131 */	{ 0,			Ukn,	"memcntl",	""	},
+#if defined(CONFIG_ABI_XTI)
+/* 132 */	{ svr4_getpmsg,		5,	"getpmsg",	"dxxxx"	},
+/* 133 */	{ svr4_putpmsg,		5,	"putpmsg",	"dxxdd"	},
+#else
+/* 132 */	{ 0,			5,	"getpmsg",	"dxxxx"	},
+/* 133 */	{ 0,			5,	"putpmsg",	"dxxdd"	},
+#endif
+/* 134 */	{ sys_rename,		2,	"rename",	"ss"	},
+/* 135 */	{ abi_utsname,		1,	"uname",	"x"	},
+/* 136 */	{ uw7_setegid,		1,	"setegid",	"d"	},
+/* 137 */	{ svr4_sysconfig,	1,	"sysconfig",	"d"	},
+/* 138 */	{ 0,			Ukn,	"adjtime",	""	},
+/* 139 */	{ svr4_sysinfo,		3,	"systeminfo",	"dsd"	},
+/* 140 */	{ socksys_syscall,	1,	"socksys_syscall","x"	},
+/* 141 */	{ uw7_seteuid,		1,	"seteuid",	"d"	},
+/* 142 */	{ 0,			Ukn,	"unimpl 142",	""	},
+/* 143 */	{ 0,			Ukn,	"keyctl",	""	},
+/* 144 */	{ 0,			2,	"secsys",	"dx"	},
+/* 145 */	{ 0,			4,	"filepriv",	"sdxd"	},
+/* 146 */	{ 0,			3,	"procpriv",	"dxd"	},
+/* 147 */	{ 0,			3,	"devstat",	"sdx"	},
+/* 148 */	{ 0,			5,	"aclipc",	"ddddx"	},
+/* 149 */	{ 0,			3,	"fdevstat",	"ddx"	},
+/* 150 */	{ 0,			3,	"flvlfile",	"ddx"	},
+/* 151 */	{ 0,			3,	"lvlfile",	"sdx"	},
+/* 152 */	{ 0,			Ukn,	"sendv",	""	},
+/* 153 */	{ 0,			2,	"lvlequal",	"xx"	},
+/* 154 */	{ 0,			2,	"lvlproc",	"dx"	},
+/* 155 */	{ 0,			Ukn,	"unimpl 155",	""	},
+/* 156 */	{ 0,			4,	"lvlipc",	"dddx"	},
+/* 157 */	{ 0,			4,	"acl",		"sddx"	},
+/* 158 */	{ 0,			Ukn,	"auditevt",	""	},
+/* 159 */	{ 0,			Ukn,	"auditctl",	""	},
+/* 160 */	{ 0,			Ukn,	"auditdmp",	""	},
+/* 161 */	{ 0,			Ukn,	"auditlog",	""	},
+/* 162 */	{ 0,			Ukn,	"auditbuf",	""	},
+/* 163 */	{ 0,			2,	"lvldom",	"xx"	},
+/* 164 */	{ 0,			Ukn,	"lvlvfs",	""	},
+/* 165 */	{ 0,			2,	"mkmld",	"so"	},
+/* 166 */	{ uw7_mldmode,		1,	"mldmode",	"d"	},
+/* 167 */	{ 0,			2,	"secadvise",	"xx"	},
+/* 168 */	{ 0,			Ukn,	"online",	""	},
+/* 169 */	{ sys_setitimer,	3,	"setitimer",	"dxx"	},
+/* 170 */	{ sys_getitimer,	2,	"getitimer",	"dx"	},
+/* 171 */	{ sys_gettimeofday,	2,	"gettimeofday",	"xx"	},
+/* 172 */	{ sys_settimeofday,	2,	"settimeofday",	"xx"	},
+/* 173 */	{ 0,			Ukn,	"lwpcreate",	""	},
+/* 174 */	{ 0,			Ukn,	"lwpexit",	""	},
+/* 175 */	{ 0,			Ukn,	"lwpwait",	""	},
+/* 176 */	{ 0,			Ukn,	"lwpself",	""	},
+/* 177 */	{ 0,			Ukn,	"lwpinfo",	""	},
+/* 178 */	{ 0,			Ukn,	"lwpprivate",	""	},
+/* 179 */	{ 0,			Ukn,	"processorbind",""	},
+/* 180 */	{ 0,			Ukn,	"processorexbind",""	},
+/* 181 */	{ 0,			Ukn,	"unimpl 181",	""	},
+/* 182 */	{ 0,			Ukn, 	"sendv64",	""	},
+/* 183 */	{ 0,			Ukn,	"prepblock",	""	},
+/* 184 */	{ 0,			Ukn,	"block",	""	},
+/* 185 */	{ 0,			Ukn,	"rdblock",	""	},
+/* 186 */	{ 0,			Ukn,	"unblock",	""	},
+/* 187 */	{ 0,			Ukn,	"cancelblock",	""	},
+/* 188 */	{ 0,			Ukn,	"unimpl 188",	""	},
+/* 189 */	{ uw7_pread,		4,	"pread",	"dsdd"	},
+/* 190 */	{ uw7_pwrite,		4,	"pwrite",	"dsdd"	},
+/* 191 */	{ sys_truncate,		2,	"truncate",	"sd"	},
+/* 192 */	{ sys_ftruncate,	2,	"ftruncate",	"dd"	},
+/* 193 */	{ 0,			Ukn,	"lwpkill",	""	},
+/* 194 */	{ 0,			Ukn,	"sigwait",	""	},
+/* 195 */	{ abi_fork,		Spl,	"fork1",	""	},
+/* 196 */ 	{ abi_fork,		Spl,	"forkall",	""	},
+
+/*
+ *	197-202 are for loadable kernel module support.
+ */
+/* 197 */	{ 0,			Ukn,	"modload",	""	},
+/* 198 */	{ 0,			Ukn,	"moduload",	""	},
+/* 199 */	{ 0,			Ukn,	"modpath",	""	},
+/* 200 */	{ 0,			Ukn,	"modstat",	""	},
+/* 201 */	{ 0,			Ukn,	"modadm",	""	},
+/* 202 */	{ 0,			Ukn,	"getksym",	""	},
+
+/* 203 */	{ 0,			Ukn,	"lwpsuspend",	""	},
+/* 204 */	{ 0,			Ukn,	"lwpcontinue",	""	},
+/* 205 */	{ 0,			Ukn,	"priocntllst",	""	},
+/* 206 */	{ uw7_sleep,		1,	"sleep",	"d"	},
+
+/*
+ *	207-209 are for post/wait synchronisation.
+ */
+/* 207 */	{ 0,			Ukn,	"lwp_sema_wait",""	},
+/* 208 */	{ 0,			Ukn,	"lwp_sema_post",""	},
+/* 209 */	{ 0,			Ukn,	"lwp_sema_trywait",""	},
+
+/* 210 */	{ 0,			Ukn,	"reserved 210",	""	},
+/* 211 */	{ 0,			Ukn,	"unused 211",	""	},
+/* 212 */	{ 0,			Ukn,	"unused 212",	""	},
+/* 213 */	{ 0,			Ukn,	"unused 213",	""	},
+/* 214 */	{ 0,			Ukn,	"unused 214",	""	},
+/* 215 */	{ 0,			Ukn,	"unused 215",	""	},
+
+/*
+ *	216-226 are for LFS (Large File Summit) support
+ */
+/* 216 */	{ uw7_fstatvfs64,	2,	"fstatvfs64",	"dp"	},
+/* 217 */	{ uw7_statvfs64,	2,	"statvfs64",	"sp"	},
+/* 218 */	{ uw7_ftruncate64,	3,	"ftruncate64",	"sdd"	},
+/* 219 */	{ uw7_truncate64,	3,	"truncate64",	"ddd"	},
+/* 220 */	{ uw7_getrlimit64,	2,	"getrlimit64",	"dp"	},
+/* 221 */	{ uw7_setrlimit64,	2,	"setrlimit64",	"dp"	},
+/* 222 */	{ uw7_lseek64,		4,	"lseek64",	"dddd"	},
+/* 223 */	{ uw7_mmap64,		7,	"mmap64",      "xxxxdxx"},
+/* 224 */	{ uw7_pread64,		5,	"pread64",	"dsddd"	},
+/* 225 */	{ uw7_pwrite64,		5,	"pwrite64",	"dsddd"	},
+/* 226 */	{ uw7_creat64,		2,	"creat64",	"so"	},
+
+/* 227 */	{ 0,			Ukn,	"dshmsys",	""	},
+/* 228 */	{ 0,			Ukn,	"invlpg",	""	},
+
+/*
+ *	229-234 are used for SSI clustering (Nonstop cluster)
+ */
+/* 229 */   { 0,			Ukn,	"rfork1",	""	},
+/* 230 */   { 0,			Ukn,	"rforkall",	""	},
+/* 231 */   { 0,			Ukn,	"rexecve",	""	},
+/* 232 */   { 0,			Ukn,	"migrate",	""	},
+/* 233 */   { 0,			Ukn,	"kill3",	""	},
+/* 234 */   { 0,			Ukn,	"ssisys",	""	},
+
+/*
+ *	235-248 are for kernel-based sockets (Yeah, SVR5 finally got sockets)
+ */
+/* 235 */   { 0,			Ukn,	"xaccept",	""	},
+/* 236 */   { 0,			Ukn,	"xbind",	""	},
+/* 237 */   { 0,			Ukn,	"xbindresvport",""	},
+/* 238 */   { 0,			Ukn,	"xconnect",	""	},
+/* 239 */   { 0,			Ukn,	"xgetsockaddr",	""	},
+/* 240 */   { 0,			Ukn,	"xgetsockopt",	""	},
+/* 241 */   { 0,			Ukn,	"xlisten",	""	},
+/* 242 */   { 0,			Ukn,	"xrecvmsg",	""	},
+/* 243 */   { 0,			Ukn,	"xsendmsg",	""	},
+/* 244 */   { 0,			Ukn,	"xsetsockaddr",	""	},
+/* 245 */   { 0,			Ukn,	"xsetsockopt",	""	},
+/* 246 */   { 0,			Ukn,	"xshutdown",	""	},
+/* 247 */   { 0,			Ukn,	"xsocket",	""	},
+/* 248 */   { 0,			Ukn,	"xsocketpair",	""	},
+
+/* 249 */   { 0,			Ukn,	"unused 249",	""	},
+/* 250 */   { 0,			Ukn,	"unused 250",	""	},
+};
+
+
+static void
+uw7_lcall7(int segment, struct pt_regs *regs)
+{
+	int sysno = regs->eax & 0xff;
+
+	if (sysno >= ARRAY_SIZE(uw7_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &uw7_syscall_table[sysno], 1);
+}
+
+static struct exec_domain uw7_exec_domain = {
+	name:		"UnixWare 7",
+	handler:	uw7_lcall7,
+	pers_low:	14 /* PER_UW7 */,
+	pers_high:	14 /* PER_UW7 */,
+	signal_map:	uw7_to_linux_signals,
+	signal_invmap:	linux_to_uw7_signals,
+	err_map:	uw7_err_map,
+	socktype_map:	uw7_socktype_map,
+	sockopt_map:	uw7_sockopt_map,
+	af_map:		uw7_af_map,
+	module:		THIS_MODULE
+};
+
+static int __init
+init_uw7(void)
+{
+	return register_exec_domain(&uw7_exec_domain);
+}
+
+static void __exit
+cleanup_uw7(void)
+{
+	unregister_exec_domain(&uw7_exec_domain);
+}
+
+module_init(init_uw7);
+module_exit(cleanup_uw7);
diff -Nru linux-2.6.7/abi/wyse/Makefile linux-2.6.7-abi/abi/wyse/Makefile
--- linux-2.6.7/abi/wyse/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/wyse/Makefile	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,7 @@
+
+abi-wyse-objs	:= sysent.o ptrace.o socket.o
+
+obj-$(CONFIG_ABI_WYSE)		+= abi-wyse.o
+
+abi-wyse.o: $(abi-wyse-objs)
+	$(LD) -r -o $@ $(abi-wyse-objs)
diff -Nru linux-2.6.7/abi/wyse/ptrace.c linux-2.6.7-abi/abi/wyse/ptrace.c
--- linux-2.6.7/abi/wyse/ptrace.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/wyse/ptrace.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,113 @@
+/*
+ * ptrace.c - Wyse V/386 ptrace(2) support.
+ *
+ * Copyright (c) 1995 Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+/*
+ * This file is nearly identical to abi/sco/ptrace.c, please keep it in sync.
+ */
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/ptrace.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/personality.h>
+#include <linux/user.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+
+#include <asm/uaccess.h>
+
+#include <abi/signal.h>
+#include <abi/util/trace.h>
+
+
+#define NREGS	19
+#define U(X)	((unsigned long)&((struct user *)0)->X)
+
+
+static unsigned long wysev386_to_linux_reg[NREGS] = {
+	U(regs.es),	U(regs.ds),	U(regs.edi),	U(regs.esi),
+	U(regs.ebp),	U(regs.esp),
+	U(regs.ebx),	U(regs.edx),	U(regs.ecx),	U(regs.eax),
+	U(signal	/* Trap */),
+	U(reserved	/* ERR */),
+	U(regs.eip),	U(regs.cs),
+	U(regs.eflags),
+	U(regs.esp	/* UESP */),
+	U(regs.ss),
+	U(regs.fs),	U(regs.gs)
+};
+
+static const char *regnam[] = {
+	"EBX", "ECX", "EDX", "ESI", "EDI", "EBP", "EAX",
+	"DS", "ES", "FS", "GS", "ORIG_EAX", "EIP", "CS",
+	"EFL", "UESP", "SS"
+};
+
+
+int
+wyse_ptrace(int req, int pid, u_long addr, u_long data)
+{
+	u_long			res;
+
+	/*
+	 * Slight variations between iBCS and Linux codes.
+	 */
+	if (req == PTRACE_ATTACH)
+		req = 10;
+	else if (req == PTRACE_DETACH)
+		req = 11;
+
+	if (req == 3 || req == 6) {
+		/* get offset of u_ar0 */
+		if (addr == 0x1292)
+			return 0x4000;
+
+		/* remap access to the registers. */
+		if ((addr & 0xff00) == 0x4000) { /* Registers */
+			addr = (addr & 0xff) >> 2;
+			if (addr > NREGS)
+				return -EIO;
+			addr = wysev386_to_linux_reg[addr];
+			if (addr == -1)
+				return -EIO;
+		}
+	}
+
+	if (req == 7 && data > 0) {
+		if (data > NSIGNALS)
+			return -EIO;
+		data = current_thread_info()->exec_domain->signal_map[data];
+	}
+
+	if (req == 1 || req == 2 || req == 3) {
+		mm_segment_t	old_fs = get_fs();
+		int		error;
+
+		set_fs(get_ds());
+		error = sys_ptrace(req, pid, addr, (long)&res);
+		set_fs(old_fs);
+
+		if (error)
+			return (error);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	if (req == 3 || req == 6) {
+		abi_trace(ABI_TRACE_API, "%ld [%s] = 0x%08lx\n",
+			addr >> 2, (addr >> 2) < ARRAY_SIZE(regnam) ?
+				regnam[addr >> 2] : "???",
+			req == 3 ? res : data);
+	}
+#endif
+
+	if (req == 1 || req == 2 || req == 3)
+		return (res);
+
+	return sys_ptrace(req, pid, addr, data);
+}
diff -Nru linux-2.6.7/abi/wyse/socket.c linux-2.6.7-abi/abi/wyse/socket.c
--- linux-2.6.7/abi/wyse/socket.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/wyse/socket.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 1994,1996 Mike Jagdis.
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ident "%W% %G%"
+
+/*
+ * BSD-style socket support for Wyse/V386.
+ */
+#include <linux/net.h>
+#include <linux/personality.h>
+#include <linux/syscalls.h>
+#include <linux/utsname.h>
+#include <linux/signal.h>
+#include <linux/wait.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/map.h>
+#include <abi/util/socket.h>
+#include <abi/wyse/sysent.h>
+
+
+int wyse_gethostname(char *name, int len)
+{
+	int error;
+	char *p;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, name, len);
+	if (!error) {
+		--len;
+		for (p = system_utsname.nodename; *p && len; p++,len--) {
+			__put_user(*p, name);
+			name++;
+		}
+		__put_user('\0', name);
+	}
+	up_read(&uts_sem);
+	return error;
+}
+
+int wyse_getdomainname(char *name, int len)
+{
+	int error;
+	char *p;
+
+	down_read(&uts_sem);
+	error = verify_area(VERIFY_WRITE, name, len);
+	if (!error) {
+		--len;
+		for (p = system_utsname.domainname; *p && len; p++,len--) {
+			__put_user(*p, name);
+			name++;
+		}
+		__put_user('\0', name);
+	}
+	up_read(&uts_sem);
+	return error;
+}
+
+int wyse_wait3(int *loc)
+{
+	pid_t pid;
+	int res;
+
+	pid = sys_wait4(-1, loc, WNOHANG, 0);
+	if (!loc)
+		return pid;
+
+	get_user(res, (unsigned long *)loc);
+
+	if ((res & 0xff) == 0x7f) {
+		int sig = (res >> 8) & 0xff;
+
+		sig = current_thread_info()->exec_domain->signal_map[sig];
+		res = (res & (~0xff00)) | (sig << 8);
+		put_user(res, (unsigned long *)loc);
+	} else if (res && res == (res & 0xff)) {
+		res = current_thread_info()->exec_domain->signal_map[res & 0x7f];
+		put_user(res, (unsigned long *)loc);
+	}
+
+	return pid;
+}
+
+int wyse_socket(int family, int type, int protocol)
+{
+	family = map_value(current_thread_info()->exec_domain->af_map, family, 0);
+	type = map_value(current_thread_info()->exec_domain->socktype_map, family, 0);
+
+	return sys_socket(family, type, protocol);
+}
+
+int wyse_setsockopt(int fd, int level, int optname, char *optval, int optlen)
+{
+	switch (level) {
+	case 0: /* IPPROTO_IP aka SOL_IP */
+		if (--optname == 0)
+			optname = 4;
+		if (optname > 4) {
+			optname += 24;
+			if (optname <= 33)
+				optname--;
+			if (optname < 32 || optname > 36)
+				return -EINVAL;
+			break;
+		}
+	case 0xffff:
+		level = SOL_SOCKET;
+		optname = map_value(current_thread_info()->exec_domain->sockopt_map, optname, 0);
+		switch (optname) {
+		case SO_LINGER:
+			/*
+			 * SO_LINGER takes a struct linger as the argument
+			 * but some code uses an int and expects to get
+			 * away without an error. Sigh...
+			 */
+			if (optlen == sizeof(int))
+				return 0;
+			break;
+		/*
+		 * The following are not currently implemented under Linux
+		 * so we must fake them in reasonable ways.
+		 * (Only SO_PROTOTYPE is documented in SCO's man page).
+		 */
+		case SO_PROTOTYPE:
+		case SO_ORDREL:
+		case SO_SNDTIMEO:
+		case SO_RCVTIMEO:
+			return -ENOPROTOOPT;
+
+		case SO_USELOOPBACK:
+		case SO_SNDLOWAT:
+		case SO_RCVLOWAT:
+			return 0;
+
+		/*
+		 * The following are not currenty implemented under Linux
+		 * and probably aren't settable anyway.
+		 */
+		case SO_IMASOCKET:
+			return -ENOPROTOOPT;
+		default:
+			break;
+		}
+	default:
+		/*
+		 * XXX We assume everything else uses the same level and
+		 * XXX option numbers.  This is true for IPPROTO_TCP(/SOL_TCP)
+		 * XXX and TCP_NDELAY but is known to be incorrect for other
+		 * XXX potential options :-(.
+		 */
+		break;
+	}
+
+	return sys_setsockopt(fd, level, optname, optval, optlen);
+}
+
+int wyse_getsockopt(int fd, int level, int optname, char *optval, int *optlen)
+{
+	unsigned int len;
+	int val;
+
+	if (get_user(len,optlen))
+		return -EFAULT;
+	if (len < 0)
+		return -EINVAL;
+
+	switch (level) {
+	case 0: /* IPPROTO_IP aka SOL_IP */
+		if (--optname == 0)
+			optname = 4;
+		if (optname > 4) {
+			optname += 24;
+			if (optname <= 33)
+				optname--;
+			if (optname < 32 || optname > 36)
+				return -EINVAL;
+			break;
+		}
+	case 0xffff:
+		level = SOL_SOCKET;
+		optname = map_value(current_thread_info()->exec_domain->sockopt_map, optname, 0);
+		switch (optname) {
+		case SO_LINGER:
+			/*
+			 * SO_LINGER takes a struct linger as the argument
+			 * but some code uses an int and expects to get
+			 * away without an error. Sigh...
+			 */
+			if (len != sizeof(int))
+				goto native;
+			
+			val = 0;
+			break;
+		/*
+		 * The following are not currently implemented under Linux
+		 * so we must fake them in reasonable ways.
+		 * (Only SO_PROTOTYPE is documented in SCO's man page).
+		 */
+		case SO_PROTOTYPE:
+			val = 0;
+			break;
+
+		case SO_ORDREL:
+		case SO_SNDTIMEO:
+		case SO_RCVTIMEO:
+			return -ENOPROTOOPT;
+
+		case SO_USELOOPBACK:
+		case SO_SNDLOWAT:
+		case SO_RCVLOWAT:
+			return 0;
+
+		/*
+		 * The following are not currenty implemented under Linux
+		 * and probably aren't settable anyway.
+		 */
+		case SO_IMASOCKET:
+			val = 1;
+			break;
+		default:
+			goto native;
+		}
+
+		if (len > sizeof(int))
+			len = sizeof(int);
+		if (copy_to_user(optval, &val, len))
+			return -EFAULT;
+		if (put_user(len, optlen))
+			 return -EFAULT;
+		return 0;
+
+	default:
+		/*
+		 * XXX We assume everything else uses the same level and
+		 * XXX option numbers.  This is true for IPPROTO_TCP(/SOL_TCP)
+		 * XXX and TCP_NDELAY but is known to be incorrect for other
+		 * XXX potential options :-(.
+		 */
+		break;
+	}
+
+native:
+	return sys_getsockopt(fd, level, optname, optval, optlen);
+}
+
+int wyse_recvfrom(int fd, void *buff, size_t size, unsigned flags,
+		  struct sockaddr *addr, int *addr_len)
+{
+	int error;
+
+	error = sys_recvfrom(fd, buff, size, flags, addr, addr_len);
+	if (error == -EAGAIN)
+		error = -EWOULDBLOCK;
+	return error;
+}
+
+int wyse_recv(int fd, void *buff, size_t size, unsigned flags)
+{
+	int error;
+
+	error = sys_recvfrom(fd, buff, size, flags, NULL, NULL);
+	if (error == -EAGAIN)
+		error = -EWOULDBLOCK;
+	return error;
+}
+
+int wyse_sendto(int fd, void *buff, size_t len, unsigned flags,
+		struct sockaddr *addr, int addr_len)
+{
+	int error;
+
+	error = sys_sendto(fd, buff, len, flags, addr, addr_len);
+	if (error == -EAGAIN)
+		error = -EWOULDBLOCK;
+	return error;
+}
+
+int wyse_send(int fd, void *buff, size_t len, unsigned flags)
+{
+	int error;
+
+	error = sys_sendto(fd, buff, len, flags, NULL, 0);
+	if (error == -EAGAIN)
+		error = -EWOULDBLOCK;
+	return error;
+}
diff -Nru linux-2.6.7/abi/wyse/sysent.c linux-2.6.7-abi/abi/wyse/sysent.c
--- linux-2.6.7/abi/wyse/sysent.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/wyse/sysent.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,394 @@
+/*
+ * Copyright (c) 2001 Christoph Hellwig.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Wyse/V386 personality switch.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/personality.h>
+#include <linux/sched.h>
+#include <linux/syscalls.h>
+#include <linux/socket.h>
+#include <linux/net.h>
+#include <asm/uaccess.h>
+
+#include <abi/svr4/sysent.h>
+#include <abi/wyse/sysent.h>
+
+#include <abi/signal.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/sysent.h>
+#include <abi/util/socket.h>
+
+
+MODULE_DESCRIPTION("Wyse/V386 personality");
+MODULE_AUTHOR("Christoph Hellwig, partially taken from iBCS");
+MODULE_LICENSE("GPL");
+
+
+/*
+ * local functions
+ */
+static void	wyse_class_nfs(struct pt_regs *);
+static void	wyse_class_tcp(struct pt_regs *);
+
+
+/*
+ * local variables
+ */
+static u_char wyse_err_table[] = {
+	/*   0 -   9 */   0,   1,   2,    3,   4,   5,   6,   7,   8,   9,
+	/*  10 -  19 */   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+	/*  20 -  29 */   20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+	/*  30 -  39 */   30,  31,  32,  33,  34,  45,  78,  46,  228, 46,
+	/*  40 -  49 */   22, 231, 227, 200,  37,  38,  39,  40,  41,  42,
+	/*  50 -  59 */   43,  44,  50,  51,  52,  53,  54,  55,  56,  57,
+	/*  60 -  69 */   60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
+	/*  70 -  79 */   70,  71,  74,  76,  77,  22,  80,  81,  82,  83,
+	/*  80 -  89 */   84,  85,  86,  87,  22,   4,  22, 233, 203, 204,
+	/*  90 -  99 */  205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
+	/* 100 - 109 */  215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
+	/* 110 - 119 */  225, 226, 229, 230, 202, 201, 237, 135, 137, 138,
+	/* 120 - 122 */  139, 140, 234
+};
+
+/*
+ * Map Linux RESTART* values (512,513,514) to EINTR
+ */
+static u_char lnx_err_table[] = {
+	/* 512 - 514 */ EINTR, EINTR, EINTR
+};
+
+static struct map_segment wyse_err_map[] = {
+	{ 0,	0 + sizeof(wyse_err_table) - 1,		wyse_err_table },
+	{ 512,	512 + sizeof(lnx_err_table) - 1,	lnx_err_table },
+	{ -1 }
+};
+
+static long linux_to_wyse_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		IBCS_SIGHUP,    IBCS_SIGINT,    IBCS_SIGQUIT,
+/*  4 -  7 */	IBCS_SIGILL,	IBCS_SIGTRAP,   IBCS_SIGABRT,   -1,
+/*  8 - 11 */	IBCS_SIGFPE,	IBCS_SIGKILL,   IBCS_SIGUSR1,   IBCS_SIGSEGV,
+/* 12 - 15 */	IBCS_SIGUSR2,	IBCS_SIGPIPE,   IBCS_SIGALRM,   IBCS_SIGTERM,
+/* 16 - 19 */	IBCS_SIGSEGV,	IBCS_SIGCHLD,   IBCS_SIGCONT,   IBCS_SIGSTOP,
+/* 20 - 23 */	IBCS_SIGTSTP,	IBCS_SIGTTIN,   IBCS_SIGTTOU,   IBCS_SIGURG,
+/* 24 - 27 */	IBCS_SIGGXCPU,	IBCS_SIGGXFSZ,  IBCS_SIGVTALRM, IBCS_SIGPROF,
+/* 28 - 31 */	IBCS_SIGWINCH,	IBCS_SIGIO,     IBCS_SIGPWR,    -1,
+/*	32 */	-1
+};
+
+static long wyse_to_linux_signals[NSIGNALS+1] = {
+/*  0 -  3 */	0,		SIGHUP,         SIGINT,         SIGQUIT,
+/*  4 -  7 */	SIGILL,		SIGTRAP,        SIGIOT,         SIGUNUSED,
+/*  8 - 11 */	SIGFPE,		SIGKILL,        SIGUNUSED,      SIGSEGV,
+/* 12 - 15 */	SIGUNUSED,	SIGPIPE,        SIGALRM,        SIGTERM,
+/* 16 - 19 */	SIGUSR1,	SIGUSR2,        SIGCHLD,        SIGPWR,
+/* 20 - 23 */	SIGWINCH,	SIGURG,         SIGPOLL,        SIGSTOP,
+/* 24 - 27 */	SIGTSTP,	SIGCONT,        SIGTTIN,        SIGTTOU,
+/* 28 - 31 */	SIGVTALRM,	SIGPROF,        SIGXCPU,        SIGXFSZ,
+/*	32 */	-1
+};
+
+static char wyse_socktype[] = {
+	SOCK_STREAM,
+	SOCK_DGRAM,
+	0,
+	SOCK_RAW,
+	SOCK_RDM,
+	SOCK_SEQPACKET
+};
+
+static struct map_segment wyse_socktype_map[] = {
+	{ 1, 6, wyse_socktype },
+	{ -1 }
+};
+
+static struct map_segment wyse_sockopt_map[] =  {
+	{ 0x0001, 0x0001, (char *)SO_DEBUG },
+	{ 0x0002, 0x0002, (char *)__SO_ACCEPTCON },
+	{ 0x0004, 0x0004, (char *)SO_REUSEADDR },
+	{ 0x0008, 0x0008, (char *)SO_KEEPALIVE },
+	{ 0x0010, 0x0010, (char *)SO_DONTROUTE },
+	{ 0x0020, 0x0020, (char *)SO_BROADCAST },
+	{ 0x0040, 0x0040, (char *)SO_USELOOPBACK },
+	{ 0x0080, 0x0080, (char *)SO_LINGER },
+	{ 0x0100, 0x0100, (char *)SO_OOBINLINE },
+	{ 0x0200, 0x0200, (char *)SO_ORDREL },
+	{ 0x0400, 0x0400, (char *)SO_IMASOCKET },
+	{ 0x1001, 0x1001, (char *)SO_SNDBUF },
+	{ 0x1002, 0x1002, (char *)SO_RCVBUF },
+	{ 0x1003, 0x1003, (char *)SO_SNDLOWAT },
+	{ 0x1004, 0x1004, (char *)SO_RCVLOWAT },
+	{ 0x1005, 0x1005, (char *)SO_SNDTIMEO },
+	{ 0x1006, 0x1006, (char *)SO_RCVTIMEO },
+	{ 0x1007, 0x1007, (char *)SO_ERROR },
+	{ 0x1008, 0x1008, (char *)SO_TYPE },
+	{ 0x1009, 0x1009, (char *)SO_PROTOTYPE },
+	{ -1 }
+};
+
+static struct map_segment wyse_af_map[] =  {
+	{ 0, 2, NULL },
+	{ -1 }
+};
+
+
+static struct sysent wyse_nfscall_table[] = {
+/*   0 */	{ 0,			Ukn,	"nfs_svc",	""	},
+/*   1 */	{ 0,			Ukn,	"async_daemon",	""	},
+/*   2 */	{ 0,			Ukn,	"nfs_getfh",	""	},
+/*   3 */	{ 0,			Ukn,	"nfsmount",	""	},
+};
+
+static struct sysent wyse_tcpcall_table[] = {
+/*   0 */	{ sys_select,		5,	"select",	"dxxxx"	},
+/*   1 */	{ wyse_socket,		3,	"socket",	"ddd"	},
+/*   2 */	{ sys_connect,		3,	"connect",	"dxd"	},
+/*   3 */	{ sys_accept,		3,	"accept",	"dxx"	},
+/*   4 */	{ wyse_send,		4,	"send",		"dxdd"	},
+/*   5 */	{ wyse_recv,		4,	"recv",		"dxdd"	},
+/*   6 */	{ sys_bind,		3,	"bind",		"dxd"	},
+/*   7 */	{ wyse_setsockopt,	5,	"setsockopt",	"dddxx"	},
+/*   8 */	{ sys_listen,		2,	"listen",	"dd"	},
+/*   9 */	{ 0,			3,	"recvmsg",	"dxd"	},
+/*  10 */	{ 0,			3,	"sendmsg",	"dxd"	},
+/*  11 */	{ wyse_getsockopt,	5,	"getsockopt",	"dddxx"	},
+/*  12 */	{ wyse_recvfrom,	6,	"recvfrom",	"dxddxd"},
+/*  13 */	{ wyse_sendto,		6,	"sendto",	"dxddxd"},
+/*  14 */	{ sys_shutdown,		2,	"shutdown",	"dd"	},
+/*  15 */	{ sys_socketpair,	4,	"socketpair",	"dddx"	}, 
+/*  16 */	{ 0,			Ukn,	"trace",	""	},
+/*  17 */	{ sys_getpeername,	3,	"getpeername",	"dxx"	},
+/*  18 */	{ sys_getsockname,	Spl,	"getsockname",	"dxx"	},
+/*  19 */	{ wyse_wait3,		1,	"wait3",	"x"	},
+};
+
+
+static struct sysent wyse_syscall_table[] = {
+/*   0 */	{ abi_syscall,		Fast,	"syscall",	""	},
+/*   1 */	{ sys_exit,		1,	"exit",		"d"	},
+/*   2 */	{ abi_fork,		Spl,	"fork",		""	},
+/*   3 */	{ abi_read,		3,	"read",		"dpd"	},
+/*   4 */	{ sys_write,		3,	"write",	"dpd"	},
+/*   5 */	{ svr4_open,		3,	"open",		"soo"	},
+/*   6 */	{ sys_close,		1,	"close",	"d"	},
+/*   7 */	{ abi_wait,		Spl,	"wait",		"xxx"	},
+/*   8 */	{ sys_creat,		2,	"creat",	"so"	},
+/*   9 */	{ sys_link,		2,	"link",		"ss"	},
+/*  10 */	{ sys_unlink,		1,	"unlink",	"s"	},
+/*  11 */	{ abi_exec,		Spl,	"exec",		"sxx"	},
+/*  12 */	{ sys_chdir,		1,	"chdir",	"s"	},
+/*  13 */	{ abi_time,		0,	"time",		""	},
+/*  14 */	{ svr4_mknod,		3,	"mknod",	"soo"	},
+/*  15 */	{ sys_chmod,		2,	"chmod",	"so"	},
+/*  16 */	{ sys_chown,		3,	"chown",	"sdd"	},
+/*  17 */	{ abi_brk,		1,	"brk/break",	"x"	},
+/*  18 */	{ svr4_stat,		2,	"stat",		"sp"	},
+/*  19 */	{ sys_lseek,		3,	"seek/lseek",	"ddd"	},
+/*  20 */	{ abi_getpid,		Spl,	"getpid",	""	},
+/*  21 */	{ 0,			Ukn,	"mount",	""	},
+/*  22 */	{ sys_umount,		1,	"umount",	"s"	},
+/*  23 */	{ sys_setuid,		1,	"setuid",	"d"	},
+/*  24 */	{ abi_getuid,		Spl,	"getuid",	""	},
+/*  25 */	{ sys_stime,		1,	"stime",	"d"	},
+/*  26 */	{ wyse_ptrace,		4,	"ptrace",	"xdxx"	},
+/*  27 */	{ sys_alarm,		1,	"alarm",	"d"	},
+/*  28 */	{ svr4_fstat,		2,	"fstat",	"dp"	},
+/*  29 */	{ sys_pause,		0,	"pause",	""	},
+/*  30 */	{ sys_utime,		2,	"utime",	"xx"	},
+/*  31 */	{ 0,			Ukn,	"stty",		""	}, /*   31 */
+/*  32 */	{ 0,			Ukn,	"gtty",		""	},
+/*  33 */	{ sys_access,		2,	"access",	"so"	},
+/*  34 */	{ sys_nice,		1,	"nice",		"d"	},
+/*  35 */	{ svr4_statfs,		4,	"statfs",	"spdd"	},
+/*  36 */	{ sys_sync,		0,	"sync",		""	},
+/*  37 */	{ abi_kill,		2,	"kill",		"dd"	},
+/*  38 */	{ svr4_fstatfs,		4,	"fstatfs",	"dpdd"	},
+/*  39 */	{ abi_procids,		Spl,	"procids",	"d"	},
+/*  40 */	{ 0,			Ukn,	"cxenix",	""	},
+/*  41 */	{ sys_dup,		1,	"dup",		"d"	},
+/*  42 */	{ abi_pipe,		Spl,	"pipe",		""	},
+/*  43 */	{ sys_times,		1,	"times",	"p"	},
+/*  44 */	{ 0,			4,	"prof",		"xxxx"	},
+/*  45 */	{ 0,			Ukn,	"lock/plock",	""	},
+/*  46 */	{ sys_setgid,		1,	"setgid",	"d"	},
+/*  47 */	{ abi_getgid,		Spl,	"getgid",	""	},
+/*  48 */	{ abi_sigfunc,		Fast,	"sigfunc",	"xxx"	},
+/*  49 */	{ svr4_msgsys,		Spl,	"msgsys",	"dxddd"	},
+/*  50 */	{ svr4_sysi86,		3,	"sysi86/sys3b",	"d"	},
+/*  51 */	{ sys_acct,		1,	"acct/sysacct",	"x"	},
+/*  52 */	{ svr4_shmsys,		Fast,	"shmsys",	"ddxo"	},
+/*  53 */	{ svr4_semsys,		Spl,	"semsys",	"dddx"	},
+/*  54 */	{ svr4_ioctl,		Spl,	"ioctl",	"dxx"	},
+/*  55 */	{ 0,			3,	"uadmin",	"xxx"	},
+/*  56 */	{ 0,			Ukn,	"?",		""	},
+/*  57 */	{ v7_utsname,		1,	"utsys",	"x"	},
+/*  58 */	{ sys_fsync,		1,	"fsync",	"d"	},
+/*  59 */	{ abi_exec,		Spl,	"execv",	"spp"	},
+/*  60 */	{ sys_umask,		1,	"umask",	"o"	},
+/*  61 */	{ sys_chroot,		1,	"chroot",	"s"	},
+/*  62 */	{ svr4_fcntl,		3,	"fcntl",	"dxx"	},
+/*  63 */	{ svr4_ulimit,		2,	"ulimit",	"xx"	},
+/*  64 */	{ 0,			Ukn,	"?",		""	},
+/*  65 */	{ 0,			Ukn,	"?",		""	},
+/*  66 */	{ 0,			Ukn,	"?",		""	},
+/*  67 */	{ 0,			Ukn,	"?",		""	},
+/*  68 */	{ 0,			Ukn,	"?",		""	},
+/*  69 */	{ 0,			Ukn,	"?",		""	},
+/*  70 */	{ 0,			Ukn,	"advfs",	""	},
+/*  71 */	{ 0,			Ukn,	"unadvfs",	""	},
+/*  72 */	{ 0,			Ukn,	"rmount",	""	},
+/*  73 */	{ 0,			Ukn,	"rumount",	""	},
+/*  74 */	{ 0,			Ukn,	"rfstart",	""	},
+/*  75 */	{ 0,			Ukn,	"?",		""	},
+/*  76 */	{ 0,			Ukn,	"rdebug",	""	},
+/*  77 */	{ 0,			Ukn,	"rfstop",	""	},
+/*  78 */	{ 0,			Ukn,	"rfsys",	""	},
+/*  79 */	{ sys_rmdir,		1,	"rmdir",	"s"	},
+/*  80 */	{ abi_mkdir,		2,	"mkdir",	"so"	},
+/*  81 */	{ svr4_getdents,	3,	"getdents",	"dxd"	},
+/*  82 */	{ 0,			Ukn,	"libattach",	""	},
+/*  83 */	{ 0,			Ukn,	"libdetach",	""	},
+/*  84 */	{ svr4_sysfs,		3,	"sysfs",	"dxx"	},
+/*  85 */	{ svr4_getmsg,		Spl,	"getmsg",	"dxxx"	},
+/*  86 */	{ svr4_putmsg,		Spl,	"putmsg",	"dxxd"	},
+/*  87 */	{ sys_poll,		3,	"poll",		"xdd"	},
+/*  88 */	{ 0,			Ukn,	"nosys88",	""	},
+/*  89 */	{ 0,			Ukn,	"nosys89",	""	},
+/*  90 */	{ 0,			Ukn,	"nosys90",	""	},
+/*  91 */	{ 0,			Ukn,	"nosys91",	""	},
+/*  92 */	{ 0,			Ukn,	"nosys92",	""	},
+/*  93 */	{ 0,			Ukn,	"nosys93",	""	},
+/*  94 */	{ 0,			Ukn,	"nosys94",	""	},
+/*  95 */	{ 0,			Ukn,	"nosys95",	""	},
+/*  96 */	{ 0,			Ukn,	"nosys96",	""	},
+/*  97 */	{ 0,			Ukn,	"nosys97",	""	},
+/*  98 */	{ 0,			Ukn,	"nosys98",	""	},
+/*  99 */	{ 0,			Ukn,	"nosys99",	""	},
+/* 100 */	{ 0,			Ukn,	"nosys100",	""	},
+/* 101 */	{ 0,			Ukn,	"nosys101",	""	},
+/* 102 */	{ 0,			Ukn,	"nosys102",	""	},
+/* 103 */	{ 0,			Ukn,	"nosys103",	""	},
+/* 104 */	{ 0,			Ukn,	"nosys104",	""	},
+/* 105 */	{ 0,			Ukn,	"nosys105",	""	},
+/* 106 */	{ 0,			Ukn,	"nosys106",	""	},
+/* 107 */	{ 0,			Ukn,	"nosys107",	""	},
+/* 108 */	{ 0,			Ukn,	"nosys108",	""	},
+/* 109 */	{ 0,			Ukn,	"nosys109",	""	},
+/* 110 */	{ 0,			Ukn,	"nosys110",	""	},
+/* 111 */	{ 0,			Ukn,	"nosys111",	""	},
+/* 112 */	{ 0,			Ukn,	"nosys112",	""	},
+/* 113 */	{ 0,			Ukn,	"nosys113",	""	},
+/* 114 */	{ 0,			Ukn,	"nosys114",	""	},
+/* 115 */	{ 0,			Ukn,	"nosys115",	""	},
+/* 116 */	{ 0,			Ukn,	"nosys116",	""	},
+/* 117 */	{ 0,			Ukn,	"nosys117",	""	},
+/* 118 */	{ 0,			Ukn,	"nosys118",	""	},
+/* 119 */	{ 0,			Ukn,	"nosys119",	""	},
+/* 120 */	{ 0,			Ukn,	"nosys120",	""	},
+/* 121 */	{ 0,			Ukn,	"nosys121",	""	},
+/* 122 */	{ 0,			Ukn,	"nosys122",	""	},
+/* 123 */	{ 0,			Ukn,	"nosys123",	""	},
+/* 124 */	{ 0,			Ukn,	"nosys124",	""	},
+/* 125 */	{ 0,			Ukn,	"nosys125",	""	},
+/* 126 */	{ 0,			Ukn,	"nosys126",	""	},
+/* 127 */	{ 0,			Ukn, 	"nosys127",	""	},
+/* 128 */	{ svr4_lstat,		2,	"lstat",	"sp"	},
+/* 129 */	{ sys_readlink,		3,	"readlink",	"spd"	},
+/* 130 */	{ sys_symlink,		2,	"symlink",	"ss"	},
+/* 131 */	{ wyse_class_tcp,	Fast,	"",		""	},
+/* 132 */	{ wyse_class_nfs,	Fast,	"",		""	},
+/* 133 */	{ wyse_gethostname,	2,	"gethostname",	"xd"	},
+/* 134 */	{ sys_sethostname,	2,	"sethostname",	"sd"	},
+/* 135 */	{ wyse_getdomainname,	2,	"getdomainname","xd"	},
+/* 136 */	{ sys_setdomainname,	2,	"setdomainname","sd"	},
+/* 137 */	{ 0,			Ukn,	"?",		""	},
+/* 138 */	{ sys_setreuid,		2,	"setreuid",	"dd"	},
+/* 139 */	{ sys_setregid,		2,	"setregid",	"dd"	},
+};
+
+static void
+wyse_class_nfs(struct pt_regs *regs)
+{
+
+	int sysno = regs->eax >> 8;
+
+	if (sysno >= ARRAY_SIZE(wyse_nfscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &wyse_nfscall_table[sysno], 1);
+}
+
+static void
+wyse_class_tcp(struct pt_regs *regs)
+{
+	int sysno = regs->eax >> 8;
+
+	if (sysno >= ARRAY_SIZE(wyse_tcpcall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &wyse_tcpcall_table[sysno], 1);
+}
+
+static void
+wyse_lcall7(int segment, struct pt_regs *regs)
+{
+	int sysno = regs->eax & 0xff;
+	
+	if (sysno >= ARRAY_SIZE(wyse_syscall_table))
+		set_error(regs, iABI_errors(-EINVAL));
+	else
+		lcall7_dispatch(regs, &wyse_syscall_table[sysno], 1);
+}
+
+static struct exec_domain wyse_exec_domain = {
+	name:		"Wyse/386",
+	handler:	wyse_lcall7,
+	pers_low:	4 /* PER_WYSEV386 */,
+	pers_high:	4 /* PER_WYSEV386 */,
+	signal_map:	wyse_to_linux_signals,
+	signal_invmap:	linux_to_wyse_signals,
+	err_map:	wyse_err_map,
+	socktype_map:	wyse_socktype_map,
+	sockopt_map:	wyse_sockopt_map,
+	af_map:		wyse_af_map,
+	module:		THIS_MODULE
+};
+
+
+static int __init
+wyse_module_init(void)
+{
+	return register_exec_domain(&wyse_exec_domain);
+}
+
+static void __exit
+wyse_module_exit(void)
+{
+	unregister_exec_domain(&wyse_exec_domain);
+}
+
+module_init(wyse_module_init);
+module_exit(wyse_module_exit);
diff -Nru linux-2.6.7/abi/wyse/syslocal.c linux-2.6.7-abi/abi/wyse/syslocal.c
--- linux-2.6.7/abi/wyse/syslocal.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/abi/wyse/syslocal.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 1994	Mike Jagdis (jaggy@purplet.demon.co.uk)
+ */
+
+#ident "%W% %G%"
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/trace.h>
+
+
+/*
+ * The syslocal() call is used for machine specific functions. For
+ * instance on a Wyse 9000 it give information and control of the
+ * available processors.
+ */
+#define SL_ONLINE	0	/* Turn processor online		*/
+#define SL_OFFLINE	1	/* Turn processor offline		*/
+#define SL_QUERY	2	/* Query processor status		*/
+#define SL_NENG		3	/* Return No. of processors configured	*/
+#define SL_AFFINITY	4	/* processor binding			*/
+#define SL_CMC_STAT	7	/* gather CMC performance counters info	*/
+#define SL_KACC		8	/* make kernel data readable by user	*/
+#define SL_MACHTYPE	9	/* return machine type (MP/AT)		*/
+#define SL_BOOTNAME	10	/* return name of booted kernel		*/
+#define SL_BOOTDEV	11	/* return type of booted device		*/
+#define SL_UQUERY	12	/* query user status			*/
+
+#define SL_MACH_MP	0
+#define SL_MACH_AT	1
+#define SL_MACH_EISA	2
+#define SL_MACH_EMP	3
+
+
+int
+wyse_syslocal(struct pt_regs *regp)
+{
+	int			cmd = get_syscall_parameter(regp, 0);
+
+	switch (cmd) {
+	case SL_QUERY:
+		return 0;
+	case SL_NENG:
+		return 1;
+	case SL_MACHTYPE:
+		return (EISA_bus ? SL_MACH_EISA : SL_MACH_AT);
+	}
+
+#if defined(CONFIG_ABI_TRACE)
+	abi_trace(ABI_TRACE_UNIMPL, "unsupported syslocal call %d\n", cmd);
+#endif
+	return -EINVAL;
+}
diff -Nru linux-2.6.7/arch/i386/kernel/i386_ksyms.c linux-2.6.7-abi/arch/i386/kernel/i386_ksyms.c
--- linux-2.6.7/arch/i386/kernel/i386_ksyms.c	2004-06-16 07:20:26.000000000 +0200
+++ linux-2.6.7-abi/arch/i386/kernel/i386_ksyms.c	2004-07-22 17:44:21.000000000 +0200
@@ -16,6 +16,9 @@
 #include <linux/tty.h>
 #include <linux/highmem.h>
 #include <linux/time.h>
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <linux/syscalls.h>
 
 #include <asm/semaphore.h>
 #include <asm/processor.h>
@@ -206,3 +209,8 @@
 #endif
 
 EXPORT_SYMBOL(csum_partial);
+
+EXPORT_SYMBOL(sys_modify_ldt);
+EXPORT_SYMBOL(sys_ptrace);
+EXPORT_SYMBOL(sys_ipc);
+EXPORT_SYMBOL(sys_pause);
diff -Nru linux-2.6.7/arch/i386/kernel/lcall7.c linux-2.6.7-abi/arch/i386/kernel/lcall7.c
--- linux-2.6.7/arch/i386/kernel/lcall7.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/arch/i386/kernel/lcall7.c	2004-07-22 17:44:21.000000000 +0200
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2000,2001 Christoph Hellwig.
+ * Copyright (c) 2001 Caldera Deutschland GmbH.
+ * All rights resered.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ident "%W% %G%"
+
+/*
+ * Lowlevel handler for lcall7-based syscalls.
+ */
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/ptrace.h>
+#include <linux/init.h>
+#include <linux/personality.h>
+#include <asm/uaccess.h>
+
+#include <abi/util/errno.h>
+#include <abi/util/trace.h>
+#include <abi/util/sysent.h>
+
+MODULE_AUTHOR("Christoph Hellwig");
+MODULE_DESCRIPTION("Lowlevel handler for lcall7-based syscalls");
+MODULE_LICENSE("GPL");
+
+
+static void get_args(int args[], struct pt_regs *regs, int of, int n)
+{
+	int i;
+
+	for (i = 0; i < n; i++)
+		get_user(args[i], ((unsigned long *)regs->esp) + (i+of));
+}
+
+/*
+ *	lcall7_syscall    -    indirect syscall for the lcall7 entry point
+ *
+ *	@regs:		saved user registers
+ *
+ *	This function implements syscall(2) in kernelspace for the lcall7-
+ *	based personalities.
+ */
+
+int lcall7_syscall(struct pt_regs *regs)
+{
+	__get_user(regs->eax, ((unsigned long *)regs->esp)+1);
+
+	++regs->esp;
+	current_thread_info()->exec_domain->handler(-1,regs);
+	--regs->esp;
+
+	return 0;
+}
+
+/**
+ *	lcall7_dispatch    -    handle lcall7-based syscall entry
+ *
+ *	@regs:		saved user registers
+ *	@ap:		syscall table entry
+ *	@off:		argument offset
+ *
+ *	This function handles lcall7-based syscalls after the personality-
+ *	specific rountine selected the right syscall table entry.
+ */
+
+void lcall7_dispatch(struct pt_regs *regs, struct sysent *ap, int off)
+{
+	short nargs = ap->se_nargs;
+	int args[8], error;
+
+	if (!ap->se_syscall) /* XXX kludge XXX */
+		nargs = Unimpl;
+
+	if (nargs <= ARRAY_SIZE(args))
+		get_args(args, regs, off, nargs);
+
+#if defined(CONFIG_ABI_TRACE)
+	if (abi_traced(ABI_TRACE_API)) {
+		if (nargs == Spl)
+			get_args(args, regs, off, strlen(ap->se_args));
+		plist(ap->se_name, ap->se_args, args);
+	}
+#endif
+
+	switch (nargs) {
+	case Fast:
+		SYSCALL_PREGS(ap->se_syscall, regs);
+		goto show_signals;
+	case Spl:
+		error = SYSCALL_PREGS(ap->se_syscall, regs);
+		break;
+	case 0:
+		error = SYSCALL_VOID(ap->se_syscall);
+		break;
+	case 1:
+		error = SYSCALL_1ARG(ap->se_syscall, args);
+		break;
+	case 2:
+		error = SYSCALL_2ARG(ap->se_syscall, args);
+		break;
+	case 3:
+		error = SYSCALL_3ARG(ap->se_syscall, args);
+		break;
+	case 4:
+		error = SYSCALL_4ARG(ap->se_syscall, args);
+		break;
+	case 5:
+		error = SYSCALL_5ARG(ap->se_syscall, args);
+		break;
+	case 6:
+		error = SYSCALL_6ARG(ap->se_syscall, args);
+		break;
+	case 7:
+		error = SYSCALL_7ARG(ap->se_syscall, args);
+		break;
+	default:
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_UNIMPL,
+			"Unsupported ABI function 0x%lx (%s)\n",
+			regs->eax, ap->se_name);
+#endif
+		error = -ENOSYS;
+	}
+
+	if (error > -ENOIOCTLCMD && error < 0) {
+		set_error(regs, iABI_errors(-error));
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API,
+		    "%s error return %d/%ld\n",
+		    ap->se_name, error, regs->eax);
+#endif
+	} else {
+		clear_error(regs);
+		set_result(regs, error);
+
+#if defined(CONFIG_ABI_TRACE)
+		abi_trace(ABI_TRACE_API,
+		    "%s returns %ld (edx:%ld)\n",
+		    ap->se_name, regs->eax, regs->edx);
+#endif
+	}
+
+show_signals:
+#if defined(CONFIG_ABI_TRACE)
+	if (signal_pending(current) && abi_traced(ABI_TRACE_SIGNAL)) {
+		unsigned long signr;
+
+		signr = current->pending.signal.sig[0] &
+			~current->blocked.sig[0];
+
+		__asm__("bsf %1,%0\n\t"
+				:"=r" (signr)
+				:"0" (signr));
+
+		__abi_trace("SIGNAL %lu, queued 0x%08lx\n",
+			signr+1, current->pending.signal.sig[0]);
+	}
+#endif
+        return;
+}
+
+#if defined(CONFIG_ABI_SYSCALL_MODULES)
+EXPORT_SYMBOL(lcall7_syscall);
+EXPORT_SYMBOL(lcall7_dispatch);
+#endif
diff -Nru linux-2.6.7/arch/i386/kernel/Makefile linux-2.6.7-abi/arch/i386/kernel/Makefile
--- linux-2.6.7/arch/i386/kernel/Makefile	2004-06-16 07:19:01.000000000 +0200
+++ linux-2.6.7-abi/arch/i386/kernel/Makefile	2004-07-22 17:44:21.000000000 +0200
@@ -25,6 +25,7 @@
 obj-$(CONFIG_X86_IO_APIC)	+= io_apic.o
 obj-$(CONFIG_X86_NUMAQ)		+= numaq.o
 obj-$(CONFIG_X86_SUMMIT_NUMA)	+= summit.o
+obj-$(CONFIG_ABI_LCALL7)	+= lcall7.o
 obj-$(CONFIG_MODULES)		+= module.o
 obj-y				+= sysenter.o vsyscall.o
 obj-$(CONFIG_ACPI_SRAT) 	+= srat.o
diff -Nru linux-2.6.7/arch/i386/kernel/traps.c linux-2.6.7-abi/arch/i386/kernel/traps.c
--- linux-2.6.7/arch/i386/kernel/traps.c	2004-06-16 07:19:01.000000000 +0200
+++ linux-2.6.7-abi/arch/i386/kernel/traps.c	2004-07-22 17:44:21.000000000 +0200
@@ -588,6 +588,26 @@
 
 	__asm__ __volatile__("movl %%db6,%0" : "=r" (condition));
 
+      /*                                                                      
+       * Entering the kernel via lcall7 or lcall27 does not clear the TF bit. 
+       * Leaving it set in kernel code will stop the machine.  The first      
+       * instructions of lcall7 and lcall27 in entry.S save the CPU flags.    
+       * The saved flags should have the TF bit set, so we ignore this trap.  
+       */                                                                     
+      if (regs->eip == (unsigned long) &lcall7 ||
+          regs->eip == (unsigned long) &lcall27)  
+              return;                                                         
+                                                                              
+      /*                                                                      
+       * After having saved the flags, TF will fire the single step trap      
+       * again.  This time TF should be cleared. It will be restored by the   
+       * iret instruction returning to user mode.  This way, the very next    
+       * instruction after lcall in the user programm will not be stopped at. 
+       */                                                                     
+      if (regs->eip - 1 == (unsigned long) &lcall7 || /* pushfl is a one-byte op */ 
+          regs->eip - 1 == (unsigned long) &lcall27)                                
+              goto clear_TF;
+
 	/* It's safe to allow irq's after DR6 has been saved */
 	if (regs->eflags & X86_EFLAGS_IF)
 		local_irq_enable();
diff -Nru linux-2.6.7/arch/ia64/ia32/ia32priv.h linux-2.6.7-abi/arch/ia64/ia32/ia32priv.h
--- linux-2.6.7/arch/ia64/ia32/ia32priv.h	2004-06-16 07:20:19.000000000 +0200
+++ linux-2.6.7-abi/arch/ia64/ia32/ia32priv.h	2004-07-22 17:44:21.000000000 +0200
@@ -332,7 +332,7 @@
 
 #ifdef __KERNEL__
 # define SET_PERSONALITY(EX,IBCS2)				\
-	(current->personality = (IBCS2) ? PER_SVR4 : PER_LINUX)
+	(is_cur_personality((IBCS2)) ? PER_SVR4 : PER_LINUX)
 #endif
 
 #define IA32_EFLAG	0x200
diff -Nru linux-2.6.7/arch/parisc/kernel/signal.c linux-2.6.7-abi/arch/parisc/kernel/signal.c
--- linux-2.6.7/arch/parisc/kernel/signal.c	2004-06-16 07:20:19.000000000 +0200
+++ linux-2.6.7-abi/arch/parisc/kernel/signal.c	2004-07-22 17:44:21.000000000 +0200
@@ -75,7 +75,7 @@
 #ifdef __LP64__
 	compat_sigset_t newset32;
 
-	if(personality(current->personality) == PER_LINUX32){
+	if(is_cur_personality_id(PERID_LINUX32)){
 		/* XXX: Don't preclude handling different sized sigset_t's.  */
 		if (sigsetsize != sizeof(compat_sigset_t))
 			return -EINVAL;
@@ -152,7 +152,7 @@
 	compat_sigset_t compat_set;
 	struct compat_rt_sigframe * compat_frame;
 	
-	if(personality(current->personality) == PER_LINUX32)
+	if(is_cur_personality_id(PERID_LINUX32))
 		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 #endif
 
@@ -165,7 +165,7 @@
 #ifdef __LP64__
 	compat_frame = (struct compat_rt_sigframe *)frame;
 	
-	if(personality(current->personality) == PER_LINUX32){
+	if(is_cur_personality_id(PERID_LINUX32)){
 		DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
 		if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
 			goto give_sigsegv;
@@ -185,7 +185,7 @@
 
 	/* Good thing we saved the old gr[30], eh? */
 #ifdef __LP64__
-	if(personality(current->personality) == PER_LINUX32){
+	if(is_cur_personality_id(PERID_LINUX32)){
 		DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
 				&compat_frame->uc.uc_mcontext);
 // FIXME: Load upper half from register file
@@ -315,7 +315,7 @@
 
 	compat_frame = (struct compat_rt_sigframe *)frame;
 	
-	if(personality(current->personality) == PER_LINUX32) {
+	if(is_personality_id(PERID_LINUX32)) {
 		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
 		err |= compat_copy_siginfo_to_user(&compat_frame->info, info);
 		DBG(1,"SETUP_RT_FRAME: 1\n");
@@ -392,7 +392,7 @@
 	haddr = A(ka->sa.sa_handler);
 	/* The sa_handler may be a pointer to a function descriptor */
 #ifdef __LP64__
-	if(personality(current->personality) == PER_LINUX32) {
+	if(is_cur_personality_id(PERID_LINUX32)) {
 #endif
 		if (haddr & PA_PLABEL_FDESC) {
 			Elf32_Fdesc fdesc;
@@ -427,19 +427,19 @@
 	 */
 	sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 #ifdef __LP64__
-	if(personality(current->personality) == PER_LINUX32)
+	if(is_cur_personality_id(PERID_LINUX32))
 		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 #endif
 	if (in_syscall) {
 		regs->gr[31] = haddr;
 #ifdef __LP64__
-		if(personality(current->personality) == PER_LINUX)
+		if(is_cur_personality_id(PERID_LINUX))
 			sigframe_size |= 1;
 #endif
 	} else {
 		unsigned long psw = USER_PSW;
 #ifdef __LP64__
-		if(personality(current->personality) == PER_LINUX)
+		if(is_cur_personality_id(PERID_LINUX))
 			psw |= PSW_W;
 #endif
 
@@ -452,7 +452,7 @@
 	regs->gr[26] = sig;               /* signal number */
 	
 #ifdef __LP64__
-	if(personality(current->personality) == PER_LINUX32){
+	if(is_cur_personality_id(PERID_LINUX32)){
 		regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
 		regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
 	} else
diff -Nru linux-2.6.7/arch/x86_64/ia32/sys_ia32.c linux-2.6.7-abi/arch/x86_64/ia32/sys_ia32.c
--- linux-2.6.7/arch/x86_64/ia32/sys_ia32.c	2004-06-16 07:19:22.000000000 +0200
+++ linux-2.6.7-abi/arch/x86_64/ia32/sys_ia32.c	2004-07-22 17:44:21.000000000 +0200
@@ -924,12 +924,15 @@
 sys32_personality(unsigned long personality)
 {
 	int ret;
-	if (personality(current->personality) == PER_LINUX32 && 
+
+	if (is_personality_id(PERID_LINUX32) && 
 		personality == PER_LINUX)
 		personality = PER_LINUX32;
 	ret = sys_personality(personality);
+
 	if (ret == PER_LINUX32)
 		ret = PER_LINUX;
+
 	return ret;
 }
 
@@ -1077,7 +1080,7 @@
 	 __put_user(0,name->version+__OLD_UTS_LEN);
 	 { 
 		 char *arch = "x86_64";
-		 if (personality(current->personality) == PER_LINUX32)
+		 if (is_cur_personality_id(PERID_LINUX32))
 			 arch = "i686";
 		 
 		 __copy_to_user(&name->machine,arch,strlen(arch)+1);
@@ -1098,7 +1101,7 @@
 	down_read(&uts_sem);
 	err=copy_to_user(name, &system_utsname, sizeof (*name));
 	up_read(&uts_sem);
-	if (personality(current->personality) == PER_LINUX32) 
+	if (is_cur_personality_id(PERID_LINUX32))
 		err |= copy_to_user(&name->machine, "i686", 5);
 	return err?-EFAULT:0;
 }
diff -Nru linux-2.6.7/arch/x86_64/kernel/sys_x86_64.c linux-2.6.7-abi/arch/x86_64/kernel/sys_x86_64.c
--- linux-2.6.7/arch/x86_64/kernel/sys_x86_64.c	2004-06-16 07:19:37.000000000 +0200
+++ linux-2.6.7-abi/arch/x86_64/kernel/sys_x86_64.c	2004-07-22 17:44:21.000000000 +0200
@@ -148,7 +148,7 @@
 	down_read(&uts_sem);
 	err = copy_to_user(name, &system_utsname, sizeof (*name));
 	up_read(&uts_sem);
-	if (personality(current->personality) == PER_LINUX32) 
+	if (is_cur_personality_id(PERID_LINUX32)) 
 		err |= copy_to_user(&name->machine, "i686", 5); 		
 	return err ? -EFAULT : 0;
 }
diff -Nru linux-2.6.7/Documentation/abi/00-INDEX linux-2.6.7-abi/Documentation/abi/00-INDEX
--- linux-2.6.7/Documentation/abi/00-INDEX	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/Documentation/abi/00-INDEX	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,30 @@
+00-INDEX
+	- this file
+COMPAT
+	- a list of software that has run succesfull under iBCS
+CREDITS
+	- a list of people that have contributed to linux-abi or iBCS
+ChangeLog
+	- changelog of linux-abi
+ChangeLog.ibcs
+	- changelog of the iBCS project (up to 1998)
+Error.map
+	- mapping of error codes from Linux to various personalities
+HINTS
+	- FAQ-style Q&A
+Local-X
+	- help on local X interfaces
+Notes.Signal
+	- some notes on signal handling
+Personality
+	- an introduction into Linux personality support
+README.first
+	- read this first!
+Syscall.map
+	- the syscall mapping for certain personalities
+TODO.ibcs
+	- things to be done, leftovers from iBCS
+autoload.txt
+	- autoloading personality modules under Linux-ABI
+modules.txt
+	- a brief overview of the Linux-ABI modules
diff -Nru linux-2.6.7/Documentation/abi/autoload.txt linux-2.6.7-abi/Documentation/abi/autoload.txt
--- linux-2.6.7/Documentation/abi/autoload.txt	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/Documentation/abi/autoload.txt	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,49 @@
+Autoloading personality modules under Linux-ABI
+2001-July-19
+Christoph Hellwig, <hch@caldera.de>
+
+Linux-ABI can automatically load binary format modules (see modules.txt
+for information on what binary format modules are).  This file explains
+how to setup a system to automatically load the binary format modules
+on demand.
+
+Automatic module loading is done in Linux using a facility called 'kmod'
+which is - unlike the name suggests - _not_ a system daemon, but a kernel-
+facility to make userspace upcalls to te module loading program 'modprobe'.
+
+Linux-ABI uses the function request_module that is exported by kmod to
+request modules for personalities that are currently not available but
+requested by one of the binary fomrat detection heuristics.  For a missing
+personality, request_module is called for the module-string
+
+	personality-<personality-number>
+
+To get the right modules loaded you have to alias these string to the
+actually wanted modules in /etc/modules.conf.  To do that you have to know
+which personality number maps to what module.  Here is a table for the
+personalities supported by Linux-ABI:
+
+
+	  personalities		module
+	-----------------------------------
+	  1,2,5,7		abi-ibcs
+	  3			abi-sco
+	  4			abi-wyse
+	  13			abi-solaris
+	  14			abi-uw7
+
+Below is an example snipplet from modules.conf for such a setup:
+
+------------------- snip --------------------
+
+alias personality-1	abi-ibcs
+alias personality-2	abi-ibcs
+alias personality-3	abi-sco
+alias personality-4	abi-wyse
+alias personality-5	abi-ibcs
+alias personality-7	abi-ibcs
+alias personality-13	abi-solaris
+alias personality-14	abi-uw7
+
+------------------- snip --------------------
+
diff -Nru linux-2.6.7/Documentation/abi/ChangeLog linux-2.6.7-abi/Documentation/abi/ChangeLog
--- linux-2.6.7/Documentation/abi/ChangeLog	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.7-abi/Documentation/abi/ChangeLog	2004-07-22 17:44:20.000000000 +0200
@@ -0,0 +1,135 @@
+2002-01-03  Christoph Hellwig  <hch@caldera.de>
+