Athena::Signal Class Reference

Utilities for handling signals and fatal errors. More...

#include <SealSignal.h>

Collaboration diagram for Athena::Signal:

Public Types
typedef bool(*	QuitHook) (int sig, siginfo_t *info, void *x)
	Application clean-up hook invoked before #quit(int , siginfo_t *, void *) exits from program termination signals (SIGHUP, SIGTERM or SIGQUIT).
typedef bool(*	FatalHook) (int sig, siginfo_t *info, void *x)
	Application hook to run in fatal().
typedef void(*	FatalReturn) (int sig, siginfo_t *info, void *x)
	Application hook to jump back to the main program from a fatal signal, for example using #siglongjmp.
typedef void(*	HandlerType) (int sig, siginfo_t *info, void *extra)
	Signal handler type.

Static Public Member Functions
static const char *	name (int sig)
	Return the name of the signal number sig.
static HandlerType	handler (int sig, sigset_t *mask=0)
	Return the current handler for signal number sig and its blocked signals in mask (if non-null).
static HandlerType	handle (int sig, HandlerType handler, const sigset_t *blockMask=0)
	Install a new signal handler handler for signal number sig and returns the old handler.
static void	revert (int sig)
	Revert the signal number sig back to its default behaviour.
static void	ignore (int sig)
	Ignore the signal number sig.
static void	block (int sig, bool sense)
	Block or unblock the signal number sig.
static void	block (const sigset_t *mask, bool sense)
	Block or unblock the signals specified by mask.
static void	mask (const sigset_t *mask, sigset_t *old=0)
	Set the list of currently blocked signals to mask and return the old setting in old (if non-null).
static int	raise (int sig)
	Raise the signal number sig.
static int	kill (pid_t process, int sig)
	Send the signal sig to process identified by process.
static int	queue (int sig, int value=0)
	Queue signal sig for this process with additional data value.
static int	queue (int sig, void *value)
	Queue signal sig for this process with additional data value.
static int	queue (pid_t process, int sig, int value=0)
	Queue signal sig with additional data value for process.
static int	queue (pid_t process, int sig, void *value)
	Queue signal sig with additional data value for process.
static bool	pending (int sig)
	Check if sig is pending for this process.
static void	pending (sigset_t *mask)
	Return in mask the list of signals pending for this process.
static void	suspend (const sigset_t *mask)
	Temporarily replace the signal mask of the process with mask and then suspend until a signal is received.
static bool	wait (int sig, siginfo_t *info=0, long msecs=-1)
	Suspend the thread waiting for signal sig at most msecs milliseconds.
static int	wait (const sigset_t *mask, siginfo_t *info=0, long msecs=-1)
	Suspend the thread waiting for signals specified by mask for at most msecs milliseconds.
static void handleQuit	ATLAS_NOT_THREAD_SAFE (QuitHook hook=0)
static QuitHook handleQuitHook	ATLAS_NOT_THREAD_SAFE (void)
static void quit	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
static void handleFatal	ATLAS_NOT_THREAD_SAFE (const char *applicationName=0, IOFD fd=IOFD_INVALID, FatalHook hook=0, FatalReturn mainreturn=0, unsigned options=FATAL_DEFAULT)
static IOFD handleFatalFd	ATLAS_NOT_THREAD_SAFE (void)
static FatalHook handleFatalHook	ATLAS_NOT_THREAD_SAFE (void)
static FatalReturn handleFatalReturn	ATLAS_NOT_THREAD_SAFE (void)
static unsigned handleFatalOptions	ATLAS_NOT_THREAD_SAFE (void)
static void fatal	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
static bool fatalDump	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x, IOFD fd, unsigned options)
static bool fatalDump	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
static int fatalLevel	ATLAS_NOT_THREAD_SAFE (void)
static bool crashed	ATLAS_NOT_THREAD_SAFE (void)
static void	dumpInfo (IOFD fd, char *buf, unsigned int buf_size, int sig, const siginfo_t *info)
	Utility function to dump the signal info descriptor for signal sig, as obtained for instance through signal handler parameters or wait().
static void	dumpMemory (IOFD fd, char *buf, unsigned int buf_size, const void *data, size_t n)
	Utility function to dump memory section from data for n bytes.
static unsigned long	dumpContext (IOFD fd, char *buf, unsigned int buf_size, const void *context)
	Utility function to dump the process context, as obtained for instance through signal handler parameters, unix getcontext() or Windows GetThreadContext().
static const char *	describe (int sig, int code)
	Return the description for signal info code code for signal number sig.

Static Public Attributes
static const int	USR1_DUMP_CORE = 1
	Option that instructs #fatal(int, siginfo_t *, void *) to call #coredump() on SIGUSR1.
static const int	FATAL_ON_QUIT = 2
	Option to make SIGHUP, SIGTERM and SIGQUIT fatal instead of just #quit(int , siginfo_t *, void *) signals.
static const int	FATAL_ON_INT = 4
	Option to make SIGINT fatal.
static const int	FATAL_DUMP_CORE = 8
	Option to make #fatal(int, siginfo_t *, void *) dump a core file before crashing.
static const int	FATAL_DUMP_SIG = 16
	Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the signal name (as reported by name()).
static const int	FATAL_DUMP_STACK = 32
	Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump stack backtrace for the offending code location.
static const int	FATAL_DUMP_LIBS = 64
	Option to make #fataldump(int sig, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the list of currently loaded shared libraries.
static const int	FATAL_DUMP_CONTEXT = 128
	Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the machine context (registers etc.) from the fault position.
static const int	FATAL_AUTO_EXIT = 256
	Option to make #fatal(int, siginfo_t *, void *) exit via #quit(int , siginfo_t *, void *).
static const int	FATAL_DEFAULT
	Default options to #handleFatal(const char *, IOFD fd, FatalHook, FatalReturn, unsigned.

Static Private Member Functions
static void	trampoline (int sig)
	Internal signal handler trampoline to convert handler arguments to look more like POSIX signals.

Static Private Attributes
static bool	s_crashed = false
	Indicator that the application has been crashed: that a fatal signal has been delivered.
static int	s_inFatal = 0
	Indicator that we are currently executing inside #fatal().
static std::atomic< unsigned long >	s_lastSP
	Used to switch to a raw stack dump if we crash during a backtrace.
static const char *	s_applicationName = 0
	The current application name.
