---

SimpleProfiler.cc File Reference

#include <pthread.h>
#include <unistd.h>
#include <dlfcn.h>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/resource.h>
#include <fcntl.h>
#include <ucontext.h>
#include <execinfo.h>
#include "SimpleProfiler.h"
#include "ProfParse.h"
#include <fstream>

Go to the source code of this file.

Namespaces
namespace	INSTR
Defines
#define	_POSIX_C_SOURCE   199309
#define	DODEBUG   if(0) std::cerr
#define	getBP(X)   asm ( "movl %%ebp,%0" : "=m" (X) )
#define	getSP(X)   asm ( "movl %%esp,%0" : "=m" (X) )
#define	MUST_BE_ZERO(fun)   if((fun)!=0) { perror("function failed"); abort(); }
Typedefs
typedef unsigned char	INSTR::byte
Functions
void	closeCondFile ()
void	dumpStack (const char *msg, unsigned int *esp, unsigned int *ebp, unsigned char *eip, ucontext_t *ucp)
std::string	makeFileName ()
void	openCondFile ()
void *	setStacktop ()
void	setupTimer ()
void	setupTimer ()
void	sigFunc (int sig, siginfo_t *info, void *context)
int	stacktrace (void *addresses[], int nmax)
void	write_maps ()
void	writeCond (int code)
Variables
FILE *	frame_cond = 0
static AdjustSigs	global_adjust
const int	REG_EBP = 6
const int	REG_EIP = 14
const int	REG_ESP = 7
const byte	INSTR::RET = 0xc3
int	samples_missing_framepointer = 0
int	samples_total = 0
stack_t	ss_area

---

Define Documentation

#define _POSIX_C_SOURCE   199309

Definition at line 3 of file SimpleProfiler.cc.

#define DODEBUG   if(0) std::cerr

Definition at line 68 of file SimpleProfiler.cc.

#define getBP

(

X

)

asm ( "movl %%ebp,%0" : "=m" (X) )

Definition at line 62 of file SimpleProfiler.cc.

Referenced by setStacktop().

#define getSP

(

X

)

asm ( "movl %%esp,%0" : "=m" (X) )

Definition at line 63 of file SimpleProfiler.cc.

#define MUST_BE_ZERO

(

fun

)

if((fun)!=0) { perror("function failed"); abort(); }

Definition at line 61 of file SimpleProfiler.cc.

Referenced by edm::disableAllSigs(), edm::disableRTSigs(), edm::disableSignal(), edm::enableSignal(), edm::installSig(), edm::reenableSigs(), setupTimer(), and edm::sigInventory().

---

Function Documentation

void @7703::closeCondFile

(

)

[static]

Definition at line 123 of file SimpleProfiler.cc.

Referenced by SimpleProfiler::~SimpleProfiler().

  {
    fclose(frame_cond);
  }

void @7703::dumpStack	(	const char *	msg,
		unsigned int *	esp,
		unsigned int *	ebp,
		unsigned char *	eip,
		ucontext_t *	ucp
	)			[static]

Definition at line 128 of file SimpleProfiler.cc.

References i.

  {
#if defined(__x86_64__) || defined(__LP64__) || defined(_LP64)
    throw std::logic_error("Cannot dumpStack on 64 bit build");
#else
    fprintf(frame_cond, msg);
    fflush(frame_cond);
    return;
    fprintf(frame_cond, "dumpStack:\n i= %x\n eip[0]= %2.2x\nb= %x\n s= %x\n b[0]= %x\n b[1]= %x\n b[2]= %x\n",
            (void*)eip, eip[0], (void*)ebp, (void*)esp, (void*)(ebp[0]), (void*)(ebp[1]), (void*)(ebp[2]));
    fflush(frame_cond);


#if 0
    unsigned int* spp = esp;
    for(int i=15;i>-5;--i)
      {
        fprintf(frame_cond, "    %x esp[%d]= %x\n", (void*)(spp+i), i, (void*)*(spp+i));
        fflush(frame_cond);
      }
#else
    while(ucp->uc_link)
      {
        fprintf(frame_cond, "   %8.8x\n",ucp->uc_link);
        ucp = ucp->uc_link;
      }
#endif
#endif
  }

std::string @7703::makeFileName

(

)

[static]

Definition at line 48 of file SimpleProfiler.cc.

References p.

Referenced by SimpleProfiler::complete(), and openCondFile().

  {
    pid_t p = getpid();
    std::ostringstream ost;
    ost << "profdata_" << p;
    return ost.str();
  }

void @7703::openCondFile

(

)

[static]

Definition at line 106 of file SimpleProfiler.cc.

