---

IgHookTrace.cc

Go to the documentation of this file.

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

#include "IgTools/IgHook/interface/IgHookTrace.h"
#include <cstdlib>
#include <cstdio>
#include <dlfcn.h>
#include <unistd.h>
#include <sys/mman.h>
#if __linux
# include <execinfo.h>
# include <ucontext.h>
# include <sys/syscall.h>
#endif
#if __APPLE__
extern "C" void _sigtramp (void);
#endif

//<<<<<< PRIVATE DEFINES                                                >>>>>>

#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# define HAVE_UNWIND_BACKTRACE 1
#endif
#if !defined MAP_ANONYMOUS && defined MAP_ANON
# define MAP_ANONYMOUS MAP_ANON
#endif

//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>

#if HAVE_UNWIND_BACKTRACE
struct IgHookTraceArgs { void **array; int count; int size; };
extern "C" {
  typedef unsigned _Unwind_Ptr __attribute__((__mode__(__pointer__)));
  struct _Unwind_Context;
  enum _Unwind_Reason_Code
  {
      _URC_NO_REASON = 0,
      _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
      _URC_FATAL_PHASE2_ERROR = 2,
      _URC_FATAL_PHASE1_ERROR = 3,
      _URC_NORMAL_STOP = 4,
      _URC_END_OF_STACK = 5,
      _URC_HANDLER_FOUND = 6,
      _URC_INSTALL_CONTEXT = 7,
      _URC_CONTINUE_UNWIND = 8
  };

  typedef _Unwind_Reason_Code (*_Unwind_Trace_Fn) (_Unwind_Context *, void *);
  _Unwind_Reason_Code _Unwind_Backtrace (_Unwind_Trace_Fn, void *);
  _Unwind_Ptr _Unwind_GetIP (_Unwind_Context *);
}

static _Unwind_Reason_Code
GCCBackTrace (_Unwind_Context *context, void *arg)
{
    IgHookTraceArgs *args = (IgHookTraceArgs *) arg;
    if (args->count >= 0 && args->count < args->size)
        args->array [args->count++] = (void *) _Unwind_GetIP (context);
    else
        return _URC_END_OF_STACK;
    return _URC_NO_REASON;
}
#endif

//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>

IgHookTraceAlloc::IgHookTraceAlloc (void)
    : m_pool (0),
      m_left (0)
{}

