xref: /netbsd-src/sys/compat/linux32/common/linux32_misc.c (revision 2f5e5e735694c180714bb1b7faa48b23eb56b861)

/*	$NetBSD: linux32_misc.c,v 1.34 2021/11/25 03:08:04 ryo Exp $	*/

/*-
 * Copyright (c) 1995, 1998, 1999 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
 * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center;
 * by Edgar Fu\ss, Mathematisches Institut der Uni Bonn.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: linux32_misc.c,v 1.34 2021/11/25 03:08:04 ryo Exp $");

#include <sys/param.h>
#include <sys/proc.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/fstypes.h>
#include <sys/vfs_syscalls.h>
#include <sys/ptrace.h>
#include <sys/syscall.h>
#include <sys/poll.h>
#include <sys/futex.h>

#include <compat/netbsd32/netbsd32.h>
#include <compat/netbsd32/netbsd32_syscallargs.h>

#include <compat/linux/common/linux_types.h>

#include <compat/linux32/common/linux32_types.h>
#include <compat/linux32/common/linux32_machdep.h>
#include <compat/linux32/common/linux32_signal.h>
#include <compat/linux32/common/linux32_sched.h>
#include <compat/linux32/linux32_syscallargs.h>

#include <compat/linux/common/linux_ptrace.h>
#include <compat/linux/common/linux_emuldata.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_misc.h>
#include <compat/linux/common/linux_statfs.h>
#include <compat/linux/common/linux_ipc.h>
#include <compat/linux/common/linux_sem.h>
#include <compat/linux/linux_syscallargs.h>

extern const struct linux_mnttypes linux_fstypes[];
extern const int linux_fstypes_cnt;

/*
 * Implement the fs stat functions. Straightforward.
 */
int
linux32_sys_statfs(struct lwp *l, const struct linux32_sys_statfs_args *uap, register_t *retval)
{
	/* {
		syscallarg(const netbsd32_charp char) path;
		syscallarg(linux32_statfsp) sp;
	} */
	struct statvfs *sb;
	struct linux_statfs ltmp;
	int error;

	sb = STATVFSBUF_GET();
	error = do_sys_pstatvfs(l, SCARG_P32(uap, path), ST_WAIT, sb);
	if (error == 0) {
		bsd_to_linux_statfs(sb, &ltmp);
		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
	}

	STATVFSBUF_PUT(sb);
	return error;
}

int
linux32_sys_fstatfs(struct lwp *l, const struct linux32_sys_fstatfs_args *uap, register_t *retval)
{
	/* {
		syscallarg(int) fd;
		syscallarg(linux32_statfsp) sp;
	} */
	struct statvfs *sb;
	struct linux_statfs ltmp;
	int error;

	sb = STATVFSBUF_GET();
	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
	if (error == 0) {
		bsd_to_linux_statfs(sb, &ltmp);
		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
	}
	STATVFSBUF_PUT(sb);

	return error;
}

int
linux32_sys_statfs64(struct lwp *l, const struct linux32_sys_statfs64_args *uap, register_t *retval)
{
	/* {
		syscallarg(const netbsd32_charp char) path;
		syscallarg(linux32_statfs64p) sp;
	} */
	struct statvfs *sb;
	struct linux_statfs64 ltmp;
	int error;

	sb = STATVFSBUF_GET();
	error = do_sys_pstatvfs(l, SCARG_P32(uap, path), ST_WAIT, sb);
	if (error == 0) {
		bsd_to_linux_statfs64(sb, &ltmp);
		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
	}

	STATVFSBUF_PUT(sb);
	return error;
}

int
linux32_sys_fstatfs64(struct lwp *l, const struct linux32_sys_fstatfs64_args *uap, register_t *retval)
{
	/* {
		syscallarg(int) fd;
		syscallarg(linux32_statfs64p) sp;
	} */
	struct statvfs *sb;
	struct linux_statfs64 ltmp;
	int error;

	sb = STATVFSBUF_GET();
	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
	if (error == 0) {
		bsd_to_linux_statfs64(sb, &ltmp);
		error = copyout(&ltmp, SCARG_P32(uap, sp), sizeof ltmp);
	}
	STATVFSBUF_PUT(sb);

	return error;
}

extern const int linux_ptrace_request_map[];

