/* $NetBSD: trap.c,v 1.74 2022/05/28 21:14:56 andvar Exp $ */

/*-
 * Copyright (c) 2011 Reinoud Zandijk <reinoud@netbsd.org>
 * 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 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: trap.c,v 1.74 2022/05/28 21:14:56 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/userret.h>
#include <sys/kauth.h>
#include <sys/errno.h>

#include <uvm/uvm_extern.h>
#include <machine/cpu.h>
#include <machine/pcb.h>
#include <machine/pmap.h>
#include <machine/machdep.h>
#include <machine/intr.h>
#include <machine/thunk.h>

#include "opt_kgdb.h"

#ifdef KGDB
#include <sys/kgdb.h>
#endif

/* define maximum signal number */
#ifndef NSIG
#define NSIG 64
#endif

/* forwards and externals */
void setup_signal_handlers(void);
void stop_all_signal_handlers(void);

static sigfunc_t pagefault;
static sigfunc_t illegal_instruction;
static sigfunc_t alarm;
static sigfunc_t sigio;
static sigfunc_t pass_on;

void kgdb_kernel_trap(int signo, vaddr_t pc, vaddr_t va, ucontext_t *ctx);

/* raw signal handlers */
static char    sig_stack[SIGSTKSZ];
static stack_t sigstk;
ucontext_t jump_ucp;

sigfunc_t *sig_funcs[NSIG];

/* segv, bus */
extern bool pmap_fault(pmap_t pmap, vaddr_t va, vm_prot_t *atype);

/* alarm */
void setup_clock_intr(void);
extern void clock_intr(void *priv);

extern int clock_running;
void *alrm_ih;

/* sigio handlers */
struct intr_handler {
        int (*func)(void *);
        void *arg;
};
#define SIGIO_MAX_HANDLERS      8
static struct intr_handler sigio_intr_handler[SIGIO_MAX_HANDLERS];

/* misc */
int astpending = 0;


/* XXX why is it here ? */
void
startlwp(void *arg)
{
        /* nothing here */
}


void
setup_signal_handlers(void)
{
        int i;

        /*
         * Set up the alternative signal stack. This prevents signals to be
         * pushed on the NetBSD/usermode userland's stack with all desastrous
         * effects. Especially ld.so and friends have such tiny stacks that
         * its not feasible.
         */
        sigstk.ss_sp    = sig_stack;
        sigstk.ss_size  = SIGSTKSZ;
        sigstk.ss_flags = 0;
        if (thunk_sigaltstack(&sigstk, 0) < 0)
                panic("can't set alternate stacksize: %d",
                    thunk_geterrno());

        for (i = 0; i < NSIG; i++)
                sig_funcs[i] = NULL;

        /* HUP */
        /* INT */       /* ttycons ^C */
        /* QUIT */
        signal_intr_establish(SIGILL, illegal_instruction);
        signal_intr_establish(SIGTRAP, pass_on);        /* special */
        /* ABRT */
        /* SIGEMT */
        signal_intr_establish(SIGFPE, pass_on);
        /* KILL */
        signal_intr_establish(SIGBUS,  pagefault);
        signal_intr_establish(SIGSEGV, pagefault);
        /* SYS */
        /* PIPE */
        signal_intr_establish(SIGALRM, alarm);
        /* TERM */
        /* URG */
        /* STOP */
        /* TSTP */      /* ttycons ^Z */
        /* CONT */
        /* CHLD */
        /* GTTIN */
        /* TTOU */
        signal_intr_establish(SIGIO,   sigio);
        /* XCPU */
        /* XFSZ */
        /* VTALRM */
        /* PROF */
        /* WINCH */
        /* INFO */
        /* USR1 */
        /* USR2 */
        /* PWR */
}


/* XXX yes this is blunt */
void
stop_all_signal_handlers(void)
{
        int i;
        for (i = 0; i < NSIG; i++)
                if (sig_funcs[i])
                        thunk_sigblock(i);
}


void
setup_clock_intr(void)
{
        /* setup soft interrupt handler */
        alrm_ih = softint_establish(SOFTINT_CLOCK,
                clock_intr, NULL);
}


