sparc/sys/signal.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*LINTLIBRARY*/

/*
 * 4.3BSD signal compatibility functions
 *
 * the implementation interprets signal masks equal to -1 as "all of the
 * signals in the signal set", thereby allowing signals with numbers
 * above 32 to be blocked when referenced in code such as:
 *
 *  for (i = 0; i < NSIG; i++)
 *      mask |= sigmask(i)
 */

#include <sys/types.h>
#include <ucontext.h>
#include <signal.h>
#include <errno.h>

#undef  BUS_OBJERR  /* namespace conflict */
#include <sys/siginfo.h>
#include "libc.h"

#pragma weak sigvechandler = _sigvechandler
#pragma weak sigsetmask = _sigsetmask
#pragma weak sigblock = _sigblock
#pragma weak sigpause = usigpause
#pragma weak sigvec = _sigvec
#pragma weak sigstack = _sigstack
#pragma weak signal = usignal
#pragma weak siginterrupt = _siginterrupt

/*
 * DO NOT remove the _ from these 3 functions or the subsequent
 * calls to them below.  The non _ versions of these functions
 * are the wrong functions to call.  This is BCP.  Extra
 * care should be taken when modifying this code.
 */
extern int _sigfillset(sigset_t *);
extern int _sigemptyset(sigset_t *);
extern int _sigprocmask(int, const sigset_t *, sigset_t *);

#define set2mask(setp) ((setp)->__sigbits[0])
#define mask2set(mask, setp) \
    ((mask) == -1 ? _sigfillset(setp) : \
        ((void) _sigemptyset(setp), (((setp)->__sigbits[0]) = (int)(mask))))

void (*_siguhandler[NSIG])() = { 0 };

/*
 * forward declarations
 */
int ucbsiginterrupt(int, int);
int ucbsigvec(int, struct sigvec *, struct sigvec *);
int ucbsigpause(int);
int ucbsigblock(int);
int ucbsigsetmask(int);
static void ucbsigvechandler(int, siginfo_t *, ucontext_t *);

/*
 * sigvechandler is the real signal handler installed for all
 * signals handled in the 4.3BSD compatibility interface - it translates
 * SVR4 signal hander arguments into 4.3BSD signal handler arguments
 * and then calls the real handler
 */

int
_sigvechandler(int sig, siginfo_t *sip, ucontext_t *ucp)
{
    ucbsigvechandler(sig, sip, ucp);
    return (0); /* keep the same as the original prototype */
}

