/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/CxxUtils/CxxUtils/SealSignal.h

Go to the documentation of this file.

#ifndef CXXUTILS_SEAL_SIGNAL_H // wlav SEAL_BASE_SIGNAL_H
#define CXXUTILS_SEAL_SIGNAL_H // wlav SEAL_BASE_SIGNAL_H

//<<<<<< INCLUDES                                                       >>>>>>

//# include "SealBase/sysapi/IOTypes.h"           wlav

// These should be hidden, but we can't do that for now: the clients
// must be able to operate on sigset_t and pid_t.  Note that we do not
// want to have <csignal> -- we need all the extra POSIX stuff.
# include <signal.h>
# include <sys/types.h>
# include <climits>

//<<<<<< PUBLIC DEFINES                                                 >>>>>>

// Hacks for fields we might not have in siginfo_t.  Just print zero.
#ifdef si_utime // sss
# define HAVE_SIGINFO_SI_UTIME 1  // sss
#endif // sss 
#ifdef si_int // sss
# define HAVE_SIGINFO_SI_INT 1 // sss
#endif // sss
# if !HAVE_SIGINFO_SI_UTIME     // darwin
#  define si_utime si_signo ? 0 : 0
#  define si_stime si_signo ? 0 : 0
# endif
# if !HAVE_SIGINFO_SI_INT
#  if HAVE_SIGINFO_SI_VALUE     // darwin
#   define si_int   si_value.sigval_int
#   define si_ptr   si_value.sigval_ptr
#  else                 // (none known)
#   define si_int   si_signo ? 0 : 0
#   define si_ptr   si_signo ? (void *) 0 : (void *) 0
#  endif
# endif

//<<<<<< PUBLIC CONSTANTS                                               >>>>>>
//<<<<<< PUBLIC TYPES                                                   >>>>>>
//<<<<<< PUBLIC VARIABLES                                               >>>>>>
//<<<<<< PUBLIC FUNCTIONS                                               >>>>>>
//<<<<<< CLASS DECLARATIONS                                             >>>>>>

# if !HAVE_POSIX_SIGNALS
// Forward declare POSIX signal handling stuff for platforms that
// don't have them.  This allows them to be mentioned in the Signal
// interface and minimally used in the clients.  Special kludge for
// Windows.
#  ifdef _WIN32
typedef struct _EXCEPTION_RECORD siginfo_t;
#define SIGHUP          1       /* Hangup (POSIX).  */
#define SIGQUIT         3       /* Quit (POSIX).  */
#define SIGTRAP         5       /* Trace trap (POSIX).  */
#define SIGKILL         9       /* Kill, unblockable (POSIX).  */
#define SIGUSR1         10      /* User-defined signal 1 (POSIX).  */
#define SIGUSR2         12      /* User-defined signal 2 (POSIX).  */
#define SIGPIPE         13      /* Broken pipe (POSIX).  */
#define SIGALRM         14      /* Alarm clock (POSIX).  */
#define SIGCHLD         17      /* Child status has changed (POSIX).  */
#define SIGCONT         18      /* Continue (POSIX).  */
#define SIGSTOP         19      /* Stop, unblockable (POSIX).  */
#define SIGTSTP         20      /* Keyboard stop (POSIX).  */
#define SIGTTIN         21      /* Background read from tty (POSIX).  */
#define SIGTTOU         22      /* Background write to tty (POSIX).  */
#  else
struct siginfo_t {};
#  endif

typedef int sigset_t;

#  define sigemptyset(x)     (0)
#  define sigfillset(x)      (0)
#  define sigaddset(x,y)     (0)
#  define sigdelset(x,y)     (0)
#  define sigismember(x,y) (0)
# endif

//namespace seal {                                wlav
namespace Athena {                             // wlav

// wlav copied from SealBase/BitTraits.h
template <class T>
struct BitTraits
{
    enum { Bits     = sizeof (T) * CHAR_BIT };

    enum { Bytes    = Bits / 8 + ((Bits % 8) > 0) };

    enum { Digits   = (Bits * 30103) / 100000 + 1 };
    // 30103 =~ M_LN2 / M_LN10 * 100000

    enum { HexDigits    = Bits / 4 + ((Bits % 4) > 0) };
};


class Signal
{
public:
    static const int USR1_DUMP_CORE = 1;