/* ast and userret */
static void
ast(struct lwp *l)
{
        struct pcb *pcb;

        curcpu()->ci_data.cpu_ntrap++;

        do {
                astpending = 0;
                mi_userret(l);
        } while (astpending);

#if 0
        /* profiling */
        if (l->l_pflag & LP_OWEUPC) {
                l->l_pflag &= ~LP_OWEUPC;
                ADDUPROF(l);
        }
#endif

        KASSERT(l == curlwp); KASSERT(l);
        pcb = lwp_getpcb(l); KASSERT(pcb);
}


void
userret(struct lwp *l)
{
        /* invoke MI userret code */
        mi_userret(l);

        ast(l);
}


#ifdef DEBUG
/*
 * Uncomment the following if you want to receive information about what
 * triggered the fault. Mainly for debugging and porting purposes
 */
static void
print_mem_access_siginfo(int sig, siginfo_t *info, void *ctx,
        vaddr_t pc, vaddr_t va, vaddr_t sp)
{
#if 0
        thunk_printf_debug("SIGSEGV or SIGBUS!\n");
        thunk_printf_debug("\tsi_signo = %d\n", info->si_signo);
        thunk_printf_debug("\tsi_errno = %d\n", info->si_errno);
        thunk_printf_debug("\tsi_code  = %d\n", info->si_code);
        if (info->si_code == SEGV_MAPERR)
                thunk_printf_debug("\t\tSEGV_MAPERR\n");
        if (info->si_code == SEGV_ACCERR)
                thunk_printf_debug("\t\tSEGV_ACCERR\n");
        if (info->si_code == BUS_ADRALN)
                thunk_printf_debug("\t\tBUS_ADRALN\n");
        if (info->si_code == BUS_ADRERR)
                thunk_printf_debug("\t\tBUS_ADRERR\n");
        if (info->si_code == BUS_OBJERR)
                thunk_printf_debug("\t\tBUS_OBJERR\n");
        thunk_printf_debug("\tsi_addr = %p\n", info->si_addr);
        thunk_printf_debug("\tsi_trap = %d\n", info->si_trap);
#endif

#if 0
        thunk_printf("memaccess error, pc %p, va %p, sp %p\n",
                (void *) pc, (void *) va, (void *) sp);
#endif
}

/*
 * Uncomment the following if you want to receive information about what
 * triggered the fault. Mainly for debugging and porting purposes
 */
static void
print_illegal_instruction_siginfo(int sig, siginfo_t *info, void *ctx,
        vaddr_t pc, vaddr_t va, vaddr_t sp)
{
#if 0
        thunk_printf("SIGILL!\n");
        thunk_printf("\tsi_signo = %d\n", info->si_signo);
        thunk_printf("\tsi_errno = %d\n", info->si_errno);
        thunk_printf("\tsi_code  = %d\n", info->si_code);
        if (info->si_code == ILL_ILLOPC)
                thunk_printf("\t\tIllegal opcode");
        if (info->si_code == ILL_ILLOPN)
                thunk_printf("\t\tIllegal operand");
        if (info->si_code == ILL_ILLADR)
                thunk_printf("\t\tIllegal addressing mode");
        if (info->si_code == ILL_ILLTRP)
                thunk_printf("\t\tIllegal trap");
        if (info->si_code == ILL_PRVOPC)
                thunk_printf("\t\tPrivileged opcode");
        if (info->si_code == ILL_PRVREG)
                thunk_printf("\t\tPrivileged register");
        if (info->si_code == ILL_COPROC)
                thunk_printf("\t\tCoprocessor error");
        if (info->si_code == ILL_BADSTK)
                thunk_printf("\t\tInternal stack error");
        thunk_printf("\tsi_addr = %p\n", info->si_addr);
        thunk_printf("\tsi_trap = %d\n", info->si_trap);

        thunk_printf("%p : ", info->si_addr);
        for (int i = 0; i < 10; i++)
                thunk_printf("%02x ", *((uint8_t *) info->si_addr + i));
        thunk_printf("\n");
#endif

#if 0
        thunk_printf("sigill\n");
#endif
}
#else /* DEBUG */
#define print_mem_access_siginfo(s, i, c, p, v, sp) {}
#define print_illegal_instruction_siginfo(s, i, c, p, v, sp) {}
#endif /* DEBUG */