static IOFD	s_fatalFd = IOFD_INVALID
	The output file descriptor for #fataldump().
static FatalHook	s_fatalHook = 0
	The application handler hook for fatal signals.
static FatalReturn	s_fatalReturn = 0
	The application main return hook for fatal signals.
static unsigned	s_fatalOptions = 0
	The current fatal signal handling options.
static QuitHook	s_quitHook = 0
	The application handler hook for quitting-related signals.
static HandlerType	s_trampolines [NSIG]
	Actual signal handlers when POSIX signals are not available.

Detailed Description

Utilities for handling signals and fatal errors.

FIXME: POSIX single-threaded vs. multi-threaded signals?

• all threads should block all the signals
• one thread should do sigwait.

The fatal error handling is largely inspired by code in DDD, the Data Display Debugger, and by the examples in GNU libc manual.

Definition at line 100 of file SealSignal.h.

Member Typedef Documentation

FatalHook

typedef bool(* Athena::Signal::FatalHook) (int sig, siginfo_t *info, void *x)

Application hook to run in fatal().

The hook should return true if the signal handler should proceed to die. sig is the signal number, or its negative if core was dumped and, as far as can determined, successfully produced.

The fatal hooks should, if possible, perform clean-ups similar to QuitHook. The application may achieve this by actually using the quit by setting FATAL_AUTO_EXIT for #handleFatal(const char *, IOFD fd, FatalHook, FatalReturn, unsigned), or it could reuse an internal function in both handlers.

Definition at line 176 of file SealSignal.h.

FatalReturn

typedef void(* Athena::Signal::FatalReturn) (int sig, siginfo_t *info, void *x)

Application hook to jump back to the main program from a fatal signal, for example using #siglongjmp.

It must never return. sig is the signal number, or its negative if core was dumped and, as far as can determined, successfully produced.

Definition at line 182 of file SealSignal.h.

HandlerType

typedef void(* Athena::Signal::HandlerType) (int sig, siginfo_t *info, void *extra)

Signal handler type.

This is defined explicitly and does not necessarily match the system's concept of signal handler type. If necessary, suitable trampolines are used internally to make sure the arguments make sense.

Parameters

sig	The signal number.
info	Pointer to signal info. This pointer will be null on platforms that do not support POSIX signals.
extra	Extra argument, e.g. the fault address. This pointer will be null on platforms that do not support POSIX signals.

Definition at line 196 of file SealSignal.h.

QuitHook

typedef bool(* Athena::Signal::QuitHook) (int sig, siginfo_t *info, void *x)

Application clean-up hook invoked before #quit(int , siginfo_t *, void *) exits from program termination signals (SIGHUP, SIGTERM or SIGQUIT).

The handler should return true if the signal handler should proceed to exit the application. Note that certain options to #handlFatal() cause this hook to be invoked for fatal signals. If such behaviour is enabled, be sure to check the #crashed() status before deciding to let the application to continue.

The quit hook should take care of resetting terminal modes, killing child processes, removing lock files, and so forth.

Definition at line 165 of file SealSignal.h.

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/13]

void handleFatal Athena::Signal::ATLAS_NOT_THREAD_SAFE ( const char * applicationName = 0, IOFD fd = IOFD_INVALID, FatalHook hook = 0, FatalReturn mainreturn = 0, unsigned options = FATAL_DEFAULT )

static

ATLAS_NOT_THREAD_SAFE() [2/13]

bool fatalDump Athena::Signal::ATLAS_NOT_THREAD_SAFE ( int sig, siginfo_t * info, void * x )

static

ATLAS_NOT_THREAD_SAFE() [3/13]

void fatal Athena::Signal::ATLAS_NOT_THREAD_SAFE ( int sig, siginfo_t * info, void * x )

static

ATLAS_NOT_THREAD_SAFE() [4/13]

void quit Athena::Signal::ATLAS_NOT_THREAD_SAFE ( int sig, siginfo_t * info, void * x )

static

ATLAS_NOT_THREAD_SAFE() [5/13]

bool fatalDump Athena::Signal::ATLAS_NOT_THREAD_SAFE ( int sig, siginfo_t * info, void * x, IOFD fd, unsigned options )

static

ATLAS_NOT_THREAD_SAFE() [6/13]

void handleQuit Athena::Signal::ATLAS_NOT_THREAD_SAFE ( QuitHook hook = 0 )

static

ATLAS_NOT_THREAD_SAFE() [7/13]

bool crashed Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [8/13]

int fatalLevel Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [9/13]

unsigned handleFatalOptions Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [10/13]

FatalReturn handleFatalReturn Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [11/13]

FatalHook handleFatalHook Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [12/13]

IOFD handleFatalFd Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

ATLAS_NOT_THREAD_SAFE() [13/13]

QuitHook handleQuitHook Athena::Signal::ATLAS_NOT_THREAD_SAFE ( void )

static

block() [1/2]

void Athena::Signal::block ( const sigset_t * mask, bool sense )

static

Block or unblock the signals specified by mask.

The signals are blocked if sense is true, unblocked otherwise. This function is implemented only on systems with POSIX signals.

Definition at line 352 of file SealSignal.cxx.

{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigprocmask (sense ? SIG_BLOCK : SIG_UNBLOCK, mask, 0);
#endif
}

block() [2/2]

void Athena::Signal::block ( int sig, bool sense )

static

Block or unblock the signal number sig.

The signal is blocked if sense is true, unblocked otherwise. This function is implemented only on systems with POSIX signals.

Definition at line 337 of file SealSignal.cxx.

{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigset_t mask;
    sigemptyset (&mask);
    sigaddset (&mask, sig);
    block (&mask, sense);
#endif
}

describe()

const char * Athena::Signal::describe ( int sig, int code )

static

Return the description for signal info code code for signal number sig.

The code should come from siginfo_t::si_code.

Definition at line 967 of file SealSignal.cxx.

