X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fdebug.cpp;h=bdd4146cab253e9c57fcf1da3a5e867884c7478a;hb=a3441638c67c9a9f626d7542a53fef6340d42751;hp=2489413862615473166ad2bbe09ad9e8119364b2;hpb=4e249fb3fbf75f0359758760d88e22aa5b14533c;p=minetest.git diff --git a/src/debug.cpp b/src/debug.cpp index 248941386..bdd4146ca 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -1,72 +1,79 @@ /* -(c) 2010 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 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 Lesser General Public License for more details. + +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 -#include - -#ifdef _WIN32 - #define WIN32_LEAN_AND_MEAN - #include - #define sleep_ms(x) Sleep(x) -#else - #include - #define sleep_ms(x) usleep(x*1000) +#include "exceptions.h" +#include +#include +#include +#include +#include +#include +#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; - - 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"); - } -} +#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 + << std::this_thread::get_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 - if(g_debugstreams[1]) - fclose(g_debugstreams[1]); + errorstream << std::endl << "In thread " << std::hex + << std::this_thread::get_id() << ":" << std::endl; + errorstream << file << ":" << line << ": " << function + << ": A fatal error occured: " << msg << std::endl; - //sleep_ms(3000); + debug_stacks_print_to(errorstream); abort(); } @@ -75,115 +82,249 @@ void assert_fail(const char *assertion, const char *file, DebugStack */ -DebugStack::DebugStack(threadid_t id) +struct DebugStack { - threadid = id; + DebugStack(std::thread::id id); + void print(FILE *file, bool everything); + void print(std::ostream &os, bool everything); + + std::thread::id thread_id; + 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(std::thread::id id) +{ + thread_id = id; stack_i = 0; stack_max_i = 0; + memset(stack, 0, DEBUG_STACK_SIZE*DEBUG_STACK_TEXT_SIZE); } void DebugStack::print(FILE *file, bool everything) { - fprintf(file, "BEGIN STACK: Debug stack for thread %x:\n", - (unsigned int)threadid); - - for(int i=0; i g_debug_stacks; -JMutex g_debug_stacks_mutex; + for(int i = 0; i < stack_max_i; i++) { + if(i == stack_i && !everything) + break; -void debug_stacks_init() -{ - g_debug_stacks_mutex.Init(); + if (i < stack_i) + os<<"#"< g_debug_stacks; +std::mutex g_debug_stacks_mutex; - DEBUGPRINT("Debug stacks:\n"); +void debug_stacks_print_to(std::ostream &os) +{ + MutexAutoLock lock(g_debug_stacks_mutex); - for(core::map::Iterator - i = g_debug_stacks.getIterator(); - i.atEnd() == false; i++) - { - DebugStack *stack = i.getNode()->getValue(); + os<<"Debug stacks:"<print(g_debugstreams[i], true); - } + for (auto it : g_debug_stacks) { + it.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(); + std::thread::id thread_id = std::this_thread::get_id(); - JMutexAutoLock lock(g_debug_stacks_mutex); + MutexAutoLock lock(g_debug_stacks_mutex); - core::map::Node *n; - n = g_debug_stacks.find(threadid); - if(n != NULL) - { - m_stack = n->getValue(); - } - else - { + auto n = g_debug_stacks.find(thread_id); + if (n != g_debug_stacks.end()) { + 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); + (unsigned int)thread_id);*/ + m_stack = new DebugStack(thread_id); + g_debug_stacks[thread_id] = m_stack; } - if(m_stack->stack_i >= DEBUG_STACK_SIZE) - { + if (m_stack->stack_i >= DEBUG_STACK_SIZE) { m_overflowed = true; - } - else - { + } else { m_overflowed = false; snprintf(m_stack->stack[m_stack->stack_i], DEBUG_STACK_TEXT_SIZE, "%s", text); m_stack->stack_i++; - if(m_stack->stack_i > m_stack->stack_max_i) + if (m_stack->stack_i > m_stack->stack_max_i) m_stack->stack_max_i = m_stack->stack_i; } } DebugStacker::~DebugStacker() { - JMutexAutoLock lock(g_debug_stacks_mutex); - - if(m_overflowed == true) + MutexAutoLock lock(g_debug_stacks_mutex); + + if (m_overflowed) return; - + m_stack->stack_i--; - if(m_stack->stack_i == 0) - { - threadid_t threadid = m_stack->threadid; + if (m_stack->stack_i == 0) { + std::thread::id thread_id = m_stack->thread_id; /*DEBUGPRINT("Deleting debug stack for thread %x\n", - (unsigned int)threadid);*/ + (unsigned int)thread_id);*/ delete m_stack; - g_debug_stacks.remove(threadid); + g_debug_stacks.erase(thread_id); + } +} + +#ifdef _MSC_VER + +const char *Win32ExceptionCodeToString(DWORD exception_code) +{ + switch (exception_code) { + case EXCEPTION_ACCESS_VIOLATION: + return "Access violation"; + case EXCEPTION_DATATYPE_MISALIGNMENT: + return "Misaligned data access"; + case EXCEPTION_BREAKPOINT: + return "Breakpoint reached"; + case EXCEPTION_SINGLE_STEP: + return "Single debug step"; + case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: + return "Array access out of bounds"; + case EXCEPTION_FLT_DENORMAL_OPERAND: + return "Denormal floating point operand"; + case EXCEPTION_FLT_DIVIDE_BY_ZERO: + return "Floating point division by zero"; + case EXCEPTION_FLT_INEXACT_RESULT: + return "Inaccurate floating point result"; + case EXCEPTION_FLT_INVALID_OPERATION: + return "Invalid floating point operation"; + case EXCEPTION_FLT_OVERFLOW: + return "Floating point exponent overflow"; + case EXCEPTION_FLT_STACK_CHECK: + return "Floating point stack overflow or underflow"; + case EXCEPTION_FLT_UNDERFLOW: + return "Floating point exponent underflow"; + case EXCEPTION_INT_DIVIDE_BY_ZERO: + return "Integer division by zero"; + case EXCEPTION_INT_OVERFLOW: + return "Integer overflow"; + case EXCEPTION_PRIV_INSTRUCTION: + return "Privileged instruction executed"; + case EXCEPTION_IN_PAGE_ERROR: + return "Could not access or load page"; + case EXCEPTION_ILLEGAL_INSTRUCTION: + return "Illegal instruction encountered"; + case EXCEPTION_NONCONTINUABLE_EXCEPTION: + return "Attempted to continue after fatal exception"; + case EXCEPTION_STACK_OVERFLOW: + return "Stack overflow"; + case EXCEPTION_INVALID_DISPOSITION: + return "Invalid disposition returned to the exception dispatcher"; + case EXCEPTION_GUARD_PAGE: + return "Attempted guard page access"; + case EXCEPTION_INVALID_HANDLE: + return "Invalid handle"; } + + return "Unknown exception"; +} + +long WINAPI Win32ExceptionHandler(struct _EXCEPTION_POINTERS *pExceptInfo) +{ + char buf[512]; + MINIDUMP_EXCEPTION_INFORMATION mdei; + MINIDUMP_USER_STREAM_INFORMATION mdusi; + MINIDUMP_USER_STREAM mdus; + bool minidump_created = false; + + std::string dumpfile = porting::path_user + DIR_DELIM PROJECT_NAME ".dmp"; + + std::string version_str(PROJECT_NAME " "); + version_str += g_version_hash; + + HANDLE hFile = CreateFileA(dumpfile.c_str(), GENERIC_WRITE, + FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) + goto minidump_failed; + + if (SetEndOfFile(hFile) == FALSE) + goto minidump_failed; + + mdei.ClientPointers = NULL; + mdei.ExceptionPointers = pExceptInfo; + mdei.ThreadId = GetCurrentThreadId(); + + mdus.Type = CommentStreamA; + mdus.BufferSize = version_str.size(); + mdus.Buffer = (PVOID)version_str.c_str(); + + mdusi.UserStreamArray = &mdus; + mdusi.UserStreamCount = 1; + + if (MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, + MiniDumpNormal, &mdei, &mdusi, NULL) == FALSE) + goto minidump_failed; + + minidump_created = true; + +minidump_failed: + + CloseHandle(hFile); + + DWORD excode = pExceptInfo->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 }