SealDebug.cxx File Reference

#include "CxxUtils/SealCommon.h"
#include "CxxUtils/SealDebug.h"
#include "CxxUtils/SealSignal.h"
#include "CxxUtils/UnwindBacktrace.h"
#include "CxxUtils/checker_macros.h"
#include <cstring>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <climits>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/resource.h>

Go to the source code of this file.

Macros
#define	STDERR_HANDLE   STDERR_FILENO
#define	MYWRITE(fd, data, n)
#define	MYWRITELIT(fd, str)

Functions
void DebugAids::stacktraceLine	ATLAS_NOT_THREAD_SAFE (IOFD fd, unsigned long addr)
	Write out stack trace line to FD.
void DebugAids::setStackTraceAddr2Line	ATLAS_NOT_THREAD_SAFE (const char *path)
void DebugAids::stacktrace	ATLAS_NOT_THREAD_SAFE (IOFD fd)
	Produce a stack trace.

Macro Definition Documentation

MYWRITE

#define MYWRITE	(		fd,
			data,
			n )

Value:

write(fd,data,n)

MYWRITELIT

#define MYWRITELIT	(		fd,
			str )

Value:

MYWRITE(fd,str,sizeof(str)-1)

STDERR_HANDLE

#define STDERR_HANDLE   STDERR_FILENO

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/3]

void DebugAids::setStackTraceAddr2Line ATLAS_NOT_THREAD_SAFE

(

const char *

path

)

Definition at line 582 of file SealDebug.cxx.

{
  addr2LinePath = path;
}

ATLAS_NOT_THREAD_SAFE() [2/3]

void DebugAids::stacktrace ATLAS_NOT_THREAD_SAFE

(

IOFD

fd

)

Produce a stack trace.

Prints the current stack trace to file descriptor fd or if the default invalid descriptor, the currently registered stack trace descriptor as registered with #stacktraceFd(). Avoids unnecessary memory allocation so it should be safe to call this function even in dire situations. On some systems the implementation always outputs to the standard error and has no means for redirection. On these systems an attempt is made to redirect standard error momentarily elsewhere and then redirect standard error to the desired file descriptor, invoke the output, and redirect standard error back to its original location. If the redirection fails or the system has no stack tracing support, no stack trace is produced.

Definition at line 637 of file SealDebug.cxx.