{
    static const struct { int sig; int code; const char *desc; } infos [] = {
#if HAVE_POSIX_SIGNALS
    { -1,      SI_USER, "user sent: kill, sigsend or raise" },
# ifdef SI_KERNEL
    { -1,      SI_KERNEL,   "kernel" },
# endif
    { -1,      SI_QUEUE,    "sigqueue" },
    { -1,      SI_TIMER,    "timer expired" },
    { -1,      SI_MESGQ,    "mesq state changed" },
    { -1,      SI_ASYNCIO,  "AIO completed" },
# ifdef SI_SIGIO // not solaris
    { -1,      SI_SIGIO,    "queued SIGIO" },
# endif
 
# ifdef ILL_NOOP // darwin
    { SIGILL,  ILL_NOOP,    "noop" },
# endif
    { SIGILL,  ILL_ILLOPC,  "illegal opcode" },
# ifdef ILL_ILLOPN // not darwin
    { SIGILL,  ILL_ILLOPN,  "illegal operand" },
# endif
# ifdef ILL_ILLADR // not darwin
    { SIGILL,  ILL_ILLADR,  "illegal addressing mode" },
# endif
    { SIGILL,  ILL_ILLTRP,  "illegal trap" },
    { SIGILL,  ILL_PRVOPC,  "privileged opcode" },
# ifdef ILL_PRVREG // not darwin
    { SIGILL,  ILL_PRVREG,  "privileged register" },
# endif
# ifdef ILL_COPROC // not darwin
    { SIGILL,  ILL_COPROC,  "coprocessor error" },
# endif
# ifdef ILL_BADSTK // not darwin
    { SIGILL,  ILL_BADSTK,  "internal stack error" },
# endif
 
# ifdef FPE_NOOP // darwin
    { SIGFPE,  FPE_NOOP,    "noop" },
# endif
# ifdef FPE_INTDIV // not darwin
    { SIGFPE,  FPE_INTDIV,  "integer divide by zero" },
# endif
# ifdef FPE_INTOVF // not darwin
    { SIGFPE,  FPE_INTOVF,  "integer overflow" },
# endif
    { SIGFPE,  FPE_FLTDIV,  "floating point divide by zero" },
    { SIGFPE,  FPE_FLTOVF,  "floating point overflow" },
    { SIGFPE,  FPE_FLTUND,  "floating point underflow" },
    { SIGFPE,  FPE_FLTRES,  "floating point inexact result" },
    { SIGFPE,  FPE_FLTINV,  "floating point invalid operation" },
# ifdef FPE_FLTSUB // not darwin
    { SIGFPE,  FPE_FLTSUB,  "subscript out of range" },
# endif
 
# ifdef SEGV_NOOP // darwin
    { SIGSEGV, SEGV_NOOP,   "noop" },
# endif
    { SIGSEGV, SEGV_MAPERR, "address not mapped to object" },
    { SIGSEGV, SEGV_ACCERR, "invalid permissions for mapped object" },
 
# ifdef BUS_NOOP // darwin
    { SIGBUS,  BUS_NOOP,    "noop" },
# endif
    { SIGBUS,  BUS_ADRALN,  "invalid address alignment" },
# ifdef BUS_ADRERR // not darwin
    { SIGBUS,  BUS_ADRERR,  "non-existent physical address" },
# endif
# ifdef BUS_OBJERR // not darwin
    { SIGBUS,  BUS_OBJERR,  "object specific hardware error" },
# endif
 
# ifdef TRAP_BRKPT // not darwin
    { SIGTRAP, TRAP_BRKPT,  "process break point" },
# endif
# ifdef TRAP_TRACE // not darwin
    { SIGTRAP, TRAP_TRACE,  "process trace trap" },
# endif
        
# ifdef CLD_NOOP // darwin
    { SIGCHLD, CLD_NOOP,    "noop" },
# endif
    { SIGCHLD, CLD_EXITED,  "child has exited" },
    { SIGCHLD, CLD_KILLED,  "child was killed" },
    { SIGCHLD, CLD_DUMPED,  "child terminated abnormally" },
    { SIGCHLD, CLD_TRAPPED, "traced child has trapped" },
    { SIGCHLD, CLD_STOPPED, "child has stopped" },
    { SIGCHLD, CLD_CONTINUED,"stopped child has continued" },
 
# ifdef SIGPOLL // not darwin
    { SIGPOLL, POLL_IN, "data input available" },
    { SIGPOLL, POLL_OUT,    "output buffers available" },
    { SIGPOLL, POLL_MSG,    "input message available" },
    { SIGPOLL, POLL_ERR,    "i/o error" },
    { SIGPOLL, POLL_PRI,    "high priority input available" },
    { SIGPOLL, POLL_HUP,    "device disconnected" },
# endif
#endif  // HAVE_POSIX_SIGNALS
 
    { -1,      -1,      0 }
    };
 
    for (unsigned i = 0; infos [i].desc; ++i)
    if ((infos [i].sig == -1 || infos [i].sig == sig)
        && infos [i].code == code)
        return infos [i].desc;
 
    return "*unknown reason*";
}

dumpContext()

unsigned long Athena::Signal::dumpContext ( IOFD fd, char * buf, unsigned int buf_size, const void * context )

static

Utility function to dump the process context, as obtained for instance through signal handler parameters, unix getcontext() or Windows GetThreadContext().

The output is written directly to the file descriptor fd, using buf as the formatting buffer.

Returns SP if we can find it, else null.

Definition at line 1210 of file SealSignal.cxx.

{
     unsigned long sp = 0;
#if defined _WIN32 && defined _M_IX86
    const CONTEXT *uc = static_cast<const CONTEXT *> (context);
    sp = uc->Esp;
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n"
                                "\n  eip: %04lx:%08lx           eflags: %08lx"
                                "\n  eax: %08lx   ebx: %08lx"
                                "   ecx: %08lx   edx: %08lx"
                                "\n  esi: %08lx   edi: %08lx"
                                "   ebp: %08lx   esp: %08lx"
                                "\n   ds: %04lx        es: %04lx"
                                "    fs: %04lx        ss: %04lx",
                                uc->SegCs, uc->Eip, uc->EFlags,
                                uc->Eax, uc->Ebx, uc->Ecx, uc->Edx,
                                uc->Esi, uc->Edi, uc->Ebp, uc->Esp,
                                uc->SegDs, uc->SegEs, uc->SegFs, uc->SegSs));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  FPU:  control = %08lx"
                                "\n        status  = %08lx"
                                "\n        tag     = %08lx"
                                "\n        ip      = %04lx:%08lx"
                                "\n        data    = %04lx:%08lx"
                                "\n        state   = %08lx",
                                uc->FloatSave.ControlWord,
                                uc->FloatSave.StatusWord,
                                uc->FloatSave.TagWord,
                                uc->FloatSave.ErrorSelector,
                                uc->FloatSave.ErrorOffset,
                                uc->FloatSave.DataSelector,
                                uc->FloatSave.DataOffset,
                                uc->FloatSave.Cr0NpxState));
 
    for (int i = 0; i < 8; ++i)
    MYWRITE (fd, buf, snprintf (buf, buf_size.
                                    "\n    %%fp%d = [%02x%02x:%02x%02x%02x%02x"
                                    "%02x%02x%02x%02x]",
                                    i,
                                    uc->FloatSave.RegisterArea [i * 10 + 0],
                                    uc->FloatSave.RegisterArea [i * 10 + 1],
                                    uc->FloatSave.RegisterArea [i * 10 + 2],
                                    uc->FloatSave.RegisterArea [i * 10 + 3],
                                    uc->FloatSave.RegisterArea [i * 10 + 4],
                                    uc->FloatSave.RegisterArea [i * 10 + 5],
                                    uc->FloatSave.RegisterArea [i * 10 + 6],
                                    uc->FloatSave.RegisterArea [i * 10 + 7],
                                    uc->FloatSave.RegisterArea [i * 10 + 8],
                                    uc->FloatSave.RegisterArea [i * 10 + 9]));
    MYWRITE (fd, "\n", 1);
 