References TestMuL1L2Filter_cff::cerr, EgammaValidation_cff::filename, and makeFileName().

Referenced by SimpleProfiler::SimpleProfiler().

  {
    std::string filename(makeFileName());
    filename += "_condfile";
    frame_cond = fopen(filename.c_str(),"w");
    if(frame_cond==0)
      {
        std::cerr << "bad open of profdata_condfile\n";
        throw std::runtime_error("bad open");
      }
  }

void* @7703::setStacktop

(

)

[static]

Definition at line 358 of file SimpleProfiler.cc.

References TestMuL1L2Filter_cff::cerr, getBP, and i.

  {
#if defined(__x86_64__) || defined(__LP64__) || defined(_LP64)
    throw std::logic_error("setStacktop not callable on 64 bit platform");
    return 0;
#else
    const std::string target_name("__libc_start_main");
    unsigned int* ebp_reg;
    getBP(ebp_reg);
    unsigned int* ebp = (unsigned int*)(ebp_reg);
    unsigned int* top = (unsigned int*)(ebp);

    void* address_of_target = 0;
    const int max_stackdepth=30;
    void* sta[max_stackdepth];

    int depth = backtrace(sta, max_stackdepth);
    int cnt = depth;
    if (depth > 1) depth-=1;

    // find function one below main()
    Dl_info look;
    for (int i=0; i<cnt && !address_of_target; ++i)
      {
        if(dladdr(sta[i],&look)!=0)
          {
            if (look.dli_saddr && target_name==look.dli_sname)
              {
                address_of_target = sta[i];
              }
          }
        else
          {
            // This isn't really an error; it just means the function
            // was not found by the dynamic loader. The function might
            // be one that is declared 'static', and is thus not
            // visible outside of its compilation unit.
            std::cerr << "setStacktop: no function information for " 
                      << sta[i] 
                      << "\n";
          }
      }

    if (address_of_target == 0)
      throw std::runtime_error("no main function found in stack");

    //fprintf(stderr,"depth=%d top=%8.8x\n",depth,top);

    // Now we walk toward the beginning of the stack until we find the
    // frame that is holding the return address of our target function.

    // depth is how many more frames there are to look at in the stack.
    // top is the frame we are currently looking at.
    // top+1 is the address to which the current frame will return.
    while (depth>0 && (void*)*(top+1) != address_of_target)
      {
        //fprintf(stderr,"depth=%d top=%8.8x func=%8.8x\n",depth,top,*(top+1));
        if (top<(unsigned int*)0x10) fprintf(stderr,"problem\n");
        top=(unsigned int*)(*top);
        --depth;
      };

    if (depth==0) 
      throw std::runtime_error("setStacktop: could not find stack bottom");

    // Now we have to move one frame more, to the frame of the target
    // function. We want the location in memory of this frame (not any
    // address stored in the frame, but the address of the frame
    // itself).
    top=(unsigned int*)(*top);

    return top;
#endif
  }

void @7703::setupTimer

(

)

[static]

Definition at line 433 of file SimpleProfiler.cc.

References TestMuL1L2Filter_cff::cerr, MUST_BE_ZERO, NULL, funct::num(), SA_SIGINFO, sigaction, sigaddset, sigdelset, sigfillset, and sigFunc().

  {
#if USE_SIGALTSTACK
    static vector<char> charbuffer(SIGSTKSZ);
    //ss_area.ss_sp = new char[SIGSTKSZ];
    ss_area.ss_sp = &charbuffer[0];
    ss_area.ss_flags = 0;
    ss_area.ss_size = SIGSTKSZ;
#endif
    //static int is_set = 0;
    //if(is_set!=1) { ++is_set; return; }
    //else ++is_set;

    sigset_t myset,oldset;
    // all blocked for now
    MUST_BE_ZERO(sigfillset(&myset));
    MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,&myset,&oldset));

#if defined(__x86_64__) || defined(__LP64__) || defined(_LP64)
    // ignore all the RT signals
    struct sigaction tmpact;
    memset(&tmpact,0,sizeof(tmpact));
    tmpact.sa_handler = SIG_IGN;

    for(int num=SIGRTMIN;num<SIGRTMAX;++num)
      {
        MUST_BE_ZERO(sigaddset(&oldset,num));
        MUST_BE_ZERO(sigaction(num,&tmpact,NULL));
      }
#endif

#if USE_SIGALTSTACK
    if(sigaltstack(&ss_area,0)!=0)
      {
        perror("sigaltstack failed for profile timer interrupt");
        abort();
      }
