/*      $NetBSD: linux32_machdep.c,v 1.3 2024/02/07 04:20:28 msaitoh Exp $      */

/*-
 * Copyright (c) 2021 Ryo Shimizu
 * 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.
 *
 * 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: linux32_machdep.c,v 1.3 2024/02/07 04:20:28 msaitoh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/exec.h>

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

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_errno.h>
#include <compat/linux/common/linux_machdep.h>

#include <compat/linux32/common/linux32_types.h>
#include <compat/linux32/common/linux32_signal.h>
#include <compat/linux32/common/linux32_errno.h>
#include <compat/linux32/common/linux32_exec.h>
#include <compat/linux32/common/linux32_machdep.h>
#include <compat/linux32/linux32_syscall.h>
#include <compat/linux32/linux32_syscallargs.h>

#include <machine/netbsd32_machdep.h>
#include <arm/vfpreg.h>

static void
linux32_save_sigcontext(struct lwp *l, struct linux32_ucontext *luc)
{
        ucontext32_t uc;
        __greg32_t *gr = uc.uc_mcontext.__gregs;
        __vfpregset32_t *vfpregs = &uc.uc_mcontext.__vfpregs;
        struct linux32_aux_sigframe *aux;
        int i;

        cpu_getmcontext32(l, &uc.uc_mcontext, &uc.uc_flags);

        luc->luc_mcontext.arm_r0 = gr[_REG_R0];
        luc->luc_mcontext.arm_r1 = gr[_REG_R1];
        luc->luc_mcontext.arm_r2 = gr[_REG_R2];
        luc->luc_mcontext.arm_r3 = gr[_REG_R3];
        luc->luc_mcontext.arm_r4 = gr[_REG_R4];
        luc->luc_mcontext.arm_r5 = gr[_REG_R5];
        luc->luc_mcontext.arm_r6 = gr[_REG_R6];
        luc->luc_mcontext.arm_r7 = gr[_REG_R7];
        luc->luc_mcontext.arm_r8 = gr[_REG_R8];
        luc->luc_mcontext.arm_r9 = gr[_REG_R9];
        luc->luc_mcontext.arm_r10 = gr[_REG_R10];
        luc->luc_mcontext.arm_fp = gr[_REG_R11];
        luc->luc_mcontext.arm_ip = gr[_REG_R12];
        luc->luc_mcontext.arm_sp = gr[_REG_R13];
        luc->luc_mcontext.arm_lr = gr[_REG_R14];
        luc->luc_mcontext.arm_pc = gr[_REG_R15];
        luc->luc_mcontext.arm_cpsr = gr[_REG_CPSR];
        luc->luc_mcontext.trap_no = 0;
        luc->luc_mcontext.error_code = 0;
        luc->luc_mcontext.oldmask = 0;
        luc->luc_mcontext.fault_address = 0;

        if (uc.uc_flags & _UC_FPU) {
                aux = (struct linux32_aux_sigframe *)luc->luc_regspace;
#define LINUX32_VFP_MAGIC       0x56465001
                aux->vfp.magic = LINUX32_VFP_MAGIC;
                aux->vfp.size = sizeof(struct linux32_vfp_sigframe);

                CTASSERT(__arraycount(aux->vfp.ufp.fpregs) ==
                    __arraycount(vfpregs->__vfp_fstmx));
                for (i = 0; i < __arraycount(aux->vfp.ufp.fpregs); i++)
                        aux->vfp.ufp.fpregs[i] = vfpregs->__vfp_fstmx[i];
                aux->vfp.ufp.fpscr = vfpregs->__vfp_fpscr;

                aux->vfp.ufp_exc.fpexc = VFP_FPEXC_EN | VFP_FPEXC_VECITR;
                aux->vfp.ufp_exc.fpinst = 0;
                aux->vfp.ufp_exc.fpinst2 = 0;
                aux->end_magic = 0 ;
        }
}

static int
linux32_restore_sigcontext(struct lwp *l, struct linux32_ucontext *luc)
{
        struct proc * const p = l->l_proc;
        ucontext32_t uc;
        __greg32_t *gr = uc.uc_mcontext.__gregs;
        __vfpregset32_t *vfpregs = &uc.uc_mcontext.__vfpregs;
        struct linux32_aux_sigframe *aux;
        int i, error;

        memset(&uc, 0, sizeof(uc));

        /* build .uc_sigmask */
        linux32_to_native_sigset(&uc.uc_sigmask, &luc->luc_sigmask);
        uc.uc_flags |= _UC_SIGMASK;

        /* build .uc_stack */
        if (luc->luc_stack.ss_flags & LINUX_SS_ONSTACK)
                uc.uc_stack.ss_flags |= SS_ONSTACK;
        if (luc->luc_stack.ss_flags & LINUX_SS_DISABLE)
                uc.uc_stack.ss_flags |= SS_DISABLE;
        uc.uc_flags |= _UC_STACK;

        /* build .uc_mcontext */
        gr[_REG_R0] = luc->luc_mcontext.arm_r0;
        gr[_REG_R1] = luc->luc_mcontext.arm_r1;
        gr[_REG_R2] = luc->luc_mcontext.arm_r2;
        gr[_REG_R3] = luc->luc_mcontext.arm_r3;
        gr[_REG_R4] = luc->luc_mcontext.arm_r4;
        gr[_REG_R5] = luc->luc_mcontext.arm_r5;
        gr[_REG_R6] = luc->luc_mcontext.arm_r6;
        gr[_REG_R7] = luc->luc_mcontext.arm_r7;
        gr[_REG_R8] = luc->luc_mcontext.arm_r8;
        gr[_REG_R9] = luc->luc_mcontext.arm_r9;
        gr[_REG_R10] = luc->luc_mcontext.arm_r10;
        gr[_REG_R11] = luc->luc_mcontext.arm_fp;
        gr[_REG_R12] = luc->luc_mcontext.arm_ip;
        gr[_REG_R13] = luc->luc_mcontext.arm_sp;
        gr[_REG_R14] = luc->luc_mcontext.arm_lr;
        gr[_REG_R15] = luc->luc_mcontext.arm_pc;
        gr[_REG_CPSR] = luc->luc_mcontext.arm_cpsr;
        uc.uc_flags |= _UC_CPU;

        aux = (struct linux32_aux_sigframe *)luc->luc_regspace;
        if (aux->vfp.magic == LINUX32_VFP_MAGIC &&
            aux->vfp.size == sizeof(struct linux32_vfp_sigframe)) {

                CTASSERT(__arraycount(vfpregs->__vfp_fstmx) ==
                    __arraycount(aux->vfp.ufp.fpregs));
                for (i = 0; i < __arraycount(vfpregs->__vfp_fstmx); i++)
                        vfpregs->__vfp_fstmx[i] = aux->vfp.ufp.fpregs[i];
                vfpregs->__vfp_fpscr = aux->vfp.ufp.fpscr;

                uc.uc_flags |= _UC_FPU;
        }

        mutex_enter(p->p_lock);
        error = setucontext32(l, &uc);
        mutex_exit(p->p_lock);

        return error;
}

