Merge 14e4664 into c192563

Author: MrLolthe1st

ydb/library/yql/utils/backtrace/backtrace.cpp

@@ -1,5 +1,8 @@
 #include "backtrace.h"
 
+#include "backtrace_lib.h"
+#include "symbolizer.h"
+
 #include <library/cpp/deprecated/atomic/atomic.h>
 #include <library/cpp/malloc/api/malloc.h>
 
@@ -15,14 +18,13 @@
 #include <util/system/mlock.h>
 
 #ifdef _linux_
-#include <dlfcn.h>
-#include <link.h>
 #include <signal.h>
-size_t BackTrace(void** p, size_t len, ucontext_t* signal_ucontext);
 #endif
 
 #include <functional>
 #include <vector>
+#include <sstream>
+#include <iostream>
 
 #ifndef _win_
 
@@ -37,22 +39,21 @@ bool SetSignalHandler(int signo, void (*handler)(int)) {
 
 namespace {
 #if defined(_linux_) && defined(_x86_64_)
-bool SetSignalAction(int signo, void (*handler)(int, siginfo_t*, void*)) {
-    struct sigaction sa;
-    memset(&sa, 0, sizeof(sa));
-    sa.sa_flags = SA_RESETHAND | SA_SIGINFO;
-    sa.sa_sigaction = (decltype(sa.sa_sigaction))handler;
-    sigfillset(&sa.sa_mask);
-    return sigaction(signo, &sa, nullptr) != -1;
-}
+    bool SetSignalAction(int signo, void (*handler)(int, siginfo_t*, void*)) {
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_flags = SA_RESETHAND | SA_SIGINFO;
+        sa.sa_sigaction = (decltype(sa.sa_sigaction))handler;
+        sigfillset(&sa.sa_mask);
+        return sigaction(signo, &sa, nullptr) != -1;
+    }
 #endif
 } // namespace
 #endif // _win_
 
 TAtomic BacktraceStarted = 0;
 
-void SetFatalSignalHandler(void (*handler)(int))
-{
+void SetFatalSignalHandler(void (*handler)(int)) {
     Y_UNUSED(handler);
 #ifndef _win_
     for (int signo: {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
@@ -66,147 +67,150 @@ void SetFatalSignalHandler(void (*handler)(int))
 #if defined(_linux_) && defined(_x86_64_)
 void SetFatalSignalAction(void (*sigaction)(int, siginfo_t*, void*))
 {
-    Y_UNUSED(sigaction);
-#ifndef _win_
     for (int signo: {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
         if (!SetSignalAction(signo, sigaction)) {
             ythrow TSystemError() << "Cannot set sigaction for signal " << strsignal(signo);
         }
     }
-#endif
 }
 #endif
 
-#include <sstream>
-#include <iostream>
 namespace {
-std::vector<std::function<void(int)>> Before, After;
-void* Stack[300];
-bool KikimrSymbolize = false;
-
-void CallCallbacks(decltype(Before)& where, int signum) {
-    for (const auto &fn: where) {
-        if (fn) {
-            fn(signum);
+    std::vector<std::function<void(int)>> Before, After;
+    bool KikimrSymbolize = false;
+    const int Limit = 400;
+    NYql::NBacktrace::TCollectedFrame Frames[Limit];
+
+    void CallCallbacks(decltype(Before)& where, int signum) {
+        for (const auto &fn: where) {
+            if (fn) {
+                fn(signum);
+            }
         }
     }
-}
 
-void StackFilledCallback(IOutputStream* out, size_t stack_size) {
-    auto symbolizer = BuildSymbolizer(KikimrSymbolize);
-    
-    for (size_t i = 0; i < stack_size; ++i) {
-        *out << symbolizer->SymbolizeFrame(Stack[i]);
+    void PrintFrames(IOutputStream* out, const NYql::NBacktrace::TCollectedFrame* frames, size_t cnt);
+
+    void DoBacktrace(IOutputStream* out, void* data) {
+        auto cnt = NYql::NBacktrace::CollectFrames(Frames, data);
+        PrintFrames(out, Frames, cnt);
     }
 
-}
+    void DoBacktrace(IOutputStream* out, void** stack, size_t cnt) {
+        Y_UNUSED(NYql::NBacktrace::CollectFrames(Frames, stack, cnt));
+        PrintFrames(out, Frames, cnt);
+    }
+    
 
-void SignalHandler(int signum)
-{
-    CallCallbacks(Before, signum);
+    void SignalHandler(int signum) {
+        CallCallbacks(Before, signum);
 
-    if (!NMalloc::IsAllocatorCorrupted) {
-        if (!AtomicTryLock(&BacktraceStarted)) {
-            return;
+        if (!NMalloc::IsAllocatorCorrupted) {
+            if (!AtomicTryLock(&BacktraceStarted)) {
+                return;
+            }
+            
+            UnlockAllMemory();
+            DoBacktrace(&Cerr, nullptr);
         }
 
-        UnlockAllMemory();
-
-        const size_t s = BackTrace(Stack, Y_ARRAY_SIZE(Stack));
-        StackFilledCallback(&Cerr, s);
+        CallCallbacks(After, signum);
+        raise(signum);
     }
-    
-    CallCallbacks(After, signum);
-
-    raise(signum);
-}
 
 #if defined(_linux_) && defined(_x86_64_)
-void SignalAction(int signum, siginfo_t* sinfo, void* context)
-{
-    Y_UNUSED(SignalHandler);
-    CallCallbacks(Before, signum);
-    Y_UNUSED(sinfo);
+    void SignalAction(int signum, siginfo_t*, void* context) {
+        Y_UNUSED(SignalHandler);
+        CallCallbacks(Before, signum);
 
-    if (!NMalloc::IsAllocatorCorrupted) {
-        if (!AtomicTryLock(&BacktraceStarted)) {
-            return;
-        }
+        if (!NMalloc::IsAllocatorCorrupted) {
+            if (!AtomicTryLock(&BacktraceStarted)) {
+                return;
+            }
 
-        UnlockAllMemory();
-        const size_t s = BackTrace(Stack, Y_ARRAY_SIZE(Stack), (ucontext_t*)context);
-        StackFilledCallback(&Cerr, s);
+            UnlockAllMemory();
+            DoBacktrace(&Cerr, context);
+        }
+        
+        CallCallbacks(After, signum);
+        raise(signum);
     }
-    
-    CallCallbacks(After, signum);
-
-    raise(signum);
-}
 #endif
-
 }
 
 namespace NYql {
+    namespace NBacktrace {
+        THashMap<TString, TString> Mapping;
 
-namespace NBacktrace {
-    
-THashMap<TString, TString> Mapping;
+        void SetModulesMapping(const THashMap<TString, TString>& mapping) {
+            Mapping = mapping;
+        }
 
-void SetModulesMapping(const THashMap<TString, TString>& mapping) {
-    Mapping = mapping;
-}
+        void AddBeforeFatalCallback(const std::function<void(int)>& before) {
+            Before.push_back(before);
+        }
 
-void AddBeforeFatalCallback(const std::function<void(int)>& before) {
-    Before.push_back(before);
-}
+        void AddAfterFatalCallback(const std::function<void(int)>& after) {
+            After.push_back(after);
+        }
 
-void AddAfterFatalCallback(const std::function<void(int)>& after) {
-    After.push_back(after);
-}
+        void RegisterKikimrFatalActions() {
+#if defined(_linux_) && defined(_x86_64_)
+            SetFatalSignalAction(SignalAction);
+#else
+            SetFatalSignalHandler(SignalHandler);
+#endif
+        }
 
-void RegisterKikimrFatalActions() {
-    #if !defined(_linux_) || !defined(_x86_64_)
-    SetFatalSignalHandler(SignalHandler);
-    #else
-    SetFatalSignalAction(SignalAction);
-    #endif
-}
+        void EnableKikimrSymbolize() {
+            KikimrSymbolize = true;
+        }
 
-void EnableKikimrSymbolize() {
-    KikimrSymbolize = true;
-}
+        void KikimrBackTrace() {
+            KikimrBackTraceFormatImpl(&Cerr);
+        }
 
-void KikimrBackTrace() {
-    KikimrBackTraceFormatImpl(&Cerr);
-}
+        void KikimrBackTraceFormatImpl(IOutputStream* out) {
+            KikimrSymbolize = true;
+            UnlockAllMemory();
+            DoBacktrace(out, nullptr);
+        }
 
-void KikimrBackTraceFormatImpl(IOutputStream* out) {
-    KikimrSymbolize = true;
-    UnlockAllMemory();
-    void* array[300];
-    const size_t s = BackTrace(array, Y_ARRAY_SIZE(array));
-    StackFilledCallback(out, s);
-}
+        void KikimrBacktraceFormatImpl(IOutputStream* out, void* const* stack, size_t stackSize) {
+            KikimrSymbolize = true;
+            DoBacktrace(out, (void**)stack, stackSize);
+        }
 
-void KikimrBacktraceFormatImpl(IOutputStream* out, void* const* stack, size_t stackSize) {
-    KikimrSymbolize = true;
-    for (size_t i = 0; i < stackSize; ++i) {
-        Stack[i] = stack[i];
     }
-
-    StackFilledCallback(out, stackSize);
-}
-
-}
-}
-
-TString IBacktraceSymbolizer::SymbolizeFrame(void* ptr) {
-    Y_UNUSED(ptr);
-    return "";
-}
-IBacktraceSymbolizer::~IBacktraceSymbolizer() {
 }
 
 void EnableKikimrBacktraceFormat() {
     SetFormatBackTraceFn(NYql::NBacktrace::KikimrBacktraceFormatImpl);
+}
+
+namespace {
+    void PrintFrames(IOutputStream* out, const NYql::NBacktrace::TCollectedFrame* frames, size_t count) {
+        auto& outp = *out;
+        if (KikimrSymbolize) {
+            TVector<NYql::NBacktrace::TStackFrame> sFrames(count);
+            for (size_t i = 0; i < count; ++i) {
+                sFrames[i] = NYql::NBacktrace::TStackFrame{frames[i].File, frames[i].Address};
+            }
+            auto symbolized = NYql::NBacktrace::Symbolize(sFrames);
+            for (auto& line: symbolized) {
+                outp << line << "\n";
+            }
+            return;
+        }
+        outp << "StackFrames: " << count << "\n";
+        for (size_t i = 0; i < count; ++i) {
+            auto& frame = frames[i];
+            auto fileName = frame.File;
+            if (!strcmp(fileName, "/proc/self/exe")) {
+                fileName = "EXE";
+            }
+            auto it = NYql::NBacktrace::Mapping.find(fileName);
+            outp << "StackFrame: " << (it == NYql::NBacktrace::Mapping.end() ? fileName : it->second) << " " << frame.Address << "\n";
+        }
+    }
 }

ydb/library/yql/utils/backtrace/backtrace.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "symbolizer.h"
 
 #include <util/system/types.h>
 #include <util/generic/string.h>

ydb/library/yql/utils/backtrace/backtrace_dummy.cpp

@@ -0,0 +1,11 @@
+#include "backtrace_lib.h"
+
+#include <util/system/backtrace.h>
+
+namespace NYql {
+    namespace NBacktrace {
+        size_t CollectBacktrace(void** addresses, size_t limit, void*) {
+            return BackTrace(addresses, limit);
+        }
+    }
+}