#endif

    // set up my RT signal now
    struct sigaction act;
    memset(&act,0,sizeof(act));
    act.sa_sigaction = sigFunc;
    act.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;

    // get my signal number
    int mysig = SIGPROF;

    if(sigaction(mysig,&act,NULL)!=0)
      {
        perror("sigaction failed");
        abort();
      }

    // Turn off handling of SIGSEGV signal
    memset(&act,0,sizeof(act));
    act.sa_handler = SIG_DFL;

    if (sigaction(SIGSEGV, &act, NULL) != 0)
      {
        perror("sigaction failed");
        abort();
      }

    struct rlimit limits;
    if (getrlimit(RLIMIT_CORE, &limits) != 0)
      {
        perror("getrlimit failed");
        abort();
      }
    std::cerr << "core size limit (soft): " << limits.rlim_cur << '\n';
    std::cerr << "core size limit (hard): " << limits.rlim_max << '\n';

    struct itimerval newval;
    struct itimerval oldval;

    newval.it_interval.tv_sec  = 0;
    newval.it_interval.tv_usec = 10000;
    newval.it_value.tv_sec  = 0;
    newval.it_value.tv_usec = 10000;

    if(setitimer(ITIMER_PROF,&newval,&oldval)!=0)
      {
        perror("setitimer failed");
        abort();
      }

    // reenable the signals, including my interval timer
    MUST_BE_ZERO(sigdelset(&oldset,mysig));
    MUST_BE_ZERO(pthread_sigmask(SIG_SETMASK,&oldset,0));
  }

void @7703::setupTimer

(

)

[static]

Referenced by SimpleProfiler::start().

void sigFunc	(	int	sig,
		siginfo_t *	info,
		void *	context
	)

Definition at line 335 of file SimpleProfiler.cc.

References SimpleProfiler::commitFrame(), SimpleProfiler::instance(), stacktrace(), SimpleProfiler::tempStack(), and SimpleProfiler::tempStackSize().

Referenced by setupTimer().

  {
    SimpleProfiler* prof = SimpleProfiler::instance();
    void** arr = prof->tempStack();
    int nmax =   prof->tempStackSize();
    int stackdepth = stacktrace(arr, nmax);

    assert(stackdepth <= nmax);

    // We don't want the first three entries, because they always
    // contain information about the how the signal handler was
    // called, the signal handler, and the stacktrace function.
    prof->commitFrame(arr+3, arr + stackdepth);
  }

int stacktrace	(	void *	addresses[],
		int	nmax
	)

Definition at line 217 of file SimpleProfiler.cc.

References if(), info, REG_EBP, REG_EIP, samples_missing_framepointer, and samples_total.

Referenced by sigFunc().

{
  ++samples_total;
#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 *) &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.
              ++samples_missing_framepointer;
            }
        }

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

  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
}

void @7703::write_maps

(

)

[static]

Definition at line 90 of file SimpleProfiler.cc.

References iggi_31X_cfg::input, parsecf::pyparsing::line(), and output().

Referenced by SimpleProfiler::complete().

  {
    pid_t pid = getpid();
    std::ostringstream strinput,stroutput;
    strinput << "/proc/" << pid << "/maps";
    stroutput << "profdata_" << pid << "_maps";
    std::ifstream input(strinput.str().c_str());
    std::ofstream output(stroutput.str().c_str());
    std::string line;
    while (getline(input, line)) output << line << '\n';
    input.close();
    output.close();
  }

void @7703::writeCond

(

int

code

)

[static]

Definition at line 118 of file SimpleProfiler.cc.

  {
    fwrite(&code,sizeof(int),1,frame_cond);
  }

---

Variable Documentation

FILE* frame_cond = 0 [static]

Definition at line 104 of file SimpleProfiler.cc.

AdjustSigs global_adjust [static]

Definition at line 553 of file SimpleProfiler.cc.

const int REG_EBP = 6

Definition at line 75 of file SimpleProfiler.cc.

Referenced by stacktrace(), and IgHookTrace::stacktrace().

const int REG_EIP = 14

Definition at line 74 of file SimpleProfiler.cc.

Referenced by stacktrace(), and IgHookTrace::stacktrace().

const int REG_ESP = 7

Definition at line 76 of file SimpleProfiler.cc.

int samples_missing_framepointer = 0 [static]

Definition at line 165 of file SimpleProfiler.cc.

Referenced by SimpleProfiler::complete(), and stacktrace().

int samples_total = 0 [static]

Definition at line 164 of file SimpleProfiler.cc.

Referenced by SimpleProfiler::complete(), and stacktrace().

stack_t ss_area [static]

Definition at line 354 of file SimpleProfiler.cc.

---