fix memalign error in debug-malloc

kernel/debugmalloc.c

@@ -5,9 +5,11 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <assert.h>
 #include <string.h>
 
 #include <myst/backtrace.h>
+#include <myst/printf.h>
 #include <myst/debugmalloc.h>
 #include <myst/defs.h>
 #include <myst/malloc.h>
@@ -20,6 +22,8 @@
 #define ENABLE_MALLOC_MEMSET
 #define ENABLE_FREE_MEMSET
 
+// #define DEBUG_MEMALIGN
+
 /*
 **==============================================================================
 **
@@ -173,6 +177,12 @@ MYST_INLINE void* _get_block_address(void* ptr)
     return (uint8_t*)ptr - sizeof(header_t) - padding_size;
 }
 
+MYST_INLINE void* _get_block_address_v2(void* ptr)
+{
+    header_t* header = _get_header(ptr);
+    return (uint8_t*)header - header->padding;
+}
+
 MYST_INLINE size_t _calculate_block_size(size_t alignment, size_t size)
 {
     size_t r = 0;
@@ -330,6 +340,17 @@ void myst_debug_free(void* ptr)
 
         void* block = _get_block_address(ptr);
 
+        /* sanity cross check for block address */
+        if (block != _get_block_address_v2(ptr))
+        {
+            assert("_get_block_address_v2() failed");
+        }
+
+#ifdef DEBUG_MEMALIGN
+        printf("free: block=%p header=%p delta=%zu\n",
+            block, header, (const uint8_t*)header - (const uint8_t*)block);
+#endif
+
         /* fill block with 0xdd (deallocated) bytes */
 #ifdef ENABLE_FREE_MEMSET
         memset(block, 0xDD, _get_block_size(ptr));
@@ -393,10 +414,39 @@ int myst_debug_posix_memalign(void** memptr, size_t alignment, size_t size)
     const size_t block_size = _calculate_block_size(alignment, size);
     void* block = NULL;
     header_t* header = NULL;
+    size_t rsize = _round_up_to_multiple(size, sizeof(uint64_t));
+
+    if (memptr)
+        *memptr = NULL;
 
     if (!memptr)
         return EINVAL;
 
+    /*
+    ** [padding][header][block][footer]
+    ** ^                ^
+    ** |                |
+    ** X                Y
+    **
+    ** Note: both X and Y are on the alignment boundary
+    */
+
+#ifdef DEBUG_MEMALIGN
+    printf("memalign: padding=%zu header=%zu block=%zu footer=%zu\n",
+        padding_size, sizeof(header_t), size, sizeof(footer_t));
+#endif
+
+    /* the sum of the parts should add up to total block size */
+    if (padding_size + sizeof(header_t) + rsize + sizeof(footer_t)
+        != block_size)
+    {
+        return EINVAL;
+    }
+
+    /* the data should be aligned on the given boundary */
+    if ((padding_size + sizeof(header_t)) % alignment)
+        return EINVAL;
+
     if (!_is_ptrsize_multiple(alignment) || !_is_pow2(alignment))
         return EINVAL;
 
@@ -421,6 +471,7 @@ void* myst_debug_memalign(size_t alignment, size_t size)
     alignment = _round_up_to_multiple(alignment, sizeof(void*));
 
     myst_debug_posix_memalign(&ptr, alignment, size);
+
     return ptr;
 }
 

tests/debugmalloc/Makefile

@@ -26,7 +26,10 @@ ifdef PERF
 OPTS += --perf
 endif
 
-OPTS += --thread-stack-size=1048576 --crt-memcheck
+OPTS += --thread-stack-size=1048576
+OPTS += --crt-memcheck
+OPTS += --nobrk
+#OPTS += --memory-size=1g
 
 tests: all
 	$(RUNTEST) $(MYST_EXEC) rootfs /bin/debugmalloc $(OPTS)

tests/debugmalloc/debugmalloc.c

@@ -3,6 +3,7 @@
 
 #define _GNU_SOURCE
 #include <assert.h>
+#include <malloc.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -44,8 +45,112 @@ void stop()
 {
 }
 
