allow interposition/replacement of allocator (malloc)

replacement is subject to conditions on the replacement functions.
they may only call functions which are async-signal-safe, as specified
either by POSIX or as an implementation-defined extension. if any
allocator functions are replaced, at least malloc, realloc, and free
must be provided. if calloc is not provided, it will behave as
malloc+memset. any of the memalign-family functions not provided will
fail with ENOMEM.

in order to implement the above properties, calloc and __memalign
check that they are using their own malloc or free, respectively.
choice to check malloc or free is based on considerations of
supporting __simple_malloc. in order to make this work, calloc is
split into separate versions for __simple_malloc and full malloc;
commit ba819787ee93ceae94efd274f7849e317c1bff58 already did most of
the split anyway, and completing it saves an extra call frame.

previously, use of -Bsymbolic-functions made dynamic interposition
impossible. now, we are using an explicit dynamic-list, so add
allocator functions to the list. most are not referenced anyway, but
all are added for completeness.

diff --git a/dynamic.list b/dynamic.list
index 8b4f236..686f8eb 100644 (file)
--- a/dynamic.list
+++ b/dynamic.list
@@ -6,6 +6,15 @@ stdin;
 stdout;
 stderr;
 
+malloc;
+calloc;
+realloc;
+free;
+memalign;
+posix_memalign;
+aligned_alloc;
+malloc_usable_size;
+
 timezone;
 daylight;
 tzname;

diff --git a/src/malloc/calloc.c b/src/malloc/calloc.c
deleted file mode 100644 (file)
index 436c0b0..0000000
--- a/src/malloc/calloc.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdlib.h>
-#include <errno.h>
-
-void *__malloc0(size_t);
-
-void *calloc(size_t m, size_t n)
-{
-       if (n && m > (size_t)-1/n) {
-               errno = ENOMEM;
-               return 0;
-       }
-       return __malloc0(n * m);
-}

diff --git a/src/malloc/lite_malloc.c b/src/malloc/lite_malloc.c
index 701f60b..29cccb1 100644 (file)
--- a/src/malloc/lite_malloc.c
+++ b/src/malloc/lite_malloc.c
@@ -47,4 +47,14 @@ static void *__simple_malloc(size_t n)
 }
 
 weak_alias(__simple_malloc, malloc);
-weak_alias(__simple_malloc, __malloc0);
+
+static void *__simple_calloc(size_t m, size_t n)
+{
+       if (n && m > (size_t)-1/n || malloc != __simple_malloc) {
+               errno = ENOMEM;
+               return 0;
+       }
+       return __simple_malloc(n * m);
+}
+
+weak_alias(__simple_calloc, calloc);

diff --git a/src/malloc/malloc.c b/src/malloc/malloc.c
index 991300c..5a56e0c 100644 (file)
--- a/src/malloc/malloc.c
+++ b/src/malloc/malloc.c
@@ -368,6 +368,8 @@ 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__
@@ -386,13 +388,21 @@ static size_t mal0_clear(char *p, size_t pagesz, size_t n)
        }
 }
 
-void *__malloc0(size_t n)
+void *calloc(size_t m, size_t n)
 {
+       if (n && m > (size_t)-1/n) {
+               errno = ENOMEM;
+               return 0;
+       }
+       n *= m;
        void *p = malloc(n);
-       if (!p || IS_MMAPPED(MEM_TO_CHUNK(p)))
-               return p;
-       if (n >= PAGE_SIZE)
-               n = mal0_clear(p, PAGE_SIZE, 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);
+       }
        return memset(p, 0, n);
 }
 
@@ -558,6 +568,8 @@ 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 006bd21..35b6759 100644 (file)
--- a/src/malloc/memalign.c
+++ b/src/malloc/memalign.c
@@ -3,9 +3,7 @@
 #include <errno.h>
 #include "libc.h"
 
-/* This function should work with most dlmalloc-like chunk bookkeeping
- * systems, but it's only guaranteed to work with the native implementation
- * used in this library. */
+void __internal_free(void *);
 
 void *__memalign(size_t align, size_t len)
 {
@@ -17,7 +15,7 @@ void *__memalign(size_t align, size_t len)
                return NULL;
        }
 
-       if (len > SIZE_MAX - align) {
+       if (len > SIZE_MAX - align || free != __internal_free) {
                errno = ENOMEM;
                return NULL;
        }