static void
ucbsigvechandler(int sig, siginfo_t *sip, ucontext_t *ucp)
{
    struct sigcontext sc;
    int code;
    char *addr;
#ifdef NEVER
    int gwinswitch = 0;
#endif

    sc.sc_onstack = ((ucp->uc_stack.ss_flags & SS_ONSTACK) != 0);
    sc.sc_mask = set2mask(&ucp->uc_sigmask);

#if defined(__sparc)
    if (sig == SIGFPE && sip != NULL && SI_FROMKERNEL(sip) &&
        (sip->si_code == FPE_INTDIV || sip->si_code == FPE_INTOVF)) {
        /*
         * Hack to emulate the 4.x kernel behavior of incrementing
         * the PC on integer divide by zero and integer overflow
         * on sparc machines.  (5.x does not increment the PC.)
         */
        ucp->uc_mcontext.gregs[REG_PC] =
            ucp->uc_mcontext.gregs[REG_nPC];
        ucp->uc_mcontext.gregs[REG_nPC] += 4;
    }
    sc.sc_sp = ucp->uc_mcontext.gregs[REG_SP];
    sc.sc_pc = ucp->uc_mcontext.gregs[REG_PC];
    sc.sc_npc = ucp->uc_mcontext.gregs[REG_nPC];

    /* XX64 There is no REG_PSR for sparcv9, we map in REG_CCR for now */
#if defined(__sparcv9)
    sc.sc_psr = ucp->uc_mcontext.gregs[REG_CCR];
#else
    sc.sc_psr = ucp->uc_mcontext.gregs[REG_PSR];
#endif

    sc.sc_g1 = ucp->uc_mcontext.gregs[REG_G1];
    sc.sc_o0 = ucp->uc_mcontext.gregs[REG_O0];

    /*
     * XXX - What a kludge!
     * Store a pointer to the original ucontext_t in the sigcontext
     * so that it's available to the sigcleanup call that needs to
     * return from the signal handler.  Otherwise, vital information
     * (e.g., the "out" registers) that's only saved in the
     * ucontext_t isn't available to sigcleanup.
     */
    sc.sc_wbcnt = (int)(sizeof (*ucp));
    sc.sc_spbuf[0] = (char *)(uintptr_t)sig;
    sc.sc_spbuf[1] = (char *)ucp;
#ifdef NEVER
    /*
     * XXX - Sorry, we can never pass the saved register windows
     * on in the sigcontext because we use that space to save the
     * ucontext_t.
     */
    if (ucp->uc_mcontext.gwins != (gwindows_t *)0) {
        int i, j;

        gwinswitch = 1;
        sc.sc_wbcnt = ucp->uc_mcontext.gwins->wbcnt;
        /* XXX - should use bcopy to move this in bulk */
        for (i = 0; i < ucp->uc_mcontext.gwins; i++) {
            sc.sc_spbuf[i] = ucp->uc_mcontext.gwins->spbuf[i];
            for (j = 0; j < 8; j++)
                sc.sc_wbuf[i][j] =
                    ucp->uc_mcontext.gwins->wbuf[i].rw_local[j];
            for (j = 0; j < 8; j++)
                sc.sc_wbuf[i][j+8] =
                    ucp->uc_mcontext.gwins->wbuf[i].rw_in[j];
        }
    }
#endif
#endif

    /*
     * Translate signal codes from new to old.
     * /usr/include/sys/siginfo.h contains new codes.
     * /usr/ucbinclude/sys/signal.h contains old codes.
     */
    code = 0;
    addr = SIG_NOADDR;
    if (sip != NULL && SI_FROMKERNEL(sip)) {
        addr = sip->si_addr;

        switch (sig) {
        case SIGILL:
            switch (sip->si_code) {
            case ILL_PRVOPC:
                code = ILL_PRIVINSTR_FAULT;
                break;
            case ILL_BADSTK:
                code = ILL_STACK;
                break;
            case ILL_ILLTRP:
                code = ILL_TRAP_FAULT(sip->si_trapno);
                break;
            default:
                code = ILL_ILLINSTR_FAULT;
                break;
            }
            break;

        case SIGEMT:
            code = EMT_TAG;
            break;

        case SIGFPE:
            switch (sip->si_code) {
            case FPE_INTDIV:
                code = FPE_INTDIV_TRAP;
                break;
            case FPE_INTOVF:
                code = FPE_INTOVF_TRAP;
                break;
            case FPE_FLTDIV:
                code = FPE_FLTDIV_TRAP;
                break;
            case FPE_FLTOVF:
                code = FPE_FLTOVF_TRAP;
                break;
            case FPE_FLTUND:
                code = FPE_FLTUND_TRAP;
                break;
            case FPE_FLTRES:
                code = FPE_FLTINEX_TRAP;
                break;
            default:
                code = FPE_FLTOPERR_TRAP;
                break;
            }
            break;

        case SIGBUS:
            switch (sip->si_code) {
            case BUS_ADRALN:
                code = BUS_ALIGN;
                break;
            case BUS_ADRERR:
                code = BUS_HWERR;
                break;
            default:    /* BUS_OBJERR */
                code = FC_MAKE_ERR(sip->si_errno);
                break;
            }
            break;

        case SIGSEGV:
            switch (sip->si_code) {
            case SEGV_MAPERR:
                code = SEGV_NOMAP;
                break;
            case SEGV_ACCERR:
                code = SEGV_PROT;
                break;
            default:
                code = FC_MAKE_ERR(sip->si_errno);
                break;
            }
            break;

        default:
            addr = SIG_NOADDR;
            break;
        }
    }

    (*_siguhandler[sig])(sig, code, &sc, addr);

    if (sc.sc_onstack)
        ucp->uc_stack.ss_flags |= SS_ONSTACK;
    else
        ucp->uc_stack.ss_flags &= ~SS_ONSTACK;
    mask2set(sc.sc_mask, &ucp->uc_sigmask);

#if defined(__sparc)
    ucp->uc_mcontext.gregs[REG_SP] = sc.sc_sp;
    ucp->uc_mcontext.gregs[REG_PC] = sc.sc_pc;
    ucp->uc_mcontext.gregs[REG_nPC] = sc.sc_npc;
#if defined(__sparcv9)
    ucp->uc_mcontext.gregs[REG_CCR] = sc.sc_psr;
#else
    ucp->uc_mcontext.gregs[REG_PSR] = sc.sc_psr;
#endif
    ucp->uc_mcontext.gregs[REG_G1] = sc.sc_g1;
    ucp->uc_mcontext.gregs[REG_O0] = sc.sc_o0;
#ifdef NEVER
    if (gwinswitch == 1) {
        int i, j;

        ucp->uc_mcontext.gwins->wbcnt = sc.sc_wbcnt;
        /* XXX - should use bcopy to move this in bulk */
        for (i = 0; i < sc.sc_wbcnt; i++) {
            ucp->uc_mcontext.gwins->spbuf[i] = sc.sc_spbuf[i];
            for (j = 0; j < 8; j++)
                ucp->uc_mcontext.gwins->wbuf[i].rw_local[j] =
                    sc.sc_wbuf[i][j];
            for (j = 0; j < 8; j++)
                ucp->uc_mcontext.gwins->wbuf[i].rw_in[j] =
                    sc.sc_wbuf[i][j+8];
        }
    }
#endif

    if (sig == SIGFPE) {
        if (ucp->uc_mcontext.fpregs.fpu_qcnt > 0) {
            ucp->uc_mcontext.fpregs.fpu_qcnt--;
            ucp->uc_mcontext.fpregs.fpu_q++;
        }
    }
#endif

    (void) setcontext(ucp);
}

