More work on BOX64_MALLOC_HACK=2

1 files changed, 77 insertions, 27 deletions

diff --git a/src/mallochook.c b/src/mallochook.c
index fd382b82..ff4b7cae 100644
--- a/src/mallochook.c
+++ b/src/mallochook.c
@@ -180,14 +180,21 @@ static int ispot(size_t l) {
     return pot(l)==l;
 }
 
+#define GO(A, B) static uintptr_t real_##A = 0;
+#define GO2(A, B) static uintptr_t real_##A = 0;
+SUPER()
+#undef GO2
+#undef GO
+
 // redefining all libc memory allocation routines
 EXPORT void* malloc(size_t l)
 {
+    if(malloc_hack_2 && real_malloc) {
+        return (void*)RunFunctionFmt(my_context, real_malloc, "L", l);
+    }
     return box_calloc(1, l);
 }
 
-static uintptr_t real_free = 0;
-static uintptr_t real_realloc = 0;
 EXPORT void free(void* p)
 {
     if(malloc_hack_2 && p) {
@@ -204,13 +211,16 @@ EXPORT void free(void* p)
 
 EXPORT void* calloc(size_t n, size_t s)
 {
+    if(malloc_hack_2 && real_calloc) {
+        return (void*)RunFunctionFmt(my_context, real_calloc, "LL", n,s);
+    }
     return box_calloc(n, s);
 }
 
 EXPORT void* realloc(void* p, size_t s)
 {
     if(malloc_hack_2)
-        if(getMmapped((uintptr_t)p)) {
+        if(getMmapped((uintptr_t)p) || (!p && real_realloc)) {
             void* ret = p;
             if(real_realloc) {
                 ret = (void*)RunFunctionFmt(my_context, real_realloc, "pL", p, s);
@@ -232,16 +242,25 @@ EXPORT void* realloc(void* p, size_t s)
 
 EXPORT void* aligned_alloc(size_t align, size_t size)
 {
+    if(malloc_hack_2 && real_aligned_alloc) {
+        return (void*)RunFunctionFmt(my_context, real_aligned_alloc, "LL", align, size);
+    }
     return box_memalign(align, size);
 }
 
 EXPORT void* memalign(size_t align, size_t size)
 {
+    if(malloc_hack_2 && real_aligned_alloc) {
+        return (void*)RunFunctionFmt(my_context, real_aligned_alloc, "LL", align, size);
+    }
     return box_memalign(align, size);
 }
 
 EXPORT int posix_memalign(void** p, size_t align, size_t size)
 {
+    if(malloc_hack_2 && real_posix_memalign) {
+        return RunFunctionFmt(my_context, real_posix_memalign, "pLL", p, align, size);
+    }
     if(align%sizeof(void*) || pot(align)!=align)
         return EINVAL;
     void* ret = box_memalign(align, size);
@@ -253,11 +272,17 @@ EXPORT int posix_memalign(void** p, size_t align, size_t size)
 
 EXPORT void* valloc(size_t size)
 {
+    if(malloc_hack_2 && real_valloc) {
+        return (void*)RunFunctionFmt(my_context, real_valloc, "L", size);
+    }
     return box_memalign(box64_pagesize, size);
 }
 
 EXPORT void* pvalloc(size_t size)
 {
+    if(malloc_hack_2 && real_pvalloc) {
+        return (void*)RunFunctionFmt(my_context, real_pvalloc, "L", size);
+    }
     return box_memalign(box64_pagesize, (size+box64_pagesize-1)&~(box64_pagesize-1));
 }
 
@@ -277,26 +302,41 @@ EXPORT void cfree(void* p)
 
 EXPORT size_t malloc_usable_size(void* p)
 {
+    if(malloc_hack_2 && real_malloc_usable_size) {
+        return RunFunctionFmt(my_context, real_malloc_usable_size, "p", p);
+    }
     return box_malloc_usable_size(p);
 }
 
 EXPORT void* my__Znwm(size_t sz)   //operator new(size_t)
 {
+    if(malloc_hack_2 && real__Znwm) {
+        return (void*)RunFunctionFmt(my_context, real__Znwm, "L", sz);
+    }
     return box_malloc(sz);
 }
 
 EXPORT void* my__ZnwmRKSt9nothrow_t(size_t sz, void* p)   //operator new(size_t, std::nothrow_t const&)
 {
+    if(malloc_hack_2 && real__ZnwmRKSt9nothrow_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnwmRKSt9nothrow_t, "Lp", sz, p);
+    }
     return box_malloc(sz);
 }
 
 EXPORT void* my__Znam(size_t sz)   //operator new[](size_t)
 {
+    if(malloc_hack_2 && real__Znam) {
+        return (void*)RunFunctionFmt(my_context, real__Znam, "L", sz);
+    }
     return box_malloc(sz);
 }
 
 EXPORT void* my__ZnamRKSt9nothrow_t(size_t sz, void* p)   //operator new[](size_t, std::nothrow_t const&)
 {
+    if(malloc_hack_2 && real__ZnamRKSt9nothrow_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnamRKSt9nothrow_t, "Lp", sz, p);
+    }
     return box_malloc(sz);
 }
 
@@ -307,8 +347,8 @@ EXPORT void my__ZdaPv(void* p)   //operator delete[](void*)
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdaPv)
+                RunFunctionFmt(my_context, real__ZdaPv, "p", p);
             return;
         }
     }
@@ -321,8 +361,8 @@ EXPORT void my__ZdaPvm(void* p, size_t sz)   //operator delete[](void*, size_t)
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdaPvm)
+                RunFunctionFmt(my_context, real__ZdaPvm, "pL", p, sz);
             return;
         }
     }