int
linux32_sys_ptrace(struct lwp *l, const struct linux32_sys_ptrace_args *uap, register_t *retval)
{
	/* {
		i386, m68k, powerpc: T=int
		aarch64, alpha, amd64: T=long
		syscallarg(T) request;
		syscallarg(T) pid;
		syscallarg(T) addr;
		syscallarg(T) data;
	} */
	const int *ptr;
	int request;
	int error;

	ptr = linux_ptrace_request_map;
	request = SCARG(uap, request);
	while (*ptr != -1)
		if (*ptr++ == request) {
			struct sys_ptrace_args pta;

			SCARG(&pta, req) = *ptr;
			SCARG(&pta, pid) = SCARG(uap, pid);
			SCARG(&pta, addr) = NETBSD32IPTR64(SCARG(uap, addr));
			SCARG(&pta, data) = SCARG(uap, data);

			/*
			 * Linux ptrace(PTRACE_CONT, pid, 0, 0) means actually
			 * to continue where the process left off previously.
			 * The same thing is achieved by addr == (void *) 1
			 * on NetBSD, so rewrite 'addr' appropriately.
			 */
			if (request == LINUX_PTRACE_CONT && SCARG(uap, addr)==0)
				SCARG(&pta, addr) = (void *) 1;

			error = sysent[SYS_ptrace].sy_call(l, &pta, retval);
			if (error)
				return error;
			switch (request) {
			case LINUX_PTRACE_PEEKTEXT:
			case LINUX_PTRACE_PEEKDATA:
				error = copyout (retval,
				    NETBSD32IPTR64(SCARG(uap, data)),
				    sizeof *retval);
				*retval = SCARG(uap, data);
				break;
			default:
				break;
			}
			return error;
		}
		else
			ptr++;

	return EIO;
}

int
linux32_sys_personality(struct lwp *l, const struct linux32_sys_personality_args *uap, register_t *retval)
{
	/* {
		syscallarg(netbsd32_u_long) per;
	} */
	struct linux_sys_personality_args ua;

	NETBSD32TOX_UAP(per, long);
	return linux_sys_personality(l, &ua, retval);
}

int
linux32_sys_futex(struct lwp *l,
    const struct linux32_sys_futex_args *uap, register_t *retval)
{
	/* {
		syscallarg(linux32_intp_t) uaddr;
		syscallarg(int) op;
		syscallarg(int) val;
		syscallarg(linux32_timespecp_t) timeout;
		syscallarg(linux32_intp_t) uaddr2;
		syscallarg(int) val3;
	} */
	struct linux32_timespec lts;
	struct timespec ts, *tsp = NULL;
	int val2 = 0;
	int error;

	/*
	 * Linux overlays the "timeout" field and the "val2" field.
	 * "timeout" is only valid for FUTEX_WAIT and FUTEX_WAIT_BITSET
	 * on Linux.
	 */
	const int op = (SCARG(uap, op) & FUTEX_CMD_MASK);
	if ((op == FUTEX_WAIT || op == FUTEX_WAIT_BITSET) &&
	    SCARG_P32(uap, timeout) != NULL) {
		if ((error = copyin(SCARG_P32(uap, timeout),
		    &lts, sizeof(lts))) != 0) {
			return error;
		}
		linux32_to_native_timespec(&ts, &lts);
		tsp = &ts;
	} else {
		val2 = (int)(uintptr_t)SCARG_P32(uap, timeout);
	}

	return linux_do_futex(SCARG_P32(uap, uaddr), SCARG(uap, op),
	    SCARG(uap, val), tsp, SCARG_P32(uap, uaddr2), val2,
	    SCARG(uap, val3), retval);
}

int
linux32_sys_truncate64(struct lwp *l, const struct linux32_sys_truncate64_args *uap, register_t *retval)
{
	/* {
		syscallarg(netbsd32_charp) path;
		syscallarg(off_t) length;
	} */
	struct sys_truncate_args ua;

	/* Linux doesn't have the 'pad' pseudo-parameter */
	NETBSD32TOP_UAP(path, const char *);
	SCARG(&ua, PAD) = 0;
	SCARG(&ua, length) = ((off_t)SCARG(uap, lenhi) << 32) + SCARG(uap, lenlo);
	return sys_truncate(l, &ua, retval);
}

int
linux32_sys_ftruncate64(struct lwp *l, const struct linux32_sys_ftruncate64_args *uap, register_t *retval)
{
	/* {
		syscallarg(unsigned int) fd;
		syscallarg(off_t) length;
	} */
	struct sys_ftruncate_args ua;

	/* Linux doesn't have the 'pad' pseudo-parameter */
	NETBSD32TO64_UAP(fd);
	SCARG(&ua, PAD) = 0;
	SCARG(&ua, length) = ((off_t)SCARG(uap, lenhi) << 32) + SCARG(uap, lenlo);
	return sys_ftruncate(l, &ua, retval);
}