static void
handle_signal(int sig, siginfo_t *info, void *ctx)
{
        sigfunc_t *f;
        ucontext_t *ucp = ctx;
        struct lwp *l;
        struct pcb *pcb;
        vaddr_t va, sp, pc, fp;
        long from_userland;

        if (sig == SIGBUS || sig == SIGSEGV || sig == SIGILL) {
                if (info->si_code == SI_NOINFO)
                        panic("received signal %d with no info",
                            info->si_signo);
        }

        f = sig_funcs[sig];
        KASSERT(f);

        /* get address of possible faulted memory access and page align it */
        va = (vaddr_t) info->si_addr;
        va = trunc_page(va);

        /* get PC address of possibly faulted instruction */
        pc = md_get_pc(ctx);

        /*
         * short-cut for SIGTRAP as we have NO indication anything is valid
         */
#ifdef KGDB
        if (sig == SIGTRAP) {
                from_userland = 0;
                if (pc < kmem_user_end)
                        from_userland = 1;
                if (!from_userland) {
                        kgdb_kernel_trap(sig, pc, va, ucp);
                        return;
                }
        }
#endif

        /* get stack pointer for nesting */
        sp = md_get_sp(ctx);

        if (sig == SIGBUS || sig == SIGSEGV)
                print_mem_access_siginfo(sig, info, ctx, pc, va, sp);
        if (sig == SIGILL)
                print_illegal_instruction_siginfo(sig, info, ctx, pc, va, sp);

        /* get thread */
        l = curlwp; KASSERT(l);
        pcb = lwp_getpcb(l); KASSERT(pcb);

        /* currently running on the dedicated signal stack */

        /* if we're running on a userland stack, switch to the system stack */
        from_userland = 0;
        if ((sp < (vaddr_t) pcb->sys_stack) ||
            (sp > (vaddr_t) pcb->sys_stack_top)) {
                sp = (vaddr_t) pcb->sys_stack_top - sizeof(register_t);
                fp = (vaddr_t) &pcb->pcb_userret_ucp;
                if (pc < kmem_user_end)
                        from_userland = 1;
        } else {
                /* stack grows down */
                fp = sp - sizeof(ucontext_t) - sizeof(register_t); /* slack */
                sp = fp - sizeof(register_t);   /* slack */

                /* sanity check before copying */
                if (fp - 4*PAGE_SIZE < (vaddr_t) pcb->sys_stack)
                        panic("%s: out of system stack", __func__);
        }

        memcpy((void *) fp, ucp, sizeof(ucontext_t));
        memcpy(&jump_ucp, ucp, sizeof(ucontext_t));

        /* create context */
        jump_ucp.uc_stack.ss_sp = (void *) pcb->sys_stack;
        jump_ucp.uc_stack.ss_size = sp - (vaddr_t) pcb->sys_stack;
        jump_ucp.uc_link = (void *) fp; /* link to old frame on stack */

        /* prevent multiple nested SIGIOs */
        if (sig == SIGIO)
                thunk_sigfillset(&jump_ucp.uc_sigmask);
        else
                thunk_sigemptyset(&jump_ucp.uc_sigmask);
        jump_ucp.uc_flags = _UC_STACK | _UC_CPU | _UC_SIGMASK;

        thunk_makecontext(&jump_ucp,
                        (void (*)(void)) f,
                4, info, (void *) from_userland, (void *) pc, (void *) va);

        /* switch to the new context on return from signal */
        thunk_setcontext(&jump_ucp);
//      memcpy(ctx, &pcb->pcb_ucp, sizeof(ucontext_t));
}


void
signal_intr_establish(int sig, sigfunc_t f)
{
        static struct sigaction sa;

        sig_funcs[sig] = f;

        sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
        sa.sa_sigaction = (void *) handle_signal;
        thunk_sigfillset(&sa.sa_mask);
        if (thunk_sigaction(sig, &sa, NULL) == -1)
                panic("couldn't register SIG%d handler: %d", sig,
                    thunk_geterrno());
}


