mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-20 15:43:16 +00:00
Code Issues Releases Activity

Import of original NetBSD's ibcs2 emulator sources by Scott Bartram,

Browse Source 
which is used as a basis for a more complete and cleaner ibcs2 emulator.
(snapshot about May 1995 with a few files from September 1995)

Some files and code from old emulator still remains.
New files, features, and changes have been implemented by myself,
which will be shown in following commits.
This commit is contained in:
Steven Wallace 1995-10-10 07:27:24 +00:00
parent dbd221904d
commit 234cc877a2
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/vendor/NetBSD/dist/; revision=11394
31 changed files with 5863 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
sys/i386/ibcs2/ibcs2_dirent.h Normal file
View File

@ -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 */

118
sys/i386/ibcs2/ibcs2_errno.c Normal file
View File

@ -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 */
};

153
sys/i386/ibcs2/ibcs2_errno.h Normal file
View File

@ -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 */

305
sys/i386/ibcs2/ibcs2_fcntl.c Normal file
View File

@ -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;
}

76
sys/i386/ibcs2/ibcs2_fcntl.h Normal file
View File

@ -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 */

487
sys/i386/ibcs2/ibcs2_ioctl.c Normal file
View File

@ -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;
}

414
sys/i386/ibcs2/ibcs2_ipc.c Normal file
View File

@ -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;
}

1200
sys/i386/ibcs2/ibcs2_misc.c Normal file
View File

File diff suppressed because it is too large Load Diff

41
sys/i386/ibcs2/ibcs2_mount.h Normal file
View File

@ -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 */

492
sys/i386/ibcs2/ibcs2_signal.c Normal file
View File

@ -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);
}

105
sys/i386/ibcs2/ibcs2_signal.h Normal file
View File

@ -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 */

131
sys/i386/ibcs2/ibcs2_socksys.c Normal file
View File

@ -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 */
}

118
sys/i386/ibcs2/ibcs2_socksys.h Normal file
View File

@ -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 */

244
sys/i386/ibcs2/ibcs2_stat.c Normal file
View File

@ -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;
}
}

89
sys/i386/ibcs2/ibcs2_stat.h Normal file
View File

@ -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 */

48
sys/i386/ibcs2/ibcs2_statfs.h Normal file
View File

@ -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 */

48
sys/i386/ibcs2/ibcs2_stropts.h Normal file
View File

@ -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 */

97
sys/i386/ibcs2/ibcs2_syscall.h Normal file
View File

@ -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

534
sys/i386/ibcs2/ibcs2_sysent.c Normal file
View File

@ -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 */
};

235
sys/i386/ibcs2/ibcs2_termios.h Normal file
View File

@ -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_ */

50
sys/i386/ibcs2/ibcs2_time.h Normal file
View File

@ -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 */

45
sys/i386/ibcs2/ibcs2_timeb.h Normal file
View File

@ -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 */

54
sys/i386/ibcs2/ibcs2_types.h Normal file
View File

@ -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 */

75
sys/i386/ibcs2/ibcs2_unistd.h Normal file
View File

@ -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 */

46
sys/i386/ibcs2/ibcs2_ustat.h Normal file
View File

@ -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 */

178
sys/i386/ibcs2/ibcs2_util.c Normal file
View File

@ -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;
}

82
sys/i386/ibcs2/ibcs2_util.h Normal file
View File

@ -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_ */

41
sys/i386/ibcs2/ibcs2_utime.h Normal file
View File

@ -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 */

45
sys/i386/ibcs2/ibcs2_utsname.h Normal file
View File

@ -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 */

12
sys/i386/ibcs2/syscalls.conf Normal file
View File

@ -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_"

243
sys/i386/ibcs2/syscalls.master Normal file
View File

@ -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); }