int
linux32_sys_setdomainname(struct lwp *l, const struct linux32_sys_setdomainname_args *uap, register_t *retval)
{
	/* {
		syscallarg(netbsd32_charp) domainname;
		syscallarg(int) len;
	} */
	struct linux_sys_setdomainname_args ua;

	NETBSD32TOP_UAP(domainname, char);
	NETBSD32TO64_UAP(len);
	return linux_sys_setdomainname(l, &ua, retval);
}

int
linux32_sys_ppoll(struct lwp *l, const struct linux32_sys_ppoll_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(netbsd32_pollfdp_t) fds;
		syscallarg(u_int) nfds;
		syscallarg(linux32_timespecp_t) timeout;
		syscallarg(linux32_sigsetp_t) sigset;
	} */
	struct linux32_timespec lts0, *lts;
	struct timespec ts0, *ts = NULL;
	linux32_sigset_t lsigmask0, *lsigmask;
	sigset_t sigmask0, *sigmask = NULL;
	int error;

	lts = SCARG_P32(uap, timeout);
	if (lts) {
		if ((error = copyin(lts, &lts0, sizeof(lts0))) != 0)
			return error;
		linux32_to_native_timespec(&ts0, &lts0);
		ts = &ts0;
	}

	lsigmask = SCARG_P32(uap, sigset);
	if (lsigmask) {
		if ((error = copyin(lsigmask, &lsigmask0, sizeof(lsigmask0))))
			return error;
		linux32_to_native_sigset(&sigmask0, &lsigmask0);
		sigmask = &sigmask0;
	}

	return pollcommon(retval, SCARG_P32(uap, fds), SCARG(uap, nfds),
	    ts, sigmask);
}

int
linux32_sys_eventfd(struct lwp *l, const struct linux32_sys_eventfd_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(unsigned int) initval;
	} */
	struct linux_sys_eventfd_args ua;

	NETBSD32TO64_UAP(initval);

	return linux_sys_eventfd(l, &ua, retval);
}

int
linux32_sys_eventfd2(struct lwp *l, const struct linux32_sys_eventfd2_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(unsigned int) initval;
		syscallarg(int) flags;
	} */
	struct linux_sys_eventfd2_args ua;

	NETBSD32TO64_UAP(initval);
	NETBSD32TO64_UAP(flags);

	return linux_sys_eventfd2(l, &ua, retval);
}

static inline off_t
linux32_hilo_to_off_t(unsigned long hi, unsigned long lo)
{
	return (((off_t)hi) << 32) | lo;
}

int
linux32_sys_preadv(struct lwp *l, const struct linux32_sys_preadv_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(int) fd;
		syscallarg(const netbsd32_iovecp_t) iovp;
		syscallarg(int) iovcnt;
		syscallarg(netbsd32_u_long) off_lo;
		syscallarg(netbsd32_u_long) off_hi;
	} */
	struct netbsd32_preadv_args ua;

	SCARG(&ua, fd) = SCARG(uap, fd);
	SCARG(&ua, iovp) = SCARG(uap, iovp);
	SCARG(&ua, iovcnt) = SCARG(uap, iovcnt);
	SCARG(&ua, PAD) = 0;
	SCARG(&ua, offset) = linux32_hilo_to_off_t(SCARG(uap, off_hi),
						   SCARG(uap, off_lo));
	return netbsd32_preadv(l, &ua, retval);
}

int
linux32_sys_pwritev(struct lwp *l, const struct linux32_sys_pwritev_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(int) fd;
		syscallarg(const netbsd32_iovecp_t) iovp;
		syscallarg(int) iovcnt;
		syscallarg(netbsd32_u_long) off_lo;
		syscallarg(netbsd32_u_long) off_hi;
	} */
	struct netbsd32_pwritev_args ua;

	SCARG(&ua, fd) = SCARG(uap, fd);
	SCARG(&ua, iovp) = SCARG(uap, iovp);
	SCARG(&ua, iovcnt) = SCARG(uap, iovcnt);
	SCARG(&ua, PAD) = 0;
	SCARG(&ua, offset) = linux32_hilo_to_off_t(SCARG(uap, off_hi),
						   SCARG(uap, off_lo));
	return netbsd32_pwritev(l, &ua, retval);
}