/************************************************************ * sig_action.c * * Copyright (C) 2007 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * 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 Gregory Nutt 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 COPYRIGHT HOLDERS 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 * COPYRIGHT OWNER 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. * ************************************************************/ /************************************************************ * Included Files ************************************************************/ #include #include #include #include #include "os_internal.h" #include "sig_internal.h" /************************************************************ * Definitions ************************************************************/ #define COPY_SIGACTION(t,f) \ { (t)->sa_sigaction = (f)->sa_sigaction; \ (t)->sa_mask = (f)->sa_mask; \ (t)->sa_flags = (f)->sa_flags; } /************************************************************ * Private Type Declarations ************************************************************/ /************************************************************ * Global Variables ************************************************************/ /************************************************************ * Private Variables ************************************************************/ /************************************************************ * Private Functions ************************************************************/ /************************************************************ * Function: sig_allocateaction * * Description: * Allocate a new element for a sigaction queue * ************************************************************/ static sigactq_t *sig_allocateaction(void) { sigactq_t *sigact; /* Try to get the signal action structure from the free list */ sigact = (sigactq_t*)sq_remfirst(&g_sigfreeaction); /* Check if we got one. */ if (!sigact) { /* Add another block of signal actions to the list */ sig_allocateactionblock(); /* And try again */ sigact = (sigactq_t*)sq_remfirst(&g_sigfreeaction); if (!sigact) { PANIC(OSERR_OUTOFMEMORY); } } return sigact; } /************************************************************ * Public Functions ************************************************************/ /************************************************************ * Function: sigaction * * Description: * This function allows the calling process to examine * and/or specify the action to be associated with a * specific signal. * * The structure sigaction, used to describe an action to * be taken, is defined to include the following members: * * - sa_u.sa_handler: Pointer to a signal-catching * function * - sa_u.sa_sigaction: Alternative form of the * signal-catching function * - sa_mask: An additional set of signals to be blocked * during execution of a signal catching function * - sa_flags. Special flags to affect the behavior of a * signal. * * If the argument 'act' is not NULL, it points to a * structure specifying the action to be associated with * the specified signal. If the argument 'oact' is not * NULL, the action previously associated with the signal * is stored in the location pointed to by the argument * 'oact.' * * When a signal is caught by a signal-catching function * installed by sigaction() function, a new signal mask is * calculated and installed for the duration of the * signal-catching function. This mask is formed by taking * the union of the current signal mask and the value of the * sa_mask for the signal being delivered and then including * the signal being delivered. If and when the user's signal * handler returns, the original signal mask is restored. * * Once an action is installed for a specific signal, it * remains installed until another action is explicitly * requested by another call to sigaction(). * * Parameters: * sig - Signal of interest * act - Location of new handler * oact - Location to store only handler * * Return Value: * 0 (OK), or -1 (ERROR) if the signal number is invalid. * (errno is not set) * * Assumptions: * * POSIX Compatibility: * - Special values of sa_handler in the struct sigaction * act input not handled (SIG_DFL, SIG_IGN). * - All sa_flags in struct sigaction of act input are * ignored (all treated like SA_SIGINFO). * ************************************************************/ int sigaction(int signo, const struct sigaction *act, struct sigaction *oact) { _TCB *rtcb = (_TCB*)g_readytorun.head; sigactq_t *sigact; int ret = ERROR; /* Assume failure */ /* Since sigactions can only be installed from the running * thread of execution, no special precautions should be * necessary. */ /* Verify the signal */ if (GOOD_SIGNO(signo)) { ret = OK; /* Assume success */ /* Find the signal in the sigactionq */ sigact = sig_findaction(rtcb, signo); /* Return the old sigaction value if so requested */ if (oact) { if (sigact) { COPY_SIGACTION(oact, &sigact->act); } else { /* There isn't an old value */ oact->sa_u._sa_handler = NULL; oact->sa_mask = NULL_SIGNAL_SET; oact->sa_flags = 0; } } /* If no sigaction was found, but one is needed, then * allocate one. */ if (!sigact && act && act->sa_u._sa_handler) { sigact = sig_allocateaction(); /* An error has occurred if we could not allocate the sigaction */ if (!sigact) { ret = ERROR; } else { /* Put the signal number in the queue entry */ sigact->signo = (ubyte)signo; /* Add the new sigaction to sigactionq */ sq_addlast((sq_entry_t*)sigact, &rtcb->sigactionq); } } /* Set the new sigaction if so requested */ if ((sigact) && (act)) { /* Check if it is a request to install a new handler */ if (act->sa_u._sa_handler) { COPY_SIGACTION(&sigact->act, act); } /* No.. It is a request to remove the old handler */ else { /* Remove the old sigaction from sigactionq */ sq_rem((sq_entry_t*)sigact, &rtcb->sigactionq); /* And deallocate it */ sig_releaseaction(sigact); } } } return ret; } /************************************************************ * Function: sig_releaseaction * * Description: * Deallocate a sigaction Q entry * ************************************************************/ void sig_releaseaction(sigactq_t *sigact) { /* Just put it back on the free list */ sq_addlast((sq_entry_t*)sigact, &g_sigfreeaction); }