bypass overridden functions for self

Signed-off-by: Tavi <[email protected]>

Author: SkewedZeppelin

h_malloc.c

@@ -528,7 +528,7 @@ static void set_canary(UNUSED const struct slab_metadata *metadata, UNUSED void
     }
 #endif
 
-    memcpy((char *)p + size - canary_size, &metadata->canary_value, canary_size);
+    h_memcpy_real((char *)p + size - canary_size, &metadata->canary_value, canary_size);
 #endif
 }
 
@@ -541,7 +541,7 @@ static void check_canary(UNUSED const struct slab_metadata *metadata, UNUSED con
 #endif
 
     u64 canary_value;
-    memcpy(&canary_value, (const char *)p + size - canary_size, canary_size);
+    h_memcpy_real(&canary_value, (const char *)p + size - canary_size, canary_size);
 
 #ifdef HAS_ARM_MTE
     if (unlikely(canary_value == 0)) {
@@ -831,7 +831,7 @@ static inline void deallocate_small(void *p, const size_t *expected_size) {
 #endif
 
         if (ZERO_ON_FREE && !skip_zero) {
-            memset(p, 0, size - canary_size);
+            h_memset_real(p, 0, size - canary_size);
         }
     }
 
@@ -1502,7 +1502,7 @@ EXPORT void *h_calloc(size_t nmemb, size_t size) {
     total_size = adjust_size_for_canary(total_size);
     void *p = alloc(total_size);
     if (!ZERO_ON_FREE && likely(p != NULL) && total_size && total_size <= max_slab_size_class) {
-        memset(p, 0, total_size - canary_size);
+        h_memset_real(p, 0, total_size - canary_size);
     }
 #ifdef HAS_ARM_MTE
     // use an assert instead of adding a conditional to memset() above (freed memory is always
@@ -1624,7 +1624,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
                 mutex_unlock(&ra->lock);
 
                 if (memory_remap_fixed(old, old_size, new, size)) {
-                    memcpy(new, old, copy_size);
+                    h_memcpy_real(new, old, copy_size);
                     deallocate_pages(old, old_size, old_guard_size);
                 } else {
                     memory_unmap((char *)old - old_guard_size, old_guard_size);
@@ -1646,7 +1646,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
     if (copy_size > 0 && copy_size <= max_slab_size_class) {
         copy_size -= canary_size;
     }
-    memcpy(new, old_orig, copy_size);
+    h_memcpy_real(new, old_orig, copy_size);
     if (old_size <= max_slab_size_class) {
         deallocate_small(old, NULL);
     } else {
@@ -1874,8 +1874,8 @@ EXPORT size_t h_malloc_object_size_fast(const void *p) {
     return SIZE_MAX;
 }
 
-#if CONFIG_BLOCK_OPS_CHECK_SIZE
 inline void *h_memcpy_real(void *dst, const void *src, size_t len) {
+#if CONFIG_BLOCK_OPS_CHECK_SIZE
     char *p_dst = (char *)dst;
     char const *p_src = (char const *)src;
 
@@ -1884,20 +1884,13 @@ inline void *h_memcpy_real(void *dst, const void *src, size_t len) {
     }
 
     return dst;
-}
-
-EXPORT void *h_memcpy(void *dst, const void *src, size_t len) {
-    if (len > malloc_object_size_fast(src)) {
-        fatal_error("memcpy read overflow");
-    }
-    if (len > malloc_object_size_fast(dst)) {
-        fatal_error("memcpy buffer overflow");
-    }
-
-    return h_memcpy_real(dst, src, len);
+#else
+    return memcpy(dst, src, len);
+#endif
 }
 
 inline void *h_memmove_real(void *dst, const void *src, size_t len) {
+#if CONFIG_BLOCK_OPS_CHECK_SIZE
     char *p_dst = (char *)dst;
     char const *p_src = (char const *)src;
 
@@ -1912,38 +1905,58 @@ inline void *h_memmove_real(void *dst, const void *src, size_t len) {
             *--p_dst = *--p_src;
         }
     } else {
-        dst = h_memcpy(dst, src, len);
+        dst = h_memcpy_real(dst, src, len);
     }
 
     return dst;
-}
-
-EXPORT void *h_memmove(void *dst, const void *src, size_t len) {
-    if (len > malloc_object_size_fast(src)) {
-        fatal_error("memmove read overflow");
-    }
-    if (len > malloc_object_size_fast(dst)) {
-        fatal_error("memmove buffer overflow");
-    }
-
-    return h_memmove_real(dst, src, len);
+#else
+    return memmove(dst, src, len);
+#endif
 }
 
 inline void *h_memset_real(void *dst, int value, size_t len) {
+#if CONFIG_BLOCK_OPS_CHECK_SIZE
     char *p_dst = (char *)dst;
 
     while(len--) {
         *p_dst++ = value;
     }
 
     return dst;
+#else
+    return memset(dst, value, len);
+#endif
 }
 
-EXPORT void *h_memset(void *dst, int value, size_t len) {
+#if CONFIG_BLOCK_OPS_CHECK_SIZE
+EXPORT void *h_memcpy(void *dst, const void *src, size_t len) {
+    if (len > malloc_object_size_fast(src)) {
+        fatal_error("memcpy read overflow");
+    }
     if (len > malloc_object_size_fast(dst)) {
-        fatal_error("memset buffer overflow");
+        fatal_error("memcpy buffer overflow");
     }
 
+    return h_memcpy_real(dst, src, len);
+}
+
+EXPORT void *h_memmove(void *dst, const void *src, size_t len) {
+    if (len > malloc_object_size_fast(src)) {
+        fatal_error("memmove read overflow");
+    }
+    if (len > malloc_object_size_fast(dst)) {
+        fatal_error("memmove buffer overflow");
+    }
+
+    return h_memmove_real(dst, src, len);
+}
+
+EXPORT void *h_memset(void *dst, int value, size_t len) {
+    //if (len > malloc_object_size_fast(dst)) {
+    //    fatal_error("memset buffer overflow");
+    //}
+    fprintf(stderr, "memset: dst: %p, value: %d len: %zu\n", dst, value, len);
+
     return h_memset_real(dst, value, len);
 }
 #endif

include/h_malloc.h

@@ -59,12 +59,12 @@ __attribute__((alloc_size(2))) void *h_realloc(void *ptr, size_t size);
 __attribute__((malloc)) __attribute__((alloc_size(2))) __attribute__((alloc_align(1)))
 void *h_aligned_alloc(size_t alignment, size_t size);
 void h_free(void *ptr);
-#if CONFIG_BLOCK_OPS_CHECK_SIZE
 void *h_memcpy_real(void *dst, const void *src, size_t len);
-void *h_memcpy(void *dst, const void *src, size_t len);
 void *h_memmove_real(void *dst, const void *src, size_t len);
-void *h_memmove(void *dst, const void *src, size_t len);
 void *h_memset_real(void *dst, int value, size_t len);
+#if CONFIG_BLOCK_OPS_CHECK_SIZE
+void *h_memcpy(void *dst, const void *src, size_t len);
+void *h_memmove(void *dst, const void *src, size_t len);
 void *h_memset(void *dst, int value, size_t len);
 #endif