signal.cpp File Reference

#include <corecrt_internal.h>
#include <errno.h>
#include <excpt.h>
#include <float.h>
#include <malloc.h>
#include <signal.h>
#include <stddef.h>
#include <string.h>

Include dependency graph for signal.cpp:

Go to the source code of this file.

Macros
#define	_SIGHUP_IGNORE   1
#define	_SIGQUIT_IGNORE   3
#define	_SIGPIPE_IGNORE   13
#define	_SIGIOINT_IGNORE   16
#define	_SIGSTOP_IGNORE   17

Functions
void __cdecl	__acrt_initialize_signal_handlers (void *const encoded_nullptr)
static __crt_signal_handler_t *__cdecl	get_global_action_nolock (int const signum) throw ()
static __crt_signal_action_t *__cdecl	siglookup (int const signum, __crt_signal_action_t *const action_table) throw ()
static __crt_signal_handler_t __cdecl	signal_failed (int const signum) throw ()
static __inline BOOL	is_unsupported_signal (int const, __crt_signal_handler_t const sigact)
static __inline BOOL	is_console_signal (int const signum)
static BOOL WINAPI	ctrlevent_capture (DWORD const ctrl_type) throw ()
__crt_signal_handler_t __cdecl	signal (int signum, __crt_signal_handler_t sigact)
int __cdecl	raise (int const signum)
__crt_signal_handler_t __cdecl	__acrt_get_sigabrt_handler ()
int *__cdecl	__fpecode ()
void **__cdecl	__pxcptinfoptrs ()

Variables
static __crt_state_management::dual_state_global< __crt_signal_handler_t >	ctrlc_action
static __crt_state_management::dual_state_global< __crt_signal_handler_t >	ctrlbreak_action
static __crt_state_management::dual_state_global< __crt_signal_handler_t >	abort_action
static __crt_state_management::dual_state_global< __crt_signal_handler_t >	term_action
static bool	console_ctrl_handler_installed = false

Macro Definition Documentation

_SIGHUP_IGNORE

#define _SIGHUP_IGNORE   1

Definition at line 35 of file signal.cpp.

_SIGIOINT_IGNORE

#define _SIGIOINT_IGNORE   16

Definition at line 38 of file signal.cpp.

_SIGPIPE_IGNORE

#define _SIGPIPE_IGNORE   13

Definition at line 37 of file signal.cpp.

_SIGQUIT_IGNORE

#define _SIGQUIT_IGNORE   3

Definition at line 36 of file signal.cpp.

_SIGSTOP_IGNORE

#define _SIGSTOP_IGNORE   17

Definition at line 39 of file signal.cpp.

Function Documentation

__acrt_get_sigabrt_handler()

__crt_signal_handler_t __cdecl __acrt_get_sigabrt_handler

(

void

)

Definition at line 564 of file signal.cpp.

{
    return __acrt_lock_and_call(__acrt_signal_lock, []
    {
        return __crt_fast_decode_pointer(abort_action.value());
    });
}

Referenced by abort(), and common_message_window().

__acrt_initialize_signal_handlers()

void __cdecl __acrt_initialize_signal_handlers

(

void *const

encoded_nullptr

)

Definition at line 44 of file signal.cpp.

