diff --git a/bin/dig/dighost.c b/bin/dig/dighost.c
index 5d35e79439..c362ba5741 100644
--- a/bin/dig/dighost.c
+++ b/bin/dig/dighost.c
@@ -1390,8 +1390,7 @@ setup_libs(void) {
 	isc_mempool_setfreemax(commctx, 6);
 	isc_mempool_setfillcount(commctx, 2);
 
-	result = isc_mutex_init(&lookup_lock);
-	check_result(result, "isc_mutex_init");
+	isc_mutex_init(&lookup_lock);
 }
 
 typedef struct dig_ednsoptname {
diff --git a/bin/dnssec/dnssec-signzone.c b/bin/dnssec/dnssec-signzone.c
index c409ac25cc..d5423902e8 100644
--- a/bin/dnssec/dnssec-signzone.c
+++ b/bin/dnssec/dnssec-signzone.c
@@ -3874,9 +3874,11 @@ main(int argc, char *argv[]) {
 			      isc_result_totext(result));
 	}
 
-	RUNTIME_CHECK(isc_mutex_init(&namelock) == ISC_R_SUCCESS);
-	if (printstats)
-		RUNTIME_CHECK(isc_mutex_init(&statslock) == ISC_R_SUCCESS);
+	isc_mutex_init(&namelock);
+
+	if (printstats) {
+		isc_mutex_init(&statslock);
+	}
 
 	presign();
 	TIME_NOW(&sign_start);
diff --git a/bin/named/server.c b/bin/named/server.c
index 4b1e6a3fb4..75104226a0 100644
--- a/bin/named/server.c
+++ b/bin/named/server.c
@@ -9615,8 +9615,8 @@ named_server_create(isc_mem_t *mctx, named_server_t **serverp) {
 				     &server->in_roothints),
 		   "setting up root hints");
 
-	CHECKFATAL(isc_mutex_init(&server->reload_event_lock),
-		   "initializing reload event lock");
+	isc_mutex_init(&server->reload_event_lock);
+
 	server->reload_event =
 		isc_event_allocate(named_g_mctx, server,
 				   NAMED_EVENT_RELOAD,
diff --git a/bin/named/statschannel.c b/bin/named/statschannel.c
index bd8d1c58ce..7e023f064a 100644
--- a/bin/named/statschannel.c
+++ b/bin/named/statschannel.c
@@ -3253,11 +3253,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
 	listener->mctx = NULL;
 	ISC_LINK_INIT(listener, link);
 
-	result = isc_mutex_init(&listener->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(server->mctx, listener, sizeof(*listener));
-		return (ISC_R_FAILURE);
-	}
+	isc_mutex_init(&listener->lock);
 
 	isc_mem_attach(server->mctx, &listener->mctx);
 
diff --git a/bin/named/unix/dlz_dlopen_driver.c b/bin/named/unix/dlz_dlopen_driver.c
index 5adb8d2268..61602f3aea 100644
--- a/bin/named/unix/dlz_dlopen_driver.c
+++ b/bin/named/unix/dlz_dlopen_driver.c
@@ -252,9 +252,7 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
 	}
 
 	/* Initialize the lock */
-	result = isc_mutex_init(&cd->lock);
-	if (result != ISC_R_SUCCESS)
-		goto failed;
+	isc_mutex_init(&cd->lock);
 
 	/* Open the library */
 	dlopen_flags = RTLD_NOW|RTLD_GLOBAL;
diff --git a/bin/named/win32/dlz_dlopen_driver.c b/bin/named/win32/dlz_dlopen_driver.c
index bfc8605802..650f56aba3 100644
--- a/bin/named/win32/dlz_dlopen_driver.c
+++ b/bin/named/win32/dlz_dlopen_driver.c
@@ -253,9 +253,7 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
 	triedload = true;
 
 	/* Initialize the lock */
-	result = isc_mutex_init(&cd->lock);
-	if (result != ISC_R_SUCCESS)
-		goto failed;
+	isc_mutex_init(&cd->lock);
 
 	/* Open the library */
 	cd->dl_handle = LoadLibraryA(cd->dl_path);