#elif HAVE_POSIX_SIGNALS
    // FIXME: how much of this is defined in POSIX or ABIs?
    const ucontext_t *uc = static_cast<const ucontext_t *> (context);
    const mcontext_t *mc = &uc->uc_mcontext;
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  stack  = (%x, %x, %p)",
                                uc->uc_stack.ss_flags,
                                unsigned(uc->uc_stack.ss_size),
                                uc->uc_stack.ss_sp));
 
    MYWRITE (fd, "\n", 1);
#if defined __i386 && defined __linux
# if !defined REG_CS && defined CS
#  define REG_CS    CS
#  define REG_DS    DS
#  define REG_ES    ES
#  define REG_FS    FS
#  define REG_SS    SS
#  define REG_EIP   EIP
#  define REG_EFL   EFL
#  define REG_EAX   EAX
#  define REG_EBX   EBX
#  define REG_ECX   ECX
#  define REG_EDX   EDX
#  define REG_ESI   ESI
#  define REG_EDI   EDI
#  define REG_EBP   EBP
#  define REG_ESP   ESP
#  define REG_UESP  UESP
#  define REG_TRAPNO    TRAPNO
#  define REG_ERR   ERR
# endif
    sp = mc->gregs[REG_ESP];
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  eip: %04x:%08x           eflags: %08x"
                                "\n  eax: %08x   ebx: %08x"
                                "   ecx: %08x   edx: %08x"
                                "\n  esi: %08x   edi: %08x"
                                "   ebp: %08x   esp: %08x"
                                "\n   ds: %04x        es: %04x"
                                "        fs: %04x        ss: %04x",
                                mc->gregs [REG_CS] & 0xffff, mc->gregs [REG_EIP],
                                mc->gregs [REG_EFL],
                                mc->gregs [REG_EAX], mc->gregs [REG_EBX],
                                mc->gregs [REG_ECX], mc->gregs [REG_EDX],
                                mc->gregs [REG_ESI], mc->gregs [REG_EDI],
                                mc->gregs [REG_EBP], mc->gregs [REG_ESP],
                                mc->gregs [REG_DS] & 0xffff,
                                mc->gregs [REG_ES] & 0xffff,
                                mc->gregs [REG_FS] & 0xffff,
                                mc->gregs [REG_SS] & 0xffff));
 
    MYWRITE (fd, buf, snprintf (buf, buf__size,
                                "\n\n  signal esp: %08x"
                                "  trap: %d/%d"
                                "  oldmask: %08lx   cr2: %08lx",
                                mc->gregs [REG_UESP],
                                mc->gregs [REG_TRAPNO], mc->gregs [REG_ERR],
                                mc->oldmask, mc->cr2));
 
    if (mc->fpregs)
    {
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                    "\n"
                                    "\n  FPU:  control = %08lx"
                                    "\n        status  = %08lx"
                                    "\n        tag     = %08lx"
                                    "\n        ip      = %04lx:%08lx"
                                    "\n        data    = %04lx:%08lx"
                                    "\n        state   = %08lx",
                                    mc->fpregs->cw, mc->fpregs->sw, mc->fpregs->tag,
                                    mc->fpregs->cssel & 0xffff, mc->fpregs->ipoff,
                                    mc->fpregs->datasel & 0xffff, mc->fpregs->dataoff,
                                    mc->fpregs->status));
 
    for (int i = 0; i < 8; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%fp%d = [%04hx:%04hx%04hx%04hx%04hx]",
                                        i,
                                        mc->fpregs->_st [i].exponent,
                                        mc->fpregs->_st [i].significand [0],
                                        mc->fpregs->_st [i].significand [1],
                                        mc->fpregs->_st [i].significand [2],
                                        mc->fpregs->_st [i].significand [3]));
    }
    
