From c9f415d7ea2dace5bf77f6518b6afc36bb7a5732 Mon Sep 17 00:00:00 2001 From: Rich Felker Date: Tue, 17 Apr 2018 18:36:19 -0400 Subject: [PATCH] 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. --- dynamic.list | 9 +++++++++ src/malloc/calloc.c | 13 ------------- src/malloc/lite_malloc.c | 12 +++++++++++- src/malloc/malloc.c | 22 +++++++++++++++++----- src/malloc/memalign.c | 6 ++---- 5 files changed, 39 insertions(+), 23 deletions(-) delete mode 100644 src/malloc/calloc.c diff --git a/dynamic.list b/dynamic.list index 8b4f2366..686f8eb4 100644 --- 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 index 436c0b03..00000000 --- a/src/malloc/calloc.c +++ /dev/null @@ -1,13 +0,0 @@ -#include -#include - -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 701f60b4..29cccb10 100644 --- 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 991300cc..5a56e0c5 100644 --- 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 006bd21c..35b67599 100644 --- a/src/malloc/memalign.c +++ b/src/malloc/memalign.c @@ -3,9 +3,7 @@ #include #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; } -- 2.25.1