void
linux32_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
{
        struct lwp * const l = curlwp;
        struct proc * const p = l->l_proc;
        struct trapframe * const tf = lwp_trapframe(l);
        stack_t * const ss = &l->l_sigstk;
        const int sig = ksi->ksi_signo;
        const sig_t handler = SIGACTION(p, sig).sa_handler;
        struct linux32_rt_sigframe rt_sigframe_buf, *u_rt_sigframe;
        struct linux32_sigframe *tmp_sigframe, *u_sigframe;
        struct linux32_siginfo *tmp_siginfo, *u_siginfo;
        vaddr_t sp;
        int error;
        const bool onstack_p = /* use signal stack? */
            (ss->ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
            (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
        const bool rt_p = !!(SIGACTION(curproc, ksi->ksi_signo).sa_flags &
            SA_SIGINFO);

        sp = onstack_p ? ((vaddr_t)ss->ss_sp + ss->ss_size) & -16 :
            tf->tf_reg[13];

        memset(&rt_sigframe_buf, 0, sizeof(rt_sigframe_buf));

        if (rt_p) {
                /* allocate rt_sigframe on stack */
                sp -= sizeof(struct linux32_rt_sigframe);
                u_rt_sigframe = (struct linux32_rt_sigframe *)sp;
                u_sigframe = &u_rt_sigframe->sig;
                u_siginfo = &u_rt_sigframe->info;
                tmp_sigframe = &rt_sigframe_buf.sig;
                tmp_siginfo = &rt_sigframe_buf.info;
        } else {
                /* allocate sigframe on stack */
                sp -= sizeof(struct linux32_sigframe);
                u_rt_sigframe = NULL;
                u_sigframe = (struct linux32_sigframe *)sp;
                u_siginfo = NULL;
                tmp_sigframe = &rt_sigframe_buf.sig;
                tmp_siginfo = NULL;
        }

        if ((vaddr_t)sp >= VM_MAXUSER_ADDRESS32) {
                sigexit(l, SIGILL);
                return;
        }

        /* build linux sigframe, and copyout to user stack */
        tmp_sigframe->uc.luc_flags = 0;
        tmp_sigframe->uc.luc_link = NULL;
        NETBSD32PTR32(tmp_sigframe->uc.luc_stack.ss_sp, ss->ss_sp);
        tmp_sigframe->uc.luc_stack.ss_size = ss->ss_size;
        tmp_sigframe->uc.luc_stack.ss_flags = 0;
        if (ss->ss_flags & SS_ONSTACK)
                tmp_sigframe->uc.luc_stack.ss_flags |= LINUX_SS_ONSTACK;
        if (ss->ss_flags & SS_DISABLE)
                tmp_sigframe->uc.luc_stack.ss_flags |= LINUX_SS_DISABLE;
        native_to_linux32_sigset(&tmp_sigframe->uc.luc_sigmask, mask);
        if (tmp_siginfo != NULL)
                native_to_linux32_siginfo(tmp_siginfo, &ksi->ksi_info);
        sendsig_reset(l, sig);

        mutex_exit(p->p_lock);
        linux32_save_sigcontext(l, &tmp_sigframe->uc);

        /* copy linux sigframe onto the user stack */
        if (rt_p) {
                error = copyout(&rt_sigframe_buf, u_rt_sigframe,
                    sizeof(rt_sigframe_buf));
        } else {
                error = copyout(tmp_sigframe, u_sigframe,
                    sizeof(*tmp_sigframe));
        }

        mutex_enter(p->p_lock);

        if (error != 0 || (vaddr_t)handler >= VM_MAXUSER_ADDRESS32) {
                sigexit(l, SIGILL);
                return;
        }

        /* build context to run handler in. */
        tf->tf_reg[0] = native_to_linux_signo[sig];
        tf->tf_reg[1] = NETBSD32PTR32I(u_siginfo);
        tf->tf_reg[2] = NETBSD32PTR32I(&u_sigframe->uc);
        tf->tf_pc = (uint64_t)handler;
        tf->tf_reg[13] = sp;

        /* sigreturn trampoline */
        extern char linux32_sigcode[], linux32_rt_sigcode[];
        vsize_t linux_sigcode_offset;
        if (rt_p) {
                /* set return address to linux32_rt_sigcode() */
                linux_sigcode_offset = linux32_rt_sigcode - linux32_sigcode;
        } else {
                /* set return address to linux32_sigcode() */
                linux_sigcode_offset = linux32_sigcode - linux32_sigcode;
        }
        /* tf->tf_reg[14] is aarch32 lr */
        tf->tf_reg[14] = NETBSD32PTR32I((char *)p->p_sigctx.ps_sigcode +
            linux_sigcode_offset);

        if (onstack_p)
                ss->ss_flags |= SS_ONSTACK;
}

int
linux32_sys_sigreturn(struct lwp *l,
    const struct linux32_sys_sigreturn_args *uap, register_t *retval)
{
        struct trapframe * const tf = lwp_trapframe(l);
        struct linux32_sigframe sigframe;
        int error;

        error = copyin((void *)tf->tf_reg[13], &sigframe, sizeof(sigframe));
        if (error != 0)
                goto done;

        error = linux32_restore_sigcontext(l, &sigframe.uc);
        if (error != 0)
                goto done;
        error = EJUSTRETURN;

 done:
        return error;
}

int
linux32_sys_rt_sigreturn(struct lwp *l,
    const struct linux32_sys_rt_sigreturn_args *uap, register_t *retval)
{
        struct trapframe * const tf = lwp_trapframe(l);
        struct linux32_rt_sigframe rt_sigframe;
        int error;

        error = copyin((void *)tf->tf_reg[13], &rt_sigframe,
            sizeof(rt_sigframe));
        if (error != 0)
                goto done;

        error = linux32_restore_sigcontext(l, &rt_sigframe.sig.uc);
        if (error != 0)
                goto done;
        error = EJUSTRETURN;

 done:
        return error;
}

void
linux32_setregs(struct lwp *l, struct exec_package *pack, u_long stack)
{
        struct trapframe * const tf = lwp_trapframe(l);

        netbsd32_setregs(l, pack, stack);

        /* Same as netbsd32_setregs(), but some registers are set for linux */
        tf->tf_reg[0] = 0;
        tf->tf_reg[12] = 0;
        tf->tf_reg[13] = stack;         /* sp */
        tf->tf_reg[14] = pack->ep_entry;/* lr */
        tf->tf_reg[18] = 0;
        tf->tf_pc = pack->ep_entry;
}

int
linux32_sys_set_tls(struct lwp *l, const struct linux32_sys_set_tls_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(netbsd32_voidp) tls;
        } */
        return lwp_setprivate(l, SCARG_P32(uap, tls));
}

int
linux32_sys_get_tls(struct lwp *l, const void *uap, register_t *retval)
{
        retval[0] = NETBSD32PTR32I(l->l_private);
        return 0;
}