#elif defined __x86_64__ && defined __linux
    sp = mc->gregs[REG_RSP];
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  rip: %04x:%016llx           eflags: %016llx"
                                "\n  rax: %016llx   rbx: %016llx"
                                "\n  rcx: %016llx   rdx: %016llx"
                                "\n  r08: %016llx   r09: %016llx"
                                "\n  r10: %016llx   r11: %016llx"
                                "\n  r12: %016llx   r13: %016llx"
                                "\n  r14: %016llx   r15: %016llx"
                                "\n  rsi: %016llx   rdi: %016llx"
                                "\n  rbp: %016llx   rsp: %016llx"
                                "\n   gs: %04x     fs: %04x",
                                (unsigned)mc->gregs [REG_CSGSFS] & 0xffff,
                                (unsigned long long)mc->gregs [REG_RIP],
                                (unsigned long long)mc->gregs [REG_EFL],
                                (unsigned long long)mc->gregs [REG_RAX],
                                (unsigned long long)mc->gregs [REG_RBX],
                                (unsigned long long)mc->gregs [REG_RCX],
                                (unsigned long long)mc->gregs [REG_RDX],
                                (unsigned long long)mc->gregs [REG_R8],
                                (unsigned long long)mc->gregs [REG_R9],
                                (unsigned long long)mc->gregs [REG_R10],
                                (unsigned long long)mc->gregs [REG_R11],
                                (unsigned long long)mc->gregs [REG_R12],
                                (unsigned long long)mc->gregs [REG_R13],
                                (unsigned long long)mc->gregs [REG_R14],
                                (unsigned long long)mc->gregs [REG_R15],
                                (unsigned long long)mc->gregs [REG_RSI],
                                (unsigned long long)mc->gregs [REG_RDI],
                                (unsigned long long)mc->gregs [REG_RBP],
                                (unsigned long long)mc->gregs [REG_RSP],
                                (unsigned)(mc->gregs [REG_CSGSFS]>>16) & 0xffff,
                                (unsigned)(mc->gregs [REG_CSGSFS]>>32) & 0xffff));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n\n"
                                "  trap: %llu/%llu"
                                "  oldmask: %16llx   cr2: %016llx",
                                (unsigned long long)mc->gregs [REG_TRAPNO],
                                (unsigned long long)mc->gregs [REG_ERR],
                                (unsigned long long)mc->gregs [REG_OLDMASK],
                                (unsigned long long)mc->gregs [REG_CR2]));
 
    if (mc->fpregs)
    {
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                    "\n"
                                    "\n  FPU:  control = %04x"
                                    "\n        status  = %04x"
                                    "\n        tag     = %02x"
                                    "\n        op      = %04x"
                                    "\n        ip      = %016lx"
                                    "\n        data    = %016lx"
                                    "\n        mxcsr   = %08x"
                                    "\n        mxcr_mask= %08x",
                                    mc->fpregs->cwd,
                                    mc->fpregs->swd,
                                    mc->fpregs->ftw,
                                    mc->fpregs->fop,
                                    mc->fpregs->rip,
                                    mc->fpregs->rdp,
                                    mc->fpregs->mxcsr,
                                    mc->fpregs->mxcr_mask));
 
    for (int i = 0; i < 8; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%fp%d = [%04hx:%04hx%04hx%04hx%04hx]",
                                        i,
                                        mc->fpregs->_st [i].exponent,
                                        mc->fpregs->_st [i].significand [0],
                                        mc->fpregs->_st [i].significand [1],
                                        mc->fpregs->_st [i].significand [2],
                                        mc->fpregs->_st [i].significand [3]));
 
    for (int i = 0; i < 16; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%xmm%02d = [%08x %08x %08x %08x]",
                                        i,
                                        mc->fpregs->_xmm[i].element[0],
                                        mc->fpregs->_xmm[i].element[1],
                                        mc->fpregs->_xmm[i].element[2],
                                        mc->fpregs->_xmm[i].element[3]));
    }
    
#elif __APPLE__ && defined __ppc__
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  dar: %08lx   dsisr: %08lx  exception: %08lx",
                                (*mc)->es.dar, (*mc)->es.dsisr, (*mc)->es.exception));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  srr0: %08x  srr1: %08x   cr: %08x         xer: %08x"
                                "\n  lr: %08x    ctr: %08x    vrsave: %08x     fpscr: %08x",
                                (*mc)->ss.srr0, (*mc)->ss.srr1, (*mc)->ss.cr, (*mc)->ss.xer,
                                (*mc)->ss.lr, (*mc)->ss.ctr, (*mc)->ss.vrsave, (*mc)->fs.fpscr));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  vrvalid: %08x  vscr: %08lx:%08lx:%08lx:%08lx\n",
                                (*mc)->vs.save_vrvalid,
                                (*mc)->vs.save_vscr [0], (*mc)->vs.save_vscr [1],
                                (*mc)->vs.save_vscr [2], (*mc)->vs.save_vscr [3]));
 
    for (unsigned int *regs = &(*mc)->ss.r0, i = 0; i < 32; i += 4)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  r%-2d  %08x   r%-2d  %08x   r%-2d  %08x   r%-2d  %08x",
                                    i, regs [i], i+1, regs [i+1], i+2, regs [i+2], i+3, regs [i+3]));
    for (int i = 0; i < 32; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  fp%-2d %016qx (%f)", i,
                                    *(unsigned long long *) &(*mc)->fs.fpregs [i],
                                    (*mc)->fs.fpregs [i]));
    for (int i = 0; i < 32; ++i)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  vr%-2d %08lx:%08lx:%08lx:%08lx", i,
                                    (*mc)->vs.save_vr[i][0], (*mc)->vs.save_vr[i][1],
                                    (*mc)->vs.save_vr[i][2], (*mc)->vs.save_vr[i][3]));
#elif defined __aarch64__ && defined __linux
    CxxUtils::aarch64_dump_registers (fd, buf, buf_size, *mc);
#elif __sun
    for (int i = 0; i < NGREG; i++)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "%s  %%r%02d = %08x",
                                    i % 4 == 0 ? "\n" : "", i, mc->gregs [i]));
#else
    dumpMemory (fd, buf, buf_size, mc, sizeof (*mc));
#endif // __i386 && __linux, __sun, other
 
    MYWRITE (fd, "\n", 1);
#endif // HAVE_POSIX_SIGNALS
 
    return sp;
}

dumpInfo()

void Athena::Signal::dumpInfo ( IOFD fd, char * buf, unsigned int buf_size, int sig, const siginfo_t * info )

static

Utility function to dump the signal info descriptor for signal sig, as obtained for instance through signal handler parameters or wait().

The output is written directly to the file descriptor fd, using buf as the formatting buffer.

Definition at line 1083 of file SealSignal.cxx.

