Index: head/sys/compat/svr4/imgact_svr4.c =================================================================== --- head/sys/compat/svr4/imgact_svr4.c (revision 49266) +++ head/sys/compat/svr4/imgact_svr4.c (revision 49267) @@ -1,235 +1,236 @@ /*- * 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. * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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. */ struct execsw svr4_execsw = { exec_svr4_imgact, "svr4 ELF" }; EXEC_SET(execsw_set, svr4_execsw); Index: head/sys/compat/svr4/svr4.h =================================================================== --- head/sys/compat/svr4/svr4.h (revision 49266) +++ head/sys/compat/svr4/svr4.h (revision 49267) @@ -1,38 +1,40 @@ /* * 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. + * + * $Id$ */ #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 Index: head/sys/compat/svr4/svr4_acl.h =================================================================== --- head/sys/compat/svr4/svr4_acl.h (revision 49266) +++ head/sys/compat/svr4/svr4_acl.h (revision 49267) @@ -1,44 +1,46 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_dirent.h =================================================================== --- head/sys/compat/svr4/svr4_dirent.h (revision 49266) +++ head/sys/compat/svr4/svr4_dirent.h (revision 49267) @@ -1,51 +1,53 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_errno.h =================================================================== --- head/sys/compat/svr4/svr4_errno.h (revision 49266) +++ head/sys/compat/svr4/svr4_errno.h (revision 49267) @@ -1,170 +1,172 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_exec.h =================================================================== --- head/sys/compat/svr4/svr4_exec.h (revision 49266) +++ head/sys/compat/svr4/svr4_exec.h (revision 49267) @@ -1,68 +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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_fcntl.c =================================================================== --- head/sys/compat/svr4/svr4_fcntl.c (revision 49266) +++ head/sys/compat/svr4/svr4_fcntl.c (revision 49267) @@ -1,721 +1,723 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include /*#include */ #include #include #include #include #include #include #include #include #include #include #include #include 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)) != 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; } } Index: head/sys/compat/svr4/svr4_fcntl.h =================================================================== --- head/sys/compat/svr4/svr4_fcntl.h (revision 49266) +++ head/sys/compat/svr4/svr4_fcntl.h (revision 49267) @@ -1,132 +1,134 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_FCNTL_H_ #define _SVR4_FCNTL_H_ #include #include #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_ */ Index: head/sys/compat/svr4/svr4_filio.c =================================================================== --- head/sys/compat/svr4/svr4_filio.c (revision 49266) +++ head/sys/compat/svr4/svr4_filio.c (revision 49267) @@ -1,245 +1,247 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /*#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 */ } } Index: head/sys/compat/svr4/svr4_filio.h =================================================================== --- head/sys/compat/svr4/svr4_filio.h (revision 49266) +++ head/sys/compat/svr4/svr4_filio.h (revision 49267) @@ -1,43 +1,45 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_fuser.h =================================================================== --- head/sys/compat/svr4/svr4_fuser.h (revision 49266) +++ head/sys/compat/svr4/svr4_fuser.h (revision 49267) @@ -1,96 +1,97 @@ /* + * $Id$ * 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 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_ */ Index: head/sys/compat/svr4/svr4_hrt.h =================================================================== --- head/sys/compat/svr4/svr4_hrt.h (revision 49266) +++ head/sys/compat/svr4/svr4_hrt.h (revision 49267) @@ -1,85 +1,87 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ioctl.c =================================================================== --- head/sys/compat/svr4/svr4_ioctl.c (revision 49266) +++ head/sys/compat/svr4/svr4_ioctl.c (revision 49267) @@ -1,167 +1,169 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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)); } Index: head/sys/compat/svr4/svr4_ioctl.h =================================================================== --- head/sys/compat/svr4/svr4_ioctl.h (revision 49266) +++ head/sys/compat/svr4/svr4_ioctl.h (revision 49267) @@ -1,60 +1,62 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ipc.c =================================================================== --- head/sys/compat/svr4/svr4_ipc.c (revision 49266) +++ head/sys/compat/svr4/svr4_ipc.c (revision 49267) @@ -1,831 +1,832 @@ /* + * $Id$ * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 */ Index: head/sys/compat/svr4/svr4_ipc.h =================================================================== --- head/sys/compat/svr4/svr4_ipc.h (revision 49266) +++ head/sys/compat/svr4/svr4_ipc.h (revision 49267) @@ -1,174 +1,176 @@ /* * 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. + * + * $Id$ */ #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 */ Index: head/sys/compat/svr4/svr4_misc.c =================================================================== --- head/sys/compat/svr4/svr4_misc.c (revision 49266) +++ head/sys/compat/svr4/svr4_misc.c (revision 49267) @@ -1,1626 +1,1628 @@ /* * 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. + * + * $Id$ */ /* * SVR4 compatibility module. * * SVR4 system calls that are implemented differently in BSD are * handled here. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(NetBSD) # if defined(UVM) # include # endif #endif #define BSD_DIRENT(cp) ((struct dirent *)(cp)) 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); + outp = (caddr_t)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)) + if (outp == (caddr_t)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)) != 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))); + (svr4_dev_t)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))); + (svr4_dev_t)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; } Index: head/sys/compat/svr4/svr4_mman.h =================================================================== --- head/sys/compat/svr4/svr4_mman.h (revision 49266) +++ head/sys/compat/svr4/svr4_mman.h (revision 49267) @@ -1,45 +1,47 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_MMAN_H_ #define _SVR4_MMAN_H_ /* * Commands and flags passed to memcntl(). * Most of them are the same as , 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 */ Index: head/sys/compat/svr4/svr4_proto.h =================================================================== --- head/sys/compat/svr4/svr4_proto.h (revision 49266) +++ head/sys/compat/svr4/svr4_proto.h (revision 49267) @@ -1,472 +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 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 *)]; + void * buf; char buf_[PAD_(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 *)]; + struct sockaddr * to; char to_[PAD_(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_ */ Index: head/sys/compat/svr4/svr4_resource.c =================================================================== --- head/sys/compat/svr4/svr4_resource.c (revision 49266) +++ head/sys/compat/svr4/svr4_resource.c (revision 49267) @@ -1,311 +1,313 @@ /* 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. + * + * $Id$ */ /* * 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 #include #include #include #include #include #include #include #include #include #include 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); } Index: head/sys/compat/svr4/svr4_resource.h =================================================================== --- head/sys/compat/svr4/svr4_resource.h (revision 49266) +++ head/sys/compat/svr4/svr4_resource.h (revision 49267) @@ -1,107 +1,109 @@ /* 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. + * + * $Id$ */ /* * 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_ */ Index: head/sys/compat/svr4/svr4_siginfo.h =================================================================== --- head/sys/compat/svr4/svr4_siginfo.h (revision 49266) +++ head/sys/compat/svr4/svr4_siginfo.h (revision 49267) @@ -1,109 +1,111 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_signal.c =================================================================== --- head/sys/compat/svr4/svr4_signal.c (revision 49266) +++ head/sys/compat/svr4/svr4_signal.c (revision 49267) @@ -1,623 +1,625 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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->ssa_handler; svr4_to_bsd_sigset(&ssa->ssa_mask, &bsa->sa_mask); bsa->sa_flags = 0; if ((ssa->ssa_flags & SVR4_SA_ONSTACK) != 0) bsa->sa_flags |= SA_ONSTACK; if ((ssa->ssa_flags & SVR4_SA_RESETHAND) != 0) bsa->sa_flags |= SA_RESETHAND; if ((ssa->ssa_flags & SVR4_SA_RESTART) != 0) bsa->sa_flags |= SA_RESTART; if ((ssa->ssa_flags & SVR4_SA_SIGINFO) != 0) DPRINTF(("svr4_to_bsd_sigaction: SA_SIGINFO ignored\n")); if ((ssa->ssa_flags & SVR4_SA_NOCLDSTOP) != 0) bsa->sa_flags |= SA_NOCLDSTOP; if ((ssa->ssa_flags & SVR4_SA_NODEFER) != 0) bsa->sa_flags |= SA_NODEFER; if ((ssa->ssa_flags & SVR4_SA_NOCLDWAIT) != 0) bsa->sa_flags |= SA_NOCLDWAIT; if ((ssa->ssa_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->ssa_handler = (svr4_sig_t) bsa->sa_handler; bsd_to_svr4_sigset(&bsa->sa_mask, &ssa->ssa_mask); ssa->ssa_flags = 0; if ((bsa->sa_flags & SA_ONSTACK) != 0) ssa->ssa_flags |= SVR4_SA_ONSTACK; if ((bsa->sa_flags & SA_RESETHAND) != 0) ssa->ssa_flags |= SVR4_SA_RESETHAND; if ((bsa->sa_flags & SA_RESTART) != 0) ssa->ssa_flags |= SVR4_SA_RESTART; if ((bsa->sa_flags & SA_NODEFER) != 0) ssa->ssa_flags |= SVR4_SA_NODEFER; if ((bsa->sa_flags & SA_NOCLDSTOP) != 0) ssa->ssa_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); } Index: head/sys/compat/svr4/svr4_signal.h =================================================================== --- head/sys/compat/svr4/svr4_signal.h (revision 49266) +++ head/sys/compat/svr4/svr4_signal.h (revision 49267) @@ -1,130 +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. + * + * $Id$ */ #ifndef _SVR4_SIGNAL_H_ #define _SVR4_SIGNAL_H_ #include #include #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 ssa_flags; svr4_sig_t ssa_handler; svr4_sigset_t ssa_mask; int ssa_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_ */ Index: head/sys/compat/svr4/svr4_socket.c =================================================================== --- head/sys/compat/svr4/svr4_socket.c (revision 49266) +++ head/sys/compat/svr4/svr4_socket.c (revision 49267) @@ -1,204 +1,206 @@ /* * 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. + * + * $Id$ */ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 */ + udev_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; + udev_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); } Index: head/sys/compat/svr4/svr4_socket.h =================================================================== --- head/sys/compat/svr4/svr4_socket.h (revision 49266) +++ head/sys/compat/svr4/svr4_socket.h (revision 49267) @@ -1,53 +1,55 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_SOCKET_H_ #define _SVR4_SOCKET_H_ #include 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)); + udev_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_ */ Index: head/sys/compat/svr4/svr4_sockio.c =================================================================== --- head/sys/compat/svr4/svr4_sockio.c (revision 49266) +++ head/sys/compat/svr4/svr4_sockio.c (revision 49267) @@ -1,174 +1,176 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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, 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 */ } } Index: head/sys/compat/svr4/svr4_sockio.h =================================================================== --- head/sys/compat/svr4/svr4_sockio.h (revision 49266) +++ head/sys/compat/svr4/svr4_sockio.h (revision 49267) @@ -1,91 +1,93 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_sockmod.h =================================================================== --- head/sys/compat/svr4/svr4_sockmod.h (revision 49266) +++ head/sys/compat/svr4/svr4_sockmod.h (revision 49267) @@ -1,81 +1,83 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_statvfs.h =================================================================== --- head/sys/compat/svr4/svr4_statvfs.h (revision 49266) +++ head/sys/compat/svr4/svr4_statvfs.h (revision 49267) @@ -1,70 +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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_stream.c =================================================================== --- head/sys/compat/svr4/svr4_stream.c (revision 49266) +++ head/sys/compat/svr4/svr4_stream.c (revision 49267) @@ -1,2264 +1,2266 @@ /* * 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. + * + * $Id$ */ /* * Pretend that we have streams... * Yes, this is gross. * * ToDo: The state machine for getmsg needs re-thinking */ #define COMPAT_43 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* 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)); /* 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)) + if ((error = copyout((caddr_t)mtod(m, caddr_t), + ctlbuf, tocopy)) != 0) 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); + udev_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("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 */ Index: head/sys/compat/svr4/svr4_sysconfig.h =================================================================== --- head/sys/compat/svr4/svr4_sysconfig.h (revision 49266) +++ head/sys/compat/svr4/svr4_sysconfig.h (revision 49267) @@ -1,60 +1,62 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_systeminfo.h =================================================================== --- head/sys/compat/svr4/svr4_systeminfo.h (revision 49266) +++ head/sys/compat/svr4/svr4_systeminfo.h (revision 49267) @@ -1,48 +1,50 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_sysvec.c =================================================================== --- head/sys/compat/svr4/svr4_sysvec.c (revision 49266) +++ head/sys/compat/svr4/svr4_sysvec.c (revision 49267) @@ -1,383 +1,411 @@ +/* + * 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. 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. + * + * $Id$ + */ + /* 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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); +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" + NULL, + "SVR4", + elf_coredump }; 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: /* Only allow the emulator to be removed if it isn't in use. */ if (elf_brand_inuse(&svr4_brand) != 0) { error = EBUSY; } else if (elf_remove_brand_entry(&svr4_brand) < 0) { error = EINVAL; } if (error) printf("Could not deinstall ELF interpreter entry (error %d)\n", error); 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); Index: head/sys/compat/svr4/svr4_termios.c =================================================================== --- head/sys/compat/svr4/svr4_termios.c (revision 49266) +++ head/sys/compat/svr4/svr4_termios.c (revision 49267) @@ -1,619 +1,621 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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); } } Index: head/sys/compat/svr4/svr4_termios.h =================================================================== --- head/sys/compat/svr4/svr4_termios.h (revision 49266) +++ head/sys/compat/svr4/svr4_termios.h (revision 49267) @@ -1,222 +1,224 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_time.h =================================================================== --- head/sys/compat/svr4/svr4_time.h (revision 49266) +++ head/sys/compat/svr4/svr4_time.h (revision 49267) @@ -1,39 +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. + * + * $Id$ */ #ifndef _SVR4_TIME_H_ #define _SVR4_TIME_H_ #include struct svr4_utimbuf { time_t actime; time_t modtime; }; #endif /* !_SVR4_TIME_H_ */ Index: head/sys/compat/svr4/svr4_timod.h =================================================================== --- head/sys/compat/svr4/svr4_timod.h (revision 49266) +++ head/sys/compat/svr4/svr4_timod.h (revision 49267) @@ -1,85 +1,87 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ttold.c =================================================================== --- head/sys/compat/svr4/svr4_ttold.c (revision 49266) +++ head/sys/compat/svr4/svr4_ttold.c (revision 49267) @@ -1,381 +1,383 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 */ } } Index: head/sys/compat/svr4/svr4_ttold.h =================================================================== --- head/sys/compat/svr4/svr4_ttold.h (revision 49266) +++ head/sys/compat/svr4/svr4_ttold.h (revision 49267) @@ -1,120 +1,122 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ucontext.h =================================================================== --- head/sys/compat/svr4/svr4_ucontext.h (revision 49266) +++ head/sys/compat/svr4/svr4_ucontext.h (revision 49267) @@ -1,72 +1,74 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ulimit.h =================================================================== --- head/sys/compat/svr4/svr4_ulimit.h (revision 49266) +++ head/sys/compat/svr4/svr4_ulimit.h (revision 49267) @@ -1,39 +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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/svr4_ustat.h =================================================================== --- head/sys/compat/svr4/svr4_ustat.h (revision 49266) +++ head/sys/compat/svr4/svr4_ustat.h (revision 49267) @@ -1,41 +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. + * + * $Id$ */ #ifndef _SVR4_USTAT_H_ #define _SVR4_USTAT_H_ #include 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_ */ Index: head/sys/compat/svr4/svr4_util.h =================================================================== --- head/sys/compat/svr4/svr4_util.h (revision 49266) +++ head/sys/compat/svr4/svr4_util.h (revision 49267) @@ -1,78 +1,80 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_UTIL_H_ #define _SVR4_UTIL_H_ /*#include */ #include #include #include #include #include #include #include #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_ */ Index: head/sys/compat/svr4/svr4_utsname.h =================================================================== --- head/sys/compat/svr4/svr4_utsname.h (revision 49266) +++ head/sys/compat/svr4/svr4_utsname.h (revision 49267) @@ -1,42 +1,44 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_UTSNAME_H_ #define _SVR4_UTSNAME_H_ #include struct svr4_utsname { char sysname[257]; char nodename[257]; char release[257]; char version[257]; char machine[257]; }; #endif /* !_SVR4_UTSNAME_H_ */ Index: head/sys/compat/svr4/svr4_wait.h =================================================================== --- head/sys/compat/svr4/svr4_wait.h (revision 49266) +++ head/sys/compat/svr4/svr4_wait.h (revision 49267) @@ -1,54 +1,56 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/compat/svr4/syscalls.master =================================================================== --- head/sys/compat/svr4/syscalls.master (revision 49266) +++ head/sys/compat/svr4/syscalls.master (revision 49267) @@ -1,373 +1,375 @@ ; @(#)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 - +; +; $Id$ +; #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include ; #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, \ +242 STD SVR4 { ssize_t svr4_sys_sendto(int s, void *buf, \ size_t len, int flags, \ - const struct sockaddr *to, int tolen); } + 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); } Index: head/sys/svr4/imgact_svr4.c =================================================================== --- head/sys/svr4/imgact_svr4.c (revision 49266) +++ head/sys/svr4/imgact_svr4.c (revision 49267) @@ -1,235 +1,236 @@ /*- * 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. * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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. */ struct execsw svr4_execsw = { exec_svr4_imgact, "svr4 ELF" }; EXEC_SET(execsw_set, svr4_execsw); Index: head/sys/svr4/svr4.h =================================================================== --- head/sys/svr4/svr4.h (revision 49266) +++ head/sys/svr4/svr4.h (revision 49267) @@ -1,38 +1,40 @@ /* * 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. + * + * $Id$ */ #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 Index: head/sys/svr4/svr4_acl.h =================================================================== --- head/sys/svr4/svr4_acl.h (revision 49266) +++ head/sys/svr4/svr4_acl.h (revision 49267) @@ -1,44 +1,46 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_dirent.h =================================================================== --- head/sys/svr4/svr4_dirent.h (revision 49266) +++ head/sys/svr4/svr4_dirent.h (revision 49267) @@ -1,51 +1,53 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_errno.h =================================================================== --- head/sys/svr4/svr4_errno.h (revision 49266) +++ head/sys/svr4/svr4_errno.h (revision 49267) @@ -1,170 +1,172 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_exec.h =================================================================== --- head/sys/svr4/svr4_exec.h (revision 49266) +++ head/sys/svr4/svr4_exec.h (revision 49267) @@ -1,68 +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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_fcntl.c =================================================================== --- head/sys/svr4/svr4_fcntl.c (revision 49266) +++ head/sys/svr4/svr4_fcntl.c (revision 49267) @@ -1,721 +1,723 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include /*#include */ #include #include #include #include #include #include #include #include #include #include #include #include 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)) != 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; } } Index: head/sys/svr4/svr4_fcntl.h =================================================================== --- head/sys/svr4/svr4_fcntl.h (revision 49266) +++ head/sys/svr4/svr4_fcntl.h (revision 49267) @@ -1,132 +1,134 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_FCNTL_H_ #define _SVR4_FCNTL_H_ #include #include #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_ */ Index: head/sys/svr4/svr4_filio.c =================================================================== --- head/sys/svr4/svr4_filio.c (revision 49266) +++ head/sys/svr4/svr4_filio.c (revision 49267) @@ -1,245 +1,247 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /*#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 */ } } Index: head/sys/svr4/svr4_filio.h =================================================================== --- head/sys/svr4/svr4_filio.h (revision 49266) +++ head/sys/svr4/svr4_filio.h (revision 49267) @@ -1,43 +1,45 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_fuser.h =================================================================== --- head/sys/svr4/svr4_fuser.h (revision 49266) +++ head/sys/svr4/svr4_fuser.h (revision 49267) @@ -1,96 +1,97 @@ /* + * $Id$ * 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 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_ */ Index: head/sys/svr4/svr4_hrt.h =================================================================== --- head/sys/svr4/svr4_hrt.h (revision 49266) +++ head/sys/svr4/svr4_hrt.h (revision 49267) @@ -1,85 +1,87 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ioctl.c =================================================================== --- head/sys/svr4/svr4_ioctl.c (revision 49266) +++ head/sys/svr4/svr4_ioctl.c (revision 49267) @@ -1,167 +1,169 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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)); } Index: head/sys/svr4/svr4_ioctl.h =================================================================== --- head/sys/svr4/svr4_ioctl.h (revision 49266) +++ head/sys/svr4/svr4_ioctl.h (revision 49267) @@ -1,60 +1,62 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ipc.c =================================================================== --- head/sys/svr4/svr4_ipc.c (revision 49266) +++ head/sys/svr4/svr4_ipc.c (revision 49267) @@ -1,831 +1,832 @@ /* + * $Id$ * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 */ Index: head/sys/svr4/svr4_ipc.h =================================================================== --- head/sys/svr4/svr4_ipc.h (revision 49266) +++ head/sys/svr4/svr4_ipc.h (revision 49267) @@ -1,174 +1,176 @@ /* * 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. + * + * $Id$ */ #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 */ Index: head/sys/svr4/svr4_misc.c =================================================================== --- head/sys/svr4/svr4_misc.c (revision 49266) +++ head/sys/svr4/svr4_misc.c (revision 49267) @@ -1,1626 +1,1628 @@ /* * 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. + * + * $Id$ */ /* * SVR4 compatibility module. * * SVR4 system calls that are implemented differently in BSD are * handled here. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(NetBSD) # if defined(UVM) # include # endif #endif #define BSD_DIRENT(cp) ((struct dirent *)(cp)) 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); + outp = (caddr_t)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)) + if (outp == (caddr_t)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)) != 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))); + (svr4_dev_t)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))); + (svr4_dev_t)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; } Index: head/sys/svr4/svr4_mman.h =================================================================== --- head/sys/svr4/svr4_mman.h (revision 49266) +++ head/sys/svr4/svr4_mman.h (revision 49267) @@ -1,45 +1,47 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_MMAN_H_ #define _SVR4_MMAN_H_ /* * Commands and flags passed to memcntl(). * Most of them are the same as , 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 */ Index: head/sys/svr4/svr4_proto.h =================================================================== --- head/sys/svr4/svr4_proto.h (revision 49266) +++ head/sys/svr4/svr4_proto.h (revision 49267) @@ -1,472 +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 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 *)]; + void * buf; char buf_[PAD_(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 *)]; + struct sockaddr * to; char to_[PAD_(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_ */ Index: head/sys/svr4/svr4_resource.c =================================================================== --- head/sys/svr4/svr4_resource.c (revision 49266) +++ head/sys/svr4/svr4_resource.c (revision 49267) @@ -1,311 +1,313 @@ /* 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. + * + * $Id$ */ /* * 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 #include #include #include #include #include #include #include #include #include #include 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); } Index: head/sys/svr4/svr4_resource.h =================================================================== --- head/sys/svr4/svr4_resource.h (revision 49266) +++ head/sys/svr4/svr4_resource.h (revision 49267) @@ -1,107 +1,109 @@ /* 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. + * + * $Id$ */ /* * 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_ */ Index: head/sys/svr4/svr4_siginfo.h =================================================================== --- head/sys/svr4/svr4_siginfo.h (revision 49266) +++ head/sys/svr4/svr4_siginfo.h (revision 49267) @@ -1,109 +1,111 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_signal.c =================================================================== --- head/sys/svr4/svr4_signal.c (revision 49266) +++ head/sys/svr4/svr4_signal.c (revision 49267) @@ -1,623 +1,625 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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->ssa_handler; svr4_to_bsd_sigset(&ssa->ssa_mask, &bsa->sa_mask); bsa->sa_flags = 0; if ((ssa->ssa_flags & SVR4_SA_ONSTACK) != 0) bsa->sa_flags |= SA_ONSTACK; if ((ssa->ssa_flags & SVR4_SA_RESETHAND) != 0) bsa->sa_flags |= SA_RESETHAND; if ((ssa->ssa_flags & SVR4_SA_RESTART) != 0) bsa->sa_flags |= SA_RESTART; if ((ssa->ssa_flags & SVR4_SA_SIGINFO) != 0) DPRINTF(("svr4_to_bsd_sigaction: SA_SIGINFO ignored\n")); if ((ssa->ssa_flags & SVR4_SA_NOCLDSTOP) != 0) bsa->sa_flags |= SA_NOCLDSTOP; if ((ssa->ssa_flags & SVR4_SA_NODEFER) != 0) bsa->sa_flags |= SA_NODEFER; if ((ssa->ssa_flags & SVR4_SA_NOCLDWAIT) != 0) bsa->sa_flags |= SA_NOCLDWAIT; if ((ssa->ssa_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->ssa_handler = (svr4_sig_t) bsa->sa_handler; bsd_to_svr4_sigset(&bsa->sa_mask, &ssa->ssa_mask); ssa->ssa_flags = 0; if ((bsa->sa_flags & SA_ONSTACK) != 0) ssa->ssa_flags |= SVR4_SA_ONSTACK; if ((bsa->sa_flags & SA_RESETHAND) != 0) ssa->ssa_flags |= SVR4_SA_RESETHAND; if ((bsa->sa_flags & SA_RESTART) != 0) ssa->ssa_flags |= SVR4_SA_RESTART; if ((bsa->sa_flags & SA_NODEFER) != 0) ssa->ssa_flags |= SVR4_SA_NODEFER; if ((bsa->sa_flags & SA_NOCLDSTOP) != 0) ssa->ssa_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); } Index: head/sys/svr4/svr4_signal.h =================================================================== --- head/sys/svr4/svr4_signal.h (revision 49266) +++ head/sys/svr4/svr4_signal.h (revision 49267) @@ -1,130 +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. + * + * $Id$ */ #ifndef _SVR4_SIGNAL_H_ #define _SVR4_SIGNAL_H_ #include #include #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 ssa_flags; svr4_sig_t ssa_handler; svr4_sigset_t ssa_mask; int ssa_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_ */ Index: head/sys/svr4/svr4_socket.c =================================================================== --- head/sys/svr4/svr4_socket.c (revision 49266) +++ head/sys/svr4/svr4_socket.c (revision 49267) @@ -1,204 +1,206 @@ /* * 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. + * + * $Id$ */ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 */ + udev_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; + udev_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); } Index: head/sys/svr4/svr4_socket.h =================================================================== --- head/sys/svr4/svr4_socket.h (revision 49266) +++ head/sys/svr4/svr4_socket.h (revision 49267) @@ -1,53 +1,55 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_SOCKET_H_ #define _SVR4_SOCKET_H_ #include 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)); + udev_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_ */ Index: head/sys/svr4/svr4_sockio.c =================================================================== --- head/sys/svr4/svr4_sockio.c (revision 49266) +++ head/sys/svr4/svr4_sockio.c (revision 49267) @@ -1,174 +1,176 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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, 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 */ } } Index: head/sys/svr4/svr4_sockio.h =================================================================== --- head/sys/svr4/svr4_sockio.h (revision 49266) +++ head/sys/svr4/svr4_sockio.h (revision 49267) @@ -1,91 +1,93 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_sockmod.h =================================================================== --- head/sys/svr4/svr4_sockmod.h (revision 49266) +++ head/sys/svr4/svr4_sockmod.h (revision 49267) @@ -1,81 +1,83 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_statvfs.h =================================================================== --- head/sys/svr4/svr4_statvfs.h (revision 49266) +++ head/sys/svr4/svr4_statvfs.h (revision 49267) @@ -1,70 +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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_stream.c =================================================================== --- head/sys/svr4/svr4_stream.c (revision 49266) +++ head/sys/svr4/svr4_stream.c (revision 49267) @@ -1,2264 +1,2266 @@ /* * 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. + * + * $Id$ */ /* * Pretend that we have streams... * Yes, this is gross. * * ToDo: The state machine for getmsg needs re-thinking */ #define COMPAT_43 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* 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)); /* 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)) + if ((error = copyout((caddr_t)mtod(m, caddr_t), + ctlbuf, tocopy)) != 0) 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); + udev_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("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 */ Index: head/sys/svr4/svr4_sysconfig.h =================================================================== --- head/sys/svr4/svr4_sysconfig.h (revision 49266) +++ head/sys/svr4/svr4_sysconfig.h (revision 49267) @@ -1,60 +1,62 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_systeminfo.h =================================================================== --- head/sys/svr4/svr4_systeminfo.h (revision 49266) +++ head/sys/svr4/svr4_systeminfo.h (revision 49267) @@ -1,48 +1,50 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_sysvec.c =================================================================== --- head/sys/svr4/svr4_sysvec.c (revision 49266) +++ head/sys/svr4/svr4_sysvec.c (revision 49267) @@ -1,383 +1,411 @@ +/* + * 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. 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. + * + * $Id$ + */ + /* 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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); +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" + NULL, + "SVR4", + elf_coredump }; 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: /* Only allow the emulator to be removed if it isn't in use. */ if (elf_brand_inuse(&svr4_brand) != 0) { error = EBUSY; } else if (elf_remove_brand_entry(&svr4_brand) < 0) { error = EINVAL; } if (error) printf("Could not deinstall ELF interpreter entry (error %d)\n", error); 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); Index: head/sys/svr4/svr4_termios.c =================================================================== --- head/sys/svr4/svr4_termios.c (revision 49266) +++ head/sys/svr4/svr4_termios.c (revision 49267) @@ -1,619 +1,621 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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); } } Index: head/sys/svr4/svr4_termios.h =================================================================== --- head/sys/svr4/svr4_termios.h (revision 49266) +++ head/sys/svr4/svr4_termios.h (revision 49267) @@ -1,222 +1,224 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_time.h =================================================================== --- head/sys/svr4/svr4_time.h (revision 49266) +++ head/sys/svr4/svr4_time.h (revision 49267) @@ -1,39 +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. + * + * $Id$ */ #ifndef _SVR4_TIME_H_ #define _SVR4_TIME_H_ #include struct svr4_utimbuf { time_t actime; time_t modtime; }; #endif /* !_SVR4_TIME_H_ */ Index: head/sys/svr4/svr4_timod.h =================================================================== --- head/sys/svr4/svr4_timod.h (revision 49266) +++ head/sys/svr4/svr4_timod.h (revision 49267) @@ -1,85 +1,87 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ttold.c =================================================================== --- head/sys/svr4/svr4_ttold.c (revision 49266) +++ head/sys/svr4/svr4_ttold.c (revision 49267) @@ -1,381 +1,383 @@ /* * 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. + * + * $Id$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 */ } } Index: head/sys/svr4/svr4_ttold.h =================================================================== --- head/sys/svr4/svr4_ttold.h (revision 49266) +++ head/sys/svr4/svr4_ttold.h (revision 49267) @@ -1,120 +1,122 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ucontext.h =================================================================== --- head/sys/svr4/svr4_ucontext.h (revision 49266) +++ head/sys/svr4/svr4_ucontext.h (revision 49267) @@ -1,72 +1,74 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ulimit.h =================================================================== --- head/sys/svr4/svr4_ulimit.h (revision 49266) +++ head/sys/svr4/svr4_ulimit.h (revision 49267) @@ -1,39 +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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/svr4_ustat.h =================================================================== --- head/sys/svr4/svr4_ustat.h (revision 49266) +++ head/sys/svr4/svr4_ustat.h (revision 49267) @@ -1,41 +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. + * + * $Id$ */ #ifndef _SVR4_USTAT_H_ #define _SVR4_USTAT_H_ #include 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_ */ Index: head/sys/svr4/svr4_util.h =================================================================== --- head/sys/svr4/svr4_util.h (revision 49266) +++ head/sys/svr4/svr4_util.h (revision 49267) @@ -1,78 +1,80 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_UTIL_H_ #define _SVR4_UTIL_H_ /*#include */ #include #include #include #include #include #include #include #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_ */ Index: head/sys/svr4/svr4_utsname.h =================================================================== --- head/sys/svr4/svr4_utsname.h (revision 49266) +++ head/sys/svr4/svr4_utsname.h (revision 49267) @@ -1,42 +1,44 @@ /* * 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. + * + * $Id$ */ #ifndef _SVR4_UTSNAME_H_ #define _SVR4_UTSNAME_H_ #include struct svr4_utsname { char sysname[257]; char nodename[257]; char release[257]; char version[257]; char machine[257]; }; #endif /* !_SVR4_UTSNAME_H_ */ Index: head/sys/svr4/svr4_wait.h =================================================================== --- head/sys/svr4/svr4_wait.h (revision 49266) +++ head/sys/svr4/svr4_wait.h (revision 49267) @@ -1,54 +1,56 @@ /* * 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. + * + * $Id$ */ #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_ */ Index: head/sys/svr4/syscalls.master =================================================================== --- head/sys/svr4/syscalls.master (revision 49266) +++ head/sys/svr4/syscalls.master (revision 49267) @@ -1,373 +1,375 @@ ; @(#)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 - +; +; $Id$ +; #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include ; #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, \ +242 STD SVR4 { ssize_t svr4_sys_sendto(int s, void *buf, \ size_t len, int flags, \ - const struct sockaddr *to, int tolen); } + 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); }