{
    // The encoded nullptr is SIG_DFL
    ctrlc_action.initialize    (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
    ctrlbreak_action.initialize(reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
    abort_action.initialize    (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
    term_action.initialize     (reinterpret_cast<__crt_signal_handler_t>(encoded_nullptr));
}

__fpecode()

int *__cdecl __fpecode

(

void

)

Definition at line 573 of file signal.cpp.

{
    return &__acrt_getptd()->_tfpecode;
}

__pxcptinfoptrs()

void **__cdecl __pxcptinfoptrs

(

void

)

Definition at line 579 of file signal.cpp.

{
    return reinterpret_cast<void**>(&__acrt_getptd()->_tpxcptinfoptrs);
}

Referenced by sighandler(), and test___pxcptinfoptrs().

ctrlevent_capture()

static BOOL WINAPI ctrlevent_capture ( DWORD const  ctrl_type ) throw ( )

static

Definition at line 163 of file signal.cpp.

{
    __crt_signal_handler_t ctrl_action = nullptr;
    int signal_code = 0;
 
    __acrt_lock(__acrt_signal_lock);
    __try
    {
        __crt_signal_handler_t* pctrl_action;
 
        // Identify the type of event and fetch the corresponding action
        // description:
        if (ctrl_type == CTRL_C_EVENT)
        {
            pctrl_action = &ctrlc_action.value();
            ctrl_action = __crt_fast_decode_pointer(*pctrl_action);
            signal_code = SIGINT;
        }
        else
        {
            pctrl_action = &ctrlbreak_action.value();
            ctrl_action = __crt_fast_decode_pointer(*pctrl_action);
            signal_code = SIGBREAK;
        }
 
        if (ctrl_action != SIG_DFL && ctrl_action != SIG_IGN)
        {
            // Reset the action to be SIG_DFL:
            *pctrl_action = __crt_fast_encode_pointer(nullptr);
        }
    }
    __finally
    {
        __acrt_unlock(__acrt_signal_lock);
    }
    __endtry
 
    // The default signal action leaves the event unhandled, so return false to
    // indicate such:
    if (ctrl_action == SIG_DFL)
        return FALSE;
 
    // If the action is not to ignore the signal, then invoke the action:
    if (ctrl_action != SIG_IGN)
        (*ctrl_action)(signal_code);
 
    // Then return TRUE to indicate the event has been handled (this may mean
    // that the even is being ignored):
    return TRUE;
}

Referenced by signal().

get_global_action_nolock()

static __crt_signal_handler_t *__cdecl get_global_action_nolock ( int const  signum ) throw ( )

static

Definition at line 58 of file signal.cpp.

{
    switch (signum)
    {
    // CRT_REFACTOR TODO: PERFORMANCE: for OS mode, these might be able to be in the const data section, instead of in writeable page data.
    case SIGINT:         return &ctrlc_action.value();
    case SIGBREAK:       return &ctrlbreak_action.value();
    case SIGABRT:        return &abort_action.value();
    case SIGABRT_COMPAT: return &abort_action.value();
    case SIGTERM:        return &term_action.value();
    }
 
    return nullptr;
}

Referenced by raise(), and signal().

is_console_signal()

static __inline BOOL is_console_signal ( int const  signum )

static

Definition at line 134 of file signal.cpp.

{
    return (signum == SIGINT || signum == SIGBREAK);
}

Referenced by signal().

is_unsupported_signal()

static __inline BOOL is_unsupported_signal ( int const  , __crt_signal_handler_t const  sigact  )

static

Definition at line 129 of file signal.cpp.

{
    return (sigact == SIG_ACK || sigact == SIG_SGE);
}

Referenced by signal().

raise()

int __cdecl raise

(

int const

signum

)

Definition at line 425 of file signal.cpp.

{
    __acrt_ptd* ptd = nullptr;
    int old_fpecode = 0;
 
    __crt_signal_handler_t* action_pointer = nullptr;
    bool action_is_global = true;
    switch (signum)
    {
    case SIGINT:
    case SIGBREAK:
    case SIGABRT:
    case SIGABRT_COMPAT:
    case SIGTERM:
        action_pointer = get_global_action_nolock(signum);;
        break;
 
    case SIGFPE:
    case SIGILL:
    case SIGSEGV:
    {
        ptd = __acrt_getptd_noexit();
        if (ptd == nullptr)
            return -1;
 
        __crt_signal_action_t* const local_action = siglookup(signum, ptd->_pxcptacttab);
        _VALIDATE_RETURN(local_action != nullptr, EINVAL, -1);
        action_pointer = &local_action->_action;
        action_is_global = false;
        break;
    }
    default:
        // unsupported signal, return an error
        _VALIDATE_RETURN(("Invalid signal or error", 0), EINVAL, -1);
    }
 
 
    PEXCEPTION_POINTERS old_pxcptinfoptrs = nullptr;
 
    // If the action is global, we must acquire the lock before accessing it:
    if (action_is_global)
        __acrt_lock(__acrt_signal_lock);
 
    __crt_signal_handler_t action = nullptr;
    bool return0 = false;
    __try
    {
        // Global function pointers are encoded; per-thread pointers are not:
        action = action_is_global ? __crt_fast_decode_pointer(*action_pointer) : *action_pointer;
 
        // If the current action is SIG_IGN, just return:
        return0 = action == SIG_IGN;
        if (return0)
            __leave;
 
        // If the current action is SIG_DFL, take the default action.  The current
        // default action for all of the supported signals is to terminate with an
        // exit code of 3:
        if (action == SIG_DFL)
        {
            // Be sure to unlock before entering the exit code.  The exit function
            // does not return.
            if (action_is_global)
                __acrt_unlock(__acrt_signal_lock);
 
            _exit(3);
        }
 
        // For signals that correspond to exceptions, set the pointer to the
        // EXCEPTION_POINTERS structure to nullptr:
        if (signum == SIGFPE  || signum == SIGSEGV || signum == SIGILL)
        {
            old_pxcptinfoptrs = ptd->_tpxcptinfoptrs;
            ptd->_tpxcptinfoptrs = nullptr;
 
            // If the signal is SIGFPE, also set _fpecode to _FPE_EXPLICITGEN:
            if ( signum == SIGFPE )
            {
                old_fpecode = _fpecode;
                _fpecode = _FPE_EXPLICITGEN;
            }
        }
 
        // Reset the action to SIG_DFL before calling the user-specified handler.
        // For SIGFPE, we must reset the action for all of the FP exceptions:
        if (signum == SIGFPE)
        {
            __crt_signal_action_t* const first = ptd->_pxcptacttab + __acrt_signal_action_first_fpe_index;
            __crt_signal_action_t* const last = first + __acrt_signal_action_fpe_count;
 
            for (__crt_signal_action_t* p = first; p != last; ++p)
            {
                p->_action = SIG_DFL;
            }
        }
        else
        {
            *action_pointer = __crt_fast_encode_pointer(nullptr);
        }
    }
    __finally
    {
        if (action_is_global)
            __acrt_unlock(__acrt_signal_lock);
    }
    __endtry
 
    if (return0)
        return 0;
 
    // Call the user-specified handler routine.  For SIGFPE, we have special
    // code to support old handlers which expect the value of _fpecode as the
    // second argument:
    if (signum == SIGFPE)
    {
        reinterpret_cast<void(__cdecl*)(int,int)>(action)(SIGFPE, _fpecode);
    }
    else
    {
        action(signum);
    }
 
 
    // For signals that correspond to exceptions, restore the pointer to the
    // EXCEPTION_POINTERS structure:
    if (signum == SIGFPE  ||  signum == SIGSEGV || signum == SIGILL)
    {
        ptd->_tpxcptinfoptrs = old_pxcptinfoptrs;
 
        // If signum is SIGFPE, also restore _fpecode
        if (signum == SIGFPE)
            _fpecode = old_fpecode;
    }
 
    return 0;
}

Referenced by _CrtHandleDbgReport(), abort(), common_assert_to_message_box(), common_message_window(), getline(), test___pxcptinfoptrs(), and test_signal().

siglookup()

static __crt_signal_action_t *__cdecl siglookup ( int const  signum, __crt_signal_action_t *const  action_table  ) throw ( )

static

Definition at line 78 of file signal.cpp.

{
    // Walk through the table looking for the proper entry.  Note that in the
    // case where more than one exception corresponds to the same signal, the
    // first such instance in the table is the one returned.
    for (__crt_signal_action_t* p = action_table; p != action_table + __acrt_signal_action_table_count; ++p)
        if (p->_signal_number == signum)
            return p;
 
    // If we reached the end of the table, return nullptr:
    return nullptr;
}

Referenced by raise(), and signal().

signal()

__crt_signal_handler_t __cdecl signal	(	int	signum,
		__crt_signal_handler_t	sigact
	)

Definition at line 287 of file signal.cpp.

{
    // Check for signal actions that are supported on other platforms but not on
    // this one, and make sure the action is not SIG_DIE:
    if (is_unsupported_signal(signum, sigact))
        return signal_failed(signum);
 
    // First, handle the case where the signal does not correspond to an
    // exception in the host OS:
    if (signum == SIGINT         ||
        signum == SIGBREAK       ||
        signum == SIGABRT        ||
        signum == SIGABRT_COMPAT ||
        signum == SIGTERM)
    {
        bool set_console_ctrl_error = false;
        __crt_signal_handler_t old_action = nullptr;
 
        __acrt_lock(__acrt_signal_lock);
        __try
        {
            // If the signal is SIGINT or SIGBREAK make sure the handler is
            // installed to capture ^C and ^Break events:
            // C4127: conditional expression is constant
#pragma warning( suppress: 4127 )
            if (is_console_signal(signum) && !console_ctrl_handler_installed)
            {
                if (SetConsoleCtrlHandler(ctrlevent_capture, TRUE))
                {
                    console_ctrl_handler_installed = true;
                }
                else
                {
                    _doserrno = GetLastError();
                    set_console_ctrl_error = true;
                }
            }
 
            __crt_signal_handler_t* const action_pointer = get_global_action_nolock(signum);
            if (action_pointer != nullptr)
            {
                old_action = __crt_fast_decode_pointer(*action_pointer);
                if (sigact != SIG_GET)
                    *action_pointer = __crt_fast_encode_pointer(sigact);
            }
        }
        __finally
        {
            __acrt_unlock(__acrt_signal_lock);
        }
        __endtry
 
        if (set_console_ctrl_error)
            return signal_failed(signum);
 
        return old_action;
    }
 
 
    // If we reach here, signum is supposed to be one of the signals which
    // correspond to exceptions on the host OS.  If it's not one of these,
    // fail and return immediately:
    if (signum != SIGFPE && signum != SIGILL && signum != SIGSEGV)
        return signal_failed(signum);
 
    __acrt_ptd* const ptd = __acrt_getptd_noexit();
    if (ptd == nullptr)
        return signal_failed(signum);
 
    // Check that there is a per-thread instance of the exception-action table
    // for this thread.  If there isn't, create one:
    if (ptd->_pxcptacttab == __acrt_exception_action_table)
    {
        // Allocate space for an exception-action table:
        ptd->_pxcptacttab = static_cast<__crt_signal_action_t*>(_malloc_crt(__acrt_signal_action_table_size));
        if (ptd->_pxcptacttab == nullptr)
            return signal_failed(signum);
 
        // Initialize the table by copying the contents of __acrt_exception_action_table:
        memcpy(ptd->_pxcptacttab, __acrt_exception_action_table, __acrt_signal_action_table_size);
    }
 
    // Look up the proper entry in the exception-action table. Note that if
    // several exceptions are mapped to the same signal, this returns the
    // pointer to first such entry in the exception action table. It is assumed
    // that the other entries immediately follow this one.
    __crt_signal_action_t* const xcpt_action = siglookup(signum, ptd->_pxcptacttab);
    if (xcpt_action == nullptr)
        return signal_failed(signum);
 
    // SIGSEGV, SIGILL and SIGFPE all have more than one exception mapped to
    // them.  The code below depends on the exceptions corresponding to the same
    // signal being grouped together in the exception-action table.
 
    __crt_signal_handler_t const old_action = xcpt_action->_action;
 
    // If we are not just getting the currently installed action, loop through
    // all the entries corresponding to the given signal and update them as
    // appropriate:
    if (sigact != SIG_GET)
    {
        __crt_signal_action_t* const last = ptd->_pxcptacttab + __acrt_signal_action_table_count;
 
        // Iterate until we reach the end of the table or we reach the end of
        // the range of actions for this signal, whichever comes first:
        for (__crt_signal_action_t* p = xcpt_action; p != last && p->_signal_number == signum; ++p)
        {
            p->_action = sigact;
        }
    }
 
    return old_action;
}

signal_failed()

static __crt_signal_handler_t __cdecl signal_failed ( int const  signum ) throw ( )

static

Definition at line 97 of file signal.cpp.

{
    switch (signum)
    {
    case _SIGHUP_IGNORE:
    case _SIGQUIT_IGNORE:
    case _SIGPIPE_IGNORE:
    case _SIGIOINT_IGNORE:
    case _SIGSTOP_IGNORE:
        return SIG_ERR;
 
    default:
        errno = EINVAL;
        return SIG_ERR;
    }
}

Referenced by signal().

Variable Documentation

abort_action

__crt_state_management::dual_state_global<__crt_signal_handler_t> abort_action

static

Definition at line 26 of file signal.cpp.

Referenced by __acrt_get_sigabrt_handler(), __acrt_initialize_signal_handlers(), and get_global_action_nolock().

console_ctrl_handler_installed

bool console_ctrl_handler_installed = false

static

Definition at line 33 of file signal.cpp.

Referenced by signal().

ctrlbreak_action

__crt_state_management::dual_state_global<__crt_signal_handler_t> ctrlbreak_action

static

Definition at line 25 of file signal.cpp.

Referenced by __acrt_initialize_signal_handlers(), ctrlevent_capture(), and get_global_action_nolock().

ctrlc_action

__crt_state_management::dual_state_global<__crt_signal_handler_t> ctrlc_action

static

Definition at line 24 of file signal.cpp.

Referenced by __acrt_initialize_signal_handlers(), ctrlevent_capture(), and get_global_action_nolock().

term_action

__crt_state_management::dual_state_global<__crt_signal_handler_t> term_action

static

Definition at line 27 of file signal.cpp.

Referenced by __acrt_initialize_signal_handlers(), and get_global_action_nolock().