    static const int FATAL_ON_QUIT  = 2;

    static const int FATAL_ON_INT   = 4;

    static const int FATAL_DUMP_CORE    = 8;

    static const int FATAL_DUMP_SIG = 16;

    static const int FATAL_DUMP_STACK   = 32;

    static const int FATAL_DUMP_LIBS    = 64;

    static const int FATAL_DUMP_CONTEXT = 128;

    static const int FATAL_AUTO_EXIT    = 256;

    static const int FATAL_DEFAULT  = (USR1_DUMP_CORE
                       | FATAL_ON_INT
                       | FATAL_DUMP_CORE
                       | FATAL_DUMP_SIG
                       | FATAL_DUMP_STACK
                       | FATAL_DUMP_LIBS
                       | FATAL_DUMP_CONTEXT
                       | FATAL_AUTO_EXIT);

    typedef bool        (*QuitHook) (int sig, siginfo_t *info, void *x);

    typedef bool        (*FatalHook) (int sig, siginfo_t *info, void *x);

    typedef void        (*FatalReturn) (int sig, siginfo_t *info, void *x);

    typedef void (*HandlerType) (int sig, siginfo_t *info, void *extra);


    // Generic signal operations
    // - Signal names
    static const char *     name (int sig);

    // - Signal handlers and masks
    static HandlerType      handler (int sig, sigset_t *mask = 0);
    static HandlerType      handle (int sig, HandlerType handler,
                    const sigset_t *blockMask = 0);
    static void         revert (int sig);
    static void         ignore (int sig);

    static void         block (int sig, bool sense);
    static void         block (const sigset_t *mask, bool sense);
    static void         mask (const sigset_t *mask, sigset_t *old = 0);

    // - Sending and receiving signals
    static int          raise (int sig);
    static int          kill (pid_t process, int sig);
    static int          queue (int sig, int value = 0);
    static int          queue (int sig, void *value);
    static int          queue (pid_t process, int sig, int value = 0);
    static int          queue (pid_t process, int sig, void *value);

    static bool         pending (int sig);
    static void         pending (sigset_t *mask);
    static void         suspend (const sigset_t *mask);
    static bool         wait (int       sig,
                      siginfo_t     *info = 0,
                      long      msecs = -1);
    static int          wait (const sigset_t    *mask,
                      siginfo_t     *info = 0,
                      long      msecs = -1);

    // Assisted handling of program termination signals
    static void         handleQuit (QuitHook hook = 0);
    static QuitHook     handleQuitHook (void);

    static void         quit (int sig, siginfo_t *info, void *x);

    // Assisted handling of fatal signals
    static void         handleFatal (const char *applicationName = 0,
                         IOFD fd = IOFD_INVALID,
                         FatalHook hook = 0,
                         FatalReturn mainreturn = 0,
                         unsigned options = FATAL_DEFAULT);
    static IOFD         handleFatalFd (void);
    static FatalHook        handleFatalHook (void);
    static FatalReturn      handleFatalReturn (void);
    static unsigned     handleFatalOptions (void);

    static void         fatal (int sig, siginfo_t *info, void *x);
    static bool         fatalDump (int sig, siginfo_t *info, void *x);
    static int          fatalLevel (void);
    static bool         crashed (void);

    static void         dumpInfo    (IOFD fd, char *buf, int sig,
                         const siginfo_t *info);
    static void         dumpMemory  (IOFD fd, char *buf,
                         const void *data, size_t n);
    static void         dumpContext (IOFD fd, char *buf,
                         const void *context);

    static const char *     describe (int sig, int code);
  
private:
    static void         trampoline (int sig);

    static bool         s_crashed;
    static int          s_inFatal;
    static const char       *s_applicationName;
    static IOFD         s_fatalFd;
    static FatalHook        s_fatalHook;
    static FatalReturn      s_fatalReturn;
    static unsigned     s_fatalOptions;
    static QuitHook     s_quitHook;
#if !HAVE_POSIX_SIGNALS
    static HandlerType      s_trampolines [NSIG];
#endif
};

//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>

//} // namespace seal                             wlav
} // namespace Athena                             wlav


extern "C" {
  void CxxUtils_installFatalHandler();
}


#endif // CXXUTILS_SEAL_SIGNAL_H wlav SEAL_BASE_SIGNAL_H

---