Add empty trackers of mmap/munmap.

diff --git a/src/track/heaptrack_inject.cpp b/src/track/heaptrack_inject.cpp
index f20f658..80abf3f 100644 (file)
--- a/src/track/heaptrack_inject.cpp
+++ b/src/track/heaptrack_inject.cpp
@@ -181,6 +181,68 @@ struct posix_memalign
     }
 };
 
+struct mmap
+{
+    static constexpr auto name = "mmap";
+    static constexpr auto original = &::mmap;
+
+    static void *hook(void *addr,
+                      size_t length,
+                      int prot,
+                      int flags,
+                      int fd,
+                      off_t offset)
+    {
+        void *ret = original(addr, length, prot, flags, fd, offset);
+
+        if (ret != MAP_FAILED) {
+            heaptrack_mmap(ret, length, prot, flags, fd, offset);
+        }
+
+        return ret;
+    }
+};
+
+struct mmap64
+{
+    static constexpr auto name = "mmap64";
+    static constexpr auto original = &::mmap64;
+
+    static void *hook(void *addr,
+                      size_t length,
+                      int prot,
+                      int flags,
+                      int fd,
+                      off64_t offset)
+    {
+        void *ret = original(addr, length, prot, flags, fd, offset);
+
+        if (ret != MAP_FAILED) {
+            heaptrack_mmap(ret, length, prot, flags, fd, offset);
+        }
+
+        return ret;
+    }
+};
+
+struct munmap
+{
+    static constexpr auto name = "munmap";
+    static constexpr auto original = &::munmap;
+
+    static int hook(void *addr,
+                    size_t length)
+    {
+        int ret = original(addr, length);
+
+        if (ret != -1) {
+            heaptrack_munmap(addr, length);
+        }
+
+        return ret;
+    }
+};
+
 template <typename Hook>
 bool hook(const char* symname, Elf::Addr addr, bool restore)
 {
@@ -218,7 +280,10 @@ void apply(const char* symname, Elf::Addr addr, bool restore)
         || hook<cfree>(symname, addr, restore)
 #endif
         || hook<posix_memalign>(symname, addr, restore) || hook<dlopen>(symname, addr, restore)
-        || hook<dlclose>(symname, addr, restore);
+        || hook<dlclose>(symname, addr, restore)
+        || hook<mmap>(symname, addr, restore)
+        || hook<mmap64>(symname, addr, restore)
+        || hook<munmap>(symname, addr, restore);
 }
 }
 

diff --git a/src/track/heaptrack_preload.cpp b/src/track/heaptrack_preload.cpp
index d8dde24..cac0b84 100644 (file)
--- a/src/track/heaptrack_preload.cpp
+++ b/src/track/heaptrack_preload.cpp
@@ -23,6 +23,8 @@
 #include <cstring>
 #include <dlfcn.h>
 
+#include <sys/mman.h>
+
 #include <atomic>
 #include <type_traits>
 
@@ -97,6 +99,9 @@ HOOK(aligned_alloc);
 #endif
 HOOK(dlopen);
 HOOK(dlclose);
+HOOK(mmap);
+HOOK(mmap64);
+HOOK(munmap);
 
 /**
  * Dummy implementation, since the call to dlsym from findReal triggers a call
@@ -156,6 +161,9 @@ void init()
 #if HAVE_ALIGNED_ALLOC
                        hooks::aligned_alloc.init();
 #endif
+                       hooks::mmap.init();
+                       hooks::mmap64.init();
+                       hooks::munmap.init();
 
                        // cleanup environment to prevent tracing of child apps
                        unsetenv("LD_PRELOAD");
@@ -258,6 +266,62 @@ int posix_memalign(void** memptr, size_t alignment, size_t size) noexcept
     return ret;
 }
 
+void *mmap(void *addr,
+           size_t length,
+           int prot,
+           int flags,
+           int fd,
+           off_t offset)
+{
+    if (!hooks::mmap) {
+        hooks::init();
+    }
+
+    void *ret = hooks::mmap(addr, length, prot, flags, fd, offset);
+
+    if (ret != MAP_FAILED) {
+        heaptrack_mmap(ret, length, prot, flags, fd, offset);
+    }
+
+    return ret;
+}
+
+void *mmap64(void *addr,
+             size_t length,
+             int prot,
+             int flags,
+             int fd,
+             off64_t offset)
+{
+    if (!hooks::mmap64) {
+        hooks::init();
+    }
+
+    void *ret = hooks::mmap64(addr, length, prot, flags, fd, offset);
+
+    if (ret != MAP_FAILED) {
+        heaptrack_mmap(ret, length, prot, flags, fd, offset);
+    }
+
+    return ret;
+}
+
+int munmap(void *addr,
+           size_t length)
+{
+    if (!hooks::munmap) {
+        hooks::init();
+    }
+
+    int ret = hooks::munmap(addr, length);
+
+    if (ret != -1) {
+        heaptrack_munmap(addr, length);
+    }
+
+    return ret;
+}
+
 #if HAVE_ALIGNED_ALLOC
 void* aligned_alloc(size_t alignment, size_t size) noexcept
 {

diff --git a/src/track/libheaptrack.cpp b/src/track/libheaptrack.cpp
index 7eba14b..7bd5d32 100644 (file)
--- a/src/track/libheaptrack.cpp
+++ b/src/track/libheaptrack.cpp
@@ -714,6 +714,22 @@ void heaptrack_realloc(void* ptr_in, size_t size, void* ptr_out)
     }
 }
 
+void heaptrack_mmap(void* ptr, size_t length, int prot, int flags, int fd, off64_t offset)
+{
+    debugLog<VeryVerboseOutput>("heaptrack_mmap(%p, %zu, %d, %d, %d, %llu)",
+                                ptr, length, prot, flags, fd, offset);
+
+    // TODO
+}
+
+void heaptrack_munmap(void* ptr, size_t length)
+{
+    debugLog<VeryVerboseOutput>("heaptrack_munmap(%p, %zu)",
+                                ptr, length);
+
+    // TODO
+}
+
 void heaptrack_invalidate_module_cache()
 {
     RecursionGuard guard;

diff --git a/src/track/libheaptrack.h b/src/track/libheaptrack.h
index dc9cbfa..5ac1be1 100644 (file)
--- a/src/track/libheaptrack.h
+++ b/src/track/libheaptrack.h
@@ -36,6 +36,9 @@ void heaptrack_free(void* ptr);
 
 void heaptrack_realloc(void* ptr_in, size_t size, void* ptr_out);
 
+void heaptrack_mmap(void* ptr, size_t length, int prot, int flags, int fd, off64_t offset);
+void heaptrack_munmap(void* ptr, size_t length);
+
 void heaptrack_invalidate_module_cache();
 
 #ifdef __cplusplus