chg: dev: Cleanup parts of the isc_mem API

This MR changes custom attach/detach implementation with refcount macros, replaces isc_mem_destroy() with isc_mem_detach(), and does various small cleanups.

Merge branch 'ondrej/cleanup-isc_mem-api' into 'main'

See merge request isc-projects/bind9!9456

bin/check/named-checkconf.c

@@ -761,7 +761,7 @@ cleanup:
 	}
 
 	if (mctx != NULL) {
-		isc_mem_destroy(&mctx);
+		isc_mem_detach(&mctx);
 	}
 
 	return result == ISC_R_SUCCESS ? 0 : 1;

bin/check/named-checkzone.c

@@ -577,7 +577,7 @@ main(int argc, char **argv) {
 		fprintf(errout, "OK\n");
 	}
 	destroy();
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return (result == ISC_R_SUCCESS) ? 0 : 1;
 }

bin/confgen/rndc-confgen.c

@@ -290,7 +290,7 @@ options {\n\
 		isc_mem_stats(mctx, stderr);
 	}
 
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

bin/confgen/tsig-keygen.c

@@ -296,7 +296,7 @@ nsupdate -k <keyfile>\n");
 		isc_mem_stats(mctx, stderr);
 	}
 
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

bin/dnssec/dnssec-cds.c

@@ -1075,7 +1075,7 @@ cleanup(void) {
 		if (print_mem_stats && verbose > 10) {
 			isc_mem_stats(mctx, stdout);
 		}
-		isc_mem_destroy(&mctx);
+		isc_mem_detach(&mctx);
 	}
 }
 

bin/dnssec/dnssec-dsfromkey.c

