X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fdebug.cpp;h=8647160b1bed7c20cae3dae6e035bfc23bef521e;hb=5a2431a9bd9a019a47cd279ac988435b075cdabe;hp=a19186232a5b8d6e735b2db172ff5c7044135b0d;hpb=7cfb71385d00d1cbbbfd9c76f6c01adafa9e648a;p=minetest.git diff --git a/src/debug.cpp b/src/debug.cpp index a19186232..8647160b1 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -1,82 +1,80 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola 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 +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include "porting.h" #include "debug.h" +#include "exceptions.h" +#include "threads.h" #include #include +#include +#include +#include +#include "threading/mutex.h" +#include "threading/mutex_auto_lock.h" +#include "config.h" + +#ifdef _MSC_VER + #include + #include "version.h" + #include "filesys.h" +#endif + +#if USE_CURSES + #include "terminal_chat_console.h" +#endif /* - Debug output + Assert */ -FILE *g_debugstreams[DEBUGSTREAM_COUNT] = {stderr, NULL}; - -void debugstreams_init(bool disable_stderr, const char *filename) +void sanity_check_fn(const char *assertion, const char *file, + unsigned int line, const char *function) { - if(disable_stderr) - g_debugstreams[0] = NULL; - else - g_debugstreams[0] = stderr; - - if(filename) - g_debugstreams[1] = fopen(filename, "a"); - - if(g_debugstreams[1]) - { - fprintf(g_debugstreams[1], "\n\n-------------\n"); - fprintf(g_debugstreams[1], " Separator \n"); - fprintf(g_debugstreams[1], "-------------\n\n"); - } - - DEBUGPRINT("Debug streams initialized, disable_stderr=%d\n", - disable_stderr); -} +#if USE_CURSES + g_term_console.stopAndWaitforThread(); +#endif -void debugstreams_deinit() -{ - if(g_debugstreams[1] != NULL) - fclose(g_debugstreams[1]); -} + errorstream << std::endl << "In thread " << std::hex + << thr_get_current_thread_id() << ":" << std::endl; + errorstream << file << ":" << line << ": " << function + << ": An engine assumption '" << assertion << "' failed." << std::endl; -Debugbuf debugbuf(false); -std::ostream dstream(&debugbuf); -Debugbuf debugbuf_no_stderr(true); -std::ostream dstream_no_stderr(&debugbuf_no_stderr); -Nullstream dummyout; + debug_stacks_print_to(errorstream); -/* - Assert -*/ + abort(); +} -void assert_fail(const char *assertion, const char *file, +void fatal_error_fn(const char *msg, const char *file, unsigned int line, const char *function) { - DEBUGPRINT("\nIn thread %x:\n" - "%s:%d: %s: Assertion '%s' failed.\n", - (unsigned int)get_current_thread_id(), - file, line, function, assertion); - - debug_stacks_print(); +#if USE_CURSES + g_term_console.stopAndWaitforThread(); +#endif + + errorstream << std::endl << "In thread " << std::hex + << thr_get_current_thread_id() << ":" << std::endl; + errorstream << file << ":" << line << ": " << function + << ": A fatal error occured: " << msg << std::endl; - if(g_debugstreams[1]) - fclose(g_debugstreams[1]); + debug_stacks_print_to(errorstream); abort(); } @@ -85,6 +83,18 @@ void assert_fail(const char *assertion, const char *file, DebugStack */ +struct DebugStack +{ + DebugStack(threadid_t id); + void print(FILE *file, bool everything); + void print(std::ostream &os, bool everything); + + threadid_t threadid; + char stack[DEBUG_STACK_SIZE][DEBUG_STACK_TEXT_SIZE]; + int stack_i; // Points to the lowest empty position + int stack_max_i; // Highest i that was seen +}; + DebugStack::DebugStack(threadid_t id) { threadid = id; @@ -95,13 +105,15 @@ DebugStack::DebugStack(threadid_t id) void DebugStack::print(FILE *file, bool everything) { - fprintf(file, "DEBUG STACK FOR THREAD %x:\n", - (unsigned int)threadid); + std::ostringstream os; + os << threadid; + fprintf(file, "DEBUG STACK FOR THREAD %s:\n", + os.str().c_str()); for(int i=0; i g_debug_stacks; -JMutex g_debug_stacks_mutex; +// Note: Using pthread_t (that is, threadid_t on POSIX platforms) as the key to +// a std::map is naughty. Formally, a pthread_t may only be compared using +// pthread_equal() - pthread_t lacks the well-ordered property needed for +// comparisons in binary searches. This should be fixed at some point by +// defining a custom comparator with an arbitrary but stable ordering of +// pthread_t, but it isn't too important since none of our supported platforms +// implement pthread_t as a non-ordinal type. +std::map g_debug_stacks; +Mutex g_debug_stacks_mutex; void debug_stacks_init() { - g_debug_stacks_mutex.Init(); } -void debug_stacks_print() +void debug_stacks_print_to(std::ostream &os) { - JMutexAutoLock lock(g_debug_stacks_mutex); + MutexAutoLock lock(g_debug_stacks_mutex); - DEBUGPRINT("Debug stacks:\n"); + os<<"Debug stacks:"<::Iterator - i = g_debug_stacks.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = g_debug_stacks.begin(); + i != g_debug_stacks.end(); ++i) { - DebugStack *stack = i.getNode()->getValue(); - - for(int i=0; iprint(g_debugstreams[i], true); - } + i->second->print(os, false); } } +void debug_stacks_print() +{ + debug_stacks_print_to(errorstream); +} + DebugStacker::DebugStacker(const char *text) { - threadid_t threadid = get_current_thread_id(); + threadid_t threadid = thr_get_current_thread_id(); - JMutexAutoLock lock(g_debug_stacks_mutex); + MutexAutoLock lock(g_debug_stacks_mutex); - core::map::Node *n; + std::map::iterator n; n = g_debug_stacks.find(threadid); - if(n != NULL) + if(n != g_debug_stacks.end()) { - m_stack = n->getValue(); + m_stack = n->second; } else { /*DEBUGPRINT("Creating new debug stack for thread %x\n", (unsigned int)threadid);*/ m_stack = new DebugStack(threadid); - g_debug_stacks.insert(threadid, m_stack); + g_debug_stacks[threadid] = m_stack; } if(m_stack->stack_i >= DEBUG_STACK_SIZE) @@ -180,11 +215,11 @@ DebugStacker::DebugStacker(const char *text) DebugStacker::~DebugStacker() { - JMutexAutoLock lock(g_debug_stacks_mutex); - + MutexAutoLock lock(g_debug_stacks_mutex); + if(m_overflowed == true) return; - + m_stack->stack_i--; if(m_stack->stack_i == 0) @@ -193,39 +228,128 @@ DebugStacker::~DebugStacker() /*DEBUGPRINT("Deleting debug stack for thread %x\n", (unsigned int)threadid);*/ delete m_stack; - g_debug_stacks.remove(threadid); + g_debug_stacks.erase(threadid); } } - #ifdef _MSC_VER -#if CATCH_UNHANDLED_EXCEPTIONS == 1 -void se_trans_func(unsigned int u, EXCEPTION_POINTERS* pExp) + +const char *Win32ExceptionCodeToString(DWORD exception_code) { - dstream<<"In trans_func.\n"; - if(u == EXCEPTION_ACCESS_VIOLATION) - { - PEXCEPTION_RECORD r = pExp->ExceptionRecord; - dstream<<"Access violation at "<ExceptionAddress - <<" write?="<ExceptionInformation[0] - <<" address="<ExceptionInformation[1] - <ExceptionRecord->ExceptionCode; + _snprintf(buf, sizeof(buf), + " >> === FATAL ERROR ===\n" + " >> %s (Exception 0x%08X) at 0x%p\n", + Win32ExceptionCodeToString(excode), excode, + pExceptInfo->ExceptionRecord->ExceptionAddress); + dstream << buf; + + if (minidump_created) + dstream << " >> Saved dump to " << dumpfile << std::endl; + else + dstream << " >> Failed to save dump" << std::endl; + + return EXCEPTION_EXECUTE_HANDLER; +} + +#endif + +void debug_set_exception_handler() +{ +#ifdef _MSC_VER + SetUnhandledExceptionFilter(Win32ExceptionHandler); +#endif +}