OpenGrok

/*	$NetBSD: syscall.c,v 1.7 2026/05/10 23:51:37 tls Exp $	*/

/*-
 * Copyright (c) 2014 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Matt Thomas of 3am Software Foundry.
 *
 * 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: syscall.c,v 1.7 2026/05/10 23:51:37 tls Exp $");

#include <sys/param.h>
#include <sys/cpu.h>
#include <sys/endian.h>
#include <sys/proc.h>
#include <sys/signal.h>
#include <sys/systm.h>

#include <riscv/frame.h>
#include <riscv/userret.h>

#ifndef EMULNAME
#define EMULNAME(x)	(x)
#include <sys/syscall.h>
#include <sys/syscallvar.h>
#endif

#ifndef SYSCALL_SHIFT
#define SYSCALL_SHIFT 0
#endif

void	EMULNAME(syscall_intern)(struct proc *);
static void EMULNAME(syscall)(struct trapframe *);

__CTASSERT(EMULNAME(SYS_MAXSYSARGS) <= 8);

void
EMULNAME(syscall_intern)(struct proc *p)
{
	p->p_md.md_syscall = EMULNAME(syscall);
}

#define INSN_SIZE 4
/*
 * Process a system call.
 *
 * System calls are strange beasts.  They are passed the syscall number
 * in t6, and the arguments in the registers (as normal).
 * The return value (if any) in a0 and possibly a1.  The instruction
 * directly after the syscall is excepted to contain a jump instruction
 * for an error handler.  If the syscall completes with no error, the PC
 * will be advanced past that instruction.
 */

