Refactor test extent hook code to be reusable.
Move test extent hook code from the extent integration test into a
header, and normalize the out-of-band controls and introspection.
Also refactor the base unit test to use the header.
diff --git a/test/include/test/extent_hooks.h b/test/include/test/extent_hooks.h
new file mode 100644
index 0000000..f50747d
--- /dev/null
+++ b/test/include/test/extent_hooks.h
@@ -0,0 +1,264 @@
+/*
+ * Boilerplate code used for testing extent hooks via interception and
+ * passthrough.
+ */
+
+static void *extent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr,
+ size_t size, size_t alignment, bool *zero, bool *commit,
+ unsigned arena_ind);
+static bool extent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr,
+ size_t size, bool committed, unsigned arena_ind);
+static bool extent_commit_hook(extent_hooks_t *extent_hooks, void *addr,
+ size_t size, size_t offset, size_t length, unsigned arena_ind);
+static bool extent_decommit_hook(extent_hooks_t *extent_hooks, void *addr,
+ size_t size, size_t offset, size_t length, unsigned arena_ind);
+static bool extent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr,
+ size_t size, size_t offset, size_t length, unsigned arena_ind);
+static bool extent_purge_forced_hook(extent_hooks_t *extent_hooks,
+ void *addr, size_t size, size_t offset, size_t length, unsigned arena_ind);
+static bool extent_split_hook(extent_hooks_t *extent_hooks, void *addr,
+ size_t size, size_t size_a, size_t size_b, bool committed,
+ unsigned arena_ind);
+static bool extent_merge_hook(extent_hooks_t *extent_hooks, void *addr_a,
+ size_t size_a, void *addr_b, size_t size_b, bool committed,
+ unsigned arena_ind);
+
+static extent_hooks_t *default_hooks;
+static extent_hooks_t hooks = {
+ extent_alloc_hook,
+ extent_dalloc_hook,
+ extent_commit_hook,
+ extent_decommit_hook,
+ extent_purge_lazy_hook,
+ extent_purge_forced_hook,
+ extent_split_hook,
+ extent_merge_hook
+};
+
+/* Control whether hook functions pass calls through to default hooks. */
+static bool try_alloc = true;
+static bool try_dalloc = true;
+static bool try_commit = true;
+static bool try_decommit = true;
+static bool try_purge_lazy = true;
+static bool try_purge_forced = true;
+static bool try_split = true;
+static bool try_merge = true;
+
+/* Set to false prior to operations, then introspect after operations. */
+static bool called_alloc;
+static bool called_dalloc;
+static bool called_commit;
+static bool called_decommit;
+static bool called_purge_lazy;
+static bool called_purge_forced;
+static bool called_split;
+static bool called_merge;
+
+/* Set to false prior to operations, then introspect after operations. */
+static bool did_alloc;
+static bool did_dalloc;
+static bool did_commit;
+static bool did_decommit;
+static bool did_purge_lazy;
+static bool did_purge_forced;
+static bool did_split;
+static bool did_merge;
+
+#if 0
+# define TRACE_HOOK(fmt, ...) malloc_printf(fmt, __VA_ARGS__)
+#else
+# define TRACE_HOOK(fmt, ...)
+#endif
+
+static void *
+extent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr, size_t size,
+ size_t alignment, bool *zero, bool *commit, unsigned arena_ind)
+{
+ void *ret;
+
+ TRACE_HOOK("%s(extent_hooks=%p, new_addr=%p, size=%zu, alignment=%zu, "
+ "*zero=%s, *commit=%s, arena_ind=%u)\n", __func__, extent_hooks,
+ new_addr, size, alignment, *zero ? "true" : "false", *commit ?
+ "true" : "false", arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->alloc, extent_alloc_hook,
+ "Wrong hook function");
+ called_alloc = true;
+ if (!try_alloc)
+ return (NULL);
+ ret = default_hooks->alloc(default_hooks, new_addr, size, alignment,
+ zero, commit, 0);
+ did_alloc = (ret != NULL);
+ return (ret);
+}
+
+static bool
+extent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ bool committed, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, "
+ "arena_ind=%u)\n", __func__, extent_hooks, addr, size, committed ?
+ "true" : "false", arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->dalloc, extent_dalloc_hook,
+ "Wrong hook function");
+ called_dalloc = true;
+ if (!try_dalloc)
+ return (true);
+ err = default_hooks->dalloc(default_hooks, addr, size, committed, 0);
+ did_dalloc = !err;
+ return (err);
+}
+
+static bool
+extent_commit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ size_t offset, size_t length, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
+ "length=%zu, arena_ind=%u)\n", __func__, extent_hooks, addr, size,
+ offset, length, arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->commit, extent_commit_hook,
+ "Wrong hook function");
+ called_commit = true;
+ if (!try_commit)
+ return (true);
+ err = default_hooks->commit(default_hooks, addr, size, offset, length,
+ 0);
+ did_commit = !err;
+ return (err);
+}
+
+static bool
+extent_decommit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ size_t offset, size_t length, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
+ "length=%zu, arena_ind=%u)\n", __func__, extent_hooks, addr, size,
+ offset, length, arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->decommit, extent_decommit_hook,
+ "Wrong hook function");
+ called_decommit = true;
+ if (!try_decommit)
+ return (true);
+ err = default_hooks->decommit(default_hooks, addr, size, offset, length,
+ 0);
+ did_decommit = !err;
+ return (err);
+}
+
+static bool
+extent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ size_t offset, size_t length, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
+ "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
+ offset, length, arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->purge_lazy, extent_purge_lazy_hook,
+ "Wrong hook function");
+ called_purge_lazy = true;
+ if (!try_purge_lazy)
+ return (true);
+ err = default_hooks->purge_lazy == NULL ||
+ default_hooks->purge_lazy(default_hooks, addr, size, offset, length,
+ 0);
+ did_purge_lazy = !err;
+ return (err);
+}
+
+static bool
+extent_purge_forced_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ size_t offset, size_t length, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
+ "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
+ offset, length, arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->purge_forced, extent_purge_forced_hook,
+ "Wrong hook function");
+ called_purge_forced = true;
+ if (!try_purge_forced)
+ return (true);
+ err = default_hooks->purge_forced == NULL ||
+ default_hooks->purge_forced(default_hooks, addr, size, offset,
+ length, 0);
+ did_purge_forced = !err;
+ return (err);
+}
+
+static bool
+extent_split_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
+ size_t size_a, size_t size_b, bool committed, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, size_a=%zu, "
+ "size_b=%zu, committed=%s, arena_ind=%u)\n", __func__, extent_hooks,
+ addr, size, size_a, size_b, committed ? "true" : "false",
+ arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->split, extent_split_hook,
+ "Wrong hook function");
+ called_split = true;
+ if (!try_split)
+ return (true);
+ err = (default_hooks->split == NULL ||
+ default_hooks->split(default_hooks, addr, size, size_a, size_b,
+ committed, 0));
+ did_split = !err;
+ return (err);
+}
+
+static bool
+extent_merge_hook(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a,
+ void *addr_b, size_t size_b, bool committed, unsigned arena_ind)
+{
+ bool err;
+
+ TRACE_HOOK("%s(extent_hooks=%p, addr_a=%p, size_a=%zu, addr_b=%p "
+ "size_b=%zu, committed=%s, arena_ind=%u)\n", __func__, extent_hooks,
+ addr_a, size_a, addr_b, size_b, committed ? "true" : "false",
+ arena_ind);
+ assert_ptr_eq(extent_hooks, &hooks,
+ "extent_hooks should be same as pointer used to set hooks");
+ assert_ptr_eq(extent_hooks->merge, extent_merge_hook,
+ "Wrong hook function");
+ called_merge = true;
+ if (!try_merge)
+ return (true);
+ err = (default_hooks->merge == NULL ||
+ default_hooks->merge(default_hooks, addr_a, size_a, addr_b, size_b,
+ committed, 0));
+ did_merge = !err;
+ return (err);
+}
+
+static void
+extent_hooks_prep(void)
+{
+ size_t sz;
+
+ sz = sizeof(default_hooks);
+ assert_d_eq(mallctl("arena.0.extent_hooks", (void *)&default_hooks, &sz,
+ NULL, 0), 0, "Unexpected mallctl() error");
+}
diff --git a/test/integration/extent.c b/test/integration/extent.c
index 6be3b83..e347b66 100644
--- a/test/integration/extent.c
+++ b/test/integration/extent.c
@@ -4,204 +4,7 @@
const char *malloc_conf = "junk:false";
#endif
-static void *extent_alloc(extent_hooks_t *extent_hooks, void *new_addr,
- size_t size, size_t alignment, bool *zero, bool *commit,
- unsigned arena_ind);
-static bool extent_dalloc(extent_hooks_t *extent_hooks, void *addr,
- size_t size, bool committed, unsigned arena_ind);
-static bool extent_commit(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_decommit(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_purge_lazy(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_purge_forced(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_split(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t size_a, size_t size_b, bool committed,
- unsigned arena_ind);
-static bool extent_merge(extent_hooks_t *extent_hooks, void *addr_a,
- size_t size_a, void *addr_b, size_t size_b, bool committed,
- unsigned arena_ind);
-
-static extent_hooks_t hooks = {
- extent_alloc,
- extent_dalloc,
- extent_commit,
- extent_decommit,
- extent_purge_lazy,
- extent_purge_forced,
- extent_split,
- extent_merge
-};
-static extent_hooks_t *new_hooks = &hooks;
-static extent_hooks_t *orig_hooks;
-static extent_hooks_t *old_hooks;
-
-static bool do_dalloc = true;
-static bool do_decommit;
-
-static bool did_alloc;
-static bool did_dalloc;
-static bool did_commit;
-static bool did_decommit;
-static bool did_purge_lazy;
-static bool did_purge_forced;
-static bool tried_split;
-static bool did_split;
-static bool did_merge;
-
-#if 0
-# define TRACE_HOOK(fmt, ...) malloc_printf(fmt, __VA_ARGS__)
-#else
-# define TRACE_HOOK(fmt, ...)
-#endif
-
-static void *
-extent_alloc(extent_hooks_t *extent_hooks, void *new_addr, size_t size,
- size_t alignment, bool *zero, bool *commit, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, new_addr=%p, size=%zu, alignment=%zu, "
- "*zero=%s, *commit=%s, arena_ind=%u)\n", __func__, extent_hooks,
- new_addr, size, alignment, *zero ? "true" : "false", *commit ?
- "true" : "false", arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->alloc, extent_alloc, "Wrong hook function");
- did_alloc = true;
- return (old_hooks->alloc(old_hooks, new_addr, size, alignment, zero,
- commit, 0));
-}
-
-static bool
-extent_dalloc(extent_hooks_t *extent_hooks, void *addr, size_t size,
- bool committed, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, "
- "arena_ind=%u)\n", __func__, extent_hooks, addr, size, committed ?
- "true" : "false", arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->dalloc, extent_dalloc,
- "Wrong hook function");
- did_dalloc = true;
- if (!do_dalloc)
- return (true);
- return (old_hooks->dalloc(old_hooks, addr, size, committed, 0));
-}
-
-static bool
-extent_commit(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
- bool err;
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu, arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->commit, extent_commit,
- "Wrong hook function");
- err = old_hooks->commit(old_hooks, addr, size, offset, length, 0);
- did_commit = !err;
- return (err);
-}
-
-static bool
-extent_decommit(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
- bool err;
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu, arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->decommit, extent_decommit,
- "Wrong hook function");
- if (!do_decommit)
- return (true);
- err = old_hooks->decommit(old_hooks, addr, size, offset, length, 0);
- did_decommit = !err;
- return (err);
-}
-
-static bool
-extent_purge_lazy(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->purge_lazy, extent_purge_lazy,
- "Wrong hook function");
- did_purge_lazy = true;
- return (old_hooks->purge_lazy == NULL ||
- old_hooks->purge_lazy(old_hooks, addr, size, offset, length, 0));
-}
-
-static bool
-extent_purge_forced(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->purge_forced, extent_purge_forced,
- "Wrong hook function");
- did_purge_forced = true;
- return (old_hooks->purge_forced == NULL ||
- old_hooks->purge_forced(old_hooks, addr, size, offset, length, 0));
-}
-
-static bool
-extent_split(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t size_a, size_t size_b, bool committed, unsigned arena_ind)
-{
- bool err;
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, size_a=%zu, "
- "size_b=%zu, committed=%s, arena_ind=%u)\n", __func__, extent_hooks,
- addr, size, size_a, size_b, committed ? "true" : "false",
- arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->split, extent_split, "Wrong hook function");
- tried_split = true;
- err = (old_hooks->split == NULL || old_hooks->split(old_hooks, addr,
- size, size_a, size_b, committed, 0));
- did_split = !err;
- return (err);
-}
-
-static bool
-extent_merge(extent_hooks_t *extent_hooks, void *addr_a, size_t size_a,
- void *addr_b, size_t size_b, bool committed, unsigned arena_ind)
-{
- bool err;
-
- TRACE_HOOK("%s(extent_hooks=%p, addr_a=%p, size_a=%zu, addr_b=%p "
- "size_b=%zu, committed=%s, arena_ind=%u)\n", __func__, extent_hooks,
- addr_a, size_a, addr_b, size_b, committed ? "true" : "false",
- arena_ind);
- assert_ptr_eq(extent_hooks, new_hooks,
- "extent_hooks should be same as pointer used to set hooks");
- assert_ptr_eq(extent_hooks->merge, extent_merge, "Wrong hook function");
- err = (old_hooks->merge == NULL || old_hooks->merge(old_hooks, addr_a,
- size_a, addr_b, size_b, committed, 0));
- did_merge = !err;
- return (err);
-}
+#include "test/extent_hooks.h"
static void
test_extent_body(unsigned arena_ind)
@@ -229,37 +32,36 @@
assert_d_eq(mallctlnametomib("arena.0.purge", purge_mib, &purge_miblen),
0, "Unexpected mallctlnametomib() failure");
purge_mib[1] = (size_t)arena_ind;
- do_dalloc = false;
- do_decommit = false;
+ try_dalloc = false;
+ try_decommit = false;
p = mallocx(large0 * 2, flags);
assert_ptr_not_null(p, "Unexpected mallocx() error");
- did_dalloc = false;
- did_decommit = false;
+ called_dalloc = false;
+ called_decommit = false;
did_purge_lazy = false;
did_purge_forced = false;
- tried_split = false;
- did_split = false;
+ called_split = false;
xallocx_success_a = (xallocx(p, large0, 0, flags) == large0);
assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
0, "Unexpected arena.%u.purge error", arena_ind);
if (xallocx_success_a) {
- assert_true(did_dalloc, "Expected dalloc");
- assert_false(did_decommit, "Unexpected decommit");
+ assert_true(called_dalloc, "Expected dalloc call");
+ assert_true(called_decommit, "Expected decommit call");
assert_true(did_purge_lazy || did_purge_forced,
"Expected purge");
}
- assert_true(tried_split, "Expected split");
+ assert_true(called_split, "Expected split call");
dallocx(p, flags);
- do_dalloc = true;
+ try_dalloc = true;
/* Test decommit/commit and observe split/merge. */
- do_dalloc = false;
- do_decommit = true;
+ try_dalloc = false;
+ try_decommit = true;
p = mallocx(large0 * 2, flags);
assert_ptr_not_null(p, "Unexpected mallocx() error");
did_decommit = false;
did_commit = false;
- tried_split = false;
+ called_split = false;
did_split = false;
did_merge = false;
xallocx_success_b = (xallocx(p, large0, 0, flags) == large0);
@@ -275,8 +77,8 @@
if (xallocx_success_b && xallocx_success_c)
assert_true(did_merge, "Expected merge");
dallocx(p, flags);
- do_dalloc = true;
- do_decommit = false;
+ try_dalloc = true;
+ try_decommit = false;
/* Make sure non-large allocation succeeds. */
p = mallocx(42, flags);
@@ -290,6 +92,9 @@
size_t old_size, new_size, sz;
size_t hooks_mib[3];
size_t hooks_miblen;
+ extent_hooks_t *new_hooks, *old_hooks;
+
+ extent_hooks_prep();
sz = sizeof(unsigned);
assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
@@ -301,24 +106,27 @@
&hooks_miblen), 0, "Unexpected mallctlnametomib() failure");
hooks_mib[1] = (size_t)arena_ind;
old_size = sizeof(extent_hooks_t *);
+ new_hooks = &hooks;
new_size = sizeof(extent_hooks_t *);
assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
&old_size, (void *)&new_hooks, new_size), 0,
"Unexpected extent_hooks error");
- orig_hooks = old_hooks;
- assert_ptr_ne(old_hooks->alloc, extent_alloc, "Unexpected alloc error");
- assert_ptr_ne(old_hooks->dalloc, extent_dalloc,
- "Unexpected dalloc error");
- assert_ptr_ne(old_hooks->commit, extent_commit,
- "Unexpected commit error");
- assert_ptr_ne(old_hooks->decommit, extent_decommit,
- "Unexpected decommit error");
- assert_ptr_ne(old_hooks->purge_lazy, extent_purge_lazy,
- "Unexpected purge_lazy error");
- assert_ptr_ne(old_hooks->purge_forced, extent_purge_forced,
- "Unexpected purge_forced error");
- assert_ptr_ne(old_hooks->split, extent_split, "Unexpected split error");
- assert_ptr_ne(old_hooks->merge, extent_merge, "Unexpected merge error");
+ assert_ptr_ne(old_hooks->alloc, extent_alloc_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->dalloc, extent_dalloc_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->commit, extent_commit_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->decommit, extent_decommit_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->purge_lazy, extent_purge_lazy_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->purge_forced, extent_purge_forced_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->split, extent_split_hook,
+ "Unexpected extent_hooks error");
+ assert_ptr_ne(old_hooks->merge, extent_merge_hook,
+ "Unexpected extent_hooks error");
test_extent_body(arena_ind);
@@ -327,23 +135,23 @@
(void *)&old_hooks, new_size), 0, "Unexpected extent_hooks error");
assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
&old_size, NULL, 0), 0, "Unexpected extent_hooks error");
- assert_ptr_eq(old_hooks, orig_hooks, "Unexpected hooks error");
- assert_ptr_eq(old_hooks->alloc, orig_hooks->alloc,
- "Unexpected alloc error");
- assert_ptr_eq(old_hooks->dalloc, orig_hooks->dalloc,
- "Unexpected dalloc error");
- assert_ptr_eq(old_hooks->commit, orig_hooks->commit,
- "Unexpected commit error");
- assert_ptr_eq(old_hooks->decommit, orig_hooks->decommit,
- "Unexpected decommit error");
- assert_ptr_eq(old_hooks->purge_lazy, orig_hooks->purge_lazy,
- "Unexpected purge_lazy error");
- assert_ptr_eq(old_hooks->purge_forced, orig_hooks->purge_forced,
- "Unexpected purge_forced error");
- assert_ptr_eq(old_hooks->split, orig_hooks->split,
- "Unexpected split error");
- assert_ptr_eq(old_hooks->merge, orig_hooks->merge,
- "Unexpected merge error");
+ assert_ptr_eq(old_hooks, default_hooks, "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->alloc, default_hooks->alloc,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->dalloc, default_hooks->dalloc,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->commit, default_hooks->commit,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->decommit, default_hooks->decommit,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->purge_lazy, default_hooks->purge_lazy,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->purge_forced, default_hooks->purge_forced,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->split, default_hooks->split,
+ "Unexpected extent_hooks error");
+ assert_ptr_eq(old_hooks->merge, default_hooks->merge,
+ "Unexpected extent_hooks error");
}
TEST_END
@@ -351,8 +159,12 @@
{
unsigned arena_ind;
size_t new_size, sz;
+ extent_hooks_t *new_hooks;
+
+ extent_hooks_prep();
sz = sizeof(unsigned);
+ new_hooks = &hooks;
new_size = sizeof(extent_hooks_t *);
assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz,
(void *)&new_hooks, new_size), 0, "Unexpected mallctl() failure");
diff --git a/test/unit/base.c b/test/unit/base.c
index 6a082a5..8f97e8b 100644
--- a/test/unit/base.c
+++ b/test/unit/base.c
@@ -1,27 +1,6 @@
#include "test/jemalloc_test.h"
-static void *extent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr,
- size_t size, size_t alignment, bool *zero, bool *commit,
- unsigned arena_ind);
-static bool extent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr,
- size_t size, bool committed, unsigned arena_ind);
-static bool extent_decommit_hook(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr,
- size_t size, size_t offset, size_t length, unsigned arena_ind);
-static bool extent_purge_forced_hook(extent_hooks_t *extent_hooks,
- void *addr, size_t size, size_t offset, size_t length, unsigned arena_ind);
-
-static extent_hooks_t hooks_not_null = {
- extent_alloc_hook,
- extent_dalloc_hook,
- NULL, /* commit */
- extent_decommit_hook,
- extent_purge_lazy_hook,
- extent_purge_forced_hook,
- NULL, /* split */
- NULL /* merge */
-};
+#include "test/extent_hooks.h"
static extent_hooks_t hooks_null = {
extent_alloc_hook,
@@ -34,80 +13,16 @@
NULL /* merge */
};
-static bool did_alloc;
-static bool did_dalloc;
-static bool did_decommit;
-static bool did_purge_lazy;
-static bool did_purge_forced;
-
-#if 0
-# define TRACE_HOOK(fmt, ...) malloc_printf(fmt, __VA_ARGS__)
-#else
-# define TRACE_HOOK(fmt, ...)
-#endif
-
-static void *
-extent_alloc_hook(extent_hooks_t *extent_hooks, void *new_addr, size_t size,
- size_t alignment, bool *zero, bool *commit, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, new_addr=%p, size=%zu, alignment=%zu, "
- "*zero=%s, *commit=%s, arena_ind=%u)\n", __func__, extent_hooks,
- new_addr, size, alignment, *zero ? "true" : "false", *commit ?
- "true" : "false", arena_ind);
- did_alloc = true;
- return (extent_hooks_default.alloc(
- (extent_hooks_t *)&extent_hooks_default, new_addr, size, alignment,
- zero, commit, 0));
-}
-
-static bool
-extent_dalloc_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
- bool committed, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, committed=%s, "
- "arena_ind=%u)\n", __func__, extent_hooks, addr, size, committed ?
- "true" : "false", arena_ind);
- did_dalloc = true;
- return (true); /* Cause cascade. */
-}
-
-static bool
-extent_decommit_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu, arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- did_decommit = true;
- return (true); /* Cause cascade. */
-}
-
-static bool
-extent_purge_lazy_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- did_purge_lazy = true;
- return (true); /* Cause cascade. */
-}
-
-static bool
-extent_purge_forced_hook(extent_hooks_t *extent_hooks, void *addr, size_t size,
- size_t offset, size_t length, unsigned arena_ind)
-{
-
- TRACE_HOOK("%s(extent_hooks=%p, addr=%p, size=%zu, offset=%zu, "
- "length=%zu arena_ind=%u)\n", __func__, extent_hooks, addr, size,
- offset, length, arena_ind);
- did_purge_forced = true;
- return (true); /* Cause cascade. */
-}
+static extent_hooks_t hooks_not_null = {
+ extent_alloc_hook,
+ extent_dalloc_hook,
+ NULL, /* commit */
+ extent_decommit_hook,
+ extent_purge_lazy_hook,
+ extent_purge_forced_hook,
+ NULL, /* split */
+ NULL /* merge */
+};
TEST_BEGIN(test_base_hooks_default)
{
@@ -135,12 +50,21 @@
TEST_BEGIN(test_base_hooks_null)
{
+ extent_hooks_t hooks_orig;
tsdn_t *tsdn;
base_t *base;
size_t allocated0, allocated1, resident, mapped;
+ extent_hooks_prep();
+ try_dalloc = false;
+ try_decommit = false;
+ try_purge_lazy = false;
+ try_purge_forced = false;
+ memcpy(&hooks_orig, &hooks, sizeof(extent_hooks_t));
+ memcpy(&hooks, &hooks_null, sizeof(extent_hooks_t));
+
tsdn = tsdn_fetch();
- base = base_new(tsdn, 0, (extent_hooks_t *)&hooks_null);
+ base = base_new(tsdn, 0, &hooks);
assert_ptr_not_null(base, "Unexpected base_new() failure");
base_stats_get(tsdn, base, &allocated0, &resident, &mapped);
@@ -155,20 +79,31 @@
"At least 42 bytes were allocated by base_alloc()");
base_delete(base);
+
+ memcpy(&hooks, &hooks_orig, sizeof(extent_hooks_t));
}
TEST_END
TEST_BEGIN(test_base_hooks_not_null)
{
+ extent_hooks_t hooks_orig;
tsdn_t *tsdn;
base_t *base;
void *p, *q, *r, *r_exp;
+ extent_hooks_prep();
+ try_dalloc = false;
+ try_decommit = false;
+ try_purge_lazy = false;
+ try_purge_forced = false;
+ memcpy(&hooks_orig, &hooks, sizeof(extent_hooks_t));
+ memcpy(&hooks, &hooks_not_null, sizeof(extent_hooks_t));
+
tsdn = tsdn_fetch();
did_alloc = false;
- base = base_new(tsdn, 0, (extent_hooks_t *)&hooks_not_null);
+ base = base_new(tsdn, 0, &hooks);
assert_ptr_not_null(base, "Unexpected base_new() failure");
- assert_true(did_alloc, "Expected alloc hook call");
+ assert_true(did_alloc, "Expected alloc");
/*
* Check for tight packing at specified alignment under simple
@@ -254,12 +189,19 @@
}
}
- did_dalloc = did_decommit = did_purge_lazy = did_purge_forced = false;
+ called_dalloc = called_decommit = called_purge_lazy =
+ called_purge_forced = false;
base_delete(base);
- assert_true(did_dalloc, "Expected dalloc hook call");
- assert_true(did_decommit, "Expected decommit hook call");
- assert_true(did_purge_lazy, "Expected purge_lazy hook call");
- assert_true(did_purge_forced, "Expected purge_forced hook call");
+ assert_true(called_dalloc, "Expected dalloc call");
+ assert_true(called_decommit, "Expected decommit call");
+ assert_true(called_purge_lazy, "Expected purge_lazy call");
+ assert_true(called_purge_forced, "Expected purge_forced call");
+
+ try_dalloc = true;
+ try_decommit = true;
+ try_purge_lazy = true;
+ try_purge_forced = true;
+ memcpy(&hooks, &hooks_orig, sizeof(extent_hooks_t));
}
TEST_END