#if defined(__sparc)
/*
 * Emulate the special sigcleanup trap.
 * This is only used by statically linked 4.x applications
 * and thus is only called by the static BCP support.
 * It lives here because of its close relationship with
 * the ucbsigvechandler code above.
 *
 * It's used by 4.x applications to:
 *  1. return from a signal handler (in __sigtramp)
 *  2. [sig]longjmp
 *  3. context switch, in the old 4.x liblwp
 */

void
__sigcleanup(struct sigcontext *scp)
{
    ucontext_t uc, *ucp;
    int sig;

    /*
     * If there's a pointer to a ucontext_t hiding in the sigcontext,
     * we *must* use that to return, since it contains important data
     * such as the original "out" registers when the signal occurred.
     */
    if (scp->sc_wbcnt == sizeof (*ucp)) {
        sig = (int)(uintptr_t)scp->sc_spbuf[0];
        ucp = (ucontext_t *)scp->sc_spbuf[1];
    } else {
        /*
         * Otherwise, use a local ucontext_t and
         * initialize it with getcontext.
         */
        sig = 0;
        ucp = &uc;
        (void) getcontext(ucp);
    }

    if (scp->sc_onstack) {
        ucp->uc_stack.ss_flags |= SS_ONSTACK;
    } else
        ucp->uc_stack.ss_flags &= ~SS_ONSTACK;
    mask2set(scp->sc_mask, &ucp->uc_sigmask);

    ucp->uc_mcontext.gregs[REG_SP] = scp->sc_sp;
    ucp->uc_mcontext.gregs[REG_PC] = scp->sc_pc;
    ucp->uc_mcontext.gregs[REG_nPC] = scp->sc_npc;
#if defined(__sparcv9)
    ucp->uc_mcontext.gregs[REG_CCR] = scp->sc_psr;
#else
    ucp->uc_mcontext.gregs[REG_PSR] = scp->sc_psr;
#endif
    ucp->uc_mcontext.gregs[REG_G1] = scp->sc_g1;
    ucp->uc_mcontext.gregs[REG_O0] = scp->sc_o0;

    if (sig == SIGFPE) {
        if (ucp->uc_mcontext.fpregs.fpu_qcnt > 0) {
            ucp->uc_mcontext.fpregs.fpu_qcnt--;
            ucp->uc_mcontext.fpregs.fpu_q++;
        }
    }
    (void) setcontext(ucp);
    /* NOTREACHED */
}
#endif

