xref: /netbsd-src/sys/compat/linux/arch/alpha/linux_osf1.c (revision 21709ad01db1a91e3c201ed96d7d83992cdf0208)

/*	$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);
}