YQL-20086 utils

init
commit_hash:54feccd520ebd0ab23612bc0cb830914dff9d0e8

1 files changed, 111 insertions, 112 deletions

diff --git a/yql/essentials/utils/backtrace/backtrace.cpp b/yql/essentials/utils/backtrace/backtrace.cpp
index 938ac90501a..5d289454210 100644
--- a/yql/essentials/utils/backtrace/backtrace.cpp
+++ b/yql/essentials/utils/backtrace/backtrace.cpp
@@ -18,7 +18,7 @@
 #include <util/system/mlock.h>
 
 #ifdef _linux_
-#include <signal.h>
+    #include <signal.h>
 #endif
 
 #include <functional>
@@ -38,16 +38,16 @@ 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;
-    }
-#endif
+    #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;
+}
+    #endif
 } // namespace
 #endif // _win_
 
@@ -56,7 +56,7 @@ TAtomic BacktraceStarted = 0;
 void SetFatalSignalHandler(void (*handler)(int)) {
     Y_UNUSED(handler);
 #ifndef _win_
-    for (int signo: {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
+    for (int signo : {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
         if (!SetSignalHandler(signo, handler)) {
             ythrow TSystemError() << "Cannot set handler for signal " << strsignal(signo);
         }
@@ -67,7 +67,7 @@ void SetFatalSignalHandler(void (*handler)(int)) {
 #if defined(_linux_) && defined(_x86_64_)
 void SetFatalSignalAction(void (*sigaction)(int, siginfo_t*, void*))
 {
-    for (int signo: {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
+    for (int signo : {SIGSEGV, SIGILL, SIGABRT, SIGFPE}) {
         if (!SetSignalAction(signo, sigaction)) {
             ythrow TSystemError() << "Cannot set sigaction for signal " << strsignal(signo);
         }
@@ -76,140 +76,139 @@ void SetFatalSignalAction(void (*sigaction)(int, siginfo_t*, void*))
 #endif
 
 namespace {
-    std::vector<std::function<void(int)>> Before, After;
-    bool KikimrSymbolize = false;
-    NYql::NBacktrace::TCollectedFrame Frames[NYql::NBacktrace::Limit];
-
-    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;
+NYql::NBacktrace::TCollectedFrame Frames[NYql::NBacktrace::Limit];
+
+void CallCallbacks(decltype(Before)& where, int signum) {
+    for (const auto& fn : where) {
+        if (fn) {
+            fn(signum);
         }
     }
+}
 
-    void PrintFrames(IOutputStream* out, const NYql::NBacktrace::TCollectedFrame* frames, size_t cnt);
+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* 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);
-
-        if (!NMalloc::IsAllocatorCorrupted) {
-            if (!AtomicTryLock(&BacktraceStarted)) {
-                return;
-            }
-            
-            UnlockAllMemory();
-            DoBacktrace(&Cerr, nullptr);
+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);
+
+    if (!NMalloc::IsAllocatorCorrupted) {
+        if (!AtomicTryLock(&BacktraceStarted)) {
+            return;
         }
-        
-        CallCallbacks(After, signum);
-        raise(signum);
+
+        UnlockAllMemory();
+        DoBacktrace(&Cerr, nullptr);
     }
 
-#if defined(_linux_) && defined(_x86_64_)
-    void SignalAction(int signum, siginfo_t*, void* context) {
-        Y_UNUSED(SignalHandler);
-        CallCallbacks(Before, signum);
+    CallCallbacks(After, signum);
+    raise(signum);
+}
 
-        if (!NMalloc::IsAllocatorCorrupted) {
-            if (!AtomicTryLock(&BacktraceStarted)) {
-                return;
-            }
+#if defined(_linux_) && defined(_x86_64_)
+void SignalAction(int signum, siginfo_t*, void* context) {
+    Y_UNUSED(SignalHandler);
+    CallCallbacks(Before, signum);
 
-            UnlockAllMemory();
-            DoBacktrace(&Cerr, context);
+    if (!NMalloc::IsAllocatorCorrupted) {
+        if (!AtomicTryLock(&BacktraceStarted)) {
+            return;
         }
-        
-        CallCallbacks(After, signum);
-        raise(signum);
+
+        UnlockAllMemory();
+        DoBacktrace(&Cerr, context);
     }
-#endif
+
+    CallCallbacks(After, signum);
+    raise(signum);
 }
+#endif
+} // namespace
 
 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() {
+void RegisterKikimrFatalActions() {
 #if defined(_linux_) && defined(_x86_64_)
-            SetFatalSignalAction(SignalAction);
+    SetFatalSignalAction(SignalAction);
 #else
-            SetFatalSignalHandler(SignalHandler);
+    SetFatalSignalHandler(SignalHandler);
 #endif
-        }
-
-        void EnableKikimrSymbolize() {
-            KikimrSymbolize = true;
-        }
+}
 
-        void KikimrBackTrace() {
-            FormatBackTrace(&Cerr);
-        }
+void EnableKikimrSymbolize() {
+    KikimrSymbolize = true;
+}
 
-        void KikimrBackTraceFormatImpl(IOutputStream* out) {
-            KikimrSymbolize = true;
-            UnlockAllMemory();
-            DoBacktrace(out, nullptr);
-        }
+void KikimrBackTrace() {
+    FormatBackTrace(&Cerr);
+}
 
-        void KikimrBacktraceFormatImpl(IOutputStream* out, void* const* stack, size_t stackSize) {
-            KikimrSymbolize = true;
-            DoBacktrace(out, (void**)stack, stackSize);
-        }
+void KikimrBackTraceFormatImpl(IOutputStream* out) {
+    KikimrSymbolize = true;
+    UnlockAllMemory();
+    DoBacktrace(out, nullptr);
+}
 
-    }
+void KikimrBacktraceFormatImpl(IOutputStream* out, void* const* stack, size_t stackSize) {
+    KikimrSymbolize = true;
+    DoBacktrace(out, (void**)stack, stackSize);
 }
 
+} // namespace NBacktrace
+} // namespace NYql
+
 void EnableKikimrBacktraceFormat() {
     SetFormatBackTraceFn(NYql::NBacktrace::KikimrBacktraceFormatImpl);
 }
 
 namespace {
-    NYql::NBacktrace::TStackFrame SFrames[NYql::NBacktrace::Limit];
-    void PrintFrames(IOutputStream* out, const NYql::NBacktrace::TCollectedFrame* frames, size_t count) {
-        auto& outp = *out;
-        Y_UNUSED(SFrames);
+NYql::NBacktrace::TStackFrame SFrames[NYql::NBacktrace::Limit];
+void PrintFrames(IOutputStream* out, const NYql::NBacktrace::TCollectedFrame* frames, size_t count) {
+    auto& outp = *out;
+    Y_UNUSED(SFrames);
 #if defined(_linux_) && defined(_x86_64_)
-        if (KikimrSymbolize) {
-            for (size_t i = 0; i < count; ++i) {
-                SFrames[i] = NYql::NBacktrace::TStackFrame{frames[i].File, frames[i].Address};
-            }
-            NYql::NBacktrace::Symbolize(SFrames, count, out);
-            return;
+    if (KikimrSymbolize) {
+        for (size_t i = 0; i < count; ++i) {
+            SFrames[i] = NYql::NBacktrace::TStackFrame{frames[i].File, frames[i].Address};
         }
+        NYql::NBacktrace::Symbolize(SFrames, count, out);
+        return;
+    }
 #endif
-        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 << " 0\n";
+    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 << " 0\n";
     }
-}
\ No newline at end of file
+}
+} // namespace