{
    if (! info)
    return;
 
#ifdef _WIN32
# define DOCODE(x) case x: name = #x
    // NB: siginfo_t == EXCEPTION_RECORD.
    const char *name = 0;
 
    switch (info->ExceptionCode)
    {
    DOCODE(STATUS_ABANDONED_WAIT_0);
    DOCODE(STATUS_ACCESS_VIOLATION);
    DOCODE(STATUS_ARRAY_BOUNDS_EXCEEDED);
    DOCODE(STATUS_BREAKPOINT);
    DOCODE(STATUS_CONTROL_C_EXIT);
    DOCODE(STATUS_DATATYPE_MISALIGNMENT);
    DOCODE(STATUS_FLOAT_DENORMAL_OPERAND);
    DOCODE(STATUS_FLOAT_DIVIDE_BY_ZERO);
    DOCODE(STATUS_FLOAT_INEXACT_RESULT);
    DOCODE(STATUS_FLOAT_INVALID_OPERATION);
    DOCODE(STATUS_FLOAT_OVERFLOW);
    DOCODE(STATUS_FLOAT_STACK_CHECK);
    DOCODE(STATUS_FLOAT_UNDERFLOW);
    DOCODE(STATUS_GUARD_PAGE_VIOLATION);
    DOCODE(STATUS_ILLEGAL_INSTRUCTION);
    DOCODE(STATUS_INTEGER_DIVIDE_BY_ZERO);
    DOCODE(STATUS_INTEGER_OVERFLOW);
    DOCODE(STATUS_INVALID_DISPOSITION);
    DOCODE(STATUS_IN_PAGE_ERROR);
    DOCODE(STATUS_NONCONTINUABLE_EXCEPTION);
    DOCODE(STATUS_NO_MEMORY);
    DOCODE(STATUS_PENDING);
    DOCODE(STATUS_PRIVILEGED_INSTRUCTION);
    DOCODE(STATUS_SINGLE_STEP);
    DOCODE(STATUS_STACK_OVERFLOW);
    DOCODE(STATUS_TIMEOUT);
    DOCODE(STATUS_USER_APC);
    DOCODE(STATUS_WAIT_0);
    }
    // -> DWORD ExceptionCode
    // -> DWORD ExceptionFlags
    // -> EXCEPTION_RECORD *ExceptionRecord
    // -> PVOID ExceptionAddress
    // -> DWORD NumberParameters
    // -> DWORD ExceptionInfo [MAX_PARAMETERS (15)]
    if (name)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "Exception: %s\n", name));
    else
        MYWRITE (fd, buf, snprintf (buf, buf_size, "Exception %lu\n",
                                    info->ExceptionCode));
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  addr = %08lx", info->ExceptionAddress));
 
#elif HAVE_POSIX_SIGNALS
    // These should always be set.
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                               "  signo  = %d, errno = %d, code = %d (%s)\n",
                               info->si_signo, info->si_errno, info->si_code,
                               describe (sig, info->si_code)));
 
    // These are set if the signal was sent by kill, POSIX signal
    // send or SIGCHLD.
    //coverity[INCONSISTENT_UNION_ACCESS]
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  pid    = %ld, uid = %ld\n",
                                (long) info->si_pid, (long) info->si_uid));
 
    // Child status for SIGCHLD.
    if (sig == SIGCHLD) {
       // Create temporary variables, as MacOS/clang doesn't want to
       // accept the on-the-fly conversion of the following variables
       // without printing some warnings.
       //coverity[INCONSISTENT_UNION_ACCESS]
       const long status = info->si_status;
       const long utime = info->si_utime;
       const long stime = info->si_stime;
       MYWRITE (fd, buf, snprintf (buf, buf_size,
                                   "  status = %ld, utime = %ld, stime = %ld\n",
                                   status, utime, stime));
    }
 
    // These are set if the POSIX signal sender passed them.
    //coverity[INCONSISTENT_UNION_ACCESS]
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  value  = (%d, %p)\n",
                                info->si_int, info->si_ptr));
 
    // This is the interesting address for memory faults.
    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || sig == SIGBUS)
    //coverity[INCONSISTENT_UNION_ACCESS]
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  addr   = %p\n", info->si_addr));
 
# ifdef SIGPOLL // not darwin
    // SIGPOLL status data.
    if (sig == SIGPOLL)
    //coverity[INCONSISTENT_UNION_ACCESS]
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  band   = %ld, fd = %d\n",
                                    (long) info->si_band, info->si_fd));
# endif
#endif // HAVE_POSIX_SIGNALS
}

dumpMemory()

void Athena::Signal::dumpMemory ( IOFD fd, char * buf, unsigned int buf_size, const void * data, size_t n )

static

Utility function to dump memory section from data for n bytes.

Used to dump machine context on platforms where we don't know any better. The output is written directly to the file descriptor fd, using buf as the formatting buffer.

Definition at line 1189 of file SealSignal.cxx.

{
    for (size_t i = 0; i < n; )
    {
        size_t m = snprintf (buf, buf_size, "\n ");
    for (size_t j = 0; i < n && j < 32; ++j, ++i)
        m += snprintf (buf + m, buf_size-m, "%s%02x",
              j % 4 == 0 ? " " : "",
              (unsigned int) (((const unsigned char *) data) [i]));
 
    MYWRITE (fd, buf, m);
    }
}

handle()

Signal::HandlerType Athena::Signal::handle ( int sig, HandlerType handler, const sigset_t * blockMask = 0 )

static

Install a new signal handler handler for signal number sig and returns the old handler.

This method uses the POSIX signal handling primitives if they are available, failing which falling back to the C standard signal() function.

When POSIX signals are used, signals other than sig are blocked according to blockMask (if null, no change is made) during the execution of handler. Note that the signal itself is always blocked during the handler execution and need not be mentioned in the mask explicitly. System calls are made restartable although this has little impact as this library always restarts interrupted system calls automatically despite the signal handling settings.

(FIXME: Expose option SA_NOCLDSTOP, SA_ONSTACK?) (FIXME: Threads vs. signals)

Definition at line 276 of file SealSignal.cxx.

{
    assert (sig > 0 && sig < NSIG);
 //    LOG (0, trace, LFsignal, "[" << sig << "] (" << name (sig) << ") = "
 //  << (void *) handler << '\n');            // wlav
 
    HandlerType oldhandler;
#if !HAVE_POSIX_SIGNALS || !SA_SIGINFO
    // Switch to using trampoline if we don't have the necessary
    // arguments.  FIXME: multiple threads; WIN32?
    oldhandler = s_trampolines [sig];
    if (handler == (HandlerType) SIG_IGN || handler == (HandlerType) SIG_DFL)
    s_trampolines [sig] = 0;
    else
    {
        s_trampolines [sig] = handler;
        handler = (HandlerType) &trampoline;
    }
#endif
 
    // Set the handler
#if HAVE_POSIX_SIGNALS
    struct sigaction old, act;
    STDC::memset (&act, 0, sizeof (act));
    STDC::memset (&old, 0, sizeof (old));
    act.sa_flags = SA_RESTART | SA_SIGINFO;
    act.sa_sigaction = handler;
    sigemptyset (&act.sa_mask);
    if (blockMask)
    act.sa_mask = *blockMask;
    else if (sigaction (sig, &old, 0) == 0)
    act.sa_mask = old.sa_mask;
    else
    sigemptyset (&act.sa_mask);
 
    // There isn't much we can do to check the return status.  We get
    // called in all sorts fragile places like signal handlers, and
    // those are not the place for throwing exceptions or asserting.
    if (sigaction (sig, &act, &old) == -1)
      return (HandlerType) (void*)SIG_ERR;
    oldhandler = (HandlerType) old.sa_sigaction;
#else // ! HAVE_POSIX_SIGNALS
    (HandlerType) ::signal (sig, (DummyHandlerType) handler);
#endif // HAVE_POSIX_SIGNALS
    return oldhandler;
}