int
_sigsetmask(int mask)
{
    return (ucbsigsetmask(mask));
}

int
ucbsigsetmask(int mask)
{
    sigset_t oset;
    sigset_t nset;

    (void) _sigprocmask(0, (sigset_t *)0, &nset);
    mask2set(mask, &nset);
    (void) _sigprocmask(SIG_SETMASK, &nset, &oset);
    return (set2mask(&oset));
}

int
_sigblock(int mask)
{
    return (ucbsigblock(mask));
}

int
ucbsigblock(int mask)
{
    sigset_t oset;
    sigset_t nset;

    (void) _sigprocmask(0, (sigset_t *)0, &nset);
    mask2set(mask, &nset);
    (void) _sigprocmask(SIG_BLOCK, &nset, &oset);
    return (set2mask(&oset));
}

int
usigpause(int mask)
{
    return (ucbsigpause(mask));
}

int
ucbsigpause(int mask)
{
    sigset_t set, oset;
    int ret;

    (void) _sigprocmask(0, (sigset_t *)0, &set);
    oset = set;
    mask2set(mask, &set);
    ret = sigsuspend(&set);
    (void) _sigprocmask(SIG_SETMASK, &oset, (sigset_t *)0);
    return (ret);
}

int
_sigvec(int sig, struct sigvec *nvec, struct sigvec *ovec)
{
    return (ucbsigvec(sig, nvec, ovec));
}

int
ucbsigvec(int sig, struct sigvec *nvec, struct sigvec *ovec)
{
    struct sigaction nact;
    struct sigaction oact;
    struct sigaction *nactp;
    void (*ohandler)(int, int, struct sigcontext *, char *);
    void (*nhandler)(int, int, struct sigcontext *, char *);

    if (sig <= 0 || sig >= NSIG) {
        errno = EINVAL;
        return (-1);
    }

    if ((long)ovec == -1L || (long)nvec == -1L) {
        errno = EFAULT;
        return (-1);
    }

    ohandler = _siguhandler[sig];

    if (nvec) {
        (void) _sigaction(sig, (struct sigaction *)0, &nact);
        nhandler = nvec->sv_handler;
        /*
         * To be compatible with the behavior of SunOS 4.x:
         * If the new signal handler is SIG_IGN or SIG_DFL,
         * do not change the signal's entry in the handler array.
         * This allows a child of vfork(2) to set signal handlers
         * to SIG_IGN or SIG_DFL without affecting the parent.
         */
        if ((void (*)(int))nhandler != SIG_DFL &&
            (void (*)(int))nhandler != SIG_IGN) {
            _siguhandler[sig] = nhandler;
            nact.sa_handler = (void (*)(int))ucbsigvechandler;
        } else {
            nact.sa_handler = (void (*)(int))nhandler;
        }
        mask2set(nvec->sv_mask, &nact.sa_mask);
        if (sig == SIGKILL || sig == SIGSTOP)
            nact.sa_handler = SIG_DFL;
        nact.sa_flags = SA_SIGINFO;
        if (!(nvec->sv_flags & SV_INTERRUPT))
            nact.sa_flags |= SA_RESTART;
        if (nvec->sv_flags & SV_RESETHAND)
            nact.sa_flags |= SA_RESETHAND;
        if (nvec->sv_flags & SV_ONSTACK)
            nact.sa_flags |= SA_ONSTACK;
        nactp = &nact;
    } else
        nactp = (struct sigaction *)0;

    if (_sigaction(sig, nactp, &oact) < 0) {
        _siguhandler[sig] = ohandler;
        return (-1);
    }

    if (ovec) {
        if (oact.sa_handler == SIG_DFL || oact.sa_handler == SIG_IGN)
            ovec->sv_handler =
                (void (*) (int, int, struct sigcontext *, char *))
                oact.sa_handler;
        else
            ovec->sv_handler = ohandler;
        ovec->sv_mask = set2mask(&oact.sa_mask);
        ovec->sv_flags = 0;
        if (oact.sa_flags & SA_ONSTACK)
            ovec->sv_flags |= SV_ONSTACK;
        if (oact.sa_flags & SA_RESETHAND)
            ovec->sv_flags |= SV_RESETHAND;
        if (!(oact.sa_flags & SA_RESTART))
            ovec->sv_flags |= SV_INTERRUPT;
    }

    return (0);
}

