Avoid patching symbols in the extension module

The fact that patching ourselves had not raised problems so far its
really an outstanding fact in this universe. Unfortunately seems that
with the latest toolchain + GCC there is something that causes memray to
point the d_original entry of the hooks pointing to itself, which should
never happen.

To fix this resiliently, avoid patching ourselves by getting our own
name in the extension module and then avoiding that shared object.

Signed-off-by: Pablo Galindo <[email protected]>

Author: pablogsal

news/685.bugfix.rst

@@ -0,0 +1 @@
+Fix some crashes caused by interposing symbols in memray itself

src/memray/_memray/elf_shenanigans.cpp

@@ -1,4 +1,5 @@
 #include <cstring>
+#include <mutex>
 #include <set>
 #include <string>
 #include <sys/mman.h>
@@ -18,6 +19,7 @@ struct elf_patcher_context_t
 {
     bool restore_original;
     std::set<std::string> patched;
+    std::string self_so_name;
 };
 
 }  // namespace
@@ -172,10 +174,10 @@ phdrs_callback(dl_phdr_info* info, [[maybe_unused]] size_t size, void* data) noe
     }
 
     if (strstr(info->dlpi_name, "/ld-linux") || strstr(info->dlpi_name, "/ld-musl")
-        || strstr(info->dlpi_name, "linux-vdso.so.1"))
+        || strstr(info->dlpi_name, "linux-vdso.so.1")
+        || strstr(info->dlpi_name, context.self_so_name.c_str()))
     {
         // Avoid chaos by not overwriting the symbols in the linker.
-        // TODO: Don't override the symbols in our shared library!
         return 0;
     }
 
@@ -198,14 +200,14 @@ phdrs_callback(dl_phdr_info* info, [[maybe_unused]] size_t size, void* data) noe
 void
 SymbolPatcher::overwrite_symbols() noexcept
 {
-    elf_patcher_context_t context{false, symbols};
+    elf_patcher_context_t context{false, symbols, self_so_name};
     dl_iterate_phdr(&phdrs_callback, (void*)&context);
 }
 
 void
 SymbolPatcher::restore_symbols() noexcept
 {
-    elf_patcher_context_t context{true, symbols};
+    elf_patcher_context_t context{true, symbols, self_so_name};
     dl_iterate_phdr(&phdrs_callback, (void*)&context);
 }
 

src/memray/_memray/linker_shenanigans.h

@@ -13,5 +13,7 @@ class SymbolPatcher
   public:
     void overwrite_symbols() noexcept;
     void restore_symbols() noexcept;
+
+    std::string self_so_name;
 };
 }  // namespace memray::linker

src/memray/_memray/tracking_api.cpp

@@ -433,6 +433,7 @@ std::unique_ptr<std::mutex> Tracker::s_mutex(new std::mutex);
 pthread_key_t Tracker::s_native_unwind_vector_key;
 std::unique_ptr<Tracker> Tracker::s_instance_owner;
 std::atomic<Tracker*> Tracker::s_instance = nullptr;
+std::string Tracker::s_self_so_name = "_memray.cpython-";
 
 std::vector<PythonStackTracker::LazilyEmittedFrame>
 PythonStackTracker::pythonFrameToStack(PyFrameObject* current_frame)
@@ -554,7 +555,7 @@ Tracker::Tracker(
 , d_trace_python_allocators(trace_python_allocators)
 {
     static std::once_flag once;
-    call_once(once, [] {
+    call_once(once, []() {
         // We use the pthread TLS API for this vector because we must be able
         // to re-create it while TLS destructors are running (a destructor can
         // call malloc, hitting our malloc hook). POSIX guarantees multiple
@@ -569,6 +570,11 @@ Tracker::Tracker(
 
         hooks::ensureAllHooksAreValid();
         NativeTrace::setup();
+
+        Dl_info info;
+        if (dladdr((void*)&get_executable, &info)) {
+            Tracker::s_self_so_name = info.dli_fname;
+        }
     });
 
     d_writer->setMainTidAndSkippedFrames(thread_id(), computeMainTidSkip());
@@ -587,6 +593,7 @@ Tracker::Tracker(
     d_background_thread = std::make_unique<BackgroundThread>(d_writer, memory_interval);
     d_background_thread->start();
 
+    d_patcher.self_so_name = Tracker::s_self_so_name;
     d_patcher.overwrite_symbols();
 }
 

src/memray/_memray/tracking_api.h

@@ -374,6 +374,7 @@ class Tracker
     static pthread_key_t s_native_unwind_vector_key;
     static std::unique_ptr<Tracker> s_instance_owner;
     static std::atomic<Tracker*> s_instance;
+    static std::string s_self_so_name;
 
     FrameCollection<RawFrame> d_frames;
     std::shared_ptr<RecordWriter> d_writer;