+void test_malloc()
+{
+    void** ptrs;
+    size_t* sizes;
+    const size_t n = 1024*10;
+
+    if (!(ptrs = calloc(n, sizeof(void*))))
+    {
+        fprintf(stderr, "calloc() failed\n");
+        exit(1);
+    }
+
+    if (!(sizes = calloc(n, sizeof(size_t))))
+    {
+        fprintf(stderr, "calloc() failed\n");
+        exit(1);
+    }
+
+    /* malloc */
+    for (size_t i = 0; i < n; i++)
+    {
+        size_t size = rand() % 64 + 1;
+
+        if (!(ptrs[i] = memalign(128, size)))
+        {
+            fprintf(stderr, "memalign() failed\n");
+            exit(1);
+        }
+
+        memset(ptrs[i], '\0', size);
+        sizes[i] = size;
+    }
+
+    /* realloc */
+    for (size_t i = 0; i < n; i++)
+    {
+        size_t size = rand() % 128 + 1;
+
+        memset(ptrs[i], '\0', sizes[i]);
+
+        if (!(ptrs[i] = realloc(ptrs[i], size)))
+        {
+            fprintf(stderr, "malloc() failed\n");
+            exit(1);
+        }
+
+        memset(ptrs[i], '\0', size);
+        sizes[i] = size;
+    }
+
+    /* clear */
+    for (size_t i = 0; i < n; i++)
+    {
+        memset(ptrs[i], '\0', sizes[i]);
+    }
+
+    /* free every other and allocate new */
+    for (size_t i = 0; i < n; i += 2)
+    {
+        size_t size = rand() % 128 + 1;
+
+        memset(ptrs[i], '\0', sizes[i]);
+        free(ptrs[i]);
+        ptrs[i] = NULL;
+        sizes[i] = 0;
+
+        if (!(ptrs[i] = malloc(size)))
+        {
+            fprintf(stderr, "malloc() failed\n");
+            exit(1);
+        }
+
+        memset(ptrs[i], '\0', size);
+        sizes[i] = size;
+    }
+
+    /* free */
+    for (size_t i = 0; i < n; i++)
+    {
+        memset(ptrs[i], '\0', sizes[i]);
+        free(ptrs[i]);
+        sizes[i] = 0;
+        ptrs[i] = NULL;
+    }
+
+    free(ptrs);
+    free(sizes);
+}
+
+void test_malloc2()
+{
+    void* ptr;
+
+    if (!(ptr = memalign(256, 16)))
+    {
+        fprintf(stderr, "memalign() failed\n");
+        exit(1);
+    }
+    free(ptr);
+}
+
 int main(int argc, const char* argv[])
 {
+    test_malloc();
+    debug_malloc_check(true);
+
     size_t count;
     a();
 

third_party/musl/crt/patch.diff

@@ -963,19 +963,33 @@ index 672b518a..0f9a8057 100644
 +    return libc_malloc_usable_size(p);
 +}
 diff --git a/src/malloc/memalign.c b/src/malloc/memalign.c
-index cf9dfbda..1aba670c 100644
+index cf9dfbda..ac1fca21 100644
 --- a/src/malloc/memalign.c
 +++ b/src/malloc/memalign.c
-@@ -3,7 +3,7 @@
+@@ -3,7 +3,9 @@
  #include <errno.h>
  #include "malloc_impl.h"
 
 -void *__memalign(size_t align, size_t len)
++void *libc_malloc(size_t n);
++
 +void *libc_memalign(size_t align, size_t len)
  {
  	unsigned char *mem, *new;
 
-@@ -51,4 +51,14 @@ void *__memalign(size_t align, size_t len)
+@@ -18,9 +20,9 @@ void *__memalign(size_t align, size_t len)
+ 	}
+
+ 	if (align <= SIZE_ALIGN)
+-		return malloc(len);
++		return libc_malloc(len);
+
+-	if (!(mem = malloc(len + align-1)))
++	if (!(mem = libc_malloc(len + align-1)))
+ 		return 0;
+
+ 	new = (void *)((uintptr_t)mem + align-1 & -align);
+@@ -51,4 +53,14 @@ void *__memalign(size_t align, size_t len)
  	return new;
  }