handler()

Signal::HandlerType Athena::Signal::handler ( int sig, sigset_t * mask = 0 )

static

Return the current handler for signal number sig and its blocked signals in mask (if non-null).

Definition at line 235 of file SealSignal.cxx.

{
    assert (sig > 0 && sig < NSIG);
 
    // Get the handler
#if HAVE_POSIX_SIGNALS
    struct sigaction old;
    STDC::memset (&old, 0, sizeof (old));
    if (sigaction (sig, &old, 0) == 0)
    {
    if (mask)
        *mask = old.sa_mask;
    return (HandlerType) (void*) old.sa_handler;
    }
    else
      return (HandlerType) (void*)SIG_ERR;
#else // ! HAVE_POSIX_SIGNALS
    HandlerType old = (HandlerType) signal (sig, SIG_DFL);
    signal (sig, (DummyHandlerType) old);
    return old;
#endif // HAVE_POSIX_SIGNALS
}

ignore()

void Athena::Signal::ignore ( int sig )

static

Ignore the signal number sig.

Definition at line 330 of file SealSignal.cxx.

{ handle (sig, (HandlerType) (void*)SIG_IGN); }

kill()

int Athena::Signal::kill ( pid_t process, int sig )

static

Send the signal sig to process identified by process.

Implemented only on unixen.

Definition at line 388 of file SealSignal.cxx.

{
    // FIXME: sending signals to threads?
#ifndef _WIN32
    return ::kill (process, sig);
#else
    return 0;
#endif
}

mask()

void Athena::Signal::mask ( const sigset_t * mask, sigset_t * old = 0 )

static

Set the list of currently blocked signals to mask and return the old setting in old (if non-null).

This function is implemented only on systems with POSIX signals.

Definition at line 364 of file SealSignal.cxx.

{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigprocmask (SIG_SETMASK, mask, old);
#endif
}

name()

const char * Athena::Signal::name ( int sig )

static

Return the name of the signal number sig.

The returned memory is statically allocated and must not be freed.

Definition at line 215 of file SealSignal.cxx.

{
#if HAVE_STRSIGNAL
    return strsignal (sig);
#elif HAVE_SYS_SIGLIST
    return sys_siglist [sig];
#else
    // This is not thread safe.  But if you have threads, you probably
    // have strsignal() as well (FIXME: check WIN32).
    static const int buf_size = 8 + BitTraits<int>::Digits;
    static char buf [NSIG] [buf_size];
    if (! buf [sig][0])
    snprintf (buf [sig], buf_size, "Signal %d", sig);
    return buf [sig];
#endif
}

pending() [1/2]

bool Athena::Signal::pending ( int sig )

static

Check if sig is pending for this process.

Definition at line 470 of file SealSignal.cxx.

{ sigset_t s; pending (&s); return sigismember (&s, sig); }

pending() [2/2]

void Athena::Signal::pending ( sigset_t * mask )

static

Return in mask the list of signals pending for this process.

Definition at line 483 of file SealSignal.cxx.

{
}

queue() [1/4]

int Athena::Signal::queue ( int sig, int value = 0 )

static

Queue signal sig for this process with additional data value.

Implemented only on systems with POSIX real-time signals.

Definition at line 445 of file SealSignal.cxx.

{
    return 0;
}

queue() [2/4]

int Athena::Signal::queue ( int sig, void * value )

static

Queue signal sig for this process with additional data value.

Implemented only on systems with POSIX real-time signals.

Definition at line 462 of file SealSignal.cxx.

{
    return 0;
}

queue() [3/4]

int Athena::Signal::queue ( pid_t process, int sig, int value = 0 )

static

Queue signal sig with additional data value for process.

Implemented only on systems with POSIX real-time signals.

Definition at line 410 of file SealSignal.cxx.

{
    return 0;
}

queue() [4/4]

int Athena::Signal::queue ( pid_t process, int sig, void * value )

static

Queue signal sig with additional data value for process.

Implemented only on systems with POSIX real-time signals.

Definition at line 428 of file SealSignal.cxx.

{
    return 0;
}

raise()

int Athena::Signal::raise ( int sig )

static

Raise the signal number sig.

Returns the exit code from the raise() system call (or kill() if raise() does not exist).

Definition at line 376 of file SealSignal.cxx.

{
#if HAVE_RAISE
    return ::raise (sig);
#else
    return ::kill (getpid (), sig);
#endif
}

revert()

void Athena::Signal::revert ( int sig )

static

Revert the signal number sig back to its default behaviour.

Definition at line 325 of file SealSignal.cxx.

{ handle (sig, (HandlerType) (void*)SIG_DFL); }

suspend()

void Athena::Signal::suspend ( const sigset_t * mask )

static

Temporarily replace the signal mask of the process with mask and then suspend until a signal is received.

Definition at line 499 of file SealSignal.cxx.

{
}

trampoline()

void Athena::Signal::trampoline ( int sig )

staticprivate

Internal signal handler trampoline to convert handler arguments to look more like POSIX signals.

The actual handler must have been installed into s_trampolines by handle().

Definition at line 202 of file SealSignal.cxx.

{
    assert (sig > 0 && sig < NSIG);
    assert (s_trampolines [sig]);
    siginfo_t info;
    memset (&info, 0, sizeof (info));
    s_trampolines [sig] (sig, &info, 0);
}

wait() [1/2]

int Athena::Signal::wait ( const sigset_t * mask, siginfo_t * info = 0, long msecs = -1 )

static

Suspend the thread waiting for signals specified by mask for at most msecs milliseconds.

