/**
*
* 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);
}
static void Stacktrace(bool* aiCrash, pthread_t* hThread = NULL, const char* threadName = NULL, const int logLevel = LOG_LEVEL_ERROR)
{
#ifndef DEDICATED
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());
}
bool containsDriverSo = false; // OpenGL lib -> graphic problem
bool containedAIInterfaceSo = false;
bool containedSkirmishAISo = false;
std::vector<std::string> stacktrace;
std::vector< std::pair<std::string,uintptr_t> > symbols;
// Get untranslated stacktrace symbols
{
// process and analyse the raw stack trace
std::vector<void*> buffer(MAX_STACKTRACE_DEPTH + 2);
int numLines;
if (hThread && Threading::GetCurrentThread() != *hThread) {
LOG_I(logLevel, " (Note: This stacktrace is not 100%% accurate! It just gives an impression.)");
LOG_CLEANUP();
numLines = thread_backtrace(*hThread, &buffer[0], buffer.size()); // stack pointers
} else {
numLines = backtrace(&buffer[0], buffer.size()); // stack pointers
buffer.erase(buffer.begin()); // pop Stacktrace()
buffer.erase(buffer.begin()); // pop HandleSignal()
numLines -= 2;
}
numLines = (numLines > MAX_STACKTRACE_DEPTH) ? MAX_STACKTRACE_DEPTH : numLines;
char** lines = backtrace_symbols(&buffer[0], numLines); // give them meaningfull names
stacktrace.reserve(numLines);
for (int l = 0; l < numLines; l++) {
stacktrace.push_back(lines[l]);
}
free(lines);
}
if (stacktrace.empty()) {
LOG_I(logLevel, " Unable to create stacktrace");
return;
}
// Extract important data from backtrace_symbols' output
{
for (std::vector<std::string>::iterator it = stacktrace.begin(); it != stacktrace.end(); ++it) {
std::pair<std::string,uintptr_t> data;
// prepare for TranslateStackTrace()
const std::string path = ExtractPath(*it);
const std::string absPath = CreateAbsolutePath(path);
data.first = absPath;
data.second = ExtractAddr(*it);
symbols.push_back(data);
// check if there are known sources of fail on the stack
containsDriverSo = (containsDriverSo || (path.find("libGLcore.so") != std::string::npos));
containsDriverSo = (containsDriverSo || (path.find("psb_dri.so") != std::string::npos));
containsDriverSo = (containsDriverSo || (path.find("i965_dri.so") != std::string::npos));
containsDriverSo = (containsDriverSo || (path.find("fglrx_dri.so") != std::string::npos));
if (!containedAIInterfaceSo && (absPath.find("Interfaces") != std::string::npos)) {
containedAIInterfaceSo = true;
}
if (!containedSkirmishAISo && (absPath.find("Skirmish") != std::string::npos)) {
containedSkirmishAISo = true;
}
}
// Linux Graphic drivers are known to fail with moderate OpenGL usage
if (containsDriverSo) {
LOG_I(logLevel, "This stack trace indicates a problem with your graphic card driver. "
"Please try upgrading or downgrading it. "
"Specifically recommended is the latest driver, and one that is as old as your graphic card. "
"Also try lower graphic details and disabling Lua widgets in spring-settings.\n");
}
// if stack trace contains AI and AI Interface frames,
// it is very likely that the problem lies in the AI only
if (containedSkirmishAISo) {
containedAIInterfaceSo = false;
}
if (containedAIInterfaceSo) {
LOG_I(logLevel, "This stack trace indicates a problem with an AI Interface library.");
if (aiCrash) *aiCrash = true;
}
if (containedSkirmishAISo) {
LOG_I(logLevel, "This stack trace indicates a problem with a Skirmish AI library.");
if (aiCrash) *aiCrash = true;
}
LOG_CLEANUP();
}
// Translate it
TranslateStackTrace(&stacktrace, symbols);
// Print out the translated StackTrace
unsigned numLine = 0;
for (std::vector<std::string>::iterator it = stacktrace.begin(); it != stacktrace.end(); ++it) {
LOG_I(logLevel, " <%u> %s", numLine++, it->c_str());
}
}