Athena::DebugAids Class Reference

Utilities for debugging support. More...

#include <SealDebug.h>

Collaboration diagram for Athena::DebugAids:

Static Public Member Functions
static IOFD	stacktraceFd (IOFD fd=IOFD_INVALID)
	Set and return the file descriptor for stack trace output. More...
static void stacktrace	ATLAS_NOT_THREAD_SAFE (IOFD fd=IOFD_INVALID)
static void	coredump (int sig,...)
	Drop a core dump and continue. More...
static void stacktraceLine	ATLAS_NOT_THREAD_SAFE (IOFD fd, unsigned long addr)
static void setStackTraceAddr2Line	ATLAS_NOT_THREAD_SAFE (const char *path)
static unsigned long	enableCoreFiles ()
	Try to enable core dump files by raising the soft size limit to the hard limit. More...
static void	disableCoreFiles ()
	Disable core dump files by setting the soft limit to 0. More...

Static Private Attributes
static std::atomic< IOFD >	s_stackTraceFd = IOFD_INVALID
	The default output file descriptor for #stacktrace(). More...

Detailed Description

Utilities for debugging support.

Definition at line 72 of file SealDebug.h.

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/3]

static void setStackTraceAddr2Line Athena::DebugAids::ATLAS_NOT_THREAD_SAFE ( const char *  path )

static

ATLAS_NOT_THREAD_SAFE() [2/3]

static void stacktraceLine Athena::DebugAids::ATLAS_NOT_THREAD_SAFE ( IOFD  fd, unsigned long  addr  )

static

ATLAS_NOT_THREAD_SAFE() [3/3]

static void stacktrace Athena::DebugAids::ATLAS_NOT_THREAD_SAFE ( IOFD  fd = IOFD_INVALID )

static

coredump()

void Athena::DebugAids::coredump ( int  sig,   ...  )

static

Drop a core dump and continue.

Creates a core file for the current program state and continues execution. sig should be the number of the signal from which the program should appear to have died; this should a fatal signal that does cause a core file to be created (or SIGUSR1).

This works by forking the process and then killing the child with the given signal; the signal is automatically unblocked in the child to make sure the sure the signal is delivered. Thus the function returns only once, in the parent process.

This function can be safely installed directly as a signal handler. #Signal::handleFatal() will do so for SIGUSR1 with suitable options.

Note that this function does not change core dump resource limits, not even for the forked child process. If core files are disabled through resource limits, no core file will be created despite your explicit request to create one.

This concept was taken from DDD, the Data Display Debugger.

Definition at line 974 of file SealDebug.cxx.

{
#ifndef _WIN32
    // FIXME: Forking vs. threads -- need to sort out what is safe.
    // FIXME: Provide a resource limits interface so that core
    // resource limits can be raised?
 
    pid_t   corepid;
    int     status;
 
    ::unlink ("core");
    if ((corepid = ::fork ()) == 0)
    {
    // In child: re-raise the signal, thus killing the process and
    // producing a core dump.  Make sure 1) the signal is not
    // blocked so that we won't return to the caller, 2) we have a
    // signal that is fatal, 3) the signal falls to its default
    // handler to produce the dump.
 
#ifdef SIGUSR1
    // SIGUSR1 does not cause a core dump; use abort() instead
    if (sig == SIGUSR1)
        sig = SIGABRT;  // Could be SIGIOT if SIGABRT is not defined
#endif
    Signal::handle (sig, (Signal::HandlerType) (void*)SIG_DFL);
    Signal::block (sig, false);
    Signal::raise (sig);
 
    // Yikes, this shouldn't happen.  ASSERT isn't right here.  If
    // raise() failed to deliver the signal, abort() is unlikely
    // to work any better, but try it anyway.  Then make sure we
    // die so that we won't return to the caller from the child.
    abort ();
        // cppcheck-suppress unreachableCode
    _exit (255);
    }
    else if (corepid > 0) {
      pid_t wait_pid;
      do {
    wait_pid = ::waitpid (corepid, &status, 0);
      } while (wait_pid == -1 && errno == EINTR);
    }
#endif // !_WIN32
}

disableCoreFiles()

void Athena::DebugAids::disableCoreFiles ( )

static

Disable core dump files by setting the soft limit to 0.

This is equivalent to ulimit -Sc 0 in bash.

Definition at line 1050 of file SealDebug.cxx.

{
  struct rlimit core_limit;
  core_limit.rlim_cur = 0;
  core_limit.rlim_max = 0;
  setrlimit(RLIMIT_CORE, &core_limit);
}

enableCoreFiles()

unsigned long Athena::DebugAids::enableCoreFiles ( )

static

Try to enable core dump files by raising the soft size limit to the hard limit.

There might be other reason though why the system does not produce core files, so this is only one of the prerequisites.

Returns the currently valid soft size limit.

This is equivalent to using ulimit -Sc in bash.

Definition at line 1030 of file SealDebug.cxx.

{
  struct rlimit core_limit;
  getrlimit(RLIMIT_CORE, &core_limit);
 
  unsigned long old_limit = core_limit.rlim_cur;
  core_limit.rlim_cur = core_limit.rlim_max;
  if ( setrlimit(RLIMIT_CORE, &core_limit) == 0 ) {
    return core_limit.rlim_cur;
  }
  else {
    return old_limit;
  }
}

stacktraceFd()

IOFD Athena::DebugAids::stacktraceFd ( IOFD  fd = IOFD_INVALID )

static

Set and return the file descriptor for stack trace output.

If fd is the default invalid descriptor value, returns the current value without changing the setting. This value is only effective for #stacktrace(), but can be overridden by the argument given to that function.

Definition at line 607 of file SealDebug.cxx.

{
  IOFD old = s_stackTraceFd;
  if (fd == IOFD_INVALID) {
    if (old == IOFD_INVALID) {
      s_stackTraceFd.compare_exchange_strong (old, STDERR_HANDLE);
      return s_stackTraceFd;
    }
  }
  else {
    s_stackTraceFd.compare_exchange_strong (old, fd);
  }
  return old;
}

Member Data Documentation

s_stackTraceFd

std::atomic< IOFD > Athena::DebugAids::s_stackTraceFd = IOFD_INVALID

staticprivate

The default output file descriptor for #stacktrace().

Definition at line 88 of file SealDebug.h.

---

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

• SealDebug.h
• SealDebug.cxx