/*
 * Context for handing page faults from the sigsegv handler; check if its a
 * pmap reference fault or let uvm handle it.
 */
static void
pagefault(siginfo_t *info, vaddr_t from_userland, vaddr_t pc, vaddr_t va)
{
        struct proc *p;
        struct lwp *l;
        struct pcb *pcb;
        struct vmspace *vm;
        struct vm_map *vm_map;
        vm_prot_t atype;
        void *onfault;
        int from_kernel, lwp_errno, error;
        ksiginfo_t ksi;

        l = curlwp; KASSERT(l);
        pcb = lwp_getpcb(l);
        p = l->l_proc;
        vm = p->p_vmspace;

        lwp_errno = thunk_geterrno();

        vm_map = &vm->vm_map;
        from_kernel = (pc >= kmem_k_start) && (!from_userland);
        if (from_kernel && (va >= VM_MIN_KERNEL_ADDRESS))
                vm_map = kernel_map;

#if 0
        thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
        thunk_printf("\tpc %p, va %p\n", (void *) pc, (void *) va);
#endif

        /* can pmap handle it? on its own? (r/m) emulation */
        if (pmap_fault(vm_map->pmap, va, &atype)) {
                /* no use doing anything else here */
                goto out_quick;
        }

        /* ask UVM */
#if 0
thunk_printf("%s: l %p, pcb %p, ", __func__, l, pcb);
thunk_printf("pc %p, va %p ", (void *) pc, (void *) va);
thunk_printf("derived atype %d\n", atype);
#endif
        thunk_printf_debug("pmap fault couldn't handle it! : "
                "derived atype %d\n", atype);

        onfault = pcb->pcb_onfault;
        pcb->pcb_onfault = NULL;
        error = uvm_fault(vm_map, va, atype);
        pcb->pcb_onfault = onfault;

        if (vm_map != kernel_map) {
                if (error == 0)
                        uvm_grow(l->l_proc, va);
        }
        if (error == EACCES)
                error = EFAULT;

        /* if uvm handled it, return */
        if (error == 0) {
//              thunk_printf("pagefault leave (uvm)\n");
                goto out;
        }

        /* check if its from copyin/copyout */
        if (onfault) {
                panic("%s: can't call onfault yet\n", __func__);
                /* XXX implement me ? */
                /* jump to given onfault */
                // tf = &kernel_tf;
                // memset(tf, 0, sizeof(struct trapframe));
                // tf->tf_pc = onfault;
                // tf->tf_io[0] = (rv == EACCES) ? EFAULT : rv;
                goto out;
        }

        if (from_kernel) {
                thunk_printf("%s: uvm fault %d, pc %p, va %p, from_kernel %d\n",
                        __func__, error, (void *) pc, (void *) va, from_kernel);
                panic("Unhandled page fault in kernel mode");
        }

        /* send signal */
        /* something got wrong */
        thunk_printf_debug("%s: uvm fault %d, pc %p, va %p, from_kernel %d\n",
                __func__, error, (void *) pc, (void *) va, from_kernel);

        thunk_printf_debug("giving signal to userland\n");

        KASSERT(from_userland);
        KSI_INIT_TRAP(&ksi);
        ksi.ksi_signo = info->si_signo;
        ksi.ksi_trap = 0;       /* XXX */
        ksi.ksi_code = (error == EPERM) ? SEGV_ACCERR : SEGV_MAPERR;
        ksi.ksi_addr = (void *) va;

        if (error == ENOMEM) {
                printf("UVM: pid %d.%d (%s), uid %d killed: "
                    "out of swap\n",
                    p->p_pid, l->l_lid, p->p_comm,
                    l->l_cred ? kauth_cred_geteuid(l->l_cred) : -1);
                ksi.ksi_signo = SIGKILL;
        }

#if 0
        p->p_emul->e_trapsignal(l, &ksi);
#else
        trapsignal(l, &ksi);
#endif

//      thunk_printf("pagefault leave\n");
out:
        if (from_userland)
                userret(l);
out_quick:
        thunk_seterrno(lwp_errno);
        pcb->pcb_errno = lwp_errno;
}