void *
IgHookTraceAlloc::allocate (size_t bytes)
{
    // The reason for the existence of this class is to allocate
    // memory directly using mmap() so we don't create calls to
    // malloc() and friends.  This is for two reasons: it must be
    // possible to use this in asynchronous signal handlers, and
    // calling malloc() in those is a really bad idea; and this is
    // meant to be used by profiling code and it's nicer to not
    // allocate memory in ways tracked by the profiler.
    if (m_left < bytes)
    {
        size_t psize = getpagesize ();
        size_t hunk = psize * 20;
        if (hunk < bytes) hunk = (hunk + psize - 1) & ~(psize-1);
        void *addr = mmap (0, hunk, PROT_READ | PROT_WRITE,
                           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
        if (addr == MAP_FAILED)
            return 0;

        m_pool = addr;
        m_left = hunk;
    }

    void *ptr = m_pool;
    m_pool = (char *) m_pool + bytes;
    m_left -= bytes;
    return ptr;
}

void *
IgHookTrace::CounterValue::operator new (size_t n, IgHookTraceAlloc *alloc /* = 0 */)
{ return alloc ? alloc->allocate (n) : ::operator new (n); }

IgHookTrace::CounterValue::CounterValue (Counter *counter,
                                         CounterValue *next /* = 0 */,
                                         unsigned long long value /* = 0 */)
    : m_counter (counter),
      m_next (next),
      m_value (value),
      m_count (0)
{}

IgHookTrace::Counter *
IgHookTrace::CounterValue::counter (void)
{ return m_counter; }

IgHookTrace::CounterValue *
IgHookTrace::CounterValue::next (void)
{ return m_next; }

unsigned long long
IgHookTrace::CounterValue::value (void)
{ return m_value; }
    
unsigned long long
IgHookTrace::CounterValue::count (void)
{ return m_count; }
    
unsigned long long
IgHookTrace::CounterValue::tick (void)
{ ++m_count; return ++m_value; }

unsigned long long
IgHookTrace::CounterValue::untick (void)
{ --m_count; return --m_value; }

unsigned long long
IgHookTrace::CounterValue::add (unsigned long long value)
{ ++m_count; return m_value += value; }

unsigned long long
IgHookTrace::CounterValue::sub (unsigned long long value)
{ --m_count; return m_value -= value; }

unsigned long long
IgHookTrace::CounterValue::max (unsigned long long value)
{ ++m_count; if (m_value < value) m_value = value; return m_value; }

unsigned long long
IgHookTrace::CounterValue::add (CounterValue &x)
{ m_count += x.m_count; m_value += x.m_value; return m_value; }

unsigned long long
IgHookTrace::CounterValue::sub (CounterValue &x)
{ m_count -= x.m_count; m_value -= x.m_value; return m_value; }

unsigned long long
IgHookTrace::CounterValue::max (CounterValue &x)
{ m_count += x.m_count; if (m_value < x.m_value) m_value = x.m_value; return m_value; }

void *
IgHookTrace::operator new (size_t n, IgHookTraceAlloc *alloc /* = 0 */)
{ return alloc ? alloc->allocate (n) : ::operator new (n); }

IgHookTrace::IgHookTrace (IgHookTrace *parent /* = 0 */, void *address /* = 0 */)
    : m_alloc (parent ? parent->m_alloc : new IgHookTraceAlloc),
      m_parent (parent),
      m_next (parent ? parent->m_children : 0),
      m_children (0),
      m_address (address),
      m_counters (0)
{ if (m_parent) m_parent->m_children = this; }

IgHookTrace *
IgHookTrace::parent (void)
{ return m_parent; }

IgHookTrace *
IgHookTrace::next (void)
{ return m_next; }

void *
IgHookTrace::address (void)
{ return m_address; }

bool
IgHookTrace::symbol (void *address,
                     const char *&sym,
                     const char *&lib,
                     int &offset,
                     int &liboffset)
{
    sym = lib = 0;
    offset = 0;
    liboffset = (unsigned long) address;

    Dl_info info;
    if (dladdr (address, &info))
    {
        if (info.dli_fname && info.dli_fname [0])
            lib = info.dli_fname;

        if (info.dli_fbase)
            liboffset = (unsigned long) address - (unsigned long) info.dli_fbase;

        if (info.dli_saddr)
            offset = (unsigned long) address - (unsigned long) info.dli_saddr;

        if (info.dli_sname && info.dli_sname [0])
            sym = info.dli_sname;

        return true;
    }

    return false;
}

bool
IgHookTrace::symbol (const char *&sym, const char *&lib, int &offset, int &liboffset)
{ return symbol (m_address, sym, lib, offset, liboffset); }

void *
IgHookTrace::tosymbol (void *address)
{
    Dl_info info;
    return (dladdr (address, &info)
            && info.dli_fname
            && info.dli_fname [0]
            && info.dli_saddr)
        ? info.dli_saddr : address;
}

int
IgHookTrace::stacktrace (void **addresses, int nmax)
{
#if __linux && __i386
# if ! __x86_64__
#  define PROBABLY_VSYSCALL_PAGE 0xffff0000
# else
#  define PROBABLY_VSYSCALL_PAGE 0xffffffff00000000
# endif
    struct frame
    {
        // Normal frame.
        frame           *ebp;
        void            *eip;
        // Signal frame stuff, put in here by kernel.
        int             signo;
        siginfo_t       *info;
        ucontext_t      *ctx;
    };
    register frame      *ebp __asm__ ("ebp");
    register frame      *esp __asm__ ("esp");
    frame               *fp = ebp;
    int                 depth = 0;

    // Add fake entry to be compatible with other methods
    if (depth < nmax)
        addresses[depth++] = (void *) &IgHookTrace::stacktrace;

    // Top-most frame ends with null pointer; check the rest is reasonable
    while (depth < nmax && fp >= esp)
    {
        // Add this stack frame.  The return address is the
        // instruction immediately after the "call".  The call
        // instruction itself is 4 or 6 bytes; we guess 4.
        addresses[depth++] = (char *) fp->eip - 4;

        // Recognise signal frames.  We use two different methods
        // depending on the linux kernel version.
        //
        // For the "old" kernels / systems we check the instructions
        // at the caller's return address.  We take it to be a signal
        // frame if we find the signal return code sequence there
        // and the thread register context structure pointer:
        //
        //    mov $__NR_rt_sigreturn, %eax
        //    int 0x80
        //
        // For the "new" kernels / systems the operating system maps
        // a "vsyscall" page at a high address, and it may contain
        // either the above code, or use of the sysenter/sysexit
        // instructions.  We cannot poke at that page so we take the
        // the high address as an indication this is a signal frame.
        // (https://www.trilithium.com/johan/2005/08/linux-gate/)
        // (https://manugarg.googlepages.com/systemcallinlinux2_6.html)
        //
        // If we don't recognise the signal frame correctly here, we
        // lose one stack frame: signal delivery is not a call so
        // when the signal handler is entered, ebp still points to
        // what it was just before the signal.
        unsigned char *insn = (unsigned char *) fp->eip;
        if (insn
            && insn[0] == 0xb8 && insn[1] == __NR_rt_sigreturn
            && insn[5] == 0xcd && insn[6] == 0x80
            && fp->ctx)
        {   
            void *retip = (void *) fp->ctx->uc_mcontext.gregs [REG_EIP];
            if (depth < nmax)
                addresses[depth++] = retip;

            fp = (frame *) fp->ctx->uc_mcontext.gregs [REG_EBP];
            if (fp && (unsigned long) retip > PROBABLY_VSYSCALL_PAGE)
            {
                // __kernel_vsyscall stack on system call exit is
                // [0] %ebp, [1] %edx, [2] %ecx, [3] return address.
                if (depth < nmax)
                    addresses[depth++] = ((void **) fp)[3];
                fp = fp->ebp;

                // It seems the frame _above_ __kernel_syscall (the
                // syscall implementation in libc, such as __mmap())
                // is essentially frame-pointer-less, so we should
                // find also the call above, but I don't know how
                // to determine how many arguments the system call
                // pushed on stack to call __kernel_syscall short
                // of interpreting the DWARF unwind information :-(
                // So we may lose one level of call stack here.
            }
        }

        // Otherwise it's a normal frame, process through frame pointer.
        else
            fp = fp->ebp;
    }

    return depth;
#elif __APPLE__ && __ppc__
    struct frame { frame *sp; void *cr; char *lr; };
    char                *sigtramplow = (char *) &_sigtramp;
    char                *sigtramphi  = (char *) sigtramplow + 256;
    register frame      *sp __asm__ ("sp");
    register char       *lr __asm__ ("lr");
    frame               *fp = sp;
    char                *entry = lr;
    int                 depth = 0;

    // Add fake entry to be compatible with other methods
    if (depth < nmax)
        addresses[depth++] = (void *) &IgHookTrace::stacktrace;

    while (depth < nmax && entry)
    {
        // LR points to the instruction after call, so step back.
        addresses[depth++] = entry - 4;

        // Check next one is a valid frame.
        frame *next = fp->sp;
        if (next <= fp || next <= sp)
            break;

        // Get and handle previous frame's call address.  Signal
        // frames are detected by being in sigtramp() and need
        // special handling.  The offset for pre-signal SP is
        // somewhat magic.
        if (entry >= sigtramplow && entry <= sigtramphi)
        {
            fp = *(frame **) ((char *) next + 156);
            entry = *(char **) ((char *) next + 144);
        }
        else
        {
            fp = next;
            entry = fp->lr;
        }
    }

    return depth;
#elif __linux
    return backtrace (addresses, nmax);
#elif HAVE_UNWIND_BACKTRACE
    if (nmax >= 1)
    {
        IgHookTraceArgs args = { addresses, 0, nmax };
        _Unwind_Backtrace (&GCCBackTrace, &args);

        if (args.count > 1 && args.array [args.count-1] == 0)
            args.count--;

        return args.count;
    }
    return 0;
#else
    return 0;
#endif
}

IgHookTrace *
IgHookTrace::children (void)
{ return m_children; }

IgHookTrace *
IgHookTrace::child (void *address)
{
    for (IgHookTrace *kid = m_children; kid; kid = kid->m_next)
        if (kid->m_address == address)
            return kid;
    
    return new (m_alloc) IgHookTrace (this, address);
}

IgHookTrace::CounterValue *
IgHookTrace::counters (void)
{ return m_counters; }

IgHookTrace::CounterValue *
IgHookTrace::counter (Counter *id)
{
    for (CounterValue *val = m_counters; val; val = val->next ())
        if (val->counter () == id)
            return val;
    
    m_counters = new (m_alloc) CounterValue (id, m_counters);
    return m_counters;
}

void
IgHookTrace::merge (IgHookTrace *other)
{
    for (CounterValue *val = other->m_counters; val; val = val->next ())
        // FIXME: should counter know which of add()/max() we should use?
        counter (val->counter ())->add (*val);

    for (IgHookTrace *kid = other->m_children; kid; kid = kid->m_next)
        child (kid->m_address)->merge (kid);
}

---