/** * * This entry point is tailored for the Watchdog module. * Since the thread to be traced may be running, it requires a ThreadControls object in order to suspend/resume the thread. * @brief RemoteStacktrace */ void SuspendedStacktrace(Threading::ThreadControls* ctls, const std::string& threadName) { #if !(DEDICATED || UNIT_TEST) Watchdog::ClearTimer(); #endif assert(ctls != nullptr); assert(ctls->handle != 0); assert(threadName.size() > 0); LOG_L(L_WARNING, "Suspended-thread Stacktrace (%s) for Spring %s:", threadName.c_str(), (SpringVersion::GetFull()).c_str()); LOG_L(L_DEBUG, "SuspendedStacktrace[1]"); StackTrace stacktrace; // Get untranslated stacktrace symbols { // process and analyse the raw stack trace void* iparray[MAX_STACKTRACE_DEPTH]; ctls->Suspend(); const int numLines = thread_unwind(&ctls->ucontext, iparray, stacktrace); ctls->Resume(); LOG_L(L_DEBUG, "SuspendedStacktrace[2]"); if(numLines > MAX_STACKTRACE_DEPTH) { LOG_L(L_ERROR, "thread_unwind returned more lines than we allotted space for!"); } char** lines = backtrace_symbols(iparray, numLines); // give them meaningfull names ExtractSymbols(lines, stacktrace); } if (stacktrace.empty()) { LOG_L(L_WARNING, " Unable to create suspended stacktrace"); return; } LOG_L(L_DEBUG, "SuspendedStacktrace[3]"); // Translate symbols into code line numbers TranslateStackTrace(NULL, stacktrace, LOG_LEVEL_WARNING); LOG_L(L_DEBUG, "SuspendedStacktrace[4]"); // Print out the translated StackTrace LogStacktrace(LOG_LEVEL_WARNING, stacktrace); }
/** * This stack trace is tailored for the SIGSEGV / SIGILL / SIGFPE etc signal handler. * The thread to be traced is usually in a halted state, but the signal handler can provide siginfo_t and ucontext_t structures to help produce the trace using libunwind. * @brief PrepareStacktrace */ void HaltedStacktrace(const std::string& errstr, siginfo_t* siginfo, ucontext_t* ucontext) { LOG_L(L_ERROR, "Halted Stacktrace for Spring %s using libunwind:", (SpringVersion::GetFull()).c_str()); assert(siginfo != nullptr); assert(ucontext != nullptr); StackTrace stacktrace; LOG_L(L_DEBUG, "HaltedStacktrace[1]"); // Get untranslated stacktrace symbols { // process and analyse the raw stack trace void* iparray[MAX_STACKTRACE_DEPTH]; const int numLines = thread_unwind(nullptr, iparray, stacktrace); LOG_L(L_DEBUG, "HaltedStacktrace[2]"); if(numLines > MAX_STACKTRACE_DEPTH) { LOG_L(L_ERROR, "thread_unwind returned more lines than we allotted space for!"); } char** lines = backtrace_symbols(iparray, numLines); // give them meaningfull names ExtractSymbols(lines, stacktrace); } LOG_L(L_DEBUG, "HaltedStacktrace[3]"); if (stacktrace.empty()) { LOG_I(LOG_LEVEL_ERROR, " Unable to create stacktrace"); return; } // Translate it TranslateStackTrace(NULL, stacktrace, LOG_LEVEL_ERROR); LOG_L(L_DEBUG, "HaltedStacktrace[4]"); // Print out the translated StackTrace. Ignore the frames that occur inside the signal handler (before its line in the trace) -- they are likely some kind of padding or just garbage. LogStacktrace(LOG_LEVEL_ERROR, stacktrace); }
static void Stacktrace(bool* aiCrash, pthread_t* hThread = NULL, const char* threadName = NULL, const int logLevel = LOG_LEVEL_ERROR) { #if !(DEDICATED || UNIT_TEST) Watchdog::ClearTimer(); #endif if (threadName != NULL) { LOG_I(logLevel, "Stacktrace (%s) for Spring %s:", threadName, (SpringVersion::GetFull()).c_str()); } else { LOG_I(logLevel, "Stacktrace for Spring %s:", (SpringVersion::GetFull()).c_str()); } StackTrace stacktrace; // Get untranslated stacktrace symbols { // process and analyse the raw stack trace void* iparray[MAX_STACKTRACE_DEPTH]; int numLines = thread_unwind(nullptr, iparray, stacktrace); if (numLines > MAX_STACKTRACE_DEPTH) { LOG_L(L_ERROR, "thread_unwind returned more lines than we allotted space for!"); } char** lines = backtrace_symbols(iparray, numLines); // give them meaningfull names ExtractSymbols(lines, stacktrace); } if (stacktrace.empty()) { LOG_I(logLevel, " Unable to create stacktrace"); return; } // Translate it TranslateStackTrace(aiCrash, stacktrace, logLevel); LogStacktrace(logLevel, stacktrace); }
void _pthread_exit_mask(void *status, sigset_t *mask) { struct pthread *curthread = _get_curthread(); /* Check if this thread is already in the process of exiting: */ if (curthread->cancelling) { char msg[128]; snprintf(msg, sizeof(msg), "Thread %p has called " "pthread_exit() from a destructor. POSIX 1003.1 " "1996 s16.2.5.2 does not allow this!", curthread); PANIC(msg); } /* Flag this thread as exiting. */ curthread->cancelling = 1; curthread->no_cancel = 1; curthread->cancel_async = 0; curthread->cancel_point = 0; if (mask != NULL) __sys_sigprocmask(SIG_SETMASK, mask, NULL); if (curthread->unblock_sigcancel) { sigset_t set; curthread->unblock_sigcancel = 0; SIGEMPTYSET(set); SIGADDSET(set, SIGCANCEL); __sys_sigprocmask(SIG_UNBLOCK, mask, NULL); } /* Save the return value: */ curthread->ret = status; #ifdef _PTHREAD_FORCED_UNWIND #ifdef PIC thread_uw_init(); #endif /* PIC */ #ifdef PIC if (uwl_forcedunwind != NULL) { #else if (_Unwind_ForcedUnwind != NULL) { #endif if (curthread->unwind_disabled) { if (message_printed == 0) { message_printed = 1; _thread_printf(2, "Warning: old _pthread_cleanup_push was called, " "stack unwinding is disabled.\n"); } goto cleanup; } thread_unwind(); } else { cleanup: while (curthread->cleanup != NULL) { __pthread_cleanup_pop_imp(1); } exit_thread(); } #else while (curthread->cleanup != NULL) { __pthread_cleanup_pop_imp(1); } exit_thread(); #endif /* _PTHREAD_FORCED_UNWIND */ } static void exit_thread(void) { struct pthread *curthread = _get_curthread(); /* Check if there is thread specific data: */ if (curthread->specific != NULL) { /* Run the thread-specific data destructors: */ _thread_cleanupspecific(); } if (!_thr_isthreaded()) exit(0); if (atomic_fetchadd_int(&_thread_active_threads, -1) == 1) { exit(0); /* Never reach! */ } /* Tell malloc that the thread is exiting. */ _malloc_thread_cleanup(); THR_LOCK(curthread); curthread->state = PS_DEAD; if (curthread->flags & THR_FLAGS_NEED_SUSPEND) { curthread->cycle++; _thr_umtx_wake(&curthread->cycle, INT_MAX, 0); } if (!curthread->force_exit && SHOULD_REPORT_EVENT(curthread, TD_DEATH)) _thr_report_death(curthread); /* * Thread was created with initial refcount 1, we drop the * reference count to allow it to be garbage collected. */ curthread->refcount--; _thr_try_gc(curthread, curthread); /* thread lock released */ #if defined(_PTHREADS_INVARIANTS) if (THR_IN_CRITICAL(curthread)) PANIC("thread exits with resources held!"); #endif /* * Kernel will do wakeup at the address, so joiner thread * will be resumed if it is sleeping at the address. */ thr_exit(&curthread->tid); PANIC("thr_exit() returned"); /* Never reach! */ }