If msecs is negative (the default), waits until a signal is delivered. Otherwise waits up to the specified time limit. Returns the number of the signal that was received, or -1 if the time limit expired. If info is given, fills it with the information that the handler would have otherwise been given. Note that the signals must be blocked (in a multi-threaded application in all the threads, not just the calling one) and not be ignored before calling this function; if a handler is registered, it won't be called. Implemented only on systems with POSIX real-time signals.

Definition at line 561 of file SealSignal.cxx.

{
    return 0;
}

wait() [2/2]

bool Athena::Signal::wait ( int sig, siginfo_t * info = 0, long msecs = -1 )

static

Suspend the thread waiting for signal sig at most msecs milliseconds.

If msecs is negative (the default), waits until a signal is delivered. Otherwise waits up to the specified time limit. Returns true if the signal was received. Note that the signal must be blocked (in a multi-threaded application in all the threads, not just the calling one) and not be ignored before calling this function; if a handler is registered, it won't be called. Implemented only on systems with POSIX real-time signals.

Definition at line 514 of file SealSignal.cxx.

{
    sigset_t s;
    sigemptyset (&s);
    sigaddset (&s, sig);
    // cppcheck-suppress uninitvar
    return wait (&s, info, msecs) == sig;
}

Member Data Documentation

FATAL_AUTO_EXIT

const int Athena::Signal::FATAL_AUTO_EXIT = 256

static

Option to make #fatal(int, siginfo_t *, void *) exit via #quit(int , siginfo_t *, void *).

This will cause all the application clean-up hook to run.

Definition at line 142 of file SealSignal.h.

FATAL_DEFAULT

const int Athena::Signal::FATAL_DEFAULT

static

Initial value:

             = (USR1_DUMP_CORE
| FATAL_ON_INT
| FATAL_DUMP_CORE
| FATAL_DUMP_SIG
| FATAL_DUMP_STACK
| FATAL_DUMP_LIBS
| FATAL_DUMP_CONTEXT
| FATAL_AUTO_EXIT)

Default options to #handleFatal(const char *, IOFD fd, FatalHook, FatalReturn, unsigned.

Definition at line 145 of file SealSignal.h.

FATAL_DUMP_CONTEXT

const int Athena::Signal::FATAL_DUMP_CONTEXT = 128

static

Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the machine context (registers etc.) from the fault position.

Definition at line 138 of file SealSignal.h.

FATAL_DUMP_CORE

const int Athena::Signal::FATAL_DUMP_CORE = 8

static

Option to make #fatal(int, siginfo_t *, void *) dump a core file before crashing.

Definition at line 122 of file SealSignal.h.

FATAL_DUMP_LIBS

const int Athena::Signal::FATAL_DUMP_LIBS = 64

static

Option to make #fataldump(int sig, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the list of currently loaded shared libraries.

Definition at line 134 of file SealSignal.h.

FATAL_DUMP_SIG

const int Athena::Signal::FATAL_DUMP_SIG = 16

static

Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump the signal name (as reported by name()).

Definition at line 126 of file SealSignal.h.

FATAL_DUMP_STACK

const int Athena::Signal::FATAL_DUMP_STACK = 32

static

Option to make #fataldump(int, siginfo_t *, void *) (invoked by #fatal(int, siginfo_t *, void *)) to dump stack backtrace for the offending code location.

Definition at line 130 of file SealSignal.h.

FATAL_ON_INT

const int Athena::Signal::FATAL_ON_INT = 4

static

Option to make SIGINT fatal.

It will still just quit, not crash.

Definition at line 119 of file SealSignal.h.

FATAL_ON_QUIT

const int Athena::Signal::FATAL_ON_QUIT = 2

static

Option to make SIGHUP, SIGTERM and SIGQUIT fatal instead of just #quit(int , siginfo_t *, void *) signals.

Definition at line 115 of file SealSignal.h.

s_applicationName

const char * Athena::Signal::s_applicationName = 0

staticprivate

The current application name.

Definition at line 276 of file SealSignal.h.

s_crashed

bool Athena::Signal::s_crashed = false

staticprivate

Indicator that the application has been crashed: that a fatal signal has been delivered.

Definition at line 273 of file SealSignal.h.

s_fatalFd

IOFD Athena::Signal::s_fatalFd = IOFD_INVALID

staticprivate

The output file descriptor for #fataldump().

Definition at line 277 of file SealSignal.h.

s_fatalHook

Signal::FatalHook Athena::Signal::s_fatalHook = 0

staticprivate

The application handler hook for fatal signals.

Definition at line 278 of file SealSignal.h.

s_fatalOptions

unsigned Athena::Signal::s_fatalOptions = 0

staticprivate

The current fatal signal handling options.

Definition at line 280 of file SealSignal.h.

s_fatalReturn

Signal::FatalReturn Athena::Signal::s_fatalReturn = 0

staticprivate

The application main return hook for fatal signals.

Definition at line 279 of file SealSignal.h.

s_inFatal

int Athena::Signal::s_inFatal = 0

staticprivate

Indicator that we are currently executing inside #fatal().

Used to protect against signals delivered during recovery attempts.

Definition at line 274 of file SealSignal.h.

s_lastSP

std::atomic< unsigned long > Athena::Signal::s_lastSP

staticprivate

Used to switch to a raw stack dump if we crash during a backtrace.

Definition at line 275 of file SealSignal.h.

s_quitHook

Signal::QuitHook Athena::Signal::s_quitHook = 0

staticprivate

The application handler hook for quitting-related signals.

Definition at line 281 of file SealSignal.h.

s_trampolines

Signal::HandlerType Athena::Signal::s_trampolines

staticprivate

Actual signal handlers when POSIX signals are not available.

These are required so that we can send pass correct (= null) arguments to the registered handler when the system is not passing anything, or garbage. If this happens, handle() will register trampoline() as the signal handler and register the signal in this table, and trampoline just looks the actual handler here.

Definition at line 283 of file SealSignal.h.

USR1_DUMP_CORE

const int Athena::Signal::USR1_DUMP_CORE = 1

static

Option that instructs #fatal(int, siginfo_t *, void *) to call #coredump() on SIGUSR1.

This is merely a request to drop a core; no attempt is made to guarantee success. Failure may result for example for lack of permissions, for lack of disk space, or due to low resource limits. Please note that core files can only be created on unixen. Note also that dropping a core is a security risk and should never be enabled in setuid or setgid programs or for production applications.

Definition at line 111 of file SealSignal.h.

---

The documentation for this class was generated from the following files:

• SealSignal.h
• SealSignal.cxx