CoreDumpSvcHandler Namespace Reference

Signal handler for CoreDumpSvc. More...

Typedefs
typedef std::map< int, struct sigaction >	SigHandler_t

Functions
bool	callOldHandler (true)
	forward calls to old handlers?
bool	dumpCoreFile (false)
	dump core file on exit?
bool	stackTrace (false)
	produce stack trace?
bool	fastStackTrace (false)
	produce fast stack trace using CxxUtils/Seal
CoreDumpSvc *	coreDumpSvc (nullptr)
	pointer to CoreDumpSvc
std::ostream &log	ATLAS_NOT_THREAD_SAFE ()
	convenience method for logging
void action	ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *extra)
	Signal handler for the CoreDumpSvc.

Variables
SigHandler_t	oldSigHandler
	old signal handlers

Detailed Description

Signal handler for CoreDumpSvc.

All information accessible from the signal handler is in this namespace. It carries a pointer to the CoreDumpSvc instance. Therefore no static methods are needed in the CoreDumpSvc to provide a function pointer.

Typedef Documentation

SigHandler_t

typedef std::map<int, struct sigaction> CoreDumpSvcHandler::SigHandler_t

Definition at line 81 of file CoreDumpSvc.cxx.

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/2]

std::ostream &log CoreDumpSvcHandler::ATLAS_NOT_THREAD_SAFE

(

void

)

convenience method for logging

Definition at line 91 of file CoreDumpSvc.cxx.

ATLAS_NOT_THREAD_SAFE() [2/2]

void action CoreDumpSvcHandler::ATLAS_NOT_THREAD_SAFE	(	int	sig,
		siginfo_t *	info,
		void *	extra )

Signal handler for the CoreDumpSvc.

Definition at line 96 of file CoreDumpSvc.cxx.

  {
    // Careful: don't do anything here that might allocate memory.
 
    // Protect against recursion.
    // We originally used a thread_local here --- but accessing
    // a thread_local can result in a call to malloc.
 
    const int maxcalls = 64;
    static std::atomic<int> ncalls (0);
    if (++ncalls >= maxcalls) _exit (98);
 
    static std::mutex tidlist_mutex;
    static size_t ntids ATLAS_THREAD_SAFE = 0;
    static pthread_t tids[maxcalls] ATLAS_THREAD_SAFE;
    {
      pthread_t self = pthread_self();
      std::lock_guard<std::mutex> lock (tidlist_mutex);
      for (size_t i = 0; i < ntids; i++) {
        if (pthread_equal (self, tids[i])) return;
      }
      if (ntids == maxcalls) _exit (98);
      tids[ntids++] = self;
    }
 
    // Count the number of threads trying to dump.
    static std::atomic<int> inThreads = 0;
    ++inThreads;
 
    const unsigned int timeoutSeconds = static_cast<unsigned int>(round(coreDumpSvc->m_timeout * 1e-9));
 
    if ( sig == SIGALRM) {
      if (dumpCoreFile) {
        std::println (log(), "Received SIGALRM. Aborting job...");
        // Restore default abort handler that should create a core file
        Athena::Signal::revert (SIGABRT);
        std::abort();
      }
      else {
        std::println (log(), "Received SIGALRM. Terminating job...");
        _exit(97);   // exit without raising any further signals
      }
    }
 
    // Only allow one thread past at a time.
    // Try to assume as little as possible about the state of the library.
    // We don't want to hang forever here, but we also don't want
    // to call any library functions that might use signals under the hood.
    // So use nanosleep() to do the delay --- that's defined to be
    // independent of signals.
    static std::mutex threadMutex;
    const timespec one_second { 1, 0 };
    {
      unsigned int waits = 0;
      while (!threadMutex.try_lock()) {
        nanosleep (&one_second, nullptr);
        if (++waits > timeoutSeconds) _exit (97);
      }
    }
 
    // setup timeout
    if ( timeoutSeconds > 0 && (sig == SIGSEGV || sig == SIGBUS || sig == SIGABRT) ) {
      // This will trigger SIGALRM, which we then handle ourselves above
      alarm(timeoutSeconds);
    }
 
    // Do fast stack trace before anything that might touch the heap.
    // For extra paranoia, avoid iostreams/stdio and use write() directly.
    if (fastStackTrace) {
      write (1, horizLine, strlen(horizLine));
      const char* msg = "Producing (fast) stack trace...\n";
      write (1, msg, strlen (msg));
      write (1, horizLine, strlen(horizLine));
      Athena::Signal::fatalDump (sig, info, extra,
                                 Athena::DebugAids::stacktraceFd(),
                                 Athena::Signal::FATAL_DUMP_SIG +
                                 Athena::Signal::FATAL_DUMP_CONTEXT +
                                 Athena::Signal::FATAL_DUMP_STACK);
      write (1, "\n", 1);
    }
 
    std::cout.flush();
    std::cerr.flush();
    
    if (coreDumpSvc) {
      coreDumpSvc->setSigInfo(info);
      coreDumpSvc->print();
    }
 
    if (gSystem && stackTrace) {
      std::print (log(), "{}Producing stack trace (can be slow, check gdb process)...\n{}",
                  horizLine, horizLine);
      log().flush();
      gSystem->StackTrace();
      std::println (log());
    }
 
    if (callOldHandler) {
      // Call previous signal handler
      // Need to distinguish between the two different types
      const struct sigaction& oact = oldSigHandler[sig];
      std::print (log(), "{}Invoking previous signal handler (can be slow, check gdb process)...\n{}",
                  horizLine, horizLine);
      log().flush();
      if ( oact.sa_flags & SA_SIGINFO ) {
        oact.sa_sigaction(sig, info, extra);
      }
      else if (oact.sa_handler != SIG_DFL && oact.sa_handler != SIG_IGN ) {
        oact.sa_handler(sig);
      }
      else {
        std::println (log(), "Could not invoke previous signal handler");
      }
    }
 
    // This thread is done dumping.
    threadMutex.unlock();
    --inThreads;
 
    if (coreDumpSvc && (sig == SIGSEGV || sig == SIGBUS || sig == SIGABRT) ) {
      // Don't terminate the program while there are other threads
      // trying to dump (but don't wait forever either).
      unsigned int waits = 0;
      while (inThreads > 0 && waits < timeoutSeconds) {
        nanosleep (&one_second, nullptr);
      }
 
      if (dumpCoreFile) {
        std::println (log(), "Aborting job... ");
        // Restore default abort handler that should create a core file
        Athena::Signal::revert (SIGABRT);
        std::abort();
      }
 
      // Exit now on a fatal signal; otherwise, we can hang.
      _exit (99);
    }
  }

callOldHandler()

bool CoreDumpSvcHandler::callOldHandler

(

true

)

forward calls to old handlers?

coreDumpSvc()

CoreDumpSvc * CoreDumpSvcHandler::coreDumpSvc

(

nullptr

)

pointer to CoreDumpSvc

dumpCoreFile()

bool CoreDumpSvcHandler::dumpCoreFile

(

false

)

dump core file on exit?

fastStackTrace()

bool CoreDumpSvcHandler::fastStackTrace

(

false

)

produce fast stack trace using CxxUtils/Seal

stackTrace()

bool CoreDumpSvcHandler::stackTrace

(

false

)

produce stack trace?

Variable Documentation

oldSigHandler

SigHandler_t CoreDumpSvcHandler::oldSigHandler

old signal handlers

Definition at line 83 of file CoreDumpSvc.cxx.