{
    if (fd == IOFD_INVALID)
      fd = stacktraceFd();
 
    std::cerr.flush ();
    fflush (stderr);
 
#ifdef _WIN32
    // FIXME: Autoload all these functions so users don't need to
    // link in imagehlp.dll.
    if (! SymInitialize (GetCurrentProcess (), NULL, TRUE))
    {
    MYWRITELIT (fd, ("failed to dump stack trace:"
             " cannot get symbolic information\n"));
    return;
    }
 
    union SYMBUFFER {
    IMAGEHLP_SYMBOL sym;
    BYTE        buffer [ sizeof (IMAGEHLP_SYMBOL) + 512 ];
    };
 
    unsigned        level = 0;
    CONTEXT     context;
    STACKFRAME      frame;
    SYMBUFFER       symbol;
    IMAGEHLP_MODULE module;
    char        modulename [MAX_PATH];
    DWORD       section;
    DWORD       offset;
    const int       buf_size = 2*40+6;   // ample for two 128+ bit numbers
    char        buf [buf_size];
    // DWORD        exceptargs [] = { (DWORD) &context };
 
    // FIXME: XP 64-bit adds: RtlCaptureContext (&context);
    // This is documented to *not* work, but apparently it does.
    context.ContextFlags = CONTEXT_FULL;
    if (! GetThreadContext (GetCurrentThread (), &context))
    return;
 
    // LPTOP_LEVEL_EXCEPTION_FILTER oldseh
    //  = SetUnhandledExceptionFilter (&GrabExceptionContext);
    // RaiseException (0, 0, 1, exceptargs);
    // SetUnhandledExceptionFilter (oldseh);
 
    memset (&module, 0, sizeof (module));
    memset (&frame, 0, sizeof (frame));
 
    module.SizeOfStruct     = sizeof (module);
 
    frame.AddrPC.Offset     = context.Eip;
    frame.AddrPC.Mode       = AddrModeFlat;
    frame.AddrStack.Offset  = context.Esp;
    frame.AddrStack.Mode    = AddrModeFlat;
    frame.AddrFrame.Offset  = context.Ebp;
    frame.AddrFrame.Mode    = AddrModeFlat;
 
    while (true)
    {
    if (! StackWalk (IMAGE_FILE_MACHINE_I386,
             GetCurrentProcess (),
             GetCurrentThread (),
             &frame,
             &context,
             NULL,
             SymFunctionTableAccess,
             SymGetModuleBase,
             NULL)
        || frame.AddrFrame.Offset == 0)
        break;
 
    // FIXME: Throw away everything above stacktrace?  Keep looping
    // below until the name includes something we understand?
 
    // Print stack frame too?  If we know how many arguments there
    // are (from demangling function name -- see below, could count
    // commas), args are: *((ULONG *)frame.AddrFrame.Offset+2+ARG).
    MYWRITE (fd, buf, snprintf (buf, buf_size, "(%2u) 0x%08lx 0x%08lx   ",
                    level, frame.AddrPC.Offset,
                    frame.AddrFrame.Offset));
 
    memset (&symbol, 0, sizeof (symbol));
    symbol.sym.SizeOfStruct = sizeof (symbol);
    symbol.sym.MaxNameLength = sizeof (symbol) - sizeof (symbol.sym);
 
    offset = 0;
    if (SymGetSymFromAddr (GetCurrentProcess (), frame.AddrPC.Offset,
                   &offset, &symbol.sym))
    {
        // FIXME: Demangle name with:
        //   UnDecorateSymbolName (name, undecname, sizeof (undecname),
        //              UNDNAME_COMPLETE
        //              | UNDNAME_NO_THISTYPE
        //              | UNDNAME_NO_SPECIAL_SYMS
        //              | UNDNAME_NO_MEMBER_TYPE
        //              | UNDNAME_NO_MS_KEYWORDS
        //              | UNDNAME_NO_ACCESS_SPECIFIERS);
        MYWRITE (fd, symbol.sym.Name, STDC::strlen (symbol.sym.Name));
        MYWRITE (fd, buf, snprintf (buf, buf_size, " + %lx", offset));
 
        if (SymGetModuleInfo (GetCurrentProcess(), frame.AddrPC.Offset,
                  &module))
        {
        MYWRITELIT (fd, " [");
        MYWRITE (fd, module.ImageName,
             STDC::strlen (module.ImageName));
        MYWRITELIT (fd, "]");
        }
    }
    else
    {
        GetLogicalAddress ((PVOID) frame.AddrPC.Offset,
                   modulename, sizeof (modulename),
                   section, offset);
        MYWRITE (fd, buf, snprintf (buf, buf_size, "%04lx:%08lx [", section, offset));
        MYWRITE (fd, modulename, STDC::strlen (modulename));
        MYWRITELIT (fd, "]");
    }
    MYWRITELIT (fd, "\n");
    ++level;
    }
    SymCleanup (GetCurrentProcess ());
 
#elif (HAVE_U_STACK_TRACE || HAVE_XL_TRBK)      // hp-ux, aix
    // FIXME: deal with inability to duplicate the file handle
    int stderrfd = dup (STDERR_FILENO);
    if (stderrfd == -1)
    return;
 
    int newfd    = dup2 (fd, STDERR_FILENO);
    if (newfd == -1)
    {
    close (stderrfd);
    return;
    }
 
# if HAVE_U_STACK_TRACE     // hp-ux
    U_STACK_TRACE ();
# elif HAVE_XL_TRBK     // aix
    xl__trbk ();
# else
#  error "oops, you shouldn't have gotten here!"
# endif
 
    fflush (stderr);
    dup2 (stderrfd, STDERR_FILENO);
    close (newfd);
#elif HAVE_LINUX_UNWIND_BACKTRACE
    CxxUtils::backtraceByUnwind (stacktraceLine, fd);
 
#elif HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR      // linux
    // we could have used backtrace_symbols_fd, except its output
    // format is pretty bad, so recode that here :-(
    void        *trace [MAX_BACKTRACE_DEPTH];
    int         depth = backtrace (trace, MAX_BACKTRACE_DEPTH);
 
    for (int n = 0; n < depth; ++n/*, nbufs = 0*/)
    {
    unsigned long   addr = (unsigned long) trace [n];
        stacktraceLine (fd, addr);
    }
 
#elif HAVE_EXCPT_H && HAVE_PDSC_H && HAVE_RLD_INTERFACE_H // tru64
    // Tru64 stack walk.  Uses the exception handling library and the
    // run-time linker's core functions (loader(5)).  FIXME: Tru64
    // should have _RLD_DLADDR like IRIX below.  Verify and update.
 
    const int   buffer_size = 100 + BitTraits<unsigned long>::HexDigits * 2 + 11;
    char    buffer [buffer_size];
    sigcontext  context;
    int     rc = 0;
 
    exc_capture_context (&context);
    while (!rc && context.sc_pc)
    {
    // FIXME: Elf32?
    pdsc_crd *func, *base, *crd
      = exc_remote_lookup_function_entry(0, 0, context.sc_pc, 0, &func, &base);
    Elf32_Addr addr = PDSC_CRD_BEGIN_ADDRESS(base, func);
    // const char *name = _rld_address_to_name(addr);
    const char *name = "<unknown function>";
    snprintf (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
          context.sc_pc, name, context.sc_pc - addr);
    write (fd, buffer, STDC::strlen(buffer));
    rc = exc_virtual_unwind(0, &context);
    }
 
#elif HAVE_EXCEPTION_H && defined __sgi         // irix
    // IRIX stack walk -- like Tru64 but with a little different names.
    // NB: The guard above is to protect against unrelated <exception.h>
    //   provided by some compilers (e.g. KCC 4.0f).
    // NB: libexc.h has trace_back_stack and trace_back_stack_and_print
    //   but their output isn't pretty and nowhere as complete as ours.
    char       buffer [340];
    sigcontext context;
 
    exc_setjmp (&context);
    while (context.sc_pc >= 4)
    {
    // Do two lookups, one using exception handling tables and
    // another using _RLD_DLADDR, and use the one with a smaller
    // offset.  For signal handlers we seem to get things wrong:
    // _sigtramp's exception range is huge while based on Dl_info
    // the offset is small -- but both supposedly describe the
    // same thing.  Go figure.
    char            *name = 0;
    const char      *libname = 0;
    const char      *symname = 0;
    Elf32_Addr      offset = ~0L;
 
    // Do the exception/dwarf lookup
    Elf32_Addr      pc = context.sc_pc;
    Dwarf_Fde       fde = find_fde_name (&pc, &name);
    Dwarf_Addr      low_pc = context.sc_pc;
    Dwarf_Unsigned  udummy;
    Dwarf_Signed    sdummy;
    Dwarf_Ptr       pdummy;
    Dwarf_Off       odummy;
    Dwarf_Error     err;
 
    symname = name;
 
    // Determine offset using exception descriptor range information.
    if (dwarf_get_fde_range (fde, &low_pc, &udummy, &pdummy, &udummy,
                 &odummy, &sdummy, &odummy, &err) == DW_DLV_OK)
        offset = context.sc_pc - low_pc;
 
       // Now do a dladdr() lookup.  If the found symbol has the same
       // address, trust the more accurate offset from dladdr();
       // ignore the looked up mangled symbol name and prefer the
       // demangled name produced by find_fde_name().  If we find a
       // smaller offset, trust the dynamic symbol as well.  Always
       // trust the library name even if we can't match it with an
       // exact symbol.
    Elf32_Addr      addr = context.sc_pc;
    Dl_info         info;
 
    if (_rld_new_interface (_RLD_DLADDR, addr, &info))
    {
        if (info.dli_fname && info.dli_fname [0])
        libname = info.dli_fname;
 
        Elf32_Addr symaddr = (Elf32_Addr) info.dli_saddr;
        if (symaddr == low_pc)
        offset = addr - symaddr;
        else if (info.dli_sname
             && info.dli_sname [0]
             && addr - symaddr < offset)
        {
        offset = addr - symaddr;
        symname = info.dli_sname;
        }
    }
 
    // Print out the result
    if (libname && symname)
            write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx [%.200s]\n",
            addr, symname, offset, libname));
    else if (symname)
        write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
            addr, symname, offset));
    else
        write (fd, buffer, snprintf
           (buffer, buffer_size, " 0x%012lx <unknown function>\n", addr));
 
    // Free name from find_fde_name().
    free (name);
 
    // Check for termination.  exc_unwind() sets context.sc_pc to
    // 0 or an error (< 4).  However it seems we can't unwind
    // through signal stack frames though this is not mentioned in
    // the docs; it seems that for those we need to check for
    // changed pc after find_fde_name().  That seems to indicate
    // end of the post-signal stack frame.  (FIXME: Figure out how
    // to unwind through signal stack frame, e.g. perhaps using
    // sigcontext_t's old pc?  Or perhaps we can keep on going
    // down without doing the symbol lookup?)
    if (pc != context.sc_pc)
        break;
 
    exc_unwind (&context, fde);
    }
 
