diff options
Diffstat (limited to 'sys/compat/svr4')
56 files changed, 14053 insertions, 0 deletions
diff --git a/sys/compat/svr4/Makefile b/sys/compat/svr4/Makefile new file mode 100644 index 0000000..d8fd59b --- /dev/null +++ b/sys/compat/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/compat/svr4/imgact_svr4.c b/sys/compat/svr4/imgact_svr4.c new file mode 100644 index 0000000..1324805 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4.h b/sys/compat/svr4/svr4.h new file mode 100644 index 0000000..45e08b3 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_acl.h b/sys/compat/svr4/svr4_acl.h new file mode 100644 index 0000000..2d4f10f --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_dirent.h b/sys/compat/svr4/svr4_dirent.h new file mode 100644 index 0000000..a2e8a59 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_errno.h b/sys/compat/svr4/svr4_errno.h new file mode 100644 index 0000000..42de6d0 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_exec.h b/sys/compat/svr4/svr4_exec.h new file mode 100644 index 0000000..84fcd3d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_fcntl.c b/sys/compat/svr4/svr4_fcntl.c new file mode 100644 index 0000000..9bd403c --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_fcntl.h b/sys/compat/svr4/svr4_fcntl.h new file mode 100644 index 0000000..8c202f2 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_filio.c b/sys/compat/svr4/svr4_filio.c new file mode 100644 index 0000000..c82b09b --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_filio.h b/sys/compat/svr4/svr4_filio.h new file mode 100644 index 0000000..2f105a7 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_fuser.h b/sys/compat/svr4/svr4_fuser.h new file mode 100644 index 0000000..669d527 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_hrt.h b/sys/compat/svr4/svr4_hrt.h new file mode 100644 index 0000000..ce54ad0 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ioctl.c b/sys/compat/svr4/svr4_ioctl.c new file mode 100644 index 0000000..2ce3004 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ioctl.h b/sys/compat/svr4/svr4_ioctl.h new file mode 100644 index 0000000..e95fa5a --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ipc.c b/sys/compat/svr4/svr4_ipc.c new file mode 100644 index 0000000..8bb661b --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ipc.h b/sys/compat/svr4/svr4_ipc.h new file mode 100644 index 0000000..798920d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_misc.c b/sys/compat/svr4/svr4_misc.c new file mode 100644 index 0000000..5b537c6 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_mman.h b/sys/compat/svr4/svr4_mman.h new file mode 100644 index 0000000..9a7f213 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_proto.h b/sys/compat/svr4/svr4_proto.h new file mode 100644 index 0000000..101d36e --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_resource.c b/sys/compat/svr4/svr4_resource.c new file mode 100644 index 0000000..083049f --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_resource.h b/sys/compat/svr4/svr4_resource.h new file mode 100644 index 0000000..98c4fce --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_siginfo.h b/sys/compat/svr4/svr4_siginfo.h new file mode 100644 index 0000000..fe63e5d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_signal.c b/sys/compat/svr4/svr4_signal.c new file mode 100644 index 0000000..47cc6fe --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_signal.h b/sys/compat/svr4/svr4_signal.h new file mode 100644 index 0000000..39444a9 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_socket.c b/sys/compat/svr4/svr4_socket.c new file mode 100644 index 0000000..314e1cd --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_socket.h b/sys/compat/svr4/svr4_socket.h new file mode 100644 index 0000000..8e0dc31 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sockio.c b/sys/compat/svr4/svr4_sockio.c new file mode 100644 index 0000000..7b9fb1f --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sockio.h b/sys/compat/svr4/svr4_sockio.h new file mode 100644 index 0000000..7ddbcf7 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sockmod.h b/sys/compat/svr4/svr4_sockmod.h new file mode 100644 index 0000000..e0fe451 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_stat.c b/sys/compat/svr4/svr4_stat.c new file mode 100644 index 0000000..99448ba --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_stat.h b/sys/compat/svr4/svr4_stat.h new file mode 100644 index 0000000..dea7d1f --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_statvfs.h b/sys/compat/svr4/svr4_statvfs.h new file mode 100644 index 0000000..30ae808 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_stream.c b/sys/compat/svr4/svr4_stream.c new file mode 100644 index 0000000..a656d33 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_stropts.h b/sys/compat/svr4/svr4_stropts.h new file mode 100644 index 0000000..75a33b3 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_syscall.h b/sys/compat/svr4/svr4_syscall.h new file mode 100644 index 0000000..1489740 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_syscallnames.c b/sys/compat/svr4/svr4_syscallnames.c new file mode 100644 index 0000000..bb715b0 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sysconfig.h b/sys/compat/svr4/svr4_sysconfig.h new file mode 100644 index 0000000..bb1000a --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sysent.c b/sys/compat/svr4/svr4_sysent.c new file mode 100644 index 0000000..3b1415d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_systeminfo.h b/sys/compat/svr4/svr4_systeminfo.h new file mode 100644 index 0000000..520c6fa --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_sysvec.c b/sys/compat/svr4/svr4_sysvec.c new file mode 100644 index 0000000..8b0997d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_termios.c b/sys/compat/svr4/svr4_termios.c new file mode 100644 index 0000000..fd5db71 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_termios.h b/sys/compat/svr4/svr4_termios.h new file mode 100644 index 0000000..a8f40ad --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_time.h b/sys/compat/svr4/svr4_time.h new file mode 100644 index 0000000..c92f4f4 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_timod.h b/sys/compat/svr4/svr4_timod.h new file mode 100644 index 0000000..277f1f4 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ttold.c b/sys/compat/svr4/svr4_ttold.c new file mode 100644 index 0000000..691f1d6 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ttold.h b/sys/compat/svr4/svr4_ttold.h new file mode 100644 index 0000000..edc0762 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_types.h b/sys/compat/svr4/svr4_types.h new file mode 100644 index 0000000..406e0da --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ucontext.h b/sys/compat/svr4/svr4_ucontext.h new file mode 100644 index 0000000..e2bdb82 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ulimit.h b/sys/compat/svr4/svr4_ulimit.h new file mode 100644 index 0000000..c151da1 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_ustat.h b/sys/compat/svr4/svr4_ustat.h new file mode 100644 index 0000000..89712d5 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_util.h b/sys/compat/svr4/svr4_util.h new file mode 100644 index 0000000..8bbb980 --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_utsname.h b/sys/compat/svr4/svr4_utsname.h new file mode 100644 index 0000000..c3afa1d --- /dev/null +++ b/sys/compat/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/compat/svr4/svr4_wait.h b/sys/compat/svr4/svr4_wait.h new file mode 100644 index 0000000..1935163 --- /dev/null +++ b/sys/compat/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/compat/svr4/syscalls.conf b/sys/compat/svr4/syscalls.conf new file mode 100644 index 0000000..5c01a85 --- /dev/null +++ b/sys/compat/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/compat/svr4/syscalls.master b/sys/compat/svr4/syscalls.master new file mode 100644 index 0000000..1420318 --- /dev/null +++ b/sys/compat/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); } |
