janwas
ed5041a301
squelch debug asserts during self-tests to avoid warning about intended errors (passing invalid data into functions to test their error reporting) This was SVN commit r2646.
518 lines
14 KiB
C++
518 lines
14 KiB
C++
// platform-independent debug code
|
|
// Copyright (c) 2005 Jan Wassenberg
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// General Public License for more details.
|
|
//
|
|
// Contact info:
|
|
// Jan.Wassenberg@stud.uni-karlsruhe.de
|
|
// http://www.stud.uni-karlsruhe.de/~urkt/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#include "lib.h"
|
|
#include "debug.h"
|
|
#include "debug_stl.h"
|
|
#include "posix.h"
|
|
#include "nommgr.h"
|
|
// some functions here are called from within mmgr; disable its hooks
|
|
// so that our allocations don't cause infinite recursion.
|
|
#include "self_test.h"
|
|
|
|
// needed when writing crashlog
|
|
static const size_t LOG_CHARS = 16384;
|
|
wchar_t debug_log[LOG_CHARS];
|
|
wchar_t* debug_log_pos = debug_log;
|
|
|
|
// write to memory buffer (fast)
|
|
void debug_wprintf_mem(const wchar_t* fmt, ...)
|
|
{
|
|
const ssize_t chars_left = (ssize_t)LOG_CHARS - (debug_log_pos-debug_log);
|
|
debug_assert(chars_left >= 0);
|
|
|
|
// potentially not enough room for the new string; throw away the
|
|
// older half of the log. we still protect against overflow below.
|
|
if(chars_left < 512)
|
|
{
|
|
const size_t copy_size = sizeof(wchar_t) * LOG_CHARS/2;
|
|
wchar_t* const middle = &debug_log[LOG_CHARS/2];
|
|
memcpy(debug_log, middle, copy_size);
|
|
memset(middle, 0, copy_size);
|
|
debug_log_pos -= LOG_CHARS/2; // don't assign middle (may leave gap)
|
|
}
|
|
|
|
// write into buffer (in-place)
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
int len = vswprintf(debug_log_pos, chars_left-2, fmt, args);
|
|
va_end(args);
|
|
if(len < 0)
|
|
{
|
|
debug_warn("debug_wprintf_mem: vswprintf failed");
|
|
return;
|
|
}
|
|
debug_log_pos += len+2;
|
|
wcscpy(debug_log_pos-2, L"\r\n"); // safe
|
|
}
|
|
|
|
|
|
|
|
|
|
// convert contents of file <in_filename> from char to wchar_t and
|
|
// append to <out> file. used by debug_write_crashlog.
|
|
static void cat_atow(FILE* out, const char* in_filename)
|
|
{
|
|
FILE* in = fopen(in_filename, "rb");
|
|
if(!in)
|
|
{
|
|
fwprintf(out, L"(unavailable)");
|
|
return;
|
|
}
|
|
|
|
const size_t buf_size = 1024;
|
|
char buf[buf_size+1]; // include space for trailing '\0'
|
|
|
|
while(!feof(in))
|
|
{
|
|
size_t bytes_read = fread(buf, 1,buf_size, in);
|
|
if(!bytes_read)
|
|
break;
|
|
buf[bytes_read] = 0; // 0-terminate
|
|
fwprintf(out, L"%hs", buf);
|
|
}
|
|
|
|
fclose(in);
|
|
}
|
|
|
|
|
|
int debug_write_crashlog(const wchar_t* text)
|
|
{
|
|
const wchar_t divider[] = L"\n\n====================================\n\n";
|
|
#define WRITE_DIVIDER fwprintf(f, divider);
|
|
|
|
FILE* f = fopen("crashlog.txt", "w");
|
|
if(!f)
|
|
return -1;
|
|
|
|
fputwc(0xfeff, f); // BOM
|
|
|
|
fwprintf(f, L"%s\n", text);
|
|
WRITE_DIVIDER
|
|
|
|
|
|
// for user convenience, bundle all logs into this file:
|
|
|
|
fwprintf(f, L"System info:\n\n");
|
|
cat_atow(f, "../logs/system_info.txt");
|
|
WRITE_DIVIDER
|
|
|
|
fwprintf(f, L"Main log:\n\n");
|
|
cat_atow(f, "../logs/mainlog.html");
|
|
WRITE_DIVIDER
|
|
|
|
fwprintf(f, L"Last known activity:\n\n %s\n", debug_log);
|
|
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// storage for and construction of strings describing a symbol
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
// tightly pack strings within one large buffer. we never need to free them,
|
|
// since the program structure / addresses can never change.
|
|
static const size_t STRING_BUF_SIZE = 64*KiB;
|
|
static char* string_buf;
|
|
static char* string_buf_pos;
|
|
|
|
static const char* symbol_string_build(void* symbol, const char* name, const char* file, int line)
|
|
{
|
|
// maximum bytes allowed per string (arbitrary).
|
|
// needed to prevent possible overflows.
|
|
const size_t STRING_MAX = 1000;
|
|
|
|
if(!string_buf)
|
|
{
|
|
string_buf = (char*)malloc(STRING_BUF_SIZE);
|
|
if(!string_buf)
|
|
{
|
|
debug_warn("failed to allocate string_buf");
|
|
return 0;
|
|
}
|
|
string_buf_pos = string_buf;
|
|
}
|
|
|
|
// make sure there's enough space for a new string
|
|
char* string = string_buf_pos;
|
|
if(string + STRING_MAX >= string_buf + STRING_BUF_SIZE)
|
|
{
|
|
debug_warn("increase STRING_BUF_SIZE");
|
|
return 0;
|
|
}
|
|
|
|
// user didn't know name/file/line. attempt to resolve from debug info.
|
|
char name_buf[DBG_SYMBOL_LEN];
|
|
char file_buf[DBG_FILE_LEN];
|
|
if(!name || !file || !line)
|
|
{
|
|
int line_buf;
|
|
(void)debug_resolve_symbol(symbol, name_buf, file_buf, &line_buf);
|
|
|
|
// only override the original parameters if value is meaningful;
|
|
// otherwise, stick with what we got, even if 0.
|
|
// (obviates test of return value; correctly handles partial failure).
|
|
if(name_buf[0])
|
|
name = name_buf;
|
|
if(file_buf[0])
|
|
file = file_buf;
|
|
if(line_buf)
|
|
line = line_buf;
|
|
}
|
|
|
|
// file and line are available: write them
|
|
int len;
|
|
if(file && line)
|
|
{
|
|
// strip path from filename (long and irrelevant)
|
|
const char* filename_only = file;
|
|
const char* slash = strrchr(file, DIR_SEP);
|
|
if(slash)
|
|
filename_only = slash+1;
|
|
|
|
len = snprintf(string, STRING_MAX-1, "%s:%05d ", filename_only, line);
|
|
}
|
|
// only address is known
|
|
else
|
|
len = snprintf(string, STRING_MAX-1, "%p ", symbol);
|
|
|
|
// append symbol name
|
|
if(name)
|
|
{
|
|
snprintf(string+len, STRING_MAX-1-len, "%s", name);
|
|
stl_simplify_name(string+len);
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// cache, mapping symbol address to its description string.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
// note: we don't want to allocate a new string for every symbol -
|
|
// that would waste lots of memory. instead, when a new address is first
|
|
// encountered, allocate a string describing it, and store for later use.
|
|
|
|
// hash table entry; valid iff symbol != 0. the string pointer must remain
|
|
// valid until the cache is shut down.
|
|
struct Symbol
|
|
{
|
|
void* symbol;
|
|
const char* string;
|
|
};
|
|
|
|
static const uint MAX_SYMBOLS = 2048;
|
|
static Symbol* symbols;
|
|
static uint total_symbols;
|
|
|
|
|
|
static uint hash_jumps;
|
|
|
|
// strip off lower 2 bits, since it's unlikely that 2 symbols are
|
|
// within 4 bytes of one another.
|
|
static uint hash(void* symbol)
|
|
{
|
|
const uintptr_t address = (uintptr_t)symbol;
|
|
return (uint)( (address >> 2) % MAX_SYMBOLS );
|
|
}
|
|
|
|
|
|
// algorithm: hash lookup with linear probing.
|
|
static const char* symbol_string_from_cache(void* symbol)
|
|
{
|
|
// hash table not initialized yet, nothing to find
|
|
if(!symbols)
|
|
return 0;
|
|
|
|
uint idx = hash(symbol);
|
|
for(;;)
|
|
{
|
|
Symbol* c = &symbols[idx];
|
|
|
|
// not in table
|
|
if(!c->symbol)
|
|
return 0;
|
|
// found
|
|
if(c->symbol == symbol)
|
|
return c->string;
|
|
|
|
idx = (idx+1) % MAX_SYMBOLS;
|
|
}
|
|
}
|
|
|
|
|
|
// associate <string> (must remain valid) with <symbol>, for
|
|
// later calls to symbol_string_from_cache.
|
|
static void symbol_string_add_to_cache(const char* string, void* symbol)
|
|
{
|
|
if(!symbols)
|
|
{
|
|
// note: must be zeroed to set each Symbol to "invalid"
|
|
symbols = (Symbol*)calloc(MAX_SYMBOLS, sizeof(Symbol));
|
|
if(!symbols)
|
|
debug_warn("failed to allocate symbols");
|
|
}
|
|
|
|
// hash table is completely full (guard against infinite loop below).
|
|
// if this happens, the string won't be cached - nothing serious.
|
|
if(total_symbols >= MAX_SYMBOLS)
|
|
{
|
|
debug_warn("increase MAX_SYMBOLS");
|
|
return;
|
|
}
|
|
total_symbols++;
|
|
|
|
// find Symbol slot in hash table
|
|
Symbol* c;
|
|
uint idx = hash(symbol);
|
|
for(;;)
|
|
{
|
|
c = &symbols[idx];
|
|
|
|
// found an empty slot
|
|
if(!c->symbol)
|
|
break;
|
|
|
|
idx = (idx+1) % MAX_SYMBOLS;
|
|
hash_jumps++;
|
|
}
|
|
|
|
// commit Symbol information
|
|
c->symbol = symbol;
|
|
c->string = string;
|
|
|
|
string_buf_pos += strlen(string)+1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* debug_get_symbol_string(void* symbol, const char* name, const char* file, int line)
|
|
{
|
|
// return it if already in cache
|
|
const char* string = symbol_string_from_cache(symbol);
|
|
if(string)
|
|
return string;
|
|
|
|
// try to build a new string
|
|
string = symbol_string_build(symbol, name, file, line);
|
|
if(!string)
|
|
return 0;
|
|
|
|
symbol_string_add_to_cache(string, symbol);
|
|
|
|
return string;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ErrorReaction display_error(const wchar_t* description, int flags,
|
|
uint skip, void* context, const char* file, int line)
|
|
{
|
|
if(!file || file[0] == '\0')
|
|
file = "unknown";
|
|
if(line <= 0)
|
|
line = 0;
|
|
|
|
// display in output window; double-click will navigate to error location.
|
|
const char* slash = strrchr(file, DIR_SEP);
|
|
const char* filename = slash? slash+1 : file;
|
|
debug_wprintf(L"%hs(%d): %s\n", filename, line, description);
|
|
|
|
// allocate memory for the stack trace. this needs to be quite large,
|
|
// so preallocating is undesirable. it must work even if the heap is
|
|
// corrupted (since that's an error we might want to display), so
|
|
// we cannot rely on the heap alloc alone. what we do is try malloc,
|
|
// fall back to alloca if it failed, and give up after that.
|
|
wchar_t* text = 0;
|
|
size_t max_chars = 256*KiB;
|
|
// .. try allocating from heap
|
|
void* heap_mem = malloc(max_chars*sizeof(wchar_t));
|
|
text = (wchar_t*)heap_mem;
|
|
// .. heap alloc failed; try allocating from stack
|
|
if(!text)
|
|
{
|
|
max_chars = 128*KiB; // (stack limit is usually 1 MiB)
|
|
text = (wchar_t*)alloca(max_chars*sizeof(wchar_t));
|
|
}
|
|
|
|
// alloc succeeded; proceed
|
|
if(text)
|
|
{
|
|
static const wchar_t fmt[] = L"%s\r\n\r\nCall stack:\r\n\r\n";
|
|
int len = swprintf(text, max_chars, fmt, description);
|
|
// paranoia - only dump stack if this string output succeeded.
|
|
if(len >= 0)
|
|
{
|
|
if(!context)
|
|
skip++; // skip this frame
|
|
debug_dump_stack(text+len, max_chars-len, skip, context);
|
|
}
|
|
}
|
|
else
|
|
text = L"(insufficient memory to display error message)";
|
|
|
|
debug_write_crashlog(text);
|
|
ErrorReaction er = display_error_impl(text, flags);
|
|
|
|
// note: debug_break-ing here to make sure the app doesn't continue
|
|
// running is no longer necessary. display_error now determines our
|
|
// window handle and is modal.
|
|
|
|
// handle "break" request unless the caller wants to (doing so here
|
|
// instead of within the dlgproc yields a correct call stack)
|
|
if(er == ER_BREAK && !(flags & DE_MANUAL_BREAK))
|
|
{
|
|
debug_break();
|
|
er = ER_CONTINUE;
|
|
}
|
|
|
|
free(heap_mem); // no-op if not allocated from heap
|
|
// after debug_break to ease debugging, but before exit to avoid leak.
|
|
|
|
// exit requested. do so here to disburden callers.
|
|
if(er == ER_EXIT)
|
|
{
|
|
// disable memory-leak reporting to avoid a flood of warnings
|
|
// (lots of stuff will leak since we exit abnormally).
|
|
debug_heap_enable(DEBUG_HEAP_NONE);
|
|
#if CONFIG_USE_MMGR
|
|
mmgr_set_options(0);
|
|
#endif
|
|
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
return er;
|
|
}
|
|
|
|
|
|
// notify the user that an assertion failed; displays a stack trace with
|
|
// local variables.
|
|
ErrorReaction debug_assert_failed(const char* file, int line, const char* expr)
|
|
{
|
|
// for edge cases in some functions, warnings (=asserts) are raised in
|
|
// addition to returning an error code. self-tests deliberately trigger
|
|
// these cases and check for the latter but shouldn't cause the former.
|
|
// we therefore squelch them here.
|
|
// (note: don't do so in lib.h's CHECK_ERR or debug_assert to reduce
|
|
// compile-time dependency on self_test.h)
|
|
if(self_test_active)
|
|
return ER_CONTINUE;
|
|
|
|
// __FILE__ evaluates to the full path (albeit without drive letter)
|
|
// which is rather long. we only display the base name for clarity.
|
|
const char* slash = strrchr(file, DIR_SEP);
|
|
const char* base_name = slash? slash+1 : file;
|
|
|
|
uint skip = 1; void* context = 0;
|
|
wchar_t buf[200];
|
|
swprintf(buf, ARRAY_SIZE(buf), L"Assertion failed in %hs, line %d: \"%hs\"", base_name, line, expr);
|
|
return display_error(buf, DE_ALLOW_SUPPRESS|DE_MANUAL_BREAK, skip, context, base_name, line);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// thread naming
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// when debugging multithreading problems, logging the currently running
|
|
// thread is helpful; a user-specified name is easier to remember than just
|
|
// the thread handle. to that end, we provide a robust TLS mechanism that is
|
|
// much safer than the previous method of hijacking TIB.pvArbitrary.
|
|
//
|
|
// note: on Win9x thread "IDs" are pointers to the TIB xor-ed with an
|
|
// obfuscation value calculated at boot-time.
|
|
//
|
|
// __declspec(thread) et al. are now available on VC and newer GCC but we
|
|
// implement TLS manually (via pthread_setspecific) to ensure compatibility.
|
|
|
|
static pthread_key_t tls_key;
|
|
static pthread_once_t tls_once = PTHREAD_ONCE_INIT;
|
|
|
|
|
|
// provided for completeness and to avoid displaying bogus resource leaks.
|
|
static void tls_shutdown()
|
|
{
|
|
WARN_ERR(pthread_key_delete(tls_key));
|
|
tls_key = 0;
|
|
}
|
|
|
|
|
|
// (called via pthread_once from debug_set_thread_name)
|
|
static void tls_init()
|
|
{
|
|
WARN_ERR(pthread_key_create(&tls_key, 0)); // no dtor
|
|
|
|
// note: do not use atexit; this may be called before _cinit.
|
|
}
|
|
|
|
|
|
|
|
|
|
// set the current thread's name; it will be returned by subsequent calls to
|
|
// debug_get_thread_name.
|
|
//
|
|
// the string pointed to by <name> MUST remain valid throughout the
|
|
// entire program; best to pass a string literal. allocating a copy
|
|
// would be quite a bit more work due to cleanup issues.
|
|
//
|
|
// if supported on this platform, the debugger is notified of the new name;
|
|
// it will be displayed there instead of just the handle.
|
|
void debug_set_thread_name(const char* name)
|
|
{
|
|
WARN_ERR(pthread_once(&tls_once, tls_init));
|
|
|
|
WARN_ERR(pthread_setspecific(tls_key, name));
|
|
|
|
wdbg_set_thread_name(name);
|
|
}
|
|
|
|
|
|
// return the pointer assigned by debug_set_thread_name or 0 if
|
|
// that hasn't been done yet for this thread.
|
|
const char* debug_get_thread_name()
|
|
{
|
|
return (const char*)pthread_getspecific(tls_key);
|
|
}
|
|
|
|
|
|
|
|
|
|
void debug_shutdown()
|
|
{
|
|
tls_shutdown();
|
|
}
|