summaryrefslogtreecommitdiffstats
path: root/sys/svr4
diff options
context:
space:
mode:
authornewton <newton@FreeBSD.org>1999-01-30 06:29:48 +0000
committernewton <newton@FreeBSD.org>1999-01-30 06:29:48 +0000
commit3997fb47add29faec9e3ac9c1925d021e723f6fb (patch)
tree3c76919da523b05b639dba820ce9b8ffd560037a /sys/svr4
parent1be412c9d1b16dd39a049d5986d2729ab61295a5 (diff)
downloadFreeBSD-src-3997fb47add29faec9e3ac9c1925d021e723f6fb.zip
FreeBSD-src-3997fb47add29faec9e3ac9c1925d021e723f6fb.tar.gz
Emulator KLD for SysVR4 executables grabbed from NetBSD.
See http://www.freebsd.org/~newton/freebsd-svr4 for limitations, capabilities, history and TO-DO list.
Diffstat (limited to 'sys/svr4')
-rw-r--r--sys/svr4/Makefile13
-rw-r--r--sys/svr4/imgact_svr4.c237
-rw-r--r--sys/svr4/svr4.h38
-rw-r--r--sys/svr4/svr4_acl.h44
-rw-r--r--sys/svr4/svr4_dirent.h51
-rw-r--r--sys/svr4/svr4_errno.h170
-rw-r--r--sys/svr4/svr4_exec.h68
-rw-r--r--sys/svr4/svr4_fcntl.c721
-rw-r--r--sys/svr4/svr4_fcntl.h132
-rw-r--r--sys/svr4/svr4_filio.c245
-rw-r--r--sys/svr4/svr4_filio.h43
-rw-r--r--sys/svr4/svr4_fuser.h96
-rw-r--r--sys/svr4/svr4_hrt.h85
-rw-r--r--sys/svr4/svr4_ioctl.c167
-rw-r--r--sys/svr4/svr4_ioctl.h60
-rw-r--r--sys/svr4/svr4_ipc.c831
-rw-r--r--sys/svr4/svr4_ipc.h174
-rw-r--r--sys/svr4/svr4_misc.c1629
-rw-r--r--sys/svr4/svr4_mman.h45
-rw-r--r--sys/svr4/svr4_proto.h472
-rw-r--r--sys/svr4/svr4_resource.c311
-rw-r--r--sys/svr4/svr4_resource.h107
-rw-r--r--sys/svr4/svr4_siginfo.h109
-rw-r--r--sys/svr4/svr4_signal.c623
-rw-r--r--sys/svr4/svr4_signal.h130
-rw-r--r--sys/svr4/svr4_socket.c204
-rw-r--r--sys/svr4/svr4_socket.h53
-rw-r--r--sys/svr4/svr4_sockio.c174
-rw-r--r--sys/svr4/svr4_sockio.h91
-rw-r--r--sys/svr4/svr4_sockmod.h81
-rw-r--r--sys/svr4/svr4_stat.c803
-rw-r--r--sys/svr4/svr4_stat.h103
-rw-r--r--sys/svr4/svr4_statvfs.h70
-rw-r--r--sys/svr4/svr4_stream.c2264
-rw-r--r--sys/svr4/svr4_stream.h0
-rw-r--r--sys/svr4/svr4_stropts.h173
-rw-r--r--sys/svr4/svr4_syscall.h144
-rw-r--r--sys/svr4/svr4_syscallnames.c263
-rw-r--r--sys/svr4/svr4_sysconfig.h60
-rw-r--r--sys/svr4/svr4_sysent.c282
-rw-r--r--sys/svr4/svr4_systeminfo.h48
-rw-r--r--sys/svr4/svr4_sysvec.c383
-rw-r--r--sys/svr4/svr4_termios.c619
-rw-r--r--sys/svr4/svr4_termios.h222
-rw-r--r--sys/svr4/svr4_time.h39
-rw-r--r--sys/svr4/svr4_timod.h85
-rw-r--r--sys/svr4/svr4_ttold.c381
-rw-r--r--sys/svr4/svr4_ttold.h120
-rw-r--r--sys/svr4/svr4_types.h79
-rw-r--r--sys/svr4/svr4_ucontext.h72
-rw-r--r--sys/svr4/svr4_ulimit.h39
-rw-r--r--sys/svr4/svr4_ustat.h41
-rw-r--r--sys/svr4/svr4_util.h78
-rw-r--r--sys/svr4/svr4_utsname.h42
-rw-r--r--sys/svr4/svr4_wait.h54
-rw-r--r--sys/svr4/syscalls.conf12
-rw-r--r--sys/svr4/syscalls.master373
57 files changed, 14053 insertions, 0 deletions
diff --git a/sys/svr4/Makefile b/sys/svr4/Makefile
new file mode 100644
index 0000000..d8fd59b
--- /dev/null
+++ b/sys/svr4/Makefile
@@ -0,0 +1,13 @@
+# Makefile for syscall tables
+#
+# $Id: Makefile,v 1.3 1997/03/29 11:17:26 peter Exp $
+
+all:
+ @echo "make svr4_sysent.c only"
+
+svr4_sysent.c svr4_syscall.h svr4_proto.h: ../kern/makesyscalls.sh \
+ syscalls.master syscalls.conf
+ -mv -f svr4_sysent.c svr4_sysent.c.bak
+ -mv -f svr4_syscall.h svr4_syscall.h.bak
+ -mv -f svr4_proto.h svr4_proto.h.bak
+ sh ../kern/makesyscalls.sh syscalls.master syscalls.conf
diff --git a/sys/svr4/imgact_svr4.c b/sys/svr4/imgact_svr4.c
new file mode 100644
index 0000000..1324805
--- /dev/null
+++ b/sys/svr4/imgact_svr4.c
@@ -0,0 +1,237 @@
+/*-
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994-1996 Søren Schmidt
+ * All rights reserved.
+ *
+ * Based heavily on /sys/kern/imgact_aout.c which is:
+ * Copyright (c) 1993, David Greenman
+ *
+ * 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
+ * in this position and unchanged.
+ * 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 withough 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/resourcevar.h>
+#include <sys/exec.h>
+#include <sys/mman.h>
+#include <sys/imgact.h>
+#include <sys/imgact_aout.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_param.h>
+#include <vm/pmap.h>
+#include <vm/vm_map.h>
+#include <vm/vm_prot.h>
+#include <vm/vm_extern.h>
+
+#include <svr4/svr4.h>
+
+static int exec_svr4_imgact __P((struct image_params *iparams));
+
+static int
+exec_svr4_imgact(imgp)
+ struct image_params *imgp;
+{
+ const struct exec *a_out = (const struct exec *) imgp->image_header;
+ struct vmspace *vmspace;
+ vm_offset_t vmaddr;
+ unsigned long virtual_offset, file_offset;
+ vm_offset_t buffer;
+ unsigned long bss_size;
+ int error;
+
+ if (((a_out->a_magic >> 16) & 0xff) != 0x64)
+ return -1;
+
+ /*
+ * Set file/virtual offset based on a.out variant.
+ */
+ switch ((int)(a_out->a_magic & 0xffff)) {
+ case 0413:
+ virtual_offset = 0;
+ file_offset = 1024;
+ break;
+ case 0314:
+ virtual_offset = 4096;
+ file_offset = 0;
+ break;
+ default:
+ return (-1);
+ }
+ bss_size = round_page(a_out->a_bss);
+#ifdef DEBUG
+ printf("imgact: text: %08x, data: %08x, bss: %08x\n", a_out->a_text, a_out->a_data, bss_size);
+#endif
+
+ /*
+ * Check various fields in header for validity/bounds.
+ */
+ if (a_out->a_entry < virtual_offset ||
+ a_out->a_entry >= virtual_offset + a_out->a_text ||
+ a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK)
+ return (-1);
+
+ /* text + data can't exceed file size */
+ if (a_out->a_data + a_out->a_text > imgp->attr->va_size)
+ return (EFAULT);
+ /*
+ * text/data/bss must not exceed limits
+ */
+ if (a_out->a_text > MAXTSIZ ||
+ a_out->a_data + bss_size > imgp->proc->p_rlimit[RLIMIT_DATA].rlim_cur)
+ return (ENOMEM);
+
+ /* copy in arguments and/or environment from old process */
+ error = exec_extract_strings(imgp);
+ if (error)
+ return (error);
+
+ /*
+ * Destroy old process VM and create a new one (with a new stack)
+ */
+ exec_new_vmspace(imgp);
+ vmspace = imgp->proc->p_vmspace;
+
+ /*
+ * Check if file_offset page aligned,.
+ * Currently we cannot handle misalinged file offsets,
+ * and so we read in the entire image (what a waste).
+ */
+ if (file_offset & PAGE_MASK) {
+#ifdef DEBUG
+ printf("imgact: Non page aligned binary %d\n", file_offset);
+#endif
+ /*
+ * Map text+data+bss read/write/execute
+ */
+ vmaddr = virtual_offset;
+ error = vm_map_find(&vmspace->vm_map, NULL, 0, &vmaddr,
+ a_out->a_text + a_out->a_data + bss_size, FALSE,
+ VM_PROT_ALL, VM_PROT_ALL, 0);
+ if (error)
+ return error;
+
+ error = vm_mmap(kernel_map, &buffer,
+ round_page(a_out->a_text + a_out->a_data + file_offset),
+ VM_PROT_READ, VM_PROT_READ, 0,
+ (caddr_t) imgp->vp, trunc_page(file_offset));
+ if (error)
+ return error;
+
+ error = copyout((caddr_t)(buffer + file_offset), (caddr_t)vmaddr,
+ a_out->a_text + a_out->a_data);
+
+ vm_map_remove(kernel_map, buffer,
+ buffer + round_page(a_out->a_text + a_out->a_data + file_offset));
+
+ if (error)
+ return error;
+
+ /*
+ * remove write enable on the 'text' part
+ */
+ error = vm_map_protect(&vmspace->vm_map,
+ vmaddr,
+ vmaddr + a_out->a_text,
+ VM_PROT_EXECUTE|VM_PROT_READ,
+ TRUE);
+ if (error)
+ return error;
+ }
+ else {
+#ifdef DEBUG
+ printf("imgact: Page aligned binary %d\n", file_offset);
+#endif
+ /*
+ * Map text+data read/execute
+ */
+ vmaddr = virtual_offset;
+ error = vm_mmap(&vmspace->vm_map, &vmaddr,
+ a_out->a_text + a_out->a_data,
+ VM_PROT_READ | VM_PROT_EXECUTE,
+ VM_PROT_ALL,
+ MAP_PRIVATE | MAP_FIXED,
+ (caddr_t)imgp->vp, file_offset);
+ if (error)
+ return (error);
+
+#ifdef DEBUG
+ printf("imgact: startaddr=%08x, length=%08x\n", vmaddr, a_out->a_text + a_out->a_data);
+#endif
+ /*
+ * allow read/write of data
+ */
+ error = vm_map_protect(&vmspace->vm_map,
+ vmaddr + a_out->a_text,
+ vmaddr + a_out->a_text + a_out->a_data,
+ VM_PROT_ALL,
+ FALSE);
+ if (error)
+ return (error);
+
+ /*
+ * Allocate anon demand-zeroed area for uninitialized data
+ */
+ if (bss_size != 0) {
+ vmaddr = virtual_offset + a_out->a_text + a_out->a_data;
+ error = vm_map_find(&vmspace->vm_map, NULL, 0, &vmaddr,
+ bss_size, FALSE, VM_PROT_ALL, VM_PROT_ALL, 0);
+ if (error)
+ return (error);
+#ifdef DEBUG
+ printf("imgact: bssaddr=%08x, length=%08x\n", vmaddr, bss_size);
+#endif
+
+ }
+ /* Indicate that this file should not be modified */
+ imgp->vp->v_flag |= VTEXT;
+ }
+ /* Fill in process VM information */
+ vmspace->vm_tsize = round_page(a_out->a_text) >> PAGE_SHIFT;
+ vmspace->vm_dsize = round_page(a_out->a_data + bss_size) >> PAGE_SHIFT;
+ vmspace->vm_taddr = (caddr_t)virtual_offset;
+ vmspace->vm_daddr = (caddr_t)virtual_offset + a_out->a_text;
+
+ /* Fill in image_params */
+ imgp->interpreted = 0;
+ imgp->entry_addr = a_out->a_entry;
+
+ imgp->proc->p_sysent = &svr4_sysvec;
+ return (0);
+}
+
+/*
+ * Tell kern_execve.c about it, with a little help from the linker.
+ * Since `const' objects end up in the text segment, TEXT_SET is the
+ * correct directive to use. Do not staticize; used by Linux LKM.
+ */
+const struct execsw svr4_execsw = { exec_svr4_imgact, "svr4 ELF" };
+TEXT_SET(execsw_set, svr4_execsw);
+
diff --git a/sys/svr4/svr4.h b/sys/svr4/svr4.h
new file mode 100644
index 0000000..45e08b3
--- /dev/null
+++ b/sys/svr4/svr4.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * 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.
+ */
+
+#if !defined(_SVR4_H)
+#define _SVR4_H
+
+extern struct sysentvec svr4_sysvec;
+
+#define memset(x,y,z) bzero(x,z)
+
+#define COMPAT_SVR4_SOLARIS2
+#define KTRACE
+
+#endif
diff --git a/sys/svr4/svr4_acl.h b/sys/svr4/svr4_acl.h
new file mode 100644
index 0000000..2d4f10f
--- /dev/null
+++ b/sys/svr4/svr4_acl.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1996 Christos Zoulas.
+ * 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 Christos Zoulas.
+ * 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 _SVR4_ACL_H_
+#define _SVR4_ACL_H_
+
+typedef struct svr4_aclent {
+ int a_type;
+ svr4_uid_t a_id;
+ svr4_o_mode_t a_perm;
+} svr4_aclent_t;
+
+#define SVR4_SYS_GETACL 1
+#define SVR4_SYS_SETACL 2
+#define SVR4_SYS_GETACLCNT 3
+
+#endif /* !_SVR4_ACL_H_ */
diff --git a/sys/svr4/svr4_dirent.h b/sys/svr4/svr4_dirent.h
new file mode 100644
index 0000000..a2e8a59
--- /dev/null
+++ b/sys/svr4/svr4_dirent.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_DIRENT_H_
+#define _SVR4_DIRENT_H_
+
+#define SVR4_MAXNAMLEN 512
+
+struct svr4_dirent {
+ svr4_ino_t d_ino;
+ svr4_off_t d_off;
+ u_short d_reclen;
+ char d_name[SVR4_MAXNAMLEN + 1];
+};
+
+struct svr4_dirent64 {
+ svr4_ino64_t d_ino;
+ svr4_off64_t d_off;
+ u_short d_reclen;
+ char d_name[SVR4_MAXNAMLEN + 1];
+};
+
+#define SVR4_NAMEOFF(dp) ((char *)&(dp)->d_name - (char *)dp)
+#define SVR4_RECLEN(de,namlen) ALIGN((SVR4_NAMEOFF(de) + (namlen) + 1))
+
+#endif /* !_SVR4_DIRENT_H_ */
diff --git a/sys/svr4/svr4_errno.h b/sys/svr4/svr4_errno.h
new file mode 100644
index 0000000..42de6d0
--- /dev/null
+++ b/sys/svr4/svr4_errno.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_ERRNO_H_
+#define _SVR4_ERRNO_H_
+
+#define SVR4_EPERM 1
+#define SVR4_ENOENT 2
+#define SVR4_ESRCH 3
+#define SVR4_EINTR 4
+#define SVR4_EIO 5
+#define SVR4_ENXIO 6
+#define SVR4_E2BIG 7
+#define SVR4_ENOEXEC 8
+#define SVR4_EBADF 9
+#define SVR4_ECHILD 10
+#define SVR4_EAGAIN 11
+#define SVR4_ENOMEM 12
+#define SVR4_EACCES 13
+#define SVR4_EFAULT 14
+#define SVR4_ENOTBLK 15
+#define SVR4_EBUSY 16
+#define SVR4_EEXIST 17
+#define SVR4_EXDEV 18
+#define SVR4_ENODEV 19
+#define SVR4_ENOTDIR 20
+#define SVR4_EISDIR 21
+#define SVR4_EINVAL 22
+#define SVR4_ENFILE 23
+#define SVR4_EMFILE 24
+#define SVR4_ENOTTY 25
+#define SVR4_ETXTBSY 26
+#define SVR4_EFBIG 27
+#define SVR4_ENOSPC 28
+#define SVR4_ESPIPE 29
+#define SVR4_EROFS 30
+#define SVR4_EMLINK 31
+#define SVR4_EPIPE 32
+#define SVR4_EDOM 33
+#define SVR4_ERANGE 34
+#define SVR4_ENOMSG 35
+#define SVR4_EIDRM 36
+#define SVR4_ECHRNG 37
+#define SVR4_EL2NSYNC 38
+#define SVR4_EL3HLT 39
+#define SVR4_EL3RST 40
+#define SVR4_ELNRNG 41
+#define SVR4_EUNATCH 42
+#define SVR4_ENOCSI 43
+#define SVR4_EL2HLT 44
+#define SVR4_EDEADLK 45
+#define SVR4_ENOLCK 46
+#define SVR4_EBADE 50
+#define SVR4_EBADR 51
+#define SVR4_EXFULL 52
+#define SVR4_ENOANO 53
+#define SVR4_EBADRQC 54
+#define SVR4_EBADSLT 55
+#define SVR4_EDEADLOCK 56
+#define SVR4_EBFONT 57
+#define SVR4_ENOSTR 60
+#define SVR4_ENODATA 61
+#define SVR4_ETIME 62
+#define SVR4_ENOSR 63
+#define SVR4_ENONET 64
+#define SVR4_ENOPKG 65
+#define SVR4_EREMOTE 66
+#define SVR4_ENOLINK 67
+#define SVR4_EADV 68
+#define SVR4_ESRMNT 69
+#define SVR4_ECOMM 70
+#define SVR4_EPROTO 71
+#define SVR4_EMULTIHOP 74
+#define SVR4_EBADMSG 77
+#define SVR4_ENAMETOOLONG 78
+#define SVR4_EOVERFLOW 79
+#define SVR4_ENOTUNIQ 80
+#define SVR4_EBADFD 81
+#define SVR4_EREMCHG 82
+#define SVR4_ELIBACC 83
+#define SVR4_ELIBBAD 84
+#define SVR4_ELIBSCN 85
+#define SVR4_ELIBMAX 86
+#define SVR4_ELIBEXEC 87
+#define SVR4_EILSEQ 88
+#define SVR4_ENOSYS 89
+#define SVR4_ELOOP 90
+#define SVR4_ERESTART 91
+#define SVR4_ESTRPIPE 92
+#define SVR4_ENOTEMPTY 93
+#define SVR4_EUSERS 94
+#define SVR4_ENOTSOCK 95
+#define SVR4_EDESTADDRREQ 96
+#define SVR4_EMSGSIZE 97
+#define SVR4_EPROTOTYPE 98
+#define SVR4_ENOPROTOOPT 99
+#define SVR4_EPROTONOSUPPORT 120
+#define SVR4_ESOCKTNOSUPPORT 121
+#define SVR4_EOPNOTSUPP 122
+#define SVR4_EPFNOSUPPORT 123
+#define SVR4_EAFNOSUPPORT 124
+#define SVR4_EADDRINUSE 125
+#define SVR4_EADDRNOTAVAIL 126
+#define SVR4_ENETDOWN 127
+#define SVR4_ENETUNREACH 128
+#define SVR4_ENETRESET 129
+#define SVR4_ECONNABORTED 130
+#define SVR4_ECONNRESET 131
+#define SVR4_ENOBUFS 132
+#define SVR4_EISCONN 133
+#define SVR4_ENOTCONN 134
+#define SVR4_EUCLEAN 135
+#define SVR4_ENOTNAM 137
+#define SVR4_ENAVAIL 138
+#define SVR4_EISNAM 139
+#define SVR4_EREMOTEIO 140
+#define SVR4_EINIT 141
+#define SVR4_EREMDEV 142
+#define SVR4_ESHUTDOWN 143
+#define SVR4_ETOOMANYREFS 144
+#define SVR4_ETIMEDOUT 145
+#define SVR4_ECONNREFUSED 146
+#define SVR4_EHOSTDOWN 147
+#define SVR4_EHOSTUNREACH 148
+#define SVR4_EWOULDBLOCK SVR4_EAGAIN
+#define SVR4_EALREADY 149
+#define SVR4_EINPROGRESS 150
+#define SVR4_ESTALE 151
+#define SVR4_EIORESID 500
+
+/*
+ * These ones are not translated...
+ */
+#define SVR4_EPROCLIM SVR4_ENOSYS
+#define SVR4_EDQUOT SVR4_ENOSYS
+#define SVR4_EBADRPC SVR4_ENOSYS
+#define SVR4_ERPCMISMATCH SVR4_ENOSYS
+#define SVR4_EPROGUNAVAIL SVR4_ENOSYS
+#define SVR4_EPROGMISMATCH SVR4_ENOSYS
+#define SVR4_EPROCUNAVAIL SVR4_ENOSYS
+#define SVR4_EFTYPE SVR4_ENOSYS
+#define SVR4_EAUTH SVR4_ENOSYS
+#define SVR4_ENEEDAUTH SVR4_ENOSYS
+
+#endif /* !_SVR4_ERRNO_H_ */
diff --git a/sys/svr4/svr4_exec.h b/sys/svr4/svr4_exec.h
new file mode 100644
index 0000000..84fcd3d
--- /dev/null
+++ b/sys/svr4/svr4_exec.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_EXEC_H_
+#define _SVR4_EXEC_H_
+
+#ifdef SVR4_COMPAT_SOLARIS2
+# define SVR4_AUX_ARGSIZ (sizeof(AuxInfo) * 12 / sizeof(char *))
+#else
+# define SVR4_AUX_ARGSIZ (sizeof(AuxInfo) * 8 / sizeof(char *))
+#endif
+
+#if 0
+/* Don't think we need all this NetBSD stuff */
+/*
+ * The following is horrible; there must be a better way. I need to
+ * play with brk(2) a bit more.
+ */
+#ifdef i386
+/*
+ * I cannot load the interpreter after the data segment because brk(2)
+ * breaks. I have to load it somewhere before. Programs start at
+ * 0x08000000 so I load the interpreter far before.
+ */
+#define SVR4_INTERP_ADDR 0x01000000
+#endif
+
+#ifdef sparc
+/*
+ * Here programs load at 0x00010000, so I load the interpreter far after
+ * the end of the data segment.
+ */
+#define SVR4_INTERP_ADDR 0x10000000
+#endif
+
+#ifndef SVR4_INTERP_ADDR
+# define SVR4_INTERP_ADDR 0
+#endif
+#endif
+
+/*void svr4_setregs __P((struct proc *, struct exec_package *, u_long));*/
+
+#endif /* !_SVR4_EXEC_H_ */
diff --git a/sys/svr4/svr4_fcntl.c b/sys/svr4/svr4_fcntl.c
new file mode 100644
index 0000000..9bd403c
--- /dev/null
+++ b/sys/svr4/svr4_fcntl.c
@@ -0,0 +1,721 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994, 1997 Christos Zoulas.
+ * 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 Christos Zoulas.
+ * 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 <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/unistd.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_fcntl.h>
+
+static int svr4_to_bsd_flags __P((int));
+static u_long svr4_to_bsd_cmd __P((u_long));
+static int fd_revoke __P((struct proc *, int));
+static int fd_truncate __P((struct proc *, int, struct flock *));
+static int bsd_to_svr4_flags __P((int));
+static void bsd_to_svr4_flock __P((struct flock *, struct svr4_flock *));
+static void svr4_to_bsd_flock __P((struct svr4_flock *, struct flock *));
+static void bsd_to_svr4_flock64 __P((struct flock *, struct svr4_flock64 *));
+static void svr4_to_bsd_flock64 __P((struct svr4_flock64 *, struct flock *));
+
+static u_long
+svr4_to_bsd_cmd(cmd)
+ u_long cmd;
+{
+ switch (cmd) {
+ case SVR4_F_DUPFD:
+ return F_DUPFD;
+ case SVR4_F_GETFD:
+ return F_GETFD;
+ case SVR4_F_SETFD:
+ return F_SETFD;
+ case SVR4_F_GETFL:
+ return F_GETFL;
+ case SVR4_F_SETFL:
+ return F_SETFL;
+ case SVR4_F_GETLK:
+ return F_GETLK;
+ case SVR4_F_SETLK:
+ return F_SETLK;
+ case SVR4_F_SETLKW:
+ return F_SETLKW;
+ default:
+ return -1;
+ }
+}
+
+static int
+svr4_to_bsd_flags(l)
+ int l;
+{
+ int r = 0;
+ r |= (l & SVR4_O_RDONLY) ? O_RDONLY : 0;
+ r |= (l & SVR4_O_WRONLY) ? O_WRONLY : 0;
+ r |= (l & SVR4_O_RDWR) ? O_RDWR : 0;
+ r |= (l & SVR4_O_NDELAY) ? O_NONBLOCK : 0;
+ r |= (l & SVR4_O_APPEND) ? O_APPEND : 0;
+ r |= (l & SVR4_O_SYNC) ? O_FSYNC : 0;
+ r |= (l & SVR4_O_NONBLOCK) ? O_NONBLOCK : 0;
+ r |= (l & SVR4_O_PRIV) ? O_EXLOCK : 0;
+ r |= (l & SVR4_O_CREAT) ? O_CREAT : 0;
+ r |= (l & SVR4_O_TRUNC) ? O_TRUNC : 0;
+ r |= (l & SVR4_O_EXCL) ? O_EXCL : 0;
+ r |= (l & SVR4_O_NOCTTY) ? O_NOCTTY : 0;
+ return r;
+}
+
+static int
+bsd_to_svr4_flags(l)
+ int l;
+{
+ int r = 0;
+ r |= (l & O_RDONLY) ? SVR4_O_RDONLY : 0;
+ r |= (l & O_WRONLY) ? SVR4_O_WRONLY : 0;
+ r |= (l & O_RDWR) ? SVR4_O_RDWR : 0;
+ r |= (l & O_NDELAY) ? SVR4_O_NONBLOCK : 0;
+ r |= (l & O_APPEND) ? SVR4_O_APPEND : 0;
+ r |= (l & O_FSYNC) ? SVR4_O_SYNC : 0;
+ r |= (l & O_NONBLOCK) ? SVR4_O_NONBLOCK : 0;
+ r |= (l & O_EXLOCK) ? SVR4_O_PRIV : 0;
+ r |= (l & O_CREAT) ? SVR4_O_CREAT : 0;
+ r |= (l & O_TRUNC) ? SVR4_O_TRUNC : 0;
+ r |= (l & O_EXCL) ? SVR4_O_EXCL : 0;
+ r |= (l & O_NOCTTY) ? SVR4_O_NOCTTY : 0;
+ return r;
+}
+
+
+static void
+bsd_to_svr4_flock(iflp, oflp)
+ struct flock *iflp;
+ struct svr4_flock *oflp;
+{
+ switch (iflp->l_type) {
+ case F_RDLCK:
+ oflp->l_type = SVR4_F_RDLCK;
+ break;
+ case F_WRLCK:
+ oflp->l_type = SVR4_F_WRLCK;
+ break;
+ case F_UNLCK:
+ oflp->l_type = SVR4_F_UNLCK;
+ break;
+ default:
+ oflp->l_type = -1;
+ break;
+ }
+
+ oflp->l_whence = (short) iflp->l_whence;
+ oflp->l_start = (svr4_off_t) iflp->l_start;
+ oflp->l_len = (svr4_off_t) iflp->l_len;
+ oflp->l_sysid = 0;
+ oflp->l_pid = (svr4_pid_t) iflp->l_pid;
+}
+
+
+static void
+svr4_to_bsd_flock(iflp, oflp)
+ struct svr4_flock *iflp;
+ struct flock *oflp;
+{
+ switch (iflp->l_type) {
+ case SVR4_F_RDLCK:
+ oflp->l_type = F_RDLCK;
+ break;
+ case SVR4_F_WRLCK:
+ oflp->l_type = F_WRLCK;
+ break;
+ case SVR4_F_UNLCK:
+ oflp->l_type = F_UNLCK;
+ break;
+ default:
+ oflp->l_type = -1;
+ break;
+ }
+
+ oflp->l_whence = iflp->l_whence;
+ oflp->l_start = (off_t) iflp->l_start;
+ oflp->l_len = (off_t) iflp->l_len;
+ oflp->l_pid = (pid_t) iflp->l_pid;
+
+}
+
+static void
+bsd_to_svr4_flock64(iflp, oflp)
+ struct flock *iflp;
+ struct svr4_flock64 *oflp;
+{
+ switch (iflp->l_type) {
+ case F_RDLCK:
+ oflp->l_type = SVR4_F_RDLCK;
+ break;
+ case F_WRLCK:
+ oflp->l_type = SVR4_F_WRLCK;
+ break;
+ case F_UNLCK:
+ oflp->l_type = SVR4_F_UNLCK;
+ break;
+ default:
+ oflp->l_type = -1;
+ break;
+ }
+
+ oflp->l_whence = (short) iflp->l_whence;
+ oflp->l_start = (svr4_off64_t) iflp->l_start;
+ oflp->l_len = (svr4_off64_t) iflp->l_len;
+ oflp->l_sysid = 0;
+ oflp->l_pid = (svr4_pid_t) iflp->l_pid;
+}
+
+
+static void
+svr4_to_bsd_flock64(iflp, oflp)
+ struct svr4_flock64 *iflp;
+ struct flock *oflp;
+{
+ switch (iflp->l_type) {
+ case SVR4_F_RDLCK:
+ oflp->l_type = F_RDLCK;
+ break;
+ case SVR4_F_WRLCK:
+ oflp->l_type = F_WRLCK;
+ break;
+ case SVR4_F_UNLCK:
+ oflp->l_type = F_UNLCK;
+ break;
+ default:
+ oflp->l_type = -1;
+ break;
+ }
+
+ oflp->l_whence = iflp->l_whence;
+ oflp->l_start = (off_t) iflp->l_start;
+ oflp->l_len = (off_t) iflp->l_len;
+ oflp->l_pid = (pid_t) iflp->l_pid;
+
+}
+
+
+static int
+fd_revoke(p, fd)
+ struct proc *p;
+ int fd;
+{
+ struct filedesc *fdp = p->p_fd;
+ struct file *fp;
+ struct vnode *vp;
+ struct vattr vattr;
+ int error, *retval;
+
+ retval = p->p_retval;
+ if ((u_int)fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
+ return EBADF;
+
+ switch (fp->f_type) {
+ case DTYPE_VNODE:
+ vp = (struct vnode *) fp->f_data;
+
+ case DTYPE_SOCKET:
+ return EINVAL;
+
+ default:
+ panic("svr4_fcntl(F_REVOKE)");
+ /*NOTREACHED*/
+ }
+
+ if (vp->v_type != VCHR && vp->v_type != VBLK) {
+ error = EINVAL;
+ goto out;
+ }
+
+ if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
+ goto out;
+
+ if (p->p_ucred->cr_uid != vattr.va_uid &&
+ (error = suser(p->p_ucred, &p->p_acflag)) != 0)
+ goto out;
+
+ if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
+ VOP_REVOKE(vp, REVOKEALL);
+out:
+ vrele(vp);
+ return error;
+}
+
+
+static int
+fd_truncate(p, fd, flp)
+ struct proc *p;
+ int fd;
+ struct flock *flp;
+{
+ struct filedesc *fdp = p->p_fd;
+ struct file *fp;
+ off_t start, length;
+ struct vnode *vp;
+ struct vattr vattr;
+ int error, *retval;
+ struct ftruncate_args ft;
+
+ retval = p->p_retval;
+
+ /*
+ * We only support truncating the file.
+ */
+ if ((u_int)fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
+ return EBADF;
+
+ vp = (struct vnode *)fp->f_data;
+ if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO)
+ return ESPIPE;
+
+ if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
+ return error;
+
+ length = vattr.va_size;
+
+ switch (flp->l_whence) {
+ case SEEK_CUR:
+ start = fp->f_offset + flp->l_start;
+ break;
+
+ case SEEK_END:
+ start = flp->l_start + length;
+ break;
+
+ case SEEK_SET:
+ start = flp->l_start;
+ break;
+
+ default:
+ return EINVAL;
+ }
+
+ if (start + flp->l_len < length) {
+ /* We don't support free'ing in the middle of the file */
+ return EINVAL;
+ }
+
+ SCARG(&ft, fd) = fd;
+ SCARG(&ft, length) = start;
+
+ return ftruncate(p, &ft);
+}
+
+int
+svr4_sys_open(p, uap)
+ register struct proc *p;
+ struct svr4_sys_open_args *uap;
+{
+ int error, retval;
+ struct open_args cup;
+
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ (&cup)->path = uap->path;
+ (&cup)->flags = svr4_to_bsd_flags(uap->flags);
+ (&cup)->mode = uap->mode;
+ error = open(p, &cup);
+
+ if (error) {
+ /* uprintf("svr4_open(%s, 0x%0x, 0%o): %d\n", uap->path,
+ uap->flags, uap->mode, error);*/
+ return error;
+ }
+
+ retval = p->p_retval[0];
+
+ if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(p) &&
+ !(p->p_flag & P_CONTROLT)) {
+#if defined(NOTYET)
+ 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);
+#endif
+ }
+ return error;
+}
+
+int
+svr4_sys_open64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_open64_args *uap;
+{
+ return svr4_sys_open(p, (struct svr4_sys_open_args *)uap);
+}
+
+int
+svr4_sys_creat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_creat_args *uap;
+{
+ struct open_args cup;
+
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(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);
+}
+
+int
+svr4_sys_creat64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_creat64_args *uap;
+{
+ return svr4_sys_creat(p, (struct svr4_sys_creat_args *)uap);
+}
+
+int
+svr4_sys_llseek(p, v)
+ register struct proc *p;
+ struct svr4_sys_llseek_args *v;
+{
+ struct svr4_sys_llseek_args *uap = v;
+ struct lseek_args ap;
+
+ SCARG(&ap, fd) = SCARG(uap, fd);
+
+#if BYTE_ORDER == BIG_ENDIAN
+ SCARG(&ap, offset) = (((long long) SCARG(uap, offset1)) << 32) |
+ SCARG(uap, offset2);
+#else
+ SCARG(&ap, offset) = (((long long) SCARG(uap, offset2)) << 32) |
+ SCARG(uap, offset1);
+#endif
+ SCARG(&ap, whence) = SCARG(uap, whence);
+
+ return lseek(p, &ap);
+}
+
+int
+svr4_sys_access(p, uap)
+ register struct proc *p;
+ struct svr4_sys_access_args *uap;
+{
+ struct access_args cup;
+ int *retval;
+
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ retval = p->p_retval;
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, flags) = SCARG(uap, flags);
+
+ return access(p, &cup);
+}
+
+#if defined(NOTYET)
+int
+svr4_sys_pread(p, uap)
+ register struct proc *p;
+ struct svr4_sys_pread_args *uap;
+{
+ struct pread_args pra;
+
+ /*
+ * Just translate the args structure and call the NetBSD
+ * pread(2) system call (offset type is 64-bit in NetBSD).
+ */
+ SCARG(&pra, fd) = SCARG(uap, fd);
+ SCARG(&pra, buf) = SCARG(uap, buf);
+ SCARG(&pra, nbyte) = SCARG(uap, nbyte);
+ SCARG(&pra, offset) = SCARG(uap, off);
+
+ return pread(p, &pra);
+}
+#endif
+
+#if defined(NOTYET)
+int
+svr4_sys_pread64(p, v, retval)
+ register struct proc *p;
+ void *v;
+ register_t *retval;
+{
+
+ struct svr4_sys_pread64_args *uap = v;
+ struct sys_pread_args pra;
+
+ /*
+ * Just translate the args structure and call the NetBSD
+ * pread(2) system call (offset type is 64-bit in NetBSD).
+ */
+ SCARG(&pra, fd) = SCARG(uap, fd);
+ SCARG(&pra, buf) = SCARG(uap, buf);
+ SCARG(&pra, nbyte) = SCARG(uap, nbyte);
+ SCARG(&pra, offset) = SCARG(uap, off);
+
+ return (sys_pread(p, &pra, retval));
+}
+#endif /* NOTYET */
+
+#if defined(NOTYET)
+int
+svr4_sys_pwrite(p, uap)
+ register struct proc *p;
+ struct svr4_sys_pwrite_args *uap;
+{
+ struct pwrite_args pwa;
+
+ /*
+ * Just translate the args structure and call the NetBSD
+ * pwrite(2) system call (offset type is 64-bit in NetBSD).
+ */
+ SCARG(&pwa, fd) = SCARG(uap, fd);
+ SCARG(&pwa, buf) = SCARG(uap, buf);
+ SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
+ SCARG(&pwa, offset) = SCARG(uap, off);
+
+ return pwrite(p, &pwa);
+}
+#endif
+
+#if defined(NOTYET)
+int
+svr4_sys_pwrite64(p, v, retval)
+ register struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_pwrite64_args *uap = v;
+ struct sys_pwrite_args pwa;
+
+ /*
+ * Just translate the args structure and call the NetBSD
+ * pwrite(2) system call (offset type is 64-bit in NetBSD).
+ */
+ SCARG(&pwa, fd) = SCARG(uap, fd);
+ SCARG(&pwa, buf) = SCARG(uap, buf);
+ SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
+ SCARG(&pwa, offset) = SCARG(uap, off);
+
+ return (sys_pwrite(p, &pwa, retval));
+}
+#endif /* NOTYET */
+
+int
+svr4_sys_fcntl(p, uap)
+ register struct proc *p;
+ struct svr4_sys_fcntl_args *uap;
+{
+ int error;
+ struct fcntl_args fa;
+ int *retval;
+
+ retval = p->p_retval;
+
+ SCARG(&fa, fd) = SCARG(uap, fd);
+ SCARG(&fa, cmd) = svr4_to_bsd_cmd(SCARG(uap, cmd));
+
+ switch (SCARG(&fa, cmd)) {
+ case F_DUPFD:
+ case F_GETFD:
+ case F_SETFD:
+ SCARG(&fa, arg) = (long) SCARG(uap, arg);
+ return fcntl(p, &fa);
+
+ case F_GETFL:
+ SCARG(&fa, arg) = (long) SCARG(uap, arg);
+ error = fcntl(p, &fa);
+ if (error)
+ return error;
+ *retval = bsd_to_svr4_flags(*retval);
+ return error;
+
+ case F_SETFL:
+ {
+ /*
+ * we must save the O_ASYNC flag, as that is
+ * handled by ioctl(_, I_SETSIG, _) emulation.
+ */
+ long cmd;
+ int flags;
+
+ DPRINTF(("Setting flags 0x%x\n", SCARG(uap, arg)));
+ cmd = SCARG(&fa, cmd); /* save it for a while */
+
+ SCARG(&fa, cmd) = F_GETFL;
+ if ((error = fcntl(p, &fa)) != 0)
+ return error;
+ flags = *retval;
+ flags &= O_ASYNC;
+ flags |= svr4_to_bsd_flags((u_long) SCARG(uap, arg));
+ SCARG(&fa, cmd) = cmd;
+ SCARG(&fa, arg) = (long) flags;
+ return fcntl(p, &fa);
+ }
+
+ case F_GETLK:
+ case F_SETLK:
+ case F_SETLKW:
+ {
+ struct svr4_flock ifl;
+ struct flock *flp, fl;
+ caddr_t sg = stackgap_init();
+
+ flp = stackgap_alloc(&sg, sizeof(struct flock));
+ SCARG(&fa, arg) = (long) flp;
+
+ error = copyin(SCARG(uap, arg), &ifl, sizeof ifl);
+ if (error)
+ return error;
+
+ svr4_to_bsd_flock(&ifl, &fl);
+
+ error = copyout(&fl, flp, sizeof fl);
+ if (error)
+ return error;
+
+ error = fcntl(p, &fa);
+ if (error || SCARG(&fa, cmd) != F_GETLK)
+ return error;
+
+ error = copyin(flp, &fl, sizeof fl);
+ if (error)
+ return error;
+
+ bsd_to_svr4_flock(&fl, &ifl);
+
+ return copyout(&ifl, SCARG(uap, arg), sizeof ifl);
+ }
+ case -1:
+ switch (SCARG(uap, cmd)) {
+ case SVR4_F_DUP2FD:
+ {
+ struct dup2_args du;
+
+ SCARG(&du, from) = SCARG(uap, fd);
+ SCARG(&du, to) = (int)SCARG(uap, arg);
+ error = dup2(p, &du);
+ if (error)
+ return error;
+ *retval = SCARG(&du, to);
+ return 0;
+ }
+
+ case SVR4_F_FREESP:
+ {
+ struct svr4_flock ifl;
+ struct flock fl;
+
+ error = copyin(SCARG(uap, arg), &ifl,
+ sizeof ifl);
+ if (error)
+ return error;
+ svr4_to_bsd_flock(&ifl, &fl);
+ return fd_truncate(p, SCARG(uap, fd), &fl);
+ }
+
+ case SVR4_F_GETLK64:
+ case SVR4_F_SETLK64:
+ case SVR4_F_SETLKW64:
+ {
+ struct svr4_flock64 ifl;
+ struct flock *flp, fl;
+ caddr_t sg = stackgap_init();
+
+ flp = stackgap_alloc(&sg, sizeof(struct flock));
+ SCARG(&fa, arg) = (long) flp;
+
+ error = copyin(SCARG(uap, arg), &ifl,
+ sizeof ifl);
+ if (error)
+ return error;
+
+ svr4_to_bsd_flock64(&ifl, &fl);
+
+ error = copyout(&fl, flp, sizeof fl);
+ if (error)
+ return error;
+
+ error = fcntl(p, &fa);
+ if (error || SCARG(&fa, cmd) != F_GETLK)
+ return error;
+
+ error = copyin(flp, &fl, sizeof fl);
+ if (error)
+ return error;
+
+ bsd_to_svr4_flock64(&fl, &ifl);
+
+ return copyout(&ifl, SCARG(uap, arg),
+ sizeof ifl);
+ }
+
+ case SVR4_F_FREESP64:
+ {
+ struct svr4_flock64 ifl;
+ struct flock fl;
+
+ error = copyin(SCARG(uap, arg), &ifl,
+ sizeof ifl);
+ if (error)
+ return error;
+ svr4_to_bsd_flock64(&ifl, &fl);
+ return fd_truncate(p, SCARG(uap, fd), &fl);
+ }
+
+ case SVR4_F_REVOKE:
+ return fd_revoke(p, SCARG(uap, fd));
+
+ default:
+ return ENOSYS;
+ }
+
+ default:
+ return ENOSYS;
+ }
+}
diff --git a/sys/svr4/svr4_fcntl.h b/sys/svr4/svr4_fcntl.h
new file mode 100644
index 0000000..8c202f2
--- /dev/null
+++ b/sys/svr4/svr4_fcntl.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_FCNTL_H_
+#define _SVR4_FCNTL_H_
+
+#include <svr4/svr4_types.h>
+#include <sys/fcntl.h>
+
+#define SVR4_O_RDONLY 0x0000
+#define SVR4_O_WRONLY 0x0001
+#define SVR4_O_RDWR 0x0002
+#define SVR4_O_ACCMODE 0x0003
+#define SVR4_O_NDELAY 0x0004
+#define SVR4_O_APPEND 0x0008
+#define SVR4_O_SYNC 0x0010
+#define SVR4_O_NONBLOCK 0x0080
+#define SVR4_O_CREAT 0x0100
+#define SVR4_O_TRUNC 0x0200
+#define SVR4_O_EXCL 0x0400
+#define SVR4_O_NOCTTY 0x0800
+#define SVR4_O_PRIV 0x1000
+
+
+#define SVR4_FD_CLOEXEC 1
+
+#define SVR4_F_DUPFD 0
+#define SVR4_F_GETFD 1
+#define SVR4_F_SETFD 2
+#define SVR4_F_GETFL 3
+#define SVR4_F_SETFL 4
+#define SVR4_F_GETLK_SVR3 5
+#define SVR4_F_SETLK 6
+#define SVR4_F_SETLKW 7
+#define SVR4_F_CHKFL 8
+#define SVR4_F_DUP2FD 9
+#define SVR4_F_ALLOCSP 10
+#define SVR4_F_FREESP 11
+
+#define SVR4_F_ISSTREAM 13
+#define SVR4_F_GETLK 14
+#define SVR4_F_PRIV 15
+#define SVR4_F_NPRIV 16
+#define SVR4_F_QUOTACTL 17
+#define SVR4_F_BLOCKS 18
+#define SVR4_F_BLKSIZE 19
+#define SVR4_F_RSETLK 20
+#define SVR4_F_RGETLK 21
+#define SVR4_F_RSETLKW 22
+#define SVR4_F_GETOWN 23
+#define SVR4_F_SETOWN 24
+#define SVR4_F_REVOKE 25
+#define SVR4_F_HASREMOTELOCKS 26
+#define SVR4_F_FREESP64 27
+
+#define SVR4_F_GETLK64 33
+#define SVR4_F_SETLK64 34
+#define SVR4_F_SETLKW64 35
+
+#define SVR4_F_SHARE 40
+#define SVR4_F_UNSHARE 41
+
+#define SVR4_F_CHSIZE_XENIX 0x6000
+#define SVR4_F_RDCHK_XENIX 0x6001
+#define SVR4_F_LK_UNLCK_XENIX 0x6300
+#define SVR4_F_LK_LOCK_XENIX 0x7200
+#define SVR4_F_LK_NBLCK_XENIX 0x6200
+#define SVR4_F_LK_RLCK_XENIX 0x7100
+#define SVR4_F_LK_NBRLCK_XENIX 0x6100
+
+#define SVR4_LK_CMDTYPE(x) (((x) >> 12) & 0x7)
+#define SVR4_LK_LCKTYPE(x) (((x) >> 8) & 0x7)
+
+#define SVR4_F_RDLCK 1
+#define SVR4_F_WRLCK 2
+#define SVR4_F_UNLCK 3
+
+struct svr4_flock_svr3 {
+ short l_type;
+ short l_whence;
+ svr4_off_t l_start;
+ svr4_off_t l_len;
+ short l_sysid;
+ svr4_o_pid_t l_pid;
+};
+
+
+struct svr4_flock {
+ short l_type;
+ short l_whence;
+ svr4_off_t l_start;
+ svr4_off_t l_len;
+ long l_sysid;
+ svr4_pid_t l_pid;
+ long pad[4];
+};
+
+struct svr4_flock64 {
+ short l_type;
+ short l_whence;
+ svr4_off64_t l_start;
+ svr4_off64_t l_len;
+ long l_sysid;
+ svr4_pid_t l_pid;
+ long pad[4];
+};
+#endif /* !_SVR4_FCNTL_H_ */
diff --git a/sys/svr4/svr4_filio.c b/sys/svr4/svr4_filio.c
new file mode 100644
index 0000000..c82b09b
--- /dev/null
+++ b/sys/svr4/svr4_filio.c
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/proc.h>
+#include <sys/systm.h>
+#include <sys/file.h>
+#include <sys/filio.h>
+#include <sys/fcntl.h>
+#include <sys/signal.h>
+#include <sys/unistd.h>
+#include <sys/filedesc.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/mount.h>
+#include <net/if.h>
+#include <sys/malloc.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_ioctl.h>
+#include <svr4/svr4_filio.h>
+
+/*#define GROTTY_READ_HACK*/
+
+int
+svr4_sys_poll(p, uap)
+ struct proc *p;
+ struct svr4_sys_poll_args *uap;
+{
+ int error;
+ struct poll_args pa;
+ struct pollfd *pfd;
+ int idx = 0, cerr;
+ u_long siz;
+
+ SCARG(&pa, fds) = SCARG(uap, fds);
+ SCARG(&pa, nfds) = SCARG(uap, nfds);
+ SCARG(&pa, timeout) = SCARG(uap, timeout);
+
+ siz = SCARG(uap, nfds) * sizeof(struct pollfd);
+ pfd = (struct pollfd *)malloc(siz, M_TEMP, M_WAITOK);
+
+ error = poll(p, (struct poll_args *)uap);
+
+ if ((cerr = copyin(SCARG(uap, fds), pfd, siz)) != 0) {
+ error = cerr;
+ goto done;
+ }
+
+ for (idx = 0; idx < SCARG(uap, nfds); idx++) {
+ /* POLLWRNORM already equals POLLOUT, so we don't worry about that */
+ if (pfd[idx].revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI))
+ pfd[idx].revents |= (POLLIN | POLLRDBAND | POLLRDNORM | POLLPRI);
+ if (pfd[idx].revents & (POLLOUT | POLLWRNORM | POLLWRBAND))
+ pfd[idx].revents |= (POLLOUT | POLLWRNORM | POLLWRBAND);
+ pfd[idx].revents &= POLLSTANDARD; /* don't want to surprise SysV */
+
+ DPRINTF(("pollfd[%d]->fd = %d\n", idx, pfd[idx].fd));
+ DPRINTF(("pollfd[%d]->events = %x\n", idx, pfd[idx].events));
+ DPRINTF(("pollfd[%d]->revents = %x\n", idx, pfd[idx].revents));
+ }
+ DPRINTF(("poll(%x, %x, %d) = %d\n", SCARG(uap, fds), SCARG(uap, nfds),
+ SCARG(uap, timeout), p->p_retval[0]));
+ if ((cerr = copyout(pfd, SCARG(uap, fds), siz)) != 0) {
+ error = cerr;
+ goto done; /* yeah, I know it's the next line, but this way I won't
+ forget to update it if I add more code */
+ }
+done:
+ free(pfd, M_TEMP);
+ return error;
+}
+
+#if defined(READ_TEST)
+int
+svr4_sys_read(p, uap)
+ struct proc *p;
+ struct svr4_sys_read_args *uap;
+{
+ struct read_args ra;
+ struct filedesc *fdp = p->p_fd;
+ struct file *fp;
+ struct socket *so = NULL;
+ int so_state;
+ sigset_t sigmask;
+ int rv;
+
+ SCARG(&ra, fd) = SCARG(uap, fd);
+ SCARG(&ra, buf) = SCARG(uap, buf);
+ SCARG(&ra, nbyte) = SCARG(uap, nbyte);
+
+ if ((fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
+ DPRINTF(("Something fishy with the user-supplied file descriptor...\n"));
+ return EBADF;
+ }
+
+ if (fp->f_type == DTYPE_SOCKET) {
+ so = (struct socket *)fp->f_data;
+ DPRINTF(("fd %d is a socket\n", SCARG(uap, fd)));
+ if (so->so_state & SS_ASYNC) {
+ DPRINTF(("fd %d is an ASYNC socket!\n", SCARG(uap, fd)));
+ }
+ DPRINTF(("Here are its flags: 0x%x\n", so->so_state));
+#if defined(GROTTY_READ_HACK)
+ so_state = so->so_state;
+ so->so_state &= ~SS_NBIO;
+#endif
+ }
+
+ rv = read(p, &ra);
+
+ DPRINTF(("svr4_read(%d, 0x%0x, %d) = %d\n",
+ SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv));
+ if (rv == EAGAIN) {
+ DPRINTF(("sigmask = 0x%x\n", p->p_sigmask));
+ DPRINTF(("sigignore = 0x%x\n", p->p_sigignore));
+ DPRINTF(("sigcaught = 0x%x\n", p->p_sigcatch));
+ DPRINTF(("siglist = 0x%x\n", p->p_siglist));
+ }
+
+#if defined(GROTTY_READ_HACK)
+ if (so) { /* We've already checked to see if this is a socket */
+ so->so_state = so_state;
+ }
+#endif
+
+ return(rv);
+}
+#endif /* READ_TEST */
+
+#if defined(BOGUS)
+int
+svr4_sys_write(p, uap)
+ struct proc *p;
+ struct svr4_sys_write_args *uap;
+{
+ struct write_args wa;
+ struct filedesc *fdp;
+ struct file *fp;
+ int rv;
+
+ SCARG(&wa, fd) = SCARG(uap, fd);
+ SCARG(&wa, buf) = SCARG(uap, buf);
+ SCARG(&wa, nbyte) = SCARG(uap, nbyte);
+
+ rv = write(p, &wa);
+
+ DPRINTF(("svr4_write(%d, 0x%0x, %d) = %d\n",
+ SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv));
+
+ return(rv);
+}
+#endif /* BOGUS */
+
+int
+svr4_fil_ioctl(fp, p, retval, fd, cmd, data)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t data;
+{
+ int error;
+ int num;
+ struct filedesc *fdp = p->p_fd;
+ int (*ctl) __P((struct file *, u_long, caddr_t, struct proc *)) =
+ fp->f_ops->fo_ioctl;
+
+ *retval = 0;
+
+ switch (cmd) {
+ case SVR4_FIOCLEX:
+ fdp->fd_ofileflags[fd] |= UF_EXCLOSE;
+ return 0;
+
+ case SVR4_FIONCLEX:
+ fdp->fd_ofileflags[fd] &= ~UF_EXCLOSE;
+ return 0;
+
+ case SVR4_FIOGETOWN:
+ case SVR4_FIOSETOWN:
+ case SVR4_FIOASYNC:
+ case SVR4_FIONBIO:
+ case SVR4_FIONREAD:
+ if ((error = copyin(data, &num, sizeof(num))) != 0)
+ return error;
+
+ switch (cmd) {
+ case SVR4_FIOGETOWN: cmd = FIOGETOWN; break;
+ case SVR4_FIOSETOWN: cmd = FIOSETOWN; break;
+ case SVR4_FIOASYNC: cmd = FIOASYNC; break;
+ case SVR4_FIONBIO: cmd = FIONBIO; break;
+ case SVR4_FIONREAD: cmd = FIONREAD; break;
+ }
+
+#ifdef SVR4_DEBUG
+ if (cmd == FIOASYNC) DPRINTF(("FIOASYNC\n"));
+#endif
+ error = (*ctl)(fp, cmd, (caddr_t) &num, p);
+
+ if (error)
+ return error;
+
+ return copyout(&num, data, sizeof(num));
+
+ default:
+ DPRINTF(("Unknown svr4 filio %lx\n", cmd));
+ return 0; /* ENOSYS really */
+ }
+}
diff --git a/sys/svr4/svr4_filio.h b/sys/svr4/svr4_filio.h
new file mode 100644
index 0000000..2f105a7
--- /dev/null
+++ b/sys/svr4/svr4_filio.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_FILIO_H_
+#define _SVR4_FILIO_H_
+
+#define SVR4_FIOC ('f' << 8)
+
+#define SVR4_FIOCLEX SVR4_IO('f', 1)
+#define SVR4_FIONCLEX SVR4_IO('f', 2)
+
+#define SVR4_FIOGETOWN SVR4_IOR('f', 123, int)
+#define SVR4_FIOSETOWN SVR4_IOW('f', 124, int)
+#define SVR4_FIOASYNC SVR4_IOW('f', 125, int)
+#define SVR4_FIONBIO SVR4_IOW('f', 126, int)
+#define SVR4_FIONREAD SVR4_IOR('f', 127, int)
+
+#endif /* !_SVR4_FILIO_H_ */
diff --git a/sys/svr4/svr4_fuser.h b/sys/svr4/svr4_fuser.h
new file mode 100644
index 0000000..669d527
--- /dev/null
+++ b/sys/svr4/svr4_fuser.h
@@ -0,0 +1,96 @@
+/*
+ * Derived from:
+ * $NetBSD: svr4_fuser.h,v 1.4 1998/09/04 19:54:38 christos Exp $ */
+
+/*-
+ * Original Copyright:
+ *
+ * Copyright (c) 1994 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions of this code have been derived from code contributed to the
+ * FreeBSD Project by Mark Newton.
+ *
+ * Copyright (c) 1999 Mark Newton
+ * 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.
+ */
+
+#ifndef _SVR4_FUSER_H_
+#define _SVR4_FUSER_H_
+
+#include <svr4/svr4_types.h>
+
+struct svr4_f_user {
+ svr4_pid_t fu_pid;
+ int fu_flags;
+ uid_t fu_uid;
+};
+
+
+#define SVR4_F_FILE_ONLY 1
+#define SVR4_F_CONTAINED 2
+
+#define SVR4_F_CDIR 0x01
+#define SVR4_F_RDIR 0x02
+#define SVR4_F_TEXT 0x04
+#define SVR4_F_MAP 0x08
+#define SVR4_F_OPEN 0x10
+#define SVR4_F_TRACE 0x20
+#define SVR4_F_TTY 0x40
+
+#endif /* !_SVR4_FUSER_H_ */
diff --git a/sys/svr4/svr4_hrt.h b/sys/svr4/svr4_hrt.h
new file mode 100644
index 0000000..ce54ad0
--- /dev/null
+++ b/sys/svr4/svr4_hrt.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_HRT_H_
+#define _SVR4_HRT_H_
+
+#define SVR4_HRT_CNTL 0
+#define SVR4_HRT_CNTL_RES 0
+#define SVR4_HRT_CNTL_TOFD 1
+#define SVR4_HRT_CNTL_START 2
+#define SVR4_HRT_CNTL_GET 3
+
+#define SVR4_HRT_ALRM 1
+#define SVR4_HRT_ALRM_DO 4
+#define SVR4_HRT_ALRM_REP 5
+#define SVR4_HRT_ALRM_TOD 6
+#define SVR4_HRT_ALRM_FUTREP 7
+#define SVR4_HRT_ALRM_TODREP 8
+#define SVR4_HRT_ALRM_PEND 9
+
+#define SVR4_HRT_SLP 2
+#define SVR4_HRT_SLP_INT 10
+#define SVR4_HRT_SLP_TOD 11
+
+#define SVR4_HRT_BSD 12
+#define SVR4_HRT_BSD_PEND 13
+#define SVR4_HRT_BSD_REP1 14
+#define SVR4_HRT_BSD_REP2 15
+#define SVR4_HRT_BSD_CANCEL 16
+
+#define SVR4_HRT_CAN 3
+
+#define SVR4_HRT_SEC 1
+#define SVR4_HRT_MSEC 1000
+#define SVR4_HRT_USEC 1000000
+#define SVR4_HRT_NSEC 1000000000
+
+#define SVR4_HRT_TRUNC 0
+#define SVR4_HRT_RND 1
+
+typedef struct {
+ u_long i_word1;
+ u_long i_word2;
+ int i_clock;
+} svr4_hrt_interval_t;
+
+typedef struct {
+ u_long h_sec;
+ long h_rem;
+ u_long h_res;
+} svr4_hrt_time_t;
+
+#define SVR4_HRT_DONE 1
+#define SVR4_HRT_ERROR 2
+
+#define SVR4_HRT_CLK_STD 1
+#define SVR4_HRT_CLK_USERVIRT 2
+#define SVR4_HRT_CLK_PROCVIRT 4
+
+#endif /* !_SVR4_HRT_H_ */
diff --git a/sys/svr4/svr4_ioctl.c b/sys/svr4/svr4_ioctl.c
new file mode 100644
index 0000000..2ce3004
--- /dev/null
+++ b/sys/svr4/svr4_ioctl.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/proc.h>
+#include <sys/systm.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/unistd.h>
+#include <sys/fcntl.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/mount.h>
+#include <net/if.h>
+#include <sys/malloc.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_ioctl.h>
+#include <svr4/svr4_termios.h>
+#include <svr4/svr4_ttold.h>
+#include <svr4/svr4_filio.h>
+#include <svr4/svr4_sockio.h>
+
+#ifdef DEBUG_SVR4
+static void svr4_decode_cmd __P((u_long, char *, char *, int *, int *));
+/*
+ * Decode an ioctl command symbolically
+ */
+static void
+svr4_decode_cmd(cmd, dir, c, num, argsiz)
+ u_long cmd;
+ char *dir, *c;
+ int *num, *argsiz;
+{
+ if (cmd & SVR4_IOC_VOID)
+ *dir++ = 'V';
+ if (cmd & SVR4_IOC_IN)
+ *dir++ = 'R';
+ if (cmd & SVR4_IOC_OUT)
+ *dir++ = 'W';
+ *dir = '\0';
+ if (cmd & SVR4_IOC_INOUT)
+ *argsiz = (cmd >> 16) & 0xff;
+ else
+ *argsiz = -1;
+
+ *c = (cmd >> 8) & 0xff;
+ *num = cmd & 0xff;
+}
+#endif
+
+int
+svr4_sys_ioctl(p, uap)
+ register struct proc *p;
+ struct svr4_sys_ioctl_args *uap;
+{
+ int *retval;
+ struct file *fp;
+ struct filedesc *fdp;
+ u_long cmd;
+ int (*fun) __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+#ifdef DEBUG_SVR4
+ char dir[4];
+ char c;
+ int num;
+ int argsiz;
+
+ svr4_decode_cmd(SCARG(uap, com), dir, &c, &num, &argsiz);
+
+ DPRINTF(("svr4_ioctl[%x](%d, _IO%s(%c, %d, %d), %p);\n", SCARG(uap, com), SCARG(uap, fd),
+ dir, c, num, argsiz, SCARG(uap, data)));
+#endif
+ retval = p->p_retval;
+ fdp = p->p_fd;
+ cmd = SCARG(uap, com);
+
+ if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
+ (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL)
+ return EBADF;
+
+ if ((fp->f_flag & (FREAD | FWRITE)) == 0)
+ return EBADF;
+
+#if defined(DEBUG_SVR4)
+ if (fp->f_type == DTYPE_SOCKET) {
+ struct socket *so = fp->f_data;
+ DPRINTF(("<<< IN: so_state = 0x%x\n", so->so_state));
+ }
+#endif
+
+ switch (cmd & 0xff00) {
+ case SVR4_tIOC:
+ DPRINTF(("ttold\n"));
+ fun = svr4_ttold_ioctl;
+ break;
+
+ case SVR4_TIOC:
+ DPRINTF(("term\n"));
+ fun = svr4_term_ioctl;
+ break;
+
+ case SVR4_STR:
+ DPRINTF(("stream\n"));
+ fun = svr4_stream_ioctl;
+ break;
+
+ case SVR4_FIOC:
+ DPRINTF(("file\n"));
+ fun = svr4_fil_ioctl;
+ break;
+
+ case SVR4_SIOC:
+ DPRINTF(("socket\n"));
+ fun = svr4_sock_ioctl;
+ break;
+
+ case SVR4_XIOC:
+ /* We do not support those */
+ return EINVAL;
+
+ default:
+ DPRINTF(("Unimplemented ioctl %lx\n", cmd));
+ return 0; /* XXX: really ENOSYS */
+ }
+#if defined(DEBUG_SVR4)
+ if (fp->f_type == DTYPE_SOCKET) {
+ struct socket *so = fp->f_data;
+ DPRINTF((">>> OUT: so_state = 0x%x\n", so->so_state));
+ }
+#endif
+ return (*fun)(fp, p, retval, SCARG(uap, fd), cmd, SCARG(uap, data));
+}
diff --git a/sys/svr4/svr4_ioctl.h b/sys/svr4/svr4_ioctl.h
new file mode 100644
index 0000000..e95fa5a
--- /dev/null
+++ b/sys/svr4/svr4_ioctl.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_IOCTL_H_
+#define _SVR4_IOCTL_H_
+
+#define SVR4_IOC_VOID 0x20000000
+#define SVR4_IOC_OUT 0x40000000
+#define SVR4_IOC_IN 0x80000000
+#define SVR4_IOC_INOUT (SVR4_IOC_IN|SVR4_IOC_OUT)
+
+#define SVR4_IOC(inout,group,num,len) \
+ (inout | ((len & 0xff) << 16) | ((group) << 8) | (num))
+
+#define SVR4_XIOC ('X' << 8)
+
+#define SVR4_IO(g,n) SVR4_IOC(SVR4_IOC_VOID, (g), (n), 0)
+#define SVR4_IOR(g,n,t) SVR4_IOC(SVR4_IOC_OUT, (g), (n), sizeof(t))
+#define SVR4_IOW(g,n,t) SVR4_IOC(SVR4_IOC_IN, (g), (n), sizeof(t))
+#define SVR4_IOWR(g,n,t) SVR4_IOC(SVR4_IOC_INOUT,(g), (n), sizeof(t))
+
+int svr4_stream_ti_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+int svr4_stream_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+int svr4_term_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+int svr4_ttold_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+int svr4_fil_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+int svr4_sock_ioctl __P((struct file *, struct proc *, register_t *,
+ int, u_long, caddr_t));
+
+#endif /* !_SVR4_IOCTL_H_ */
diff --git a/sys/svr4/svr4_ipc.c b/sys/svr4/svr4_ipc.c
new file mode 100644
index 0000000..8bb661b
--- /dev/null
+++ b/sys/svr4/svr4_ipc.c
@@ -0,0 +1,831 @@
+/*
+ * Derived from:
+ * $NetBSD: svr4_ipc.c,v 1.7 1998/10/19 22:43:00 tron Exp $ */
+
+/*-
+ * Original copyright:
+ *
+ * Copyright (c) 1995 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions of this code have been derived from software contributed
+ * to the FreeBSD Project by Mark Newton.
+ *
+ * Copyright (c) 1999 Mark Newton
+ * 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.
+ *
+ * XXX- This code is presently a no-op on FreeBSD (and isn't compiled due
+ * to preprocessor conditionals). A nice project for a kernel hacking
+ * novice might be to MakeItGo, but I have more important fish to fry
+ * at present.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/shm.h>
+#include <sys/msg.h>
+#include <sys/sem.h>
+#include <sys/proc.h>
+#include <sys/uio.h>
+#include <sys/time.h>
+#include <sys/malloc.h>
+#include <sys/mman.h>
+#include <sys/systm.h>
+#include <sys/stat.h>
+
+#include <sys/mount.h>
+#include <sys/sysproto.h>
+
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_ipc.h>
+
+#if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
+static void svr4_to_bsd_ipc_perm __P((const struct svr4_ipc_perm *,
+ struct ipc_perm *));
+static void bsd_to_svr4_ipc_perm __P((const struct ipc_perm *,
+ struct svr4_ipc_perm *));
+#endif
+
+#ifdef SYSVSEM
+static void bsd_to_svr4_semid_ds __P((const struct semid_ds *,
+ struct svr4_semid_ds *));
+static void svr4_to_bsd_semid_ds __P((const struct svr4_semid_ds *,
+ struct semid_ds *));
+static int svr4_setsemun __P((caddr_t *sgp, union semun **argp,
+ union semun *usp));
+static int svr4_semop __P((struct proc *, void *, register_t *));
+static int svr4_semget __P((struct proc *, void *, register_t *));
+static int svr4_semctl __P((struct proc *, void *, register_t *));
+#endif
+
+#ifdef SYSVMSG
+static void bsd_to_svr4_msqid_ds __P((const struct msqid_ds *,
+ struct svr4_msqid_ds *));
+static void svr4_to_bsd_msqid_ds __P((const struct svr4_msqid_ds *,
+ struct msqid_ds *));
+static int svr4_msgsnd __P((struct proc *, void *, register_t *));
+static int svr4_msgrcv __P((struct proc *, void *, register_t *));
+static int svr4_msgget __P((struct proc *, void *, register_t *));
+static int svr4_msgctl __P((struct proc *, void *, register_t *));
+#endif
+
+#ifdef SYSVSHM
+static void bsd_to_svr4_shmid_ds __P((const struct shmid_ds *,
+ struct svr4_shmid_ds *));
+static void svr4_to_bsd_shmid_ds __P((const struct svr4_shmid_ds *,
+ struct shmid_ds *));
+static int svr4_shmat __P((struct proc *, void *, register_t *));
+static int svr4_shmdt __P((struct proc *, void *, register_t *));
+static int svr4_shmget __P((struct proc *, void *, register_t *));
+static int svr4_shmctl __P((struct proc *, void *, register_t *));
+#endif
+
+#if defined(SYSVMSG) || defined(SYSVSHM) || defined(SYSVSEM)
+
+static void
+svr4_to_bsd_ipc_perm(spp, bpp)
+ const struct svr4_ipc_perm *spp;
+ struct ipc_perm *bpp;
+{
+ bpp->key = spp->key;
+ bpp->uid = spp->uid;
+ bpp->gid = spp->gid;
+ bpp->cuid = spp->cuid;
+ bpp->cgid = spp->cgid;
+ bpp->mode = spp->mode;
+ bpp->seq = spp->seq;
+}
+
+static void
+bsd_to_svr4_ipc_perm(bpp, spp)
+ const struct ipc_perm *bpp;
+ struct svr4_ipc_perm *spp;
+{
+ spp->key = bpp->key;
+ spp->uid = bpp->uid;
+ spp->gid = bpp->gid;
+ spp->cuid = bpp->cuid;
+ spp->cgid = bpp->cgid;
+ spp->mode = bpp->mode;
+ spp->seq = bpp->seq;
+}
+#endif
+
+#ifdef SYSVSEM
+static void
+bsd_to_svr4_semid_ds(bds, sds)
+ const struct semid_ds *bds;
+ struct svr4_semid_ds *sds;
+{
+ bsd_to_svr4_ipc_perm(&bds->sem_perm, &sds->sem_perm);
+ sds->sem_base = (struct svr4_sem *) bds->sem_base;
+ sds->sem_nsems = bds->sem_nsems;
+ sds->sem_otime = bds->sem_otime;
+ sds->sem_pad1 = bds->sem_pad1;
+ sds->sem_ctime = bds->sem_ctime;
+ sds->sem_pad2 = bds->sem_pad2;
+}
+
+static void
+svr4_to_bsd_semid_ds(sds, bds)
+ const struct svr4_semid_ds *sds;
+ struct semid_ds *bds;
+{
+ svr4_to_bsd_ipc_perm(&sds->sem_perm, &bds->sem_perm);
+ bds->sem_base = (struct sem *) bds->sem_base;
+ bds->sem_nsems = sds->sem_nsems;
+ bds->sem_otime = sds->sem_otime;
+ bds->sem_pad1 = sds->sem_pad1;
+ bds->sem_ctime = sds->sem_ctime;
+ bds->sem_pad2 = sds->sem_pad2;
+}
+
+static int
+svr4_setsemun(sgp, argp, usp)
+ caddr_t *sgp;
+ union semun **argp;
+ union semun *usp;
+{
+ *argp = stackgap_alloc(sgp, sizeof(union semun));
+ return copyout((caddr_t)usp, *argp, sizeof(union semun));
+}
+
+struct svr4_sys_semctl_args {
+ syscallarg(int) what;
+ syscallarg(int) semid;
+ syscallarg(int) semnum;
+ syscallarg(int) cmd;
+ syscallarg(union semun) arg;
+};
+
+static int
+svr4_semctl(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ int error;
+ struct svr4_sys_semctl_args *uap = v;
+ struct sys___semctl_args ap;
+ struct svr4_semid_ds ss;
+ struct semid_ds bs, *bsp;
+ caddr_t sg = stackgap_init(p->p_emul);
+
+ SCARG(&ap, semid) = SCARG(uap, semid);
+ SCARG(&ap, semnum) = SCARG(uap, semnum);
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_SEM_GETZCNT:
+ case SVR4_SEM_GETNCNT:
+ case SVR4_SEM_GETPID:
+ case SVR4_SEM_GETVAL:
+ switch (SCARG(uap, cmd)) {
+ case SVR4_SEM_GETZCNT:
+ SCARG(&ap, cmd) = GETZCNT;
+ break;
+ case SVR4_SEM_GETNCNT:
+ SCARG(&ap, cmd) = GETNCNT;
+ break;
+ case SVR4_SEM_GETPID:
+ SCARG(&ap, cmd) = GETPID;
+ break;
+ case SVR4_SEM_GETVAL:
+ SCARG(&ap, cmd) = GETVAL;
+ break;
+ }
+ return sys___semctl(p, &ap, retval);
+
+ case SVR4_SEM_SETVAL:
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+ if (error)
+ return error;
+ SCARG(&ap, cmd) = SETVAL;
+ return sys___semctl(p, &ap, retval);
+
+ case SVR4_SEM_GETALL:
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+ if (error)
+ return error;
+ SCARG(&ap, cmd) = GETVAL;
+ return sys___semctl(p, &ap, retval);
+
+ case SVR4_SEM_SETALL:
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg), &SCARG(uap, arg));
+ if (error)
+ return error;
+ SCARG(&ap, cmd) = SETVAL;
+ return sys___semctl(p, &ap, retval);
+
+ case SVR4_IPC_STAT:
+ SCARG(&ap, cmd) = IPC_STAT;
+ bsp = stackgap_alloc(&sg, sizeof(bs));
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+ (union semun *)&bsp);
+ if (error)
+ return error;
+ if ((error = sys___semctl(p, &ap, retval)) != 0)
+ return error;
+ error = copyin((caddr_t)bsp, (caddr_t)&bs, sizeof(bs));
+ if (error)
+ return error;
+ bsd_to_svr4_semid_ds(&bs, &ss);
+ return copyout(&ss, SCARG(uap, arg).buf, sizeof(ss));
+
+ case SVR4_IPC_SET:
+ SCARG(&ap, cmd) = IPC_SET;
+ bsp = stackgap_alloc(&sg, sizeof(bs));
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+ (union semun *)&bsp);
+ if (error)
+ return error;
+ error = copyin(SCARG(uap, arg).buf, (caddr_t) &ss, sizeof ss);
+ if (error)
+ return error;
+ svr4_to_bsd_semid_ds(&ss, &bs);
+ error = copyout(&bs, bsp, sizeof(bs));
+ if (error)
+ return error;
+ return sys___semctl(p, &ap, retval);
+
+ case SVR4_IPC_RMID:
+ SCARG(&ap, cmd) = IPC_RMID;
+ bsp = stackgap_alloc(&sg, sizeof(bs));
+ error = svr4_setsemun(&sg, &SCARG(&ap, arg),
+ (union semun *)&bsp);
+ if (error)
+ return error;
+ error = copyin(SCARG(uap, arg).buf, &ss, sizeof ss);
+ if (error)
+ return error;
+ svr4_to_bsd_semid_ds(&ss, &bs);
+ error = copyout(&bs, bsp, sizeof(bs));
+ if (error)
+ return error;
+ return sys___semctl(p, &ap, retval);
+
+ default:
+ return EINVAL;
+ }
+}
+
+struct svr4_sys_semget_args {
+ syscallarg(int) what;
+ syscallarg(svr4_key_t) key;
+ syscallarg(int) nsems;
+ syscallarg(int) semflg;
+};
+
+static int
+svr4_semget(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_semget_args *uap = v;
+ struct sys_semget_args ap;
+
+ SCARG(&ap, key) = SCARG(uap, key);
+ SCARG(&ap, nsems) = SCARG(uap, nsems);
+ SCARG(&ap, semflg) = SCARG(uap, semflg);
+
+ return sys_semget(p, &ap, retval);
+}
+
+struct svr4_sys_semop_args {
+ syscallarg(int) what;
+ syscallarg(int) semid;
+ syscallarg(struct svr4_sembuf *) sops;
+ syscallarg(u_int) nsops;
+};
+
+static int
+svr4_semop(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_semop_args *uap = v;
+ struct sys_semop_args ap;
+
+ SCARG(&ap, semid) = SCARG(uap, semid);
+ /* These are the same */
+ SCARG(&ap, sops) = (struct sembuf *) SCARG(uap, sops);
+ SCARG(&ap, nsops) = SCARG(uap, nsops);
+
+ return sys_semop(p, &ap, retval);
+}
+
+int
+svr4_sys_semsys(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_semsys_args *uap = v;
+
+ DPRINTF(("svr4_semsys(%d)\n", SCARG(uap, what)));
+
+ switch (SCARG(uap, what)) {
+ case SVR4_semctl:
+ return svr4_semctl(p, v, retval);
+ case SVR4_semget:
+ return svr4_semget(p, v, retval);
+ case SVR4_semop:
+ return svr4_semop(p, v, retval);
+ default:
+ return EINVAL;
+ }
+}
+#endif
+
+#ifdef SYSVMSG
+static void
+bsd_to_svr4_msqid_ds(bds, sds)
+ const struct msqid_ds *bds;
+ struct svr4_msqid_ds *sds;
+{
+ bsd_to_svr4_ipc_perm(&bds->msg_perm, &sds->msg_perm);
+ sds->msg_first = (struct svr4_msg *) bds->msg_first;
+ sds->msg_last = (struct svr4_msg *) bds->msg_last;
+ sds->msg_cbytes = bds->msg_cbytes;
+ sds->msg_qnum = bds->msg_qnum;
+ sds->msg_qbytes = bds->msg_qbytes;
+ sds->msg_lspid = bds->msg_lspid;
+ sds->msg_lrpid = bds->msg_lrpid;
+ sds->msg_stime = bds->msg_stime;
+ sds->msg_pad1 = bds->msg_pad1;
+ sds->msg_rtime = bds->msg_rtime;
+ sds->msg_pad2 = bds->msg_pad2;
+ sds->msg_ctime = bds->msg_ctime;
+ sds->msg_pad3 = bds->msg_pad3;
+
+ /* use the padding for the rest of the fields */
+ {
+ const short *pad = (const short *) bds->msg_pad4;
+ sds->msg_cv = pad[0];
+ sds->msg_qnum_cv = pad[1];
+ }
+}
+
+static void
+svr4_to_bsd_msqid_ds(sds, bds)
+ const struct svr4_msqid_ds *sds;
+ struct msqid_ds *bds;
+{
+ svr4_to_bsd_ipc_perm(&sds->msg_perm, &bds->msg_perm);
+ bds->msg_first = (struct msg *) sds->msg_first;
+ bds->msg_last = (struct msg *) sds->msg_last;
+ bds->msg_cbytes = sds->msg_cbytes;
+ bds->msg_qnum = sds->msg_qnum;
+ bds->msg_qbytes = sds->msg_qbytes;
+ bds->msg_lspid = sds->msg_lspid;
+ bds->msg_lrpid = sds->msg_lrpid;
+ bds->msg_stime = sds->msg_stime;
+ bds->msg_pad1 = sds->msg_pad1;
+ bds->msg_rtime = sds->msg_rtime;
+ bds->msg_pad2 = sds->msg_pad2;
+ bds->msg_ctime = sds->msg_ctime;
+ bds->msg_pad3 = sds->msg_pad3;
+
+ /* use the padding for the rest of the fields */
+ {
+ short *pad = (short *) bds->msg_pad4;
+ pad[0] = sds->msg_cv;
+ pad[1] = sds->msg_qnum_cv;
+ }
+}
+
+struct svr4_sys_msgsnd_args {
+ syscallarg(int) what;
+ syscallarg(int) msqid;
+ syscallarg(void *) msgp;
+ syscallarg(size_t) msgsz;
+ syscallarg(int) msgflg;
+};
+
+static int
+svr4_msgsnd(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_msgsnd_args *uap = v;
+ struct sys_msgsnd_args ap;
+
+ SCARG(&ap, msqid) = SCARG(uap, msqid);
+ SCARG(&ap, msgp) = SCARG(uap, msgp);
+ SCARG(&ap, msgsz) = SCARG(uap, msgsz);
+ SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+
+ return sys_msgsnd(p, &ap, retval);
+}
+
+struct svr4_sys_msgrcv_args {
+ syscallarg(int) what;
+ syscallarg(int) msqid;
+ syscallarg(void *) msgp;
+ syscallarg(size_t) msgsz;
+ syscallarg(long) msgtyp;
+ syscallarg(int) msgflg;
+};
+
+static int
+svr4_msgrcv(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_msgrcv_args *uap = v;
+ struct sys_msgrcv_args ap;
+
+ SCARG(&ap, msqid) = SCARG(uap, msqid);
+ SCARG(&ap, msgp) = SCARG(uap, msgp);
+ SCARG(&ap, msgsz) = SCARG(uap, msgsz);
+ SCARG(&ap, msgtyp) = SCARG(uap, msgtyp);
+ SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+
+ return sys_msgrcv(p, &ap, retval);
+}
+
+struct svr4_sys_msgget_args {
+ syscallarg(int) what;
+ syscallarg(svr4_key_t) key;
+ syscallarg(int) msgflg;
+};
+
+static int
+svr4_msgget(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_msgget_args *uap = v;
+ struct sys_msgget_args ap;
+
+ SCARG(&ap, key) = SCARG(uap, key);
+ SCARG(&ap, msgflg) = SCARG(uap, msgflg);
+
+ return sys_msgget(p, &ap, retval);
+}
+
+struct svr4_sys_msgctl_args {
+ syscallarg(int) what;
+ syscallarg(int) msqid;
+ syscallarg(int) cmd;
+ syscallarg(struct svr4_msqid_ds *) buf;
+};
+
+static int
+svr4_msgctl(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ int error;
+ struct svr4_sys_msgctl_args *uap = v;
+ struct sys_msgctl_args ap;
+ struct svr4_msqid_ds ss;
+ struct msqid_ds bs;
+ caddr_t sg = stackgap_init(p->p_emul);
+
+ SCARG(&ap, msqid) = SCARG(uap, msqid);
+ SCARG(&ap, cmd) = SCARG(uap, cmd);
+ SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof(bs));
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_IPC_STAT:
+ SCARG(&ap, cmd) = IPC_STAT;
+ if ((error = sys_msgctl(p, &ap, retval)) != 0)
+ return error;
+ error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
+ if (error)
+ return error;
+ bsd_to_svr4_msqid_ds(&bs, &ss);
+ return copyout(&ss, SCARG(uap, buf), sizeof ss);
+
+ case SVR4_IPC_SET:
+ SCARG(&ap, cmd) = IPC_SET;
+ error = copyin(SCARG(uap, buf), &ss, sizeof ss);
+ if (error)
+ return error;
+ svr4_to_bsd_msqid_ds(&ss, &bs);
+ error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+ if (error)
+ return error;
+ return sys_msgctl(p, &ap, retval);
+
+ case SVR4_IPC_RMID:
+ SCARG(&ap, cmd) = IPC_RMID;
+ error = copyin(SCARG(uap, buf), &ss, sizeof ss);
+ if (error)
+ return error;
+ svr4_to_bsd_msqid_ds(&ss, &bs);
+ error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+ if (error)
+ return error;
+ return sys_msgctl(p, &ap, retval);
+
+ default:
+ return EINVAL;
+ }
+}
+
+int
+svr4_sys_msgsys(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_msgsys_args *uap = v;
+
+ DPRINTF(("svr4_msgsys(%d)\n", SCARG(uap, what)));
+
+ switch (SCARG(uap, what)) {
+ case SVR4_msgsnd:
+ return svr4_msgsnd(p, v, retval);
+ case SVR4_msgrcv:
+ return svr4_msgrcv(p, v, retval);
+ case SVR4_msgget:
+ return svr4_msgget(p, v, retval);
+ case SVR4_msgctl:
+ return svr4_msgctl(p, v, retval);
+ default:
+ return EINVAL;
+ }
+}
+#endif
+
+#ifdef SYSVSHM
+
+static void
+bsd_to_svr4_shmid_ds(bds, sds)
+ const struct shmid_ds *bds;
+ struct svr4_shmid_ds *sds;
+{
+ bsd_to_svr4_ipc_perm(&bds->shm_perm, &sds->shm_perm);
+ sds->shm_segsz = bds->shm_segsz;
+ sds->shm_lkcnt = 0;
+ sds->shm_lpid = bds->shm_lpid;
+ sds->shm_cpid = bds->shm_cpid;
+ sds->shm_amp = bds->shm_internal;
+ sds->shm_nattch = bds->shm_nattch;
+ sds->shm_cnattch = 0;
+ sds->shm_atime = bds->shm_atime;
+ sds->shm_pad1 = 0;
+ sds->shm_dtime = bds->shm_dtime;
+ sds->shm_pad2 = 0;
+ sds->shm_ctime = bds->shm_ctime;
+ sds->shm_pad3 = 0;
+}
+
+static void
+svr4_to_bsd_shmid_ds(sds, bds)
+ const struct svr4_shmid_ds *sds;
+ struct shmid_ds *bds;
+{
+ svr4_to_bsd_ipc_perm(&sds->shm_perm, &bds->shm_perm);
+ bds->shm_segsz = sds->shm_segsz;
+ bds->shm_lpid = sds->shm_lpid;
+ bds->shm_cpid = sds->shm_cpid;
+ bds->shm_internal = sds->shm_amp;
+ bds->shm_nattch = sds->shm_nattch;
+ bds->shm_atime = sds->shm_atime;
+ bds->shm_dtime = sds->shm_dtime;
+ bds->shm_ctime = sds->shm_ctime;
+}
+
+struct svr4_sys_shmat_args {
+ syscallarg(int) what;
+ syscallarg(int) shmid;
+ syscallarg(void *) shmaddr;
+ syscallarg(int) shmflg;
+};
+
+static int
+svr4_shmat(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_shmat_args *uap = v;
+ struct sys_shmat_args ap;
+
+ SCARG(&ap, shmid) = SCARG(uap, shmid);
+ SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
+ SCARG(&ap, shmflg) = SCARG(uap, shmflg);
+
+ return sys_shmat(p, &ap, retval);
+}
+
+struct svr4_sys_shmdt_args {
+ syscallarg(int) what;
+ syscallarg(void *) shmaddr;
+};
+
+static int
+svr4_shmdt(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_shmdt_args *uap = v;
+ struct sys_shmdt_args ap;
+
+ SCARG(&ap, shmaddr) = SCARG(uap, shmaddr);
+
+ return sys_shmdt(p, &ap, retval);
+}
+
+struct svr4_sys_shmget_args {
+ syscallarg(int) what;
+ syscallarg(key_t) key;
+ syscallarg(int) size;
+ syscallarg(int) shmflg;
+};
+
+static int
+svr4_shmget(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_shmget_args *uap = v;
+ struct sys_shmget_args ap;
+
+ SCARG(&ap, key) = SCARG(uap, key);
+ SCARG(&ap, size) = SCARG(uap, size);
+ SCARG(&ap, shmflg) = SCARG(uap, shmflg);
+
+ return sys_shmget(p, &ap, retval);
+}
+
+struct svr4_sys_shmctl_args {
+ syscallarg(int) what;
+ syscallarg(int) shmid;
+ syscallarg(int) cmd;
+ syscallarg(struct svr4_shmid_ds *) buf;
+};
+
+int
+svr4_shmctl(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_shmctl_args *uap = v;
+ int error;
+ caddr_t sg = stackgap_init(p->p_emul);
+ struct sys_shmctl_args ap;
+ struct shmid_ds bs;
+ struct svr4_shmid_ds ss;
+
+ SCARG(&ap, shmid) = SCARG(uap, shmid);
+
+ if (SCARG(uap, buf) != NULL) {
+ SCARG(&ap, buf) = stackgap_alloc(&sg, sizeof (struct shmid_ds));
+ switch (SCARG(uap, cmd)) {
+ case SVR4_IPC_SET:
+ case SVR4_IPC_RMID:
+ case SVR4_SHM_LOCK:
+ case SVR4_SHM_UNLOCK:
+ error = copyin(SCARG(uap, buf), (caddr_t) &ss,
+ sizeof ss);
+ if (error)
+ return error;
+ svr4_to_bsd_shmid_ds(&ss, &bs);
+ error = copyout(&bs, SCARG(&ap, buf), sizeof bs);
+ if (error)
+ return error;
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ SCARG(&ap, buf) = NULL;
+
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_IPC_STAT:
+ SCARG(&ap, cmd) = IPC_STAT;
+ if ((error = sys_shmctl(p, &ap, retval)) != 0)
+ return error;
+ if (SCARG(uap, buf) == NULL)
+ return 0;
+ error = copyin(&bs, SCARG(&ap, buf), sizeof bs);
+ if (error)
+ return error;
+ bsd_to_svr4_shmid_ds(&bs, &ss);
+ return copyout(&ss, SCARG(uap, buf), sizeof ss);
+
+ case SVR4_IPC_SET:
+ SCARG(&ap, cmd) = IPC_SET;
+ return sys_shmctl(p, &ap, retval);
+
+ case SVR4_IPC_RMID:
+ case SVR4_SHM_LOCK:
+ case SVR4_SHM_UNLOCK:
+ switch (SCARG(uap, cmd)) {
+ case SVR4_IPC_RMID:
+ SCARG(&ap, cmd) = IPC_RMID;
+ break;
+ case SVR4_SHM_LOCK:
+ SCARG(&ap, cmd) = SHM_LOCK;
+ break;
+ case SVR4_SHM_UNLOCK:
+ SCARG(&ap, cmd) = SHM_UNLOCK;
+ break;
+ default:
+ return EINVAL;
+ }
+ return sys_shmctl(p, &ap, retval);
+
+ default:
+ return EINVAL;
+ }
+}
+
+int
+svr4_sys_shmsys(p, v, retval)
+ struct proc *p;
+ void *v;
+ register_t *retval;
+{
+ struct svr4_sys_shmsys_args *uap = v;
+
+ DPRINTF(("svr4_shmsys(%d)\n", SCARG(uap, what)));
+
+ switch (SCARG(uap, what)) {
+ case SVR4_shmat:
+ return svr4_shmat(p, v, retval);
+ case SVR4_shmdt:
+ return svr4_shmdt(p, v, retval);
+ case SVR4_shmget:
+ return svr4_shmget(p, v, retval);
+ case SVR4_shmctl:
+ return svr4_shmctl(p, v, retval);
+ default:
+ return ENOSYS;
+ }
+}
+#endif /* SYSVSHM */
diff --git a/sys/svr4/svr4_ipc.h b/sys/svr4/svr4_ipc.h
new file mode 100644
index 0000000..798920d
--- /dev/null
+++ b/sys/svr4/svr4_ipc.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1995 Christos Zoulas. 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 Christos Zoulas.
+ * 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 _SVR4_IPC_H_
+#define _SVR4_IPC_H_
+
+/*
+ * General IPC
+ */
+#define SVR4_IPC_RMID 10
+#define SVR4_IPC_SET 11
+#define SVR4_IPC_STAT 12
+
+struct svr4_ipc_perm {
+ svr4_uid_t uid;
+ svr4_gid_t gid;
+ svr4_uid_t cuid;
+ svr4_gid_t cgid;
+ svr4_mode_t mode;
+ u_long seq;
+ svr4_key_t key;
+ long pad[4];
+};
+
+/*
+ * Message queues
+ */
+#define SVR4_msgget 0
+#define SVR4_msgctl 1
+#define SVR4_msgrcv 2
+#define SVR4_msgsnd 3
+
+struct svr4_msg {
+ struct svr4_msg *msg_next;
+ long msg_type;
+ u_short msg_ts;
+ short msg_spot;
+};
+
+struct svr4_msqid_ds {
+ struct svr4_ipc_perm msg_perm;
+ struct svr4_msg *msg_first;
+ struct svr4_msg *msg_last;
+ u_long msg_cbytes;
+ u_long msg_qnum;
+ u_long msg_qbytes;
+ svr4_pid_t msg_lspid;
+ svr4_pid_t msg_lrpid;
+ svr4_time_t msg_stime;
+ long msg_pad1;
+ svr4_time_t msg_rtime;
+ long msg_pad2;
+ svr4_time_t msg_ctime;
+ long msg_pad3;
+ short msg_cv;
+ short msg_qnum_cv;
+ long msg_pad4[3];
+};
+
+struct svr4_msgbuf {
+ long mtype; /* message type */
+ char mtext[1]; /* message text */
+};
+
+struct svr4_msginfo {
+ int msgmap;
+ int msgmax;
+ int msgmnb;
+ int msgmni;
+ int msgssz;
+ int msgtql;
+ u_short msgseg;
+};
+
+/*
+ * Shared memory
+ */
+#define SVR4_shmat 0
+#define SVR4_shmctl 1
+#define SVR4_shmdt 2
+#define SVR4_shmget 3
+
+/* shmctl() operations */
+#define SVR4_SHM_LOCK 3
+#define SVR4_SHM_UNLOCK 4
+
+struct svr4_shmid_ds {
+ struct svr4_ipc_perm shm_perm;
+ int shm_segsz;
+ void *shm_amp;
+ u_short shm_lkcnt;
+ svr4_pid_t shm_lpid;
+ svr4_pid_t shm_cpid;
+ u_long shm_nattch;
+ u_long shm_cnattch;
+ svr4_time_t shm_atime;
+ long shm_pad1;
+ svr4_time_t shm_dtime;
+ long shm_pad2;
+ svr4_time_t shm_ctime;
+ long shm_pad3;
+ long shm_pad4[4];
+};
+
+/*
+ * Semaphores
+ */
+#define SVR4_semctl 0
+#define SVR4_semget 1
+#define SVR4_semop 2
+
+/* semctl() operations */
+#define SVR4_SEM_GETNCNT 3
+#define SVR4_SEM_GETPID 4
+#define SVR4_SEM_GETVAL 5
+#define SVR4_SEM_GETALL 6
+#define SVR4_SEM_GETZCNT 7
+#define SVR4_SEM_SETVAL 8
+#define SVR4_SEM_SETALL 9
+
+struct svr4_sem {
+ u_short semval;
+ svr4_pid_t sempid;
+ u_short semncnt;
+ u_short semzcnt;
+ u_short semncnt_cv;
+ u_short semzcnt_cv;
+};
+
+struct svr4_semid_ds {
+ struct svr4_ipc_perm sem_perm;
+ struct svr4_sem *sem_base;
+ u_short sem_nsems;
+ svr4_time_t sem_otime;
+ long sem_pad1;
+ svr4_time_t sem_ctime;
+ long sem_pad2;
+ long sem_pad3[4];
+};
+
+struct svr4_sembuf {
+ u_short sem_num;
+ short sem_op;
+ short sem_flg;
+};
+
+#endif /* _SVR4_IPC_H */
diff --git a/sys/svr4/svr4_misc.c b/sys/svr4/svr4_misc.c
new file mode 100644
index 0000000..5b537c6
--- /dev/null
+++ b/sys/svr4/svr4_misc.c
@@ -0,0 +1,1629 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+/*
+ * SVR4 compatibility module.
+ *
+ * SVR4 system calls that are implemented differently in BSD are
+ * handled here.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/dirent.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+#include <sys/socket.h>
+#include <sys/vnode.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <sys/utsname.h>
+#include <sys/unistd.h>
+#include <sys/times.h>
+#include <sys/fcntl.h>
+#include <sys/sem.h>
+#include <sys/msg.h>
+#include <sys/ptrace.h>
+#include <sys/signalvar.h>
+#include <ufs/ufs/dir.h>
+#include <vm/vm_zone.h>
+
+#include <sys/sysproto.h>
+
+#include <netinet/in.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_sysconfig.h>
+#include <svr4/svr4_dirent.h>
+#include <svr4/svr4_acl.h>
+#include <svr4/svr4_time.h>
+#include <svr4/svr4_ulimit.h>
+#include <svr4/svr4_statvfs.h>
+#include <svr4/svr4_hrt.h>
+#include <svr4/svr4_mman.h>
+#include <svr4/svr4_wait.h>
+
+#include <machine/vmparam.h>
+#include <vm/vm.h>
+#include <vm/vm_param.h>
+#include <vm/vm_map.h>
+#include <vm/vm_prot.h>
+
+#if defined(NetBSD)
+# if defined(UVM)
+# include <uvm/uvm_extern.h>
+# endif
+#endif
+
+#define BSD_DIRENT(cp) ((struct dirent *)(cp))
+
+extern void *M_ZOMBIE;
+extern void *M_SUBPROC;
+
+extern int bsd_to_svr4_sig[];
+static int svr4_mknod __P((struct proc *, register_t *, char *,
+ svr4_mode_t, svr4_dev_t));
+
+static __inline clock_t timeval_to_clock_t __P((struct timeval *));
+static int svr4_setinfo __P((struct proc *, int, svr4_siginfo_t *));
+
+struct svr4_hrtcntl_args;
+static int svr4_hrtcntl __P((struct proc *, struct svr4_hrtcntl_args *,
+ register_t *));
+static void bsd_statfs_to_svr4_statvfs __P((const struct statfs *,
+ struct svr4_statvfs *));
+static void bsd_statfs_to_svr4_statvfs64 __P((const struct statfs *,
+ struct svr4_statvfs64 *));
+static struct proc *svr4_pfind __P((pid_t pid));
+
+/* BOGUS noop */
+#if defined(BOGUS)
+int
+svr4_sys_setitimer(p, uap)
+ register struct proc *p;
+ struct svr4_sys_setitimer_args *uap;
+{
+ p->p_retval[0] = 0;
+ return 0;
+}
+#endif
+
+int
+svr4_sys_wait(p, uap)
+ struct proc *p;
+ struct svr4_sys_wait_args *uap;
+{
+ struct wait_args w4;
+ int error, *retval = p->p_retval, st, sig;
+ size_t sz = sizeof(*SCARG(&w4, status));
+
+ SCARG(&w4, rusage) = NULL;
+ SCARG(&w4, options) = 0;
+
+ if (SCARG(uap, status) == NULL) {
+ caddr_t sg = stackgap_init();
+
+ SCARG(&w4, status) = stackgap_alloc(&sg, sz);
+ }
+ else
+ SCARG(&w4, status) = SCARG(uap, status);
+
+ SCARG(&w4, pid) = WAIT_ANY;
+
+ if ((error = wait4(p, &w4)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&w4, status), &st, sizeof(st))) != 0)
+ return error;
+
+ if (WIFSIGNALED(st)) {
+ sig = WTERMSIG(st);
+ if (sig >= 0 && sig < NSIG)
+ st = (st & ~0177) | bsd_to_svr4_sig[sig];
+ } else if (WIFSTOPPED(st)) {
+ sig = WSTOPSIG(st);
+ if (sig >= 0 && sig < NSIG)
+ st = (st & ~0xff00) | (bsd_to_svr4_sig[sig] << 8);
+ }
+
+ /*
+ * It looks like wait(2) on svr4/solaris/2.4 returns
+ * the status in retval[1], and the pid on retval[0].
+ */
+ retval[1] = st;
+
+ if (SCARG(uap, status))
+ if ((error = copyout(&st, SCARG(uap, status), sizeof(st))) != 0)
+ return error;
+
+ return 0;
+}
+
+int
+svr4_sys_execv(p, uap)
+ struct proc *p;
+ struct svr4_sys_execv_args *uap;
+{
+ struct execve_args ap;
+ caddr_t sg;
+
+ sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ SCARG(&ap, fname) = SCARG(uap, path);
+ SCARG(&ap, argv) = SCARG(uap, argp);
+ SCARG(&ap, envv) = NULL;
+
+ return execve(p, &ap);
+}
+
+int
+svr4_sys_execve(p, uap)
+ struct proc *p;
+ struct svr4_sys_execve_args *uap;
+{
+ struct execve_args ap;
+ caddr_t sg;
+
+ sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, uap->path);
+
+ SCARG(&ap, fname) = SCARG(uap, path);
+ SCARG(&ap, argv) = SCARG(uap, argp);
+ SCARG(&ap, envv) = SCARG(uap, envp);
+
+ return execve(p, &ap);
+}
+
+int
+svr4_sys_time(p, v)
+ struct proc *p;
+ struct svr4_sys_time_args *v;
+{
+ struct svr4_sys_time_args *uap = v;
+ int error = 0;
+ struct timeval tv;
+
+ microtime(&tv);
+ if (SCARG(uap, t))
+ error = copyout(&tv.tv_sec, SCARG(uap, t),
+ sizeof(*(SCARG(uap, t))));
+ p->p_retval[0] = (int) tv.tv_sec;
+
+ return error;
+}
+
+
+/*
+ * Read SVR4-style directory entries. We suck them into kernel space so
+ * that they can be massaged before being copied out to user code. Like
+ * SunOS, we squish out `empty' entries.
+ *
+ * This is quite ugly, but what do you expect from compatibility code?
+ */
+
+int
+svr4_sys_getdents64(p, uap)
+ struct proc *p;
+ struct svr4_sys_getdents64_args *uap;
+{
+ struct dirent *bdp;
+ struct vnode *vp;
+ caddr_t inp, buf; /* BSD-format */
+ int len, reclen; /* BSD-format */
+ caddr_t outp; /* SVR4-format */
+ int resid, svr4_reclen; /* SVR4-format */
+ struct file *fp;
+ struct uio auio;
+ struct iovec aiov;
+ struct svr4_dirent64 idb;
+ off_t off; /* true file offset */
+ int buflen, error, eofflag;
+ u_long *cookiebuf = NULL, *cookie;
+ int ncookies = 0, retval = 0, offcnt = 0;
+
+ if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
+ return (error);
+
+ if ((fp->f_flag & FREAD) == 0)
+ return (EBADF);
+
+ vp = (struct vnode *)fp->f_data;
+ if (vp->v_type != VDIR)
+ return (EINVAL);
+
+ buflen = min(MAXBSIZE, SCARG(uap, nbytes));
+ DPRINTF(("buflen = %d, spec = %d\n", buflen, SCARG(uap, nbytes)));
+ buf = malloc(buflen, M_TEMP, M_WAITOK);
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ off = fp->f_offset;
+again:
+ aiov.iov_base = buf;
+ aiov.iov_len = buflen;
+ auio.uio_iov = &aiov;
+ auio.uio_iovcnt = 1;
+ auio.uio_rw = UIO_READ;
+ auio.uio_segflg = UIO_SYSSPACE;
+ auio.uio_procp = p;
+ auio.uio_resid = buflen;
+ auio.uio_offset = off;
+ DPRINTF((">>> off = %d\n", off));
+
+ /*
+ * First we read into the malloc'ed buffer, then
+ * we massage it into user space, one record at a time.
+ */
+ error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies,
+ &cookiebuf);
+ if (error)
+ goto out;
+
+ inp = buf;
+ outp = SCARG(uap, dp);
+ resid = SCARG(uap, nbytes);
+ if ((len = buflen - auio.uio_resid) == 0)
+ goto eof;
+
+ for (cookie = cookiebuf; len > 0; len -= reclen) {
+ bdp = (struct dirent *)inp;
+ reclen = bdp->d_reclen;
+ if (reclen & 3)
+ panic("svr4_getdents64: bad reclen");
+ if (bdp->d_fileno == 0) {
+ inp += reclen; /* it is a hole; squish it out */
+#if 0
+ off = *cookie++;
+#else
+ off += reclen;
+#endif
+ DPRINTF(("+++ off = %d\n", off));
+ continue;
+ }
+ svr4_reclen = SVR4_RECLEN(&idb, (bdp->d_namlen));
+
+ if (reclen > len || resid < svr4_reclen) {
+ /* entry too big for buffer, so just stop */
+ outp++;
+ DPRINTF(("+++ off = %d\n", off));
+ break;
+ }
+#if 0
+ off = *cookie++; /* each entry points to the next */
+#else
+ off += reclen;
+#endif
+ DPRINTF(("+++ off = %d\n", off));
+
+ /*
+ * Massage in place to make a SVR4-shaped dirent (otherwise
+ * we have to worry about touching user memory outside of
+ * the copyout() call).
+ */
+ idb.d_ino = (svr4_ino64_t)bdp->d_fileno;
+ idb.d_off = (svr4_off64_t)off;
+ idb.d_reclen = (u_short)svr4_reclen;
+ strcpy(idb.d_name, bdp->d_name);
+ if ((error = copyout((caddr_t)&idb, outp, svr4_reclen)))
+ goto out;
+ DPRINTF(("d_ino = %d\nd_off = %d\nd_reclen = %d\n",
+ idb.d_ino, idb.d_off, (u_short)idb.d_reclen));
+ DPRINTF(("d_name = %s\n", idb.d_name));
+ DPRINTF(("(bdp->d_type = %d, reclen = %d, bdp->d_namelen = %d)\n", bdp->d_type, svr4_reclen, bdp->d_namlen));
+ /* advance past this real entry */
+ inp += reclen;
+ /* advance output past SVR4-shaped entry */
+ outp += svr4_reclen;
+ resid -= svr4_reclen;
+ offcnt += svr4_reclen;
+ }
+ DPRINTF(("block finished\n"));
+ /* if we squished out the whole block, try again */
+ fp->f_offset = off; /* update the vnode offset */
+ if (outp == SCARG(uap, dp))
+ goto again;
+
+eof:
+ retval = offcnt; /* SCARG(uap, nbytes) - resid;*/
+out:
+ VOP_UNLOCK(vp, 0, p);
+ if (cookiebuf)
+ free(cookiebuf, M_TEMP);
+ free(buf, M_TEMP);
+ DPRINTF(("\t\treturning %d\n", retval));
+ p->p_retval[0] = retval;
+ return error;
+}
+
+
+int
+svr4_sys_getdents(p, uap)
+ struct proc *p;
+ struct svr4_sys_getdents_args *uap;
+{
+ struct dirent *bdp;
+ struct vnode *vp;
+ caddr_t inp, buf; /* BSD-format */
+ int len, reclen; /* BSD-format */
+ caddr_t outp; /* SVR4-format */
+ int resid, svr4_reclen; /* SVR4-format */
+ struct file *fp;
+ struct uio auio;
+ struct iovec aiov;
+ struct svr4_dirent idb;
+ off_t off; /* true file offset */
+ int buflen, error, eofflag;
+ u_long *cookiebuf = NULL, *cookie;
+ int ncookies = 0, *retval = p->p_retval;
+
+ if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
+ return (error);
+
+ if ((fp->f_flag & FREAD) == 0)
+ return (EBADF);
+
+ vp = (struct vnode *)fp->f_data;
+ if (vp->v_type != VDIR)
+ return (EINVAL);
+
+ buflen = min(MAXBSIZE, SCARG(uap, nbytes));
+ buf = malloc(buflen, M_TEMP, M_WAITOK);
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ off = fp->f_offset;
+again:
+ aiov.iov_base = buf;
+ aiov.iov_len = buflen;
+ auio.uio_iov = &aiov;
+ auio.uio_iovcnt = 1;
+ auio.uio_rw = UIO_READ;
+ auio.uio_segflg = UIO_SYSSPACE;
+ auio.uio_procp = p;
+ auio.uio_resid = buflen;
+ auio.uio_offset = off;
+ /*
+ * First we read into the malloc'ed buffer, then
+ * we massage it into user space, one record at a time.
+ */
+ error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies,
+ &cookiebuf);
+ if (error)
+ goto out;
+
+ inp = buf;
+ outp = SCARG(uap, buf);
+ resid = SCARG(uap, nbytes);
+ if ((len = buflen - auio.uio_resid) == 0)
+ goto eof;
+
+ for (cookie = cookiebuf; len > 0; len -= reclen) {
+ bdp = (struct dirent *)inp;
+ reclen = bdp->d_reclen;
+ if (reclen & 3)
+ panic("svr4_getdents: bad reclen");
+ off = *cookie++; /* each entry points to the next */
+ if ((off >> 32) != 0) {
+ uprintf("svr4_getdents: dir offset too large for emulated program");
+ error = EINVAL;
+ goto out;
+ }
+ if (bdp->d_fileno == 0) {
+ inp += reclen; /* it is a hole; squish it out */
+ continue;
+ }
+ svr4_reclen = SVR4_RECLEN(&idb, bdp->d_namlen);
+ if (reclen > len || resid < svr4_reclen) {
+ /* entry too big for buffer, so just stop */
+ outp++;
+ break;
+ }
+ /*
+ * Massage in place to make a SVR4-shaped dirent (otherwise
+ * we have to worry about touching user memory outside of
+ * the copyout() call).
+ */
+ idb.d_ino = (svr4_ino_t)bdp->d_fileno;
+ idb.d_off = (svr4_off_t)off;
+ idb.d_reclen = (u_short)svr4_reclen;
+ strcpy(idb.d_name, bdp->d_name);
+ if ((error = copyout((caddr_t)&idb, outp, svr4_reclen)))
+ goto out;
+ /* advance past this real entry */
+ inp += reclen;
+ /* advance output past SVR4-shaped entry */
+ outp += svr4_reclen;
+ resid -= svr4_reclen;
+ }
+
+ /* if we squished out the whole block, try again */
+ if (outp == SCARG(uap, buf))
+ goto again;
+ fp->f_offset = off; /* update the vnode offset */
+
+eof:
+ *retval = SCARG(uap, nbytes) - resid;
+out:
+ VOP_UNLOCK(vp, 0, p);
+ if (cookiebuf)
+ free(cookiebuf, M_TEMP);
+ free(buf, M_TEMP);
+ return error;
+}
+
+
+int
+svr4_sys_mmap(p, uap)
+ struct proc *p;
+ struct svr4_sys_mmap_args *uap;
+{
+ struct mmap_args mm;
+ int *retval;
+
+ retval = p->p_retval;
+#define _MAP_NEW 0x80000000
+ /*
+ * Verify the arguments.
+ */
+ if (SCARG(uap, prot) & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+ return EINVAL; /* XXX still needed? */
+
+ if (SCARG(uap, len) == 0)
+ return EINVAL;
+
+ SCARG(&mm, prot) = SCARG(uap, prot);
+ SCARG(&mm, len) = SCARG(uap, len);
+ SCARG(&mm, flags) = SCARG(uap, flags) & ~_MAP_NEW;
+ SCARG(&mm, fd) = SCARG(uap, fd);
+ SCARG(&mm, addr) = SCARG(uap, addr);
+ SCARG(&mm, pos) = SCARG(uap, pos);
+
+ return mmap(p, &mm);
+}
+
+int
+svr4_sys_mmap64(p, uap)
+ struct proc *p;
+ struct svr4_sys_mmap64_args *uap;
+{
+ struct mmap_args mm;
+ void *rp;
+
+#define _MAP_NEW 0x80000000
+ /*
+ * Verify the arguments.
+ */
+ if (SCARG(uap, prot) & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+ return EINVAL; /* XXX still needed? */
+
+ if (SCARG(uap, len) == 0)
+ return EINVAL;
+
+ SCARG(&mm, prot) = SCARG(uap, prot);
+ SCARG(&mm, len) = SCARG(uap, len);
+ SCARG(&mm, flags) = SCARG(uap, flags) & ~_MAP_NEW;
+ SCARG(&mm, fd) = SCARG(uap, fd);
+ SCARG(&mm, addr) = SCARG(uap, addr);
+ SCARG(&mm, pos) = SCARG(uap, pos);
+
+ rp = (void *) round_page((vm_offset_t)(p->p_vmspace->vm_daddr + MAXDSIZ));
+ if ((SCARG(&mm, flags) & MAP_FIXED) == 0 &&
+ SCARG(&mm, addr) != 0 && (void *)SCARG(&mm, addr) < rp)
+ SCARG(&mm, addr) = rp;
+
+ return mmap(p, &mm);
+}
+
+
+int
+svr4_sys_fchroot(p, uap)
+ struct proc *p;
+ struct svr4_sys_fchroot_args *uap;
+{
+ struct filedesc *fdp = p->p_fd;
+ struct vnode *vp;
+ struct file *fp;
+ int error;
+
+ if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
+ return error;
+ if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0)
+ return error;
+ vp = (struct vnode *) fp->f_data;
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ if (vp->v_type != VDIR)
+ error = ENOTDIR;
+ else
+ error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
+ VOP_UNLOCK(vp, 0, p);
+ if (error)
+ return error;
+ VREF(vp);
+ if (fdp->fd_rdir != NULL)
+ vrele(fdp->fd_rdir);
+ fdp->fd_rdir = vp;
+ return 0;
+}
+
+
+static int
+svr4_mknod(p, retval, path, mode, dev)
+ struct proc *p;
+ register_t *retval;
+ char *path;
+ svr4_mode_t mode;
+ svr4_dev_t dev;
+{
+ caddr_t sg = stackgap_init();
+
+ CHECKALTEXIST(p, &sg, path);
+
+ if (S_ISFIFO(mode)) {
+ struct mkfifo_args ap;
+ SCARG(&ap, path) = path;
+ SCARG(&ap, mode) = mode;
+ return mkfifo(p, &ap);
+ } else {
+ struct mknod_args ap;
+ SCARG(&ap, path) = path;
+ SCARG(&ap, mode) = mode;
+ SCARG(&ap, dev) = dev;
+ return mknod(p, &ap);
+ }
+}
+
+
+int
+svr4_sys_mknod(p, uap)
+ register struct proc *p;
+ struct svr4_sys_mknod_args *uap;
+{
+ int *retval = p->p_retval;
+ return svr4_mknod(p, retval,
+ SCARG(uap, path), SCARG(uap, mode),
+ svr4_to_bsd_odev_t(SCARG(uap, dev)));
+}
+
+
+int
+svr4_sys_xmknod(p, uap)
+ struct proc *p;
+ struct svr4_sys_xmknod_args *uap;
+{
+ int *retval = p->p_retval;
+ return svr4_mknod(p, retval,
+ SCARG(uap, path), SCARG(uap, mode),
+ svr4_to_bsd_dev_t(SCARG(uap, dev)));
+}
+
+
+int
+svr4_sys_vhangup(p, uap)
+ struct proc *p;
+ struct svr4_sys_vhangup_args *uap;
+{
+ return 0;
+}
+
+
+int
+svr4_sys_sysconfig(p, uap)
+ struct proc *p;
+ struct svr4_sys_sysconfig_args *uap;
+{
+ int *retval;
+
+ retval = &(p->p_retval[0]);
+
+ switch (SCARG(uap, name)) {
+ case SVR4_CONFIG_UNUSED:
+ *retval = 0;
+ break;
+ case SVR4_CONFIG_NGROUPS:
+ *retval = NGROUPS_MAX;
+ break;
+ case SVR4_CONFIG_CHILD_MAX:
+ *retval = maxproc;
+ break;
+ case SVR4_CONFIG_OPEN_FILES:
+ *retval = maxfiles;
+ break;
+ case SVR4_CONFIG_POSIX_VER:
+ *retval = 198808;
+ break;
+ case SVR4_CONFIG_PAGESIZE:
+ *retval = PAGE_SIZE;
+ break;
+ case SVR4_CONFIG_CLK_TCK:
+ *retval = 60; /* should this be `hz', ie. 100? */
+ break;
+ case SVR4_CONFIG_XOPEN_VER:
+ *retval = 2; /* XXX: What should that be? */
+ break;
+ case SVR4_CONFIG_PROF_TCK:
+ *retval = 60; /* XXX: What should that be? */
+ break;
+ case SVR4_CONFIG_NPROC_CONF:
+ *retval = 1; /* Only one processor for now */
+ break;
+ case SVR4_CONFIG_NPROC_ONLN:
+ *retval = 1; /* And it better be online */
+ break;
+ case SVR4_CONFIG_AIO_LISTIO_MAX:
+ case SVR4_CONFIG_AIO_MAX:
+ case SVR4_CONFIG_AIO_PRIO_DELTA_MAX:
+ *retval = 0; /* No aio support */
+ break;
+ case SVR4_CONFIG_DELAYTIMER_MAX:
+ *retval = 0; /* No delaytimer support */
+ break;
+ case SVR4_CONFIG_MQ_OPEN_MAX:
+ *retval = msginfo.msgmni;
+ break;
+ case SVR4_CONFIG_MQ_PRIO_MAX:
+ *retval = 0; /* XXX: Don't know */
+ break;
+ case SVR4_CONFIG_RTSIG_MAX:
+ *retval = 0;
+ break;
+ case SVR4_CONFIG_SEM_NSEMS_MAX:
+ *retval = seminfo.semmni;
+ break;
+ case SVR4_CONFIG_SEM_VALUE_MAX:
+ *retval = seminfo.semvmx;
+ break;
+ case SVR4_CONFIG_SIGQUEUE_MAX:
+ *retval = 0; /* XXX: Don't know */
+ break;
+ case SVR4_CONFIG_SIGRT_MIN:
+ case SVR4_CONFIG_SIGRT_MAX:
+ *retval = 0; /* No real time signals */
+ break;
+ case SVR4_CONFIG_TIMER_MAX:
+ *retval = 3; /* XXX: real, virtual, profiling */
+ break;
+#if defined(NOTYET)
+ case SVR4_CONFIG_PHYS_PAGES:
+#if defined(UVM)
+ *retval = uvmexp.free; /* XXX: free instead of total */
+#else
+ *retval = cnt.v_free_count; /* XXX: free instead of total */
+#endif
+ break;
+ case SVR4_CONFIG_AVPHYS_PAGES:
+#if defined(UVM)
+ *retval = uvmexp.active; /* XXX: active instead of avg */
+#else
+ *retval = cnt.v_active_count; /* XXX: active instead of avg */
+#endif
+ break;
+#endif /* NOTYET */
+
+ default:
+ return EINVAL;
+ }
+ return 0;
+}
+
+extern int swap_pager_full;
+
+/* ARGSUSED */
+int
+svr4_sys_break(p, uap)
+ struct proc *p;
+ struct svr4_sys_break_args *uap;
+{
+ struct vmspace *vm = p->p_vmspace;
+ vm_offset_t new, old, base, ns;
+ int rv;
+
+ base = round_page((vm_offset_t) vm->vm_daddr);
+ ns = (vm_offset_t)SCARG(uap, nsize);
+ new = round_page(ns);
+ if (new > base) {
+ if ((new - base) > (unsigned) p->p_rlimit[RLIMIT_DATA].rlim_cur) {
+ return ENOMEM;
+ }
+ if (new >= VM_MAXUSER_ADDRESS) {
+ return (ENOMEM);
+ }
+ } else if (new < base) {
+ /*
+ * This is simply an invalid value. If someone wants to
+ * do fancy address space manipulations, mmap and munmap
+ * can do most of what the user would want.
+ */
+ return EINVAL;
+ }
+
+ old = base + ctob(vm->vm_dsize);
+
+ if (new > old) {
+ vm_size_t diff;
+ if (swap_pager_full) {
+ return (ENOMEM);
+ }
+ diff = new - old;
+ rv = vm_map_find(&vm->vm_map, NULL, 0, &old, diff, FALSE,
+ VM_PROT_ALL, VM_PROT_ALL, 0);
+ if (rv != KERN_SUCCESS) {
+ return (ENOMEM);
+ }
+ vm->vm_dsize += btoc(diff);
+ } else if (new < old) {
+ rv = vm_map_remove(&vm->vm_map, new, old);
+ if (rv != KERN_SUCCESS) {
+ return (ENOMEM);
+ }
+ vm->vm_dsize -= btoc(old - new);
+ }
+
+ return (0);
+}
+
+static __inline clock_t
+timeval_to_clock_t(tv)
+ struct timeval *tv;
+{
+ return tv->tv_sec * hz + tv->tv_usec / (1000000 / hz);
+}
+
+
+int
+svr4_sys_times(p, uap)
+ struct proc *p;
+ struct svr4_sys_times_args *uap;
+{
+ int error, *retval = p->p_retval;
+ struct tms tms;
+ struct timeval t;
+ struct rusage *ru;
+ struct rusage r;
+ struct getrusage_args ga;
+
+ caddr_t sg = stackgap_init();
+ ru = stackgap_alloc(&sg, sizeof(struct rusage));
+
+ SCARG(&ga, who) = RUSAGE_SELF;
+ SCARG(&ga, rusage) = ru;
+
+ error = getrusage(p, &ga);
+ if (error)
+ return error;
+
+ if ((error = copyin(ru, &r, sizeof r)) != 0)
+ return error;
+
+ tms.tms_utime = timeval_to_clock_t(&r.ru_utime);
+ tms.tms_stime = timeval_to_clock_t(&r.ru_stime);
+
+ SCARG(&ga, who) = RUSAGE_CHILDREN;
+ error = getrusage(p, &ga);
+ if (error)
+ return error;
+
+ if ((error = copyin(ru, &r, sizeof r)) != 0)
+ return error;
+
+ tms.tms_cutime = timeval_to_clock_t(&r.ru_utime);
+ tms.tms_cstime = timeval_to_clock_t(&r.ru_stime);
+
+ microtime(&t);
+ *retval = timeval_to_clock_t(&t);
+
+ return copyout(&tms, SCARG(uap, tp), sizeof(tms));
+}
+
+
+int
+svr4_sys_ulimit(p, uap)
+ struct proc *p;
+ struct svr4_sys_ulimit_args *uap;
+{
+ int *retval = p->p_retval;
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_GFILLIM:
+ *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur / 512;
+ if (*retval == -1)
+ *retval = 0x7fffffff;
+ return 0;
+
+ case SVR4_SFILLIM:
+ {
+ int error;
+ struct __setrlimit_args srl;
+ struct rlimit krl;
+ caddr_t sg = stackgap_init();
+ struct rlimit *url = (struct rlimit *)
+ stackgap_alloc(&sg, sizeof *url);
+
+ krl.rlim_cur = SCARG(uap, newlimit) * 512;
+ krl.rlim_max = p->p_rlimit[RLIMIT_FSIZE].rlim_max;
+
+ error = copyout(&krl, url, sizeof(*url));
+ if (error)
+ return error;
+
+ SCARG(&srl, which) = RLIMIT_FSIZE;
+ SCARG(&srl, rlp) = (struct orlimit *)url;
+
+ error = setrlimit(p, &srl);
+ if (error)
+ return error;
+
+ *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
+ if (*retval == -1)
+ *retval = 0x7fffffff;
+ return 0;
+ }
+
+ case SVR4_GMEMLIM:
+ {
+ struct vmspace *vm = p->p_vmspace;
+ register_t r = p->p_rlimit[RLIMIT_DATA].rlim_cur;
+
+ if (r == -1)
+ r = 0x7fffffff;
+ r += (long) vm->vm_daddr;
+ if (r < 0)
+ r = 0x7fffffff;
+ *retval = r;
+ return 0;
+ }
+
+ case SVR4_GDESLIM:
+ *retval = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
+ if (*retval == -1)
+ *retval = 0x7fffffff;
+ return 0;
+
+ default:
+ return EINVAL;
+ }
+}
+
+static struct proc *
+svr4_pfind(pid)
+ pid_t pid;
+{
+ struct proc *p;
+
+ /* look in the live processes */
+ if ((p = pfind(pid)) != NULL)
+ return p;
+
+ /* look in the zombies */
+ for (p = zombproc.lh_first; p != 0; p = p->p_list.le_next)
+ if (p->p_pid == pid)
+ return p;
+
+ return NULL;
+}
+
+
+int
+svr4_sys_pgrpsys(p, uap)
+ struct proc *p;
+ struct svr4_sys_pgrpsys_args *uap;
+{
+ int *retval = p->p_retval;
+
+ switch (SCARG(uap, cmd)) {
+ case 1: /* setpgrp() */
+ /*
+ * SVR4 setpgrp() (which takes no arguments) has the
+ * semantics that the session ID is also created anew, so
+ * in almost every sense, setpgrp() is identical to
+ * setsid() for SVR4. (Under BSD, the difference is that
+ * a setpgid(0,0) will not create a new session.)
+ */
+ setsid(p, NULL);
+ /*FALLTHROUGH*/
+
+ case 0: /* getpgrp() */
+ *retval = p->p_pgrp->pg_id;
+ return 0;
+
+ case 2: /* getsid(pid) */
+ if (SCARG(uap, pid) != 0 &&
+ (p = svr4_pfind(SCARG(uap, pid))) == NULL)
+ return ESRCH;
+ /*
+ * This has already been initialized to the pid of
+ * the session leader.
+ */
+ *retval = (register_t) p->p_session->s_leader->p_pid;
+ return 0;
+
+ case 3: /* setsid() */
+ return setsid(p, NULL);
+
+ case 4: /* getpgid(pid) */
+
+ if (SCARG(uap, pid) != 0 &&
+ (p = svr4_pfind(SCARG(uap, pid))) == NULL)
+ return ESRCH;
+
+ *retval = (int) p->p_pgrp->pg_id;
+ return 0;
+
+ case 5: /* setpgid(pid, pgid); */
+ {
+ struct setpgid_args sa;
+
+ SCARG(&sa, pid) = SCARG(uap, pid);
+ SCARG(&sa, pgid) = SCARG(uap, pgid);
+ return setpgid(p, &sa);
+ }
+
+ default:
+ return EINVAL;
+ }
+}
+
+#define syscallarg(x) union { x datum; register_t pad; }
+
+struct svr4_hrtcntl_args {
+ int cmd;
+ int fun;
+ int clk;
+ svr4_hrt_interval_t * iv;
+ svr4_hrt_time_t * ti;
+};
+
+
+static int
+svr4_hrtcntl(p, uap, retval)
+ struct proc *p;
+ struct svr4_hrtcntl_args *uap;
+ register_t *retval;
+{
+ switch (SCARG(uap, fun)) {
+ case SVR4_HRT_CNTL_RES:
+ DPRINTF(("htrcntl(RES)\n"));
+ *retval = SVR4_HRT_USEC;
+ return 0;
+
+ case SVR4_HRT_CNTL_TOFD:
+ DPRINTF(("htrcntl(TOFD)\n"));
+ {
+ struct timeval tv;
+ svr4_hrt_time_t t;
+ if (SCARG(uap, clk) != SVR4_HRT_CLK_STD) {
+ DPRINTF(("clk == %d\n", SCARG(uap, clk)));
+ return EINVAL;
+ }
+ if (SCARG(uap, ti) == NULL) {
+ DPRINTF(("ti NULL\n"));
+ return EINVAL;
+ }
+ microtime(&tv);
+ t.h_sec = tv.tv_sec;
+ t.h_rem = tv.tv_usec;
+ t.h_res = SVR4_HRT_USEC;
+ return copyout(&t, SCARG(uap, ti), sizeof(t));
+ }
+
+ case SVR4_HRT_CNTL_START:
+ DPRINTF(("htrcntl(START)\n"));
+ return ENOSYS;
+
+ case SVR4_HRT_CNTL_GET:
+ DPRINTF(("htrcntl(GET)\n"));
+ return ENOSYS;
+ default:
+ DPRINTF(("Bad htrcntl command %d\n", SCARG(uap, fun)));
+ return ENOSYS;
+ }
+}
+
+
+int
+svr4_sys_hrtsys(p, uap)
+ struct proc *p;
+ struct svr4_sys_hrtsys_args *uap;
+{
+ int *retval = p->p_retval;
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_HRT_CNTL:
+ return svr4_hrtcntl(p, (struct svr4_hrtcntl_args *) uap,
+ retval);
+
+ case SVR4_HRT_ALRM:
+ DPRINTF(("hrtalarm\n"));
+ return ENOSYS;
+
+ case SVR4_HRT_SLP:
+ DPRINTF(("hrtsleep\n"));
+ return ENOSYS;
+
+ case SVR4_HRT_CAN:
+ DPRINTF(("hrtcancel\n"));
+ return ENOSYS;
+
+ default:
+ DPRINTF(("Bad hrtsys command %d\n", SCARG(uap, cmd)));
+ return EINVAL;
+ }
+}
+
+
+static int
+svr4_setinfo(p, st, s)
+ struct proc *p;
+ int st;
+ svr4_siginfo_t *s;
+{
+ svr4_siginfo_t i;
+ int sig;
+
+ memset(&i, 0, sizeof(i));
+
+ i.si_signo = SVR4_SIGCHLD;
+ i.si_errno = 0; /* XXX? */
+
+ if (p) {
+ i.si_pid = p->p_pid;
+ if (p->p_stat == SZOMB) {
+ i.si_stime = p->p_ru->ru_stime.tv_sec;
+ i.si_utime = p->p_ru->ru_utime.tv_sec;
+ }
+ else {
+ i.si_stime = p->p_stats->p_ru.ru_stime.tv_sec;
+ i.si_utime = p->p_stats->p_ru.ru_utime.tv_sec;
+ }
+ }
+
+ if (WIFEXITED(st)) {
+ i.si_status = WEXITSTATUS(st);
+ i.si_code = SVR4_CLD_EXITED;
+ } else if (WIFSTOPPED(st)) {
+ sig = WSTOPSIG(st);
+ if (sig >= 0 && sig < NSIG)
+ i.si_status = bsd_to_svr4_sig[sig];
+
+ if (i.si_status == SVR4_SIGCONT)
+ i.si_code = SVR4_CLD_CONTINUED;
+ else
+ i.si_code = SVR4_CLD_STOPPED;
+ } else {
+ sig = WTERMSIG(st);
+ if (sig >= 0 && sig < NSIG)
+ i.si_status = bsd_to_svr4_sig[sig];
+
+ if (WCOREDUMP(st))
+ i.si_code = SVR4_CLD_DUMPED;
+ else
+ i.si_code = SVR4_CLD_KILLED;
+ }
+
+ DPRINTF(("siginfo [pid %ld signo %d code %d errno %d status %d]\n",
+ i.si_pid, i.si_signo, i.si_code, i.si_errno, i.si_status));
+
+ return copyout(&i, s, sizeof(i));
+}
+
+
+int
+svr4_sys_waitsys(p, uap)
+ struct proc *p;
+ struct svr4_sys_waitsys_args *uap;
+{
+ int nfound;
+ int error, *retval = p->p_retval;
+ struct proc *q, *t;
+
+
+ switch (SCARG(uap, grp)) {
+ case SVR4_P_PID:
+ break;
+
+ case SVR4_P_PGID:
+ SCARG(uap, id) = -p->p_pgid;
+ break;
+
+ case SVR4_P_ALL:
+ SCARG(uap, id) = WAIT_ANY;
+ break;
+
+ default:
+ return EINVAL;
+ }
+
+ DPRINTF(("waitsys(%d, %d, %p, %x)\n",
+ SCARG(uap, grp), SCARG(uap, id),
+ SCARG(uap, info), SCARG(uap, options)));
+
+loop:
+ nfound = 0;
+ for (q = p->p_children.lh_first; q != 0; q = q->p_sibling.le_next) {
+ if (SCARG(uap, id) != WAIT_ANY &&
+ q->p_pid != SCARG(uap, id) &&
+ q->p_pgid != -SCARG(uap, id)) {
+ DPRINTF(("pid %d pgid %d != %d\n", q->p_pid,
+ q->p_pgid, SCARG(uap, id)));
+ continue;
+ }
+ nfound++;
+ if (q->p_stat == SZOMB &&
+ ((SCARG(uap, options) & (SVR4_WEXITED|SVR4_WTRAPPED)))) {
+ *retval = 0;
+ DPRINTF(("found %d\n", q->p_pid));
+ if ((error = svr4_setinfo(q, q->p_xstat,
+ SCARG(uap, info))) != 0)
+ return error;
+
+
+ if ((SCARG(uap, options) & SVR4_WNOWAIT)) {
+ DPRINTF(("Don't wait\n"));
+ return 0;
+ }
+
+ /*
+ * If we got the child via ptrace(2) or procfs, and
+ * the parent is different (meaning the process was
+ * attached, rather than run as a child), then we need
+ * to give it back to the ol dparent, and send the
+ * parent a SIGCHLD. The rest of the cleanup will be
+ * done when the old parent waits on the child.
+ */
+ if ((q->p_flag & P_TRACED) &&
+ q->p_oppid != q->p_pptr->p_pid) {
+ t = pfind(q->p_oppid);
+ proc_reparent(q, t ? t : initproc);
+ q->p_oppid = 0;
+ q->p_flag &= ~(P_TRACED | P_WAITED);
+ wakeup((caddr_t)q->p_pptr);
+ return 0;
+ }
+ q->p_xstat = 0;
+ ruadd(&p->p_stats->p_cru, q->p_ru);
+
+ FREE(q->p_ru, M_ZOMBIE);
+
+ /*
+ * Finally finished with old proc entry.
+ * Unlink it from its process group and free it.
+ */
+ leavepgrp(q);
+
+ LIST_REMOVE(q, p_list); /* off zombproc */
+
+ LIST_REMOVE(q, p_sibling);
+
+ /*
+ * Decrement the count of procs running with this uid.
+ */
+ (void)chgproccnt(q->p_cred->p_ruid, -1);
+
+ /*
+ * Free up credentials.
+ */
+ if (--q->p_cred->p_refcnt == 0) {
+ crfree(q->p_cred->pc_ucred);
+ FREE(q->p_cred, M_SUBPROC);
+ }
+
+ /*
+ * Release reference to text vnode
+ */
+ if (q->p_textvp)
+ vrele(q->p_textvp);
+
+ /*
+ * Give machine-dependent layer a chance
+ * to free anything that cpu_exit couldn't
+ * release while still running in process context.
+ */
+ cpu_wait(q);
+#if defined(__NetBSD__)
+ pool_put(&proc_pool, q);
+#endif
+ nprocs--;
+ return 0;
+ }
+ if (q->p_stat == SSTOP && (q->p_flag & P_WAITED) == 0 &&
+ (q->p_flag & P_TRACED ||
+ (SCARG(uap, options) & (SVR4_WSTOPPED|SVR4_WCONTINUED)))) {
+ DPRINTF(("jobcontrol %d\n", q->p_pid));
+ if (((SCARG(uap, options) & SVR4_WNOWAIT)) == 0)
+ q->p_flag |= P_WAITED;
+ *retval = 0;
+ return svr4_setinfo(q, W_STOPCODE(q->p_xstat),
+ SCARG(uap, info));
+ }
+ }
+
+ if (nfound == 0)
+ return ECHILD;
+
+ if (SCARG(uap, options) & SVR4_WNOHANG) {
+ *retval = 0;
+ if ((error = svr4_setinfo(NULL, 0, SCARG(uap, info))) != 0)
+ return error;
+ return 0;
+ }
+
+ if ((error = tsleep((caddr_t)p, PWAIT | PCATCH, "svr4_wait", 0)) != 0)
+ return error;
+ goto loop;
+}
+
+
+static void
+bsd_statfs_to_svr4_statvfs(bfs, sfs)
+ const struct statfs *bfs;
+ struct svr4_statvfs *sfs;
+{
+ sfs->f_bsize = bfs->f_iosize; /* XXX */
+ sfs->f_frsize = bfs->f_bsize;
+ sfs->f_blocks = bfs->f_blocks;
+ sfs->f_bfree = bfs->f_bfree;
+ sfs->f_bavail = bfs->f_bavail;
+ sfs->f_files = bfs->f_files;
+ sfs->f_ffree = bfs->f_ffree;
+ sfs->f_favail = bfs->f_ffree;
+ sfs->f_fsid = bfs->f_fsid.val[0];
+ memcpy(sfs->f_basetype, bfs->f_fstypename, sizeof(sfs->f_basetype));
+ sfs->f_flag = 0;
+ if (bfs->f_flags & MNT_RDONLY)
+ sfs->f_flag |= SVR4_ST_RDONLY;
+ if (bfs->f_flags & MNT_NOSUID)
+ sfs->f_flag |= SVR4_ST_NOSUID;
+ sfs->f_namemax = MAXNAMLEN;
+ memcpy(sfs->f_fstr, bfs->f_fstypename, sizeof(sfs->f_fstr)); /* XXX */
+ memset(sfs->f_filler, 0, sizeof(sfs->f_filler));
+}
+
+
+static void
+bsd_statfs_to_svr4_statvfs64(bfs, sfs)
+ const struct statfs *bfs;
+ struct svr4_statvfs64 *sfs;
+{
+ sfs->f_bsize = bfs->f_iosize; /* XXX */
+ sfs->f_frsize = bfs->f_bsize;
+ sfs->f_blocks = bfs->f_blocks;
+ sfs->f_bfree = bfs->f_bfree;
+ sfs->f_bavail = bfs->f_bavail;
+ sfs->f_files = bfs->f_files;
+ sfs->f_ffree = bfs->f_ffree;
+ sfs->f_favail = bfs->f_ffree;
+ sfs->f_fsid = bfs->f_fsid.val[0];
+ memcpy(sfs->f_basetype, bfs->f_fstypename, sizeof(sfs->f_basetype));
+ sfs->f_flag = 0;
+ if (bfs->f_flags & MNT_RDONLY)
+ sfs->f_flag |= SVR4_ST_RDONLY;
+ if (bfs->f_flags & MNT_NOSUID)
+ sfs->f_flag |= SVR4_ST_NOSUID;
+ sfs->f_namemax = MAXNAMLEN;
+ memcpy(sfs->f_fstr, bfs->f_fstypename, sizeof(sfs->f_fstr)); /* XXX */
+ memset(sfs->f_filler, 0, sizeof(sfs->f_filler));
+}
+
+
+int
+svr4_sys_statvfs(p, uap)
+ struct proc *p;
+ struct svr4_sys_statvfs_args *uap;
+{
+ struct statfs_args fs_args;
+ caddr_t sg = stackgap_init();
+ struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
+ struct statfs bfs;
+ struct svr4_statvfs sfs;
+ int error;
+
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+ SCARG(&fs_args, path) = SCARG(uap, path);
+ SCARG(&fs_args, buf) = fs;
+
+ if ((error = statfs(p, &fs_args)) != 0)
+ return error;
+
+ if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
+ return error;
+
+ bsd_statfs_to_svr4_statvfs(&bfs, &sfs);
+
+ return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+}
+
+
+int
+svr4_sys_fstatvfs(p, uap)
+ struct proc *p;
+ struct svr4_sys_fstatvfs_args *uap;
+{
+ struct fstatfs_args fs_args;
+ caddr_t sg = stackgap_init();
+ struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
+ struct statfs bfs;
+ struct svr4_statvfs sfs;
+ int error;
+
+ SCARG(&fs_args, fd) = SCARG(uap, fd);
+ SCARG(&fs_args, buf) = fs;
+
+ if ((error = fstatfs(p, &fs_args)) != 0)
+ return error;
+
+ if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
+ return error;
+
+ bsd_statfs_to_svr4_statvfs(&bfs, &sfs);
+
+ return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+}
+
+
+int
+svr4_sys_statvfs64(p, uap)
+ struct proc *p;
+ struct svr4_sys_statvfs64_args *uap;
+{
+ struct statfs_args fs_args;
+ caddr_t sg = stackgap_init();
+ struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
+ struct statfs bfs;
+ struct svr4_statvfs64 sfs;
+ int error;
+
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+ SCARG(&fs_args, path) = SCARG(uap, path);
+ SCARG(&fs_args, buf) = fs;
+
+ if ((error = statfs(p, &fs_args)) != 0)
+ return error;
+
+ if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
+ return error;
+
+ bsd_statfs_to_svr4_statvfs64(&bfs, &sfs);
+
+ return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+}
+
+
+int
+svr4_sys_fstatvfs64(p, uap)
+ struct proc *p;
+ struct svr4_sys_fstatvfs64_args *uap;
+{
+ struct fstatfs_args fs_args;
+ caddr_t sg = stackgap_init();
+ struct statfs *fs = stackgap_alloc(&sg, sizeof(struct statfs));
+ struct statfs bfs;
+ struct svr4_statvfs64 sfs;
+ int error;
+
+ SCARG(&fs_args, fd) = SCARG(uap, fd);
+ SCARG(&fs_args, buf) = fs;
+
+ if ((error = fstatfs(p, &fs_args)) != 0)
+ return error;
+
+ if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0)
+ return error;
+
+ bsd_statfs_to_svr4_statvfs64(&bfs, &sfs);
+
+ return copyout(&sfs, SCARG(uap, fs), sizeof(sfs));
+}
+
+int
+svr4_sys_alarm(p, uap)
+ struct proc *p;
+ struct svr4_sys_alarm_args *uap;
+{
+ int error;
+ struct itimerval *itp, *oitp;
+ struct setitimer_args sa;
+ caddr_t sg = stackgap_init();
+
+ itp = stackgap_alloc(&sg, sizeof(*itp));
+ oitp = stackgap_alloc(&sg, sizeof(*oitp));
+ timevalclear(&itp->it_interval);
+ itp->it_value.tv_sec = SCARG(uap, sec);
+ itp->it_value.tv_usec = 0;
+
+ SCARG(&sa, which) = ITIMER_REAL;
+ SCARG(&sa, itv) = itp;
+ SCARG(&sa, oitv) = oitp;
+ error = setitimer(p, &sa);
+ if (error)
+ return error;
+ if (oitp->it_value.tv_usec)
+ oitp->it_value.tv_sec++;
+ p->p_retval[0] = oitp->it_value.tv_sec;
+ return 0;
+
+}
+
+int
+svr4_sys_gettimeofday(p, uap)
+ struct proc *p;
+ struct svr4_sys_gettimeofday_args *uap;
+{
+ if (SCARG(uap, tp)) {
+ struct timeval atv;
+
+ microtime(&atv);
+ return copyout(&atv, SCARG(uap, tp), sizeof (atv));
+ }
+
+ return 0;
+}
+
+int
+svr4_sys_facl(p, uap)
+ struct proc *p;
+ struct svr4_sys_facl_args *uap;
+{
+ int *retval;
+
+ retval = p->p_retval;
+ *retval = 0;
+
+ switch (SCARG(uap, cmd)) {
+ case SVR4_SYS_SETACL:
+ /* We don't support acls on any filesystem */
+ return ENOSYS;
+
+ case SVR4_SYS_GETACL:
+ return copyout(retval, &SCARG(uap, num),
+ sizeof(SCARG(uap, num)));
+
+ case SVR4_SYS_GETACLCNT:
+ return 0;
+
+ default:
+ return EINVAL;
+ }
+}
+
+
+int
+svr4_sys_acl(p, uap)
+ struct proc *p;
+ struct svr4_sys_acl_args *uap;
+{
+ /* XXX: for now the same */
+ return svr4_sys_facl(p, (struct svr4_sys_facl_args *)uap);
+}
+
+int
+svr4_sys_auditsys(p, uap)
+ struct proc *p;
+ struct svr4_sys_auditsys_args *uap;
+{
+ /*
+ * XXX: Big brother is *not* watching.
+ */
+ return 0;
+}
+
+int
+svr4_sys_memcntl(p, uap)
+ struct proc *p;
+ struct svr4_sys_memcntl_args *uap;
+{
+ switch (SCARG(uap, cmd)) {
+ case SVR4_MC_SYNC:
+ {
+ struct msync_args msa;
+
+ SCARG(&msa, addr) = SCARG(uap, addr);
+ SCARG(&msa, len) = SCARG(uap, len);
+ SCARG(&msa, flags) = (int)SCARG(uap, arg);
+
+ return msync(p, &msa);
+ }
+ case SVR4_MC_ADVISE:
+ {
+ struct madvise_args maa;
+
+ SCARG(&maa, addr) = SCARG(uap, addr);
+ SCARG(&maa, len) = SCARG(uap, len);
+ SCARG(&maa, behav) = (int)SCARG(uap, arg);
+
+ return madvise(p, &maa);
+ }
+ case SVR4_MC_LOCK:
+ case SVR4_MC_UNLOCK:
+ case SVR4_MC_LOCKAS:
+ case SVR4_MC_UNLOCKAS:
+ return EOPNOTSUPP;
+ default:
+ return ENOSYS;
+ }
+}
+
+
+int
+svr4_sys_nice(p, uap)
+ struct proc *p;
+ struct svr4_sys_nice_args *uap;
+{
+ struct setpriority_args ap;
+ int error;
+
+ SCARG(&ap, which) = PRIO_PROCESS;
+ SCARG(&ap, who) = 0;
+ SCARG(&ap, prio) = SCARG(uap, prio);
+
+ if ((error = setpriority(p, &ap)) != 0)
+ return error;
+
+ /* the cast is stupid, but the structures are the same */
+ if ((error = getpriority(p, (struct getpriority_args *)&ap)) != 0)
+ return error;
+
+ return 0;
+}
+
+int
+svr4_sys_resolvepath(p, uap)
+ struct proc *p;
+ struct svr4_sys_resolvepath_args *uap;
+{
+ struct nameidata nd;
+ int error, *retval = p->p_retval;
+
+ NDINIT(&nd, LOOKUP, NOFOLLOW | SAVENAME, UIO_USERSPACE,
+ SCARG(uap, path), p);
+
+ if ((error = namei(&nd)) != 0)
+ return error;
+
+ if ((error = copyout(nd.ni_cnd.cn_pnbuf, SCARG(uap, buf),
+ SCARG(uap, bufsiz))) != 0)
+ goto bad;
+
+ *retval = strlen(nd.ni_cnd.cn_pnbuf) < SCARG(uap, bufsiz) ?
+ strlen(nd.ni_cnd.cn_pnbuf) + 1 : SCARG(uap, bufsiz);
+bad:
+ vput(nd.ni_vp);
+ zfree(namei_zone, nd.ni_cnd.cn_pnbuf);
+ return error;
+}
diff --git a/sys/svr4/svr4_mman.h b/sys/svr4/svr4_mman.h
new file mode 100644
index 0000000..9a7f213
--- /dev/null
+++ b/sys/svr4/svr4_mman.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1997 Todd Vierling
+ * 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.
+ */
+
+#ifndef _SVR4_MMAN_H_
+#define _SVR4_MMAN_H_
+
+/*
+ * Commands and flags passed to memcntl().
+ * Most of them are the same as <sys/mman.h>, but we need the MC_
+ * memcntl command definitions.
+ */
+
+#define SVR4_MC_SYNC 1
+#define SVR4_MC_LOCK 2
+#define SVR4_MC_UNLOCK 3
+#define SVR4_MC_ADVISE 4
+#define SVR4_MC_LOCKAS 5
+#define SVR4_MC_UNLOCKAS 6
+
+#endif /* !_SVR4_MMAN_H */
diff --git a/sys/svr4/svr4_proto.h b/sys/svr4/svr4_proto.h
new file mode 100644
index 0000000..101d36e
--- /dev/null
+++ b/sys/svr4/svr4_proto.h
@@ -0,0 +1,472 @@
+/*
+ * System call prototypes.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
+ */
+
+#ifndef _SVR4_SYSPROTO_H_
+#define _SVR4_SYSPROTO_H_
+
+#include <sys/signal.h>
+
+struct proc;
+
+#define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \
+ 0 : sizeof(register_t) - sizeof(t))
+
+struct svr4_sys_open_args {
+ char * path; char path_[PAD_(char *)];
+ int flags; char flags_[PAD_(int)];
+ int mode; char mode_[PAD_(int)];
+};
+struct svr4_sys_wait_args {
+ int * status; char status_[PAD_(int *)];
+};
+struct svr4_sys_creat_args {
+ char * path; char path_[PAD_(char *)];
+ int mode; char mode_[PAD_(int)];
+};
+struct svr4_sys_execv_args {
+ char * path; char path_[PAD_(char *)];
+ char ** argp; char argp_[PAD_(char **)];
+};
+struct svr4_sys_time_args {
+ time_t * t; char t_[PAD_(time_t *)];
+};
+struct svr4_sys_mknod_args {
+ char * path; char path_[PAD_(char *)];
+ int mode; char mode_[PAD_(int)];
+ int dev; char dev_[PAD_(int)];
+};
+struct svr4_sys_break_args {
+ caddr_t nsize; char nsize_[PAD_(caddr_t)];
+};
+struct svr4_sys_stat_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_stat * ub; char ub_[PAD_(struct svr4_stat *)];
+};
+struct svr4_sys_alarm_args {
+ unsigned sec; char sec_[PAD_(unsigned)];
+};
+struct svr4_sys_fstat_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_stat * sb; char sb_[PAD_(struct svr4_stat *)];
+};
+struct svr4_sys_pause_args {
+ register_t dummy;
+};
+struct svr4_sys_utime_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_utimbuf * ubuf; char ubuf_[PAD_(struct svr4_utimbuf *)];
+};
+struct svr4_sys_access_args {
+ char * path; char path_[PAD_(char *)];
+ int flags; char flags_[PAD_(int)];
+};
+struct svr4_sys_nice_args {
+ int prio; char prio_[PAD_(int)];
+};
+struct svr4_sys_kill_args {
+ int pid; char pid_[PAD_(int)];
+ int signum; char signum_[PAD_(int)];
+};
+struct svr4_sys_pgrpsys_args {
+ int cmd; char cmd_[PAD_(int)];
+ int pid; char pid_[PAD_(int)];
+ int pgid; char pgid_[PAD_(int)];
+};
+struct svr4_sys_times_args {
+ struct tms * tp; char tp_[PAD_(struct tms *)];
+};
+struct svr4_sys_signal_args {
+ int signum; char signum_[PAD_(int)];
+ svr4_sig_t handler; char handler_[PAD_(svr4_sig_t)];
+};
+#if defined(NOTYET)
+struct svr4_sys_msgsys_args {
+ int what; char what_[PAD_(int)];
+ int a2; char a2_[PAD_(int)];
+ int a3; char a3_[PAD_(int)];
+ int a4; char a4_[PAD_(int)];
+ int a5; char a5_[PAD_(int)];
+};
+#else
+#endif
+struct svr4_sys_sysarch_args {
+ int op; char op_[PAD_(int)];
+ void * a1; char a1_[PAD_(void *)];
+};
+struct svr4_sys_ioctl_args {
+ int fd; char fd_[PAD_(int)];
+ u_long com; char com_[PAD_(u_long)];
+ caddr_t data; char data_[PAD_(caddr_t)];
+};
+struct svr4_sys_utssys_args {
+ void * a1; char a1_[PAD_(void *)];
+ void * a2; char a2_[PAD_(void *)];
+ int sel; char sel_[PAD_(int)];
+ void * a3; char a3_[PAD_(void *)];
+};
+struct svr4_sys_execve_args {
+ char * path; char path_[PAD_(char *)];
+ char ** argp; char argp_[PAD_(char **)];
+ char ** envp; char envp_[PAD_(char **)];
+};
+struct svr4_sys_fcntl_args {
+ int fd; char fd_[PAD_(int)];
+ int cmd; char cmd_[PAD_(int)];
+ char * arg; char arg_[PAD_(char *)];
+};
+struct svr4_sys_ulimit_args {
+ int cmd; char cmd_[PAD_(int)];
+ long newlimit; char newlimit_[PAD_(long)];
+};
+struct svr4_sys_getdents_args {
+ int fd; char fd_[PAD_(int)];
+ char * buf; char buf_[PAD_(char *)];
+ int nbytes; char nbytes_[PAD_(int)];
+};
+struct svr4_sys_getmsg_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_strbuf * ctl; char ctl_[PAD_(struct svr4_strbuf *)];
+ struct svr4_strbuf * dat; char dat_[PAD_(struct svr4_strbuf *)];
+ int * flags; char flags_[PAD_(int *)];
+};
+struct svr4_sys_putmsg_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_strbuf * ctl; char ctl_[PAD_(struct svr4_strbuf *)];
+ struct svr4_strbuf * dat; char dat_[PAD_(struct svr4_strbuf *)];
+ int flags; char flags_[PAD_(int)];
+};
+struct svr4_sys_poll_args {
+ struct pollfd * fds; char fds_[PAD_(struct pollfd *)];
+ unsigned int nfds; char nfds_[PAD_(unsigned int)];
+ int timeout; char timeout_[PAD_(int)];
+};
+struct svr4_sys_lstat_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_stat * ub; char ub_[PAD_(struct svr4_stat *)];
+};
+struct svr4_sys_sigprocmask_args {
+ int how; char how_[PAD_(int)];
+ svr4_sigset_t * set; char set_[PAD_(svr4_sigset_t *)];
+ svr4_sigset_t * oset; char oset_[PAD_(svr4_sigset_t *)];
+};
+struct svr4_sys_sigsuspend_args {
+ svr4_sigset_t * ss; char ss_[PAD_(svr4_sigset_t *)];
+};
+struct svr4_sys_sigaltstack_args {
+ struct svr4_sigaltstack * nss; char nss_[PAD_(struct svr4_sigaltstack *)];
+ struct svr4_sigaltstack * oss; char oss_[PAD_(struct svr4_sigaltstack *)];
+};
+struct svr4_sys_sigaction_args {
+ int signum; char signum_[PAD_(int)];
+ struct svr4_sigaction * nsa; char nsa_[PAD_(struct svr4_sigaction *)];
+ struct svr4_sigaction * osa; char osa_[PAD_(struct svr4_sigaction *)];
+};
+struct svr4_sys_sigpending_args {
+ int what; char what_[PAD_(int)];
+ svr4_sigset_t * mask; char mask_[PAD_(svr4_sigset_t *)];
+};
+struct svr4_sys_context_args {
+ int func; char func_[PAD_(int)];
+ struct svr4_ucontext * uc; char uc_[PAD_(struct svr4_ucontext *)];
+};
+struct svr4_sys_statvfs_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_statvfs * fs; char fs_[PAD_(struct svr4_statvfs *)];
+};
+struct svr4_sys_fstatvfs_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_statvfs * fs; char fs_[PAD_(struct svr4_statvfs *)];
+};
+struct svr4_sys_waitsys_args {
+ int grp; char grp_[PAD_(int)];
+ int id; char id_[PAD_(int)];
+ union svr4_siginfo * info; char info_[PAD_(union svr4_siginfo *)];
+ int options; char options_[PAD_(int)];
+};
+struct svr4_sys_hrtsys_args {
+ int cmd; char cmd_[PAD_(int)];
+ int fun; char fun_[PAD_(int)];
+ int sub; char sub_[PAD_(int)];
+ void * rv1; char rv1_[PAD_(void *)];
+ void * rv2; char rv2_[PAD_(void *)];
+};
+struct svr4_sys_pathconf_args {
+ char * path; char path_[PAD_(char *)];
+ int name; char name_[PAD_(int)];
+};
+struct svr4_sys_mmap_args {
+ caddr_t addr; char addr_[PAD_(caddr_t)];
+ svr4_size_t len; char len_[PAD_(svr4_size_t)];
+ int prot; char prot_[PAD_(int)];
+ int flags; char flags_[PAD_(int)];
+ int fd; char fd_[PAD_(int)];
+ svr4_off_t pos; char pos_[PAD_(svr4_off_t)];
+};
+struct svr4_sys_fpathconf_args {
+ int fd; char fd_[PAD_(int)];
+ int name; char name_[PAD_(int)];
+};
+struct svr4_sys_xstat_args {
+ int two; char two_[PAD_(int)];
+ char * path; char path_[PAD_(char *)];
+ struct svr4_xstat * ub; char ub_[PAD_(struct svr4_xstat *)];
+};
+struct svr4_sys_lxstat_args {
+ int two; char two_[PAD_(int)];
+ char * path; char path_[PAD_(char *)];
+ struct svr4_xstat * ub; char ub_[PAD_(struct svr4_xstat *)];
+};
+struct svr4_sys_fxstat_args {
+ int two; char two_[PAD_(int)];
+ int fd; char fd_[PAD_(int)];
+ struct svr4_xstat * sb; char sb_[PAD_(struct svr4_xstat *)];
+};
+struct svr4_sys_xmknod_args {
+ int two; char two_[PAD_(int)];
+ char * path; char path_[PAD_(char *)];
+ svr4_mode_t mode; char mode_[PAD_(svr4_mode_t)];
+ svr4_dev_t dev; char dev_[PAD_(svr4_dev_t)];
+};
+struct svr4_sys_setrlimit_args {
+ int which; char which_[PAD_(int)];
+ const struct svr4_rlimit * rlp; char rlp_[PAD_(const struct svr4_rlimit *)];
+};
+struct svr4_sys_getrlimit_args {
+ int which; char which_[PAD_(int)];
+ struct svr4_rlimit * rlp; char rlp_[PAD_(struct svr4_rlimit *)];
+};
+struct svr4_sys_memcntl_args {
+ void * addr; char addr_[PAD_(void *)];
+ svr4_size_t len; char len_[PAD_(svr4_size_t)];
+ int cmd; char cmd_[PAD_(int)];
+ void * arg; char arg_[PAD_(void *)];
+ int attr; char attr_[PAD_(int)];
+ int mask; char mask_[PAD_(int)];
+};
+struct svr4_sys_uname_args {
+ struct svr4_utsname * name; char name_[PAD_(struct svr4_utsname *)];
+ int dummy; char dummy_[PAD_(int)];
+};
+struct svr4_sys_sysconfig_args {
+ int name; char name_[PAD_(int)];
+};
+struct svr4_sys_systeminfo_args {
+ int what; char what_[PAD_(int)];
+ char * buf; char buf_[PAD_(char *)];
+ long len; char len_[PAD_(long)];
+};
+struct svr4_sys_fchroot_args {
+ int fd; char fd_[PAD_(int)];
+};
+struct svr4_sys_utimes_args {
+ char * path; char path_[PAD_(char *)];
+ struct timeval * tptr; char tptr_[PAD_(struct timeval *)];
+};
+struct svr4_sys_vhangup_args {
+ register_t dummy;
+};
+struct svr4_sys_gettimeofday_args {
+ struct timeval * tp; char tp_[PAD_(struct timeval *)];
+};
+struct svr4_sys_llseek_args {
+ int fd; char fd_[PAD_(int)];
+ long offset1; char offset1_[PAD_(long)];
+ long offset2; char offset2_[PAD_(long)];
+ int whence; char whence_[PAD_(int)];
+};
+struct svr4_sys_acl_args {
+ char * path; char path_[PAD_(char *)];
+ int cmd; char cmd_[PAD_(int)];
+ int num; char num_[PAD_(int)];
+ struct svr4_aclent * buf; char buf_[PAD_(struct svr4_aclent *)];
+};
+struct svr4_sys_auditsys_args {
+ int code; char code_[PAD_(int)];
+ int a1; char a1_[PAD_(int)];
+ int a2; char a2_[PAD_(int)];
+ int a3; char a3_[PAD_(int)];
+ int a4; char a4_[PAD_(int)];
+ int a5; char a5_[PAD_(int)];
+};
+struct svr4_sys_facl_args {
+ int fd; char fd_[PAD_(int)];
+ int cmd; char cmd_[PAD_(int)];
+ int num; char num_[PAD_(int)];
+ struct svr4_aclent * buf; char buf_[PAD_(struct svr4_aclent *)];
+};
+struct svr4_sys_resolvepath_args {
+ const char * path; char path_[PAD_(const char *)];
+ char * buf; char buf_[PAD_(char *)];
+ size_t bufsiz; char bufsiz_[PAD_(size_t)];
+};
+struct svr4_sys_getdents64_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_dirent64 * dp; char dp_[PAD_(struct svr4_dirent64 *)];
+ int nbytes; char nbytes_[PAD_(int)];
+};
+struct svr4_sys_mmap64_args {
+ void * addr; char addr_[PAD_(void *)];
+ svr4_size_t len; char len_[PAD_(svr4_size_t)];
+ int prot; char prot_[PAD_(int)];
+ int flags; char flags_[PAD_(int)];
+ int fd; char fd_[PAD_(int)];
+ svr4_off64_t pos; char pos_[PAD_(svr4_off64_t)];
+};
+struct svr4_sys_stat64_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_stat64 * sb; char sb_[PAD_(struct svr4_stat64 *)];
+};
+struct svr4_sys_lstat64_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_stat64 * sb; char sb_[PAD_(struct svr4_stat64 *)];
+};
+struct svr4_sys_fstat64_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_stat64 * sb; char sb_[PAD_(struct svr4_stat64 *)];
+};
+struct svr4_sys_statvfs64_args {
+ char * path; char path_[PAD_(char *)];
+ struct svr4_statvfs64 * fs; char fs_[PAD_(struct svr4_statvfs64 *)];
+};
+struct svr4_sys_fstatvfs64_args {
+ int fd; char fd_[PAD_(int)];
+ struct svr4_statvfs64 * fs; char fs_[PAD_(struct svr4_statvfs64 *)];
+};
+struct svr4_sys_setrlimit64_args {
+ int which; char which_[PAD_(int)];
+ const struct svr4_rlimit64 * rlp; char rlp_[PAD_(const struct svr4_rlimit64 *)];
+};
+struct svr4_sys_getrlimit64_args {
+ int which; char which_[PAD_(int)];
+ struct svr4_rlimit64 * rlp; char rlp_[PAD_(struct svr4_rlimit64 *)];
+};
+struct svr4_sys_creat64_args {
+ char * path; char path_[PAD_(char *)];
+ int mode; char mode_[PAD_(int)];
+};
+struct svr4_sys_open64_args {
+ char * path; char path_[PAD_(char *)];
+ int flags; char flags_[PAD_(int)];
+ int mode; char mode_[PAD_(int)];
+};
+struct svr4_sys_socket_args {
+ int domain; char domain_[PAD_(int)];
+ int type; char type_[PAD_(int)];
+ int protocol; char protocol_[PAD_(int)];
+};
+struct svr4_sys_recv_args {
+ int s; char s_[PAD_(int)];
+ caddr_t buf; char buf_[PAD_(caddr_t)];
+ int len; char len_[PAD_(int)];
+ int flags; char flags_[PAD_(int)];
+};
+struct svr4_sys_send_args {
+ int s; char s_[PAD_(int)];
+ caddr_t buf; char buf_[PAD_(caddr_t)];
+ int len; char len_[PAD_(int)];
+ int flags; char flags_[PAD_(int)];
+};
+struct svr4_sys_sendto_args {
+ int s; char s_[PAD_(int)];
+ const void * buf; char buf_[PAD_(const void *)];
+ size_t len; char len_[PAD_(size_t)];
+ int flags; char flags_[PAD_(int)];
+ const struct sockaddr * to; char to_[PAD_(const struct sockaddr *)];
+ int tolen; char tolen_[PAD_(int)];
+};
+int svr4_sys_open __P((struct proc *, struct svr4_sys_open_args *));
+int svr4_sys_wait __P((struct proc *, struct svr4_sys_wait_args *));
+int svr4_sys_creat __P((struct proc *, struct svr4_sys_creat_args *));
+int svr4_sys_execv __P((struct proc *, struct svr4_sys_execv_args *));
+int svr4_sys_time __P((struct proc *, struct svr4_sys_time_args *));
+int svr4_sys_mknod __P((struct proc *, struct svr4_sys_mknod_args *));
+int svr4_sys_break __P((struct proc *, struct svr4_sys_break_args *));
+int svr4_sys_stat __P((struct proc *, struct svr4_sys_stat_args *));
+int svr4_sys_alarm __P((struct proc *, struct svr4_sys_alarm_args *));
+int svr4_sys_fstat __P((struct proc *, struct svr4_sys_fstat_args *));
+int svr4_sys_pause __P((struct proc *, struct svr4_sys_pause_args *));
+int svr4_sys_utime __P((struct proc *, struct svr4_sys_utime_args *));
+int svr4_sys_access __P((struct proc *, struct svr4_sys_access_args *));
+int svr4_sys_nice __P((struct proc *, struct svr4_sys_nice_args *));
+int svr4_sys_kill __P((struct proc *, struct svr4_sys_kill_args *));
+int svr4_sys_pgrpsys __P((struct proc *, struct svr4_sys_pgrpsys_args *));
+int svr4_sys_times __P((struct proc *, struct svr4_sys_times_args *));
+int svr4_sys_signal __P((struct proc *, struct svr4_sys_signal_args *));
+#if defined(NOTYET)
+int svr4_sys_msgsys __P((struct proc *, struct svr4_sys_msgsys_args *));
+#else
+#endif
+int svr4_sys_sysarch __P((struct proc *, struct svr4_sys_sysarch_args *));
+int svr4_sys_ioctl __P((struct proc *, struct svr4_sys_ioctl_args *));
+int svr4_sys_utssys __P((struct proc *, struct svr4_sys_utssys_args *));
+int svr4_sys_execve __P((struct proc *, struct svr4_sys_execve_args *));
+int svr4_sys_fcntl __P((struct proc *, struct svr4_sys_fcntl_args *));
+int svr4_sys_ulimit __P((struct proc *, struct svr4_sys_ulimit_args *));
+int svr4_sys_getdents __P((struct proc *, struct svr4_sys_getdents_args *));
+int svr4_sys_getmsg __P((struct proc *, struct svr4_sys_getmsg_args *));
+int svr4_sys_putmsg __P((struct proc *, struct svr4_sys_putmsg_args *));
+int svr4_sys_poll __P((struct proc *, struct svr4_sys_poll_args *));
+int svr4_sys_lstat __P((struct proc *, struct svr4_sys_lstat_args *));
+int svr4_sys_sigprocmask __P((struct proc *, struct svr4_sys_sigprocmask_args *));
+int svr4_sys_sigsuspend __P((struct proc *, struct svr4_sys_sigsuspend_args *));
+int svr4_sys_sigaltstack __P((struct proc *, struct svr4_sys_sigaltstack_args *));
+int svr4_sys_sigaction __P((struct proc *, struct svr4_sys_sigaction_args *));
+int svr4_sys_sigpending __P((struct proc *, struct svr4_sys_sigpending_args *));
+int svr4_sys_context __P((struct proc *, struct svr4_sys_context_args *));
+int svr4_sys_statvfs __P((struct proc *, struct svr4_sys_statvfs_args *));
+int svr4_sys_fstatvfs __P((struct proc *, struct svr4_sys_fstatvfs_args *));
+int svr4_sys_waitsys __P((struct proc *, struct svr4_sys_waitsys_args *));
+int svr4_sys_hrtsys __P((struct proc *, struct svr4_sys_hrtsys_args *));
+int svr4_sys_pathconf __P((struct proc *, struct svr4_sys_pathconf_args *));
+int svr4_sys_mmap __P((struct proc *, struct svr4_sys_mmap_args *));
+int svr4_sys_fpathconf __P((struct proc *, struct svr4_sys_fpathconf_args *));
+int svr4_sys_xstat __P((struct proc *, struct svr4_sys_xstat_args *));
+int svr4_sys_lxstat __P((struct proc *, struct svr4_sys_lxstat_args *));
+int svr4_sys_fxstat __P((struct proc *, struct svr4_sys_fxstat_args *));
+int svr4_sys_xmknod __P((struct proc *, struct svr4_sys_xmknod_args *));
+int svr4_sys_setrlimit __P((struct proc *, struct svr4_sys_setrlimit_args *));
+int svr4_sys_getrlimit __P((struct proc *, struct svr4_sys_getrlimit_args *));
+int svr4_sys_memcntl __P((struct proc *, struct svr4_sys_memcntl_args *));
+int svr4_sys_uname __P((struct proc *, struct svr4_sys_uname_args *));
+int svr4_sys_sysconfig __P((struct proc *, struct svr4_sys_sysconfig_args *));
+int svr4_sys_systeminfo __P((struct proc *, struct svr4_sys_systeminfo_args *));
+int svr4_sys_fchroot __P((struct proc *, struct svr4_sys_fchroot_args *));
+int svr4_sys_utimes __P((struct proc *, struct svr4_sys_utimes_args *));
+int svr4_sys_vhangup __P((struct proc *, struct svr4_sys_vhangup_args *));
+int svr4_sys_gettimeofday __P((struct proc *, struct svr4_sys_gettimeofday_args *));
+int svr4_sys_llseek __P((struct proc *, struct svr4_sys_llseek_args *));
+int svr4_sys_acl __P((struct proc *, struct svr4_sys_acl_args *));
+int svr4_sys_auditsys __P((struct proc *, struct svr4_sys_auditsys_args *));
+int svr4_sys_facl __P((struct proc *, struct svr4_sys_facl_args *));
+int svr4_sys_resolvepath __P((struct proc *, struct svr4_sys_resolvepath_args *));
+int svr4_sys_getdents64 __P((struct proc *, struct svr4_sys_getdents64_args *));
+int svr4_sys_mmap64 __P((struct proc *, struct svr4_sys_mmap64_args *));
+int svr4_sys_stat64 __P((struct proc *, struct svr4_sys_stat64_args *));
+int svr4_sys_lstat64 __P((struct proc *, struct svr4_sys_lstat64_args *));
+int svr4_sys_fstat64 __P((struct proc *, struct svr4_sys_fstat64_args *));
+int svr4_sys_statvfs64 __P((struct proc *, struct svr4_sys_statvfs64_args *));
+int svr4_sys_fstatvfs64 __P((struct proc *, struct svr4_sys_fstatvfs64_args *));
+int svr4_sys_setrlimit64 __P((struct proc *, struct svr4_sys_setrlimit64_args *));
+int svr4_sys_getrlimit64 __P((struct proc *, struct svr4_sys_getrlimit64_args *));
+int svr4_sys_creat64 __P((struct proc *, struct svr4_sys_creat64_args *));
+int svr4_sys_open64 __P((struct proc *, struct svr4_sys_open64_args *));
+int svr4_sys_socket __P((struct proc *, struct svr4_sys_socket_args *));
+int svr4_sys_recv __P((struct proc *, struct svr4_sys_recv_args *));
+int svr4_sys_send __P((struct proc *, struct svr4_sys_send_args *));
+int svr4_sys_sendto __P((struct proc *, struct svr4_sys_sendto_args *));
+
+#ifdef COMPAT_43
+
+#if defined(NOTYET)
+#else
+#endif
+
+#endif /* COMPAT_43 */
+
+#undef PAD_
+
+#endif /* !_SVR4_SYSPROTO_H_ */
diff --git a/sys/svr4/svr4_resource.c b/sys/svr4/svr4_resource.c
new file mode 100644
index 0000000..083049f
--- /dev/null
+++ b/sys/svr4/svr4_resource.c
@@ -0,0 +1,311 @@
+/* Derived from:
+ * $NetBSD: svr4_resource.c,v 1.3 1998/12/13 18:00:52 christos Exp $
+ */
+
+/*-
+ * Original copyright:
+ *
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions of this software have been derived from software contributed
+ * to the FreeBSD Project by Mark Newton.
+ *
+ * Copyright (c) 1999 Mark Newton
+ * 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/proc.h>
+#include <sys/file.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_resource.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+
+static __inline int svr4_to_native_rl __P((int));
+
+static __inline int
+svr4_to_native_rl(rl)
+ int rl;
+{
+ switch (rl) {
+ case SVR4_RLIMIT_CPU:
+ return RLIMIT_CPU;
+ case SVR4_RLIMIT_FSIZE:
+ return RLIMIT_FSIZE;
+ case SVR4_RLIMIT_DATA:
+ return RLIMIT_DATA;
+ case SVR4_RLIMIT_STACK:
+ return RLIMIT_STACK;
+ case SVR4_RLIMIT_CORE:
+ return RLIMIT_CORE;
+ case SVR4_RLIMIT_NOFILE:
+ return RLIMIT_NOFILE;
+ case SVR4_RLIMIT_VMEM:
+ return RLIMIT_RSS;
+ default:
+ return -1;
+ }
+}
+
+/*
+ * Check if the resource limit fits within the BSD range and it is not
+ * one of the magic SVR4 limit values
+ */
+#define OKLIMIT(l) (((int32_t)(l)) >= 0 && ((int32_t)(l)) < 0x7fffffff && \
+ ((svr4_rlim_t)(l)) != SVR4_RLIM_INFINITY && \
+ ((svr4_rlim_t)(l)) != SVR4_RLIM_SAVED_CUR && \
+ ((svr4_rlim_t)(l)) != SVR4_RLIM_SAVED_MAX)
+
+#define OKLIMIT64(l) (((rlim_t)(l)) >= 0 && ((rlim_t)(l)) < RLIM_INFINITY && \
+ ((svr4_rlim64_t)(l)) != SVR4_RLIM64_INFINITY && \
+ ((svr4_rlim64_t)(l)) != SVR4_RLIM64_SAVED_CUR && \
+ ((svr4_rlim64_t)(l)) != SVR4_RLIM64_SAVED_MAX)
+
+int
+svr4_sys_getrlimit(p, uap)
+ register struct proc *p;
+ struct svr4_sys_getrlimit_args *uap;
+{
+ int rl = svr4_to_native_rl(SCARG(uap, which));
+ struct rlimit blim;
+ struct svr4_rlimit slim;
+
+ if (rl == -1)
+ return EINVAL;
+
+ blim = p->p_rlimit[rl];
+
+ /*
+ * Our infinity, is their maxfiles.
+ */
+ if (rl == RLIMIT_NOFILE && blim.rlim_max == RLIM_INFINITY)
+ blim.rlim_max = maxfiles;
+
+ /*
+ * If the limit can be be represented, it is returned.
+ * Otherwise, if rlim_cur == rlim_max, return RLIM_SAVED_MAX
+ * else return RLIM_SAVED_CUR
+ */
+ if (blim.rlim_max == RLIM_INFINITY)
+ slim.rlim_max = SVR4_RLIM_INFINITY;
+ else if (OKLIMIT(blim.rlim_max))
+ slim.rlim_max = (svr4_rlim_t) blim.rlim_max;
+ else
+ slim.rlim_max = SVR4_RLIM_SAVED_MAX;
+
+ if (blim.rlim_cur == RLIM_INFINITY)
+ slim.rlim_cur = SVR4_RLIM_INFINITY;
+ else if (OKLIMIT(blim.rlim_cur))
+ slim.rlim_cur = (svr4_rlim_t) blim.rlim_cur;
+ else if (blim.rlim_max == blim.rlim_cur)
+ slim.rlim_cur = SVR4_RLIM_SAVED_MAX;
+ else
+ slim.rlim_cur = SVR4_RLIM_SAVED_CUR;
+
+ return copyout(&slim, SCARG(uap, rlp), sizeof(*SCARG(uap, rlp)));
+}
+
+
+int
+svr4_sys_setrlimit(p, uap)
+ register struct proc *p;
+ struct svr4_sys_setrlimit_args *uap;
+{
+ int rl = svr4_to_native_rl(SCARG(uap, which));
+ struct rlimit blim, *limp;
+ struct svr4_rlimit slim;
+ int error;
+
+ if (rl == -1)
+ return EINVAL;
+
+ limp = &p->p_rlimit[rl];
+
+ if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0)
+ return error;
+
+ /*
+ * if the limit is SVR4_RLIM_INFINITY, then we set it to our
+ * unlimited.
+ * We should also: If it is SVR4_RLIM_SAVED_MAX, we should set the
+ * new limit to the corresponding saved hard limit, and if
+ * it is equal to SVR4_RLIM_SAVED_CUR, we should set it to the
+ * corresponding saved soft limit.
+ *
+ */
+ if (slim.rlim_max == SVR4_RLIM_INFINITY)
+ blim.rlim_max = RLIM_INFINITY;
+ else if (OKLIMIT(slim.rlim_max))
+ blim.rlim_max = (rlim_t) slim.rlim_max;
+ else if (slim.rlim_max == SVR4_RLIM_SAVED_MAX)
+ blim.rlim_max = limp->rlim_max;
+ else if (slim.rlim_max == SVR4_RLIM_SAVED_CUR)
+ blim.rlim_max = limp->rlim_cur;
+
+ if (slim.rlim_cur == SVR4_RLIM_INFINITY)
+ blim.rlim_cur = RLIM_INFINITY;
+ else if (OKLIMIT(slim.rlim_cur))
+ blim.rlim_cur = (rlim_t) slim.rlim_cur;
+ else if (slim.rlim_cur == SVR4_RLIM_SAVED_MAX)
+ blim.rlim_cur = limp->rlim_max;
+ else if (slim.rlim_cur == SVR4_RLIM_SAVED_CUR)
+ blim.rlim_cur = limp->rlim_cur;
+
+ return dosetrlimit(p, rl, &blim);
+}
+
+
+int
+svr4_sys_getrlimit64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_getrlimit64_args *uap;
+{
+ int rl = svr4_to_native_rl(SCARG(uap, which));
+ struct rlimit blim;
+ struct svr4_rlimit64 slim;
+
+ if (rl == -1)
+ return EINVAL;
+
+ blim = p->p_rlimit[rl];
+
+ /*
+ * Our infinity, is their maxfiles.
+ */
+ if (rl == RLIMIT_NOFILE && blim.rlim_max == RLIM_INFINITY)
+ blim.rlim_max = maxfiles;
+
+ /*
+ * If the limit can be be represented, it is returned.
+ * Otherwise, if rlim_cur == rlim_max, return SVR4_RLIM_SAVED_MAX
+ * else return SVR4_RLIM_SAVED_CUR
+ */
+ if (blim.rlim_max == RLIM_INFINITY)
+ slim.rlim_max = SVR4_RLIM64_INFINITY;
+ else if (OKLIMIT64(blim.rlim_max))
+ slim.rlim_max = (svr4_rlim64_t) blim.rlim_max;
+ else
+ slim.rlim_max = SVR4_RLIM64_SAVED_MAX;
+
+ if (blim.rlim_cur == RLIM_INFINITY)
+ slim.rlim_cur = SVR4_RLIM64_INFINITY;
+ else if (OKLIMIT64(blim.rlim_cur))
+ slim.rlim_cur = (svr4_rlim64_t) blim.rlim_cur;
+ else if (blim.rlim_max == blim.rlim_cur)
+ slim.rlim_cur = SVR4_RLIM64_SAVED_MAX;
+ else
+ slim.rlim_cur = SVR4_RLIM64_SAVED_CUR;
+
+ return copyout(&slim, SCARG(uap, rlp), sizeof(*SCARG(uap, rlp)));
+}
+
+
+int
+svr4_sys_setrlimit64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_setrlimit64_args *uap;
+{
+ int rl = svr4_to_native_rl(SCARG(uap, which));
+ struct rlimit blim, *limp;
+ struct svr4_rlimit64 slim;
+ int error;
+
+ if (rl == -1)
+ return EINVAL;
+
+ limp = &p->p_rlimit[rl];
+
+ if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0)
+ return error;
+
+ /*
+ * if the limit is SVR4_RLIM64_INFINITY, then we set it to our
+ * unlimited.
+ * We should also: If it is SVR4_RLIM64_SAVED_MAX, we should set the
+ * new limit to the corresponding saved hard limit, and if
+ * it is equal to SVR4_RLIM64_SAVED_CUR, we should set it to the
+ * corresponding saved soft limit.
+ *
+ */
+ if (slim.rlim_max == SVR4_RLIM64_INFINITY)
+ blim.rlim_max = RLIM_INFINITY;
+ else if (OKLIMIT64(slim.rlim_max))
+ blim.rlim_max = (rlim_t) slim.rlim_max;
+ else if (slim.rlim_max == SVR4_RLIM64_SAVED_MAX)
+ blim.rlim_max = limp->rlim_max;
+ else if (slim.rlim_max == SVR4_RLIM64_SAVED_CUR)
+ blim.rlim_max = limp->rlim_cur;
+
+ if (slim.rlim_cur == SVR4_RLIM64_INFINITY)
+ blim.rlim_cur = RLIM_INFINITY;
+ else if (OKLIMIT64(slim.rlim_cur))
+ blim.rlim_cur = (rlim_t) slim.rlim_cur;
+ else if (slim.rlim_cur == SVR4_RLIM64_SAVED_MAX)
+ blim.rlim_cur = limp->rlim_max;
+ else if (slim.rlim_cur == SVR4_RLIM64_SAVED_CUR)
+ blim.rlim_cur = limp->rlim_cur;
+
+ return dosetrlimit(p, rl, &blim);
+}
diff --git a/sys/svr4/svr4_resource.h b/sys/svr4/svr4_resource.h
new file mode 100644
index 0000000..98c4fce
--- /dev/null
+++ b/sys/svr4/svr4_resource.h
@@ -0,0 +1,107 @@
+/* Derived from:
+ * $NetBSD: svr4_resource.h,v 1.1 1998/11/28 21:53:02 christos Exp $ */
+
+/*-
+ * Original copyright:
+ *
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions of this code derived from software contributed to the
+ * FreeBSD Project by Mark Newton.
+ *
+ * Copyright (c) 1999 Mark Newton
+ * 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.
+ */
+
+#ifndef _SVR4_RESOURCE_H_
+#define _SVR4_RESOURCE_H_
+
+#define SVR4_RLIMIT_CPU 0
+#define SVR4_RLIMIT_FSIZE 1
+#define SVR4_RLIMIT_DATA 2
+#define SVR4_RLIMIT_STACK 3
+#define SVR4_RLIMIT_CORE 4
+#define SVR4_RLIMIT_NOFILE 5
+#define SVR4_RLIMIT_VMEM 6
+#define SVR4_RLIMIT_AS SVR4_RLIMIT_VMEM
+#define SVR4_RLIM_NLIMITS 7
+
+typedef u_int32_t svr4_rlim_t;
+
+#define SVR4_RLIM_SAVED_CUR 0x7ffffffd
+#define SVR4_RLIM_SAVED_MAX 0x7ffffffe
+#define SVR4_RLIM_INFINITY 0x7fffffff
+
+struct svr4_rlimit {
+ svr4_rlim_t rlim_cur;
+ svr4_rlim_t rlim_max;
+};
+
+typedef u_int64_t svr4_rlim64_t;
+
+#define SVR4_RLIM64_SAVED_CUR ((svr4_rlim64_t) -1)
+#define SVR4_RLIM64_SAVED_MAX ((svr4_rlim64_t) -2)
+#define SVR4_RLIM64_INFINITY ((svr4_rlim64_t) -3)
+
+struct svr4_rlimit64 {
+ svr4_rlim64_t rlim_cur;
+ svr4_rlim64_t rlim_max;
+};
+
+#endif /* !_SVR4_RESOURCE_H_ */
diff --git a/sys/svr4/svr4_siginfo.h b/sys/svr4/svr4_siginfo.h
new file mode 100644
index 0000000..fe63e5d
--- /dev/null
+++ b/sys/svr4/svr4_siginfo.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SIGINFO_H_
+#define _SVR4_SIGINFO_H_
+
+#define SVR4_ILL_ILLOPC 1
+#define SVR4_ILL_ILLOPN 2
+#define SVR4_ILL_ILLADR 3
+#define SVR4_ILL_ILLTRP 4
+#define SVR4_ILL_PRVOPC 5
+#define SVR4_ILL_PRVREG 6
+#define SVR4_ILL_COPROC 7
+#define SVR4_ILL_BADSTK 8
+
+#define SVR4_FPE_INTDIV 1
+#define SVR4_FPE_INTOVF 2
+#define SVR4_FPE_FLTDIV 3
+#define SVR4_FPE_FLTOVF 4
+#define SVR4_FPE_FLTUND 5
+#define SVR4_FPE_FLTRES 6
+#define SVR4_FPE_FLTINV 7
+#define SVR4_FPE_FLTSUB 8
+
+#define SVR4_SEGV_MAPERR 1
+#define SVR4_SEGV_ACCERR 2
+
+#define SVR4_BUS_ADRALN 1
+#define SVR4_BUS_ADRERR 2
+#define SVR4_BUS_OBJERR 3
+
+#define SVR4_TRAP_BRKPT 1
+#define SVR4_TRAP_TRACE 2
+
+#define SVR4_POLL_IN 1
+#define SVR4_POLL_OUT 2
+#define SVR4_POLL_MSG 3
+#define SVR4_POLL_ERR 4
+#define SVR4_POLL_PRI 5
+
+#define SVR4_CLD_EXITED 1
+#define SVR4_CLD_KILLED 2
+#define SVR4_CLD_DUMPED 3
+#define SVR4_CLD_TRAPPED 4
+#define SVR4_CLD_STOPPED 5
+#define SVR4_CLD_CONTINUED 6
+
+#define SVR4_EMT_TAGOVF 1
+
+typedef union svr4_siginfo {
+ char si_pad[128]; /* Total size; for future expansion */
+ struct {
+ int _signo;
+ int _code;
+ int _errno;
+ union {
+ struct {
+ svr4_pid_t _pid;
+ svr4_clock_t _utime;
+ int _status;
+ svr4_clock_t _stime;
+ } _child;
+
+ struct {
+ caddr_t _addr;
+ int _trap;
+ } _fault;
+ } _reason;
+ } _info;
+} svr4_siginfo_t;
+
+#define si_signo _info._signo
+#define si_code _info._code
+#define si_errno _info._errno
+
+#define si_pid _info._reason._child._pid
+#define si_stime _info._reason._child._stime
+#define si_status _info._reason._child._status
+#define si_utime _info._reason._child._utime
+
+#define si_addr _info._reason._fault._addr
+#define si_trap _info._reason._fault._trap
+
+#endif /* !_SVR4_SIGINFO_H_ */
diff --git a/sys/svr4/svr4_signal.c b/sys/svr4/svr4_signal.c
new file mode 100644
index 0000000..47cc6fe
--- /dev/null
+++ b/sys/svr4/svr4_signal.c
@@ -0,0 +1,623 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/mount.h>
+#include <sys/kernel.h>
+#include <sys/signal.h>
+#include <sys/signalvar.h>
+#include <sys/malloc.h>
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_ucontext.h>
+
+#define sigemptyset(s) memset((s), 0, sizeof(*(s)))
+#define sigismember(s, n) (*(s) & sigmask(n))
+#define sigaddset(s, n) (*(s) |= sigmask(n))
+
+#define svr4_sigmask(n) (1 << (((n) - 1) & 31))
+#define svr4_sigword(n) (((n) - 1) >> 5)
+#define svr4_sigemptyset(s) memset((s), 0, sizeof(*(s)))
+#define svr4_sigismember(s, n) ((s)->bits[svr4_sigword(n)] & svr4_sigmask(n))
+#define svr4_sigaddset(s, n) ((s)->bits[svr4_sigword(n)] |= svr4_sigmask(n))
+
+static __inline void svr4_sigfillset __P((svr4_sigset_t *));
+void svr4_to_bsd_sigaction __P((const struct svr4_sigaction *,
+ struct sigaction *));
+void bsd_to_svr4_sigaction __P((const struct sigaction *,
+ struct svr4_sigaction *));
+
+int bsd_to_svr4_sig[] = {
+ 0,
+ SVR4_SIGHUP,
+ SVR4_SIGINT,
+ SVR4_SIGQUIT,
+ SVR4_SIGILL,
+ SVR4_SIGTRAP,
+ SVR4_SIGABRT,
+ SVR4_SIGEMT,
+ SVR4_SIGFPE,
+ SVR4_SIGKILL,
+ SVR4_SIGBUS,
+ SVR4_SIGSEGV,
+ SVR4_SIGSYS,
+ SVR4_SIGPIPE,
+ SVR4_SIGALRM,
+ SVR4_SIGTERM,
+ SVR4_SIGURG,
+ SVR4_SIGSTOP,
+ SVR4_SIGTSTP,
+ SVR4_SIGCONT,
+ SVR4_SIGCHLD,
+ SVR4_SIGTTIN,
+ SVR4_SIGTTOU,
+ SVR4_SIGIO,
+ SVR4_SIGXCPU,
+ SVR4_SIGXFSZ,
+ SVR4_SIGVTALRM,
+ SVR4_SIGPROF,
+ SVR4_SIGWINCH,
+ 0, /* SIGINFO */
+ SVR4_SIGUSR1,
+ SVR4_SIGUSR2,
+};
+
+int svr4_to_bsd_sig[] = {
+ 0,
+ SIGHUP,
+ SIGINT,
+ SIGQUIT,
+ SIGILL,
+ SIGTRAP,
+ SIGABRT,
+ SIGEMT,
+ SIGFPE,
+ SIGKILL,
+ SIGBUS,
+ SIGSEGV,
+ SIGSYS,
+ SIGPIPE,
+ SIGALRM,
+ SIGTERM,
+ SIGUSR1,
+ SIGUSR2,
+ SIGCHLD,
+ 0, /* XXX NetBSD uses SIGPWR here, but we don't seem to have one */
+ SIGWINCH,
+ SIGURG,
+ SIGIO,
+ SIGSTOP,
+ SIGTSTP,
+ SIGCONT,
+ SIGTTIN,
+ SIGTTOU,
+ SIGVTALRM,
+ SIGPROF,
+ SIGXCPU,
+ SIGXFSZ,
+};
+
+static __inline void
+svr4_sigfillset(s)
+ svr4_sigset_t *s;
+{
+ int i;
+
+ svr4_sigemptyset(s);
+ for (i = 1; i < SVR4_NSIG; i++)
+ svr4_sigaddset(s, i);
+}
+
+void
+svr4_to_bsd_sigset(sss, bss)
+ const svr4_sigset_t *sss;
+ sigset_t *bss;
+{
+ int i, newsig;
+
+ sigemptyset(bss);
+ for (i = 1; i < SVR4_NSIG; i++) {
+ if (svr4_sigismember(sss, i)) {
+ newsig = svr4_to_bsd_sig[i];
+ if (newsig)
+ sigaddset(bss, newsig);
+ }
+ }
+}
+
+
+void
+bsd_to_svr4_sigset(bss, sss)
+ const sigset_t *bss;
+ svr4_sigset_t *sss;
+{
+ int i, newsig;
+
+ svr4_sigemptyset(sss);
+ for (i = 1; i < NSIG; i++) {
+ if (sigismember(bss, i)) {
+ newsig = bsd_to_svr4_sig[i];
+ if (newsig)
+ svr4_sigaddset(sss, newsig);
+ }
+ }
+}
+
+
+/*
+ * XXX: Only a subset of the flags is currently implemented.
+ */
+void
+svr4_to_bsd_sigaction(ssa, bsa)
+ const struct svr4_sigaction *ssa;
+ struct sigaction *bsa;
+{
+
+ bsa->sa_handler = (sig_t) ssa->sa_handler;
+ svr4_to_bsd_sigset(&ssa->sa_mask, &bsa->sa_mask);
+ bsa->sa_flags = 0;
+ if ((ssa->sa_flags & SVR4_SA_ONSTACK) != 0)
+ bsa->sa_flags |= SA_ONSTACK;
+ if ((ssa->sa_flags & SVR4_SA_RESETHAND) != 0)
+ bsa->sa_flags |= SA_RESETHAND;
+ if ((ssa->sa_flags & SVR4_SA_RESTART) != 0)
+ bsa->sa_flags |= SA_RESTART;
+ if ((ssa->sa_flags & SVR4_SA_SIGINFO) != 0)
+ DPRINTF(("svr4_to_bsd_sigaction: SA_SIGINFO ignored\n"));
+ if ((ssa->sa_flags & SVR4_SA_NOCLDSTOP) != 0)
+ bsa->sa_flags |= SA_NOCLDSTOP;
+ if ((ssa->sa_flags & SVR4_SA_NODEFER) != 0)
+ bsa->sa_flags |= SA_NODEFER;
+ if ((ssa->sa_flags & SVR4_SA_NOCLDWAIT) != 0)
+ bsa->sa_flags |= SA_NOCLDWAIT;
+ if ((ssa->sa_flags & ~SVR4_SA_ALLBITS) != 0)
+ DPRINTF(("svr4_to_bsd_sigaction: extra bits ignored\n"));
+}
+
+void
+bsd_to_svr4_sigaction(bsa, ssa)
+ const struct sigaction *bsa;
+ struct svr4_sigaction *ssa;
+{
+
+ ssa->sa_handler = (svr4_sig_t) bsa->sa_handler;
+ bsd_to_svr4_sigset(&bsa->sa_mask, &ssa->sa_mask);
+ ssa->sa_flags = 0;
+ if ((bsa->sa_flags & SA_ONSTACK) != 0)
+ ssa->sa_flags |= SVR4_SA_ONSTACK;
+ if ((bsa->sa_flags & SA_RESETHAND) != 0)
+ ssa->sa_flags |= SVR4_SA_RESETHAND;
+ if ((bsa->sa_flags & SA_RESTART) != 0)
+ ssa->sa_flags |= SVR4_SA_RESTART;
+ if ((bsa->sa_flags & SA_NODEFER) != 0)
+ ssa->sa_flags |= SVR4_SA_NODEFER;
+ if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
+ ssa->sa_flags |= SVR4_SA_NOCLDSTOP;
+}
+
+void
+svr4_to_bsd_sigaltstack(sss, bss)
+ const struct svr4_sigaltstack *sss;
+ struct sigaltstack *bss;
+{
+
+ bss->ss_sp = sss->ss_sp;
+ bss->ss_size = sss->ss_size;
+ bss->ss_flags = 0;
+ if ((sss->ss_flags & SVR4_SS_DISABLE) != 0)
+ bss->ss_flags |= SS_DISABLE;
+ if ((sss->ss_flags & SVR4_SS_ONSTACK) != 0)
+ bss->ss_flags |= SS_ONSTACK;
+ if ((sss->ss_flags & ~SVR4_SS_ALLBITS) != 0)
+ /*XXX*/ uprintf("svr4_to_bsd_sigaltstack: extra bits ignored\n");
+}
+
+void
+bsd_to_svr4_sigaltstack(bss, sss)
+ const struct sigaltstack *bss;
+ struct svr4_sigaltstack *sss;
+{
+
+ sss->ss_sp = bss->ss_sp;
+ sss->ss_size = bss->ss_size;
+ sss->ss_flags = 0;
+ if ((bss->ss_flags & SS_DISABLE) != 0)
+ sss->ss_flags |= SVR4_SS_DISABLE;
+ if ((bss->ss_flags & SS_ONSTACK) != 0)
+ sss->ss_flags |= SVR4_SS_ONSTACK;
+}
+
+int
+svr4_sys_sigaction(p, uap)
+ register struct proc *p;
+ struct svr4_sys_sigaction_args *uap;
+{
+ struct svr4_sigaction *nisa, *oisa, tmpisa;
+ struct sigaction *nbsa, *obsa, tmpbsa;
+ struct sigaction_args sa;
+ caddr_t sg;
+ int error;
+
+ sg = stackgap_init();
+ nisa = SCARG(uap, nsa);
+ oisa = SCARG(uap, osa);
+
+ 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;
+ svr4_to_bsd_sigaction(&tmpisa, &tmpbsa);
+ if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
+ return error;
+ } else
+ nbsa = NULL;
+
+ SCARG(&sa, signum) = svr4_to_bsd_sig[SCARG(uap, signum)];
+ SCARG(&sa, nsa) = nbsa;
+ SCARG(&sa, osa) = obsa;
+
+ if ((error = sigaction(p, &sa)) != 0)
+ return error;
+
+ if (oisa != NULL) {
+ if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
+ return error;
+ bsd_to_svr4_sigaction(&tmpbsa, &tmpisa);
+ if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
+ return error;
+ }
+
+ return 0;
+}
+
+int
+svr4_sys_sigaltstack(p, uap)
+ register struct proc *p;
+ struct svr4_sys_sigaltstack_args *uap;
+{
+ struct svr4_sigaltstack *nsss, *osss, tmpsss;
+ struct sigaltstack *nbss, *obss, tmpbss;
+ struct sigaltstack_args sa;
+ caddr_t sg;
+ int error, *retval;
+
+ retval = p->p_retval;
+ sg = stackgap_init();
+ nsss = SCARG(uap, nss);
+ osss = SCARG(uap, oss);
+
+ if (osss != NULL)
+ obss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
+ else
+ obss = NULL;
+
+ if (nsss != NULL) {
+ nbss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
+ if ((error = copyin(nsss, &tmpsss, sizeof(tmpsss))) != 0)
+ return error;
+ svr4_to_bsd_sigaltstack(&tmpsss, &tmpbss);
+ if ((error = copyout(&tmpbss, nbss, sizeof(tmpbss))) != 0)
+ return error;
+ } else
+ nbss = NULL;
+
+ SCARG(&sa, nss) = nbss;
+ SCARG(&sa, oss) = obss;
+
+ if ((error = sigaltstack(p, &sa)) != 0)
+ return error;
+
+ if (obss != NULL) {
+ if ((error = copyin(obss, &tmpbss, sizeof(tmpbss))) != 0)
+ return error;
+ bsd_to_svr4_sigaltstack(&tmpbss, &tmpsss);
+ if ((error = copyout(&tmpsss, osss, sizeof(tmpsss))) != 0)
+ return error;
+ }
+
+ return 0;
+}
+
+/*
+ * Stolen from the ibcs2 one
+ */
+int
+svr4_sys_signal(p, uap)
+ register struct proc *p;
+ struct svr4_sys_signal_args *uap;
+{
+ int signum = svr4_to_bsd_sig[SVR4_SIGNO(SCARG(uap, signum))];
+ int error, *retval;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ if (signum <= 0 || signum >= SVR4_NSIG)
+ return (EINVAL);
+
+ switch (SVR4_SIGCALL(SCARG(uap, signum))) {
+ case SVR4_SIGDEFER_MASK:
+ if (SCARG(uap, handler) == SVR4_SIG_HOLD)
+ goto sighold;
+ /* FALLTHROUGH */
+
+ case SVR4_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 = (sig_t) SCARG(uap, handler);
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = 0;
+
+ if (signum != SIGALRM)
+ sa.sa_flags = SA_RESTART;
+
+ if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
+ return error;
+ if ((error = sigaction(p, &sa_args)) != 0) {
+ DPRINTF(("signal: sigaction failed: %d\n",
+ error));
+ *retval = (int)SVR4_SIG_ERR;
+ return error;
+ }
+ if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
+ return error;
+ *retval = (int)sa.sa_handler;
+ return 0;
+ }
+
+ case SVR4_SIGHOLD_MASK:
+sighold:
+ {
+ struct sigprocmask_args sa;
+
+ SCARG(&sa, how) = SIG_BLOCK;
+ SCARG(&sa, mask) = sigmask(signum);
+ return sigprocmask(p, &sa);
+ }
+
+ case SVR4_SIGRELSE_MASK:
+ {
+ struct sigprocmask_args sa;
+
+ SCARG(&sa, how) = SIG_UNBLOCK;
+ SCARG(&sa, mask) = sigmask(signum);
+ return sigprocmask(p, &sa);
+ }
+
+ case SVR4_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)) != 0) {
+ DPRINTF(("sigignore: sigaction failed\n"));
+ return error;
+ }
+ return 0;
+ }
+
+ case SVR4_SIGPAUSE_MASK:
+ {
+ struct sigsuspend_args sa;
+
+ SCARG(&sa, mask) = p->p_sigmask & ~sigmask(signum);
+ return sigsuspend(p, &sa);
+ }
+
+ default:
+ return (ENOSYS);
+ }
+}
+
+
+int
+svr4_sys_sigprocmask(p, uap)
+ struct proc *p;
+ struct svr4_sys_sigprocmask_args *uap;
+{
+ svr4_sigset_t sss;
+ sigset_t bss;
+ int error = 0, *retval;
+
+ retval = p->p_retval;
+ if (SCARG(uap, oset) != NULL) {
+ /* Fix the return value first if needed */
+ bsd_to_svr4_sigset(&p->p_sigmask, &sss);
+ if ((error = copyout(&sss, SCARG(uap, oset), sizeof(sss))) != 0)
+ return error;
+ }
+
+ if (SCARG(uap, set) == NULL)
+ /* Just examine */
+ return 0;
+
+ if ((error = copyin(SCARG(uap, set), &sss, sizeof(sss))) != 0)
+ return error;
+
+ svr4_to_bsd_sigset(&sss, &bss);
+
+ (void) splhigh();
+
+ switch (SCARG(uap, how)) {
+ case SVR4_SIG_BLOCK:
+ p->p_sigmask |= bss & ~sigcantmask;
+ break;
+
+ case SVR4_SIG_UNBLOCK:
+ p->p_sigmask &= ~bss;
+ break;
+
+ case SVR4_SIG_SETMASK:
+ p->p_sigmask = bss & ~sigcantmask;
+ break;
+
+ default:
+ error = EINVAL;
+ break;
+ }
+
+ (void) spl0();
+
+ return error;
+}
+
+int
+svr4_sys_sigpending(p, uap)
+ struct proc *p;
+ struct svr4_sys_sigpending_args *uap;
+{
+ sigset_t bss;
+ int *retval;
+ svr4_sigset_t sss;
+
+ retval = p->p_retval;
+ switch (SCARG(uap, what)) {
+ case 1: /* sigpending */
+ if (SCARG(uap, mask) == NULL)
+ return 0;
+ bss = p->p_siglist & p->p_sigmask;
+ bsd_to_svr4_sigset(&bss, &sss);
+ break;
+
+ case 2: /* sigfillset */
+ svr4_sigfillset(&sss);
+ break;
+
+ default:
+ return EINVAL;
+ }
+
+ return copyout(&sss, SCARG(uap, mask), sizeof(sss));
+}
+
+int
+svr4_sys_sigsuspend(p, uap)
+ register struct proc *p;
+ struct svr4_sys_sigsuspend_args *uap;
+{
+ svr4_sigset_t sss;
+ sigset_t bss;
+ struct sigsuspend_args sa;
+ int error;
+
+ if ((error = copyin(SCARG(uap, ss), &sss, sizeof(sss))) != 0)
+ return error;
+
+ svr4_to_bsd_sigset(&sss, &bss);
+
+ SCARG(&sa, mask) = bss;
+ return sigsuspend(p, &sa);
+}
+
+
+int
+svr4_sys_kill(p, uap)
+ register struct proc *p;
+ struct svr4_sys_kill_args *uap;
+{
+ struct kill_args ka;
+
+ SCARG(&ka, pid) = SCARG(uap, pid);
+ SCARG(&ka, signum) = svr4_to_bsd_sig[SCARG(uap, signum)];
+ return kill(p, &ka);
+}
+
+
+int
+svr4_sys_context(p, uap)
+ register struct proc *p;
+ struct svr4_sys_context_args *uap;
+{
+ struct svr4_ucontext uc;
+ int error;
+
+ switch (uap->func) {
+ case 0:
+ DPRINTF(("getcontext(%p)\n", uap->uc));
+ svr4_getcontext(p, &uc, p->p_sigmask,
+ p->p_sigacts->ps_sigstk.ss_flags & SS_ONSTACK);
+ return copyout(&uc, uap->uc, sizeof(uc));
+
+ case 1:
+ DPRINTF(("setcontext(%p)\n", uap->uc));
+ if ((error = copyin(uap->uc, &uc, sizeof(uc))) != 0)
+ return error;
+ DPRINTF(("uc_flags = %x\n", uc.uc_flags));
+ DPRINTF(("uc_sigmask = %x\n", uc.uc_sigmask));
+
+ return svr4_setcontext(p, &uc);
+
+ default:
+ DPRINTF(("context(%d, %p)\n", uap->func,
+ uap->uc));
+ return ENOSYS;
+ }
+ return 0;
+}
+
+int
+svr4_sys_pause(p, uap)
+ register struct proc *p;
+ struct svr4_sys_pause_args *uap;
+{
+ struct sigsuspend_args bsa;
+
+ SCARG(&bsa, mask) = p->p_sigmask;
+ return sigsuspend(p, &bsa);
+}
diff --git a/sys/svr4/svr4_signal.h b/sys/svr4/svr4_signal.h
new file mode 100644
index 0000000..39444a9
--- /dev/null
+++ b/sys/svr4/svr4_signal.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SIGNAL_H_
+#define _SVR4_SIGNAL_H_
+
+#include <i386/svr4/svr4_machdep.h>
+#include <svr4/svr4_siginfo.h>
+
+#define SVR4_SIGHUP 1
+#define SVR4_SIGINT 2
+#define SVR4_SIGQUIT 3
+#define SVR4_SIGILL 4
+#define SVR4_SIGTRAP 5
+#define SVR4_SIGIOT 6
+#define SVR4_SIGABRT 6
+#define SVR4_SIGEMT 7
+#define SVR4_SIGFPE 8
+#define SVR4_SIGKILL 9
+#define SVR4_SIGBUS 10
+#define SVR4_SIGSEGV 11
+#define SVR4_SIGSYS 12
+#define SVR4_SIGPIPE 13
+#define SVR4_SIGALRM 14
+#define SVR4_SIGTERM 15
+#define SVR4_SIGUSR1 16
+#define SVR4_SIGUSR2 17
+#define SVR4_SIGCLD 18
+#define SVR4_SIGCHLD 18
+#define SVR4_SIGPWR 19
+#define SVR4_SIGWINCH 20
+#define SVR4_SIGURG 21
+#define SVR4_SIGPOLL 22
+#define SVR4_SIGIO 22
+#define SVR4_SIGSTOP 23
+#define SVR4_SIGTSTP 24
+#define SVR4_SIGCONT 25
+#define SVR4_SIGTTIN 26
+#define SVR4_SIGTTOU 27
+#define SVR4_SIGVTALRM 28
+#define SVR4_SIGPROF 29
+#define SVR4_SIGXCPU 30
+#define SVR4_SIGXFSZ 31
+#define SVR4_NSIG 32
+
+#define SVR4_SIGNO_MASK 0x00FF
+#define SVR4_SIGNAL_MASK 0x0000
+#define SVR4_SIGDEFER_MASK 0x0100
+#define SVR4_SIGHOLD_MASK 0x0200
+#define SVR4_SIGRELSE_MASK 0x0400
+#define SVR4_SIGIGNORE_MASK 0x0800
+#define SVR4_SIGPAUSE_MASK 0x1000
+
+typedef void (*svr4_sig_t) __P((int, svr4_siginfo_t *, void *));
+#define SVR4_SIG_DFL (svr4_sig_t) 0
+#define SVR4_SIG_ERR (svr4_sig_t) -1
+#define SVR4_SIG_IGN (svr4_sig_t) 1
+#define SVR4_SIG_HOLD (svr4_sig_t) 2
+
+#define SVR4_SIGNO(a) ((a) & SVR4_SIGNO_MASK)
+#define SVR4_SIGCALL(a) ((a) & ~SVR4_SIGNO_MASK)
+
+#define SVR4_SIG_BLOCK 1
+#define SVR4_SIG_UNBLOCK 2
+#define SVR4_SIG_SETMASK 3
+
+typedef struct {
+ u_long bits[4];
+} svr4_sigset_t;
+
+struct svr4_sigaction {
+ int sa_flags;
+ svr4_sig_t sa_handler;
+ svr4_sigset_t sa_mask;
+ int sa_reserved[2];
+};
+
+struct svr4_sigaltstack {
+ char *ss_sp;
+ int ss_size;
+ int ss_flags;
+};
+
+/* sa_flags */
+#define SVR4_SA_ONSTACK 0x00000001
+#define SVR4_SA_RESETHAND 0x00000002
+#define SVR4_SA_RESTART 0x00000004
+#define SVR4_SA_SIGINFO 0x00000008
+#define SVR4_SA_NODEFER 0x00000010
+#define SVR4_SA_NOCLDWAIT 0x00010000 /* No zombies */
+#define SVR4_SA_NOCLDSTOP 0x00020000 /* No jcl */
+#define SVR4_SA_ALLBITS 0x0003001f
+
+/* ss_flags */
+#define SVR4_SS_ONSTACK 0x00000001
+#define SVR4_SS_DISABLE 0x00000002
+#define SVR4_SS_ALLBITS 0x00000003
+
+void bsd_to_svr4_sigaltstack __P((const struct sigaltstack *, struct svr4_sigaltstack *));
+void bsd_to_svr4_sigset __P((const sigset_t *, svr4_sigset_t *));
+void svr4_to_bsd_sigaltstack __P((const struct svr4_sigaltstack *, struct sigaltstack *));
+void svr4_to_bsd_sigset __P((const svr4_sigset_t *, sigset_t *));
+void svr4_sendsig(sig_t, int, int, u_long);
+
+#endif /* !_SVR4_SIGNAL_H_ */
diff --git a/sys/svr4/svr4_socket.c b/sys/svr4/svr4_socket.c
new file mode 100644
index 0000000..314e1cd
--- /dev/null
+++ b/sys/svr4/svr4_socket.c
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1996 Christos Zoulas.
+ * 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 Christos Zoulas.
+ * 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.
+ */
+
+/*
+ * In SVR4 unix domain sockets are referenced sometimes
+ * (in putmsg(2) for example) as a [device, inode] pair instead of a pathname.
+ * Since there is no iname() routine in the kernel, and we need access to
+ * a mapping from inode to pathname, we keep our own table. This is a simple
+ * linked list that contains the pathname, the [device, inode] pair, the
+ * file corresponding to that socket and the process. When the
+ * socket gets closed we remove the item from the list. The list gets loaded
+ * every time a stat(2) call finds a socket.
+ */
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/queue.h>
+#include <sys/mbuf.h>
+#include <sys/file.h>
+#include <sys/mount.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/sysproto.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <sys/proc.h>
+#include <sys/malloc.h>
+
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_socket.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_sockmod.h>
+#include <svr4/svr4_proto.h>
+
+struct svr4_sockcache_entry {
+ struct proc *p; /* Process for the socket */
+ void *cookie; /* Internal cookie used for matching */
+ struct sockaddr_un sock;/* Pathname for the socket */
+ dev_t dev; /* Device where the socket lives on */
+ ino_t ino; /* Inode where the socket lives on */
+ TAILQ_ENTRY(svr4_sockcache_entry) entries;
+};
+
+extern TAILQ_HEAD(svr4_sockcache_head, svr4_sockcache_entry) svr4_head;
+extern int svr4_str_initialized;
+
+struct sockaddr_un *
+svr4_find_socket(p, fp, dev, ino)
+ struct proc *p;
+ struct file *fp;
+ dev_t dev;
+ ino_t ino;
+{
+ struct svr4_sockcache_entry *e;
+ void *cookie = ((struct socket *) fp->f_data)->so_emuldata;
+
+ if (!svr4_str_initialized) {
+ DPRINTF(("svr4_find_socket: uninitialized [%p,%d,%d]\n",
+ p, dev, ino));
+ TAILQ_INIT(&svr4_head);
+ svr4_str_initialized = 1;
+ return NULL;
+ }
+
+
+ DPRINTF(("svr4_find_socket: [%p,%d,%d]: ", p, dev, ino));
+ for (e = svr4_head.tqh_first; e != NULL; e = e->entries.tqe_next)
+ if (e->p == p && e->dev == dev && e->ino == ino) {
+#ifdef DIAGNOSTIC
+ if (e->cookie != NULL && e->cookie != cookie)
+ panic("svr4 socket cookie mismatch");
+#endif
+ e->cookie = cookie;
+ DPRINTF(("%s\n", e->sock.sun_path));
+ return &e->sock;
+ }
+
+ DPRINTF(("not found\n"));
+ return NULL;
+}
+
+
+void
+svr4_delete_socket(p, fp)
+ struct proc *p;
+ struct file *fp;
+{
+ struct svr4_sockcache_entry *e;
+ void *cookie = ((struct socket *) fp->f_data)->so_emuldata;
+
+ if (!svr4_str_initialized) {
+ TAILQ_INIT(&svr4_head);
+ svr4_str_initialized = 1;
+ return;
+ }
+
+ for (e = svr4_head.tqh_first; e != NULL; e = e->entries.tqe_next)
+ if (e->p == p && e->cookie == cookie) {
+ TAILQ_REMOVE(&svr4_head, e, entries);
+ DPRINTF(("svr4_delete_socket: %s [%p,%d,%d]\n",
+ e->sock.sun_path, p, e->dev, e->ino));
+ free(e, M_TEMP);
+ return;
+ }
+}
+
+
+int
+svr4_add_socket(p, path, st)
+ struct proc *p;
+ const char *path;
+ struct stat *st;
+{
+ struct svr4_sockcache_entry *e;
+ int len, error;
+
+ if (!svr4_str_initialized) {
+ TAILQ_INIT(&svr4_head);
+ svr4_str_initialized = 1;
+ }
+
+ e = malloc(sizeof(*e), M_TEMP, M_WAITOK);
+ e->cookie = NULL;
+ e->dev = st->st_dev;
+ e->ino = st->st_ino;
+ e->p = p;
+
+ if ((error = copyinstr(path, e->sock.sun_path,
+ sizeof(e->sock.sun_path), &len)) != 0) {
+ DPRINTF(("svr4_add_socket: copyinstr failed %d\n", error));
+ free(e, M_TEMP);
+ return error;
+ }
+
+ e->sock.sun_family = AF_LOCAL;
+ e->sock.sun_len = len;
+
+ TAILQ_INSERT_HEAD(&svr4_head, e, entries);
+ DPRINTF(("svr4_add_socket: %s [%p,%d,%d]\n", e->sock.sun_path,
+ p, e->dev, e->ino));
+ return 0;
+}
+
+
+int
+svr4_sys_socket(p, uap)
+ struct proc *p;
+ struct svr4_sys_socket_args *uap;
+{
+ switch (SCARG(uap, type)) {
+ case SVR4_SOCK_DGRAM:
+ SCARG(uap, type) = SOCK_DGRAM;
+ break;
+
+ case SVR4_SOCK_STREAM:
+ SCARG(uap, type) = SOCK_STREAM;
+ break;
+
+ case SVR4_SOCK_RAW:
+ SCARG(uap, type) = SOCK_RAW;
+ break;
+
+ case SVR4_SOCK_RDM:
+ SCARG(uap, type) = SOCK_RDM;
+ break;
+
+ case SVR4_SOCK_SEQPACKET:
+ SCARG(uap, type) = SOCK_SEQPACKET;
+ break;
+ default:
+ return EINVAL;
+ }
+ return socket(p, (struct socket_args *)uap);
+}
diff --git a/sys/svr4/svr4_socket.h b/sys/svr4/svr4_socket.h
new file mode 100644
index 0000000..8e0dc31
--- /dev/null
+++ b/sys/svr4/svr4_socket.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1996 Christos Zoulas.
+ * 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 Christos Zoulas.
+ * 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 _SVR4_SOCKET_H_
+#define _SVR4_SOCKET_H_
+
+#include <netinet/in.h>
+
+struct sockaddr_un;
+struct proc;
+struct file;
+
+struct svr4_sockaddr_in {
+ u_char sin_family;
+ u_short sin_port;
+ struct in_addr sin_addr;
+ u_char sin_zero[8];
+};
+
+struct sockaddr_un *svr4_find_socket __P((struct proc *, struct file *,
+ dev_t, ino_t));
+void svr4_delete_socket __P((struct proc *, struct file *));
+int svr4_add_socket __P((struct proc *, const char *, struct stat *));
+
+#endif /* _SVR4_SOCKET_H_ */
diff --git a/sys/svr4/svr4_sockio.c b/sys/svr4/svr4_sockio.c
new file mode 100644
index 0000000..7b9fb1f
--- /dev/null
+++ b/sys/svr4/svr4_sockio.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1995 Christos Zoulas
+ * 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/proc.h>
+#include <sys/systm.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/sockio.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/socket.h>
+#include <sys/mount.h>
+#include <net/if.h>
+#include <sys/malloc.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_ioctl.h>
+#include <svr4/svr4_sockio.h>
+
+static int bsd_to_svr4_flags __P((int));
+
+#define bsd_to_svr4_flag(a) \
+ if (bf & __CONCAT(I,a)) sf |= __CONCAT(SVR4_I,a)
+
+static int
+bsd_to_svr4_flags(bf)
+ int bf;
+{
+ int sf = 0;
+ bsd_to_svr4_flag(FF_UP);
+ bsd_to_svr4_flag(FF_BROADCAST);
+ bsd_to_svr4_flag(FF_DEBUG);
+ bsd_to_svr4_flag(FF_LOOPBACK);
+ bsd_to_svr4_flag(FF_POINTOPOINT);
+#if defined(IFF_NOTRAILERS)
+ bsd_to_svr4_flag(FF_NOTRAILERS);
+#endif
+ bsd_to_svr4_flag(FF_RUNNING);
+ bsd_to_svr4_flag(FF_NOARP);
+ bsd_to_svr4_flag(FF_PROMISC);
+ bsd_to_svr4_flag(FF_ALLMULTI);
+ bsd_to_svr4_flag(FF_MULTICAST);
+ return sf;
+}
+
+int
+svr4_sock_ioctl(fp, p, retval, fd, cmd, data)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t data;
+{
+ int error;
+ int (*ctl) __P((struct file *, u_long, caddr_t, struct proc *)) =
+ fp->f_ops->fo_ioctl;
+
+ *retval = 0;
+
+ switch (cmd) {
+ case SVR4_SIOCGIFNUM:
+ {
+ struct ifnet *ifp;
+ struct ifaddr *ifa;
+ int ifnum = 0;
+
+ /*
+ * This does not return the number of physical
+ * interfaces (if_index), but the number of interfaces
+ * + addresses like ifconf() does, because this number
+ * is used by code that will call SVR4_SIOCGIFCONF to
+ * find the space needed for SVR4_SIOCGIFCONF. So we
+ * count the number of ifreq entries that the next
+ * SVR4_SIOCGIFCONF will return. Maybe a more correct
+ * fix is to make SVR4_SIOCGIFCONF return only one
+ * entry per physical interface?
+ */
+
+ for (ifp = ifnet.tqh_first;
+ ifp != 0; ifp = ifp->if_link.tqe_next)
+ if ((ifa = ifp->if_addrhead.tqh_first) == NULL)
+ ifnum++;
+ else
+ for (;ifa != NULL;
+ ifa = ifa->ifa_link.tqe_next)
+ ifnum++;
+
+
+ DPRINTF(("SIOCGIFNUM %d\n", ifnum));
+ return copyout(&ifnum, data, sizeof(ifnum));
+ }
+
+ case SVR4_SIOCGIFFLAGS:
+ {
+ struct ifreq br;
+ struct svr4_ifreq sr;
+
+ if ((error = copyin(data, &sr, sizeof(sr))) != 0)
+ return error;
+
+ (void) strncpy(br.ifr_name, "de0", /*sr.svr4_ifr_name,*/
+ sizeof(br.ifr_name));
+ if ((error = (*ctl)(fp, SIOCGIFFLAGS,
+ (caddr_t) &br, p)) != 0) {
+ DPRINTF(("SIOCGIFFLAGS (%s) %s: error %d\n",
+ br.ifr_name, sr.svr4_ifr_name, error));
+ return error;
+ }
+
+ sr.svr4_ifr_flags = bsd_to_svr4_flags(br.ifr_flags);
+ DPRINTF(("SIOCGIFFLAGS %s = %x\n",
+ sr.svr4_ifr_name, sr.svr4_ifr_flags));
+ return copyout(&sr, data, sizeof(sr));
+ }
+
+ case SVR4_SIOCGIFCONF:
+ {
+ struct svr4_ifconf sc;
+
+ if ((error = copyin(data, &sc, sizeof(sc))) != 0)
+ return error;
+
+ DPRINTF(("ifreq %d svr4_ifreq %d ifc_len %d\n",
+ sizeof(struct ifreq), sizeof(struct svr4_ifreq),
+ sc.svr4_ifc_len));
+
+ if ((error = (*ctl)(fp, OSIOCGIFCONF,
+ (caddr_t) &sc, p)) != 0)
+ return error;
+
+ DPRINTF(("SIOCGIFCONF\n"));
+ return 0;
+ }
+
+
+ default:
+ DPRINTF(("Unknown svr4 sockio %lx\n", cmd));
+ return 0; /* ENOSYS really */
+ }
+}
diff --git a/sys/svr4/svr4_sockio.h b/sys/svr4/svr4_sockio.h
new file mode 100644
index 0000000..7ddbcf7
--- /dev/null
+++ b/sys/svr4/svr4_sockio.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1995 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SOCKIO_H_
+#define _SVR4_SOCKIO_H_
+
+#define SVR4_IFF_UP 0x0001
+#define SVR4_IFF_BROADCAST 0x0002
+#define SVR4_IFF_DEBUG 0x0004
+#define SVR4_IFF_LOOPBACK 0x0008
+#define SVR4_IFF_POINTOPOINT 0x0010
+#define SVR4_IFF_NOTRAILERS 0x0020
+#define SVR4_IFF_RUNNING 0x0040
+#define SVR4_IFF_NOARP 0x0080
+#define SVR4_IFF_PROMISC 0x0100
+#define SVR4_IFF_ALLMULTI 0x0200
+#define SVR4_IFF_INTELLIGENT 0x0400
+#define SVR4_IFF_MULTICAST 0x0800
+#define SVR4_IFF_MULTI_BCAST 0x1000
+#define SVR4_IFF_UNNUMBERED 0x2000
+#define SVR4_IFF_PRIVATE 0x8000
+
+struct svr4_ifreq {
+#define SVR4_IFNAMSIZ 16
+ char svr4_ifr_name[SVR4_IFNAMSIZ];
+ union {
+ struct osockaddr ifru_addr;
+ struct osockaddr ifru_dstaddr;
+ struct osockaddr ifru_broadaddr;
+ short ifru_flags;
+ int ifru_metric;
+ char ifru_data;
+ char ifru_enaddr[6];
+ int if_muxid[2];
+
+ } ifr_ifru;
+
+#define svr4_ifr_addr ifr_ifru.ifru_addr
+#define svr4_ifr_dstaddr ifr_ifru.ifru_dstaddr
+#define svr4_ifr_broadaddr ifr_ifru.ifru_broadaddr
+#define svr4_ifr_flags ifr_ifru.ifru_flags
+#define svr4_ifr_metric ifr_ifru.ifru_metric
+#define svr4_ifr_data ifr_ifru.ifru_data
+#define svr4_ifr_enaddr ifr_ifru.ifru_enaddr
+#define svr4_ifr_muxid ifr_ifru.ifru_muxid
+
+};
+
+struct svr4_ifconf {
+ int svr4_ifc_len;
+ union {
+ caddr_t ifcu_buf;
+ struct svr4_ifreq *ifcu_req;
+ } ifc_ifcu;
+
+#define svr4_ifc_buf ifc_ifcu.ifcu_buf
+#define svr4_ifc_req ifc_ifcu.ifcu_req
+};
+
+#define SVR4_SIOC ('i' << 8)
+
+#define SVR4_SIOCGIFFLAGS SVR4_IOWR('i', 17, struct svr4_ifreq)
+#define SVR4_SIOCGIFCONF SVR4_IOWR('i', 20, struct svr4_ifconf)
+#define SVR4_SIOCGIFNUM SVR4_IOR('i', 87, int)
+
+#endif /* !_SVR4_SOCKIO_H_ */
diff --git a/sys/svr4/svr4_sockmod.h b/sys/svr4/svr4_sockmod.h
new file mode 100644
index 0000000..e0fe451
--- /dev/null
+++ b/sys/svr4/svr4_sockmod.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SOCKMOD_H_
+#define _SVR4_SOCKMOD_H_
+
+#define SVR4_SIMOD ('I' << 8)
+
+#define SVR4_SI_OGETUDATA (SVR4_SIMOD|101)
+#define SVR4_SI_SHUTDOWN (SVR4_SIMOD|102)
+#define SVR4_SI_LISTEN (SVR4_SIMOD|103)
+#define SVR4_SI_SETMYNAME (SVR4_SIMOD|104)
+#define SVR4_SI_SETPEERNAME (SVR4_SIMOD|105)
+#define SVR4_SI_GETINTRANSIT (SVR4_SIMOD|106)
+#define SVR4_SI_TCL_LINK (SVR4_SIMOD|107)
+#define SVR4_SI_TCL_UNLINK (SVR4_SIMOD|108)
+#define SVR4_SI_SOCKPARAMS (SVR4_SIMOD|109)
+#define SVR4_SI_GETUDATA (SVR4_SIMOD|110)
+
+
+#define SVR4_SOCK_DGRAM 1
+#define SVR4_SOCK_STREAM 2
+#define SVR4_SOCK_STREAM_ORD 3
+#define SVR4_SOCK_RAW 4
+#define SVR4_SOCK_RDM 5
+#define SVR4_SOCK_SEQPACKET 6
+
+struct svr4_si_sockparms {
+ int family;
+ int type;
+ int protocol;
+};
+
+struct svr4_si_oudata {
+ int tidusize;
+ int addrsize;
+ int optsize;
+ int etsdusize;
+ int servtype;
+ int so_state;
+ int so_options;
+ int tsdusize;
+};
+
+struct svr4_si_udata {
+ int tidusize;
+ int addrsize;
+ int optsize;
+ int etsdusize;
+ int servtype;
+ int so_state;
+ int so_options;
+ int tsdusize;
+ struct svr4_si_sockparms sockparms;
+};
+#endif /* !_SVR4_SOCKMOD_H_ */
diff --git a/sys/svr4/svr4_stat.c b/sys/svr4/svr4_stat.c
new file mode 100644
index 0000000..99448ba
--- /dev/null
+++ b/sys/svr4/svr4_stat.c
@@ -0,0 +1,803 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/kernel.h>
+#include <sys/mount.h>
+#include <sys/malloc.h>
+#include <sys/unistd.h>
+
+#include <sys/time.h>
+#include <sys/ucred.h>
+#include <vm/vm.h>
+#include <sys/sysctl.h>
+#include <netinet/in.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_stat.h>
+#include <svr4/svr4_ustat.h>
+#include <svr4/svr4_utsname.h>
+#include <svr4/svr4_systeminfo.h>
+#include <svr4/svr4_socket.h>
+#include <svr4/svr4_time.h>
+#if defined(NOTYET)
+#include "svr4_fuser.h"
+#endif
+
+#ifdef sparc
+/*
+ * Solaris-2.4 on the sparc has the old stat call using the new
+ * stat data structure...
+ */
+# define SVR4_NO_OSTAT
+#endif
+
+struct svr4_ustat_args {
+ svr4_dev_t dev;
+ struct svr4_ustat * name;
+};
+
+static void bsd_to_svr4_xstat __P((struct stat *, struct svr4_xstat *));
+static void bsd_to_svr4_stat64 __P((struct stat *, struct svr4_stat64 *));
+int svr4_ustat __P((struct proc *, struct svr4_ustat_args *));
+static int svr4_to_bsd_pathconf __P((int));
+
+/*
+ * SVR4 uses named pipes as named sockets, so we tell programs
+ * that sockets are named pipes with mode 0
+ */
+#define BSD_TO_SVR4_MODE(mode) (S_ISSOCK(mode) ? S_IFIFO : (mode))
+
+
+#ifndef SVR4_NO_OSTAT
+static void bsd_to_svr4_stat __P((struct stat *, struct svr4_stat *));
+
+static void
+bsd_to_svr4_stat(st, st4)
+ struct stat *st;
+ struct svr4_stat *st4;
+{
+ memset(st4, 0, sizeof(*st4));
+ st4->st_dev = bsd_to_svr4_odev_t(st->st_dev);
+ st4->st_ino = st->st_ino;
+ st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
+ st4->st_nlink = st->st_nlink;
+ st4->st_uid = st->st_uid;
+ st4->st_gid = st->st_gid;
+ st4->st_rdev = bsd_to_svr4_odev_t(st->st_rdev);
+ st4->st_size = st->st_size;
+ st4->st_atim = st->st_atimespec.tv_sec;
+ st4->st_mtim = st->st_mtimespec.tv_sec;
+ st4->st_ctim = st->st_ctimespec.tv_sec;
+}
+#endif
+
+
+static void
+bsd_to_svr4_xstat(st, st4)
+ struct stat *st;
+ struct svr4_xstat *st4;
+{
+ memset(st4, 0, sizeof(*st4));
+ st4->st_dev = bsd_to_svr4_dev_t(st->st_dev);
+ st4->st_ino = st->st_ino;
+ st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
+ st4->st_nlink = st->st_nlink;
+ st4->st_uid = st->st_uid;
+ st4->st_gid = st->st_gid;
+ st4->st_rdev = bsd_to_svr4_dev_t(st->st_rdev);
+ st4->st_size = st->st_size;
+ st4->st_atim = st->st_atimespec;
+ st4->st_mtim = st->st_mtimespec;
+ st4->st_ctim = st->st_ctimespec;
+ st4->st_blksize = st->st_blksize;
+ st4->st_blocks = st->st_blocks;
+ strcpy(st4->st_fstype, "unknown");
+}
+
+
+static void
+bsd_to_svr4_stat64(st, st4)
+ struct stat *st;
+ struct svr4_stat64 *st4;
+{
+ memset(st4, 0, sizeof(*st4));
+ st4->st_dev = bsd_to_svr4_dev_t(st->st_dev);
+ st4->st_ino = st->st_ino;
+ st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
+ st4->st_nlink = st->st_nlink;
+ st4->st_uid = st->st_uid;
+ st4->st_gid = st->st_gid;
+ st4->st_rdev = bsd_to_svr4_dev_t(st->st_rdev);
+ st4->st_size = st->st_size;
+ st4->st_atim = st->st_atimespec;
+ st4->st_mtim = st->st_mtimespec;
+ st4->st_ctim = st->st_ctimespec;
+ st4->st_blksize = st->st_blksize;
+ st4->st_blocks = st->st_blocks;
+ strcpy(st4->st_fstype, "unknown");
+}
+
+int
+svr4_sys_stat(p, uap)
+ struct proc *p;
+ struct svr4_sys_stat_args *uap;
+{
+ int *retval;
+#ifdef SVR4_NO_OSTAT
+ struct svr4_sys_xstat_args cup;
+
+ retval = &(p->p_retval[0]);
+ SCARG(&cup, two) = 2;
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = (struct svr4_xstat *) SCARG(uap, ub);
+ return svr4_sys_xstat(p, &cup, retval);
+#else
+ struct stat st;
+ struct svr4_stat svr4_st;
+ struct stat_args cup;
+ int error;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+
+ if ((error = stat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat(&st, &svr4_st);
+
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+#endif
+}
+
+
+int
+svr4_sys_lstat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_lstat_args *uap;
+{
+ int *retval;
+ struct stat st;
+ struct svr4_stat svr4_st;
+ struct lstat_args cup;
+ int error;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = lstat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat(&st, &svr4_st);
+
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_sys_fstat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_fstat_args *uap;
+{
+ struct stat st;
+ struct svr4_stat svr4_st;
+ struct fstat_args cup;
+ int error, *retval;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ SCARG(&cup, fd) = SCARG(uap, fd);
+ SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = fstat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat(&st, &svr4_st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_sys_xstat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_xstat_args *uap;
+{
+ struct stat st;
+ struct svr4_xstat svr4_st;
+ struct stat_args cup;
+ int error, *retval;
+
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ retval = p->p_retval;
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = stat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_xstat(&st, &svr4_st);
+
+#if defined(SOCKET_NOTYET)
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+#endif
+
+ if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+int
+svr4_sys_lxstat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_lxstat_args *uap;
+{
+ int *retval;
+ struct stat st;
+ struct svr4_xstat svr4_st;
+ struct lstat_args cup;
+ int error;
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ retval = p->p_retval;
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = lstat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_xstat(&st, &svr4_st);
+
+#if defined(SOCKET_NOTYET)
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+#endif
+ if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_sys_fxstat(p, uap)
+ register struct proc *p;
+ struct svr4_sys_fxstat_args *uap;
+{
+ int *retval;
+ struct stat st;
+ struct svr4_xstat svr4_st;
+ struct fstat_args cup;
+ int error;
+
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ SCARG(&cup, fd) = SCARG(uap, fd);
+ SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = fstat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_xstat(&st, &svr4_st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+int
+svr4_sys_stat64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_stat64_args *uap;
+{
+ struct stat st;
+ struct svr4_stat64 svr4_st;
+ struct stat_args cup;
+ int error, *retval;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = stat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat64(&st, &svr4_st);
+
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_sys_lstat64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_lstat64_args *uap;
+{
+ struct stat st;
+ struct svr4_stat64 svr4_st;
+ struct stat_args cup;
+ int error, *retval;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+
+ CHECKALTEXIST(p, &sg, (char *) SCARG(uap, path));
+
+ SCARG(&cup, path) = SCARG(uap, path);
+ SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = lstat(p, (struct lstat_args *)&cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat64(&st, &svr4_st);
+
+ if (S_ISSOCK(st.st_mode))
+ (void) svr4_add_socket(p, SCARG(uap, path), &st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_sys_fstat64(p, uap)
+ register struct proc *p;
+ struct svr4_sys_fstat64_args *uap;
+{
+ struct stat st;
+ struct svr4_stat64 svr4_st;
+ struct fstat_args cup;
+ int error, *retval;
+ caddr_t sg = stackgap_init();
+
+ retval = p->p_retval;
+
+ SCARG(&cup, fd) = SCARG(uap, fd);
+ SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = fstat(p, &cup)) != 0)
+ return error;
+
+ if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
+ return error;
+
+ bsd_to_svr4_stat64(&st, &svr4_st);
+
+ if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+int
+svr4_ustat(p, uap)
+ register struct proc *p;
+ struct svr4_ustat_args *uap;
+{
+ struct svr4_ustat us;
+ int error;
+
+ memset(&us, 0, sizeof us);
+
+ /*
+ * XXX: should set f_tfree and f_tinode at least
+ * How do we translate dev -> fstat? (and then to svr4_ustat)
+ */
+ if ((error = copyout(&us, SCARG(uap, name), sizeof us)) != 0)
+ return (error);
+
+ return 0;
+}
+
+/*extern char ostype[], hostname[], osrelease[], version[], machine[];*/
+
+int
+svr4_sys_uname(p, uap)
+ register struct proc *p;
+ struct svr4_sys_uname_args *uap;
+{
+ struct svr4_utsname sut;
+
+
+ memset(&sut, 0, sizeof(sut));
+
+ strncpy(sut.sysname, ostype, sizeof(sut.sysname));
+ sut.sysname[sizeof(sut.sysname) - 1] = '\0';
+
+ strncpy(sut.nodename, hostname, sizeof(sut.nodename));
+ sut.nodename[sizeof(sut.nodename) - 1] = '\0';
+
+ strncpy(sut.release, osrelease, sizeof(sut.release));
+ sut.release[sizeof(sut.release) - 1] = '\0';
+
+ strncpy(sut.version, version, sizeof(sut.version));
+ sut.version[sizeof(sut.version) - 1] = '\0';
+
+ strncpy(sut.machine, machine, sizeof(sut.machine));
+ sut.machine[sizeof(sut.machine) - 1] = '\0';
+
+ return copyout((caddr_t) &sut, (caddr_t) SCARG(uap, name),
+ sizeof(struct svr4_utsname));
+}
+
+int
+svr4_sys_systeminfo(p, uap)
+ struct proc *p;
+ struct svr4_sys_systeminfo_args *uap;
+{
+ char *str = NULL;
+ int error = 0, *retval = p->p_retval;
+ size_t len = 0;
+ char buf[1]; /* XXX NetBSD uses 256, but that seems like awfully
+ excessive kstack usage for an empty string... */
+ u_int rlen = SCARG(uap, len);
+
+ switch (SCARG(uap, what)) {
+ case SVR4_SI_SYSNAME:
+ str = ostype;
+ break;
+
+ case SVR4_SI_HOSTNAME:
+ str = hostname;
+ break;
+
+ case SVR4_SI_RELEASE:
+ str = osrelease;
+ break;
+
+ case SVR4_SI_VERSION:
+ str = version;
+ break;
+
+ case SVR4_SI_MACHINE:
+ str = machine;
+ break;
+
+ case SVR4_SI_ARCHITECTURE:
+ str = machine;
+ break;
+
+ case SVR4_SI_HW_SERIAL:
+ str = "0";
+ break;
+
+ case SVR4_SI_HW_PROVIDER:
+ str = ostype;
+ break;
+
+ case SVR4_SI_SRPC_DOMAIN:
+ str = domainname;
+ break;
+
+ case SVR4_SI_PLATFORM:
+#ifdef __i386__
+ str = "i86pc";
+#else
+ str = "unknown";
+#endif
+ break;
+
+ case SVR4_SI_KERB_REALM:
+ str = "unsupported";
+ break;
+#if defined(WHY_DOES_AN_EMULATOR_WANT_TO_SET_HOSTNAMES)
+ case SVR4_SI_SET_HOSTNAME:
+ if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
+ return error;
+ name = KERN_HOSTNAME;
+ return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p);
+
+ case SVR4_SI_SET_SRPC_DOMAIN:
+ if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
+ return error;
+ name = KERN_NISDOMAINNAME;
+ return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p);
+#else
+ case SVR4_SI_SET_HOSTNAME:
+ case SVR4_SI_SET_SRPC_DOMAIN:
+ /* FALLTHROUGH */
+#endif
+ case SVR4_SI_SET_KERB_REALM:
+ return 0;
+
+ default:
+ DPRINTF(("Bad systeminfo command %d\n", SCARG(uap, what)));
+ return ENOSYS;
+ }
+
+ if (str) {
+ len = strlen(str) + 1;
+ if (len > rlen)
+ len = rlen;
+
+ if (SCARG(uap, buf)) {
+ error = copyout(str, SCARG(uap, buf), len);
+ if (error)
+ return error;
+ /* make sure we are NULL terminated */
+ buf[0] = '\0';
+ error = copyout(buf, &(SCARG(uap, buf)[len - 1]), 1);
+ }
+ else
+ error = 0;
+ }
+ /* XXX NetBSD has hostname setting stuff here. Why would an emulator
+ want to do that? */
+
+ *retval = len;
+ return error;
+}
+
+int
+svr4_sys_utssys(p, uap)
+ register struct proc *p;
+ struct svr4_sys_utssys_args *uap;
+{
+ switch (SCARG(uap, sel)) {
+ case 0: /* uname(2) */
+ {
+ struct svr4_sys_uname_args ua;
+ SCARG(&ua, name) = SCARG(uap, a1);
+ return svr4_sys_uname(p, &ua);
+ }
+
+ case 2: /* ustat(2) */
+ {
+ struct svr4_ustat_args ua;
+ SCARG(&ua, dev) = (svr4_dev_t) SCARG(uap, a2);
+ SCARG(&ua, name) = SCARG(uap, a1);
+ return svr4_ustat(p, &ua);
+ }
+
+ case 3: /* fusers(2) */
+ return ENOSYS;
+
+ default:
+ return ENOSYS;
+ }
+ return ENOSYS;
+}
+
+
+int
+svr4_sys_utime(p, uap)
+ register struct proc *p;
+ struct svr4_sys_utime_args *uap;
+{
+ struct svr4_utimbuf ub;
+ struct timeval tbuf[2];
+ struct utimes_args ap;
+ int error;
+ caddr_t sg = stackgap_init();
+ void *ttp;
+
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+ SCARG(&ap, path) = SCARG(uap, path);
+ if (SCARG(uap, ubuf) != NULL) {
+ if ((error = copyin(SCARG(uap, ubuf), &ub, sizeof(ub))) != 0)
+ return error;
+ tbuf[0].tv_sec = ub.actime;
+ tbuf[0].tv_usec = 0;
+ tbuf[1].tv_sec = ub.modtime;
+ tbuf[1].tv_usec = 0;
+ ttp = stackgap_alloc(&sg, sizeof(tbuf));
+ error = copyout(tbuf, ttp, sizeof(tbuf));
+ if (error)
+ return error;
+ SCARG(&ap, tptr) = ttp;
+ }
+ else
+ SCARG(&ap, tptr) = NULL;
+ return utimes(p, &ap);
+}
+
+
+int
+svr4_sys_utimes(p, uap)
+ register struct proc *p;
+ struct svr4_sys_utimes_args *uap;
+{
+ caddr_t sg = stackgap_init();
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+ return utimes(p, (struct utimes_args *)uap);
+}
+
+static int
+svr4_to_bsd_pathconf(name)
+ int name;
+{
+ switch (name) {
+ case SVR4_PC_LINK_MAX:
+ return _PC_LINK_MAX;
+
+ case SVR4_PC_MAX_CANON:
+ return _PC_MAX_CANON;
+
+ case SVR4_PC_MAX_INPUT:
+ return _PC_MAX_INPUT;
+
+ case SVR4_PC_NAME_MAX:
+ return _PC_NAME_MAX;
+
+ case SVR4_PC_PATH_MAX:
+ return _PC_PATH_MAX;
+
+ case SVR4_PC_PIPE_BUF:
+ return _PC_PIPE_BUF;
+
+ case SVR4_PC_NO_TRUNC:
+ return _PC_NO_TRUNC;
+
+ case SVR4_PC_VDISABLE:
+ return _PC_VDISABLE;
+
+ case SVR4_PC_CHOWN_RESTRICTED:
+ return _PC_CHOWN_RESTRICTED;
+ case SVR4_PC_SYNC_IO:
+#if defined(_PC_SYNC_IO)
+ return _PC_SYNC_IO;
+#else
+ return 0;
+#endif
+ case SVR4_PC_ASYNC_IO:
+ case SVR4_PC_PRIO_IO:
+ /* Not supported */
+ return 0;
+
+ default:
+ /* Invalid */
+ return -1;
+ }
+}
+
+
+int
+svr4_sys_pathconf(p, uap)
+ register struct proc *p;
+ struct svr4_sys_pathconf_args *uap;
+{
+ caddr_t sg = stackgap_init();
+ int *retval = p->p_retval;
+
+ CHECKALTEXIST(p, &sg, SCARG(uap, path));
+
+ SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
+
+ switch (SCARG(uap, name)) {
+ case -1:
+ *retval = -1;
+ return EINVAL;
+ case 0:
+ *retval = 0;
+ return 0;
+ default:
+ return pathconf(p, (struct pathconf_args *)uap);
+ }
+}
+
+
+int
+svr4_sys_fpathconf(p, uap)
+ register struct proc *p;
+ struct svr4_sys_fpathconf_args *uap;
+{
+ int *retval = p->p_retval;
+
+ SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
+
+ switch (SCARG(uap, name)) {
+ case -1:
+ *retval = -1;
+ return EINVAL;
+ case 0:
+ *retval = 0;
+ return 0;
+ default:
+ return fpathconf(p, (struct fpathconf_args *)uap);
+ }
+}
diff --git a/sys/svr4/svr4_stat.h b/sys/svr4/svr4_stat.h
new file mode 100644
index 0000000..dea7d1f
--- /dev/null
+++ b/sys/svr4/svr4_stat.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_STAT_H_
+#define _SVR4_STAT_H_
+
+#include <svr4/svr4_types.h>
+#include <sys/stat.h>
+
+struct svr4_stat {
+ svr4_o_dev_t st_dev;
+ svr4_o_ino_t st_ino;
+ svr4_o_mode_t st_mode;
+ svr4_o_nlink_t st_nlink;
+ svr4_o_uid_t st_uid;
+ svr4_o_gid_t st_gid;
+ svr4_o_dev_t st_rdev;
+ svr4_off_t st_size;
+ svr4_time_t st_atim;
+ svr4_time_t st_mtim;
+ svr4_time_t st_ctim;
+};
+
+struct svr4_xstat {
+ svr4_dev_t st_dev;
+ long st_pad1[3];
+ svr4_ino_t st_ino;
+ svr4_mode_t st_mode;
+ svr4_nlink_t st_nlink;
+ svr4_uid_t st_uid;
+ svr4_gid_t st_gid;
+ svr4_dev_t st_rdev;
+ long st_pad2[2];
+ svr4_off_t st_size;
+ long st_pad3;
+ svr4_timestruc_t st_atim;
+ svr4_timestruc_t st_mtim;
+ svr4_timestruc_t st_ctim;
+ long st_blksize;
+ svr4_blkcnt_t st_blocks;
+ char st_fstype[16];
+ long st_pad4[8];
+};
+
+struct svr4_stat64 {
+ svr4_dev_t st_dev;
+ long st_pad1[3];
+ svr4_ino64_t st_ino;
+ svr4_mode_t st_mode;
+ svr4_nlink_t st_nlink;
+ svr4_uid_t st_uid;
+ svr4_gid_t st_gid;
+ svr4_dev_t st_rdev;
+ long st_pad2[2];
+ svr4_off64_t st_size;
+ svr4_timestruc_t st_atim;
+ svr4_timestruc_t st_mtim;
+ svr4_timestruc_t st_ctim;
+ long st_blksize;
+ svr4_blkcnt64_t st_blocks;
+ char st_fstype[16];
+ long st_pad4[8];
+};
+
+#define SVR4_PC_LINK_MAX 1
+#define SVR4_PC_MAX_CANON 2
+#define SVR4_PC_MAX_INPUT 3
+#define SVR4_PC_NAME_MAX 4
+#define SVR4_PC_PATH_MAX 5
+#define SVR4_PC_PIPE_BUF 6
+#define SVR4_PC_NO_TRUNC 7
+#define SVR4_PC_VDISABLE 8
+#define SVR4_PC_CHOWN_RESTRICTED 9
+#define SVR4_PC_ASYNC_IO 10
+#define SVR4_PC_PRIO_IO 11
+#define SVR4_PC_SYNC_IO 12
+
+#endif /* !_SVR4_STAT_H_ */
diff --git a/sys/svr4/svr4_statvfs.h b/sys/svr4/svr4_statvfs.h
new file mode 100644
index 0000000..30ae808
--- /dev/null
+++ b/sys/svr4/svr4_statvfs.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_STATVFS_H_
+#define _SVR4_STATVFS_H_
+
+typedef struct svr4_statvfs {
+ u_long f_bsize;
+ u_long f_frsize;
+ svr4_fsblkcnt_t f_blocks;
+ svr4_fsblkcnt_t f_bfree;
+ svr4_fsblkcnt_t f_bavail;
+ svr4_fsblkcnt_t f_files;
+ svr4_fsblkcnt_t f_ffree;
+ svr4_fsblkcnt_t f_favail;
+ u_long f_fsid;
+ char f_basetype[16];
+ u_long f_flag;
+ u_long f_namemax;
+ char f_fstr[32];
+ u_long f_filler[16];
+} svr4_statvfs_t;
+
+typedef struct svr4_statvfs64 {
+ u_long f_bsize;
+ u_long f_frsize;
+ svr4_fsblkcnt64_t f_blocks;
+ svr4_fsblkcnt64_t f_bfree;
+ svr4_fsblkcnt64_t f_bavail;
+ svr4_fsblkcnt64_t f_files;
+ svr4_fsblkcnt64_t f_ffree;
+ svr4_fsblkcnt64_t f_favail;
+ u_long f_fsid;
+ char f_basetype[16];
+ u_long f_flag;
+ u_long f_namemax;
+ char f_fstr[32];
+ u_long f_filler[16];
+} svr4_statvfs64_t;
+
+#define SVR4_ST_RDONLY 0x01
+#define SVR4_ST_NOSUID 0x02
+#define SVR4_ST_NOTRUNC 0x04
+
+#endif /* !_SVR4_STATVFS_H_ */
diff --git a/sys/svr4/svr4_stream.c b/sys/svr4/svr4_stream.c
new file mode 100644
index 0000000..a656d33
--- /dev/null
+++ b/sys/svr4/svr4_stream.c
@@ -0,0 +1,2264 @@
+/*
+ * Copyright (c) 1998 Mark Newton. All rights reserved.
+ * Copyright (c) 1994, 1996 Christos Zoulas. 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 Christos Zoulas.
+ * 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.
+ */
+
+/*
+ * Pretend that we have streams...
+ * Yes, this is gross.
+ *
+ * ToDo: The state machine for getmsg needs re-thinking
+ */
+
+#define COMPAT_43 1
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/malloc.h>
+#include <sys/tty.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/unistd.h>
+#include <sys/fcntl.h>
+#include <sys/filio.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/un.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/mount.h>
+#include <sys/mbuf.h>
+#include <sys/protosw.h>
+#include <sys/signal.h>
+#include <sys/signalvar.h>
+#include <sys/uio.h>
+#include <sys/ktrace.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/device.h>
+#include <sys/stat.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_timod.h>
+#include <svr4/svr4_sockmod.h>
+#include <svr4/svr4_ioctl.h>
+#include <svr4/svr4_socket.h>
+
+/* Utils */
+static int clean_pipe __P((struct proc *, const char *));
+static void getparm __P((struct file *, struct svr4_si_sockparms *));
+
+/* Address Conversions */
+static void sockaddr_to_netaddr_in __P((struct svr4_strmcmd *,
+ const struct sockaddr_in *));
+static void sockaddr_to_netaddr_un __P((struct svr4_strmcmd *,
+ const struct sockaddr_un *));
+static void netaddr_to_sockaddr_in __P((struct sockaddr_in *,
+ const struct svr4_strmcmd *));
+static void netaddr_to_sockaddr_un __P((struct sockaddr_un *,
+ const struct svr4_strmcmd *));
+
+/* stream ioctls */
+static int i_nread __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int i_fdinsert __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int i_str __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int i_setsig __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int i_getsig __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int _i_bind_rsvd __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+static int _i_rele_rsvd __P((struct file *, struct proc *, register_t *, int,
+ u_long, caddr_t));
+
+/* i_str sockmod calls */
+static int sockmod __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int si_listen __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int si_ogetudata __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int si_sockparams __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int si_shutdown __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int si_getudata __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+
+/* i_str timod calls */
+static int timod __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int ti_getinfo __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+static int ti_bind __P((struct file *, int, struct svr4_strioctl *,
+ struct proc *));
+
+/* infrastructure */
+static int svr4_sendit __P((struct proc *p, int s, struct msghdr *mp,
+ int flags));
+
+static int svr4_recvit __P((struct proc *p, int s, struct msghdr *mp,
+ caddr_t namelenp));
+
+/* <sigh> Ok, so we shouldn't use sendit() in uipc_syscalls.c because
+ * it isn't part of a "public" interface; We're supposed to use
+ * pru_sosend instead. Same goes for recvit()/pru_soreceive() for
+ * that matter. Solution: Suck sendit()/recvit() into here where we
+ * can do what we like.
+ *
+ * I hate code duplication.
+ *
+ * I will take out all the #ifdef COMPAT_OLDSOCK gumph, though.
+ */
+static int
+svr4_sendit(p, s, mp, flags)
+ register struct proc *p;
+ int s;
+ register struct msghdr *mp;
+ int flags;
+{
+ struct file *fp;
+ struct uio auio;
+ register struct iovec *iov;
+ register int i;
+ struct mbuf *control;
+ struct sockaddr *to;
+ int len, error;
+ struct socket *so;
+#ifdef KTRACE
+ struct iovec *ktriov = NULL;
+#endif
+
+ error = getsock(p->p_fd, s, &fp);
+ if (error)
+ return (error);
+ auio.uio_iov = mp->msg_iov;
+ auio.uio_iovcnt = mp->msg_iovlen;
+ auio.uio_segflg = UIO_USERSPACE;
+ auio.uio_rw = UIO_WRITE;
+ auio.uio_procp = p;
+ auio.uio_offset = 0; /* XXX */
+ auio.uio_resid = 0;
+ iov = mp->msg_iov;
+ for (i = 0; i < mp->msg_iovlen; i++, iov++) {
+ if ((auio.uio_resid += iov->iov_len) < 0)
+ return (EINVAL);
+ }
+ if (mp->msg_name) {
+ error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
+ if (error)
+ return (error);
+ } else
+ to = 0;
+ if (mp->msg_control) {
+ if (mp->msg_controllen < sizeof(struct cmsghdr)) {
+ error = EINVAL;
+ goto bad;
+ }
+ error = sockargs(&control, mp->msg_control,
+ mp->msg_controllen, MT_CONTROL);
+ if (error)
+ goto bad;
+ } else
+ control = 0;
+#ifdef KTRACE
+ if (KTRPOINT(p, KTR_GENIO)) {
+ int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
+
+ MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
+ bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
+ }
+#endif
+ len = auio.uio_resid;
+ so = (struct socket *)fp->f_data;
+ error = so->so_proto->pr_usrreqs->pru_sosend(so, to, &auio, 0, control,
+ flags, p);
+ if (error) {
+ if (auio.uio_resid != len && (error == ERESTART ||
+ error == EINTR || error == EWOULDBLOCK))
+ error = 0;
+ if (error == EPIPE)
+ psignal(p, SIGPIPE);
+ }
+ if (error == 0)
+ p->p_retval[0] = len - auio.uio_resid;
+#ifdef KTRACE
+ if (ktriov != NULL) {
+ if (error == 0)
+ ktrgenio(p->p_tracep, s, UIO_WRITE,
+ ktriov, p->p_retval[0], error);
+ FREE(ktriov, M_TEMP);
+ }
+#endif
+bad:
+ if (to)
+ FREE(to, M_SONAME);
+ return (error);
+}
+
+static int
+svr4_recvit(p, s, mp, namelenp)
+ register struct proc *p;
+ int s;
+ register struct msghdr *mp;
+ caddr_t namelenp;
+{
+ struct file *fp;
+ struct uio auio;
+ register struct iovec *iov;
+ register int i;
+ int len, error;
+ struct mbuf *m, *control = 0;
+ caddr_t ctlbuf;
+ struct socket *so;
+ struct sockaddr *fromsa = 0;
+#ifdef KTRACE
+ struct iovec *ktriov = NULL;
+#endif
+
+ error = getsock(p->p_fd, s, &fp);
+ if (error)
+ return (error);
+ auio.uio_iov = mp->msg_iov;
+ auio.uio_iovcnt = mp->msg_iovlen;
+ auio.uio_segflg = UIO_USERSPACE;
+ auio.uio_rw = UIO_READ;
+ auio.uio_procp = p;
+ auio.uio_offset = 0; /* XXX */
+ auio.uio_resid = 0;
+ iov = mp->msg_iov;
+ for (i = 0; i < mp->msg_iovlen; i++, iov++) {
+ if ((auio.uio_resid += iov->iov_len) < 0)
+ return (EINVAL);
+ }
+#ifdef KTRACE
+ if (KTRPOINT(p, KTR_GENIO)) {
+ int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
+
+ MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
+ bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
+ }
+#endif
+ len = auio.uio_resid;
+ so = (struct socket *)fp->f_data;
+ error = so->so_proto->pr_usrreqs->pru_soreceive(so, &fromsa, &auio,
+ (struct mbuf **)0, mp->msg_control ? &control : (struct mbuf **)0,
+ &mp->msg_flags);
+ if (error) {
+ if (auio.uio_resid != len && (error == ERESTART ||
+ error == EINTR || error == EWOULDBLOCK))
+ error = 0;
+ }
+#ifdef KTRACE
+ if (ktriov != NULL) {
+ if (error == 0)
+ ktrgenio(p->p_tracep, s, UIO_READ,
+ ktriov, len - auio.uio_resid, error);
+ FREE(ktriov, M_TEMP);
+ }
+#endif
+ if (error)
+ goto out;
+ p->p_retval[0] = len - auio.uio_resid;
+ if (mp->msg_name) {
+ len = mp->msg_namelen;
+ if (len <= 0 || fromsa == 0)
+ len = 0;
+ else {
+#ifndef MIN
+#define MIN(a,b) ((a)>(b)?(b):(a))
+#endif
+ /* save sa_len before it is destroyed by MSG_COMPAT */
+ len = MIN(len, fromsa->sa_len);
+ error = copyout(fromsa,
+ (caddr_t)mp->msg_name, (unsigned)len);
+ if (error)
+ goto out;
+ }
+ mp->msg_namelen = len;
+ if (namelenp &&
+ (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) {
+ goto out;
+ }
+ }
+ if (mp->msg_control) {
+ len = mp->msg_controllen;
+ m = control;
+ mp->msg_controllen = 0;
+ ctlbuf = (caddr_t) mp->msg_control;
+
+ while (m && len > 0) {
+ unsigned int tocopy;
+
+ if (len >= m->m_len)
+ tocopy = m->m_len;
+ else {
+ mp->msg_flags |= MSG_CTRUNC;
+ tocopy = len;
+ }
+
+ if (error = copyout((caddr_t)mtod(m, caddr_t),
+ ctlbuf, tocopy))
+ goto out;
+
+ ctlbuf += tocopy;
+ len -= tocopy;
+ m = m->m_next;
+ }
+ mp->msg_controllen = ctlbuf - mp->msg_control;
+ }
+out:
+ if (fromsa)
+ FREE(fromsa, M_SONAME);
+ if (control)
+ m_freem(control);
+ return (error);
+}
+
+#ifdef DEBUG_SVR4
+static void bufprint __P((u_char *, size_t));
+static int show_ioc __P((const char *, struct svr4_strioctl *));
+static int show_strbuf __P((struct svr4_strbuf *));
+static void show_msg __P((const char *, int, struct svr4_strbuf *,
+ struct svr4_strbuf *, int));
+
+static void
+bufprint(buf, len)
+ u_char *buf;
+ size_t len;
+{
+ size_t i;
+
+ uprintf("\n\t");
+ for (i = 0; i < len; i++) {
+ uprintf("%x ", buf[i]);
+ if (i && (i % 16) == 0)
+ uprintf("\n\t");
+ }
+}
+
+static int
+show_ioc(str, ioc)
+ const char *str;
+ struct svr4_strioctl *ioc;
+{
+ u_char *ptr = (u_char *) malloc(ioc->len, M_TEMP, M_WAITOK);
+ int error;
+
+ uprintf("%s cmd = %ld, timeout = %d, len = %d, buf = %p { ",
+ str, ioc->cmd, ioc->timeout, ioc->len, ioc->buf);
+
+ if ((error = copyin(ioc->buf, ptr, ioc->len)) != 0) {
+ free((char *) ptr, M_TEMP);
+ return error;
+ }
+
+ bufprint(ptr, ioc->len);
+
+ uprintf("}\n");
+
+ free((char *) ptr, M_TEMP);
+ return 0;
+}
+
+
+static int
+show_strbuf(str)
+ struct svr4_strbuf *str;
+{
+ int error;
+ u_char *ptr = NULL;
+ int maxlen = str->maxlen;
+ int len = str->len;
+
+ if (maxlen < 0)
+ maxlen = 0;
+
+ if (len >= maxlen)
+ len = maxlen;
+
+ if (len > 0) {
+ ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK);
+
+ if ((error = copyin(str->buf, ptr, len)) != 0) {
+ free((char *) ptr, M_TEMP);
+ return error;
+ }
+ }
+
+ uprintf(", { %d, %d, %p=[ ", str->maxlen, str->len, str->buf);
+
+ if (ptr)
+ bufprint(ptr, len);
+
+ uprintf("]}");
+
+ if (ptr)
+ free((char *) ptr, M_TEMP);
+
+ return 0;
+}
+
+
+static void
+show_msg(str, fd, ctl, dat, flags)
+ const char *str;
+ int fd;
+ struct svr4_strbuf *ctl;
+ struct svr4_strbuf *dat;
+ int flags;
+{
+ struct svr4_strbuf buf;
+ int error;
+
+ uprintf("%s(%d", str, fd);
+ if (ctl != NULL) {
+ if ((error = copyin(ctl, &buf, sizeof(buf))) != 0)
+ return;
+ show_strbuf(&buf);
+ }
+ else
+ uprintf(", NULL");
+
+ if (dat != NULL) {
+ if ((error = copyin(dat, &buf, sizeof(buf))) != 0)
+ return;
+ show_strbuf(&buf);
+ }
+ else
+ uprintf(", NULL");
+
+ uprintf(", %x);\n", flags);
+}
+
+#endif /* DEBUG_SVR4 */
+
+/*
+ * We are faced with an interesting situation. On svr4 unix sockets
+ * are really pipes. But we really have sockets, and we might as
+ * well use them. At the point where svr4 calls TI_BIND, it has
+ * already created a named pipe for the socket using mknod(2).
+ * We need to create a socket with the same name when we bind,
+ * so we need to remove the pipe before, otherwise we'll get address
+ * already in use. So we *carefully* remove the pipe, to avoid
+ * using this as a random file removal tool. We use system calls
+ * to avoid code duplication.
+ */
+static int
+clean_pipe(p, path)
+ struct proc *p;
+ const char *path;
+{
+ struct lstat_args la;
+ struct unlink_args ua;
+ struct stat st;
+ int error;
+ caddr_t sg = stackgap_init();
+ size_t l = strlen(path) + 1;
+ void *tpath;
+
+ tpath = stackgap_alloc(&sg, l);
+ SCARG(&la, ub) = stackgap_alloc(&sg, sizeof(struct stat));
+
+ if ((error = copyout(path, tpath, l)) != 0)
+ return error;
+
+ SCARG(&la, path) = tpath;
+
+ if ((error = lstat(p, &la)) != 0)
+ return 0;
+
+ if ((error = copyin(SCARG(&la, ub), &st, sizeof(st))) != 0)
+ return 0;
+
+ /*
+ * Make sure we are dealing with a mode 0 named pipe.
+ */
+ if ((st.st_mode & S_IFMT) != S_IFIFO)
+ return 0;
+
+ if ((st.st_mode & ALLPERMS) != 0)
+ return 0;
+
+ SCARG(&ua, path) = SCARG(&la, path);
+
+ if ((error = unlink(p, &ua)) != 0) {
+ DPRINTF(("clean_pipe: unlink failed %d\n", error));
+ return error;
+ }
+
+ return 0;
+}
+
+
+static void
+sockaddr_to_netaddr_in(sc, sain)
+ struct svr4_strmcmd *sc;
+ const struct sockaddr_in *sain;
+{
+ struct svr4_netaddr_in *na;
+ na = SVR4_ADDROF(sc);
+
+ na->family = sain->sin_family;
+ na->port = sain->sin_port;
+ na->addr = sain->sin_addr.s_addr;
+ DPRINTF(("sockaddr_in -> netaddr %d %d %lx\n", na->family, na->port,
+ na->addr));
+}
+
+
+static void
+sockaddr_to_netaddr_un(sc, saun)
+ struct svr4_strmcmd *sc;
+ const struct sockaddr_un *saun;
+{
+ struct svr4_netaddr_un *na;
+ char *dst, *edst = ((char *) sc) + sc->offs + sizeof(na->family) + 1 -
+ sizeof(*sc);
+ const char *src;
+
+ na = SVR4_ADDROF(sc);
+ na->family = saun->sun_family;
+ for (src = saun->sun_path, dst = na->path; (*dst++ = *src++) != '\0'; )
+ if (dst == edst)
+ break;
+ DPRINTF(("sockaddr_un -> netaddr %d %s\n", na->family, na->path));
+}
+
+
+static void
+netaddr_to_sockaddr_in(sain, sc)
+ struct sockaddr_in *sain;
+ const struct svr4_strmcmd *sc;
+{
+ const struct svr4_netaddr_in *na;
+
+
+ na = SVR4_C_ADDROF(sc);
+ memset(sain, 0, sizeof(*sain));
+ sain->sin_len = sizeof(*sain);
+ sain->sin_family = na->family;
+ sain->sin_port = na->port;
+ sain->sin_addr.s_addr = na->addr;
+ DPRINTF(("netaddr -> sockaddr_in %d %d %x\n", sain->sin_family,
+ sain->sin_port, sain->sin_addr.s_addr));
+}
+
+
+static void
+netaddr_to_sockaddr_un(saun, sc)
+ struct sockaddr_un *saun;
+ const struct svr4_strmcmd *sc;
+{
+ const struct svr4_netaddr_un *na;
+ char *dst, *edst = &saun->sun_path[sizeof(saun->sun_path) - 1];
+ const char *src;
+
+ na = SVR4_C_ADDROF(sc);
+ memset(saun, 0, sizeof(*saun));
+ saun->sun_family = na->family;
+ for (src = na->path, dst = saun->sun_path; (*dst++ = *src++) != '\0'; )
+ if (dst == edst)
+ break;
+ saun->sun_len = dst - saun->sun_path;
+ DPRINTF(("netaddr -> sockaddr_un %d %s\n", saun->sun_family,
+ saun->sun_path));
+}
+
+
+static void
+getparm(fp, pa)
+ struct file *fp;
+ struct svr4_si_sockparms *pa;
+{
+ struct svr4_strm *st = svr4_stream_get(fp);
+ struct socket *so = (struct socket *) fp->f_data;
+
+ if (st == NULL)
+ return;
+
+ pa->family = st->s_family;
+
+ switch (so->so_type) {
+ case SOCK_DGRAM:
+ pa->type = SVR4_T_CLTS;
+ pa->protocol = IPPROTO_UDP;
+ DPRINTF(("getparm(dgram)\n"));
+ return;
+
+ case SOCK_STREAM:
+ pa->type = SVR4_T_COTS; /* What about T_COTS_ORD? XXX */
+ pa->protocol = IPPROTO_IP;
+ DPRINTF(("getparm(stream)\n"));
+ return;
+
+ case SOCK_RAW:
+ pa->type = SVR4_T_CLTS;
+ pa->protocol = IPPROTO_RAW;
+ DPRINTF(("getparm(raw)\n"));
+ return;
+
+ default:
+ pa->type = 0;
+ pa->protocol = 0;
+ DPRINTF(("getparm(type %d?)\n", so->so_type));
+ return;
+ }
+}
+
+
+static int
+si_ogetudata(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct svr4_si_oudata ud;
+ struct svr4_si_sockparms pa;
+
+ if (ioc->len != sizeof(ud) && ioc->len != sizeof(ud) - sizeof(int)) {
+ DPRINTF(("SI_OGETUDATA: Wrong size %d != %d\n",
+ sizeof(ud), ioc->len));
+ return EINVAL;
+ }
+
+ if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
+ return error;
+
+ getparm(fp, &pa);
+
+ switch (pa.family) {
+ case AF_INET:
+ ud.tidusize = 16384;
+ ud.addrsize = sizeof(struct svr4_sockaddr_in);
+ if (pa.type == SVR4_SOCK_STREAM)
+ ud.etsdusize = 1;
+ else
+ ud.etsdusize = 0;
+ break;
+
+ case AF_LOCAL:
+ ud.tidusize = 65536;
+ ud.addrsize = 128;
+ ud.etsdusize = 128;
+ break;
+
+ default:
+ DPRINTF(("SI_OGETUDATA: Unsupported address family %d\n",
+ pa.family));
+ return ENOSYS;
+ }
+
+ /* I have no idea what these should be! */
+ ud.optsize = 128;
+ ud.tsdusize = 128;
+
+ ud.servtype = pa.type;
+
+ /* XXX: Fixme */
+ ud.so_state = 0;
+ ud.so_options = 0;
+ return copyout(&ud, ioc->buf, ioc->len);
+}
+
+
+static int
+si_sockparams(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ struct svr4_si_sockparms pa;
+
+ getparm(fp, &pa);
+ return copyout(&pa, ioc->buf, sizeof(pa));
+}
+
+
+static int
+si_listen(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct svr4_strm *st = svr4_stream_get(fp);
+ struct svr4_strmcmd lst;
+ struct listen_args la;
+
+ if (st == NULL)
+ return EINVAL;
+
+ if ((error = copyin(ioc->buf, &lst, ioc->len)) != 0)
+ return error;
+
+ if (lst.cmd != SVR4_TI_OLD_BIND_REQUEST) {
+ DPRINTF(("si_listen: bad request %ld\n", lst.cmd));
+ return EINVAL;
+ }
+
+ /*
+ * We are making assumptions again...
+ */
+ SCARG(&la, s) = fd;
+ DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5));
+ SCARG(&la, backlog) = 5;
+
+ if ((error = listen(p, &la)) != 0) {
+ DPRINTF(("SI_LISTEN: listen failed %d\n", error));
+ return error;
+ }
+
+ st->s_cmd = SVR4_TI__ACCEPT_WAIT;
+ lst.cmd = SVR4_TI_BIND_REPLY;
+
+ switch (st->s_family) {
+ case AF_INET:
+ /* XXX: Fill the length here */
+ break;
+
+ case AF_LOCAL:
+ lst.len = 140;
+ lst.pad[28] = 0x00000000; /* magic again */
+ lst.pad[29] = 0x00000800; /* magic again */
+ lst.pad[30] = 0x80001400; /* magic again */
+ break;
+
+ default:
+ DPRINTF(("SI_LISTEN: Unsupported address family %d\n",
+ st->s_family));
+ return ENOSYS;
+ }
+
+
+ if ((error = copyout(&lst, ioc->buf, ioc->len)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+static int
+si_getudata(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct svr4_si_udata ud;
+
+ if (sizeof(ud) != ioc->len) {
+ DPRINTF(("SI_GETUDATA: Wrong size %d != %d\n",
+ sizeof(ud), ioc->len));
+ return EINVAL;
+ }
+
+ if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0)
+ return error;
+
+ getparm(fp, &ud.sockparms);
+
+ switch (ud.sockparms.family) {
+ case AF_INET:
+ DPRINTF(("getudata_inet\n"));
+ ud.tidusize = 16384;
+ ud.tsdusize = 16384;
+ ud.addrsize = sizeof(struct svr4_sockaddr_in);
+ if (ud.sockparms.type == SVR4_SOCK_STREAM)
+ ud.etsdusize = 1;
+ else
+ ud.etsdusize = 0;
+ ud.optsize = 0;
+ break;
+
+ case AF_LOCAL:
+ DPRINTF(("getudata_local\n"));
+ ud.tidusize = 65536;
+ ud.tsdusize = 128;
+ ud.addrsize = 128;
+ ud.etsdusize = 128;
+ ud.optsize = 128;
+ break;
+
+ default:
+ DPRINTF(("SI_GETUDATA: Unsupported address family %d\n",
+ ud.sockparms.family));
+ return ENOSYS;
+ }
+
+
+ ud.servtype = ud.sockparms.type;
+ DPRINTF(("ud.servtype = %d\n", ud.servtype));
+ /* XXX: Fixme */
+ ud.so_state = 0;
+ ud.so_options = 0;
+ return copyout(&ud, ioc->buf, sizeof(ud));
+}
+
+
+static int
+si_shutdown(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct shutdown_args ap;
+
+ if (ioc->len != sizeof(SCARG(&ap, how))) {
+ DPRINTF(("SI_SHUTDOWN: Wrong size %d != %d\n",
+ sizeof(SCARG(&ap, how)), ioc->len));
+ return EINVAL;
+ }
+
+ if ((error = copyin(ioc->buf, &SCARG(&ap, how), ioc->len)) != 0)
+ return error;
+
+ SCARG(&ap, s) = fd;
+
+ return shutdown(p, &ap);
+}
+
+
+static int
+sockmod(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ switch (ioc->cmd) {
+ case SVR4_SI_OGETUDATA:
+ DPRINTF(("SI_OGETUDATA\n"));
+ return si_ogetudata(fp, fd, ioc, p);
+
+ case SVR4_SI_SHUTDOWN:
+ DPRINTF(("SI_SHUTDOWN\n"));
+ return si_shutdown(fp, fd, ioc, p);
+
+ case SVR4_SI_LISTEN:
+ DPRINTF(("SI_LISTEN\n"));
+ return si_listen(fp, fd, ioc, p);
+
+ case SVR4_SI_SETMYNAME:
+ DPRINTF(("SI_SETMYNAME\n"));
+ return 0;
+
+ case SVR4_SI_SETPEERNAME:
+ DPRINTF(("SI_SETPEERNAME\n"));
+ return 0;
+
+ case SVR4_SI_GETINTRANSIT:
+ DPRINTF(("SI_GETINTRANSIT\n"));
+ return 0;
+
+ case SVR4_SI_TCL_LINK:
+ DPRINTF(("SI_TCL_LINK\n"));
+ return 0;
+
+ case SVR4_SI_TCL_UNLINK:
+ DPRINTF(("SI_TCL_UNLINK\n"));
+ return 0;
+
+ case SVR4_SI_SOCKPARAMS:
+ DPRINTF(("SI_SOCKPARAMS\n"));
+ return si_sockparams(fp, fd, ioc, p);
+
+ case SVR4_SI_GETUDATA:
+ DPRINTF(("SI_GETUDATA\n"));
+ return si_getudata(fp, fd, ioc, p);
+
+ default:
+ DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd));
+ return 0;
+
+ }
+}
+
+
+static int
+ti_getinfo(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct svr4_infocmd info;
+
+ memset(&info, 0, sizeof(info));
+
+ if ((error = copyin(ioc->buf, &info, ioc->len)) != 0)
+ return error;
+
+ if (info.cmd != SVR4_TI_INFO_REQUEST)
+ return EINVAL;
+
+ info.cmd = SVR4_TI_INFO_REPLY;
+ info.tsdu = 0;
+ info.etsdu = 1;
+ info.cdata = -2;
+ info.ddata = -2;
+ info.addr = 16;
+ info.opt = -1;
+ info.tidu = 16384;
+ info.serv = 2;
+ info.current = 0;
+ info.provider = 2;
+
+ ioc->len = sizeof(info);
+ if ((error = copyout(&info, ioc->buf, ioc->len)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+static int
+ti_bind(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ int error;
+ struct svr4_strm *st = svr4_stream_get(fp);
+ struct sockaddr_in sain;
+ struct sockaddr_un saun;
+ caddr_t sg;
+ void *skp, *sup = NULL;
+ int sasize;
+ struct svr4_strmcmd bnd;
+ struct bind_args ba;
+
+ if (st == NULL) {
+ DPRINTF(("ti_bind: bad file descriptor\n"));
+ return EINVAL;
+ }
+
+ if ((error = copyin(ioc->buf, &bnd, ioc->len)) != 0)
+ return error;
+
+ if (bnd.cmd != SVR4_TI_OLD_BIND_REQUEST) {
+ DPRINTF(("ti_bind: bad request %ld\n", bnd.cmd));
+ return EINVAL;
+ }
+
+ switch (st->s_family) {
+ case AF_INET:
+ skp = &sain;
+ sasize = sizeof(sain);
+
+ if (bnd.offs == 0)
+ goto reply;
+
+ netaddr_to_sockaddr_in(&sain, &bnd);
+
+ DPRINTF(("TI_BIND: fam %d, port %d, addr %x\n",
+ sain.sin_family, sain.sin_port,
+ sain.sin_addr.s_addr));
+ break;
+
+ case AF_LOCAL:
+ skp = &saun;
+ sasize = sizeof(saun);
+ if (bnd.offs == 0)
+ goto reply;
+
+ netaddr_to_sockaddr_un(&saun, &bnd);
+
+ if (saun.sun_path[0] == '\0')
+ goto reply;
+
+ DPRINTF(("TI_BIND: fam %d, path %s\n",
+ saun.sun_family, saun.sun_path));
+
+ if ((error = clean_pipe(p, saun.sun_path)) != 0)
+ return error;
+
+ bnd.pad[28] = 0x00001000; /* magic again */
+ break;
+
+ default:
+ DPRINTF(("TI_BIND: Unsupported address family %d\n",
+ st->s_family));
+ return ENOSYS;
+ }
+
+ sg = stackgap_init();
+ sup = stackgap_alloc(&sg, sasize);
+
+ if ((error = copyout(skp, sup, sasize)) != 0)
+ return error;
+
+ SCARG(&ba, s) = fd;
+ DPRINTF(("TI_BIND: fileno %d\n", fd));
+ SCARG(&ba, name) = (void *) sup;
+ SCARG(&ba, namelen) = sasize;
+
+ if ((error = bind(p, &ba)) != 0) {
+ DPRINTF(("TI_BIND: bind failed %d\n", error));
+ return error;
+ }
+
+reply:
+ if (sup == NULL) {
+ memset(&bnd, 0, sizeof(bnd));
+ bnd.len = sasize + 4;
+ bnd.offs = 0x10; /* XXX */
+ }
+
+ bnd.cmd = SVR4_TI_BIND_REPLY;
+
+ if ((error = copyout(&bnd, ioc->buf, ioc->len)) != 0)
+ return error;
+
+ return 0;
+}
+
+
+static int
+timod(fp, fd, ioc, p)
+ struct file *fp;
+ int fd;
+ struct svr4_strioctl *ioc;
+ struct proc *p;
+{
+ switch (ioc->cmd) {
+ case SVR4_TI_GETINFO:
+ DPRINTF(("TI_GETINFO\n"));
+ return ti_getinfo(fp, fd, ioc, p);
+
+ case SVR4_TI_OPTMGMT:
+ DPRINTF(("TI_OPTMGMT\n"));
+ return 0;
+
+ case SVR4_TI_BIND:
+ DPRINTF(("TI_BIND\n"));
+ return ti_bind(fp, fd, ioc, p);
+
+ case SVR4_TI_UNBIND:
+ DPRINTF(("TI_UNBIND\n"));
+ return 0;
+
+ default:
+ DPRINTF(("Unknown timod ioctl %lx\n", ioc->cmd));
+ return 0;
+ }
+}
+
+
+int
+svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ struct svr4_strbuf skb, *sub = (struct svr4_strbuf *) dat;
+ struct svr4_strm *st = svr4_stream_get(fp);
+ int error;
+ void *skp, *sup;
+ struct sockaddr_in sain;
+ struct sockaddr_un saun;
+ struct svr4_strmcmd sc;
+ int sasize;
+ caddr_t sg;
+ int *lenp;
+
+ DPRINTF(("svr4_stream_ti_ioctl\n"));
+
+ if (st == NULL)
+ return EINVAL;
+
+ sc.offs = 0x10;
+
+ if ((error = copyin(sub, &skb, sizeof(skb))) != 0) {
+ DPRINTF(("ti_ioctl: error copying in strbuf\n"));
+ return error;
+ }
+
+ switch (st->s_family) {
+ case AF_INET:
+ skp = &sain;
+ sasize = sizeof(sain);
+ break;
+
+ case AF_LOCAL:
+ skp = &saun;
+ sasize = sizeof(saun);
+ break;
+
+ default:
+ DPRINTF(("ti_ioctl: Unsupported address family %d\n",
+ st->s_family));
+ return ENOSYS;
+ }
+
+ sg = stackgap_init();
+ sup = stackgap_alloc(&sg, sasize);
+ lenp = stackgap_alloc(&sg, sizeof(*lenp));
+
+ if ((error = copyout(&sasize, lenp, sizeof(*lenp))) != 0) {
+ DPRINTF(("ti_ioctl: error copying out lenp\n"));
+ return error;
+ }
+
+ switch (cmd) {
+ case SVR4_TI_GETMYNAME:
+ DPRINTF(("TI_GETMYNAME\n"));
+ {
+ struct getsockname_args ap;
+ SCARG(&ap, fdes) = fd;
+ SCARG(&ap, asa) = sup;
+ SCARG(&ap, alen) = lenp;
+ if ((error = getsockname(p, &ap)) != 0) {
+ DPRINTF(("ti_ioctl: getsockname error\n"));
+ return error;
+ }
+ }
+ break;
+
+ case SVR4_TI_GETPEERNAME:
+ DPRINTF(("TI_GETPEERNAME\n"));
+ {
+ struct getpeername_args ap;
+ SCARG(&ap, fdes) = fd;
+ SCARG(&ap, asa) = sup;
+ SCARG(&ap, alen) = lenp;
+ if ((error = getpeername(p, &ap)) != 0) {
+ DPRINTF(("ti_ioctl: getpeername error\n"));
+ return error;
+ }
+ }
+ break;
+
+ case SVR4_TI_SETMYNAME:
+ DPRINTF(("TI_SETMYNAME\n"));
+ return 0;
+
+ case SVR4_TI_SETPEERNAME:
+ DPRINTF(("TI_SETPEERNAME\n"));
+ return 0;
+ default:
+ DPRINTF(("ti_ioctl: Unknown ioctl %lx\n", cmd));
+ return ENOSYS;
+ }
+
+ if ((error = copyin(sup, skp, sasize)) != 0) {
+ DPRINTF(("ti_ioctl: error copying in socket data\n"));
+ return error;
+ }
+
+ if ((error = copyin(lenp, &sasize, sizeof(*lenp))) != 0) {
+ DPRINTF(("ti_ioctl: error copying in socket size\n"));
+ return error;
+ }
+
+ switch (st->s_family) {
+ case AF_INET:
+ sockaddr_to_netaddr_in(&sc, &sain);
+ skb.len = sasize;
+ break;
+
+ case AF_LOCAL:
+ sockaddr_to_netaddr_un(&sc, &saun);
+ skb.len = sasize + 4;
+ break;
+
+ default:
+ return ENOSYS;
+ }
+
+
+ if ((error = copyout(SVR4_ADDROF(&sc), skb.buf, sasize)) != 0) {
+ DPRINTF(("ti_ioctl: error copying out socket data\n"));
+ return error;
+ }
+
+
+ if ((error = copyout(&skb, sub, sizeof(skb))) != 0) {
+ DPRINTF(("ti_ioctl: error copying out strbuf\n"));
+ return error;
+ }
+
+ return error;
+}
+
+
+
+
+static int
+i_nread(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ int error;
+ int nread = 0;
+
+ /*
+ * We are supposed to return the message length in nread, and the
+ * number of messages in retval. We don't have the notion of number
+ * of stream messages, so we just find out if we have any bytes waiting
+ * for us, and if we do, then we assume that we have at least one
+ * message waiting for us.
+ */
+ if ((error = (*fp->f_ops->fo_ioctl)(fp, FIONREAD,
+ (caddr_t) &nread, p)) != 0)
+ return error;
+
+ if (nread != 0)
+ *retval = 1;
+ else
+ *retval = 0;
+
+ return copyout(&nread, dat, sizeof(nread));
+}
+
+static int
+i_fdinsert(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ /*
+ * Major hack again here. We assume that we are using this to
+ * implement accept(2). If that is the case, we have already
+ * called accept, and we have stored the file descriptor in
+ * afd. We find the file descriptor that the code wants to use
+ * in fd insert, and then we dup2() our accepted file descriptor
+ * to it.
+ */
+ int error;
+ struct svr4_strm *st = svr4_stream_get(fp);
+ struct svr4_strfdinsert fdi;
+ struct dup2_args d2p;
+ struct close_args clp;
+
+ if (st == NULL) {
+ DPRINTF(("fdinsert: bad file type\n"));
+ return EINVAL;
+ }
+
+ if (st->s_afd == -1) {
+ DPRINTF(("fdinsert: accept fd not found\n"));
+ return ENOENT;
+ }
+
+ if ((error = copyin(dat, &fdi, sizeof(fdi))) != 0) {
+ DPRINTF(("fdinsert: copyin failed %d\n", error));
+ return error;
+ }
+
+ SCARG(&d2p, from) = st->s_afd;
+ SCARG(&d2p, to) = fdi.fd;
+
+ if ((error = dup2(p, &d2p)) != 0) {
+ DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n",
+ st->s_afd, fdi.fd, error));
+ return error;
+ }
+
+ SCARG(&clp, fd) = st->s_afd;
+
+ if ((error = close(p, &clp)) != 0) {
+ DPRINTF(("fdinsert: close(%d) failed %d\n",
+ st->s_afd, error));
+ return error;
+ }
+
+ st->s_afd = -1;
+
+ *retval = 0;
+ return 0;
+}
+
+
+static int
+_i_bind_rsvd(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ struct mkfifo_args ap;
+
+ /*
+ * This is a supposed to be a kernel and library only ioctl.
+ * It gets called before ti_bind, when we have a unix
+ * socket, to physically create the socket transport and
+ * ``reserve'' it. I don't know how this get reserved inside
+ * the kernel, but we are going to create it nevertheless.
+ */
+ SCARG(&ap, path) = dat;
+ SCARG(&ap, mode) = S_IFIFO;
+
+ return mkfifo(p, &ap);
+}
+
+static int
+_i_rele_rsvd(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ struct unlink_args ap;
+
+ /*
+ * This is a supposed to be a kernel and library only ioctl.
+ * I guess it is supposed to release the socket.
+ */
+ SCARG(&ap, path) = dat;
+
+ return unlink(p, &ap);
+}
+
+static int
+i_str(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ int error;
+ struct svr4_strioctl ioc;
+
+ if ((error = copyin(dat, &ioc, sizeof(ioc))) != 0)
+ return error;
+
+#ifdef DEBUG_SVR4
+ if ((error = show_ioc(">", &ioc)) != 0)
+ return error;
+#endif /* DEBUG_SVR4 */
+
+ switch (ioc.cmd & 0xff00) {
+ case SVR4_SIMOD:
+ if ((error = sockmod(fp, fd, &ioc, p)) != 0)
+ return error;
+ break;
+
+ case SVR4_TIMOD:
+ if ((error = timod(fp, fd, &ioc, p)) != 0)
+ return error;
+ break;
+
+ default:
+ DPRINTF(("Unimplemented module %c %ld\n",
+ (char) (cmd >> 8), cmd & 0xff));
+ return 0;
+ }
+
+#ifdef DEBUG_SVR4
+ if ((error = show_ioc("<", &ioc)) != 0)
+ return error;
+#endif /* DEBUG_SVR4 */
+ return copyout(&ioc, dat, sizeof(ioc));
+}
+
+static int
+i_setsig(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ /*
+ * This is the best we can do for now; we cannot generate
+ * signals only for specific events so the signal mask gets
+ * ignored; we save it just to pass it to a possible I_GETSIG...
+ *
+ * We alse have to fix the O_ASYNC fcntl bit, so the
+ * process will get SIGPOLLs.
+ */
+ struct fcntl_args fa;
+ int error;
+ register_t oflags, flags;
+ struct svr4_strm *st = svr4_stream_get(fp);
+
+ if (st == NULL) {
+ DPRINTF(("i_setsig: bad file descriptor\n"));
+ return EINVAL;
+ }
+ /* get old status flags */
+ SCARG(&fa, fd) = fd;
+ SCARG(&fa, cmd) = F_GETFL;
+ if ((error = fcntl(p, &fa)) != 0)
+ return error;
+
+ oflags = p->p_retval[0];
+
+ /* update the flags */
+ if (dat != NULL) {
+ int mask;
+
+ flags = oflags | O_ASYNC;
+ if ((error = copyin(dat, &mask, sizeof(mask))) != 0) {
+ DPRINTF(("i_setsig: bad eventmask pointer\n"));
+ return error;
+ }
+ if (mask & SVR4_S_ALLMASK) {
+ DPRINTF(("i_setsig: bad eventmask data %x\n", mask));
+ return EINVAL;
+ }
+ st->s_eventmask = mask;
+ }
+ else {
+ flags = oflags & ~O_ASYNC;
+ st->s_eventmask = 0;
+ }
+
+ /* set the new flags, if changed */
+ if (flags != oflags) {
+ SCARG(&fa, cmd) = F_SETFL;
+ SCARG(&fa, arg) = (long) flags;
+ if ((error = fcntl(p, &fa)) != 0)
+ return error;
+ flags = p->p_retval[0];
+ }
+
+ /* set up SIGIO receiver if needed */
+ if (dat != NULL) {
+ SCARG(&fa, cmd) = F_SETOWN;
+ SCARG(&fa, arg) = (long) p->p_pid;
+ return fcntl(p, &fa);
+ }
+ return 0;
+}
+
+static int
+i_getsig(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ int error;
+
+ if (dat != NULL) {
+ struct svr4_strm *st = svr4_stream_get(fp);
+
+ if (st == NULL) {
+ DPRINTF(("i_getsig: bad file descriptor\n"));
+ return EINVAL;
+ }
+ if ((error = copyout(&st->s_eventmask, dat,
+ sizeof(st->s_eventmask))) != 0) {
+ DPRINTF(("i_getsig: bad eventmask pointer\n"));
+ return error;
+ }
+ }
+ return 0;
+}
+
+int
+svr4_stream_ioctl(fp, p, retval, fd, cmd, dat)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t dat;
+{
+ *retval = 0;
+
+ /*
+ * All the following stuff assumes "sockmod" is pushed...
+ */
+ switch (cmd) {
+ case SVR4_I_NREAD:
+ DPRINTF(("I_NREAD\n"));
+ return i_nread(fp, p, retval, fd, cmd, dat);
+
+ case SVR4_I_PUSH:
+ DPRINTF(("I_PUSH %x\n", dat));
+#if defined(DEBUG_SVR4)
+ show_strbuf(dat);
+#endif
+ return 0;
+
+ case SVR4_I_POP:
+ DPRINTF(("I_POP\n"));
+ return 0;
+
+ case SVR4_I_LOOK:
+ DPRINTF(("I_LOOK\n"));
+ return 0;
+
+ case SVR4_I_FLUSH:
+ DPRINTF(("I_FLUSH\n"));
+ return 0;
+
+ case SVR4_I_SRDOPT:
+ DPRINTF(("I_SRDOPT\n"));
+ return 0;
+
+ case SVR4_I_GRDOPT:
+ DPRINTF(("I_GRDOPT\n"));
+ return 0;
+
+ case SVR4_I_STR:
+ DPRINTF(("I_STR\n"));
+ return i_str(fp, p, retval, fd, cmd, dat);
+
+ case SVR4_I_SETSIG:
+ DPRINTF(("I_SETSIG\n"));
+ return i_setsig(fp, p, retval, fd, cmd, dat);
+
+ case SVR4_I_GETSIG:
+ DPRINTF(("I_GETSIG\n"));
+ return i_getsig(fp, p, retval, fd, cmd, dat);
+
+ case SVR4_I_FIND:
+ DPRINTF(("I_FIND\n"));
+ /*
+ * Here we are not pushing modules really, we just
+ * pretend all are present
+ */
+ *retval = 0;
+ return 0;
+
+ case SVR4_I_LINK:
+ DPRINTF(("I_LINK\n"));
+ return 0;
+
+ case SVR4_I_UNLINK:
+ DPRINTF(("I_UNLINK\n"));
+ return 0;
+
+ case SVR4_I_ERECVFD:
+ DPRINTF(("I_ERECVFD\n"));
+ return 0;
+
+ case SVR4_I_PEEK:
+ DPRINTF(("I_PEEK\n"));
+ return 0;
+
+ case SVR4_I_FDINSERT:
+ DPRINTF(("I_FDINSERT\n"));
+ return i_fdinsert(fp, p, retval, fd, cmd, dat);
+
+ case SVR4_I_SENDFD:
+ DPRINTF(("I_SENDFD\n"));
+ return 0;
+
+ case SVR4_I_RECVFD:
+ DPRINTF(("I_RECVFD\n"));
+ return 0;
+
+ case SVR4_I_SWROPT:
+ DPRINTF(("I_SWROPT\n"));
+ return 0;
+
+ case SVR4_I_GWROPT:
+ DPRINTF(("I_GWROPT\n"));
+ return 0;
+
+ case SVR4_I_LIST:
+ DPRINTF(("I_LIST\n"));
+ return 0;
+
+ case SVR4_I_PLINK:
+ DPRINTF(("I_PLINK\n"));
+ return 0;
+
+ case SVR4_I_PUNLINK:
+ DPRINTF(("I_PUNLINK\n"));
+ return 0;
+
+ case SVR4_I_SETEV:
+ DPRINTF(("I_SETEV\n"));
+ return 0;
+
+ case SVR4_I_GETEV:
+ DPRINTF(("I_GETEV\n"));
+ return 0;
+
+ case SVR4_I_STREV:
+ DPRINTF(("I_STREV\n"));
+ return 0;
+
+ case SVR4_I_UNSTREV:
+ DPRINTF(("I_UNSTREV\n"));
+ return 0;
+
+ case SVR4_I_FLUSHBAND:
+ DPRINTF(("I_FLUSHBAND\n"));
+ return 0;
+
+ case SVR4_I_CKBAND:
+ DPRINTF(("I_CKBAND\n"));
+ return 0;
+
+ case SVR4_I_GETBAND:
+ DPRINTF(("I_GETBANK\n"));
+ return 0;
+
+ case SVR4_I_ATMARK:
+ DPRINTF(("I_ATMARK\n"));
+ return 0;
+
+ case SVR4_I_SETCLTIME:
+ DPRINTF(("I_SETCLTIME\n"));
+ return 0;
+
+ case SVR4_I_GETCLTIME:
+ DPRINTF(("I_GETCLTIME\n"));
+ return 0;
+
+ case SVR4_I_CANPUT:
+ DPRINTF(("I_CANPUT\n"));
+ return 0;
+
+ case SVR4__I_BIND_RSVD:
+ DPRINTF(("_I_BIND_RSVD\n"));
+ return _i_bind_rsvd(fp, p, retval, fd, cmd, dat);
+
+ case SVR4__I_RELE_RSVD:
+ DPRINTF(("_I_RELE_RSVD\n"));
+ return _i_rele_rsvd(fp, p, retval, fd, cmd, dat);
+
+ default:
+ DPRINTF(("unimpl cmd = %lx\n", cmd));
+ break;
+ }
+
+ return 0;
+}
+
+
+
+int
+svr4_sys_putmsg(p, uap)
+ register struct proc *p;
+ struct svr4_sys_putmsg_args *uap;
+{
+ struct filedesc *fdp = p->p_fd;
+ struct file *fp;
+ struct svr4_strbuf dat, ctl;
+ struct svr4_strmcmd sc;
+ struct sockaddr_in sain;
+ struct sockaddr_un saun;
+ void *skp, *sup;
+ int sasize, *retval;
+ struct svr4_strm *st;
+ int error;
+ caddr_t sg;
+
+ retval = p->p_retval;
+ if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
+ (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
+#ifdef DEBUG_SVR4
+ uprintf("putmsg: bad fp\n");
+#endif
+ return EBADF;
+ }
+
+#ifdef DEBUG_SVR4
+ show_msg(">putmsg", SCARG(uap, fd), SCARG(uap, ctl),
+ SCARG(uap, dat), SCARG(uap, flags));
+#endif /* DEBUG_SVR4 */
+
+ if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
+ (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
+#ifdef DEBUG_SVR4
+ uprintf("putmsg: bad fp(2)\n");
+#endif
+ return EBADF;
+ }
+
+ if (SCARG(uap, ctl) != NULL) {
+ if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0) {
+#ifdef DEBUG_SVR4
+ uprintf("putmsg: copyin(): %d\n", error);
+#endif
+ return error;
+ }
+ }
+ else
+ ctl.len = -1;
+
+ if (SCARG(uap, dat) != NULL) {
+ if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0) {
+#ifdef DEBUG_SVR4
+ uprintf("putmsg: copyin(): %d (2)\n", error);
+#endif
+ return error;
+ }
+ }
+ else
+ dat.len = -1;
+
+ /*
+ * Only for sockets for now.
+ */
+ if ((st = svr4_stream_get(fp)) == NULL) {
+ DPRINTF(("putmsg: bad file type\n"));
+ return EINVAL;
+ }
+
+ if (ctl.len > sizeof(sc)) {
+ DPRINTF(("putmsg: Bad control size %d != %d\n", ctl.len,
+ sizeof(struct svr4_strmcmd)));
+ return EINVAL;
+ }
+
+ if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0)
+ return error;
+
+ switch (st->s_family) {
+ case AF_INET:
+ if (sc.len != sizeof(sain)) {
+ if (sc.cmd == SVR4_TI_DATA_REQUEST) {
+ struct write_args wa;
+
+ /* Solaris seems to use sc.cmd = 3 to
+ * send "expedited" data. telnet uses
+ * this for options processing, sending EOF,
+ * etc. I'm sure other things use it too.
+ * I don't have any documentation
+ * on it, so I'm making a guess that this
+ * is how it works. newton@atdot.dotat.org XXX
+ */
+ DPRINTF(("sending expedited data (???)\n"));
+ SCARG(&wa, fd) = SCARG(uap, fd);
+ SCARG(&wa, buf) = dat.buf;
+ SCARG(&wa, nbyte) = dat.len;
+ return write(p, &wa);
+ }
+ DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len));
+ return EINVAL;
+ }
+ netaddr_to_sockaddr_in(&sain, &sc);
+ skp = &sain;
+ sasize = sizeof(sain);
+ error = sain.sin_family != st->s_family;
+ break;
+
+ case AF_LOCAL:
+ if (ctl.len == 8) {
+ /* We are doing an accept; succeed */
+ DPRINTF(("putmsg: Do nothing\n"));
+ *retval = 0;
+ return 0;
+ }
+ else {
+ /* Maybe we've been given a device/inode pair */
+ dev_t *dev = SVR4_ADDROF(&sc);
+ ino_t *ino = (ino_t *) &dev[1];
+ skp = svr4_find_socket(p, fp, *dev, *ino);
+ if (skp == NULL) {
+ skp = &saun;
+ /* I guess we have it by name */
+ netaddr_to_sockaddr_un(skp, &sc);
+ }
+ sasize = sizeof(saun);
+ }
+ break;
+
+ default:
+ DPRINTF(("putmsg: Unsupported address family %d\n",
+ st->s_family));
+ return ENOSYS;
+ }
+
+ sg = stackgap_init();
+ sup = stackgap_alloc(&sg, sasize);
+
+ if ((error = copyout(skp, sup, sasize)) != 0)
+ return error;
+
+ switch (st->s_cmd = sc.cmd) {
+ case SVR4_TI_CONNECT_REQUEST: /* connect */
+ {
+ struct connect_args co;
+
+ SCARG(&co, s) = SCARG(uap, fd);
+ SCARG(&co, name) = (void *) sup;
+ SCARG(&co, namelen) = (int) sasize;
+
+ return connect(p, &co);
+ }
+
+ case SVR4_TI_SENDTO_REQUEST: /* sendto */
+ {
+ struct msghdr msg;
+ struct iovec aiov;
+
+ msg.msg_name = (caddr_t) sup;
+ msg.msg_namelen = sasize;
+ msg.msg_iov = &aiov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = 0;
+ msg.msg_flags = 0;
+ aiov.iov_base = dat.buf;
+ aiov.iov_len = dat.len;
+#if 0
+ error = so->so_proto->pr_usrreqs->pru_sosend(so, 0,
+ uio, 0, 0, 0, uio->uio_procp);
+#endif
+ error = svr4_sendit(p, SCARG(uap, fd), &msg,
+ SCARG(uap, flags));
+ DPRINTF(("sendto_request error: %d\n", error));
+ *retval = 0;
+ return error;
+ }
+
+ default:
+ DPRINTF(("putmsg: Unimplemented command %lx\n", sc.cmd));
+ return ENOSYS;
+ }
+}
+
+int
+svr4_sys_getmsg(p, uap)
+ register struct proc *p;
+ struct svr4_sys_getmsg_args *uap;
+{
+ struct filedesc *fdp = p->p_fd;
+ struct file *fp;
+ struct getpeername_args ga;
+ struct accept_args aa;
+ struct svr4_strbuf dat, ctl;
+ struct svr4_strmcmd sc;
+ int error, *retval;
+ struct msghdr msg;
+ struct iovec aiov;
+ struct sockaddr_in sain;
+ struct sockaddr_un saun;
+ void *skp, *sup;
+ int sasize;
+ struct svr4_strm *st;
+ int *flen;
+ int fl;
+ caddr_t sg;
+
+ retval = p->p_retval;
+ if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
+ (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL)
+ return EBADF;
+
+ memset(&sc, 0, sizeof(sc));
+
+#ifdef DEBUG_SVR4
+ show_msg(">getmsg", SCARG(uap, fd), SCARG(uap, ctl),
+ SCARG(uap, dat), 0);
+#endif /* DEBUG_SVR4 */
+
+ if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
+ (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL)
+ return EBADF;
+
+ if (SCARG(uap, ctl) != NULL) {
+ if ((error = copyin(SCARG(uap, ctl), &ctl, sizeof(ctl))) != 0)
+ return error;
+ }
+ else {
+ ctl.len = -1;
+ ctl.maxlen = 0;
+ }
+
+ if (SCARG(uap, dat) != NULL) {
+ if ((error = copyin(SCARG(uap, dat), &dat, sizeof(dat))) != 0)
+ return error;
+ }
+ else {
+ dat.len = -1;
+ dat.maxlen = 0;
+ }
+
+ /*
+ * Only for sockets for now.
+ */
+ if ((st = svr4_stream_get(fp)) == NULL) {
+ DPRINTF(("getmsg: bad file type\n"));
+ return EINVAL;
+ }
+
+ if (ctl.maxlen == -1 || dat.maxlen == -1) {
+ DPRINTF(("getmsg: Cannot handle -1 maxlen (yet)\n"));
+ return ENOSYS;
+ }
+
+ switch (st->s_family) {
+ case AF_INET:
+ skp = &sain;
+ sasize = sizeof(sain);
+ break;
+
+ case AF_LOCAL:
+ skp = &saun;
+ sasize = sizeof(saun);
+ break;
+
+ default:
+ DPRINTF(("getmsg: Unsupported address family %d\n",
+ st->s_family));
+ return ENOSYS;
+ }
+
+ sg = stackgap_init();
+ sup = stackgap_alloc(&sg, sasize);
+ flen = (int *) stackgap_alloc(&sg, sizeof(*flen));
+
+ fl = sasize;
+ if ((error = copyout(&fl, flen, sizeof(fl))) != 0)
+ return error;
+
+ switch (st->s_cmd) {
+ case SVR4_TI_CONNECT_REQUEST:
+ DPRINTF(("getmsg: TI_CONNECT_REQUEST\n"));
+ /*
+ * We do the connect in one step, so the putmsg should
+ * have gotten the error.
+ */
+ sc.cmd = SVR4_TI_OK_REPLY;
+ sc.len = 0;
+
+ ctl.len = 8;
+ dat.len = -1;
+ fl = 1;
+ st->s_cmd = sc.cmd;
+ break;
+
+ case SVR4_TI_OK_REPLY:
+ DPRINTF(("getmsg: TI_OK_REPLY\n"));
+ /*
+ * We are immediately after a connect reply, so we send
+ * a connect verification.
+ */
+
+ SCARG(&ga, fdes) = SCARG(uap, fd);
+ SCARG(&ga, asa) = (void *) sup;
+ SCARG(&ga, alen) = flen;
+
+ if ((error = getpeername(p, &ga)) != 0) {
+ DPRINTF(("getmsg: getpeername failed %d\n", error));
+ return error;
+ }
+
+ if ((error = copyin(sup, skp, sasize)) != 0)
+ return error;
+
+ sc.cmd = SVR4_TI_CONNECT_REPLY;
+ sc.pad[0] = 0x4;
+ sc.offs = 0x18;
+ sc.pad[1] = 0x14;
+ sc.pad[2] = 0x04000402;
+
+ switch (st->s_family) {
+ case AF_INET:
+ sc.len = sasize;
+ sockaddr_to_netaddr_in(&sc, &sain);
+ break;
+
+ case AF_LOCAL:
+ sc.len = sasize + 4;
+ sockaddr_to_netaddr_un(&sc, &saun);
+ break;
+
+ default:
+ return ENOSYS;
+ }
+
+ ctl.len = 40;
+ dat.len = -1;
+ fl = 0;
+ st->s_cmd = sc.cmd;
+ break;
+
+ case SVR4_TI__ACCEPT_OK:
+ DPRINTF(("getmsg: TI__ACCEPT_OK\n"));
+ /*
+ * We do the connect in one step, so the putmsg should
+ * have gotten the error.
+ */
+ sc.cmd = SVR4_TI_OK_REPLY;
+ sc.len = 1;
+
+ ctl.len = 8;
+ dat.len = -1;
+ fl = 1;
+ st->s_cmd = SVR4_TI__ACCEPT_WAIT;
+ break;
+
+ case SVR4_TI__ACCEPT_WAIT:
+ DPRINTF(("getmsg: TI__ACCEPT_WAIT\n"));
+ /*
+ * We are after a listen, so we try to accept...
+ */
+ SCARG(&aa, s) = SCARG(uap, fd);
+ SCARG(&aa, name) = (void *) sup;
+ SCARG(&aa, anamelen) = flen;
+
+ if ((error = accept(p, &aa)) != 0) {
+ DPRINTF(("getmsg: accept failed %d\n", error));
+ return error;
+ }
+
+ st->s_afd = *retval;
+
+ DPRINTF(("getmsg: Accept fd = %d\n", st->s_afd));
+
+ if ((error = copyin(sup, skp, sasize)) != 0)
+ return error;
+
+ sc.cmd = SVR4_TI_ACCEPT_REPLY;
+ sc.offs = 0x18;
+ sc.pad[0] = 0x0;
+
+ switch (st->s_family) {
+ case AF_INET:
+ sc.pad[1] = 0x28;
+ sockaddr_to_netaddr_in(&sc, &sain);
+ ctl.len = 40;
+ sc.len = sasize;
+ break;
+
+ case AF_LOCAL:
+ sc.pad[1] = 0x00010000;
+ sc.pad[2] = 0xf6bcdaa0; /* I don't know what that is */
+ sc.pad[3] = 0x00010000;
+ ctl.len = 134;
+ sc.len = sasize + 4;
+ break;
+
+ default:
+ return ENOSYS;
+ }
+
+ dat.len = -1;
+ fl = 0;
+ st->s_cmd = SVR4_TI__ACCEPT_OK;
+ break;
+
+ case SVR4_TI_SENDTO_REQUEST:
+ DPRINTF(("getmsg: TI_SENDTO_REQUEST\n"));
+ if (ctl.maxlen > 36 && ctl.len < 36)
+ ctl.len = 36;
+
+ if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0)
+ return error;
+
+ switch (st->s_family) {
+ case AF_INET:
+ sockaddr_to_netaddr_in(&sc, &sain);
+ break;
+
+ case AF_LOCAL:
+ sockaddr_to_netaddr_un(&sc, &saun);
+ break;
+
+ default:
+ return ENOSYS;
+ }
+
+ msg.msg_name = (caddr_t) sup;
+ msg.msg_namelen = sasize;
+ msg.msg_iov = &aiov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = 0;
+ aiov.iov_base = dat.buf;
+ aiov.iov_len = dat.maxlen;
+ msg.msg_flags = 0;
+
+ error = svr4_recvit(p, SCARG(uap, fd), &msg, (caddr_t) flen);
+
+ if (error) {
+ DPRINTF(("getmsg: recvit failed %d\n", error));
+ return error;
+ }
+
+ if ((error = copyin(msg.msg_name, skp, sasize)) != 0)
+ return error;
+
+ sc.cmd = SVR4_TI_RECVFROM_IND;
+
+ switch (st->s_family) {
+ case AF_INET:
+ sc.len = sasize;
+ sockaddr_to_netaddr_in(&sc, &sain);
+ break;
+
+ case AF_LOCAL:
+ sc.len = sasize + 4;
+ sockaddr_to_netaddr_un(&sc, &saun);
+ break;
+
+ default:
+ return ENOSYS;
+ }
+
+ dat.len = *retval;
+ fl = 0;
+ st->s_cmd = sc.cmd;
+ break;
+
+ default:
+ st->s_cmd = sc.cmd;
+ if (st->s_cmd == SVR4_TI_CONNECT_REQUEST) {
+ struct read_args ra;
+
+ /* More wierdness: Again, I can't find documentation
+ * to back this up, but when a process does a generic
+ * "getmsg()" call it seems that the command field is
+ * zero and the length of the data area is zero. I
+ * think processes expect getmsg() to fill in dat.len
+ * after reading at most dat.maxlen octets from the
+ * stream. Since we're using sockets I can let
+ * read() look after it and frob return values
+ * appropriately (or inappropriately :-)
+ * -- newton@atdot.dotat.org XXX
+ */
+ SCARG(&ra, fd) = SCARG(uap, fd);
+ SCARG(&ra, buf) = dat.buf;
+ SCARG(&ra, nbyte) = dat.maxlen;
+ if ((error = read(p, &ra)) != 0) {
+ return error;
+ }
+ dat.len = *retval;
+ *retval = 0;
+ st->s_cmd = SVR4_TI_SENDTO_REQUEST;
+ break;
+ }
+ DPRINTF(("getmsg: Unknown state %x\n", st->s_cmd));
+ return EINVAL;
+ }
+
+ if (SCARG(uap, ctl)) {
+ if (ctl.len != -1)
+ if ((error = copyout(&sc, ctl.buf, ctl.len)) != 0)
+ return error;
+
+ if ((error = copyout(&ctl, SCARG(uap, ctl), sizeof(ctl))) != 0)
+ return error;
+ }
+
+ if (SCARG(uap, dat)) {
+ if ((error = copyout(&dat, SCARG(uap, dat), sizeof(dat))) != 0)
+ return error;
+ }
+
+ if (SCARG(uap, flags)) { /* XXX: Need translation */
+ if ((error = copyout(&fl, SCARG(uap, flags), sizeof(fl))) != 0)
+ return error;
+ }
+
+ *retval = 0;
+
+#ifdef DEBUG_SVR4
+ show_msg("<getmsg", SCARG(uap, fd), SCARG(uap, ctl),
+ SCARG(uap, dat), fl);
+#endif /* DEBUG_SVR4 */
+ return error;
+}
+
+int svr4_sys_send(p, uap)
+ struct proc *p;
+ struct svr4_sys_send_args *uap;
+{
+ struct osend_args osa;
+ SCARG(&osa, s) = SCARG(uap, s);
+ SCARG(&osa, buf) = SCARG(uap, buf);
+ SCARG(&osa, len) = SCARG(uap, len);
+ SCARG(&osa, flags) = SCARG(uap, flags);
+ return osend(p, &osa);
+}
+
+int svr4_sys_recv(p, uap)
+ struct proc *p;
+ struct svr4_sys_recv_args *uap;
+{
+ struct orecv_args ora;
+ SCARG(&ora, s) = SCARG(uap, s);
+ SCARG(&ora, buf) = SCARG(uap, buf);
+ SCARG(&ora, len) = SCARG(uap, len);
+ SCARG(&ora, flags) = SCARG(uap, flags);
+ return orecv(p, &ora);
+}
+
+/*
+ * XXX This isn't necessary, but it's handy for inserting debug code into
+ * sendto(). Let's leave it here for now...
+ */
+int
+svr4_sys_sendto(p, uap)
+ struct proc *p;
+ struct svr4_sys_sendto_args *uap;
+{
+ struct sendto_args sa;
+
+ SCARG(&sa, s) = SCARG(uap, s);
+ SCARG(&sa, buf) = SCARG(uap, buf);
+ SCARG(&sa, len) = SCARG(uap, len);
+ SCARG(&sa, flags) = SCARG(uap, flags);
+ SCARG(&sa, to) = SCARG(uap, to);
+ SCARG(&sa, tolen) = SCARG(uap, tolen);
+
+ DPRINTF(("calling sendto()\n"));
+ return sendto(p, &sa);
+}
+
diff --git a/sys/svr4/svr4_stream.h b/sys/svr4/svr4_stream.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/sys/svr4/svr4_stream.h
diff --git a/sys/svr4/svr4_stropts.h b/sys/svr4/svr4_stropts.h
new file mode 100644
index 0000000..75a33b3
--- /dev/null
+++ b/sys/svr4/svr4_stropts.h
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_STROPTS_H_
+#define _SVR4_STROPTS_H_
+
+
+struct svr4_strbuf {
+ int maxlen;
+ int len;
+ char *buf;
+};
+
+#define SVR4_STR ('S' << 8)
+#define SVR4_I_NREAD (SVR4_STR| 1)
+#define SVR4_I_PUSH (SVR4_STR| 2)
+#define SVR4_I_POP (SVR4_STR| 3)
+#define SVR4_I_LOOK (SVR4_STR| 4)
+#define SVR4_I_FLUSH (SVR4_STR| 5)
+#define SVR4_I_SRDOPT (SVR4_STR| 6)
+#define SVR4_I_GRDOPT (SVR4_STR| 7)
+#define SVR4_I_STR (SVR4_STR| 8)
+#define SVR4_I_SETSIG (SVR4_STR| 9)
+#define SVR4_I_GETSIG (SVR4_STR|10)
+#define SVR4_I_FIND (SVR4_STR|11)
+#define SVR4_I_LINK (SVR4_STR|12)
+#define SVR4_I_UNLINK (SVR4_STR|13)
+#define SVR4_I_ERECVFD (SVR4_STR|14)
+#define SVR4_I_PEEK (SVR4_STR|15)
+#define SVR4_I_FDINSERT (SVR4_STR|16)
+#define SVR4_I_SENDFD (SVR4_STR|17)
+#define SVR4_I_RECVFD (SVR4_STR|18)
+#define SVR4_I_SWROPT (SVR4_STR|19)
+#define SVR4_I_GWROPT (SVR4_STR|20)
+#define SVR4_I_LIST (SVR4_STR|21)
+#define SVR4_I_PLINK (SVR4_STR|22)
+#define SVR4_I_PUNLINK (SVR4_STR|23)
+#define SVR4_I_SETEV (SVR4_STR|24)
+#define SVR4_I_GETEV (SVR4_STR|25)
+#define SVR4_I_STREV (SVR4_STR|26)
+#define SVR4_I_UNSTREV (SVR4_STR|27)
+#define SVR4_I_FLUSHBAND (SVR4_STR|28)
+#define SVR4_I_CKBAND (SVR4_STR|29)
+#define SVR4_I_GETBAND (SVR4_STR|30)
+#define SVR4_I_ATMARK (SVR4_STR|31)
+#define SVR4_I_SETCLTIME (SVR4_STR|32)
+#define SVR4_I_GETCLTIME (SVR4_STR|33)
+#define SVR4_I_CANPUT (SVR4_STR|34)
+
+/*
+ * The following two ioctls are OS specific and
+ * undocumented.
+ */
+#define SVR4__I_BIND_RSVD (SVR4_STR|242)
+#define SVR4__I_RELE_RSVD (SVR4_STR|243)
+
+/*
+ * Service type definitions
+ */
+#define SVR4_T_COTS 1 /* Connection-orieted */
+#define SVR4_T_COTS_ORD 2 /* Local connection-oriented */
+#define SVR4_T_CLTS 3 /* Connectionless */
+
+/* Struct passed for SVR4_I_STR */
+struct svr4_strioctl {
+ u_long cmd;
+ int timeout;
+ int len;
+ char *buf;
+};
+
+/*
+ * Bits for I_{G,S}ETSIG
+ */
+#define SVR4_S_INPUT 0x0001 /* any message on read queue no HIPRI */
+#define SVR4_S_HIPRI 0x0002 /* high prio message on read queue */
+#define SVR4_S_OUTPUT 0x0004 /* write queue has free space */
+#define SVR4_S_MSG 0x0008 /* signal message in read queue head */
+#define SVR4_S_ERROR 0x0010 /* error message in read queue head */
+#define SVR4_S_HANGUP 0x0020 /* hangup message in read queue head */
+#define SVR4_S_RDNORM 0x0040 /* normal message on read queue */
+#define SVR4_S_WRNORM S_OUTPUT /* write queue has free space */
+#define SVR4_S_RDBAND 0x0080 /* out of band message on read queue */
+#define SVR4_S_WRBAND 0x0100 /* write queue has free space for oob */
+#define SVR4_S_BANDURG 0x0200 /* generate SIGURG instead of SIGPOLL */
+#define SVR4_S_ALLMASK 0x03ff /* all events mask */
+
+/*
+ * Our internal state for the stream
+ * For now we keep almost nothing... In the future we can keep more
+ * streams state.
+ */
+struct svr4_strm {
+ int s_family; /* socket family */
+ int s_cmd; /* last getmsg reply or putmsg request */
+ int s_afd; /* last accepted fd; [for fd_insert] */
+ int s_eventmask; /* state info from I_SETSIG et al */
+};
+
+/*
+ * The following structures are determined empirically.
+ */
+struct svr4_strmcmd {
+ long cmd; /* command ? */
+ long len; /* Address len */
+ long offs; /* Address offset */
+ long pad[61];
+};
+
+struct svr4_infocmd {
+ long cmd;
+ long tsdu;
+ long etsdu;
+ long cdata;
+ long ddata;
+ long addr;
+ long opt;
+ long tidu;
+ long serv;
+ long current;
+ long provider;
+};
+
+struct svr4_strfdinsert {
+ struct svr4_strbuf ctl;
+ struct svr4_strbuf data;
+ long flags;
+ int fd;
+ int offset;
+};
+
+struct svr4_netaddr_in {
+ u_short family;
+ u_short port;
+ u_long addr;
+};
+
+struct svr4_netaddr_un {
+ u_short family;
+ char path[1];
+};
+
+#define SVR4_ADDROF(sc) (void *) (((char *) (sc)) + (sc)->offs)
+#define SVR4_C_ADDROF(sc) (const void *) (((const char *) (sc)) + (sc)->offs)
+
+struct svr4_strm *svr4_stream_get __P((struct file *fp));
+
+#endif /* !_SVR4_STROPTS */
diff --git a/sys/svr4/svr4_syscall.h b/sys/svr4/svr4_syscall.h
new file mode 100644
index 0000000..1489740
--- /dev/null
+++ b/sys/svr4/svr4_syscall.h
@@ -0,0 +1,144 @@
+/*
+ * System call numbers.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
+ */
+
+#define SVR4_SYS_exit 1
+#define SVR4_SYS_fork 2
+#define SVR4_SYS_read 3
+#define SVR4_SYS_write 4
+#define SVR4_SYS_svr4_sys_open 5
+#define SVR4_SYS_close 6
+#define SVR4_SYS_svr4_sys_wait 7
+#define SVR4_SYS_svr4_sys_creat 8
+#define SVR4_SYS_link 9
+#define SVR4_SYS_unlink 10
+#define SVR4_SYS_svr4_sys_execv 11
+#define SVR4_SYS_chdir 12
+#define SVR4_SYS_svr4_sys_time 13
+#define SVR4_SYS_svr4_sys_mknod 14
+#define SVR4_SYS_chmod 15
+#define SVR4_SYS_chown 16
+#define SVR4_SYS_svr4_sys_break 17
+#define SVR4_SYS_svr4_sys_stat 18
+#define SVR4_SYS_lseek 19
+#define SVR4_SYS_getpid 20
+#define SVR4_SYS_setuid 23
+#define SVR4_SYS_getuid 24
+#define SVR4_SYS_svr4_sys_alarm 27
+#define SVR4_SYS_svr4_sys_fstat 28
+#define SVR4_SYS_svr4_sys_pause 29
+#define SVR4_SYS_svr4_sys_utime 30
+#define SVR4_SYS_svr4_sys_access 33
+#define SVR4_SYS_svr4_sys_nice 34
+#define SVR4_SYS_sync 36
+#define SVR4_SYS_svr4_sys_kill 37
+#define SVR4_SYS_svr4_sys_pgrpsys 39
+#define SVR4_SYS_dup 41
+#define SVR4_SYS_pipe 42
+#define SVR4_SYS_svr4_sys_times 43
+#define SVR4_SYS_setgid 46
+#define SVR4_SYS_getgid 47
+#define SVR4_SYS_svr4_sys_signal 48
+#define SVR4_SYS_svr4_sys_msgsys 49
+#define SVR4_SYS_svr4_sys_sysarch 50
+#define SVR4_SYS_svr4_sys_ioctl 54
+#define SVR4_SYS_svr4_sys_utssys 57
+#define SVR4_SYS_fsync 58
+#define SVR4_SYS_svr4_sys_execve 59
+#define SVR4_SYS_umask 60
+#define SVR4_SYS_chroot 61
+#define SVR4_SYS_svr4_sys_fcntl 62
+#define SVR4_SYS_svr4_sys_ulimit 63
+#define SVR4_SYS_rmdir 79
+#define SVR4_SYS_mkdir 80
+#define SVR4_SYS_svr4_sys_getdents 81
+#define SVR4_SYS_svr4_sys_getmsg 85
+#define SVR4_SYS_svr4_sys_putmsg 86
+#define SVR4_SYS_svr4_sys_poll 87
+#define SVR4_SYS_svr4_sys_lstat 88
+#define SVR4_SYS_symlink 89
+#define SVR4_SYS_readlink 90
+#define SVR4_SYS_getgroups 91
+#define SVR4_SYS_setgroups 92
+#define SVR4_SYS_fchmod 93
+#define SVR4_SYS_fchown 94
+#define SVR4_SYS_svr4_sys_sigprocmask 95
+#define SVR4_SYS_svr4_sys_sigsuspend 96
+#define SVR4_SYS_svr4_sys_sigaltstack 97
+#define SVR4_SYS_svr4_sys_sigaction 98
+#define SVR4_SYS_svr4_sys_sigpending 99
+#define SVR4_SYS_svr4_sys_context 100
+#define SVR4_SYS_svr4_sys_statvfs 103
+#define SVR4_SYS_svr4_sys_fstatvfs 104
+#define SVR4_SYS_svr4_sys_waitsys 107
+#define SVR4_SYS_svr4_sys_hrtsys 109
+#define SVR4_SYS_svr4_sys_pathconf 113
+#define SVR4_SYS_svr4_sys_mmap 115
+#define SVR4_SYS_mprotect 116
+#define SVR4_SYS_munmap 117
+#define SVR4_SYS_svr4_sys_fpathconf 118
+#define SVR4_SYS_vfork 119
+#define SVR4_SYS_fchdir 120
+#define SVR4_SYS_readv 121
+#define SVR4_SYS_writev 122
+#define SVR4_SYS_svr4_sys_xstat 123
+#define SVR4_SYS_svr4_sys_lxstat 124
+#define SVR4_SYS_svr4_sys_fxstat 125
+#define SVR4_SYS_svr4_sys_xmknod 126
+#define SVR4_SYS_svr4_sys_setrlimit 128
+#define SVR4_SYS_svr4_sys_getrlimit 129
+#define SVR4_SYS_lchown 130
+#define SVR4_SYS_svr4_sys_memcntl 131
+#define SVR4_SYS_rename 134
+#define SVR4_SYS_svr4_sys_uname 135
+#define SVR4_SYS_setegid 136
+#define SVR4_SYS_svr4_sys_sysconfig 137
+#define SVR4_SYS_adjtime 138
+#define SVR4_SYS_svr4_sys_systeminfo 139
+#define SVR4_SYS_seteuid 141
+#define SVR4_SYS_svr4_sys_fchroot 153
+#define SVR4_SYS_svr4_sys_utimes 154
+#define SVR4_SYS_svr4_sys_vhangup 155
+#define SVR4_SYS_svr4_sys_gettimeofday 156
+#define SVR4_SYS_getitimer 157
+#define SVR4_SYS_setitimer 158
+#define SVR4_SYS_svr4_sys_llseek 175
+#define SVR4_SYS_svr4_sys_acl 185
+#define SVR4_SYS_svr4_sys_auditsys 186
+#define SVR4_SYS_nanosleep 199
+#define SVR4_SYS_svr4_sys_facl 200
+#define SVR4_SYS_setreuid 202
+#define SVR4_SYS_setregid 203
+#define SVR4_SYS_svr4_sys_resolvepath 209
+#define SVR4_SYS_svr4_sys_getdents64 213
+#define SVR4_SYS_svr4_sys_mmap64 214
+#define SVR4_SYS_svr4_sys_stat64 215
+#define SVR4_SYS_svr4_sys_lstat64 216
+#define SVR4_SYS_svr4_sys_fstat64 217
+#define SVR4_SYS_svr4_sys_statvfs64 218
+#define SVR4_SYS_svr4_sys_fstatvfs64 219
+#define SVR4_SYS_svr4_sys_setrlimit64 220
+#define SVR4_SYS_svr4_sys_getrlimit64 221
+#define SVR4_SYS_svr4_sys_creat64 224
+#define SVR4_SYS_svr4_sys_open64 225
+#define SVR4_SYS_svr4_sys_socket 230
+#define SVR4_SYS_socketpair 231
+#define SVR4_SYS_bind 232
+#define SVR4_SYS_listen 233
+#define SVR4_SYS_accept 234
+#define SVR4_SYS_connect 235
+#define SVR4_SYS_shutdown 236
+#define SVR4_SYS_svr4_sys_recv 237
+#define SVR4_SYS_recvfrom 238
+#define SVR4_SYS_recvmsg 239
+#define SVR4_SYS_svr4_sys_send 240
+#define SVR4_SYS_sendmsg 241
+#define SVR4_SYS_svr4_sys_sendto 242
+#define SVR4_SYS_getpeername 243
+#define SVR4_SYS_getsockname 244
+#define SVR4_SYS_getsockopt 245
+#define SVR4_SYS_setsockopt 246
+#define SVR4_SYS_MAXSYSCALL 250
diff --git a/sys/svr4/svr4_syscallnames.c b/sys/svr4/svr4_syscallnames.c
new file mode 100644
index 0000000..bb715b0
--- /dev/null
+++ b/sys/svr4/svr4_syscallnames.c
@@ -0,0 +1,263 @@
+/*
+ * System call names.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
+ */
+
+char *svr4_syscallnames[] = {
+ "#0", /* 0 = unused */
+ "exit", /* 1 = exit */
+ "fork", /* 2 = fork */
+ "read", /* 3 = read */
+ "write", /* 4 = write */
+ "svr4_sys_open", /* 5 = svr4_sys_open */
+ "close", /* 6 = close */
+ "svr4_sys_wait", /* 7 = svr4_sys_wait */
+ "svr4_sys_creat", /* 8 = svr4_sys_creat */
+ "link", /* 9 = link */
+ "unlink", /* 10 = unlink */
+ "svr4_sys_execv", /* 11 = svr4_sys_execv */
+ "chdir", /* 12 = chdir */
+ "svr4_sys_time", /* 13 = svr4_sys_time */
+ "svr4_sys_mknod", /* 14 = svr4_sys_mknod */
+ "chmod", /* 15 = chmod */
+ "chown", /* 16 = chown */
+ "svr4_sys_break", /* 17 = svr4_sys_break */
+ "svr4_sys_stat", /* 18 = svr4_sys_stat */
+ "lseek", /* 19 = lseek */
+ "getpid", /* 20 = getpid */
+ "#21", /* 21 = old_mount */
+ "#22", /* 22 = sysv_umount */
+ "setuid", /* 23 = setuid */
+ "getuid", /* 24 = getuid */
+ "#25", /* 25 = stime */
+ "#26", /* 26 = ptrace */
+ "svr4_sys_alarm", /* 27 = svr4_sys_alarm */
+ "svr4_sys_fstat", /* 28 = svr4_sys_fstat */
+ "svr4_sys_pause", /* 29 = svr4_sys_pause */
+ "svr4_sys_utime", /* 30 = svr4_sys_utime */
+ "#31", /* 31 = stty */
+ "#32", /* 32 = gtty */
+ "svr4_sys_access", /* 33 = svr4_sys_access */
+ "svr4_sys_nice", /* 34 = svr4_sys_nice */
+ "#35", /* 35 = statfs */
+ "sync", /* 36 = sync */
+ "svr4_sys_kill", /* 37 = svr4_sys_kill */
+ "#38", /* 38 = fstatfs */
+ "svr4_sys_pgrpsys", /* 39 = svr4_sys_pgrpsys */
+ "#40", /* 40 = xenix */
+ "dup", /* 41 = dup */
+ "pipe", /* 42 = pipe */
+ "svr4_sys_times", /* 43 = svr4_sys_times */
+ "#44", /* 44 = profil */
+ "#45", /* 45 = plock */
+ "setgid", /* 46 = setgid */
+ "getgid", /* 47 = getgid */
+ "svr4_sys_signal", /* 48 = svr4_sys_signal */
+#if defined(NOTYET)
+ "svr4_sys_msgsys", /* 49 = svr4_sys_msgsys */
+#else
+ "#49", /* 49 = msgsys */
+#endif
+ "svr4_sys_sysarch", /* 50 = svr4_sys_sysarch */
+ "#51", /* 51 = acct */
+ "#52", /* 52 = shmsys */
+ "#53", /* 53 = semsys */
+ "svr4_sys_ioctl", /* 54 = svr4_sys_ioctl */
+ "#55", /* 55 = uadmin */
+ "#56", /* 56 = exch */
+ "svr4_sys_utssys", /* 57 = svr4_sys_utssys */
+ "fsync", /* 58 = fsync */
+ "svr4_sys_execve", /* 59 = svr4_sys_execve */
+ "umask", /* 60 = umask */
+ "chroot", /* 61 = chroot */
+ "svr4_sys_fcntl", /* 62 = svr4_sys_fcntl */
+ "svr4_sys_ulimit", /* 63 = svr4_sys_ulimit */
+ "#64", /* 64 = reserved */
+ "#65", /* 65 = reserved */
+ "#66", /* 66 = reserved */
+ "#67", /* 67 = reserved */
+ "#68", /* 68 = reserved */
+ "#69", /* 69 = reserved */
+ "#70", /* 70 = advfs */
+ "#71", /* 71 = unadvfs */
+ "#72", /* 72 = rmount */
+ "#73", /* 73 = rumount */
+ "#74", /* 74 = rfstart */
+ "#75", /* 75 = sigret */
+ "#76", /* 76 = rdebug */
+ "#77", /* 77 = rfstop */
+ "#78", /* 78 = rfsys */
+ "rmdir", /* 79 = rmdir */
+ "mkdir", /* 80 = mkdir */
+ "svr4_sys_getdents", /* 81 = svr4_sys_getdents */
+ "#82", /* 82 = libattach */
+ "#83", /* 83 = libdetach */
+ "#84", /* 84 = sysfs */
+ "svr4_sys_getmsg", /* 85 = svr4_sys_getmsg */
+ "svr4_sys_putmsg", /* 86 = svr4_sys_putmsg */
+ "svr4_sys_poll", /* 87 = svr4_sys_poll */
+ "svr4_sys_lstat", /* 88 = svr4_sys_lstat */
+ "symlink", /* 89 = symlink */
+ "readlink", /* 90 = readlink */
+ "getgroups", /* 91 = getgroups */
+ "setgroups", /* 92 = setgroups */
+ "fchmod", /* 93 = fchmod */
+ "fchown", /* 94 = fchown */
+ "svr4_sys_sigprocmask", /* 95 = svr4_sys_sigprocmask */
+ "svr4_sys_sigsuspend", /* 96 = svr4_sys_sigsuspend */
+ "svr4_sys_sigaltstack", /* 97 = svr4_sys_sigaltstack */
+ "svr4_sys_sigaction", /* 98 = svr4_sys_sigaction */
+ "svr4_sys_sigpending", /* 99 = svr4_sys_sigpending */
+ "svr4_sys_context", /* 100 = svr4_sys_context */
+ "#101", /* 101 = evsys */
+ "#102", /* 102 = evtrapret */
+ "svr4_sys_statvfs", /* 103 = svr4_sys_statvfs */
+ "svr4_sys_fstatvfs", /* 104 = svr4_sys_fstatvfs */
+ "#105", /* 105 = whoknows */
+ "#106", /* 106 = nfssvc */
+ "svr4_sys_waitsys", /* 107 = svr4_sys_waitsys */
+ "#108", /* 108 = sigsendsys */
+ "svr4_sys_hrtsys", /* 109 = svr4_sys_hrtsys */
+ "#110", /* 110 = acancel */
+ "#111", /* 111 = async */
+ "#112", /* 112 = priocntlsys */
+ "svr4_sys_pathconf", /* 113 = svr4_sys_pathconf */
+ "#114", /* 114 = mincore */
+ "svr4_sys_mmap", /* 115 = svr4_sys_mmap */
+ "mprotect", /* 116 = mprotect */
+ "munmap", /* 117 = munmap */
+ "svr4_sys_fpathconf", /* 118 = svr4_sys_fpathconf */
+ "vfork", /* 119 = vfork */
+ "fchdir", /* 120 = fchdir */
+ "readv", /* 121 = readv */
+ "writev", /* 122 = writev */
+ "svr4_sys_xstat", /* 123 = svr4_sys_xstat */
+ "svr4_sys_lxstat", /* 124 = svr4_sys_lxstat */
+ "svr4_sys_fxstat", /* 125 = svr4_sys_fxstat */
+ "svr4_sys_xmknod", /* 126 = svr4_sys_xmknod */
+ "#127", /* 127 = clocal */
+ "svr4_sys_setrlimit", /* 128 = svr4_sys_setrlimit */
+ "svr4_sys_getrlimit", /* 129 = svr4_sys_getrlimit */
+ "lchown", /* 130 = lchown */
+ "svr4_sys_memcntl", /* 131 = svr4_sys_memcntl */
+ "#132", /* 132 = getpmsg */
+ "#133", /* 133 = putpmsg */
+ "rename", /* 134 = rename */
+ "svr4_sys_uname", /* 135 = svr4_sys_uname */
+ "setegid", /* 136 = setegid */
+ "svr4_sys_sysconfig", /* 137 = svr4_sys_sysconfig */
+ "adjtime", /* 138 = adjtime */
+ "svr4_sys_systeminfo", /* 139 = svr4_sys_systeminfo */
+ "#140", /* 140 = notused */
+ "seteuid", /* 141 = seteuid */
+ "#142", /* 142 = vtrace */
+ "#143", /* 143 = { */
+ "#144", /* 144 = sigtimedwait */
+ "#145", /* 145 = lwp_info */
+ "#146", /* 146 = yield */
+ "#147", /* 147 = lwp_sema_wait */
+ "#148", /* 148 = lwp_sema_post */
+ "#149", /* 149 = lwp_sema_trywait */
+ "#150", /* 150 = notused */
+ "#151", /* 151 = notused */
+ "#152", /* 152 = modctl */
+ "svr4_sys_fchroot", /* 153 = svr4_sys_fchroot */
+ "svr4_sys_utimes", /* 154 = svr4_sys_utimes */
+ "svr4_sys_vhangup", /* 155 = svr4_sys_vhangup */
+ "svr4_sys_gettimeofday", /* 156 = svr4_sys_gettimeofday */
+ "getitimer", /* 157 = getitimer */
+ "setitimer", /* 158 = setitimer */
+ "#159", /* 159 = lwp_create */
+ "#160", /* 160 = lwp_exit */
+ "#161", /* 161 = lwp_suspend */
+ "#162", /* 162 = lwp_continue */
+ "#163", /* 163 = lwp_kill */
+ "#164", /* 164 = lwp_self */
+ "#165", /* 165 = lwp_getprivate */
+ "#166", /* 166 = lwp_setprivate */
+ "#167", /* 167 = lwp_wait */
+ "#168", /* 168 = lwp_mutex_unlock */
+ "#169", /* 169 = lwp_mutex_lock */
+ "#170", /* 170 = lwp_cond_wait */
+ "#171", /* 171 = lwp_cond_signal */
+ "#172", /* 172 = lwp_cond_broadcast */
+ "#173", /* 173 = { */
+ "#174", /* 174 = { */
+ "svr4_sys_llseek", /* 175 = svr4_sys_llseek */
+ "#176", /* 176 = inst_sync */
+ "#177", /* 177 = whoknows */
+ "#178", /* 178 = kaio */
+ "#179", /* 179 = whoknows */
+ "#180", /* 180 = whoknows */
+ "#181", /* 181 = whoknows */
+ "#182", /* 182 = whoknows */
+ "#183", /* 183 = whoknows */
+ "#184", /* 184 = tsolsys */
+ "svr4_sys_acl", /* 185 = svr4_sys_acl */
+ "svr4_sys_auditsys", /* 186 = svr4_sys_auditsys */
+ "#187", /* 187 = processor_bind */
+ "#188", /* 188 = processor_info */
+ "#189", /* 189 = p_online */
+ "#190", /* 190 = sigqueue */
+ "#191", /* 191 = clock_gettime */
+ "#192", /* 192 = clock_settime */
+ "#193", /* 193 = clock_getres */
+ "#194", /* 194 = timer_create */
+ "#195", /* 195 = timer_delete */
+ "#196", /* 196 = timer_settime */
+ "#197", /* 197 = timer_gettime */
+ "#198", /* 198 = timer_overrun */
+ "nanosleep", /* 199 = nanosleep */
+ "svr4_sys_facl", /* 200 = svr4_sys_facl */
+ "#201", /* 201 = door */
+ "setreuid", /* 202 = setreuid */
+ "setregid", /* 203 = setregid */
+ "#204", /* 204 = install_utrap */
+ "#205", /* 205 = signotify */
+ "#206", /* 206 = schedctl */
+ "#207", /* 207 = pset */
+ "#208", /* 208 = whoknows */
+ "svr4_sys_resolvepath", /* 209 = svr4_sys_resolvepath */
+ "#210", /* 210 = signotifywait */
+ "#211", /* 211 = lwp_sigredirect */
+ "#212", /* 212 = lwp_alarm */
+ "svr4_sys_getdents64", /* 213 = svr4_sys_getdents64 */
+ "svr4_sys_mmap64", /* 214 = svr4_sys_mmap64 */
+ "svr4_sys_stat64", /* 215 = svr4_sys_stat64 */
+ "svr4_sys_lstat64", /* 216 = svr4_sys_lstat64 */
+ "svr4_sys_fstat64", /* 217 = svr4_sys_fstat64 */
+ "svr4_sys_statvfs64", /* 218 = svr4_sys_statvfs64 */
+ "svr4_sys_fstatvfs64", /* 219 = svr4_sys_fstatvfs64 */
+ "svr4_sys_setrlimit64", /* 220 = svr4_sys_setrlimit64 */
+ "svr4_sys_getrlimit64", /* 221 = svr4_sys_getrlimit64 */
+ "#222", /* 222 = pread64 */
+ "#223", /* 223 = pwrite64 */
+ "svr4_sys_creat64", /* 224 = svr4_sys_creat64 */
+ "svr4_sys_open64", /* 225 = svr4_sys_open64 */
+ "#226", /* 226 = rpcsys */
+ "#227", /* 227 = whoknows */
+ "#228", /* 228 = whoknows */
+ "#229", /* 229 = whoknows */
+ "svr4_sys_socket", /* 230 = svr4_sys_socket */
+ "socketpair", /* 231 = socketpair */
+ "bind", /* 232 = bind */
+ "listen", /* 233 = listen */
+ "accept", /* 234 = accept */
+ "connect", /* 235 = connect */
+ "shutdown", /* 236 = shutdown */
+ "svr4_sys_recv", /* 237 = svr4_sys_recv */
+ "recvfrom", /* 238 = recvfrom */
+ "recvmsg", /* 239 = recvmsg */
+ "svr4_sys_send", /* 240 = svr4_sys_send */
+ "sendmsg", /* 241 = sendmsg */
+ "svr4_sys_sendto", /* 242 = svr4_sys_sendto */
+ "getpeername", /* 243 = getpeername */
+ "getsockname", /* 244 = getsockname */
+ "getsockopt", /* 245 = getsockopt */
+ "setsockopt", /* 246 = setsockopt */
+ "#247", /* 247 = sockconfig */
+ "#248", /* 248 = { */
+ "#249", /* 249 = { */
+};
diff --git a/sys/svr4/svr4_sysconfig.h b/sys/svr4/svr4_sysconfig.h
new file mode 100644
index 0000000..bb1000a
--- /dev/null
+++ b/sys/svr4/svr4_sysconfig.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1995 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SYSCONFIG_H_
+#define _SVR4_SYSCONFIG_H_
+
+#define SVR4_CONFIG_UNUSED 0x01
+#define SVR4_CONFIG_NGROUPS 0x02
+#define SVR4_CONFIG_CHILD_MAX 0x03
+#define SVR4_CONFIG_OPEN_FILES 0x04
+#define SVR4_CONFIG_POSIX_VER 0x05
+#define SVR4_CONFIG_PAGESIZE 0x06
+#define SVR4_CONFIG_CLK_TCK 0x07
+#define SVR4_CONFIG_XOPEN_VER 0x08
+#define SVR4_CONFIG_UNUSED_9 0x09
+#define SVR4_CONFIG_PROF_TCK 0x0a
+#define SVR4_CONFIG_NPROC_CONF 0x0b
+#define SVR4_CONFIG_NPROC_ONLN 0x0c
+#define SVR4_CONFIG_AIO_LISTIO_MAX 0x0e
+#define SVR4_CONFIG_AIO_MAX 0x0f
+#define SVR4_CONFIG_AIO_PRIO_DELTA_MAX 0x10
+#define SVR4_CONFIG_DELAYTIMER_MAX 0x11
+#define SVR4_CONFIG_MQ_OPEN_MAX 0x12
+#define SVR4_CONFIG_MQ_PRIO_MAX 0x13
+#define SVR4_CONFIG_RTSIG_MAX 0x14
+#define SVR4_CONFIG_SEM_NSEMS_MAX 0x15
+#define SVR4_CONFIG_SEM_VALUE_MAX 0x16
+#define SVR4_CONFIG_SIGQUEUE_MAX 0x17
+#define SVR4_CONFIG_SIGRT_MIN 0x18
+#define SVR4_CONFIG_SIGRT_MAX 0x19
+#define SVR4_CONFIG_TIMER_MAX 0x20
+#define SVR4_CONFIG_PHYS_PAGES 0x21
+#define SVR4_CONFIG_AVPHYS_PAGES 0x22
+
+#endif /* !_SVR4_SYSCONFIG_H_ */
diff --git a/sys/svr4/svr4_sysent.c b/sys/svr4/svr4_sysent.c
new file mode 100644
index 0000000..3b1415d
--- /dev/null
+++ b/sys/svr4/svr4_sysent.c
@@ -0,0 +1,282 @@
+/*
+ * System call switch table.
+ *
+ * DO NOT EDIT-- this file is automatically generated.
+ * created from; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/param.h>
+#include <sys/file.h>
+#include <sys/filio.h>
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_socket.h>
+#include <svr4/svr4_sockio.h>
+#include <svr4/svr4_timod.h>
+#include <svr4/svr4_proto.h>
+
+/* The casts are bogus but will do for now. */
+struct sysent svr4_sysent[] = {
+ { 0, (sy_call_t *)nosys }, /* 0 = unused */
+ { 1, (sy_call_t *)exit }, /* 1 = exit */
+ { 0, (sy_call_t *)fork }, /* 2 = fork */
+ { 3, (sy_call_t *)read }, /* 3 = read */
+ { 3, (sy_call_t *)write }, /* 4 = write */
+ { 3, (sy_call_t *)svr4_sys_open }, /* 5 = svr4_sys_open */
+ { 1, (sy_call_t *)close }, /* 6 = close */
+ { 1, (sy_call_t *)svr4_sys_wait }, /* 7 = svr4_sys_wait */
+ { 2, (sy_call_t *)svr4_sys_creat }, /* 8 = svr4_sys_creat */
+ { 2, (sy_call_t *)link }, /* 9 = link */
+ { 1, (sy_call_t *)unlink }, /* 10 = unlink */
+ { 2, (sy_call_t *)svr4_sys_execv }, /* 11 = svr4_sys_execv */
+ { 1, (sy_call_t *)chdir }, /* 12 = chdir */
+ { 1, (sy_call_t *)svr4_sys_time }, /* 13 = svr4_sys_time */
+ { 3, (sy_call_t *)svr4_sys_mknod }, /* 14 = svr4_sys_mknod */
+ { 2, (sy_call_t *)chmod }, /* 15 = chmod */
+ { 3, (sy_call_t *)chown }, /* 16 = chown */
+ { 1, (sy_call_t *)svr4_sys_break }, /* 17 = svr4_sys_break */
+ { 2, (sy_call_t *)svr4_sys_stat }, /* 18 = svr4_sys_stat */
+ { 3, (sy_call_t *)lseek }, /* 19 = lseek */
+ { 0, (sy_call_t *)getpid }, /* 20 = getpid */
+ { 0, (sy_call_t *)nosys }, /* 21 = old_mount */
+ { 0, (sy_call_t *)nosys }, /* 22 = sysv_umount */
+ { 1, (sy_call_t *)setuid }, /* 23 = setuid */
+ { 0, (sy_call_t *)getuid }, /* 24 = getuid */
+ { 0, (sy_call_t *)nosys }, /* 25 = stime */
+ { 0, (sy_call_t *)nosys }, /* 26 = ptrace */
+ { 1, (sy_call_t *)svr4_sys_alarm }, /* 27 = svr4_sys_alarm */
+ { 2, (sy_call_t *)svr4_sys_fstat }, /* 28 = svr4_sys_fstat */
+ { 0, (sy_call_t *)svr4_sys_pause }, /* 29 = svr4_sys_pause */
+ { 2, (sy_call_t *)svr4_sys_utime }, /* 30 = svr4_sys_utime */
+ { 0, (sy_call_t *)nosys }, /* 31 = stty */
+ { 0, (sy_call_t *)nosys }, /* 32 = gtty */
+ { 2, (sy_call_t *)svr4_sys_access }, /* 33 = svr4_sys_access */
+ { 1, (sy_call_t *)svr4_sys_nice }, /* 34 = svr4_sys_nice */
+ { 0, (sy_call_t *)nosys }, /* 35 = statfs */
+ { 0, (sy_call_t *)sync }, /* 36 = sync */
+ { 2, (sy_call_t *)svr4_sys_kill }, /* 37 = svr4_sys_kill */
+ { 0, (sy_call_t *)nosys }, /* 38 = fstatfs */
+ { 3, (sy_call_t *)svr4_sys_pgrpsys }, /* 39 = svr4_sys_pgrpsys */
+ { 0, (sy_call_t *)nosys }, /* 40 = xenix */
+ { 1, (sy_call_t *)dup }, /* 41 = dup */
+ { 0, (sy_call_t *)pipe }, /* 42 = pipe */
+ { 1, (sy_call_t *)svr4_sys_times }, /* 43 = svr4_sys_times */
+ { 0, (sy_call_t *)nosys }, /* 44 = profil */
+ { 0, (sy_call_t *)nosys }, /* 45 = plock */
+ { 1, (sy_call_t *)setgid }, /* 46 = setgid */
+ { 0, (sy_call_t *)getgid }, /* 47 = getgid */
+ { 2, (sy_call_t *)svr4_sys_signal }, /* 48 = svr4_sys_signal */
+#if defined(NOTYET)
+ { 5, (sy_call_t *)svr4_sys_msgsys }, /* 49 = svr4_sys_msgsys */
+#else
+ { 0, (sy_call_t *)nosys }, /* 49 = msgsys */
+#endif
+ { 2, (sy_call_t *)svr4_sys_sysarch }, /* 50 = svr4_sys_sysarch */
+ { 0, (sy_call_t *)nosys }, /* 51 = acct */
+ { 0, (sy_call_t *)nosys }, /* 52 = shmsys */
+ { 0, (sy_call_t *)nosys }, /* 53 = semsys */
+ { 3, (sy_call_t *)svr4_sys_ioctl }, /* 54 = svr4_sys_ioctl */
+ { 0, (sy_call_t *)nosys }, /* 55 = uadmin */
+ { 0, (sy_call_t *)nosys }, /* 56 = exch */
+ { 4, (sy_call_t *)svr4_sys_utssys }, /* 57 = svr4_sys_utssys */
+ { 1, (sy_call_t *)fsync }, /* 58 = fsync */
+ { 3, (sy_call_t *)svr4_sys_execve }, /* 59 = svr4_sys_execve */
+ { 1, (sy_call_t *)umask }, /* 60 = umask */
+ { 1, (sy_call_t *)chroot }, /* 61 = chroot */
+ { 3, (sy_call_t *)svr4_sys_fcntl }, /* 62 = svr4_sys_fcntl */
+ { 2, (sy_call_t *)svr4_sys_ulimit }, /* 63 = svr4_sys_ulimit */
+ { 0, (sy_call_t *)nosys }, /* 64 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 65 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 66 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 67 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 68 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 69 = reserved */
+ { 0, (sy_call_t *)nosys }, /* 70 = advfs */
+ { 0, (sy_call_t *)nosys }, /* 71 = unadvfs */
+ { 0, (sy_call_t *)nosys }, /* 72 = rmount */
+ { 0, (sy_call_t *)nosys }, /* 73 = rumount */
+ { 0, (sy_call_t *)nosys }, /* 74 = rfstart */
+ { 0, (sy_call_t *)nosys }, /* 75 = sigret */
+ { 0, (sy_call_t *)nosys }, /* 76 = rdebug */
+ { 0, (sy_call_t *)nosys }, /* 77 = rfstop */
+ { 0, (sy_call_t *)nosys }, /* 78 = rfsys */
+ { 1, (sy_call_t *)rmdir }, /* 79 = rmdir */
+ { 2, (sy_call_t *)mkdir }, /* 80 = mkdir */
+ { 3, (sy_call_t *)svr4_sys_getdents }, /* 81 = svr4_sys_getdents */
+ { 0, (sy_call_t *)nosys }, /* 82 = libattach */
+ { 0, (sy_call_t *)nosys }, /* 83 = libdetach */
+ { 0, (sy_call_t *)nosys }, /* 84 = sysfs */
+ { 4, (sy_call_t *)svr4_sys_getmsg }, /* 85 = svr4_sys_getmsg */
+ { 4, (sy_call_t *)svr4_sys_putmsg }, /* 86 = svr4_sys_putmsg */
+ { 3, (sy_call_t *)svr4_sys_poll }, /* 87 = svr4_sys_poll */
+ { 2, (sy_call_t *)svr4_sys_lstat }, /* 88 = svr4_sys_lstat */
+ { 2, (sy_call_t *)symlink }, /* 89 = symlink */
+ { 3, (sy_call_t *)readlink }, /* 90 = readlink */
+ { 2, (sy_call_t *)getgroups }, /* 91 = getgroups */
+ { 2, (sy_call_t *)setgroups }, /* 92 = setgroups */
+ { 2, (sy_call_t *)fchmod }, /* 93 = fchmod */
+ { 3, (sy_call_t *)fchown }, /* 94 = fchown */
+ { 3, (sy_call_t *)svr4_sys_sigprocmask }, /* 95 = svr4_sys_sigprocmask */
+ { 1, (sy_call_t *)svr4_sys_sigsuspend }, /* 96 = svr4_sys_sigsuspend */
+ { 2, (sy_call_t *)svr4_sys_sigaltstack }, /* 97 = svr4_sys_sigaltstack */
+ { 3, (sy_call_t *)svr4_sys_sigaction }, /* 98 = svr4_sys_sigaction */
+ { 2, (sy_call_t *)svr4_sys_sigpending }, /* 99 = svr4_sys_sigpending */
+ { 2, (sy_call_t *)svr4_sys_context }, /* 100 = svr4_sys_context */
+ { 0, (sy_call_t *)nosys }, /* 101 = evsys */
+ { 0, (sy_call_t *)nosys }, /* 102 = evtrapret */
+ { 2, (sy_call_t *)svr4_sys_statvfs }, /* 103 = svr4_sys_statvfs */
+ { 2, (sy_call_t *)svr4_sys_fstatvfs }, /* 104 = svr4_sys_fstatvfs */
+ { 0, (sy_call_t *)nosys }, /* 105 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 106 = nfssvc */
+ { 4, (sy_call_t *)svr4_sys_waitsys }, /* 107 = svr4_sys_waitsys */
+ { 0, (sy_call_t *)nosys }, /* 108 = sigsendsys */
+ { 5, (sy_call_t *)svr4_sys_hrtsys }, /* 109 = svr4_sys_hrtsys */
+ { 0, (sy_call_t *)nosys }, /* 110 = acancel */
+ { 0, (sy_call_t *)nosys }, /* 111 = async */
+ { 0, (sy_call_t *)nosys }, /* 112 = priocntlsys */
+ { 2, (sy_call_t *)svr4_sys_pathconf }, /* 113 = svr4_sys_pathconf */
+ { 0, (sy_call_t *)nosys }, /* 114 = mincore */
+ { 6, (sy_call_t *)svr4_sys_mmap }, /* 115 = svr4_sys_mmap */
+ { 3, (sy_call_t *)mprotect }, /* 116 = mprotect */
+ { 2, (sy_call_t *)munmap }, /* 117 = munmap */
+ { 2, (sy_call_t *)svr4_sys_fpathconf }, /* 118 = svr4_sys_fpathconf */
+ { 0, (sy_call_t *)vfork }, /* 119 = vfork */
+ { 1, (sy_call_t *)fchdir }, /* 120 = fchdir */
+ { 3, (sy_call_t *)readv }, /* 121 = readv */
+ { 3, (sy_call_t *)writev }, /* 122 = writev */
+ { 3, (sy_call_t *)svr4_sys_xstat }, /* 123 = svr4_sys_xstat */
+ { 3, (sy_call_t *)svr4_sys_lxstat }, /* 124 = svr4_sys_lxstat */
+ { 3, (sy_call_t *)svr4_sys_fxstat }, /* 125 = svr4_sys_fxstat */
+ { 4, (sy_call_t *)svr4_sys_xmknod }, /* 126 = svr4_sys_xmknod */
+ { 0, (sy_call_t *)nosys }, /* 127 = clocal */
+ { 2, (sy_call_t *)svr4_sys_setrlimit }, /* 128 = svr4_sys_setrlimit */
+ { 2, (sy_call_t *)svr4_sys_getrlimit }, /* 129 = svr4_sys_getrlimit */
+ { 3, (sy_call_t *)lchown }, /* 130 = lchown */
+ { 6, (sy_call_t *)svr4_sys_memcntl }, /* 131 = svr4_sys_memcntl */
+ { 0, (sy_call_t *)nosys }, /* 132 = getpmsg */
+ { 0, (sy_call_t *)nosys }, /* 133 = putpmsg */
+ { 2, (sy_call_t *)rename }, /* 134 = rename */
+ { 2, (sy_call_t *)svr4_sys_uname }, /* 135 = svr4_sys_uname */
+ { 1, (sy_call_t *)setegid }, /* 136 = setegid */
+ { 1, (sy_call_t *)svr4_sys_sysconfig }, /* 137 = svr4_sys_sysconfig */
+ { 2, (sy_call_t *)adjtime }, /* 138 = adjtime */
+ { 3, (sy_call_t *)svr4_sys_systeminfo }, /* 139 = svr4_sys_systeminfo */
+ { 0, (sy_call_t *)nosys }, /* 140 = notused */
+ { 1, (sy_call_t *)seteuid }, /* 141 = seteuid */
+ { 0, (sy_call_t *)nosys }, /* 142 = vtrace */
+ { 0, (sy_call_t *)nosys }, /* 143 = { */
+ { 0, (sy_call_t *)nosys }, /* 144 = sigtimedwait */
+ { 0, (sy_call_t *)nosys }, /* 145 = lwp_info */
+ { 0, (sy_call_t *)nosys }, /* 146 = yield */
+ { 0, (sy_call_t *)nosys }, /* 147 = lwp_sema_wait */
+ { 0, (sy_call_t *)nosys }, /* 148 = lwp_sema_post */
+ { 0, (sy_call_t *)nosys }, /* 149 = lwp_sema_trywait */
+ { 0, (sy_call_t *)nosys }, /* 150 = notused */
+ { 0, (sy_call_t *)nosys }, /* 151 = notused */
+ { 0, (sy_call_t *)nosys }, /* 152 = modctl */
+ { 1, (sy_call_t *)svr4_sys_fchroot }, /* 153 = svr4_sys_fchroot */
+ { 2, (sy_call_t *)svr4_sys_utimes }, /* 154 = svr4_sys_utimes */
+ { 0, (sy_call_t *)svr4_sys_vhangup }, /* 155 = svr4_sys_vhangup */
+ { 1, (sy_call_t *)svr4_sys_gettimeofday }, /* 156 = svr4_sys_gettimeofday */
+ { 2, (sy_call_t *)getitimer }, /* 157 = getitimer */
+ { 3, (sy_call_t *)setitimer }, /* 158 = setitimer */
+ { 0, (sy_call_t *)nosys }, /* 159 = lwp_create */
+ { 0, (sy_call_t *)nosys }, /* 160 = lwp_exit */
+ { 0, (sy_call_t *)nosys }, /* 161 = lwp_suspend */
+ { 0, (sy_call_t *)nosys }, /* 162 = lwp_continue */
+ { 0, (sy_call_t *)nosys }, /* 163 = lwp_kill */
+ { 0, (sy_call_t *)nosys }, /* 164 = lwp_self */
+ { 0, (sy_call_t *)nosys }, /* 165 = lwp_getprivate */
+ { 0, (sy_call_t *)nosys }, /* 166 = lwp_setprivate */
+ { 0, (sy_call_t *)nosys }, /* 167 = lwp_wait */
+ { 0, (sy_call_t *)nosys }, /* 168 = lwp_mutex_unlock */
+ { 0, (sy_call_t *)nosys }, /* 169 = lwp_mutex_lock */
+ { 0, (sy_call_t *)nosys }, /* 170 = lwp_cond_wait */
+ { 0, (sy_call_t *)nosys }, /* 171 = lwp_cond_signal */
+ { 0, (sy_call_t *)nosys }, /* 172 = lwp_cond_broadcast */
+ { 0, (sy_call_t *)nosys }, /* 173 = { */
+ { 0, (sy_call_t *)nosys }, /* 174 = { */
+ { 4, (sy_call_t *)svr4_sys_llseek }, /* 175 = svr4_sys_llseek */
+ { 0, (sy_call_t *)nosys }, /* 176 = inst_sync */
+ { 0, (sy_call_t *)nosys }, /* 177 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 178 = kaio */
+ { 0, (sy_call_t *)nosys }, /* 179 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 180 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 181 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 182 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 183 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 184 = tsolsys */
+ { 4, (sy_call_t *)svr4_sys_acl }, /* 185 = svr4_sys_acl */
+ { 6, (sy_call_t *)svr4_sys_auditsys }, /* 186 = svr4_sys_auditsys */
+ { 0, (sy_call_t *)nosys }, /* 187 = processor_bind */
+ { 0, (sy_call_t *)nosys }, /* 188 = processor_info */
+ { 0, (sy_call_t *)nosys }, /* 189 = p_online */
+ { 0, (sy_call_t *)nosys }, /* 190 = sigqueue */
+ { 0, (sy_call_t *)nosys }, /* 191 = clock_gettime */
+ { 0, (sy_call_t *)nosys }, /* 192 = clock_settime */
+ { 0, (sy_call_t *)nosys }, /* 193 = clock_getres */
+ { 0, (sy_call_t *)nosys }, /* 194 = timer_create */
+ { 0, (sy_call_t *)nosys }, /* 195 = timer_delete */
+ { 0, (sy_call_t *)nosys }, /* 196 = timer_settime */
+ { 0, (sy_call_t *)nosys }, /* 197 = timer_gettime */
+ { 0, (sy_call_t *)nosys }, /* 198 = timer_overrun */
+ { 2, (sy_call_t *)nanosleep }, /* 199 = nanosleep */
+ { 4, (sy_call_t *)svr4_sys_facl }, /* 200 = svr4_sys_facl */
+ { 0, (sy_call_t *)nosys }, /* 201 = door */
+ { 2, (sy_call_t *)setreuid }, /* 202 = setreuid */
+ { 2, (sy_call_t *)setregid }, /* 203 = setregid */
+ { 0, (sy_call_t *)nosys }, /* 204 = install_utrap */
+ { 0, (sy_call_t *)nosys }, /* 205 = signotify */
+ { 0, (sy_call_t *)nosys }, /* 206 = schedctl */
+ { 0, (sy_call_t *)nosys }, /* 207 = pset */
+ { 0, (sy_call_t *)nosys }, /* 208 = whoknows */
+ { 3, (sy_call_t *)svr4_sys_resolvepath }, /* 209 = svr4_sys_resolvepath */
+ { 0, (sy_call_t *)nosys }, /* 210 = signotifywait */
+ { 0, (sy_call_t *)nosys }, /* 211 = lwp_sigredirect */
+ { 0, (sy_call_t *)nosys }, /* 212 = lwp_alarm */
+ { 3, (sy_call_t *)svr4_sys_getdents64 }, /* 213 = svr4_sys_getdents64 */
+ { 6, (sy_call_t *)svr4_sys_mmap64 }, /* 214 = svr4_sys_mmap64 */
+ { 2, (sy_call_t *)svr4_sys_stat64 }, /* 215 = svr4_sys_stat64 */
+ { 2, (sy_call_t *)svr4_sys_lstat64 }, /* 216 = svr4_sys_lstat64 */
+ { 2, (sy_call_t *)svr4_sys_fstat64 }, /* 217 = svr4_sys_fstat64 */
+ { 2, (sy_call_t *)svr4_sys_statvfs64 }, /* 218 = svr4_sys_statvfs64 */
+ { 2, (sy_call_t *)svr4_sys_fstatvfs64 }, /* 219 = svr4_sys_fstatvfs64 */
+ { 2, (sy_call_t *)svr4_sys_setrlimit64 }, /* 220 = svr4_sys_setrlimit64 */
+ { 2, (sy_call_t *)svr4_sys_getrlimit64 }, /* 221 = svr4_sys_getrlimit64 */
+ { 0, (sy_call_t *)nosys }, /* 222 = pread64 */
+ { 0, (sy_call_t *)nosys }, /* 223 = pwrite64 */
+ { 2, (sy_call_t *)svr4_sys_creat64 }, /* 224 = svr4_sys_creat64 */
+ { 3, (sy_call_t *)svr4_sys_open64 }, /* 225 = svr4_sys_open64 */
+ { 0, (sy_call_t *)nosys }, /* 226 = rpcsys */
+ { 0, (sy_call_t *)nosys }, /* 227 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 228 = whoknows */
+ { 0, (sy_call_t *)nosys }, /* 229 = whoknows */
+ { 3, (sy_call_t *)svr4_sys_socket }, /* 230 = svr4_sys_socket */
+ { 4, (sy_call_t *)socketpair }, /* 231 = socketpair */
+ { 3, (sy_call_t *)bind }, /* 232 = bind */
+ { 2, (sy_call_t *)listen }, /* 233 = listen */
+ { 3, (sy_call_t *)accept }, /* 234 = accept */
+ { 3, (sy_call_t *)connect }, /* 235 = connect */
+ { 2, (sy_call_t *)shutdown }, /* 236 = shutdown */
+ { 4, (sy_call_t *)svr4_sys_recv }, /* 237 = svr4_sys_recv */
+ { 6, (sy_call_t *)recvfrom }, /* 238 = recvfrom */
+ { 3, (sy_call_t *)recvmsg }, /* 239 = recvmsg */
+ { 4, (sy_call_t *)svr4_sys_send }, /* 240 = svr4_sys_send */
+ { 3, (sy_call_t *)sendmsg }, /* 241 = sendmsg */
+ { 6, (sy_call_t *)svr4_sys_sendto }, /* 242 = svr4_sys_sendto */
+ { 3, (sy_call_t *)getpeername }, /* 243 = getpeername */
+ { 3, (sy_call_t *)getsockname }, /* 244 = getsockname */
+ { 5, (sy_call_t *)getsockopt }, /* 245 = getsockopt */
+ { 5, (sy_call_t *)setsockopt }, /* 246 = setsockopt */
+ { 0, (sy_call_t *)nosys }, /* 247 = sockconfig */
+ { 0, (sy_call_t *)nosys }, /* 248 = { */
+ { 0, (sy_call_t *)nosys }, /* 249 = { */
+};
diff --git a/sys/svr4/svr4_systeminfo.h b/sys/svr4/svr4_systeminfo.h
new file mode 100644
index 0000000..520c6fa
--- /dev/null
+++ b/sys/svr4/svr4_systeminfo.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_SYSTEMINFO_H_
+#define _SVR4_SYSTEMINFO_H_
+
+#define SVR4_SI_SYSNAME 1
+#define SVR4_SI_HOSTNAME 2
+#define SVR4_SI_RELEASE 3
+#define SVR4_SI_VERSION 4
+#define SVR4_SI_MACHINE 5
+#define SVR4_SI_ARCHITECTURE 6
+#define SVR4_SI_HW_SERIAL 7
+#define SVR4_SI_HW_PROVIDER 8
+#define SVR4_SI_SRPC_DOMAIN 9
+#define SVR4_SI_SET_HOSTNAME 258
+#define SVR4_SI_SET_SRPC_DOMAIN 265
+#define SVR4_SI_SET_KERB_REALM 266
+#define SVR4_SI_KERB_REALM 267
+#define SVR4_SI_PLATFORM 513
+#define SVR4_SI_ISALIST 514
+
+#endif /* !_SVR4_SYSTEMINFO_H_ */
diff --git a/sys/svr4/svr4_sysvec.c b/sys/svr4/svr4_sysvec.c
new file mode 100644
index 0000000..8b0997d
--- /dev/null
+++ b/sys/svr4/svr4_sysvec.c
@@ -0,0 +1,383 @@
+/* XXX we use functions that might not exist. */
+#include "opt_compat.h"
+
+#ifndef COMPAT_43
+#error "Unable to compile SVR4-emulator due to missing COMPAT_43 option!"
+#endif
+
+#include <sys/param.h>
+#include <sys/buf.h>
+#include <sys/proc.h>
+#include <sys/systm.h>
+#include <sys/sysent.h>
+#include <sys/imgact.h>
+#include <sys/imgact_elf.h>
+#include <sys/socket.h>
+#include <sys/sockio.h>
+#include <sys/signalvar.h>
+#include <sys/malloc.h>
+#include <sys/namei.h>
+#include <sys/vnode.h>
+#include <sys/module.h>
+#include <vm/vm.h>
+#include <vm/vm_param.h>
+#include <vm/vm_prot.h>
+#include <vm/vm_page.h>
+#include <vm/vm_extern.h>
+#include <sys/exec.h>
+#include <sys/kernel.h>
+#include <machine/cpu.h>
+#include <netinet/in.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_syscall.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_sockio.h>
+#include <svr4/svr4_socket.h>
+#include <svr4/svr4_errno.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_siginfo.h>
+#include <svr4/svr4_util.h>
+
+extern int bsd_to_svr4_sig[];
+extern int svr4_to_bsd_sig[];
+
+int bsd_to_svr4_errno[ELAST+1] = {
+ 0,
+ SVR4_EPERM,
+ SVR4_ENOENT,
+ SVR4_ESRCH,
+ SVR4_EINTR,
+ SVR4_EIO,
+ SVR4_ENXIO,
+ SVR4_E2BIG,
+ SVR4_ENOEXEC,
+ SVR4_EBADF,
+ SVR4_ECHILD,
+ SVR4_EDEADLK,
+ SVR4_ENOMEM,
+ SVR4_EACCES,
+ SVR4_EFAULT,
+ SVR4_ENOTBLK,
+ SVR4_EBUSY,
+ SVR4_EEXIST,
+ SVR4_EXDEV,
+ SVR4_ENODEV,
+ SVR4_ENOTDIR,
+ SVR4_EISDIR,
+ SVR4_EINVAL,
+ SVR4_ENFILE,
+ SVR4_EMFILE,
+ SVR4_ENOTTY,
+ SVR4_ETXTBSY,
+ SVR4_EFBIG,
+ SVR4_ENOSPC,
+ SVR4_ESPIPE,
+ SVR4_EROFS,
+ SVR4_EMLINK,
+ SVR4_EPIPE,
+ SVR4_EDOM,
+ SVR4_ERANGE,
+ SVR4_EAGAIN,
+ SVR4_EINPROGRESS,
+ SVR4_EALREADY,
+ SVR4_ENOTSOCK,
+ SVR4_EDESTADDRREQ,
+ SVR4_EMSGSIZE,
+ SVR4_EPROTOTYPE,
+ SVR4_ENOPROTOOPT,
+ SVR4_EPROTONOSUPPORT,
+ SVR4_ESOCKTNOSUPPORT,
+ SVR4_EOPNOTSUPP,
+ SVR4_EPFNOSUPPORT,
+ SVR4_EAFNOSUPPORT,
+ SVR4_EADDRINUSE,
+ SVR4_EADDRNOTAVAIL,
+ SVR4_ENETDOWN,
+ SVR4_ENETUNREACH,
+ SVR4_ENETRESET,
+ SVR4_ECONNABORTED,
+ SVR4_ECONNRESET,
+ SVR4_ENOBUFS,
+ SVR4_EISCONN,
+ SVR4_ENOTCONN,
+ SVR4_ESHUTDOWN,
+ SVR4_ETOOMANYREFS,
+ SVR4_ETIMEDOUT,
+ SVR4_ECONNREFUSED,
+ SVR4_ELOOP,
+ SVR4_ENAMETOOLONG,
+ SVR4_EHOSTDOWN,
+ SVR4_EHOSTUNREACH,
+ SVR4_ENOTEMPTY,
+ SVR4_EPROCLIM,
+ SVR4_EUSERS,
+ SVR4_EDQUOT,
+ SVR4_ESTALE,
+ SVR4_EREMOTE,
+ SVR4_EBADRPC,
+ SVR4_ERPCMISMATCH,
+ SVR4_EPROGUNAVAIL,
+ SVR4_EPROGMISMATCH,
+ SVR4_EPROCUNAVAIL,
+ SVR4_ENOLCK,
+ SVR4_ENOSYS,
+ SVR4_EFTYPE,
+ SVR4_EAUTH,
+ SVR4_ENEEDAUTH,
+ SVR4_EIDRM,
+ SVR4_ENOMSG,
+};
+
+
+static int svr4_fixup(long **stack_base, struct image_params *imgp);
+
+extern struct sysent svr4_sysent[];
+#undef szsigcode
+#undef sigcode
+
+extern int svr4_szsigcode;
+extern char svr4_sigcode[];
+
+struct sysentvec svr4_sysvec = {
+ SVR4_SYS_MAXSYSCALL,
+ svr4_sysent,
+ 0xff,
+ NSIG,
+ bsd_to_svr4_sig,
+ ELAST, /* ELAST */
+ bsd_to_svr4_errno,
+ 0,
+ svr4_fixup,
+ svr4_sendsig,
+ svr4_sigcode,
+ &svr4_szsigcode,
+ 0,
+ "SVR4"
+};
+
+Elf32_Brandinfo svr4_brand = {
+ "SVR4",
+ "/compat/svr4",
+ "/lib/libc.so.1",
+ &svr4_sysvec
+};
+
+const char svr4_emul_path[] = "/compat/svr4";
+
+static int
+svr4_fixup(long **stack_base, struct image_params *imgp)
+{
+ Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;
+ long *pos;
+
+ pos = *stack_base + (imgp->argc + imgp->envc + 2);
+
+ if (args->trace) {
+ AUXARGS_ENTRY(pos, AT_DEBUG, 1);
+ }
+ if (args->execfd != -1) {
+ AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
+ }
+ AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
+ AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
+ AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
+ AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
+ AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
+ AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
+ AUXARGS_ENTRY(pos, AT_BASE, args->base);
+ AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_cred->p_ruid);
+ AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_cred->p_svuid);
+ AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_cred->p_rgid);
+ AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_cred->p_svgid);
+ AUXARGS_ENTRY(pos, AT_NULL, 0);
+
+ free(imgp->auxargs, M_TEMP);
+ imgp->auxargs = NULL;
+
+ (*stack_base)--;
+ **stack_base = (int)imgp->argc;
+ return 0;
+}
+
+/*
+ * 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.
+ *
+ * Code shamelessly stolen by Mark Newton from IBCS2 emulation code.
+ */
+int
+svr4_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 svr4_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 :-(
+ */
+ NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, svr4_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;
+}
+
+/*
+ * XXX: wrong, for the same reason described in linux_sysvec.c
+ */
+static int svr4_elf_modevent __P((module_t mod, int type, void *data));
+
+static int
+svr4_elf_modevent(module_t mod, int type, void *data)
+{
+ int error;
+
+ error = 0;
+
+ switch(type) {
+ case MOD_LOAD:
+ if (elf_insert_brand_entry(&svr4_brand) < 0)
+ error = EINVAL;
+ if (error)
+ printf("cannot insert svr4 elf brand handler\n");
+ else if (bootverbose)
+ printf("svr4 ELF exec handler installed\n");
+ break;
+ case MOD_UNLOAD:
+ /* XXX There needs to be a generic function that any
+ * emulator can call to say, "Are any currently-running
+ * executables using me?" so we can fail to unload the
+ * module if it's in use. Locking up because you forgot
+ * to shut down a program prior to a kldunload isn't fun.
+ */
+ if (elf_remove_brand_entry(&svr4_brand) < 0)
+ error = EINVAL;
+ if (error)
+ printf("Could not deinstall ELF interpreter entry\n");
+ else if (bootverbose)
+ printf("svr4 ELF exec handler removed\n");
+ break;
+ default:
+ break;
+ }
+ return error;
+}
+
+static moduledata_t svr4_elf_mod = {
+ "svr4elf",
+ svr4_elf_modevent,
+ 0
+};
+DECLARE_MODULE(svr4elf, svr4_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);
diff --git a/sys/svr4/svr4_termios.c b/sys/svr4/svr4_termios.c
new file mode 100644
index 0000000..fd5db71
--- /dev/null
+++ b/sys/svr4/svr4_termios.c
@@ -0,0 +1,619 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/proc.h>
+#include <sys/systm.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/fcntl.h>
+#include <sys/unistd.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/socket.h>
+#include <sys/mount.h>
+#include <net/if.h>
+#include <sys/malloc.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4.h>
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_ioctl.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_termios.h>
+
+
+#ifndef __CONCAT3
+# if __STDC__
+# define __CONCAT3(a,b,c) a ## b ## c
+# else
+# define __CONCAT3(a,b,c) a/**/b/**/c
+# endif
+#endif
+
+static u_long bsd_to_svr4_speed __P((u_long, u_long));
+static u_long svr4_to_bsd_speed __P((u_long, u_long));
+static void svr4_to_bsd_termios __P((const struct svr4_termios *,
+ struct termios *, int));
+static void bsd_to_svr4_termios __P((const struct termios *,
+ struct svr4_termios *));
+static void svr4_termio_to_termios __P((const struct svr4_termio *,
+ struct svr4_termios *));
+static void svr4_termios_to_termio __P((const struct svr4_termios *,
+ struct svr4_termio *));
+#ifdef DEBUG_SVR4
+static void print_svr4_termios __P((const struct svr4_termios *));
+static void print_bsd_termios __P((const struct termios *));
+#endif /* DEBUG_SVR4 */
+
+#define undefined_char(a,b) /**/
+#define undefined_flag1(f,a,b) /**/
+#define undefined_flag2(f,a,b,c1,t1,c2,t2) /**/
+#define undefined_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) /**/
+
+#define svr4_to_bsd_char(a,b) \
+ if (new || __CONCAT3(SVR4_,a,b) < SVR4_NCC) { \
+ if (st->c_cc[__CONCAT3(SVR4_,a,b)] == SVR4_POSIX_VDISABLE) \
+ bt->c_cc[__CONCAT(a,b)] = _POSIX_VDISABLE; \
+ else \
+ bt->c_cc[__CONCAT(a,b)] = st->c_cc[__CONCAT3(SVR4_,a,b)]; \
+ }
+
+#define svr4_to_bsd_flag1(f,a,b) \
+ if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
+ if (st->f & __CONCAT3(SVR4_,a,b)) \
+ bt->f |= __CONCAT(a,b); \
+ else \
+ bt->f &= ~__CONCAT(a,b); \
+ }
+
+#define svr4_to_bsd_flag2(f,a,b,c1,t1,c2,t2) \
+ if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
+ bt->f &= ~__CONCAT(a,b); \
+ switch (st->f & __CONCAT3(SVR4_,a,b)) { \
+ case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
+ case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
+ } \
+ }
+
+#define svr4_to_bsd_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
+ if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
+ bt->f &= ~__CONCAT(a,b); \
+ switch (st->f & __CONCAT3(SVR4_,a,b)) { \
+ case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
+ case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
+ case __CONCAT3(SVR4_,c3,t3): bt->f |= __CONCAT(c3,t3); break; \
+ case __CONCAT3(SVR4_,c4,t4): bt->f |= __CONCAT(c4,t4); break; \
+ } \
+ }
+
+
+#define bsd_to_svr4_char(a,b) \
+ if (bt->c_cc[__CONCAT(a,b)] == _POSIX_VDISABLE) \
+ st->c_cc[__CONCAT3(SVR4_,a,b)] = SVR4_POSIX_VDISABLE; \
+ else \
+ st->c_cc[__CONCAT3(SVR4_,a,b)] = bt->c_cc[__CONCAT(a,b)]
+
+#define bsd_to_svr4_flag1(f,a,b) \
+ if (bt->f & __CONCAT(a,b)) \
+ st->f |= __CONCAT3(SVR4_,a,b); \
+ else \
+ st->f &= ~__CONCAT3(SVR4_,a,b)
+
+#define bsd_to_svr4_flag2(f,a,b,c1,t1,c2,t2) \
+ st->f &= ~__CONCAT(a,b); \
+ switch (bt->f & __CONCAT(a,b)) { \
+ case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
+ case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
+ }
+
+#define bsd_to_svr4_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
+ st->f &= ~__CONCAT(a,b); \
+ switch (bt->f & __CONCAT(a,b)) { \
+ case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
+ case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
+ case __CONCAT(c3,t3): st->f |= __CONCAT3(SVR4_,c3,t3); break; \
+ case __CONCAT(c4,t4): st->f |= __CONCAT3(SVR4_,c4,t4); break; \
+ }
+
+#ifdef DEBUG_SVR4
+static void
+print_svr4_termios(st)
+ const struct svr4_termios *st;
+{
+ int i;
+ DPRINTF(("SVR4\niflag=%lo oflag=%lo cflag=%lo lflag=%lo\n",
+ st->c_iflag, st->c_oflag, st->c_cflag, st->c_lflag));
+ DPRINTF(("cc: "));
+ for (i = 0; i < SVR4_NCCS; i++)
+ DPRINTF(("%o ", st->c_cc[i]));
+ DPRINTF(("\n"));
+}
+
+
+static void
+print_bsd_termios(bt)
+ const struct termios *bt;
+{
+ int i;
+ uprintf("BSD\niflag=%o oflag=%o cflag=%o lflag=%o\n",
+ bt->c_iflag, bt->c_oflag, bt->c_cflag, bt->c_lflag);
+ uprintf("cc: ");
+ for (i = 0; i < NCCS; i++)
+ uprintf("%o ", bt->c_cc[i]);
+ uprintf("\n");
+}
+#endif /* DEBUG_SVR4 */
+
+static u_long
+bsd_to_svr4_speed(sp, mask)
+ u_long sp;
+ u_long mask;
+{
+ switch (sp) {
+#undef getval
+#define getval(a,b) case __CONCAT(a,b): sp = __CONCAT3(SVR4_,a,b)
+ getval(B,0);
+ getval(B,50);
+ getval(B,75);
+ getval(B,110);
+ getval(B,134);
+ getval(B,150);
+ getval(B,200);
+ getval(B,300);
+ getval(B,600);
+ getval(B,1200);
+ getval(B,1800);
+ getval(B,2400);
+ getval(B,4800);
+ getval(B,9600);
+ getval(B,19200);
+ getval(B,38400);
+ getval(B,57600);
+ getval(B,115200);
+ default: sp = SVR4_B9600; /* XXX */
+ }
+
+ while ((mask & 1) == 0) {
+ mask >>= 1;
+ sp <<= 1;
+ }
+
+ return sp;
+}
+
+
+static u_long
+svr4_to_bsd_speed(sp, mask)
+ u_long sp;
+ u_long mask;
+{
+ while ((mask & 1) == 0) {
+ mask >>= 1;
+ sp >>= 1;
+ }
+
+ switch (sp & mask) {
+#undef getval
+#define getval(a,b) case __CONCAT3(SVR4_,a,b): return __CONCAT(a,b)
+ getval(B,0);
+ getval(B,50);
+ getval(B,75);
+ getval(B,110);
+ getval(B,134);
+ getval(B,150);
+ getval(B,200);
+ getval(B,300);
+ getval(B,600);
+ getval(B,1200);
+ getval(B,1800);
+ getval(B,2400);
+ getval(B,4800);
+ getval(B,9600);
+ getval(B,19200);
+ getval(B,38400);
+ getval(B,57600);
+ getval(B,115200);
+ default: return B9600; /* XXX */
+ }
+}
+
+
+static void
+svr4_to_bsd_termios(st, bt, new)
+ const struct svr4_termios *st;
+ struct termios *bt;
+ int new;
+{
+ /* control characters */
+ /*
+ * We process VMIN and VTIME first,
+ * because they are shared with VEOF and VEOL
+ */
+ svr4_to_bsd_char(V,MIN);
+ svr4_to_bsd_char(V,TIME);
+
+ svr4_to_bsd_char(V,INTR);
+ svr4_to_bsd_char(V,QUIT);
+ svr4_to_bsd_char(V,ERASE);
+ svr4_to_bsd_char(V,KILL);
+ svr4_to_bsd_char(V,EOF);
+ svr4_to_bsd_char(V,EOL);
+ svr4_to_bsd_char(V,EOL2);
+ undefined_char(V,SWTCH);
+ svr4_to_bsd_char(V,START);
+ svr4_to_bsd_char(V,STOP);
+ svr4_to_bsd_char(V,SUSP);
+ svr4_to_bsd_char(V,DSUSP);
+ svr4_to_bsd_char(V,REPRINT);
+ svr4_to_bsd_char(V,DISCARD);
+ svr4_to_bsd_char(V,WERASE);
+ svr4_to_bsd_char(V,LNEXT);
+
+ /* Input modes */
+ svr4_to_bsd_flag1(c_iflag,I,GNBRK);
+ svr4_to_bsd_flag1(c_iflag,B,RKINT);
+ svr4_to_bsd_flag1(c_iflag,I,GNPAR);
+ svr4_to_bsd_flag1(c_iflag,P,ARMRK);
+ svr4_to_bsd_flag1(c_iflag,I,NPCK);
+ svr4_to_bsd_flag1(c_iflag,I,STRIP);
+ svr4_to_bsd_flag1(c_iflag,I,NLCR);
+ svr4_to_bsd_flag1(c_iflag,I,GNCR);
+ svr4_to_bsd_flag1(c_iflag,I,CRNL);
+ undefined_flag1(c_iflag,I,UCLC);
+ svr4_to_bsd_flag1(c_iflag,I,XON);
+ svr4_to_bsd_flag1(c_iflag,I,XANY);
+ svr4_to_bsd_flag1(c_iflag,I,XOFF);
+ svr4_to_bsd_flag1(c_iflag,I,MAXBEL);
+ undefined_flag1(c_iflag,D,OSMODE);
+
+ /* Output modes */
+ svr4_to_bsd_flag1(c_oflag,O,POST);
+ undefined_flag1(c_oflag,O,LCUC);
+ svr4_to_bsd_flag1(c_oflag,O,NLCR);
+ undefined_flag1(c_oflag,O,CRNL);
+ undefined_flag1(c_oflag,O,NOCR);
+ undefined_flag1(c_oflag,O,NLRET);
+ undefined_flag1(c_oflag,O,FILL);
+ undefined_flag1(c_oflag,O,FDEL);
+ undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
+ undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
+ undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
+ undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
+ undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
+ undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
+ undefined_flag1(c_oflag,P,AGEOUT);
+ undefined_flag1(c_oflag,W,RAP);
+
+ /* Control modes */
+ bt->c_ospeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CBAUD);
+ svr4_to_bsd_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
+ svr4_to_bsd_flag1(c_cflag,C,STOPB);
+ svr4_to_bsd_flag1(c_cflag,C,READ);
+ svr4_to_bsd_flag1(c_cflag,P,ARENB);
+ svr4_to_bsd_flag1(c_cflag,P,ARODD);
+ svr4_to_bsd_flag1(c_cflag,H,UPCL);
+ svr4_to_bsd_flag1(c_cflag,C,LOCAL);
+ undefined_flag1(c_cflag,R,CV1EN);
+ undefined_flag1(c_cflag,X,MT1EN);
+ undefined_flag1(c_cflag,L,OBLK);
+ undefined_flag1(c_cflag,X,CLUDE);
+ bt->c_ispeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CIBAUD);
+ undefined_flag1(c_cflag,P,AREXT);
+
+ /* line discipline modes */
+ svr4_to_bsd_flag1(c_lflag,I,SIG);
+ svr4_to_bsd_flag1(c_lflag,I,CANON);
+ undefined_flag1(c_lflag,X,CASE);
+ svr4_to_bsd_flag1(c_lflag,E,CHO);
+ svr4_to_bsd_flag1(c_lflag,E,CHOE);
+ svr4_to_bsd_flag1(c_lflag,E,CHOK);
+ svr4_to_bsd_flag1(c_lflag,E,CHONL);
+ svr4_to_bsd_flag1(c_lflag,N,OFLSH);
+ svr4_to_bsd_flag1(c_lflag,T,OSTOP);
+ svr4_to_bsd_flag1(c_lflag,E,CHOCTL);
+ svr4_to_bsd_flag1(c_lflag,E,CHOPRT);
+ svr4_to_bsd_flag1(c_lflag,E,CHOKE);
+ undefined_flag1(c_lflag,D,EFECHO);
+ svr4_to_bsd_flag1(c_lflag,F,LUSHO);
+ svr4_to_bsd_flag1(c_lflag,P,ENDIN);
+ svr4_to_bsd_flag1(c_lflag,I,EXTEN);
+}
+
+
+static void
+bsd_to_svr4_termios(bt, st)
+ const struct termios *bt;
+ struct svr4_termios *st;
+{
+ /* control characters */
+ /*
+ * We process VMIN and VTIME first,
+ * because they are shared with VEOF and VEOL
+ */
+ bsd_to_svr4_char(V,MIN);
+ bsd_to_svr4_char(V,TIME);
+ bsd_to_svr4_char(V,INTR);
+ bsd_to_svr4_char(V,QUIT);
+ bsd_to_svr4_char(V,ERASE);
+ bsd_to_svr4_char(V,KILL);
+ bsd_to_svr4_char(V,EOF);
+ bsd_to_svr4_char(V,EOL);
+ bsd_to_svr4_char(V,EOL2);
+ undefined_char(V,SWTCH);
+ bsd_to_svr4_char(V,START);
+ bsd_to_svr4_char(V,STOP);
+ bsd_to_svr4_char(V,SUSP);
+ bsd_to_svr4_char(V,DSUSP);
+ bsd_to_svr4_char(V,REPRINT);
+ bsd_to_svr4_char(V,DISCARD);
+ bsd_to_svr4_char(V,WERASE);
+ bsd_to_svr4_char(V,LNEXT);
+
+ /* Input modes */
+ bsd_to_svr4_flag1(c_iflag,I,GNBRK);
+ bsd_to_svr4_flag1(c_iflag,B,RKINT);
+ bsd_to_svr4_flag1(c_iflag,I,GNPAR);
+ bsd_to_svr4_flag1(c_iflag,P,ARMRK);
+ bsd_to_svr4_flag1(c_iflag,I,NPCK);
+ bsd_to_svr4_flag1(c_iflag,I,STRIP);
+ bsd_to_svr4_flag1(c_iflag,I,NLCR);
+ bsd_to_svr4_flag1(c_iflag,I,GNCR);
+ bsd_to_svr4_flag1(c_iflag,I,CRNL);
+ undefined_flag1(c_iflag,I,UCLC);
+ bsd_to_svr4_flag1(c_iflag,I,XON);
+ bsd_to_svr4_flag1(c_iflag,I,XANY);
+ bsd_to_svr4_flag1(c_iflag,I,XOFF);
+ bsd_to_svr4_flag1(c_iflag,I,MAXBEL);
+ undefined_flag1(c_iflag,D,OSMODE);
+
+ /* Output modes */
+ bsd_to_svr4_flag1(c_oflag,O,POST);
+ undefined_flag1(c_oflag,O,LCUC);
+ bsd_to_svr4_flag1(c_oflag,O,NLCR);
+ undefined_flag1(c_oflag,O,CRNL);
+ undefined_flag1(c_oflag,O,NOCR);
+ undefined_flag1(c_oflag,O,NLRET);
+ undefined_flag1(c_oflag,O,FILL);
+ undefined_flag1(c_oflag,O,FDEL);
+ undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
+ undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
+ undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
+ undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
+ undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
+ undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
+ undefined_flag1(c_oflag,P,AGEOUT);
+ undefined_flag1(c_oflag,W,RAP);
+
+ /* Control modes */
+ st->c_cflag &= ~SVR4_CBAUD;
+ st->c_cflag |= bsd_to_svr4_speed(bt->c_ospeed, SVR4_CBAUD);
+ bsd_to_svr4_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
+ bsd_to_svr4_flag1(c_cflag,C,STOPB);
+ bsd_to_svr4_flag1(c_cflag,C,READ);
+ bsd_to_svr4_flag1(c_cflag,P,ARENB);
+ bsd_to_svr4_flag1(c_cflag,P,ARODD);
+ bsd_to_svr4_flag1(c_cflag,H,UPCL);
+ bsd_to_svr4_flag1(c_cflag,C,LOCAL);
+ undefined_flag1(c_cflag,R,CV1EN);
+ undefined_flag1(c_cflag,X,MT1EN);
+ undefined_flag1(c_cflag,L,OBLK);
+ undefined_flag1(c_cflag,X,CLUDE);
+ st->c_cflag &= ~SVR4_CIBAUD;
+ st->c_cflag |= bsd_to_svr4_speed(bt->c_ispeed, SVR4_CIBAUD);
+
+ undefined_flag1(c_oflag,P,AREXT);
+
+ /* line discipline modes */
+ bsd_to_svr4_flag1(c_lflag,I,SIG);
+ bsd_to_svr4_flag1(c_lflag,I,CANON);
+ undefined_flag1(c_lflag,X,CASE);
+ bsd_to_svr4_flag1(c_lflag,E,CHO);
+ bsd_to_svr4_flag1(c_lflag,E,CHOE);
+ bsd_to_svr4_flag1(c_lflag,E,CHOK);
+ bsd_to_svr4_flag1(c_lflag,E,CHONL);
+ bsd_to_svr4_flag1(c_lflag,N,OFLSH);
+ bsd_to_svr4_flag1(c_lflag,T,OSTOP);
+ bsd_to_svr4_flag1(c_lflag,E,CHOCTL);
+ bsd_to_svr4_flag1(c_lflag,E,CHOPRT);
+ bsd_to_svr4_flag1(c_lflag,E,CHOKE);
+ undefined_flag1(c_lflag,D,EFECHO);
+ bsd_to_svr4_flag1(c_lflag,F,LUSHO);
+ bsd_to_svr4_flag1(c_lflag,P,ENDIN);
+ bsd_to_svr4_flag1(c_lflag,I,EXTEN);
+}
+
+
+static void
+svr4_termio_to_termios(t, ts)
+ const struct svr4_termio *t;
+ struct svr4_termios *ts;
+{
+ int i;
+
+ ts->c_iflag = (svr4_tcflag_t) t->c_iflag;
+ ts->c_oflag = (svr4_tcflag_t) t->c_oflag;
+ ts->c_cflag = (svr4_tcflag_t) t->c_cflag;
+ ts->c_lflag = (svr4_tcflag_t) t->c_lflag;
+
+ for (i = 0; i < SVR4_NCC; i++)
+ ts->c_cc[i] = (svr4_cc_t) t->c_cc[i];
+}
+
+
+static void
+svr4_termios_to_termio(ts, t)
+ const struct svr4_termios *ts;
+ struct svr4_termio *t;
+{
+ int i;
+
+ t->c_iflag = (u_short) ts->c_iflag;
+ t->c_oflag = (u_short) ts->c_oflag;
+ t->c_cflag = (u_short) ts->c_cflag;
+ t->c_lflag = (u_short) ts->c_lflag;
+ t->c_line = 0; /* XXX */
+
+ for (i = 0; i < SVR4_NCC; i++)
+ t->c_cc[i] = (u_char) ts->c_cc[i];
+}
+
+int
+svr4_term_ioctl(fp, p, retval, fd, cmd, data)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t data;
+{
+ struct termios bt;
+ struct svr4_termios st;
+ struct svr4_termio t;
+ int error, new;
+ int (*ctl) __P((struct file *, u_long, caddr_t, struct proc *)) =
+ fp->f_ops->fo_ioctl;
+
+ *retval = 0;
+
+ DPRINTF(("TERM ioctl %x\n", cmd));
+
+ switch (cmd) {
+ case SVR4_TCGETA:
+ case SVR4_TCGETS:
+ DPRINTF(("ioctl(TCGET%c);\n", cmd == SVR4_TCGETA ? 'A' : 'S'));
+ if ((error = (*ctl)(fp, TIOCGETA, (caddr_t) &bt, p)) != 0)
+ return error;
+
+ memset(&st, 0, sizeof(st));
+ bsd_to_svr4_termios(&bt, &st);
+
+#ifdef DEBUG_SVR4
+ print_bsd_termios(&bt);
+ print_svr4_termios(&st);
+#endif /* DEBUG_SVR4 */
+
+ if (cmd == SVR4_TCGETA) {
+ svr4_termios_to_termio(&st, &t);
+ return copyout(&t, data, sizeof(t));
+ }
+ else {
+ return copyout(&st, data, sizeof(st));
+ }
+
+ case SVR4_TCSETA:
+ case SVR4_TCSETS:
+ case SVR4_TCSETAW:
+ case SVR4_TCSETSW:
+ case SVR4_TCSETAF:
+ case SVR4_TCSETSF:
+ DPRINTF(("TCSET{A,S,AW,SW,AF,SF}\n"));
+ /* get full BSD termios so we don't lose information */
+ if ((error = (*ctl)(fp, TIOCGETA, (caddr_t) &bt, p)) != 0)
+ return error;
+
+ switch (cmd) {
+ case SVR4_TCSETS:
+ case SVR4_TCSETSW:
+ case SVR4_TCSETSF:
+ if ((error = copyin(data, &st, sizeof(st))) != 0)
+ return error;
+ new = 1;
+ break;
+
+ case SVR4_TCSETA:
+ case SVR4_TCSETAW:
+ case SVR4_TCSETAF:
+ if ((error = copyin(data, &t, sizeof(t))) != 0)
+ return error;
+
+ svr4_termio_to_termios(&t, &st);
+ new = 0;
+ break;
+
+ default:
+ return EINVAL;
+ }
+
+ svr4_to_bsd_termios(&st, &bt, new);
+
+ switch (cmd) {
+ case SVR4_TCSETA:
+ case SVR4_TCSETS:
+ DPRINTF(("ioctl(TCSET[A|S]);\n"));
+ cmd = TIOCSETA;
+ break;
+ case SVR4_TCSETAW:
+ case SVR4_TCSETSW:
+ DPRINTF(("ioctl(TCSET[A|S]W);\n"));
+ cmd = TIOCSETAW;
+ break;
+ case SVR4_TCSETAF:
+ case SVR4_TCSETSF:
+ DPRINTF(("ioctl(TCSET[A|S]F);\n"));
+ cmd = TIOCSETAF;
+ break;
+ }
+
+#ifdef DEBUG_SVR4
+ print_bsd_termios(&bt);
+ print_svr4_termios(&st);
+#endif /* DEBUG_SVR4 */
+
+ return (*ctl)(fp, cmd, (caddr_t) &bt, p);
+
+ case SVR4_TIOCGWINSZ:
+ DPRINTF(("TIOCGWINSZ\n"));
+ {
+ struct svr4_winsize ws;
+
+ error = (*ctl)(fp, TIOCGWINSZ, (caddr_t) &ws, p);
+ if (error)
+ return error;
+ return copyout(&ws, data, sizeof(ws));
+ }
+
+ case SVR4_TIOCSWINSZ:
+ DPRINTF(("TIOCSWINSZ\n"));
+ {
+ struct svr4_winsize ws;
+
+ if ((error = copyin(data, &ws, sizeof(ws))) != 0)
+ return error;
+ return (*ctl)(fp, TIOCSWINSZ, (caddr_t) &ws, p);
+ }
+
+ default:
+ DPRINTF(("teleport to STREAMS ioctls...\n"));
+ return svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, data);
+ }
+}
diff --git a/sys/svr4/svr4_termios.h b/sys/svr4/svr4_termios.h
new file mode 100644
index 0000000..a8f40ad
--- /dev/null
+++ b/sys/svr4/svr4_termios.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_TERMIOS_H_
+#define _SVR4_TERMIOS_H_
+
+#define SVR4_POSIX_VDISABLE 0
+#define SVR4_NCC 8
+#define SVR4_NCCS 19
+
+typedef u_long svr4_tcflag_t;
+typedef u_char svr4_cc_t;
+typedef u_long svr4_speed_t;
+
+struct svr4_termios {
+ svr4_tcflag_t c_iflag;
+ svr4_tcflag_t c_oflag;
+ svr4_tcflag_t c_cflag;
+ svr4_tcflag_t c_lflag;
+ svr4_cc_t c_cc[SVR4_NCCS];
+};
+
+struct svr4_termio {
+ u_short c_iflag;
+ u_short c_oflag;
+ u_short c_cflag;
+ u_short c_lflag;
+ char c_line;
+ u_char c_cc[SVR4_NCC];
+};
+
+/* control characters */
+#define SVR4_VINTR 0
+#define SVR4_VQUIT 1
+#define SVR4_VERASE 2
+#define SVR4_VKILL 3
+#define SVR4_VEOF 4
+#define SVR4_VEOL 5
+#define SVR4_VEOL2 6
+#define SVR4_VMIN 4
+#define SVR4_VTIME 5
+#define SVR4_VSWTCH 7
+#define SVR4_VSTART 8
+#define SVR4_VSTOP 9
+#define SVR4_VSUSP 10
+#define SVR4_VDSUSP 11
+#define SVR4_VREPRINT 12
+#define SVR4_VDISCARD 13
+#define SVR4_VWERASE 14
+#define SVR4_VLNEXT 15
+
+/* Input modes */
+#define SVR4_IGNBRK 00000001
+#define SVR4_BRKINT 00000002
+#define SVR4_IGNPAR 00000004
+#define SVR4_PARMRK 00000010
+#define SVR4_INPCK 00000020
+#define SVR4_ISTRIP 00000040
+#define SVR4_INLCR 00000100
+#define SVR4_IGNCR 00000200
+#define SVR4_ICRNL 00000400
+#define SVR4_IUCLC 00001000
+#define SVR4_IXON 00002000
+#define SVR4_IXANY 00004000
+#define SVR4_IXOFF 00010000
+#define SVR4_IMAXBEL 00020000
+#define SVR4_DOSMODE 00100000
+
+/* Output modes */
+#define SVR4_OPOST 00000001
+#define SVR4_OLCUC 00000002
+#define SVR4_ONLCR 00000004
+#define SVR4_OCRNL 00000010
+#define SVR4_ONOCR 00000020
+#define SVR4_ONLRET 00000040
+#define SVR4_OFILL 00000100
+#define SVR4_OFDEL 00000200
+#define SVR4_NLDLY 00000400
+#define SVR4_NL0 00000000
+#define SVR4_NL1 00000400
+#define SVR4_CRDLY 00003000
+#define SVR4_CR0 00000000
+#define SVR4_CR1 00001000
+#define SVR4_CR2 00002000
+#define SVR4_CR3 00003000
+#define SVR4_TABDLY 00014000
+#define SVR4_TAB0 00000000
+#define SVR4_TAB1 00004000
+#define SVR4_TAB2 00010000
+#define SVR4_TAB3 00014000
+#define SVR4_XTABS 00014000
+#define SVR4_BSDLY 00020000
+#define SVR4_BS0 00000000
+#define SVR4_BS1 00020000
+#define SVR4_VTDLY 00040000
+#define SVR4_VT0 00000000
+#define SVR4_VT1 00040000
+#define SVR4_FFDLY 00100000
+#define SVR4_FF0 00000000
+#define SVR4_FF1 00100000
+#define SVR4_PAGEOUT 00200000
+#define SVR4_WRAP 00400000
+
+/* Control modes */
+#define SVR4_CBAUD 00000017
+#define SVR4_CSIZE 00000060
+#define SVR4_CS5 00000000
+#define SVR4_CS6 00000200
+#define SVR4_CS7 00000040
+#define SVR4_CS8 00000006
+#define SVR4_CSTOPB 00000100
+#define SVR4_CREAD 00000200
+#define SVR4_PARENB 00000400
+#define SVR4_PARODD 00001000
+#define SVR4_HUPCL 00002000
+#define SVR4_CLOCAL 00004000
+#define SVR4_RCV1EN 00010000
+#define SVR4_XMT1EN 00020000
+#define SVR4_LOBLK 00040000
+#define SVR4_XCLUDE 00100000
+#define SVR4_CIBAUD 03600000
+#define SVR4_PAREXT 04000000
+
+/* line discipline modes */
+#define SVR4_ISIG 00000001
+#define SVR4_ICANON 00000002
+#define SVR4_XCASE 00000004
+#define SVR4_ECHO 00000010
+#define SVR4_ECHOE 00000020
+#define SVR4_ECHOK 00000040
+#define SVR4_ECHONL 00000100
+#define SVR4_NOFLSH 00000200
+#define SVR4_TOSTOP 00000400
+#define SVR4_ECHOCTL 00001000
+#define SVR4_ECHOPRT 00002000
+#define SVR4_ECHOKE 00004000
+#define SVR4_DEFECHO 00010000
+#define SVR4_FLUSHO 00020000
+#define SVR4_PENDIN 00040000
+#define SVR4_IEXTEN 00100000
+
+#define SVR4_TIOC ('T' << 8)
+
+#define SVR4_TCGETA (SVR4_TIOC| 1)
+#define SVR4_TCSETA (SVR4_TIOC| 2)
+#define SVR4_TCSETAW (SVR4_TIOC| 3)
+#define SVR4_TCSETAF (SVR4_TIOC| 4)
+#define SVR4_TCSBRK (SVR4_TIOC| 5)
+#define SVR4_TCXONC (SVR4_TIOC| 6)
+#define SVR4_TCFLSH (SVR4_TIOC| 7)
+#define SVR4_TIOCKBON (SVR4_TIOC| 8)
+#define SVR4_TIOCKBOF (SVR4_TIOC| 9)
+#define SVR4_KBENABLED (SVR4_TIOC|10)
+#define SVR4_TCGETS (SVR4_TIOC|13)
+#define SVR4_TCSETS (SVR4_TIOC|14)
+#define SVR4_TCSETSW (SVR4_TIOC|15)
+#define SVR4_TCSETSF (SVR4_TIOC|16)
+#define SVR4_TCDSET (SVR4_TIOC|32)
+#define SVR4_RTS_TOG (SVR4_TIOC|33)
+#define SVR4_TCGETSC (SVR4_TIOC|34)
+#define SVR4_TCSETSC (SVR4_TIOC|35)
+#define SVR4_TCMOUSE (SVR4_TIOC|36)
+#define SVR4_TIOCGWINSZ (SVR4_TIOC|104)
+#define SVR4_TIOCSWINSZ (SVR4_TIOC|103)
+
+struct svr4_winsize {
+ u_short ws_row;
+ u_short ws_col;
+ u_short ws_xpixel;
+ u_short ws_ypixel;
+};
+
+#define SVR4_B0 0
+#define SVR4_B50 1
+#define SVR4_B75 2
+#define SVR4_B110 3
+#define SVR4_B134 4
+#define SVR4_B150 5
+#define SVR4_B200 6
+#define SVR4_B300 7
+#define SVR4_B600 8
+#define SVR4_B1200 9
+#define SVR4_B1800 10
+#define SVR4_B2400 11
+#define SVR4_B4800 12
+#define SVR4_B9600 13
+#define SVR4_B19200 14
+#define SVR4_B38400 15
+#define SVR4_B57600 16
+#define SVR4_B76800 17
+#define SVR4_B115200 18
+#define SVR4_B153600 19
+#define SVR4_B230400 20
+#define SVR4_B307200 21
+#define SVR4_B460800 22
+
+#endif /* !_SVR4_TERMIOS_H_ */
diff --git a/sys/svr4/svr4_time.h b/sys/svr4/svr4_time.h
new file mode 100644
index 0000000..c92f4f4
--- /dev/null
+++ b/sys/svr4/svr4_time.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_TIME_H_
+#define _SVR4_TIME_H_
+
+#include <sys/time.h>
+
+struct svr4_utimbuf {
+ time_t actime;
+ time_t modtime;
+};
+
+#endif /* !_SVR4_TIME_H_ */
diff --git a/sys/svr4/svr4_timod.h b/sys/svr4/svr4_timod.h
new file mode 100644
index 0000000..277f1f4
--- /dev/null
+++ b/sys/svr4/svr4_timod.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_TIMOD_H_
+#define _SVR4_TIMOD_H_
+
+#define SVR4_TIMOD ('T' << 8)
+#define SVR4_TI_GETINFO (SVR4_TIMOD|140)
+#define SVR4_TI_OPTMGMT (SVR4_TIMOD|141)
+#define SVR4_TI_BIND (SVR4_TIMOD|142)
+#define SVR4_TI_UNBIND (SVR4_TIMOD|143)
+#define SVR4_TI_GETMYNAME (SVR4_TIMOD|144)
+#define SVR4_TI_GETPEERNAME (SVR4_TIMOD|145)
+#define SVR4_TI_SETMYNAME (SVR4_TIMOD|146)
+#define SVR4_TI_SETPEERNAME (SVR4_TIMOD|147)
+#define SVR4_TI_SYNC (SVR4_TIMOD|148)
+#define SVR4_TI_GETADDRS (SVR4_TIMOD|149)
+
+#define SVR4_TI_CONNECT_REQUEST 0x00
+#define SVR4_TI_CONNECT_RESPONSE 0x01
+#define SVR4_TI_DISCONNECT_REQUEST 0x02
+#define SVR4_TI_DATA_REQUEST 0x03
+#define SVR4_TI_EXPDATA_REQUEST 0x04
+#define SVR4_TI_INFO_REQUEST 0x05
+#define SVR4_TI_OLD_BIND_REQUEST 0x06
+#define SVR4_TI_UNBIND_REQUEST 0x07
+#define SVR4_TI_SENDTO_REQUEST 0x08
+#define SVR4_TI_OLD_OPTMGMT_REQUEST 0x09
+#define SVR4_TI_ORDREL_REQUEST 0x0a
+
+#define SVR4_TI_ACCEPT_REPLY 0x0b
+#define SVR4_TI_CONNECT_REPLY 0x0c
+#define SVR4_TI_DISCONNECT_IND 0x0d
+#define SVR4_TI_DATA_IND 0x0e
+#define SVR4_TI_EXPDATA_IND 0x0f
+#define SVR4_TI_INFO_REPLY 0x10
+#define SVR4_TI_BIND_REPLY 0x11
+#define SVR4_TI_ERROR_REPLY 0x12
+#define SVR4_TI_OK_REPLY 0x13
+#define SVR4_TI_RECVFROM_IND 0x14
+#define SVR4_TI_RECVFROM_ERROR_IND 0x15
+#define SVR4_TI_OPTMGMT_REPLY 0x16
+#define SVR4_TI_ORDREL_IND 0x17
+
+#define SVR4_TI_ADDRESS_REQUEST 0x18
+#define SVR4_TI_ADDRESS_REPLY 0x19
+
+#define SVR4_TI_BIND_REQUEST 0x20
+#define SVR4_TI_OPTMGMT_REQUEST 0x21
+
+#define SVR4_TI__ACCEPT_WAIT 0x10000001
+#define SVR4_TI__ACCEPT_OK 0x10000002
+
+struct svr4_netbuf {
+ u_int maxlen;
+ u_int len;
+ char *buf;
+};
+
+#endif /* !_SVR4_TIMOD_H_ */
diff --git a/sys/svr4/svr4_ttold.c b/sys/svr4/svr4_ttold.c
new file mode 100644
index 0000000..691f1d6
--- /dev/null
+++ b/sys/svr4/svr4_ttold.c
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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/proc.h>
+#include <sys/systm.h>
+#include <sys/file.h>
+#include <sys/filedesc.h>
+#include <sys/fcntl.h>
+#include <sys/ioctl_compat.h>
+#include <sys/unistd.h>
+#include <sys/termios.h>
+#include <sys/tty.h>
+#include <sys/socket.h>
+#include <sys/mount.h>
+#include <net/if.h>
+#include <sys/malloc.h>
+
+#include <sys/sysproto.h>
+
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_util.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_proto.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_ttold.h>
+#include <svr4/svr4_ioctl.h>
+
+
+static void svr4_tchars_to_bsd_tchars __P((const struct svr4_tchars *st,
+ struct tchars *bt));
+static void bsd_tchars_to_svr4_tchars __P((const struct tchars *bt,
+ struct svr4_tchars *st));
+static void svr4_sgttyb_to_bsd_sgttyb __P((const struct svr4_sgttyb *ss,
+ struct sgttyb *bs));
+static void bsd_sgttyb_to_svr4_sgttyb __P((const struct sgttyb *bs,
+ struct svr4_sgttyb *ss));
+static void svr4_ltchars_to_bsd_ltchars __P((const struct svr4_ltchars *sl,
+ struct ltchars *bl));
+static void bsd_ltchars_to_svr4_ltchars __P((const struct ltchars *bl,
+ struct svr4_ltchars *sl));
+
+#ifdef DEBUG_SVR4
+static void print_svr4_sgttyb __P((const char *, struct svr4_sgttyb *));
+static void print_svr4_tchars __P((const char *, struct svr4_tchars *));
+static void print_svr4_ltchars __P((const char *, struct svr4_ltchars *));
+
+static void
+print_svr4_sgttyb(str, ss)
+ const char *str;
+ struct svr4_sgttyb *ss;
+{
+
+ uprintf("%s\nispeed=%o ospeed=%o ", str, ss->sg_ispeed, ss->sg_ospeed);
+ uprintf("erase=%o kill=%o flags=%o\n", ss->sg_erase, ss->sg_kill,
+ ss->sg_flags);
+}
+
+static void
+print_svr4_tchars(str, st)
+ const char *str;
+ struct svr4_tchars *st;
+{
+ uprintf("%s\nintrc=%o quitc=%o ", str, st->t_intrc, st->t_quitc);
+ uprintf("startc=%o stopc=%o eofc=%o brkc=%o\n", st->t_startc,
+ st->t_stopc, st->t_eofc, st->t_brkc);
+}
+
+static void
+print_svr4_ltchars(str, sl)
+ const char *str;
+ struct svr4_ltchars *sl;
+{
+ uprintf("%s\nsuspc=%o dsuspc=%o ", str, sl->t_suspc, sl->t_dsuspc);
+ uprintf("rprntc=%o flushc=%o werasc=%o lnextc=%o\n", sl->t_rprntc,
+ sl->t_flushc, sl->t_werasc, sl->t_lnextc);
+}
+#endif /* DEBUG_SVR4 */
+
+static void
+svr4_tchars_to_bsd_tchars(st, bt)
+ const struct svr4_tchars *st;
+ struct tchars *bt;
+{
+ bt->t_intrc = st->t_intrc;
+ bt->t_quitc = st->t_quitc;
+ bt->t_startc = st->t_startc;
+ bt->t_stopc = st->t_stopc;
+ bt->t_eofc = st->t_eofc;
+ bt->t_brkc = st->t_brkc;
+}
+
+
+static void
+bsd_tchars_to_svr4_tchars(bt, st)
+ const struct tchars *bt;
+ struct svr4_tchars *st;
+{
+ st->t_intrc = bt->t_intrc;
+ st->t_quitc = bt->t_quitc;
+ st->t_startc = bt->t_startc;
+ st->t_stopc = bt->t_stopc;
+ st->t_eofc = bt->t_eofc;
+ st->t_brkc = bt->t_brkc;
+}
+
+
+static void
+svr4_sgttyb_to_bsd_sgttyb(ss, bs)
+ const struct svr4_sgttyb *ss;
+ struct sgttyb *bs;
+{
+ bs->sg_ispeed = ss->sg_ispeed;
+ bs->sg_ospeed = ss->sg_ospeed;
+ bs->sg_erase = ss->sg_erase;
+ bs->sg_kill = ss->sg_kill;
+ bs->sg_flags = ss->sg_flags;
+};
+
+
+static void
+bsd_sgttyb_to_svr4_sgttyb(bs, ss)
+ const struct sgttyb *bs;
+ struct svr4_sgttyb *ss;
+{
+ ss->sg_ispeed = bs->sg_ispeed;
+ ss->sg_ospeed = bs->sg_ospeed;
+ ss->sg_erase = bs->sg_erase;
+ ss->sg_kill = bs->sg_kill;
+ ss->sg_flags = bs->sg_flags;
+}
+
+
+static void
+svr4_ltchars_to_bsd_ltchars(sl, bl)
+ const struct svr4_ltchars *sl;
+ struct ltchars *bl;
+{
+ bl->t_suspc = sl->t_suspc;
+ bl->t_dsuspc = sl->t_dsuspc;
+ bl->t_rprntc = sl->t_rprntc;
+ bl->t_flushc = sl->t_flushc;
+ bl->t_werasc = sl->t_werasc;
+ bl->t_lnextc = sl->t_lnextc;
+}
+
+
+static void
+bsd_ltchars_to_svr4_ltchars(bl, sl)
+ const struct ltchars *bl;
+ struct svr4_ltchars *sl;
+{
+ sl->t_suspc = bl->t_suspc;
+ sl->t_dsuspc = bl->t_dsuspc;
+ sl->t_rprntc = bl->t_rprntc;
+ sl->t_flushc = bl->t_flushc;
+ sl->t_werasc = bl->t_werasc;
+ sl->t_lnextc = bl->t_lnextc;
+}
+
+
+int
+svr4_ttold_ioctl(fp, p, retval, fd, cmd, data)
+ struct file *fp;
+ struct proc *p;
+ register_t *retval;
+ int fd;
+ u_long cmd;
+ caddr_t data;
+{
+ int error;
+ int (*ctl) __P((struct file *, u_long, caddr_t, struct proc *)) =
+ fp->f_ops->fo_ioctl;
+
+ *retval = 0;
+
+ switch (cmd) {
+ case SVR4_TIOCGPGRP:
+ {
+ pid_t pid;
+
+ if ((error = (*ctl)(fp, TIOCGPGRP,
+ (caddr_t) &pid, p)) != 0)
+ return error;
+
+ DPRINTF(("TIOCGPGRP %d\n", pid));
+
+ if ((error = copyout(&pid, data, sizeof(pid))) != 0)
+ return error;
+
+ }
+
+ case SVR4_TIOCSPGRP:
+ {
+ pid_t pid;
+
+ if ((error = copyin(data, &pid, sizeof(pid))) != 0)
+ return error;
+
+ DPRINTF(("TIOCSPGRP %d\n", pid));
+
+ return (*ctl)(fp, TIOCSPGRP, (caddr_t) &pid, p);
+ }
+
+ case SVR4_TIOCGSID:
+ {
+#if defined(TIOCGSID)
+ pid_t pid;
+ if ((error = (*ctl)(fp, TIOCGSID,
+ (caddr_t) &pid, p)) != 0)
+ return error;
+
+ DPRINTF(("TIOCGSID %d\n", pid));
+
+ return copyout(&pid, data, sizeof(pid));
+#else
+ uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", p->p_pid);
+ return EINVAL;
+#endif
+ }
+
+ case SVR4_TIOCGETP:
+ {
+ struct sgttyb bs;
+ struct svr4_sgttyb ss;
+
+ error = (*ctl)(fp, TIOCGETP, (caddr_t) &bs, p);
+ if (error)
+ return error;
+
+ bsd_sgttyb_to_svr4_sgttyb(&bs, &ss);
+#ifdef DEBUG_SVR4
+ print_svr4_sgttyb("SVR4_TIOCGETP", &ss);
+#endif /* DEBUG_SVR4 */
+ return copyout(&ss, data, sizeof(ss));
+ }
+
+ case SVR4_TIOCSETP:
+ case SVR4_TIOCSETN:
+ {
+ struct sgttyb bs;
+ struct svr4_sgttyb ss;
+
+ if ((error = copyin(data, &ss, sizeof(ss))) != 0)
+ return error;
+
+ svr4_sgttyb_to_bsd_sgttyb(&ss, &bs);
+#ifdef DEBUG_SVR4
+ print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss);
+#endif /* DEBUG_SVR4 */
+ cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN;
+ return (*ctl)(fp, cmd, (caddr_t) &bs, p);
+ }
+
+ case SVR4_TIOCGETC:
+ {
+ struct tchars bt;
+ struct svr4_tchars st;
+
+ error = (*ctl)(fp, TIOCGETC, (caddr_t) &bt, p);
+ if (error)
+ return error;
+
+ bsd_tchars_to_svr4_tchars(&bt, &st);
+#ifdef DEBUG_SVR4
+ print_svr4_tchars("SVR4_TIOCGETC", &st);
+#endif /* DEBUG_SVR4 */
+ return copyout(&st, data, sizeof(st));
+ }
+
+ case SVR4_TIOCSETC:
+ {
+ struct tchars bt;
+ struct svr4_tchars st;
+
+ if ((error = copyin(data, &st, sizeof(st))) != 0)
+ return error;
+
+ svr4_tchars_to_bsd_tchars(&st, &bt);
+#ifdef DEBUG_SVR4
+ print_svr4_tchars("SVR4_TIOCSETC", &st);
+#endif /* DEBUG_SVR4 */
+ return (*ctl)(fp, TIOCSETC, (caddr_t) &bt, p);
+ }
+
+ case SVR4_TIOCGLTC:
+ {
+ struct ltchars bl;
+ struct svr4_ltchars sl;
+
+ error = (*ctl)(fp, TIOCGLTC, (caddr_t) &bl, p);
+ if (error)
+ return error;
+
+ bsd_ltchars_to_svr4_ltchars(&bl, &sl);
+#ifdef DEBUG_SVR4
+ print_svr4_ltchars("SVR4_TIOCGLTC", &sl);
+#endif /* DEBUG_SVR4 */
+ return copyout(&sl, data, sizeof(sl));
+ }
+
+ case SVR4_TIOCSLTC:
+ {
+ struct ltchars bl;
+ struct svr4_ltchars sl;
+
+ if ((error = copyin(data, &sl, sizeof(sl))) != 0)
+ return error;
+
+ svr4_ltchars_to_bsd_ltchars(&sl, &bl);
+#ifdef DEBUG_SVR4
+ print_svr4_ltchars("SVR4_TIOCSLTC", &sl);
+#endif /* DEBUG_SVR4 */
+ return (*ctl)(fp, TIOCSLTC, (caddr_t) &bl, p);
+ }
+
+ case SVR4_TIOCLGET:
+ {
+ int flags;
+ if ((error = (*ctl)(fp, TIOCLGET,
+ (caddr_t) &flags, p)) != 0)
+ return error;
+ DPRINTF(("SVR4_TIOCLGET %o\n", flags));
+ return copyout(&flags, data, sizeof(flags));
+ }
+
+ case SVR4_TIOCLSET:
+ case SVR4_TIOCLBIS:
+ case SVR4_TIOCLBIC:
+ {
+ int flags;
+
+ if ((error = copyin(data, &flags, sizeof(flags))) != 0)
+ return error;
+
+ switch (cmd) {
+ case SVR4_TIOCLSET:
+ cmd = TIOCLSET;
+ break;
+ case SVR4_TIOCLBIS:
+ cmd = TIOCLBIS;
+ break;
+ case SVR4_TIOCLBIC:
+ cmd = TIOCLBIC;
+ break;
+ }
+
+ DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags));
+ return (*ctl)(fp, cmd, (caddr_t) &flags, p);
+ }
+
+ default:
+ DPRINTF(("Unknown svr4 ttold %lx\n", cmd));
+ return 0; /* ENOSYS really */
+ }
+}
diff --git a/sys/svr4/svr4_ttold.h b/sys/svr4/svr4_ttold.h
new file mode 100644
index 0000000..edc0762
--- /dev/null
+++ b/sys/svr4/svr4_ttold.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_TTOLD_H_
+#define _SVR4_TTOLD_H_
+
+struct svr4_tchars {
+ char t_intrc;
+ char t_quitc;
+ char t_startc;
+ char t_stopc;
+ char t_eofc;
+ char t_brkc;
+};
+
+struct svr4_sgttyb {
+ u_char sg_ispeed;
+ u_char sg_ospeed;
+ u_char sg_erase;
+ u_char sg_kill;
+ int sg_flags;
+};
+
+struct svr4_ltchars {
+ char t_suspc;
+ char t_dsuspc;
+ char t_rprntc;
+ char t_flushc;
+ char t_werasc;
+ char t_lnextc;
+};
+
+#ifndef SVR4_tIOC
+#define SVR4_tIOC ('t' << 8)
+#endif
+
+#define SVR4_TIOCGETD (SVR4_tIOC | 0)
+#define SVR4_TIOCSETD (SVR4_tIOC | 1)
+#define SVR4_TIOCHPCL (SVR4_tIOC | 2)
+#define SVR4_TIOCGETP (SVR4_tIOC | 8)
+#define SVR4_TIOCSETP (SVR4_tIOC | 9)
+#define SVR4_TIOCSETN (SVR4_tIOC | 10)
+#define SVR4_TIOCEXCL (SVR4_tIOC | 13)
+#define SVR4_TIOCNXCL (SVR4_tIOC | 14)
+#define SVR4_TIOCFLUSH (SVR4_tIOC | 16)
+#define SVR4_TIOCSETC (SVR4_tIOC | 17)
+#define SVR4_TIOCGETC (SVR4_tIOC | 18)
+#define SVR4_TIOCGPGRP (SVR4_tIOC | 20)
+#define SVR4_TIOCSPGRP (SVR4_tIOC | 21)
+#define SVR4_TIOCGSID (SVR4_tIOC | 22)
+#define SVR4_TIOCSTI (SVR4_tIOC | 23)
+#define SVR4_TIOCSSID (SVR4_tIOC | 24)
+#define SVR4_TIOCMSET (SVR4_tIOC | 26)
+#define SVR4_TIOCMBIS (SVR4_tIOC | 27)
+#define SVR4_TIOCMBIC (SVR4_tIOC | 28)
+#define SVR4_TIOCMGET (SVR4_tIOC | 29)
+#define SVR4_TIOCREMOTE (SVR4_tIOC | 30)
+#define SVR4_TIOCSIGNAL (SVR4_tIOC | 31)
+
+#define SVR4_TIOCSTART (SVR4_tIOC | 110)
+#define SVR4_TIOCSTOP (SVR4_tIOC | 111)
+#define SVR4_TIOCNOTTY (SVR4_tIOC | 113)
+#define SVR4_TIOCOUTQ (SVR4_tIOC | 115)
+#define SVR4_TIOCGLTC (SVR4_tIOC | 116)
+#define SVR4_TIOCSLTC (SVR4_tIOC | 117)
+#define SVR4_TIOCCDTR (SVR4_tIOC | 120)
+#define SVR4_TIOCSDTR (SVR4_tIOC | 121)
+#define SVR4_TIOCCBRK (SVR4_tIOC | 122)
+#define SVR4_TIOCSBRK (SVR4_tIOC | 123)
+#define SVR4_TIOCLGET (SVR4_tIOC | 124)
+#define SVR4_TIOCLSET (SVR4_tIOC | 125)
+#define SVR4_TIOCLBIC (SVR4_tIOC | 126)
+#define SVR4_TIOCLBIS (SVR4_tIOC | 127)
+
+#define SVR4_TIOCM_LE 0001
+#define SVR4_TIOCM_DTR 0002
+#define SVR4_TIOCM_RTS 0004
+#define SVR4_TIOCM_ST 0010
+#define SVR4_TIOCM_SR 0020
+#define SVR4_TIOCM_CTS 0040
+#define SVR4_TIOCM_CAR 0100
+#define SVR4_TIOCM_CD SVR4_TIOCM_CAR
+#define SVR4_TIOCM_RNG 0200
+#define SVR4_TIOCM_RI SVR4_TIOCM_RNG
+#define SVR4_TIOCM_DSR 0400
+
+#define SVR4_OTTYDISC 0
+#define SVR4_NETLDISC 1
+#define SVR4_NTTYDISC 2
+#define SVR4_TABLDISC 3
+#define SVR4_NTABLDISC 4
+#define SVR4_MOUSELDISC 5
+#define SVR4_KBDLDISC 6
+
+#endif /* !_SVR4_TTOLD_H_ */
diff --git a/sys/svr4/svr4_types.h b/sys/svr4/svr4_types.h
new file mode 100644
index 0000000..406e0da
--- /dev/null
+++ b/sys/svr4/svr4_types.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_TYPES_H_
+#define _SVR4_TYPES_H_
+
+typedef u_quad_t svr4_ino64_t;
+typedef quad_t svr4_off64_t;
+typedef quad_t svr4_blkcnt64_t;
+typedef u_quad_t svr4_fsblkcnt64_t;
+
+typedef long svr4_off_t;
+typedef u_long svr4_dev_t;
+typedef u_long svr4_ino_t;
+typedef u_long svr4_mode_t;
+typedef u_long svr4_nlink_t;
+typedef long svr4_uid_t;
+typedef long svr4_gid_t;
+typedef long svr4_daddr_t;
+typedef long svr4_pid_t;
+typedef long svr4_time_t;
+typedef long svr4_blkcnt_t;
+typedef u_long svr4_fsblkcnt_t;
+typedef char *svr4_caddr_t;
+typedef u_int svr4_size_t;
+
+typedef short svr4_o_dev_t;
+typedef short svr4_o_pid_t;
+typedef u_short svr4_o_ino_t;
+typedef u_short svr4_o_mode_t;
+typedef short svr4_o_nlink_t;
+typedef u_short svr4_o_uid_t;
+typedef u_short svr4_o_gid_t;
+typedef long svr4_clock_t;
+typedef int svr4_key_t;
+
+typedef struct timespec svr4_timestruc_t;
+
+#define svr4_omajor(x) ((int32_t)((((x) & 0x7f00) >> 8)))
+#define svr4_ominor(x) ((int32_t)((((x) & 0x00ff) >> 0)))
+#define svr4_omakedev(x,y) ((svr4_o_dev_t)((((x) << 8) & 0x7f00) | \
+ (((y) << 0) & 0x00ff)))
+
+#define svr4_to_bsd_odev_t(d) makedev(svr4_omajor(d), svr4_ominor(d))
+#define bsd_to_svr4_odev_t(d) svr4_omakedev(major(d), minor(d))
+
+#define svr4_major(x) ((int32_t)((((x) & 0xfffc0000) >> 18)))
+#define svr4_minor(x) ((int32_t)((((x) & 0x0003ffff) >> 0)))
+#define svr4_makedev(x,y) ((svr4_dev_t)((((x) << 18) & 0xfffc0000) | \
+ (((y) << 0) & 0x0003ffff)))
+#define svr4_to_bsd_dev_t(d) makedev(svr4_major(d), svr4_minor(d))
+#define bsd_to_svr4_dev_t(d) svr4_makedev(major(d), minor(d))
+
+#endif /* !_SVR4_TYPES_H_ */
diff --git a/sys/svr4/svr4_ucontext.h b/sys/svr4/svr4_ucontext.h
new file mode 100644
index 0000000..e2bdb82
--- /dev/null
+++ b/sys/svr4/svr4_ucontext.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_UCONTEXT_H_
+#define _SVR4_UCONTEXT_H_
+
+/*
+ * Machine context
+ */
+
+#define SVR4_UC_SIGMASK 0x01
+#define SVR4_UC_STACK 0x02
+
+#define SVR4_UC_CPU 0x04
+#define SVR4_UC_FPU 0x08
+#define SVR4_UC_WEITEK 0x10
+
+#define SVR4_UC_MCONTEXT (SVR4_UC_CPU|SVR4_UC_FPU|SVR4_UC_WEITEK)
+
+#define SVR4_UC_ALL (SVR4_UC_SIGMASK|SVR4_UC_STACK|SVR4_UC_MCONTEXT)
+
+typedef struct svr4_ucontext {
+ u_long uc_flags;
+ /* struct svr4_ucontext *uc_link;*/
+ void *uc_link;
+ svr4_sigset_t uc_sigmask;
+ struct svr4_sigaltstack uc_stack;
+ svr4_mcontext_t uc_mcontext;
+ long uc_pad[5];
+} svr4_ucontext_t;
+
+#define SVR4_UC_GETREGSET 0
+#define SVR4_UC_SETREGSET 1
+
+/*
+ * Signal frame
+ */
+struct svr4_sigframe {
+ int sf_signum;
+ union svr4_siginfo *sf_sip;
+ struct svr4_ucontext *sf_ucp;
+ sig_t sf_handler;
+ struct svr4_ucontext sf_uc;
+ union svr4_siginfo sf_si;
+};
+
+#endif /* !_SVR4_UCONTEXT_H_ */
diff --git a/sys/svr4/svr4_ulimit.h b/sys/svr4/svr4_ulimit.h
new file mode 100644
index 0000000..c151da1
--- /dev/null
+++ b/sys/svr4/svr4_ulimit.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_ULIMIT_H_
+#define _SVR4_ULIMIT_H_
+
+#define SVR4_GFILLIM 1
+#define SVR4_SFILLIM 2
+#define SVR4_GMEMLIM 3
+#define SVR4_GDESLIM 4
+#define SVR4_GTXTOFF 64
+
+
+#endif /* !_SVR4_ULIMIT_H_ */
diff --git a/sys/svr4/svr4_ustat.h b/sys/svr4/svr4_ustat.h
new file mode 100644
index 0000000..89712d5
--- /dev/null
+++ b/sys/svr4/svr4_ustat.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_USTAT_H_
+#define _SVR4_USTAT_H_
+
+#include <svr4/svr4_types.h>
+
+struct svr4_ustat {
+ svr4_daddr_t f_tfree;
+ svr4_ino_t f_tinode;
+ char f_fname[6];
+ char f_fpack[6];
+};
+
+#endif /* !_SVR4_USTAT_H_ */
diff --git a/sys/svr4/svr4_util.h b/sys/svr4/svr4_util.h
new file mode 100644
index 0000000..8bbb980
--- /dev/null
+++ b/sys/svr4/svr4_util.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_UTIL_H_
+#define _SVR4_UTIL_H_
+
+/*#include <compat/common/compat_util.h>*/
+#include <vm/vm.h>
+#include <vm/vm_param.h>
+#include <vm/pmap.h>
+#include <machine/vmparam.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/cdefs.h>
+
+#ifdef DEBUG_SVR4
+#define DPRINTF(a) uprintf a;
+#else
+#define DPRINTF(a)
+#endif
+
+
+static __inline caddr_t stackgap_init(void);
+static __inline void *stackgap_alloc(caddr_t *, size_t);
+
+static __inline caddr_t
+stackgap_init()
+{
+#define szsigcode (*(curproc->p_sysent->sv_szsigcode))
+ return (caddr_t)(((caddr_t)PS_STRINGS) - szsigcode - SPARE_USRSPACE);
+}
+
+static __inline void *
+stackgap_alloc(sgp, sz)
+ caddr_t *sgp;
+ size_t sz;
+{
+ void *p = (void *) *sgp;
+ *sgp += ALIGN(sz);
+ return p;
+}
+
+extern const char svr4_emul_path[];
+int svr4_emul_find __P((struct proc *, caddr_t *, const char *, char *,
+ char **, int));
+
+#define CHECKALTEXIST(p, sgp, path) \
+ svr4_emul_find(p, sgp, svr4_emul_path, path, &(path), 0)
+
+#define CHECKALTCREAT(p, sgp, path) \
+ svr4_emul_find(p, sgp, svr4_emul_path, path, &(path), 1)
+
+#endif /* !_SVR4_UTIL_H_ */
diff --git a/sys/svr4/svr4_utsname.h b/sys/svr4/svr4_utsname.h
new file mode 100644
index 0000000..c3afa1d
--- /dev/null
+++ b/sys/svr4/svr4_utsname.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_UTSNAME_H_
+#define _SVR4_UTSNAME_H_
+
+#include <svr4/svr4_types.h>
+
+struct svr4_utsname {
+ char sysname[257];
+ char nodename[257];
+ char release[257];
+ char version[257];
+ char machine[257];
+};
+
+#endif /* !_SVR4_UTSNAME_H_ */
diff --git a/sys/svr4/svr4_wait.h b/sys/svr4/svr4_wait.h
new file mode 100644
index 0000000..1935163
--- /dev/null
+++ b/sys/svr4/svr4_wait.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1998 Mark Newton
+ * Copyright (c) 1994 Christos Zoulas
+ * 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.
+ */
+
+#ifndef _SVR4_WAIT_H_
+#define _SVR4_WAIT_H_
+
+
+#define SVR4_P_PID 0
+#define SVR4_P_PPID 1
+#define SVR4_P_PGID 2
+#define SVR4_P_SID 3
+#define SVR4_P_CID 4
+#define SVR4_P_UID 5
+#define SVR4_P_GID 6
+#define SVR4_P_ALL 7
+
+#define SVR4_WEXITED 0x01
+#define SVR4_WTRAPPED 0x02
+#define SVR4_WSTOPPED 0x04
+#define SVR4_WCONTINUED 0x08
+#define SVR4_WUNDEF1 0x10
+#define SVR4_WUNDEF2 0x20
+#define SVR4_WNOHANG 0x40
+#define SVR4_WNOWAIT 0x80
+
+#define SVR4_WOPTMASK (SVR4_WEXITED|SVR4_WTRAPPED|SVR4_WSTOPPED|\
+ SVR4_WCONTINUED|SVR4_WNOHANG|SVR4_WNOWAIT)
+
+#endif /* !_SVR4_WAIT_H_ */
diff --git a/sys/svr4/syscalls.conf b/sys/svr4/syscalls.conf
new file mode 100644
index 0000000..5c01a85
--- /dev/null
+++ b/sys/svr4/syscalls.conf
@@ -0,0 +1,12 @@
+# $Id: syscalls.conf,v 1.4 1998/03/13 19:13:54 jb Exp $
+sysnames="svr4_syscallnames.c"
+sysproto="svr4_proto.h"
+sysproto_h=_SVR4_SYSPROTO_H_
+syshdr="svr4_syscall.h"
+syssw="svr4_sysent.c"
+sysmk="/dev/null"
+syshide="/dev/null"
+syscallprefix="SVR4_SYS_"
+switchname="svr4_sysent"
+namesname="svr4_syscallnames"
+sysvec="\n"
diff --git a/sys/svr4/syscalls.master b/sys/svr4/syscalls.master
new file mode 100644
index 0000000..1420318
--- /dev/null
+++ b/sys/svr4/syscalls.master
@@ -0,0 +1,373 @@
+; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
+; System call name/number master file (or rather, slave, from SVR4).
+; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h.
+
+; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments
+; number system call number, must be in order
+; type one of STD, OBSOL, UNIMPL, COMPAT
+; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter
+; name psuedo-prototype of syscall routine
+; If one of the following alts is different, then all appear:
+; altname name of system call if different
+; alttag name of args struct tag if different from [o]`name'"_args"
+; altrtyp return type if not int (bogus - syscalls always return int)
+; for UNIMPL/OBSOL, name continues with comments
+
+; types:
+; STD always included
+; COMPAT included on COMPAT #ifdef
+; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
+; OBSOL obsolete, not included in system, only specifies name
+; UNIMPL not implemented, placeholder only
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/param.h>
+#include <sys/file.h>
+#include <sys/filio.h>
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <netinet/in.h>
+
+#include <svr4/svr4_types.h>
+#include <svr4/svr4_signal.h>
+#include <svr4/svr4_stropts.h>
+#include <svr4/svr4_socket.h>
+#include <svr4/svr4_sockio.h>
+#include <svr4/svr4_timod.h>
+#include <svr4/svr4_proto.h>
+
+; #ifdef's, etc. may be included, and are copied to the output files.
+
+0 UNIMPL SVR4 unused
+1 NOPROTO POSIX { int exit(int rval); }
+2 NOPROTO POSIX { int fork(void); }
+3 NOPROTO POSIX { int read(int fd, char *buf, u_int nbyte); }
+4 NOPROTO SVR4 { int write(int fd, char *buf, u_int nbyte); }
+5 STD SVR4 { int svr4_sys_open(char *path, int flags, int mode); }
+6 NOPROTO SVR4 { int close(int fd); }
+7 STD SVR4 { int svr4_sys_wait(int *status); }
+8 STD SVR4 { int svr4_sys_creat(char *path, int mode); }
+9 NOPROTO SVR4 { int link(char *path, char *link); }
+10 NOPROTO SVR4 { int unlink(char *path); }
+11 STD SVR4 { int svr4_sys_execv(char *path, char **argp); }
+12 NOPROTO SVR4 { int chdir(char *path); }
+13 STD SVR4 { int svr4_sys_time(time_t *t); }
+14 STD SVR4 { int svr4_sys_mknod(char* path, int mode, int dev); }
+15 NOPROTO SVR4 { int chmod(char *path, int mode); }
+16 NOPROTO SVR4 { int chown(char *path, uid_t uid, gid_t gid); }
+17 STD SVR4 { int svr4_sys_break(caddr_t nsize); }
+18 STD SVR4 { int svr4_sys_stat(char* path, \
+ struct svr4_stat* ub); }
+19 NOPROTO SVR4 { int lseek(int filedes, off_t *offset, int whence); }
+20 NOPROTO SVR4 { pid_t getpid(void); }
+21 UNIMPL SVR4 old_mount
+22 UNIMPL SVR4 sysv_umount
+23 NOPROTO SVR4 { int setuid(uid_t uid); }
+24 NOPROTO SVR4 { uid_t getuid(void); }
+25 UNIMPL SVR4 stime
+26 UNIMPL SVR4 ptrace
+27 STD SVR4 { int svr4_sys_alarm(unsigned sec); }
+28 STD SVR4 { int svr4_sys_fstat(int fd, struct svr4_stat *sb); }
+29 STD SVR4 { int svr4_sys_pause(void); }
+30 STD SVR4 { int svr4_sys_utime(char *path, \
+ struct svr4_utimbuf *ubuf); }
+31 UNIMPL SVR4 stty
+32 UNIMPL SVR4 gtty
+33 STD SVR4 { int svr4_sys_access(char *path, int flags); }
+34 STD SVR4 { int svr4_sys_nice(int prio); }
+35 UNIMPL SVR4 statfs
+36 NOPROTO SVR4 { int sync(void); }
+37 STD SVR4 { int svr4_sys_kill(int pid, int signum); }
+38 UNIMPL SVR4 fstatfs
+39 STD SVR4 { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); }
+40 UNIMPL SVR4 xenix
+41 NOPROTO SVR4 { int dup(u_int fd); }
+42 NOPROTO SVR4 { int pipe(void); }
+43 STD SVR4 { int svr4_sys_times(struct tms *tp); }
+44 UNIMPL SVR4 profil
+45 UNIMPL SVR4 plock
+46 NOPROTO SVR4 { int setgid(gid_t gid); }
+47 NOPROTO SVR4 { gid_t getgid(void); }
+48 STD SVR4 { int svr4_sys_signal(int signum, \
+ svr4_sig_t handler); }
+#if defined(NOTYET)
+49 STD SVR4 { int svr4_sys_msgsys(int what, int a2, int a3, \
+ int a4, int a5); }
+#else
+49 UNIMPL SVR4 msgsys
+#endif
+50 STD SVR4 { int svr4_sys_sysarch(int op, void *a1); }
+51 UNIMPL SVR4 acct
+52 UNIMPL SVR4 shmsys
+53 UNIMPL SVR4 semsys
+54 STD SVR4 { int svr4_sys_ioctl(int fd, u_long com, \
+ caddr_t data); }
+55 UNIMPL SVR4 uadmin
+56 UNIMPL SVR4 exch
+57 STD SVR4 { int svr4_sys_utssys(void *a1, void *a2, int sel, \
+ void *a3); }
+58 NOPROTO SVR4 { int fsync(int fd); }
+59 STD SVR4 { int svr4_sys_execve(char *path, char **argp, \
+ char **envp); }
+60 NOPROTO SVR4 { int umask(int newmask); }
+61 NOPROTO SVR4 { int chroot(char *path); }
+62 STD SVR4 { int svr4_sys_fcntl(int fd, int cmd, char *arg); }
+63 STD SVR4 { int svr4_sys_ulimit(int cmd, long newlimit); }
+64 UNIMPL SVR4 reserved
+65 UNIMPL SVR4 reserved
+66 UNIMPL SVR4 reserved
+67 UNIMPL SVR4 reserved
+68 UNIMPL SVR4 reserved
+69 UNIMPL SVR4 reserved
+70 UNIMPL SVR4 advfs
+71 UNIMPL SVR4 unadvfs
+72 UNIMPL SVR4 rmount
+73 UNIMPL SVR4 rumount
+74 UNIMPL SVR4 rfstart
+75 UNIMPL SVR4 sigret
+76 UNIMPL SVR4 rdebug
+77 UNIMPL SVR4 rfstop
+78 UNIMPL SVR4 rfsys
+79 NOPROTO SVR4 { int rmdir(char *path); }
+80 NOPROTO SVR4 { int mkdir(char *path, int mode); }
+81 STD SVR4 { int svr4_sys_getdents(int fd, char *buf, \
+ int nbytes); }
+82 UNIMPL SVR4 libattach
+83 UNIMPL SVR4 libdetach
+84 UNIMPL SVR4 sysfs
+85 STD SVR4 { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \
+ struct svr4_strbuf *dat, int *flags); }
+86 STD SVR4 { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \
+ struct svr4_strbuf *dat, int flags); }
+87 STD SVR4 { int svr4_sys_poll(struct pollfd *fds, unsigned int nfds, \
+ int timeout); }
+88 STD SVR4 { int svr4_sys_lstat(char *path, \
+ struct svr4_stat *ub); }
+89 NOPROTO SVR4 { int symlink(char *path, char *link); }
+90 NOPROTO SVR4 { int readlink(char *path, char *buf, int count); }
+91 NOPROTO SVR4 { int getgroups(u_int gidsetsize, gid_t *gidset); }
+92 NOPROTO SVR4 { int setgroups(u_int gidsetsize, gid_t *gidset); }
+93 NOPROTO SVR4 { int fchmod(int fd, int mode); }
+94 NOPROTO SVR4 { int fchown(int fd, int uid, int gid); }
+95 STD SVR4 { int svr4_sys_sigprocmask(int how, \
+ svr4_sigset_t *set, svr4_sigset_t *oset); }
+96 STD SVR4 { int svr4_sys_sigsuspend(svr4_sigset_t *ss); }
+97 STD SVR4 { int svr4_sys_sigaltstack( \
+ struct svr4_sigaltstack *nss, \
+ struct svr4_sigaltstack *oss); }
+98 STD SVR4 { int svr4_sys_sigaction(int signum, \
+ struct svr4_sigaction *nsa, \
+ struct svr4_sigaction *osa); }
+99 STD SVR4 { int svr4_sys_sigpending(int what, \
+ svr4_sigset_t *mask); }
+100 STD SVR4 { int svr4_sys_context(int func, \
+ struct svr4_ucontext *uc); }
+101 UNIMPL SVR4 evsys
+102 UNIMPL SVR4 evtrapret
+103 STD SVR4 { int svr4_sys_statvfs(char *path, \
+ struct svr4_statvfs *fs); }
+104 STD SVR4 { int svr4_sys_fstatvfs(int fd, \
+ struct svr4_statvfs *fs); }
+105 UNIMPL SVR4 whoknows
+106 UNIMPL SVR4 nfssvc
+107 STD SVR4 { int svr4_sys_waitsys(int grp, int id, \
+ union svr4_siginfo *info, int options); }
+108 UNIMPL SVR4 sigsendsys
+109 STD SVR4 { int svr4_sys_hrtsys(int cmd, int fun, int sub, \
+ void *rv1, void *rv2); }
+110 UNIMPL SVR4 acancel
+111 UNIMPL SVR4 async
+112 UNIMPL SVR4 priocntlsys
+113 STD SVR4 { int svr4_sys_pathconf(char *path, int name); }
+114 UNIMPL SVR4 mincore
+115 STD SVR4 { caddr_t svr4_sys_mmap( caddr_t addr, svr4_size_t len, \
+ int prot, int flags, int fd, svr4_off_t pos); }
+116 NOPROTO SVR4 { int mprotect(void *addr, int len, int prot); }
+117 NOPROTO SVR4 { int munmap(void *addr, int len); }
+118 STD SVR4 { int svr4_sys_fpathconf(int fd, int name); }
+119 NOPROTO SVR4 { int vfork(void); }
+120 NOPROTO SVR4 { int fchdir(int fd); }
+121 NOPROTO SVR4 { int readv(int fd, struct iovec *iovp, \
+ u_int iovcnt); }
+122 NOPROTO SVR4 { int writev(int fd, struct iovec *iovp, \
+ u_int iovcnt); }
+123 STD SVR4 { int svr4_sys_xstat(int two, char *path, \
+ struct svr4_xstat *ub); }
+124 STD SVR4 { int svr4_sys_lxstat(int two, char *path, \
+ struct svr4_xstat *ub); }
+125 STD SVR4 { int svr4_sys_fxstat(int two, int fd, \
+ struct svr4_xstat *sb); }
+126 STD SVR4 { int svr4_sys_xmknod(int two, char *path, \
+ svr4_mode_t mode, svr4_dev_t dev); }
+127 UNIMPL SVR4 clocal
+128 STD SVR4 { int svr4_sys_setrlimit(int which, \
+ const struct svr4_rlimit *rlp); }
+129 STD SVR4 { int svr4_sys_getrlimit(int which, \
+ struct svr4_rlimit *rlp); }
+130 NOPROTO SVR4 { int lchown(char *path, uid_t uid, gid_t gid); }
+131 STD SVR4 { int svr4_sys_memcntl(void * addr, \
+ svr4_size_t len, int cmd, void * arg, \
+ int attr, int mask); }
+132 UNIMPL SVR4 getpmsg
+133 UNIMPL SVR4 putpmsg
+134 NOPROTO SVR4 { int rename(char *from, char *to); }
+135 STD SVR4 { int svr4_sys_uname(struct svr4_utsname* name, \
+ int dummy); }
+136 NOPROTO SVR4 { int setegid(gid_t egid); }
+137 STD SVR4 { int svr4_sys_sysconfig(int name); }
+138 NOPROTO SVR4 { int adjtime(struct timeval *delta, \
+ struct timeval *olddelta); }
+139 STD SVR4 { long svr4_sys_systeminfo(int what, char *buf, \
+ long len); }
+140 UNIMPL SVR4 notused
+141 NOPROTO SVR4 { int seteuid(uid_t euid); }
+142 UNIMPL SVR4 vtrace
+; fork1
+143 UNIMPL SVR4 { int fork(void); }
+144 UNIMPL SVR4 sigtimedwait
+145 UNIMPL SVR4 lwp_info
+146 UNIMPL SVR4 yield
+147 UNIMPL SVR4 lwp_sema_wait
+148 UNIMPL SVR4 lwp_sema_post
+149 UNIMPL SVR4 lwp_sema_trywait
+150 UNIMPL SVR4 notused
+151 UNIMPL SVR4 notused
+152 UNIMPL SVR4 modctl
+153 STD SVR4 { int svr4_sys_fchroot(int fd); }
+154 STD SVR4 { int svr4_sys_utimes(char *path, \
+ struct timeval *tptr); }
+155 STD SVR4 { int svr4_sys_vhangup(void); }
+156 STD SVR4 { int svr4_sys_gettimeofday(struct timeval *tp); }
+157 NOPROTO SVR4 { int getitimer(u_int which, struct itimerval *itv); }
+158 NOPROTO SVR4 { int setitimer(u_int which, struct itimerval *itv, \
+ struct itimerval *oitv); }
+159 UNIMPL SVR4 lwp_create
+160 UNIMPL SVR4 lwp_exit
+161 UNIMPL SVR4 lwp_suspend
+162 UNIMPL SVR4 lwp_continue
+163 UNIMPL SVR4 lwp_kill
+164 UNIMPL SVR4 lwp_self
+165 UNIMPL SVR4 lwp_getprivate
+166 UNIMPL SVR4 lwp_setprivate
+167 UNIMPL SVR4 lwp_wait
+168 UNIMPL SVR4 lwp_mutex_unlock
+169 UNIMPL SVR4 lwp_mutex_lock
+170 UNIMPL SVR4 lwp_cond_wait
+171 UNIMPL SVR4 lwp_cond_signal
+172 UNIMPL SVR4 lwp_cond_broadcast
+173 UNIMPL SVR4 { ssize_t svr4_sys_pread(int fd, void *buf, \
+ size_t nbyte, svr4_off_t off); }
+174 UNIMPL SVR4 { ssize_t svr4_sys_pwrite(int fd, const void *buf, \
+ size_t nbyte, svr4_off_t off); }
+175 STD SVR4 { svr4_off64_t svr4_sys_llseek(int fd, long offset1, \
+ long offset2, int whence); }
+176 UNIMPL SVR4 inst_sync
+177 UNIMPL SVR4 whoknows
+178 UNIMPL SVR4 kaio
+179 UNIMPL SVR4 whoknows
+180 UNIMPL SVR4 whoknows
+181 UNIMPL SVR4 whoknows
+182 UNIMPL SVR4 whoknows
+183 UNIMPL SVR4 whoknows
+184 UNIMPL SVR4 tsolsys
+185 STD SVR4 { int svr4_sys_acl(char *path, int cmd, int num, \
+ struct svr4_aclent *buf); }
+186 STD SVR4 { int svr4_sys_auditsys(int code, int a1, int a2, \
+ int a3, int a4, int a5); }
+187 UNIMPL SVR4 processor_bind
+188 UNIMPL SVR4 processor_info
+189 UNIMPL SVR4 p_online
+190 UNIMPL SVR4 sigqueue
+191 UNIMPL SVR4 clock_gettime
+192 UNIMPL SVR4 clock_settime
+193 UNIMPL SVR4 clock_getres
+194 UNIMPL SVR4 timer_create
+195 UNIMPL SVR4 timer_delete
+196 UNIMPL SVR4 timer_settime
+197 UNIMPL SVR4 timer_gettime
+198 UNIMPL SVR4 timer_overrun
+199 NOPROTO SVR4 { int nanosleep(const struct timespec *rqtp, \
+ struct timespec *rmtp); }
+200 STD SVR4 { int svr4_sys_facl(int fd, int cmd, int num, \
+ struct svr4_aclent *buf); }
+201 UNIMPL SVR4 door
+202 NOPROTO SVR4 { int setreuid(int ruid, int euid); }
+203 NOPROTO SVR4 { int setregid(int rgid, int egid); }
+204 UNIMPL SVR4 install_utrap
+205 UNIMPL SVR4 signotify
+206 UNIMPL SVR4 schedctl
+207 UNIMPL SVR4 pset
+208 UNIMPL SVR4 whoknows
+209 STD SVR4 { int svr4_sys_resolvepath(const char *path, \
+ char *buf, size_t bufsiz); }
+210 UNIMPL SVR4 signotifywait
+211 UNIMPL SVR4 lwp_sigredirect
+212 UNIMPL SVR4 lwp_alarm
+213 STD SVR4 { int svr4_sys_getdents64(int fd, \
+ struct svr4_dirent64 *dp, \
+ int nbytes); }
+;213 UNIMPL SVR4 getdents64
+214 STD SVR4 { caddr_t svr4_sys_mmap64(void *addr, \
+ svr4_size_t len, int prot, int flags, int fd, \
+ svr4_off64_t pos); }
+215 STD SVR4 { int svr4_sys_stat64(char *path, \
+ struct svr4_stat64 *sb); }
+216 STD SVR4 { int svr4_sys_lstat64(char *path, \
+ struct svr4_stat64 *sb); }
+217 STD SVR4 { int svr4_sys_fstat64(int fd, \
+ struct svr4_stat64 *sb); }
+218 STD SVR4 { int svr4_sys_statvfs64(char *path, \
+ struct svr4_statvfs64 *fs); }
+219 STD SVR4 { int svr4_sys_fstatvfs64(int fd, \
+ struct svr4_statvfs64 *fs); }
+220 STD SVR4 { int svr4_sys_setrlimit64(int which, \
+ const struct svr4_rlimit64 *rlp); }
+221 STD SVR4 { int svr4_sys_getrlimit64(int which, \
+ struct svr4_rlimit64 *rlp); }
+222 UNIMPL SVR4 pread64
+223 UNIMPL SVR4 pwrite64
+224 STD SVR4 { int svr4_sys_creat64(char *path, int mode); }
+225 STD SVR4 { int svr4_sys_open64(char *path, int flags, \
+ int mode); }
+226 UNIMPL SVR4 rpcsys
+227 UNIMPL SVR4 whoknows
+228 UNIMPL SVR4 whoknows
+229 UNIMPL SVR4 whoknows
+230 STD SVR4 { int svr4_sys_socket(int domain, int type, \
+ int protocol); }
+231 NOPROTO SVR4 { int socketpair(int domain, int type, \
+ int protocol, int *rsv); }
+232 NOPROTO SVR4 { int bind(int s, const struct sockaddr *name, \
+ int namelen); }
+233 NOPROTO SVR4 { int listen(int s, int backlog); }
+234 NOPROTO SVR4 { int accept(int s, struct sockaddr *name, \
+ int *anamelen); }
+235 NOPROTO SVR4 { int connect(int s, const struct sockaddr *name, \
+ int namelen); }
+236 NOPROTO SVR4 { int shutdown(int s, int how); }
+237 STD SVR4 { int svr4_sys_recv(int s, caddr_t buf, int len, int flags); }
+238 NOPROTO SVR4 { ssize_t recvfrom(int s, void *buf, size_t len, \
+ int flags, struct sockaddr *from, \
+ int *fromlenaddr); }
+239 NOPROTO SVR4 { ssize_t recvmsg(int s, struct msghdr *msg, \
+ int flags); }
+240 STD SVR4 { int svr4_sys_send(int s, caddr_t buf, int len, int flags); }
+241 NOPROTO SVR4 { ssize_t sendmsg(int s, const struct msghdr *msg, \
+ int flags); }
+242 STD SVR4 { ssize_t svr4_sys_sendto(int s, const void *buf, \
+ size_t len, int flags, \
+ const struct sockaddr *to, int tolen); }
+243 NOPROTO SVR4 { int getpeername(int fdes, struct sockaddr *asa, \
+ int *alen); }
+244 NOPROTO SVR4 { int getsockname(int fdes, struct sockaddr *asa, \
+ int *alen); }
+245 NOPROTO SVR4 { int getsockopt(int s, int level, int name, \
+ void *val, int *avalsize); }
+246 NOPROTO SVR4 { int setsockopt(int s, int level, int name, \
+ const void *val, int valsize); }
+247 UNIMPL SVR4 sockconfig
+248 UNIMPL SVR4 { int ntp_gettime(struct ntptimeval *ntvp); }
+249 UNIMPL SVR4 { int ntp_adjtime(struct timex *tp); }
OpenPOWER on IntegriCloud