Glenn Maynard
350 lines
8.1 KiB
C++
350 lines
8.1 KiB
C++
#include "global.h"
|
|
#include "Backtrace.h"
|
|
#include "RageUtil.h"
|
|
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/ptrace.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
|
|
#if defined(BACKTRACE_METHOD_X86_LINUX)
|
|
#include "LinuxThreadHelpers.h"
|
|
|
|
void GetCurrentBacktraceContext( BacktraceContext *ctx )
|
|
{
|
|
register void *esp __asm__ ("esp");
|
|
ctx->esp = (long) esp;
|
|
ctx->eip = (long) GetThreadBacktraceContext;
|
|
ctx->ebp = (long) __builtin_frame_address(0);
|
|
}
|
|
|
|
int GetThreadBacktraceContext( int ThreadID, BacktraceContext *ctx )
|
|
{
|
|
ctx->pid = ThreadID;
|
|
|
|
if( ThreadID != GetCurrentThreadId() )
|
|
return GetThreadContext( ThreadID, ctx );
|
|
|
|
GetCurrentBacktraceContext( ctx );
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const char *itoa(unsigned n)
|
|
{
|
|
static char ret[32];
|
|
char *p = ret;
|
|
for( int div = 1000000000; div > 0; div /= 10 )
|
|
{
|
|
*p++ = (n / div) + '0';
|
|
n %= div;
|
|
}
|
|
*p = 0;
|
|
p = ret;
|
|
while( p[0] == '0' && p[1] )
|
|
++p;
|
|
return p;
|
|
}
|
|
|
|
static int xtoi( const char *hex )
|
|
{
|
|
int ret = 0;
|
|
while( 1 )
|
|
{
|
|
int val = -1;
|
|
if( *hex >= '0' && *hex <= '9' )
|
|
val = *hex - '0';
|
|
else if( *hex >= 'A' && *hex <= 'F' )
|
|
val = *hex - 'A' + 10;
|
|
else if( *hex >= 'a' && *hex <= 'f' )
|
|
val = *hex - 'a' + 10;
|
|
else
|
|
break;
|
|
hex++;
|
|
|
|
ret *= 16;
|
|
ret += val;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
enum { READABLE_ONLY=1, EXECUTABLE_ONLY=2 };
|
|
static int get_readable_ranges( const void **starts, const void **ends, int size, int type=READABLE_ONLY )
|
|
{
|
|
char path[PATH_MAX] = "/proc/";
|
|
strcat( path, itoa(getpid()) );
|
|
strcat( path, "/maps" );
|
|
|
|
int fd = open(path, O_RDONLY);
|
|
if( fd == -1 )
|
|
return false;
|
|
|
|
/* Format:
|
|
*
|
|
* 402dd000-402de000 rw-p 00010000 03:03 16815669 /lib/libnsl-2.3.1.so
|
|
* or
|
|
* bfffb000-c0000000 rwxp ffffc000 00:00 0
|
|
*
|
|
* Look for the range that includes the stack pointer. */
|
|
char file[1024];
|
|
int file_used = 0;
|
|
bool eof = false;
|
|
int got = 0;
|
|
while( !eof && got < size-1 )
|
|
{
|
|
int ret = read( fd, file+file_used, sizeof(file) - file_used);
|
|
if( ret < int(sizeof(file)) - file_used)
|
|
eof = true;
|
|
|
|
file_used += ret;
|
|
|
|
/* Parse lines. */
|
|
while( got < size )
|
|
{
|
|
char *p = (char *) memchr( file, '\n', file_used );
|
|
if( p == NULL )
|
|
break;
|
|
*p++ = 0;
|
|
|
|
char line[1024];
|
|
strcpy( line, file );
|
|
memmove(file, p, file_used);
|
|
file_used -= p-file;
|
|
|
|
/* Search for the hyphen. */
|
|
char *hyphen = strchr( line, '-' );
|
|
if( hyphen == NULL )
|
|
continue; /* Parse error. */
|
|
|
|
|
|
/* Search for the space. */
|
|
char *space = strchr( hyphen, ' ' );
|
|
if( space == NULL )
|
|
continue; /* Parse error. */
|
|
|
|
/* " rwxp". If space[1] isn't 'r', then the block isn't readable. */
|
|
if( type & READABLE_ONLY )
|
|
if( strlen(space) < 2 || space[1] != 'r' )
|
|
continue;
|
|
/* " rwxp". If space[3] isn't 'x', then the block isn't readable. */
|
|
if( type & EXECUTABLE_ONLY )
|
|
if( strlen(space) < 4 || space[3] != 'x' )
|
|
continue;
|
|
|
|
*starts++ = (const void *) xtoi( line );
|
|
*ends++ = (const void *) xtoi( hyphen+1 );
|
|
++got;
|
|
}
|
|
|
|
if( file_used == sizeof(file) )
|
|
{
|
|
/* Line longer than the buffer. Weird; bail. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
close(fd);
|
|
|
|
*starts++ = NULL;
|
|
*ends++ = NULL;
|
|
|
|
return got;
|
|
}
|
|
|
|
/* If the address is readable (eg. reading it won't cause a segfault), return
|
|
* the block it's in. Otherwise, return -1. */
|
|
static int find_address( const void *p, const void **starts, const void **ends )
|
|
{
|
|
for( int i = 0; starts[i]; ++i )
|
|
{
|
|
/* Found it. */
|
|
if( starts[i] <= p && p < ends[i] )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void *SavedStackPointer = NULL;
|
|
|
|
void InitializeBacktrace()
|
|
{
|
|
static bool bInitialized = false;
|
|
if( bInitialized )
|
|
return;
|
|
bInitialized = true;
|
|
|
|
/* We might have a different stack in the signal handler. Record a pointer
|
|
* that lies in the real stack, so we can look it up later. */
|
|
register void *esp __asm__ ("esp");
|
|
SavedStackPointer = esp;
|
|
}
|
|
|
|
/* backtrace() for x86 Linux, tested with kernel 2.4.18, glibc 2.3.1. */
|
|
static void do_backtrace( const void **buf, size_t size, BacktraceContext *ctx )
|
|
{
|
|
/* Read /proc/pid/maps to find the address range of the stack. */
|
|
const void *readable_begin[1024], *readable_end[1024];
|
|
get_readable_ranges( readable_begin, readable_end, 1024 );
|
|
|
|
/* Find the stack memory blocks. */
|
|
const int stack_block1 = find_address( (void *) ctx->esp, readable_begin, readable_end );
|
|
const int stack_block2 = find_address( SavedStackPointer, readable_begin, readable_end );
|
|
|
|
/* This matches the layout of the stack. The frame pointer makes the
|
|
* stack a linked list. */
|
|
struct StackFrame
|
|
{
|
|
StackFrame *link;
|
|
char *return_address;
|
|
|
|
/* These are only relevant if the frame is a signal trampoline. */
|
|
int signal;
|
|
sigcontext sig;
|
|
};
|
|
|
|
StackFrame *frame = (StackFrame *) ctx->ebp;
|
|
|
|
unsigned i=0;
|
|
if( i < size-1 ) // -1 for NULL
|
|
buf[i++] = (void *) ctx->eip;
|
|
|
|
while( i < size-1 ) // -1 for NULL
|
|
{
|
|
/* Make sure that this frame address is readable, and is on the stack. */
|
|
int val = find_address(frame, readable_begin, readable_end);
|
|
if( val == -1 )
|
|
break;
|
|
if( val != stack_block1 && val != stack_block2 )
|
|
break;
|
|
|
|
/* XXX */
|
|
//if( frame->return_address == (void*) CrashSignalHandler )
|
|
// continue;
|
|
|
|
/*
|
|
* The stack return stub is:
|
|
*
|
|
* 0x401139d8 <sigaction+280>: pop %eax 0x58
|
|
* 0x401139d9 <sigaction+281>: mov $0x77,%eax 0xb8 0x77 0x00 0x00 0x00
|
|
* 0x401139de <sigaction+286>: int $0x80 0xcd 0x80
|
|
*
|
|
* This will be different if using realtime signals, as will the stack layout.
|
|
*
|
|
* If we detect this, it means this is a stack frame returning from a signal.
|
|
* Ignore the return_address and use the sigcontext instead.
|
|
*/
|
|
const char comp[] = { 0x58, 0xb8, 0x77, 0x0, 0x0, 0x0, 0xcd, 0x80 };
|
|
bool is_signal_return = true;
|
|
|
|
/* Ugh. Linux 2.6 is putting the return address in a place that isn't listed
|
|
* as readable in /proc/pid/maps. This is probably brittle. */
|
|
if( frame->return_address != (void*)0xffffe420 &&
|
|
find_address(frame->return_address, readable_begin, readable_end) == -1)
|
|
is_signal_return = false;
|
|
|
|
for( unsigned pos = 0; is_signal_return && pos < sizeof(comp); ++pos )
|
|
if(frame->return_address[pos] != comp[pos])
|
|
is_signal_return = false;
|
|
|
|
void *to_add = NULL;
|
|
if( is_signal_return )
|
|
{
|
|
/* Mark the signal trampoline. */
|
|
if( i < size-1 )
|
|
buf[i++] = BACKTRACE_SIGNAL_TRAMPOLINE;
|
|
|
|
to_add = (void *) frame->sig.eip;
|
|
}
|
|
else
|
|
to_add = frame->return_address;
|
|
|
|
if( i < size-1 && to_add )
|
|
buf[i++] = to_add;
|
|
|
|
/* frame always goes down. Make sure it doesn't go up; that could
|
|
* cause an infinite loop. */
|
|
if( frame->link <= frame )
|
|
break;
|
|
|
|
frame = frame->link;
|
|
}
|
|
|
|
buf[i] = NULL;
|
|
}
|
|
|
|
void GetBacktrace( const void **buf, size_t size, BacktraceContext *ctx )
|
|
{
|
|
InitializeBacktrace();
|
|
|
|
BacktraceContext CurrentCtx;
|
|
if( ctx == NULL )
|
|
{
|
|
ctx = &CurrentCtx;
|
|
GetCurrentBacktraceContext( &CurrentCtx );
|
|
}
|
|
|
|
|
|
do_backtrace( buf, size, ctx );
|
|
}
|
|
#elif defined(BACKTRACE_METHOD_BACKTRACE)
|
|
#include <execinfo.h>
|
|
|
|
void InitializeBacktrace() { }
|
|
|
|
void GetBacktrace( const void **buf, size_t size, BacktraceContext *ctx )
|
|
{
|
|
InitializeBacktrace();
|
|
|
|
int retsize = backtrace( buf, size-1 );
|
|
|
|
/* Remove any NULL entries. We want to null-terminate the list, and null entries are useless. */
|
|
for( int i = retsize-1; i >= 0; --i )
|
|
{
|
|
if( buf[i] != NULL )
|
|
continue;
|
|
|
|
memmove( &buf[i], &buf[i]+1, retsize-i-1 );
|
|
}
|
|
|
|
buf[retsize] = NULL;
|
|
}
|
|
#elif defined(BACKTRACE_METHOD_POWERPC_DARWIN)
|
|
|
|
#include "archutils/Darwin/Crash.h"
|
|
typedef struct Frame {
|
|
Frame *stackPointer;
|
|
long conditionReg;
|
|
void *linkReg;
|
|
} *FramePtr;
|
|
|
|
void InitializeBacktrace() { }
|
|
|
|
void GetBacktrace( const void **buf, size_t size, BacktraceContext *ctx )
|
|
{
|
|
FramePtr frame = FramePtr(GetCrashedFramePtr());
|
|
unsigned i;
|
|
for (i=0; frame && frame->linkReg && i<size; ++i, frame=frame->stackPointer)
|
|
buf[i] = frame->linkReg;
|
|
i = (i == size ? size - 1 : i);
|
|
buf[i] = NULL;
|
|
}
|
|
|
|
#else
|
|
|
|
#warning Undefined BACKTRACE_METHOD_*
|
|
void InitializeBacktrace() { }
|
|
|
|
void GetBacktrace( const void **buf, size_t size, BacktraceContext *ctx )
|
|
{
|
|
buf[0] = BACKTRACE_METHOD_NOT_AVAILABLE;
|
|
buf[1] = NULL;
|
|
}
|
|
|
|
#endif
|
|
|