Merge openenclave#2303

2303: Add malloc_usable_size r=CodeMonkeyLeet a=thomasten



Co-authored-by: Thomas Tendyck <[email protected]>

docs/LibcSupport.md

@@ -12,7 +12,7 @@ inttypes.h | Partial | **Unsupported functions:** imaxabs(), imaxdiv() |
 iso646.h | Yes | - |
 limits.h | Yes | - |
 locale.h | Partial | Only basic support for C/POSIX locale |
-malloc.h | Partial | **Unsupported functions:** malloc_usable_size() |
+malloc.h | Partial | - |
 math.h | Partial | **Unsupported functions:** acosh(), asinh(), fmal(), lgamma(), lgammaf(), sinh(), sinhl(), tgamma() |
 setjmp.h | Yes | - |
 signal.h | No | - |

enclave/core/debugmalloc.c

@@ -430,6 +430,13 @@ int oe_debug_posix_memalign(void** memptr, size_t alignment, size_t size)
     return 0;
 }
 
+size_t oe_debug_malloc_usable_size(void* ptr)
+{
+    if (!ptr)
+        return 0;
+    return _get_header(ptr)->size;
+}
+
 void oe_debug_malloc_dump(void)
 {
     _dump(true);

enclave/core/debugmalloc.h

@@ -18,4 +18,6 @@ void* oe_debug_memalign(size_t alignment, size_t size);
 
 int oe_debug_posix_memalign(void** memptr, size_t alignment, size_t size);
 
+size_t oe_debug_malloc_usable_size(void* ptr);
+
 #endif /* _OE_DEBUG_MALLOC_H */

enclave/core/malloc.c

@@ -51,13 +51,15 @@ static int _dlmalloc_stats_fprintf(FILE* stream, const char* format, ...);
 #define MEMALIGN oe_debug_memalign
 #define POSIX_MEMALIGN oe_debug_posix_memalign
 #define FREE oe_debug_free
+#define MALLOC_USABLE_SIZE oe_debug_malloc_usable_size
 #else
 #define MALLOC dlmalloc
 #define CALLOC dlcalloc
 #define REALLOC dlrealloc
 #define MEMALIGN dlmemalign
 #define POSIX_MEMALIGN dlposix_memalign
 #define FREE dlfree
+#define MALLOC_USABLE_SIZE dlmalloc_usable_size
 #endif
 
 static oe_allocation_failure_callback_t _failure_callback;
@@ -153,6 +155,11 @@ void* oe_memalign(size_t alignment, size_t size)
     return p;
 }
 
+size_t oe_malloc_usable_size(void* ptr)
+{
+    return MALLOC_USABLE_SIZE(ptr);
+}
+
 /*
 **==============================================================================
 **

include/openenclave/corelibc/bits/malloc.h

@@ -40,4 +40,10 @@ int posix_memalign(void** memptr, size_t alignment, size_t size)
     return oe_posix_memalign(memptr, alignment, size);
 }
 
+OE_INLINE
+size_t malloc_usable_size(void* ptr)
+{
+    return oe_malloc_usable_size(ptr);
+}
+
 #endif /* _OE_BITS_MALLOC_H */

include/openenclave/corelibc/stdlib.h

@@ -37,6 +37,8 @@ void* oe_memalign(size_t alignment, size_t size);
 
 int oe_posix_memalign(void** memptr, size_t alignment, size_t size);
 
+size_t oe_malloc_usable_size(void* ptr);
+
 unsigned long int oe_strtoul(const char* nptr, char** endptr, int base);
 
 long int oe_strtol(const char* nptr, char** endptr, int base);

tests/memory/enc/basic.c

@@ -5,6 +5,7 @@
 #include <openenclave/internal/globals.h>
 #include <openenclave/internal/tests.h>
 
+#include <malloc.h>
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -168,3 +169,31 @@ void test_posix_memalign(void)
     /* Should fail if alignment isn't possible. */
     OE_TEST(posix_memalign(&ptr, max, 64) != 0);
 }
+
+void test_malloc_usable_size(void)
+{
+    int* p1 = (int*)malloc(sizeof *p1);
+    OE_TEST(p1);
+    int* p2 = (int*)malloc(sizeof *p2);
+    OE_TEST(p2);
+
+    /* Ensure that p1 < p2 so that we can use p2 as upper bound. */
+    if (p1 > p2)
+    {
+        int* const tmp = p1;
+        p1 = p2;
+        p2 = tmp;
+    }
+    OE_TEST(p1 < p2);
+
+    const size_t s1 = malloc_usable_size(p1);
+    OE_TEST(sizeof *p1 <= s1 && s1 <= (size_t)(p2 - p1) * sizeof *p1);
+
+    OE_TEST(sizeof *p2 <= malloc_usable_size(p2));
+
+    const size_t end = s1 / sizeof *p1;
+    _set_buffer(p1, 0, end);
+    _check_buffer(p1, 0, end);
+    free(p1);
+    free(p2);
+}

tests/memory/host/host.cpp

@@ -22,6 +22,7 @@ static void _malloc_basic_test(oe_enclave_t* enclave)
     OE_TEST(test_realloc(enclave) == OE_OK);
     OE_TEST(test_memalign(enclave) == OE_OK);
     OE_TEST(test_posix_memalign(enclave) == OE_OK);
+    OE_TEST(test_malloc_usable_size(enclave) == OE_OK);
 }
 
 static void _malloc_stress_test_single_thread(

tests/memory/memory.edl

@@ -13,6 +13,7 @@ enclave {
         public void test_realloc();
         public void test_memalign();
         public void test_posix_memalign();
+        public void test_malloc_usable_size();
 
         public void init_malloc_stress_test();
         public void malloc_stress_test(int threads);