Loading...
--- libmalloc/libmalloc-521.120.7/src/malloc_exclaves.c
+++ libmalloc/libmalloc-792.1.1/src/malloc_exclaves.c
@@ -27,6 +27,9 @@
#define MAX_MALLOC_ZONES 2
+#define DEFAULT_MALLOC_ZONE_STRING "DefaultXzoneZone"
+#define DEFAULT_SANITIZER_ZONE_STRING "DefaultWrapperSanitizerZone"
+
MALLOC_NOEXPORT
unsigned int phys_ncpus = 0;
@@ -38,6 +41,8 @@
malloc_zone_t ** __unsafe_indexable malloc_zones = _malloc_zones;
bool malloc_sanitizer_enabled = false;
+
+
#if __LIBLIBC_F_ASAN_INSTRUMENTATION
static struct malloc_sanitizer_poison malloc_poison_default = {
.heap_allocate_poison = __asan_poison_heap_memory_alloc,
@@ -53,7 +58,7 @@
malloc_zero_policy_t malloc_zero_policy = MALLOC_ZERO_POLICY_DEFAULT;
static inline malloc_zone_t *
-find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
+_find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
bool known_non_default)
{
malloc_zone_t *zone;
@@ -87,6 +92,13 @@
return zone;
}
+malloc_zone_t *
+find_registered_zone(const void * __unsafe_indexable ptr, size_t *returned_size,
+ bool known_non_default)
+{
+ return _find_registered_zone(ptr, returned_size, known_non_default);
+}
+
/********* Creation and destruction ************/
static void
@@ -134,15 +146,19 @@
logical_ncpus = _liblibc_plat_num_cpus;
phys_ncpus = _liblibc_plat_num_cpus;
+
const unsigned malloc_debug_flags = MALLOC_ABORT_ON_CORRUPTION |
MALLOC_ABORT_ON_ERROR;
- mfm_initialize();
- _malloc_zone_register(xzm_main_malloc_zone_create(malloc_debug_flags,
- NULL, args, NULL), true);
+ malloc_zone_t *xzone = xzm_main_malloc_zone_create(malloc_debug_flags,
+ NULL, args, NULL);
+ _malloc_zone_register(xzone, true);
+ malloc_set_zone_name(xzone, DEFAULT_MALLOC_ZONE_STRING);
#if __LIBLIBC_F_ASAN_INSTRUMENTATION
if ((malloc_sanitizer_enabled = sanitizer_should_enable())) {
- _malloc_zone_register(sanitizer_create_zone(_malloc_zones[0]), true);
+ malloc_zone_t *sanitizer = sanitizer_create_zone(xzone);
+ _malloc_zone_register(sanitizer, true);
+ malloc_set_zone_name(sanitizer, DEFAULT_SANITIZER_ZONE_STRING);
}
#endif // __LIBLIBC_F_ASAN_INSTRUMENTATION
}
@@ -154,7 +170,7 @@
/********* Block creation and manipulation ************/
-void *
+void * __sized_by_or_null(size)
_malloc_zone_malloc(malloc_zone_t *zone, size_t size, malloc_zone_options_t mzo)
{
// This and similar conditionals are commented out to avoid compiler
@@ -169,13 +185,13 @@
}
MALLOC_NOINLINE
-void *
+void * __sized_by_or_null(size)
malloc_zone_malloc(malloc_zone_t *zone, size_t size)
{
return _malloc_zone_malloc(zone, size, MZ_NONE);
}
-void *
+void * __sized_by_or_null(num_items * size)
_malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size,
malloc_zone_options_t mzo)
{
@@ -191,13 +207,13 @@
}
MALLOC_NOINLINE
-void *
+void * __sized_by_or_null(num_items * size)
malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
return _malloc_zone_calloc(zone, num_items, size, MZ_NONE);
}
-void *
+void * __sized_by_or_null(size)
_malloc_zone_valloc(malloc_zone_t *zone, size_t size, malloc_zone_options_t mzo)
{
// if (os_unlikely(malloc_too_large(size))) {
@@ -214,13 +230,13 @@
}
MALLOC_NOINLINE
-void *
+void * __sized_by_or_null(size)
malloc_zone_valloc(malloc_zone_t *zone, size_t size)
{
return _malloc_zone_valloc(zone, size, MZ_NONE);
}
-void *
+void * __sized_by_or_null(size)
_malloc_zone_realloc(malloc_zone_t *zone, void * __unsafe_indexable ptr,
size_t size, malloc_type_descriptor_t type_desc)
{
@@ -232,7 +248,7 @@
}
MALLOC_NOINLINE
-void *
+void * __sized_by_or_null(size)
malloc_zone_realloc(malloc_zone_t *zone, void * __unsafe_indexable ptr,
size_t size)
{
@@ -259,11 +275,11 @@
if (!ptr) {
return NULL;
} else {
- return find_registered_zone(ptr, NULL, false);
- }
-}
-
-void * __alloc_align(2) __alloc_size(3)
+ return _find_registered_zone(ptr, NULL, false);
+ }
+}
+
+void * __alloc_align(2) __alloc_size(3) __sized_by_or_null(size)
_malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size,
malloc_zone_options_t mzo, malloc_type_descriptor_t type_desc)
{
@@ -276,7 +292,7 @@
// excludes 0 == alignment
// relies on sizeof(void *) being a power of two.
- if (alignment < sizeof(void *) ||
+ if (alignment < MALLOC_ZONE_MALLOC_DEFAULT_ALIGN ||
0 != (alignment & (alignment - 1))) {
err = EINVAL;
goto out;
@@ -303,7 +319,7 @@
}
MALLOC_NOINLINE
-void *
+void * __sized_by_or_null(size)
malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size)
{
return _malloc_zone_memalign(zone, alignment, size, MZ_NONE,
@@ -311,9 +327,9 @@
}
MALLOC_NOINLINE
-void *
-malloc_zone_malloc_with_options_np(malloc_zone_t *zone, size_t align,
- size_t size, malloc_options_np_t options)
+void * __sized_by_or_null(size)
+malloc_zone_malloc_with_options(malloc_zone_t *zone, size_t align,
+ size_t size, malloc_zone_malloc_options_t options)
{
if (os_unlikely((align != 0) && (!powerof2(align) ||
((size & (align-1)) != 0)))) { // equivalent to (size % align != 0)
@@ -324,21 +340,29 @@
zone = malloc_zones[0];
}
- if (zone->version >= 15) {
+ if (zone->version >= 15 && zone->malloc_with_options) {
return zone->malloc_with_options(zone, align, size, options);
}
- if (align) {
+ if (align > MALLOC_ZONE_MALLOC_DEFAULT_ALIGN) {
void *ptr = zone->memalign(zone, align, size);
- if (ptr && (options & MALLOC_NP_OPTION_CLEAR)) {
+ if (ptr && (options & MALLOC_ZONE_MALLOC_OPTION_CLEAR)) {
memset(ptr, 0, size);
}
return ptr;
- } else if (options & MALLOC_NP_OPTION_CLEAR) {
+ } else if (options & MALLOC_ZONE_MALLOC_OPTION_CLEAR) {
return zone->calloc(zone, 1, size);
} else {
return zone->malloc(zone, size);
}
+}
+
+MALLOC_NOINLINE
+void * __sized_by_or_null(size)
+malloc_zone_malloc_with_options_np(malloc_zone_t *zone, size_t align,
+ size_t size, malloc_options_np_t options)
+{
+ return malloc_zone_malloc_with_options(zone, align, size, options);
}
boolean_t
@@ -364,7 +388,7 @@
malloc_set_zone_name(malloc_zone_t *z, const char *name)
{
if (z->zone_name) {
- malloc_zone_t *old_zone = find_registered_zone(z->zone_name, NULL,
+ malloc_zone_t *old_zone = _find_registered_zone(z->zone_name, NULL,
false);
if (old_zone) {
malloc_zone_free(old_zone, (char *)z->zone_name);
@@ -400,11 +424,9 @@
return;
}
- zone = find_registered_zone(ptr, &size, known_non_default);
+ zone = _find_registered_zone(ptr, &size, known_non_default);
if (!zone) {
- malloc_report(MALLOC_REPORT_DEBUG | MALLOC_REPORT_NOLOG,
- "*** error for object %p: pointer being freed was not allocated\n",
- ptr);
+ malloc_report_pointer_was_not_allocated(MALLOC_REPORT_CRASH, ptr);
} else if (zone->free_definite_size) {
malloc_zone_free_definite_size(zone,
__unsafe_forge_bidi_indexable(void *, ptr, size), size);
@@ -415,27 +437,23 @@
/********* Generic ANSI callouts ************/
-// FIXME: Return NULL instead but we need bounds checking support
-// rdar://75598414 (Support __counted_by_or_null and __sized_by_or_null)
-#define NONZERO_SZ(sz) ((sz) ? (sz) : 1)
-
-void *
+void * __sized_by_or_null(size)
malloc(size_t size)
{
- return malloc_zone_malloc(_malloc_zones[0], NONZERO_SZ(size));
-}
-
-void *
+ return malloc_zone_malloc(_malloc_zones[0], size);
+}
+
+void * __sized_by_or_null(size)
aligned_alloc(size_t alignment, size_t size)
{
- return _malloc_zone_memalign(_malloc_zones[0], alignment, NONZERO_SZ(size),
+ return _malloc_zone_memalign(_malloc_zones[0], alignment, size,
MZ_POSIX | MZ_C11, MALLOC_TYPE_DESCRIPTOR_NONE);
}
-void *
+void * __sized_by_or_null(num_items * size)
calloc(size_t num_items, size_t size)
{
- return malloc_zone_calloc(_malloc_zones[0], num_items, NONZERO_SZ(size));
+ return malloc_zone_calloc(_malloc_zones[0], num_items, size);
}
void
@@ -459,7 +477,7 @@
return _free(ptr);
}
-void *
+void * __sized_by_or_null(new_size)
_realloc(void * __unsafe_indexable in_ptr, size_t new_size)
{
void * __bidi_indexable retval = NULL;
@@ -476,13 +494,12 @@
// size." So we only free the original memory if the allocation succeeds.
old_ptr = (new_size == 0) ? NULL : in_ptr;
if (!old_ptr) {
- retval = malloc_zone_malloc(_malloc_zones[0], NONZERO_SZ(new_size));
- } else {
- zone = find_registered_zone(old_ptr, NULL, false);
+ retval = malloc_zone_malloc(_malloc_zones[0], new_size);
+ } else {
+ zone = _find_registered_zone(old_ptr, NULL, false);
if (!zone) {
- malloc_report(MALLOC_REPORT_CRASH,
- "*** error for object %p: pointer being realloc'd was not allocated\n",
- in_ptr);
+ malloc_report_pointer_was_not_allocated(MALLOC_REPORT_CRASH,
+ in_ptr);
} else {
retval = malloc_zone_realloc(zone, old_ptr, new_size);
}
@@ -496,28 +513,33 @@
return retval;
}
-void *
+void * __sized_by_or_null(new_size)
realloc(void * __unsafe_indexable in_ptr, size_t new_size)
{
return _realloc(in_ptr, new_size);
}
-void *
+void * __sized_by_or_null(new_size)
reallocf(void * __unsafe_indexable in_ptr, size_t new_size)
{
void *ptr = realloc(in_ptr, new_size);
if (!ptr && in_ptr && new_size != 0) {
+ // Save and restore `errno`, because `realloc` will set it to ENOMEM
+ // on allocation failure, but it could be overwritten if `free` calls
+ // into a library function that also modifies `errno`
+ errno_t error = errno;
free(in_ptr);
+ errno = error;
}
return ptr;
}
-void *
+void * __sized_by_or_null(size)
valloc(size_t size)
{
- return _malloc_zone_valloc(_malloc_zones[0], NONZERO_SZ(size), MZ_POSIX);
+ return _malloc_zone_valloc(_malloc_zones[0], size, MZ_POSIX);
}
size_t
@@ -529,7 +551,7 @@
return size;
}
- (void)find_registered_zone(ptr, &size, false);
+ (void)_find_registered_zone(ptr, &size, false);
return size;
}
@@ -548,13 +570,13 @@
/* POSIX is silent on NULL == memptr !?! */
- retval = malloc_zone_memalign(_malloc_zones[0], alignment, NONZERO_SZ(size));
+ retval = malloc_zone_memalign(_malloc_zones[0], alignment, size);
if (retval == NULL) {
// To avoid testing the alignment constraints redundantly, we'll rely on
// the test made in malloc_zone_memalign to vet each request. Only if
// that test fails and returns NULL, do we arrive here to detect the
// bogus alignment and give the required EINVAL return.
- if (alignment < sizeof(void *) || // excludes 0 == alignment
+ if (alignment < MALLOC_ZONE_MALLOC_DEFAULT_ALIGN || // excludes 0 == alignment
0 != (alignment & (alignment - 1))) { // relies on sizeof(void *)
// being a power of two.
return EINVAL;
@@ -591,7 +613,7 @@
return false;
}
-void *
+void * __sized_by_or_null(nmemb * size)
reallocarray(void * in_ptr, size_t nmemb, size_t size)
{
size_t alloc_size;
@@ -602,7 +624,7 @@
return realloc(in_ptr, alloc_size);
}
-void *
+void * __sized_by_or_null(nmemb * size)
reallocarrayf(void * in_ptr, size_t nmemb, size_t size)
{
size_t alloc_size;
@@ -686,5 +708,6 @@
void
malloc_zero_on_free_disable(void)
{
- malloc_zero_policy = MALLOC_ZERO_NONE;
-}
+ malloc_zone_error(MALLOC_ABORT_ON_ERROR, false,
+ "xzone cannot disable zero on free");
+}