/*      $NetBSD: linux_osf1.c,v 1.6 2024/10/01 16:35:41 riastradh 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.6 2024/10/01 16:35:41 riastradh 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)
{

        memset(oru, 0, sizeof(*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(*osfs));
        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);
#ifdef MAXTSIZ
        if (tsize > MAXTSIZ)
                return (ENOMEM);
#endif

        /* 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, tv), 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))
                        error = ustore_char(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;

                memset(&endotv, 0, sizeof(endotv));
                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);
}