revert detection of partially-replaced allocator

commit c9f415d7ea2dace5bf77f6518b6afc36bb7a5732 included checks to
make calloc fallback to memset if used with a replaced malloc that
didn't also replace calloc, and the memalign family fail if free has
been replaced. however, the checks gave false positives for
replacement whenever malloc or free resolved to a PLT entry in the
main program.

for now, disable the checks so as not to leave libc in a broken state.
this means that the properties documented in the above commit are no
longer satisfied; failure to replace calloc and the memalign family
along with malloc is unsafe if they are ever called.

the calloc checks were correct but useless for static linking. in both
cases (simple or full malloc), calloc and malloc are in a source file
together, so replacement of one but not the other would give linking
errors. the memalign-family check was useful for static linking, but
broken for dynamic as described above, and can be replaced with a
better link-time check.

diff --git a/src/malloc/lite_malloc.c b/src/malloc/lite_malloc.c
index 29cccb10cb1b7ab00ea51687a1718ec233dc28b8..96c4feacddc4d253c72827a4e4461f939e5f2d4b 100644 (file)
--- a/src/malloc/lite_malloc.c
+++ b/src/malloc/lite_malloc.c
@@ -50,7 +50,7 @@ weak_alias(__simple_malloc, malloc);
 
 static void *__simple_calloc(size_t m, size_t n)
 {
-       if (n && m > (size_t)-1/n || malloc != __simple_malloc) {
+       if (n && m > (size_t)-1/n) {
                errno = ENOMEM;
                return 0;
        }

diff --git a/src/malloc/malloc.c b/src/malloc/malloc.c
index 5a56e0c59a5da51f246da1a732694b3085b2b763..da77592162c19f1560462072de42796b3c6a7d16 100644 (file)
--- a/src/malloc/malloc.c
+++ b/src/malloc/malloc.c
@@ -368,8 +368,6 @@ void *malloc(size_t n)
        return CHUNK_TO_MEM(c);
 }
 
-weak_alias(malloc, __internal_malloc);
-
 static size_t mal0_clear(char *p, size_t pagesz, size_t n)
 {
 #ifdef __GNUC__
@@ -396,13 +394,10 @@ void *calloc(size_t m, size_t n)
        }
        n *= m;
        void *p = malloc(n);
-       if (!p) return p;
-       if (malloc == __internal_malloc) {
-               if (IS_MMAPPED(MEM_TO_CHUNK(p)))
-                       return p;
-               if (n >= PAGE_SIZE)
-                       n = mal0_clear(p, PAGE_SIZE, n);
-       }
+       if (!p || IS_MMAPPED(MEM_TO_CHUNK(p)))
+               return p;
+       if (n >= PAGE_SIZE)
+               n = mal0_clear(p, PAGE_SIZE, n);
        return memset(p, 0, n);
 }
 
@@ -568,8 +563,6 @@ void free(void *p)
                bin_chunk(self);
 }
 
-weak_alias(free, __internal_free);
-
 void __malloc_donate(char *start, char *end)
 {
        size_t align_start_up = (SIZE_ALIGN-1) & (-(uintptr_t)start - OVERHEAD);

diff --git a/src/malloc/memalign.c b/src/malloc/memalign.c
index 35b67599b1c2a22b7213f9f97f1671d2ecfa9517..8fb2002ca87ce0ad6a577bd3977691eefa50f497 100644 (file)
--- a/src/malloc/memalign.c
+++ b/src/malloc/memalign.c
@@ -3,8 +3,6 @@
 #include <errno.h>
 #include "libc.h"
 
-void __internal_free(void *);
-
 void *__memalign(size_t align, size_t len)
 {
        unsigned char *mem, *new, *end;
@@ -15,7 +13,7 @@ void *__memalign(size_t align, size_t len)
                return NULL;
        }
 
-       if (len > SIZE_MAX - align || free != __internal_free) {
+       if (len > SIZE_MAX - align) {
                errno = ENOMEM;
                return NULL;
        }