From d78f381862c05f299bade9d0a8e4fa822ddeadd1 Mon Sep 17 00:00:00 2001 From: John Lindgren Date: Sun, 24 Mar 2024 21:29:05 -0400 Subject: [PATCH 1/4] Guard against arithmetic overflows and handle malloc(0) correctly --- tinyalloc.c | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/tinyalloc.c b/tinyalloc.c index eb9fa3f..2108fab 100644 --- a/tinyalloc.c +++ b/tinyalloc.c @@ -159,9 +159,16 @@ static Block *alloc_block(size_t num) { Block *ptr = heap->free; Block *prev = NULL; size_t top = heap->top; - num = (num + heap_alignment - 1) & -heap_alignment; + if (num > -heap_alignment) { + return NULL; // prevent overflow + } + num = (num + heap_alignment - 1) & -heap_alignment; + if (num == 0) { + num = heap_alignment; // prevent zero-size block + } while (ptr != NULL) { - const int is_top = ((size_t)ptr->addr + ptr->size >= top) && ((size_t)ptr->addr + num <= (size_t)heap_limit); + const int is_top = ((size_t)ptr->addr + ptr->size >= top) && + (num <= (size_t)heap_limit - (size_t)ptr->addr); if (is_top || ptr->size >= num) { if (prev != NULL) { prev->next = ptr->next; @@ -199,15 +206,14 @@ static Block *alloc_block(size_t num) { } // no matching free blocks // see if any other blocks available - size_t new_top = top + num; - if (heap->fresh != NULL && new_top <= (size_t)heap_limit) { + if (heap->fresh != NULL && (num <= (size_t)heap_limit - top)) { ptr = heap->fresh; heap->fresh = ptr->next; ptr->addr = (void *)top; ptr->next = heap->used; ptr->size = num; heap->used = ptr; - heap->top = new_top; + heap->top = top + num; return ptr; } return NULL; @@ -235,7 +241,11 @@ static void memclear(void *ptr, size_t num) { } void *ta_calloc(size_t num, size_t size) { + size_t orig = num; num *= size; + if (size != 0 && num / size != orig) { + return NULL; // overflow + } Block *block = alloc_block(num); if (block != NULL) { memclear(block->addr, num); From 1728acae2aa9571c289c721b8027d1d2783ed5b9 Mon Sep 17 00:00:00 2001 From: John Lindgren Date: Sun, 24 Mar 2024 22:24:07 -0400 Subject: [PATCH 2/4] Add early NULL check to ta_free() (optimization) --- tinyalloc.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tinyalloc.c b/tinyalloc.c index 2108fab..148751e 100644 --- a/tinyalloc.c +++ b/tinyalloc.c @@ -134,6 +134,9 @@ bool ta_init(const void *base, const void *limit, const size_t heap_blocks, cons } bool ta_free(void *free) { + if (free == NULL) { + return false; + } Block *block = heap->used; Block *prev = NULL; while (block != NULL) { From 44c4678fa510283882211e90a6bb751e947b052c Mon Sep 17 00:00:00 2001 From: John Lindgren Date: Sun, 24 Mar 2024 23:41:44 -0400 Subject: [PATCH 3/4] Implement ta_getsize() and ta_realloc() --- tinyalloc.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++- tinyalloc.h | 2 ++ 2 files changed, 55 insertions(+), 1 deletion(-) diff --git a/tinyalloc.c b/tinyalloc.c index 148751e..9fecf50 100644 --- a/tinyalloc.c +++ b/tinyalloc.c @@ -243,6 +243,21 @@ static void memclear(void *ptr, size_t num) { } } +static void memcopy(void *dst, void *src, size_t num) { + size_t *dstw = (size_t *)dst; + size_t *srcw = (size_t *)src; + size_t numw = (num & -sizeof(size_t)) / sizeof(size_t); + while (numw--) { + *dstw++ = *srcw++; + } + num &= (sizeof(size_t) - 1); + uint8_t *dstb = (uint8_t *)dstw; + uint8_t *srcb = (uint8_t *)srcw; + while (num--) { + *dstb++ = *srcb++; + } +} + void *ta_calloc(size_t num, size_t size) { size_t orig = num; num *= size; @@ -251,7 +266,44 @@ void *ta_calloc(size_t num, size_t size) { } Block *block = alloc_block(num); if (block != NULL) { - memclear(block->addr, num); + memclear(block->addr, block->size); + return block->addr; + } + return NULL; +} + +size_t ta_getsize(void *ptr) { + if (ptr == NULL) { + return 0; + } + Block *block = heap->used; + while (block != NULL) { + if (ptr == block->addr) { + return block->size; + } + block = block->next; + } + return 0; +} + +void *ta_realloc(void *ptr, size_t num) { + if (ptr == NULL) { + return ta_alloc(num); + } else if (num == 0) { + ta_free(ptr); + return NULL; + } + size_t size = ta_getsize(ptr); + if (num <= size && size - num <= heap_split_thresh) { + return ptr; // keep current block + } + Block *block = alloc_block(num); + if (block != NULL) { + if (size > num) { + size = num; + } + memcopy(block->addr, ptr, size); + ta_free(ptr); return block->addr; } return NULL; diff --git a/tinyalloc.h b/tinyalloc.h index 113f147..2ea0a2f 100644 --- a/tinyalloc.h +++ b/tinyalloc.h @@ -8,6 +8,8 @@ extern "C" { bool ta_init(const void *base, const void *limit, const size_t heap_blocks, const size_t split_thresh, const size_t alignment); void *ta_alloc(size_t num); void *ta_calloc(size_t num, size_t size); +size_t ta_getsize(void *ptr); +void *ta_realloc(void *ptr, size_t num); bool ta_free(void *ptr); size_t ta_num_free(); From fce0c31c86f32fbbd6be32970931af1047488484 Mon Sep 17 00:00:00 2001 From: John Lindgren Date: Sat, 23 Mar 2024 15:34:13 -0400 Subject: [PATCH 4/4] Optional better C stdlib integration - Optionally set errno to ENOMEM when out of memory - Optionally use memset() to implement memclear() - Optionally use memcpy() to implement memcopy() --- tinyalloc.c | 34 +++++++++++++++++++++++++++------- 1 file changed, 27 insertions(+), 7 deletions(-) diff --git a/tinyalloc.c b/tinyalloc.c index 9fecf50..96f02d3 100644 --- a/tinyalloc.c +++ b/tinyalloc.c @@ -9,6 +9,12 @@ extern void print_i(size_t); #define print_i(X) #endif +/* optional C stdlib integration */ +#ifdef TA_USE_STDLIB +#include +#include +#endif + typedef struct Block Block; struct Block { @@ -227,9 +233,16 @@ void *ta_alloc(size_t num) { if (block != NULL) { return block->addr; } +#ifdef TA_USE_STDLIB + errno = ENOMEM; +#endif return NULL; } +#ifdef TA_USE_STDLIB +#define memclear(ptr, num) memset((ptr), 0, (num)) +#define memcopy(dst, src, num) memcpy((dst), (src), (num)) +#else static void memclear(void *ptr, size_t num) { size_t *ptrw = (size_t *)ptr; size_t numw = (num & -sizeof(size_t)) / sizeof(size_t); @@ -257,18 +270,22 @@ static void memcopy(void *dst, void *src, size_t num) { *dstb++ = *srcb++; } } +#endif void *ta_calloc(size_t num, size_t size) { size_t orig = num; num *= size; - if (size != 0 && num / size != orig) { - return NULL; // overflow - } - Block *block = alloc_block(num); - if (block != NULL) { - memclear(block->addr, block->size); - return block->addr; + // check for overflow + if (size == 0 || num / size == orig) { + Block *block = alloc_block(num); + if (block != NULL) { + memclear(block->addr, block->size); + return block->addr; + } } +#ifdef TA_USE_STDLIB + errno = ENOMEM; +#endif return NULL; } @@ -306,6 +323,9 @@ void *ta_realloc(void *ptr, size_t num) { ta_free(ptr); return block->addr; } +#ifdef TA_USE_STDLIB + errno = ENOMEM; +#endif return NULL; }