Module Name: src
Committed By: maxv
Date: Sun Mar 24 16:24:20 UTC 2019
Modified Files:
src/sys/compat/linux/arch/alpha: files.linux_alpha syscalls.master
src/sys/compat/osf1: files.osf1
Added Files:
src/sys/compat/linux/arch/alpha: linux_osf1.c linux_osf1.h
Log Message:
Remove Alpha's compat_linux dependency on compat_osf1. Each function is
copied as-is from compat_osf1 with no functional change. Discussed on
tech-kern@, ok @thorpej.
To generate a diff of this commit:
cvs rdiff -u -r1.9 -r1.10 src/sys/compat/linux/arch/alpha/files.linux_alpha
cvs rdiff -u -r0 -r1.1 src/sys/compat/linux/arch/alpha/linux_osf1.c \
src/sys/compat/linux/arch/alpha/linux_osf1.h
cvs rdiff -u -r1.94 -r1.95 src/sys/compat/linux/arch/alpha/syscalls.master
cvs rdiff -u -r1.21 -r1.22 src/sys/compat/osf1/files.osf1
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/compat/linux/arch/alpha/files.linux_alpha
diff -u src/sys/compat/linux/arch/alpha/files.linux_alpha:1.9 src/sys/compat/linux/arch/alpha/files.linux_alpha:1.10
--- src/sys/compat/linux/arch/alpha/files.linux_alpha:1.9 Tue May 31 20:53:13 2011
+++ src/sys/compat/linux/arch/alpha/files.linux_alpha Sun Mar 24 16:24:19 2019
@@ -1,8 +1,9 @@
-# $NetBSD: files.linux_alpha,v 1.9 2011/05/31 20:53:13 njoly Exp $
+# $NetBSD: files.linux_alpha,v 1.10 2019/03/24 16:24:19 maxv Exp $
#
# Config file description for alpha-dependent Linux compat code.
file compat/linux/arch/alpha/linux_machdep.c compat_linux
+file compat/linux/arch/alpha/linux_osf1.c compat_linux
file compat/linux/arch/alpha/linux_pipe.c compat_linux
file compat/linux/arch/alpha/linux_syscalls.c compat_linux
file compat/linux/arch/alpha/linux_sysent.c compat_linux
Index: src/sys/compat/linux/arch/alpha/syscalls.master
diff -u src/sys/compat/linux/arch/alpha/syscalls.master:1.94 src/sys/compat/linux/arch/alpha/syscalls.master:1.95
--- src/sys/compat/linux/arch/alpha/syscalls.master:1.94 Fri Feb 3 16:17:08 2017
+++ src/sys/compat/linux/arch/alpha/syscalls.master Sun Mar 24 16:24:19 2019
@@ -1,4 +1,4 @@
- $NetBSD: syscalls.master,v 1.94 2017/02/03 16:17:08 christos Exp $
+ $NetBSD: syscalls.master,v 1.95 2019/03/24 16:24:19 maxv Exp $
;
; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
@@ -78,6 +78,7 @@
;#include <compat/linux/common/linux_machdep.h>
#include <compat/linux/linux_syscallargs.h>
+#include <compat/linux/arch/alpha/linux_osf1.h>
%%
@@ -89,7 +90,7 @@
size_t nbyte); }
5 UNIMPL
6 NOARGS { int|sys||close(int fd); }
-7 NODEF { int|osf1_sys||wait4(int pid, int *status, \
+7 STD { int|linux_sys||osf1_wait4(int pid, int *status, \
int options, struct osf1_rusage *rusage); }
;8 ALIAS osf1_sys_old_creat, NOT USED
8 STD { int|linux_sys||creat(const char *path, linux_umode_t mode); }
@@ -109,7 +110,7 @@
19 NOARGS { long|compat_43_sys||lseek(int fd, long offset, \
int whence); }
20 NOARGS { pid_t|sys||getpid_with_ppid(void); }
-21 NODEF { int|osf1_sys||mount(int type, const char *path, \
+21 STD { int|linux_sys||osf1_mount(int type, const char *path, \
int flags, void *data); }
22 UNIMPL umount
23 NOARGS { int|sys||setuid(uid_t uid); }
@@ -133,7 +134,7 @@
40 UNIMPL
41 NOARGS { int|sys||dup(int fd); }
42 NOARGS { int|linux_sys||pipe(void); }
-43 NODEF { int|osf1_sys||set_program_attributes( \
+43 STD { int|linux_sys||osf1_set_program_attributes( \
void *taddr, unsigned long tsize, \
void *daddr, unsigned long dsize); }
44 UNIMPL
@@ -187,7 +188,7 @@
80 NOARGS { int|sys||setgroups(int gidsetsize, const gid_t *gidset); }
81 UNIMPL
82 UNIMPL setpgrp
-83 NODEF { int|osf1_sys||setitimer(int which, \
+83 STD { int|linux_sys||osf1_setitimer(int which, \
struct osf1_itimerval *itv, \
struct osf1_itimerval *oitv); }
84 UNIMPL
@@ -201,7 +202,7 @@
90 NOARGS { int|sys||dup2(int from, int to); }
91 STD { int|linux_sys||fstat(int fd, struct linux_stat *sp); }
92 STD { int|linux_sys||fcntl(int fd, int cmd, void *arg); }
-93 NODEF { int|osf1_sys||select(u_int nd, fd_set *in, \
+93 STD { int|linux_sys||osf1_select(u_int nd, fd_set *in, \
fd_set *ou, fd_set *ex, struct osf1_timeval *tv); }
94 NOARGS { int|sys||poll(struct pollfd *fds, u_int nfds, \
int timeout); }
@@ -242,9 +243,9 @@
114 STD { ssize_t|linux_sys||sendmsg(int s, \
const struct linux_msghdr *msg, int flags); }
115 UNIMPL
-116 NODEF { int|osf1_sys||gettimeofday(struct osf1_timeval *tv, \
+116 STD { int|linux_sys||osf1_gettimeofday(struct osf1_timeval *tv, \
struct osf1_timezone *tzp); }
-117 NODEF { int|osf1_sys||getrusage(int who, \
+117 STD { int|linux_sys||osf1_getrusage(int who, \
struct osf1_rusage *rusage); }
118 STD { int|linux_sys||getsockopt(int s, int level, \
int optname, void *optval, int *optlen); }
@@ -253,7 +254,7 @@
int iovcnt); }
121 NOARGS { ssize_t|sys||writev(int fd, const struct iovec *iovp, \
int iovcnt); }
-122 NODEF { int|osf1_sys||settimeofday(struct osf1_timeval *tv, \
+122 STD { int|linux_sys||osf1_settimeofday(struct osf1_timeval *tv, \
struct osf1_timezone *tzp); }
123 NOARGS { int|sys||__posix_fchown(int fd, uid_t uid, \
gid_t gid); }
@@ -276,7 +277,7 @@
int protocol, int *rsv); }
136 NOARGS { int|sys||mkdir(const char *path, linux_umode_t mode); }
137 NOARGS { int|sys||rmdir(const char *path); }
-138 NODEF { int|osf1_sys||utimes(const char *path, \
+138 STD { int|linux_sys||osf1_utimes(const char *path, \
const struct osf1_timeval *tptr); }
139 UNIMPL
140 UNIMPL
@@ -308,9 +309,9 @@
;159 ALIAS osf1_sys_getdirentries
159 NOARGS { int|compat_43_sys||getdirentries(int fd, char *buf, \
u_int count, long *basep); }
-160 NODEF { int|osf1_sys||statfs(const char *path, \
+160 STD { int|linux_sys||osf1_statfs(const char *path, \
struct osf1_statfs *buf, int len); }
-161 NODEF { int|osf1_sys||fstatfs(int fd, \
+161 STD { int|linux_sys||osf1_fstatfs(int fd, \
struct osf1_statfs *buf, int len); }
162 UNIMPL
163 UNIMPL
@@ -425,7 +426,7 @@
238 UNIMPL
239 UNIMPL
240 UNIMPL
-241 NODEF { int|osf1_sys||sysinfo(int cmd, char buf, long len); }
+241 STD { int|linux_sys||osf1_sysinfo(int cmd, char *buf, long len); }
242 UNIMPL
243 UNIMPL
244 UNIMPL osf1_sys_proplist_syscall
@@ -435,16 +436,16 @@
248 UNIMPL
249 UNIMPL
250 UNIMPL
-251 NODEF { int|osf1_sys||usleep_thread( \
+251 STD { int|linux_sys||osf1_usleep_thread( \
struct osf1_timeval *sleep, \
struct osf1_timeval *slept); }
252 UNIMPL
253 UNIMPL
254 UNIMPL
255 UNIMPL sysfs
-256 NODEF { int|osf1_sys||getsysinfo(u_long op, void *buffer, \
+256 STD { int|linux_sys||osf1_getsysinfo(u_long op, void *buffer, \
u_long nbytes, void *arg, u_long flag); }
-257 NODEF { int|osf1_sys||setsysinfo(u_long op, void *buffer, \
+257 STD { int|linux_sys||osf1_setsysinfo(u_long op, void *buffer, \
u_long nbytes, void *arg, u_long flag); }
258 UNIMPL
259 UNIMPL
Index: src/sys/compat/osf1/files.osf1
diff -u src/sys/compat/osf1/files.osf1:1.21 src/sys/compat/osf1/files.osf1:1.22
--- src/sys/compat/osf1/files.osf1:1.21 Sun Mar 17 14:11:48 2019
+++ src/sys/compat/osf1/files.osf1 Sun Mar 24 16:24:19 2019
@@ -1,4 +1,4 @@
-# $NetBSD: files.osf1,v 1.21 2019/03/17 14:11:48 christos Exp $
+# $NetBSD: files.osf1,v 1.22 2019/03/24 16:24:19 maxv Exp $
#
# Config file description for machine-independent OSF/1 compat code.
# Included by ports that need it.
@@ -15,24 +15,24 @@ file compat/osf1/osf1_syscalls.c compat_
file compat/osf1/osf1_sysent.c compat_osf1
# OSF/1 <-> NetBSD structure, flag, and value conversion files
-file compat/osf1/osf1_cvt.c compat_osf1 | compat_linux
+file compat/osf1/osf1_cvt.c compat_osf1
file compat/osf1/osf1_errno.c compat_osf1
-file compat/osf1/osf1_signo.c compat_osf1 | compat_linux
+file compat/osf1/osf1_signo.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_exec_ecoff.c compat_osf1 & exec_ecoff
-file compat/osf1/osf1_file.c compat_osf1 | compat_linux
-file compat/osf1/osf1_generic.c compat_osf1 | compat_linux
+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 | compat_linux
+file compat/osf1/osf1_misc.c compat_osf1
file compat/osf1/osf1_mmap.c compat_osf1
file compat/osf1/osf1_mod.c compat_osf1
-file compat/osf1/osf1_mount.c compat_osf1 | compat_linux
+file compat/osf1/osf1_mount.c compat_osf1
file compat/osf1/osf1_prot.c compat_osf1
-file compat/osf1/osf1_resource.c compat_osf1 | compat_linux
+file compat/osf1/osf1_resource.c compat_osf1
file compat/osf1/osf1_signal.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 | compat_linux
+file compat/osf1/osf1_time.c compat_osf1
Added files:
Index: src/sys/compat/linux/arch/alpha/linux_osf1.c
diff -u /dev/null src/sys/compat/linux/arch/alpha/linux_osf1.c:1.1
--- /dev/null Sun Mar 24 16:24:20 2019
+++ src/sys/compat/linux/arch/alpha/linux_osf1.c Sun Mar 24 16:24:19 2019
@@ -0,0 +1,785 @@
+/* $NetBSD: linux_osf1.c,v 1.1 2019/03/24 16:24:19 maxv 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/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD: linux_osf1.c,v 1.1 2019/03/24 16:24:19 maxv Exp $");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#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/wait.h>
+#include <sys/select.h>
+#include <sys/syscallargs.h>
+#include <sys/vfs_syscalls.h>
+
+#include <machine/alpha.h>
+#include <machine/cpuconf.h>
+#include <machine/rpb.h>
+#include <machine/fpu.h>
+
+#include <compat/common/compat_util.h>
+#include <compat/linux/common/linux_types.h>
+#include <compat/linux/common/linux_signal.h>
+#include <compat/linux/arch/alpha/linux_signal.h>
+#include <compat/linux/arch/alpha/linux_osf1.h>
+#include <compat/linux/linux_syscallargs.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 <ufs/ufs/quota.h>
+#include <ufs/ufs/ufsmount.h>
+
+#include <machine/vmparam.h>
+
+const struct emul_flags_xtab osf1_wait_options_xtab[] = {
+ { OSF1_WNOHANG, OSF1_WNOHANG, WNOHANG },
+ { OSF1_WUNTRACED, OSF1_WUNTRACED, WUNTRACED },
+ { 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 }
+};
+
+static void
+osf1_cvt_rusage_from_native(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;
+}
+
+static void
+osf1_cvt_statfs_from_native(const struct statvfs *bsfs, struct osf1_statfs *osfs)
+{
+
+ memset(osfs, 0, sizeof (struct osf1_statfs));
+ if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename)))
+ osfs->f_type = OSF1_MOUNT_UFS;
+ else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename)))
+ osfs->f_type = OSF1_MOUNT_NFS;
+ else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename)))
+ 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_flag; /* XXX translate */
+ osfs->f_fsize = bsfs->f_frsize;
+ osfs->f_bsize = bsfs->f_bsize;
+ 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_fsidx, sizeof osfs->f_fsid);
+ /* osfs->f_spare zeroed above */
+ memcpy(osfs->f_mntonname, bsfs->f_mntonname, sizeof osfs->f_mntonname);
+ memcpy(osfs->f_mntfromname, bsfs->f_mntfromname,
+ sizeof osfs->f_mntfromname);
+ /* XXX osfs->f_xxx should be filled in... */
+}
+
+/* --------------------------------------------------------------------- */
+
+int
+linux_sys_osf1_wait4(struct lwp *l, const struct linux_sys_osf1_wait4_args *uap, register_t *retval)
+{
+ struct osf1_rusage osf1_rusage;
+ struct rusage netbsd_rusage;
+ unsigned long leftovers;
+ int error, status;
+ int options = SCARG(uap, options);
+ int pid = SCARG(uap, pid);
+
+ /* translate options */
+ options = emul_flags_translate(osf1_wait_options_xtab,
+ options, &leftovers);
+ if (leftovers != 0)
+ return (EINVAL);
+
+ error = do_sys_wait(&pid, &status, options,
+ SCARG(uap, rusage) != NULL ? &netbsd_rusage : NULL);
+
+ retval[0] = pid;
+ if (pid == 0)
+ return error;
+
+ if (SCARG(uap, rusage)) {
+ osf1_cvt_rusage_from_native(&netbsd_rusage, &osf1_rusage);
+ error = copyout(&osf1_rusage, SCARG(uap, rusage),
+ sizeof osf1_rusage);
+ }
+
+ if (error == 0 && SCARG(uap, status))
+ error = copyout(&status, SCARG(uap, status), sizeof(status));
+
+ return error;
+}
+
+#define OSF1_MNT_WAIT 0x1
+#define OSF1_MNT_NOWAIT 0x2
+
+#define OSF1_MNT_FORCE 0x1
+#define OSF1_MNT_NOFORCE 0x2
+
+/* acceptable flags for various calls */
+#define OSF1_GETFSSTAT_FLAGS (OSF1_MNT_WAIT|OSF1_MNT_NOWAIT)
+#define OSF1_MOUNT_FLAGS 0xffffffff /* XXX */
+#define OSF1_UNMOUNT_FLAGS (OSF1_MNT_FORCE|OSF1_MNT_NOFORCE)
+
+static int
+osf1_mount_mfs(struct lwp *l, const struct linux_sys_osf1_mount_args *uap)
+{
+ struct osf1_mfs_args osf_ma;
+ struct mfs_args bsd_ma;
+ int error;
+ register_t dummy;
+
+ if ((error = copyin(SCARG(uap, data), &osf_ma, sizeof osf_ma)))
+ return error;
+
+ 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;
+
+ return do_sys_mount(l, "mfs", UIO_SYSSPACE, SCARG(uap, path),
+ SCARG(uap, flags), &bsd_ma, UIO_SYSSPACE, sizeof bsd_ma, &dummy);
+}
+
+static int
+osf1_mount_nfs(struct lwp *l, const struct linux_sys_osf1_mount_args *uap)
+{
+ struct osf1_nfs_args osf_na;
+ struct nfs_args bsd_na;
+ int error;
+ unsigned long leftovers;
+ register_t dummy;
+
+ if ((error = copyin(SCARG(uap, data), &osf_na, sizeof osf_na)))
+ return error;
+
+ memset(&bsd_na, 0, sizeof bsd_na);
+ bsd_na.addr = (struct sockaddr *)osf_na.addr;
+ bsd_na.addrlen = sizeof (struct sockaddr_in);
+ 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 (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 (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;
+ if (bsd_na.flags & NFSMNT_RETRANS)
+ bsd_na.retrans = osf_na.retrans;
+
+ return do_sys_mount(l, "nfs", UIO_SYSSPACE, SCARG(uap, path),
+ SCARG(uap, flags), &bsd_na, UIO_SYSSPACE, sizeof bsd_na, &dummy);
+}
+
+int
+linux_sys_osf1_mount(struct lwp *l, const struct linux_sys_osf1_mount_args *uap, register_t *retval)
+{
+
+ if (SCARG(uap, flags) & ~OSF1_MOUNT_FLAGS)
+ return (EINVAL);
+
+ /* XXX - xlate flags */
+
+ switch (SCARG(uap, type)) {
+ case OSF1_MOUNT_NFS:
+ return osf1_mount_nfs(l, uap);
+ break;
+
+ case OSF1_MOUNT_MFS:
+ return osf1_mount_mfs(l, uap);
+
+ default:
+ return (EINVAL);
+ }
+}
+
+int
+linux_sys_osf1_set_program_attributes(struct lwp *l, const struct linux_sys_osf1_set_program_attributes_args *uap, register_t *retval)
+{
+ struct proc *p = l->l_proc;
+ segsz_t tsize, dsize;
+
+ tsize = btoc(SCARG(uap, tsize));
+ dsize = btoc(SCARG(uap, dsize));
+
+ if (dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur)
+ return (ENOMEM);
+ if (tsize > MAXTSIZ)
+ return (ENOMEM);
+
+ /* XXXSMP unlocked */
+ 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;
+
+ return (0);
+}
+
+int
+linux_sys_osf1_setitimer(struct lwp *l, const struct linux_sys_osf1_setitimer_args *uap, register_t *retval)
+{
+ struct osf1_itimerval o_itv, o_oitv;
+ struct itimerval b_itv, b_oitv;
+ int which;
+ int error;
+
+ switch (SCARG(uap, which)) {
+ case OSF1_ITIMER_REAL:
+ which = ITIMER_REAL;
+ break;
+
+ case OSF1_ITIMER_VIRTUAL:
+ which = ITIMER_VIRTUAL;
+ break;
+
+ case OSF1_ITIMER_PROF:
+ which = ITIMER_PROF;
+ break;
+
+ default:
+ return (EINVAL);
+ }
+
+ /* get the OSF/1 itimerval argument */
+ error = copyin(SCARG(uap, itv), &o_itv, sizeof o_itv);
+ if (error != 0)
+ return error;
+
+ /* fill in and 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;
+
+ if (SCARG(uap, oitv) != NULL) {
+ dogetitimer(l->l_proc, which, &b_oitv);
+ if (error)
+ return error;
+ }
+
+ error = dosetitimer(l->l_proc, which, &b_itv);
+
+ if (error == 0 || SCARG(uap, oitv) == NULL)
+ return error;
+
+ /* fill in and copy out the old 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;
+
+ return copyout(&o_oitv, SCARG(uap, oitv), sizeof o_oitv);
+}
+
+int
+linux_sys_osf1_select(struct lwp *l, const struct linux_sys_osf1_select_args *uap,
+ register_t *retval)
+{
+ struct osf1_timeval otv;
+ struct timespec ats, *ts = NULL;
+ int error;
+
+ if (SCARG(uap, tv)) {
+ /* get the OSF/1 timeval argument */
+ error = copyin(SCARG(uap, tv), &otv, sizeof otv);
+ if (error != 0)
+ return error;
+
+ ats.tv_sec = otv.tv_sec;
+ ats.tv_nsec = otv.tv_usec * 1000;
+ ts = &ats;
+ }
+
+ return selcommon(retval, SCARG(uap, nd), SCARG(uap, in),
+ SCARG(uap, ou), SCARG(uap, ex), ts, NULL);
+}
+
+int
+linux_sys_osf1_gettimeofday(struct lwp *l, const struct linux_sys_osf1_gettimeofday_args *uap, register_t *retval)
+{
+ struct osf1_timeval otv;
+ struct osf1_timezone otz;
+ struct timeval tv;
+ int error;
+
+ microtime(&tv);
+ memset(&otv, 0, sizeof otv);
+ otv.tv_sec = tv.tv_sec;
+ otv.tv_usec = tv.tv_usec;
+ error = copyout(&otv, SCARG(uap, tp), sizeof otv);
+
+ if (error == 0 && SCARG(uap, tzp) != NULL) {
+ memset(&otz, 0, sizeof otz);
+ error = copyout(&otz, SCARG(uap, tzp), sizeof otz);
+ }
+ return (error);
+}
+
+int
+linux_sys_osf1_getrusage(struct lwp *l, const struct linux_sys_osf1_getrusage_args *uap, register_t *retval)
+{
+ int error, who;
+ struct osf1_rusage osf1_rusage;
+ struct rusage ru;
+ struct proc *p = l->l_proc;
+
+
+ switch (SCARG(uap, who)) {
+ case OSF1_RUSAGE_SELF:
+ who = RUSAGE_SELF;
+ break;
+
+ case OSF1_RUSAGE_CHILDREN:
+ who = RUSAGE_CHILDREN;
+ break;
+
+ case OSF1_RUSAGE_THREAD: /* XXX not supported */
+ default:
+ return EINVAL;
+ }
+
+ error = getrusage1(p, who, &ru);
+ if (error != 0)
+ return error;
+
+ osf1_cvt_rusage_from_native(&ru, &osf1_rusage);
+
+ return copyout(&osf1_rusage, SCARG(uap, rusage), sizeof osf1_rusage);
+}
+
+int
+linux_sys_osf1_settimeofday(struct lwp *l, const struct linux_sys_osf1_settimeofday_args *uap, register_t *retval)
+{
+ struct osf1_timeval otv;
+ struct timeval tv, *tvp;
+ int error = 0;
+
+ if (SCARG(uap, tv) == NULL)
+ tvp = NULL;
+ else {
+ /* get the OSF/1 timeval argument */
+ error = copyin(SCARG(uap, tv), &otv, sizeof otv);
+ if (error != 0)
+ return error;
+
+ tv.tv_sec = otv.tv_sec;
+ tv.tv_usec = otv.tv_usec;
+ tvp = &tv;
+ }
+
+ /* NetBSD ignores the timezone field */
+
+ return settimeofday1(tvp, false, (const void *)SCARG(uap, tzp), l, true);
+}
+
+int
+linux_sys_osf1_utimes(struct lwp *l, const struct linux_sys_osf1_utimes_args *uap, register_t *retval)
+{
+ struct osf1_timeval otv;
+ struct timeval tv[2], *tvp;
+ int error;
+
+ if (SCARG(uap, tptr) == NULL)
+ tvp = NULL;
+ else {
+ /* get the OSF/1 timeval argument */
+ error = copyin(SCARG(uap, tptr), &otv, sizeof otv);
+ if (error != 0)
+ return error;
+
+ /* fill in and copy out the NetBSD timeval */
+ tv[0].tv_sec = otv.tv_sec;
+ tv[0].tv_usec = otv.tv_usec;
+ /* Set access and modified to the same time */
+ tv[1].tv_sec = otv.tv_sec;
+ tv[1].tv_usec = otv.tv_usec;
+ tvp = tv;
+ }
+
+ return do_sys_utimes(l, NULL, SCARG(uap, path), FOLLOW,
+ tvp, UIO_SYSSPACE);
+}
+
+int
+linux_sys_osf1_statfs(struct lwp *l, const struct linux_sys_osf1_statfs_args *uap, register_t *retval)
+{
+ struct mount *mp;
+ struct statvfs *sp;
+ struct osf1_statfs osfs;
+ int error;
+ struct vnode *vp;
+
+ error = namei_simple_user(SCARG(uap, path),
+ NSM_FOLLOW_TRYEMULROOT, &vp);
+ if (error != 0)
+ return (error);
+ mp = vp->v_mount;
+ sp = &mp->mnt_stat;
+ vrele(vp);
+ if ((error = VFS_STATVFS(mp, sp)))
+ return (error);
+ sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
+ osf1_cvt_statfs_from_native(sp, &osfs);
+ return copyout(&osfs, SCARG(uap, buf), uimin(sizeof osfs,
+ SCARG(uap, len)));
+}
+
+int
+linux_sys_osf1_fstatfs(struct lwp *l, const struct linux_sys_osf1_fstatfs_args *uap, register_t *retval)
+{
+ file_t *fp;
+ struct mount *mp;
+ struct statvfs *sp;
+ struct osf1_statfs osfs;
+ int error;
+
+ /* fd_getvnode() will use the descriptor for us */
+ if ((error = fd_getvnode(SCARG(uap, fd), &fp)))
+ return (error);
+ mp = fp->f_vnode->v_mount;
+ sp = &mp->mnt_stat;
+ if ((error = VFS_STATVFS(mp, sp)))
+ goto out;
+ sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
+ osf1_cvt_statfs_from_native(sp, &osfs);
+ error = copyout(&osfs, SCARG(uap, buf), uimin(sizeof osfs,
+ SCARG(uap, len)));
+ out:
+ fd_putfile(SCARG(uap, fd));
+ return (error);
+}
+
+int
+linux_sys_osf1_sysinfo(struct lwp *l, const struct linux_sys_osf1_sysinfo_args *uap, register_t *retval)
+{
+ const char *string;
+ size_t slen;
+ int error;
+
+ error = 0;
+ switch (SCARG(uap, cmd)) {
+ case OSF1_SI_SYSNAME:
+ string = ostype;
+ break;
+
+ case OSF1_SI_HOSTNAME:
+ string = hostname;
+ break;
+
+ case OSF1_SI_RELEASE:
+ string = osrelease;
+ break;
+
+ case OSF1_SI_VERSION:
+ goto should_handle;
+
+ case OSF1_SI_MACHINE:
+ string = MACHINE;
+ break;
+
+ case OSF1_SI_ARCHITECTURE:
+ string = MACHINE_ARCH;
+ break;
+
+ case OSF1_SI_HW_SERIAL:
+ string = "666"; /* OSF/1 emulation? YES! */
+ break;
+
+ case OSF1_SI_HW_PROVIDER:
+ string = "unknown";
+ break;
+
+ case OSF1_SI_SRPC_DOMAIN:
+ goto dont_care;
+
+ case OSF1_SI_SET_HOSTNAME:
+ goto should_handle;
+
+ case OSF1_SI_SET_SYSNAME:
+ goto should_handle;
+
+ case OSF1_SI_SET_SRPC_DOMAIN:
+ goto dont_care;
+
+ default:
+should_handle:
+ printf("osf1_sys_sysinfo(%d, %p, 0x%lx)\n", SCARG(uap, cmd),
+ SCARG(uap, buf), SCARG(uap,len));
+dont_care:
+ return (EINVAL);
+ };
+
+ slen = strlen(string) + 1;
+ if (SCARG(uap, buf)) {
+ error = copyout(string, SCARG(uap, buf),
+ uimin(slen, SCARG(uap, len)));
+ if (!error && (SCARG(uap, len) > 0) && (SCARG(uap, len) < slen))
+ subyte(SCARG(uap, buf) + SCARG(uap, len) - 1, 0);
+ }
+ if (!error)
+ retval[0] = slen;
+
+ return (error);
+}
+
+int
+linux_sys_osf1_usleep_thread(struct lwp *l, const struct linux_sys_osf1_usleep_thread_args *uap, register_t *retval)
+{
+ struct osf1_timeval otv, endotv;
+ struct timeval tv, ntv, endtv;
+ u_long ticks;
+ int error;
+
+ if ((error = copyin(SCARG(uap, sleep), &otv, sizeof otv)))
+ return (error);
+ tv.tv_sec = otv.tv_sec;
+ tv.tv_usec = otv.tv_usec;
+
+ ticks = howmany((u_long)tv.tv_sec * 1000000 + tv.tv_usec, tick);
+ if (ticks == 0)
+ ticks = 1;
+
+ getmicrotime(&tv);
+
+ tsleep(l, PUSER|PCATCH, "uslpthrd", ticks); /* XXX */
+
+ if (SCARG(uap, slept) != NULL) {
+ getmicrotime(&ntv);
+ timersub(&ntv, &tv, &endtv);
+ if (endtv.tv_sec < 0 || endtv.tv_usec < 0)
+ endtv.tv_sec = endtv.tv_usec = 0;
+
+ endotv.tv_sec = endtv.tv_sec;
+ endotv.tv_usec = endtv.tv_usec;
+ error = copyout(&endotv, SCARG(uap, slept), sizeof endotv);
+ }
+ return (error);
+}
+
+int
+linux_sys_osf1_getsysinfo(struct lwp *l, const struct linux_sys_osf1_getsysinfo_args *uap, register_t *retval)
+{
+ extern int ncpus;
+ int error;
+ int unit;
+ long percpu;
+ long proctype;
+ u_int64_t fpflags;
+ struct osf1_cpu_info cpuinfo;
+ const void *data;
+ size_t datalen;
+
+ error = 0;
+
+ switch(SCARG(uap, op))
+ {
+ case OSF_GET_MAX_UPROCS:
+ data = &maxproc;
+ datalen = sizeof(maxproc);
+ break;
+ case OSF_GET_PHYSMEM:
+ data = &physmem;
+ datalen = sizeof(physmem);
+ break;
+ case OSF_GET_MAX_CPU:
+ case OSF_GET_CPUS_IN_BOX:
+ data = &ncpus;
+ datalen = sizeof(ncpus);
+ break;
+ case OSF_GET_IEEE_FP_CONTROL:
+ if (((fpflags = alpha_read_fp_c(l)) & IEEE_INHERIT) != 0) {
+ fpflags |= 1ULL << 63;
+ fpflags &= ~IEEE_INHERIT;
+ }
+ data = &fpflags;
+ datalen = sizeof(fpflags);
+ break;
+ case OSF_GET_CPU_INFO:
+ memset(&cpuinfo, 0, sizeof(cpuinfo));
+#ifdef __alpha__
+ unit = alpha_pal_whami();
+#else
+ unit = 0; /* XXX */
+#endif
+ cpuinfo.current_cpu = unit;
+ cpuinfo.cpus_in_box = ncpus;
+ cpuinfo.cpu_type = LOCATE_PCS(hwrpb, unit)->pcs_proc_type;
+ cpuinfo.ncpus = ncpus;
+ cpuinfo.cpus_present = ncpus;
+ cpuinfo.cpus_running = ncpus;
+ cpuinfo.cpu_binding = 1;
+ cpuinfo.cpu_ex_binding = 0;
+ cpuinfo.mhz = hwrpb->rpb_cc_freq / 1000000;
+ data = &cpuinfo;
+ datalen = sizeof(cpuinfo);
+ break;
+ case OSF_GET_PROC_TYPE:
+#ifdef __alpha__
+ unit = alpha_pal_whami();
+ proctype = LOCATE_PCS(hwrpb, unit)->pcs_proc_type;
+#else
+ proctype = 0; /* XXX */
+#endif
+ data = &proctype;
+ datalen = sizeof(percpu);
+ break;
+ case OSF_GET_HWRPB: /* note -- osf/1 doesn't have rpb_tbhint[8] */
+ data = hwrpb;
+ datalen = hwrpb->rpb_size;
+ break;
+ case OSF_GET_PLATFORM_NAME:
+ data = platform.model;
+ datalen = strlen(platform.model) + 1;
+ break;
+ default:
+ printf("osf1_getsysinfo called with unknown op=%ld\n",
+ SCARG(uap, op));
+ /* return EINVAL; */
+ return 0;
+ }
+
+ if (SCARG(uap, nbytes) < datalen)
+ return (EINVAL);
+ error = copyout(data, SCARG(uap, buffer), datalen);
+ if (!error)
+ retval[0] = 1;
+ return (error);
+}
+
+int
+linux_sys_osf1_setsysinfo(struct lwp *l, const struct linux_sys_osf1_setsysinfo_args *uap, register_t *retval)
+{
+ u_int64_t temp;
+ int error;
+
+ error = 0;
+
+ switch(SCARG(uap, op)) {
+ case OSF_SET_IEEE_FP_CONTROL:
+
+ if ((error = copyin(SCARG(uap, buffer), &temp, sizeof(temp))))
+ break;
+ if (temp >> 63 != 0)
+ temp |= IEEE_INHERIT;
+ alpha_write_fp_c(l, temp);
+ break;
+ default:
+ uprintf("osf1_setsysinfo called with op=%ld\n", SCARG(uap, op));
+ //error = EINVAL;
+ }
+ retval[0] = 0;
+ return (error);
+}
Index: src/sys/compat/linux/arch/alpha/linux_osf1.h
diff -u /dev/null src/sys/compat/linux/arch/alpha/linux_osf1.h:1.1
--- /dev/null Sun Mar 24 16:24:20 2019
+++ src/sys/compat/linux/arch/alpha/linux_osf1.h Sun Mar 24 16:24:19 2019
@@ -0,0 +1,222 @@
+/* $NetBSD: linux_osf1.h,v 1.1 2019/03/24 16:24:19 maxv 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.
+ */
+
+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 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 u_int64_t osf1_blksize_t;
+typedef u_int64_t osf1_blkcnt_t;
+
+#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
+
+struct osf1_timeval { /* time.h */
+ osf1_time_t tv_sec;
+ osf1_int tv_usec;
+};
+
+#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;
+};
+
+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;
+};
+
+#define OSF1_WNOHANG 0x01
+#define OSF1_WUNTRACED 0x02
+
+struct osf1_cpu_info {
+ int current_cpu;
+ int cpus_in_box;
+ int cpu_type;
+ int ncpus;
+ u_int64_t cpus_present;
+ u_int64_t cpus_running;
+ u_int64_t cpu_binding;
+ u_int64_t cpu_ex_binding;
+ int mhz;
+ int unused[3];
+};
+
+#define OSF_SET_IEEE_FP_CONTROL 14
+
+#define OSF_GET_MAX_UPROCS 2
+#define OSF_GET_PHYSMEM 19
+#define OSF_GET_MAX_CPU 30
+#define OSF_GET_IEEE_FP_CONTROL 45
+#define OSF_GET_CPUS_IN_BOX 55
+#define OSF_GET_CPU_INFO 59
+#define OSF_GET_PROC_TYPE 60
+#define OSF_GET_HWRPB 101
+#define OSF_GET_PLATFORM_NAME 103
+
+#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
+
+struct osf1_mfs_args {
+ osf1_data_ptr name;
+ osf1_data_ptr base;
+ osf1_u_int size;
+};
+
+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;
+};
+
+union osf1_mount_info {
+ struct osf1_mfs_args mfs_args;
+ struct osf1_nfs_args nfs_args;
+ char pad[80];
+};
+
+#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
+
+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;
+};