@@ -335,8 +375,8 @@ EXPORT void my__ZdaPvmSt11align_val_t(void* p, size_t sz, size_t align)   //oper
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdaPvmSt11align_val_t)
+                RunFunctionFmt(my_context, real__ZdaPvmSt11align_val_t, "pLL", p, sz, align);
             return;
         }
     }
@@ -349,8 +389,8 @@ EXPORT void my__ZdlPv(void* p)   //operator delete(void*)
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdlPv)
+                RunFunctionFmt(my_context, real__ZdlPv, "p", p);
             return;
         }
     }
@@ -363,8 +403,8 @@ EXPORT void my__ZdlPvm(void* p, size_t sz)   //operator delete(void*, size_t)
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdlPvm)
+                RunFunctionFmt(my_context, real__ZdlPvm, "pL", p, sz);
             return;
         }
     }
@@ -373,21 +413,33 @@ EXPORT void my__ZdlPvm(void* p, size_t sz)   //operator delete(void*, size_t)
 
 EXPORT void* my__ZnwmSt11align_val_t(size_t sz, size_t align)  //// operator new(unsigned long, std::align_val_t)
 {
+    if(malloc_hack_2 && real__ZnwmSt11align_val_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnwmSt11align_val_t, "LL", sz, align);
+    }
     return box_memalign(align, sz);
 }
 
 EXPORT void* my__ZnwmSt11align_val_tRKSt9nothrow_t(size_t sz, size_t align, void* p)  //// operator new(unsigned long, std::align_val_t, std::nothrow_t const&)
 {
+    if(malloc_hack_2 && real__ZnwmSt11align_val_tRKSt9nothrow_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnwmSt11align_val_tRKSt9nothrow_t, "LLp", sz, align, p);
+    }
     return box_memalign(align, sz);
 }
 
 EXPORT void* my__ZnamSt11align_val_t(size_t sz, size_t align)  //// operator new[](unsigned long, std::align_val_t)
 {
+    if(malloc_hack_2 && real__ZnamSt11align_val_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnamSt11align_val_t, "LL", sz, align);
+    }
     return box_memalign(align, sz);
 }
 
 EXPORT void* my__ZnamSt11align_val_tRKSt9nothrow_t(size_t sz, size_t align, void* p)  //// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
 {
+    if(malloc_hack_2 && real__ZnamSt11align_val_tRKSt9nothrow_t) {
+        return (void*)RunFunctionFmt(my_context, real__ZnamSt11align_val_tRKSt9nothrow_t, "LLp", sz, align, p);
+    }
     return box_memalign(align, sz);
 }
 