void
EMULNAME(syscall)(struct trapframe *tf)
{
	struct lwp * const l = curlwp;
	struct proc * const p = l->l_proc;
	register_t *args = &tf->tf_a0;
	register_t retval[2];
	const struct sysent *callp;
	int code, error;
#ifdef _LP64
	const bool pk32_p = (p->p_flag & PK_32) != 0;
	register_t copyargs[EMULNAME(SYS_MAXSYSARGS)];
#endif

	curcpu()->ci_data.cpu_nsyscall++;

	callp = p->p_emul->e_sysent;
	code = tf->tf_t6 - SYSCALL_SHIFT;

	/*
	 * Userland should have taken care of moving everything to their
	 * usual place so these code's should never get to the kernel.
	 */
	if (code == SYS_syscall || code == SYS___syscall) {
#ifdef RISCV_SYSCALL_DEBUG
		printf("syscall: _syscall code %#"PRIxREGISTER"\n", tf->tf_a0);
#endif
		/* XXX 32-bit vs 64-bit handling?? */
		code = *args;	/* syscall num is first arg */
		args++;		/* shuffle args */
	}

	if (code >= p->p_emul->e_nsysent)
		callp += p->p_emul->e_nosys;
	else
		callp += code;

#ifdef _LP64
	const size_t nargs = callp->sy_narg;
	/*
	 * If there are no 64bit arguments, we still need "sanitize" the
	 * 32-bit arguments in case they try to slip through a 64-bit pointer.
	 *  and all arguments were in
	 * registers, just use the trapframe for the source of arguments
	 */
	if (pk32_p) {
		size_t narg64 = SYCALL_NARGS64(callp);
		unsigned int arg64mask = SYCALL_ARG_64_MASK(callp);
		bool doing_arg64 = false;
		register_t *args32 = args;

		/*
		 * All arguments are 32bits wide and if we have 64bit arguments
		 * then use two 32bit registers to construct a 64bit argument.
		 * We remarshall them into 64bit slots but we don't want to
		 * disturb the original arguments in case we get restarted.
		 */
		if (SYCALL_NARGS64(callp) > 0) {
			args = copyargs;
		}

		/*
		 * Copy all the arguments to copyargs, starting with the ones
		 * in registers.  Using the hints in the 64bit argmask,
		 * we marshall the passed 32bit values into 64bit slots.  If we
		 * encounter a 64 bit argument, we grab two adjacent 32bit
		 * values and synthesize the 64bit argument.
		 */
		for (size_t i = 0; i < nargs + narg64; ) {
			register_t arg = *args32++;
			if (__predict_true((arg64mask & 1) == 0)) {
				/*
				 * Just copy it with sign extension on
				 */
				args[i++] = (int32_t) arg;
				arg64mask >>= 1;
				continue;
			}
			/*
			 * 64bit arg.  grab the low 32 bits, discard the high.
			 */
			arg = (uint32_t)arg;
			if (!doing_arg64) {
				/*
				 * Pick up the 1st word of a 64bit arg.
				 * If lowword == 1 then highword == 0,
				 * so this is the highword and thus
				 * shifted left by 32, otherwise
				 * lowword == 0 and highword == 1 so
				 * it isn't shifted at all.  Remember
				 * we still need another word.
				 */
				doing_arg64 = true;
				args[i] = arg << (_QUAD_LOWWORD*32);
				narg64--;	/* one less 64bit arg */
			} else {
				/*
				 * Pick up the 2nd word of a 64bit arg.
				 * if highword == 1, it's shifted left
				 * by 32, otherwise lowword == 1 and
				 * highword == 0 so it isn't shifted at
				 * all.  And now head to the next argument.
				 */
				doing_arg64 = false;
				args[i++] |= arg << (_QUAD_HIGHWORD*32);
				arg64mask >>= 1;
			}
		}
	}
#endif

#ifdef RISCV_SYSCALL_DEBUG
	if (p->p_emul->e_syscallnames)
		printf("syscall %s:", p->p_emul->e_syscallnames[code]);
	else
		printf("syscall %u:", code);
	if (nargs == 0)
		printf(" <no args>");
	else for (size_t j = 0; j < nargs; j++) {
		printf(" [%s%zu]=%#"PRIxREGISTER,
		    SYCALL_ARG_64_P(callp, j) ? "+" : "",
		    j, args[j]);
	}
	printf("\n");
#endif
	/*
	 * Assume success and fixup pc to point after the ecall and jump
	 * to cerror.  fork, and friends, expect this.
	 */
	tf->tf_pc +=
	    INSN_SIZE + 	// ecall
	    INSN_SIZE * 2;	// jump to cerror (or nops)

	error = sy_invoke(callp, l, args, retval, code);

	switch (error) {
	case 0:
#ifdef _LP64
#if 0
		if (pk32_p && SYCALL_RET_64_P(callp)) {

			/*
			 * If this is from O32 and it's a 64bit quantity,
			 * split it into 2 32bit values in adjacent registers.
			 */
			register_t tmp = retval[0];
			tf->tf_reg[_X_A0 + _QUAD_LOWWORD] = (int32_t) tmp;
			tf->tf_reg[_X_A0 + _QUAD_HIGHWORD] = tmp >> 32;
		}
#endif
		if (!SYCALL_RET_WIDE_P(callp)) {
			/*
			 * Sign-extend 32-bit syscall return values to 64
			 * bits, as required by ABI.  Avoids corruption if
			 * the returned value is spilled to and reloaded
			 * from the stack in userspace.
			 */
			retval[0] = (int32_t)(int64_t)retval[0];
			retval[1] = (int32_t)(int64_t)retval[1];
		}
#endif

		tf->tf_a0 = retval[0];
		tf->tf_a1 = retval[1];

#ifdef RISCV_SYSCALL_DEBUG
		if (p->p_emul->e_syscallnames)
			printf("syscall %s:", p->p_emul->e_syscallnames[code]);
		else
			printf("syscall %u:", code);
		printf(" return a0=%#"PRIxREGISTER" a1=%#"PRIxREGISTER" to"
		    " %#"PRIxREGISTER "\n",
		    tf->tf_a0, tf->tf_a1, tf->tf_pc);
#endif
		break;
	case ERESTART:
		tf->tf_pc -=
		    INSN_SIZE + 	// ecall
		    INSN_SIZE * 2;	// jump to cerror (or nops)
		break;
	case EJUSTRETURN:
		break;
	default:
		if (p->p_emul->e_errno)
			error = p->p_emul->e_errno[error];
		tf->tf_a0 = error;
		tf->tf_pc -= INSN_SIZE * 2;	// jump to cerror.
#ifdef RISCV_SYSCALL_DEBUG
		if (p->p_emul->e_syscallnames)
			printf("syscall %s:", p->p_emul->e_syscallnames[code]);
		else
			printf("syscall %u:", code);
		printf(" return error=%d to %#" PRIxREGISTER "\n", error, tf->tf_pc);
#endif
		break;
	}

	KASSERT(l->l_blcnt == 0);
	KASSERT(curcpu()->ci_biglock_count == 0);

	userret(l);
}