/*
 * handle an illegal instruction.
 *
 * arguments 'pc' and 'va' are ignored here
 */
static void
illegal_instruction(siginfo_t *info, vaddr_t from_userland, vaddr_t pc, vaddr_t va)
{
        struct lwp *l = curlwp;
        struct pcb *pcb = lwp_getpcb(l);
        ucontext_t *ucp = &pcb->pcb_userret_ucp;
        ksiginfo_t ksi;

//      thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);

        KASSERT(from_userland);

        /* if its a syscall ... */
        if (md_syscall_check_opcode(ucp)) {
                syscall();
                userret(l);
                return;
        }

        thunk_printf("%s: giving SIGILL (TRAP)\n", __func__);

        KASSERT(from_userland);
        KSI_INIT_TRAP(&ksi);
        ksi.ksi_signo = SIGILL;
        ksi.ksi_trap  = 0;      /* XXX */
        ksi.ksi_errno = 0; // info->si_errno;
        ksi.ksi_code  = 0; // info->si_code;
        ksi.ksi_addr  = (void *) md_get_pc(ucp); /* only reliable source */

#if 0
        p->p_emul->e_trapsignal(l, &ksi);
#else
        trapsignal(l, &ksi);
#endif
        userret(l);
}


/*
 * handle pass to userland signals
 *
 * arguments other than the original siginfo_t are not used
 */
static void
pass_on(siginfo_t *info, vaddr_t from_userland, vaddr_t pc, vaddr_t va)
{
        struct lwp *l = curlwp;
        struct pcb *pcb = lwp_getpcb(l);
        ucontext_t *ucp = &pcb->pcb_userret_ucp;
        ksiginfo_t ksi;

        KASSERT(from_userland);
        KSI_INIT_TRAP(&ksi);
        ksi.ksi_signo = info->si_signo;
        ksi.ksi_trap  = 0;      /* XXX ? */
        ksi.ksi_errno = info->si_errno;
        ksi.ksi_code  = info->si_code;
        ksi.ksi_addr  = (void *) md_get_pc(ucp); /* only reliable source */

        trapsignal(l, &ksi);
        userret(l);
}


/*
 * handle alarm, a clock ticker.
 *
 * arguments 'pc' and 'va' are ignored here
 */
static void
alarm(siginfo_t *info, vaddr_t from_userland, vaddr_t pc, vaddr_t va)
{
        struct lwp *l = curlwp;
        struct pcb *pcb = lwp_getpcb(l); KASSERT(pcb);

        if (!clock_running)
                return;
//      thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);

        softint_schedule(alrm_ih);

        KASSERT(l == curlwp);
        if (from_userland)
                userret(l);
}


/*
 * handle sigio, a mux for all io operations.
 *
 * arguments 'pc' and 'va' are ignored here
 */
static void
sigio(siginfo_t *info, vaddr_t from_userland, vaddr_t pc, vaddr_t va)
{
        struct lwp *l = curlwp;
        struct pcb *pcb = lwp_getpcb(l); KASSERT(pcb);
        struct intr_handler *sih;
        unsigned int n, pass;

//      thunk_printf("%s: l %p, pcb %p\n", __func__, l, pcb);
        for (pass = 0; pass < 2; pass++) {
                for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
                        sih = &sigio_intr_handler[n];
                        if (sih->func)
                                sih->func(sih->arg);
                }
        }

        KASSERT(l == curlwp);
        if (from_userland)
                userret(l);             /* or ast? */
}


/* sigio register function */
void *
sigio_intr_establish(int (*func)(void *), void *arg)
{
        struct intr_handler *sih;
        unsigned int n;

        for (n = 0; n < SIGIO_MAX_HANDLERS; n++) {
                sih = &sigio_intr_handler[n];
                if (sih->func == NULL) {
                        sih->func = func;
                        sih->arg = arg;
                        return sih;
                }
        }

        panic("increase SIGIO_MAX_HANDLERS");
}