@@ -397,8 +449,8 @@ EXPORT void my__ZdlPvRKSt9nothrow_t(void* p, void* n)   //operator delete(void*,
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdlPvRKSt9nothrow_t)
+                RunFunctionFmt(my_context, real__ZdlPvRKSt9nothrow_t, "pp", p, n);
             return;
         }
     }
@@ -481,8 +533,8 @@ EXPORT void my__ZdlPvSt11align_val_tRKSt9nothrow_t(void* p, size_t align, void*
         if(getMmapped((uintptr_t)p)) {
             printf_log(LOG_DEBUG, "%04d|Malloc_Hack_2: not freeing %p\n", GetTID(), p);
             // Mmaped, free with original function
-            if(real_free)
-                RunFunctionFmt(my_context, real_free, "p", p);
+            if(real__ZdlPvSt11align_val_tRKSt9nothrow_t)
+                RunFunctionFmt(my_context, real__ZdlPvSt11align_val_tRKSt9nothrow_t, "pLp", p, align, n);
             return;
         }
     }
@@ -712,12 +764,10 @@ typedef struct simple_jmp_s {
 } simple_jmp_t;
 #pragma pack(pop)
 
-static void addRelocJmp(void* offs, void* where, size_t size, const char* name, elfheader_t* h)
+static void addRelocJmp(void* offs, void* where, size_t size, const char* name, elfheader_t* h, uintptr_t *real)
 {
-    if(malloc_hack_2 && !real_free && !strcmp(name, "free")) {
-        real_free = (uintptr_t)offs;
-    } else if(malloc_hack_2 && !real_realloc && !strcmp(name, "realloc")) {
-        real_realloc = (uintptr_t)offs;
+    if(malloc_hack_2 && !*real) {
+        *real = (uintptr_t)offs;
     }
     AddSymbol(h->mapsymbols, name, (uintptr_t)where, size, 1, NULL);
     AddSymbol(h->mapsymbols, name, (uintptr_t)offs, size, 0, NULL);
@@ -750,8 +800,6 @@ void checkHookedSymbols(elfheader_t* h)
     }
     if(hooked<2)
         return; // only redirect on lib that hooked / redefined the operators
-    if(box64_malloc_hack==2)
-        malloc_hack_2 = 1;
     printf_log(LOG_INFO, "Redirecting overridden malloc%s function for %s\n", malloc_hack_2?" with hack":"", ElfName(h));
     for (size_t i=0; i<h->numDynSym; ++i) {
         const char * symname = h->DynStr+h->DynSym[i].st_name;
@@ -763,19 +811,21 @@ void checkHookedSymbols(elfheader_t* h)
             uintptr_t offs = h->DynSym[i].st_value + h->delta;
             size_t sz = h->DynSym[i].st_size;
             if(bind!=STB_LOCAL && bind!=STB_WEAK) {
-                #define GO(A, B) if(!strcmp(symname, "__libc_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, "__libc_" #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, "__libc_" #A, h);}
+                #define GO(A, B) if(!strcmp(symname, "__libc_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, "__libc_" #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, "__libc_" #A, h, &real_##A);}
                 #define GO2(A, B)
                 SUPER()
                 #undef GO
                 #undef GO2
-                #define GO(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A, h);}
-                #define GO2(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, my_##A, 0, "my_" #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, "my_" #A, h);}
+                #define GO(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A, h, &real_##A);}
+                #define GO2(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, my_##A, 0, "my_" #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, "my_" #A, h, &real_##A);}
                 SUPER()
                 #undef GO
                 #undef GO2
             }
         }
     }
+    if(box64_malloc_hack==2)
+        malloc_hack_2 = 1;
 }
 
 EXPORT int my___TBB_internal_find_original_malloc(int n, char* names[], void* ptr[])