diff options
Diffstat (limited to 'sys')
29 files changed, 4906 insertions, 1649 deletions
diff --git a/sys/compat/osf1/Makefile b/sys/compat/osf1/Makefile index df0262d81ef..2791a967572 100644 --- a/sys/compat/osf1/Makefile +++ b/sys/compat/osf1/Makefile @@ -1,4 +1,3 @@ -# $OpenBSD: Makefile,v 1.2 1996/08/02 20:35:23 niklas Exp $ # $NetBSD: Makefile,v 1.1 1995/02/13 21:39:00 cgd Exp $ DEP= syscalls.conf syscalls.master ../../kern/makesyscalls.sh @@ -10,3 +9,6 @@ ${OBJS}: ${DEP} -mv -f osf1_syscall.h osf1_syscall.h.bak -mv -f osf1_syscallargs.h osf1_syscallargs.h.bak sh ../../kern/makesyscalls.sh syscalls.conf syscalls.master + +clean: + rm -f ${OBJS} diff --git a/sys/compat/osf1/README.dynamic b/sys/compat/osf1/README.dynamic index 0545a15b72c..5f60ad0efee 100644 --- a/sys/compat/osf1/README.dynamic +++ b/sys/compat/osf1/README.dynamic @@ -1,78 +1,54 @@ -$OpenBSD: README.dynamic,v 1.3 1998/02/15 21:19:14 niklas Exp $ -$NetBSD: README.dynamic,v 1.1 1995/02/13 21:39:01 cgd Exp $ +$NetBSD: README.dynamic,v 1.2 1999/04/27 06:39:49 cgd Exp $ -Currently, the OpenBSD OSF/1 emulation code only supports statically -linked OSF/1 binaries. This document is meant to be a quick -description of what would need to happen to support dynamically linked -OSF/1 binaries, and to provide an indication of the amount of work -that would be required to add such support. +Dynamically linked programs are supported by NetBSD's Digital UNIX +(formerly DEC OSF/1) emulation. The OSF/1 dynamic linker scheme is +described in fair detail in: -To support dynamically linked OSF/1 binaries, three steps would have -to be taken: - (1) The osf1_exec_with_loader() syscall emulation code would - have to be written. - (2) Execve() would have to be changed to support invocation of - a loader for dynamically linked binaries. - (3) The pmap code would have to be extended to allow process - virtual spaces that are much larger than are currently - allowed. + %A Larry W. Allen + %A Harminder G. Singh + %A Kevin G. Wallace + %A Melanie B. Weaver + %T Program Loading in OSF/1 + %P 145-160 + %I USENIX + %B USENIX Conference Proceedings + %D January 21-25, 1991 + %C Dallas, TX + %W Open Software Foundation -1. Implementing osf1_exec_with_loader(). +Additionally, the object file formats in use are described in the +Digital UNIX _Assembly Language Programmer's Guide_ which can be +found (among other places) on a version-specific page off of: -The description of osf1_exec_with_loader is as follows: + http://www.unix.digital.com/faqs/publications/pub_page/doc_list.html - int exec_with_loader(int flags, const char *loader, - const char *file, char * const argv[], - char * const envp[]); +Finally, the actual representation of Auxiliary Vectors came from information +in the Digital UNIX auxv.h header file. -It invokes the program named by file, with the given argv and envp, -by starting the specified loader (or /sbin/loader) and somehow passing -the flags, file name, argv, and envp in such a way that the -appropriate things will happen with them. This interface is -completely undocumented (in the documentation that we have available), -and so the only way to figure it out is to disassemble the OSF/1 -kernel and/or /sbin/loader. +There are at least two potential issues with the implementation as it +currently exists: -2. Changing execve() to support OSF/1 dynamically linked executables. +1. exec_with_loader() is not emulated. -Normally, dynamically linked executables are invoked using execve(), -in the normal fashion. The kernel transforms that request into one -that uses the loader, and causes the loader to be invoked with the -appropriate information to run the target executable. + Most uses of dynamically linked programs come through execve() + and use the default loader (/sbin/loader). In Digital UNIX + (and OSF/1) you can also force a specific loader to always be + invoked to load an executable by using the exec_with_loader() + system call. Few, if any, programs use this feature. -The mechanism by which this is done is unknown; it may be possible to -completely replace the OSF/1 loader with one designed for NetBSD, but -that is rather prohibitive. (Additionally, it wouldn't solve the -problem of needing to implement the osf1_exec_with_loader() -functionality.) +2. It is not immediately obvious that the right values are used for + text and data locations when invoking a dynamically linked executable. -In any case, this would not be insignificant; it and/or the -implementation of osf1_exec_with_loader() would probably require a -complete rewrite or duplication of the current execve() code. + The text and data sections, and the break, are set up as if + /sbin/loader itself had been executed. It's not clear that this + is correct, but /sbin/loader seems to expect that at least the + break will be set up this way. -3. Extending the pmap code to handle larger virtual spaces. + This has certain implications for the way mmap() behaves. See + the comment in the osf1_mmap() function in osf1_misc.c. -OSF/1's /sbin/loader wants to be loaded at 0x3ff80000000. Currently, -because of a simplifying assumption (specifically, to only use the -first level-one pte for user-space mappings, effectively turning the -pmap into one that looks much like one for a mc68030), only 8Gb -(0x200000000 bytes) of user virtual space are supported. +3. The stack location is used is the normal NetBSD/alpha stack location. -It is unclear that the extra virtual space is necessary for any -applications that NetBSD/Alpha would be used for, and support for it -would add a significant amount of complexity to the pmap module. -Adding that support would probably require a from-scratch rewrite of -the pmap module. - - -Because of the difficulties in emulating the system call interface -used to run dynamic executables, and the difficulties in allowing -support for the address space the OSF/1 loader needs, I do not think -that it is feasible to support dynamically linked OSF/1 executables -with the OSF/1 loading mechanism. It may be possible to do so with a -new loading mechanism which could be written for NetBSD, but it is -unclear that the necessary interfaces to do even that could be -discovered, and the effort required to implement a new loading -mechanism would be prohibitive. - --- cgd + No attempt is made to put the stack in the place where + Digital UNIX would normally put it. This may confuse some + programs. diff --git a/sys/compat/osf1/README.mach-traps b/sys/compat/osf1/README.mach-traps index c1326769f92..545e626c298 100644 --- a/sys/compat/osf1/README.mach-traps +++ b/sys/compat/osf1/README.mach-traps @@ -1,4 +1,3 @@ -$OpenBSD: README.mach-traps,v 1.2 1996/08/02 20:35:24 niklas Exp $ $NetBSD: README.mach-traps,v 1.1 1995/02/13 21:39:02 cgd Exp $ Some Alpha AXP OSF/1 binaries directly use the facilities provided by @@ -35,15 +34,25 @@ msg_receive_trap -21 5 msg_rpc_trap -22 6 lw_wire -30 3 lw_unwire -31 1 -inode_swap_preference -40 3 +nxm_task_init -33 2 +nxm_sched_thread -34 1 +nxm_idle -35 1 +nxm_wakeup_idle -36 1 +nxm_set_pthid -37 2 +nxm_thread_kill -38 2 +nxm_thread_block -39 1 +nxm_thread_wakeup -40 1 +inode_swap_preference -40 3 old call? init_process -41 0 map_fd -43 5 +nxm_resched -44 2 htg_unix_syscall -52 3 host_self -55 1 host_priv_self -56 1 swtch_pri -59 1 swtch -60 0 thread_switch -61 3 +semop_fast -62 4 mach_sctimes_0 -70 0 only if MACH_SCTIMES defined mach_sctimes_1 -71 1 only if MACH_SCTIMES defined mach_sctimes_2 -72 2 only if MACH_SCTIMES defined diff --git a/sys/compat/osf1/README.syscalls b/sys/compat/osf1/README.syscalls index 0e5cb85dc3b..6b0af772c31 100644 --- a/sys/compat/osf1/README.syscalls +++ b/sys/compat/osf1/README.syscalls @@ -1,5 +1,7 @@ -$OpenBSD: README.syscalls,v 1.2 1996/08/02 20:35:25 niklas Exp $ -$NetBSD: README.syscalls,v 1.1 1995/02/13 21:39:03 cgd Exp $ +$NetBSD: README.syscalls,v 1.2 1999/04/27 16:09:28 cgd Exp $ + +XXX this file should be gutted. functions' comments should go with +XXX the functions. Further, this file is ... very out of date. Once the new syscall argument-handling method was implemented, most OSF/1 syscalls boiled down to their NetBSD equivalents. The @@ -16,7 +18,7 @@ but which seem strange enough to merit a bit more explanation. OSF/1 compatibility is helped by the fact that the sigcontext structure was created for NetBSD/Alpha to be the same as the OSF/1 sigcontext structure. Because of this, only one sendsig() function is -needed, and the the NetBSD sigreturn() function can be used for OSF/1 +needed, and then the NetBSD sigreturn() function can be used for OSF/1 sigreturn(), as well. The system calls are split out among the three files: diff --git a/sys/compat/osf1/files.osf1 b/sys/compat/osf1/files.osf1 index 4c1292ad6a2..b853b3c9d7f 100644 --- a/sys/compat/osf1/files.osf1 +++ b/sys/compat/osf1/files.osf1 @@ -1,5 +1,5 @@ -# $OpenBSD: files.osf1,v 1.4 1999/11/10 15:55:22 mickey Exp $ -# $NetBSD: files.osf1,v 1.3 1995/11/15 05:42:17 cgd Exp $ +# $OpenBSD: files.osf1,v 1.5 2000/08/04 15:47:54 ericj Exp $ +# $NetBSD: files.osf1,v 1.15 1999/05/01 05:49:01 cgd Exp $ # # Config file description for machine-independent OSF/1 compat code. # Included by ports that need it. @@ -9,9 +9,27 @@ # XXX COMPAT_OSF1 requires ECOFF +# syscall table-related files +file compat/osf1/osf1_syscalls.c compat_osf1 & syscall_debug +file compat/osf1/osf1_sysent.c compat_osf1 + +# OSF/1 <-> OpenBSD structure, flag, and value conversion files +file compat/osf1/osf1_cvt.c compat_osf1 +file compat/osf1/osf1_cvt_errno.c compat_osf1 +file compat/osf1/osf1_cvt_signal.c compat_osf1 + +# functionality emulation files +file compat/osf1/osf1_descrip.c compat_osf1 +file compat/osf1/osf1_exec.c compat_osf1 +file compat/osf1/osf1_file.c compat_osf1 +file compat/osf1/osf1_generic.c compat_osf1 file compat/osf1/osf1_ioctl.c compat_osf1 file compat/osf1/osf1_misc.c compat_osf1 +file compat/osf1/osf1_mmap.c compat_osf1 file compat/osf1/osf1_mount.c compat_osf1 +file compat/osf1/osf1_prot.c compat_osf1 +file compat/osf1/osf1_resource.c compat_osf1 file compat/osf1/osf1_signal.c compat_osf1 -file compat/osf1/osf1_syscalls.c compat_osf1 & syscall_debug -file compat/osf1/osf1_sysent.c compat_osf1 +file compat/osf1/osf1_socket.c compat_osf1 +file compat/osf1/osf1_sysv_ipc.c compat_osf1 +file compat/osf1/osf1_time.c compat_osf1 diff --git a/sys/compat/osf1/osf1.h b/sys/compat/osf1/osf1.h new file mode 100644 index 00000000000..f485096d36d --- /dev/null +++ b/sys/compat/osf1/osf1.h @@ -0,0 +1,599 @@ +/* $OpenBSD */ +/* $NetBSD: osf1.h,v 1.20 1999/05/10 21:41:07 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _COMPAT_OSF1_OSF1_H_ +#define _COMPAT_OSF1_OSF1_H_ + +/* + * Collected OSF/1 definitions and structures, sorted by OSF/1 header. + * Error numbers (errno.h) aren't here, since they're likely to change + * (additions) more often. + * + * This file is up to date as of Digital UNIX V4.0. + */ + +#include <sys/types.h> +#include <compat/osf1/osf1_errno.h> +#include <compat/osf1/osf1_signal.h> + +/* + * type and structure definitions used by other structures + */ + +typedef int16_t osf1_short; +typedef int32_t osf1_int; +typedef int64_t osf1_long; +typedef u_int32_t osf1_u_int; + +typedef int32_t osf1_dev_t; +typedef u_int32_t osf1_ino_t; +typedef u_int32_t osf1_mode_t; +typedef u_int16_t osf1_nlink_t; +typedef u_int32_t osf1_uid_t; +typedef u_int32_t osf1_gid_t; +typedef u_int64_t osf1_off_t; +typedef int32_t osf1_time_t; +typedef u_int32_t osf1_uint_t; +typedef u_int64_t osf1_sigset_t; +typedef u_int64_t osf1_size_t; +typedef u_int64_t osf1_fsid_t; +typedef u_int64_t osf1_rlim_t; +typedef void *osf1_data_ptr; /* XXX hard to fix size */ +typedef void *osf1_fcn_ptr; /* XXX hard to fix size, bogus */ +typedef osf1_int osf1_key_t; +typedef osf1_int osf1_pid_t; +typedef void (*osf1_handler_t) __P((int)); + +struct osf1_timeval { /* time.h */ + osf1_time_t tv_sec; + osf1_int tv_usec; +}; + + +/* access.h */ + +#define OSF1_F_OK 0 /* pseudo-flag */ +#define OSF1_X_OK 0x01 +#define OSF1_W_OK 0x02 +#define OSF1_R_OK 0x04 + + +/* auxv.h */ + +union osf1_auxv_data { + osf1_long a_val; + osf1_data_ptr a_ptr; + osf1_fcn_ptr a_fcn; +}; + +struct osf1_auxv { + osf1_int a_type; + union osf1_auxv_data a_un; +}; + +/* auxv entry types */ +#define OSF1_AT_NULL 0 +#define OSF1_AT_IGNORE 1 +#define OSF1_AT_EXECFD 2 +#define OSF1_AT_PHDR 3 +#define OSF1_AT_PHENT 4 +#define OSF1_AT_PHNUM 5 +#define OSF1_AT_PAGESZ 6 +#define OSF1_AT_BASE 7 +#define OSF1_AT_FLAGS 8 +#define OSF1_AT_ENTRY 9 +#define OSF1_AT_EXEC_FILENAME 1001 +#define OSF1_AT_EXEC_LOADER_FILENAME 1002 +#define OSF1_AT_EXEC_LOADER_FLAGS 1003 + + +/* exec.h/ldr_exec.h */ + +#define OSF1_LDR_EXEC_DEFAULT_LOADER "/sbin/loader" + +/* exec_with_loader()/OSF1_AT_EXEC_LOADER_FLAGS flags regions */ +#define OSF1_LDR_EXEC_SYSTEM_MASK 0xffff0000 +#define OSF1_LDR_EXEC_USER_MASK 0xffff0000 + +/* OSF1_AT_EXEC_LOADER_FLAGS flags */ +#define OSF1_LDR_EXEC_NOPRIVS_F 0x10000000 +#define OSF1_LDR_EXEC_PTRACE_F 0x20000000 +#define OSF1_LDR_EXEC_SETGID_F 0x40000000 +#define OSF1_LDR_EXEC_SETUID_F 0x80000000 + + +/* fcntl.h */ + +/* fcntl ops */ +#define OSF1_F_DUPFD 0 +#define OSF1_F_GETFD 1 /* uses flags, see below */ +#define OSF1_F_SETFD 2 /* uses flags, see below */ +#define OSF1_F_GETFL 3 /* uses flags, see below */ +#define OSF1_F_SETFL 4 /* uses flags, see below */ +#define OSF1_F_GETOWN 5 +#define OSF1_F_SETOWN 6 +#define OSF1_F_GETLK 7 /* uses osf1_flock, see below */ +#define OSF1_F_SETLK 8 /* uses osf1_flock, see below */ +#define OSF1_F_SETLKW 9 /* uses osf1_flock, see below */ +#define OSF1_F_RGETLK 10 /* [lock mgr op] */ +#define OSF1_F_RSETLK 11 /* [lock mgr op] */ +#define OSF1_F_CNVT 12 /* [lock mgr op] */ +#define OSF1_F_RSETLKW 13 /* [lock mgr op] */ +#define OSF1_F_PURGEFS 14 /* [lock mgr op] */ +#define OSF1_F_PURGENFS 15 /* [DECsafe op] */ + +/* fcntl GETFD/SETFD flags */ +#define OSF1_FD_CLOEXEC 1 + +/* fcntl GETFL/SETFL flags, in addition to the O_* flags below */ +#define OSF1_FASYNC 0x00000040 + +/* struct osf1_flock, for GETLK/SETLK/SETLKW */ +struct osf1_flock { + osf1_short l_type; + osf1_short l_whence; + osf1_off_t l_start; + osf1_off_t l_len; + osf1_pid_t l_pid; +}; + +/* GETLK/SETLK/SETLKW locking types */ +#define OSF1_F_RDLCK 1 +#define OSF1_F_WRLCK 2 +#define OSF1_F_UNLCK 8 + +/* open flags */ +#define OSF1_O_RDONLY 0x00000000 +#define OSF1_O_WRONLY 0x00000001 +#define OSF1_O_RDWR 0x00000002 +#define OSF1_O_ACCMODE 0x00000003 /* mask of RD and WR bits */ +#define OSF1_O_NONBLOCK 0x00000004 +#define OSF1_O_APPEND 0x00000008 +/* no 0x00000010 */ +#define OSF1_O_DEFER 0x00000020 +/* no 0x00000040 */ +/* no 0x00000080 */ +/* no 0x00000100 */ +#define OSF1_O_CREAT 0x00000200 +#define OSF1_O_TRUNC 0x00000400 +#define OSF1_O_EXCL 0x00000800 +#define OSF1_O_NOCTTY 0x00001000 +#define OSF1_O_SYNC 0x00004000 +#define OSF1_O_NDELAY 0x00008000 +#define OSF1_O_DRD 0x00008000 /* == O_NDELAY, DON'T USE */ +/* no 0x00010000 */ +/* no 0x00020000 */ +/* no 0x00040000 */ +#define OSF1_O_DSYNC 0x00080000 +#define OSF1_O_RSYNC 0x00100000 +/* no 0x00200000+ */ + + +/* ioctl.h */ + +#define OSF1_IOCPARM_MASK 0x1fff +#define OSF1_IOCPARM_LEN(x) (((x) >> 16) & OSF1_IOCPARM_MASK) +#define OSF1_IOCGROUP(x) (((x) >> 8) & 0xff) +#define OSF1_IOCCMD(x) ((x) & 0xff) + +#define OSF1_IOCPARM_MAX 8192 +#define OSF1_IOC_VOID 0x20000000 +#define OSF1_IOC_OUT 0x40000000 +#define OSF1_IOC_IN 0x80000000 +#define OSF1_IOC_INOUT (OSF1_IOC_IN|OSF1_IOC_OUT) +#define OSF1_IOC_DIRMASK 0xe0000000 + + +/* mman.h */ + +/* protection mask */ +#define OSF1_PROT_NONE 0 /* pseudo-flag */ +#define OSF1_PROT_READ 0x0001 +#define OSF1_PROT_WRITE 0x0002 +#define OSF1_PROT_EXEC 0x0004 + +/* mmap flags */ +#define OSF1_MAP_SHARED 0x0001 +#define OSF1_MAP_PRIVATE 0x0002 + +#define OSF1_MAP_FILE 0 /* pseudo-flag */ +#define OSF1_MAP_ANON 0x0010 +#define OSF1_MAP_TYPE 0x00f0 + +#define OSF1_MAP_FIXED 0x0100 +#define OSF1_MAP_VARIABLE 0 /* pseudo-flag */ + +#define OSF1_MAP_HASSEMAPHORE 0x0200 +#define OSF1_MAP_INHERIT 0x0400 +#define OSF1_MAP_UNALIGNED 0x0800 + +/* madvise operations */ +#define OSF1_MADV_NORMAL 0 +#define OSF1_MADV_RANDOM 1 +#define OSF1_MADV_SEQUENTIAL 2 +#define OSF1_MADV_WILLNEED 3 +#define OSF1_MADV_DONTNEED_COMPAT 4 +#define OSF1_MADV_SPACEAVAIL 5 +#define OSF1_MADV_DONTNEED 6 + + +/* mount.h */ + +/* file system type numbers */ +#define OSF1_MOUNT_NONE 0 +#define OSF1_MOUNT_UFS 1 +#define OSF1_MOUNT_NFS 2 +#define OSF1_MOUNT_MFS 3 +#define OSF1_MOUNT_PC 4 +#define OSF1_MOUNT_S5FS 5 +#define OSF1_MOUNT_CDFS 6 +#define OSF1_MOUNT_DFS 7 +#define OSF1_MOUNT_EFS 8 +#define OSF1_MOUNT_PROCFS 9 +#define OSF1_MOUNT_MSFS 10 +#define OSF1_MOUNT_FFM 11 +#define OSF1_MOUNT_FDFS 12 +#define OSF1_MOUNT_ADDON 13 +#define OSF1_MOUNT_NFS3 14 + +#define OSF1_MNAMELEN 90 + +/* MFS mount argument structure */ +struct osf1_mfs_args { + osf1_data_ptr name; + osf1_data_ptr base; + osf1_u_int size; +}; + +/* NFS mount argument structure */ +struct osf1_nfs_args { + osf1_data_ptr addr; + osf1_data_ptr fh; + osf1_int flags; + osf1_int wsize; + osf1_int rsize; + osf1_int timeo; + osf1_int retrans; + osf1_data_ptr hostname; + osf1_int acregmin; + osf1_int acregmax; + osf1_int acdirmin; + osf1_int acdirmax; + osf1_data_ptr netname; + osf1_data_ptr pathconf; +}; + +/* NFS mount argument structure flags */ +#define OSF1_NFSMNT_SOFT 0x00000001 +#define OSF1_NFSMNT_WSIZE 0x00000002 +#define OSF1_NFSMNT_RSIZE 0x00000004 +#define OSF1_NFSMNT_TIMEO 0x00000008 +#define OSF1_NFSMNT_RETRANS 0x00000010 +#define OSF1_NFSMNT_HOSTNAME 0x00000020 +#define OSF1_NFSMNT_INT 0x00000040 +#define OSF1_NFSMNT_NOCONN 0x00000080 +#define OSF1_NFSMNT_NOAC 0x00000100 +#define OSF1_NFSMNT_ACREGMIN 0x00000200 +#define OSF1_NFSMNT_ACREGMAX 0x00000400 +#define OSF1_NFSMNT_ACDIRMIN 0x00000800 +#define OSF1_NFSMNT_ACDIRMAX 0x00001000 +#define OSF1_NFSMNT_NOCTO 0x00002000 +#define OSF1_NFSMNT_POSIX 0x00004000 +#define OSF1_NFSMNT_AUTO 0x00008000 +#define OSF1_NFSMNT_SEC 0x00010000 +#define OSF1_NFSMNT_TCP 0x00020000 +#define OSF1_NFSMNT_PROPLIST 0x00040000 +/* no 0x00080000+ */ + +/* union of all mount argument structures */ +union osf1_mount_info { + struct osf1_mfs_args mfs_args; + struct osf1_nfs_args nfs_args; + char pad[80]; +}; + +/* statfs structure */ +struct osf1_statfs { + osf1_short f_type; + osf1_short f_flags; + osf1_int f_fsize; + osf1_int f_bsize; + osf1_int f_blocks; + osf1_int f_bfree; + osf1_int f_bavail; + osf1_int f_files; + osf1_int f_ffree; + osf1_fsid_t f_fsid; + osf1_int f_spare[9]; + char f_mntonname[OSF1_MNAMELEN]; + char f_mntfromname[OSF1_MNAMELEN]; + union osf1_mount_info mount_info; +}; + + +/* reboot.h */ + +/* reboot flags */ +#define OSF1_RB_AUTOBOOT 0 /* pseudo-flag */ + +#define OSF1_RB_ASKNAME 0x0001 +#define OSF1_RB_SINGLE 0x0002 +#define OSF1_RB_NOSYNC 0x0004 +#define OSF1_RB_KDB 0x0004 /* == RB_NOSYNC; boot only? */ +#define OSF1_RB_HALT 0x0008 +#define OSF1_RB_INITNAME 0x0010 +#define OSF1_RB_DFLTROOT 0x0020 +#define OSF1_RB_ALTBOOT 0x0040 +#define OSF1_RB_UNIPROC 0x0080 +#define OSF1_RB_PARAM 0x0100 +#define OSF1_RB_DUMP 0x0200 + + +/* resource.h */ + +#define OSF1_RUSAGE_THREAD 1 +#define OSF1_RUSAGE_SELF 0 +#define OSF1_RUSAGE_CHILDREN -1 + +struct osf1_rusage { + struct osf1_timeval ru_utime; + struct osf1_timeval ru_stime; + osf1_long ru_maxrss; + osf1_long ru_ixrss; + osf1_long ru_idrss; + osf1_long ru_isrss; + osf1_long ru_minflt; + osf1_long ru_majflt; + osf1_long ru_nswap; + osf1_long ru_inblock; + osf1_long ru_oublock; + osf1_long ru_msgsnd; + osf1_long ru_msgrcv; + osf1_long ru_nsignals; + osf1_long ru_nvcsw; + osf1_long ru_nivcsw; +}; + +#define OSF1_RLIMIT_CPU 0 +#define OSF1_RLIMIT_FSIZE 1 +#define OSF1_RLIMIT_DATA 2 +#define OSF1_RLIMIT_STACK 3 +#define OSF1_RLIMIT_CORE 4 +#define OSF1_RLIMIT_RSS 5 +#define OSF1_RLIMIT_NOFILE 6 +#define OSF1_RLIMIT_AS 7 + +#define OSF1_RLIM_INFINITY 0x7fffffffffffffffL + +struct osf1_rlimit { + rlim_t rlim_cur; + rlim_t rlim_max; +}; + + +/* seek.h */ + +#define OSF1_SEEK_SET 0 +#define OSF1_SEEK_CUR 1 +#define OSF1_SEEK_END 2 + + +/* signal.h (some in machine/signal.h) */ + +#define sigemptyset(s) bzero((s), sizeof(*(s))) +#define sigismember(s, n) (*(s) & sigmask(n)) +#define sigaddset(s, n) (*(s) |= sigmask(n)) + +struct osf1_sigaction { + osf1_handler_t sa__handler; + osf1_sigset_t sa_mask; + int sa_flags; +}; + +/* actually from sysmisc.h */ +struct osf1_sigaltstack { + osf1_data_ptr ss_sp; + osf1_int ss_flags; + osf1_size_t ss_size; +}; + +/* sigaction flags */ +#define OSF1_SA_ONSTACK 0x00000001 +#define OSF1_SA_RESTART 0x00000002 +#define OSF1_SA_NOCLDSTOP 0x00000004 +#define OSF1_SA_NODEFER 0x00000008 +#define OSF1_SA_RESETHAND 0x00000010 +#define OSF1_SA_NOCLDWAIT 0x00000020 +#define OSF1_SA_SIGINFO 0x00000040 + +/* sigaltstack flags */ +#define OSF1_SS_ONSTACK 0x00000001 +#define OSF1_SS_DISABLE 0x00000002 +#define OSF1_SS_NOMASK 0x00000004 +#define OSF1_SS_UCONTEXT 0x00000008 + +/* signal set manipulation macros */ +#define osf1_sigmask(n) ((osf1_sigset_t)1 << ((n) - 1)) +#define osf1_sigemptyset(s) (*(s) = (osf1_sigset_t)0) +#define osf1_sigismember(s, n) (*(s) & osf1_sigmask(n)) +#define osf1_sigaddset(s, n) (*(s) |= osf1_sigmask(n)) + + +/* socket.h */ + +struct osf1_msghdr { + osf1_data_ptr msg_name; + osf1_u_int msg_namelen; + osf1_data_ptr msg_iov; /* struct osf1_iovec_xopen * */ + osf1_u_int msg_iovlen; + osf1_data_ptr msg_control; + osf1_u_int msg_controllen; + osf1_int msg_flags; +}; + +struct osf1_msghdr_xopen { + osf1_data_ptr msg_name; + osf1_size_t msg_namelen; + osf1_data_ptr msg_iov; /* struct osf1_iovec_xopen * */ + osf1_int msg_iovlen; + osf1_data_ptr msg_control; + osf1_size_t msg_controllen; + osf1_int msg_flags; +}; + +/* max message iov len */ +#define OSF1_MSG_MAXIOVLEN 16 + +/* send/recv-family message flags */ +#define OSF1_MSG_OOB 0x0001 +#define OSF1_MSG_PEEK 0x0002 +#define OSF1_MSG_DONTROUTE 0x0004 +#define OSF1_MSG_EOR 0x0008 +#define OSF1_MSG_TRUNC 0x0010 +#define OSF1_MSG_CTRUNC 0x0020 +#define OSF1_MSG_WAITALL 0x0040 + + +/* stat.h */ + +struct osf1_stat { + osf1_dev_t st_dev; + osf1_ino_t st_ino; + osf1_mode_t st_mode; + osf1_nlink_t st_nlink; + osf1_uid_t st_uid; + osf1_gid_t st_gid; + osf1_dev_t st_rdev; + osf1_off_t st_size; + osf1_time_t st_atime_sec; + osf1_int st_spare1; + osf1_time_t st_mtime_sec; + osf1_int st_spare2; + osf1_time_t st_ctime_sec; + osf1_int st_spare3; + osf1_uint_t st_blksize; + osf1_int st_blocks; + osf1_uint_t st_flags; + osf1_uint_t st_gen; +}; + + +/* systeminfo.h */ + +#define OSF1_SI_SYSNAME 1 +#define OSF1_SI_HOSTNAME 2 +#define OSF1_SI_RELEASE 3 +#define OSF1_SI_VERSION 4 +#define OSF1_SI_MACHINE 5 +#define OSF1_SI_ARCHITECTURE 6 +#define OSF1_SI_HW_SERIAL 7 +#define OSF1_SI_HW_PROVIDER 8 +#define OSF1_SI_SRPC_DOMAIN 9 +#define OSF1_SI_SET_HOSTNAME 258 +#define OSF1_SI_SET_SYSNAME 259 +#define OSF1_SI_SET_SRPC_DOMAIN 265 + + +/* time.h */ + +struct osf1_itimerval { + struct osf1_timeval it_interval; + struct osf1_timeval it_value; +}; + +#define OSF1_ITIMER_REAL 0 +#define OSF1_ITIMER_VIRTUAL 1 +#define OSF1_ITIMER_PROF 2 + +struct osf1_timezone { + osf1_int tz_minuteswest; + osf1_int tz_dsttime; +}; + + +/* types.h */ + +#define osf1_major(x) ((((dev_t)(x)) >> 20) & 0x00000fff) +#define osf1_minor(x) ((((dev_t)(x)) >> 0) & 0x000fffff) +#define osf1_makedev(x,y) ((((dev_t)(x)) << 20) | ((dev_t)(y))) + + +/* uio.h */ + +struct osf1_iovec { + osf1_data_ptr iov_base; + osf1_int iov_len; +}; + +struct osf1_iovec_xopen { + osf1_data_ptr iov_base; + osf1_size_t iov_len; +}; + + +/* unistd.h (user-land header) */ + +#define OSF1__PC_CHOWN_RESTRICTED 10 +#define OSF1__PC_LINK_MAX 11 +#define OSF1__PC_MAX_CANON 12 +#define OSF1__PC_MAX_INPUT 13 +#define OSF1__PC_NAME_MAX 14 +#define OSF1__PC_NO_TRUNC 15 +#define OSF1__PC_PATH_MAX 16 +#define OSF1__PC_PIPE_BUF 17 +#define OSF1__PC_VDISABLE 18 + + +/* utsname.h */ + +#define OSF1__SYS_NMLN 32 + +struct osf1_utsname { + char sysname[OSF1__SYS_NMLN]; + char nodename[OSF1__SYS_NMLN]; + char release[OSF1__SYS_NMLN]; + char version[OSF1__SYS_NMLN]; + char machine[OSF1__SYS_NMLN]; +}; + + +/* wait.h */ + +/* wait3() and wait4() options. */ +#define OSF1_WNOHANG 0x01 +#define OSF1_WUNTRACED 0x02 + +/* XXX should have status word bits */ + + +#endif /* _COMPAT_OSF1_OSF1_H_ */ diff --git a/sys/compat/osf1/osf1_cvt.c b/sys/compat/osf1/osf1_cvt.c new file mode 100644 index 00000000000..d8c99097ee5 --- /dev/null +++ b/sys/compat/osf1/osf1_cvt.c @@ -0,0 +1,705 @@ +/* $OpenBSD: osf1_cvt.c,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_cvt.c,v 1.7 1999/06/26 01:23:23 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/filedesc.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/signal.h> +#include <sys/signalvar.h> +#include <sys/reboot.h> +#include <sys/syscallargs.h> +#include <sys/exec.h> +#include <sys/vnode.h> +#include <sys/socketvar.h> +#include <sys/resource.h> +#include <sys/resourcevar.h> +#include <sys/wait.h> +#include <vm/vm.h> /* XXX see mmap emulation */ + +#include <nfs/rpcv2.h> +#include <nfs/nfsproto.h> +#include <nfs/nfs.h> +#include <nfs/nfsmount.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> + +const struct emul_flags_xtab osf1_access_flags_xtab[] = { +#if 0 /* pseudo-flag */ + { OSF1_F_OK, OSF1_F_OK, F_OK }, +#endif + { OSF1_X_OK, OSF1_X_OK, X_OK }, + { OSF1_W_OK, OSF1_W_OK, W_OK }, + { OSF1_R_OK, OSF1_R_OK, R_OK }, + { 0 } +}; + +const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_rxtab[] = { + { FD_CLOEXEC, FD_CLOEXEC, OSF1_FD_CLOEXEC }, + { 0 } +}; + +const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_xtab[] = { + { OSF1_FD_CLOEXEC, OSF1_FD_CLOEXEC, FD_CLOEXEC }, + { 0 } +}; + +/* flags specific to GETFL/SETFL; also uses open rxtab */ +const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_rxtab[] = { + { FASYNC, FASYNC, OSF1_FASYNC }, + { 0 } +}; + +/* flags specific to GETFL/SETFL; also uses open xtab */ +const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_xtab[] = { + { OSF1_FASYNC, OSF1_FASYNC, FASYNC }, + { 0 } +}; + +const struct emul_flags_xtab osf1_mmap_flags_xtab[] = { + { OSF1_MAP_SHARED, OSF1_MAP_SHARED, MAP_SHARED }, + { OSF1_MAP_PRIVATE, OSF1_MAP_PRIVATE, MAP_PRIVATE }, + { OSF1_MAP_TYPE, OSF1_MAP_FILE, MAP_FILE }, + { OSF1_MAP_TYPE, OSF1_MAP_ANON, MAP_ANON }, + { OSF1_MAP_FIXED, OSF1_MAP_FIXED, MAP_FIXED }, +#if 0 /* pseudo-flag, and the default */ + { OSF1_MAP_VARIABLE, OSF1_MAP_VARIABLE, 0 }, +#endif + { OSF1_MAP_HASSEMAPHORE, OSF1_MAP_HASSEMAPHORE, MAP_HASSEMAPHORE }, + { OSF1_MAP_INHERIT, OSF1_MAP_INHERIT, MAP_INHERIT }, +#if 0 /* no equivalent +++ */ + { OSF1_MAP_UNALIGNED, OSF1_MAP_UNALIGNED, ??? }, +#endif + { 0 } +}; + +const struct emul_flags_xtab osf1_mmap_prot_xtab[] = { +#if 0 /* pseudo-flag */ + { OSF1_PROT_NONE, OSF1_PROT_NONE, PROT_NONE }, +#endif + { OSF1_PROT_READ, OSF1_PROT_READ, PROT_READ }, + { OSF1_PROT_WRITE, OSF1_PROT_WRITE, PROT_READ|PROT_WRITE }, + { OSF1_PROT_EXEC, OSF1_PROT_EXEC, PROT_READ|PROT_EXEC }, + { 0 } +}; + +const struct emul_flags_xtab osf1_nfs_mount_flags_xtab[] = { + { OSF1_NFSMNT_SOFT, OSF1_NFSMNT_SOFT, NFSMNT_SOFT, }, + { OSF1_NFSMNT_WSIZE, OSF1_NFSMNT_WSIZE, NFSMNT_WSIZE, }, + { OSF1_NFSMNT_RSIZE, OSF1_NFSMNT_RSIZE, NFSMNT_RSIZE, }, + { OSF1_NFSMNT_TIMEO, OSF1_NFSMNT_TIMEO, NFSMNT_TIMEO, }, + { OSF1_NFSMNT_RETRANS, OSF1_NFSMNT_RETRANS, NFSMNT_RETRANS, }, +#if 0 /* no equivalent; needs special handling, see below */ + { OSF1_NFSMNT_HOSTNAME, OSF1_NFSMNT_HOSTNAME, ???, }, +#endif + { OSF1_NFSMNT_INT, OSF1_NFSMNT_INT, NFSMNT_INT, }, + { OSF1_NFSMNT_NOCONN, OSF1_NFSMNT_NOCONN, NFSMNT_NOCONN, }, +#if 0 /* no equivalents */ + { OSF1_NFSMNT_NOAC, OSF1_NFSMNT_NOAC, ???, }, + { OSF1_NFSMNT_ACREGMIN, OSF1_NFSMNT_ACREGMIN, ???, }, + { OSF1_NFSMNT_ACREGMAX, OSF1_NFSMNT_ACREGMAX, ???, }, + { OSF1_NFSMNT_ACDIRMIN, OSF1_NFSMNT_ACDIRMIN, ???, }, + { OSF1_NFSMNT_ACDIRMAX, OSF1_NFSMNT_ACDIRMAX, ???, }, + { OSF1_NFSMNT_NOCTO, OSF1_NFSMNT_NOCTO, ???, }, + { OSF1_NFSMNT_POSIX, OSF1_NFSMNT_POSIX, ???, }, + { OSF1_NFSMNT_AUTO, OSF1_NFSMNT_AUTO, ???, }, + { OSF1_NFSMNT_SEC, OSF1_NFSMNT_SEC, ???, }, + { OSF1_NFSMNT_TCP, OSF1_NFSMNT_TCP, ???, }, + { OSF1_NFSMNT_PROPLIST, OSF1_NFSMNT_PROPLIST, ???, }, +#endif + { 0 } +}; + +const struct emul_flags_xtab osf1_open_flags_rxtab[] = { + { O_ACCMODE, O_RDONLY, OSF1_O_RDONLY }, + { O_ACCMODE, O_WRONLY, OSF1_O_WRONLY }, + { O_ACCMODE, O_RDWR, OSF1_O_RDWR }, + { O_NONBLOCK, O_NONBLOCK, OSF1_O_NONBLOCK }, + { O_APPEND, O_APPEND, OSF1_O_APPEND }, +#if 0 /* no equivalent +++ */ + { ???, ???, O_DEFER }, +#endif + { O_CREAT, O_CREAT, OSF1_O_CREAT }, + { O_TRUNC, O_TRUNC, OSF1_O_TRUNC }, + { O_EXCL, O_EXCL, OSF1_O_EXCL }, + { O_NOCTTY, O_NOCTTY, OSF1_O_NOCTTY }, + { O_SYNC, O_SYNC, OSF1_O_SYNC }, + { O_NDELAY, O_NDELAY, OSF1_O_NDELAY }, +#if 0 /* no equivalent, also same value as O_NDELAY! */ + { ???, ???, O_DRD }, +#endif + { O_DSYNC, O_DSYNC, OSF1_O_DSYNC }, + { O_RSYNC, O_RSYNC, OSF1_O_RSYNC }, + { 0 } +}; + +const struct emul_flags_xtab osf1_open_flags_xtab[] = { + { OSF1_O_ACCMODE, OSF1_O_RDONLY, O_RDONLY }, + { OSF1_O_ACCMODE, OSF1_O_WRONLY, O_WRONLY }, + { OSF1_O_ACCMODE, OSF1_O_RDWR, O_RDWR }, + { OSF1_O_NONBLOCK, OSF1_O_NONBLOCK, O_NONBLOCK }, + { OSF1_O_APPEND, OSF1_O_APPEND, O_APPEND }, +#if 0 /* no equivalent +++ */ + { OSF1_O_DEFER, OSF1_O_DEFER, ??? }, +#endif + { OSF1_O_CREAT, OSF1_O_CREAT, O_CREAT }, + { OSF1_O_TRUNC, OSF1_O_TRUNC, O_TRUNC }, + { OSF1_O_EXCL, OSF1_O_EXCL, O_EXCL }, + { OSF1_O_NOCTTY, OSF1_O_NOCTTY, O_NOCTTY }, + { OSF1_O_SYNC, OSF1_O_SYNC, O_SYNC }, + { OSF1_O_NDELAY, OSF1_O_NDELAY, O_NDELAY }, +#if 0 /* no equivalent, also same value as O_NDELAY! */ + { OSF1_O_DRD, OSF1_O_DRD, ??? }, +#endif + { OSF1_O_DSYNC, OSF1_O_DSYNC, O_DSYNC }, + { OSF1_O_RSYNC, OSF1_O_RSYNC, O_RSYNC }, + { 0 } +}; + +const struct emul_flags_xtab osf1_reboot_opt_xtab[] = { +#if 0 /* pseudo-flag */ + { OSF1_RB_AUTOBOOT, OSF1_RB_AUTOBOOT, RB_AUTOBOOT }, +#endif + { OSF1_RB_ASKNAME, OSF1_RB_ASKNAME, RB_ASKNAME }, + { OSF1_RB_SINGLE, OSF1_RB_SINGLE, RB_SINGLE }, + { OSF1_RB_NOSYNC, OSF1_RB_NOSYNC, RB_NOSYNC }, +#if 0 /* same value as O_NDELAY, only used at boot time? */ + { OSF1_RB_KDB, OSF1_RB_KDB, RB_KDB }, +#endif + { OSF1_RB_HALT, OSF1_RB_HALT, RB_HALT }, + { OSF1_RB_INITNAME, OSF1_RB_INITNAME, RB_INITNAME }, + { OSF1_RB_DFLTROOT, OSF1_RB_DFLTROOT, RB_DFLTROOT }, +#if 0 /* no equivalents +++ */ + { OSF1_RB_ALTBOOT, OSF1_RB_ALTBOOT, ??? }, + { OSF1_RB_UNIPROC, OSF1_RB_UNIPROC, ??? }, + { OSF1_RB_PARAM, OSF1_RB_PARAM, ??? }, +#endif + { OSF1_RB_DUMP, OSF1_RB_DUMP, RB_DUMP }, + { 0 } +}; + +const struct emul_flags_xtab osf1_sendrecv_msg_flags_xtab[] = { + { OSF1_MSG_OOB, OSF1_MSG_OOB, MSG_OOB }, + { OSF1_MSG_PEEK, OSF1_MSG_PEEK, MSG_PEEK }, + { OSF1_MSG_DONTROUTE, OSF1_MSG_DONTROUTE, MSG_DONTROUTE }, + { OSF1_MSG_EOR, OSF1_MSG_EOR, MSG_EOR }, + { OSF1_MSG_TRUNC, OSF1_MSG_TRUNC, MSG_TRUNC }, + { OSF1_MSG_CTRUNC, OSF1_MSG_CTRUNC, MSG_CTRUNC }, + { OSF1_MSG_WAITALL, OSF1_MSG_WAITALL, MSG_WAITALL }, + { 0 } +}; + +const struct emul_flags_xtab osf1_sigaction_flags_rxtab[] = { + { SA_ONSTACK, SA_ONSTACK, OSF1_SA_ONSTACK }, + { SA_RESTART, SA_RESTART, OSF1_SA_RESTART }, + { SA_NOCLDSTOP, SA_NOCLDSTOP, OSF1_SA_NOCLDSTOP }, + { SA_NODEFER, SA_NODEFER, OSF1_SA_NODEFER }, + { SA_RESETHAND, SA_RESETHAND, OSF1_SA_RESETHAND }, + { SA_NOCLDWAIT, SA_NOCLDWAIT, OSF1_SA_NOCLDWAIT }, +#if 0 /* XXX not yet */ + { SA_SIGINFO, SA_SIGINFO, OSF1_SA_SIGINFO }, +#endif + { 0 }, +}; + +const struct emul_flags_xtab osf1_sigaction_flags_xtab[] = { + { OSF1_SA_ONSTACK, OSF1_SA_ONSTACK, SA_ONSTACK }, + { OSF1_SA_RESTART, OSF1_SA_RESTART, SA_RESTART }, + { OSF1_SA_NOCLDSTOP, OSF1_SA_NOCLDSTOP, SA_NOCLDSTOP }, + { OSF1_SA_NODEFER, OSF1_SA_NODEFER, SA_NODEFER }, + { OSF1_SA_RESETHAND, OSF1_SA_RESETHAND, SA_RESETHAND }, + { OSF1_SA_NOCLDWAIT, OSF1_SA_NOCLDWAIT, SA_NOCLDWAIT }, +#if 0 /* XXX not yet */ + { OSF1_SA_SIGINFO, OSF1_SA_SIGINFO, SA_SIGINFO }, +#endif + { 0 }, +}; + +const struct emul_flags_xtab osf1_sigaltstack_flags_rxtab[] = { + { SS_ONSTACK, SS_ONSTACK, OSF1_SS_ONSTACK }, + { SS_DISABLE, SS_DISABLE, OSF1_SS_DISABLE }, +#if 0 /* XXX no equivalents */ + { ???, ???, OSF1_SS_NOMASK }, + { ???, ???, OSF1_SS_UCONTEXT }, +#endif + { 0 }, +}; + +const struct emul_flags_xtab osf1_sigaltstack_flags_xtab[] = { + { OSF1_SS_ONSTACK, OSF1_SS_ONSTACK, SS_ONSTACK }, + { OSF1_SS_DISABLE, OSF1_SS_DISABLE, SS_DISABLE }, +#if 0 /* XXX no equivalents */ + { OSF1_SS_NOMASK, OSF1_SS_NOMASK, ??? }, + { OSF1_SS_UCONTEXT, OSF1_SS_UCONTEXT, ??? }, +#endif + { 0 }, +}; + +const struct emul_flags_xtab osf1_wait_options_xtab[] = { + { OSF1_WNOHANG, OSF1_WNOHANG, WNOHANG }, + { OSF1_WUNTRACED, OSF1_WUNTRACED, WUNTRACED }, + { 0 } +}; + +void +osf1_cvt_flock_from_native(nf, of) + const struct flock *nf; + struct osf1_flock *of; +{ + + memset(of, 0, sizeof of); + + of->l_start = nf->l_start; + of->l_len = nf->l_len; + of->l_pid = nf->l_pid; + + switch (nf->l_type) { + case F_RDLCK: + of->l_type = OSF1_F_RDLCK; + break; + + case F_WRLCK: + of->l_type = OSF1_F_WRLCK; + break; + + case F_UNLCK: + of->l_type = OSF1_F_UNLCK; + break; + } + + switch (nf->l_whence) { + case SEEK_SET: + of->l_whence = OSF1_SEEK_SET; + break; + + case SEEK_CUR: + of->l_whence = OSF1_SEEK_CUR; + break; + + case SEEK_END: + of->l_whence = OSF1_SEEK_END; + break; + } +} + +int +osf1_cvt_flock_to_native(of, nf) + const struct osf1_flock *of; + struct flock *nf; +{ + + memset(nf, 0, sizeof nf); + + nf->l_start = of->l_start; + nf->l_len = of->l_len; + nf->l_pid = of->l_pid; + + switch (of->l_type) { + case OSF1_F_RDLCK: + nf->l_type = F_RDLCK; + break; + + case OSF1_F_WRLCK: + nf->l_type = F_WRLCK; + break; + + case OSF1_F_UNLCK: + nf->l_type = F_UNLCK; + break; + + default: + return (EINVAL); + } + + switch (of->l_whence) { + case OSF1_SEEK_SET: + nf->l_whence = SEEK_SET; + break; + + case OSF1_SEEK_CUR: + nf->l_whence = SEEK_CUR; + break; + + case OSF1_SEEK_END: + nf->l_whence = SEEK_END; + break; + + default: + return (EINVAL); + } + + return (0); +} + +int +osf1_cvt_msghdr_xopen_to_native(omh, bmh) + const struct osf1_msghdr_xopen *omh; + struct msghdr *bmh; +{ + unsigned long leftovers; + + memset(bmh, 0, sizeof bmh); + bmh->msg_name = omh->msg_name; /* XXX sockaddr translation */ + bmh->msg_namelen = omh->msg_namelen; + bmh->msg_iov = NULL; /* iovec xlation separate */ + bmh->msg_iovlen = omh->msg_iovlen; + + /* XXX we don't translate control messages (yet) */ + if (bmh->msg_control != NULL || bmh->msg_controllen != 0) +{ +printf("osf1_cvt_msghdr_xopen_to_native: control\n"); + return (EINVAL); +} + + /* translate flags */ + bmh->msg_flags = emul_flags_translate(osf1_sendrecv_msg_flags_xtab, + omh->msg_flags, &leftovers); + if (leftovers != 0) +{ +printf("osf1_cvt_msghdr_xopen_to_native: leftovers 0x%lx\n", leftovers); + return (EINVAL); +} + + return (0); +} + +int +osf1_cvt_pathconf_name_to_native(oname, bnamep) + int oname, *bnamep; +{ + int error; + + error = 0; + switch (oname) { + case OSF1__PC_CHOWN_RESTRICTED: + *bnamep = _PC_CHOWN_RESTRICTED; + break; + + case OSF1__PC_LINK_MAX: + *bnamep = _PC_LINK_MAX; + break; + + case OSF1__PC_MAX_CANON: + *bnamep = _PC_MAX_CANON; + break; + + case OSF1__PC_MAX_INPUT: + *bnamep = _PC_MAX_INPUT; + break; + + case OSF1__PC_NAME_MAX: + *bnamep = _PC_NAME_MAX; + break; + + case OSF1__PC_NO_TRUNC: + *bnamep = _PC_NO_TRUNC; + break; + + case OSF1__PC_PATH_MAX: + *bnamep = _PC_PATH_MAX; + break; + + case OSF1__PC_PIPE_BUF: + *bnamep = _PC_PIPE_BUF; + break; + + case OSF1__PC_VDISABLE: + *bnamep = _PC_VDISABLE; + break; + + default: + error = EINVAL; + break; + } + + return (error); +} + +/* + * Convert from as rusage structure to an osf1 rusage structure. + */ +void +osf1_cvt_rusage_from_native(ru, oru) + const struct rusage *ru; + struct osf1_rusage *oru; +{ + + oru->ru_utime.tv_sec = ru->ru_utime.tv_sec; + oru->ru_utime.tv_usec = ru->ru_utime.tv_usec; + + oru->ru_stime.tv_sec = ru->ru_stime.tv_sec; + oru->ru_stime.tv_usec = ru->ru_stime.tv_usec; + + oru->ru_maxrss = ru->ru_maxrss; + oru->ru_ixrss = ru->ru_ixrss; + oru->ru_idrss = ru->ru_idrss; + oru->ru_isrss = ru->ru_isrss; + oru->ru_minflt = ru->ru_minflt; + oru->ru_majflt = ru->ru_majflt; + oru->ru_nswap = ru->ru_nswap; + oru->ru_inblock = ru->ru_inblock; + oru->ru_oublock = ru->ru_oublock; + oru->ru_msgsnd = ru->ru_msgsnd; + oru->ru_msgrcv = ru->ru_msgrcv; + oru->ru_nsignals = ru->ru_nsignals; + oru->ru_nvcsw = ru->ru_nvcsw; + oru->ru_nivcsw = ru->ru_nivcsw; +} + +/* + * XXX: Only a subset of the flags is currently implemented. + */ +void +osf1_cvt_sigaction_from_native(bsa, osa) + const struct sigaction *bsa; + struct osf1_sigaction *osa; +{ + osa->sa__handler = bsa->sa_handler; + osf1_cvt_sigset_from_native(&bsa->sa_mask, &osa->sa_mask); + osa->sa_flags = 0; + + /* Translate by hand */ + if ((bsa->sa_flags & SA_ONSTACK) != 0) + osa->sa_flags |= OSF1_SA_ONSTACK; + if ((bsa->sa_flags & SA_RESTART) != 0) + osa->sa_flags |= OSF1_SA_RESTART; + if ((bsa->sa_flags & SA_NOCLDSTOP) != 0) + osa->sa_flags |= OSF1_SA_NOCLDSTOP; + if ((bsa->sa_flags & SA_NOCLDWAIT) != 0) + osa->sa_flags |= OSF1_SA_NOCLDWAIT; + if ((bsa->sa_flags & SA_NODEFER) != 0) + osa->sa_flags |= OSF1_SA_NODEFER; + if ((bsa->sa_flags & SA_RESETHAND) != 0) + osa->sa_flags |= OSF1_SA_RESETHAND; + if ((bsa->sa_flags & SA_SIGINFO) != 0) + osa->sa_flags |= OSF1_SA_SIGINFO; +} + +int +osf1_cvt_sigaction_to_native(osa, bsa) + const struct osf1_sigaction *osa; + struct sigaction *bsa; +{ + bsa->sa_handler = osa->sa__handler; + osf1_cvt_sigset_to_native(&osa->sa_mask, &bsa->sa_mask); + bsa->sa_flags = 0; + + /* Translate by hand */ + if ((osa->sa_flags & OSF1_SA_ONSTACK) != 0) + bsa->sa_flags |= SA_ONSTACK; + if ((osa->sa_flags & OSF1_SA_RESTART) != 0) + bsa->sa_flags |= SA_RESTART; + if ((osa->sa_flags & OSF1_SA_RESETHAND) != 0) + bsa->sa_flags |= SA_RESETHAND; + if ((osa->sa_flags & OSF1_SA_NOCLDSTOP) != 0) + bsa->sa_flags |= SA_NOCLDSTOP; + if ((osa->sa_flags & OSF1_SA_NOCLDWAIT) != 0) + bsa->sa_flags |= SA_NOCLDWAIT; + if ((osa->sa_flags & OSF1_SA_NODEFER) != 0) + bsa->sa_flags |= SA_NODEFER; + if ((osa->sa_flags & OSF1_SA_SIGINFO) != 0) + bsa->sa_flags |= SA_SIGINFO; + + return(0); +} + +void +osf1_cvt_sigaltstack_from_native(bss, oss) + const struct sigaltstack *bss; + struct osf1_sigaltstack *oss; +{ + + oss->ss_sp = bss->ss_sp; + oss->ss_size = bss->ss_size; + + /* translate flags */ + oss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_rxtab, + bss->ss_flags, NULL); +} + +int +osf1_cvt_sigaltstack_to_native(oss, bss) + const struct osf1_sigaltstack *oss; + struct sigaltstack *bss; +{ + unsigned long leftovers; + + bss->ss_sp = oss->ss_sp; + bss->ss_size = oss->ss_size; + + /* translate flags */ + bss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_xtab, + oss->ss_flags, &leftovers); + + if (leftovers != 0) { + printf("osf1_cvt_sigaltstack_to_native: leftovers = 0x%lx\n", + leftovers); + return (EINVAL); + } + + return (0); +} + +void +osf1_cvt_sigset_from_native(bss, oss) + const sigset_t *bss; + osf1_sigset_t *oss; +{ + int i, newsig; + + osf1_sigemptyset(oss); + for (i = 1; i < NSIG; i++) { + if (sigismember(bss, i)) { + newsig = osf1_signal_rxlist[i]; + if (newsig) + osf1_sigaddset(oss, newsig); + } + } +} + +int +osf1_cvt_sigset_to_native(oss, bss) + const osf1_sigset_t *oss; + sigset_t *bss; +{ + int i, newsig; + + sigemptyset(bss); + for (i = 1; i < OSF1_NSIG; i++) { + if (osf1_sigismember(oss, i)) { + newsig = osf1_signal_xlist[i]; + if (newsig) + sigaddset(bss, newsig); + } + } + return (0); +} + +/* + * Convert from a stat structure to an osf1 stat structure. + */ +void +osf1_cvt_stat_from_native(st, ost) + const struct stat *st; + struct osf1_stat *ost; +{ + + ost->st_dev = osf1_cvt_dev_from_native(st->st_dev); + ost->st_ino = st->st_ino; + ost->st_mode = st->st_mode; + ost->st_nlink = st->st_nlink; + ost->st_uid = st->st_uid == -2 ? (u_int16_t) -2 : st->st_uid; + ost->st_gid = st->st_gid == -2 ? (u_int16_t) -2 : st->st_gid; + ost->st_rdev = osf1_cvt_dev_from_native(st->st_rdev); + ost->st_size = st->st_size; + ost->st_atime_sec = st->st_atime; + ost->st_spare1 = 0; + ost->st_mtime_sec = st->st_mtime; + ost->st_spare2 = 0; + ost->st_ctime_sec = st->st_ctime; + ost->st_spare3 = 0; + ost->st_blksize = st->st_blksize; + ost->st_blocks = st->st_blocks; + ost->st_flags = st->st_flags; + ost->st_gen = st->st_gen; +} + +void +osf1_cvt_statfs_from_native(bsfs, osfs) + const struct statfs *bsfs; + struct osf1_statfs *osfs; +{ + + memset(osfs, 0, sizeof (struct osf1_statfs)); + if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, MFSNAMELEN)) + osfs->f_type = OSF1_MOUNT_UFS; + else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, MFSNAMELEN)) + osfs->f_type = OSF1_MOUNT_NFS; + else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, MFSNAMELEN)) + osfs->f_type = OSF1_MOUNT_MFS; + else + /* uh oh... XXX = PC, CDFS, PROCFS, etc. */ + osfs->f_type = OSF1_MOUNT_ADDON; + osfs->f_flags = bsfs->f_flags; /* XXX translate */ + osfs->f_fsize = bsfs->f_bsize; + osfs->f_bsize = bsfs->f_iosize; + osfs->f_blocks = bsfs->f_blocks; + osfs->f_bfree = bsfs->f_bfree; + osfs->f_bavail = bsfs->f_bavail; + osfs->f_files = bsfs->f_files; + osfs->f_ffree = bsfs->f_ffree; + memcpy(&osfs->f_fsid, &bsfs->f_fsid, + max(sizeof bsfs->f_fsid, sizeof osfs->f_fsid)); + /* osfs->f_spare zeroed above */ + memcpy(osfs->f_mntonname, bsfs->f_mntonname, + max(sizeof bsfs->f_mntonname, sizeof osfs->f_mntonname)); + memcpy(osfs->f_mntfromname, bsfs->f_mntfromname, + max(sizeof bsfs->f_mntfromname, sizeof osfs->f_mntfromname)); + /* XXX osfs->f_xxx should be filled in... */ +} diff --git a/sys/compat/osf1/osf1_cvt.h b/sys/compat/osf1/osf1_cvt.h new file mode 100644 index 00000000000..1f8dd8f43b1 --- /dev/null +++ b/sys/compat/osf1/osf1_cvt.h @@ -0,0 +1,98 @@ +/* $OpenBSD: osf1_cvt.h,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_cvt.h,v 1.5 1999/05/10 05:58:44 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _COMPAT_OSF1_OSF1_CVT_H_ +#define _COMPAT_OSF1_OSF1_CVT_H_ + +#include <sys/param.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/resource.h> +#include <sys/signal.h> +#include <sys/stat.h> +#include <sys/fcntl.h> + +#include <compat/common/compat_util.h> + +#define osf1_cvt_dev_from_native(dev) \ + osf1_makedev(major(dev), minor(dev)) +#define osf1_cvt_dev_to_native(dev) \ + makedev(osf1_major(dev), osf1_minor(dev)) + +void osf1_cvt_flock_from_native(const struct flock *nf, + struct osf1_flock *of); +int osf1_cvt_flock_to_native(const struct osf1_flock *of, + struct flock *nf); +int osf1_cvt_msghdr_xopen_to_native(const struct osf1_msghdr_xopen *omh, + struct msghdr *nmh); +int osf1_cvt_pathconf_name_to_native(int oname, int *bnamep); +void osf1_cvt_rusage_from_native(const struct rusage *nru, + struct osf1_rusage *oru); +void osf1_cvt_sigaction_from_native(const struct sigaction *nsa, + struct osf1_sigaction *osa); +int osf1_cvt_sigaction_to_native(const struct osf1_sigaction *osa, + struct sigaction *nsa); +void osf1_cvt_sigaltstack_from_native(const struct sigaltstack *nss, + struct osf1_sigaltstack *oss); +int osf1_cvt_sigaltstack_to_native(const struct osf1_sigaltstack *oss, + struct sigaltstack *nss); +void osf1_cvt_sigset_from_native(const sigset_t *nss, osf1_sigset_t *oss); +int osf1_cvt_sigset_to_native(const osf1_sigset_t *oss, sigset_t *nss); +void osf1_cvt_stat_from_native(const struct stat *nst, + struct osf1_stat *ost); +void osf1_cvt_statfs_from_native(const struct statfs *nsfs, + struct osf1_statfs *osfs); + +extern const int osf1_errno_rxlist[]; +extern const int osf1_signal_xlist[]; +extern const int osf1_signal_rxlist[]; + +extern const struct emul_flags_xtab osf1_access_flags_xtab[]; +extern const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_rxtab[]; +extern const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_xtab[]; +extern const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_rxtab[]; +extern const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_xtab[]; +extern const struct emul_flags_xtab osf1_mmap_flags_xtab[]; +extern const struct emul_flags_xtab osf1_mmap_prot_xtab[]; +extern const struct emul_flags_xtab osf1_nfs_mount_flags_xtab[]; +extern const struct emul_flags_xtab osf1_open_flags_rxtab[]; +extern const struct emul_flags_xtab osf1_open_flags_xtab[]; +extern const struct emul_flags_xtab osf1_reboot_opt_xtab[]; +extern const struct emul_flags_xtab osf1_sendrecv_msg_flags_xtab[]; +extern const struct emul_flags_xtab osf1_sigaction_flags_rxtab[]; +extern const struct emul_flags_xtab osf1_sigaction_flags_xtab[]; +extern const struct emul_flags_xtab osf1_sigaltstack_flags_rxtab[]; +extern const struct emul_flags_xtab osf1_sigaltstack_flags_xtab[]; +extern const struct emul_flags_xtab osf1_wait_options_xtab[]; + +#endif /* _COMPAT_OSF1_OSF1_CVT_H_ */ diff --git a/sys/compat/osf1/osf1_cvt_errno.c b/sys/compat/osf1/osf1_cvt_errno.c new file mode 100644 index 00000000000..f31b2a5a1c0 --- /dev/null +++ b/sys/compat/osf1/osf1_cvt_errno.c @@ -0,0 +1,130 @@ +/* $OpenBSD: osf1_cvt_errno.c,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_cvt_errno.c,v 1.4 1999/05/01 02:16:01 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_cvt.h> + +/* + * This table is used to translate NetBSD errnos to OSF/1 errnos + * when returning from a system call. + * + * It is up to date as of Digital UNIX V4.0 and NetBSD 1.4. + */ + +const int osf1_errno_rxlist[] = { + 0, + OSF1_EPERM, /* EPERM (1) -> 1 */ + OSF1_ENOENT, /* ENOENT (2) -> 2 */ + OSF1_ESRCH, /* ESRCH (3) -> 3 */ + OSF1_EINTR, /* EINTR (4) -> 4 */ + OSF1_EIO, /* EIO (5) -> 5 */ + OSF1_ENXIO, /* ENXIO (6) -> 6 */ + OSF1_E2BIG, /* E2BIG (7) -> 7 */ + OSF1_ENOEXEC, /* ENOEXEC (8) -> 8 */ + OSF1_EBADF, /* EBADF (9) -> 9 */ + OSF1_ECHILD, /* ECHILD (10) -> 10 */ + OSF1_EDEADLK, /* EDEADLK (11) -> 11 */ + OSF1_ENOMEM, /* ENOMEM (12) -> 12 */ + OSF1_EACCES, /* EACCES (13) -> 13 */ + OSF1_EFAULT, /* EFAULT (14) -> 14 */ + OSF1_ENOTBLK, /* ENOTBLK (15) -> 15 */ + OSF1_EBUSY, /* EBUSY (16) -> 16 */ + OSF1_EEXIST, /* EEXIST (17) -> 17 */ + OSF1_EXDEV, /* EXDEV (18) -> 18 */ + OSF1_ENODEV, /* ENODEV (19) -> 19 */ + OSF1_ENOTDIR, /* ENOTDIR (20) -> 20 */ + OSF1_EISDIR, /* EISDIR (21) -> 21 */ + OSF1_EINVAL, /* EINVAL (22) -> 22 */ + OSF1_ENFILE, /* ENFILE (23) -> 23 */ + OSF1_EMFILE, /* EMFILE (24) -> 24 */ + OSF1_ENOTTY, /* ENOTTY (25) -> 25 */ + OSF1_ETXTBSY, /* ETXTBSY (26) -> 26 */ + OSF1_EFBIG, /* EFBIG (27) -> 27 */ + OSF1_ENOSPC, /* ENOSPC (28) -> 28 */ + OSF1_ESPIPE, /* ESPIPE (29) -> 29 */ + OSF1_EROFS, /* EROFS (30) -> 30 */ + OSF1_EMLINK, /* EMLINK (31) -> 31 */ + OSF1_EPIPE, /* EPIPE (32) -> 32 */ + OSF1_EDOM, /* EDOM (33) -> 33 */ + OSF1_ERANGE, /* ERANGE (34) -> 34 */ + OSF1_EWOULDBLOCK, /* EAGAIN (35) -> OSF1_EWOULDBLOCK (35) */ + OSF1_EINPROGRESS, /* EINPROGRESS (36) -> 36 */ + OSF1_EALREADY, /* EALREADY (37) -> 37 */ + OSF1_ENOTSOCK, /* ENOTSOCK (38) -> 38 */ + OSF1_EDESTADDRREQ, /* EDESTADDRREQ (39) -> 39 */ + OSF1_EMSGSIZE, /* EMSGSIZE (40) -> 40 */ + OSF1_EPROTOTYPE, /* EPROTOTYPE (41) -> 41 */ + OSF1_ENOPROTOOPT, /* ENOPROTOOPT (42) -> 42 */ + OSF1_EPROTONOSUPPORT, /* EPROTONOSUPPORT (43) -> 43 */ + OSF1_ESOCKTNOSUPPORT, /* ESOCKTNOSUPPORT (44) -> 44 */ + OSF1_EOPNOTSUPP, /* EOPNOTSUPP (45) -> 45 */ + OSF1_EPFNOSUPPORT, /* EPFNOSUPPORT (46) -> 46 */ + OSF1_EAFNOSUPPORT, /* EAFNOSUPPORT (47) -> 47 */ + OSF1_EADDRINUSE, /* EADDRINUSE (48) -> 48 */ + OSF1_EADDRNOTAVAIL, /* EADDRNOTAVAIL (49) -> 49 */ + OSF1_ENETDOWN, /* ENETDOWN (50) -> 50 */ + OSF1_ENETUNREACH, /* ENETUNREACH (51) -> 51 */ + OSF1_ENETRESET, /* ENETRESET (52) -> 52 */ + OSF1_ECONNABORTED, /* ECONNABORTED (53) -> 53 */ + OSF1_ECONNRESET, /* ECONNRESET (54) -> 54 */ + OSF1_ENOBUFS, /* ENOBUFS (55) -> 55 */ + OSF1_EISCONN, /* EISCONN (56) -> 56 */ + OSF1_ENOTCONN, /* ENOTCONN (57) -> 57 */ + OSF1_ESHUTDOWN, /* ESHUTDOWN (58) -> 58 */ + OSF1_ETOOMANYREFS, /* ETOOMANYREFS (59) -> 59 */ + OSF1_ETIMEDOUT, /* ETIMEDOUT (60) -> 60 */ + OSF1_ECONNREFUSED, /* ECONNREFUSED (61) -> 61 */ + OSF1_ELOOP, /* ELOOP (62) -> 62 */ + OSF1_ENAMETOOLONG, /* ENAMETOOLONG (63) -> 63 */ + OSF1_EHOSTDOWN, /* EHOSTDOWN (64) -> 64 */ + OSF1_EHOSTUNREACH, /* EHOSTUNREACH (65) -> 65 */ + OSF1_ENOTEMPTY, /* ENOTEMPTY (66) -> 66 */ + OSF1_EPROCLIM, /* EPROCLIM (67) -> 67 */ + OSF1_EUSERS, /* EUSERS (68) -> 68 */ + OSF1_EDQUOT, /* EDQUOT (69) -> 69 */ + OSF1_ESTALE, /* ESTALE (70) -> 70 */ + OSF1_EREMOTE, /* EREMOTE (71) -> 71 */ + OSF1_EBADRPC, /* EBADRPC (72) -> 72 */ + OSF1_ERPCMISMATCH, /* ERPCMISMATCH (73) -> 73 */ + OSF1_EPROGUNAVAIL, /* EPROGUNAVAIL (74) -> 74 */ + OSF1_EPROGMISMATCH, /* EPROGMISMATCH (75) -> 75 */ + OSF1_EPROCUNAVAIL, /* EPROCUNAVAIL (76) -> 76 */ + OSF1_ENOLCK, /* ENOLCK (77) -> 77 */ + OSF1_ENOSYS, /* ENOSYS (78) -> 78 */ + OSF1_EFTYPE, /* EFTYPE (79) -> 79 */ + OSF1_ENOSYS, /* EAUTH (80) has no equivalent */ + OSF1_ENOSYS, /* ENEEDAUTH (81) has no equivalent */ + OSF1_EIDRM, /* EIDRM (82) -> 81 */ + OSF1_ENOMSG, /* ENOMSG (83) -> 80 */ + OSF1_EOVERFLOW, /* EOVERFLOW (84) -> 103 */ +}; diff --git a/sys/compat/osf1/osf1_cvt_signal.c b/sys/compat/osf1/osf1_cvt_signal.c new file mode 100644 index 00000000000..1ae4d84e7a3 --- /dev/null +++ b/sys/compat/osf1/osf1_cvt_signal.c @@ -0,0 +1,112 @@ +/* $OpenBSD: osf1_cvt_signal.c,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_signal.c,v 1.13 1999/04/30 05:24:04 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_cvt.h> + +/* + * These tables are used to translate between NetBSD and OSF/1 signal + * numbers. + * + * XXX IT IS NOT UP TO DATE. + */ + +const int osf1_signal_rxlist[] = { + 0, + OSF1_SIGHUP, + OSF1_SIGINT, + OSF1_SIGQUIT, + OSF1_SIGILL, + OSF1_SIGTRAP, + OSF1_SIGABRT, + OSF1_SIGEMT, + OSF1_SIGFPE, + OSF1_SIGKILL, + OSF1_SIGBUS, + OSF1_SIGSEGV, + OSF1_SIGSYS, + OSF1_SIGPIPE, + OSF1_SIGALRM, + OSF1_SIGTERM, + OSF1_SIGURG, + OSF1_SIGSTOP, + OSF1_SIGTSTP, + OSF1_SIGCONT, + OSF1_SIGCHLD, + OSF1_SIGTTIN, + OSF1_SIGTTOU, + OSF1_SIGIO, + OSF1_SIGXCPU, + OSF1_SIGXFSZ, + OSF1_SIGVTALRM, + OSF1_SIGPROF, + OSF1_SIGWINCH, + OSF1_SIGINFO, + OSF1_SIGUSR1, + OSF1_SIGUSR2, +}; + +const int osf1_signal_xlist[] = { + 0, + SIGHUP, + SIGINT, + SIGQUIT, + SIGILL, + SIGTRAP, + SIGABRT, + SIGEMT, + SIGFPE, + SIGKILL, + SIGBUS, + SIGSEGV, + SIGSYS, + SIGPIPE, + SIGALRM, + SIGTERM, + SIGURG, + SIGSTOP, + SIGTSTP, + SIGCONT, + SIGCHLD, + SIGTTIN, + SIGTTOU, + SIGIO, + SIGXCPU, + SIGXFSZ, + SIGVTALRM, + SIGPROF, + SIGWINCH, + SIGINFO, + SIGUSR1, + SIGUSR2, +}; diff --git a/sys/compat/osf1/osf1_descrip.c b/sys/compat/osf1/osf1_descrip.c new file mode 100644 index 00000000000..a9123899768 --- /dev/null +++ b/sys/compat/osf1/osf1_descrip.c @@ -0,0 +1,305 @@ +/* $OpenBSD: osf1_descrip.c,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_descrip.c,v 1.5 1999/06/26 01:24:41 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/filedesc.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/signal.h> +#include <sys/signalvar.h> +#include <sys/reboot.h> +#include <sys/syscallargs.h> +#include <sys/exec.h> +#include <sys/vnode.h> +#include <sys/socketvar.h> +#include <sys/resource.h> +#include <sys/resourcevar.h> +#include <sys/wait.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_fcntl(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_fcntl_args *uap = v; + struct sys_fcntl_args a; + struct osf1_flock oflock; + struct flock nflock; + unsigned long xfl, leftovers; + caddr_t sg; + int error; + + sg = stackgap_init(p->p_emul); + + SCARG(&a, fd) = SCARG(uap, fd); + + leftovers = 0; + switch (SCARG(uap, cmd)) { + case OSF1_F_DUPFD: + SCARG(&a, cmd) = F_DUPFD; + SCARG(&a, arg) = SCARG(uap, arg); + break; + + case OSF1_F_GETFD: + SCARG(&a, cmd) = F_GETFD; + SCARG(&a, arg) = 0; /* ignored */ + break; + + case OSF1_F_SETFD: + SCARG(&a, cmd) = F_SETFD; + SCARG(&a, arg) = (void *)emul_flags_translate( + osf1_fcntl_getsetfd_flags_xtab, + (unsigned long)SCARG(uap, arg), &leftovers); + break; + + case OSF1_F_GETFL: + SCARG(&a, cmd) = F_GETFL; + SCARG(&a, arg) = 0; /* ignored */ + break; + + case OSF1_F_SETFL: + SCARG(&a, cmd) = F_SETFL; + xfl = emul_flags_translate(osf1_open_flags_xtab, + (unsigned long)SCARG(uap, arg), &leftovers); + xfl |= emul_flags_translate(osf1_fcntl_getsetfl_flags_xtab, + leftovers, &leftovers); + SCARG(&a, arg) = (void *)xfl; + break; + + case OSF1_F_GETOWN: /* XXX not yet supported */ + case OSF1_F_SETOWN: /* XXX not yet supported */ + /* XXX translate. */ + return (EINVAL); + + case OSF1_F_GETLK: + case OSF1_F_SETLK: + case OSF1_F_SETLKW: + if (SCARG(uap, cmd) == OSF1_F_GETLK) + SCARG(&a, cmd) = F_GETLK; + else if (SCARG(uap, cmd) == OSF1_F_SETLK) + SCARG(&a, cmd) = F_SETLK; + else if (SCARG(uap, cmd) == OSF1_F_SETLKW) + SCARG(&a, cmd) = F_SETLKW; + SCARG(&a, arg) = stackgap_alloc(&sg, sizeof nflock); + + error = copyin(SCARG(uap, arg), &oflock, sizeof oflock); + if (error == 0) + error = osf1_cvt_flock_to_native(&oflock, &nflock); + if (error == 0) + error = copyout(&nflock, SCARG(&a, arg), + sizeof nflock); + if (error != 0) + return (error); + break; + + case OSF1_F_RGETLK: /* [lock mgr op] XXX not supported */ + case OSF1_F_RSETLK: /* [lock mgr op] XXX not supported */ + case OSF1_F_CNVT: /* [lock mgr op] XXX not supported */ + case OSF1_F_RSETLKW: /* [lock mgr op] XXX not supported */ + case OSF1_F_PURGEFS: /* [lock mgr op] XXX not supported */ + case OSF1_F_PURGENFS: /* [DECsafe op] XXX not supported */ + default: + /* XXX syslog? */ + return (EINVAL); + } + if (leftovers != 0) + return (EINVAL); + + error = sys_fcntl(p, &a, retval); + + if (error) + return error; + + switch (SCARG(uap, cmd)) { + case OSF1_F_GETFD: + retval[0] = emul_flags_translate( + osf1_fcntl_getsetfd_flags_rxtab, retval[0], NULL); + break; + + case OSF1_F_GETFL: + xfl = emul_flags_translate(osf1_open_flags_rxtab, + retval[0], &leftovers); + xfl |= emul_flags_translate(osf1_fcntl_getsetfl_flags_rxtab, + leftovers, NULL); + retval[0] = xfl; + break; + + case OSF1_F_GETLK: + error = copyin(SCARG(&a, arg), &nflock, sizeof nflock); + if (error == 0) { + osf1_cvt_flock_from_native(&nflock, &oflock); + error = copyout(&oflock, SCARG(uap, arg), + sizeof oflock); + } + break; + } + + return error; +} + +int +osf1_sys_fpathconf(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_fpathconf_args *uap = v; + struct sys_fpathconf_args a; + int error; + + SCARG(&a, fd) = SCARG(uap, fd); + + error = osf1_cvt_pathconf_name_to_native(SCARG(uap, name), + &SCARG(&a, name)); + + if (error == 0) + error = sys_fpathconf(p, &a, retval); + + return (error); +} + +/* + * Return status information about a file descriptor. + */ +int +osf1_sys_fstat(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_fstat_args *uap = v; + struct filedesc *fdp = p->p_fd; + struct file *fp; + struct stat ub; + struct osf1_stat oub; + int error; + + /* XXX */ + if ((unsigned)SCARG(uap, fd) >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) /* || + (fp->f_iflags & FIF_WANTCLOSE) != 0) */ + return (EBADF); + + switch (fp->f_type) { + + case DTYPE_VNODE: + error = vn_stat((struct vnode *)fp->f_data, &ub, p); + break; + + case DTYPE_SOCKET: + error = soo_stat((struct socket *)fp->f_data, &ub); + break; + + default: + panic("ofstat"); + /*NOTREACHED*/ + } + osf1_cvt_stat_from_native(&ub, &oub); + if (error == 0) + error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb), + sizeof (oub)); + + return (error); +} + +int +osf1_sys_ftruncate(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_ftruncate_args *uap = v; + struct sys_ftruncate_args a; + + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, pad) = 0; + SCARG(&a, length) = SCARG(uap, length); + + return sys_ftruncate(p, &a, retval); +} + +int +osf1_sys_lseek(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_lseek_args *uap = v; + struct sys_lseek_args a; + + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, pad) = 0; + SCARG(&a, offset) = SCARG(uap, offset); + SCARG(&a, whence) = SCARG(uap, whence); + + return sys_lseek(p, &a, retval); +} diff --git a/sys/compat/osf1/osf1_errno.h b/sys/compat/osf1/osf1_errno.h new file mode 100644 index 00000000000..c69e14321ea --- /dev/null +++ b/sys/compat/osf1/osf1_errno.h @@ -0,0 +1,149 @@ +/* $OpenBSD: osf1_errno.h,v 1.1 2000/08/04 15:47:54 ericj Exp $ */ +/* $NetBSD: osf1_errno.h,v 1.2 1999/04/23 18:00:34 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * OSF/1 error number definitions, as described by the Digital UNIX V4.0 + * <sys/errno.h>. + */ + +#ifndef _COMPAT_OSF1_OSF1_ERRNO_H_ +#define _COMPAT_OSF1_OSF1_ERRNO_H_ + +#define OSF1_ESUCCESS 0 +#define OSF1_EPERM 1 +#define OSF1_ENOENT 2 +#define OSF1_ESRCH 3 +#define OSF1_EINTR 4 +#define OSF1_EIO 5 +#define OSF1_ENXIO 6 +#define OSF1_E2BIG 7 +#define OSF1_ENOEXEC 8 +#define OSF1_EBADF 9 +#define OSF1_ECHILD 10 +#define OSF1_EDEADLK 11 +#define OSF1_ENOMEM 12 +#define OSF1_EACCES 13 +#define OSF1_EFAULT 14 +#define OSF1_ENOTBLK 15 +#define OSF1_EBUSY 16 +#define OSF1_EEXIST 17 +#define OSF1_EXDEV 18 +#define OSF1_ENODEV 19 +#define OSF1_ENOTDIR 20 +#define OSF1_EISDIR 21 +#define OSF1_EINVAL 22 +#define OSF1_ENFILE 23 +#define OSF1_EMFILE 24 +#define OSF1_ENOTTY 25 +#define OSF1_ETXTBSY 26 +#define OSF1_EFBIG 27 +#define OSF1_ENOSPC 28 +#define OSF1_ESPIPE 29 +#define OSF1_EROFS 30 +#define OSF1_EMLINK 31 +#define OSF1_EPIPE 32 +#define OSF1_EDOM 33 +#define OSF1_ERANGE 34 +#define OSF1_EWOULDBLOCK 35 +#define OSF1_EINPROGRESS 36 +#define OSF1_EALREADY 37 +#define OSF1_ENOTSOCK 38 +#define OSF1_EDESTADDRREQ 39 +#define OSF1_EMSGSIZE 40 +#define OSF1_EPROTOTYPE 41 +#define OSF1_ENOPROTOOPT 42 +#define OSF1_EPROTONOSUPPORT 43 +#define OSF1_ESOCKTNOSUPPORT 44 +#define OSF1_EOPNOTSUPP 45 +#define OSF1_EPFNOSUPPORT 46 +#define OSF1_EAFNOSUPPORT 47 +#define OSF1_EADDRINUSE 48 +#define OSF1_EADDRNOTAVAIL 49 +#define OSF1_ENETDOWN 50 +#define OSF1_ENETUNREACH 51 +#define OSF1_ENETRESET 52 +#define OSF1_ECONNABORTED 53 +#define OSF1_ECONNRESET 54 +#define OSF1_ENOBUFS 55 +#define OSF1_EISCONN 56 +#define OSF1_ENOTCONN 57 +#define OSF1_ESHUTDOWN 58 +#define OSF1_ETOOMANYREFS 59 +#define OSF1_ETIMEDOUT 60 +#define OSF1_ECONNREFUSED 61 +#define OSF1_ELOOP 62 +#define OSF1_ENAMETOOLONG 63 +#define OSF1_EHOSTDOWN 64 +#define OSF1_EHOSTUNREACH 65 +#define OSF1_ENOTEMPTY 66 +#define OSF1_EPROCLIM 67 +#define OSF1_EUSERS 68 +#define OSF1_EDQUOT 69 +#define OSF1_ESTALE 70 +#define OSF1_EREMOTE 71 +#define OSF1_EBADRPC 72 +#define OSF1_ERPCMISMATCH 73 +#define OSF1_EPROGUNAVAIL 74 +#define OSF1_EPROGMISMATCH 75 +#define OSF1_EPROCUNAVAIL 76 +#define OSF1_ENOLCK 77 +#define OSF1_ENOSYS 78 +#define OSF1_EFTYPE 79 +#define OSF1_ENOMSG 80 +#define OSF1_EIDRM 81 +#define OSF1_ENOSR 82 +#define OSF1_ETIME 83 +#define OSF1_EBADMSG 84 +#define OSF1_EPROTO 85 +#define OSF1_ENODATA 86 +#define OSF1_ENOSTR 87 +#define OSF1_ECLONEME 88 +#define OSF1_EDIRTY 89 +#define OSF1_EDUPPKG 90 +#define OSF1_EVERSION 91 +#define OSF1_ENOPKG 92 +#define OSF1_ENOSYM 93 +#define OSF1_ECANCELED 94 +#define OSF1_EFAIL 95 +#define OSF1_EINPROG 97 +#define OSF1_EMTIMERS 98 +#define OSF1_ENOTSUP 99 +#define OSF1_EAIO 100 +#define OSF1_EMULTIHOP 101 +#define OSF1_ENOLINK 102 +#define OSF1_EOVERFLOW 103 +#define OSF1_EILSEQ 116 +#define OSF1_ESOFT 123 +#define OSF1_EMEDIA 124 + +#endif /* _COMPAT_OSF1_OSF1_ERRNO_H_ */ diff --git a/sys/compat/osf1/osf1_exec.c b/sys/compat/osf1/osf1_exec.c new file mode 100644 index 00000000000..036c36cc3f1 --- /dev/null +++ b/sys/compat/osf1/osf1_exec.c @@ -0,0 +1,352 @@ +/* $OpenBSD: osf1_exec.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD$ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/proc.h> +#include <sys/malloc.h> +#include <sys/namei.h> +#include <sys/vnode.h> +#include <sys/mount.h> +#include <sys/exec.h> +#include <sys/exec_ecoff.h> +#include <sys/signalvar.h> +#include <sys/fcntl.h> +#include <sys/stat.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscall.h> +#include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> + +extern int scdebug; +extern char *osf1_syscallnames[]; + + +struct osf1_exec_emul_arg { + int flags; +#define OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER 0x01 + + char exec_name[MAXPATHLEN+1]; + char loader_name[MAXPATHLEN+1]; +}; + +#if 0 +static void *osf1_copyargs(struct exec_package *pack, + struct ps_strings *arginfo, void *stack, void *argp); + +#define MAX_AUX_ENTRIES 4 /* max we'll ever push (right now) */ +#endif + +extern struct sysent osf1_sysent[]; +extern void cpu_exec_ecoff_setregs __P((struct proc *, struct exec_package *, + u_long, register_t *)); +extern char sigcode[], esigcode[]; + +struct emul emul_osf1 = { + "osf1", + NULL, + sendsig, + OSF1_SYS_syscall, + OSF1_SYS_MAXSYSCALL, + osf1_sysent, +#ifdef SYSCALL_DEBUG + osf1_syscallnames, +#else + NULL, +#endif + 0, + copyargs, + cpu_exec_ecoff_setregs, + NULL, + sigcode, + esigcode, +}; + +#if 0 +int +osf1_exec_ecoff_hook(struct proc *p, struct exec_package *epp) +{ + struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr; + struct osf1_exec_emul_arg *emul_arg; + int error; + + /* if we're here and we're exec-able at all, we're an OSF/1 binary */ + epp->ep_emul = &emul_osf1; + + /* set up the exec package emul arg as appropriate */ + emul_arg = malloc(sizeof *emul_arg, M_TEMP, M_WAITOK); + epp->ep_emul_arg = emul_arg; + + emul_arg->flags = 0; + if (epp->ep_ndp->ni_segflg == UIO_SYSSPACE) + error = copystr(epp->ep_ndp->ni_dirp, emul_arg->exec_name, + MAXPATHLEN + 1, NULL); + else + error = copyinstr(epp->ep_ndp->ni_dirp, emul_arg->exec_name, + MAXPATHLEN + 1, NULL); +#ifdef DIAGNOSTIC + if (error != 0) + panic("osf1_exec_ecoff_hook: copyinstr failed"); +#endif + + /* do any special object file handling */ + switch (execp->f.f_flags & ECOFF_FLAG_OBJECT_TYPE_MASK) { + case ECOFF_OBJECT_TYPE_SHARABLE: + /* can't exec a shared library! */ +#if 0 + uprintf("can't execute OSF/1 shared libraries\n"); +#endif + error = ENOEXEC; + break; + + case ECOFF_OBJECT_TYPE_CALL_SHARED: + error = osf1_exec_ecoff_dynamic(p, epp); + break; + + default: + /* just let the normal ECOFF handlers deal with it. */ + error = 0; + break; + } + + if (error) { + free(epp->ep_emul_arg, M_TEMP); + epp->ep_emul_arg = NULL; + kill_vmcmds(&epp->ep_vmcmds); /* if any */ + } + + return (error); +} + +/* + * copy arguments onto the stack in the normal way, then copy out + * any ELF-like AUX entries used by the dynamic loading scheme. + */ +static void * +osf1_copyargs(pack, arginfo, stack, argp) + struct exec_package *pack; + struct ps_strings *arginfo; + void *stack; + void *argp; +{ + struct proc *p = curproc; /* XXX !!! */ + struct osf1_exec_emul_arg *emul_arg = pack->ep_emul_arg; + struct osf1_auxv ai[MAX_AUX_ENTRIES], *a; + char *prognameloc, *loadernameloc; + size_t len; + + stack = copyargs(pack, arginfo, stack, argp); + if (!stack) + goto bad; + + a = ai; + memset(ai, 0, sizeof ai); + + prognameloc = (char *)stack + sizeof ai; + if (copyoutstr(emul_arg->exec_name, prognameloc, MAXPATHLEN + 1, NULL)) + goto bad; + a->a_type = OSF1_AT_EXEC_FILENAME; + a->a_un.a_ptr = prognameloc; + a++; + + /* + * if there's a loader, push additional auxv entries on the stack. + */ + if (emul_arg->flags & OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER) { + + loadernameloc = prognameloc + MAXPATHLEN + 1; + if (copyoutstr(emul_arg->loader_name, loadernameloc, + MAXPATHLEN + 1, NULL)) + goto bad; + a->a_type = OSF1_AT_EXEC_LOADER_FILENAME; + a->a_un.a_ptr = loadernameloc; + a++; + + a->a_type = OSF1_AT_EXEC_LOADER_FLAGS; + a->a_un.a_val = 0; + if (pack->ep_vap->va_mode & S_ISUID) + a->a_un.a_val |= OSF1_LDR_EXEC_SETUID_F; + if (pack->ep_vap->va_mode & S_ISGID) + a->a_un.a_val |= OSF1_LDR_EXEC_SETGID_F; + if (p->p_flag & P_TRACED) + a->a_un.a_val |= OSF1_LDR_EXEC_PTRACE_F; + a++; + } + + a->a_type = OSF1_AT_NULL; + a->a_un.a_val = 0; + a++; + + len = (a - ai) * sizeof(struct osf1_auxv); + if (copyout(ai, stack, len)) + goto bad; + stack = (caddr_t)stack + len; + +out: + free(pack->ep_emul_arg, M_TEMP); + pack->ep_emul_arg = NULL; + return stack; + +bad: + stack = NULL; + goto out; +} + +static int +osf1_exec_ecoff_dynamic(struct proc *p, struct exec_package *epp) +{ + struct osf1_exec_emul_arg *emul_arg = epp->ep_emul_arg; + struct ecoff_exechdr ldr_exechdr; + struct nameidata nd; + struct vnode *ldr_vp; + const char *pathbuf; + size_t resid; + int error; + + /* + * locate the loader + */ + error = emul_find(p, NULL, osf1_emul_path, + OSF1_LDR_EXEC_DEFAULT_LOADER, &pathbuf, 0); + /* includes /emul/osf1 if appropriate */ + strncpy(emul_arg->loader_name, pathbuf, MAXPATHLEN + 1); + emul_arg->flags |= OSF1_EXEC_EMUL_FLAGS_HAVE_LOADER; + if (!error) + free((char *)pathbuf, M_TEMP); + +#if 0 + uprintf("loader is %s\n", emul_arg->loader_name); +#endif + + /* + * open the loader, see if it's an ECOFF executable, + * make sure the object type is amenable, then arrange to + * load it up. + */ + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, + emul_arg->loader_name, p); + if ((error = namei(&nd)) != 0) + goto bad_no_vp; + ldr_vp = nd.ni_vp; + + /* + * Basic access checks. Reject if: + * not a regular file + * exec not allowed on binary + * exec not allowed on mount point + */ + if (ldr_vp->v_type != VREG) { + error = EACCES; + goto badunlock; + } + + if ((error = VOP_ACCESS(ldr_vp, VEXEC, p->p_ucred, p)) != 0) + goto badunlock; + + if (ldr_vp->v_mount->mnt_flag & MNT_NOEXEC) { + error = EACCES; + goto badunlock; + } + + /* + * If loader's mount point disallows set-id execution, + * disable set-id. + */ + if (ldr_vp->v_mount->mnt_flag & MNT_NOSUID) + epp->ep_vap->va_mode &= ~(S_ISUID | S_ISGID); + + VOP_UNLOCK(ldr_vp, 0); + + /* + * read the header, and make sure we got all of it. + */ + if ((error = vn_rdwr(UIO_READ, ldr_vp, (caddr_t)&ldr_exechdr, + sizeof ldr_exechdr, 0, UIO_SYSSPACE, 0, p->p_ucred, + &resid, p)) != 0) + goto bad; + if (resid != 0) { + error = ENOEXEC; + goto bad; + } + + /* + * Check the magic. We expect it to be the native Alpha ECOFF + * (Digital UNIX) magic number. Also make sure it's not a shared + * lib or dynamically linked executable. + */ + if (ldr_exechdr.f.f_magic != ECOFF_MAGIC_ALPHA) { + error = ENOEXEC; + goto bad; + } + switch (ldr_exechdr.f.f_flags & ECOFF_FLAG_OBJECT_TYPE_MASK) { + case ECOFF_OBJECT_TYPE_SHARABLE: + case ECOFF_OBJECT_TYPE_CALL_SHARED: + /* can't exec shared lib or dynamically linked executable. */ + error = ENOEXEC; + goto bad; + } + + switch (ldr_exechdr.a.magic) { + case ECOFF_OMAGIC: + error = exec_ecoff_prep_omagic(p, epp, &ldr_exechdr, ldr_vp); + break; + case ECOFF_NMAGIC: + error = exec_ecoff_prep_nmagic(p, epp, &ldr_exechdr, ldr_vp); + break; + case ECOFF_ZMAGIC: + error = exec_ecoff_prep_zmagic(p, epp, &ldr_exechdr, ldr_vp); + break; + default: + error = ENOEXEC; + } + if (error) + goto bad; + + /* finally, set up the stack. */ + error = exec_ecoff_setup_stack(p, epp); + if (error) + goto bad; + + vrele(ldr_vp); + return (0); + +badunlock: + VOP_UNLOCK(ldr_vp, 0); +bad: + vrele(ldr_vp); +bad_no_vp: + return (error); +} +#endif diff --git a/sys/compat/osf1/osf1_file.c b/sys/compat/osf1/osf1_file.c new file mode 100644 index 00000000000..23e472e6ff9 --- /dev/null +++ b/sys/compat/osf1/osf1_file.c @@ -0,0 +1,348 @@ +/* $OpenBSD: osf1_file.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_file.c,v 1.6 2000/06/06 19:04:17 soren Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/filedesc.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/signal.h> +#include <sys/signalvar.h> +#include <sys/reboot.h> +#include <sys/syscallargs.h> +#include <sys/exec.h> +#include <sys/vnode.h> +#include <sys/socketvar.h> +#include <sys/resource.h> +#include <sys/resourcevar.h> +#include <sys/wait.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_access(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_access_args *uap = v; + struct sys_access_args a; + unsigned long leftovers; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + SCARG(&a, path) = SCARG(uap, path); + + /* translate flags */ + SCARG(&a, flags) = emul_flags_translate(osf1_access_flags_xtab, + SCARG(uap, flags), &leftovers); + if (leftovers != 0) + return (EINVAL); + + return sys_access(p, &a, retval); +} + +int +osf1_sys_execve(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_execve_args *uap = v; + struct sys_execve_args ap; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + SCARG(&ap, path) = SCARG(uap, path); + SCARG(&ap, argp) = SCARG(uap, argp); + SCARG(&ap, envp) = SCARG(uap, envp); + + return sys_execve(p, &ap, retval); +} + +/* + * Get file status; this version does not follow links. + */ +/* ARGSUSED */ +int +osf1_sys_lstat(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_lstat_args *uap = v; + struct stat sb; + struct osf1_stat osb; + int error; + struct nameidata nd; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, + SCARG(uap, path), p); + if ((error = namei(&nd))) + return (error); + error = vn_stat(nd.ni_vp, &sb, p); + vput(nd.ni_vp); + if (error) + return (error); + osf1_cvt_stat_from_native(&sb, &osb); + error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); + return (error); +} + +int +osf1_sys_mknod(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_mknod_args *uap = v; + struct sys_mknod_args a; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + SCARG(&a, path) = SCARG(uap, path); + SCARG(&a, mode) = SCARG(uap, mode); + SCARG(&a, dev) = osf1_cvt_dev_to_native(SCARG(uap, dev)); + + return sys_mknod(p, &a, retval); +} + +int +osf1_sys_open(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_open_args *uap = v; + struct sys_open_args a; + char *path; + caddr_t sg; + unsigned long leftovers; +#ifdef SYSCALL_DEBUG + char pnbuf[1024]; + + if (scdebug && + copyinstr(SCARG(uap, path), pnbuf, sizeof pnbuf, NULL) == 0) + printf("osf1_open: open: %s\n", pnbuf); +#endif + + sg = stackgap_init(p->p_emul); + + /* translate flags */ + SCARG(&a, flags) = emul_flags_translate(osf1_open_flags_xtab, + SCARG(uap, flags), &leftovers); + if (leftovers != 0) + return (EINVAL); + + /* copy mode, no translation necessary */ + SCARG(&a, mode) = SCARG(uap, mode); + + /* pick appropriate path */ + path = SCARG(uap, path); + if (SCARG(&a, flags) & O_CREAT) + OSF1_CHECK_ALT_CREAT(p, &sg, path); + else + OSF1_CHECK_ALT_EXIST(p, &sg, path); + SCARG(&a, path) = path; + + return sys_open(p, &a, retval); +} + +int +osf1_sys_pathconf(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_pathconf_args *uap = v; + struct sys_pathconf_args a; + caddr_t sg; + int error; + + sg = stackgap_init(p->p_emul); + + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + SCARG(&a, path) = SCARG(uap, path); + + error = osf1_cvt_pathconf_name_to_native(SCARG(uap, name), + &SCARG(&a, name)); + + if (error == 0) + error = sys_pathconf(p, &a, retval); + + return (error); +} + +/* + * Get file status; this version follows links. + */ +/* ARGSUSED */ +int +osf1_sys_stat(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_stat_args *uap = v; + struct stat sb; + struct osf1_stat osb; + int error; + struct nameidata nd; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, + SCARG(uap, path), p); + if ((error = namei(&nd))) + return (error); + error = vn_stat(nd.ni_vp, &sb, p); + vput(nd.ni_vp); + if (error) + return (error); + osf1_cvt_stat_from_native(&sb, &osb); + error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); + return (error); +} + +int +osf1_sys_truncate(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_truncate_args *uap = v; + struct sys_truncate_args a; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + + SCARG(&a, path) = SCARG(uap, path); + SCARG(&a, pad) = 0; + SCARG(&a, length) = SCARG(uap, length); + + return sys_truncate(p, &a, retval); +} + +int +osf1_sys_utimes(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_utimes_args *uap = v; + struct sys_utimes_args a; + struct osf1_timeval otv; + struct timeval tv; + caddr_t sg; + int error; + + sg = stackgap_init(p->p_emul); + + OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); + SCARG(&a, path) = SCARG(uap, path); + + error = 0; + if (SCARG(uap, tptr) == NULL) + SCARG(&a, tptr) = NULL; + else { + SCARG(&a, tptr) = stackgap_alloc(&sg, sizeof tv); + + /* get the OSF/1 timeval argument */ + error = copyin((caddr_t)SCARG(uap, tptr), + (caddr_t)&otv, sizeof otv); + if (error == 0) { + + /* fill in and copy out the NetBSD timeval */ + memset(&tv, 0, sizeof tv); + tv.tv_sec = otv.tv_sec; + tv.tv_usec = otv.tv_usec; + + error = copyout((caddr_t)&tv, + (caddr_t)SCARG(&a, tptr), sizeof tv); + } + } + + if (error == 0) + error = sys_utimes(p, &a, retval); + + return (error); +} diff --git a/sys/compat/osf1/osf1_generic.c b/sys/compat/osf1/osf1_generic.c new file mode 100644 index 00000000000..853608877a5 --- /dev/null +++ b/sys/compat/osf1/osf1_generic.c @@ -0,0 +1,213 @@ +/* $OpenBSD: osf1_generic.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_generic.c,v 1.1 1999/05/01 05:06:46 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/malloc.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <sys/exec.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +/* + * The structures end up being the same... but we can't be sure that + * the other word of our iov_len is zero! + */ +int +osf1_sys_readv(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_readv_args *uap = v; + struct sys_readv_args a; + struct osf1_iovec *oio; + struct iovec *nio; + caddr_t sg = stackgap_init(p->p_emul); + int error, osize, nsize, i; + + if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) + return (EINVAL); + + osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec); + nsize = SCARG(uap, iovcnt) * sizeof (struct iovec); + + oio = malloc(osize, M_TEMP, M_WAITOK); + nio = malloc(nsize, M_TEMP, M_WAITOK); + + error = 0; + if ((error = copyin(SCARG(uap, iovp), oio, osize))) + goto punt; + for (i = 0; i < SCARG(uap, iovcnt); i++) { + nio[i].iov_base = oio[i].iov_base; + nio[i].iov_len = oio[i].iov_len; + } + + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, iovp) = stackgap_alloc(&sg, nsize); + SCARG(&a, iovcnt) = SCARG(uap, iovcnt); + + if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize))) + goto punt; + error = sys_readv(p, &a, retval); + +punt: + free(oio, M_TEMP); + free(nio, M_TEMP); + return (error); +} + +int +osf1_sys_select(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_select_args *uap = v; + struct sys_select_args a; + struct osf1_timeval otv; + struct timeval tv; + int error; + caddr_t sg; + + SCARG(&a, nd) = SCARG(uap, nd); + SCARG(&a, in) = SCARG(uap, in); + SCARG(&a, ou) = SCARG(uap, ou); + SCARG(&a, ex) = SCARG(uap, ex); + + error = 0; + if (SCARG(uap, tv) == NULL) + SCARG(&a, tv) = NULL; + else { + sg = stackgap_init(p->p_emul); + SCARG(&a, tv) = stackgap_alloc(&sg, sizeof tv); + + /* get the OSF/1 timeval argument */ + error = copyin((caddr_t)SCARG(uap, tv), + (caddr_t)&otv, sizeof otv); + if (error == 0) { + + /* fill in and copy out the NetBSD timeval */ + memset(&tv, 0, sizeof tv); + tv.tv_sec = otv.tv_sec; + tv.tv_usec = otv.tv_usec; + + error = copyout((caddr_t)&tv, + (caddr_t)SCARG(&a, tv), sizeof tv); + } + } + + if (error == 0) + error = sys_select(p, &a, retval); + + return (error); +} + +int +osf1_sys_writev(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_writev_args *uap = v; + struct sys_writev_args a; + struct osf1_iovec *oio; + struct iovec *nio; + caddr_t sg = stackgap_init(p->p_emul); + int error, osize, nsize, i; + + if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) + return (EINVAL); + + osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec); + nsize = SCARG(uap, iovcnt) * sizeof (struct iovec); + + oio = malloc(osize, M_TEMP, M_WAITOK); + nio = malloc(nsize, M_TEMP, M_WAITOK); + + error = 0; + if ((error = copyin(SCARG(uap, iovp), oio, osize))) + goto punt; + for (i = 0; i < SCARG(uap, iovcnt); i++) { + nio[i].iov_base = oio[i].iov_base; + nio[i].iov_len = oio[i].iov_len; + } + + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, iovp) = stackgap_alloc(&sg, nsize); + SCARG(&a, iovcnt) = SCARG(uap, iovcnt); + + if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize))) + goto punt; + error = sys_writev(p, &a, retval); + +punt: + free(oio, M_TEMP); + free(nio, M_TEMP); + return (error); +} diff --git a/sys/compat/osf1/osf1_ioctl.c b/sys/compat/osf1/osf1_ioctl.c index 8ad73d211a3..cba166475c5 100644 --- a/sys/compat/osf1/osf1_ioctl.c +++ b/sys/compat/osf1/osf1_ioctl.c @@ -1,5 +1,35 @@ -/* $OpenBSD: osf1_ioctl.c,v 1.2 1996/08/02 20:35:26 niklas Exp $ */ -/* $NetBSD: osf1_ioctl.c,v 1.3 1995/10/07 06:27:19 mycroft Exp $ */ +/* $OpenBSD: osf1_ioctl.c,v 1.3 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_ioctl.c,v 1.11 1999/05/05 01:51:33 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ /* * Copyright (c) 1994, 1995 Carnegie-Mellon University. @@ -32,31 +62,21 @@ #include <sys/systm.h> #include <sys/ioctl.h> #include <sys/termios.h> - #include <sys/mount.h> #include <sys/syscallargs.h> + +#include <compat/osf1/osf1.h> #include <compat/osf1/osf1_syscallargs.h> #ifdef SYSCALL_DEBUG extern int scdebug; #endif -#define OSF1_IOCPARM_MASK 0x1fff /* parameter length, at most 13 bits */ -#define OSF1_IOCPARM_LEN(x) (((x) >> 16) & OSF1_IOCPARM_MASK) -#define OSF1_IOCGROUP(x) (((x) >> 8) & 0xff) - -#define OSF1_IOCPARM_MAX NBPG /* max size of ioctl */ -#define OSF1_IOC_VOID 0x20000000 /* no parameters */ -#define OSF1_IOC_OUT 0x40000000 /* copy out parameters */ -#define OSF1_IOC_IN 0x80000000 /* copy in parameters */ -#define OSF1_IOC_INOUT (OSF1_IOC_IN|OSF1_IOC_OUT) -#define OSF1_IOC_DIRMASK 0xe0000000 /* mask for IN/OUT/VOID */ - -#define OSF1_IOCCMD(x) ((x) & 0xff) - -int osf1_ioctl_i __P((struct proc *p, struct sys_ioctl_args *nuap, +static int osf1_ioctl_f __P((struct proc *p, struct sys_ioctl_args *nuap, register_t *retval, int cmd, int dir, int len)); -int osf1_ioctl_t __P((struct proc *p, struct sys_ioctl_args *nuap, +static int osf1_ioctl_i __P((struct proc *p, struct sys_ioctl_args *nuap, + register_t *retval, int cmd, int dir, int len)); +static int osf1_ioctl_t __P((struct proc *p, struct sys_ioctl_args *nuap, register_t *retval, int cmd, int dir, int len)); int @@ -65,16 +85,8 @@ osf1_sys_ioctl(p, v, retval) void *v; register_t *retval; { - struct osf1_sys_ioctl_args /* { - syscallarg(int) fd; - syscallarg(int) com; - syscallarg(caddr_t) data; - } */ *uap = v; - struct sys_ioctl_args /* { - syscallarg(int) fd; - syscallarg(u_long) com; - syscallarg(caddr_t) data; - } */ a; + struct osf1_sys_ioctl_args *uap = v; + struct sys_ioctl_args a; int op, dir, group, cmd, len; #ifdef SYSCALL_DEBUG char *dirstr; @@ -123,9 +135,11 @@ osf1_sys_ioctl(p, v, retval) #endif SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, com) = SCARG(uap, com); + SCARG(&a, com) = SCARG(uap, com) & 0xffffffff; /* XXX */ SCARG(&a, data) = SCARG(uap, data); switch (group) { + case 'f': + return osf1_ioctl_f(p, &a, retval, cmd, dir, len); case 'i': return osf1_ioctl_i(p, &a, retval, cmd, dir, len); case 't': @@ -135,14 +149,38 @@ osf1_sys_ioctl(p, v, retval) } } -int +static int +osf1_ioctl_f(p, uap, retval, cmd, dir, len) + struct proc *p; + struct sys_ioctl_args *uap; + register_t *retval; + int cmd; + int dir; + int len; +{ + + switch (cmd) { + case 1: /* OSF/1 FIOCLEX */ + case 2: /* OSF/1 FIONCLEX */ + case 123: /* OSF/1 FIOGETOWN */ + case 124: /* OSF/1 FIOSETOWN */ + case 125: /* OSF/1 FIOASYNC */ + case 126: /* OSF/1 FIONBIO */ + case 127: /* OSF/1 FIONREAD */ + /* same as in NetBSD */ + break; + + default: + return (ENOTTY); + } + + return sys_ioctl(p, uap, retval); +} + +static int osf1_ioctl_i(p, uap, retval, cmd, dir, len) struct proc *p; - struct sys_ioctl_args /* { - syscallarg(int) fd; - syscallarg(int) com; - syscallarg(caddr_t) data; - } */ *uap; + struct sys_ioctl_args *uap; register_t *retval; int cmd; int dir; @@ -173,14 +211,10 @@ osf1_ioctl_i(p, uap, retval, cmd, dir, len) return sys_ioctl(p, uap, retval); } -int +static int osf1_ioctl_t(p, uap, retval, cmd, dir, len) struct proc *p; - struct sys_ioctl_args /* { - syscallarg(int) fd; - syscallarg(int) com; - syscallarg(caddr_t) data; - } */ *uap; + struct sys_ioctl_args *uap; register_t *retval; int cmd; int dir; diff --git a/sys/compat/osf1/osf1_misc.c b/sys/compat/osf1/osf1_misc.c index 272308b3272..0800adcce1b 100644 --- a/sys/compat/osf1/osf1_misc.c +++ b/sys/compat/osf1/osf1_misc.c @@ -1,5 +1,35 @@ -/* $OpenBSD: osf1_misc.c,v 1.11 1999/11/10 15:55:23 mickey Exp $ */ -/* $NetBSD: osf1_misc.c,v 1.7 1995/10/07 06:53:04 mycroft Exp $ */ +/* $OpenBSD: osf1_misc.c,v 1.12 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_misc.c,v 1.55 2000/06/28 15:39:33 mrg Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ /* * Copyright (c) 1994, 1995 Carnegie-Mellon University. @@ -41,949 +71,282 @@ #include <sys/mount.h> #include <sys/signal.h> #include <sys/signalvar.h> -#include <sys/socketvar.h> #include <sys/reboot.h> #include <sys/syscallargs.h> +#include <sys/exec.h> #include <sys/vnode.h> +#include <sys/socketvar.h> +#include <sys/resource.h> +#include <sys/resourcevar.h> +#include <sys/wait.h> -#include <compat/osf1/osf1_syscall.h> +#include <compat/osf1/osf1.h> #include <compat/osf1/osf1_syscallargs.h> #include <compat/osf1/osf1_util.h> - -#include <vm/vm.h> +#include <compat/osf1/osf1_cvt.h> #ifdef SYSCALL_DEBUG extern int scdebug; -extern char *osf1_syscallnames[]; -#endif - -extern struct sysent osf1_sysent[]; -extern void cpu_exec_ecoff_setregs __P((struct proc *, struct exec_package *, - u_long, register_t *)); - -extern char sigcode[], esigcode[]; - -void cvtstat2osf1 __P((struct stat *, struct osf1_stat *)); - -struct emul emul_osf1 = { - "osf1", - NULL, - sendsig, - OSF1_SYS_syscall, - OSF1_SYS_MAXSYSCALL, - osf1_sysent, -#ifdef SYSCALL_DEBUG - osf1_syscallnames, -#else - NULL, -#endif - 0, - copyargs, - cpu_exec_ecoff_setregs, - NULL, - sigcode, - esigcode, -}; - -int -osf1_sys_open(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_open_args /* { - syscallarg(char *) path; - syscallarg(int) flags; - syscallarg(int) mode; - } */ *uap = v; - struct sys_open_args /* { - syscallarg(char *) path; - syscallarg(int) flags; - syscallarg(int) mode; - } */ a; -#ifdef SYSCALL_DEBUG - char pnbuf[1024]; - - if (scdebug && - copyinstr(SCARG(uap, path), pnbuf, sizeof pnbuf, NULL) == 0) - printf("osf1_open: open: %s\n", pnbuf); #endif - SCARG(&a, path) = SCARG(uap, path); - SCARG(&a, flags) = SCARG(uap, flags); /* XXX translate */ - SCARG(&a, mode) = SCARG(uap, mode); - - return sys_open(p, &a, retval); -} +const char osf1_emul_path[] = "/emul/osf1"; int -osf1_sys_setsysinfo(p, v, retval) +osf1_sys_classcntl(p, v, retval) struct proc *p; void *v; register_t *retval; { -#if 0 - struct osf1_setsysinfo_args /* { - syscallarg(u_long) op; - syscallarg(caddr_t) buffer; - syscallarg(u_long) nbytes; - syscallarg(caddr_t) arg; - syscallarg(u_long) flag; - } */ *uap = v; -#endif; - return (0); + /* XXX */ + return (ENOSYS); } -#define OSF1_RLIMIT_LASTCOMMON 5 /* last one that's common */ -#define OSF1_RLIMIT_NOFILE 6 /* OSF1's RLIMIT_NOFILE */ -#define OSF1_RLIMIT_NLIMITS 8 /* Number of OSF1 rlimits */ - int -osf1_sys_getrlimit(p, v, retval) +osf1_sys_reboot(p, v, retval) struct proc *p; void *v; register_t *retval; { - struct osf1_sys_getrlimit_args /* { - syscallarg(u_int) which; - syscallarg(struct rlimit *) rlp; - } */ *uap = v; - struct sys_getrlimit_args /* { - syscallarg(u_int) which; - syscallarg(struct rlimit *) rlp; - } */ a; - - if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS) - return (EINVAL); - - if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON) - SCARG(&a, which) = SCARG(uap, which); - else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE) - SCARG(&a, which) = RLIMIT_NOFILE; - else - return (0); - SCARG(&a, rlp) = SCARG(uap, rlp); - - return sys_getrlimit(p, &a, retval); -} + struct osf1_sys_reboot_args *uap = v; + struct sys_reboot_args a; + unsigned long leftovers; -int -osf1_sys_setrlimit(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_setrlimit_args /* { - syscallarg(u_int) which; - syscallarg(struct rlimit *) rlp; - } */ *uap = v; - struct sys_setrlimit_args /* { - syscallarg(u_int) which; - syscallarg(struct rlimit *) rlp; - } */ a; - - if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS) + /* translate opt */ + SCARG(&a, opt) = emul_flags_translate(osf1_reboot_opt_xtab, + SCARG(uap, opt), &leftovers); + if (leftovers != 0) return (EINVAL); - if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON) - SCARG(&a, which) = SCARG(uap, which); - else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE) - SCARG(&a, which) = RLIMIT_NOFILE; - else - return (0); - SCARG(&a, rlp) = SCARG(uap, rlp); - - return sys_setrlimit(p, &a, retval); -} - -#define OSF1_MAP_SHARED 0x001 -#define OSF1_MAP_PRIVATE 0x002 -#define OSF1_MAP_ANONYMOUS 0x010 -#define OSF1_MAP_FILE 0x000 -#define OSF1_MAP_TYPE 0x0f0 -#define OSF1_MAP_FIXED 0x100 -#define OSF1_MAP_HASSEMAPHORE 0x200 -#define OSF1_MAP_INHERIT 0x400 -#define OSF1_MAP_UNALIGNED 0x800 - -int -osf1_sys_mmap(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_mmap_args /* { - syscallarg(caddr_t) addr; - syscallarg(size_t) len; - syscallarg(int) prot; - syscallarg(int) flags; - syscallarg(int) fd; - syscallarg(off_t) pos; - } */ *uap = v; - struct sys_mmap_args /* { - syscallarg(caddr_t) addr; - syscallarg(size_t) len; - syscallarg(int) prot; - syscallarg(int) flags; - syscallarg(int) fd; - syscallarg(long) pad; - syscallarg(off_t) pos; - } */ a; - - SCARG(&a, addr) = SCARG(uap, addr); - SCARG(&a, len) = SCARG(uap, len); - SCARG(&a, prot) = SCARG(uap, prot); - SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, pad) = 0; - SCARG(&a, pos) = SCARG(uap, pos); - - SCARG(&a, flags) = 0; - if (SCARG(uap, flags) & OSF1_MAP_SHARED) - SCARG(&a, flags) |= MAP_SHARED; - if (SCARG(uap, flags) & OSF1_MAP_PRIVATE) - SCARG(&a, flags) |= MAP_PRIVATE; - switch (SCARG(uap, flags) & OSF1_MAP_TYPE) { - case OSF1_MAP_ANONYMOUS: - SCARG(&a, flags) |= MAP_ANON; - break; - case OSF1_MAP_FILE: - SCARG(&a, flags) |= MAP_FILE; - break; - default: - return (EINVAL); - } - if (SCARG(uap, flags) & OSF1_MAP_FIXED) - SCARG(&a, flags) |= MAP_FIXED; - if (SCARG(uap, flags) & OSF1_MAP_HASSEMAPHORE) - SCARG(&a, flags) |= MAP_HASSEMAPHORE; - if (SCARG(uap, flags) & OSF1_MAP_INHERIT) - SCARG(&a, flags) |= MAP_INHERIT; - if (SCARG(uap, flags) & OSF1_MAP_UNALIGNED) - return (EINVAL); + /* SCARG(&a, bootstr) = NULL; */ - return sys_mmap(p, &a, retval); + return sys_reboot(p, &a, retval); } int -osf1_sys_usleep_thread(p, v, retval) +osf1_sys_set_program_attributes(p, v, retval) struct proc *p; void *v; register_t *retval; { - struct osf1_sys_usleep_thread_args /* { - syscallarg(struct timeval *) sleep; - syscallarg(struct timeval *) slept; - } */ *uap = v; - struct timeval tv, endtv; - u_long ticks; - int error, s; - - if ((error = copyin(SCARG(uap, sleep), &tv, sizeof tv)) != 0) - return (error); + struct osf1_sys_set_program_attributes_args *uap = v; + segsz_t tsize, dsize; - ticks = ((u_long)tv.tv_sec * 1000000 + tv.tv_usec) / tick; - s = splclock(); - tv = time; - splx(s); + tsize = btoc(SCARG(uap, tsize)); + dsize = btoc(SCARG(uap, dsize)); - tsleep(p, PUSER|PCATCH, "OSF/1", ticks); /* XXX */ + if (dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur) + return (ENOMEM); + if (tsize > MAXTSIZ) + return (ENOMEM); - if (SCARG(uap, slept) != NULL) { - s = splclock(); - timersub(&time, &tv, &endtv); - splx(s); - if (tv.tv_sec < 0 || tv.tv_usec < 0) - tv.tv_sec = tv.tv_usec = 0; + p->p_vmspace->vm_taddr = SCARG(uap, taddr); + p->p_vmspace->vm_tsize = tsize; + p->p_vmspace->vm_daddr = SCARG(uap, daddr); + p->p_vmspace->vm_dsize = dsize; - error = copyout(&endtv, SCARG(uap, slept), sizeof endtv); - } - return (error); -} - -struct osf1_stat { - int32_t st_dev; - u_int32_t st_ino; - u_int32_t st_mode; - u_int16_t st_nlink; - u_int32_t st_uid; - u_int32_t st_gid; - int32_t st_rdev; - u_int64_t st_size; - int32_t st_atime_sec; - int32_t st_spare1; - int32_t st_mtime_sec; - int32_t st_spare2; - int32_t st_ctime_sec; - int32_t st_spare3; - u_int32_t st_blksize; - int32_t st_blocks; - u_int32_t st_flags; - u_int32_t st_gen; -}; - -/* - * Get file status; this version follows links. - */ -/* ARGSUSED */ -int -osf1_sys_stat(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - register struct osf1_sys_stat_args /* { - syscallarg(char *) path; - syscallarg(struct osf1_stat *) ub; - } */ *uap = v; - struct stat sb; - struct osf1_stat osb; - int error; - struct nameidata nd; - - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = namei(&nd)) != 0) - return (error); - error = vn_stat(nd.ni_vp, &sb, p); - vput(nd.ni_vp); - if (error) - return (error); - cvtstat2osf1(&sb, &osb); - error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); - return (error); + return (0); } -/* - * Get file status; this version does not follow links. - */ -/* ARGSUSED */ int -osf1_sys_lstat(p, v, retval) +osf1_sys_setsysinfo(p, v, retval) struct proc *p; void *v; register_t *retval; { - register struct osf1_sys_lstat_args /* { - syscallarg(char *) path; - syscallarg(struct osf1_stat *) ub; - } */ *uap = v; - struct stat sb; - struct osf1_stat osb; - int error; - struct nameidata nd; - NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = namei(&nd)) != 0) - return (error); - error = vn_stat(nd.ni_vp, &sb, p); - vput(nd.ni_vp); - if (error) - return (error); - cvtstat2osf1(&sb, &osb); - error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); - return (error); + /* XXX */ + return (0); } -/* - * Return status information about a file descriptor. - */ int -osf1_sys_fstat(p, v, retval) +osf1_sys_sysinfo(p, v, retval) struct proc *p; void *v; register_t *retval; { - register struct osf1_sys_fstat_args /* { - syscallarg(int) fd; - syscallarg(struct osf1_stat *) sb; - } */ *uap = v; - register struct filedesc *fdp = p->p_fd; - register struct file *fp; - struct stat ub; - struct osf1_stat oub; + struct osf1_sys_sysinfo_args *uap = v; + const char *string; int error; - if ((unsigned)SCARG(uap, fd) >= fdp->fd_nfiles || - (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) - return (EBADF); - switch (fp->f_type) { - - case DTYPE_VNODE: - error = vn_stat((struct vnode *)fp->f_data, &ub, p); + error = 0; + switch (SCARG(uap, cmd)) { + case OSF1_SI_SYSNAME: + goto should_handle; + /* string = ostype; */ break; - case DTYPE_SOCKET: - error = soo_stat((struct socket *)fp->f_data, &ub); + case OSF1_SI_HOSTNAME: + string = hostname; break; - default: - panic("ofstat"); - /*NOTREACHED*/ - } - cvtstat2osf1(&ub, &oub); - if (error == 0) - error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb), - sizeof (oub)); - return (error); -} - -#define bsd2osf_dev(dev) (major(dev) << 20 | minor(dev)) -#define osf2bsd_dev(dev) makedev((dev >> 20) & 0xfff, dev & 0xfffff) - -/* - * Convert from a stat structure to an osf1 stat structure. - */ -void -cvtstat2osf1(st, ost) - struct stat *st; - struct osf1_stat *ost; -{ - - ost->st_dev = bsd2osf_dev(st->st_dev); - ost->st_ino = st->st_ino; - ost->st_mode = st->st_mode; - ost->st_nlink = st->st_nlink; - ost->st_uid = st->st_uid == -2 ? (u_int16_t) -2 : st->st_uid; - ost->st_gid = st->st_gid == -2 ? (u_int16_t) -2 : st->st_gid; - ost->st_rdev = bsd2osf_dev(st->st_rdev); - ost->st_size = st->st_size; - ost->st_atime_sec = st->st_atime; - ost->st_spare1 = 0; - ost->st_mtime_sec = st->st_mtime; - ost->st_spare2 = 0; - ost->st_ctime_sec = st->st_ctime; - ost->st_spare3 = 0; - ost->st_blksize = st->st_blksize; - ost->st_blocks = st->st_blocks; - ost->st_flags = st->st_flags; - ost->st_gen = st->st_gen; -} - -int -osf1_sys_mknod(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_mknod_args /* { - syscallarg(char *) path; - syscallarg(int) mode; - syscallarg(int) dev; - } */ *uap = v; - struct sys_mknod_args a; - - SCARG(&a, path) = SCARG(uap, path); - SCARG(&a, mode) = SCARG(uap, mode); - SCARG(&a, dev) = osf2bsd_dev(SCARG(uap, dev)); - - return sys_mknod(p, &a, retval); -} - -#define OSF1_F_DUPFD 0 -#define OSF1_F_GETFD 1 -#define OSF1_F_SETFD 2 -#define OSF1_F_GETFL 3 -#define OSF1_F_SETFL 4 - -#define OSF1_FAPPEND 0x00008 /* XXX OSF1_O_APPEND */ -#define OSF1_FNONBLOCK 0x00004 /* XXX OSF1_O_NONBLOCK */ -#define OSF1_FASYNC 0x00040 -#define OSF1_FSYNC 0x04000 /* XXX OSF1_O_SYNC */ - -int -osf1_sys_fcntl(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_fcntl_args /* { - syscallarg(int) fd; - syscallarg(int) cmd; - syscallarg(void *) arg; - } */ *uap = v; - struct sys_fcntl_args a; - long tmp; - int error; + case OSF1_SI_RELEASE: + string = version; + break; - SCARG(&a, fd) = SCARG(uap, fd); + case OSF1_SI_VERSION: + goto should_handle; - switch (SCARG(uap, cmd)) { - case OSF1_F_DUPFD: - SCARG(&a, cmd) = F_DUPFD; - SCARG(&a, arg) = SCARG(uap, arg); + case OSF1_SI_MACHINE: + string = MACHINE; break; - case OSF1_F_GETFD: - SCARG(&a, cmd) = F_GETFD; - SCARG(&a, arg) = SCARG(uap, arg); + case OSF1_SI_ARCHITECTURE: + string = MACHINE_ARCH; break; - case OSF1_F_SETFD: - SCARG(&a, cmd) = F_SETFD; - SCARG(&a, arg) = SCARG(uap, arg); + case OSF1_SI_HW_SERIAL: + string = "666"; /* OSF/1 emulation? YES! */ break; - case OSF1_F_GETFL: - SCARG(&a, cmd) = F_GETFL; - SCARG(&a, arg) = SCARG(uap, arg); /* ignored */ + case OSF1_SI_HW_PROVIDER: + string = "unknown"; break; - case OSF1_F_SETFL: - SCARG(&a, cmd) = F_SETFL; - tmp = 0; - if ((long)SCARG(uap, arg) & OSF1_FAPPEND) - tmp |= FAPPEND; - if ((long)SCARG(uap, arg) & OSF1_FNONBLOCK) - tmp |= FNONBLOCK; - if ((long)SCARG(uap, arg) & OSF1_FASYNC) - tmp |= FASYNC; - if ((long)SCARG(uap, arg) & OSF1_FSYNC) - tmp |= FFSYNC; - SCARG(&a, arg) = (void *)tmp; - break; + case OSF1_SI_SRPC_DOMAIN: + goto dont_care; - default: /* XXX other cases */ - return (EINVAL); - } + case OSF1_SI_SET_HOSTNAME: + goto should_handle; - error = sys_fcntl(p, &a, retval); + case OSF1_SI_SET_SYSNAME: + goto should_handle; - if (error) - return error; + case OSF1_SI_SET_SRPC_DOMAIN: + goto dont_care; - switch (SCARG(uap, cmd)) { - case OSF1_F_GETFL: - /* XXX */ + default: +should_handle: + printf("osf1_sys_sysinfo(%d, %p, 0x%lx)\n", SCARG(uap, cmd), + SCARG(uap, buf), SCARG(uap,len)); +dont_care: + error = EINVAL; break; - } - - return error; -} + }; -int -osf1_sys_poll(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - register struct osf1_sys_poll_args /* { - syscallarg(struct pollfd *) fds; - syscallarg(unsigned int) nfds; - syscallarg(int) timeout; - } */ *uap = v; - struct sys_poll_args a; - - SCARG(&a, fds) = SCARG(uap, fds); - SCARG(&a, nfds) = SCARG(uap, nfds); - SCARG(&a, timeout) = SCARG(uap, timeout); - - return sys_poll(p, &a, retval); -} - -int -osf1_sys_socket(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - register struct osf1_sys_socket_args /* { - syscallarg(int) domain; - syscallarg(int) type; - syscallarg(int) protocol; - } */ *uap = v; - struct sys_socket_args a; - - if (SCARG(uap, type) > AF_LINK) - return (EINVAL); /* XXX After AF_LINK, divergence. */ - - SCARG(&a, domain) = SCARG(uap, domain); - SCARG(&a, type) = SCARG(uap, type); - SCARG(&a, protocol) = SCARG(uap, protocol); + if (error == 0) + error = copyoutstr(string, SCARG(uap, buf), SCARG(uap, len), + NULL); - return sys_socket(p, &a, retval); + return (error); } int -osf1_sys_sendto(p, v, retval) +osf1_sys_uname(p, v, retval) struct proc *p; void *v; register_t *retval; { - register struct osf1_sys_sendto_args /* { - syscallarg(int) s; - syscallarg(const void *) buf; - syscallarg(size_t) len; - syscallarg(int) flags; - syscallarg(const struct sockaddr *) to; - syscallarg(int) tolen; - } */ *uap = v; - struct sys_sendto_args a; - - if (SCARG(uap, flags) & ~0x7f) /* unsupported flags */ - return (EINVAL); - - SCARG(&a, s) = SCARG(uap, s); - SCARG(&a, buf) = SCARG(uap, buf); - SCARG(&a, len) = SCARG(uap, len); - SCARG(&a, flags) = SCARG(uap, flags); - SCARG(&a, to) = SCARG(uap, to); - SCARG(&a, tolen) = SCARG(uap, tolen); - - return sys_sendto(p, &a, retval); + struct osf1_sys_uname_args *uap = v; + struct osf1_utsname u; + const char *cp; + char *dp, *ep; + + /* XXX would use stackgap, but our struct utsname is too big! */ + /* + * strncpy(u.sysname, ostype, sizeof(u.sysname)); + */ + strncpy(u.sysname, "OpenBSD", sizeof(u.sysname)); + strncpy(u.nodename, hostname, sizeof(u.nodename)); + strncpy(u.release, version, sizeof(u.release)); + dp = u.version; + ep = &u.version[sizeof(u.version) - 1]; + for (cp = version; *cp && *cp != '('; cp++) + ; + for (cp++; *cp && *cp != ')' && dp < ep; cp++) + *dp++ = *cp; + for (; *cp && *cp != '#'; cp++) + ; + for (; *cp && *cp != ':' && dp < ep; cp++) + *dp++ = *cp; + *dp = '\0'; + strncpy(u.machine, MACHINE, sizeof(u.machine)); + return (copyout((caddr_t)&u, (caddr_t)SCARG(uap, name), sizeof u)); } -#define OSF1_RB_ASKNAME 0x001 -#define OSF1_RB_SINGLE 0x002 -#define OSF1_RB_NOSYNC 0x004 -#define OSF1_RB_HALT 0x008 -#define OSF1_RB_INITNAME 0x010 -#define OSF1_RB_DFLTROOT 0x020 -#define OSF1_RB_ALTBOOT 0x040 -#define OSF1_RB_UNIPROC 0x080 -#define OSF1_RB_ALLFLAGS 0x0ff /* all of the above */ - int -osf1_sys_reboot(p, v, retval) +osf1_sys_usleep_thread(p, v, retval) struct proc *p; void *v; register_t *retval; { - struct osf1_sys_reboot_args /* { - syscallarg(int) opt; - } */ *uap = v; - struct sys_reboot_args a; + struct osf1_sys_usleep_thread_args *uap = v; + struct osf1_timeval otv, endotv; + struct timeval tv, endtv; + u_long ticks; + int error, s; - if (SCARG(uap, opt) & ~OSF1_RB_ALLFLAGS && - SCARG(uap, opt) & (OSF1_RB_ALTBOOT|OSF1_RB_UNIPROC)) - return (EINVAL); + if ((error = copyin(SCARG(uap, sleep), &otv, sizeof otv))) + return (error); + tv.tv_sec = otv.tv_sec; + tv.tv_usec = otv.tv_usec; - SCARG(&a, opt) = 0; - if (SCARG(uap, opt) & OSF1_RB_ASKNAME) - SCARG(&a, opt) |= RB_ASKNAME; - if (SCARG(uap, opt) & OSF1_RB_SINGLE) - SCARG(&a, opt) |= RB_SINGLE; - if (SCARG(uap, opt) & OSF1_RB_NOSYNC) - SCARG(&a, opt) |= RB_NOSYNC; - if (SCARG(uap, opt) & OSF1_RB_HALT) - SCARG(&a, opt) |= RB_HALT; - if (SCARG(uap, opt) & OSF1_RB_INITNAME) - SCARG(&a, opt) |= RB_INITNAME; - if (SCARG(uap, opt) & OSF1_RB_DFLTROOT) - SCARG(&a, opt) |= RB_DFLTROOT; + ticks = howmany((u_long)tv.tv_sec * 1000000 + tv.tv_usec, tick); + if (ticks == 0) + ticks = 1; - return sys_reboot(p, &a, retval); -} + s = splclock(); + tv = time; + splx(s); -int -osf1_sys_lseek(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_lseek_args /* { - syscallarg(int) fd; - syscallarg(off_t) offset; - syscallarg(int) whence; - } */ *uap = v; - struct sys_lseek_args a; - - SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, pad) = 0; - SCARG(&a, offset) = SCARG(uap, offset); - SCARG(&a, whence) = SCARG(uap, whence); - - return sys_lseek(p, &a, retval); -} + tsleep(p, PUSER|PCATCH, "uslpthrd", ticks); /* XXX */ -/* - * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal - * setuid() won't work. - * - * Instead, by P1003.1b-1993, setuid() is supposed to work like: - * If the process has appropriate [super-user] priviledges, the - * setuid() function sets the real user ID, effective user - * ID, and the saved set-user-ID to uid. - * If the process does not have appropriate priviledges, but uid - * is equal to the real user ID or the saved set-user-ID, the - * setuid() function sets the effective user ID to uid; the - * real user ID and saved set-user-ID remain unchanged by - * this function call. - */ -int -osf1_sys_setuid(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_setuid_args /* { - syscallargs(uid_t) uid; - } */ *uap = v; - register struct pcred *pc = p->p_cred; - uid_t uid = SCARG(uap, uid); - int error; - - if ((error = suser(pc->pc_ucred, &p->p_acflag)) != 0 && - uid != pc->p_ruid && uid != pc->p_svuid) - return (error); + if (SCARG(uap, slept) != NULL) { + s = splclock(); + timersub(&time, &tv, &endtv); + splx(s); + if (endtv.tv_sec < 0 || endtv.tv_usec < 0) + endtv.tv_sec = endtv.tv_usec = 0; - pc->pc_ucred = crcopy(pc->pc_ucred); - pc->pc_ucred->cr_uid = uid; - if (error == 0) { - (void)chgproccnt(pc->p_ruid, -1); - (void)chgproccnt(uid, 1); - pc->p_ruid = uid; - pc->p_svuid = uid; + endotv.tv_sec = endtv.tv_sec; + endotv.tv_usec = endtv.tv_usec; + error = copyout(&endotv, SCARG(uap, slept), sizeof endotv); } - p->p_flag |= P_SUGID; - return (0); + return (error); } -/* - * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal - * setgid() won't work. - * - * If you change "uid" to "gid" in the discussion, above, about - * setuid(), you'll get a correct description of setgid(). - */ int -osf1_sys_setgid(p, v, retval) +osf1_sys_wait4(p, v, retval) struct proc *p; void *v; register_t *retval; { - struct osf1_sys_setgid_args /* { - syscallargs(gid_t) gid; - } */ *uap = v; - register struct pcred *pc = p->p_cred; - gid_t gid = SCARG(uap, gid); + struct osf1_sys_wait4_args *uap = v; + struct sys_wait4_args a; + struct osf1_rusage osf1_rusage; + struct rusage netbsd_rusage; + unsigned long leftovers; + caddr_t sg; int error; - if ((error = suser(pc->pc_ucred, &p->p_acflag)) != 0 && - gid != pc->p_rgid && gid != pc->p_svgid) - return (error); - - pc->pc_ucred = crcopy(pc->pc_ucred); - pc->pc_ucred->cr_gid = gid; - if (error == 0) { - pc->p_rgid = gid; - pc->p_svgid = gid; - } - p->p_flag |= P_SUGID; - return (0); -} - -/* - * The structures end up being the same... but we can't be sure that - * the other word of our iov_len is zero! - */ -struct osf1_iovec { - char *iov_base; - int iov_len; -}; + SCARG(&a, pid) = SCARG(uap, pid); + SCARG(&a, status) = SCARG(uap, status); -int -osf1_sys_readv(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_readv_args /* { - syscallarg(int) fd; - syscallarg(struct osf1_iovec *) iovp; - syscallarg(u_int) iovcnt; - } */ *uap = v; - struct sys_readv_args /* { - syscallarg(int) fd; - syscallarg(struct iovec *) iovp; - syscallarg(u_int) iovcnt; - } */ a; - struct emul *e = p->p_emul; - struct osf1_iovec *oio; - struct iovec *nio; - int error, i; - - if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) + /* translate options */ + SCARG(&a, options) = emul_flags_translate(osf1_wait_options_xtab, + SCARG(uap, options), &leftovers); + if (leftovers != 0) return (EINVAL); - oio = (struct osf1_iovec *) - malloc(SCARG(uap, iovcnt)*sizeof (struct osf1_iovec), - M_TEMP, M_WAITOK); - nio = (struct iovec *)malloc(SCARG(uap, iovcnt)*sizeof (struct iovec), - M_TEMP, M_WAITOK); - - error = 0; - if ((error = copyin(SCARG(uap, iovp), oio, - SCARG(uap, iovcnt) * sizeof (struct osf1_iovec))) != 0) - goto punt; - for (i = 0; i < SCARG(uap, iovcnt); i++) { - nio[i].iov_base = oio[i].iov_base; - nio[i].iov_len = oio[i].iov_len; + if (SCARG(uap, rusage) == NULL) + SCARG(&a, rusage) = NULL; + else { + sg = stackgap_init(p->p_emul); + SCARG(&a, rusage) = stackgap_alloc(&sg, sizeof netbsd_rusage); } - SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, iovp) = (struct iovec *)STACKGAPBASE; - SCARG(&a, iovcnt) = SCARG(uap, iovcnt); - - if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), - SCARG(uap, iovcnt) * sizeof (struct iovec))) != 0) - goto punt; - error = sys_readv(p, &a, retval); - -punt: - free(oio, M_TEMP); - free(nio, M_TEMP); - return (error); -} - -int -osf1_sys_writev(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_writev_args /* { - syscallarg(int) fd; - syscallarg(struct osf1_iovec *) iovp; - syscallarg(u_int) iovcnt; - } */ *uap = v; - struct sys_writev_args /* { - syscallarg(int) fd; - syscallarg(struct iovec *) iovp; - syscallarg(u_int) iovcnt; - } */ a; - struct emul *e = p->p_emul; - struct osf1_iovec *oio; - struct iovec *nio; - int error, i; - - if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) - return (EINVAL); - - oio = (struct osf1_iovec *) - malloc(SCARG(uap, iovcnt)*sizeof (struct osf1_iovec), - M_TEMP, M_WAITOK); - nio = (struct iovec *)malloc(SCARG(uap, iovcnt)*sizeof (struct iovec), - M_TEMP, M_WAITOK); - - error = 0; - if ((error = copyin(SCARG(uap, iovp), oio, - SCARG(uap, iovcnt) * sizeof (struct osf1_iovec))) != 0) - goto punt; - for (i = 0; i < SCARG(uap, iovcnt); i++) { - nio[i].iov_base = oio[i].iov_base; - nio[i].iov_len = oio[i].iov_len; + error = sys_wait4(p, &a, retval); + + if (error == 0 && SCARG(&a, rusage) != NULL) { + error = copyin((caddr_t)SCARG(&a, rusage), + (caddr_t)&netbsd_rusage, sizeof netbsd_rusage); + if (error == 0) { + osf1_cvt_rusage_from_native(&netbsd_rusage, + &osf1_rusage); + error = copyout((caddr_t)&osf1_rusage, + (caddr_t)SCARG(uap, rusage), sizeof osf1_rusage); + } } - SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, iovp) = (struct iovec *)STACKGAPBASE; - SCARG(&a, iovcnt) = SCARG(uap, iovcnt); - - if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), - SCARG(uap, iovcnt) * sizeof (struct iovec))) != 0) - goto punt; - error = sys_writev(p, &a, retval); - -punt: - free(oio, M_TEMP); - free(nio, M_TEMP); return (error); } - -/* More of the stupid off_t padding! */ -int -osf1_sys_truncate(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_truncate_args /* { - syscallarg(char *) path; - syscallarg(off_t) length; - } */ *uap = v; - struct sys_truncate_args a; - - SCARG(&a, path) = SCARG(uap, path); - SCARG(&a, pad) = 0; - SCARG(&a, length) = SCARG(uap, length); - - return sys_truncate(p, &a, retval); -} - -int -osf1_sys_ftruncate(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_ftruncate_args /* { - syscallarg(int) fd; - syscallarg(off_t) length; - } */ *uap = v; - struct sys_ftruncate_args a; - - SCARG(&a, fd) = SCARG(uap, fd); - SCARG(&a, pad) = 0; - SCARG(&a, length) = SCARG(uap, length); - - return sys_ftruncate(p, &a, retval); -} - -int -osf1_sys_getsid(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_getsid_args /* { - syscallarg(pid_t) pid; - } */ *uap = v; - struct proc *t; - - if (SCARG(uap, pid) == 0) - t = p; - else if ((t = pfind(SCARG(uap, pid))) == NULL) - return (ESRCH); - - *retval = t->p_session->s_leader->p_pid; - return (0); -} - -int -osf1_sys_getrusage(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - - /* XXX */ - return EINVAL; -} - -int -osf1_sys_madvise(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - - /* XXX */ - return EINVAL; -} - -int -osf1_sys_execve(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_execve_args *uap = v; -#if 0 - caddr_t sg = stackgap_init(p->p_emul); - - OSF1_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); -#endif - - return (sys_execve(p, (struct sys_execve_args *)&uap, retval)); -} diff --git a/sys/compat/osf1/osf1_mmap.c b/sys/compat/osf1/osf1_mmap.c new file mode 100644 index 00000000000..8db88e47986 --- /dev/null +++ b/sys/compat/osf1/osf1_mmap.c @@ -0,0 +1,282 @@ +/* $OpenBSD: osf1_mmap.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_mmap.c,v 1.5 2000/04/11 05:26:27 chs Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <vm/vm.h> /* XXX see mmap emulation */ + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_madvise(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_madvise_args *uap = v; + struct sys_madvise_args a; + int error; + + SCARG(&a, addr) = SCARG(uap, addr); + SCARG(&a, len) = SCARG(uap, len); + + error = 0; + switch (SCARG(uap, behav)) { + case OSF1_MADV_NORMAL: + SCARG(&a, behav) = MADV_NORMAL; + break; + + case OSF1_MADV_RANDOM: + SCARG(&a, behav) = MADV_RANDOM; + break; + + case OSF1_MADV_SEQUENTIAL: + SCARG(&a, behav) = MADV_SEQUENTIAL; + break; + + case OSF1_MADV_WILLNEED: + SCARG(&a, behav) = MADV_WILLNEED; + break; + + case OSF1_MADV_DONTNEED_COMPAT: + SCARG(&a, behav) = MADV_DONTNEED; + break; +#if 0 + case OSF1_MADV_SPACEAVAIL: + SCARG(&a, behav) = MADV_SPACEAVAIL; + break; +#endif + case OSF1_MADV_DONTNEED: + /* + * XXX not supported. In Digital UNIX, this flushes all + * XXX data in the region and replaces it with ZFOD pages. + */ + error = EINVAL; + break; + + default: + error = EINVAL; + break; + } + + if (error == 0) { + error = sys_madvise(p, &a, retval); + + /* + * NetBSD madvise() currently always returns ENOSYS. + * Digital UNIX says that non-operational requests (i.e. + * valid, but unimplemented 'behav') will return success. + */ + if (error == ENOSYS) + error = 0; + } + return (error); +} + +int +osf1_sys_mmap(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ +#if defined(UVM) + struct osf1_sys_mmap_args *uap = v; + struct sys_mmap_args a; + unsigned long leftovers; + + SCARG(&a, addr) = SCARG(uap, addr); + SCARG(&a, len) = SCARG(uap, len); + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, pad) = 0; + SCARG(&a, pos) = SCARG(uap, pos); + + /* translate prot */ + SCARG(&a, prot) = emul_flags_translate(osf1_mmap_prot_xtab, + SCARG(uap, prot), &leftovers); + if (leftovers != 0) + return (EINVAL); + + /* translate flags */ + SCARG(&a, flags) = emul_flags_translate(osf1_mmap_flags_xtab, + SCARG(uap, flags), &leftovers); + if (leftovers != 0) + return (EINVAL); + + /* + * XXX The following code is evil. + * + * The OSF/1 mmap() function attempts to map non-fixed entries + * near the address that the user specified. Therefore, for + * non-fixed entires we try to find space in the address space + * starting at that address. If the user specified zero, we + * start looking at at least NBPG, so that programs can't + * accidentally live through deferencing NULL. + * + * The need for this kludgery is increased by the fact that + * the loader data segment is mapped at + * (end of user address space) - 1G, MAXDSIZ is 1G, and + * the VM system tries allocate non-fixed mappings _AFTER_ + * (start of data) + MAXDSIZ. With the loader, of course, + * that means that it'll start trying at + * (end of user address space), and will never succeed! + * + * Notes: + * + * * Though we find space here, if something else (e.g. a second + * thread) were mucking with the address space the mapping + * we found might be used by another mmap(), and this call + * would clobber that region. + * + * * In general, tricks like this only work for MAP_ANON mappings, + * because of sharing/cache issues. That's not a problem on + * the Alpha, and though it's not good style to abuse that fact, + * there's little choice. + * + * * In order for this to be done right, the VM system should + * really try to use the requested 'addr' passed in to mmap() + * as a hint, even if non-fixed. If it's passed as zero, + * _maybe_ then try (start of data) + MAXDSIZ, or maybe + * provide a better way to avoid the data region altogether. + */ + if ((SCARG(&a, flags) & MAP_FIXED) == 0) { + vaddr_t addr = round_page((vaddr_t)SCARG(&a, addr)); + vsize_t size = round_page((vsize_t)SCARG(&a, len)); + int fixed = 0; + + vm_map_lock(&p->p_vmspace->vm_map); + + /* if non-NULL address given, start looking there */ + /* XXX - UVM */ + if (addr != 0 && vm_map_findspace(&p->p_vmspace->vm_map, + addr, size, &addr, NULL, 0, 0) != NULL) { + fixed = 1; + goto done; + } + + /* didn't find anything. take it again from the top. */ + if (uvm_map_findspace(&p->p_vmspace->vm_map, NBPG, size, &addr, + NULL, 0, 0) != NULL) { + fixed = 1; + goto done; + } + +done: + vm_map_unlock(&p->p_vmspace->vm_map); + if (fixed) { + SCARG(&a, flags) |= MAP_FIXED; + SCARG(&a, addr) = (void *)addr; + } + } + + return sys_mmap(p, &a, retval); +#else + struct osf1_sys_mmap_args /* { + syscallarg(caddr_t) addr; + syscallarg(size_t) len; + syscallarg(int) prot; + syscallarg(int) flags; + syscallarg(int) fd; + syscallarg(off_t) pos; + } */ *uap = v; + struct sys_mmap_args /* { + syscallarg(caddr_t) addr; + syscallarg(size_t) len; + syscallarg(int) prot; + syscallarg(int) flags; + syscallarg(int) fd; + syscallarg(long) pad; + syscallarg(off_t) pos; + } */ a; + + SCARG(&a, addr) = SCARG(uap, addr); + SCARG(&a, len) = SCARG(uap, len); + SCARG(&a, prot) = SCARG(uap, prot); + SCARG(&a, fd) = SCARG(uap, fd); + SCARG(&a, pad) = 0; + SCARG(&a, pos) = SCARG(uap, pos); + + SCARG(&a, flags) = 0; + if (SCARG(uap, flags) & OSF1_MAP_SHARED) + SCARG(&a, flags) |= MAP_SHARED; + if (SCARG(uap, flags) & OSF1_MAP_PRIVATE) + SCARG(&a, flags) |= MAP_PRIVATE; + switch (SCARG(uap, flags) & OSF1_MAP_TYPE) { + case OSF1_MAP_ANON: + SCARG(&a, flags) |= MAP_ANON; + break; + case OSF1_MAP_FILE: + SCARG(&a, flags) |= MAP_FILE; + break; + default: + return (EINVAL); + } + if (SCARG(uap, flags) & OSF1_MAP_FIXED) + SCARG(&a, flags) |= MAP_FIXED; + if (SCARG(uap, flags) & OSF1_MAP_HASSEMAPHORE) + SCARG(&a, flags) |= MAP_HASSEMAPHORE; + if (SCARG(uap, flags) & OSF1_MAP_INHERIT) + SCARG(&a, flags) |= MAP_INHERIT; + if (SCARG(uap, flags) & OSF1_MAP_UNALIGNED) + return (EINVAL); + + return sys_mmap(p, &a, retval); +#endif +} + +int +osf1_sys_mprotect(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_mprotect_args *uap = v; + struct sys_mprotect_args a; + unsigned long leftovers; + + SCARG(&a, addr) = SCARG(uap, addr); + SCARG(&a, len) = SCARG(uap, len); + + /* translate prot */ + SCARG(&a, prot) = emul_flags_translate(osf1_mmap_prot_xtab, + SCARG(uap, prot), &leftovers); + if (leftovers != 0) + return (EINVAL); + + return sys_mprotect(p, &a, retval); +} diff --git a/sys/compat/osf1/osf1_mount.c b/sys/compat/osf1/osf1_mount.c index a591c6014ab..2872db884eb 100644 --- a/sys/compat/osf1/osf1_mount.c +++ b/sys/compat/osf1/osf1_mount.c @@ -1,5 +1,35 @@ -/* $OpenBSD: osf1_mount.c,v 1.4 1996/10/30 16:37:20 niklas Exp $ */ -/* $NetBSD: osf1_mount.c,v 1.6 1996/02/17 23:08:36 jtk Exp $ */ +/* $OpenBSD: osf1_mount.c,v 1.5 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_mount.c,v 1.14 1999/05/05 01:51:34 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ /* * Copyright (c) 1994, 1995 Carnegie-Mellon University. @@ -33,38 +63,29 @@ #include <sys/namei.h> #include <sys/proc.h> #include <sys/file.h> +#include <sys/filedesc.h> #include <sys/kernel.h> #include <sys/mount.h> #include <sys/vnode.h> #include <sys/syscallargs.h> +#include <compat/osf1/osf1.h> #include <compat/osf1/osf1_syscallargs.h> #include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> #include <net/if.h> #include <netinet/in.h> +#include <nfs/rpcv2.h> #include <nfs/nfsproto.h> +#include <nfs/nfs.h> +#include <nfs/nfsmount.h> -#include <machine/vmparam.h> +#include <ufs/ufs/quota.h> +#include <ufs/ufs/ufsmount.h> -/* File system type numbers. */ -#define OSF1_MOUNT_NONE 0 -#define OSF1_MOUNT_UFS 1 -#define OSF1_MOUNT_NFS 2 -#define OSF1_MOUNT_MFS 3 -#define OSF1_MOUNT_PC 4 -#define OSF1_MOUNT_S5FS 5 -#define OSF1_MOUNT_CDFS 6 -#define OSF1_MOUNT_DFS 7 -#define OSF1_MOUNT_EFS 8 -#define OSF1_MOUNT_PROCFS 9 -#define OSF1_MOUNT_MSFS 10 -#define OSF1_MOUNT_FFM 11 -#define OSF1_MOUNT_FDFS 12 -#define OSF1_MOUNT_ADDON 13 -#define OSF1_MOUNT_NFSV3 14 -#define OSF1_MOUNT_MAXTYPE 15 +#include <machine/vmparam.h> #define OSF1_MNT_WAIT 0x1 #define OSF1_MNT_NOWAIT 0x2 @@ -77,154 +98,11 @@ #define OSF1_MOUNT_FLAGS 0xffffffff /* XXX */ #define OSF1_UNMOUNT_FLAGS (OSF1_MNT_FORCE|OSF1_MNT_NOFORCE) -struct osf1_statfs { - int16_t f_type; /* 0 */ - int16_t f_flags; /* 2 */ - int32_t f_fsize; /* 4 */ - int32_t f_bsize; /* 8 */ - int32_t f_blocks; /* 12 */ - int32_t f_bfree; /* 16 */ - int32_t f_bavail; /* 20 */ - int32_t f_files; /* 24 */ - int32_t f_ffree; /* 28 */ - int64_t f_fsid; /* 32 */ - int32_t f_spare[9]; /* 40 (36 bytes) */ - char f_mntonname[90]; /* 76 (90 bytes) */ - char f_mntfromname[90]; /* 166 (90 bytes) */ - char f_xxx[80]; /* 256 (80 bytes) XXX */ -}; - -/* Arguments to mount() for various FS types. */ -#ifdef notyet /* XXX */ -struct osf1_ufs_args { - char *fspec; - int32_t exflags; - u_int32_t exroot; -}; - -struct osf1_cdfs_args { - char *fspec; - int32_t exflags; - u_int32_t exroot; - int32_t flags; -}; -#endif - -struct osf1_mfs_args { - char *name; - caddr_t base; - u_int size; -}; - -struct osf1_nfs_args { - struct sockaddr_in *addr; - caddr_t fh; - int32_t flags; - int32_t wsize; - int32_t rsize; - int32_t timeo; - int32_t retrans; - char *hostname; - int32_t acregmin; - int32_t acregmax; - int32_t acdirmin; - int32_t acdirmax; - char *netname; - void *pathconf; -}; - -#define OSF1_NFSMNT_SOFT 0x00001 -#define OSF1_NFSMNT_WSIZE 0x00002 -#define OSF1_NFSMNT_RSIZE 0x00004 -#define OSF1_NFSMNT_TIMEO 0x00008 -#define OSF1_NFSMNT_RETRANS 0x00010 -#define OSF1_NFSMNT_HOSTNAME 0x00020 -#define OSF1_NFSMNT_INT 0x00040 -#define OSF1_NFSMNT_NOCONN 0x00080 -#define OSF1_NFSMNT_NOAC 0x00100 /* ??? */ -#define OSF1_NFSMNT_ACREGMIN 0x00200 /* ??? */ -#define OSF1_NFSMNT_ACREGMAX 0x00400 /* ??? */ -#define OSF1_NFSMNT_ACDIRMIN 0x00800 /* ??? */ -#define OSF1_NFSMNT_ACDIRMAX 0x01000 /* ??? */ -#define OSF1_NFSMNT_NOCTO 0x02000 /* ??? */ -#define OSF1_NFSMNT_POSIX 0x04000 /* ??? */ -#define OSF1_NFSMNT_AUTO 0x08000 /* ??? */ - -#define OSF1_NFSMNT_FLAGS \ - (OSF1_NFSMNT_SOFT|OSF1_NFSMNT_WSIZE|OSF1_NFSMNT_RSIZE| \ - OSF1_NFSMNT_TIMEO|OSF1_NFSMNT_RETRANS|OSF1_NFSMNT_HOSTNAME| \ - OSF1_NFSMNT_INT|OSF1_NFSMNT_NOCONN) - -void bsd2osf_statfs __P((struct statfs *, struct osf1_statfs *)); -int osf1_mount_mfs __P((struct proc *, struct osf1_sys_mount_args *, - struct sys_mount_args *)); -int osf1_mount_nfs __P((struct proc *, struct osf1_sys_mount_args *, - struct sys_mount_args *)); - -void -bsd2osf_statfs(bsfs, osfs) - struct statfs *bsfs; - struct osf1_statfs *osfs; -{ - - bzero(osfs, sizeof (struct osf1_statfs)); - if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, MFSNAMELEN)) - osfs->f_type = OSF1_MOUNT_UFS; - else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, MFSNAMELEN)) - osfs->f_type = OSF1_MOUNT_NFS; - else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, MFSNAMELEN)) - osfs->f_type = OSF1_MOUNT_MFS; - else - /* uh oh... XXX = PC, CDFS, PROCFS, etc. */ - osfs->f_type = OSF1_MOUNT_ADDON; - osfs->f_flags = bsfs->f_flags; /* XXX translate */ - osfs->f_fsize = bsfs->f_bsize; - osfs->f_bsize = bsfs->f_iosize; - osfs->f_blocks = bsfs->f_blocks; - osfs->f_bfree = bsfs->f_bfree; - osfs->f_bavail = bsfs->f_bavail; - osfs->f_files = bsfs->f_files; - osfs->f_ffree = bsfs->f_ffree; - bcopy(&bsfs->f_fsid, &osfs->f_fsid, - max(sizeof bsfs->f_fsid, sizeof osfs->f_fsid)); - /* osfs->f_spare zeroed above */ - bcopy(bsfs->f_mntonname, osfs->f_mntonname, - max(sizeof bsfs->f_mntonname, sizeof osfs->f_mntonname)); - bcopy(bsfs->f_mntfromname, osfs->f_mntfromname, - max(sizeof bsfs->f_mntfromname, sizeof osfs->f_mntfromname)); - /* XXX osfs->f_xxx should be filled in... */ -} - -int -osf1_sys_statfs(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_statfs_args /* { - syscallarg(char *) path; - syscallarg(struct osf1_statfs *) buf; - syscallarg(int) len; - } */ *uap = v; - struct mount *mp; - struct statfs *sp; - struct osf1_statfs osfs; - int error; - struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); - if ((error = namei(&nd)) != 0) - return (error); - mp = nd.ni_vp->v_mount; - sp = &mp->mnt_stat; - vrele(nd.ni_vp); - if ((error = VFS_STATFS(mp, sp, p)) != 0) - return (error); - sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - bsd2osf_statfs(sp, &osfs); - return copyout(&osfs, SCARG(uap, buf), min(sizeof osfs, - SCARG(uap, len))); -} +static int osf1_mount_mfs __P((struct proc *, + struct osf1_sys_mount_args *, struct sys_mount_args *)); +static int osf1_mount_nfs __P((struct proc *, + struct osf1_sys_mount_args *, struct sys_mount_args *)); int osf1_sys_fstatfs(p, v, retval) @@ -232,27 +110,26 @@ osf1_sys_fstatfs(p, v, retval) void *v; register_t *retval; { - struct osf1_sys_fstatfs_args /* { - syscallarg(int) fd; - syscallarg(struct osf1_statfs *) buf; - syscallarg(int) len; - } */ *uap = v; + struct osf1_sys_fstatfs_args *uap = v; struct file *fp; struct mount *mp; struct statfs *sp; struct osf1_statfs osfs; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + /* getvnode() will use the descriptor for us */ + if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp))) return (error); mp = ((struct vnode *)fp->f_data)->v_mount; sp = &mp->mnt_stat; - if ((error = VFS_STATFS(mp, sp, p)) != 0) - return (error); + if ((error = VFS_STATFS(mp, sp, p))) + goto out; sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - bsd2osf_statfs(sp, &osfs); - return copyout(&osfs, SCARG(uap, buf), min(sizeof osfs, + osf1_cvt_statfs_from_native(sp, &osfs); + error = copyout(&osfs, SCARG(uap, buf), min(sizeof osfs, SCARG(uap, len))); + out: + return (error); } int @@ -261,11 +138,7 @@ osf1_sys_getfsstat(p, v, retval) void *v; register_t *retval; { - register struct osf1_sys_getfsstat_args /* { - syscallarg(struct osf1_statfs *) buf; - syscallarg(long) bufsize; - syscallarg(int) flags; - } */ *uap = v; + struct osf1_sys_getfsstat_args *uap = v; struct mount *mp, *nmp; struct statfs *sp; struct osf1_statfs osfs; @@ -280,8 +153,7 @@ osf1_sys_getfsstat(p, v, retval) for (count = 0, mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { nmp = mp->mnt_list.cqe_next; - if (osf_sfsp && count < maxcount && - ((mp->mnt_flag & MNT_MLOCK) == 0)) { + if (osf_sfsp && count < maxcount) { sp = &mp->mnt_stat; /* * If OSF1_MNT_NOWAIT is specified, do not refresh the @@ -293,9 +165,9 @@ osf1_sys_getfsstat(p, v, retval) (error = VFS_STATFS(mp, sp, p))) continue; sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - bsd2osf_statfs(sp, &osfs); + osf1_cvt_statfs_from_native(sp, &osfs); if ((error = copyout(&osfs, osf_sfsp, - sizeof (struct osf1_statfs))) != 0) + sizeof (struct osf1_statfs)))) return (error); osf_sfsp += sizeof (struct osf1_statfs); } @@ -309,41 +181,12 @@ osf1_sys_getfsstat(p, v, retval) } int -osf1_sys_unmount(p, v, retval) - struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_unmount_args /* { - syscallarg(char *) path; - syscallarg(int) flags; - } */ *uap = v; - struct sys_unmount_args a; - - SCARG(&a, path) = SCARG(uap, path); - - if (SCARG(uap, flags) & ~OSF1_UNMOUNT_FLAGS) - return (EINVAL); - SCARG(&a, flags) = 0; - if ((SCARG(uap, flags) & OSF1_MNT_FORCE) && - (SCARG(uap, flags) & OSF1_MNT_NOFORCE) == 0) - SCARG(&a, flags) |= MNT_FORCE; - - return sys_unmount(p, &a, retval); -} - -int osf1_sys_mount(p, v, retval) struct proc *p; void *v; register_t *retval; { - struct osf1_sys_mount_args /* { - syscallarg(int) type; - syscallarg(char *) path; - syscallarg(int) flags; - syscallarg(caddr_t) data; - } */ *uap = v; + struct osf1_sys_mount_args *uap = v; struct sys_mount_args a; int error; @@ -354,37 +197,16 @@ osf1_sys_mount(p, v, retval) SCARG(&a, flags) = SCARG(uap, flags); /* XXX - xlate */ switch (SCARG(uap, type)) { - case OSF1_MOUNT_UFS: /* XXX */ - return (EINVAL); - break; - - case OSF1_MOUNT_NFS: /* XXX */ - if ((error = osf1_mount_nfs(p, uap, &a)) != 0) + case OSF1_MOUNT_NFS: + if ((error = osf1_mount_nfs(p, uap, &a))) return error; break; - case OSF1_MOUNT_MFS: /* XXX */ - if ((error = osf1_mount_mfs(p, uap, &a)) != 0) + case OSF1_MOUNT_MFS: + if ((error = osf1_mount_mfs(p, uap, &a))) return error; break; - case OSF1_MOUNT_CDFS: /* XXX */ - return (EINVAL); - break; - - case OSF1_MOUNT_PROCFS: /* XXX */ - return (EINVAL); - break; - - case OSF1_MOUNT_NONE: - case OSF1_MOUNT_PC: - case OSF1_MOUNT_S5FS: - case OSF1_MOUNT_DFS: - case OSF1_MOUNT_EFS: - case OSF1_MOUNT_MSFS: - case OSF1_MOUNT_FFM: - case OSF1_MOUNT_FDFS: - case OSF1_MOUNT_ADDON: default: return (EINVAL); } @@ -393,99 +215,144 @@ osf1_sys_mount(p, v, retval) } int +osf1_sys_statfs(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_statfs_args *uap = v; + struct mount *mp; + struct statfs *sp; + struct osf1_statfs osfs; + int error; + struct nameidata nd; + + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + if ((error = namei(&nd))) + return (error); + mp = nd.ni_vp->v_mount; + sp = &mp->mnt_stat; + vrele(nd.ni_vp); + if ((error = VFS_STATFS(mp, sp, p))) + return (error); + sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; + osf1_cvt_statfs_from_native(sp, &osfs); + return copyout(&osfs, SCARG(uap, buf), min(sizeof osfs, + SCARG(uap, len))); +} + +int +osf1_sys_unmount(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_unmount_args *uap = v; + struct sys_unmount_args a; + + SCARG(&a, path) = SCARG(uap, path); + + if (SCARG(uap, flags) & ~OSF1_UNMOUNT_FLAGS) + return (EINVAL); + SCARG(&a, flags) = 0; + if ((SCARG(uap, flags) & OSF1_MNT_FORCE) && + (SCARG(uap, flags) & OSF1_MNT_NOFORCE) == 0) + SCARG(&a, flags) |= MNT_FORCE; + + return sys_unmount(p, &a, retval); +} + +static int osf1_mount_mfs(p, osf_argp, bsd_argp) struct proc *p; struct osf1_sys_mount_args *osf_argp; struct sys_mount_args *bsd_argp; { - struct emul *e = p->p_emul; struct osf1_mfs_args osf_ma; struct mfs_args bsd_ma; - caddr_t cp; - int error; + caddr_t sg = stackgap_init(p->p_emul); + int error, len; + static const char mfs_name[] = MOUNT_MFS; - error = copyin(SCARG(osf_argp, data), &osf_ma, sizeof osf_ma); - if (error) + if ((error = copyin(SCARG(osf_argp, data), &osf_ma, sizeof osf_ma))) return error; - bzero(&bsd_ma, sizeof bsd_ma); + memset(&bsd_ma, 0, sizeof bsd_ma); bsd_ma.fspec = osf_ma.name; /* XXX export args */ bsd_ma.base = osf_ma.base; bsd_ma.size = osf_ma.size; - cp = STACKGAPBASE; - SCARG(bsd_argp, data) = cp; - if ((error = copyout(&bsd_ma, cp, sizeof bsd_ma)) != 0) + SCARG(bsd_argp, data) = stackgap_alloc(&sg, sizeof bsd_ma); + if ((error = copyout(&bsd_ma, SCARG(bsd_argp, data), sizeof bsd_ma))) return error; - cp += ALIGN(sizeof bsd_ma); - SCARG(bsd_argp, type) = cp; - if ((error = copyout(MOUNT_MFS, cp, strlen(MOUNT_MFS) + 1)) != 0) + len = strlen(mfs_name) + 1; + SCARG(bsd_argp, type) = stackgap_alloc(&sg, len); + if ((error = copyout(mfs_name, (void *)SCARG(bsd_argp, type), len))) return error; return 0; } -int +static int osf1_mount_nfs(p, osf_argp, bsd_argp) struct proc *p; struct osf1_sys_mount_args *osf_argp; struct sys_mount_args *bsd_argp; { - struct emul *e = p->p_emul; struct osf1_nfs_args osf_na; struct nfs_args bsd_na; - caddr_t cp; - int error; + caddr_t sg = stackgap_init(p->p_emul); + int error, len; + static const char nfs_name[] = MOUNT_NFS; + unsigned long leftovers; - error = copyin(SCARG(osf_argp, data), &osf_na, sizeof osf_na); - if (error) + if ((error = copyin(SCARG(osf_argp, data), &osf_na, sizeof osf_na))) return error; - bzero(&bsd_na, sizeof bsd_na); - bsd_na.version = 2; + memset(&bsd_na, 0, sizeof bsd_na); bsd_na.addr = (struct sockaddr *)osf_na.addr; bsd_na.addrlen = sizeof (struct sockaddr_in); - bsd_na.sotype = SOCK_DGRAM; - bsd_na.proto = 0; - bsd_na.fh = (char *)osf_na.fh; - - if (osf_na.flags & ~OSF1_NFSMNT_FLAGS) - return EINVAL; - if (osf_na.flags & OSF1_NFSMNT_SOFT) - bsd_na.flags |= NFSMNT_SOFT; - if (osf_na.flags & OSF1_NFSMNT_WSIZE) { - bsd_na.wsize = osf_na.wsize; - bsd_na.flags |= NFSMNT_WSIZE; + bsd_na.fh = osf_na.fh; + + /* translate flags */ + bsd_na.flags = emul_flags_translate(osf1_nfs_mount_flags_xtab, + osf_na.flags, &leftovers); + if (leftovers & OSF1_NFSMNT_HOSTNAME) { + leftovers &= ~OSF1_NFSMNT_HOSTNAME; + bsd_na.hostname = osf_na.hostname; + } else { + /* XXX FILL IN HOST NAME WITH IPADDR? */ } - if (osf_na.flags & OSF1_NFSMNT_RSIZE) { - bsd_na.rsize = osf_na.rsize; - bsd_na.flags |= NFSMNT_RSIZE; + if (leftovers & OSF1_NFSMNT_TCP) { + leftovers &= ~OSF1_NFSMNT_TCP; + bsd_na.sotype = SOCK_DGRAM; + bsd_na.proto = 0; + } else { + bsd_na.sotype = SOCK_STREAM; + bsd_na.proto = 0; } - if (osf_na.flags & OSF1_NFSMNT_TIMEO) { + if (leftovers != 0) + return (EINVAL); + + /* copy structure elements based on flags */ + if (bsd_na.flags & NFSMNT_WSIZE) + bsd_na.wsize = osf_na.wsize; + if (bsd_na.flags & NFSMNT_RSIZE) + bsd_na.rsize = osf_na.rsize; + if (bsd_na.flags & NFSMNT_TIMEO) bsd_na.timeo = osf_na.timeo; - bsd_na.flags |= NFSMNT_TIMEO; - } - if (osf_na.flags & OSF1_NFSMNT_RETRANS) { + if (bsd_na.flags & NFSMNT_RETRANS) bsd_na.retrans = osf_na.retrans; - bsd_na.flags |= NFSMNT_RETRANS; - } - if (osf_na.flags & OSF1_NFSMNT_HOSTNAME) - bsd_na.hostname = osf_na.hostname; - if (osf_na.flags & OSF1_NFSMNT_INT) - bsd_na.flags |= NFSMNT_INT; - if (osf_na.flags & OSF1_NFSMNT_NOCONN) - bsd_na.flags |= NFSMNT_NOCONN; - - cp = STACKGAPBASE; - SCARG(bsd_argp, data) = cp; - if ((error = copyout(&bsd_na, cp, sizeof bsd_na)) != 0) + + SCARG(bsd_argp, data) = stackgap_alloc(&sg, sizeof bsd_na); + if ((error = copyout(&bsd_na, SCARG(bsd_argp, data), sizeof bsd_na))) return error; - cp += ALIGN(sizeof bsd_na); - SCARG(bsd_argp, type) = cp; - if ((error = copyout(MOUNT_NFS, cp, strlen(MOUNT_NFS) + 1)) != 0) + len = strlen(nfs_name) + 1; + SCARG(bsd_argp, type) = stackgap_alloc(&sg, len); + if ((error = copyout(MOUNT_NFS, (void *)SCARG(bsd_argp, type), len))) return error; return 0; diff --git a/sys/compat/osf1/osf1_prot.c b/sys/compat/osf1/osf1_prot.c new file mode 100644 index 00000000000..9385ab48f24 --- /dev/null +++ b/sys/compat/osf1/osf1_prot.c @@ -0,0 +1,142 @@ +/* $OpenBSD: osf1_prot.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_prot.c,v 1.2 1999/05/05 01:51:35 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +/* + * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal + * setgid() won't work. + * + * If you change "uid" to "gid" in the discussion, below, about + * setuid(), you'll get a correct description of setgid(). + */ +int +osf1_sys_setgid(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_setgid_args *uap = v; + struct pcred *pc = p->p_cred; + gid_t gid = SCARG(uap, gid); + int error; + + if ((error = suser(pc->pc_ucred, &p->p_acflag)) != 0 && + gid != pc->p_rgid && gid != pc->p_svgid) + return (error); + + pc->pc_ucred = crcopy(pc->pc_ucred); + pc->pc_ucred->cr_gid = gid; + if (error == 0) { + pc->p_rgid = gid; + pc->p_svgid = gid; + } + p->p_flag |= P_SUGID; + return (0); +} + +/* + * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal + * setuid() won't work. + * + * Instead, by P1003.1b-1993, setuid() is supposed to work like: + * If the process has appropriate [super-user] privileges, the + * setuid() function sets the real user ID, effective user + * ID, and the saved set-user-ID to uid. + * If the process does not have appropriate privileges, but uid + * is equal to the real user ID or the saved set-user-ID, the + * setuid() function sets the effective user ID to uid; the + * real user ID and saved set-user-ID remain unchanged by + * this function call. + */ +int +osf1_sys_setuid(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_setuid_args *uap = v; + struct pcred *pc = p->p_cred; + uid_t uid = SCARG(uap, uid); + int error; + + if ((error = suser(pc->pc_ucred, &p->p_acflag)) != 0 && + uid != pc->p_ruid && uid != pc->p_svuid) + return (error); + + pc->pc_ucred = crcopy(pc->pc_ucred); + pc->pc_ucred->cr_uid = uid; + if (error == 0) { + (void)chgproccnt(pc->p_ruid, -1); + (void)chgproccnt(uid, 1); + pc->p_ruid = uid; + pc->p_svuid = uid; + } + p->p_flag |= P_SUGID; + return (0); +} diff --git a/sys/compat/osf1/osf1_resource.c b/sys/compat/osf1/osf1_resource.c new file mode 100644 index 00000000000..7285af7ee50 --- /dev/null +++ b/sys/compat/osf1/osf1_resource.c @@ -0,0 +1,171 @@ +/* $OpenBSD: osf1_resource.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_resource.c,v 1.1 1999/05/01 05:41:56 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <sys/resource.h> +#include <sys/resourcevar.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_getrlimit(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_getrlimit_args *uap = v; + struct sys_getrlimit_args a; + + switch (SCARG(uap, which)) { + case OSF1_RLIMIT_CPU: + SCARG(&a, which) = RLIMIT_CPU; + break; + case OSF1_RLIMIT_FSIZE: + SCARG(&a, which) = RLIMIT_FSIZE; + break; + case OSF1_RLIMIT_DATA: + SCARG(&a, which) = RLIMIT_DATA; + break; + case OSF1_RLIMIT_STACK: + SCARG(&a, which) = RLIMIT_STACK; + break; + case OSF1_RLIMIT_CORE: + SCARG(&a, which) = RLIMIT_CORE; + break; + case OSF1_RLIMIT_RSS: + SCARG(&a, which) = RLIMIT_RSS; + break; + case OSF1_RLIMIT_NOFILE: + SCARG(&a, which) = RLIMIT_NOFILE; + break; + case OSF1_RLIMIT_AS: /* unhandled */ + default: + return (EINVAL); + } + + /* XXX should translate */ + SCARG(&a, rlp) = SCARG(uap, rlp); + + return sys_getrlimit(p, &a, retval); +} + +int +osf1_sys_getrusage(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_getrusage_args *uap = v; + struct sys_getrusage_args a; + struct osf1_rusage osf1_rusage; + struct rusage netbsd_rusage; + caddr_t sg; + int error; + + switch (SCARG(uap, who)) { + case OSF1_RUSAGE_SELF: + SCARG(&a, who) = RUSAGE_SELF; + break; + + case OSF1_RUSAGE_CHILDREN: + SCARG(&a, who) = RUSAGE_CHILDREN; + break; + + case OSF1_RUSAGE_THREAD: /* XXX not supported */ + default: + return (EINVAL); + } + + sg = stackgap_init(p->p_emul); + SCARG(&a, rusage) = stackgap_alloc(&sg, sizeof netbsd_rusage); + + error = sys_getrusage(p, &a, retval); + if (error == 0) + error = copyin((caddr_t)SCARG(&a, rusage), + (caddr_t)&netbsd_rusage, sizeof netbsd_rusage); + if (error == 0) { + osf1_cvt_rusage_from_native(&netbsd_rusage, &osf1_rusage); + error = copyout((caddr_t)&osf1_rusage, + (caddr_t)SCARG(uap, rusage), sizeof osf1_rusage); + } + + return (error); +} + +int +osf1_sys_setrlimit(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_setrlimit_args *uap = v; + struct sys_setrlimit_args a; + + switch (SCARG(uap, which)) { + case OSF1_RLIMIT_CPU: + SCARG(&a, which) = RLIMIT_CPU; + break; + case OSF1_RLIMIT_FSIZE: + SCARG(&a, which) = RLIMIT_FSIZE; + break; + case OSF1_RLIMIT_DATA: + SCARG(&a, which) = RLIMIT_DATA; + break; + case OSF1_RLIMIT_STACK: + SCARG(&a, which) = RLIMIT_STACK; + break; + case OSF1_RLIMIT_CORE: + SCARG(&a, which) = RLIMIT_CORE; + break; + case OSF1_RLIMIT_RSS: + SCARG(&a, which) = RLIMIT_RSS; + break; + case OSF1_RLIMIT_NOFILE: + SCARG(&a, which) = RLIMIT_NOFILE; + break; + case OSF1_RLIMIT_AS: /* unhandled */ + default: + return (EINVAL); + } + + /* XXX should translate */ + SCARG(&a, rlp) = SCARG(uap, rlp); + + return sys_setrlimit(p, &a, retval); +} diff --git a/sys/compat/osf1/osf1_signal.c b/sys/compat/osf1/osf1_signal.c index 5e5b9e1a7f9..40165280f70 100644 --- a/sys/compat/osf1/osf1_signal.c +++ b/sys/compat/osf1/osf1_signal.c @@ -1,4 +1,35 @@ -/* $OpenBSD: osf1_signal.c,v 1.8 1998/12/23 16:23:47 millert Exp $ */ +/* $OpenBSD: osf1_signal.c,v 1.9 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_signal.c,v 1.15 1999/05/05 00:57:43 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ #include <sys/param.h> #include <sys/systm.h> @@ -14,213 +45,27 @@ #include <sys/syscallargs.h> +#include <compat/osf1/osf1.h> #include <compat/osf1/osf1_signal.h> #include <compat/osf1/osf1_syscallargs.h> #include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> -static void bsd_to_osf1_sigaction __P((const struct sigaction *bsa, - struct osf1_sigaction *osa)); -static void osf1_to_bsd_sigaction __P((const struct osf1_sigaction *osa, - struct sigaction *bsa)); - -#define sigemptyset(s) bzero((s), sizeof(*(s))) -#define sigismember(s, n) (*(s) & sigmask(n)) -#define sigaddset(s, n) (*(s) |= sigmask(n)) - -#define osf1_sigmask(n) (1 << ((n) - 1)) -#define osf1_sigemptyset(s) bzero((s), sizeof(*(s))) -#define osf1_sigismember(s, n) (*(s) & sigmask(n)) -#define osf1_sigaddset(s, n) (*(s) |= sigmask(n)) - -int bsd_to_osf1_sig[] = { - 0, - OSF1_SIGHUP, - OSF1_SIGINT, - OSF1_SIGQUIT, - OSF1_SIGILL, - OSF1_SIGTRAP, - OSF1_SIGABRT, - OSF1_SIGEMT, - OSF1_SIGFPE, - OSF1_SIGKILL, - OSF1_SIGBUS, - OSF1_SIGSEGV, - OSF1_SIGSYS, - OSF1_SIGPIPE, - OSF1_SIGALRM, - OSF1_SIGTERM, - OSF1_SIGURG, - OSF1_SIGSTOP, - OSF1_SIGTSTP, - OSF1_SIGCONT, - OSF1_SIGCHLD, - OSF1_SIGTTIN, - OSF1_SIGTTOU, - OSF1_SIGIO, - OSF1_SIGXCPU, - OSF1_SIGXFSZ, - OSF1_SIGVTALRM, - OSF1_SIGPROF, - OSF1_SIGWINCH, - OSF1_SIGINFO, - OSF1_SIGUSR1, - OSF1_SIGUSR2, -}; - -int osf1_to_bsd_sig[] = { - 0, - SIGHUP, - SIGINT, - SIGQUIT, - SIGILL, - SIGTRAP, - SIGABRT, - SIGEMT, - SIGFPE, - SIGKILL, - SIGBUS, - SIGSEGV, - SIGSYS, - SIGPIPE, - SIGALRM, - SIGTERM, - SIGURG, - SIGSTOP, - SIGTSTP, - SIGCONT, - SIGCHLD, - SIGTTIN, - SIGTTOU, - SIGIO, - SIGXCPU, - SIGXFSZ, - SIGVTALRM, - SIGPROF, - SIGWINCH, - SIGINFO, - SIGUSR1, - SIGUSR2, -}; - -void -osf1_to_bsd_sigset(oss, bss) - const osf1_sigset_t *oss; - sigset_t *bss; -{ - int i, newsig; - - sigemptyset(bss); - for (i = 1; i < OSF1_NSIG; i++) { - if (osf1_sigismember(oss, i)) { - newsig = osf1_to_bsd_sig[i]; - if (newsig) - sigaddset(bss, newsig); - } - } -} - - -void -bsd_to_osf1_sigset(bss, oss) - const sigset_t *bss; - osf1_sigset_t *oss; -{ - int i, newsig; - - osf1_sigemptyset(oss); - for (i = 1; i < NSIG; i++) { - if (sigismember(bss, i)) { - newsig = bsd_to_osf1_sig[i]; - if (newsig) - osf1_sigaddset(oss, newsig); - } - } -} - -/* - * XXX: Only a subset of the flags is currently implemented. - */ -void -osf1_to_bsd_sigaction(osa, bsa) - const struct osf1_sigaction *osa; - struct sigaction *bsa; -{ - - bsa->sa_handler = osa->sa__handler; - osf1_to_bsd_sigset(&osa->sa_mask, &bsa->sa_mask); - bsa->sa_flags = 0; - if ((osa->sa_flags & OSF1_SA_ONSTACK) != 0) - bsa->sa_flags |= SA_ONSTACK; - if ((osa->sa_flags & OSF1_SA_RESTART) != 0) - bsa->sa_flags |= SA_RESTART; - if ((osa->sa_flags & OSF1_SA_RESETHAND) != 0) - bsa->sa_flags |= SA_RESETHAND; - if ((osa->sa_flags & OSF1_SA_NOCLDSTOP) != 0) - bsa->sa_flags |= SA_NOCLDSTOP; - if ((osa->sa_flags & OSF1_SA_NOCLDWAIT) != 0) - bsa->sa_flags |= SA_NOCLDWAIT; - if ((osa->sa_flags & OSF1_SA_NODEFER) != 0) - bsa->sa_flags |= SA_NODEFER; - if ((osa->sa_flags & OSF1_SA_SIGINFO) != 0) - bsa->sa_flags |= SA_SIGINFO; -} - -void -bsd_to_osf1_sigaction(bsa, osa) - const struct sigaction *bsa; - struct osf1_sigaction *osa; -{ - - osa->sa__handler = bsa->sa_handler; - bsd_to_osf1_sigset(&bsa->sa_mask, &osa->sa_mask); - osa->sa_flags = 0; - if ((bsa->sa_flags & SA_ONSTACK) != 0) - osa->sa_flags |= OSF1_SA_ONSTACK; - if ((bsa->sa_flags & SA_RESTART) != 0) - osa->sa_flags |= OSF1_SA_RESTART; - if ((bsa->sa_flags & SA_NOCLDSTOP) != 0) - osa->sa_flags |= OSF1_SA_NOCLDSTOP; - if ((bsa->sa_flags & SA_NOCLDWAIT) != 0) - osa->sa_flags |= OSF1_SA_NOCLDWAIT; - if ((bsa->sa_flags & SA_NODEFER) != 0) - osa->sa_flags |= OSF1_SA_NODEFER; - if ((bsa->sa_flags & SA_RESETHAND) != 0) - osa->sa_flags |= OSF1_SA_RESETHAND; - if ((bsa->sa_flags & SA_SIGINFO) != 0) - osa->sa_flags |= OSF1_SA_SIGINFO; -} - -void -osf1_to_bsd_sigaltstack(oss, bss) - const struct osf1_sigaltstack *oss; - struct sigaltstack *bss; -{ - - bss->ss_sp = oss->ss_sp; - bss->ss_size = oss->ss_size; - bss->ss_flags = 0; - - if ((oss->ss_flags & OSF1_SS_DISABLE) != 0) - bss->ss_flags |= SS_DISABLE; - if ((oss->ss_flags & OSF1_SS_ONSTACK) != 0) - bss->ss_flags |= SS_ONSTACK; -} - -void -bsd_to_osf1_sigaltstack(bss, oss) - const struct sigaltstack *bss; - struct osf1_sigaltstack *oss; +#if 0 +int +osf1_sys_kill(p, v, retval) + struct proc *p; + void *v; + register_t *retval; { + struct osf1_sys_kill_args *uap = v; + struct sys_kill_args ka; - oss->ss_sp = bss->ss_sp; - oss->ss_size = bss->ss_size; - oss->ss_flags = 0; - - if ((bss->ss_flags & SS_DISABLE) != 0) - oss->ss_flags |= OSF1_SS_DISABLE; - if ((bss->ss_flags & SS_ONSTACK) != 0) - oss->ss_flags |= OSF1_SS_ONSTACK; + SCARG(&ka, pid) = SCARG(uap, pid); + SCARG(&ka, signum) = osf1_signal_xlist[SCARG(uap, signum)]; + return sys_kill(p, &ka, retval); } +#endif int osf1_sys_sigaction(p, v, retval) @@ -228,20 +73,13 @@ osf1_sys_sigaction(p, v, retval) void *v; register_t *retval; { - struct osf1_sys_sigaction_args /* { - syscallarg(int) signum; - syscallarg(struct osf1_sigaction *) nsa; - syscallarg(struct osf1_sigaction *) osa; - } */ *uap = v; + struct osf1_sys_sigaction_args *uap = v; struct osf1_sigaction *nosa, *oosa, tmposa; struct sigaction *nbsa, *obsa, tmpbsa; struct sys_sigaction_args sa; caddr_t sg; int error; - if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= OSF1_NSIG) - return (EINVAL); - sg = stackgap_init(p->p_emul); nosa = SCARG(uap, nsa); oosa = SCARG(uap, osa); @@ -255,23 +93,24 @@ osf1_sys_sigaction(p, v, retval) nbsa = stackgap_alloc(&sg, sizeof(struct sigaction)); if ((error = copyin(nosa, &tmposa, sizeof(tmposa))) != 0) return error; - osf1_to_bsd_sigaction(&tmposa, &tmpbsa); + osf1_cvt_sigaction_to_native(&tmposa, &tmpbsa); if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0) return error; } else nbsa = NULL; - SCARG(&sa, signum) = osf1_to_bsd_sig[SCARG(uap, signum)]; + SCARG(&sa, signum) = osf1_signal_xlist[SCARG(uap, signum)]; SCARG(&sa, nsa) = nbsa; SCARG(&sa, osa) = obsa; + /* XXX */ if ((error = sys_sigaction(p, &sa, retval)) != 0) return error; if (oosa != NULL) { if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0) return error; - bsd_to_osf1_sigaction(&tmpbsa, &tmposa); + osf1_cvt_sigaction_from_native(&tmpbsa, &tmposa); if ((error = copyout(&tmposa, oosa, sizeof(tmposa))) != 0) return error; } @@ -281,14 +120,11 @@ osf1_sys_sigaction(p, v, retval) int osf1_sys_sigaltstack(p, v, retval) - register struct proc *p; + struct proc *p; void *v; register_t *retval; { - struct osf1_sys_sigaltstack_args /* { - syscallarg(struct osf1_sigaltstack *) nss; - syscallarg(struct osf1_sigaltstack *) oss; - } */ *uap = v; + struct osf1_sys_sigaltstack_args *uap = v; struct osf1_sigaltstack *noss, *ooss, tmposs; struct sigaltstack *nbss, *obss, tmpbss; struct sys_sigaltstack_args sa; @@ -308,7 +144,8 @@ osf1_sys_sigaltstack(p, v, retval) nbss = stackgap_alloc(&sg, sizeof(struct sigaltstack)); if ((error = copyin(noss, &tmposs, sizeof(tmposs))) != 0) return error; - osf1_to_bsd_sigaltstack(&tmposs, &tmpbss); + if ((error = osf1_cvt_sigaltstack_to_native(&tmposs, &tmpbss)) != 0) + return error; if ((error = copyout(&tmpbss, nbss, sizeof(tmpbss))) != 0) return error; } else @@ -317,13 +154,14 @@ osf1_sys_sigaltstack(p, v, retval) SCARG(&sa, nss) = nbss; SCARG(&sa, oss) = obss; + /* XXX */ if ((error = sys_sigaltstack(p, &sa, retval)) != 0) return error; if (obss != NULL) { if ((error = copyin(obss, &tmpbss, sizeof(tmpbss))) != 0) return error; - bsd_to_osf1_sigaltstack(&tmpbss, &tmposs); + osf1_cvt_sigaltstack_from_native(&tmpbss, &tmposs); if ((error = copyout(&tmposs, ooss, sizeof(tmposs))) != 0) return error; } @@ -334,24 +172,21 @@ osf1_sys_sigaltstack(p, v, retval) #if 0 int osf1_sys_signal(p, v, retval) - register struct proc *p; + struct proc *p; void *v; register_t *retval; { - struct osf1_sys_signal_args /* { - syscallarg(int) signum; - syscallarg(osf1_sig_t) handler; - } */ *uap = v; - int signum, error; + struct osf1_sys_signal_args *uap = v; + int signum = osf1_signal_xlist[OSF1_SIGNO(SCARG(uap, signum))]; + int error; caddr_t sg = stackgap_init(p->p_emul); - if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= OSF1_NSIG) + if (signum <= 0 || signum >= OSF1_NSIG) { if (OSF1_SIGCALL(SCARG(uap, signum)) == OSF1_SIGNAL_MASK || OSF1_SIGCALL(SCARG(uap, signum)) == OSF1_SIGDEFER_MASK) *retval = (int)OSF1_SIG_ERR; return EINVAL; } - int signum = osf1_to_bsd_sig[signum]; switch (OSF1_SIGCALL(SCARG(uap, signum))) { case OSF1_SIGDEFER_MASK: @@ -455,23 +290,35 @@ osf1_sys_signal(p, v, retval) } int +osf1_sys_sigpending(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_sigpending_args *uap = v; + sigset_t bss; + osf1_sigset_t oss; + + bss = p->p_siglist & p->p_sigmask; + osf1_cvt_sigset_from_native(&bss, &oss); + + return copyout(&oss, SCARG(uap, mask), sizeof(oss)); +} + +int osf1_sys_sigprocmask(p, v, retval) - register struct proc *p; + struct proc *p; void *v; register_t *retval; { - struct osf1_sys_sigprocmask_args /* { - syscallarg(int) how; - syscallarg(osf1_sigset_t *) set; - syscallarg(osf1_sigset_t *) oset; - } */ *uap = v; + struct osf1_sys_sigprocmask_args *uap = v; osf1_sigset_t oss; sigset_t bss; int error = 0; if (SCARG(uap, oset) != NULL) { /* Fix the return value first if needed */ - bsd_to_osf1_sigset(&p->p_sigmask, &oss); + osf1_cvt_sigset_from_native(&p->p_sigmask, &oss); if ((error = copyout(&oss, SCARG(uap, oset), sizeof(oss))) != 0) return error; } @@ -483,7 +330,7 @@ osf1_sys_sigprocmask(p, v, retval) if ((error = copyin(SCARG(uap, set), &oss, sizeof(oss))) != 0) return error; - osf1_to_bsd_sigset(&oss, &bss); + osf1_cvt_sigset_to_native(&oss, &bss); (void) splhigh(); @@ -511,32 +358,12 @@ osf1_sys_sigprocmask(p, v, retval) } int -osf1_sys_sigpending(p, v, retval) - register struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_sigpending_args /* { - syscallarg(osf1_sigset_t *) mask; - } */ *uap = v; - sigset_t bss; - osf1_sigset_t oss; - - bss = p->p_siglist & p->p_sigmask; - bsd_to_osf1_sigset(&bss, &oss); - - return copyout(&oss, SCARG(uap, mask), sizeof(oss)); -} - -int osf1_sys_sigsuspend(p, v, retval) - register struct proc *p; + struct proc *p; void *v; register_t *retval; { - struct osf1_sys_sigsuspend_args /* { - syscallarg(osf1_sigset_t *) ss; - } */ *uap = v; + struct osf1_sys_sigsuspend_args *uap = v; osf1_sigset_t oss; sigset_t bss; struct sys_sigsuspend_args sa; @@ -545,28 +372,9 @@ osf1_sys_sigsuspend(p, v, retval) if ((error = copyin(SCARG(uap, ss), &oss, sizeof(oss))) != 0) return error; - osf1_to_bsd_sigset(&oss, &bss); + osf1_cvt_sigset_to_native(&oss, &bss); SCARG(&sa, mask) = bss; return sys_sigsuspend(p, &sa, retval); } - -int -osf1_sys_kill(p, v, retval) - register struct proc *p; - void *v; - register_t *retval; -{ - struct osf1_sys_kill_args /* { - syscallarg(int) pid; - syscallarg(int) signum; - } */ *uap = v; - struct sys_kill_args ka; - - if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= OSF1_NSIG) - return (EINVAL); - SCARG(&ka, pid) = SCARG(uap, pid); - SCARG(&ka, signum) = osf1_to_bsd_sig[SCARG(uap, signum)]; - return sys_kill(p, &ka, retval); -} #endif diff --git a/sys/compat/osf1/osf1_signal.h b/sys/compat/osf1/osf1_signal.h index 08183d59579..a224df51cb6 100644 --- a/sys/compat/osf1/osf1_signal.h +++ b/sys/compat/osf1/osf1_signal.h @@ -1,4 +1,7 @@ -/* $OpenBSD: osf1_signal.h,v 1.3 1998/02/17 01:48:08 millert Exp $ */ +/* $OpenBSD: osf1_signal.h,v 1.4 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_signal.h,v 1.5 1999/05/01 02:57:11 cgd Exp $ */ + +/* XXX OUT OF DATE, some of the non-signal number bits here don't belong */ #ifndef _OSF1_SIGNAL_H #define _OSF1_SIGNAL_H @@ -45,38 +48,4 @@ #define OSF1_SIG_UNBLOCK 2 #define OSF1_SIG_SETMASK 3 -typedef u_long osf1_sigset_t; -typedef void (*osf1_handler_t) __P((int)); - -struct osf1_sigaction { - osf1_handler_t sa__handler; - osf1_sigset_t sa_mask; - int sa_flags; -}; - -struct osf1_sigaltstack { - caddr_t ss_sp; - int ss_flags; - size_t ss_size; -}; - -/* sa_flags */ -#define OSF1_SA_ONSTACK 0x00000001 -#define OSF1_SA_RESTART 0x00000002 -#define OSF1_SA_NOCLDSTOP 0x00000004 -#define OSF1_SA_NODEFER 0x00000008 -#define OSF1_SA_RESETHAND 0x00000010 -#define OSF1_SA_NOCLDWAIT 0x00000020 -#define OSF1_SA_SIGINFO 0x00000040 - -/* ss_flags */ -#define OSF1_SS_ONSTACK 0x00000001 -#define OSF1_SS_DISABLE 0x00000002 - -extern int osf1_to_bsd_sig[]; -void bsd_to_osf1_sigaltstack __P((const struct sigaltstack *, struct osf1_sigaltstack *)); -void bsd_to_osf1_sigset __P((const sigset_t *, osf1_sigset_t *)); -void osf1_to_bsd_sigaltstack __P((const struct osf1_sigaltstack *, struct sigaltstack *)); -void osf1_to_bsd_sigset __P((const osf1_sigset_t *, sigset_t *)); - #endif /* !_OSF1_SIGNAL_H */ diff --git a/sys/compat/osf1/osf1_socket.c b/sys/compat/osf1/osf1_socket.c new file mode 100644 index 00000000000..846ee8090ed --- /dev/null +++ b/sys/compat/osf1/osf1_socket.c @@ -0,0 +1,229 @@ +/* $OpenBSD: osf1_socket.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_socket.c,v 1.4 1999/05/10 01:58:37 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 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. + */ + +/* + * Copyright (c) 1994, 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Chris G. Demetriou + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <sys/socketvar.h> +#include <sys/exec.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_util.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_recvmsg_xopen(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + /* XXX */ + return (EINVAL); +} + +int +osf1_sys_sendmsg_xopen(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_sendmsg_xopen_args *uap = v; + struct sys_sendmsg_args a; + struct osf1_msghdr_xopen osf_msghdr; + struct osf1_iovec_xopen osf_iovec, *osf_iovec_ptr; + struct msghdr bsd_msghdr; + struct iovec bsd_iovec, *bsd_iovec_ptr; + unsigned long leftovers; + caddr_t sg; + unsigned int i; + int error; + + sg = stackgap_init(p->p_emul); + + SCARG(&a, s) = SCARG(uap, s); + + /* + * translate msghdr structure + */ + if ((error = copyin(SCARG(uap, msg), &osf_msghdr, + sizeof osf_msghdr)) != 0) + return (error); + + error = osf1_cvt_msghdr_xopen_to_native(&osf_msghdr, &bsd_msghdr); + if (error != 0) + return (error); + + if (STACKGAPLEN < (bsd_msghdr.msg_iovlen * sizeof (struct iovec) + + sizeof (struct msghdr))) +{ +printf("sendmsg space\n"); + return (EINVAL); +} + + SCARG(&a, msg) = stackgap_alloc(&sg, sizeof bsd_msghdr); + bsd_msghdr.msg_iov = stackgap_alloc(&sg, + bsd_msghdr.msg_iovlen * sizeof (struct iovec)); + + if ((error = copyout(&bsd_msghdr, (caddr_t)SCARG(&a, msg), + sizeof bsd_msghdr)) != 0) + return (error); + + osf_iovec_ptr = osf_msghdr.msg_iov; + bsd_iovec_ptr = bsd_msghdr.msg_iov; + for (i = 0; i < bsd_msghdr.msg_iovlen; i++) { + if ((error = copyin(&osf_iovec_ptr[i], &osf_iovec, + sizeof osf_iovec)) != 0) + return (error); + + bsd_iovec.iov_base = osf_iovec.iov_base; + bsd_iovec.iov_len = osf_iovec.iov_len; + + if ((error = copyout(&bsd_iovec, &bsd_iovec_ptr[i], + sizeof bsd_iovec)) != 0) + return (error); + } + + /* + * translate flags + */ + SCARG(&a, flags) = emul_flags_translate(osf1_sendrecv_msg_flags_xtab, + SCARG(uap, flags), &leftovers); + if (leftovers != 0) +{ +printf("sendmsg flags leftover: 0x%lx\n", leftovers); + return (EINVAL); +} + + return sys_sendmsg(p, &a, retval); +} + +int +osf1_sys_sendto(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_sendto_args *uap = v; + struct sys_sendto_args a; + unsigned long leftovers; + + SCARG(&a, s) = SCARG(uap, s); + SCARG(&a, buf) = SCARG(uap, buf); + SCARG(&a, len) = SCARG(uap, len); + SCARG(&a, to) = SCARG(uap, to); + SCARG(&a, tolen) = SCARG(uap, tolen); + + /* translate flags */ + SCARG(&a, flags) = emul_flags_translate(osf1_sendrecv_msg_flags_xtab, + SCARG(uap, flags), &leftovers); + if (leftovers != 0) + return (EINVAL); + + return sys_sendto(p, &a, retval); +} + +int +osf1_sys_socket(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_socket_args *uap = v; + struct sys_socket_args a; + + /* XXX TRANSLATE */ + + if (SCARG(uap, domain) > AF_LINK) + return (EINVAL); /* XXX After AF_LINK, divergence. */ + + SCARG(&a, domain) = SCARG(uap, domain); + SCARG(&a, type) = SCARG(uap, type); + SCARG(&a, protocol) = SCARG(uap, protocol); + + return sys_socket(p, &a, retval); +} + +int +osf1_sys_socketpair(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_socketpair_args *uap = v; + struct sys_socketpair_args a; + + /* XXX TRANSLATE */ + + if (SCARG(uap, domain) > AF_LINK) + return (EINVAL); /* XXX After AF_LINK, divergence. */ + + SCARG(&a, domain) = SCARG(uap, domain); + SCARG(&a, type) = SCARG(uap, type); + SCARG(&a, protocol) = SCARG(uap, protocol); + SCARG(&a, rsv) = SCARG(uap, rsv); + + return sys_socketpair(p, &a, retval); +} diff --git a/sys/compat/osf1/osf1_sysv_ipc.c b/sys/compat/osf1/osf1_sysv_ipc.c new file mode 100644 index 00000000000..ae9debabb48 --- /dev/null +++ b/sys/compat/osf1/osf1_sysv_ipc.c @@ -0,0 +1,88 @@ +/* $OpenBSD: osf1_sysv_ipc.c,v 1.1 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_sysv_ipc.c,v 1.1 1999/05/04 04:59:21 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_shmat(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + /* XXX */ + return (ENOSYS); +} + +int +osf1_sys_shmctl(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + /* XXX */ + return (ENOSYS); +} + +int +osf1_sys_shmdt(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + /* XXX */ + return (ENOSYS); +} + +int +osf1_sys_shmget(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + /* XXX */ + return (ENOSYS); +} diff --git a/sys/compat/osf1/osf1_time.c b/sys/compat/osf1/osf1_time.c new file mode 100644 index 00000000000..813e4f2d8fd --- /dev/null +++ b/sys/compat/osf1/osf1_time.c @@ -0,0 +1,238 @@ +/* $NetBSD: osf1_time.c,v 1.1 1999/05/01 05:25:37 cgd Exp $ */ + +/* + * Copyright (c) 1999 Christopher G. Demetriou. 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 Christopher G. Demetriou + * for the NetBSD Project. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> + +#include <compat/osf1/osf1.h> +#include <compat/osf1/osf1_syscallargs.h> +#include <compat/osf1/osf1_cvt.h> + +int +osf1_sys_gettimeofday(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_gettimeofday_args *uap = v; + struct sys_gettimeofday_args a; + struct osf1_timeval otv; + struct osf1_timezone otz; + struct timeval tv; + struct timezone tz; + int error; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + if (SCARG(uap, tp) == NULL) + SCARG(&a, tp) = NULL; + else + SCARG(&a, tp) = stackgap_alloc(&sg, sizeof tv); + if (SCARG(uap, tzp) == NULL) + SCARG(&a, tzp) = NULL; + else + SCARG(&a, tzp) = stackgap_alloc(&sg, sizeof tz); + + error = sys_gettimeofday(p, &a, retval); + + if (error == 0 && SCARG(uap, tp) != NULL) { + error = copyin((caddr_t)SCARG(&a, tp), + (caddr_t)&tv, sizeof tv); + if (error == 0) { + memset(&otv, 0, sizeof otv); + otv.tv_sec = tv.tv_sec; + otv.tv_usec = tv.tv_usec; + + error = copyout((caddr_t)&otv, + (caddr_t)SCARG(uap, tp), sizeof otv); + } + } + if (error == 0 && SCARG(uap, tzp) != NULL) { + error = copyin((caddr_t)SCARG(&a, tzp), + (caddr_t)&tz, sizeof tz); + if (error == 0) { + memset(&otz, 0, sizeof otz); + otz.tz_minuteswest = tz.tz_minuteswest; + otz.tz_dsttime = tz.tz_dsttime; + + error = copyout((caddr_t)&otz, + (caddr_t)SCARG(uap, tzp), sizeof otz); + } + } + return (error); +} + +int +osf1_sys_setitimer(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_setitimer_args *uap = v; + struct sys_setitimer_args a; + struct osf1_itimerval o_itv, o_oitv; + struct itimerval b_itv, b_oitv; + caddr_t sg; + int error; + + switch (SCARG(uap, which)) { + case OSF1_ITIMER_REAL: + SCARG(&a, which) = ITIMER_REAL; + break; + + case OSF1_ITIMER_VIRTUAL: + SCARG(&a, which) = ITIMER_VIRTUAL; + break; + + case OSF1_ITIMER_PROF: + SCARG(&a, which) = ITIMER_PROF; + break; + + default: + return (EINVAL); + } + + sg = stackgap_init(p->p_emul); + + SCARG(&a, itv) = stackgap_alloc(&sg, sizeof b_itv); + + /* get the OSF/1 itimerval argument */ + error = copyin((caddr_t)SCARG(uap, itv), (caddr_t)&o_itv, + sizeof o_itv); + if (error == 0) { + + /* fill in and copy out the NetBSD timeval */ + memset(&b_itv, 0, sizeof b_itv); + b_itv.it_interval.tv_sec = o_itv.it_interval.tv_sec; + b_itv.it_interval.tv_usec = o_itv.it_interval.tv_usec; + b_itv.it_value.tv_sec = o_itv.it_value.tv_sec; + b_itv.it_value.tv_usec = o_itv.it_value.tv_usec; + + error = copyout((caddr_t)&b_itv, + (caddr_t)SCARG(&a, itv), sizeof b_itv); + } + + if (SCARG(uap, oitv) == NULL) + SCARG(&a, oitv) = NULL; + else + SCARG(&a, oitv) = stackgap_alloc(&sg, sizeof b_oitv); + + if (error == 0) + error = sys_setitimer(p, &a, retval); + + if (error == 0 && SCARG(uap, oitv) != NULL) { + /* get the NetBSD itimerval return value */ + error = copyin((caddr_t)SCARG(&a, oitv), (caddr_t)&b_oitv, + sizeof b_oitv); + if (error == 0) { + + /* fill in and copy out the NetBSD timeval */ + memset(&o_oitv, 0, sizeof o_oitv); + o_oitv.it_interval.tv_sec = b_oitv.it_interval.tv_sec; + o_oitv.it_interval.tv_usec = b_oitv.it_interval.tv_usec; + o_oitv.it_value.tv_sec = b_oitv.it_value.tv_sec; + o_oitv.it_value.tv_usec = b_oitv.it_value.tv_usec; + + error = copyout((caddr_t)&o_oitv, + (caddr_t)SCARG(uap, oitv), sizeof o_oitv); + } + } + + return (error); +} + +int +osf1_sys_settimeofday(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct osf1_sys_settimeofday_args *uap = v; + struct sys_settimeofday_args a; + struct osf1_timeval otv; + struct osf1_timezone otz; + struct timeval tv; + struct timezone tz; + int error; + caddr_t sg; + + sg = stackgap_init(p->p_emul); + if (SCARG(uap, tv) == NULL) + SCARG(&a, tv) = NULL; + else { + SCARG(&a, tv) = stackgap_alloc(&sg, sizeof tv); + + /* get the OSF/1 timeval argument */ + error = copyin((caddr_t)SCARG(uap, tv), + (caddr_t)&otv, sizeof otv); + if (error == 0) { + + /* fill in and copy out the NetBSD timeval */ + memset(&tv, 0, sizeof tv); + tv.tv_sec = otv.tv_sec; + tv.tv_usec = otv.tv_usec; + + error = copyout((caddr_t)&tv, + (caddr_t)SCARG(&a, tv), sizeof tv); + } + } + + if (SCARG(uap, tzp) == NULL) + SCARG(&a, tzp) = NULL; + else { + SCARG(&a, tzp) = stackgap_alloc(&sg, sizeof tz); + + /* get the OSF/1 timeval argument */ + error = copyin((caddr_t)SCARG(uap, tzp), + (caddr_t)&otz, sizeof otz); + if (error == 0) { + + /* fill in and copy out the NetBSD timezone */ + memset(&tz, 0, sizeof tz); + tz.tz_minuteswest = otz.tz_minuteswest; + tz.tz_dsttime = otz.tz_dsttime; + + error = copyout((caddr_t)&tz, + (caddr_t)SCARG(&a, tzp), sizeof tz); + } + } + + if (error == 0) + error = sys_settimeofday(p, &a, retval); + + return (error); +} diff --git a/sys/compat/osf1/osf1_util.h b/sys/compat/osf1/osf1_util.h index 87cc309774d..1470b8b7a25 100644 --- a/sys/compat/osf1/osf1_util.h +++ b/sys/compat/osf1/osf1_util.h @@ -1,3 +1,17 @@ -/* $OpenBSD: osf1_util.h,v 1.2 1996/08/02 20:35:29 niklas Exp $ */ +/* $OpenBSD: osf1_util.h,v 1.3 2000/08/04 15:47:55 ericj Exp $ */ +/* $NetBSD: osf1_util.h,v 1.4 1999/04/23 05:55:13 cgd Exp $ */ + +#ifndef _COMPAT_OSF1_OSF1_UTIL_H_ +#define _COMPAT_OSF1_OSF1_UTIL_H_ #include <compat/common/compat_util.h> + +extern const char osf1_emul_path[]; + +#define OSF1_CHECK_ALT_EXIST(p, sgp, path) \ + CHECK_ALT_EXIST(p, sgp, osf1_emul_path, path) + +#define OSF1_CHECK_ALT_CREAT(p, sgp, path) \ + CHECK_ALT_CREAT(p, sgp, osf1_emul_path, path) + +#endif /* _COMPAT_OSF1_OSF1_UTIL_H_ */ diff --git a/sys/compat/osf1/syscalls.conf b/sys/compat/osf1/syscalls.conf index aa6d4a59c92..51dfa388f60 100644 --- a/sys/compat/osf1/syscalls.conf +++ b/sys/compat/osf1/syscalls.conf @@ -1,5 +1,5 @@ -# $OpenBSD: syscalls.conf,v 1.2 1996/08/02 20:35:30 niklas Exp $ -# $NetBSD: syscalls.conf,v 1.1 1995/02/13 21:39:08 cgd Exp $ +# $OpenBSD: syscalls.conf,v 1.3 2000/08/04 15:47:55 ericj Exp $ +# $NetBSD: syscalls.conf,v 1.1 1994/08/21 19:27:06 cgd Exp $ sysnames="osf1_syscalls.c" sysnumhdr="osf1_syscall.h" diff --git a/sys/compat/osf1/syscalls.master b/sys/compat/osf1/syscalls.master index 3b10ea400bb..c91e636465b 100644 --- a/sys/compat/osf1/syscalls.master +++ b/sys/compat/osf1/syscalls.master @@ -1,9 +1,9 @@ -; $OpenBSD: syscalls.master,v 1.7 2000/07/21 19:26:39 ericj Exp $ -; $NetBSD: syscalls.master,v 1.2 1995/10/07 06:27:28 mycroft Exp $ + $OpenBSD: syscalls.master,v 1.8 2000/08/04 15:47:55 ericj Exp $ +; $NetBSD: syscalls.master,v 1.29 1999/05/10 03:33:04 cgd Exp $ ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93 -; OpenBSD COMPAT_OSF1 system call name/number "master" file. +; NetBSD COMPAT_OSF1 system call name/number "master" file. ; (See syscalls.conf to see what it is processed into.) ; ; Fields: number type [type-dependent ...] @@ -30,7 +30,7 @@ ; [comment] ; ; #ifdef's, etc. may be included, and are copied to the output files. -; #include's are copied to the syscall switch definition file only. +; #include's are copied to the syscall names and switch definition files only. #include <sys/param.h> #include <sys/systm.h> @@ -39,46 +39,52 @@ #include <sys/poll.h> #include <sys/syscallargs.h> +#include <compat/osf1/osf1.h> #include <compat/osf1/osf1_syscallargs.h> 0 NOARGS { int sys_nosys(void); } syscall 1 NOARGS { int sys_exit(int rval); } 2 NOARGS { int sys_fork(void); } 3 NOARGS { int sys_read(int fd, char *buf, u_int nbyte); } -4 NOARGS { int sys_write(int fd, char *buf, u_int nbyte); } +4 NOARGS { int sys_write(int fd, const char *buf, \ + u_int nbyte); } 5 UNIMPL old open 6 NOARGS { int sys_close(int fd); } -7 NOARGS { int sys_wait4(int pid, int *status, int options, \ - struct rusage *rusage); } +7 STD { int osf1_sys_wait4(int pid, int *status, \ + int options, struct osf1_rusage *rusage); } 8 UNIMPL old creat -9 NOARGS { int sys_link(char *path, char *link); } -10 NOARGS { int sys_unlink(char *path); } +9 NOARGS { int sys_link(const char *path, const char *link); } +10 NOARGS { int sys_unlink(const char *path); } 11 UNIMPL execv -12 NOARGS { int sys_chdir(char *path); } +12 NOARGS { int sys_chdir(const char *path); } 13 NOARGS { int sys_fchdir(int fd); } -14 STD { int osf1_sys_mknod(char *path, int mode, int dev); } -15 NOARGS { int sys_chmod(char *path, int mode); } -16 NOARGS { int sys_chown(char *path, int uid, int gid); } +14 STD { int osf1_sys_mknod(char *path, int mode, \ + int dev); } +15 NOARGS { int sys_chmod(const char *path, int mode); } +16 NOARGS { int sys_chown(const char *path, int uid, \ + int gid); } 17 NOARGS { int sys_obreak(char *nsize); } 18 STD { int osf1_sys_getfsstat(struct osf1_statfs *buf, \ long bufsize, int flags); } 19 STD { off_t osf1_sys_lseek(int fd, off_t offset, \ int whence); } 20 NOARGS { pid_t sys_getpid(void); } -21 STD { int osf1_sys_mount(int type, char *path, int flags, \ - caddr_t data); } -22 STD { int osf1_sys_unmount(char *path, int flags); } +21 STD { int osf1_sys_mount(int type, const char *path, \ + int flags, caddr_t data); } +22 STD { int osf1_sys_unmount(const char *path, int flags); } 23 STD { int osf1_sys_setuid(uid_t uid); } 24 NOARGS { uid_t sys_getuid(void); } 25 UNIMPL exec_with_loader 26 UNIMPL ptrace -27 UNIMPL recvmsg -28 UNIMPL sendmsg +27 STD { int osf1_sys_recvmsg_xopen(int s, \ + struct osf1_msghdr_xopen *msg, int flags); } +28 STD { int osf1_sys_sendmsg_xopen(int s, \ + const struct osf1_msghdr_xopen *msg, int flags); } 29 UNIMPL recvfrom 30 UNIMPL accept 31 UNIMPL getpeername 32 UNIMPL getsockname -33 NOARGS { int sys_access(char *path, int flags); } +33 STD { int osf1_sys_access(char *path, int flags); } 34 UNIMPL chflags 35 UNIMPL fchflags 36 NOARGS { int sys_sync(void); } @@ -87,33 +93,41 @@ 39 NOARGS { int sys_setpgid(int pid, int pgid); } 40 UNIMPL old lstat 41 NOARGS { int sys_dup(u_int fd); } -42 NOARGS { int sys_opipe(void); } -43 UNIMPL set_program_attributes +42 NOARGS { int sys_pipe(void); } +43 STD { int osf1_sys_set_program_attributes( \ + caddr_t taddr, unsigned long tsize, \ + caddr_t daddr, unsigned long dsize); } 44 UNIMPL profil -45 STD { int osf1_sys_open(char *path, int flags, int mode); } +45 STD { int osf1_sys_open(char *path, int flags, \ + int mode); } 46 OBSOL sigaction 47 NOARGS { gid_t sys_getgid(void); } +; XXX 48 NOARGS { int sys_sigprocmask(int how, sigset_t mask); } 49 NOARGS { int sys_getlogin(char *namebuf, u_int namelen); } -50 NOARGS { int sys_setlogin(char *namebuf); } -51 NOARGS { int sys_acct(char *path); } +50 NOARGS { int sys_setlogin(const char *namebuf); } +51 NOARGS { int sys_acct(const char *path); } 52 UNIMPL sigpending -53 UNIMPL +53 STD { int osf1_sys_classcntl(int opcode, int arg1, \ + int arg2, int arg3); } 54 STD { int osf1_sys_ioctl(int fd, int com, caddr_t data); } 55 STD { int osf1_sys_reboot(int opt); } -56 NOARGS { int sys_revoke(char *path); } -57 NOARGS { int sys_symlink(char *path, char *link); } -58 NOARGS { int sys_readlink(char *path, char *buf, int count); } -59 STD { int osf1_sys_execve(char *path, char **argp, \ - char **envp); } +56 NOARGS { int sys_revoke(const char *path); } +57 NOARGS { int sys_symlink(const char *path, \ + const char *link); } +58 NOARGS { int sys_readlink(const char *path, char *buf, \ + int count); } +59 STD { int osf1_sys_execve(char *path, \ + char * const *argp, char * const *envp); } 60 NOARGS { int sys_umask(int newmask); } -61 NOARGS { int sys_chroot(char *path); } +61 NOARGS { int sys_chroot(const char *path); } 62 UNIMPL old fstat 63 NOARGS { int sys_getpgrp(void); } 64 NOARGS { int compat_43_sys_getpagesize(void); } 65 UNIMPL mremap 66 NOARGS { int sys_vfork(void); } -67 STD { int osf1_sys_stat(char *path, struct osf1_stat *ub); } +67 STD { int osf1_sys_stat(char *path, \ + struct osf1_stat *ub); } 68 STD { int osf1_sys_lstat(char *path, \ struct osf1_stat *ub); } 69 UNIMPL sbrk @@ -122,9 +136,10 @@ int prot, int flags, int fd, off_t pos); } 72 UNIMPL ovadvise 73 NOARGS { int sys_munmap(caddr_t addr, size_t len); } -74 UNIMPL mprotect -; XXX -75 STD { int osf1_sys_madvise(void); } +74 STD { int osf1_sys_mprotect(void *addr, size_t len, \ + int prot); } +75 STD { int osf1_sys_madvise(void *addr, size_t len, \ + int behav); } 76 UNIMPL old vhangup 77 UNIMPL kmodcall 78 UNIMPL mincore @@ -133,23 +148,25 @@ 81 UNIMPL old getpgrp ; OSF/1 setpgrp(); identical in function to setpgid(). XXX 82 NOARGS { int sys_setpgid(int pid, int pgid); } setpgrp -83 NOARGS { int sys_setitimer(u_int which, \ - struct itimerval *itv, struct itimerval *oitv); } +83 STD { int osf1_sys_setitimer(u_int which, \ + struct osf1_itimerval *itv, \ + struct osf1_itimerval *oitv); } 84 UNIMPL old wait 85 UNIMPL table 86 UNIMPL getitimer 87 NOARGS { int compat_43_sys_gethostname(char *hostname, \ u_int len); } -88 NOARGS { int compat_43_sys_sethostname(char *hostname, \ +88 NOARGS { int compat_43_sys_sethostname(const char *hostname, \ u_int len); } 89 NOARGS { int compat_43_sys_getdtablesize(void); } 90 NOARGS { int sys_dup2(u_int from, u_int to); } 91 STD { int osf1_sys_fstat(int fd, void *sb); } 92 STD { int osf1_sys_fcntl(int fd, int cmd, void *arg); } -93 NOARGS { int sys_select(u_int nd, fd_set *in, fd_set *ou, \ - fd_set *ex, struct timeval *tv); } -94 STD { int osf1_sys_poll(struct pollfd *fds, \ - unsigned int nfds, int timeout); } +93 STD { int osf1_sys_select(u_int nd, fd_set *in, \ + fd_set *ou, fd_set *ex, struct osf1_timeval *tv); } +; maybe XXX +94 NOARGS { int sys_poll(struct pollfd *fds, u_int nfds, \ + int timeout); } 95 NOARGS { int sys_fsync(int fd); } 96 NOARGS { int sys_setpriority(int which, int who, int prio); } 97 STD { int osf1_sys_socket(int domain, int type, \ @@ -165,7 +182,7 @@ 103 NOARGS { int sys_sigreturn(struct sigcontext *sigcntxp); } 104 NOARGS { int sys_bind(int s, caddr_t name, int namelen); } 105 NOARGS { int sys_setsockopt(int s, int level, int name, \ - caddr_t val, int valsize); } + caddr_t val, int valsize); } 106 NOARGS { int sys_listen(int s, int backlog); } 107 UNIMPL plock 108 UNIMPL old sigvec @@ -176,20 +193,21 @@ struct sigstack *oss); } 113 UNIMPL old recvmsg 114 UNIMPL old sendmsg -115 UNIMPL vtrace -116 NOARGS { int sys_gettimeofday(struct timeval *tp, \ - struct timezone *tzp); } +115 OBSOL vtrace +116 STD { int osf1_sys_gettimeofday(struct osf1_timeval *tp, \ + struct osf1_timezone *tzp); } +117 STD { int osf1_sys_getrusage(int who, \ + struct osf1_rusage *rusage); } ; XXX -117 STD { int osf1_sys_getrusage(void); } 118 NOARGS { int sys_getsockopt(int s, int level, int name, \ - caddr_t val, int *avalsize); } + caddr_t val, int *avalsize); } 119 UNIMPL -120 STD { int osf1_sys_readv(int fd, struct osf1_iovec *iovp, \ - u_int iovcnt); } -121 STD { int osf1_sys_writev(int fd, struct osf1_iovec *iovp, \ - u_int iovcnt); } -122 NOARGS { int sys_settimeofday(struct timeval *tv, \ - struct timezone *tzp); } +120 STD { int osf1_sys_readv(int fd, \ + struct osf1_iovec *iovp, u_int iovcnt); } +121 STD { int osf1_sys_writev(int fd, \ + struct osf1_iovec *iovp, u_int iovcnt); } +122 STD { int osf1_sys_settimeofday(struct osf1_timeval *tv, \ + struct osf1_timezone *tzp); } 123 NOARGS { int sys_fchown(int fd, int uid, int gid); } 124 NOARGS { int sys_fchmod(int fd, int mode); } 125 NOARGS { int compat_43_sys_recvfrom(int s, caddr_t buf, \ @@ -197,54 +215,63 @@ int *fromlenaddr); } 126 UNIMPL setreuid 127 UNIMPL setregid -128 NOARGS { int sys_rename(char *from, char *to); } -129 STD { int osf1_sys_truncate(char *path, off_t length); } +128 NOARGS { int sys_rename(const char *from, \ + const char *to); } +129 STD { int osf1_sys_truncate(char *path, \ + off_t length); } 130 STD { int osf1_sys_ftruncate(int fd, off_t length); } 131 UNIMPL flock 132 STD { int osf1_sys_setgid(gid_t gid); } -133 STD { int osf1_sys_sendto(int s, const void *buf, \ - size_t len, int flags, const struct sockaddr *to, \ - int tolen); } +133 STD { int osf1_sys_sendto(int s, caddr_t buf, size_t len, \ + int flags, struct sockaddr *to, int tolen); } 134 NOARGS { int sys_shutdown(int s, int how); } -135 UNIMPL socketpair -136 NOARGS { int sys_mkdir(char *path, int mode); } -137 NOARGS { int sys_rmdir(char *path); } -138 NOARGS { int sys_utimes(char *path, struct timeval *tptr); } +135 STD { int osf1_sys_socketpair(int domain, int type, \ + int protocol, int *rsv); } +136 NOARGS { int sys_mkdir(const char *path, int mode); } +137 NOARGS { int sys_rmdir(const char *path); } +138 STD { int osf1_sys_utimes(char *path, \ + const struct osf1_timeval *tptr); } 139 OBSOL 4.2 sigreturn 140 UNIMPL adjtime -141 UNIMPL old getpeername +141 NOARGS { int compat_43_sys_getpeername(int fdes, \ + caddr_t asa, int *alen); } 142 NOARGS { int32_t compat_43_sys_gethostid(void); } 143 NOARGS { int compat_43_sys_sethostid(int32_t hostid); } +; XXX 144 STD { int osf1_sys_getrlimit(u_int which, \ struct rlimit *rlp); } +; XXX 145 STD { int osf1_sys_setrlimit(u_int which, \ struct rlimit *rlp); } 146 UNIMPL old killpg 147 NOARGS { int sys_setsid(void); } 148 UNIMPL quotactl 149 NOARGS { int compat_43_sys_quota(void); } -150 UNIMPL old getsockname -151 UNIMPL -152 UNIMPL -153 UNIMPL -154 UNIMPL -155 UNIMPL +150 NOARGS { int compat_43_sys_getsockname(int fdec, \ + caddr_t asa, int *alen); } +151 UNIMPL pread +152 UNIMPL pwrite +153 UNIMPL pid_block +154 UNIMPL pid_unblock +155 UNIMPL signal_urti 156 STD { int osf1_sys_sigaction(int signum, \ struct osf1_sigaction *nsa, \ struct osf1_sigaction *osa); } -157 UNIMPL +157 UNIMPL sigwaitprim 158 UNIMPL nfssvc 159 NOARGS { int compat_43_sys_getdirentries(int fd, char *buf, \ u_int count, long *basep); } -160 STD { int osf1_sys_statfs(char *path, \ +160 STD { int osf1_sys_statfs(const char *path, \ struct osf1_statfs *buf, int len); } -161 STD { int osf1_sys_fstatfs(int fd, \ +161 STD { int osf1_sys_fstatfs(int fd, \ struct osf1_statfs *buf, int len); } 162 UNIMPL 163 UNIMPL async_daemon 164 UNIMPL getfh -165 UNIMPL getdomainname -166 UNIMPL setdomainname +165 NOARGS { int compat_09_sys_getdomainname(char *domainname, \ + int len); } +166 NOARGS { int compat_09_sys_setdomainname(char *domainname, \ + int len); } 167 UNIMPL 168 UNIMPL 169 UNIMPL exportfs @@ -285,12 +312,16 @@ 204 UNIMPL semctl 205 UNIMPL semget 206 UNIMPL semop -207 UNIMPL uname -208 NOARGS { int sys_lchown(char *path, int uid, int gid); } -209 UNIMPL shmat -210 UNIMPL shmctl -211 UNIMPL shmdt -212 UNIMPL shmget +207 STD { int osf1_sys_uname(struct osf1_uname *name); } +208 NOARGS { int sys_lchown(const char *path, int uid, \ + int gid); } +209 STD { void *osf1_sys_shmat(int shmid, \ + const void *shmaddr, int shmflg); } +210 STD { int osf1_sys_shmctl(int shmid, int cmd, \ + struct osf1_shmid_ds *buf); } +211 STD { int osf1_sys_shmdt(const void *shmaddr); } +212 STD { int osf1_sys_shmget(osf1_key_t key, size_t size, \ + int flags); } 213 UNIMPL mvalid 214 UNIMPL getaddressconf 215 UNIMPL msleep @@ -312,33 +343,36 @@ 231 UNIMPL 232 UNIMPL 233 UNIMPL getpgid -234 STD { pid_t osf1_sys_getsid(pid_t pid); } -235 STD { int osf1_sys_sigaltstack(struct osf1_sigaltstack *nss, \ +234 NOARGS { pid_t sys_getsid(pid_t pid); } +235 STD { int osf1_sys_sigaltstack( \ + struct osf1_sigaltstack *nss, \ struct osf1_sigaltstack *oss); } 236 UNIMPL waitid 237 UNIMPL priocntlset 238 UNIMPL sigsendset -239 UNIMPL +239 UNIMPL set_speculative 240 UNIMPL msfs_syscall -241 UNIMPL sysinfo +241 STD { int osf1_sys_sysinfo(int cmd, char *buf, long len); } 242 UNIMPL uadmin 243 UNIMPL fuser -244 UNIMPL -245 UNIMPL -246 UNIMPL -247 UNIMPL -248 UNIMPL +244 UNIMPL proplist_syscall +245 UNIMPL ntp_adjtime +246 UNIMPL ntp_gettime +247 STD { long osf1_sys_pathconf(char *path, int name); } +248 STD { long osf1_sys_fpathconf(int fd, int name); } 249 UNIMPL 250 UNIMPL uswitch -251 STD { int osf1_sys_usleep_thread(struct timeval *sleep, \ - struct timeval *slept); } +251 STD { int osf1_sys_usleep_thread( \ + struct osf1_timeval *sleep, \ + struct osf1_timeval *slept); } 252 UNIMPL audcntl 253 UNIMPL audgen 254 UNIMPL sysfs -255 UNIMPL +255 UNIMPL subsys_info 256 UNIMPL getsysinfo 257 STD { int osf1_sys_setsysinfo(u_long op, caddr_t buffer, \ u_long nbytes, caddr_t arg, u_long flag); } 258 UNIMPL afs_syscall 259 UNIMPL swapctl 260 UNIMPL memcntl +261 UNIMPL fdatasync |