Loading...
--- libmalloc/libmalloc-657.60.21/tests/malloc_create_zone_tests.c
+++ libmalloc/libmalloc-792.80.2/tests/malloc_create_zone_tests.c
@@ -11,6 +11,23 @@
#include <malloc/malloc.h>
#include <../src/internal.h>
+T_DECL(malloc_create_many_zones, "Register lots of zones",
+ T_META_CHECK_LEAKS(false), T_META_TAG_ALL_ALLOCATORS,
+ T_META_TAG_VM_NOT_PREFERRED, T_META_ENABLED(MALLOC_TARGET_64BIT))
+{
+ const int num_zones = 4097;
+
+ for (int i = 0; i < num_zones; i++) {
+ malloc_zone_t *zone = malloc_create_zone(0, 0);
+ T_QUIET; T_ASSERT_NOTNULL(zone, "create zone %d", i);
+
+ void *p = malloc_zone_malloc(zone, 16);
+ T_QUIET; T_ASSERT_NOTNULL(p, "malloc_zone_malloc %d", i);
+ T_QUIET; T_ASSERT_GE(malloc_size(p), 16ul, "malloc_size %d", i);
+ free(p);
+ }
+}
+
#if CONFIG_XZONE_MALLOC
#define PTR_EQUALS(a, b) (((uintptr_t)a & (XZM_LIMIT_ADDRESS - 1)) == \
@@ -18,7 +35,7 @@
T_DECL(malloc_xzone_create_zone, "Test malloc_create_zone with xzones enabled",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE_ONLY)
+ T_META_TAG_XZONE_ONLY, T_META_TAG_VM_PREFERRED)
{
// Check that we can create a new zone, and that it is an xzone
malloc_zone_t *new_zone = malloc_create_zone(0, 0);
@@ -30,7 +47,7 @@
void *ptr = malloc_zone_malloc(new_zone, 65536);
T_ASSERT_NOTNULL(ptr, "allocate from new zone");
- T_ASSERT_GE(malloc_size(ptr), 65536, "pointer size works");
+ T_ASSERT_GE(malloc_size(ptr), 65536ul, "pointer size works");
malloc_destroy_zone(new_zone);
@@ -43,40 +60,23 @@
"New zone is of type XZONE");
ptr = malloc_zone_malloc(new_zone, 64);
T_ASSERT_NOTNULL(ptr, "allocate from new zone");
- T_ASSERT_GE(malloc_size(ptr), 64, "pointer size works");
+ T_ASSERT_GE(malloc_size(ptr), 64ul, "pointer size works");
malloc_destroy_zone(new_zone);
- T_ASSERT_EQ(malloc_size(ptr), 0, "pointer is freed by destroying zone");
+ T_ASSERT_EQ(malloc_size(ptr), 0ul, "pointer is freed by destroying zone");
T_PASS("success");
-}
-
-T_DECL(malloc_xzone_create_many_zones, "Register 2048 xzm zones, 256 at a time",
- T_META_TAG_XZONE_ONLY)
-{
- const int num_zones = 256;
- malloc_zone_t *zone_array[num_zones];
- for (int i = 0; i < (2048 / num_zones); i++) {
- for (int j = 0; j < num_zones; j++) {
- zone_array[j] = malloc_create_zone(0, 0);
- T_QUIET;
- T_ASSERT_NOTNULL(zone_array[j], "create zone %d", i * num_zones + j);
- }
- for (int j = 0; j < num_zones; j++) {
- zone_array[j] = NULL;
- }
- }
}
// This test would exhaust the 64GB embedded address space, so only run on OSX
#if TARGET_OS_OSX
T_DECL(malloc_xzone_too_many_zones, "Register more zones than xzm supports",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE_ONLY)
+ T_META_TAG_XZONE_ONLY, T_META_TAG_VM_PREFERRED)
{
// XZM uses a uint16_t for the mzone unique ID, so we can only register
- // UINT16_MAX - 2 new zones (ID 1 is reserved for the main zone, and ID 0 is
+ // (1 << 16) - 2 new zones (ID 1 is reserved for the main zone, and ID 0 is
// a magic invalid value). After running out of IDs, check that
// malloc_create_zone falls back to a scalable zone
- const size_t num_xzone_zones = UINT16_MAX - 2;
+ const size_t num_xzone_zones = (1 << 16) - 2;
malloc_zone_t *xzm_zones[num_xzone_zones];
for (int i = 0; i < num_xzone_zones; i++) {
xzm_zones[i] = malloc_create_zone(0, 0);
@@ -91,7 +91,7 @@
malloc_zone_t *szone = malloc_create_zone(0, 0);
T_ASSERT_NOTNULL(szone, "Fallback to new scalable zone");
if (szone->version >= 14) {
- T_ASSERT_EQ(szone->introspect->zone_type, MALLOC_ZONE_TYPE_XZONE,
+ T_ASSERT_NE(szone->introspect->zone_type, MALLOC_ZONE_TYPE_XZONE,
"Fallback shouldn't be xzone malloc zone");
} else {
T_LOG("Fallback malloc zone doesn't support zone_type");
@@ -156,7 +156,7 @@
T_DECL(malloc_new_xzone_enumerate, "Test non-default xzone enumerator",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE_ONLY)
+ T_META_TAG_XZONE_ONLY, T_META_TAG_VM_PREFERRED)
{
malloc_zone_t *new_zone = malloc_create_zone(0, 0);
T_ASSERT_GE(new_zone->version, 14, "New zone isn't an xzone");
@@ -223,11 +223,12 @@
T_QUIET; T_ASSERT_NOTNULL(ptr, "malloc failed");
free(ptr);
}
+ return NULL;
}
T_DECL(malloc_fork_with_xzone, "Test that we can fork with a non-default xzone",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE_ONLY)
+ T_META_TAG_XZONE_ONLY, T_META_TAG_VM_NOT_PREFERRED)
{
malloc_zone_t *new_zone = malloc_create_zone(0, 0);
T_ASSERT_GE(new_zone->version, 14, "New zone isn't an xzone");
@@ -297,8 +298,8 @@
T_ASSERT_TRUE(WIFEXITED(child_status), "Child called exit");
T_ASSERT_EQ(WEXITSTATUS(child_status), 0, "Child called exit(0)");
- T_ASSERT_LE(malloc_size(ptr1), 64, "tiny pointer still seen post fork");
- T_ASSERT_LE(malloc_size(ptr2), 65536, "large pointer still seen post fork");
+ T_ASSERT_LE(malloc_size(ptr1), 64ul, "tiny pointer still seen post fork");
+ T_ASSERT_LE(malloc_size(ptr2), 65536ul, "large pointer still seen post fork");
free(ptr1);
free(ptr2);
@@ -312,7 +313,7 @@
T_DECL(malloc_statistics, "Make sure the main and new zone support statistics",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE)
+ T_META_TAG_ALL_ALLOCATORS, T_META_TAG_VM_PREFERRED)
{
malloc_zone_t *default_zone = malloc_default_zone();
malloc_zone_t *new_zone = malloc_create_zone(0, 0);
@@ -323,9 +324,9 @@
malloc_zone_statistics(default_zone, &default_stats);
malloc_zone_statistics(new_zone, &new_stats);
- T_ASSERT_EQ(new_stats.size_in_use, 0,
+ T_ASSERT_EQ(new_stats.size_in_use, 0ul,
"Accurate stats before any allocations");
- T_ASSERT_EQ(new_stats.blocks_in_use, 0,
+ T_ASSERT_EQ(new_stats.blocks_in_use, 0u,
"Accurate allocation count before any allocations");
void *ptr1 = malloc_zone_malloc(new_zone, 1024);
void *ptr2 = malloc_zone_malloc(new_zone, 8192);
@@ -333,15 +334,15 @@
free(ptr1);
free(ptr2);
- T_ASSERT_EQ(new_stats.size_in_use, 1024 + 8192,
+ T_ASSERT_EQ(new_stats.size_in_use, 1024ul + 8192ul,
"Accurate stats after allocations");
- T_ASSERT_EQ(new_stats.blocks_in_use, 2,
+ T_ASSERT_EQ(new_stats.blocks_in_use, 2u,
"Accurate allocation count after allocations");
}
T_DECL(malloc_free_pointers_on_destroy,
"Make many allocations, make sure they're freed on zone destroy",
- T_META_TAG_XZONE)
+ T_META_TAG_ALL_ALLOCATORS, T_META_TAG_VM_PREFERRED)
{
malloc_zone_t *new_zone = malloc_create_zone(0, 0);
@@ -360,50 +361,50 @@
for (int i = 0; i < countof(tiny_ptrs); i++) {
tiny_ptrs[i] = malloc_zone_malloc(new_zone, 1024);
T_QUIET; T_ASSERT_NOTNULL(tiny_ptrs[i], "TINY allocation succeeded");
- T_QUIET; T_ASSERT_GE(malloc_size(tiny_ptrs[i]), 1024,
+ T_QUIET; T_ASSERT_GE(malloc_size(tiny_ptrs[i]), 1024ul,
"TINY allocation is of requested size");
}
for (int i = 0; i < countof(small_ptrs); i++) {
small_ptrs[i] = malloc_zone_malloc(new_zone, 32768);
T_QUIET; T_ASSERT_NOTNULL(small_ptrs[i], "SMALL allocation succeeded");
- T_QUIET; T_ASSERT_GE(malloc_size(small_ptrs[i]), 32768,
+ T_QUIET; T_ASSERT_GE(malloc_size(small_ptrs[i]), 32768ul,
"SMALL allocation is of requested size");
}
for (int i = 0; i < countof(large_ptrs); i++) {
large_ptrs[i] = malloc_zone_malloc(new_zone, 65536);
T_QUIET; T_ASSERT_NOTNULL(large_ptrs[i], "LARGE allocation succeeded");
- T_QUIET; T_ASSERT_GE(malloc_size(large_ptrs[i]), 65536,
+ T_QUIET; T_ASSERT_GE(malloc_size(large_ptrs[i]), 65536ul,
"LARGE allocation is of requested size");
}
for (int i = 0; i < countof(huge_ptrs); i++) {
huge_ptrs[i] = malloc_zone_malloc(new_zone, MiB(32));
T_QUIET; T_ASSERT_NOTNULL(huge_ptrs[i], "HUGE allocation succeeded");
- T_QUIET; T_ASSERT_GE(malloc_size(huge_ptrs[i]), MiB(32),
+ T_QUIET; T_ASSERT_GE(malloc_size(huge_ptrs[i]), (size_t)MiB(32),
"HUGE allocation is of requested size");
}
malloc_destroy_zone(new_zone);
for (int i = 0; i < countof(tiny_ptrs); i++) {
- T_QUIET; T_ASSERT_EQ(malloc_size(tiny_ptrs[i]), 0,
+ T_QUIET; T_ASSERT_EQ(malloc_size(tiny_ptrs[i]), 0ul,
"TINY allocation is freed by destroying zone");
}
for (int i = 0; i < countof(small_ptrs); i++) {
- T_QUIET; T_ASSERT_EQ(malloc_size(small_ptrs[i]), 0,
+ T_QUIET; T_ASSERT_EQ(malloc_size(small_ptrs[i]), 0ul,
"SMALL allocation is freed by destroying zone");
}
for (int i = 0; i < countof(large_ptrs); i++) {
- T_QUIET; T_ASSERT_EQ(malloc_size(large_ptrs[i]), 0,
+ T_QUIET; T_ASSERT_EQ(malloc_size(large_ptrs[i]), 0ul,
"LARGE allocation is freed by destroying zone");
}
for (int i = 0; i < countof(huge_ptrs); i++) {
- T_QUIET; T_ASSERT_EQ(malloc_size(huge_ptrs[i]), 0,
+ T_QUIET; T_ASSERT_EQ(malloc_size(huge_ptrs[i]), 0ul,
"HUGE allocation is freed by destroying zone");
}
}
@@ -524,7 +525,7 @@
T_DECL(malloc_create_zone_stress,
"Create and destroy zones while stressing main zone",
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE)
+ T_META_TAG_ALL_ALLOCATORS, T_META_TAG_VM_NOT_PREFERRED)
{
create_zone_stress();
}
@@ -533,27 +534,28 @@
"Create and destroy zones while stressing main zone, guard pages enabled",
T_META_ENVVAR("MallocXzoneGuarded=1"),
T_META_ENVVAR("MallocProbGuard=0"),
- T_META_TAG_XZONE_ONLY)
+ T_META_TAG_XZONE_ONLY, T_META_TAG_VM_NOT_PREFERRED)
{
create_zone_stress();
}
T_DECL(free_default_with_scribble,
"Test freeing from a non-default zone while MALLOC_SCRIBBLE is enabled",
- T_META_TAG_XZONE,
- T_META_ENVVAR("MallocScribble=1"))
+ T_META_TAG_ALL_ALLOCATORS,
+ T_META_ENVVAR("MallocScribble=1"), T_META_TAG_VM_NOT_PREFERRED)
{
malloc_zone_t *zone = malloc_create_zone(0, 0);
void *ptr = malloc_zone_malloc(zone, 16384);
T_ASSERT_NOTNULL(ptr, "Allocate from non-default zone");
free(ptr);
- T_ASSERT_EQ(malloc_size(ptr), 0, "Pointer is freed");
+ T_ASSERT_EQ(malloc_size(ptr), 0ul, "Pointer is freed");
}
#else // CONFIG_XZONE_MALLOC
T_DECL(skip_create_zone, "Do nothing test for !CONFIG_XZONE_MALLOC",
- T_META_ENABLED(false))
+ T_META_ENABLED(false), T_META_TAG_VM_PREFERRED,
+ T_META_TAG_NO_ALLOCATOR_OVERRIDE)
{
T_SKIP("Nothing to test under !CONFIG_XZONE_MALLOC");