diff --git a/bin/tests/optional/adb_test.c b/bin/tests/optional/adb_test.c
index f871c21691..8eeef45a47 100644
--- a/bin/tests/optional/adb_test.c
+++ b/bin/tests/optional/adb_test.c
@@ -290,8 +290,8 @@ main(int argc, char **argv) {
 
 	isc_stdtime_get(&now);
 
-	result = isc_mutex_init(&client_lock);
-	check_result(result, "isc_mutex_init(&client_lock)");
+	isc_mutex_init(&client_lock);
+
 	ISC_LIST_INIT(clients);
 
 	/*
diff --git a/bin/tests/optional/mempool_test.c b/bin/tests/optional/mempool_test.c
index 6a878f449c..f696ce0f69 100644
--- a/bin/tests/optional/mempool_test.c
+++ b/bin/tests/optional/mempool_test.c
@@ -30,7 +30,7 @@ main(int argc, char *argv[]) {
 
 	isc_mem_debugging = ISC_MEM_DEBUGRECORD;
 
-	RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	mctx = NULL;
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
diff --git a/bin/tests/optional/sig0_test.c b/bin/tests/optional/sig0_test.c
index cf00896409..3416f3588b 100644
--- a/bin/tests/optional/sig0_test.c
+++ b/bin/tests/optional/sig0_test.c
@@ -206,7 +206,7 @@ main(int argc, char *argv[]) {
 
 	RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
 
-	RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	mctx = NULL;
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
diff --git a/contrib/dlz/drivers/sdlz_helper.c b/contrib/dlz/drivers/sdlz_helper.c
index 6ed62697a4..c44f724382 100644
--- a/contrib/dlz/drivers/sdlz_helper.c
+++ b/contrib/dlz/drivers/sdlz_helper.c
@@ -35,7 +35,7 @@
 
 /*
  * Copyright (C) 1999-2001, 2016  Internet Systems Consortium, Inc. ("ISC")
- * 
+ *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
@@ -364,13 +364,7 @@ sdlzh_build_sqldbinstance(isc_mem_t *mctx, const char *allnodes_str,
 	isc_mem_attach(mctx, &db->mctx);
 
 	/* initialize the reference count mutex */
-	result = isc_mutex_init(&db->instance_lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		goto cleanup;
-	}
+	isc_mutex_init(&db->instance_lock);
 
 	/* build the all nodes query list */
 	result = build_querylist(mctx, allnodes_str, &db->zone,
diff --git a/lib/dns/acl.c b/lib/dns/acl.c
index f941512a46..7dfed5f69b 100644
--- a/lib/dns/acl.c
+++ b/lib/dns/acl.c
@@ -498,7 +498,7 @@ static bool	insecure_prefix_found;
 
 static void
 initialize_action(void) {
-	RUNTIME_CHECK(isc_mutex_init(&insecure_prefix_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&insecure_prefix_lock);
 }
 
 /*
diff --git a/lib/dns/adb.c b/lib/dns/adb.c
index c9b8510161..3e5bab999b 100644
--- a/lib/dns/adb.c
+++ b/lib/dns/adb.c
@@ -1895,7 +1895,6 @@ free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
 static inline dns_adbfind_t *
 new_adbfind(dns_adb_t *adb) {
 	dns_adbfind_t *h;
-	isc_result_t result;
 
 	h = isc_mempool_get(adb->ahmp);
 	if (h == NULL)
@@ -1920,11 +1919,7 @@ new_adbfind(dns_adb_t *adb) {
 	/*
 	 * private members
 	 */
-	result = isc_mutex_init(&h->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mempool_put(adb->ahmp, h);
-		return (NULL);
-	}
+	isc_mutex_init(&h->lock);
 
 	ISC_EVENT_INIT(&h->event, sizeof(isc_event_t), 0, 0, 0, NULL, NULL,
 		       NULL, NULL, h);
@@ -2606,29 +2601,12 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 
 	isc_mem_attach(mem, &adb->mctx);
 
-	result = isc_mutex_init(&adb->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0b;
-
-	result = isc_mutex_init(&adb->mplock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0c;
-
-	result = isc_mutex_init(&adb->reflock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0d;
-
-	result = isc_mutex_init(&adb->overmemlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0e;
-
-	result = isc_mutex_init(&adb->entriescntlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0f;
-
-	result = isc_mutex_init(&adb->namescntlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0g;
+	isc_mutex_init(&adb->lock);
+	isc_mutex_init(&adb->mplock);
+	isc_mutex_init(&adb->reflock);
+	isc_mutex_init(&adb->overmemlock);
+	isc_mutex_init(&adb->entriescntlock);
+	isc_mutex_init(&adb->namescntlock);
 
 #define ALLOCENTRY(adb, el) \
 	do { \
@@ -2790,17 +2768,11 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 		isc_mempool_destroy(&adb->afmp);
 
 	DESTROYLOCK(&adb->namescntlock);
- fail0g:
 	DESTROYLOCK(&adb->entriescntlock);
- fail0f:
 	DESTROYLOCK(&adb->overmemlock);
- fail0e:
 	DESTROYLOCK(&adb->reflock);
- fail0d:
 	DESTROYLOCK(&adb->mplock);
- fail0c:
 	DESTROYLOCK(&adb->lock);
- fail0b:
 	if (adb->excl != NULL)
 		isc_task_detach(&adb->excl);
 	isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
diff --git a/lib/dns/badcache.c b/lib/dns/badcache.c
index a47b72209c..3802f60119 100644
--- a/lib/dns/badcache.c
+++ b/lib/dns/badcache.c
@@ -75,9 +75,7 @@ dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
 	memset(bc, 0, sizeof(dns_badcache_t));
 
 	isc_mem_attach(mctx, &bc->mctx);
-	result = isc_mutex_init(&bc->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&bc->lock);
 
 	bc->table = isc_mem_get(bc->mctx, sizeof(*bc->table) * size);
 	if (bc->table == NULL) {
@@ -97,7 +95,6 @@ dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
 
  destroy_lock:
 	DESTROYLOCK(&bc->lock);
- cleanup:
 	isc_mem_putanddetach(&bc->mctx, bc, sizeof(dns_badcache_t));
 	return (result);
 }
diff --git a/lib/dns/byaddr.c b/lib/dns/byaddr.c
index a91b347ca7..63a5a9d381 100644
--- a/lib/dns/byaddr.c
+++ b/lib/dns/byaddr.c
@@ -224,9 +224,7 @@ dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
 	byaddr->task = NULL;
 	isc_task_attach(task, &byaddr->task);
 
-	result = isc_mutex_init(&byaddr->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_event;
+	isc_mutex_init(&byaddr->lock);
 
 	dns_fixedname_init(&byaddr->name);
 
@@ -252,7 +250,6 @@ dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
  cleanup_lock:
 	DESTROYLOCK(&byaddr->lock);
 
- cleanup_event:
 	ievent = (isc_event_t *)byaddr->event;
 	isc_event_free(&ievent);
 	byaddr->event = NULL;
diff --git a/lib/dns/cache.c b/lib/dns/cache.c
index 6523c98826..7a0b5142e9 100644
--- a/lib/dns/cache.c
+++ b/lib/dns/cache.c
@@ -212,13 +212,8 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 		}
 	}
 
-	result = isc_mutex_init(&cache->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mem;
-
-	result = isc_mutex_init(&cache->filelock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_lock;
+	isc_mutex_init(&cache->lock);
+	isc_mutex_init(&cache->filelock);
 
 	cache->references = 1;
 	cache->live_tasks = 0;
@@ -313,26 +308,26 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 	*cachep = cache;
 	return (ISC_R_SUCCESS);
 
- cleanup_db:
+cleanup_db:
 	dns_db_detach(&cache->db);
- cleanup_dbargv:
+cleanup_dbargv:
 	for (i = extra; i < cache->db_argc; i++)
 		if (cache->db_argv[i] != NULL)
 			isc_mem_free(cmctx, cache->db_argv[i]);
 	if (cache->db_argv != NULL)
 		isc_mem_put(cmctx, cache->db_argv,
 			    cache->db_argc * sizeof(char *));
- cleanup_dbtype:
+cleanup_dbtype:
 	isc_mem_free(cmctx, cache->db_type);
- cleanup_filelock:
+cleanup_filelock:
 	DESTROYLOCK(&cache->filelock);
- cleanup_stats:
+cleanup_stats:
 	isc_stats_detach(&cache->stats);
- cleanup_lock:
 	DESTROYLOCK(&cache->lock);
- cleanup_mem:
-	if (cache->name != NULL)
+cleanup_mem:
+	if (cache->name != NULL) {
 		isc_mem_free(cmctx, cache->name);
+	}
 	isc_mem_detach(&cache->hmctx);
 	isc_mem_putanddetach(&cache->mctx, cache, sizeof(*cache));
 	return (result);
@@ -596,9 +591,7 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
 {
 	isc_result_t result;
 
-	result = isc_mutex_init(&cleaner->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail;
+	isc_mutex_init(&cleaner->lock);
 
 	cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
 	cleaner->state = cleaner_s_idle;
@@ -687,7 +680,7 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
 	if (cleaner->iterator != NULL)
 		dns_dbiterator_destroy(&cleaner->iterator);
 	DESTROYLOCK(&cleaner->lock);
- fail:
+
 	return (result);
 }
 
diff --git a/lib/dns/catz.c b/lib/dns/catz.c
index ca42a55f7d..a0a653f008 100644
--- a/lib/dns/catz.c
+++ b/lib/dns/catz.c
@@ -557,9 +557,7 @@ dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm,
 		return (ISC_R_NOMEMORY);
 	memset(new_zones, 0, sizeof(*new_zones));
 
-	result = isc_mutex_init(&new_zones->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_newzones;
+	isc_mutex_init(&new_zones->lock);
 
 	isc_refcount_init(&new_zones->refs, 1);
 
@@ -584,7 +582,6 @@ dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm,
   cleanup_refcount:
 	isc_refcount_destroy(&new_zones->refs);
 	isc_mutex_destroy(&new_zones->lock);
-  cleanup_newzones:
 	isc_mem_put(mctx, new_zones, sizeof(*new_zones));
 
 	return (result);
diff --git a/lib/dns/client.c b/lib/dns/client.c
index 6c96a40b30..0ab615bb5c 100644
--- a/lib/dns/client.c
+++ b/lib/dns/client.c
@@ -450,11 +450,7 @@ dns_client_createx(isc_mem_t *mctx, isc_appctx_t *actx,
 	if (client == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&client->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, client, sizeof(*client));
-		return (result);
-	}
+	isc_mutex_init(&client->lock);
 
 	client->actx = actx;
 	client->taskmgr = taskmgr;
@@ -1244,11 +1240,7 @@ dns_client_resolve(dns_client_t *client, const dns_name_t *name,
 	if (resarg == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&resarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, resarg, sizeof(*resarg));
-		return (result);
-	}
+	isc_mutex_init(&resarg->lock);
 
 	resarg->actx = actx;
 	resarg->client = client;
@@ -1356,11 +1348,7 @@ dns_client_startresolve(dns_client_t *client, const dns_name_t *name,
 	if (rctx == NULL)
 		result = ISC_R_NOMEMORY;
 	else {
-		result = isc_mutex_init(&rctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_put(mctx, rctx, sizeof(*rctx));
-			rctx = NULL;
-		}
+		isc_mutex_init(&rctx->lock);
 	}
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
@@ -1655,11 +1643,7 @@ dns_client_request(dns_client_t *client, dns_message_t *qmessage,
 	if (reqarg == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&reqarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, reqarg, sizeof(*reqarg));
-		return (result);
-	}
+	isc_mutex_init(&reqarg->lock);
 
 	reqarg->actx = actx;
 	reqarg->client = client;
@@ -1761,11 +1745,7 @@ dns_client_startrequest(dns_client_t *client, dns_message_t *qmessage,
 	if (ctx == NULL)
 		result = ISC_R_NOMEMORY;
 	else {
-		result = isc_mutex_init(&ctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_put(client->mctx, ctx, sizeof(*ctx));
-			ctx = NULL;
-		}
+		isc_mutex_init(&ctx->lock);
 	}
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
@@ -2714,11 +2694,7 @@ dns_client_update(dns_client_t *client, dns_rdataclass_t rdclass,
 	if (uarg == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&uarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, uarg, sizeof(*uarg));
-		return (result);
-	}
+	isc_mutex_init(&uarg->lock);
 
 	uarg->actx = actx;
 	uarg->client = client;
@@ -2861,12 +2837,7 @@ dns_client_startupdate(dns_client_t *client, dns_rdataclass_t rdclass,
 		return (ISC_R_NOMEMORY);
 	}
 
-	result = isc_mutex_init(&uctx->lock);
-	if (result != ISC_R_SUCCESS) {
-		dns_view_detach(&view);
-		isc_mem_put(client->mctx, uctx, sizeof(*uctx));
-		return (ISC_R_NOMEMORY);
-	}
+	isc_mutex_init(&uctx->lock);
 
 	tclone = NULL;
 	isc_task_attach(task, &tclone);
diff --git a/lib/dns/dbtable.c b/lib/dns/dbtable.c
index 43951d6a39..934baac9d1 100644
--- a/lib/dns/dbtable.c
+++ b/lib/dns/dbtable.c
@@ -67,9 +67,7 @@ dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 	if (result != ISC_R_SUCCESS)
 		goto clean1;
 
-	result = isc_mutex_init(&dbtable->lock);
-	if (result != ISC_R_SUCCESS)
-		goto clean2;
+	isc_mutex_init(&dbtable->lock);
 
 	result = isc_rwlock_init(&dbtable->tree_lock, 0, 0);
 	if (result != ISC_R_SUCCESS)
@@ -89,7 +87,6 @@ dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
  clean3:
 	DESTROYLOCK(&dbtable->lock);
 
- clean2:
 	dns_rbt_destroy(&dbtable->rbt);
 
  clean1:
diff --git a/lib/dns/dispatch.c b/lib/dns/dispatch.c
index 57c94ba403..969153d0ef 100644
--- a/lib/dns/dispatch.c
+++ b/lib/dns/dispatch.c
@@ -1760,33 +1760,13 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 	mgr->blackhole = NULL;
 	mgr->stats = NULL;
 
-	result = isc_mutex_init(&mgr->lock);
-	if (result != ISC_R_SUCCESS)
-		goto deallocate;
-
-	result = isc_mutex_init(&mgr->buffer_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_lock;
-
-	result = isc_mutex_init(&mgr->depool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_buffer_lock;
-
-	result = isc_mutex_init(&mgr->rpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_depool_lock;
-
-	result = isc_mutex_init(&mgr->dpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_rpool_lock;
-
-	result = isc_mutex_init(&mgr->bpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_dpool_lock;
-
-	result = isc_mutex_init(&mgr->spool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_bpool_lock;
+	isc_mutex_init(&mgr->lock);
+	isc_mutex_init(&mgr->buffer_lock);
+	isc_mutex_init(&mgr->depool_lock);
+	isc_mutex_init(&mgr->rpool_lock);
+	isc_mutex_init(&mgr->dpool_lock);
+	isc_mutex_init(&mgr->bpool_lock);
+	isc_mutex_init(&mgr->spool_lock);
 
 	mgr->depool = NULL;
 	if (isc_mempool_create(mgr->mctx, sizeof(dns_dispatchevent_t),
@@ -1868,19 +1848,12 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 	isc_mempool_destroy(&mgr->depool);
  kill_spool_lock:
 	DESTROYLOCK(&mgr->spool_lock);
- kill_bpool_lock:
 	DESTROYLOCK(&mgr->bpool_lock);
- kill_dpool_lock:
 	DESTROYLOCK(&mgr->dpool_lock);
- kill_rpool_lock:
 	DESTROYLOCK(&mgr->rpool_lock);
- kill_depool_lock:
 	DESTROYLOCK(&mgr->depool_lock);
- kill_buffer_lock:
 	DESTROYLOCK(&mgr->buffer_lock);
- kill_lock:
 	DESTROYLOCK(&mgr->lock);
- deallocate:
 	isc_mem_put(mctx, mgr, sizeof(dns_dispatchmgr_t));
 	isc_mem_detach(&mctx);
 
@@ -2262,7 +2235,6 @@ qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
 {
 	dns_qid_t *qid;
 	unsigned int i;
-	isc_result_t result;
 
 	REQUIRE(VALID_DISPATCHMGR(mgr));
 	REQUIRE(buckets < 2097169);  /* next prime > 65536 * 32 */
@@ -2292,17 +2264,7 @@ qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
 		}
 	}
 
-	result = isc_mutex_init(&qid->lock);
-	if (result != ISC_R_SUCCESS) {
-		if (qid->sock_table != NULL) {
-			isc_mem_put(mgr->mctx, qid->sock_table,
-				    buckets * sizeof(dispsocketlist_t));
-		}
-		isc_mem_put(mgr->mctx, qid->qid_table,
-			    buckets * sizeof(dns_displist_t));
-		isc_mem_put(mgr->mctx, qid, sizeof(*qid));
-		return (result);
-	}
+	isc_mutex_init(&qid->lock);
 
 	for (i = 0; i < buckets; i++) {
 		ISC_LIST_INIT(qid->qid_table[i]);
@@ -2385,9 +2347,7 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, unsigned int maxrequests,
 	disp->portpool = NULL;
 	disp->dscp = -1;
 
-	result = isc_mutex_init(&disp->lock);
-	if (result != ISC_R_SUCCESS)
-		goto deallocate;
+	isc_mutex_init(&disp->lock);
 
 	disp->failsafe_ev = allocate_devent(disp);
 	if (disp->failsafe_ev == NULL) {
@@ -2405,7 +2365,6 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, unsigned int maxrequests,
 	 */
  kill_lock:
 	DESTROYLOCK(&disp->lock);
- deallocate:
 	isc_mempool_put(mgr->dpool, disp);
 
 	return (result);
@@ -2987,10 +2946,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 		goto kill_ctlevent;
 	}
 
-	result = isc_mutex_init(&disp->sepool_lock);
-	if (result != ISC_R_SUCCESS) {
-		goto kill_sepool;
-	}
+	isc_mutex_init(&disp->sepool_lock);
 
 	isc_mempool_setname(disp->sepool, "disp_sepool");
 	isc_mempool_setmaxalloc(disp->sepool, 32768);
@@ -3020,8 +2976,6 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 	/*
 	 * Error returns.
 	 */
- kill_sepool:
-	isc_mempool_destroy(&disp->sepool);
  kill_ctlevent:
 	isc_event_free(&disp->ctlevent);
  kill_task:
@@ -3692,9 +3646,7 @@ dns_dispatchset_create(isc_mem_t *mctx, isc_socketmgr_t *sockmgr,
 		return (ISC_R_NOMEMORY);
 	memset(dset, 0, sizeof(*dset));
 
-	result = isc_mutex_init(&dset->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail_alloc;
+	isc_mutex_init(&dset->lock);
 
 	dset->dispatches = isc_mem_get(mctx, sizeof(dns_dispatch_t *) * n);
 	if (dset->dispatches == NULL) {
@@ -3738,8 +3690,6 @@ dns_dispatchset_create(isc_mem_t *mctx, isc_socketmgr_t *sockmgr,
 
  fail_lock:
 	DESTROYLOCK(&dset->lock);
-
- fail_alloc:
 	isc_mem_put(mctx, dset, sizeof(dns_dispatchset_t));
 	return (result);
 }
diff --git a/lib/dns/dnsrps.c b/lib/dns/dnsrps.c
index b217b795d8..f2027fb52a 100644
--- a/lib/dns/dnsrps.c
+++ b/lib/dns/dnsrps.c
@@ -145,9 +145,7 @@ dns_dnsrps_server_create(void) {
 	if (librpz == NULL)
 		return (ISC_R_SUCCESS);
 
-	result = isc_mutex_init(&dnsrps_mutex);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mutex_init(&dnsrps_mutex);
 
 	librpz->set_log(&dnsrps_log_fnc, NULL);
 
diff --git a/lib/dns/dnstap.c b/lib/dns/dnstap.c
index d93e22d103..3a91090aa3 100644
--- a/lib/dns/dnstap.c
+++ b/lib/dns/dnstap.c
@@ -142,7 +142,7 @@ static unsigned int generation;
 
 static void
 mutex_init(void) {
-	RUNTIME_CHECK(isc_mutex_init(&dt_mutex) == ISC_R_SUCCESS);
+	isc_mutex_init(&dt_mutex);
 }
 
 static void
diff --git a/lib/dns/dyndb.c b/lib/dns/dyndb.c
index 93ad795401..0faf393878 100644
--- a/lib/dns/dyndb.c
+++ b/lib/dns/dyndb.c
@@ -67,7 +67,7 @@ static isc_once_t once = ISC_ONCE_INIT;
 
 static void
 dyndb_initialize(void) {
-	RUNTIME_CHECK(isc_mutex_init(&dyndb_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&dyndb_lock);
 	INIT_LIST(dyndb_implementations);
 }
 
diff --git a/lib/dns/ecdb.c b/lib/dns/ecdb.c
index e75a624157..cdf1a8e2c9 100644
--- a/lib/dns/ecdb.c
+++ b/lib/dns/ecdb.c
@@ -354,14 +354,7 @@ findnode(dns_db_t *db, const dns_name_t *name, bool create,
 	if (node == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&node->lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		isc_mem_put(mctx, node, sizeof(*node));
-		return (ISC_R_UNEXPECTED);
-	}
+	isc_mutex_init(&node->lock);
 
 	dns_name_init(&node->name, NULL);
 	result = dns_name_dup(name, mctx, &node->name);
@@ -625,16 +618,7 @@ dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 		return (result);
 	}
 
-	result = isc_mutex_init(&ecdb->lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		if (dns_name_dynamic(&ecdb->common.origin))
-			dns_name_free(&ecdb->common.origin, mctx);
-		isc_mem_put(mctx, ecdb, sizeof(*ecdb));
-		return (ISC_R_UNEXPECTED);
-	}
+	isc_mutex_init(&ecdb->lock);
 
 	ecdb->references = 1;
 	ISC_LIST_INIT(ecdb->nodes);
diff --git a/lib/dns/geoip.c b/lib/dns/geoip.c
index 49bdd7faac..140fe3b65e 100644
--- a/lib/dns/geoip.c
+++ b/lib/dns/geoip.c
@@ -86,7 +86,7 @@ static isc_mem_t *state_mctx = NULL;
 
 static void
 key_mutex_init(void) {
-	RUNTIME_CHECK(isc_mutex_init(&key_mutex) == ISC_R_SUCCESS);
+	isc_mutex_init(&key_mutex);
 }
 
 static void
diff --git a/lib/dns/lib.c b/lib/dns/lib.c
index 9bcf12bfa8..a58b0912db 100644
--- a/lib/dns/lib.c
+++ b/lib/dns/lib.c
@@ -91,15 +91,11 @@ initialize(void) {
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_db;
 
-	result = isc_mutex_init(&reflock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_dst;
+	isc_mutex_init(&reflock);
 
 	initialize_done = true;
 	return;
 
-  cleanup_dst:
-	dst_lib_destroy();
   cleanup_db:
 	if (dbimp != NULL)
 		dns_ecdb_unregister(&dbimp);
diff --git a/lib/dns/lookup.c b/lib/dns/lookup.c
index 997d4eac33..ecf9c8dab8 100644
--- a/lib/dns/lookup.c
+++ b/lib/dns/lookup.c
@@ -410,9 +410,7 @@ dns_lookup_create(isc_mem_t *mctx, const dns_name_t *name, dns_rdatatype_t type,
 	lookup->task = NULL;
 	isc_task_attach(task, &lookup->task);
 
-	result = isc_mutex_init(&lookup->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_event;
+	isc_mutex_init(&lookup->lock);
 
 	dns_fixedname_init(&lookup->name);
 
@@ -438,8 +436,6 @@ dns_lookup_create(isc_mem_t *mctx, const dns_name_t *name, dns_rdatatype_t type,
 
  cleanup_lock:
 	DESTROYLOCK(&lookup->lock);
-
- cleanup_event:
 	ievent = (isc_event_t *)lookup->event;
 	isc_event_free(&ievent);
 	lookup->event = NULL;
diff --git a/lib/dns/master.c b/lib/dns/master.c
index 875e5f7793..ac4c137468 100644
--- a/lib/dns/master.c
+++ b/lib/dns/master.c
@@ -534,11 +534,7 @@ loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
 	lctx = isc_mem_get(mctx, sizeof(*lctx));
 	if (lctx == NULL)
 		return (ISC_R_NOMEMORY);
-	result = isc_mutex_init(&lctx->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, lctx, sizeof(*lctx));
-		return (result);
-	}
+	isc_mutex_init(&lctx->lock);
 
 	lctx->inc = NULL;
 	result = incctx_create(mctx, origin, &lctx->inc);
diff --git a/lib/dns/masterdump.c b/lib/dns/masterdump.c
index e870d58703..109bffdc33 100644
--- a/lib/dns/masterdump.c
+++ b/lib/dns/masterdump.c
@@ -1527,9 +1527,8 @@ dumpctx_create(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version,
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 
-	result = isc_mutex_init(&dctx->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&dctx->lock);
+
 	if (version != NULL)
 		dns_db_attachversion(dctx->db, version, &dctx->version);
 	else if (!dns_db_iscache(db))
diff --git a/lib/dns/name.c b/lib/dns/name.c
index 74452934e9..9b704c75b5 100644
--- a/lib/dns/name.c
+++ b/lib/dns/name.c
@@ -1283,7 +1283,7 @@ free_specific(void *arg) {
 
 static void
 thread_key_mutex_init(void) {
-	RUNTIME_CHECK(isc_mutex_init(&thread_key_mutex) == ISC_R_SUCCESS);
+	isc_mutex_init(&thread_key_mutex);
 }
 
 static isc_result_t
diff --git a/lib/dns/portlist.c b/lib/dns/portlist.c
index 9fb983f6c5..882058de3b 100644
--- a/lib/dns/portlist.c
+++ b/lib/dns/portlist.c
@@ -68,18 +68,13 @@ compare(const void *arg1, const void *arg2) {
 isc_result_t
 dns_portlist_create(isc_mem_t *mctx, dns_portlist_t **portlistp) {
 	dns_portlist_t *portlist;
-	isc_result_t result;
 
 	REQUIRE(portlistp != NULL && *portlistp == NULL);
 
 	portlist = isc_mem_get(mctx, sizeof(*portlist));
 	if (portlist == NULL)
 		return (ISC_R_NOMEMORY);
-	result = isc_mutex_init(&portlist->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, portlist, sizeof(*portlist));
-		return (result);
-	}
+	isc_mutex_init(&portlist->lock);
 	isc_refcount_init(&portlist->refcount, 1);
 	portlist->list = NULL;
 	portlist->allocated = 0;
diff --git a/lib/dns/rdata/in_1/wks_11.c b/lib/dns/rdata/in_1/wks_11.c
index be5755412c..eabbe5bf7d 100644
--- a/lib/dns/rdata/in_1/wks_11.c
+++ b/lib/dns/rdata/in_1/wks_11.c
@@ -34,7 +34,7 @@
 static isc_mutex_t wks_lock;
 
 static void init_lock(void) {
-	RUNTIME_CHECK(isc_mutex_init(&wks_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&wks_lock);
 }
 
 static bool
diff --git a/lib/dns/request.c b/lib/dns/request.c
index d9902907c0..df19ebc37a 100644
--- a/lib/dns/request.c
+++ b/lib/dns/request.c
@@ -141,7 +141,6 @@ dns_requestmgr_create(isc_mem_t *mctx,
 {
 	dns_requestmgr_t *requestmgr;
 	isc_socket_t *sock;
-	isc_result_t result;
 	int i;
 	unsigned int dispattr;
 
@@ -166,20 +165,10 @@ dns_requestmgr_create(isc_mem_t *mctx,
 	if (requestmgr == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&requestmgr->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, requestmgr, sizeof(*requestmgr));
-		return (result);
-	}
+	isc_mutex_init(&requestmgr->lock);
+
 	for (i = 0; i < DNS_REQUEST_NLOCKS; i++) {
-		result = isc_mutex_init(&requestmgr->locks[i]);
-		if (result != ISC_R_SUCCESS) {
-			while (--i >= 0)
-				DESTROYLOCK(&requestmgr->locks[i]);
-			DESTROYLOCK(&requestmgr->lock);
-			isc_mem_put(mctx, requestmgr, sizeof(*requestmgr));
-			return (result);
-		}
+		isc_mutex_init(&requestmgr->locks[i]);
 	}
 	requestmgr->timermgr = timermgr;
 	requestmgr->socketmgr = socketmgr;
diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
index 4ed282b726..1d25f44505 100644
--- a/lib/dns/resolver.c
+++ b/lib/dns/resolver.c
@@ -9921,9 +9921,8 @@ dns_resolver_create(dns_view_t *view,
 		goto cleanup_badcache;
 	}
 	for (i = 0; i < ntasks; i++) {
-		result = isc_mutex_init(&res->buckets[i].lock);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup_buckets;
+		isc_mutex_init(&res->buckets[i].lock);
+
 		res->buckets[i].task = NULL;
 		result = isc_task_create(taskmgr, 0, &res->buckets[i].task);
 		if (result != ISC_R_SUCCESS) {
@@ -9960,11 +9959,7 @@ dns_resolver_create(dns_view_t *view,
 		ISC_LIST_INIT(res->dbuckets[i].list);
 		res->dbuckets[i].mctx = NULL;
 		isc_mem_attach(view->mctx, &res->dbuckets[i].mctx);
-		result = isc_mutex_init(&res->dbuckets[i].lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_detach(&res->dbuckets[i].mctx);
-			goto cleanup_dbuckets;
-		}
+		isc_mutex_init(&res->dbuckets[i].lock);
 		dbuckets_created++;
 	}
 
@@ -9994,17 +9989,9 @@ dns_resolver_create(dns_view_t *view,
 	res->primefetch = NULL;
 	res->nfctx = 0;
 
-	result = isc_mutex_init(&res->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_dispatches;
-
-	result = isc_mutex_init(&res->nlock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_lock;
-
-	result = isc_mutex_init(&res->primelock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_nlock;
+	isc_mutex_init(&res->lock);
+	isc_mutex_init(&res->nlock);
+	isc_mutex_init(&res->primelock);
 
 	task = NULL;
 	result = isc_task_create(taskmgr, 0, &task);
@@ -10052,20 +10039,14 @@ dns_resolver_create(dns_view_t *view,
 
  cleanup_primelock:
 	DESTROYLOCK(&res->primelock);
-
- cleanup_nlock:
 	DESTROYLOCK(&res->nlock);
-
- cleanup_lock:
 	DESTROYLOCK(&res->lock);
 
- cleanup_dispatches:
 	if (res->dispatches6 != NULL)
 		dns_dispatchset_destroy(&res->dispatches6);
 	if (res->dispatches4 != NULL)
 		dns_dispatchset_destroy(&res->dispatches4);
 
- cleanup_dbuckets:
 	for (i = 0; i < dbuckets_created; i++) {
 		DESTROYLOCK(&res->dbuckets[i].lock);
 		isc_mem_detach(&res->dbuckets[i].mctx);
diff --git a/lib/dns/rpz.c b/lib/dns/rpz.c
index c8d55208b7..09b71ba0a4 100644
--- a/lib/dns/rpz.c
+++ b/lib/dns/rpz.c
@@ -1447,10 +1447,7 @@ dns_rpz_new_zones(dns_rpz_zones_t **rpzsp, char *rps_cstr,
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_rwlock;
 
-	result = isc_mutex_init(&zones->maint_lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mutex;
-
+	isc_mutex_init(&zones->maint_lock);
 	isc_refcount_init(&zones->refs, 1);
 
 	zones->rps_cstr = rps_cstr;
@@ -1490,7 +1487,6 @@ cleanup_rbt:
 
 	DESTROYLOCK(&zones->maint_lock);
 
-cleanup_mutex:
 	isc_rwlock_destroy(&zones->search_lock);
 
 cleanup_rwlock:
diff --git a/lib/dns/rrl.c b/lib/dns/rrl.c
index 4b3ad7d67a..9a15bc813a 100644
--- a/lib/dns/rrl.c
+++ b/lib/dns/rrl.c
@@ -1296,11 +1296,7 @@ dns_rrl_init(dns_rrl_t **rrlp, dns_view_t *view, int min_entries) {
 		return (ISC_R_NOMEMORY);
 	memset(rrl, 0, sizeof(*rrl));
 	isc_mem_attach(view->mctx, &rrl->mctx);
-	result = isc_mutex_init(&rrl->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_putanddetach(&rrl->mctx, rrl, sizeof(*rrl));
-		return (result);
-	}
+	isc_mutex_init(&rrl->lock);
 	isc_stdtime_get(&rrl->ts_bases[0]);
 
 	view->rrl = rrl;
diff --git a/lib/dns/sdb.c b/lib/dns/sdb.c
index e8331bf2eb..fcde0e045e 100644
--- a/lib/dns/sdb.c
+++ b/lib/dns/sdb.c
@@ -226,9 +226,7 @@ dns_sdb_register(const char *drivername, const dns_sdbmethods_t *methods,
 	imp->flags = flags;
 	imp->mctx = NULL;
 	isc_mem_attach(mctx, &imp->mctx);
-	result = isc_mutex_init(&imp->driverlock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mctx;
+	isc_mutex_init(&imp->driverlock);
 
 	imp->dbimp = NULL;
 	result = dns_db_register(drivername, dns_sdb_create, imp, mctx,
@@ -241,7 +239,6 @@ dns_sdb_register(const char *drivername, const dns_sdbmethods_t *methods,
 
  cleanup_mutex:
 	DESTROYLOCK(&imp->driverlock);
- cleanup_mctx:
 	isc_mem_put(mctx, imp, sizeof(dns_sdbimplementation_t));
 	return (result);
 }
@@ -655,7 +652,6 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) {
 static isc_result_t
 createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep) {
 	dns_sdbnode_t *node;
-	isc_result_t result;
 
 	node = isc_mem_get(sdb->common.mctx, sizeof(dns_sdbnode_t));
 	if (node == NULL)
@@ -667,11 +663,7 @@ createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep) {
 	ISC_LIST_INIT(node->buffers);
 	ISC_LINK_INIT(node, link);
 	node->name = NULL;
-	result = isc_mutex_init(&node->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(sdb->common.mctx, node, sizeof(dns_sdbnode_t));
-		return (result);
-	}
+	isc_mutex_init(&node->lock);
 	dns_rdatacallbacks_init(&node->callbacks);
 	node->references = 1;
 	node->magic = SDBLOOKUP_MAGIC;
@@ -1333,9 +1325,7 @@ dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 
 	isc_mem_attach(mctx, &sdb->common.mctx);
 
-	result = isc_mutex_init(&sdb->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mctx;
+	isc_mutex_init(&sdb->lock);
 
 	result = dns_name_dupwithoffsets(origin, mctx, &sdb->common.origin);
 	if (result != ISC_R_SUCCESS)
@@ -1378,7 +1368,6 @@ dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 	dns_name_free(&sdb->common.origin, mctx);
  cleanup_lock:
 	(void)isc_mutex_destroy(&sdb->lock);
- cleanup_mctx:
 	isc_mem_put(mctx, sdb, sizeof(dns_sdb_t));
 	isc_mem_detach(&mctx);
 
diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c
index 015a358c37..405b14973f 100644
--- a/lib/dns/sdlz.c
+++ b/lib/dns/sdlz.c
@@ -467,7 +467,6 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) {
 static isc_result_t
 createnode(dns_sdlz_db_t *sdlz, dns_sdlznode_t **nodep) {
 	dns_sdlznode_t *node;
-	isc_result_t result;
 
 	node = isc_mem_get(sdlz->common.mctx, sizeof(dns_sdlznode_t));
 	if (node == NULL)
@@ -479,14 +478,7 @@ createnode(dns_sdlz_db_t *sdlz, dns_sdlznode_t **nodep) {
 	ISC_LIST_INIT(node->buffers);
 	ISC_LINK_INIT(node, link);
 	node->name = NULL;
-	result = isc_mutex_init(&node->lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		isc_mem_put(sdlz->common.mctx, node, sizeof(dns_sdlznode_t));
-		return (ISC_R_UNEXPECTED);
-	}
+	isc_mutex_init(&node->lock);
 	dns_rdatacallbacks_init(&node->callbacks);
 	node->references = 1;
 	node->magic = SDLZLOOKUP_MAGIC;
@@ -1550,9 +1542,7 @@ dns_sdlzcreateDBP(isc_mem_t *mctx, void *driverarg, void *dbdata,
 		goto mem_cleanup;
 
 	/* initialize the reference count mutex */
-	result = isc_mutex_init(&sdlzdb->refcnt_lock);
-	if (result != ISC_R_SUCCESS)
-		goto name_cleanup;
+	isc_mutex_init(&sdlzdb->refcnt_lock);
 
 	/* set the rest of the database structure attributes */
 	sdlzdb->dlzimp = imp;
@@ -1572,13 +1562,6 @@ dns_sdlzcreateDBP(isc_mem_t *mctx, void *driverarg, void *dbdata,
 	*dbp = (dns_db_t *) sdlzdb;
 
 	return (result);
-
-	/*
-	 * reference count mutex could not be initialized, clean up
-	 * name memory
-	 */
- name_cleanup:
-	dns_name_free(&sdlzdb->common.origin, mctx);
  mem_cleanup:
 	isc_mem_put(mctx, sdlzdb, sizeof(dns_sdlz_db_t));
 	return (result);
@@ -2096,13 +2079,7 @@ dns_sdlzregister(const char *drivername, const dns_sdlzmethods_t *methods,
 	 * initialize the driver lock, error if we cannot
 	 * (used if a driver does not support multiple threads)
 	 */
-	result = isc_mutex_init(&imp->driverlock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		goto cleanup_mctx;
-	}
+	isc_mutex_init(&imp->driverlock);
 
 	imp->dlz_imp = NULL;
 
@@ -2127,7 +2104,6 @@ dns_sdlzregister(const char *drivername, const dns_sdlzmethods_t *methods,
 	/* destroy the driver lock, we don't need it anymore */
 	DESTROYLOCK(&imp->driverlock);
 
- cleanup_mctx:
 	/*
 	 * return the memory back to the available memory pool and
 	 * remove it from the memory context.
diff --git a/lib/dns/ssu.c b/lib/dns/ssu.c
index 908569dba9..7a6b530670 100644
--- a/lib/dns/ssu.c
+++ b/lib/dns/ssu.c
@@ -61,7 +61,6 @@ struct dns_ssutable {
 
 isc_result_t
 dns_ssutable_create(isc_mem_t *mctx, dns_ssutable_t **tablep) {
-	isc_result_t result;
 	dns_ssutable_t *table;
 
 	REQUIRE(tablep != NULL && *tablep == NULL);
@@ -70,11 +69,7 @@ dns_ssutable_create(isc_mem_t *mctx, dns_ssutable_t **tablep) {
 	table = isc_mem_get(mctx, sizeof(dns_ssutable_t));
 	if (table == NULL)
 		return (ISC_R_NOMEMORY);
-	result = isc_mutex_init(&table->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, table, sizeof(dns_ssutable_t));
-		return (result);
-	}
+	isc_mutex_init(&table->lock);
 	table->references = 1;
 	table->mctx = NULL;
 	isc_mem_attach(mctx, &table->mctx);
diff --git a/lib/dns/stats.c b/lib/dns/stats.c
index 617ed3bf8f..4e63d42470 100644
--- a/lib/dns/stats.c
+++ b/lib/dns/stats.c
@@ -139,9 +139,7 @@ create_stats(isc_mem_t *mctx, dns_statstype_t type, int ncounters,
 	stats->counters = NULL;
 	stats->references = 1;
 
-	result = isc_mutex_init(&stats->lock);
-	if (result != ISC_R_SUCCESS)
-		goto clean_stats;
+	isc_mutex_init(&stats->lock);
 
 	result = isc_stats_create(mctx, &stats->counters, ncounters);
 	if (result != ISC_R_SUCCESS)
@@ -157,7 +155,6 @@ create_stats(isc_mem_t *mctx, dns_statstype_t type, int ncounters,
 
   clean_mutex:
 	DESTROYLOCK(&stats->lock);
-  clean_stats:
 	isc_mem_put(mctx, stats, sizeof(*stats));
 
 	return (result);
diff --git a/lib/dns/tests/dispatch_test.c b/lib/dns/tests/dispatch_test.c
index 68a9cd46ce..8bf338fb46 100644
--- a/lib/dns/tests/dispatch_test.c
+++ b/lib/dns/tests/dispatch_test.c
@@ -268,8 +268,7 @@ dispatch_getnext(void **state) {
 
 	UNUSED(state);
 
-	result = isc_mutex_init(&lock);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	result = isc_task_create(taskmgr, 0, &task);
 	assert_int_equal(result, ISC_R_SUCCESS);
diff --git a/lib/dns/validator.c b/lib/dns/validator.c
index b590abde75..1354e0b895 100644
--- a/lib/dns/validator.c
+++ b/lib/dns/validator.c
@@ -3762,9 +3762,9 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
 	memset(event->proofs, 0, sizeof(event->proofs));
 	event->optout = false;
 	event->secure = false;
-	result = isc_mutex_init(&val->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_event;
+
+	isc_mutex_init(&val->lock);
+
 	val->event = event;
 	val->options = options;
 	val->attributes = 0;
@@ -3812,7 +3812,6 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
  cleanup_mutex:
 	DESTROYLOCK(&val->lock);
 
- cleanup_event:
 	isc_task_detach(&tclone);
 	isc_event_free(ISC_EVENT_PTR(&event));
 
diff --git a/lib/dns/view.c b/lib/dns/view.c
index ecc43952d7..a568f624ed 100644
--- a/lib/dns/view.c
+++ b/lib/dns/view.c
@@ -115,9 +115,7 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 		goto cleanup_name;
 	}
 
-	result = isc_mutex_init(&view->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_name;
+	isc_mutex_init(&view->lock);
 
 	view->zonetable = NULL;
 	result = dns_zt_create(mctx, rdclass, &view->zonetable);
@@ -261,10 +259,7 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 	view->dtenv = NULL;
 	view->dttypes = 0;
 
-	result = isc_mutex_init(&view->new_zone_lock);
-	if (result != ISC_R_SUCCESS) {
-		goto cleanup_failcache;
-	}
+	isc_mutex_init(&view->new_zone_lock);
 
 	result = dns_order_create(view->mctx, &view->order);
 	if (result != ISC_R_SUCCESS) {
@@ -311,7 +306,6 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
  cleanup_new_zone_lock:
 	DESTROYLOCK(&view->new_zone_lock);
 
- cleanup_failcache:
 	dns_badcache_destroy(&view->failcache);
 
  cleanup_dynkeys:
diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index dbea5994e6..5ac43fba53 100644
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -900,10 +900,7 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
 	zone->mctx = NULL;
 	isc_mem_attach(mctx, &zone->mctx);
 
-	result = isc_mutex_init(&zone->lock);
-	if (result != ISC_R_SUCCESS) {
-		goto free_zone;
-	}
+	isc_mutex_init(&zone->lock);
 
 	result = ZONEDB_INITLOCK(&zone->dblock);
 	if (result != ISC_R_SUCCESS) {
@@ -1093,7 +1090,6 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
  free_mutex:
 	DESTROYLOCK(&zone->lock);
 
- free_zone:
 	isc_mem_putanddetach(&zone->mctx, zone, sizeof(*zone));
 	return (result);
 }
@@ -16189,9 +16185,7 @@ dns_zonemgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
 	ISC_LIST_INIT(zmgr->high);
 	ISC_LIST_INIT(zmgr->low);
 
-	result = isc_mutex_init(&zmgr->iolock);
-	if (result != ISC_R_SUCCESS)
-		goto free_startuprefreshrl;
+	isc_mutex_init(&zmgr->iolock);
 
 	zmgr->magic = ZONEMGR_MAGIC;
 
@@ -16202,8 +16196,6 @@ dns_zonemgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
  free_iolock:
 	DESTROYLOCK(&zmgr->iolock);
 #endif
- free_startuprefreshrl:
-	isc_ratelimiter_detach(&zmgr->startuprefreshrl);
  free_startupnotifyrl:
 	isc_ratelimiter_detach(&zmgr->startupnotifyrl);
  free_refreshrl:
diff --git a/lib/irs/context.c b/lib/irs/context.c
index 05450067a5..1e56786b09 100644
--- a/lib/irs/context.c
+++ b/lib/irs/context.c
@@ -135,7 +135,7 @@ free_specific_context(void *arg) {
 
 static void
 thread_key_mutex_init(void) {
-	RUNTIME_CHECK(isc_mutex_init(&thread_key_mutex) == ISC_R_SUCCESS);
+	isc_mutex_init(&thread_key_mutex);
 }
 
 static isc_result_t
diff --git a/lib/irs/getaddrinfo.c b/lib/irs/getaddrinfo.c
index c2f756264d..e78b9267f6 100644
--- a/lib/irs/getaddrinfo.c
+++ b/lib/irs/getaddrinfo.c
@@ -950,10 +950,7 @@ resolve_name(int family, const char *hostname, int flags,
 	head.ai_port = port;
 	head.actx = actx;
 	head.dnsclient = client;
-	result = isc_mutex_init(&head.list_lock);
-	if (result != ISC_R_SUCCESS) {
-		return (EAI_FAIL);
-	}
+	isc_mutex_init(&head.list_lock);
 
 	ISC_LIST_INIT(head.resstates);
 	result = make_resstates(mctx, hostname, &head, conf);
diff --git a/lib/isc/counter.c b/lib/isc/counter.c
index 8c70051837..64defaaf83 100644
--- a/lib/isc/counter.c
+++ b/lib/isc/counter.c
@@ -35,7 +35,6 @@ struct isc_counter {
 
 isc_result_t
 isc_counter_create(isc_mem_t *mctx, int limit, isc_counter_t **counterp) {
-	isc_result_t result;
 	isc_counter_t *counter;
 
 	REQUIRE(counterp != NULL && *counterp == NULL);
@@ -44,11 +43,7 @@ isc_counter_create(isc_mem_t *mctx, int limit, isc_counter_t **counterp) {
 	if (counter == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&counter->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, counter, sizeof(*counter));
-		return (result);
-	}
+	isc_mutex_init(&counter->lock);
 
 	counter->mctx = NULL;
 	isc_mem_attach(mctx, &counter->mctx);
diff --git a/lib/isc/httpd.c b/lib/isc/httpd.c
index 87a2187128..2cdec11f7c 100644
--- a/lib/isc/httpd.c
+++ b/lib/isc/httpd.c
@@ -268,11 +268,7 @@ isc_httpdmgr_create(isc_mem_t *mctx, isc_socket_t *sock, isc_task_t *task,
 	if (httpdmgr == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&httpdmgr->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, httpdmgr, sizeof(isc_httpdmgr_t));
-		return (result);
-	}
+	isc_mutex_init(&httpdmgr->lock);
 	httpdmgr->mctx = NULL;
 	isc_mem_attach(mctx, &httpdmgr->mctx);
 	httpdmgr->sock = NULL;
diff --git a/lib/isc/include/isc/queue.h b/lib/isc/include/isc/queue.h
index 210f302c84..6f8919da24 100644
--- a/lib/isc/include/isc/queue.h
+++ b/lib/isc/include/isc/queue.h
@@ -49,8 +49,8 @@
 
 #define ISC_QUEUE_INIT(queue, link) \
 	do { \
-		(void) isc_mutex_init(&(queue).taillock); \
-		(void) isc_mutex_init(&(queue).headlock); \
+		isc_mutex_init(&(queue).taillock); \
+		isc_mutex_init(&(queue).headlock); \
 		(queue).tail = (queue).head = NULL; \
 	} while (0)
 
diff --git a/lib/isc/log.c b/lib/isc/log.c
index b42d030d7d..1626ffcd0a 100644
--- a/lib/isc/log.c
+++ b/lib/isc/log.c
@@ -277,11 +277,7 @@ isc_log_create(isc_mem_t *mctx, isc_log_t **lctxp, isc_logconfig_t **lcfgp) {
 
 		ISC_LIST_INIT(lctx->messages);
 
-		result = isc_mutex_init(&lctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_putanddetach(&mctx, lctx, sizeof(*lctx));
-			return (result);
-		}
+		isc_mutex_init(&lctx->lock);
 
 		/*
 		 * Normally setting the magic number is the last step done
diff --git a/lib/isc/mem.c b/lib/isc/mem.c
index 5c449f3482..2733f618f7 100644
--- a/lib/isc/mem.c
+++ b/lib/isc/mem.c
@@ -751,7 +751,7 @@ default_memfree(void *arg, void *ptr) {
 
 static void
 initialize_action(void) {
-	RUNTIME_CHECK(isc_mutex_init(&contextslock) == ISC_R_SUCCESS);
+	isc_mutex_init(&contextslock);
 	ISC_LIST_INIT(contexts);
 	totallost = 0;
 }
@@ -783,11 +783,7 @@ isc_mem_createx(size_t init_max_size, size_t target_size,
 	}
 
 	if ((flags & ISC_MEMFLAG_NOLOCK) == 0) {
-		result = isc_mutex_init(&ctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			(memfree)(arg, ctx);
-			return (result);
-		}
+		isc_mutex_init(&ctx->lock);
 	}
 
 	if (init_max_size == 0U)
diff --git a/lib/isc/mutexblock.c b/lib/isc/mutexblock.c
index 6a629e7e0d..9cbd470318 100644
--- a/lib/isc/mutexblock.c
+++ b/lib/isc/mutexblock.c
@@ -19,18 +19,10 @@
 
 isc_result_t
 isc_mutexblock_init(isc_mutex_t *block, unsigned int count) {
-	isc_result_t result;
 	unsigned int i;
 
 	for (i = 0; i < count; i++) {
-		result = isc_mutex_init(&block[i]);
-		if (result != ISC_R_SUCCESS) {
-			while (i > 0U) {
-				i--;
-				DESTROYLOCK(&block[i]);
-			}
-			return (result);
-		}
+		isc_mutex_init(&block[i]);
 	}
 
 	return (ISC_R_SUCCESS);
diff --git a/lib/isc/pk11.c b/lib/isc/pk11.c
index c405e61608..aaddac5c20 100644
--- a/lib/isc/pk11.c
+++ b/lib/isc/pk11.c
@@ -137,8 +137,8 @@ static void
 initialize(void) {
 	char *pk11_provider;
 
-	RUNTIME_CHECK(isc_mutex_init(&alloclock) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_mutex_init(&sessionlock) == ISC_R_SUCCESS);
+	isc_mutex_init(&alloclock);
+	isc_mutex_init(&sessionlock);
 
 	pk11_provider = getenv("PKCS11_PROVIDER");
 	if (pk11_provider != NULL)
diff --git a/lib/isc/pthreads/include/isc/condition.h b/lib/isc/pthreads/include/isc/condition.h
index 0ad9a0f0b2..9cc04d0133 100644
--- a/lib/isc/pthreads/include/isc/condition.h
+++ b/lib/isc/pthreads/include/isc/condition.h
@@ -20,6 +20,7 @@
 #include <isc/mutex.h>
 #include <isc/result.h>
 #include <isc/strerr.h>
+#include <isc/string.h>
 #include <isc/types.h>
 
 typedef pthread_cond_t isc_condition_t;
diff --git a/lib/isc/pthreads/include/isc/mutex.h b/lib/isc/pthreads/include/isc/mutex.h
index 6c34a69c47..ed9c7c71ee 100644
--- a/lib/isc/pthreads/include/isc/mutex.h
+++ b/lib/isc/pthreads/include/isc/mutex.h
@@ -69,7 +69,7 @@ typedef pthread_mutex_t	isc_mutex_t;
 #else
 #define isc_mutex_init(mp) \
 	isc__mutex_init((mp), __FILE__, __LINE__)
-isc_result_t isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line);
+void isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line);
 #endif
 #endif
 
@@ -119,7 +119,7 @@ isc_result_t isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int lin
 
 #if ISC_MUTEX_PROFILE
 
-isc_result_t
+void
 isc_mutex_init_profile(isc_mutex_t *mp, const char * _file, int _line);
 isc_result_t
 isc_mutex_lock_profile(isc_mutex_t *mp, const char * _file, int _line);
@@ -129,7 +129,7 @@ isc_mutex_unlock_profile(isc_mutex_t *mp, const char * _file, int _line);
 void
 isc_mutex_statsprofile(FILE *fp);
 
-isc_result_t
+void
 isc_mutex_init_errcheck(isc_mutex_t *mp);
 
 #endif /* ISC_MUTEX_PROFILE */
diff --git a/lib/isc/pthreads/mutex.c b/lib/isc/pthreads/mutex.c
index b290b50fe0..68b782400a 100644
--- a/lib/isc/pthreads/mutex.c
+++ b/lib/isc/pthreads/mutex.c
@@ -83,7 +83,7 @@ static bool stats_init = false;
 static pthread_mutex_t statslock = PTHREAD_MUTEX_INITIALIZER;
 
 
-isc_result_t
+void
 isc_mutex_init_profile(isc_mutex_t *mp, const char *file, int line) {
 	int i, err;
 
@@ -123,8 +123,6 @@ isc_mutex_init_profile(isc_mutex_t *mp, const char *file, int line) {
 		timevalclear(&mp->stats->lockers[i].locked_total);
 		timevalclear(&mp->stats->lockers[i].wait_total);
 	}
-
-	return (ISC_R_SUCCESS);
 }
 
 isc_result_t
@@ -235,7 +233,7 @@ initialize_errcheck(void) {
 	errcheck_initialized = true;
 }
 
-isc_result_t
+void
 isc_mutex_init_errcheck(isc_mutex_t *mp) {
 	isc_result_t result;
 	int err;
@@ -244,9 +242,10 @@ isc_mutex_init_errcheck(isc_mutex_t *mp) {
 	RUNTIME_CHECK(result == ISC_R_SUCCESS);
 
 	err = pthread_mutex_init(mp, &errcheck);
-	if (err == ENOMEM)
-		return (ISC_R_NOMEMORY);
-	return ((err == 0) ? ISC_R_SUCCESS : ISC_R_UNEXPECTED);
+	if (err != 0) {
+		strerror_r(err, strbuf, sizeof(strbuf));
+		isc_error_fatal(file, line, "pthread_mutex_init failed: %s", strbuf);
+	}
 }
 #endif
 
@@ -275,13 +274,12 @@ initialize_attr(void) {
 }
 #endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
 
-isc_result_t
+void
 isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line) {
-	char strbuf[ISC_STRERRORSIZE];
-	isc_result_t result = ISC_R_SUCCESS;
 	int err;
 
 #ifdef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
+	isc_result_t result = ISC_R_SUCCESS;
 	result = isc_once_do(&once_attr, initialize_attr);
 	RUNTIME_CHECK(result == ISC_R_SUCCESS);
 
@@ -289,13 +287,10 @@ isc__mutex_init(isc_mutex_t *mp, const char *file, unsigned int line) {
 #else /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
 	err = pthread_mutex_init(mp, ISC__MUTEX_ATTRS);
 #endif /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP */
-
-	if (err == ENOMEM)
-		return (ISC_R_NOMEMORY);
 	if (err != 0) {
+		char strbuf[ISC_STRERRORSIZE];
 		strerror_r(err, strbuf, sizeof(strbuf));
 		isc_error_fatal(file, line, "pthread_mutex_init failed: %s", strbuf);
 	}
-	return (result);
 }
 #endif
diff --git a/lib/isc/quota.c b/lib/isc/quota.c
index 3ddff0d875..1f4c5fb51f 100644
--- a/lib/isc/quota.c
+++ b/lib/isc/quota.c
@@ -24,7 +24,9 @@ isc_quota_init(isc_quota_t *quota, int max) {
 	quota->max = max;
 	quota->used = 0;
 	quota->soft = 0;
-	return (isc_mutex_init(&quota->lock));
+	isc_mutex_init(&quota->lock);
+	/* XXXOND: Todo make return void */
+	return (ISC_R_SUCCESS);
 }
 
 void
diff --git a/lib/isc/ratelimiter.c b/lib/isc/ratelimiter.c
index 180d72fe14..e59301ca72 100644
--- a/lib/isc/ratelimiter.c
+++ b/lib/isc/ratelimiter.c
@@ -74,9 +74,7 @@ isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
 	rl->state = isc_ratelimiter_idle;
 	ISC_LIST_INIT(rl->pending);
 
-	result = isc_mutex_init(&rl->lock);
-	if (result != ISC_R_SUCCESS)
-		goto free_mem;
+	isc_mutex_init(&rl->lock);
 
 	result = isc_timer_create(timermgr, isc_timertype_inactive,
 				  NULL, NULL, rl->task, ratelimiter_tick,
@@ -100,7 +98,6 @@ isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
 
 free_mutex:
 	DESTROYLOCK(&rl->lock);
-free_mem:
 	isc_mem_put(mctx, rl, sizeof(*rl));
 	return (result);
 }
diff --git a/lib/isc/result.c b/lib/isc/result.c
index 4920a98be7..417533d18c 100644
--- a/lib/isc/result.c
+++ b/lib/isc/result.c
@@ -218,7 +218,7 @@ static void
 initialize_action(void) {
 	isc_result_t result;
 
-	RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 	ISC_LIST_INIT(description_tables);
 	ISC_LIST_INIT(identifier_tables);
 
diff --git a/lib/isc/rwlock.c b/lib/isc/rwlock.c
index d95950658e..c4e87ed986 100644
--- a/lib/isc/rwlock.c
+++ b/lib/isc/rwlock.c
@@ -94,8 +94,6 @@ isc_result_t
 isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
 		unsigned int write_quota)
 {
-	isc_result_t result;
-
 	REQUIRE(rwl != NULL);
 
 	/*
@@ -118,9 +116,7 @@ isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
 		write_quota = RWLOCK_DEFAULT_WRITE_QUOTA;
 	rwl->write_quota = write_quota;
 
-	result = isc_mutex_init(&rwl->lock);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mutex_init(&rwl->lock);
 
 	isc_condition_init(&rwl->readable);
 	isc_condition_init(&rwl->writeable);
diff --git a/lib/isc/stats.c b/lib/isc/stats.c
index 3a09aaa2ac..9fec283155 100644
--- a/lib/isc/stats.c
+++ b/lib/isc/stats.c
@@ -72,9 +72,7 @@ create_stats(isc_mem_t *mctx, int ncounters, isc_stats_t **statsp) {
 	if (stats == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&stats->lock);
-	if (result != ISC_R_SUCCESS)
-		goto clean_stats;
+	isc_mutex_init(&stats->lock);
 
 	stats->counters = isc_mem_get(mctx, sizeof(isc_stat_t) * ncounters);
 	if (stats->counters == NULL) {
@@ -104,8 +102,6 @@ clean_counters:
 
 clean_mutex:
 	DESTROYLOCK(&stats->lock);
-
-clean_stats:
 	isc_mem_put(mctx, stats, sizeof(*stats));
 
 	return (result);
diff --git a/lib/isc/task.c b/lib/isc/task.c
index 93cdac3bdd..5808054135 100644
--- a/lib/isc/task.c
+++ b/lib/isc/task.c
@@ -248,7 +248,6 @@ isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
 	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
 	isc__task_t *task;
 	bool exiting;
-	isc_result_t result;
 
 	REQUIRE(VALID_MANAGER(manager));
 	REQUIRE(taskp != NULL && *taskp == NULL);
@@ -261,11 +260,8 @@ isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
 	task->threadid = atomic_fetch_add_explicit(&manager->curq, 1,
 						   memory_order_relaxed)
 						   % manager->workers;
-	result = isc_mutex_init(&task->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(manager->mctx, task, sizeof(*task));
-		return (result);
-	}
+	isc_mutex_init(&task->lock);
+
 	task->state = task_state_idle;
 	task->references = 1;
 	INIT_LIST(task->events);
@@ -1336,10 +1332,10 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	manager->common.magic = ISCAPI_TASKMGR_MAGIC;
 	manager->mode = isc_taskmgrmode_normal;
 	manager->mctx = NULL;
-	RUNTIME_CHECK(isc_mutex_init(&manager->lock) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_mutex_init(&manager->excl_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&manager->lock);
+	isc_mutex_init(&manager->excl_lock);
 
-	RUNTIME_CHECK(isc_mutex_init(&manager->halt_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&manager->halt_lock);
 	isc_condition_init(&manager->halt_cond);
 
 	manager->workers = workers;
@@ -1370,8 +1366,7 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	for (i = 0; i < workers; i++) {
 		INIT_LIST(manager->queues[i].ready_tasks);
 		INIT_LIST(manager->queues[i].ready_priority_tasks);
-		RUNTIME_CHECK(isc_mutex_init(&manager->queues[i].lock)
-			      == ISC_R_SUCCESS);
+		isc_mutex_init(&manager->queues[i].lock);
 		isc_condition_init(&manager->queues[i].work_available);
 
 		manager->queues[i].manager = manager;
diff --git a/lib/isc/tests/task_test.c b/lib/isc/tests/task_test.c
index c9c1d51277..18c1717b9a 100644
--- a/lib/isc/tests/task_test.c
+++ b/lib/isc/tests/task_test.c
@@ -56,8 +56,7 @@ _setup(void **state) {
 
 	UNUSED(state);
 
-	result = isc_mutex_init(&lock);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	isc_condition_init(&cv);
 
@@ -73,8 +72,7 @@ _setup2(void **state) {
 
 	UNUSED(state);
 
-	result = isc_mutex_init(&lock);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	isc_condition_init(&cv);
 
@@ -91,8 +89,7 @@ _setup4(void **state) {
 
 	UNUSED(state);
 
-	result = isc_mutex_init(&lock);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&lock);
 
 	isc_condition_init(&cv);
 
diff --git a/lib/isc/tests/timer_test.c b/lib/isc/tests/timer_test.c
index 1ef15779e1..7df08db4f4 100644
--- a/lib/isc/tests/timer_test.c
+++ b/lib/isc/tests/timer_test.c
@@ -105,8 +105,7 @@ setup_test(isc_timertype_t timertype, isc_time_t *expires,
 	isc_time_settoepoch(&endtime);
 	eventcnt = 0;
 
-	result = isc_mutex_init(&mx);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&mx);
 
 	isc_condition_init(&cv);
 
@@ -502,8 +501,7 @@ purge(void **state) {
 	seconds = 1;
 	nanoseconds = 0;
 
-	result = isc_mutex_init(&mx);
-	assert_int_equal(result, ISC_R_SUCCESS);
+	isc_mutex_init(&mx);
 
 	isc_condition_init(&cv);
 
diff --git a/lib/isc/timer.c b/lib/isc/timer.c
index 96b3d4293a..540bf28ee8 100644
--- a/lib/isc/timer.c
+++ b/lib/isc/timer.c
@@ -321,12 +321,7 @@ isc_timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
 	 */
 	DE_CONST(arg, timer->arg);
 	timer->index = 0;
-	result = isc_mutex_init(&timer->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_task_detach(&timer->task);
-		isc_mem_put(manager->mctx, timer, sizeof(*timer));
-		return (result);
-	}
+	isc_mutex_init(&timer->lock);
 	ISC_LINK_INIT(timer, link);
 	timer->common.impmagic = TIMER_MAGIC;
 	timer->common.magic = ISCAPI_TIMER_MAGIC;
@@ -743,12 +738,7 @@ isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 		isc_mem_put(mctx, manager, sizeof(*manager));
 		return (ISC_R_NOMEMORY);
 	}
-	result = isc_mutex_init(&manager->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_heap_destroy(&manager->heap);
-		isc_mem_put(mctx, manager, sizeof(*manager));
-		return (result);
-	}
+	isc_mutex_init(&manager->lock);
 	isc_mem_attach(mctx, &manager->mctx);
 	isc_condition_init(&manager->wakeup);
 	if (isc_thread_create(run, manager, &manager->thread) !=
diff --git a/lib/isc/unix/app.c b/lib/isc/unix/app.c
index 8027f592bf..983ce9f251 100644
--- a/lib/isc/unix/app.c
+++ b/lib/isc/unix/app.c
@@ -138,15 +138,11 @@ isc_app_ctxstart(isc_appctx_t *ctx0) {
 	 * Start an ISC library application.
 	 */
 
-	result = isc_mutex_init(&ctx->readylock);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mutex_init(&ctx->readylock);
 
 	isc_condition_init(&ctx->ready);
 
-	result = isc_mutex_init(&ctx->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&ctx->lock);
 
 	ISC_LIST_INIT(ctx->on_run);
 
diff --git a/lib/isc/unix/socket.c b/lib/isc/unix/socket.c
index 9b29cde324..f667d497b8 100644
--- a/lib/isc/unix/socket.c
+++ b/lib/isc/unix/socket.c
@@ -1935,7 +1935,7 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
 	/*
 	 * Initialize the lock.
 	 */
-	RUNTIME_CHECK(isc_mutex_init(&sock->lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&sock->lock);
 
 	sock->common.magic = ISCAPI_SOCKET_MAGIC;
 	sock->common.impmagic = SOCKET_MAGIC;
@@ -3682,10 +3682,7 @@ setup_thread(isc__socketthread_t *thread) {
 				     FDLOCK_COUNT * sizeof(isc_mutex_t));
 
 	for (i = 0; i < FDLOCK_COUNT; i++) {
-		result = isc_mutex_init(&thread->fdlock[i]);
-		if (result != ISC_R_SUCCESS) {
-			return (result);
-		}
+		isc_mutex_init(&thread->fdlock[i]);
 	}
 
 	if (pipe(thread->pipe_fds) != 0) {
@@ -3932,8 +3929,7 @@ isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 	manager->common.impmagic = SOCKET_MANAGER_MAGIC;
 	manager->mctx = NULL;
 	ISC_LIST_INIT(manager->socklist);
-	RUNTIME_CHECK(isc_mutex_init(&manager->lock) == ISC_R_SUCCESS);
-
+	isc_mutex_init(&manager->lock);
 	isc_condition_init(&manager->shutdown_ok);
 
 	/*
diff --git a/lib/isc/win32/app.c b/lib/isc/win32/app.c
index ae4c015413..e3d4c7b37d 100644
--- a/lib/isc/win32/app.c
+++ b/lib/isc/win32/app.c
@@ -99,9 +99,7 @@ isc_app_ctxstart(isc_appctx_t *ctx0) {
 
 	main_thread = GetCurrentThread();
 
-	result = isc_mutex_init(&ctx->lock);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mutex_init(&ctx->lock);
 
 	ctx->shutdown_requested = false;
 	ctx->running = false;
diff --git a/lib/isc/win32/include/isc/mutex.h b/lib/isc/win32/include/isc/mutex.h
index 6815741b89..1d49430cd1 100644
--- a/lib/isc/win32/include/isc/mutex.h
+++ b/lib/isc/win32/include/isc/mutex.h
@@ -30,7 +30,7 @@ TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
 #endif /* _WIN32_WINNT < 0x0400 */
 
 #define isc_mutex_init(mp) \
-	(InitializeCriticalSection((mp)), ISC_R_SUCCESS)
+	InitializeCriticalSection((mp))
 #define isc_mutex_lock(mp) \
 	(EnterCriticalSection((mp)), ISC_R_SUCCESS)
 #define isc_mutex_unlock(mp) \
diff --git a/lib/isc/win32/socket.c b/lib/isc/win32/socket.c
index 4bd9b87b67..761a1d2abf 100644
--- a/lib/isc/win32/socket.c
+++ b/lib/isc/win32/socket.c
@@ -1385,9 +1385,7 @@ allocate_socket(isc_socketmgr_t *manager, isc_sockettype_t type,
 	/*
 	 * Initialize the lock.
 	 */
-	result = isc_mutex_init(&sock->lock);
-	if (result != ISC_R_SUCCESS)
-		goto error;
+	isc_mutex_init(&sock->lock);
 
 	socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
 		   "allocated");
@@ -2556,11 +2554,7 @@ isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 	manager->mctx = NULL;
 	manager->stats = NULL;
 	ISC_LIST_INIT(manager->socklist);
-	result = isc_mutex_init(&manager->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, manager, sizeof(*manager));
-		return (result);
-	}
+	isc_mutex_init(&manager->lock);
 	isc_condition_init(&manager->shutdown_ok);
 
 	isc_mem_attach(mctx, &manager->mctx);
diff --git a/lib/ns/client.c b/lib/ns/client.c
index 60929a8dba..83d6342737 100644
--- a/lib/ns/client.c
+++ b/lib/ns/client.c
@@ -3421,17 +3421,9 @@ ns_clientmgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_taskmgr_t *taskmgr,
 	if (manager == NULL)
 		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&manager->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_manager;
-
-	result = isc_mutex_init(&manager->listlock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_lock;
-
-	result = isc_mutex_init(&manager->reclock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_listlock;
+	isc_mutex_init(&manager->lock);
+	isc_mutex_init(&manager->listlock);
+	isc_mutex_init(&manager->reclock);
 
 	manager->excl = NULL;
 	result = isc_taskmgr_excltask(taskmgr, &manager->excl);
@@ -3465,14 +3457,9 @@ ns_clientmgr_create(isc_mem_t *mctx, ns_server_t *sctx, isc_taskmgr_t *taskmgr,
 
  cleanup_reclock:
 	(void) isc_mutex_destroy(&manager->reclock);
-
- cleanup_listlock:
 	(void) isc_mutex_destroy(&manager->listlock);
-
- cleanup_lock:
 	(void) isc_mutex_destroy(&manager->lock);
 
- cleanup_manager:
 	isc_mem_put(manager->mctx, manager, sizeof(*manager));
 
 	return (result);
diff --git a/lib/ns/interfacemgr.c b/lib/ns/interfacemgr.c
index adba622d09..ae539c245d 100644
--- a/lib/ns/interfacemgr.c
+++ b/lib/ns/interfacemgr.c
@@ -201,9 +201,7 @@ ns_interfacemgr_create(isc_mem_t *mctx,
 	mgr->sctx = NULL;
 	ns_server_attach(sctx, &mgr->sctx);
 
-	result = isc_mutex_init(&mgr->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_ctx;
+	isc_mutex_init(&mgr->lock);
 
 	mgr->excl = NULL;
 	result = isc_taskmgr_excltask(taskmgr, &mgr->excl);
@@ -404,9 +402,7 @@ ns_interface_create(ns_interfacemgr_t *mgr, isc_sockaddr_t *addr,
 	strlcpy(ifp->name, name, sizeof(ifp->name));
 	ifp->clientmgr = NULL;
 
-	result = isc_mutex_init(&ifp->lock);
-	if (result != ISC_R_SUCCESS)
-		goto lock_create_failure;
+	isc_mutex_init(&ifp->lock);
 
 	result = ns_clientmgr_create(mgr->mctx, mgr->sctx,
 				     mgr->taskmgr, mgr->timermgr,
@@ -449,7 +445,6 @@ ns_interface_create(ns_interfacemgr_t *mgr, isc_sockaddr_t *addr,
  clientmgr_create_failure:
 	DESTROYLOCK(&ifp->lock);
 
- lock_create_failure:
 	ifp->magic = 0;
 	isc_mem_put(mgr->mctx, ifp, sizeof(*ifp));
 
diff --git a/lib/ns/lib.c b/lib/ns/lib.c
index 7aebe53f11..6c41521de6 100644
--- a/lib/ns/lib.c
+++ b/lib/ns/lib.c
@@ -54,16 +54,10 @@ initialize(void) {
 	if (result != ISC_R_SUCCESS)
 		return;
 
-	result = isc_mutex_init(&reflock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mctx;
+	isc_mutex_init(&reflock);
 
 	initialize_done = true;
 	return;
-
-  cleanup_mctx:
-	if (ns_g_mctx != NULL)
-		isc_mem_detach(&ns_g_mctx);
 }
 
 isc_result_t
diff --git a/lib/ns/query.c b/lib/ns/query.c
index 35ffc095cc..b649254caa 100644
--- a/lib/ns/query.c
+++ b/lib/ns/query.c
@@ -923,9 +923,8 @@ ns_query_init(ns_client_t *client) {
 	 * This mutex is destroyed when the client is destroyed in
 	 * exit_check().
 	 */
-	result = isc_mutex_init(&client->query.fetchlock);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mutex_init(&client->query.fetchlock);
+
 	client->query.fetch = NULL;
 	client->query.prefetch = NULL;
 	client->query.authdb = NULL;
diff --git a/lib/ns/stats.c b/lib/ns/stats.c
index d1fa7fe53a..0555fc3202 100644
--- a/lib/ns/stats.c
+++ b/lib/ns/stats.c
@@ -80,9 +80,7 @@ ns_stats_create(isc_mem_t *mctx, int ncounters, ns_stats_t **statsp) {
 	stats->counters = NULL;
 	stats->references = 1;
 
-	result = isc_mutex_init(&stats->lock);
-	if (result != ISC_R_SUCCESS)
-		goto clean_stats;
+	isc_mutex_init(&stats->lock);
 
 	result = isc_stats_create(mctx, &stats->counters, ncounters);
 	if (result != ISC_R_SUCCESS)
@@ -97,7 +95,6 @@ ns_stats_create(isc_mem_t *mctx, int ncounters, ns_stats_t **statsp) {
 
   clean_mutex:
 	DESTROYLOCK(&stats->lock);
-  clean_stats:
 	isc_mem_put(mctx, stats, sizeof(*stats));
 
 	return (result);