@@ -543,7 +543,7 @@ main(int argc, char **argv) {
 	if (verbose > 10) {
 		isc_mem_stats(mctx, stdout);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	fflush(stdout);
 	if (ferror(stdout)) {

bin/dnssec/dnssec-importkey.c

@@ -456,7 +456,7 @@ main(int argc, char **argv) {
 	if (verbose > 10) {
 		isc_mem_stats(mctx, stdout);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	fflush(stdout);
 	if (ferror(stdout)) {

bin/dnssec/dnssec-keyfromlabel.c

@@ -746,7 +746,7 @@ main(int argc, char **argv) {
 		isc_mem_stats(mctx, stdout);
 	}
 	isc_mem_free(mctx, label);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	if (freeit != NULL) {
 		free(freeit);

bin/dnssec/dnssec-keygen.c

@@ -1280,7 +1280,7 @@ main(int argc, char **argv) {
 	if (verbose > 10) {
 		isc_mem_stats(mctx, stdout);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	if (freeit != NULL) {
 		free(freeit);

bin/dnssec/dnssec-revoke.c

@@ -248,7 +248,7 @@ cleanup:
 	if (dir != NULL) {
 		isc_mem_free(mctx, dir);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

bin/dnssec/dnssec-settime.c

@@ -949,7 +949,7 @@ main(int argc, char **argv) {
 		isc_mem_stats(mctx, stdout);
 	}
 	isc_mem_free(mctx, directory);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

bin/dnssec/dnssec-verify.c

@@ -330,7 +330,7 @@ main(int argc, char *argv[]) {
 	if (verbose > 10) {
 		isc_mem_stats(mctx, stdout);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return result == ISC_R_SUCCESS ? 0 : 1;
 }

bin/tests/system/makejournal.c

@@ -111,7 +111,7 @@ cleanup:
 	}
 
 	if (mctx != NULL) {
-		isc_mem_destroy(&mctx);
+		isc_mem_detach(&mctx);
 	}
 
 	return result != ISC_R_SUCCESS ? 1 : 0;

bin/tests/system/rsabigexponent/bigkey.c

@@ -140,7 +140,7 @@ main(int argc, char **argv) {
 	printf("%s\n", filename);
 	dst_key_free(&key);
 
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 	return 0;
 }
 

bin/tests/wire_test.c

@@ -260,7 +260,7 @@ main(int argc, char *argv[]) {
 	if (printmemstats) {
 		isc_mem_stats(mctx, stdout);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

bin/tools/dnstap-read.c

@@ -425,7 +425,7 @@ cleanup:
 	if (message != NULL) {
 		dns_message_detach(&message);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	exit(rv);
 }

bin/tools/named-rrchecker.c

@@ -61,7 +61,7 @@ cleanup(void) {
 		isc_lex_destroy(&lex);
 	}
 	if (mctx != NULL) {
-		isc_mem_destroy(&mctx);
+		isc_mem_detach(&mctx);
 	}
 }
 

doc/misc/cfg_test.c

@@ -154,7 +154,7 @@ main(int argc, char **argv) {
 	if (memstats) {
 		isc_mem_stats(mctx, stderr);
 	}
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	fflush(stdout);
 	if (ferror(stdout)) {

fuzz/dns_master_load.c

@@ -74,6 +74,6 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
 end:
 	dns_db_detach(&db);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 	return 0;
 }

fuzz/dns_qp.c

@@ -211,7 +211,7 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 	}
 
 	dns_qp_destroy(&qp);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 	isc_mem_checkdestroyed(stderr);
 
 	for (size_t i = 0; i < ARRAY_SIZE(item); i++) {

fuzz/dns_rdata_fromtext.c

@@ -145,6 +145,6 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 cleanup:
 	isc_lex_close(lex);
 	isc_lex_destroy(&lex);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 	return 0;
 }

lib/dns/dst_api.c

@@ -226,7 +226,7 @@ dst__lib_shutdown(void) {
 		}
 	}
 
-	isc_mem_destroy(&dst__mctx);
+	isc_mem_detach(&dst__mctx);
 }
 
 bool

lib/isc/crypto.c

@@ -114,14 +114,14 @@ unregister_algorithms(void) {
 
 static void *
 isc__crypto_malloc_ex(size_t size, const char *file, int line) {
-	return isc__mem_allocate(isc__crypto_mctx, size, 0, file,
+	return isc__mem_allocate(isc__crypto_mctx, size, 0, __func__, file,
 				 (unsigned int)line);
 }
 
 static void *
 isc__crypto_realloc_ex(void *ptr, size_t size, const char *file, int line) {
-	return isc__mem_reallocate(isc__crypto_mctx, ptr, size, 0, file,
-				   (unsigned int)line);
+	return isc__mem_reallocate(isc__crypto_mctx, ptr, size, 0, __func__,
+				   file, (unsigned int)line);
 }
 
 static void
@@ -130,7 +130,7 @@ isc__crypto_free_ex(void *ptr, const char *file, int line) {
 		return;
 	}
 	if (isc__crypto_mctx != NULL) {
-		isc__mem_free(isc__crypto_mctx, ptr, 0, file,
+		isc__mem_free(isc__crypto_mctx, ptr, 0, __func__, file,
 			      (unsigned int)line);
 	}
 }
@@ -314,5 +314,5 @@ isc__crypto_shutdown(void) {
 
 	OPENSSL_cleanup();
 
-	isc_mem_destroy(&isc__crypto_mctx);
+	isc_mem_detach(&isc__crypto_mctx);
 }

lib/isc/include/isc/mem.h

@@ -21,9 +21,12 @@
 #include <isc/attributes.h>
 #include <isc/mutex.h>
 #include <isc/overflow.h>
+#include <isc/refcount.h>
 #include <isc/types.h>
 #include <isc/urcu.h>
 
+/* Add -DISC_MEM_TRACE=1 to CFLAGS for detailed reference tracing */
+
 /*%
  * Define ISC_MEM_TRACKLINES=1 to turn on detailed tracing of memory
  * allocation and freeing by file and line number.
@@ -62,8 +65,8 @@ extern unsigned int isc_mem_defaultflags;
 /*@}*/
 
 #if ISC_MEM_TRACKLINES
-#define _ISC_MEM_FILELINE , __FILE__, __LINE__
-#define _ISC_MEM_FLARG	  , const char *, unsigned int
+#define _ISC_MEM_FILELINE , __func__, __FILE__, __LINE__
+#define _ISC_MEM_FLARG	  , const char *, const char *, unsigned int
 #else /* if ISC_MEM_TRACKLINES */
 #define _ISC_MEM_FILELINE
 #define _ISC_MEM_FLARG
@@ -249,35 +252,16 @@ isc_mem_arena_set_dirty_decay_ms(isc_mem_t *mctx, const ssize_t decay_ms);
  */
 /*@}*/
 
-void
-isc_mem_attach(isc_mem_t *, isc_mem_t **);
-
-/*@{*/
-void
-isc_mem_attach(isc_mem_t *, isc_mem_t **);
-#define isc_mem_detach(cp) isc__mem_detach((cp)_ISC_MEM_FILELINE)
-void
-isc__mem_detach(isc_mem_t **_ISC_MEM_FLARG);
-/*!<
- * \brief Attach to / detach from a memory context.
- *
- * This is intended for applications that use multiple memory contexts
- * in such a way that it is not obvious when the last allocations from
- * a given context has been freed and destroying the context is safe.
- *
- * Most applications do not need to call these functions as they can
- * simply create a single memory context at the beginning of main()
- * and destroy it at the end of main(), thereby guaranteeing that it
- * is not destroyed while there are outstanding allocations.
- */
-/*@}*/
-
-#define isc_mem_destroy(cp) isc__mem_destroy((cp)_ISC_MEM_FILELINE)
-void
-isc__mem_destroy(isc_mem_t **_ISC_MEM_FLARG);
-/*%<
- * Destroy a memory context.
- */
+#if ISC_MEM_TRACE
+#define isc_mem_ref(ptr)   isc_mem__ref(ptr, __func__, __FILE__, __LINE__)
+#define isc_mem_unref(ptr) isc_mem__unref(ptr, __func__, __FILE__, __LINE__)
+#define isc_mem_attach(ptr, ptrp) \
+	isc_mem__attach(ptr, ptrp, __func__, __FILE__, __LINE__)
+#define isc_mem_detach(ptrp) isc_mem__detach(ptrp, __func__, __FILE__, __LINE__)
+ISC_REFCOUNT_TRACE_DECL(isc_mem);
+#else
+ISC_REFCOUNT_DECL(isc_mem);
+#endif
 
 void
 isc_mem_stats(isc_mem_t *mctx, FILE *out);

lib/isc/managers.c

@@ -47,5 +47,5 @@ isc_managers_destroy(isc_mem_t **mctxp, isc_loopmgr_t **loopmgrp,
 
 	isc_netmgr_destroy(netmgrp);
 	isc_loopmgr_destroy(loopmgrp);
-	isc_mem_destroy(mctxp);
+	isc_mem_detach(mctxp);
 }

lib/isc/mem.c

@@ -86,14 +86,15 @@ struct debuglink {
 	ISC_LINK(debuglink_t) link;
 	const void *ptr;
 	size_t size;
+	const char *func;
 	const char *file;
 	unsigned int line;
 };
 
 typedef ISC_LIST(debuglink_t) debuglist_t;
 
-#define FLARG_PASS , file, line
-#define FLARG	   , const char *file, unsigned int line
+#define FLARG_PASS , func, file, line
+#define FLARG	   , const char *func, const char *file, unsigned int line
 #else /* if ISC_MEM_TRACKLINES */
 #define FLARG_PASS
 #define FLARG
@@ -164,8 +165,8 @@ struct isc_mempool {
  */
 
 #if !ISC_MEM_TRACKLINES
-#define ADD_TRACE(mctx, ptr, size, file, line)
-#define DELETE_TRACE(mctx, ptr, size, file, line)
+#define ADD_TRACE(mctx, ptr, size, func, file, line)
+#define DELETE_TRACE(mctx, ptr, size, func, file, line)
 #define ISC_MEMFUNC_SCOPE
 #else /* if !ISC_MEM_TRACKLINES */
 #define TRACE_OR_RECORD (ISC_MEM_DEBUGTRACE | ISC_MEM_DEBUGRECORD)
@@ -173,14 +174,14 @@ struct isc_mempool {
 #define SHOULD_TRACE_OR_RECORD(mctx, ptr) \
 	(((mctx)->debugging & TRACE_OR_RECORD) != 0 && ptr != NULL)
 
-#define ADD_TRACE(mctx, ptr, size, file, line)                \
-	if (SHOULD_TRACE_OR_RECORD(mctx, ptr)) {              \
-		add_trace_entry(mctx, ptr, size, file, line); \
+#define ADD_TRACE(mctx, ptr, size, func, file, line)                \
+	if (SHOULD_TRACE_OR_RECORD(mctx, ptr)) {                    \
+		add_trace_entry(mctx, ptr, size, func, file, line); \
 	}
 
-#define DELETE_TRACE(mctx, ptr, size, file, line)                \
-	if (SHOULD_TRACE_OR_RECORD(mctx, ptr)) {                 \
-		delete_trace_entry(mctx, ptr, size, file, line); \
+#define DELETE_TRACE(mctx, ptr, size, func, file, line)                \
+	if (SHOULD_TRACE_OR_RECORD(mctx, ptr)) {                       \
+		delete_trace_entry(mctx, ptr, size, func, file, line); \
 	}
 
 static void
@@ -200,8 +201,9 @@ add_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size FLARG) {
 	MCTXLOCK(mctx);
 
 	if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "add %p size %zu file %s line %u mctx %p\n",
-			ptr, size, file, line, mctx);
+		fprintf(stderr,
+			"add %p size %zu func %s file %s line %u mctx %p\n",
+			ptr, size, func, file, line, mctx);
 	}
 
 	if (mctx->debuglist == NULL) {
@@ -225,6 +227,7 @@ add_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size FLARG) {
 	ISC_LINK_INIT(dl, link);
 	dl->ptr = ptr;
 	dl->size = size;
+	dl->func = func;
 	dl->file = file;
 	dl->line = line;
 
@@ -235,8 +238,7 @@ unlock:
 }
 
 static void
-delete_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size,
-		   const char *file, unsigned int line) {
+delete_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size FLARG) {
 	debuglink_t *dl = NULL;
 	uint32_t hash;
 	uint32_t idx;
@@ -244,8 +246,9 @@ delete_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size,
 	MCTXLOCK(mctx);
 
 	if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "del %p size %zu file %s line %u mctx %p\n",
-			ptr, size, file, line, mctx);
+		fprintf(stderr,
+			"del %p size %zu func %s file %s line %u mctx %p\n",
+			ptr, size, func, file, line, mctx);
 	}
 
 	if (mctx->debuglist == NULL) {
@@ -427,6 +430,8 @@ void
 isc__mem_shutdown(void) {
 	bool empty;
 
+	rcu_barrier();
+
 	isc__mem_checkdestroyed();
 
 	LOCK(&contextslock);
@@ -495,8 +500,11 @@ mem_create(isc_mem_t **ctxp, unsigned int debugging, unsigned int flags,
  */
 
 static void
-destroy(isc_mem_t *ctx) {
+mem_destroy(isc_mem_t *ctx) {
 	unsigned int arena_no;
+
+	isc_refcount_destroy(&ctx->references);
+
 	LOCK(&contextslock);
 	ISC_LIST_UNLINK(contexts, ctx, link);
 	UNLOCK(&contextslock);
@@ -543,36 +551,11 @@ destroy(isc_mem_t *ctx) {
 	}
 }
 
-void
-isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
-	REQUIRE(VALID_CONTEXT(source));
-	REQUIRE(targetp != NULL && *targetp == NULL);
-
-	isc_refcount_increment(&source->references);
-
-	*targetp = source;
-}
-
-void
-isc__mem_detach(isc_mem_t **ctxp FLARG) {
-	isc_mem_t *ctx = NULL;
-
-	REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp));
-
-	ctx = *ctxp;
-	*ctxp = NULL;
-
-	if (isc_refcount_decrement(&ctx->references) == 1) {
-		isc_refcount_destroy(&ctx->references);
-#if ISC_MEM_TRACKLINES
-		if ((ctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-			fprintf(stderr, "destroy mctx %p file %s line %u\n",
-				ctx, file, line);
-		}
+#if ISC_MEM_TRACE
+ISC_REFCOUNT_TRACE_IMPL(isc_mem, mem_destroy);
+#else
+ISC_REFCOUNT_IMPL(isc_mem, mem_destroy);
 #endif
-		destroy(ctx);
-	}
-}
 
 /*
  * isc_mem_putanddetach() is the equivalent of:
@@ -595,41 +578,11 @@ isc__mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size,
 	*ctxp = NULL;
 
 	isc__mem_put(ctx, ptr, size, flags FLARG_PASS);
-	isc__mem_detach(&ctx FLARG_PASS);
-}
-
-void
-isc__mem_destroy(isc_mem_t **ctxp FLARG) {
-	isc_mem_t *ctx = NULL;
-
-	/*
-	 * This routine provides legacy support for callers who use mctxs
-	 * without attaching/detaching.
-	 */
-
-	REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp));
-
-	ctx = *ctxp;
-	*ctxp = NULL;
-
-	rcu_barrier();
-
-#if ISC_MEM_TRACKLINES
-	if ((ctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "destroy mctx %p file %s line %u\n", ctx, file,
-			line);
-	}
-
-	if (isc_refcount_decrement(&ctx->references) > 1) {
-		print_active(ctx, stderr);
-	}
-#else  /* if ISC_MEM_TRACKLINES */
-	isc_refcount_decrementz(&ctx->references);
-#endif /* if ISC_MEM_TRACKLINES */
-	isc_refcount_destroy(&ctx->references);
-	destroy(ctx);
-
-	*ctxp = NULL;
+#if ISC_MEM_TRACE
+	isc_mem__detach(&ctx, func, file, line);
+#else
+	isc_mem_detach(&ctx);
+#endif
 }
 
 void *
@@ -641,7 +594,7 @@ isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) {
 	ptr = mem_get(ctx, size, flags);
 
 	mem_getstats(ctx, size);
-	ADD_TRACE(ctx, ptr, size, file, line);
+	ADD_TRACE(ctx, ptr, size, func, file, line);
 
 	return ptr;
 }
@@ -650,7 +603,7 @@ void
 isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) {
 	REQUIRE(VALID_CONTEXT(ctx));
 
-	DELETE_TRACE(ctx, ptr, size, file, line);
+	DELETE_TRACE(ctx, ptr, size, func, file, line);
 
 	mem_putstats(ctx, size);
 	mem_put(ctx, ptr, size, flags);
@@ -747,7 +700,7 @@ isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) {
 	size = sallocx(ptr, flags | ctx->jemalloc_flags);
 
 	mem_getstats(ctx, size);
-	ADD_TRACE(ctx, ptr, size, file, line);
+	ADD_TRACE(ctx, ptr, size, func, file, line);
 
 	return ptr;
 }
@@ -763,13 +716,13 @@ isc__mem_reget(isc_mem_t *ctx, void *old_ptr, size_t old_size, size_t new_size,
 	} else if (new_size == 0) {
 		isc__mem_put(ctx, old_ptr, old_size, flags FLARG_PASS);
 	} else {
-		DELETE_TRACE(ctx, old_ptr, old_size, file, line);
+		DELETE_TRACE(ctx, old_ptr, old_size, func, file, line);
 		mem_putstats(ctx, old_size);
 
 		new_ptr = mem_realloc(ctx, old_ptr, old_size, new_size, flags);
 
 		mem_getstats(ctx, new_size);
-		ADD_TRACE(ctx, new_ptr, new_size, file, line);
+		ADD_TRACE(ctx, new_ptr, new_size, func, file, line);
 
 		/*
 		 * We want to postpone the call to water in edge case
@@ -795,7 +748,7 @@ isc__mem_reallocate(isc_mem_t *ctx, void *old_ptr, size_t new_size,
 	} else {
 		size_t old_size = sallocx(old_ptr, flags | ctx->jemalloc_flags);
 
-		DELETE_TRACE(ctx, old_ptr, old_size, file, line);
+		DELETE_TRACE(ctx, old_ptr, old_size, func, file, line);
 		mem_putstats(ctx, old_size);
 
 		new_ptr = mem_realloc(ctx, old_ptr, old_size, new_size, flags);
@@ -804,7 +757,7 @@ isc__mem_reallocate(isc_mem_t *ctx, void *old_ptr, size_t new_size,
 		new_size = sallocx(new_ptr, flags | ctx->jemalloc_flags);
 
 		mem_getstats(ctx, new_size);
-		ADD_TRACE(ctx, new_ptr, new_size, file, line);
+		ADD_TRACE(ctx, new_ptr, new_size, func, file, line);
 
 		/*
 		 * We want to postpone the call to water in edge case
@@ -825,7 +778,7 @@ isc__mem_free(isc_mem_t *ctx, void *ptr, int flags FLARG) {
 
 	size = sallocx(ptr, flags | ctx->jemalloc_flags);
 
-	DELETE_TRACE(ctx, ptr, size, file, line);
+	DELETE_TRACE(ctx, ptr, size, func, file, line);
 
 	mem_putstats(ctx, size);
 	mem_put(ctx, ptr, size, flags);
@@ -1010,8 +963,9 @@ isc__mempool_create(isc_mem_t *restrict mctx, const size_t element_size,
 
 #if ISC_MEM_TRACKLINES
 	if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "create pool %p file %s line %u mctx %p\n",
-			mpctx, file, line, mctx);
+		fprintf(stderr,
+			"create pool %p func %s file %s line %u mctx %p\n",
+			mpctx, func, file, line, mctx);
 	}
 #endif /* ISC_MEM_TRACKLINES */
 
@@ -1050,8 +1004,9 @@ isc__mempool_destroy(isc_mempool_t **restrict mpctxp FLARG) {
 
 #if ISC_MEM_TRACKLINES
 	if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "destroy pool %p file %s line %u mctx %p\n",
-			mpctx, file, line, mctx);
+		fprintf(stderr,
+			"destroy pool %p func %s file %s line %u mctx %p\n",
+			mpctx, func, file, line, mctx);
 	}
 #endif
 
@@ -1123,7 +1078,7 @@ isc__mempool_get(isc_mempool_t *restrict mpctx FLARG) {
 	mpctx->freecount--;
 	mpctx->gets++;
 
-	ADD_TRACE(mpctx->mctx, item, mpctx->size, file, line);
+	ADD_TRACE(mpctx->mctx, item, mpctx->size, func, file, line);
 
 	return item;
 }
@@ -1147,7 +1102,7 @@ isc__mempool_put(isc_mempool_t *restrict mpctx, void *mem FLARG) {
 	INSIST(mpctx->allocated > 0);
 	mpctx->allocated--;
 
-	DELETE_TRACE(mctx, mem, mpctx->size, file, line);
+	DELETE_TRACE(mctx, mem, mpctx->size, func, file, line);
 
 	/*
 	 * If our free list is full, return this to the mctx directly.
@@ -1482,8 +1437,8 @@ isc__mem_create(isc_mem_t **mctxp FLARG) {
 	mem_create(mctxp, isc_mem_debugging, isc_mem_defaultflags, 0);
 #if ISC_MEM_TRACKLINES
 	if ((isc_mem_debugging & ISC_MEM_DEBUGTRACE) != 0) {
-		fprintf(stderr, "create mctx %p file %s line %u\n", *mctxp,
-			file, line);
+		fprintf(stderr, "create mctx %p func %s file %s line %u\n",
+			*mctxp, func, file, line);
 	}
 #endif /* ISC_MEM_TRACKLINES */
 }
@@ -1509,9 +1464,9 @@ isc__mem_create_arena(isc_mem_t **mctxp FLARG) {
 #if ISC_MEM_TRACKLINES
 	if ((isc_mem_debugging & ISC_MEM_DEBUGTRACE) != 0) {
 		fprintf(stderr,
-			"create mctx %p file %s line %u for jemalloc arena "
-			"%u\n",
-			*mctxp, file, line, arena_no);
+			"create mctx %p func %s file %s line %u "
+			"for jemalloc arena %u\n",
+			*mctxp, func, file, line, arena_no);
 	}
 #endif /* ISC_MEM_TRACKLINES */
 }

lib/isc/uv.c

@@ -146,7 +146,7 @@ void
 isc__uv_shutdown(void) {
 #if UV_VERSION_HEX >= UV_VERSION(1, 38, 0)
 	uv_library_shutdown();
-	isc_mem_destroy(&isc__uv_mctx);
+	isc_mem_detach(&isc__uv_mctx);
 #endif /* UV_VERSION_HEX < UV_VERSION(1, 38, 0) */
 }
 

lib/isc/xml.c

@@ -64,7 +64,7 @@ void
 isc__xml_shutdown(void) {
 #ifdef HAVE_LIBXML2
 	xmlCleanupParser();
-	isc_mem_destroy(&isc__xml_mctx);
+	isc_mem_detach(&isc__xml_mctx);
 #endif /* HAVE_LIBXML2 */
 }
 

tests/bench/compress.c

@@ -100,7 +100,7 @@ main(void) {
 
 	printf("names %u\n", count);
 
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

tests/bench/qpmulti.c

@@ -889,7 +889,7 @@ main(void) {
 
 	isc_mem_free(mctx, item);
 	isc_mem_checkdestroyed(stdout);
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

tests/dns/qpdb_test.c

@@ -158,7 +158,7 @@ ISC_LOOP_TEST_IMPL(overmempurge_bigrdata) {
 	}
 
 	dns_db_detach(&db);
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 	isc_loopmgr_shutdown(loopmgr);
 }
 
@@ -208,7 +208,7 @@ ISC_LOOP_TEST_IMPL(overmempurge_longname) {
 	}
 
 	dns_db_detach(&db);
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 	isc_loopmgr_shutdown(loopmgr);
 }
 

tests/include/tests/isc.h

@@ -249,7 +249,7 @@ teardown_managers(void **state);
 			r = cmocka_run_group_tests(tests, setup, teardown);             \
 		}                                                                       \
                                                                                         \
-		isc_mem_destroy(&mctx);                                                 \
+		isc_mem_detach(&mctx);                                                  \
                                                                                         \
 		return (r);                                                             \
 	}

tests/isc/mem_test.c

@@ -197,7 +197,7 @@ ISC_RUN_TEST_IMPL(isc_mem_inuse) {
 
 	assert_int_equal(diff, 0);
 
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 }
 
 ISC_RUN_TEST_IMPL(isc_mem_zeroget) {
@@ -323,7 +323,7 @@ ISC_RUN_TEST_IMPL(isc_mem_overmem) {
 	isc_mem_free(omctx, data1);
 	assert_false(isc_mem_isovermem(omctx));
 
-	isc_mem_destroy(&omctx);
+	isc_mem_detach(&omctx);
 }
 
 #if ISC_MEM_TRACKLINES
@@ -345,7 +345,7 @@ ISC_RUN_TEST_IMPL(isc_mem_noflags) {
 	assert_non_null(ptr);
 	isc__mem_printactive(mctx2, f);
 	isc_mem_put(mctx2, ptr, 2048);
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 	isc_mem_debugging = ISC_MEM_DEBUGRECORD;
 	isc_stdio_close(f);
 
@@ -379,7 +379,7 @@ ISC_RUN_TEST_IMPL(isc_mem_recordflag) {
 	assert_non_null(ptr);
 	isc__mem_printactive(mctx2, f);
 	isc_mem_put(mctx2, ptr, 2048);
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 	isc_stdio_close(f);
 
 	memset(buf, 0, sizeof(buf));
@@ -419,7 +419,7 @@ ISC_RUN_TEST_IMPL(isc_mem_traceflag) {
 	assert_non_null(ptr);
 	isc__mem_printactive(mctx2, f);
 	isc_mem_put(mctx2, ptr, 2048);
-	isc_mem_destroy(&mctx2);
+	isc_mem_detach(&mctx2);
 	isc_mem_debugging = ISC_MEM_DEBUGRECORD;
 	isc_stdio_close(f);
 

tests/libtest/isc.c

@@ -79,7 +79,7 @@ setup_mctx(void **state ISC_ATTR_UNUSED) {
 
 int
 teardown_mctx(void **state ISC_ATTR_UNUSED) {
-	isc_mem_destroy(&mctx);
+	isc_mem_detach(&mctx);
 
 	return 0;
 }

util/memleak.pl

@@ -17,8 +17,8 @@
 $mem_stats = '';
 
 while (<>) {
-    $gets{$1.$2} = $_ if (/add (?:0x)?([0-9a-f]+) size (?:0x)?([0-9]+) file/);
-    delete $gets{$1.$2} if /del (?:0x)?([0-9a-f]+) size (?:0x)?([0-9]+) file/;
+    $gets{$1.$2} = $_ if (/add (?:0x)?([0-9a-f]+) size (?:0x)?([0-9]+) func/);
+    delete $gets{$1.$2} if /del (?:0x)?([0-9a-f]+) size (?:0x)?([0-9]+) func/;
     $mem_stats .= $_ if /\d+ gets, +(\d+) rem/ && $1 > 0;
 }
 print join('', values %gets);