Merge lp:~thomas-voss/process-cpp/add_symbol_demangling_in_stack_traces into lp:process-cpp

[Thomas Voß]

Add symbol demangling when printing the stack trace.

Add symbol demangling when printing the stack trace.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:36
http://jenkins.qa.ubuntu.com/job/process-cpp-ci/30/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/process-cpp-trusty-amd64-ci/30
    SUCCESS: http://jenkins.qa.ubuntu.com/job/process-cpp-trusty-armhf-ci/30
        deb: http://jenkins.qa.ubuntu.com/job/process-cpp-trusty-armhf-ci/30/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/process-cpp-trusty-i386-ci/26

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/process-cpp-ci/30/rebuild

review: Approve (continuous-integration)

[Martin Pitt (pitti)]

A test for this would be nice (redirect stdout to a file, raise an exception in child, and ensure some expected functions are in the trace). But otherwise looks good!

review: Approve

=== modified file 'src/core/posix/fork.cpp'
--- src/core/posix/fork.cpp	2013-11-29 07:38:07 +0000
+++ src/core/posix/fork.cpp	2014-01-24 11:03:09 +0000
@@ -22,6 +22,9 @@
 #include <iostream>
 #include <system_error>
 
+#include <cxxabi.h>
+
+#include <execinfo.h>
 #include <unistd.h>
 
 namespace
@@ -32,6 +35,64 @@
     if (rc == -1)
         throw std::system_error(errno, std::system_category());
 }
+
+std::tuple<std::string, bool> demangle(const std::string& symbol)
+{
+    int status = 1;
+    auto result = abi::__cxa_demangle(symbol.c_str(),
+                                      nullptr,
+                                      nullptr,
+                                      &status);
+
+    if (!result || status != 0)
+    {
+        return std::make_tuple(std::string(), false);
+    }
+
+    std::string s{result};
+    ::free(result);
+
+    return std::make_tuple(s, true);
+}
+
+void print_backtrace(std::ostream& out)
+{
+    static const unsigned int max_frames=100;
+    void *frames[max_frames];
+
+    auto frame_count = ::backtrace(frames, max_frames);
+    auto symbols = ::backtrace_symbols(frames, frame_count);
+
+    for (int i = 0; i < frame_count; i++)
+    {
+        std::string symbol(symbols[i]);
+
+        auto first = symbol.find_first_of("(");
+        auto last = symbol.find_last_of(")");
+
+        if (first != std::string::npos && last != std::string::npos)
+        {
+            auto mangled_symbol = symbol.substr(first+1,
+                                                (last-1) - (first+1));
+
+            auto plus = mangled_symbol.find_first_of("+");
+            if (plus != std::string::npos)
+                mangled_symbol.erase(plus);
+
+            std::string demangled_symbol;
+            bool successful;
+
+            std::tie(demangled_symbol, successful) = demangle(mangled_symbol);
+
+            if (successful)
+                symbol = demangled_symbol;
+        }
+
+        out << "\t" << std::hex << frames[i] << ": " << symbol << std::endl;
+    }
+
+    ::free(symbols);
+}
 }
 
 namespace core
@@ -78,8 +139,15 @@
                 redirect_stream_to_fd(stderr_pipe.write_fd(), STDERR_FILENO);
 
             result = main();
+        } catch(const std::exception& e)
+        {
+            std::cerr << "core::posix::fork(): An unhandled std::exception occured in the child process:" << std::endl
+                      << "\t" << e.what() << std::endl;
+            print_backtrace(std::cerr);
         } catch(...)
         {
+            std::cerr << "core::posix::fork(): An unhandled exception occured in the child process." << std::endl;
+            print_backtrace(std::cerr);
         }
 
         // We have to ensure that we exit here. Otherwise, we run into
@@ -128,8 +196,15 @@
                 redirect_stream_to_fd(stderr_pipe.write_fd(), STDERR_FILENO);
 
             result = main();
+        } catch(const std::exception& e)
+        {
+            std::cerr << "core::posix::fork(): An unhandled std::exception occured in the child process:" << std::endl
+                      << "\t" << e.what() << std::endl;
+            print_backtrace(std::cerr);
         } catch(...)
         {
+            std::cerr << "core::posix::fork(): An unhandled exception occured in the child process." << std::endl;
+            print_backtrace(std::cerr);
         }
 
         // We have to ensure that we exit here. Otherwise, we run into