int
_sigstack(struct sigstack *nss, struct sigstack *oss)
{
    struct sigaltstack nalt;
    struct sigaltstack oalt;
    struct sigaltstack *naltp;

    if (nss) {
        /*
         * XXX: assumes stack growth is down (like sparc)
         */
        nalt.ss_sp = nss->ss_sp - SIGSTKSZ;
        nalt.ss_size = SIGSTKSZ;
        nalt.ss_flags = 0;
        naltp = &nalt;
    } else
        naltp = (struct sigaltstack *)0;

    if (sigaltstack(naltp, &oalt) < 0)
        return (-1);

    if (oss) {
        /*
         * XXX: assumes stack growth is down (like sparc)
         */
        oss->ss_sp = oalt.ss_sp + oalt.ss_size;
        oss->ss_onstack = ((oalt.ss_flags & SS_ONSTACK) != 0);
    }

    return (0);
}

void (*
ucbsignal(int s, void (*a)(int)))(int)
{
    struct sigvec osv;
    struct sigvec nsv;
    static int mask[NSIG];
    static int flags[NSIG];

    nsv.sv_handler = (void (*) (int, int, struct sigcontext *, char *)) a;
    nsv.sv_mask = mask[s];
    nsv.sv_flags = flags[s];
    if (ucbsigvec(s, &nsv, &osv) < 0)
        return (SIG_ERR);
    if (nsv.sv_mask != osv.sv_mask || nsv.sv_flags != osv.sv_flags) {
        mask[s] = nsv.sv_mask = osv.sv_mask;
        flags[s] = nsv.sv_flags =
            osv.sv_flags & ~(SV_RESETHAND|SV_INTERRUPT);
        if (ucbsigvec(s, &nsv, (struct sigvec *)0) < 0)
            return (SIG_ERR);
    }
    return ((void (*) (int)) osv.sv_handler);
}

void (*
usignal(int s, void (*a) (int)))(int)
{
    return (ucbsignal(s, a));
}

/*
 * Set signal state to prevent restart of system calls
 * after an instance of the indicated signal.
 */

int
_siginterrupt(int sig, int flag)
{
    return (ucbsiginterrupt(sig, flag));
}

int
ucbsiginterrupt(int sig, int flag)
{
    struct sigvec sv;
    int ret;

    if ((ret = ucbsigvec(sig, 0, &sv)) < 0)
        return (ret);
    if (flag)
        sv.sv_flags |= SV_INTERRUPT;
    else
        sv.sv_flags &= ~SV_INTERRUPT;
    return (ucbsigvec(sig, &sv, 0));
}