static void LogStacktrace(const int logLevel, StackTrace& stacktrace) { int colFileline = 0; const std::string& exe_path = Platform::GetProcessExecutablePath(); const std::string& cwd_path = Platform::GetOrigCWD(); for (auto fit = stacktrace.begin(); fit != stacktrace.end(); fit++) { for (auto eit = fit->entries.begin(); eit != fit->entries.end(); eit++) { eit->abbrev_funcname = eit->funcname; std::string fileline = eit->fileline; if (fileline[1] == '?') { // case "??:?", ":?" fileline = fit->symbol; // print raw backtrace_symbol } eit->abbrev_fileline = fileline; int abbrev_start = 0; if (fileline[0] == '/') { // See if we can shorten the file/line bit by removing the common path if (CommonStringLength(fileline, exe_path, &abbrev_start) > 1) { // i.e. one char for first '/' eit->abbrev_fileline = std::string(".../") + fileline.substr(abbrev_start, std::string::npos); } else if (CommonStringLength(fileline, cwd_path, &abbrev_start) > 1) { eit->abbrev_fileline = std::string("./") + fileline.substr(abbrev_start, std::string::npos); } } if (eit->abbrev_funcname.size() > 100) { eit->abbrev_funcname.resize(94); eit->abbrev_funcname.append(" [...]"); } colFileline = std::max(colFileline, (int)eit->abbrev_fileline.length()); } } bool hideSignalHandler = true; // Print out the translated StackTrace unsigned numLine = 0; unsigned hiddenLines = 0; while (numLine == 0) { // outer loop at most twice -- tries to find the signal handler once and if that doesn't work, then just print every frame for (auto fit = stacktrace.cbegin(); fit != stacktrace.cend(); fit++) { for (auto eit = fit->entries.begin(); eit != fit->entries.end(); eit++) { if (hideSignalHandler) { hiddenLines++; if (eit->fileline.find("sigaction.c:?") == 0) { hideSignalHandler = false; LOG_I(logLevel, "(Signal handler calls suppressed [%d]. Inlined calls denoted by < > brackets.)", hiddenLines); } continue; } if (eit->inLine) { LOG_I(logLevel, " <%02u> %*s %s", fit->level, colFileline, eit->abbrev_fileline.c_str(), eit->abbrev_funcname.c_str()); } else { LOG_I(logLevel, "[%02u] %*s %s", fit->level, colFileline, eit->abbrev_fileline.c_str(), eit->abbrev_funcname.c_str()); } numLine++; } } hideSignalHandler = false; } }
/** * Consumes (and frees) the lines produced by backtrace_symbols and puts these into the StackTrace fields */ static void ExtractSymbols(char** lines, StackTrace& stacktrace) { int l=0; auto fit = stacktrace.begin(); while (fit != stacktrace.end()) { LOG_L(L_DEBUG, "backtrace_symbols: %s", lines[l]); if (strncmp(lines[l], "[(nil)]", 20) != 0) { fit->symbol = lines[l]; fit++; } else { fit = stacktrace.erase(fit); } l++; } free(lines); }
/** * @brief TranslateStackTrace * @param stacktrace These are the lines and addresses produced by backtrace_symbols() * Translates the module and address information from backtrace symbols into a vector of StackFrame objects, * each with its own set of entries representing the function call and any inlined functions for that call. */ static void TranslateStackTrace(bool* aiCrash, StackTrace& stacktrace, const int logLevel) { // Extract important data from backtrace_symbols' output bool containsDriverSo = false; // OpenGL lib -> graphic problem bool containsAIInterfaceSo = false; bool containsSkirmishAISo = false; LOG_L(L_DEBUG, "TranslateStackTrace[1]"); for (auto it = stacktrace.begin(); it != stacktrace.end(); ++it) { // prepare for addr2line() const std::string path = ExtractPath(it->symbol); const std::string absPath = CreateAbsolutePath(path); it->path = absPath; it->addr = ExtractAddr(*it); LOG_L(L_DEBUG, "symbol = \"%s\", path = \"%s\", absPath = \"%s\", addr = 0x%lx", it->symbol.c_str(), path.c_str(), absPath.c_str(), it->addr); // 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 (!containsAIInterfaceSo && (absPath.find("Interfaces") != std::string::npos)) { containsAIInterfaceSo = true; } if (!containsSkirmishAISo && (absPath.find("Skirmish") != std::string::npos)) { containsSkirmishAISo = true; } } LOG_L(L_DEBUG, "TranslateStackTrace[2]"); // 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 (containsSkirmishAISo) { containsAIInterfaceSo = false; } if (containsAIInterfaceSo) { LOG_I(logLevel, "This stack trace indicates a problem with an AI Interface library."); if (aiCrash) *aiCrash = true; } if (containsSkirmishAISo) { LOG_I(logLevel, "This stack trace indicates a problem with a Skirmish AI library."); if (aiCrash) *aiCrash = true; } LOG_L(L_DEBUG, "TranslateStackTrace[3]"); // Check if addr2line is available static int addr2line_found = -1; if (addr2line_found < 0) { FILE* cmdOut = popen(ADDR2LINE " --help", "r"); if (cmdOut == NULL) { addr2line_found = false; } else { addr2line_found = true; pclose(cmdOut); } } if (!addr2line_found) { LOG_L(L_WARNING, " addr2line not found!"); return; } LOG_L(L_DEBUG, "TranslateStackTrace[4]"); // Detect BaseMemoryAddresses of all Lib's found in the stacktrace std::map<std::string,uintptr_t> binPath_baseMemAddr; for (auto it = stacktrace.cbegin(); it != stacktrace.cend(); it++) { binPath_baseMemAddr[it->path] = 0; } FindBaseMemoryAddresses(binPath_baseMemAddr); LOG_L(L_DEBUG, "TranslateStackTrace[5]"); // Finally translate it: // This is nested so that the outer loop covers all the entries for one library -- this means fewer addr2line calls. for (auto it = binPath_baseMemAddr.cbegin(); it != binPath_baseMemAddr.cend(); it++) { const std::string& modulePath = it->first; //const uintptr_t& moduleAddr = it->second; const std::string symbolFile = LocateSymbolFile(modulePath); LOG_L(L_DEBUG, "modulePath: %s, symbolFile: %s", modulePath.c_str(), symbolFile.c_str()); std::ostringstream buf; buf << ADDR2LINE << " -i -a -f -C --exe=\"" << symbolFile << "\""; // insert requested addresses that should be translated by addr2line std::queue<size_t> indices; int i=0; for (auto fit = stacktrace.cbegin(); fit != stacktrace.cend(); fit++) { if (fit->path == modulePath) { buf << " " << std::hex << fit->addr; indices.push(i); } i++; } // execute command addr2line, read stdout and write to log-file buf << " 2>/dev/null"; // hide error output from spring's pipe LOG_L(L_DEBUG, "> %s", buf.str().c_str()); FILE* cmdOut = popen(buf.str().c_str(), "r"); if (cmdOut != NULL) { const size_t maxLength = 2048; char line[maxLength]; char* res = fgets_addr2line(line, maxLength, cmdOut); while (res != NULL) { i = indices.front(); indices.pop(); // First scan the address and ensure that it matches the one we were expecting uintptr_t parsedAddr = 0; int matched = sscanf(line, "0x%lx", &parsedAddr); if (matched != 1 || parsedAddr != stacktrace[i].addr) { LOG_L(L_WARNING, "Mismatched address received from addr2line: 0x%lx != 0x%lx", parsedAddr, stacktrace[i].addr); break; } res = fgets_addr2line(line, maxLength, cmdOut); while (res != NULL) { if (line[0] == '0' && line[1] == 'x') { break; // This is the start of a new address } StackFunction entry; entry.inLine = true; // marked false later if the last entry std::string funcname = std::string(line); entry.funcname = funcname.substr(0, funcname.rfind(" (discriminator")); if (fgets_addr2line(line, maxLength, cmdOut) == nullptr) { break; } entry.fileline = std::string(line); stacktrace[i].entries.push_back(entry); res = fgets_addr2line(line, maxLength, cmdOut); } if (!stacktrace[i].entries.empty()) { // Ensure that the last entry in a sequence of results is marked as "not inlined" stacktrace[i].entries.rbegin()->inLine = false; } } pclose(cmdOut); } } LOG_L(L_DEBUG, "TranslateStackTrace[6]"); return; }