31 files changed, 5863 insertions, 0 deletions

diff --git a/sys/i386/ibcs2/ibcs2_dirent.h b/sys/i386/ibcs2/ibcs2_dirent.h
new file mode 100644
index 000000000000..f93e3a93c5a2
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_dirent.h
@@ -0,0 +1,57 @@
+/*	$NetBSD: ibcs2_dirent.h,v 1.2 1994/10/26 02:52:51 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef _IBCS2_DIRENT_H
+#define _IBCS2_DIRENT_H 1
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+#define IBCS2_MAXNAMLEN		512
+#define IBCS2_DIRBUF		1048
+
+typedef struct {
+	int	dd_fd;
+	int	dd_loc;
+	int	dd_size;
+	char	*dd_buf;
+} IBCS2_DIR;
+
+struct ibcs2_dirent {
+	ibcs2_ino_t	d_ino;
+	short		d_pad;
+	ibcs2_off_t	d_off;
+	u_short		d_reclen;
+	char		d_name[1];
+};
+
+#endif /* _IBCS2_DIRENT_H */
diff --git a/sys/i386/ibcs2/ibcs2_errno.c b/sys/i386/ibcs2/ibcs2_errno.c
new file mode 100644
index 000000000000..48cb88eb9c16
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_errno.c
@@ -0,0 +1,118 @@
+/*
+ * ibcs2_errno.c
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <compat/ibcs2/ibcs2_errno.h>
+
+int bsd2ibcs_errno[] = {
+	0,			/* 0 */
+	IBCS2_EPERM,		/* 1 */
+	IBCS2_ENOENT,		/* 2 */
+	IBCS2_ESRCH,		/* 3 */
+	IBCS2_EINTR,		/* 4 */
+	IBCS2_EIO,		/* 5 */
+	IBCS2_ENXIO,		/* 6 */
+	IBCS2_E2BIG,		/* 7 */
+	IBCS2_ENOEXEC,		/* 8 */
+	IBCS2_EBADF,		/* 9 */
+	IBCS2_ECHILD,		/* 10 */
+	IBCS2_EDEADLK,		/* 11 */
+	IBCS2_ENOMEM,		/* 12 */
+	IBCS2_EACCES,		/* 13 */
+	IBCS2_EFAULT,		/* 14 */
+	IBCS2_ENOTBLK,		/* 15 */
+	IBCS2_EBUSY,		/* 16 */
+	IBCS2_EEXIST,		/* 17 */
+	IBCS2_EXDEV,		/* 18 */
+	IBCS2_ENODEV,		/* 19 */
+	IBCS2_ENOTDIR,		/* 20 */
+	IBCS2_EISDIR,		/* 21 */
+	IBCS2_EINVAL,		/* 22 */
+	IBCS2_ENFILE,		/* 23 */
+	IBCS2_EMFILE,		/* 24 */
+	IBCS2_ENOTTY,		/* 25 */
+	IBCS2_ETXTBSY,		/* 26 */
+	IBCS2_EFBIG,		/* 27 */
+	IBCS2_ENOSPC,		/* 28 */
+	IBCS2_ESPIPE,		/* 29 */
+	IBCS2_EROFS,		/* 30 */
+	IBCS2_EMLINK,		/* 31 */
+	IBCS2_EPIPE,		/* 32 */
+	IBCS2_EDOM,		/* 33 */
+	IBCS2_ERANGE,		/* 34 */
+	IBCS2_EAGAIN,		/* 35 */
+	IBCS2_EINPROGRESS,	/* 36 */
+	IBCS2_EALREADY,		/* 37 */
+	IBCS2_ENOTSOCK,		/* 38 */
+	IBCS2_EDESTADDRREQ,	/* 39 */
+	IBCS2_EMSGSIZE,		/* 40 */
+	IBCS2_EPROTOTYPE,	/* 41 */
+	IBCS2_ENOPROTOOPT,	/* 42 */
+	IBCS2_EPROTONOSUPPORT,	/* 43 */
+	IBCS2_ESOCKTNOSUPPORT,	/* 44 */
+	IBCS2_EOPNOTSUPP,	/* 45 */
+	IBCS2_EPFNOSUPPORT,	/* 46 */
+	IBCS2_EAFNOSUPPORT,	/* 47 */
+	IBCS2_EADDRINUSE,	/* 48 */
+	IBCS2_EADDRNOTAVAIL,	/* 49 */
+	IBCS2_ENETDOWN,		/* 50 */
+	IBCS2_ENETUNREACH,	/* 51 */
+	IBCS2_ENETRESET,	/* 52 */
+	IBCS2_ECONNABORTED,	/* 53 */
+	IBCS2_ECONNRESET,	/* 54 */
+	IBCS2_ENOBUFS,		/* 55 */
+	IBCS2_EISCONN,		/* 56 */
+	IBCS2_ENOTCONN,		/* 57 */
+	IBCS2_ESHUTDOWN,	/* 58 */
+	IBCS2_ETOOMANYREFS,	/* 59 */
+	IBCS2_ETIMEDOUT,	/* 60 */
+	IBCS2_ECONNREFUSED,	/* 61 */
+	IBCS2_ELOOP,		/* 62 */
+	IBCS2_ENAMETOOLONG,	/* 63 */
+	IBCS2_EHOSTDOWN,	/* 64 */
+	IBCS2_EHOSTUNREACH,	/* 65 */
+	IBCS2_ENOTEMPTY,	/* 66 */
+	0,			/* 67 */
+	0,			/* 68 */
+	0,			/* 69 */
+	IBCS2_ESTALE,		/* 70 */
+	IBCS2_EREMOTE,		/* 71 */
+	0,			/* 72 */
+	0,			/* 73 */
+	0,			/* 74 */
+	0,			/* 75 */
+	0,			/* 76 */
+	IBCS2_ENOLCK,		/* 77 */
+	IBCS2_ENOSYS,		/* 78 */
+	0,			/* 79 */
+	0,			/* 80 */
+	0,			/* 81 */
+};
+
diff --git a/sys/i386/ibcs2/ibcs2_errno.h b/sys/i386/ibcs2/ibcs2_errno.h
new file mode 100644
index 000000000000..30ed8241ae28
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_errno.h
@@ -0,0 +1,153 @@
+/*
+ * ibcs2_errno.h
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _IBCS2_ERRNO_H
+#define _IBCS2_ERRNO_H
+
+#define _SCO_NET 1
+
+#define IBCS2_EPERM		1
+#define IBCS2_ENOENT		2
+#define IBCS2_ESRCH		3
+#define IBCS2_EINTR		4
+#define IBCS2_EIO		5
+#define IBCS2_ENXIO		6
+#define IBCS2_E2BIG		7
+#define IBCS2_ENOEXEC		8
+#define IBCS2_EBADF		9
+#define IBCS2_ECHILD		10
+#define IBCS2_EAGAIN		11
+#define IBCS2_ENOMEM		12
+#define IBCS2_EACCES		13
+#define IBCS2_EFAULT		14
+#define IBCS2_ENOTBLK		15
+#define IBCS2_EBUSY		16
+#define IBCS2_EEXIST		17
+#define IBCS2_EXDEV		18
+#define IBCS2_ENODEV		19
+#define IBCS2_ENOTDIR		20
+#define IBCS2_EISDIR		21
+#define IBCS2_EINVAL		22
+#define IBCS2_ENFILE		23
+#define IBCS2_EMFILE		24
+#define IBCS2_ENOTTY		25
+#define IBCS2_ETXTBSY		26
+#define IBCS2_EFBIG		27
+#define IBCS2_ENOSPC		28
+#define IBCS2_ESPIPE		29
+#define IBCS2_EROFS		30
+#define IBCS2_EMLINK		31
+#define IBCS2_EPIPE		32
+#define IBCS2_EDOM		33
+#define IBCS2_ERANGE		34
+#define IBCS2_ENOMSG		35
+#define IBCS2_EIDRM		36
+#define IBCS2_ECHRNG		37
+#define IBCS2_EL2NSYNC		38
+#define IBCS2_EL3HLT		39
+#define IBCS2_EL3RST		40
+#define IBCS2_ELNRNG		41
+#define IBCS2_EUNATCH		42
+#define IBCS2_ENOCSI		43
+#define IBCS2_EL2HLT		44
+#define IBCS2_EDEADLK		45
+#define IBCS2_ENOLCK		46
+#define IBCS2_ENOSTR		60
+#define IBCS2_ENODATA		61
+#define IBCS2_ETIME		62
+#define IBCS2_ENOSR		63
+#define IBCS2_ENONET		64
+#define IBCS2_ENOPKG		65
+#define IBCS2_EREMOTE		66
+#define IBCS2_ENOLINK		67
+#define IBCS2_EADV		68
+#define IBCS2_ESRMNT		69
+#define IBCS2_ECOMM		70
+#define IBCS2_EPROTO		71
+#define IBCS2_EMULTIHOP		74
+#define IBCS2_ELBIN		75
+#define IBCS2_EDOTDOT		76
+#define IBCS2_EBADMSG		77
+#define IBCS2_ENAMETOOLONG	78
+#define IBCS2_EOVERFLOW		79
+#define IBCS2_ENOTUNIQ		80
+#define IBCS2_EBADFD		81
+#define IBCS2_EREMCHG		82
+#define IBCS2_EILSEQ		88
+#define IBCS2_ENOSYS		89
+
+#if defined(_SCO_NET)			/* not strict iBCS2 */
+#define IBCS2_EWOULDBLOCK	90
+#define IBCS2_EINPROGRESS	91
+#define IBCS2_EALREADY		92
+#define IBCS2_ENOTSOCK		93
+#define IBCS2_EDESTADDRREQ	94
+#define IBCS2_EMSGSIZE		95
+#define IBCS2_EPROTOTYPE	96
+#define IBCS2_EPROTONOSUPPORT	97
+#define IBCS2_ESOCKTNOSUPPORT	98
+#define IBCS2_EOPNOTSUPP	99
+#define IBCS2_EPFNOSUPPORT	100
+#define IBCS2_EAFNOSUPPORT	101
+#define IBCS2_EADDRINUSE	102
+#define IBCS2_EADDRNOTAVAIL	103
+#define IBCS2_ENETDOWN		104
+#define IBCS2_ENETUNREACH	105
+#define IBCS2_ENETRESET		106
+#define IBCS2_ECONNABORTED	107
+#define IBCS2_ECONNRESET	108
+#define IBCS2_ENOBUFS		IBCS2_ENOSR
+#define IBCS2_EISCONN		110
+#define IBCS2_ENOTCONN		111
+#define IBCS2_ESHUTDOWN		112
+#define IBCS2_ETOOMANYREFS	113
+#define IBCS2_ETIMEDOUT		114
+#define IBCS2_ECONNREFUSED	115
+#define IBCS2_EHOSTDOWN		116
+#define IBCS2_EHOSTUNREACH	117
+#define IBCS2_ENOPROTOOPT	118
+#define IBCS2_ENOTEMPTY		145
+#define IBCS2_ELOOP		150
+#else
+#define IBCS2_ELOOP		90
+#define IBCS2_EWOULDBLOCK	90
+#define IBCS2_ERESTART		91
+#define IBCS2_ESTRPIPE		92
+#define IBCS2_ENOTEMPTY		93
+#define IBCS2_EUSERS		94
+#endif
+
+#define IBCS2_ESTALE		151
+#define IBCS2_EIORESID		500
+
+extern int bsd2ibcs_errno[];
+
+#endif /* _IBCS2_ERRNO_H */
diff --git a/sys/i386/ibcs2/ibcs2_fcntl.c b/sys/i386/ibcs2/ibcs2_fcntl.c
new file mode 100644
index 000000000000..4dede8c15b52
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_fcntl.c
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/mount.h>
+#include <sys/malloc.h>
+#include <sys/syscallargs.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_fcntl.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+#include <compat/ibcs2/ibcs2_util.h>
+
+
+static int
+cvt_o_flags(flags)
+	int flags;
+{
+	int r = 0;
+
+        /* convert mode into NetBSD mode */
+	if (flags & IBCS2_O_WRONLY) r |= O_WRONLY;
+	if (flags & IBCS2_O_RDWR) r |= O_RDWR;
+	if (flags & (IBCS2_O_NDELAY | IBCS2_O_NONBLOCK)) r |= O_NONBLOCK;
+	if (flags & IBCS2_O_APPEND) r |= O_APPEND;
+	if (flags & IBCS2_O_SYNC) r |= O_FSYNC;
+	if (flags & IBCS2_O_CREAT) r |= O_CREAT;
+	if (flags & IBCS2_O_TRUNC) r |= O_TRUNC;
+	if (flags & IBCS2_O_EXCL) r |= O_EXCL;
+	return r;
+}
+
+static void
+cvt_flock2iflock(flp, iflp)
+	struct flock *flp;
+	struct ibcs2_flock *iflp;
+{
+	switch (flp->l_type) {
+	case F_RDLCK:
+		iflp->l_type = IBCS2_F_RDLCK;
+		break;
+	case F_WRLCK:
+		iflp->l_type = IBCS2_F_WRLCK;
+		break;
+	case F_UNLCK:
+		iflp->l_type = IBCS2_F_UNLCK;
+		break;
+	}
+	iflp->l_whence = (short)flp->l_whence;
+	iflp->l_start = (ibcs2_off_t)flp->l_start;
+	iflp->l_len = (ibcs2_off_t)flp->l_len;
+	iflp->l_sysid = 0;
+	iflp->l_pid = (ibcs2_pid_t)flp->l_pid;
+}
+
+static void
+cvt_iflock2flock(iflp, flp)
+	struct ibcs2_flock *iflp;
+	struct flock *flp;
+{
+	flp->l_start = (off_t)iflp->l_start;
+	flp->l_len = (off_t)iflp->l_len;
+	flp->l_pid = (pid_t)iflp->l_pid;
+	switch (iflp->l_type) {
+	case IBCS2_F_RDLCK:
+		flp->l_type = F_RDLCK;
+		break;
+	case IBCS2_F_WRLCK:
+		flp->l_type = F_WRLCK;
+		break;
+	case IBCS2_F_UNLCK:
+		flp->l_type = F_UNLCK;
+		break;
+	}
+	flp->l_whence = iflp->l_whence;
+}
+
+/* convert iBCS2 mode into NetBSD mode */
+static int
+ioflags2oflags(flags)
+	int flags;
+{
+	int r = 0;
+	
+	if (flags & IBCS2_O_RDONLY) r |= O_RDONLY;
+	if (flags & IBCS2_O_WRONLY) r |= O_WRONLY;
+	if (flags & IBCS2_O_RDWR) r |= O_RDWR;
+	if (flags & IBCS2_O_NDELAY) r |= O_NONBLOCK;
+	if (flags & IBCS2_O_APPEND) r |= O_APPEND;
+	if (flags & IBCS2_O_SYNC) r |= O_FSYNC;
+	if (flags & IBCS2_O_NONBLOCK) r |= O_NONBLOCK;
+	if (flags & IBCS2_O_CREAT) r |= O_CREAT;
+	if (flags & IBCS2_O_TRUNC) r |= O_TRUNC;
+	if (flags & IBCS2_O_EXCL) r |= O_EXCL;
+	if (flags & IBCS2_O_NOCTTY) r |= O_NOCTTY;
+	return r;
+}
+
+/* convert NetBSD mode into iBCS2 mode */
+static int
+oflags2ioflags(flags)
+	int flags;
+{
+	int r = 0;
+	
+	if (flags & O_RDONLY) r |= IBCS2_O_RDONLY;
+	if (flags & O_WRONLY) r |= IBCS2_O_WRONLY;
+	if (flags & O_RDWR) r |= IBCS2_O_RDWR;
+	if (flags & O_NDELAY) r |= IBCS2_O_NONBLOCK;
+	if (flags & O_APPEND) r |= IBCS2_O_APPEND;
+	if (flags & O_FSYNC) r |= IBCS2_O_SYNC;
+	if (flags & O_NONBLOCK) r |= IBCS2_O_NONBLOCK;
+	if (flags & O_CREAT) r |= IBCS2_O_CREAT;
+	if (flags & O_TRUNC) r |= IBCS2_O_TRUNC;
+	if (flags & O_EXCL) r |= IBCS2_O_EXCL;
+	if (flags & O_NOCTTY) r |= IBCS2_O_NOCTTY;
+	return r;
+}
+
+int
+ibcs2_open(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_open_args *uap;
+	int *retval;
+{
+	int noctty = SCARG(uap, flags) & IBCS2_O_NOCTTY;
+	int ret;
+	caddr_t sg = stackgap_init();
+
+	SCARG(uap, flags) = cvt_o_flags(SCARG(uap, flags));
+	if (SCARG(uap, flags) & O_CREAT)
+		CHECKALTCREAT(p, &sg, SCARG(uap, path));
+	else
+		CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	ret = open(p, uap, retval);
+
+	if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
+		struct filedesc *fdp = p->p_fd;
+		struct file *fp = fdp->fd_ofiles[*retval];
+
+		/* ignore any error, just give it a try */
+		if (fp->f_type == DTYPE_VNODE)
+			(fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, (caddr_t) 0, p);
+	}
+	return ret;
+}
+
+int
+ibcs2_creat(p, uap, retval)
+        struct proc *p;  
+	struct ibcs2_creat_args *uap;
+	int *retval;
+{       
+	struct open_args cup;   
+	caddr_t sg = stackgap_init();
+
+	CHECKALTCREAT(p, &sg, SCARG(uap, path));
+	SCARG(&cup, path) = SCARG(uap, path);
+	SCARG(&cup, mode) = SCARG(uap, mode);
+	SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
+	return open(p, &cup, retval);
+}       
+
+int
+ibcs2_access(p, uap, retval)
+        struct proc *p;
+        struct ibcs2_access_args *uap;
+        int *retval;
+{
+        struct access_args cup;
+        caddr_t sg = stackgap_init();
+
+        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+        SCARG(&cup, path) = SCARG(uap, path);
+        SCARG(&cup, flags) = SCARG(uap, flags);
+        return access(p, &cup, retval);
+}
+
+int
+ibcs2_fcntl(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_fcntl_args *uap;
+	int *retval;
+{
+	int error;
+	struct fcntl_args fa;
+	struct flock *flp;
+	struct ibcs2_flock ifl;
+	
+	switch(SCARG(uap, cmd)) {
+	case IBCS2_F_DUPFD:
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_DUPFD;
+		SCARG(&fa, arg) = SCARG(uap, arg);
+		return fcntl(p, &fa, retval);
+	case IBCS2_F_GETFD:
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_GETFD;
+		SCARG(&fa, arg) = SCARG(uap, arg);
+		return fcntl(p, &fa, retval);
+	case IBCS2_F_SETFD:
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_SETFD;
+		SCARG(&fa, arg) = SCARG(uap, arg);
+		return fcntl(p, &fa, retval);
+	case IBCS2_F_GETFL:
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_GETFL;
+		SCARG(&fa, arg) = SCARG(uap, arg);
+		error = fcntl(p, &fa, retval);
+		if (error)
+			return error;
+		*retval = oflags2ioflags(*retval);
+		return error;
+	case IBCS2_F_SETFL:
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_SETFL;
+		SCARG(&fa, arg) = (void *)ioflags2oflags(SCARG(uap, arg));
+		return fcntl(p, &fa, retval);
+
+	case IBCS2_F_GETLK:
+	    {
+		caddr_t sg = stackgap_init();
+		flp = stackgap_alloc(&sg, sizeof(*flp));
+		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+			       ibcs2_flock_len);
+		if (error)
+			return error;
+		cvt_iflock2flock(&ifl, flp);
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_GETLK;
+		SCARG(&fa, arg) = (void *)flp;
+		error = fcntl(p, &fa, retval);
+		if (error)
+			return error;
+		cvt_flock2iflock(flp, &ifl);
+		return copyout((caddr_t)&ifl, (caddr_t)SCARG(uap, arg),
+			       ibcs2_flock_len);
+	    }
+
+	case IBCS2_F_SETLK:
+	    {
+		caddr_t sg = stackgap_init();
+		flp = stackgap_alloc(&sg, sizeof(*flp));
+		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+			       ibcs2_flock_len);
+		if (error)
+			return error;
+		cvt_iflock2flock(&ifl, flp);
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_SETLK;
+		SCARG(&fa, arg) = (void *)flp;
+		return fcntl(p, &fa, retval);
+	    }
+
+	case IBCS2_F_SETLKW:
+	    {
+		caddr_t sg = stackgap_init();
+		flp = stackgap_alloc(&sg, sizeof(*flp));
+		error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
+			       ibcs2_flock_len);
+		if (error)
+			return error;
+		cvt_iflock2flock(&ifl, flp);
+		SCARG(&fa, fd) = SCARG(uap, fd);
+		SCARG(&fa, cmd) = F_SETLKW;
+		SCARG(&fa, arg) = (void *)flp;
+		return fcntl(p, &fa, retval);
+	    }
+	}
+	return ENOSYS;
+}
diff --git a/sys/i386/ibcs2/ibcs2_fcntl.h b/sys/i386/ibcs2/ibcs2_fcntl.h
new file mode 100644
index 000000000000..b75537cb66f5
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_fcntl.h
@@ -0,0 +1,76 @@
+/*	$NetBSD: ibcs2_fcntl.h,v 1.2 1994/10/26 02:52:54 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _IBCS2_FCNTL_H
+#define _IBCS2_FCNTL_H 1
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+#define IBCS2_O_RDONLY		0x0000
+#define IBCS2_O_WRONLY		0x0001
+#define IBCS2_O_RDWR		0x0002
+#define IBCS2_O_NDELAY		0x0004
+#define IBCS2_O_APPEND		0x0008
+#define IBCS2_O_SYNC		0x0010
+#define IBCS2_O_NONBLOCK	0x0080
+#define IBCS2_O_CREAT		0x0100
+#define IBCS2_O_TRUNC		0x0200
+#define IBCS2_O_EXCL		0x0400
+#define IBCS2_O_NOCTTY		0x0800
+
+#define IBCS2_F_DUPFD         0
+#define IBCS2_F_GETFD         1
+#define IBCS2_F_SETFD         2
+#define IBCS2_F_GETFL         3
+#define IBCS2_F_SETFL         4
+#define IBCS2_F_GETLK         5
+#define IBCS2_F_SETLK         6
+#define IBCS2_F_SETLKW        7
+
+struct ibcs2_flock {
+        short   	l_type;
+        short   	l_whence;
+        ibcs2_off_t	l_start;
+        ibcs2_off_t	l_len;
+        short   	l_sysid;
+        ibcs2_pid_t	l_pid;
+};
+#define ibcs2_flock_len	(sizeof(struct ibcs2_flock))
+
+#define IBCS2_F_RDLCK		1
+#define IBCS2_F_WRLCK		2
+#define IBCS2_F_UNLCK		3
+
+#define IBCS2_O_ACCMODE		3
+#define IBCS2_FD_CLOEXEC	1
+
+#endif /* _IBCS2_FCNTL_H */
diff --git a/sys/i386/ibcs2/ibcs2_ioctl.c b/sys/i386/ibcs2/ibcs2_ioctl.c
new file mode 100644
index 000000000000..9b45f50527cc
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_ioctl.c
@@ -0,0 +1,487 @@
+/*	$NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $	*/
+
+/*
+ * Copyright (c) 1994, 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * based on compat/sunos/sun_ioctl.c
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/dir.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/reboot.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+#include <sys/signal.h>
+#include <sys/signalvar.h>
+#include <sys/socket.h>
+#include <sys/termios.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/tty.h>
+#include <sys/vnode.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <sys/utsname.h>
+#include <sys/unistd.h>
+
+#include <net/if.h>
+#include <sys/syscallargs.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_socksys.h>
+#include <compat/ibcs2/ibcs2_stropts.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+#include <compat/ibcs2/ibcs2_termios.h>
+#include <compat/ibcs2/ibcs2_util.h>
+
+/*
+ * iBCS2 ioctl calls.
+ */
+
+static struct speedtab sptab[] = {
+	{ 0, 0 },
+	{ 50, 1 },
+	{ 75, 2 },
+	{ 110, 3 },
+	{ 134, 4 },
+	{ 135, 4 },
+	{ 150, 5 },
+	{ 200, 6 },
+	{ 300, 7 },
+	{ 600, 8 },
+	{ 1200, 9 },
+	{ 1800, 10 },
+	{ 2400, 11 },
+	{ 4800, 12 },
+	{ 9600, 13 },
+	{ 19200, 14 },
+	{ 38400, 15 },
+	{ -1, -1 }
+};
+
+static u_long s2btab[] = { 
+	0,
+	50,
+	75,
+	110,
+	134,
+	150,
+	200,
+	300,
+	600,
+	1200,
+	1800,
+	2400,
+	4800,
+	9600,
+	19200,
+	38400,
+};
+
+static void
+stios2btios(st, bt)
+	struct ibcs2_termios *st;
+	struct termios *bt;
+{
+	register u_long l, r;
+
+	l = st->c_iflag;	r = 0;
+	if (l & IBCS2_IGNBRK)	r |= IGNBRK;
+	if (l & IBCS2_BRKINT)	r |= BRKINT;
+	if (l & IBCS2_IGNPAR)	r |= IGNPAR;
+	if (l & IBCS2_PARMRK)	r |= PARMRK;
+	if (l & IBCS2_INPCK)	r |= INPCK;
+	if (l & IBCS2_ISTRIP)	r |= ISTRIP;
+	if (l & IBCS2_INLCR)	r |= INLCR;
+	if (l & IBCS2_IGNCR)	r |= IGNCR;
+	if (l & IBCS2_ICRNL)	r |= ICRNL;
+	if (l & IBCS2_IXON)	r |= IXON;
+	if (l & IBCS2_IXANY)	r |= IXANY;
+	if (l & IBCS2_IXOFF)	r |= IXOFF;
+	if (l & IBCS2_IMAXBEL)	r |= IMAXBEL;
+	bt->c_iflag = r;
+
+	l = st->c_oflag;	r = 0;
+	if (l & IBCS2_OPOST)	r |= OPOST;
+	if (l & IBCS2_ONLCR)	r |= ONLCR;
+	if (l & IBCS2_TAB3)	r |= OXTABS;
+	bt->c_oflag = r;
+
+	l = st->c_cflag;	r = 0;
+	switch (l & IBCS2_CSIZE) {
+	case IBCS2_CS5:		r |= CS5; break;
+	case IBCS2_CS6:		r |= CS6; break;
+	case IBCS2_CS7:		r |= CS7; break;
+	case IBCS2_CS8:		r |= CS8; break;
+	}
+	if (l & IBCS2_CSTOPB)	r |= CSTOPB;
+	if (l & IBCS2_CREAD)	r |= CREAD;
+	if (l & IBCS2_PARENB)	r |= PARENB;
+	if (l & IBCS2_PARODD)	r |= PARODD;
+	if (l & IBCS2_HUPCL)	r |= HUPCL;
+	if (l & IBCS2_CLOCAL)	r |= CLOCAL;
+	bt->c_cflag = r;
+
+	l = st->c_lflag;	r = 0;
+	if (l & IBCS2_ISIG)	r |= ISIG;
+	if (l & IBCS2_ICANON)	r |= ICANON;
+	if (l & IBCS2_ECHO)	r |= ECHO;
+	if (l & IBCS2_ECHOE)	r |= ECHOE;
+	if (l & IBCS2_ECHOK)	r |= ECHOK;
+	if (l & IBCS2_ECHONL)	r |= ECHONL;
+	if (l & IBCS2_NOFLSH)	r |= NOFLSH;
+	if (l & IBCS2_TOSTOP)	r |= TOSTOP;
+	bt->c_lflag = r;
+
+	bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
+
+	bt->c_cc[VINTR]	=
+	    st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
+	bt->c_cc[VQUIT] =
+	    st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
+	bt->c_cc[VERASE] =
+	    st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
+	bt->c_cc[VKILL] =
+	    st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
+	bt->c_cc[VEOF] =
+	    st->c_cc[IBCS2_VEOF]   ? st->c_cc[IBCS2_VEOF]   : _POSIX_VDISABLE;
+	bt->c_cc[VEOL] =
+	    st->c_cc[IBCS2_VEOL]   ? st->c_cc[IBCS2_VEOL]   : _POSIX_VDISABLE;
+	bt->c_cc[VEOL2] =
+	    st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
+#if 0
+	bt->c_cc[VSWTCH] =
+	    st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
+#endif
+	bt->c_cc[VSTART] =
+	    st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
+	bt->c_cc[VSTOP] =
+	    st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
+	bt->c_cc[VSUSP] =
+	    st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
+	bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
+	bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
+	bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
+	bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
+	bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
+	bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
+}
+
+static void
+btios2stios(bt, st)
+	struct termios *bt;
+	struct ibcs2_termios *st;
+{
+	register u_long l, r;
+
+	l = bt->c_iflag;	r = 0;
+	if (l & IGNBRK)		r |= IBCS2_IGNBRK;
+	if (l & BRKINT)		r |= IBCS2_BRKINT;
+	if (l & IGNPAR)		r |= IBCS2_IGNPAR;
+	if (l & PARMRK)		r |= IBCS2_PARMRK;
+	if (l & INPCK)		r |= IBCS2_INPCK;
+	if (l & ISTRIP)		r |= IBCS2_ISTRIP;
+	if (l & INLCR)		r |= IBCS2_INLCR;
+	if (l & IGNCR)		r |= IBCS2_IGNCR;
+	if (l & ICRNL)		r |= IBCS2_ICRNL;
+	if (l & IXON)		r |= IBCS2_IXON;
+	if (l & IXANY)		r |= IBCS2_IXANY;
+	if (l & IXOFF)		r |= IBCS2_IXOFF;
+	if (l & IMAXBEL)	r |= IBCS2_IMAXBEL;
+	st->c_iflag = r;
+
+	l = bt->c_oflag;	r = 0;
+	if (l & OPOST)		r |= IBCS2_OPOST;
+	if (l & ONLCR)		r |= IBCS2_ONLCR;
+	if (l & OXTABS)		r |= IBCS2_TAB3;
+	st->c_oflag = r;
+
+	l = bt->c_cflag;	r = 0;
+	switch (l & CSIZE) {
+	case CS5:		r |= IBCS2_CS5; break;
+	case CS6:		r |= IBCS2_CS6; break;
+	case CS7:		r |= IBCS2_CS7; break;
+	case CS8:		r |= IBCS2_CS8; break;
+	}
+	if (l & CSTOPB)		r |= IBCS2_CSTOPB;
+	if (l & CREAD)		r |= IBCS2_CREAD;
+	if (l & PARENB)		r |= IBCS2_PARENB;
+	if (l & PARODD)		r |= IBCS2_PARODD;
+	if (l & HUPCL)		r |= IBCS2_HUPCL;
+	if (l & CLOCAL)		r |= IBCS2_CLOCAL;
+	st->c_cflag = r;
+
+	l = bt->c_lflag;	r = 0;
+	if (l & ISIG)		r |= IBCS2_ISIG;
+	if (l & ICANON)		r |= IBCS2_ICANON;
+	if (l & ECHO)		r |= IBCS2_ECHO;
+	if (l & ECHOE)		r |= IBCS2_ECHOE;
+	if (l & ECHOK)		r |= IBCS2_ECHOK;
+	if (l & ECHONL)		r |= IBCS2_ECHONL;
+	if (l & NOFLSH)		r |= IBCS2_NOFLSH;
+	if (l & TOSTOP)		r |= IBCS2_TOSTOP;
+	st->c_lflag = r;
+
+	l = ttspeedtab(bt->c_ospeed, sptab);
+	if (l >= 0)
+		st->c_cflag |= l;
+
+	st->c_cc[IBCS2_VINTR] =
+	    bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
+	st->c_cc[IBCS2_VQUIT] =
+	    bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
+	st->c_cc[IBCS2_VERASE] =
+	    bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
+	st->c_cc[IBCS2_VKILL] =
+	    bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
+	st->c_cc[IBCS2_VEOF] =
+	    bt->c_cc[VEOF]   != _POSIX_VDISABLE ? bt->c_cc[VEOF]   : 0;
+	st->c_cc[IBCS2_VEOL] =
+	    bt->c_cc[VEOL]   != _POSIX_VDISABLE ? bt->c_cc[VEOL]   : 0;
+	st->c_cc[IBCS2_VEOL2] =
+	    bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
+	st->c_cc[IBCS2_VSWTCH] =
+	    0;
+	st->c_cc[IBCS2_VSUSP] =
+	    bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
+	st->c_cc[IBCS2_VSTART] =
+	    bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
+	st->c_cc[IBCS2_VSTOP] =
+	    bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
+
+	st->c_line = 0;
+}
+
+static void
+stios2stio(ts, t)
+	struct ibcs2_termios *ts;
+	struct ibcs2_termio *t;
+{
+	t->c_iflag = ts->c_iflag;
+	t->c_oflag = ts->c_oflag;
+	t->c_cflag = ts->c_cflag;
+	t->c_lflag = ts->c_lflag;
+	t->c_line  = ts->c_line;
+	bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
+}
+
+static void
+stio2stios(t, ts)
+	struct ibcs2_termio *t;
+	struct ibcs2_termios *ts;
+{
+	ts->c_iflag = t->c_iflag;
+	ts->c_oflag = t->c_oflag;
+	ts->c_cflag = t->c_cflag;
+	ts->c_lflag = t->c_lflag;
+	ts->c_line  = t->c_line;
+	bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
+}
+
+int
+ibcs2_ioctl(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_ioctl_args *uap;
+	int *retval;
+{
+	struct filedesc *fdp = p->p_fd;
+	struct file *fp;
+	int (*ctl)();
+	int error;
+
+	if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
+	    (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
+		DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
+			 SCARG(uap, fd)));
+		return EBADF;
+	}
+
+	if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
+		DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
+		return EBADF;
+	}
+
+	ctl = fp->f_ops->fo_ioctl;
+
+	switch (SCARG(uap, cmd)) {
+	case IBCS2_TCGETA:
+	case IBCS2_XCGETA:
+	case IBCS2_OXCGETA:
+	    {
+		struct termios bts;
+		struct ibcs2_termios sts;
+		struct ibcs2_termio st;
+	
+		if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0)
+			return error;
+	
+		btios2stios (&bts, &sts);
+		if (SCARG(uap, cmd) == IBCS2_TCGETA) {
+			stios2stio (&sts, &st);
+			error = copyout((caddr_t)&st, SCARG(uap, data),
+					sizeof (st));
+			if (error)
+				DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
+					 p->p_pid));
+			return error;
+		} else
+			return copyout((caddr_t)&sts, SCARG(uap, data),
+					sizeof (sts));
+		/*NOTREACHED*/
+	    }
+
+	case IBCS2_TCSETA:
+	case IBCS2_TCSETAW:
+	case IBCS2_TCSETAF:
+	    {
+		struct termios bts;
+		struct ibcs2_termios sts;
+		struct ibcs2_termio st;
+
+		if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
+				    sizeof(st))) != 0) {
+			DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
+				 p->p_pid));
+			return error;
+		}
+
+		/* get full BSD termios so we don't lose information */
+		if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) {
+			DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
+				 p->p_pid, SCARG(uap, fd)));
+			return error;
+		}
+
+		/*
+		 * convert to iBCS2 termios, copy in information from
+		 * termio, and convert back, then set new values.
+		 */
+		btios2stios(&bts, &sts);
+		stio2stios(&st, &sts);
+		stios2btios(&sts, &bts);
+
+		return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
+			      (caddr_t)&bts, p);
+	    }
+
+	case IBCS2_XCSETA:
+	case IBCS2_XCSETAW:
+	case IBCS2_XCSETAF:
+	    {
+		struct termios bts;
+		struct ibcs2_termios sts;
+
+		if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
+				    sizeof (sts))) != 0) {
+			return error;
+		}
+		stios2btios (&sts, &bts);
+		return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
+			      (caddr_t)&bts, p);
+	    }
+
+	case IBCS2_OXCSETA:
+	case IBCS2_OXCSETAW:
+	case IBCS2_OXCSETAF:
+	    {
+		struct termios bts;
+		struct ibcs2_termios sts;
+
+		if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
+				    sizeof (sts))) != 0) {
+			return error;
+		}
+		stios2btios (&sts, &bts);
+		return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
+			      (caddr_t)&bts, p);
+	    }
+
+	case IBCS2_TCSBRK:
+		DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
+		return ENOSYS;
+
+	case IBCS2_TCXONC:
+		DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
+		return ENOSYS;
+
+	case IBCS2_TCFLSH:
+		DPRINTF(("ibcs2_ioctl(%d): TCFLSH ", p->p_pid));
+		return ENOSYS;
+
+	case IBCS2_TIOCGWINSZ:
+		SCARG(uap, cmd) = TIOCGWINSZ;
+		return ioctl(p, uap, retval);
+
+	case IBCS2_TIOCSWINSZ:
+		SCARG(uap, cmd) = TIOCSWINSZ;
+		return ioctl(p, uap, retval);
+
+	case IBCS2_TIOCGPGRP:
+		return copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
+				sizeof(p->p_pgrp->pg_id));
+
+	case IBCS2_TIOCSPGRP:	/* XXX - is uap->data a pointer to pgid? */
+	    {
+		struct setpgid_args sa;
+
+		SCARG(&sa, pid) = 0;
+		SCARG(&sa, pgid) = (int)SCARG(uap, data);
+		if (error = setpgid(p, &sa, retval))
+			return error;
+		return 0;
+	    }
+
+	case IBCS2_TCGETSC:	/* SCO console - get scancode flags */
+		return ENOSYS;
+
+	case IBCS2_TCSETSC:	/* SCO console - set scancode flags */
+		return ENOSYS;
+
+	case IBCS2_SIOCSOCKSYS:
+		return ibcs2_socksys(p, uap, retval);
+
+	case IBCS2_I_NREAD:     /* STREAMS */
+	        SCARG(uap, cmd) = FIONREAD;
+		return ioctl(p, uap, retval);
+
+	default:
+		DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
+			 p->p_pid, SCARG(uap, cmd)));
+		return ENOSYS;
+	}
+	return ENOSYS;
+}
+
diff --git a/sys/i386/ibcs2/ibcs2_ipc.c b/sys/i386/ibcs2/ibcs2_ipc.c
new file mode 100644
index 000000000000..6dc171417d8f
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_ipc.c
@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/ipc.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/reboot.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+#include <sys/signal.h>
+#include <sys/signalvar.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/vnode.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <sys/utsname.h>
+#include <sys/unistd.h>
+#include <sys/msg.h>
+#include <sys/sem.h>
+#include <sys/shm.h>
+#include <sys/syscallargs.h>
+
+#include <vm/vm.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+#include <compat/ibcs2/ibcs2_util.h>
+
+#define IBCS2_IPC_RMID	0
+#define IBCS2_IPC_SET	1
+#define IBCS2_IPC_STAT	2
+
+/*
+ * iBCS2 msgsys call
+ */
+
+struct ibcs2_msqid_ds {
+	struct ipc_perm msg_perm;
+	struct msg *msg_first;
+	struct msg *msg_last;
+	u_short msg_cbytes;
+	u_short msg_qnum;
+	u_short msg_qbytes;
+	u_short msg_lspid;
+	u_short msg_lrpid;
+	ibcs2_time_t msg_stime;
+	ibcs2_time_t msg_rtime;
+	ibcs2_time_t msg_ctime;
+};
+
+static void
+cvt_msqid2imsqid(bp, ibp)
+struct msqid_ds *bp;
+struct ibcs2_msqid_ds *ibp;
+{
+	ibp->msg_perm = bp->msg_perm;
+	ibp->msg_first = bp->msg_first;
+	ibp->msg_last = bp->msg_last;
+	ibp->msg_cbytes = (u_short)bp->msg_cbytes;
+	ibp->msg_qnum = (u_short)bp->msg_qnum;
+	ibp->msg_qbytes = (u_short)bp->msg_qbytes;
+	ibp->msg_lspid = (u_short)bp->msg_lspid;
+	ibp->msg_lrpid = (u_short)bp->msg_lrpid;
+	ibp->msg_stime = bp->msg_stime;
+	ibp->msg_rtime = bp->msg_rtime;
+	ibp->msg_ctime = bp->msg_ctime;
+	return;
+}
+
+static void
+cvt_imsqid2msqid(ibp, bp)
+struct ibcs2_msqid_ds *ibp;
+struct msqid_ds *bp;
+{
+	bp->msg_perm = ibp->msg_perm;
+	bp->msg_first = ibp->msg_first;
+	bp->msg_last = ibp->msg_last;
+	bp->msg_cbytes = ibp->msg_cbytes;
+	bp->msg_qnum = ibp->msg_qnum;
+	bp->msg_qbytes = ibp->msg_qbytes;
+	bp->msg_lspid = ibp->msg_lspid;
+	bp->msg_lrpid = ibp->msg_lrpid;
+	bp->msg_stime = ibp->msg_stime;
+	bp->msg_rtime = ibp->msg_rtime;
+	bp->msg_ctime = ibp->msg_ctime;
+	return;
+}
+
+int
+ibcs2_msgsys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_msgsys_args *uap;
+	int *retval;
+{
+	switch (SCARG(uap, which)) {
+	case 0:				/* msgget */
+		SCARG(uap, which) = 1;
+		return compat_10_msgsys(p, uap, retval);
+	case 1: {			/* msgctl */
+		int error;
+		struct compat_10_msgsys_args margs;
+		caddr_t sg = stackgap_init();
+
+		SCARG(&margs, which) = 0;
+		SCARG(&margs, a2) = SCARG(uap, a2);
+		SCARG(&margs, a4) =
+		    (int)stackgap_alloc(&sg, sizeof(struct msqid_ds));
+		SCARG(&margs, a3) = SCARG(uap, a3);
+		switch (SCARG(&margs, a3)) {
+		case IBCS2_IPC_STAT:
+			error = compat_10_msgsys(p, &margs, retval);
+			if (!error)
+				cvt_msqid2imsqid(SCARG(&margs, a4),
+				    (struct ibcs2_msqid_ds *)SCARG(uap, a4));
+			return error;
+		case IBCS2_IPC_SET:
+			cvt_imsqid2msqid((struct ibcs2_msqid_ds *)SCARG(uap,
+									a4),
+					 SCARG(&margs, a4));
+			return compat_10_msgsys(p, &margs, retval);
+		case IBCS2_IPC_RMID:
+			return compat_10_msgsys(p, &margs, retval);
+		}
+		return EINVAL;
+	}
+	case 2:				/* msgrcv */
+		SCARG(uap, which) = 3;
+		return compat_10_msgsys(p, uap, retval);
+	case 3:				/* msgsnd */
+		SCARG(uap, which) = 2;
+		return compat_10_msgsys(p, uap, retval);
+	default:
+		return EINVAL;
+	}
+}
+
+
+/*
+ * iBCS2 semsys call
+ */
+
+struct ibcs2_semid_ds {
+        struct ipc_perm sem_perm;
+	struct ibcs2_sem *sem_base;
+	u_short sem_nsems;
+	int pad1;
+	ibcs2_time_t sem_otime;
+	ibcs2_time_t sem_ctime;
+};
+
+struct ibcs2_sem {
+        u_short semval;
+	ibcs2_pid_t sempid;
+	u_short semncnt;
+	u_short semzcnt;
+};
+
+static void
+cvt_sem2isem(bp, ibp)
+struct sem *bp;
+struct ibcs2_sem *ibp;
+{
+	ibp->semval = bp->semval;
+	ibp->sempid = bp->sempid;
+	ibp->semncnt = bp->semncnt;
+	ibp->semzcnt = bp->semzcnt;
+	return;
+}
+
+static void
+cvt_isem2sem(ibp, bp)
+struct ibcs2_sem *ibp;
+struct sem *bp;
+{
+	bp->semval = ibp->semval;
+	bp->sempid = ibp->sempid;
+	bp->semncnt = ibp->semncnt;
+	bp->semzcnt = ibp->semzcnt;
+	return;
+}
+
+static void
+cvt_semid2isemid(bp, ibp)
+struct semid_ds *bp;
+struct ibcs2_semid_ds *ibp;
+{
+	ibp->sem_perm = bp->sem_perm;
+	ibp->sem_base = (struct ibcs2_sem *)bp->sem_base;
+	ibp->sem_nsems = bp->sem_nsems;
+	ibp->sem_otime = bp->sem_otime;
+	ibp->sem_ctime = bp->sem_ctime;
+	return;
+}
+
+static void
+cvt_isemid2semid(ibp, bp)
+struct ibcs2_semid_ds *ibp;
+struct semid_ds *bp;
+{
+	bp->sem_perm = ibp->sem_perm;
+	bp->sem_base = (struct sem *)ibp->sem_base;
+	bp->sem_nsems = ibp->sem_nsems;
+	bp->sem_otime = ibp->sem_otime;
+	bp->sem_ctime = ibp->sem_ctime;
+	return;
+}
+
+int
+ibcs2_semsys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_semsys_args *uap;
+	int *retval;
+{
+	int error;
+
+	switch (SCARG(uap, which)) {
+	case 0:					/* semctl */
+		switch(SCARG(uap, a4)) {
+		case IBCS2_IPC_STAT:
+		    {
+			struct ibcs2_semid_ds *isp;
+			struct semid_ds *sp;
+			caddr_t sg = stackgap_init();
+
+			isp = (struct ibcs2_semid_ds *)SCARG(uap, a5);
+			sp = stackgap_alloc(&sg, sizeof(struct semid_ds));
+			SCARG(uap, a5) = (int)sp;
+			error = compat_10_semsys(p, uap, retval);
+			if (!error) {
+				SCARG(uap, a5) = (int)isp;
+				isp = stackgap_alloc(&sg, sizeof(*isp));
+				cvt_semid2isemid(sp, isp);
+				error = copyout((caddr_t)isp,
+						(caddr_t)SCARG(uap, a5),
+						sizeof(*isp));
+			}
+			return error;
+		    }
+		case IBCS2_IPC_SET:
+		    {
+			struct ibcs2_semid_ds *isp;
+			struct semid_ds *sp;
+			caddr_t sg = stackgap_init();
+
+			isp = stackgap_alloc(&sg, sizeof(*isp));
+			sp = stackgap_alloc(&sg, sizeof(*sp));
+			error = copyin((caddr_t)SCARG(uap, a5), (caddr_t)isp,
+				       sizeof(*isp));
+			if (error)
+				return error;
+			cvt_isemid2semid(isp, sp);
+			SCARG(uap, a5) = (int)sp;
+			return compat_10_semsys(p, uap, retval);
+		    }
+		}
+		return compat_10_semsys(p, uap, retval);
+
+	case 1:				/* semget */
+		return compat_10_semsys(p, uap, retval);
+
+	case 2:				/* semop */
+		return compat_10_semsys(p, uap, retval);
+	}
+	return EINVAL;
+}
+
+
+/*
+ * iBCS2 shmsys call
+ */
+
+struct ibcs2_shmid_ds {
+        struct ipc_perm shm_perm;
+	int shm_segsz;
+	int pad1;
+	char pad2[4];
+	u_short shm_lpid;
+	u_short shm_cpid;
+	u_short shm_nattch;
+	u_short shm_cnattch;
+	ibcs2_time_t shm_atime;
+	ibcs2_time_t shm_dtime;
+	ibcs2_time_t shm_ctime;
+};
+
+static void
+cvt_shmid2ishmid(bp, ibp)
+struct shmid_ds *bp;
+struct ibcs2_shmid_ds *ibp;
+{
+	ibp->shm_perm = bp->shm_perm;
+	ibp->shm_segsz = bp->shm_segsz;
+	ibp->shm_lpid = bp->shm_lpid;
+	ibp->shm_cpid = bp->shm_cpid;
+	ibp->shm_nattch = bp->shm_nattch;
+	ibp->shm_cnattch = 0;			/* ignored anyway */
+	ibp->shm_atime = bp->shm_atime;
+	ibp->shm_dtime = bp->shm_dtime;
+	ibp->shm_ctime = bp->shm_ctime;
+	return;
+}
+
+static void
+cvt_ishmid2shmid(ibp, bp)
+struct ibcs2_shmid_ds *ibp;
+struct shmid_ds *bp;
+{
+	bp->shm_perm = ibp->shm_perm;
+	bp->shm_segsz = ibp->shm_segsz;
+	bp->shm_lpid = ibp->shm_lpid;
+	bp->shm_cpid = ibp->shm_cpid;
+	bp->shm_nattch = ibp->shm_nattch;
+	bp->shm_atime = ibp->shm_atime;
+	bp->shm_dtime = ibp->shm_dtime;
+	bp->shm_ctime = ibp->shm_ctime;
+	bp->shm_internal = (void *)0;		/* ignored anyway */
+	return;
+}
+
+int
+ibcs2_shmsys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_shmsys_args *uap;
+	int *retval;
+{
+	int error;
+
+	switch (SCARG(uap, which)) {
+	case 0:						/* shmat */
+		return compat_10_shmsys(p, uap, retval);
+
+	case 1:						/* shmctl */
+		switch(SCARG(uap, a3)) {
+		case IBCS2_IPC_STAT:
+		    {
+			struct ibcs2_shmid_ds *isp;
+			struct shmid_ds *sp;
+			caddr_t sg = stackgap_init();
+
+			isp = (struct ibcs2_shmid_ds *)SCARG(uap, a4);
+			sp = stackgap_alloc(&sg, sizeof(*sp));
+			SCARG(uap, a4) = (int)sp;
+			error = compat_10_shmsys(p, uap, retval);
+			if (!error) {
+				SCARG(uap, a4) = (int)isp;
+				isp = stackgap_alloc(&sg, sizeof(*isp));
+				cvt_shmid2ishmid(sp, isp);
+				error = copyout((caddr_t)isp,
+						(caddr_t)SCARG(uap, a4),
+						sizeof(*isp));
+			}
+			return error;
+		    }
+		case IBCS2_IPC_SET:
+		    {
+			struct ibcs2_shmid_ds *isp;
+			struct shmid_ds *sp;
+			caddr_t sg = stackgap_init();
+
+			isp = stackgap_alloc(&sg, sizeof(*isp));
+			sp = stackgap_alloc(&sg, sizeof(*sp));
+			error = copyin((caddr_t)SCARG(uap, a4), (caddr_t)isp,
+				       sizeof(*isp));
+			if (error)
+				return error;
+			cvt_ishmid2shmid(isp, sp);
+			SCARG(uap, a4) = (int)sp;
+			return compat_10_shmsys(p, uap, retval);
+		    }
+		}
+		return compat_10_shmsys(p, uap, retval);
+
+	case 2:						/* shmdt */
+		return compat_10_shmsys(p, uap, retval);
+
+	case 3:						/* shmget */
+		return compat_10_shmsys(p, uap, retval);
+	}
+	return EINVAL;
+}
diff --git a/sys/i386/ibcs2/ibcs2_misc.c b/sys/i386/ibcs2/ibcs2_misc.c
new file mode 100644
index 000000000000..cc1da262bbc0
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_misc.c
@@ -0,0 +1,1200 @@
+/*	$NetBSD: ibcs2_misc.c,v 1.6 1995/05/01 19:33:17 mycroft Exp $	*/
+
+/*
+ * Copyright (c) 1994, 1995 Scott Bartram
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Lawrence Berkeley Laboratory.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp 
+ *
+ *	@(#)sun_misc.c	8.1 (Berkeley) 6/18/93
+ */
+
+/*
+ * IBCS2 compatibility module.
+ *
+ * IBCS2 system calls that are implemented differently in BSD are
+ * handled here.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/reboot.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/vnode.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <sys/utsname.h>
+#include <sys/unistd.h>
+
+#include <ufs/ufs/dir.h>
+
+#include <netinet/in.h>
+#include <sys/syscallargs.h>
+
+#include <miscfs/specfs/specdev.h>
+
+#include <vm/vm.h>
+#include <sys/sysctl.h>		/* must be included after vm.h */
+
+#include <i386/include/reg.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_dirent.h>
+#include <compat/ibcs2/ibcs2_fcntl.h>
+#include <compat/ibcs2/ibcs2_time.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_timeb.h>
+#include <compat/ibcs2/ibcs2_unistd.h>
+#include <compat/ibcs2/ibcs2_utsname.h>
+#include <compat/ibcs2/ibcs2_util.h>
+#include <compat/ibcs2/ibcs2_utime.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+
+
+int
+ibcs2_ulimit(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_ulimit_args *uap;
+	int *retval;
+{
+	int error;
+	struct rlimit rl;
+	struct setrlimit_args {
+		int resource;
+		struct rlimit *rlp;
+	} sra;
+#define IBCS2_GETFSIZE		1
+#define IBCS2_SETFSIZE		2
+#define IBCS2_GETPSIZE		3
+#define IBCS2_GETDTABLESIZE	4
+	
+	switch (SCARG(uap, cmd)) {
+	case IBCS2_GETFSIZE:
+		*retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+		return 0;
+	case IBCS2_SETFSIZE:	/* XXX - fix this */
+#ifdef notyet
+		rl.rlim_cur = SCARG(uap, newlimit);
+		sra.resource = RLIMIT_FSIZE;
+		sra.rlp = &rl;
+		error = setrlimit(p, &sra, retval);
+		if (!error)
+			*retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+		else
+			DPRINTF(("failed "));
+		return error;
+#else
+		*retval = SCARG(uap, newlimit);
+		return 0;
+#endif
+	case IBCS2_GETPSIZE:
+		*retval = p->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */
+		return 0;
+	case IBCS2_GETDTABLESIZE:
+		uap->cmd = IBCS2_SC_OPEN_MAX;
+		return ibcs2_sysconf(p, uap, retval);
+	default:
+		return ENOSYS;
+	}
+}
+
+int
+ibcs2_waitsys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_waitsys_args *uap;
+	int *retval;
+{
+	int error, status;
+	struct wait4_args w4;
+#define WAITPID_EFLAGS	0x8c4	/* OF, SF, ZF, PF */
+	
+	SCARG(&w4, rusage) = NULL;
+	if ((p->p_md.md_regs->tf_eflags & WAITPID_EFLAGS) == WAITPID_EFLAGS) {
+		/* waitpid */
+		SCARG(&w4, pid) = SCARG(uap, a1);
+		SCARG(&w4, status) = (int *)SCARG(uap, a2);
+		SCARG(&w4, options) = SCARG(uap, a3);
+	} else {
+		/* wait */
+		SCARG(&w4, pid) = WAIT_ANY;
+		SCARG(&w4, status) = (int *)SCARG(uap, a1);
+		SCARG(&w4, options) = 0;
+	}
+	if ((error = wait4(p, &w4, retval)) != 0)
+		return error;
+	if (SCARG(&w4, status))		/* this is real iBCS brain-damage */
+		return copyin((caddr_t)SCARG(&w4, status), (caddr_t)&retval[1],
+			      sizeof(SCARG(&w4, status)));
+	return 0;
+}
+
+int
+ibcs2_execv(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_execv_args *uap;
+	int *retval;
+{
+	struct execve_args ea;
+	caddr_t sg = stackgap_init();
+
+        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	SCARG(&ea, path) = SCARG(uap, path);
+	SCARG(&ea, argp) = SCARG(uap, argp);
+	SCARG(&ea, envp) = NULL;
+	return execve(p, &ea, retval);
+}
+
+int
+ibcs2_execve(p, uap, retval) 
+        struct proc *p;
+        struct execve_args *uap;
+        int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+        return execve(p, uap, retval);
+}
+
+int
+ibcs2_umount(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_umount_args *uap;
+	int *retval;
+{
+	struct unmount_args um;
+
+	SCARG(&um, path) = SCARG(uap, name);
+	SCARG(&um, flags) = 0;
+	return unmount(p, &um, retval);
+}
+
+int
+ibcs2_mount(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_mount_args *uap;
+	int *retval;
+{
+#ifdef notyet
+	int oflags = SCARG(uap, flags), nflags, error;
+	char fsname[MFSNAMELEN];
+
+	if (oflags & (IBCS2_MS_NOSUB | IBCS2_MS_SYS5))
+		return (EINVAL);
+	if ((oflags & IBCS2_MS_NEWTYPE) == 0)
+		return (EINVAL);
+	nflags = 0;
+	if (oflags & IBCS2_MS_RDONLY)
+		nflags |= MNT_RDONLY;
+	if (oflags & IBCS2_MS_NOSUID)
+		nflags |= MNT_NOSUID;
+	if (oflags & IBCS2_MS_REMOUNT)
+		nflags |= MNT_UPDATE;
+	SCARG(uap, flags) = nflags;
+
+	if (error = copyinstr((caddr_t)SCARG(uap, type), fsname, sizeof fsname,
+			      (u_int *)0))
+		return (error);
+
+	if (strcmp(fsname, "4.2") == 0) {
+		SCARG(uap, type) = (caddr_t)STACK_ALLOC();
+		if (error = copyout("ufs", SCARG(uap, type), sizeof("ufs")))
+			return (error);
+	} else if (strcmp(fsname, "nfs") == 0) {
+		struct ibcs2_nfs_args sna;
+		struct sockaddr_in sain;
+		struct nfs_args na;
+		struct sockaddr sa;
+
+		if (error = copyin(SCARG(uap, data), &sna, sizeof sna))
+			return (error);
+		if (error = copyin(sna.addr, &sain, sizeof sain))
+			return (error);
+		bcopy(&sain, &sa, sizeof sa);
+		sa.sa_len = sizeof(sain);
+		SCARG(uap, data) = (caddr_t)STACK_ALLOC();
+		na.addr = (struct sockaddr *)((int)SCARG(uap, data) + sizeof na);
+		na.sotype = SOCK_DGRAM;
+		na.proto = IPPROTO_UDP;
+		na.fh = (nfsv2fh_t *)sna.fh;
+		na.flags = sna.flags;
+		na.wsize = sna.wsize;
+		na.rsize = sna.rsize;
+		na.timeo = sna.timeo;
+		na.retrans = sna.retrans;
+		na.hostname = sna.hostname;
+
+		if (error = copyout(&sa, na.addr, sizeof sa))
+			return (error);
+		if (error = copyout(&na, SCARG(uap, data), sizeof na))
+			return (error);
+	}
+	return (mount(p, uap, retval));
+#else
+	return EINVAL;
+#endif
+}
+
+/*
+ * Read iBCS2-style directory entries.  We suck them into kernel space so
+ * that they can be massaged before being copied out to user code.  Like
+ * SunOS, we squish out `empty' entries.
+ *
+ * This is quite ugly, but what do you expect from compatibility code?
+ */
+
+int
+ibcs2_getdents(p, uap, retval)
+	struct proc *p;
+	register struct ibcs2_getdents_args *uap;
+	int *retval;
+{
+	register struct vnode *vp;
+	register caddr_t inp, buf;	/* BSD-format */
+	register int len, reclen;	/* BSD-format */
+	register caddr_t outp;		/* iBCS2-format */
+	register int resid;		/* iBCS2-format */
+	struct file *fp;
+	struct uio auio;
+	struct iovec aiov;
+	struct ibcs2_dirent idb;
+	off_t off;			/* true file offset */
+	int buflen, error, eofflag;
+#define	BSD_DIRENT(cp)		((struct direct *)(cp))
+#define	IBCS2_RECLEN(reclen)	(reclen + sizeof(u_short))
+
+	if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
+		return (error);
+	if ((fp->f_flag & FREAD) == 0)
+		return (EBADF);
+	vp = (struct vnode *)fp->f_data;
+	if (vp->v_type != VDIR)	/* XXX  vnode readdir op should do this */
+		return (EINVAL);
+	buflen = min(MAXBSIZE, SCARG(uap, nbytes));
+	buf = malloc(buflen, M_TEMP, M_WAITOK);
+	VOP_LOCK(vp);
+	off = fp->f_offset;
+again:
+	aiov.iov_base = buf;
+	aiov.iov_len = buflen;
+	auio.uio_iov = &aiov;
+	auio.uio_iovcnt = 1;
+	auio.uio_rw = UIO_READ;
+	auio.uio_segflg = UIO_SYSSPACE;
+	auio.uio_procp = p;
+	auio.uio_resid = buflen;
+	auio.uio_offset = off;
+	/*
+	 * First we read into the malloc'ed buffer, then
+	 * we massage it into user space, one record at a time.
+	 */
+	if (error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, (u_long *)0,
+	    0))
+		goto out;
+	inp = buf;
+	outp = SCARG(uap, buf);
+	resid = SCARG(uap, nbytes);
+	if ((len = buflen - auio.uio_resid) == 0)
+		goto eof;
+	for (; len > 0; len -= reclen) {
+		reclen = BSD_DIRENT(inp)->d_reclen;
+		if (reclen & 3)
+			panic("ibcs2_getdents");
+		off += reclen;		/* each entry points to next */
+		if (BSD_DIRENT(inp)->d_ino == 0) {
+			inp += reclen;	/* it is a hole; squish it out */
+			continue;
+		}
+		if (reclen > len || resid < IBCS2_RECLEN(reclen)) {
+			/* entry too big for buffer, so just stop */
+			outp++;
+			break;
+		}
+		/*
+		 * Massage in place to make a iBCS2-shaped dirent (otherwise
+		 * we have to worry about touching user memory outside of
+		 * the copyout() call).
+		 */
+		idb.d_ino = (ibcs2_ino_t)BSD_DIRENT(inp)->d_ino;
+		idb.d_off = (ibcs2_off_t)off;
+		idb.d_reclen = (u_short)IBCS2_RECLEN(reclen);
+		if ((error = copyout((caddr_t)&idb, outp, 10)) != 0 ||
+		    (error = copyout(BSD_DIRENT(inp)->d_name, outp + 10,
+				     BSD_DIRENT(inp)->d_namlen + 1)) != 0)
+			goto out;
+		/* advance past this real entry */
+		inp += reclen;
+		/* advance output past iBCS2-shaped entry */
+		outp += IBCS2_RECLEN(reclen);
+		resid -= IBCS2_RECLEN(reclen);
+	}
+	/* if we squished out the whole block, try again */
+	if (outp == SCARG(uap, buf))
+		goto again;
+	fp->f_offset = off;		/* update the vnode offset */
+eof:
+	*retval = SCARG(uap, nbytes) - resid;
+out:
+	VOP_UNLOCK(vp);
+	free(buf, M_TEMP);
+	return (error);
+}
+
+int
+ibcs2_read(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_read_args *uap;
+	int *retval;
+{
+	register struct vnode *vp;
+	register caddr_t inp, buf;	/* BSD-format */
+	register int len, reclen;	/* BSD-format */
+	register caddr_t outp;		/* iBCS2-format */
+	register int resid;		/* iBCS2-format */
+	struct file *fp;
+	struct uio auio;
+	struct iovec aiov;
+	struct ibcs2_direct {
+		ibcs2_ino_t ino;
+		char name[14];
+	} idb;
+	off_t off;			/* true file offset */
+	int buflen, error, eofflag, size;
+
+	if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) {
+		if (error == EINVAL)
+			return read(p, uap, retval);
+		else
+			return error;
+	}
+	if ((fp->f_flag & FREAD) == 0)
+		return (EBADF);
+	vp = (struct vnode *)fp->f_data;
+	if (vp->v_type != VDIR)
+		return read(p, uap, retval);
+	DPRINTF(("ibcs2_read: read directory\n"));
+	buflen = max(MAXBSIZE, SCARG(uap, nbytes));
+	buf = malloc(buflen, M_TEMP, M_WAITOK);
+	VOP_LOCK(vp);
+	off = fp->f_offset;
+again:
+	aiov.iov_base = buf;
+	aiov.iov_len = buflen;
+	auio.uio_iov = &aiov;
+	auio.uio_iovcnt = 1;
+	auio.uio_rw = UIO_READ;
+	auio.uio_segflg = UIO_SYSSPACE;
+	auio.uio_procp = p;
+	auio.uio_resid = buflen;
+	auio.uio_offset = off & ~(DIRBLKSIZ - 1);
+	/*
+	 * First we read into the malloc'ed buffer, then
+	 * we massage it into user space, one record at a time.
+	 */
+	if (error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
+				(u_long *)0, 0)) {
+		DPRINTF(("VOP_READDIR failed: %d\n", error));
+		goto out;
+	}
+	inp = buf + (off & (DIRBLKSIZ - 1));
+	buflen -= off & (DIRBLKSIZ - 1);
+	outp = SCARG(uap, buf);
+	resid = SCARG(uap, nbytes);
+	if ((len = buflen - auio.uio_resid) == 0)
+		goto eof;
+	for (; len > 0 && resid > 0; len -= reclen) {
+		reclen = BSD_DIRENT(inp)->d_reclen;
+		if (reclen & 3)
+			panic("ibcs2_read");
+		if (BSD_DIRENT(inp)->d_ino == 0) {
+			inp += reclen;	/* it is a hole; squish it out */
+			off += reclen;
+			continue;
+		}
+		if (reclen > len || resid < sizeof(struct ibcs2_direct)) {
+			/* entry too big for buffer, so just stop */
+			outp++;
+			break;
+		}
+		/*
+		 * Massage in place to make a iBCS2-shaped dirent (otherwise
+		 * we have to worry about touching user memory outside of
+		 * the copyout() call).
+		 *
+		 * TODO: if length(filename) > 14, then break filename into
+		 * multiple entries and set inode = 0xffff except last
+		 */
+		idb.ino = (BSD_DIRENT(inp)->d_ino > 0xfffe) ? 0xfffe :
+			BSD_DIRENT(inp)->d_ino;
+		(void)copystr(BSD_DIRENT(inp)->d_name, idb.name, 14, &size);
+		bzero(idb.name + size, 14 - size);
+		if (error = copyout(&idb, outp, sizeof(struct ibcs2_direct)))
+			goto out;
+		/* advance past this real entry */
+		off += reclen;
+		inp += reclen;
+		/* advance output past iBCS2-shaped entry */
+		outp += sizeof(struct ibcs2_direct);
+		resid -= sizeof(struct ibcs2_direct);
+	}
+	/* if we squished out the whole block, try again */
+	if (outp == SCARG(uap, buf))
+		goto again;
+	fp->f_offset = off;		/* update the vnode offset */
+eof:
+	*retval = SCARG(uap, nbytes) - resid;
+out:
+	VOP_UNLOCK(vp);
+	free(buf, M_TEMP);
+	return (error);
+}
+
+int
+ibcs2_mknod(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_mknod_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+        CHECKALTCREAT(p, &sg, SCARG(uap, path));
+	if (S_ISFIFO(SCARG(uap, mode))) {
+                struct mkfifo_args ap;
+                SCARG(&ap, path) = SCARG(uap, path);
+                SCARG(&ap, mode) = SCARG(uap, mode);
+		return mkfifo(p, uap, retval);
+	} else {
+                struct mknod_args ap;
+                SCARG(&ap, path) = SCARG(uap, path);
+                SCARG(&ap, mode) = SCARG(uap, mode);
+                SCARG(&ap, dev) = SCARG(uap, dev);
+                return mknod(p, &ap, retval);
+	}
+}
+
+int
+ibcs2_getgroups(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_getgroups_args *uap;
+	int *retval;
+{
+	int error, i;
+	ibcs2_gid_t igid, *iset;
+	struct getgroups_args sa;
+	gid_t *gp;
+	caddr_t sg = stackgap_init();
+
+	SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
+	if (SCARG(uap, gidsetsize)) {
+		SCARG(&sa, gidset) = stackgap_alloc(&sg, NGROUPS_MAX *
+						    sizeof(gid_t *));
+		iset = stackgap_alloc(&sg, SCARG(uap, gidsetsize) *
+				      sizeof(ibcs2_gid_t));
+	}
+	if (error = getgroups(p, &sa, retval))
+		return error;
+	for (i = 0, gp = SCARG(&sa, gidset); i < retval[0]; i++)
+		iset[i] = (ibcs2_gid_t)*gp++;
+	if (retval[0] && (error = copyout((caddr_t)iset,
+					  (caddr_t)SCARG(uap, gidset),
+					  sizeof(ibcs2_gid_t) * retval[0])))
+		return error;
+        return 0;
+}
+
+int
+ibcs2_setgroups(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_setgroups_args *uap;
+	int *retval;
+{
+	int error, i;
+	ibcs2_gid_t igid, *iset;
+	struct setgroups_args sa;
+	gid_t *gp;
+	caddr_t sg = stackgap_init();
+
+	SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
+	SCARG(&sa, gidset) = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) *
+					    sizeof(gid_t *));
+	iset = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) *
+			      sizeof(ibcs2_gid_t *));
+	if (SCARG(&sa, gidsetsize)) {
+		if (error = copyin((caddr_t)SCARG(uap, gidset), (caddr_t)iset, 
+				   sizeof(ibcs2_gid_t *) *
+				   SCARG(uap, gidsetsize)))
+			return error;
+	}
+	for (i = 0, gp = SCARG(&sa, gidset); i < SCARG(&sa, gidsetsize); i++)
+		*gp++ = (gid_t)iset[i];
+	return setgroups(p, &sa, retval);
+}
+
+int
+ibcs2_setuid(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_setuid_args *uap;
+	int *retval;
+{
+	struct setuid_args sa;
+
+	SCARG(&sa, uid) = (uid_t)SCARG(uap, uid);
+	return setuid(p, &sa, retval);
+}
+
+int
+ibcs2_setgid(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_setgid_args *uap;
+	int *retval;
+{
+	struct setgid_args sa;
+
+	SCARG(&sa, gid) = (gid_t)SCARG(uap, gid);
+	return setgid(p, &sa, retval);
+}
+
+int
+xenix_ftime(p, uap, retval)
+	struct proc *p;
+	struct xenix_ftime_args *uap;
+	int *retval;
+{
+	struct timeval tv;
+	extern struct timezone tz;
+	struct xenix_timeb itb;
+
+	microtime(&tv);
+	itb.time = tv.tv_sec;
+	itb.millitm = (tv.tv_usec / 1000);
+	itb.timezone = tz.tz_minuteswest;
+	itb.dstflag = tz.tz_dsttime;
+	return copyout((caddr_t)&itb, (caddr_t)SCARG(uap, tp), xenix_timeb_len);
+}
+
+int
+ibcs2_time(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_time_args *uap;
+	int *retval;
+{
+	struct timeval tv;
+
+	microtime(&tv);
+	*retval = tv.tv_sec;
+	if (SCARG(uap, tp))
+		return copyout((caddr_t)&tv.tv_sec, (caddr_t)SCARG(uap, tp),
+			       sizeof(ibcs2_time_t));
+	else
+		return 0;
+}
+
+int
+ibcs2_pathconf(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_pathconf_args *uap;
+	int *retval;
+{
+	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
+        return pathconf(p, uap, retval);
+}
+
+int
+ibcs2_fpathconf(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_fpathconf_args *uap;
+	int *retval;
+{
+	SCARG(uap, name)++;	/* iBCS2 _PC_* defines are offset by one */
+        return fpathconf(p, uap, retval);
+}
+
+int
+ibcs2_sysconf(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_sysconf_args *uap;
+	int *retval;
+{
+	int mib[2], value, len, error;
+	struct __sysctl_args sa;
+	struct getrlimit_args ga;
+
+	switch(SCARG(uap, name)) {
+	case IBCS2_SC_ARG_MAX:
+		mib[1] = KERN_ARGMAX;
+		break;
+
+	case IBCS2_SC_CHILD_MAX:
+	    {
+		caddr_t sg = stackgap_init();
+
+		SCARG(&ga, which) = RLIMIT_NPROC;
+		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
+		if (error = getrlimit(p, &ga, retval))
+			return error;
+		*retval = SCARG(&ga, rlp)->rlim_cur;
+		return 0;
+	    }
+
+	case IBCS2_SC_CLK_TCK:
+		*retval = hz;
+		return 0;
+
+	case IBCS2_SC_NGROUPS_MAX:
+		mib[1] = KERN_NGROUPS;
+		break;
+
+	case IBCS2_SC_OPEN_MAX:
+	    {
+		caddr_t sg = stackgap_init();
+
+		SCARG(&ga, which) = RLIMIT_NOFILE;
+		SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
+		if (error = getrlimit(p, &ga, retval))
+			return error;
+		*retval = SCARG(&ga, rlp)->rlim_cur;
+		return 0;
+	    }
+		
+	case IBCS2_SC_JOB_CONTROL:
+		mib[1] = KERN_JOB_CONTROL;
+		break;
+		
+	case IBCS2_SC_SAVED_IDS:
+		mib[1] = KERN_SAVED_IDS;
+		break;
+		
+	case IBCS2_SC_VERSION:
+		mib[1] = KERN_POSIX1;
+		break;
+		
+	case IBCS2_SC_PASS_MAX:
+		*retval = 128;		/* XXX - should we create PASS_MAX ? */
+		return 0;
+
+	case IBCS2_SC_XOPEN_VERSION:
+		*retval = 2;		/* XXX: What should that be? */
+		return 0;
+		
+	default:
+		return EINVAL;
+	}
+
+	mib[0] = CTL_KERN;
+	len = sizeof(value);
+	SCARG(&sa, name) = mib;
+	SCARG(&sa, namelen) = 2;
+	SCARG(&sa, old) = &value;
+	SCARG(&sa, oldlenp) = &len;
+	SCARG(&sa, new) = NULL;
+	SCARG(&sa, newlen) = 0;
+	if (error = __sysctl(p, &sa, retval))
+		return error;
+	*retval = value;
+	return 0;
+}
+
+int
+ibcs2_alarm(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_alarm_args *uap;
+	int *retval;
+{
+	int error;
+        struct itimerval *itp, *oitp;
+	struct setitimer_args sa;
+	caddr_t sg = stackgap_init();
+
+        itp = stackgap_alloc(&sg, sizeof(*itp));
+	oitp = stackgap_alloc(&sg, sizeof(*oitp));
+        timerclear(&itp->it_interval);
+        itp->it_value.tv_sec = SCARG(uap, sec);
+        itp->it_value.tv_usec = 0;
+
+	SCARG(&sa, which) = ITIMER_REAL;
+	SCARG(&sa, itv) = itp;
+	SCARG(&sa, oitv) = oitp;
+        error = setitimer(p, &sa, retval);
+	if (error)
+		return error;
+        if (oitp->it_value.tv_usec)
+                oitp->it_value.tv_sec++;
+        *retval = oitp->it_value.tv_sec;
+        return 0;
+}
+
+int
+ibcs2_getmsg(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_getmsg_args *uap;
+	int *retval;
+{
+	return 0;
+}
+
+int
+ibcs2_putmsg(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_putmsg_args *uap;
+	int *retval;
+{
+	return 0;
+}
+
+int
+ibcs2_times(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_times_args *uap;
+	int *retval;
+{
+	int error;
+	struct getrusage_args ga;
+	struct tms tms;
+        struct timeval t;
+	caddr_t sg = stackgap_init();
+        struct rusage *ru = stackgap_alloc(&sg, sizeof(*ru));
+#define CONVTCK(r)      (r.tv_sec * hz + r.tv_usec / (1000000 / hz))
+
+	SCARG(&ga, who) = RUSAGE_SELF;
+	SCARG(&ga, rusage) = ru;
+	error = getrusage(p, &ga, retval);
+	if (error)
+                return error;
+        tms.tms_utime = CONVTCK(ru->ru_utime);
+        tms.tms_stime = CONVTCK(ru->ru_stime);
+
+	SCARG(&ga, who) = RUSAGE_CHILDREN;
+        error = getrusage(p, &ga, retval);
+	if (error)
+		return error;
+        tms.tms_cutime = CONVTCK(ru->ru_utime);
+        tms.tms_cstime = CONVTCK(ru->ru_stime);
+
+	microtime(&t);
+        *retval = CONVTCK(t);
+	
+	return copyout((caddr_t)&tms, (caddr_t)SCARG(uap, tp),
+		       sizeof(struct tms));
+}
+
+int
+ibcs2_stime(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_stime_args *uap;
+	int *retval;
+{
+	int error;
+	struct settimeofday_args sa;
+	caddr_t sg = stackgap_init();
+
+	SCARG(&sa, tv) = stackgap_alloc(&sg, sizeof(*SCARG(&sa, tv)));
+	SCARG(&sa, tzp) = NULL;
+	if (error = copyin((caddr_t)SCARG(uap, timep),
+			   &(SCARG(&sa, tv)->tv_sec), sizeof(long)))
+		return error;
+	SCARG(&sa, tv)->tv_usec = 0;
+	if (error = settimeofday(p, &sa, retval))
+		return EPERM;
+	return 0;
+}
+
+int
+ibcs2_utime(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_utime_args *uap;
+	int *retval;
+{
+	int error;
+	struct utimes_args sa;
+	struct timeval *tp;
+	caddr_t sg = stackgap_init();
+
+        CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	SCARG(&sa, path) = SCARG(uap, path);
+	if (SCARG(uap, buf)) {
+		struct ibcs2_utimbuf ubuf;
+
+		if (error = copyin((caddr_t)SCARG(uap, buf), (caddr_t)&ubuf,
+				   sizeof(ubuf)))
+			return error;
+		SCARG(&sa, tptr) = stackgap_alloc(&sg,
+						  2 * sizeof(struct timeval *));
+		tp = (struct timeval *)SCARG(&sa, tptr);
+		tp->tv_sec = ubuf.actime;
+		tp->tv_usec = 0;
+		tp++;
+		tp->tv_sec = ubuf.modtime;
+		tp->tv_usec = 0;
+	} else
+		SCARG(&sa, tptr) = NULL;
+	return utimes(p, &sa, retval);
+}
+
+int
+ibcs2_nice(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_nice_args *uap;
+	int *retval;
+{
+	int error, cur_nice = p->p_nice;
+	struct setpriority_args sa;
+
+	SCARG(&sa, which) = PRIO_PROCESS;
+	SCARG(&sa, who) = 0;
+	SCARG(&sa, prio) = p->p_nice + SCARG(uap, incr);
+	if (error = setpriority(p, &sa, retval))
+		return EPERM;
+	*retval = p->p_nice;
+	return 0;
+}
+
+/*
+ * iBCS2 getpgrp, setpgrp, setsid, and setpgid
+ */
+
+int
+ibcs2_pgrpsys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_pgrpsys_args *uap;
+	int *retval;
+{
+	switch (SCARG(uap, type)) {
+	case 0:			/* getpgrp */
+		*retval = p->p_pgrp->pg_id;
+		return 0;
+
+	case 1:			/* setpgrp */
+	    {
+		struct setpgid_args sa;
+
+		SCARG(&sa, pid) = 0;
+		SCARG(&sa, pgid) = 0;
+		setpgid(p, &sa, retval);
+		*retval = p->p_pgrp->pg_id;
+		return 0;
+	    }
+
+	case 2:			/* setpgid */
+	    {
+		struct setpgid_args sa;
+
+		SCARG(&sa, pid) = SCARG(uap, pid);
+		SCARG(&sa, pgid) = SCARG(uap, pgid);
+		return setpgid(p, &sa, retval);
+	    }
+
+	case 3:			/* setsid */
+		return setsid(p, NULL, retval);
+
+	default:
+		return EINVAL;
+	}
+}
+
+/*
+ * XXX - need to check for nested calls
+ */
+
+int
+ibcs2_plock(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_plock_args *uap;
+	int *retval;
+{
+	int error;
+#define IBCS2_UNLOCK	0
+#define IBCS2_PROCLOCK	1
+#define IBCS2_TEXTLOCK	2
+#define IBCS2_DATALOCK	4
+
+	
+        if (error = suser(p->p_ucred, &p->p_acflag))
+                return EPERM;
+	switch(SCARG(uap, cmd)) {
+	case IBCS2_UNLOCK:
+	case IBCS2_PROCLOCK:
+	case IBCS2_TEXTLOCK:
+	case IBCS2_DATALOCK:
+		return 0;	/* XXX - TODO */
+	}
+	return EINVAL;
+}
+
+int
+ibcs2_uadmin(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_uadmin_args *uap;
+	int *retval;
+{
+#define SCO_A_REBOOT        1
+#define SCO_A_SHUTDOWN      2
+#define SCO_A_REMOUNT       4
+#define SCO_A_CLOCK         8
+#define SCO_A_SETCONFIG     128
+#define SCO_A_GETDEV        130
+
+#define SCO_AD_HALT         0
+#define SCO_AD_BOOT         1
+#define SCO_AD_IBOOT        2
+#define SCO_AD_PWRDOWN      3
+#define SCO_AD_PWRNAP       4
+
+#define SCO_AD_PANICBOOT    1
+
+#define SCO_AD_GETBMAJ      0
+#define SCO_AD_GETCMAJ      1
+
+	switch(SCARG(uap, cmd)) {
+	case SCO_A_REBOOT:
+	case SCO_A_SHUTDOWN:
+		switch(SCARG(uap, func)) {
+		case SCO_AD_HALT:
+		case SCO_AD_PWRDOWN:
+		case SCO_AD_PWRNAP:
+			reboot(RB_HALT);
+		case SCO_AD_BOOT:
+		case SCO_AD_IBOOT:
+			reboot(RB_AUTOBOOT);
+		}
+		return EINVAL;
+	case SCO_A_REMOUNT:
+	case SCO_A_CLOCK:
+	case SCO_A_SETCONFIG:
+		return 0;
+	case SCO_A_GETDEV:
+		return EINVAL;	/* XXX - TODO */
+	}
+	return EINVAL;
+}
+
+int
+ibcs2_sysfs(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_sysfs_args *uap;
+	int *retval;
+{
+#define IBCS2_GETFSIND        1
+#define IBCS2_GETFSTYP        2
+#define IBCS2_GETNFSTYP       3
+
+	switch(SCARG(uap, cmd)) {
+	case IBCS2_GETFSIND:
+	case IBCS2_GETFSTYP:
+	case IBCS2_GETNFSTYP:
+	}
+	return EINVAL;		/* XXX - TODO */
+}
+
+int
+ibcs2_poll(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_poll_args *uap;
+	int *retval;
+{
+	return EINVAL;		/* XXX - TODO */
+}
+
+int
+xenix_rdchk(p, uap, retval)
+	struct proc *p;
+	struct xenix_rdchk_args *uap;
+	int *retval;
+{
+	int error;
+	struct ioctl_args sa;
+	caddr_t sg = stackgap_init();
+
+	SCARG(&sa, fd) = SCARG(uap, fd);
+	SCARG(&sa, com) = FIONREAD;
+	SCARG(&sa, data) = stackgap_alloc(&sg, sizeof(int));
+	if (error = ioctl(p, &sa, retval))
+		return error;
+	*retval = (*((int*)SCARG(&sa, data))) ? 1 : 0;
+	return 0;
+}
+
+int
+xenix_chsize(p, uap, retval)
+	struct proc *p;
+	struct xenix_chsize_args *uap;
+	int *retval;
+{
+	struct ftruncate_args sa;
+
+	SCARG(&sa, fd) = SCARG(uap, fd);
+	SCARG(&sa, pad) = 0;
+	SCARG(&sa, length) = SCARG(uap, size);
+	return ftruncate(p, &sa, retval);
+}
+
+int
+xenix_nap(p, uap, retval)
+	struct proc *p;
+	struct xenix_nap_args *uap;
+	int *retval;
+{
+	return ENOSYS;
+}
+
+int
+ibcs2_unlink(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_unlink_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return unlink(p, uap, retval);
+}
+
+int
+ibcs2_chdir(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_chdir_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return chdir(p, uap, retval);
+}
+
+int
+ibcs2_chmod(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_chmod_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return chmod(p, uap, retval);
+}
+
+int
+ibcs2_chown(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_chown_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return chown(p, uap, retval);
+}
+
+int
+ibcs2_rmdir(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_rmdir_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return rmdir(p, uap, retval);
+}
+
+int
+ibcs2_mkdir(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_mkdir_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTCREAT(p, &sg, SCARG(uap, path));
+	return mkdir(p, uap, retval);
+}
+
+int
+ibcs2_symlink(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_symlink_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	CHECKALTCREAT(p, &sg, SCARG(uap, link));
+	return symlink(p, uap, retval);
+}
+
+int
+ibcs2_rename(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_rename_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, from));
+	CHECKALTCREAT(p, &sg, SCARG(uap, to));
+	return rename(p, uap, retval);
+}
+
+int
+ibcs2_readlink(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_readlink_args *uap;
+	int *retval;
+{
+        caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	return readlink(p, uap, retval);
+}
diff --git a/sys/i386/ibcs2/ibcs2_mount.h b/sys/i386/ibcs2/ibcs2_mount.h
new file mode 100644
index 000000000000..d1b9aaaedc24
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_mount.h
@@ -0,0 +1,41 @@
+/*	$NetBSD: ibcs2_mount.h,v 1.2 1994/10/26 02:53:00 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_MOUNT_H
+#define	_IBCS2_MOUNT_H
+
+#define IBCS2_MS_RDONLY	0x01
+#define IBCS2_MS_FSS	0x02
+#define IBCS2_MS_DATA	0x04
+#define IBCS2_MS_CACHE	0x08
+
+#endif /* _IBCS2_MOUNT_H */
diff --git a/sys/i386/ibcs2/ibcs2_signal.c b/sys/i386/ibcs2/ibcs2_signal.c
new file mode 100644
index 000000000000..ba768b0966ac
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_signal.c
@@ -0,0 +1,492 @@
+/*	$NetBSD: ibcs2_signal.c,v 1.6 1995/09/19 22:19:07 thorpej Exp $	*/
+
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+#include <sys/kernel.h>
+#include <sys/signal.h>
+#include <sys/signalvar.h>
+#include <sys/malloc.h>
+
+#include <sys/syscallargs.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+#include <compat/ibcs2/ibcs2_util.h>
+
+#define sigemptyset(s)		bzero((s), sizeof(*(s)))
+#define sigismember(s, n)	(*(s) & sigmask(n))
+#define sigaddset(s, n)		(*(s) |= sigmask(n))
+
+#define	ibcs2_sigmask(n)	(1 << ((n) - 1))
+#define ibcs2_sigemptyset(s)	bzero((s), sizeof(*(s)))
+#define ibcs2_sigismember(s, n)	(*(s) & ibcs2_sigmask(n))
+#define ibcs2_sigaddset(s, n)	(*(s) |= ibcs2_sigmask(n))
+
+int bsd_to_ibcs2_sig[] = {
+	0,			/* 0 */
+	IBCS2_SIGHUP,		/* 1 */
+	IBCS2_SIGINT,		/* 2 */
+	IBCS2_SIGQUIT,		/* 3 */
+	IBCS2_SIGILL,		/* 4 */
+	IBCS2_SIGTRAP,		/* 5 */
+	IBCS2_SIGABRT,		/* 6 */
+	IBCS2_SIGEMT,		/* 7 */
+	IBCS2_SIGFPE,		/* 8 */
+	IBCS2_SIGKILL,		/* 9 */
+	IBCS2_SIGBUS,		/* 10 */
+	IBCS2_SIGSEGV,		/* 11 */
+	IBCS2_SIGSYS,		/* 12 */
+	IBCS2_SIGPIPE,		/* 13 */
+	IBCS2_SIGALRM,		/* 14 */
+	IBCS2_SIGTERM,		/* 15 */
+	0,			/* 16 - SIGURG */
+	IBCS2_SIGSTOP,		/* 17 */
+	IBCS2_SIGTSTP,		/* 18 */
+	IBCS2_SIGCONT,		/* 19 */
+	IBCS2_SIGCLD,		/* 20 */
+	IBCS2_SIGTTIN,		/* 21 */
+	IBCS2_SIGTTOU,		/* 22 */
+	IBCS2_SIGPOLL,		/* 23 */
+	0,			/* 24 - SIGXCPU */
+	0,			/* 25 - SIGXFSZ */
+	IBCS2_SIGVTALRM,	/* 26 */
+	IBCS2_SIGPROF,		/* 27 */
+	IBCS2_SIGWINCH,		/* 28 */
+	0,			/* 29 */
+	IBCS2_SIGUSR1,		/* 30 */
+	IBCS2_SIGUSR2,		/* 31 */
+};
+
+int ibcs2_to_bsd_sig[] = {
+	0,			/* 0 */
+	SIGHUP,			/* 1 */
+	SIGINT,			/* 2 */
+	SIGQUIT,		/* 3 */
+	SIGILL,			/* 4 */
+	SIGTRAP,		/* 5 */
+	SIGABRT,		/* 6 */
+	SIGEMT,			/* 7 */
+	SIGFPE,			/* 8 */
+	SIGKILL,		/* 9 */
+	SIGBUS,			/* 10 */
+	SIGSEGV,		/* 11 */
+	SIGSYS,			/* 12 */
+	SIGPIPE,		/* 13 */
+	SIGALRM,		/* 14 */
+	SIGTERM,		/* 15 */
+	SIGUSR1,		/* 16 */
+	SIGUSR2,		/* 17 */
+	SIGCHLD,		/* 18 */
+	0,			/* 19 - SIGPWR */
+	SIGWINCH,		/* 20 */
+	0,			/* 21 */
+	SIGIO,			/* 22 */
+	SIGSTOP,		/* 23 */
+	SIGTSTP,		/* 24 */
+	SIGCONT,		/* 25 */
+	SIGTTIN,		/* 26 */
+	SIGTTOU,		/* 27 */
+	SIGVTALRM,		/* 28 */
+	SIGPROF,		/* 29 */
+	0,			/* 30 */
+	0,			/* 31 */
+};
+
+void
+ibcs2_to_bsd_sigset(iss, bss)
+	const ibcs2_sigset_t *iss;
+	sigset_t *bss;
+{
+	int i, newsig;
+
+	sigemptyset(bss);
+	for (i = 1; i < IBCS2_NSIG; i++) {
+		if (ibcs2_sigismember(iss, i)) {
+			newsig = ibcs2_to_bsd_sig[i];
+			if (newsig)
+				sigaddset(bss, newsig);
+		}
+	}
+}
+
+void
+bsd_to_ibcs2_sigset(bss, iss)
+	const sigset_t *bss;
+	ibcs2_sigset_t *iss;
+{
+	int i, newsig;
+
+	ibcs2_sigemptyset(iss);
+	for (i = 1; i < NSIG; i++) {
+		if (sigismember(bss, i)) {
+			newsig = bsd_to_ibcs2_sig[i];
+			if (newsig)
+				ibcs2_sigaddset(iss, newsig);
+		}
+	}
+}
+
+void
+ibcs2_to_bsd_sigaction(isa, bsa)
+	struct ibcs2_sigaction *isa;
+	struct sigaction *bsa;
+{
+
+	bsa->sa_handler = isa->sa_handler;
+	ibcs2_to_bsd_sigset(&isa->sa_mask, &bsa->sa_mask);
+	bsa->sa_flags = 0;
+	if ((isa->sa_flags & IBCS2_SA_NOCLDSTOP) != 0)
+		bsa->sa_flags |= SA_NOCLDSTOP;
+}
+
+void
+bsd_to_ibcs2_sigaction(bsa, isa)
+	struct sigaction *bsa;
+	struct ibcs2_sigaction *isa;
+{
+
+	isa->sa_handler = bsa->sa_handler;
+	bsd_to_ibcs2_sigset(&bsa->sa_mask, &isa->sa_mask);
+	isa->sa_flags = 0;
+	if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
+		isa->sa_flags |= SA_NOCLDSTOP;
+}
+
+int
+ibcs2_sigaction(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_sigaction_args /* {
+		syscallarg(int) sig;
+		syscallarg(struct ibcs2_sigaction *) act;
+		syscallarg(struct ibcs2_sigaction *) oact;
+	} */ *uap = v;
+	struct ibcs2_sigaction *nisa, *oisa, tmpisa;
+	struct sigaction *nbsa, *obsa, tmpbsa;
+	struct sigaction_args sa;
+	caddr_t sg;
+	int error;
+
+	sg = stackgap_init(p->p_emul);
+	nisa = SCARG(uap, act);
+	oisa = SCARG(uap, oact);
+
+	if (oisa != NULL)
+		obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
+	else
+		obsa = NULL;
+
+	if (nisa != NULL) {
+		nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
+		if ((error = copyin(nisa, &tmpisa, sizeof(tmpisa))) != 0)
+			return error;
+		ibcs2_to_bsd_sigaction(&tmpisa, &tmpbsa);
+		if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
+			return error;
+	} else
+		nbsa = NULL;
+
+	SCARG(&sa, signum) = ibcs2_to_bsd_sig[SCARG(uap, sig)];
+	SCARG(&sa, nsa) = nbsa;
+	SCARG(&sa, osa) = obsa;
+
+	if ((error = sigaction(p, &sa, retval)) != 0)
+		return error;
+
+	if (oisa != NULL) {
+		if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
+			return error;
+		bsd_to_ibcs2_sigaction(&tmpbsa, &tmpisa);
+		if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
+			return error;
+	}
+
+	return 0;
+}
+
+int
+ibcs2_sigsys(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_sigsys_args /* {
+		syscallarg(int) sig;
+		syscallarg(ibcs2_sig_t) fp;
+	} */ *uap = v;
+	int signum = ibcs2_to_bsd_sig[IBCS2_SIGNO(SCARG(uap, sig))];
+	int error;
+	caddr_t sg = stackgap_init(p->p_emul);
+
+	if (signum <= 0 || signum >= IBCS2_NSIG) {
+		if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK ||
+		    IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
+			*retval = (int)IBCS2_SIG_ERR;
+		return EINVAL;
+	}
+	
+	switch (IBCS2_SIGCALL(SCARG(uap, sig))) {
+	/*
+	 * sigset is identical to signal() except that SIG_HOLD is allowed as
+	 * an action.
+	 */
+	case IBCS2_SIGSET_MASK:
+		/*
+		 * sigset is identical to signal() except
+		 * that SIG_HOLD is allowed as
+		 * an action.
+		 */
+		if (SCARG(uap, fp) == IBCS2_SIG_HOLD) {
+			struct sigprocmask_args sa;
+
+			SCARG(&sa, how) = SIG_BLOCK;
+			SCARG(&sa, mask) = sigmask(signum);
+			return sigprocmask(p, &sa, retval);
+		}
+		/* FALLTHROUGH */
+
+	case IBCS2_SIGNAL_MASK:
+		{
+			struct sigaction_args sa_args;
+			struct sigaction *nbsa, *obsa, sa;
+
+			nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
+			obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
+			SCARG(&sa_args, signum) = signum;
+			SCARG(&sa_args, nsa) = nbsa;
+			SCARG(&sa_args, osa) = obsa;
+
+			sa.sa_handler = SCARG(uap, fp);
+			sigemptyset(&sa.sa_mask);
+			sa.sa_flags = 0;
+#if 0
+			if (signum != SIGALRM)
+				sa.sa_flags = SA_RESTART;
+#endif
+			if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
+				return error;
+			if ((error = sigaction(p, &sa_args, retval)) != 0) {
+				DPRINTF(("signal: sigaction failed: %d\n",
+					 error));
+				*retval = (int)IBCS2_SIG_ERR;
+				return error;
+			}
+			if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
+				return error;
+			*retval = (int)sa.sa_handler;
+			return 0;
+		}
+		
+	case IBCS2_SIGHOLD_MASK:
+		{
+			struct sigprocmask_args sa;
+
+			SCARG(&sa, how) = SIG_BLOCK;
+			SCARG(&sa, mask) = sigmask(signum);
+			return sigprocmask(p, &sa, retval);
+		}
+		
+	case IBCS2_SIGRELSE_MASK:
+		{
+			struct sigprocmask_args sa;
+
+			SCARG(&sa, how) = SIG_UNBLOCK;
+			SCARG(&sa, mask) = sigmask(signum);
+			return sigprocmask(p, &sa, retval);
+		}
+		
+	case IBCS2_SIGIGNORE_MASK:
+		{
+			struct sigaction_args sa_args;
+			struct sigaction *bsa, sa;
+
+			bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
+			SCARG(&sa_args, signum) = signum;
+			SCARG(&sa_args, nsa) = bsa;
+			SCARG(&sa_args, osa) = NULL;
+
+			sa.sa_handler = SIG_IGN;
+			sigemptyset(&sa.sa_mask);
+			sa.sa_flags = 0;
+			if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
+				return error;
+			if ((error = sigaction(p, &sa_args, retval)) != 0) {
+				DPRINTF(("sigignore: sigaction failed\n"));
+				return error;
+			}
+			return 0;
+		}
+		
+	case IBCS2_SIGPAUSE_MASK:
+		{
+			struct sigsuspend_args sa;
+
+			SCARG(&sa, mask) = p->p_sigmask &~ sigmask(signum);
+			return sigsuspend(p, &sa, retval);
+		}
+		
+	default:
+		return ENOSYS;
+	}
+}
+
+int
+ibcs2_sigprocmask(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_sigprocmask_args /* {
+		syscallarg(int) how;
+		syscallarg(ibcs2_sigset_t *) set;
+		syscallarg(ibcs2_sigset_t *) oset;
+	} */ *uap = v;
+	ibcs2_sigset_t iss;
+	sigset_t bss;
+	int error = 0;
+
+	if (SCARG(uap, oset) != NULL) {
+		/* Fix the return value first if needed */
+		bsd_to_ibcs2_sigset(&p->p_sigmask, &iss);
+		if ((error = copyout(&iss, SCARG(uap, oset), sizeof(iss))) != 0)
+			return error;
+	}
+		
+	if (SCARG(uap, set) == NULL)
+		/* Just examine */
+		return 0;
+
+	if ((error = copyin(SCARG(uap, set), &iss, sizeof(iss))) != 0)
+		return error;
+
+	ibcs2_to_bsd_sigset(&iss, &bss);
+
+	(void) splhigh();
+
+	switch (SCARG(uap, how)) {
+	case IBCS2_SIG_BLOCK:
+		p->p_sigmask |= bss & ~sigcantmask;
+		break;
+
+	case IBCS2_SIG_UNBLOCK:
+		p->p_sigmask &= ~bss;
+		break;
+
+	case IBCS2_SIG_SETMASK:
+		p->p_sigmask = bss & ~sigcantmask;
+		break;
+
+	default:
+		error = EINVAL;
+		break;
+	}
+
+	(void) spl0();
+
+	return error;
+}
+
+int
+ibcs2_sigpending(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_sigpending_args /* {
+		syscallarg(ibcs2_sigset_t *) mask;
+	} */ *uap = v;
+	sigset_t bss;
+	ibcs2_sigset_t iss;
+
+	bss = p->p_siglist & p->p_sigmask;
+	bsd_to_ibcs2_sigset(&bss, &iss);
+
+	return copyout(&iss, SCARG(uap, mask), sizeof(iss));
+}
+
+int
+ibcs2_sigsuspend(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_sigsuspend_args /* {
+		syscallarg(ibcs2_sigset_t *) mask;
+	} */ *uap = v;
+	ibcs2_sigset_t sss;
+	sigset_t bss;
+	struct sigsuspend_args sa;
+	int error;
+
+	if ((error = copyin(SCARG(uap, mask), &sss, sizeof(sss))) != 0)
+		return error;
+
+	ibcs2_to_bsd_sigset(&sss, &bss);
+
+	SCARG(&sa, mask) = bss;
+	return sigsuspend(p, &sa, retval);
+}
+
+int
+ibcs2_pause(p, uap, retval)
+	register struct proc *p;
+	void *uap;
+	register_t *retval;
+{
+	struct sigsuspend_args bsa;
+
+	SCARG(&bsa, mask) = p->p_sigmask;
+	return sigsuspend(p, &bsa, retval);
+}
+
+int
+ibcs2_kill(p, v, retval)
+	register struct proc *p;
+	void *v;
+	register_t *retval;
+{
+	struct ibcs2_kill_args /* {
+		syscallarg(int) pid;
+		syscallarg(int) signo;
+	} */ *uap = v;
+	struct kill_args ka;
+
+	SCARG(&ka, pid) = SCARG(uap, pid);
+	SCARG(&ka, signum) = ibcs2_to_bsd_sig[SCARG(uap, signo)];
+	return kill(p, &ka, retval);
+}
diff --git a/sys/i386/ibcs2/ibcs2_signal.h b/sys/i386/ibcs2/ibcs2_signal.h
new file mode 100644
index 000000000000..2858688d79d8
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_signal.h
@@ -0,0 +1,105 @@
+/*	$NetBSD: ibcs2_signal.h,v 1.7 1995/08/14 02:26:01 mycroft Exp $	*/
+
+/*
+ * Copyright (c) 1994, 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_SIGNAL_H
+#define	_IBCS2_SIGNAL_H
+
+#define IBCS2_SIGHUP		1
+#define IBCS2_SIGINT		2
+#define IBCS2_SIGQUIT		3
+#define IBCS2_SIGILL		4
+#define IBCS2_SIGTRAP		5
+#define IBCS2_SIGIOT		6
+#define IBCS2_SIGABRT		6
+#define IBCS2_SIGEMT		7
+#define IBCS2_SIGFPE		8
+#define IBCS2_SIGKILL		9
+#define IBCS2_SIGBUS		10
+#define IBCS2_SIGSEGV		11
+#define IBCS2_SIGSYS		12
+#define IBCS2_SIGPIPE		13
+#define IBCS2_SIGALRM		14
+#define IBCS2_SIGTERM		15
+#define IBCS2_SIGUSR1		16
+#define IBCS2_SIGUSR2		17
+#define IBCS2_SIGCLD		18
+#define IBCS2_SIGPWR		19
+#define IBCS2_SIGWINCH		20
+#define IBCS2_SIGPOLL		22
+#define IBCS2_NSIG		32
+
+/*
+ * SCO-specific
+ */
+#define IBCS2_SIGSTOP		23
+#define IBCS2_SIGTSTP		24
+#define IBCS2_SIGCONT		25
+#define IBCS2_SIGTTIN		26
+#define IBCS2_SIGTTOU		27
+#define IBCS2_SIGVTALRM		28
+#define IBCS2_SIGPROF		29
+
+#define IBCS2_SIGNO_MASK	0x00FF
+#define IBCS2_SIGNAL_MASK	0x0000
+#define IBCS2_SIGSET_MASK	0x0100
+#define IBCS2_SIGHOLD_MASK	0x0200
+#define IBCS2_SIGRELSE_MASK	0x0400
+#define IBCS2_SIGIGNORE_MASK	0x0800
+#define IBCS2_SIGPAUSE_MASK	0x1000
+
+#define IBCS2_SIGNO(x)		((x) & IBCS2_SIGNO_MASK)
+#define IBCS2_SIGCALL(x)	((x) & ~IBCS2_SIGNO_MASK)
+
+#define IBCS2_SIG_DFL		(void(*)())0
+#define IBCS2_SIG_ERR		(void(*)())-1
+#define IBCS2_SIG_IGN		(void(*)())1
+#define IBCS2_SIG_HOLD		(void(*)())2
+
+#define IBCS2_SIG_SETMASK	0
+#define IBCS2_SIG_BLOCK		1
+#define IBCS2_SIG_UNBLOCK	2
+
+typedef long	ibcs2_sigset_t;
+typedef void	(*ibcs2_sig_t) __P((int));
+
+struct ibcs2_sigaction {
+	ibcs2_sig_t	sa_handler;
+	ibcs2_sigset_t	sa_mask;
+	int		sa_flags;
+};
+
+/* sa_flags */
+#define IBCS2_SA_NOCLDSTOP	1
+
+extern int bsd_to_ibcs2_sig[];
+
+#endif /* _IBCS2_SIGNAL_H */
diff --git a/sys/i386/ibcs2/ibcs2_socksys.c b/sys/i386/ibcs2/ibcs2_socksys.c
new file mode 100644
index 000000000000..6cf0a8f0d6a9
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_socksys.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 1994, 1995 Scott Bartram
+ * Copyright (c) 1994 Arne H Juul
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+
+#include <compat/ibcs2/ibcs2_socksys.h>
+#include <compat/ibcs2/ibcs2_util.h>
+
+/*
+ * iBCS2 socksys calls.
+ */
+
+struct ibcs2_socksys_args {
+	int     fd;
+	int     magic;
+	caddr_t argsp;
+};
+
+int
+ibcs2_socksys(p, uap, retval)
+	register struct proc *p;
+	register struct ibcs2_socksys_args *uap;
+	int *retval;
+{
+	register struct filedesc *fdp = p->p_fd;
+	register struct file *fp;
+	int error;
+	int realargs[7]; /* 1 for command, 6 for recvfrom */
+      
+	/*
+	 * SOCKET should only be legal on /dev/socksys.
+	 * GETIPDOMAINNAME should only be legal on /dev/socksys ?
+	 * The others are (and should be) only legal on sockets.
+	 */
+
+	if (error = copyin(uap->argsp, (caddr_t)realargs, sizeof(realargs)))
+		return error;
+	DPRINTF(("ibcs2_socksys: %08x %08x %08x %08x %08x %08x %08x\n",
+	       realargs[0], realargs[1], realargs[2], realargs[3], 
+	       realargs[4], realargs[5], realargs[6]));
+	switch (realargs[0]) {
+	case SOCKSYS_ACCEPT:
+		return accept(p, realargs+1, retval);
+	case SOCKSYS_BIND:
+		return bind(p, realargs+1, retval);
+	case SOCKSYS_CONNECT:
+		return connect(p, realargs+1, retval);
+	case SOCKSYS_GETPEERNAME:
+		return getpeername(p, realargs+1, retval);
+	case SOCKSYS_GETSOCKNAME:
+		return getsockname(p, realargs+1, retval);
+	case SOCKSYS_GETSOCKOPT:
+		return getsockopt(p, realargs+1, retval);
+	case SOCKSYS_LISTEN:
+		return listen(p, realargs+1, retval);
+	case SOCKSYS_RECV:
+		realargs[5] = realargs[6] = 0;
+		/* FALLTHROUGH */
+	case SOCKSYS_RECVFROM:
+		return recvfrom(p, realargs+1, retval);
+	case SOCKSYS_SEND:
+		realargs[5] = realargs[6] = 0;
+		/* FALLTHROUGH */
+	case SOCKSYS_SENDTO:
+		return sendto(p, realargs+1, retval);
+	case SOCKSYS_SETSOCKOPT:
+		return setsockopt(p, realargs+1, retval);
+	case SOCKSYS_SHUTDOWN:
+		return shutdown(p, realargs+1, retval);
+	case SOCKSYS_SOCKET:
+		return socket(p, realargs+1, retval);
+	case SOCKSYS_SELECT:
+		return select(p, realargs+1, retval);
+	case SOCKSYS_GETIPDOMAIN:
+		return compat_09_getdomainname(p, realargs + 1, retval);
+	case SOCKSYS_SETIPDOMAIN:
+		return compat_09_setdomainname(p, realargs + 1, retval);
+	case SOCKSYS_ADJTIME:
+		return adjtime(p, realargs + 1, retval);
+	case SOCKSYS_SETREUID:
+		return compat_43_setreuid(p, realargs + 1, retval);
+	case SOCKSYS_SETREGID:
+		return compat_43_setregid(p, realargs + 1, retval);
+	case SOCKSYS_GETTIME:
+		return gettimeofday(p, realargs + 1, retval);
+	case SOCKSYS_SETTIME:
+		return settimeofday(p, realargs + 1, retval);
+	case SOCKSYS_GETITIMER:
+		return getitimer(p, realargs + 1, retval);
+	case SOCKSYS_SETITIMER:
+		return setitimer(p, realargs + 1, retval);
+
+	default:
+		printf("socksys unknown %08x %08x %08x %08x %08x %08x %08x\n",
+                       realargs[0], realargs[1], realargs[2], realargs[3], 
+                       realargs[4], realargs[5], realargs[6]);
+		return EINVAL;
+	}
+	/* NOTREACHED */
+}
diff --git a/sys/i386/ibcs2/ibcs2_socksys.h b/sys/i386/ibcs2/ibcs2_socksys.h
new file mode 100644
index 000000000000..bc89180b44b4
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_socksys.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 1994, 1995 Scott Bartram
+ * Copyright (c) 1994 Arne H Juul
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef _IBCS2_SOCKSYS_H
+#define _IBCS2_SOCKSYS_H 1
+
+#include <sys/ioccom.h>
+#include <compat/ibcs2/ibcs2_types.h>
+
+#define SOCKSYS_ACCEPT		1
+#define SOCKSYS_BIND		2
+#define SOCKSYS_CONNECT		3
+#define SOCKSYS_GETPEERNAME	4
+#define SOCKSYS_GETSOCKNAME	5
+#define SOCKSYS_GETSOCKOPT	6
+#define SOCKSYS_LISTEN		7
+#define SOCKSYS_RECV		8
+#define SOCKSYS_RECVFROM	9
+#define SOCKSYS_SEND		10
+#define SOCKSYS_SENDTO		11
+#define SOCKSYS_SETSOCKOPT	12
+#define SOCKSYS_SHUTDOWN	13
+#define SOCKSYS_SOCKET		14
+#define SOCKSYS_SELECT		15
+#define SOCKSYS_GETIPDOMAIN	16
+#define SOCKSYS_SETIPDOMAIN	17
+#define SOCKSYS_ADJTIME		18
+#define SOCKSYS_SETREUID	19
+#define SOCKSYS_SETREGID	20
+#define SOCKSYS_GETTIME		21
+#define SOCKSYS_SETTIME		22
+#define SOCKSYS_GETITIMER	23
+#define SOCKSYS_SETITIMER	24
+
+#define IBCS2_SIOCSHIWAT	_IOW('S', 1, int)	
+#define IBCS2_SIOCGHIWAT	_IOR('S', 2, int)	
+#define IBCS2_SIOCSLOWAT	_IOW('S', 3, int)	
+#define IBCS2_SIOCGLOWAT	_IOR('S', 4, int)	
+#define IBCS2_SIOCATMARK	_IOR('S', 5, int)	
+#define IBCS2_SIOCSPGRP		_IOW('S', 6, int)	
+#define IBCS2_SIOCGPGRP		_IOR('S', 7, int)	
+#define IBCS2_FIONREAD		_IOR('S', 8, int)	
+#define IBCS2_FIONBIO		_IOW('S', 9, int)	
+#define IBCS2_FIOASYNC		_IOW('S', 10, int)	
+#define IBCS2_SIOCPROTO		_IOW('S', 11, struct socknewproto)	
+#define IBCS2_SIOCGETNAME	_IOR('S', 12, struct sockaddr)	
+#define IBCS2_SIOCGETPEER	_IOR('S', 13, struct sockaddr)	
+#define IBCS2_IF_UNITSEL	_IOW('S', 14, int)	
+#define IBCS2_SIOCXPROTO	_IO('S', 15)	
+
+#define IBCS2_SIOCADDRT		_IOW('R', 9, struct rtentry)	
+#define IBCS2_SIOCDELRT		_IOW('R', 10, struct rtentry)	
+
+#define IBCS2_SIOCSIFADDR	_IOW('I', 11, struct ifreq)	
+#define IBCS2_SIOCGIFADDR	_IOWR('I', 12, struct ifreq)	
+#define IBCS2_SIOCSIFDSTADDR	_IOW('I', 13, struct ifreq)	
+#define IBCS2_SIOCGIFDSTADDR	_IOWR('I', 14, struct ifreq)	
+#define IBCS2_SIOCSIFFLAGS	_IOW('I', 15, struct ifreq)	
+#define IBCS2_SIOCGIFFLAGS	_IOWR('I', 16, struct ifreq)	
+#define IBCS2_SIOCGIFCONF	_IOWR('I', 17, struct ifconf)	
+#define IBCS2_SIOCSIFMTU	_IOW('I', 21, struct ifreq)	
+#define IBCS2_SIOCGIFMTU	_IOWR('I', 22, struct ifreq)	
+#define IBCS2_SIOCIFDETACH	_IOW('I', 26, struct ifreq)	
+#define IBCS2_SIOCGENPSTATS	_IOWR('I', 27, struct ifreq)	
+#define IBCS2_SIOCX25XMT	_IOWR('I', 29, struct ifreq)
+#define IBCS2_SIOCX25RCV	_IOWR('I', 30, struct ifreq)
+#define IBCS2_SIOCX25TBL	_IOWR('I', 31, struct ifreq)
+#define IBCS2_SIOCGIFBRDADDR	_IOWR('I', 32, struct ifreq)	
+#define IBCS2_SIOCSIFBRDADDR	_IOW('I', 33, struct ifreq)	
+#define IBCS2_SIOCGIFNETMASK	_IOWR('I', 34, struct ifreq)	
+#define IBCS2_SIOCSIFNETMASK	_IOW('I', 35, struct ifreq)	
+#define IBCS2_SIOCGIFMETRIC	_IOWR('I', 36, struct ifreq)	
+#define IBCS2_SIOCSIFMETRIC	_IOW('I', 37, struct ifreq)	
+#define IBCS2_SIOCSARP		_IOW('I', 38, struct arpreq)	
+#define IBCS2_SIOCGARP		_IOWR('I', 39, struct arpreq)	
+#define IBCS2_SIOCDARP		_IOW('I', 40, struct arpreq)	
+#define IBCS2_SIOCSIFNAME	_IOW('I', 41, struct ifreq)	
+#define IBCS2_SIOCGIFONEP	_IOWR('I', 42, struct ifreq)	
+#define IBCS2_SIOCSIFONEP	_IOW('I', 43, struct ifreq)	
+#define IBCS2_SIOCGENADDR	_IOWR('I', 65, struct ifreq)	
+#define IBCS2_SIOCSOCKSYS	_IOW('I', 66, struct socksysreq)	
+
+struct socksysreq {
+	int realargs[7];
+};
+
+struct socknewproto {
+	int family;
+	int type;
+	int proto;
+	ibcs2_dev_t dev;
+	int flags;
+};
+
+#endif /* _IBCS2_SOCKSYS_H */
diff --git a/sys/i386/ibcs2/ibcs2_stat.c b/sys/i386/ibcs2/ibcs2_stat.c
new file mode 100644
index 000000000000..a9d5c4bb0f9f
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_stat.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/mount.h>
+#include <sys/malloc.h>
+#include <sys/vnode.h>
+#include <sys/syscallargs.h>
+
+#include <vm/vm.h>
+
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_fcntl.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_stat.h>
+#include <compat/ibcs2/ibcs2_statfs.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+#include <compat/ibcs2/ibcs2_ustat.h>
+#include <compat/ibcs2/ibcs2_util.h>
+#include <compat/ibcs2/ibcs2_utsname.h>
+
+
+static void
+bsd_stat2ibcs_stat(st, st4)
+	struct ostat *st;
+	struct ibcs2_stat *st4;
+{
+	bzero(st4, sizeof(*st4));
+	st4->st_dev = (ibcs2_dev_t)st->st_dev;
+	st4->st_ino = (ibcs2_ino_t)st->st_ino;
+	st4->st_mode = (ibcs2_mode_t)st->st_mode;
+	st4->st_nlink = (ibcs2_nlink_t)st->st_nlink;
+	st4->st_uid = (ibcs2_uid_t)st->st_uid;
+	st4->st_gid = (ibcs2_gid_t)st->st_gid;
+	st4->st_rdev = (ibcs2_dev_t)st->st_rdev;
+	st4->st_size = (ibcs2_off_t)st->st_size;
+	st4->st_atim = (ibcs2_time_t)st->st_atime;
+	st4->st_mtim = (ibcs2_time_t)st->st_mtime;
+	st4->st_ctim = (ibcs2_time_t)st->st_ctime;
+}
+
+static int
+cvt_statfs(sp, buf, len)
+	struct statfs *sp;
+	caddr_t buf;
+	int len;
+{
+	struct ibcs2_statfs ssfs;
+
+	bzero(&ssfs, sizeof ssfs);
+	ssfs.f_fstyp = 0;
+	ssfs.f_bsize = sp->f_bsize;
+	ssfs.f_frsize = 0;
+	ssfs.f_blocks = sp->f_blocks;
+	ssfs.f_bfree = sp->f_bfree;
+	ssfs.f_files = sp->f_files;
+	ssfs.f_ffree = sp->f_ffree;
+	ssfs.f_fname[0] = 0;
+	ssfs.f_fpack[0] = 0;
+	return copyout((caddr_t)&ssfs, buf, len);
+}	
+
+int
+ibcs2_statfs(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_statfs_args *uap;
+	int *retval;
+{
+	register struct mount *mp;
+	register struct statfs *sp;
+	int error;
+	struct nameidata nd;
+	caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
+	if (error = namei(&nd))
+		return (error);
+	mp = nd.ni_vp->v_mount;
+	sp = &mp->mnt_stat;
+	vrele(nd.ni_vp);
+	if (error = VFS_STATFS(mp, sp, p))
+		return (error);
+	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
+}
+
+int
+ibcs2_fstatfs(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_fstatfs_args *uap;
+	int *retval;
+{
+	struct file *fp;
+	struct mount *mp;
+	register struct statfs *sp;
+	int error;
+
+	if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
+		return (error);
+	mp = ((struct vnode *)fp->f_data)->v_mount;
+	sp = &mp->mnt_stat;
+	if (error = VFS_STATFS(mp, sp, p))
+		return (error);
+	sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+	return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
+}
+
+int
+ibcs2_stat(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_stat_args *uap;
+	int *retval;
+{
+	struct ostat st;
+	struct ibcs2_stat ibcs2_st;
+	struct compat_43_stat_args cup;
+	int error;
+	caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	SCARG(&cup, path) = SCARG(uap, path);
+	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
+	if (error = compat_43_stat(p, &cup, retval))
+		return error;
+	if (error = copyin(SCARG(&cup, ub), &st, sizeof(st)))
+		return error;
+	bsd_stat2ibcs_stat(&st, &ibcs2_st);
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+		       ibcs2_stat_len);
+}
+
+int
+ibcs2_lstat(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_lstat_args *uap;
+	int *retval;
+{
+	struct ostat st;
+	struct ibcs2_stat ibcs2_st;
+	struct compat_43_lstat_args cup;
+	int error;
+	caddr_t sg = stackgap_init();
+
+	CHECKALTEXIST(p, &sg, SCARG(uap, path));
+	SCARG(&cup, path) = SCARG(uap, path);
+	SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
+	if (error = compat_43_lstat(p, &cup, retval))
+		return error;
+	if (error = copyin(SCARG(&cup, ub), &st, sizeof(st)))
+		return error;
+	bsd_stat2ibcs_stat(&st, &ibcs2_st);
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+		       ibcs2_stat_len);
+}
+
+int
+ibcs2_fstat(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_fstat_args *uap;
+	int *retval;
+{
+	struct ostat st;
+	struct ibcs2_stat ibcs2_st;
+	struct compat_43_fstat_args cup;
+	int error;
+	caddr_t sg = stackgap_init();
+
+	SCARG(&cup, fd) = SCARG(uap, fd);
+	SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st));
+	if (error = compat_43_fstat(p, &cup, retval))
+		return error;
+	if (error = copyin(SCARG(&cup, sb), &st, sizeof(st)))
+		return error;
+	bsd_stat2ibcs_stat(&st, &ibcs2_st);
+	return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
+		       ibcs2_stat_len);
+}
+
+int
+ibcs2_utssys(p, uap, retval)
+	struct proc *p;
+	struct ibcs2_utssys_args *uap;
+	int *retval;
+{
+	switch (SCARG(uap, flag)) {
+	case 0:			/* uname(2) */
+	{
+		struct ibcs2_utsname sut;
+		extern char ostype[], machine[], osrelease[];
+
+		bzero(&sut, ibcs2_utsname_len);
+		bcopy(ostype, sut.sysname, sizeof(sut.sysname) - 1);
+		bcopy(hostname, sut.nodename, sizeof(sut.nodename));
+		sut.nodename[sizeof(sut.nodename)-1] = '\0';
+		bcopy(osrelease, sut.release, sizeof(sut.release) - 1);
+		bcopy("1", sut.version, sizeof(sut.version) - 1);
+		bcopy(machine, sut.machine, sizeof(sut.machine) - 1);
+
+		return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, a1),
+			       ibcs2_utsname_len);
+	}
+
+	case 2:			/* ustat(2) */
+	{
+		return ENOSYS;	/* XXX - TODO */
+	}
+
+	default:
+		return ENOSYS;
+	}
+}
diff --git a/sys/i386/ibcs2/ibcs2_stat.h b/sys/i386/ibcs2/ibcs2_stat.h
new file mode 100644
index 000000000000..2eb01027e0cc
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_stat.h
@@ -0,0 +1,89 @@
+/*	$NetBSD: ibcs2_stat.h,v 1.2 1994/10/26 02:53:03 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_STAT_H
+#define	_IBCS2_STAT_H
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+struct ibcs2_stat {
+	ibcs2_dev_t	st_dev;
+	ibcs2_ino_t	st_ino;
+	ibcs2_mode_t	st_mode;
+	ibcs2_nlink_t	st_nlink;
+	ibcs2_uid_t	st_uid;
+	ibcs2_gid_t	st_gid;
+	ibcs2_dev_t	st_rdev;
+	ibcs2_off_t	st_size;
+	ibcs2_time_t	st_atim;
+	ibcs2_time_t	st_mtim;
+	ibcs2_time_t	st_ctim;
+};
+
+#define ibcs2_stat_len	(sizeof(struct ibcs2_stat))
+
+#define IBCS2_S_IFMT		0xf000
+#define IBCS2_S_IFIFO		0x1000
+#define IBCS2_S_IFCHR		0x2000
+#define IBCS2_S_IFDIR		0x4000
+#define IBCS2_S_IFBLK		0x6000
+#define IBCS2_S_IFREG		0x8000
+#define IBCS2_S_IFSOCK		0xc000
+
+#define IBCS2_S_IFNAM		0x5000
+#define IBCS2_S_IFLNK		0xa000
+
+#define IBCS2_S_ISUID		0x0800
+#define IBCS2_S_ISGID		0x0400
+#define IBCS2_S_ISVTX		0x0200
+
+#define IBCS2_S_IRWXU		0x01c0
+#define IBCS2_S_IRUSR		0x0100
+#define IBCS2_S_IWUSR		0x0080
+#define IBCS2_S_IXUSR		0x0040
+#define IBCS2_S_IRWXG		0x0038
+#define IBCS2_S_IRGRP		0x0020
+#define IBCS2_S_IWGRP		0x000f
+#define IBCS2_S_IXGRP		0x0008
+#define IBCS2_S_IRWXO		0x0007
+#define IBCS2_S_IROTH		0x0004
+#define IBCS2_S_IWOTH		0x0002
+#define IBCS2_S_IXOTH		0x0001
+
+#define IBCS2_S_ISFIFO(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFIFO)
+#define IBCS2_S_ISCHR(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFCHR)
+#define IBCS2_S_ISDIR(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFDIR)
+#define IBCS2_S_ISBLK(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFBLK)
+#define IBCS2_S_ISREG(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFREG)
+#define IBCS2_S_ISSOCK(mode)	(((mode) & IBCS2_S_IFMT) == IBCS2_S_IFSOCK)
+
+#endif /* _IBCS2_STAT_H */
diff --git a/sys/i386/ibcs2/ibcs2_statfs.h b/sys/i386/ibcs2/ibcs2_statfs.h
new file mode 100644
index 000000000000..d6e0100c1eb9
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_statfs.h
@@ -0,0 +1,48 @@
+/*	$NetBSD: ibcs2_statfs.h,v 1.2 1994/10/26 02:53:06 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_STATFS_H
+#define	_IBCS2_STATFS_H
+
+struct ibcs2_statfs {
+	short	f_fstyp;
+	long	f_bsize;
+	long	f_frsize;
+	long	f_blocks;
+	long	f_bfree;
+	long	f_files;
+	long	f_ffree;
+	char	f_fname[6];
+	char	f_fpack[6];
+};
+
+#endif /* _IBCS2_STATFS_H */
diff --git a/sys/i386/ibcs2/ibcs2_stropts.h b/sys/i386/ibcs2/ibcs2_stropts.h
new file mode 100644
index 000000000000..4d26e7358265
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_stropts.h
@@ -0,0 +1,48 @@
+/*
+ * ibcs2_stropts.h
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _IBCS2_STROPTS_H
+#define _IBCS2_STROPTS_H
+
+#define IBCS2_STR		('S'<<8)
+#define IBCS2_I_NREAD		(IBCS2_STR|01)
+#define IBCS2_I_PUSH		(IBCS2_STR|02)
+#define IBCS2_I_POP		(IBCS2_STR|03)
+#define IBCS2_I_LOOK		(IBCS2_STR|04)
+#define IBCS2_I_FLUSH		(IBCS2_STR|05)
+#define IBCS2_I_SRDOPT		(IBCS2_STR|06)
+#define IBCS2_I_GRDOPT		(IBCS2_STR|07)
+#define IBCS2_I_STR		(IBCS2_STR|010)
+#define IBCS2_I_SETSIG		(IBCS2_STR|011)
+#define IBCS2_I_GETSIG		(IBCS2_STR|012)
+#define IBCS2_I_FIND		(IBCS2_STR|013)
+#define IBCS2_I_LINK		(IBCS2_STR|014)
+#define IBCS2_I_UNLINK		(IBCS2_STR|015)
+#define IBCS2_I_PEEK		(IBCS2_STR|017)
+#define IBCS2_I_FDINSERT	(IBCS2_STR|020)
+#define IBCS2_I_SENDFD		(IBCS2_STR|021)
+#define IBCS2_I_RECVFD		(IBCS2_STR|022)
+
+#endif /* _IBCS2_STROPTS_H */
diff --git a/sys/i386/ibcs2/ibcs2_syscall.h b/sys/i386/ibcs2/ibcs2_syscall.h
new file mode 100644
index 000000000000..f02ad4242204
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_syscall.h
@@ -0,0 +1,97 @@
+/*
+ * System call numbers.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from	NetBSD: syscalls.master,v 1.4 1995/03/14 15:12:52 scottb Exp 
+ */
+
+#define	IBCS2_SYS_syscall	0
+#define	IBCS2_SYS_exit	1
+#define	IBCS2_SYS_fork	2
+#define	IBCS2_SYS_ibcs2_read	3
+#define	IBCS2_SYS_write	4
+#define	IBCS2_SYS_ibcs2_open	5
+#define	IBCS2_SYS_close	6
+#define	IBCS2_SYS_ibcs2_waitsys	7
+#define	IBCS2_SYS_ibcs2_creat	8
+#define	IBCS2_SYS_link	9
+#define	IBCS2_SYS_ibcs2_unlink	10
+#define	IBCS2_SYS_ibcs2_execv	11
+#define	IBCS2_SYS_ibcs2_chdir	12
+#define	IBCS2_SYS_ibcs2_time	13
+#define	IBCS2_SYS_ibcs2_mknod	14
+#define	IBCS2_SYS_ibcs2_chmod	15
+#define	IBCS2_SYS_ibcs2_chown	16
+#define	IBCS2_SYS_obreak	17
+#define	IBCS2_SYS_ibcs2_stat	18
+#define	IBCS2_SYS_compat_43_lseek	19
+#define	IBCS2_SYS_getpid	20
+#define	IBCS2_SYS_ibcs2_mount	21
+#define	IBCS2_SYS_ibcs2_umount	22
+#define	IBCS2_SYS_ibcs2_setuid	23
+#define	IBCS2_SYS_getuid	24
+#define	IBCS2_SYS_ibcs2_stime	25
+#define	IBCS2_SYS_ibcs2_alarm	27
+#define	IBCS2_SYS_ibcs2_fstat	28
+#define	IBCS2_SYS_ibcs2_pause	29
+#define	IBCS2_SYS_ibcs2_utime	30
+#define	IBCS2_SYS_ibcs2_access	33
+#define	IBCS2_SYS_ibcs2_nice	34
+#define	IBCS2_SYS_ibcs2_statfs	35
+#define	IBCS2_SYS_sync	36
+#define	IBCS2_SYS_ibcs2_kill	37
+#define	IBCS2_SYS_ibcs2_fstatfs	38
+#define	IBCS2_SYS_ibcs2_pgrpsys	39
+#define	IBCS2_SYS_dup	41
+#define	IBCS2_SYS_pipe	42
+#define	IBCS2_SYS_ibcs2_times	43
+#define	IBCS2_SYS_ibcs2_plock	45
+#define	IBCS2_SYS_ibcs2_setgid	46
+#define	IBCS2_SYS_getgid	47
+#define	IBCS2_SYS_ibcs2_sigsys	48
+#define	IBCS2_SYS_ibcs2_msgsys	49
+#define	IBCS2_SYS_ibcs2_shmsys	52
+#define	IBCS2_SYS_ibcs2_semsys	53
+#define	IBCS2_SYS_ibcs2_ioctl	54
+#define	IBCS2_SYS_ibcs2_uadmin	55
+#define	IBCS2_SYS_ibcs2_utssys	57
+#define	IBCS2_SYS_ibcs2_execve	59
+#define	IBCS2_SYS_umask	60
+#define	IBCS2_SYS_chroot	61
+#define	IBCS2_SYS_ibcs2_fcntl	62
+#define	IBCS2_SYS_ibcs2_ulimit	63
+				/* 70 is obsolete rfs_advfs */
+				/* 71 is obsolete rfs_unadvfs */
+				/* 72 is obsolete rfs_rmount */
+				/* 73 is obsolete rfs_rumount */
+				/* 74 is obsolete rfs_rfstart */
+				/* 75 is obsolete rfs_sigret */
+				/* 76 is obsolete rfs_rdebug */
+				/* 77 is obsolete rfs_rfstop */
+#define	IBCS2_SYS_ibcs2_rmdir	79
+#define	IBCS2_SYS_ibcs2_mkdir	80
+#define	IBCS2_SYS_ibcs2_getdents	81
+#define	IBCS2_SYS_ibcs2_sysfs	84
+#define	IBCS2_SYS_ibcs2_getmsg	85
+#define	IBCS2_SYS_ibcs2_putmsg	86
+#define	IBCS2_SYS_ibcs2_poll	87
+#define	IBCS2_SYS_ibcs2_symlink	90
+#define	IBCS2_SYS_ibcs2_lstat	91
+#define	IBCS2_SYS_ibcs2_readlink	92
+#define	IBCS2_SYS_sigreturn	103
+#define	IBCS2_SYS_xenix_rdchk	135
+#define	IBCS2_SYS_xenix_chsize	138
+#define	IBCS2_SYS_xenix_ftime	139
+#define	IBCS2_SYS_xenix_nap	140
+#define	IBCS2_SYS_select	164
+#define	IBCS2_SYS_ibcs2_sigaction	167
+#define	IBCS2_SYS_ibcs2_sigprocmask	168
+#define	IBCS2_SYS_ibcs2_sigpending	169
+#define	IBCS2_SYS_ibcs2_sigsuspend	170
+#define	IBCS2_SYS_ibcs2_getgroups	171
+#define	IBCS2_SYS_ibcs2_setgroups	172
+#define	IBCS2_SYS_ibcs2_sysconf	173
+#define	IBCS2_SYS_ibcs2_pathconf	174
+#define	IBCS2_SYS_ibcs2_fpathconf	175
+#define	IBCS2_SYS_ibcs2_rename	176
+#define	IBCS2_SYS_MAXSYSCALL	177
diff --git a/sys/i386/ibcs2/ibcs2_sysent.c b/sys/i386/ibcs2/ibcs2_sysent.c
new file mode 100644
index 000000000000..c7e9fb338214
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_sysent.c
@@ -0,0 +1,534 @@
+/*
+ * System call switch table.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from	NetBSD: syscalls.master,v 1.4 1995/03/14 15:12:52 scottb Exp 
+ */
+
+#include <sys/param.h>
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_statfs.h>
+#include <sys/systm.h>
+#include <sys/signal.h>
+#include <sys/mount.h>
+#include <sys/syscallargs.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+int	nosys();
+int	exit();
+int	fork();
+int	ibcs2_read();
+int	write();
+int	ibcs2_open();
+int	close();
+int	ibcs2_waitsys();
+int	ibcs2_creat();
+int	link();
+int	ibcs2_unlink();
+int	ibcs2_execv();
+int	ibcs2_chdir();
+int	ibcs2_time();
+int	ibcs2_mknod();
+int	ibcs2_chmod();
+int	ibcs2_chown();
+int	obreak();
+int	ibcs2_stat();
+int	compat_43_lseek();
+int	getpid();
+int	ibcs2_mount();
+int	ibcs2_umount();
+int	ibcs2_setuid();
+int	getuid();
+int	ibcs2_stime();
+int	ibcs2_alarm();
+int	ibcs2_fstat();
+int	ibcs2_pause();
+int	ibcs2_utime();
+int	ibcs2_access();
+int	ibcs2_nice();
+int	ibcs2_statfs();
+int	sync();
+int	ibcs2_kill();
+int	ibcs2_fstatfs();
+int	ibcs2_pgrpsys();
+int	dup();
+int	pipe();
+int	ibcs2_times();
+int	ibcs2_plock();
+int	ibcs2_setgid();
+int	getgid();
+int	ibcs2_sigsys();
+#ifdef SYSVMSG
+int	ibcs2_msgsys();
+#else
+#endif
+#ifdef SYSVSHM
+int	ibcs2_shmsys();
+#else
+#endif
+#ifdef SYSVSEM
+int	ibcs2_semsys();
+#else
+#endif
+int	ibcs2_ioctl();
+int	ibcs2_uadmin();
+int	ibcs2_utssys();
+int	ibcs2_execve();
+int	umask();
+int	chroot();
+int	ibcs2_fcntl();
+int	ibcs2_ulimit();
+int	ibcs2_rmdir();
+int	ibcs2_mkdir();
+int	ibcs2_getdents();
+int	ibcs2_sysfs();
+int	ibcs2_getmsg();
+int	ibcs2_putmsg();
+int	ibcs2_poll();
+int	ibcs2_symlink();
+int	ibcs2_lstat();
+int	ibcs2_readlink();
+int	sigreturn();
+int	xenix_rdchk();
+int	xenix_chsize();
+int	xenix_ftime();
+int	xenix_nap();
+int	select();
+int	ibcs2_sigaction();
+int	ibcs2_sigprocmask();
+int	ibcs2_sigpending();
+int	ibcs2_sigsuspend();
+int	ibcs2_getgroups();
+int	ibcs2_setgroups();
+int	ibcs2_sysconf();
+int	ibcs2_pathconf();
+int	ibcs2_fpathconf();
+int	ibcs2_rename();
+
+#ifdef COMPAT_43
+#define compat_43(func) __CONCAT(compat_43_,func)
+
+#ifdef SYSVMSG
+#else
+#endif
+#ifdef SYSVSHM
+#else
+#endif
+#ifdef SYSVSEM
+#else
+#endif
+
+#else /* COMPAT_43 */
+#define compat_43(func) nosys
+#endif /* COMPAT_43 */
+
+
+#ifdef COMPAT_09
+#define compat_09(func) __CONCAT(compat_09_,func)
+
+#ifdef SYSVMSG
+#else
+#endif
+#ifdef SYSVSHM
+#else
+#endif
+#ifdef SYSVSEM
+#else
+#endif
+
+#else /* COMPAT_09 */
+#define compat_09(func) nosys
+#endif /* COMPAT_09 */
+
+
+#ifdef COMPAT_10
+#define compat_10(func) __CONCAT(compat_10_,func)
+
+#ifdef SYSVMSG
+#else
+#endif
+#ifdef SYSVSHM
+#else
+#endif
+#ifdef SYSVSEM
+#else
+#endif
+
+#else /* COMPAT_10 */
+#define compat_10(func) nosys
+#endif /* COMPAT_10 */
+
+#define	s(type)	sizeof(type)
+
+struct sysent ibcs2_sysent[] = {
+	{ 0, 0,
+	    nosys },				/* 0 = syscall */
+	{ 1, s(struct exit_args),
+	    exit },				/* 1 = exit */
+	{ 0, 0,
+	    fork },				/* 2 = fork */
+	{ 3, s(struct ibcs2_read_args),
+	    ibcs2_read },			/* 3 = ibcs2_read */
+	{ 3, s(struct write_args),
+	    write },				/* 4 = write */
+	{ 3, s(struct ibcs2_open_args),
+	    ibcs2_open },			/* 5 = ibcs2_open */
+	{ 1, s(struct close_args),
+	    close },				/* 6 = close */
+	{ 3, s(struct ibcs2_waitsys_args),
+	    ibcs2_waitsys },			/* 7 = ibcs2_waitsys */
+	{ 2, s(struct ibcs2_creat_args),
+	    ibcs2_creat },			/* 8 = ibcs2_creat */
+	{ 2, s(struct link_args),
+	    link },				/* 9 = link */
+	{ 1, s(struct ibcs2_unlink_args),
+	    ibcs2_unlink },			/* 10 = ibcs2_unlink */
+	{ 2, s(struct ibcs2_execv_args),
+	    ibcs2_execv },			/* 11 = ibcs2_execv */
+	{ 1, s(struct ibcs2_chdir_args),
+	    ibcs2_chdir },			/* 12 = ibcs2_chdir */
+	{ 1, s(struct ibcs2_time_args),
+	    ibcs2_time },			/* 13 = ibcs2_time */
+	{ 3, s(struct ibcs2_mknod_args),
+	    ibcs2_mknod },			/* 14 = ibcs2_mknod */
+	{ 2, s(struct ibcs2_chmod_args),
+	    ibcs2_chmod },			/* 15 = ibcs2_chmod */
+	{ 3, s(struct ibcs2_chown_args),
+	    ibcs2_chown },			/* 16 = ibcs2_chown */
+	{ 1, s(struct obreak_args),
+	    obreak },				/* 17 = obreak */
+	{ 2, s(struct ibcs2_stat_args),
+	    ibcs2_stat },			/* 18 = ibcs2_stat */
+	{ 3, s(struct compat_43_lseek_args),
+	    compat_43_lseek },			/* 19 = compat_43_lseek */
+	{ 0, 0,
+	    getpid },				/* 20 = getpid */
+	{ 6, s(struct ibcs2_mount_args),
+	    ibcs2_mount },			/* 21 = ibcs2_mount */
+	{ 1, s(struct ibcs2_umount_args),
+	    ibcs2_umount },			/* 22 = ibcs2_umount */
+	{ 1, s(struct ibcs2_setuid_args),
+	    ibcs2_setuid },			/* 23 = ibcs2_setuid */
+	{ 0, 0,
+	    getuid },				/* 24 = getuid */
+	{ 1, s(struct ibcs2_stime_args),
+	    ibcs2_stime },			/* 25 = ibcs2_stime */
+	{ 0, 0,
+	    nosys },				/* 26 = unimplemented ibcs2_ptrace */
+	{ 1, s(struct ibcs2_alarm_args),
+	    ibcs2_alarm },			/* 27 = ibcs2_alarm */
+	{ 2, s(struct ibcs2_fstat_args),
+	    ibcs2_fstat },			/* 28 = ibcs2_fstat */
+	{ 0, 0,
+	    ibcs2_pause },			/* 29 = ibcs2_pause */
+	{ 2, s(struct ibcs2_utime_args),
+	    ibcs2_utime },			/* 30 = ibcs2_utime */
+	{ 0, 0,
+	    nosys },				/* 31 = unimplemented was stty */
+	{ 0, 0,
+	    nosys },				/* 32 = unimplemented was gtty */
+	{ 2, s(struct ibcs2_access_args),
+	    ibcs2_access },			/* 33 = ibcs2_access */
+	{ 1, s(struct ibcs2_nice_args),
+	    ibcs2_nice },			/* 34 = ibcs2_nice */
+	{ 4, s(struct ibcs2_statfs_args),
+	    ibcs2_statfs },			/* 35 = ibcs2_statfs */
+	{ 0, 0,
+	    sync },				/* 36 = sync */
+	{ 2, s(struct ibcs2_kill_args),
+	    ibcs2_kill },			/* 37 = ibcs2_kill */
+	{ 4, s(struct ibcs2_fstatfs_args),
+	    ibcs2_fstatfs },			/* 38 = ibcs2_fstatfs */
+	{ 4, s(struct ibcs2_pgrpsys_args),
+	    ibcs2_pgrpsys },			/* 39 = ibcs2_pgrpsys */
+	{ 0, 0,
+	    nosys },				/* 40 = unimplemented ibcs2_xenix */
+	{ 1, s(struct dup_args),
+	    dup },				/* 41 = dup */
+	{ 0, 0,
+	    pipe },				/* 42 = pipe */
+	{ 1, s(struct ibcs2_times_args),
+	    ibcs2_times },			/* 43 = ibcs2_times */
+	{ 0, 0,
+	    nosys },				/* 44 = unimplemented profil */
+	{ 1, s(struct ibcs2_plock_args),
+	    ibcs2_plock },			/* 45 = ibcs2_plock */
+	{ 1, s(struct ibcs2_setgid_args),
+	    ibcs2_setgid },			/* 46 = ibcs2_setgid */
+	{ 0, 0,
+	    getgid },				/* 47 = getgid */
+	{ 2, s(struct ibcs2_sigsys_args),
+	    ibcs2_sigsys },			/* 48 = ibcs2_sigsys */
+#ifdef SYSVMSG
+	{ 6, s(struct ibcs2_msgsys_args),
+	    ibcs2_msgsys },			/* 49 = ibcs2_msgsys */
+#else
+	{ 0, 0,
+	    nosys },				/* 49 = unimplemented nosys */
+#endif
+	{ 0, 0,
+	    nosys },				/* 50 = unimplemented ibcs2_sys3b */
+	{ 0, 0,
+	    nosys },				/* 51 = unimplemented ibcs2_acct */
+#ifdef SYSVSHM
+	{ 4, s(struct ibcs2_shmsys_args),
+	    ibcs2_shmsys },			/* 52 = ibcs2_shmsys */
+#else
+	{ 0, 0,
+	    nosys },				/* 52 = unimplemented nosys */
+#endif
+#ifdef SYSVSEM
+	{ 5, s(struct ibcs2_semsys_args),
+	    ibcs2_semsys },			/* 53 = ibcs2_semsys */
+#else
+	{ 0, 0,
+	    nosys },				/* 53 = unimplemented nosys */
+#endif
+	{ 3, s(struct ibcs2_ioctl_args),
+	    ibcs2_ioctl },			/* 54 = ibcs2_ioctl */
+	{ 3, s(struct ibcs2_uadmin_args),
+	    ibcs2_uadmin },			/* 55 = ibcs2_uadmin */
+	{ 0, 0,
+	    nosys },				/* 56 = unimplemented nosys */
+	{ 3, s(struct ibcs2_utssys_args),
+	    ibcs2_utssys },			/* 57 = ibcs2_utssys */
+	{ 0, 0,
+	    nosys },				/* 58 = unimplemented nosys */
+	{ 3, s(struct ibcs2_execve_args),
+	    ibcs2_execve },			/* 59 = ibcs2_execve */
+	{ 1, s(struct umask_args),
+	    umask },				/* 60 = umask */
+	{ 1, s(struct chroot_args),
+	    chroot },				/* 61 = chroot */
+	{ 3, s(struct ibcs2_fcntl_args),
+	    ibcs2_fcntl },			/* 62 = ibcs2_fcntl */
+	{ 2, s(struct ibcs2_ulimit_args),
+	    ibcs2_ulimit },			/* 63 = ibcs2_ulimit */
+	{ 0, 0,
+	    nosys },				/* 64 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 65 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 66 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 67 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 68 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 69 = unimplemented reserved for unix/pc */
+	{ 0, 0,
+	    nosys },				/* 70 = obsolete rfs_advfs */
+	{ 0, 0,
+	    nosys },				/* 71 = obsolete rfs_unadvfs */
+	{ 0, 0,
+	    nosys },				/* 72 = obsolete rfs_rmount */
+	{ 0, 0,
+	    nosys },				/* 73 = obsolete rfs_rumount */
+	{ 0, 0,
+	    nosys },				/* 74 = obsolete rfs_rfstart */
+	{ 0, 0,
+	    nosys },				/* 75 = obsolete rfs_sigret */
+	{ 0, 0,
+	    nosys },				/* 76 = obsolete rfs_rdebug */
+	{ 0, 0,
+	    nosys },				/* 77 = obsolete rfs_rfstop */
+	{ 0, 0,
+	    nosys },				/* 78 = unimplemented rfs_rfsys */
+	{ 1, s(struct ibcs2_rmdir_args),
+	    ibcs2_rmdir },			/* 79 = ibcs2_rmdir */
+	{ 2, s(struct ibcs2_mkdir_args),
+	    ibcs2_mkdir },			/* 80 = ibcs2_mkdir */
+	{ 3, s(struct ibcs2_getdents_args),
+	    ibcs2_getdents },			/* 81 = ibcs2_getdents */
+	{ 0, 0,
+	    nosys },				/* 82 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 83 = unimplemented nosys */
+	{ 3, s(struct ibcs2_sysfs_args),
+	    ibcs2_sysfs },			/* 84 = ibcs2_sysfs */
+	{ 4, s(struct ibcs2_getmsg_args),
+	    ibcs2_getmsg },			/* 85 = ibcs2_getmsg */
+	{ 4, s(struct ibcs2_putmsg_args),
+	    ibcs2_putmsg },			/* 86 = ibcs2_putmsg */
+	{ 3, s(struct ibcs2_poll_args),
+	    ibcs2_poll },			/* 87 = ibcs2_poll */
+	{ 0, 0,
+	    nosys },				/* 88 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 89 = unimplemented nosys */
+	{ 2, s(struct ibcs2_symlink_args),
+	    ibcs2_symlink },			/* 90 = ibcs2_symlink */
+	{ 2, s(struct ibcs2_lstat_args),
+	    ibcs2_lstat },			/* 91 = ibcs2_lstat */
+	{ 3, s(struct ibcs2_readlink_args),
+	    ibcs2_readlink },			/* 92 = ibcs2_readlink */
+	{ 0, 0,
+	    nosys },				/* 93 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 94 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 95 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 96 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 97 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 98 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 99 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 100 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 101 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 102 = unimplemented nosys */
+	{ 1, s(struct sigreturn_args),
+	    sigreturn },			/* 103 = sigreturn */
+	{ 0, 0,
+	    nosys },				/* 104 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 105 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 106 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 107 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 108 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 109 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 110 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 111 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 112 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 113 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 114 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 115 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 116 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 117 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 118 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 119 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 120 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 121 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 122 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 123 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 124 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 125 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 126 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 127 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 128 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 129 = unimplemented xenix_xlocking */
+	{ 0, 0,
+	    nosys },				/* 130 = unimplemented xenix_creatsem */
+	{ 0, 0,
+	    nosys },				/* 131 = unimplemented xenix_opensem */
+	{ 0, 0,
+	    nosys },				/* 132 = unimplemented xenix_sigsem */
+	{ 0, 0,
+	    nosys },				/* 133 = unimplemented xenix_waitsem */
+	{ 0, 0,
+	    nosys },				/* 134 = unimplemented xenix_nbwaitsem */
+	{ 1, s(struct xenix_rdchk_args),
+	    xenix_rdchk },			/* 135 = xenix_rdchk */
+	{ 0, 0,
+	    nosys },				/* 136 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 137 = unimplemented nosys */
+	{ 2, s(struct xenix_chsize_args),
+	    xenix_chsize },			/* 138 = xenix_chsize */
+	{ 1, s(struct xenix_ftime_args),
+	    xenix_ftime },			/* 139 = xenix_ftime */
+	{ 1, s(struct xenix_nap_args),
+	    xenix_nap },			/* 140 = xenix_nap */
+	{ 0, 0,
+	    nosys },				/* 141 = unimplemented xenix_sdget */
+	{ 0, 0,
+	    nosys },				/* 142 = unimplemented xenix_sdfree */
+	{ 0, 0,
+	    nosys },				/* 143 = unimplemented xenix_sdenter */
+	{ 0, 0,
+	    nosys },				/* 144 = unimplemented xenix_sdleave */
+	{ 0, 0,
+	    nosys },				/* 145 = unimplemented xenix_sdgetv */
+	{ 0, 0,
+	    nosys },				/* 146 = unimplemented xenix_sdwaitv */
+	{ 0, 0,
+	    nosys },				/* 147 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 148 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 149 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 150 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 151 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 152 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 153 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 154 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 155 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 156 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 157 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 158 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 159 = unimplemented nosys */
+	{ 0, 0,
+	    nosys },				/* 160 = unimplemented xenix_proctl */
+	{ 0, 0,
+	    nosys },				/* 161 = unimplemented xenix_execseg */
+	{ 0, 0,
+	    nosys },				/* 162 = unimplemented xenix_unexecseg */
+	{ 0, 0,
+	    nosys },				/* 163 = unimplemented nosys */
+	{ 5, s(struct select_args),
+	    select },				/* 164 = select */
+	{ 0, 0,
+	    nosys },				/* 165 = unimplemented xenix_eaccess */
+	{ 0, 0,
+	    nosys },				/* 166 = unimplemented xenix_paccess */
+	{ 3, s(struct ibcs2_sigaction_args),
+	    ibcs2_sigaction },			/* 167 = ibcs2_sigaction */
+	{ 3, s(struct ibcs2_sigprocmask_args),
+	    ibcs2_sigprocmask },		/* 168 = ibcs2_sigprocmask */
+	{ 1, s(struct ibcs2_sigpending_args),
+	    ibcs2_sigpending },			/* 169 = ibcs2_sigpending */
+	{ 1, s(struct ibcs2_sigsuspend_args),
+	    ibcs2_sigsuspend },			/* 170 = ibcs2_sigsuspend */
+	{ 2, s(struct ibcs2_getgroups_args),
+	    ibcs2_getgroups },			/* 171 = ibcs2_getgroups */
+	{ 2, s(struct ibcs2_setgroups_args),
+	    ibcs2_setgroups },			/* 172 = ibcs2_setgroups */
+	{ 1, s(struct ibcs2_sysconf_args),
+	    ibcs2_sysconf },			/* 173 = ibcs2_sysconf */
+	{ 2, s(struct ibcs2_pathconf_args),
+	    ibcs2_pathconf },			/* 174 = ibcs2_pathconf */
+	{ 2, s(struct ibcs2_fpathconf_args),
+	    ibcs2_fpathconf },			/* 175 = ibcs2_fpathconf */
+	{ 2, s(struct ibcs2_rename_args),
+	    ibcs2_rename },			/* 176 = ibcs2_rename */
+};
+
diff --git a/sys/i386/ibcs2/ibcs2_termios.h b/sys/i386/ibcs2/ibcs2_termios.h
new file mode 100644
index 000000000000..35602cf999d9
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_termios.h
@@ -0,0 +1,235 @@
+/*	$NetBSD: ibcs2_termios.h,v 1.3 1994/10/26 02:53:07 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_TERMIOS_H
+#define	_IBCS2_TERMIOS_H	1
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+#define IBCS2_NCC	8
+#define IBCS2_NCCS	13
+
+typedef u_short	ibcs2_tcflag_t;
+typedef u_char	ibcs2_cc_t;
+typedef u_long	ibcs2_speed_t;
+
+struct ibcs2_termio {
+	u_short	c_iflag;
+	u_short	c_oflag;
+	u_short	c_cflag;
+	u_short	c_lflag;
+	char	c_line;
+	u_char	c_cc[IBCS2_NCC];
+};
+
+struct ibcs2_termios {
+	ibcs2_tcflag_t	c_iflag;
+	ibcs2_tcflag_t	c_oflag;
+	ibcs2_tcflag_t	c_cflag;
+	ibcs2_tcflag_t	c_lflag;
+	char		c_line;
+	ibcs2_cc_t	c_cc[IBCS2_NCCS];
+	char		c_ispeed;
+	char		c_ospeed;
+};
+
+#define IBCS2_VINTR		0
+#define IBCS2_VQUIT		1
+#define IBCS2_VERASE		2
+#define IBCS2_VKILL		3
+#define IBCS2_VEOF		4
+#define IBCS2_VEOL		5
+#define IBCS2_VEOL2		6
+#define IBCS2_VMIN		4
+#define IBCS2_VTIME		5
+#define IBCS2_VSWTCH		7
+#define IBCS2_VSUSP		10
+#define IBCS2_VSTART		11
+#define IBCS2_VSTOP		12
+
+#define IBCS2_CNUL		0
+#define IBCS2_CDEL		0377
+#define IBCS2_CESC		'\\'
+#define IBCS2_CINTR		0177
+#define IBCS2_CQUIT		034
+#define IBCS2_CERASE		'#'
+#define IBCS2_CKILL		'@'
+#define IBCS2_CSTART		021
+#define IBCS2_CSTOP		023
+#define IBCS2_CSWTCH		032
+#define IBCS2_CNSWTCH		0
+#define IBCS2_CSUSP		032
+
+#define IBCS2_IGNBRK		0000001
+#define IBCS2_BRKINT		0000002
+#define IBCS2_IGNPAR		0000004
+#define IBCS2_PARMRK		0000010
+#define IBCS2_INPCK		0000020
+#define IBCS2_ISTRIP		0000040
+#define IBCS2_INLCR		0000100
+#define IBCS2_IGNCR		0000200
+#define IBCS2_ICRNL		0000400
+#define IBCS2_IUCLC		0001000
+#define IBCS2_IXON		0002000
+#define IBCS2_IXANY		0004000
+#define IBCS2_IXOFF		0010000
+#define IBCS2_IMAXBEL		0020000
+#define IBCS2_DOSMODE		0100000
+
+#define IBCS2_OPOST		0000001
+#define IBCS2_OLCUC		0000002
+#define IBCS2_ONLCR		0000004
+#define IBCS2_OCRNL		0000010
+#define IBCS2_ONOCR		0000020
+#define IBCS2_ONLRET		0000040
+#define IBCS2_OFILL		0000100
+#define IBCS2_OFDEL		0000200
+#define IBCS2_NLDLY		0000400
+#define IBCS2_NL0		0000000
+#define IBCS2_NL1		0000400
+#define IBCS2_CRDLY		0003000
+#define IBCS2_CR0		0000000
+#define IBCS2_CR1		0001000
+#define IBCS2_CR2		0002000
+#define IBCS2_CR3		0003000
+#define IBCS2_TABDLY		0014000
+#define IBCS2_TAB0		0000000
+#define IBCS2_TAB1		0004000
+#define IBCS2_TAB2		0010000
+#define IBCS2_TAB3		0014000
+#define IBCS2_BSDLY		0020000
+#define IBCS2_BS0		0000000
+#define IBCS2_BS1		0020000
+#define IBCS2_VTDLY		0040000
+#define IBCS2_VT0		0000000
+#define IBCS2_VT1		0040000
+#define IBCS2_FFDLY		0100000
+#define IBCS2_FF0		0000000
+#define IBCS2_FF1		0100000
+
+#define IBCS2_CBAUD		0000017
+#define IBCS2_CSIZE		0000060
+#define IBCS2_CS5		0000000
+#define IBCS2_CS6		0000020
+#define IBCS2_CS7		0000040
+#define IBCS2_CS8		0000060
+#define IBCS2_CSTOPB		0000100
+#define IBCS2_CREAD		0000200
+#define IBCS2_PARENB		0000400
+#define IBCS2_PARODD		0001000
+#define IBCS2_HUPCL		0002000
+#define IBCS2_CLOCAL		0004000
+#define IBCS2_RCV1EN		0010000
+#define IBCS2_XMT1EN		0020000
+#define IBCS2_LOBLK		0040000
+#define IBCS2_XCLUDE		0100000
+
+#define IBCS2_ISIG		0000001
+#define IBCS2_ICANON		0000002
+#define IBCS2_XCASE		0000004
+#define IBCS2_ECHO		0000010
+#define IBCS2_ECHOE		0000020
+#define IBCS2_ECHOK		0000040
+#define IBCS2_ECHONL		0000100
+#define IBCS2_NOFLSH		0000200
+#define IBCS2_IEXTEN		0000400
+#define IBCS2_TOSTOP		0001000
+
+#define IBCS2_XIOC		(('i'<<24)|('X'<<16))
+#define IBCS2_XCGETA  		(IBCS2_XIOC|1)
+#define IBCS2_XCSETA  		(IBCS2_XIOC|2)
+#define IBCS2_XCSETAW 		(IBCS2_XIOC|3)
+#define IBCS2_XCSETAF 		(IBCS2_XIOC|4)
+
+#define IBCS2_OXIOC		('x'<<8)
+#define IBCS2_OXCGETA  		(IBCS2_OXIOC|1)
+#define IBCS2_OXCSETA  		(IBCS2_OXIOC|2)
+#define IBCS2_OXCSETAW 		(IBCS2_OXIOC|3)
+#define IBCS2_OXCSETAF 		(IBCS2_OXIOC|4)
+
+#define IBCS2_TIOC		('T'<<8)
+#define IBCS2_TCGETA  		(IBCS2_TIOC|1)
+#define IBCS2_TCSETA  		(IBCS2_TIOC|2)
+#define IBCS2_TCSETAW 		(IBCS2_TIOC|3)
+#define IBCS2_TCSETAF 		(IBCS2_TIOC|4)
+#define IBCS2_TCSBRK  		(IBCS2_TIOC|5)
+#define IBCS2_TCXONC  		(IBCS2_TIOC|6)
+#define IBCS2_TCFLSH  		(IBCS2_TIOC|7)
+
+#define IBCS2_TCGETSC		(IBCS2_TIOC|34)
+#define IBCS2_TCSETSC		(IBCS2_TIOC|35)
+
+#define IBCS2_TIOCSWINSZ	(IBCS2_TIOC|103)
+#define IBCS2_TIOCGWINSZ	(IBCS2_TIOC|104)
+#define IBCS2_TIOCSPGRP		(IBCS2_TIOC|118)
+#define IBCS2_TIOCGPGRP		(IBCS2_TIOC|119)
+
+#define IBCS2_TCSANOW		IBCS2_XCSETA
+#define IBCS2_TCSADRAIN		IBCS2_XCSETAW
+#define IBCS2_TCSAFLUSH		IBCS2_XCSETAF
+#define IBCS2_TCSADFLUSH	IBCS2_XCSETAF
+
+#define IBCS2_TCIFLUSH		0
+#define IBCS2_TCOFLUSH		1
+#define IBCS2_TCIOFLUSH		2
+
+#define IBCS2_TCOOFF		0
+#define IBCS2_TCOON		1
+#define IBCS2_TCIOFF		2
+#define IBCS2_TCION		3
+
+#define IBCS2_B0		0
+#define IBCS2_B50		1
+#define IBCS2_B75		2
+#define IBCS2_B110		3
+#define IBCS2_B134		4
+#define IBCS2_B150		5
+#define IBCS2_B200		6
+#define IBCS2_B300		7
+#define IBCS2_B600		8
+#define IBCS2_B1200		9
+#define IBCS2_B1800		10
+#define IBCS2_B2400		11
+#define IBCS2_B4800		12
+#define IBCS2_B9600		13
+#define IBCS2_B19200		14
+#define IBCS2_B38400		15
+
+struct ibcs2_winsize {
+        u_short ws_row;
+        u_short ws_col;
+        u_short ws_xpixel;
+        u_short ws_ypixel;
+};
+
+#endif /* _IBCS2_H_ */
+
diff --git a/sys/i386/ibcs2/ibcs2_time.h b/sys/i386/ibcs2/ibcs2_time.h
new file mode 100644
index 000000000000..a3b669b6ae3f
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_time.h
@@ -0,0 +1,50 @@
+/*	$NetBSD: ibcs2_time.h,v 1.2 1994/10/26 02:53:08 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_TIME_H
+#define	_IBCS2_TIME_H
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+struct ibcs2_tm {
+	int	tm_sec;
+	int	tm_min;
+	int	tm_hour;
+	int	tm_mday;
+	int	tm_mon;
+	int	tm_year;
+	int	tm_wday;
+	int	tm_yday;
+	int	tm_isdst;
+};
+
+#endif /* _IBCS2_TIME_H */
diff --git a/sys/i386/ibcs2/ibcs2_timeb.h b/sys/i386/ibcs2/ibcs2_timeb.h
new file mode 100644
index 000000000000..d85202d91725
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_timeb.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_TIMEB_H
+#define	_IBCS2_TIMEB_H
+
+#pragma pack(2) 
+struct xenix_timeb {
+        ibcs2_time_t time;
+	unsigned short millitm;
+	short timezone;
+	short dstflag;
+};
+#pragma pack()
+
+#define xenix_timeb_len 10      /* packed struct */
+
+#endif /* _IBCS2_TIMEB_H */
diff --git a/sys/i386/ibcs2/ibcs2_types.h b/sys/i386/ibcs2/ibcs2_types.h
new file mode 100644
index 000000000000..305a1fc6f440
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_types.h
@@ -0,0 +1,54 @@
+/*	$NetBSD: ibcs2_types.h,v 1.5 1995/08/14 01:11:54 mycroft Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_TYPES_H
+#define	_IBCS2_TYPES_H
+
+typedef unsigned char	ibcs2_uchar_t;
+typedef unsigned long	ibcs2_ulong_t;
+
+typedef char *		ibcs2_caddr_t;
+typedef long		ibcs2_daddr_t;
+typedef long		ibcs2_off_t;
+typedef long		ibcs2_key_t;
+typedef unsigned short	ibcs2_uid_t;
+typedef unsigned short	ibcs2_gid_t;
+typedef short		ibcs2_nlink_t;
+typedef short		ibcs2_dev_t;
+typedef unsigned short	ibcs2_ino_t;
+typedef unsigned int	ibcs2_size_t;
+typedef long		ibcs2_time_t;
+typedef long		ibcs2_clock_t;
+typedef unsigned short	ibcs2_mode_t;
+typedef short		ibcs2_pid_t;
+
+#endif /* _IBCS2_TYPES_H */
diff --git a/sys/i386/ibcs2/ibcs2_unistd.h b/sys/i386/ibcs2/ibcs2_unistd.h
new file mode 100644
index 000000000000..1a0dd6694128
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_unistd.h
@@ -0,0 +1,75 @@
+/*	$NetBSD: ibcs2_unistd.h,v 1.2 1994/10/26 02:53:11 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_UNISTD_H
+#define	_IBCS2_UNISTD_H
+
+#define IBCS2_R_OK		4
+#define IBCS2_W_OK		2
+#define IBCS2_X_OK		1
+#define IBCS2_F_OK		0
+
+#define IBCS2_F_ULOCK		0
+#define IBCS2_F_LOCK		1
+#define IBCS2_F_TLOCK		2
+#define IBCS2_F_TEST		3
+
+#define IBCS2_SEEK_SET		0
+#define IBCS2_SEEK_CUR		1
+#define IBCS2_SEEK_END		2
+
+#define IBCS2_SC_ARG_MAX		0
+#define IBCS2_SC_CHILD_MAX		1
+#define IBCS2_SC_CLK_TCK		2
+#define IBCS2_SC_NGROUPS_MAX		3
+#define IBCS2_SC_OPEN_MAX		4
+#define IBCS2_SC_JOB_CONTROL		5
+#define IBCS2_SC_SAVED_IDS		6
+#define IBCS2_SC_VERSION		7
+#define IBCS2_SC_PASS_MAX		8
+#define IBCS2_SC_XOPEN_VERSION		9
+
+#define IBCS2_PC_LINK_MAX		0
+#define IBCS2_PC_MAX_CANON		1
+#define IBCS2_PC_MAX_INPUT		2
+#define IBCS2_PC_NAME_MAX		3
+#define IBCS2_PC_PATH_MAX		4
+#define IBCS2_PC_PIPE_BUF		5
+#define IBCS2_PC_CHOWN_RESTRICTED	6
+#define IBCS2_PC_NO_TRUNC		7
+#define IBCS2_PC_VDISABLE		8
+
+#define IBCS2_STDIN_FILENO		0
+#define IBCS2_STDOUT_FILENO		1
+#define IBCS2_STDERR_FILENO		2
+
+#endif /* _IBCS2_UNISTD_H */
diff --git a/sys/i386/ibcs2/ibcs2_ustat.h b/sys/i386/ibcs2/ibcs2_ustat.h
new file mode 100644
index 000000000000..03c714635918
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_ustat.h
@@ -0,0 +1,46 @@
+/*	$NetBSD: ibcs2_ustat.h,v 1.2 1994/10/26 02:53:13 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _IBCS2_USTAT_H
+#define _IBCS2_USTAT_H 1
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+struct ibcs2_ustat {
+	long		f_tfree;
+	ibcs2_ino_t	f_tinode;
+	char		f_fname[6];
+	char		f_fpack[6];
+};
+#define ibcs2_ustat_len	(sizeof(struct ibcs2_ustat))
+
+#endif /* _IBCS2_USTAT_H */
diff --git a/sys/i386/ibcs2/ibcs2_util.c b/sys/i386/ibcs2/ibcs2_util.c
new file mode 100644
index 000000000000..69937acda294
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_util.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 1994 Christos Zoulas
+ * Copyright (c) 1995 Frank van der Linden
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	from: svr4_util.c,v 1.5 1995/01/22 23:44:50 christos Exp
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/filedesc.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/vnode.h>
+
+#include <compat/ibcs2/ibcs2_util.h>
+
+const char      ibcs2_emul_path[] = "/emul/ibcs2";
+
+/*
+ * Search an alternate path before passing pathname arguments on
+ * to system calls. Useful for keeping a seperate 'emulation tree'.
+ *
+ * If cflag is set, we check if an attempt can be made to create
+ * the named file, i.e. we check if the directory it should
+ * be in exists.
+ */
+int
+ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag)
+	struct proc	 *p;
+	caddr_t		 *sgp;		/* Pointer to stackgap memory */
+	const char	 *prefix;
+	char		 *path;
+	char		**pbuf;
+	int		  cflag;
+{
+	struct nameidata	 nd;
+	struct nameidata	 ndroot;
+	struct vattr		 vat;
+	struct vattr		 vatroot;
+	int			 error;
+	char			*ptr, *buf, *cp;
+	size_t			 sz, len;
+
+	buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
+	*pbuf = path;
+
+	for (ptr = buf; (*ptr = *prefix) != '\0'; ptr++, prefix++)
+		continue;
+
+	sz = MAXPATHLEN - (ptr - buf);
+
+	/* 
+	 * If sgp is not given then the path is already in kernel space
+	 */
+	if (sgp == NULL)
+		error = copystr(path, ptr, sz, &len);
+	else
+		error = copyinstr(path, ptr, sz, &len);
+
+	if (error) {
+		free(buf, M_TEMP);
+		return error;
+	}
+
+	if (*ptr != '/') {
+		free(buf, M_TEMP);
+		return EINVAL;
+	}
+
+	/*
+	 * We know that there is a / somewhere in this pathname.
+	 * Search backwards for it, to find the file's parent dir
+	 * to see if it exists in the alternate tree. If it does,
+	 * and we want to create a file (cflag is set). We don't
+	 * need to worry about the root comparison in this case.
+	 */
+
+	if (cflag) {
+		for (cp = &ptr[len] - 1; *cp != '/'; cp--);
+		*cp = '\0';
+
+		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);
+
+		if ((error = namei(&nd)) != 0) {
+			free(buf, M_TEMP);
+			return error;
+		}
+
+		*cp = '/';
+	}
+	else {
+		NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p);
+
+		if ((error = namei(&nd)) != 0) {
+			free(buf, M_TEMP);
+			return error;
+		}
+
+		/*
+		 * We now compare the vnode of the ibcs2_root to the one
+		 * vnode asked. If they resolve to be the same, then we
+		 * ignore the match so that the real root gets used.
+		 * This avoids the problem of traversing "../.." to find the
+		 * root directory and never finding it, because "/" resolves
+		 * to the emulation root directory. This is expensive :-(
+		 */
+		/* XXX: prototype should have const here for NDINIT */
+		NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, 
+		       (char *) ibcs2_emul_path, p);
+
+		if ((error = namei(&ndroot)) != 0) {
+			/* Cannot happen! */
+			free(buf, M_TEMP);
+			vrele(nd.ni_vp);
+			return error;
+		}
+
+		if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) {
+			goto done;
+		}
+
+		if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p))
+		    != 0) {
+			goto done;
+		}
+
+		if (vat.va_fsid == vatroot.va_fsid &&
+		    vat.va_fileid == vatroot.va_fileid) {
+			error = ENOENT;
+			goto done;
+		}
+
+	}
+	if (sgp == NULL)
+		*pbuf = buf;
+	else {
+		sz = &ptr[len] - buf;
+		*pbuf = stackgap_alloc(sgp, sz + 1);
+		error = copyout(buf, *pbuf, sz);
+		free(buf, M_TEMP);
+	}
+
+
+done:
+	vrele(nd.ni_vp);
+	if (!cflag)
+		vrele(ndroot.ni_vp);
+	return error;
+}
diff --git a/sys/i386/ibcs2/ibcs2_util.h b/sys/i386/ibcs2/ibcs2_util.h
new file mode 100644
index 000000000000..6aa4e8c9a503
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_util.h
@@ -0,0 +1,82 @@
+
+/*
+ * Copyright (c) 1994 Christos Zoulas
+ * Copyright (c) 1995 Frank van der Linden
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * from: svr4_util.h,v 1.5 1994/11/18 02:54:31 christos Exp
+ * from: linux_util.h,v 1.2 1995/03/05 23:23:50 fvdl Exp
+ */
+
+/*
+ * This file is pretty much the same as Christos' svr4_util.h
+ * (for now).
+ */
+
+#ifndef	_IBCS2_UTIL_H_
+#define	_IBCS2_UTIL_H_
+
+#include <machine/vmparam.h>
+#include <sys/exec.h>
+#include <sys/cdefs.h>
+
+static __inline caddr_t
+stackgap_init()
+{
+	extern char     sigcode[], esigcode[];
+#define szsigcode ((caddr_t)(esigcode - sigcode))
+	return STACKGAPBASE;
+}
+
+
+static __inline void *
+stackgap_alloc(sgp, sz)
+	caddr_t	*sgp;
+	size_t   sz;
+{
+	void	*p = (void *) *sgp;
+	*sgp += ALIGN(sz);
+	return p;
+}
+
+#ifdef DEBUG_IBCS2
+#define DPRINTF(a)      printf a;
+#else
+#define DPRINTF(a)
+#endif
+
+extern const char ibcs2_emul_path[];
+
+int ibcs2_emul_find __P((struct proc *, caddr_t *, const char *, char *,
+			char **, int));
+
+#define CHECKALTEXIST(p, sgp, path) \
+    ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 0)
+
+#define CHECKALTCREAT(p, sgp, path) \
+    ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 1)
+
+#endif /* !_IBCS2_UTIL_H_ */
diff --git a/sys/i386/ibcs2/ibcs2_utime.h b/sys/i386/ibcs2/ibcs2_utime.h
new file mode 100644
index 000000000000..02d83150a27a
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_utime.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1995 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_UTIME_H
+#define	_IBCS2_UTIME_H
+
+#include <compat/ibcs2/ibcs2_types.h>
+
+struct ibcs2_utimbuf {
+        ibcs2_time_t actime;
+	ibcs2_time_t modtime;
+};
+
+#endif /* _IBCS2_UTIME_H */
diff --git a/sys/i386/ibcs2/ibcs2_utsname.h b/sys/i386/ibcs2/ibcs2_utsname.h
new file mode 100644
index 000000000000..4f2ee68f7a9b
--- /dev/null
+++ b/sys/i386/ibcs2/ibcs2_utsname.h
@@ -0,0 +1,45 @@
+/*	$NetBSD: ibcs2_utsname.h,v 1.2 1994/10/26 02:53:14 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994 Scott Bartram
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Scott Bartram.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef	_IBCS2_UTSNAME_H
+#define	_IBCS2_UTSNAME_H
+
+struct ibcs2_utsname {
+	char	sysname[9];
+	char	nodename[9];
+	char	release[9];
+	char	version[9];
+	char	machine[9];
+};
+#define ibcs2_utsname_len	(sizeof(struct ibcs2_utsname))
+
+#endif /* _IBCS2_UTSNAME_H */
diff --git a/sys/i386/ibcs2/syscalls.conf b/sys/i386/ibcs2/syscalls.conf
new file mode 100644
index 000000000000..7f46f4433407
--- /dev/null
+++ b/sys/i386/ibcs2/syscalls.conf
@@ -0,0 +1,12 @@
+#	syscalls.conf
+
+sysnames="ibcs2_syscalls.c"
+sysnumhdr="ibcs2_syscall.h"
+syssw="ibcs2_sysent.c"
+sysarghdr="ibcs2_syscallargs.h"
+compatopts="compat_43 compat_09 compat_10"
+libcompatopts=""
+
+switchname="ibcs2_sysent"
+namesname="ibcs2_syscallnames"
+constprefix="IBCS2_SYS_"
diff --git a/sys/i386/ibcs2/syscalls.master b/sys/i386/ibcs2/syscalls.master
new file mode 100644
index 000000000000..db907d72e555
--- /dev/null
+++ b/sys/i386/ibcs2/syscalls.master
@@ -0,0 +1,243 @@
+	$NetBSD: syscalls.master,v 1.4 1995/03/14 15:12:52 scottb Exp $
+
+;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
+; System call name/number master file (or rather, slave, from IBCS2).
+; Processed to created ibcs2_sysent.c, ibcs2_syscalls.c and ibcs2_syscall.h.
+
+; Columns: number type nargs name altname/comments
+;	number	system call number, must be in order
+;	type	one of STD, OBSOL, UNIMPL, STD
+;	nargs	number of arguments
+;	name	name of syscall routine
+;	altname	name of system call if different
+;		for UNIMPL/OBSOL, name continues with comments
+
+#include <sys/param.h>
+#include <compat/ibcs2/ibcs2_types.h>
+#include <compat/ibcs2/ibcs2_signal.h>
+#include <compat/ibcs2/ibcs2_statfs.h>
+#include <sys/systm.h>
+#include <sys/signal.h>
+#include <sys/mount.h>
+#include <sys/syscallargs.h>
+#include <compat/ibcs2/ibcs2_syscallargs.h>
+
+; types:
+;	STD	always included
+;	STD	included on COMPAT #ifdef
+;	LIBSTD included on COMPAT #ifdef, and placed in syscall.h
+;	OBSOL	obsolete, not included in system, only specifies name
+;	UNIMPL	not implemented, placeholder only
+
+; #ifdef's, etc. may be included, and are copied to the output files.
+
+0	NOARGS		{ int nosys(void); } syscall
+1	NOARGS		{ int exit(int rval); }
+2	NOARGS		{ int fork(void); }
+3	STD		{ int ibcs2_read(int fd, char *buf, u_int nbytes); }
+4	NOARGS		{ int write(int fd, char *buf, u_int nbytes); }
+5	STD		{ int ibcs2_open(char *path, int flags, int mode); }
+6	NOARGS		{ int close(int fd); }
+7	STD		{ int ibcs2_waitsys(int a1, int a2, int a3); }
+8	STD		{ int ibcs2_creat(char *path, int mode); }
+9	NOARGS		{ int link(char *path, char *link); }
+10	STD		{ int ibcs2_unlink(char *path); }
+11	STD		{ int ibcs2_execv(char *path, char **argp); }
+12	STD		{ int ibcs2_chdir(char *path); }
+13	STD		{ int ibcs2_time(ibcs2_time_t *tp); }
+14	STD		{ int ibcs2_mknod(char* path, int mode, int dev); }
+15	STD		{ int ibcs2_chmod(char *path, int mode); }
+16	STD		{ int ibcs2_chown(char *path, int uid, int gid); }
+17	NOARGS		{ int obreak(caddr_t nsize); }
+18	STD		{ int ibcs2_stat(char* path, struct ibcs2_stat *st); }
+19	NOARGS		{ long compat_43_lseek(int fd, long offset, \
+					       int whence); }
+20	NOARGS		{ pid_t getpid(void); }
+21	STD		{ int ibcs2_mount(char *special, char *dir, int flags, \
+				      int fstype, char *data, int len); }
+22	STD		{ int ibcs2_umount(char *name); }
+23	STD		{ int ibcs2_setuid(int uid); }
+24	NOARGS		{ uid_t getuid(void); }
+25	STD		{ int ibcs2_stime(long *timep); }
+26	UNIMPL		ibcs2_ptrace
+27	STD		{ int ibcs2_alarm(unsigned sec); }
+28	STD		{ int ibcs2_fstat(int fd, struct ibcs2_stat *st); }
+29	STD		{ int ibcs2_pause(void); }
+30	STD		{ int ibcs2_utime(char *path, \
+					  struct ibcs2_utimbuf *buf); }
+31	UNIMPL		was stty
+32	UNIMPL		was gtty
+33	STD		{ int ibcs2_access(char *path, int flags); }
+34	STD		{ int ibcs2_nice(int incr); }
+35	STD		{ int ibcs2_statfs(char *path, \
+					   struct ibcs2_statfs *buf, \
+					   int len, int fstype); }
+36	NOARGS		{ int sync(void); }
+37	STD		{ int ibcs2_kill(int pid, int signo); }
+38	STD		{ int ibcs2_fstatfs(int fd, struct ibcs2_statfs *buf, \
+					    int len, int fstype); }
+39	STD		{ int ibcs2_pgrpsys(int type, caddr_t dummy, int pid, \
+					    int pgid); }
+40	UNIMPL		ibcs2_xenix
+41	NOARGS		{ int dup(u_int fd); }
+42	NOARGS		{ int pipe(void); }
+43	STD		{ int ibcs2_times(struct tms *tp); }
+44	UNIMPL		profil
+45	STD		{ int ibcs2_plock(int cmd); }
+46	STD		{ int ibcs2_setgid(int gid); }
+47	NOARGS		{ gid_t getgid(void); }
+48	STD		{ int ibcs2_sigsys(int sig, ibcs2_sig_t fp); }
+#ifdef SYSVMSG
+49	STD		{ int ibcs2_msgsys(int which, int a2, int a3, int a4, \
+				     int a5, int a6); }
+#else
+49	UNIMPL		nosys
+#endif
+50	UNIMPL		ibcs2_sys3b
+51	UNIMPL		ibcs2_acct
+#ifdef SYSVSHM
+52	STD		{ int ibcs2_shmsys(int which, int a2, int a3, int a4); }
+#else
+52	UNIMPL		nosys
+#endif
+#ifdef SYSVSEM
+53	STD		{ int ibcs2_semsys(int which, int a2, int a3, int a4, \
+				     int a5); }
+#else
+53	UNIMPL		nosys
+#endif
+54	STD		{ int ibcs2_ioctl(int fd, int cmd, caddr_t data); }
+55	STD		{ int ibcs2_uadmin(int cmd, int func, caddr_t data); }
+56	UNIMPL		nosys
+57	STD		{ int ibcs2_utssys(int a1, int a2, int flag); }
+58	UNIMPL		nosys
+59	STD		{ int ibcs2_execve(char *path, char **argp, \
+					   char **envp); }
+60	NOARGS		{ int umask(int newmask); }
+61	NOARGS		{ int chroot(char *path); }
+62	STD		{ int ibcs2_fcntl(int fd, int cmd, char *arg); }
+63	STD		{ long ibcs2_ulimit(int cmd, int newlimit); }
+64	UNIMPL		reserved for unix/pc
+65	UNIMPL		reserved for unix/pc
+66	UNIMPL		reserved for unix/pc
+67	UNIMPL		reserved for unix/pc
+68	UNIMPL		reserved for unix/pc
+69	UNIMPL		reserved for unix/pc
+70	OBSOL		rfs_advfs
+71	OBSOL		rfs_unadvfs
+72	OBSOL		rfs_rmount
+73	OBSOL		rfs_rumount
+74	OBSOL		rfs_rfstart
+75	OBSOL		rfs_sigret
+76	OBSOL		rfs_rdebug
+77	OBSOL		rfs_rfstop
+78	UNIMPL		rfs_rfsys
+79	STD		{ int ibcs2_rmdir(char *path); }
+80	STD		{ int ibcs2_mkdir(char *path, int mode); }
+81	STD		{ int ibcs2_getdents(int fd, char *buf, int nbytes); }
+82	UNIMPL		nosys
+83	UNIMPL		nosys
+84	STD		{ int ibcs2_sysfs(int cmd, caddr_t d1, char *buf); }
+85	STD		{ int ibcs2_getmsg(int fd, struct ibcs2_stropts *ctl, \
+					  struct ibcs2_stropts *dat, \
+					  int *flags); }
+86	STD		{ int ibcs2_putmsg(int fd, struct ibcs2_stropts *ctl, \
+					  struct ibcs2_stropts *dat, \
+					  int flags); }
+87	STD		{ int ibcs2_poll(struct ibcs2_pollfd *fds, long nfds, \
+					int timeout); }
+88	UNIMPL		nosys
+89	UNIMPL		nosys
+90	STD		{ int ibcs2_symlink(char *path, char *link); }
+91	STD		{ int ibcs2_lstat(char *path, struct ibcs2_stat *st); }
+92	STD		{ int ibcs2_readlink(char *path, char *buf, int count); }
+93	UNIMPL		nosys
+94	UNIMPL		nosys
+95	UNIMPL		nosys
+96	UNIMPL		nosys
+97	UNIMPL		nosys
+98	UNIMPL		nosys
+99	UNIMPL		nosys
+100	UNIMPL		nosys
+101	UNIMPL		nosys
+102	UNIMPL		nosys
+103	NOARGS		{ int sigreturn(struct sigcontext *sigcntxp); }
+104	UNIMPL		nosys
+105	UNIMPL		nosys
+106	UNIMPL		nosys
+107	UNIMPL		nosys
+108	UNIMPL		nosys
+109	UNIMPL		nosys
+110	UNIMPL		nosys
+111	UNIMPL		nosys
+112	UNIMPL		nosys
+113	UNIMPL		nosys
+114	UNIMPL		nosys
+115	UNIMPL		nosys
+116	UNIMPL		nosys
+117	UNIMPL		nosys
+118	UNIMPL		nosys
+119	UNIMPL		nosys
+120	UNIMPL		nosys
+121	UNIMPL		nosys
+122	UNIMPL		nosys
+123	UNIMPL		nosys
+124	UNIMPL		nosys
+125	UNIMPL		nosys
+126	UNIMPL		nosys
+127	UNIMPL		nosys
+128	UNIMPL		nosys
+129	UNIMPL		xenix_xlocking
+130	UNIMPL		xenix_creatsem
+131	UNIMPL		xenix_opensem
+132	UNIMPL		xenix_sigsem
+133	UNIMPL		xenix_waitsem
+134	UNIMPL		xenix_nbwaitsem
+135	STD		{ int xenix_rdchk(int fd); }
+136	UNIMPL		nosys
+137	UNIMPL		nosys
+138	STD		{ int xenix_chsize(int fd, long size); }
+139	STD		{ int xenix_ftime(struct xenix_timeb *tp); }
+140	STD		{ int xenix_nap(int millisec); }
+141	UNIMPL		xenix_sdget
+142	UNIMPL		xenix_sdfree
+143	UNIMPL		xenix_sdenter
+144	UNIMPL		xenix_sdleave
+145	UNIMPL		xenix_sdgetv
+146	UNIMPL		xenix_sdwaitv
+147	UNIMPL		nosys
+148	UNIMPL		nosys
+149	UNIMPL		nosys
+150	UNIMPL		nosys
+151	UNIMPL		nosys
+152	UNIMPL		nosys
+153	UNIMPL		nosys
+154	UNIMPL		nosys
+155	UNIMPL		nosys
+156	UNIMPL		nosys
+157	UNIMPL		nosys
+158	UNIMPL		nosys
+159	UNIMPL		nosys
+160	UNIMPL		xenix_proctl
+161	UNIMPL		xenix_execseg
+162	UNIMPL		xenix_unexecseg
+163	UNIMPL		nosys
+164	NOARGS		{ int select(u_int nd, fd_set *in, fd_set *ou, \
+				     fd_set *ex, struct timeval *tv); }
+165	UNIMPL		xenix_eaccess
+166	UNIMPL		xenix_paccess
+167	STD		{ int ibcs2_sigaction(int sig, \
+					      struct ibcs2_sigaction *act, \
+					      struct ibcs2_sigaction *oact); }
+168	STD		{ int ibcs2_sigprocmask(int how, ibcs2_sigset_t *set, \
+					        ibcs2_sigset_t *oset); }
+169	STD		{ int ibcs2_sigpending(ibcs2_sigset_t *mask); }
+170	STD		{ int ibcs2_sigsuspend(ibcs2_sigset_t *mask); }
+171	STD		{ int ibcs2_getgroups(int gidsetsize, \
+					      ibcs2_gid_t *gidset); }
+172	STD		{ int ibcs2_setgroups(int gidsetsize, \
+					      ibcs2_gid_t *gidset); }
+173	STD		{ int ibcs2_sysconf(int name); }
+174	STD		{ int ibcs2_pathconf(char *path, int name); }
+175	STD		{ int ibcs2_fpathconf(int fd, int name); }
+176	STD		{ int ibcs2_rename(char *from, char *to); }