/*      $NetBSD: sunos_machdep.c,v 1.40 2023/12/20 00:40:43 thorpej Exp $       */

/*
 * Copyright (c) 1988 University of Utah.
 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * the Systems Programming Group of the University of Utah Computer
 * Science Department.
 *
 * 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. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 * from: Utah $Hdr: machdep.c 1.63 91/04/24$
 *
 *      @(#)machdep.c   7.16 (Berkeley) 6/3/91
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sunos_machdep.c,v 1.40 2023/12/20 00:40:43 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/filedesc.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/kernel.h>
#include <sys/signal.h>
#include <sys/signalvar.h>
#include <sys/buf.h>

#include <sys/syscallargs.h>
#include <compat/sunos/sunos.h>
#include <compat/sunos/sunos_syscallargs.h>
#include <compat/sys/signal.h>
#include <compat/sys/signalvar.h>

#include <machine/reg.h>

#ifdef DEBUG
extern int sigdebug;
extern int sigpid;
#define SDB_FOLLOW      0x01
#define SDB_KSTACK      0x02
#define SDB_FPSTATE     0x04
#endif

/* sigh.. I guess it's too late to change now, but "our" sigcontext
   is plain vax, not very 68000 (ap, for example..) */
struct sunos_sigcontext {
        int     sc_onstack;             /* sigstack state to restore */
        int     sc_mask;                /* signal mask to restore */
        int     sc_sp;                  /* sp to restore */
        int     sc_pc;                  /* pc to restore */
        int     sc_ps;                  /* psl to restore */
};
struct sunos_sigframe {
        int     sf_signum;              /* signo for handler */
        int     sf_code;                /* additional info for handler */
        struct sunos_sigcontext *sf_scp;/* context pointer for handler */
        u_int   sf_addr;                /* even more info for handler */
        struct sunos_sigcontext sf_sc;  /* I don't know if that's what
                                           comes here */
};
/*
 * much simpler sendsig() for SunOS processes, as SunOS does the whole
 * context-saving in usermode. For now, no hardware information (ie.
 * frames for buserror etc) is saved. This could be fatal, so I take
 * SIG_DFL for "dangerous" signals.
 */
void
sunos_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
{
        u_long code = KSI_TRAPCODE(ksi);
        int sig = ksi->ksi_signo;
        struct lwp *l = curlwp;
        struct proc *p = l->l_proc;
        struct frame *frame = (struct frame *)l->l_md.md_regs;
        int onstack, error;
        struct sunos_sigframe *fp = getframe(l, sig, &onstack), kf;
        sig_t catcher = SIGACTION(p, sig).sa_handler;
        short ft = frame->f_format;

        /*
         * if this is a hardware fault (ft >= FMT9), sunos_sendsig
         * can't currently handle it. Reset signal actions and
         * have the process die unconditionally.
         */
        if (ft >= FMT9) {
                SIGACTION(p, sig).sa_handler = SIG_DFL;
                sigdelset(&p->p_sigctx.ps_sigignore, sig);
                sigdelset(&p->p_sigctx.ps_sigcatch, sig);
                sigdelset(&l->l_sigmask, sig);
                mutex_exit(p->p_lock);
                psignal(p, sig);
                mutex_enter(p->p_lock);
                return;
        }

        fp--;

#ifdef DEBUG
        if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
                printf("sunos_sendsig(%d): sig %d ssp %p usp %p scp %p ft %d\n",
                       p->p_pid, sig, &onstack, fp, &fp->sf_sc, ft);
#endif

        /* Build stack frame for signal trampoline. */
        kf.sf_signum = sig;
        kf.sf_code = code;
        kf.sf_scp = &fp->sf_sc;
        kf.sf_addr = ~0;                /* means: not computable */

        /* Build the signal context to be used by sigreturn. */
        kf.sf_sc.sc_sp = frame->f_regs[SP];
        kf.sf_sc.sc_pc = frame->f_pc;
        kf.sf_sc.sc_ps = frame->f_sr;

        /* Save signal stack. */
        kf.sf_sc.sc_onstack = l->l_sigstk.ss_flags & SS_ONSTACK;

        /* Save signal mask. */
        native_sigset_to_sigset13(mask, &kf.sf_sc.sc_mask);

        sendsig_reset(l, sig);
        mutex_exit(p->p_lock);
        error = copyout(&kf, fp, sizeof(kf));
        mutex_enter(p->p_lock);

        if (error != 0) {
#ifdef DEBUG
                if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
                        printf("sendsig(%d): copyout failed on sig %d\n",
                            p->p_pid, sig);
#endif
                /*
                 * Process has trashed its stack; give it an illegal
                 * instruction to halt it in its tracks.
                 */
                sigexit(l, SIGILL);
                /* NOTREACHED */
        }
#ifdef DEBUG
        if (sigdebug & SDB_FOLLOW)
                printf("sunos_sendsig(%d): sig %d scp %p sc_sp %x\n",
                       p->p_pid, sig, &fp->sf_sc,kf.sf_sc.sc_sp);
#endif

        buildcontext(l, catcher, fp);

        /* Remember that we're now on the signal stack. */
        if (onstack)
                l->l_sigstk.ss_flags |= SS_ONSTACK;

#ifdef DEBUG
        if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
                printf("sunos_sendsig(%d): sig %d returns\n",
                       p->p_pid, sig);
#endif
}


/*
 * System call to cleanup state after a signal
 * has been taken.  Reset signal mask and
 * stack state from context left by sendsig (above).
 * Return to previous pc and psl as specified by
 * context left by sendsig. Check carefully to
 * make sure that the user has not modified the
 * psl to gain improper privileges or to cause
 * a machine fault.
 */
int
sunos_sys_sigreturn(struct lwp *l, const struct sunos_sys_sigreturn_args *uap, register_t *retval)
{
        struct proc *p = l->l_proc;
        struct sunos_sigcontext *scp;
        struct frame *frame;
        struct sunos_sigcontext tsigc;
        sigset_t mask;

        scp = (struct sunos_sigcontext *) SCARG(uap, sigcntxp);
#ifdef DEBUG
        if (sigdebug & SDB_FOLLOW)
                printf("sunos_sigreturn: pid %d, scp %p\n", p->p_pid, scp);
#endif
        if ((int)scp & 1)
                return EINVAL;
        if (copyin((void *)scp, (void *)&tsigc, sizeof(tsigc)) != 0)
                return EFAULT;
        scp = &tsigc;

        /* Make sure the user isn't pulling a fast one on us! */
        if ((scp->sc_ps & (PSL_MBZ|PSL_IPL|PSL_S)) != 0)
                return EINVAL;

        /*
         * Restore the user supplied information
         */

        frame = (struct frame *) l->l_md.md_regs;
        frame->f_regs[SP] = scp->sc_sp;
        frame->f_pc = scp->sc_pc;
        frame->f_sr = scp->sc_ps;

        mutex_enter(p->p_lock);

        /* Restore signal stack. */
        if (scp->sc_onstack & SS_ONSTACK)
                l->l_sigstk.ss_flags |= SS_ONSTACK;
        else
                l->l_sigstk.ss_flags &= ~SS_ONSTACK;

        /* Restore signal mask. */
        native_sigset13_to_sigset(&scp->sc_mask, &mask);
        (void)sigprocmask1(l, SIG_SETMASK, &mask, 0);

        mutex_exit(p->p_lock);

        return EJUSTRETURN;
}