#elif defined PROG_PSTACK               // solaris
# ifdef PROG_CXXFILT
#  define CXXFILTER " | " PROG_CXXFILT
# else
#  define CXXFILTER
# endif
    // 64 should more than plenty for a space and a pid.
    const int buffer_size = sizeof(PROG_PSTACK) + 1 + BitTraits<unsigned long>::Digits
                 + 3 + sizeof(PROG_CXXFILT) + BitTraits<int>::Digits + 1;
    char buffer [buffer_size];
    snprintf (buffer, buffer_size, "%s %lu%s 1>&%d", PROG_PSTACK, (unsigned long) getpid (),
         "" CXXFILTER, fd);
    system (buffer);
# undef CXXFILTER
 
#elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
    // FIXME: Check for _Unwind*, compilers other than GCC support this API
    _Unwind_Backtrace (unwindWalkStack, &fd);
#endif
 
    // FIXME: mpatrol has some generic unix unwind code.
    // FIXME: from unix faq: ask debugger to dump stack trace
    // with something like:
    //   - gdb: echo "thread apply all where\nwhere\ndetach" | gdb $prog $pid
    //   - dbx: echo "where\ndetach" | dbx -a $program_path $pid
    //   - dbx (aix): echo "where\ndetach" | dbx -p $program_path $pid
}

ATLAS_NOT_THREAD_SAFE() [3/3]

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

Write out stack trace line to FD.

IP is the instruction pointer. (sss)

Definition at line 332 of file SealDebug.cxx.

{
  iovec     bufs [7];
  int       nbufs = 0;
  const int     addrbuf_size = 5 + BitTraits<unsigned long>::HexDigits;
  char      addrbuf [addrbuf_size];
 
#if HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR
  const int     diffbuf_size = 15 + BitTraits<unsigned long>::HexDigits;
  char      diffbuf [diffbuf_size];
  static const char trailer [] = "]\n";
  Dl_info       info;
 
  char dembuf[ LINE_MAX ];
  char line[ LINE_MAX ];
  const int     relbuf_size = 7 + BitTraits<unsigned long>::HexDigits;
  char    relbuf [relbuf_size];
 
  if (dladdr ((void*)addr, &info) && info.dli_fname && info.dli_fname[0])
  {
    const char *libname = info.dli_fname;
           
    unsigned long   symaddr = (unsigned long) info.dli_saddr;
    bool        gte = (addr >= symaddr);
    unsigned long   diff = (gte ? addr - symaddr : symaddr - addr);
 
    // RS start
    int length = 0;
    
    // difference of two pointers
    unsigned long libaddr = (unsigned long) info.dli_fbase;
    unsigned long relative_address = (addr >= libaddr) ? addr - libaddr : libaddr - addr;
    // ELF executables are usually not relocatable, and on 64-bit platforms
    // are usually loaded starting at 0x400000.  In that case, we should _not_
    // subtract the base address.  But clang15 by default appears to produce
    // position-independent executables (PIE) by default.  In that case,
    // we do need to subtract the offset.
    // I'm not sure how to reliably tell the difference short of parsing
    // the object headers.  For now, just assume that something
    // that doesn't have .so in the name and is loaded at 0x400000
    // is not relocatable.  This is not really portable, though.
    if (strstr (info.dli_fname, ".so") == 0 && libaddr == 0x400000)
      relative_address = addr;
 
    // need popen for addr2line ...
    int pfd;
    pid_t child_pid;
    const char* symname = dembuf;
    size_t demlen = 0;
 
    // did we find valid entry ?
    size_t len = strlen(info.dli_fname);
    if ( len > 0 && len + 80 < LINE_MAX)
    {
      if (getenv ("LD_PRELOAD"))
        unsetenv ("LD_PRELOAD");
 
      if ( addr2LinePath == "/usr/bin/eu-addr2line" )
    {
      snprintf (line, LINE_MAX, "%s -f -e %s %p | /usr/bin/c++filt | /usr/bin/tr \\\\012 \\\\040 ",
            addr2LinePath.c_str(),
            info.dli_fname,
            (void*)relative_address); 
    }
      else
    {
      snprintf (line, LINE_MAX, "%s -f -C -e %s %p",
            addr2LinePath.c_str(),
            info.dli_fname,
            (void*)relative_address);
    }
 
      pfd = stacktracePopenFD( line, child_pid );
 
      length = 1;
      line[0] = ' ';
 
      // did we succeed to open the pipe?
      if ( pfd >= 0 )
      {
        demlen = stacktraceReadline (pfd, dembuf, sizeof(dembuf));
 
        length = stacktraceReadline (pfd, line+1, sizeof(line)-1);
        if (length >= 0) ++length;
 
        int stat = stacktracePcloseFD (pfd, child_pid);
 
        // don't print anything, if nothing is found
        if ( stat || line[1] == '?' || length < 0)
        {
          line[1] = '\0';
          length = 0;
        }
 
    if ( stat || demlen <= 0 || dembuf[0] == '?') {
          symname = info.dli_sname;
          if (!symname) symname = "???";
          demlen = strlen (symname);
        }
 
      }
    }
    // RS end
 
    bufs [nbufs].iov_base = addrbuf;
    bufs [nbufs].iov_len  = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
    ++nbufs;
 
    bufs [nbufs].iov_base = (void *) symname; // discard const
    bufs [nbufs].iov_len  = demlen;
    ++nbufs;
 
    // RS start
    bufs [nbufs].iov_base = line;
    bufs [nbufs].iov_len  = length;
    ++nbufs;
    // RS end
 
    bufs [nbufs].iov_base = diffbuf;
    bufs [nbufs].iov_len  = snprintf (diffbuf, diffbuf_size, " %c 0x%lx [",
                                      gte ? '+' : '-', diff);
    ++nbufs;
 
    bufs [nbufs].iov_base = (void *) libname; // discard const
    bufs [nbufs].iov_len  = strlen (libname);
    ++nbufs;
 
    // RS start
    bufs [nbufs].iov_base = relbuf;
    bufs [nbufs].iov_len  = snprintf( relbuf, relbuf_size, " D[%p]", (void*)relative_address );
    ++nbufs;
    // RS end
 
    bufs [nbufs].iov_base = (void *) trailer; // discard const
    bufs [nbufs].iov_len  = 2;
    ++nbufs;
 
  }
  else
#endif
  {
    bufs [nbufs].iov_base = addrbuf;
    bufs [nbufs].iov_len  = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
    ++nbufs;
    
    bufs [nbufs].iov_base = (void *) "<unknown function>\n"; //no const
    bufs [nbufs].iov_len  = 19;
    ++nbufs;
  }
 
  writev (fd, bufs, nbufs);
}