Rewrite isc_refcount API after stdatomics and use release-acquire memory barriers

Add compatibility stdatomic.h header for Windows
Only require stdatomic.h when compiled with threading support
2018-05-24 18:22:56 +02:00 · 2018-05-24 16:36:07 +02:00 · 2018-05-24 10:37:46 +02:00 · 2018-05-24 10:37:46 +02:00 · 2018-05-24 10:37:46 +02:00 · 2018-05-24 10:37:45 +02:00
75 changed files with 1140 additions and 5056 deletions
@@ -8984,7 +8984,7 @@ view_loaded(void *arg) {
 	ns_zoneload_t *zl = (ns_zoneload_t *) arg;
 	named_server_t *server = zl->server;
 	isc_boolean_t reconfig = zl->reconfig;
-	unsigned int refs;
+	int_fast32_t refs;


 	/*
@@ -8995,8 +8995,8 @@ view_loaded(void *arg) {
 	 * We use the zoneload reference counter to let us
 	 * know when all views are finished.
 	 */
-	isc_refcount_decrement(&zl->refs, &refs);
-	if (refs != 0)
+	refs = isc_refcount_decrement(&zl->refs);
+	if (refs > 1)
 		return (ISC_R_SUCCESS);

 	isc_refcount_destroy(&zl->refs);
@@ -9032,7 +9032,7 @@ load_zones(named_server_t *server, isc_boolean_t init, isc_boolean_t reconfig) {
 	isc_result_t result;
 	dns_view_t *view;
 	ns_zoneload_t *zl;
-	unsigned int refs = 0;
+	int_fast32_t refs;

 	zl = isc_mem_get(server->mctx, sizeof (*zl));
 	if (zl == NULL)
@@ -9071,13 +9071,13 @@ load_zones(named_server_t *server, isc_boolean_t init, isc_boolean_t reconfig) {
 		 * 'dns_view_asyncload' calls view_loaded if there are no
 		 * zones.
 		 */
-		isc_refcount_increment(&zl->refs, NULL);
+		isc_refcount_increment(&zl->refs);
 		CHECK(dns_view_asyncload(view, view_loaded, zl));
 	}

 cleanup:
-	isc_refcount_decrement(&zl->refs, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&zl->refs);
+	if (refs == 1) {
 		isc_refcount_destroy(&zl->refs);
 		isc_mem_put(server->mctx, zl, sizeof (*zl));
 	} else if (init) {
@@ -69,7 +69,7 @@ attach(dns_db_t *source, dns_db_t **targetp) {

 	REQUIRE(VALID_SAMPLEDB(sampledb));

-	isc_refcount_increment(&sampledb->refs, NULL);
+	isc_refcount_increment(&sampledb->refs);
 	*targetp = source;
 }

@@ -85,13 +85,14 @@ free_sampledb(sampledb_t *sampledb) {
 static void
 detach(dns_db_t **dbp) {
 	sampledb_t *sampledb = (sampledb_t *)(*dbp);
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(VALID_SAMPLEDB(sampledb));

-	isc_refcount_decrement(&sampledb->refs, &refs);
-	if (refs == 0)
+	refs = isc_refcount_decrement(&sampledb->refs);
+	if (refs == 1) {
 		free_sampledb(sampledb);
+	}
 	*dbp = NULL;
 }

@@ -595,9 +595,6 @@ int sigwait(const unsigned int *set, int *sig);
 /* Define if GOST private keys are encoded in ASN.1. */
 #undef PREFER_GOSTASN1

-/* The size of `void *', as computed by sizeof. */
-#undef SIZEOF_VOID_P
-
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS

@@ -22,6 +22,10 @@ AC_CANONICAL_HOST

 AC_PROG_MAKE_SET

+# Set compiler compatibility flags
+AC_PROG_CC_C99
+AC_PROG_CPP_WERROR
+
 #
 # GNU libtool support
 #
@@ -414,8 +418,6 @@ if test "X$CC" = "X" ; then
 	esac
 fi

-AC_PROG_CC
-
 #
 # gcc's optimiser is broken at -02 for ultrasparc
 #
@@ -3886,237 +3888,26 @@ AC_CHECK_FUNCS(nanosleep usleep explicit_bzero)
 #
 # Machine architecture dependent features
 #
-have_stdatomic=no
-AC_MSG_CHECKING(for usable stdatomic.h)
-AC_TRY_COMPILE([
-#include <stdio.h>
-#include <stdatomic.h>
-],
-[
-atomic_int_fast32_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);
-],
-        [AC_MSG_RESULT(yes)
-	 have_stdatomic=yes
-	 ISC_PLATFORM_HAVESTDATOMIC="#define ISC_PLATFORM_HAVESTDATOMIC 1"],
-	[AC_MSG_RESULT(no)
-	 have_stdatomic=no
-	 ISC_PLATFORM_HAVESTDATOMIC="#undef ISC_PLATFORM_HAVESTDATOMIC"])

-AC_ARG_ENABLE(atomic,
-	      AS_HELP_STRING([--enable-atomic],
-			     [enable machine specific atomic operations [default=autodetect]]),
-			enable_atomic="$enableval",
-			enable_atomic="autodetect")
-case "$enable_atomic" in
-	yes|''|autodetect)
-		case "$host" in
-		powerpc-ibm-aix*)
-			if test "X$GCC" = "Xyes"; then
-				AC_MSG_CHECKING([if asm("ics"); works])
-				AC_TRY_COMPILE(,[
-				main() { asm("ics"); exit(0); }
-				],
-				[AC_MSG_RESULT(yes)
-				 use_atomic=yes],
-				[
-				saved_cflags="$CFLAGS"
-				CFLAGS="$CFLAGS -Wa,-many"
-				AC_TRY_RUN([
-				main() { asm("ics"); exit(0); }
-				],
-				[AC_MSG_RESULT([yes, required -Wa,-many])
-				 use_atomic=yes],
-				[AC_MSG_RESULT([no, use_atomic disabled])
-				 CFLAGS="$saved_cflags"
-				 use_atomic=no],
-				[AC_MSG_RESULT([cross compile, assume yes])
-				 CFLAGS="$saved_cflags"
-				 use_atomic=yes])
-				]
-				)
-			else
-				use_atomic=yes
-			fi
-			;;
-		*)
-			use_atomic=yes
-			;;
-		esac
-		;;
-	no)
-		have_stdatomic=no
-		ISC_PLATFORM_HAVESTDATOMIC="#undef ISC_PLATFORM_HAVESTDATOMIC"
-		use_atomic=no
-		arch=noatomic
-		;;
-esac
+ISC_ATOMIC_LIBS=
+if test "$use_threads" = "yes"; then
+	AC_MSG_CHECKING(for usable stdatomic.h)
+	AC_TRY_COMPILE([#include <stdatomic.h>],
+		       [atomic_int_fast32_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);],
+        [AC_MSG_RESULT(yes)],
+	[AC_MSG_ERROR([a compiler with atomics support is required])])

-if test "X$have_stdatomic" = "Xyes"; then
-    AC_MSG_CHECKING(if -latomic is needed to use 64-bit stdatomic.h primitives)
-    AC_LINK_IFELSE(
-	[AC_LANG_PROGRAM([#include <stdatomic.h>],
-			 [atomic_int_fast64_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);])],
-	[AC_MSG_RESULT(no)
-	 ISC_ATOMIC_LIBS=""],
-	[AC_MSG_RESULT(yes)
-	 ISC_ATOMIC_LIBS="-latomic"]
-    )
-    LIBS="$LIBS $ISC_ATOMIC_LIBS"
-fi
-
-AC_SUBST(ISC_PLATFORM_HAVESTDATOMIC)
-
-ISC_PLATFORM_USEOSFASM="#undef ISC_PLATFORM_USEOSFASM"
-ISC_PLATFORM_USEGCCASM="#undef ISC_PLATFORM_USEGCCASM"
-ISC_PLATFORM_USESTDASM="#undef ISC_PLATFORM_USESTDASM"
-ISC_PLATFORM_USEMACASM="#undef ISC_PLATFORM_USEMACASM"
-if test "yes" = "$use_atomic"; then
-	AC_CHECK_SIZEOF([void *])
-	have_atomic=yes		# set default
-	case "$host" in
-	[i[3456]86-*])
-		# XXX: some old x86 architectures actually do not support
-		#      (some of) these operations.  Do we need stricter checks?
-		if test $ac_cv_sizeof_void_p = 8; then
-			arch=x86_64
-			have_xaddq=yes
-		else
-			arch=x86_32
-		fi
-	;;
-	x86_64-*|amd64-*)
-		if test $ac_cv_sizeof_void_p = 8; then
-			arch=x86_64
-			have_xaddq=yes
-		else
-			arch=x86_32
-		fi
-	;;
-	alpha*-*)
-		arch=alpha
-	;;
-	powerpc-*|powerpc64-*)
-		arch=powerpc
-	;;
-	mips-*|mipsel-*|mips64-*|mips64el-*)
-		arch=mips
-	;;
-	ia64-*)
-		arch=ia64
-	;;
-	*)
-		have_atomic=no
-		arch=noatomic
-	;;
-	esac
-	AC_MSG_CHECKING([architecture type for atomic operations])
-	AC_MSG_RESULT($arch)
-fi
-
-if test "yes" = "$have_atomic"; then
-	AC_MSG_CHECKING([compiler support for inline assembly code])
-
-	compiler=generic
-	# Check whether the compiler supports the assembly syntax we provide.
-	if test "X$GCC" = "Xyes"; then
-		# GCC's ASM extension always works
-		compiler=gcc
-		if test $arch = "x86_64"; then
-			# We can share the same code for gcc with x86_32
-			arch=x86_32
-		fi
-		if test $arch = "powerpc"; then
-			#
-			# The MacOS (and maybe others) uses "r0" for register
-			# zero. Under linux/ibm it is "0" for register 0.
-			# Probe to see if we have a MacOS style assembler.
-			#
-			AC_MSG_CHECKING([Checking for MacOS style assembler syntax])
-			AC_TRY_COMPILE(, [
-			__asm__ volatile ("li r0, 0x0\n"::);
-			], [
-			AC_MSG_RESULT(yes)
-			compiler="mac"
-			ISC_PLATFORM_USEMACASM="#define ISC_PLATFORM_USEMACASM 1"
-			], [AC_MSG_RESULT(no)])
-		fi
-	else
-		case "$host" in
-		alpha*-dec-osf*)
-			# Tru64 compiler has its own syntax for inline 
-			# assembly.
-			AC_TRY_COMPILE(, [
-#ifndef __DECC
-#error "unexpected compiler"
-#endif
-				return (0);],
-				[compiler=osf],)
-		;;
-		powerpc-ibm-aix*)
-			compiler=aix
-		;;
-		esac
-	fi
-	case "$compiler" in
-	gcc)
-		ISC_PLATFORM_USEGCCASM="#define ISC_PLATFORM_USEGCCASM 1"
-		;;
-	osf)
-		ISC_PLATFORM_USEOSFASM="#define ISC_PLATFORM_USEOSFASM 1"
-		;;
-	aix)
-		;;
-	mac)
-		;;
-	*)
-		# See if the generic __asm function works.  If not,
-		# we need to disable the atomic operations.
-		AC_TRY_LINK(, [
-					__asm("nop")
-				],
-		[compiler="standard"
-		ISC_PLATFORM_USESTDASM="#define ISC_PLATFORM_USESTDASM 1"],
-		[compiler="not supported (atomic operations disabled)"
-		have_atomic=no
-		arch=noatomic ]);
-		;;
-	esac
-
-	AC_MSG_RESULT($compiler)
-fi
-
-if test "yes" = "$have_atomic"; then
-	ISC_PLATFORM_HAVEXADD="#define ISC_PLATFORM_HAVEXADD 1"
-	ISC_PLATFORM_HAVECMPXCHG="#define ISC_PLATFORM_HAVECMPXCHG 1"
-	ISC_PLATFORM_HAVEATOMICSTORE="#define ISC_PLATFORM_HAVEATOMICSTORE 1"
-	if test "yes" = "$have_xaddq"; then
-		ISC_PLATFORM_HAVEXADDQ="#define ISC_PLATFORM_HAVEXADDQ 1"
-		ISC_PLATFORM_HAVEATOMICSTOREQ="#define ISC_PLATFORM_HAVEATOMICSTOREQ 1"
-	else
-		ISC_PLATFORM_HAVEXADDQ="#undef ISC_PLATFORM_HAVEXADDQ"
-		ISC_PLATFORM_HAVEATOMICSTOREQ="#undef ISC_PLATFORM_HAVEATOMICSTOREQ"
-	fi
-else
-	ISC_PLATFORM_HAVEXADD="#undef ISC_PLATFORM_HAVEXADD"
-	ISC_PLATFORM_HAVECMPXCHG="#undef ISC_PLATFORM_HAVECMPXCHG"
-	ISC_PLATFORM_HAVEATOMICSTORE="#undef ISC_PLATFORM_HAVEATOMICSTORE"
-	ISC_PLATFORM_HAVEXADDQ="#undef ISC_PLATFORM_HAVEXADDQ"
-	ISC_PLATFORM_HAVEATOMICSTOREQ="#undef ISC_PLATFORM_HAVEATOMICSTOREQ"
-fi
-
-AC_SUBST(ISC_PLATFORM_HAVEXADD)
-AC_SUBST(ISC_PLATFORM_HAVEXADDQ)
-AC_SUBST(ISC_PLATFORM_HAVECMPXCHG)
-AC_SUBST(ISC_PLATFORM_HAVEATOMICSTORE)
-AC_SUBST(ISC_PLATFORM_HAVEATOMICSTOREQ)
-
-AC_SUBST(ISC_PLATFORM_USEGCCASM)
-AC_SUBST(ISC_PLATFORM_USEOSFASM)
-AC_SUBST(ISC_PLATFORM_USESTDASM)
-AC_SUBST(ISC_PLATFORM_USEMACASM)
-
-ISC_ARCH_DIR=$arch
-AC_SUBST(ISC_ARCH_DIR)
+	AC_MSG_CHECKING(if -latomic is needed to use 64-bit stdatomic.h primitives)
+	AC_LINK_IFELSE(
+		[AC_LANG_PROGRAM([#include <stdatomic.h>],
+				 [atomic_int_fast64_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);])],
+		[AC_MSG_RESULT(no)
+		 ISC_ATOMIC_LIBS=""],
+		[AC_MSG_RESULT(yes)
+		 ISC_ATOMIC_LIBS="-latomic"]
+	)
+fi # use_threads
+AC_SUBST([ISC_ATOMIC_LIBS])

 #
 # Check for __builtin_expect
@@ -503,7 +503,7 @@ void
 dns_acl_attach(dns_acl_t *source, dns_acl_t **target) {
 	REQUIRE(DNS_ACL_VALID(source));

-	isc_refcount_increment(&source->refcount, NULL);
+	isc_refcount_increment(&source->refcount);
 	*target = source;
 }

@@ -536,13 +536,14 @@ destroy(dns_acl_t *dacl) {
 void
 dns_acl_detach(dns_acl_t **aclp) {
 	dns_acl_t *acl = *aclp;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(DNS_ACL_VALID(acl));

-	isc_refcount_decrement(&acl->refcount, &refs);
-	if (refs == 0)
+	refs = isc_refcount_decrement(&acl->refcount);
+	if (refs == 1) {
 		destroy(acl);
+	}
 	*aclp = NULL;
 }

@@ -230,7 +230,7 @@ dns_catz_entry_copy(dns_catz_zone_t *zone, const dns_catz_entry_t *entry,
 void
 dns_catz_entry_attach(dns_catz_entry_t *entry, dns_catz_entry_t **entryp) {
 	REQUIRE(entryp != NULL && *entryp == NULL);
-	isc_refcount_increment(&entry->refs, NULL);
+	isc_refcount_increment(&entry->refs);
 	*entryp = entry;
 }

@@ -238,7 +238,7 @@ void
 dns_catz_entry_detach(dns_catz_zone_t *zone, dns_catz_entry_t **entryp) {
 	dns_catz_entry_t *entry;
 	isc_mem_t *mctx;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(entryp != NULL && *entryp != NULL);

@@ -247,8 +247,8 @@ dns_catz_entry_detach(dns_catz_zone_t *zone, dns_catz_entry_t **entryp) {

 	mctx = zone->catzs->mctx;

-	isc_refcount_decrement(&entry->refs, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&entry->refs);
+	if (refs == 1) {
 		dns_catz_options_free(&entry->opts, mctx);
 		if (dns_name_dynamic(&entry->name))
 			dns_name_free(&entry->name, mctx);
@@ -728,7 +728,7 @@ void
 dns_catz_catzs_attach(dns_catz_zones_t *catzs, dns_catz_zones_t **catzsp) {
 	REQUIRE(catzsp != NULL && *catzsp == NULL);

-	isc_refcount_increment(&catzs->refs, NULL);
+	isc_refcount_increment(&catzs->refs);
 	*catzsp = catzs;
 }

@@ -736,7 +736,7 @@ void
 dns_catz_zone_attach(dns_catz_zone_t *zone, dns_catz_zone_t **zonep) {
 	REQUIRE(zonep != NULL && *zonep == NULL);

-	isc_refcount_increment(&zone->refs, NULL);
+	isc_refcount_increment(&zone->refs);
 	*zonep = zone;
 }

@@ -746,14 +746,14 @@ dns_catz_zone_detach(dns_catz_zone_t **zonep) {
 	dns_catz_zone_t *zone;
 	isc_ht_iter_t *iter = NULL;
 	isc_mem_t *mctx;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(zonep != NULL && *zonep != NULL);

 	zone = *zonep;
 	*zonep = NULL;
-	isc_refcount_decrement(&zone->refs, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&zone->refs);
+	if (refs == 1) {
 		if (zone->entries != NULL) {
 			result = isc_ht_iter_create(zone->entries, &iter);
 			INSIST(result == ISC_R_SUCCESS);
@@ -802,7 +802,7 @@ dns_catz_catzs_detach(dns_catz_zones_t ** catzsp) {
 	dns_catz_zones_t *catzs;
 	isc_ht_iter_t *iter = NULL;
 	isc_result_t result;
-	unsigned int refs;
+	int_fast32_t refs;
 	dns_catz_zone_t *zone;


@@ -811,9 +811,9 @@ dns_catz_catzs_detach(dns_catz_zones_t ** catzsp) {
 	REQUIRE(catzs != NULL);

 	*catzsp = NULL;
-	isc_refcount_decrement(&catzs->refs, &refs);
+	refs = isc_refcount_decrement(&catzs->refs);

-	if (refs == 0) {
+	if (refs == 1) {
 		DESTROYLOCK(&catzs->lock);
 		if (catzs->zones != NULL) {
 			result = isc_ht_iter_create(catzs->zones, &iter);
@@ -529,7 +529,7 @@ dns_dt_attach(dns_dtenv_t *source, dns_dtenv_t **destp) {
 	REQUIRE(VALID_DTENV(source));
 	REQUIRE(destp != NULL && *destp == NULL);

-	isc_refcount_increment(&source->refcount, NULL);
+	isc_refcount_increment(&source->refcount);
 	*destp = source;
 }

@@ -1163,7 +1163,7 @@ dst_key_attach(dst_key_t *source, dst_key_t **target) {
 	REQUIRE(target != NULL && *target == NULL);
 	REQUIRE(VALID_KEY(source));

-	isc_refcount_increment(&source->refs, NULL);
+	isc_refcount_increment(&source->refs);
 	*target = source;
 }

@@ -1171,7 +1171,7 @@ void
 dst_key_free(dst_key_t **keyp) {
 	isc_mem_t *mctx;
 	dst_key_t *key;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(dst_initialized == ISC_TRUE);
 	REQUIRE(keyp != NULL && VALID_KEY(*keyp));
@@ -1179,9 +1179,10 @@ dst_key_free(dst_key_t **keyp) {
 	key = *keyp;
 	mctx = key->mctx;

-	isc_refcount_decrement(&key->refs, &refs);
-	if (refs != 0)
+	refs = isc_refcount_decrement(&key->refs);
+	if (refs > 1) {
 		return;
+	}

 	isc_refcount_destroy(&key->refs);
 	if (key->keydata.generic != NULL) {
@@ -38,12 +38,6 @@ ISC_LANG_BEGINDECLS
 #define DNS_RBTFIND_NOPREDECESSOR               0x04
 /*@}*/

-#ifndef DNS_RBT_USEISCREFCOUNT
-#ifdef ISC_REFCOUNT_HAVEATOMIC
-#define DNS_RBT_USEISCREFCOUNT 1
-#endif
-#endif
-
 #define DNS_RBT_USEMAGIC 1

 /*
@@ -160,13 +154,8 @@ struct dns_rbtnode {
 	unsigned int dirty:1;
 	unsigned int wild:1;
 	unsigned int locknum:DNS_RBT_LOCKLENGTH;
-#ifndef DNS_RBT_USEISCREFCOUNT
-	unsigned int references:DNS_RBT_REFLENGTH;
-#endif
 	unsigned int :0;                /* end of bitfields c/o node lock */
-#ifdef DNS_RBT_USEISCREFCOUNT
 	isc_refcount_t references; /* note that this is not in the bitfield */
-#endif
 	/*@}*/
 };

@@ -1055,81 +1044,18 @@ dns_rbtnodechain_nextflat(dns_rbtnodechain_t *chain, dns_name_t *name);
 *   The following macros provide a common interface to these operations,
 *   hiding the back-end.  The usage is the same as that of isc_refcount_xxx().
 */
-#ifdef DNS_RBT_USEISCREFCOUNT
-#define dns_rbtnode_refinit(node, n)                            \
-	do {                                                    \
-		isc_refcount_init(&(node)->references, (n));    \
-	} while (0)
-#define dns_rbtnode_refdestroy(node)                            \
-	do {                                                    \
-		isc_refcount_destroy(&(node)->references);      \
-	} while (0)
-#define dns_rbtnode_refcurrent(node)                            \
+#define dns_rbtnode_refinit(node, n)			\
+	isc_refcount_init(&(node)->references, (n))
+#define dns_rbtnode_refdestroy(node)			\
+	isc_refcount_destroy(&(node)->references)
+#define dns_rbtnode_refcurrent(node)			\
 	isc_refcount_current(&(node)->references)
-#define dns_rbtnode_refincrement0(node, refs)                   \
-	do {                                                    \
-		isc_refcount_increment0(&(node)->references, (refs)); \
-	} while (0)
-#define dns_rbtnode_refincrement(node, refs)                    \
-	do {                                                    \
-		isc_refcount_increment(&(node)->references, (refs)); \
-	} while (0)
-#define dns_rbtnode_refdecrement(node, refs)                    \
-	do {                                                    \
-		isc_refcount_decrement(&(node)->references, (refs)); \
-	} while (0)
-#else  /* DNS_RBT_USEISCREFCOUNT */
-#define dns_rbtnode_refinit(node, n)    ((node)->references = (n))
-#define dns_rbtnode_refdestroy(node)    ISC_REQUIRE((node)->references == 0)
-#define dns_rbtnode_refcurrent(node)    ((node)->references)
-
-#if (__STDC_VERSION__ + 0) >= 199901L || defined __GNUC__
-static inline void
-dns_rbtnode_refincrement0(dns_rbtnode_t *node, unsigned int *refs) {
-	node->references++;
-	if (refs != NULL)
-		*refs = node->references;
-}
-
-static inline void
-dns_rbtnode_refincrement(dns_rbtnode_t *node, unsigned int *refs) {
-	ISC_REQUIRE(node->references > 0);
-	node->references++;
-	if (refs != NULL)
-		*refs = node->references;
-}
-
-static inline void
-dns_rbtnode_refdecrement(dns_rbtnode_t *node, unsigned int *refs) {
-	ISC_REQUIRE(node->references > 0);
-	node->references--;
-	if (refs != NULL)
-		*refs = node->references;
-}
-#else
-#define dns_rbtnode_refincrement0(node, refs)                   \
-	do {                                                    \
-		unsigned int *_tmp = (unsigned int *)(refs);    \
-		(node)->references++;                           \
-		if ((_tmp) != NULL)                             \
-			(*_tmp) = (node)->references;           \
-	} while (0)
-#define dns_rbtnode_refincrement(node, refs)                    \
-	do {                                                    \
-		ISC_REQUIRE((node)->references > 0);                \
-		(node)->references++;                           \
-		if ((refs) != NULL)                             \
-			(*refs) = (node)->references;           \
-	} while (0)
-#define dns_rbtnode_refdecrement(node, refs)                    \
-	do {                                                    \
-		ISC_REQUIRE((node)->references > 0);                \
-		(node)->references--;                           \
-		if ((refs) != NULL)                             \
-			(*refs) = (node)->references;           \
-	} while (0)
-#endif
-#endif /* DNS_RBT_USEISCREFCOUNT */
+#define dns_rbtnode_refincrement0(node)			\
+	isc_refcount_increment0(&(node)->references)
+#define dns_rbtnode_refincrement(node)			\
+	isc_refcount_increment(&(node)->references)
+#define dns_rbtnode_refdecrement(node)			\
+	isc_refcount_decrement(&(node)->references)

 void
 dns_rbtnode_nodename(dns_rbtnode_t *node, dns_name_t *name);
@@ -140,18 +140,19 @@ dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, isc_boolean_t pos)
 void
 dns_iptable_attach(dns_iptable_t *source, dns_iptable_t **target) {
 	REQUIRE(DNS_IPTABLE_VALID(source));
-	isc_refcount_increment(&source->refcount, NULL);
+	isc_refcount_increment(&source->refcount);
 	*target = source;
 }

 void
 dns_iptable_detach(dns_iptable_t **tabp) {
 	dns_iptable_t *tab = *tabp;
-	unsigned int refs;
+	int_fast32_t refs;
 	REQUIRE(DNS_IPTABLE_VALID(tab));
-	isc_refcount_decrement(&tab->refcount, &refs);
-	if (refs == 0)
+	refs = isc_refcount_decrement(&tab->refcount);
+	if (refs == 1) {
 		destroy_iptable(tab);
+	}
 	*tabp = NULL;
 }

@@ -129,7 +129,7 @@ dns_keytable_attach(dns_keytable_t *source, dns_keytable_t **targetp) {
 	REQUIRE(VALID_KEYTABLE(source));
 	REQUIRE(targetp != NULL && *targetp == NULL);

-	isc_refcount_increment(&source->references, NULL);
+	isc_refcount_increment(&source->references);

 	*targetp = source;
 }
@@ -137,7 +137,7 @@ dns_keytable_attach(dns_keytable_t *source, dns_keytable_t **targetp) {
 void
 dns_keytable_detach(dns_keytable_t **keytablep) {
 	dns_keytable_t *keytable;
-	unsigned int refs;
+	int_fast32_t refs;

 	/*
 	 * Detach *keytablep from its keytable.
@@ -148,8 +148,8 @@ dns_keytable_detach(dns_keytable_t **keytablep) {
 	keytable = *keytablep;
 	*keytablep = NULL;

-	isc_refcount_decrement(&keytable->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&keytable->references);
+	if (refs == 1) {
 		INSIST(isc_refcount_current(&keytable->active_nodes) == 0);
 		isc_refcount_destroy(&keytable->active_nodes);
 		isc_refcount_destroy(&keytable->references);
@@ -422,7 +422,7 @@ dns_keytable_find(dns_keytable_t *keytable, const dns_name_t *keyname,
 				  DNS_RBTFIND_NOOPTIONS, NULL, NULL);
 	if (result == ISC_R_SUCCESS) {
 		if (node->data != NULL) {
-			isc_refcount_increment0(&keytable->active_nodes, NULL);
+			isc_refcount_increment0(&keytable->active_nodes);
 			dns_keynode_attach(node->data, keynodep);
 		} else
 			result = ISC_R_NOTFOUND;
@@ -450,7 +450,7 @@ dns_keytable_nextkeynode(dns_keytable_t *keytable, dns_keynode_t *keynode,
 		return (ISC_R_NOTFOUND);

 	dns_keynode_attach(keynode->next, nextnodep);
-	isc_refcount_increment(&keytable->active_nodes, NULL);
+	isc_refcount_increment(&keytable->active_nodes);

 	return (ISC_R_SUCCESS);
 }
@@ -498,7 +498,7 @@ dns_keytable_findkeynode(dns_keytable_t *keytable, const dns_name_t *name,
 				break;
 		}
 		if (knode != NULL) {
-			isc_refcount_increment0(&keytable->active_nodes, NULL);
+			isc_refcount_increment0(&keytable->active_nodes);
 			dns_keynode_attach(knode, keynodep);
 		} else
 			result = DNS_R_PARTIALMATCH;
@@ -536,7 +536,7 @@ dns_keytable_findnextkeynode(dns_keytable_t *keytable, dns_keynode_t *keynode,
 			break;
 	}
 	if (knode != NULL) {
-		isc_refcount_increment(&keytable->active_nodes, NULL);
+		isc_refcount_increment(&keytable->active_nodes);
 		result = ISC_R_SUCCESS;
 		dns_keynode_attach(knode, nextnodep);
 	} else
@@ -585,7 +585,7 @@ dns_keytable_attachkeynode(dns_keytable_t *keytable, dns_keynode_t *source,
 	REQUIRE(VALID_KEYNODE(source));
 	REQUIRE(target != NULL && *target == NULL);

-	isc_refcount_increment(&keytable->active_nodes, NULL);
+	isc_refcount_increment(&keytable->active_nodes);

 	dns_keynode_attach(source, target);
 }
@@ -600,7 +600,7 @@ dns_keytable_detachkeynode(dns_keytable_t *keytable, dns_keynode_t **keynodep)
 	REQUIRE(VALID_KEYTABLE(keytable));
 	REQUIRE(keynodep != NULL && VALID_KEYNODE(*keynodep));

-	isc_refcount_decrement(&keytable->active_nodes, NULL);
+	isc_refcount_decrement(&keytable->active_nodes);
 	dns_keynode_detach(keytable->mctx, keynodep);
 }

@@ -746,7 +746,7 @@ dns_keytable_forall(dns_keytable_t *keytable,
 			result = ISC_R_SUCCESS;
 		goto cleanup;
 	}
-	isc_refcount_increment0(&keytable->active_nodes, NULL);
+	isc_refcount_increment0(&keytable->active_nodes);
 	for (;;) {
 		dns_rbtnodechain_current(&chain, NULL, NULL, &node);
 		if (node->data != NULL)
@@ -758,7 +758,7 @@ dns_keytable_forall(dns_keytable_t *keytable,
 			break;
 		}
 	}
-	isc_refcount_decrement(&keytable->active_nodes, NULL);
+	isc_refcount_decrement(&keytable->active_nodes);

   cleanup:
 	dns_rbtnodechain_invalidate(&chain);
@@ -822,17 +822,17 @@ dns_keynode_create(isc_mem_t *mctx, dns_keynode_t **target) {
 void
 dns_keynode_attach(dns_keynode_t *source, dns_keynode_t **target) {
 	REQUIRE(VALID_KEYNODE(source));
-	isc_refcount_increment(&source->refcount, NULL);
+	isc_refcount_increment(&source->refcount);
 	*target = source;
 }

 void
 dns_keynode_detach(isc_mem_t *mctx, dns_keynode_t **keynode) {
-	unsigned int refs;
+	int_fast32_t refs;
 	dns_keynode_t *node = *keynode;
 	REQUIRE(VALID_KEYNODE(node));
-	isc_refcount_decrement(&node->refcount, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&node->refcount);
+	if (refs == 1) {
 		if (node->key != NULL)
 			dst_key_free(&node->key);
 		isc_refcount_destroy(&node->refcount);
@@ -58,19 +58,19 @@ struct dns_nta {
 */
 static void
 nta_ref(dns_nta_t *nta) {
-	isc_refcount_increment(&nta->refcount, NULL);
+	isc_refcount_increment(&nta->refcount);
 }

 static void
 nta_detach(isc_mem_t *mctx, dns_nta_t **ntap) {
-	unsigned int refs;
+	int_fast32_t refs;
 	dns_nta_t *nta = *ntap;

 	REQUIRE(VALID_NTA(nta));

 	*ntap = NULL;
-	isc_refcount_decrement(&nta->refcount, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&nta->refcount);
+	if (refs == 1) {
 		nta->magic = 0;
 		if (nta->timer != NULL) {
 			(void) isc_timer_reset(nta->timer,
@@ -131,7 +131,7 @@ void
 dns_order_attach(dns_order_t *source, dns_order_t **target) {
 	REQUIRE(DNS_ORDER_VALID(source));
 	REQUIRE(target != NULL && *target == NULL);
-	isc_refcount_increment(&source->references, NULL);
+	isc_refcount_increment(&source->references);
 	*target = source;
 }

@@ -139,15 +139,16 @@ void
 dns_order_detach(dns_order_t **orderp) {
 	dns_order_t *order;
 	dns_order_ent_t *ent;
-	unsigned int references;
+	int_fast32_t refs;

 	REQUIRE(orderp != NULL);
 	order = *orderp;
 	REQUIRE(DNS_ORDER_VALID(order));
-	isc_refcount_decrement(&order->references, &references);
 	*orderp = NULL;
-	if (references != 0)
+	refs = isc_refcount_decrement(&order->references);
+	if (refs > 1) {
 		return;
+	}

 	order->magic = 0;
 	while ((ent = ISC_LIST_HEAD(order->ents)) != NULL) {
@@ -231,21 +231,20 @@ dns_portlist_attach(dns_portlist_t *portlist, dns_portlist_t **portlistp) {
 	REQUIRE(DNS_VALID_PORTLIST(portlist));
 	REQUIRE(portlistp != NULL && *portlistp == NULL);

-	isc_refcount_increment(&portlist->refcount, NULL);
+	isc_refcount_increment(&portlist->refcount);
 	*portlistp = portlist;
 }

 void
 dns_portlist_detach(dns_portlist_t **portlistp) {
 	dns_portlist_t *portlist;
-	unsigned int count;
+	int_fast32_t refs;

 	REQUIRE(portlistp != NULL);
 	portlist = *portlistp;
 	REQUIRE(DNS_VALID_PORTLIST(portlist));
-	*portlistp = NULL;
-	isc_refcount_decrement(&portlist->refcount, &count);
-	if (count == 0) {
+	refs = isc_refcount_decrement(&portlist->refcount);
+	if (refs == 1) {
 		portlist->magic = 0;
 		isc_refcount_destroy(&portlist->refcount);
 		if (portlist->list != NULL)
@@ -256,4 +255,5 @@ dns_portlist_detach(dns_portlist_t **portlistp) {
 		isc_mem_putanddetach(&portlist->mctx, portlist,
 				     sizeof(*portlist));
 	}
+	*portlistp = NULL;
 }
@@ -135,32 +135,6 @@ typedef isc_uint32_t                    rbtdb_rdatatype_t;
 #define RBTDB_RDATATYPE_NCACHEANY \
 		RBTDB_RDATATYPE_VALUE(0, dns_rdatatype_any)

-/*
- * We use rwlock for DB lock only when ISC_RWLOCK_USEATOMIC is non 0.
- * Using rwlock is effective with regard to lookup performance only when
- * it is implemented in an efficient way.
- * Otherwise, it is generally wise to stick to the simple locking since rwlock
- * would require more memory or can even make lookups slower due to its own
- * overhead (when it internally calls mutex locks).
- */
-#ifdef ISC_RWLOCK_USEATOMIC
-#define DNS_RBTDB_USERWLOCK 1
-#else
-#define DNS_RBTDB_USERWLOCK 0
-#endif
-
-#if DNS_RBTDB_USERWLOCK
-#define RBTDB_INITLOCK(l)       isc_rwlock_init((l), 0, 0)
-#define RBTDB_DESTROYLOCK(l)    isc_rwlock_destroy(l)
-#define RBTDB_LOCK(l, t)        RWLOCK((l), (t))
-#define RBTDB_UNLOCK(l, t)      RWUNLOCK((l), (t))
-#else
-#define RBTDB_INITLOCK(l)       isc_mutex_init(l)
-#define RBTDB_DESTROYLOCK(l)    DESTROYLOCK(l)
-#define RBTDB_LOCK(l, t)        LOCK(l)
-#define RBTDB_UNLOCK(l, t)      UNLOCK(l)
-#endif
-
 /*
 * Since node locking is sensitive to both performance and memory footprint,
 * we need some trick here.  If we have both high-performance rwlock and
@@ -180,7 +154,6 @@ typedef isc_uint32_t                    rbtdb_rdatatype_t;
 * Note that we cannot use NODE_LOCK()/NODE_UNLOCK() wherever the protected
 * section is also protected by NODE_STRONGLOCK().
 */
-#if defined(ISC_RWLOCK_USEATOMIC) && defined(DNS_RBT_USEISCREFCOUNT)
 typedef isc_rwlock_t nodelock_t;

 #define NODE_INITLOCK(l)        isc_rwlock_init((l), 0, 0)
@@ -194,21 +167,6 @@ typedef isc_rwlock_t nodelock_t;
 #define NODE_WEAKLOCK(l, t)     NODE_LOCK(l, t)
 #define NODE_WEAKUNLOCK(l, t)   NODE_UNLOCK(l, t)
 #define NODE_WEAKDOWNGRADE(l)   isc_rwlock_downgrade(l)
-#else
-typedef isc_mutex_t nodelock_t;
-
-#define NODE_INITLOCK(l)        isc_mutex_init(l)
-#define NODE_DESTROYLOCK(l)     DESTROYLOCK(l)
-#define NODE_LOCK(l, t)         LOCK(l)
-#define NODE_UNLOCK(l, t)       UNLOCK(l)
-#define NODE_TRYUPGRADE(l)      ISC_R_SUCCESS
-
-#define NODE_STRONGLOCK(l)      LOCK(l)
-#define NODE_STRONGUNLOCK(l)    UNLOCK(l)
-#define NODE_WEAKLOCK(l, t)     ((void)0)
-#define NODE_WEAKUNLOCK(l, t)   ((void)0)
-#define NODE_WEAKDOWNGRADE(l)   ((void)0)
-#endif

 /*%
 * Whether to rate-limit updating the LRU to avoid possible thread contention.
@@ -467,11 +425,7 @@ struct dns_rbtdb {
 	/* Unlocked. */
 	dns_db_t                        common;
 	/* Locks the data in this struct */
-#if DNS_RBTDB_USERWLOCK
 	isc_rwlock_t                    lock;
-#else
-	isc_mutex_t                     lock;
-#endif
 	/* Locks the tree structure (prevents nodes appearing/disappearing) */
 	isc_rwlock_t                    tree_lock;
 	/* Locks for individual tree nodes */
@@ -815,7 +769,7 @@ attach(dns_db_t *source, dns_db_t **targetp) {

 	REQUIRE(VALID_RBTDB(rbtdb));

-	isc_refcount_increment(&rbtdb->references, NULL);
+	isc_refcount_increment(&rbtdb->references);

 	*targetp = source;
 }
@@ -1014,14 +968,10 @@ free_rbtdb(dns_rbtdb_t *rbtdb, isc_boolean_t log, isc_event_t *event) {
 	REQUIRE(rbtdb->future_version == NULL);

 	if (rbtdb->current_version != NULL) {
-		unsigned int refs;
-
-		isc_refcount_decrement(&rbtdb->current_version->references,
-				       &refs);
-		INSIST(refs == 0);
+		isc_refcount_decrement(&rbtdb->current_version->references);
+		isc_refcount_destroy(&rbtdb->current_version->references); /* Ensures this was the last reference */
 		UNLINK(rbtdb->open_versions, rbtdb->current_version, link);
 		isc_rwlock_destroy(&rbtdb->current_version->glue_rwlock);
-		isc_refcount_destroy(&rbtdb->current_version->references);
 		isc_rwlock_destroy(&rbtdb->current_version->rwlock);
 		isc_mem_put(rbtdb->common.mctx, rbtdb->current_version,
 			    sizeof(rbtdb_version_t));
@@ -1145,7 +1095,7 @@ free_rbtdb(dns_rbtdb_t *rbtdb, isc_boolean_t log, isc_event_t *event) {
 	if (rbtdb->task != NULL)
 		isc_task_detach(&rbtdb->task);

-	RBTDB_DESTROYLOCK(&rbtdb->lock);
+	isc_rwlock_destroy(&rbtdb->lock);
 	rbtdb->common.magic = 0;
 	rbtdb->common.impmagic = 0;
 	isc_mem_detach(&rbtdb->hmctx);
@@ -1204,12 +1154,12 @@ maybe_free_rbtdb(dns_rbtdb_t *rbtdb) {
 	}

 	if (inactive != 0) {
-		RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+		RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 		rbtdb->active -= inactive;
 		if (rbtdb->active == 0) {
 			want_free = ISC_TRUE;
 		}
-		RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+		RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 		if (want_free) {
 			char buf[DNS_NAME_FORMATSIZE];
 			if (dns_name_dynamic(&rbtdb->common.origin)) {
@@ -1229,14 +1179,15 @@ maybe_free_rbtdb(dns_rbtdb_t *rbtdb) {
 static void
 detach(dns_db_t **dbp) {
 	dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(*dbp);
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(VALID_RBTDB(rbtdb));

-	isc_refcount_decrement(&rbtdb->references, &refs);
-
-	if (refs == 0)
+	refs = isc_refcount_decrement(&rbtdb->references);
+	
+	if (refs == 1) {
 		maybe_free_rbtdb(rbtdb);
+	}

 	*dbp = NULL;
 }
@@ -1245,14 +1196,13 @@ static void
 currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
 	dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
 	rbtdb_version_t *version;
-	unsigned int refs;

 	REQUIRE(VALID_RBTDB(rbtdb));

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
 	version = rbtdb->current_version;
-	isc_refcount_increment(&version->references, &refs);
-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+	isc_refcount_increment(&version->references);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);

 	*versionp = (dns_dbversion_t *)version;
 }
@@ -1315,7 +1265,7 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
 	REQUIRE(versionp != NULL && *versionp == NULL);
 	REQUIRE(rbtdb->future_version == NULL);

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 	RUNTIME_CHECK(rbtdb->next_serial != 0);         /* XXX Error? */
 	version = allocate_version(rbtdb->common.mctx, rbtdb->next_serial, 1,
 				   ISC_TRUE);
@@ -1360,7 +1310,7 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
 		}
 	} else
 		result = ISC_R_NOMEMORY;
-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	if (version == NULL)
 		return (result);
@@ -1376,13 +1326,11 @@ attachversion(dns_db_t *db, dns_dbversion_t *source,
 {
 	dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
 	rbtdb_version_t *rbtversion = source;
-	unsigned int refs;

 	REQUIRE(VALID_RBTDB(rbtdb));
 	INSIST(rbtversion != NULL && rbtversion->rbtdb == rbtdb);

-	isc_refcount_increment(&rbtversion->references, &refs);
-	INSIST(refs > 1);
+	isc_refcount_increment(&rbtversion->references);

 	*targetp = rbtversion;
 }
@@ -1392,7 +1340,6 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
 	    dns_rbtnode_t *node)
 {
 	rbtdb_changed_t *changed;
-	unsigned int refs;

 	/*
 	 * Caller must be holding the node lock if its reference must be
@@ -1401,20 +1348,19 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,

 	changed = isc_mem_get(rbtdb->common.mctx, sizeof(*changed));

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	REQUIRE(version->writer);

 	if (changed != NULL) {
-		dns_rbtnode_refincrement(node, &refs);
-		INSIST(refs != 0);
+		(void)dns_rbtnode_refincrement(node);
 		changed->node = node;
 		changed->dirty = ISC_FALSE;
 		ISC_LIST_INITANDAPPEND(version->changed_list, changed, link);
 	} else
 		version->commit_ok = ISC_FALSE;

-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	return (changed);
 }
@@ -1915,17 +1861,15 @@ check_ttl(dns_rbtnode_t *node, rbtdb_search_t *search,
 */
 static inline void
 new_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
-	unsigned int lockrefs, noderefs;
+	int_fast32_t noderefs;
 	isc_refcount_t *lockref;

 	INSIST(!ISC_LINK_LINKED(node, deadlink));
-	dns_rbtnode_refincrement0(node, &noderefs);
-	if (noderefs == 1) {    /* this is the first reference to the node */
+	noderefs = dns_rbtnode_refincrement0(node);
+	if (noderefs == 0) {    /* this is the first reference to the node */
 		lockref = &rbtdb->node_locks[node->locknum].references;
-		isc_refcount_increment0(lockref, &lockrefs);
-		INSIST(lockrefs != 0);
+		isc_refcount_increment0(lockref);
 	}
-	INSIST(noderefs != 0);
 }

 /*%
@@ -2057,7 +2001,7 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
 	isc_result_t result;
 	isc_boolean_t write_locked;
 	rbtdb_nodelock_t *nodelock;
-	unsigned int refs, nrefs;
+	int_fast32_t refs;
 	int bucket = node->locknum;
 	isc_boolean_t no_reference = ISC_TRUE;

@@ -2069,13 +2013,12 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,

 	/* Handle easy and typical case first. */
 	if (!node->dirty && KEEP_NODE(node, rbtdb)) {
-		dns_rbtnode_refdecrement(node, &nrefs);
-		INSIST((int)nrefs >= 0);
-		if (nrefs == 0) {
-			isc_refcount_decrement(&nodelock->references, &refs);
-			INSIST((int)refs >= 0);
+		refs = dns_rbtnode_refdecrement(node);
+		if (refs == 1) {
+			isc_refcount_decrement(&nodelock->references);
+			return ISC_TRUE;
 		}
-		return ((nrefs == 0) ? ISC_TRUE : ISC_FALSE);
+		return ISC_FALSE;
 	}

 	/* Upgrade the lock? */
@@ -2084,12 +2027,12 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
 		NODE_WEAKLOCK(&nodelock->lock, isc_rwlocktype_write);
 	}

-	dns_rbtnode_refdecrement(node, &nrefs);
-	INSIST((int)nrefs >= 0);
-	if (nrefs > 0) {
+	refs = dns_rbtnode_refdecrement(node);
+	if (refs > 1) {
 		/* Restore the lock? */
-		if (nlock == isc_rwlocktype_read)
+		if (nlock == isc_rwlocktype_read) {
 			NODE_WEAKDOWNGRADE(&nodelock->lock);
+		}
 		return (ISC_FALSE);
 	}

@@ -2102,9 +2045,9 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
 				 * Caller doesn't know the least serial.
 				 * Get it.
 				 */
-				RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+				RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
 				least_serial = rbtdb->least_serial;
-				RBTDB_UNLOCK(&rbtdb->lock,
+				RWUNLOCK(&rbtdb->lock,
 					     isc_rwlocktype_read);
 			}
 			clean_zone_node(rbtdb, node, least_serial);
@@ -2134,8 +2077,7 @@ decrement_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
 	} else
 		write_locked = ISC_TRUE;

-	isc_refcount_decrement(&nodelock->references, &refs);
-	INSIST((int)refs >= 0);
+	isc_refcount_decrement(&nodelock->references);

 	if (KEEP_NODE(node, rbtdb))
 		goto restore_locks;
@@ -2490,7 +2432,7 @@ cleanup_dead_nodes_callback(isc_task_t *task, isc_event_t *event) {
 	dns_rbtdb_t *rbtdb = event->ev_arg;
 	isc_boolean_t again = ISC_FALSE;
 	unsigned int locknum;
-	unsigned int refs;
+	int_fast32_t refs;

 	RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
 	for (locknum = 0; locknum < rbtdb->node_lock_count; locknum++) {
@@ -2507,9 +2449,10 @@ cleanup_dead_nodes_callback(isc_task_t *task, isc_event_t *event) {
 		isc_task_send(task, &event);
 	else {
 		isc_event_free(&event);
-		isc_refcount_decrement(&rbtdb->references, &refs);
-		if (refs == 0)
+		refs = isc_refcount_decrement(&rbtdb->references);
+		if (refs == 1) {
 			maybe_free_rbtdb(rbtdb);
+		}
 	}
 }

@@ -2523,7 +2466,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 	rbtdb_changed_t *changed, *next_changed;
 	rbtdb_serial_t serial, least_serial;
 	dns_rbtnode_t *rbtnode;
-	unsigned int refs;
+	int_fast32_t refs;
 	rdatasetheader_t *header;

 	REQUIRE(VALID_RBTDB(rbtdb));
@@ -2534,12 +2477,12 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 	ISC_LIST_INIT(cleanup_list);
 	ISC_LIST_INIT(resigned_list);

-	isc_refcount_decrement(&version->references, &refs);
-	if (refs > 0) {         /* typical and easy case first */
+	refs = isc_refcount_decrement(&version->references);
+	if (refs > 1) {         /* typical and easy case first */
 		if (commit) {
-			RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
+			RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
 			INSIST(!version->writer);
-			RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
+			RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
 		}
 		goto end;
 	}
@@ -2551,11 +2494,11 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 	if (version->writer && commit && !IS_CACHE(rbtdb))
 		iszonesecure(db, version, rbtdb->origin_node);

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 	serial = version->serial;
 	if (version->writer) {
 		if (commit) {
-			unsigned cur_ref;
+			int_fast32_t cur_refs;
 			rbtdb_version_t *cur_version;

 			INSIST(version->commit_ok);
@@ -2566,9 +2509,8 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 			 * DB itself and unlink it from the open list.
 			 */
 			cur_version = rbtdb->current_version;
-			isc_refcount_decrement(&cur_version->references,
-					       &cur_ref);
-			if (cur_ref == 0) {
+			cur_refs = isc_refcount_decrement(&cur_version->references);
+			if (cur_refs == 1) {
 				if (cur_version->serial == rbtdb->least_serial)
 					INSIST(EMPTY(cur_version->changed_list));
 				UNLINK(rbtdb->open_versions,
@@ -2602,7 +2544,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 			 * isn't being used by anyone, we can clean
 			 * it up.
 			 */
-			if (cur_ref == 0) {
+			if (cur_refs == 1) {
 				cleanup_version = cur_version;
 				APPENDLIST(version->changed_list,
 					   cleanup_version->changed_list,
@@ -2623,9 +2565,8 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 			 * case where we need to increment the counter from
 			 * zero and need to use isc_refcount_increment0().
 			 */
-			isc_refcount_increment0(&version->references,
-						&cur_ref);
-			INSIST(cur_ref == 1);
+			cur_refs = isc_refcount_increment0(&version->references);
+			INSIST(cur_refs == 0);
 			PREPEND(rbtdb->open_versions,
 				rbtdb->current_version, link);
 			resigned_list = version->resigned_list;
@@ -2684,7 +2625,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 		UNLINK(rbtdb->open_versions, version, link);
 	}
 	least_serial = rbtdb->least_serial;
-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	if (cleanup_version != NULL) {
 		INSIST(EMPTY(cleanup_version->changed_list));
@@ -2777,7 +2718,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
 				    sizeof(*changed));
 		}
 		if (event != NULL) {
-			isc_refcount_increment(&rbtdb->references, NULL);
+			isc_refcount_increment(&rbtdb->references);
 			isc_task_send(rbtdb->task, &event);
 		} else
 			RWUNLOCK(&rbtdb->tree_lock, isc_rwlocktype_write);
@@ -4479,11 +4420,6 @@ check_stale_header(dns_rbtnode_t *node, rdatasetheader_t *header,
 		   isc_rwlocktype_t *locktype, nodelock_t *lock,
 		   rbtdb_search_t *search, rdatasetheader_t **header_prev)
 {
-
-#if !defined(ISC_RWLOCK_USEATOMIC) || !defined(DNS_RBT_USEISCREFCOUNT)
-	UNUSED(lock);
-#endif
-
 	if (!ACTIVE(header, search->now)) {
 		dns_ttl_t stale = header->rdh_ttl +
 				  search->rbtdb->serve_stale_ttl;
@@ -5331,14 +5267,12 @@ static void
 attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
 	dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
 	dns_rbtnode_t *node = (dns_rbtnode_t *)source;
-	unsigned int refs;

 	REQUIRE(VALID_RBTDB(rbtdb));
 	REQUIRE(targetp != NULL && *targetp == NULL);

 	NODE_STRONGLOCK(&rbtdb->node_locks[node->locknum].lock);
-	dns_rbtnode_refincrement(node, &refs);
-	INSIST(refs != 0);
+	dns_rbtnode_refincrement(node);
 	NODE_STRONGUNLOCK(&rbtdb->node_locks[node->locknum].lock);

 	*targetp = source;
@@ -5373,11 +5307,11 @@ detachnode(dns_db_t *db, dns_dbnode_t **targetp) {
 	*targetp = NULL;

 	if (inactive) {
-		RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+		RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 		rbtdb->active--;
 		if (rbtdb->active == 0)
 			want_free = ISC_TRUE;
-		RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+		RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 		if (want_free) {
 			char buf[DNS_NAME_FORMATSIZE];
 			if (dns_name_dynamic(&rbtdb->common.origin))
@@ -5501,7 +5435,7 @@ printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_read);

-	fprintf(out, "node %p, %u references, locknum = %u\n",
+	fprintf(out, "node %p, %" PRIdFAST32 " references, locknum = %u\n",
 		rbtnode, dns_rbtnode_refcurrent(rbtnode),
 		rbtnode->locknum);
 	if (rbtnode->data != NULL) {
@@ -5767,7 +5701,6 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 	dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
 	rbtdb_version_t *rbtversion = version;
 	rbtdb_rdatasetiter_t *iterator;
-	unsigned int refs;

 	REQUIRE(VALID_RBTDB(rbtdb));

@@ -5783,9 +5716,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 		else {
 			INSIST(rbtversion->rbtdb == rbtdb);

-			isc_refcount_increment(&rbtversion->references,
-					       &refs);
-			INSIST(refs > 1);
+			isc_refcount_increment(&rbtversion->references);
 		}
 	} else {
 		if (now == 0)
@@ -5802,8 +5733,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,

 	NODE_STRONGLOCK(&rbtdb->node_locks[rbtnode->locknum].lock);

-	dns_rbtnode_refincrement(rbtnode, &refs);
-	INSIST(refs != 0);
+	dns_rbtnode_refincrement(rbtnode);

 	iterator->current = NULL;

@@ -7448,13 +7378,13 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
 	else
 		loadctx->now = 0;

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	REQUIRE((rbtdb->attributes & (RBTDB_ATTR_LOADED|RBTDB_ATTR_LOADING))
 		== 0);
 	rbtdb->attributes |= RBTDB_ATTR_LOADING;

-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	callbacks->add = loading_addrdataset;
 	callbacks->add_private = loadctx;
@@ -7475,7 +7405,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
 	REQUIRE(loadctx != NULL);
 	REQUIRE(loadctx->rbtdb == rbtdb);

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADING) != 0);
 	REQUIRE((rbtdb->attributes & RBTDB_ATTR_LOADED) == 0);
@@ -7483,7 +7413,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
 	rbtdb->attributes &= ~RBTDB_ATTR_LOADING;
 	rbtdb->attributes |= RBTDB_ATTR_LOADED;

-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);

 	/*
 	 * If there's a KEY rdataset at the zone origin containing a
@@ -7819,12 +7749,12 @@ settask(dns_db_t *db, isc_task_t *task) {

 	REQUIRE(VALID_RBTDB(rbtdb));

-	RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWLOCK(&rbtdb->lock, isc_rwlocktype_write);
 	if (rbtdb->task != NULL)
 		isc_task_detach(&rbtdb->task);
 	if (task != NULL)
 		isc_task_attach(task, &rbtdb->task);
-	RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
+	RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 }

 static isc_boolean_t
@@ -8283,7 +8213,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,

 	ISC_LIST_INIT(rbtdb->common.update_listeners);

-	result = RBTDB_INITLOCK(&rbtdb->lock);
+	result = isc_rwlock_init(&rbtdb->lock, 0, 0);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_rbtdb;

@@ -8376,7 +8306,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 		if (result != ISC_R_SUCCESS) {
 			while (i-- > 0) {
 				NODE_DESTROYLOCK(&rbtdb->node_locks[i].lock);
-				isc_refcount_decrement(&rbtdb->node_locks[i].references, NULL);
+				isc_refcount_decrement(&rbtdb->node_locks[i].references);
 				isc_refcount_destroy(&rbtdb->node_locks[i].references);
 			}
 			goto cleanup_deadnodes;
@@ -8510,7 +8440,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 	rbtdb->next_serial = 2;
 	rbtdb->current_version = allocate_version(mctx, 1, 1, ISC_FALSE);
 	if (rbtdb->current_version == NULL) {
-		isc_refcount_decrement(&rbtdb->references, NULL);
+		isc_refcount_decrement(&rbtdb->references);
 		isc_refcount_destroy(&rbtdb->references);
 		free_rbtdb(rbtdb, ISC_FALSE, NULL);
 		return (ISC_R_NOMEMORY);
@@ -8532,7 +8462,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 		isc_mem_put(mctx, rbtdb->current_version,
 			    sizeof(*rbtdb->current_version));
 		rbtdb->current_version = NULL;
-		isc_refcount_decrement(&rbtdb->references, NULL);
+		isc_refcount_decrement(&rbtdb->references);
 		isc_refcount_destroy(&rbtdb->references);
 		free_rbtdb(rbtdb, ISC_FALSE, NULL);
 		return (result);
@@ -8584,7 +8514,7 @@ dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 	isc_rwlock_destroy(&rbtdb->tree_lock);

 cleanup_lock:
-	RBTDB_DESTROYLOCK(&rbtdb->lock);
+	isc_rwlock_destroy(&rbtdb->lock);

 cleanup_rbtdb:
 	isc_mem_put(mctx, rbtdb,  sizeof(*rbtdb));
@@ -9499,12 +9429,9 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
 		 * expirenode() currently always returns success.
 		 */
 		if (expire_result == ISC_R_SUCCESS && node->down == NULL) {
-			unsigned int refs;
-
 			rbtdbiter->deletions[rbtdbiter->delcnt++] = node;
 			NODE_STRONGLOCK(&rbtdb->node_locks[node->locknum].lock);
-			dns_rbtnode_refincrement(node, &refs);
-			INSIST(refs != 0);
+			dns_rbtnode_refincrement(node);
 			NODE_STRONGUNLOCK(&rbtdb->node_locks[node->locknum].lock);
 		}
 	}
@@ -1479,7 +1479,7 @@ cleanup_task:
 	dns_rbt_destroy(&zones->rbt);

 cleanup_rbt:
-	isc_refcount_decrement(&zones->refs, NULL);
+	isc_refcount_decrement(&zones->refs);
 	isc_refcount_destroy(&zones->refs);

 cleanup_refcount:
@@ -1565,7 +1565,7 @@ cleanup_ht:
 	isc_timer_detach(&zone->updatetimer);

 cleanup_timer:
-	isc_refcount_decrement(&zone->refs, NULL);
+	isc_refcount_decrement(&zone->refs);
 	isc_refcount_destroy(&zone->refs);

 cleanup_refcount:
@@ -2048,51 +2048,64 @@ cidr_free(dns_rpz_zones_t *rpzs) {
 static void
 rpz_detach(dns_rpz_zone_t **rpzp, dns_rpz_zones_t *rpzs) {
 	dns_rpz_zone_t *rpz;
-	unsigned int refs;
+	int_fast32_t refs;

 	rpz = *rpzp;
 	*rpzp = NULL;
-	isc_refcount_decrement(&rpz->refs, &refs);
-	if (refs != 0)
+	refs = isc_refcount_decrement(&rpz->refs);
+	if (refs > 1) {
 		return;
+	}
+
 	isc_refcount_destroy(&rpz->refs);

-	if (dns_name_dynamic(&rpz->origin))
+	if (dns_name_dynamic(&rpz->origin)) {
 		dns_name_free(&rpz->origin, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->client_ip))
+	}
+	if (dns_name_dynamic(&rpz->client_ip)) {
 		dns_name_free(&rpz->client_ip, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->ip))
+	}
+	if (dns_name_dynamic(&rpz->ip)) {
 		dns_name_free(&rpz->ip, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->nsdname))
+	}
+	if (dns_name_dynamic(&rpz->nsdname)) {
 		dns_name_free(&rpz->nsdname, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->nsip))
+	}
+	if (dns_name_dynamic(&rpz->nsip)) {
 		dns_name_free(&rpz->nsip, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->passthru))
+	}
+	if (dns_name_dynamic(&rpz->passthru)) {
 		dns_name_free(&rpz->passthru, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->drop))
+	}
+	if (dns_name_dynamic(&rpz->drop)) {
 		dns_name_free(&rpz->drop, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->tcp_only))
+	}
+	if (dns_name_dynamic(&rpz->tcp_only)) {
 		dns_name_free(&rpz->tcp_only, rpzs->mctx);
-	if (dns_name_dynamic(&rpz->cname))
+	}
+	if (dns_name_dynamic(&rpz->cname)) {
 		dns_name_free(&rpz->cname, rpzs->mctx);
-	if (rpz->db_registered)
+	}
+	if (rpz->db_registered) {
 		dns_db_updatenotify_unregister(rpz->db,
 					       dns_rpz_dbupdate_callback, rpz);
-	if (rpz->dbversion != NULL)
+	}
+	if (rpz->dbversion != NULL) {
 		dns_db_closeversion(rpz->db, &rpz->dbversion,
 				    ISC_FALSE);
-	if (rpz->db)
+	}
+	if (rpz->db) {
 		dns_db_detach(&rpz->db);
+	}
 	isc_ht_destroy(&rpz->nodes);
 	isc_timer_detach(&rpz->updatetimer);
-
 	isc_mem_put(rpzs->mctx, rpz, sizeof(*rpz));
 }

 void
 dns_rpz_attach_rpzs(dns_rpz_zones_t *rpzs, dns_rpz_zones_t **rpzsp) {
 	REQUIRE(rpzsp != NULL && *rpzsp == NULL);
-	isc_refcount_increment(&rpzs->refs, NULL);
+	isc_refcount_increment(&rpzs->refs);
 	*rpzsp = rpzs;
 }

@@ -2104,18 +2117,19 @@ dns_rpz_detach_rpzs(dns_rpz_zones_t **rpzsp) {
 	dns_rpz_zones_t *rpzs;
 	dns_rpz_zone_t *rpz;
 	dns_rpz_num_t rpz_num;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(rpzsp != NULL);
 	rpzs = *rpzsp;
 	REQUIRE(rpzs != NULL);

 	*rpzsp = NULL;
-	isc_refcount_decrement(&rpzs->refs, &refs);
-	if (refs != 0) {
+	refs = isc_refcount_decrement(&rpzs->refs);
+
+	if (refs > 1) {
 		return;
 	}
-
+	
 	/*
 	 * Forget the last of view's rpz machinery after the last reference.
 	 */
@@ -375,8 +375,9 @@ dns_tsigkey_createfromkey(const dns_name_t *name, const dns_name_t *algorithm,

 cleanup_refs:
 	tkey->magic = 0;
-	while (refs-- > 0)
-		isc_refcount_decrement(&tkey->refs, NULL);
+	while (refs-- > 0) {
+		isc_refcount_decrement(&tkey->refs);
+	}
 	isc_refcount_destroy(&tkey->refs);
 cleanup_creator:
 	if (tkey->key != NULL)
@@ -712,7 +713,7 @@ dns_tsigkey_attach(dns_tsigkey_t *source, dns_tsigkey_t **targetp) {
 	REQUIRE(VALID_TSIG_KEY(source));
 	REQUIRE(targetp != NULL && *targetp == NULL);

-	isc_refcount_increment(&source->refs, NULL);
+	isc_refcount_increment(&source->refs);
 	*targetp = source;
 }

@@ -741,16 +742,17 @@ tsigkey_free(dns_tsigkey_t *key) {
 void
 dns_tsigkey_detach(dns_tsigkey_t **keyp) {
 	dns_tsigkey_t *key;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(keyp != NULL);
 	REQUIRE(VALID_TSIG_KEY(*keyp));

 	key = *keyp;
-	isc_refcount_decrement(&key->refs, &refs);
+	refs = isc_refcount_decrement(&key->refs);

-	if (refs == 0)
+	if (refs == 1) {
 		tsigkey_free(key);
+	}

 	*keyp = NULL;
 }
@@ -1790,7 +1792,7 @@ dns_tsigkey_find(dns_tsigkey_t **tsigkey, const dns_name_t *name,
 		return (ISC_R_NOTFOUND);
 	}
 #endif
-	isc_refcount_increment(&key->refs, NULL);
+	isc_refcount_increment(&key->refs);
 	RWUNLOCK(&ring->lock, isc_rwlocktype_read);
 	adjust_lru(key);
 	*tsigkey = key;
@@ -1859,8 +1861,9 @@ dns_tsigkeyring_add(dns_tsig_keyring_t *ring, const dns_name_t *name,
 	isc_result_t result;

 	result = keyring_add(ring, name, tkey);
-	if (result == ISC_R_SUCCESS)
-		isc_refcount_increment(&tkey->refs, NULL);
+	if (result == ISC_R_SUCCESS) {
+		isc_refcount_increment(&tkey->refs);
+	}

 	return (result);
 }
@@ -567,7 +567,7 @@ dns_view_attach(dns_view_t *source, dns_view_t **targetp) {
 	REQUIRE(DNS_VIEW_VALID(source));
 	REQUIRE(targetp != NULL && *targetp == NULL);

-	isc_refcount_increment(&source->references, NULL);
+	isc_refcount_increment(&source->references);

 	*targetp = source;
 }
@@ -575,7 +575,7 @@ dns_view_attach(dns_view_t *source, dns_view_t **targetp) {
 static void
 view_flushanddetach(dns_view_t **viewp, isc_boolean_t flush) {
 	dns_view_t *view;
-	unsigned int refs;
+	int_fast32_t refs;
 	isc_boolean_t done = ISC_FALSE;

 	REQUIRE(viewp != NULL);
@@ -584,8 +584,8 @@ view_flushanddetach(dns_view_t **viewp, isc_boolean_t flush) {

 	if (flush)
 		view->flush = ISC_TRUE;
-	isc_refcount_decrement(&view->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&view->references);
+	if (refs == 1) {
 		dns_zone_t *mkzone = NULL, *rdzone = NULL;

 		LOCK(&view->lock);
@@ -174,18 +174,6 @@ typedef struct dns_include dns_include_t;
 	do { result = isc_mutex_trylock(&(z)->lock); } while (0)
 #endif

-#ifdef ISC_RWLOCK_USEATOMIC
-#define ZONEDB_INITLOCK(l)	isc_rwlock_init((l), 0, 0)
-#define ZONEDB_DESTROYLOCK(l)	isc_rwlock_destroy(l)
-#define ZONEDB_LOCK(l, t)	RWLOCK((l), (t))
-#define ZONEDB_UNLOCK(l, t)	RWUNLOCK((l), (t))
-#else
-#define ZONEDB_INITLOCK(l)	isc_mutex_init(l)
-#define ZONEDB_DESTROYLOCK(l)	DESTROYLOCK(l)
-#define ZONEDB_LOCK(l, t)	LOCK(l)
-#define ZONEDB_UNLOCK(l, t)	UNLOCK(l)
-#endif
-
 struct dns_zone {
 	/* Unlocked */
 	unsigned int		magic;
@@ -196,11 +184,7 @@ struct dns_zone {
 	isc_mem_t		*mctx;
 	isc_refcount_t		erefs;

-#ifdef ISC_RWLOCK_USEATOMIC
 	isc_rwlock_t		dblock;
-#else
-	isc_mutex_t		dblock;
-#endif
 	dns_db_t		*db;		/* Locked by dblock */

 	/* Locked */
@@ -902,7 +886,7 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
 		goto free_zone;
 	}

-	result = ZONEDB_INITLOCK(&zone->dblock);
+	result = isc_rwlock_init(&zone->dblock, 0, 0);
 	if (result != ISC_R_SUCCESS) {
 		goto free_mutex;
 	}
@@ -1084,11 +1068,11 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
 		isc_stats_detach(&zone->gluecachestats);

 free_erefs:
-	isc_refcount_decrement(&zone->erefs, NULL);
+	isc_refcount_decrement(&zone->erefs);
 	isc_refcount_destroy(&zone->erefs);

 free_dblock:
-	ZONEDB_DESTROYLOCK(&zone->dblock);
+	isc_rwlock_destroy(&zone->dblock);

 free_mutex:
 	DESTROYLOCK(&zone->lock);
@@ -1249,7 +1233,7 @@ zone_free(dns_zone_t *zone) {
 	}

 	/* last stuff */
-	ZONEDB_DESTROYLOCK(&zone->dblock);
+	isc_rwlock_destroy(&zone->dblock);
 	DESTROYLOCK(&zone->lock);
 	isc_refcount_destroy(&zone->erefs);
 	zone->magic = 0;
@@ -1341,7 +1325,7 @@ dns_zone_getserial(dns_zone_t *zone, isc_uint32_t *serialp) {
 	REQUIRE(serialp != NULL);

 	LOCK_ZONE(zone);
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL) {
 		result = zone_get_from_db(zone, zone->db, NULL, &soacount,
 					  serialp, NULL, NULL, NULL, NULL,
@@ -1350,7 +1334,7 @@ dns_zone_getserial(dns_zone_t *zone, isc_uint32_t *serialp) {
 			result = ISC_R_FAILURE;
 	} else
 		result = DNS_R_NOTLOADED;
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	UNLOCK_ZONE(zone);

 	return (result);
@@ -2005,7 +1989,7 @@ zone_load(dns_zone_t *zone, unsigned int flags, isc_boolean_t locked) {
 			goto cleanup;
 		}

-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+		RWLOCK(&zone->dblock, isc_rwlocktype_write);
 		/* ask SDLZ driver if the zone is supported */
 		findzone = dlzdb->implementation->methods->findzone;
 		result = (*findzone)(dlzdb->implementation->driverarg,
@@ -2019,7 +2003,7 @@ zone_load(dns_zone_t *zone, unsigned int flags, isc_boolean_t locked) {
 			dns_db_detach(&db);
 			result = ISC_R_SUCCESS;
 		}
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_write);

 		if (result == ISC_R_SUCCESS) {
 			if (dlzdb->configure_callback == NULL)
@@ -2380,7 +2364,7 @@ zone_gotwritehandle(isc_task_t *task, isc_event_t *event) {

 	LOCK_ZONE(zone);
 	INSIST(zone != zone->raw);
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL) {
 		const dns_master_style_t *output_style;

@@ -2402,7 +2386,7 @@ zone_gotwritehandle(isc_task_t *task, isc_event_t *event) {
 		dns_db_closeversion(zone->db, &version, ISC_FALSE);
 	} else
 		result = ISC_R_CANCELED;
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	UNLOCK_ZONE(zone);
 	if (result != DNS_R_CONTINUE)
 		goto fail;
@@ -3207,10 +3191,10 @@ resume_signingwithkey(dns_zone_t *zone) {
 	isc_result_t result;
 	dns_db_t *db = NULL;

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		goto cleanup;

@@ -3280,10 +3264,10 @@ zone_addnsec3chain(dns_zone_t *zone, dns_rdata_nsec3param_t *nsec3param) {
 	char flags[sizeof("INITIAL|REMOVE|CREATE|NONSEC|OPTOUT")];
 	dns_db_t *db = NULL;

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	if (db == NULL) {
 		result = ISC_R_SUCCESS;
@@ -3459,10 +3443,10 @@ resume_addnsec3chain(dns_zone_t *zone) {
 	if (zone->privatetype == 0)
 		return;

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		goto cleanup;

@@ -3558,10 +3542,10 @@ set_resigntime(dns_zone_t *zone) {
 	dns_rdataset_init(&rdataset);
 	dns_fixedname_init(&fixed);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL) {
 		isc_time_settoepoch(&zone->resigntime);
 		return;
@@ -4735,15 +4719,15 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,
 	    DNS_ZONEKEY_OPTION(zone, DNS_ZONEKEY_MAINTAIN))
 		zone->refreshkeytime = now;

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+	RWLOCK(&zone->dblock, isc_rwlocktype_write);
 	if (zone->db != NULL) {
 		result = zone_replacedb(zone, db, ISC_FALSE);
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 		if (result != ISC_R_SUCCESS)
 			goto cleanup;
 	} else {
 		zone_attachdb(zone, db);
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 		DNS_ZONE_SETFLAG(zone,
 				 DNS_ZONEFLG_LOADED|
 				 DNS_ZONEFLG_NEEDSTARTUPNOTIFY);
@@ -5194,7 +5178,7 @@ void
 dns_zone_attach(dns_zone_t *source, dns_zone_t **target) {
 	REQUIRE(DNS_ZONE_VALID(source));
 	REQUIRE(target != NULL && *target == NULL);
-	isc_refcount_increment(&source->erefs, NULL);
+	isc_refcount_increment(&source->erefs);
 	*target = source;
 }

@@ -5203,16 +5187,16 @@ dns_zone_detach(dns_zone_t **zonep) {
 	dns_zone_t *zone;
 	dns_zone_t *raw = NULL;
 	dns_zone_t *secure = NULL;
-	unsigned int refs;
+	int_fast32_t refs;
 	isc_boolean_t free_now = ISC_FALSE;

 	REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));

 	zone = *zonep;

-	isc_refcount_decrement(&zone->erefs, &refs);
+	refs = isc_refcount_decrement(&zone->erefs);

-	if (refs == 0) {
+	if (refs == 1) {
 		LOCK_ZONE(zone);
 		INSIST(zone != zone->raw);
 		/*
@@ -5919,12 +5903,12 @@ dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) {

 	REQUIRE(DNS_ZONE_VALID(zone));

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db == NULL)
 		result = DNS_R_NOTLOADED;
 	else
 		dns_db_attach(zone->db, dpb);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	return (result);
 }
@@ -5934,10 +5918,10 @@ dns_zone_setdb(dns_zone_t *zone, dns_db_t *db) {
 	REQUIRE(DNS_ZONE_VALID(zone));
 	REQUIRE(zone->type == dns_zone_staticstub);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+	RWLOCK(&zone->dblock, isc_rwlocktype_write);
 	REQUIRE(zone->db == NULL);
 	dns_db_attach(db, &zone->db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 }

 /*
@@ -6433,9 +6417,9 @@ zone_resigninc(dns_zone_t *zone) {
 		goto failure;
 	}

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	result = dns_db_newversion(db, &version);
 	if (result != ISC_R_SUCCESS) {
@@ -7437,7 +7421,7 @@ zone_nsec3chain(dns_zone_t *zone) {
 		goto failure;
 	}

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	/*
 	 * This function is called when zone timer fires, after the latter gets
 	 * set by zone_addnsec3chain().  If the action triggering the call to
@@ -7450,7 +7434,7 @@ zone_nsec3chain(dns_zone_t *zone) {
 	if (zone->db != NULL) {
 		dns_db_attach(zone->db, &db);
 	}
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL) {
 		return;
 	}
@@ -7527,12 +7511,12 @@ zone_nsec3chain(dns_zone_t *zone) {
 		LOCK_ZONE(zone);
 		nextnsec3chain = ISC_LIST_NEXT(nsec3chain, link);

-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+		RWLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (nsec3chain->done || nsec3chain->db != zone->db) {
 			ISC_LIST_UNLINK(zone->nsec3chain, nsec3chain, link);
 			ISC_LIST_APPEND(cleanup, nsec3chain, link);
 		}
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 		UNLOCK_ZONE(zone);
 		if (ISC_LIST_TAIL(cleanup) == nsec3chain)
 			goto next_addchain;
@@ -8328,10 +8312,10 @@ zone_sign(dns_zone_t *zone) {
 		goto failure;
 	}

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL) {
 		result = ISC_R_FAILURE;
 		goto failure;
@@ -8390,7 +8374,7 @@ zone_sign(dns_zone_t *zone) {
 	while (signing != NULL && nodes-- > 0 && signatures > 0) {
 		nextsigning = ISC_LIST_NEXT(signing, link);

-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+		RWLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (signing->done || signing->db != zone->db) {
 			/*
 			 * The zone has been reloaded.	We will have
@@ -8399,10 +8383,10 @@ zone_sign(dns_zone_t *zone) {
 			 */
 			ISC_LIST_UNLINK(zone->signing, signing, link);
 			ISC_LIST_APPEND(cleanup, signing, link);
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 			goto next_signing;
 		}
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 		if (signing->db != db)
 			goto next_signing;
@@ -9672,9 +9656,9 @@ zone_refreshkeys(dns_zone_t *zone) {
 		return;
 	}

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	dns_diff_init(zone->mctx, &diff);

@@ -10039,7 +10023,7 @@ dns_zone_markdirty(dns_zone_t *zone) {
 				goto again;
 			}

-			ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+			RWLOCK(&zone->dblock, isc_rwlocktype_read);
 			if (zone->db != NULL) {
 				result = zone_get_from_db(zone, zone->db, NULL,
 							  &soacount, &serial,
@@ -10047,7 +10031,7 @@ dns_zone_markdirty(dns_zone_t *zone) {
 							  NULL, NULL);
 			} else
 				result = DNS_R_NOTLOADED;
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 			if (result == ISC_R_SUCCESS && soacount > 0U)
 				zone_send_secureserial(zone, serial);
 		}
@@ -10316,7 +10300,7 @@ dump_done(void *arg, isc_result_t result) {
 			isc_uint32_t sserial;
 			isc_result_t mresult;

-			ZONEDB_LOCK(&secure->dblock, isc_rwlocktype_read);
+			RWLOCK(&secure->dblock, isc_rwlocktype_read);
 			if (secure->db != NULL) {
 				mresult = dns_db_getsoaserial(zone->secure->db,
 							      NULL, &sserial);
@@ -10324,7 +10308,7 @@ dump_done(void *arg, isc_result_t result) {
 				    isc_serial_lt(sserial, serial))
 					serial = sserial;
 			}
-			ZONEDB_UNLOCK(&secure->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&secure->dblock, isc_rwlocktype_read);
 		}
 		if (tresult == ISC_R_SUCCESS && zone->xfr == NULL) {
 			dns_db_t *zdb = NULL;
@@ -10388,10 +10372,10 @@ zone_dump(dns_zone_t *zone, isc_boolean_t compact) {
 	ENTER;

 redo:
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	LOCK_ZONE(zone);
 	if (zone->masterfile != NULL) {
 		masterfile = isc_mem_strdup(zone->mctx, zone->masterfile);
@@ -10481,10 +10465,10 @@ dumptostream(dns_zone_t *zone, FILE *fd, const dns_master_style_t *style,

 	REQUIRE(DNS_ZONE_VALID(zone));

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		return (DNS_R_NOTLOADED);

@@ -10576,9 +10560,9 @@ zone_unload(dns_zone_t *zone) {
 		if (zone->dctx != NULL)
 			dns_dumpctx_cancel(zone->dctx);
 	}
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+	RWLOCK(&zone->dblock, isc_rwlocktype_write);
 	zone_detachdb(zone);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 	DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADED);
 	DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
 }
@@ -11130,10 +11114,10 @@ zone_notify(dns_zone_t *zone, isc_time_t *now) {
 	/*
 	 * Get SOA RRset.
 	 */
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &zonedb);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zonedb == NULL)
 		return;
 	dns_db_currentversion(zonedb, &version);
@@ -11533,7 +11517,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
 	 * Tidy up.
 	 */
 	dns_db_closeversion(stub->db, &stub->version, ISC_TRUE);
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+	RWLOCK(&zone->dblock, isc_rwlocktype_write);
 	if (zone->db == NULL)
 		zone_attachdb(zone, stub->db);
 	result = zone_get_from_db(zone, zone->db, NULL, &soacount, NULL,
@@ -11546,7 +11530,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
 				     DNS_MAX_EXPIRE);
 		DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
 	}
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 	dns_db_detach(&stub->db);

 	dns_message_destroy(&msg);
@@ -12480,12 +12464,12 @@ ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub) {
 		 * new one and attach it to the zone once we have the NS
 		 * RRset and glue.
 		 */
-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+		RWLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (zone->db != NULL) {
 			dns_db_attach(zone->db, &stub->db);
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 		} else {
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 			INSIST(zone->db_argc >= 1);
 			result = dns_db_create(zone->mctx, zone->db_argv[0],
@@ -13020,10 +13004,10 @@ notify_createmessage(dns_zone_t *zone, unsigned int flags,
 	if (result != ISC_R_SUCCESS)
 		goto soa_cleanup;

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	INSIST(zone->db != NULL); /* XXXJT: is this assumption correct? */
 	dns_db_attach(zone->db, &zonedb);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	dns_name_init(tempname, NULL);
 	dns_name_clone(&zone->origin, tempname);
@@ -13819,10 +13803,10 @@ dns_zone_settask(dns_zone_t *zone, isc_task_t *task) {
 	if (zone->task != NULL)
 		isc_task_detach(&zone->task);
 	isc_task_attach(task, &zone->task);
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_settask(zone->db, zone->task);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	UNLOCK_ZONE(zone);
 }

@@ -14154,12 +14138,12 @@ receive_secure_serial(isc_task_t *task, isc_event_t *event) {
 		 * zone->db may be NULL, if the load from disk failed.
 		 */
 		result = ISC_R_SUCCESS;
-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+		RWLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (zone->db != NULL)
 			dns_db_attach(zone->db, &zone->rss_db);
 		else
 			result = ISC_R_FAILURE;
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 		if (result == ISC_R_SUCCESS && zone->raw != NULL)
 			dns_zone_attach(zone->raw, &zone->rss_raw);
@@ -14659,7 +14643,7 @@ receive_secure_db(isc_task_t *task, isc_event_t *event) {
 	}

 	TIME_NOW(&loadtime);
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL) {
 		result = dns_db_getsoaserial(zone->db, NULL, &oldserial);
 		if (result == ISC_R_SUCCESS)
@@ -14671,11 +14655,11 @@ receive_secure_db(isc_task_t *task, isc_event_t *event) {
 		 */
 		result = save_nsec3param(zone, &nsec3list);
 		if (result != ISC_R_SUCCESS) {
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 			goto failure;
 		}
 	}
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	result = dns_db_create(zone->mctx, zone->db_argv[0],
 			       &zone->origin, dns_dbtype_zone, zone->rdclass,
@@ -14837,9 +14821,9 @@ dns_zone_replacedb(dns_zone_t *zone, dns_db_t *db, isc_boolean_t dump) {
 			goto again;
 		}
 	}
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
+	RWLOCK(&zone->dblock, isc_rwlocktype_write);
 	result = zone_replacedb(zone, db, dump);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_write);
 	if (secure != NULL)
 		UNLOCK_ZONE(secure);
 	UNLOCK_ZONE(zone);
@@ -15081,9 +15065,9 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
 		/*
 		 * Has the zone expired underneath us?
 		 */
-		ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+		RWLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (zone->db == NULL) {
-			ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+			RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 			goto same_master;
 		}

@@ -15097,7 +15081,7 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
 		result = zone_get_from_db(zone, zone->db, &nscount,
 					  &soacount, &serial, &refresh,
 					  &retry, &expire, &minimum, NULL);
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 		if (result == ISC_R_SUCCESS) {
 			if (soacount != 1)
 				dns_zone_log(zone, ISC_LOG_ERROR,
@@ -15512,9 +15496,9 @@ got_transfer_quota(isc_task_t *task, isc_event_t *event) {
 	/*
 	 * Decide whether we should request IXFR or AXFR.
 	 */
-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	loaded = ISC_TF(zone->db != NULL);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	if (!loaded) {
 		dns_zone_log(zone, ISC_LOG_DEBUG(1),
@@ -17334,10 +17318,10 @@ zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, isc_uint16_t keyid,

 	TIME_NOW(&now);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);

 	if (db == NULL) {
 		result = ISC_R_NOTFOUND;
@@ -18477,7 +18461,7 @@ dns_zone_link(dns_zone_t *zone, dns_zone_t *raw) {


 	/* dns_zone_attach(raw, &zone->raw); */
-	isc_refcount_increment(&raw->erefs, NULL);
+	isc_refcount_increment(&raw->erefs);
 	zone->raw = raw;

 	/* dns_zone_iattach(zone,  &raw->secure); */
@@ -18543,10 +18527,10 @@ keydone(isc_task_t *task, isc_event_t *event) {
 	dns_rdataset_init(&rdataset);
 	dns_diff_init(zone->mctx, &diff);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		goto failure;

@@ -18748,17 +18732,17 @@ setnsec3param(isc_task_t *task, isc_event_t *event) {
 	dns_rdataset_init(&nrdataset);
 	dns_diff_init(zone->mctx, &diff);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		goto failure;

 	dns_db_currentversion(db, &oldver);
 	result = dns_db_newversion(db, &newver);
 	if (result != ISC_R_SUCCESS) {
-		ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+		RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 		dns_zone_log(zone, ISC_LOG_ERROR,
 			     "setnsec3param:dns_db_newversion -> %s",
 			     dns_result_totext(result));
@@ -19101,10 +19085,10 @@ setserial(isc_task_t *task, isc_event_t *event) {

 	dns_diff_init(zone->mctx, &diff);

-	ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
+	RWLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (zone->db != NULL)
 		dns_db_attach(zone->db, &db);
-	ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);
+	RWUNLOCK(&zone->dblock, isc_rwlocktype_read);
 	if (db == NULL)
 		goto failure;

@@ -21,7 +21,6 @@ PROVIDER =	@PKCS11_PROVIDER@

 CINCLUDES =	-I${srcdir}/unix/include \
 		-I${srcdir}/@ISC_THREAD_DIR@/include \
-		-I${srcdir}/@ISC_ARCH_DIR@/include \
 		-I./include \
 		-I${srcdir}/include ${DNS_INCLUDES} @ISC_OPENSSL_INC@
 CDEFINES =	-DPK11_LIB_LOCATION=\"${PROVIDER}\"
@@ -58,7 +57,7 @@ OBJS =		@ISC_EXTRA_OBJS@ @ISC_PK11_O@ @ISC_PK11_RESULT_O@ \
 		md5.@O@ mem.@O@ mutexblock.@O@ \
 		netaddr.@O@ netscope.@O@ pool.@O@ \
 		parseint.@O@ portset.@O@ quota.@O@ radix.@O@ random.@O@ \
-		ratelimiter.@O@ refcount.@O@ region.@O@ regex.@O@ result.@O@ \
+		ratelimiter.@O@ region.@O@ regex.@O@ result.@O@ \
 		rwlock.@O@ \
 		safe.@O@ serial.@O@ sha1.@O@ sha2.@O@ sockaddr.@O@ stats.@O@ \
 		string.@O@ strtoul.@O@ symtab.@O@ task.@O@ taskpool.@O@ \
@@ -76,18 +75,18 @@ SRCS =		@ISC_EXTRA_SRCS@ @ISC_PK11_C@ @ISC_PK11_RESULT_C@ \
 		md5.c mem.c mutexblock.c \
 		netaddr.c netscope.c pool.c \
 		parseint.c portset.c quota.c radix.c random.c \
-		ratelimiter.c refcount.c region.c regex.c result.c rwlock.c \
+		ratelimiter.c region.c regex.c result.c rwlock.c \
 		safe.c serial.c sha1.c sha2.c sockaddr.c stats.c string.c \
 		strtoul.c symtab.c task.c taskpool.c timer.c \
 		tm.c version.c

-LIBS =		@ISC_OPENSSL_LIBS@ @LIBS@
+LIBS =		@ISC_OPENSSL_LIBS@ @ISC_ATOMIC_LIBS@ @LIBS@

 # Note: the order of SUBDIRS is important.
 # Attempt to disable parallel processing.
 .NOTPARALLEL:
 .NO_PARALLEL:
-SUBDIRS =	include unix nls @ISC_THREAD_DIR@ @ISC_ARCH_DIR@
+SUBDIRS =	include unix nls @ISC_THREAD_DIR@
 TARGETS =	timestamp
 TESTDIRS =	@UNITTESTS@

@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,178 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-/*
- * This code was written based on FreeBSD's kernel source whose copyright
- * follows:
- */
-
-/*-
- * Copyright (c) 1998 Doug Rabson
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/alpha/include/atomic.h,v 1.18.6.1 2004/09/13 21:52:04 wilko Exp $
- */
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#ifdef ISC_PLATFORM_USEOSFASM
-#include <c_asm.h>
-
-#pragma intrinsic(asm)
-
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.  Memory access ordering around this function
- * can be critical, so we add explicit memory block instructions at the
- * beginning and the end of it (same for other functions).
- */
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	return (asm("mb;"
-		    "1:"
-		    "ldl_l %t0, 0(%a0);"	/* load old value */
-		    "mov %t0, %v0;"		/* copy the old value */
-		    "addl %t0, %a1, %t0;"	/* calculate new value */
-		    "stl_c %t0, 0(%a0);"	/* attempt to store */
-		    "beq %t0, 1b;"		/* spin if failed */
-		    "mb;",
-		    p, val));
-}
-
-/*
- * This routine atomically stores the value 'val' in 'p'.
- */
-static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	(void)asm("mb;"
-		  "1:"
-		  "ldl_l %t0, 0(%a0);"		/* load old value */
-		  "mov %a1, %t0;"		/* value to store */
-		  "stl_c %t0, 0(%a0);"		/* attempt to store */
-		  "beq %t0, 1b;"		/* spin if failed */
-		  "mb;",
-		  p, val);
-}
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-
-	return(asm("mb;"
-		   "1:"
-		   "ldl_l %t0, 0(%a0);"		/* load old value */
-		   "mov %t0, %v0;"		/* copy the old value */
-		   "cmpeq %t0, %a1, %t0;"	/* compare */
-		   "beq %t0, 2f;"		/* exit if not equal */
-		   "mov %a2, %t0;"		/* value to store */
-		   "stl_c %t0, 0(%a0);"		/* attempt to store */
-		   "beq %t0, 1b;"		/* if it failed, spin */
-		   "2:"
-		   "mb;",
-		   p, cmpval, val));
-}
-#elif defined (ISC_PLATFORM_USEGCCASM)
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t temp, prev;
-
-	__asm__ volatile(
-		"mb;"
-		"1:"
-		"ldl_l %0, %1;"			/* load old value */
-		"mov %0, %2;"			/* copy the old value */
-		"addl %0, %3, %0;"		/* calculate new value */
-		"stl_c %0, %1;"			/* attempt to store */
-		"beq %0, 1b;"			/* spin if failed */
-		"mb;"
-		: "=&r"(temp), "+m"(*p), "=&r"(prev)
-		: "r"(val)
-		: "memory");
-
-	return (prev);
-}
-
-static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t temp;
-
-	__asm__ volatile(
-		"mb;"
-		"1:"
-		"ldl_l %0, %1;"			/* load old value */
-		"mov %2, %0;"			/* value to store */
-		"stl_c %0, %1;"			/* attempt to store */
-		"beq %0, 1b;"			/* if it failed, spin */
-		"mb;"
-		: "=&r"(temp), "+m"(*p)
-		: "r"(val)
-		: "memory");
-}
-
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	isc_int32_t temp, prev;
-
-	__asm__ volatile(
-		"mb;"
-		"1:"
-		"ldl_l %0, %1;"			/* load old value */
-		"mov %0, %2;"			/* copy the old value */
-		"cmpeq %0, %3, %0;"		/* compare */
-		"beq %0, 2f;"			/* exit if not equal */
-		"mov %4, %0;"			/* value to store */
-		"stl_c %0, %1;"			/* attempt to store */
-		"beq %0, 1b;"			/* if it failed, spin */
-		"2:"
-		"mb;"
-		: "=&r"(temp), "+m"(*p), "=&r"(prev)
-		: "r"(cmpval), "r"(val)
-		: "memory");
-
-	return (prev);
-}
-#else
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-
-#endif /* ISC_ATOMIC_H */
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#ifdef ISC_PLATFORM_USEGCCASM
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- *
- * Open issue: can 'fetchadd' make the code faster for some particular values
- * (e.g., 1 and -1)?
- */
-static inline isc_int32_t
-#ifdef __GNUC__
-__attribute__ ((unused))
-#endif
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val)
-{
-	isc_int32_t prev, swapped;
-
-	for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
-		swapped = prev + val;
-		__asm__ volatile(
-			"mov ar.ccv=%2;;"
-			"cmpxchg4.acq %0=%4,%3,ar.ccv"
-			: "=r" (swapped), "=m" (*p)
-			: "r" (prev), "r" (swapped), "m" (*p)
-			: "memory");
-		if (swapped == prev)
-			break;
-	}
-
-	return (prev);
-}
-
-/*
- * This routine atomically stores the value 'val' in 'p'.
- */
-static inline void
-#ifdef __GNUC__
-__attribute__ ((unused))
-#endif
-isc_atomic_store(isc_int32_t *p, isc_int32_t val)
-{
-	__asm__ volatile(
-		"st4.rel %0=%1"
-		: "=m" (*p)
-		: "r" (val)
-		: "memory"
-		);
-}
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-static inline isc_int32_t
-#ifdef __GNUC__
-__attribute__ ((unused))
-#endif
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val)
-{
-	isc_int32_t ret;
-
-	__asm__ volatile(
-		"mov ar.ccv=%2;;"
-		"cmpxchg4.acq %0=%4,%3,ar.ccv"
-		: "=r" (ret), "=m" (*p)
-		: "r" (cmpval), "r" (val), "m" (*p)
-		: "memory");
-
-	return (ret);
-}
-#else /* !ISC_PLATFORM_USEGCCASM */
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-#endif /* ISC_ATOMIC_H */
@@ -271,57 +271,6 @@
 */
@ISC_PLATFORM_HAVESYSUNH@

-/*
- * If the "xadd" operation is available on this architecture,
- * ISC_PLATFORM_HAVEXADD will be defined.
- */
-@ISC_PLATFORM_HAVEXADD@
-
-/*
- * If the "xaddq" operation (64bit xadd) is available on this architecture,
- * ISC_PLATFORM_HAVEXADDQ will be defined.
- */
-@ISC_PLATFORM_HAVEXADDQ@
-
-/*
- * If the 32-bit "atomic swap" operation is available on this
- * architecture, ISC_PLATFORM_HAVEATOMICSTORE" will be defined.
- */
-@ISC_PLATFORM_HAVEATOMICSTORE@
-
-/*
- * If the 64-bit "atomic swap" operation is available on this
- * architecture, ISC_PLATFORM_HAVEATOMICSTORE" will be defined.
- */
-@ISC_PLATFORM_HAVEATOMICSTOREQ@
-
-/*
- * If the "compare-and-exchange" operation is available on this architecture,
- * ISC_PLATFORM_HAVECMPXCHG will be defined.
- */
-@ISC_PLATFORM_HAVECMPXCHG@
-
-/*
- * If <stdatomic.h> is available on this architecture,
- * ISC_PLATFORM_HAVESTDATOMIC will be defined.
- */
-@ISC_PLATFORM_HAVESTDATOMIC@
-
-/*
- * Define if gcc ASM extension is available
- */
-@ISC_PLATFORM_USEGCCASM@
-
-/*
- * Define if Tru64 style ASM syntax must be used.
- */
-@ISC_PLATFORM_USEOSFASM@
-
-/*
- * Define if the standard __asm function must be used.
- */
-@ISC_PLATFORM_USESTDASM@
-
 /*
 * Define with the busy wait nop asm or function call.
 */
@@ -352,12 +301,6 @@
 ***	Windows dll support.
 ***/

-/*
- * Define if MacOS style of PPC assembly must be used.
- * e.g. "r6", not "6", for register six.
- */
-@ISC_PLATFORM_USEMACASM@
-
 #ifndef ISC_PLATFORM_USEDECLSPEC
 #define LIBISC_EXTERNAL_DATA
 #define LIBDNS_EXTERNAL_DATA
@@ -14,15 +14,15 @@
 #define ISC_REFCOUNT_H 1

 #include <isc/assertions.h>
-#include <isc/atomic.h>
 #include <isc/error.h>
 #include <isc/lang.h>
 #include <isc/mutex.h>
 #include <isc/platform.h>
 #include <isc/types.h>

-#if defined(ISC_PLATFORM_HAVESTDATOMIC)
+#ifdef ISC_PLATFORM_USETHREADS
 #include <stdatomic.h>
+#include <stdint.h>
 #endif

 /*! \file isc/refcount.h
@@ -93,206 +93,82 @@ ISC_LANG_BEGINDECLS
 * Sample implementations
 */
 #ifdef ISC_PLATFORM_USETHREADS
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE)) || defined(ISC_PLATFORM_HAVEXADD)
-#define ISC_REFCOUNT_HAVEATOMIC 1
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE))
-#define ISC_REFCOUNT_HAVESTDATOMIC 1
-#endif

-typedef struct isc_refcount {
-#if defined(ISC_REFCOUNT_HAVESTDATOMIC)
-	atomic_int_fast32_t refs;
-#else
-	isc_int32_t refs;
-#endif
-} isc_refcount_t;
+typedef atomic_int_fast32_t isc_refcount_t;

-#if defined(ISC_REFCOUNT_HAVESTDATOMIC)
+static inline
+isc_result_t
+isc_refcount_init(isc_refcount_t *ref, int_fast32_t n) {
+	atomic_store_explicit(ref, n, memory_order_release);
+	return (ISC_R_SUCCESS);
+}

-#define isc_refcount_current(rp)					\
-	((unsigned int)(atomic_load_explicit(&(rp)->refs,		\
-					     memory_order_relaxed)))
-#define isc_refcount_destroy(rp) ISC_REQUIRE(isc_refcount_current(rp) == 0)
+#define isc_refcount_current(ref)			\
+	atomic_load_explicit(ref, memory_order_acquire)

-#define isc_refcount_increment0(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = atomic_fetch_add_explicit		\
-			(&(rp)->refs, 1, memory_order_relaxed); \
-		if (_tmp != NULL)				\
-			*_tmp = prev + 1;			\
-	} while (0)
+static inline
+void
+isc_refcount_destroy(isc_refcount_t *ref) {
+	int_fast32_t cur = isc_refcount_current(ref);
+	ISC_REQUIRE(cur == 0);
+}

-#define isc_refcount_increment(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = atomic_fetch_add_explicit		\
-			(&(rp)->refs, 1, memory_order_relaxed); \
-		ISC_REQUIRE(prev > 0);				\
-		if (_tmp != NULL)				\
-			*_tmp = prev + 1;			\
-	} while (0)
+#define isc_refcount_increment0(ref)					\
+	atomic_fetch_add_explicit(ref, 1, memory_order_relaxed)

-#define isc_refcount_decrement(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = atomic_fetch_sub_explicit		\
-			(&(rp)->refs, 1, memory_order_relaxed); \
-		ISC_REQUIRE(prev > 0);				\
-		if (_tmp != NULL)				\
-			*_tmp = prev - 1;			\
-	} while (0)
+static inline int_fast32_t isc_refcount_increment(isc_refcount_t *ref) {
+	int_fast32_t prev = atomic_fetch_add_explicit(ref, 1,
+							memory_order_relaxed);
+	ISC_REQUIRE(prev > 0);
+	return (prev);
+}

-#else /* ISC_REFCOUNT_HAVESTDATOMIC */
+static inline int_fast32_t isc_refcount_decrement(isc_refcount_t *ref) {
+	int_fast32_t prev = atomic_fetch_sub_explicit(ref, 1,
+							memory_order_release);
+	ISC_REQUIRE(prev > 0);
+	return (prev);
+}

-#define isc_refcount_current(rp)				\
-	((unsigned int)(isc_atomic_xadd(&(rp)->refs, 0)))
-#define isc_refcount_destroy(rp) ISC_REQUIRE(isc_refcount_current(rp) == 0)
-
-#define isc_refcount_increment0(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = isc_atomic_xadd(&(rp)->refs, 1);		\
-		if (_tmp != NULL)				\
-			*_tmp = prev + 1;			\
-	} while (0)
-
-#define isc_refcount_increment(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = isc_atomic_xadd(&(rp)->refs, 1);		\
-		ISC_REQUIRE(prev > 0);				\
-		if (_tmp != NULL)				\
-			*_tmp = prev + 1;			\
-	} while (0)
-
-#define isc_refcount_decrement(rp, tp)				\
-	do {							\
-		unsigned int *_tmp = (unsigned int *)(tp);	\
-		isc_int32_t prev;				\
-		prev = isc_atomic_xadd(&(rp)->refs, -1);	\
-		ISC_REQUIRE(prev > 0);				\
-		if (_tmp != NULL)				\
-			*_tmp = prev - 1;			\
-	} while (0)
-
-#endif /* ISC_REFCOUNT_HAVESTDATOMIC */
-
-#else  /* ISC_PLATFORM_HAVEXADD */
-
-typedef struct isc_refcount {
-	int refs;
-	isc_mutex_t lock;
-} isc_refcount_t;
-
-/*% Destroys a reference counter. */
-#define isc_refcount_destroy(rp)					\
-	do {								\
-		isc_result_t _result;					\
-		ISC_REQUIRE((rp)->refs == 0);				\
-		_result = isc_mutex_destroy(&(rp)->lock);		\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-	} while (0)
-
-#define isc_refcount_current(rp) ((unsigned int)((rp)->refs))
-
-/*%
- * Increments the reference count, returning the new value in
- * 'tp' if it's not NULL.
- */
-#define isc_refcount_increment0(rp, tp)					\
-	do {								\
-		isc_result_t _result;					\
-		unsigned int *_tmp = (unsigned int *)(tp);		\
-		_result = isc_mutex_lock(&(rp)->lock);			\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-		++((rp)->refs);						\
-		if (_tmp != NULL)					\
-			*_tmp = ((rp)->refs);				\
-		_result = isc_mutex_unlock(&(rp)->lock);		\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-	} while (0)
-
-#define isc_refcount_increment(rp, tp)					\
-	do {								\
-		isc_result_t _result;					\
-		unsigned int *_tmp = (unsigned int *)(tp);		\
-		_result = isc_mutex_lock(&(rp)->lock);			\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-		ISC_REQUIRE((rp)->refs > 0);				\
-		++((rp)->refs);						\
-		if (_tmp != NULL)					\
-			*_tmp = ((rp)->refs);				\
-		_result = isc_mutex_unlock(&(rp)->lock);		\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-	} while (0)
-
-/*%
- * Decrements the reference count, returning the new value in 'tp'
- * if it's not NULL.
- */
-#define isc_refcount_decrement(rp, tp)					\
-	do {								\
-		isc_result_t _result;					\
-		unsigned int *_tmp = (unsigned int *)(tp);		\
-		_result = isc_mutex_lock(&(rp)->lock);			\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-		ISC_REQUIRE((rp)->refs > 0);				\
-		--((rp)->refs);						\
-		if (_tmp != NULL)					\
-			*_tmp = ((rp)->refs);				\
-		_result = isc_mutex_unlock(&(rp)->lock);		\
-		ISC_ERROR_RUNTIMECHECK(_result == ISC_R_SUCCESS);	\
-	} while (0)
-
-#endif /* (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE)) || defined(ISC_PLATFORM_HAVEXADD) */
 #else  /* ISC_PLATFORM_USETHREADS */

-typedef struct isc_refcount {
-	int refs;
-} isc_refcount_t;

-#define isc_refcount_destroy(rp) ISC_REQUIRE((rp)->refs == 0)
-#define isc_refcount_current(rp) ((unsigned int)((rp)->refs))
+typedef isc_int32_t isc_refcount_t

-#define isc_refcount_increment0(rp, tp)					\
+static inline
+isc_result_t
+isc_refcount_init(isc_refcount_t *ref, isc_refcount_t n) {
+	ISC_REQUIRE(ref);
+	*ref = n;
+	return (ISC_R_SUCCESS);
+}
+
+#define isc_refcount_destroy(ref) ISC_REQUIRE(ref == 0)
+#define isc_refcount_current(ref) ((unsigned int)(ref)
+
+#define isc_refcount_increment0(ref)					\
 	do {								\
-		unsigned int *_tmp = (unsigned int *)(tp);		\
-		int _n = ++(rp)->refs;					\
-		if (_tmp != NULL)					\
-			*_tmp = _n;					\
+		++ref;							\
 	} while (0)

-#define isc_refcount_increment(rp, tp)					\
+#define isc_refcount_increment(ref)					\
+	do {								\
+		ISC_REQUIRE(ref > 0);					\
+		++ref;							\
+	} while (0)
+
+#define isc_refcount_decrement(ref, tp)					\
 	do {								\
 		unsigned int *_tmp = (unsigned int *)(tp);		\
 		int _n;							\
-		ISC_REQUIRE((rp)->refs > 0);				\
-		_n = ++(rp)->refs;					\
-		if (_tmp != NULL)					\
-			*_tmp = _n;					\
-	} while (0)
-
-#define isc_refcount_decrement(rp, tp)					\
-	do {								\
-		unsigned int *_tmp = (unsigned int *)(tp);		\
-		int _n;							\
-		ISC_REQUIRE((rp)->refs > 0);				\
-		_n = --(rp)->refs;					\
+		ISC_REQUIRE((ref) > 0);					\
+		_n = --ref;						\
 		if (_tmp != NULL)					\
 			*_tmp = _n;					\
 	} while (0)

 #endif /* ISC_PLATFORM_USETHREADS */

-isc_result_t
-isc_refcount_init(isc_refcount_t *ref, unsigned int n);
-
 ISC_LANG_ENDDECLS

 #endif /* ISC_REFCOUNT_H */
@@ -15,13 +15,14 @@

 /*! \file isc/rwlock.h */

+#include <stdint.h>
+
 #include <isc/condition.h>
 #include <isc/lang.h>
 #include <isc/platform.h>
 #include <isc/types.h>

-#if defined(ISC_PLATFORM_HAVESTDATOMIC)
-#include <stdint.h>
+#ifdef ISC_PLATFORM_USETHREADS
 #include <stdatomic.h>
 #endif

@@ -34,12 +35,6 @@ typedef enum {
 } isc_rwlocktype_t;

 #ifdef ISC_PLATFORM_USETHREADS
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE)) || (defined(ISC_PLATFORM_HAVEXADD) && defined(ISC_PLATFORM_HAVECMPXCHG))
-#define ISC_RWLOCK_USEATOMIC 1
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE))
-#define ISC_RWLOCK_USESTDATOMIC 1
-#endif
-#endif

 struct isc_rwlock {
 	/* Unlocked. */
@@ -47,7 +42,6 @@ struct isc_rwlock {
 	isc_mutex_t		lock;
 	isc_int32_t		spins;

-#if defined(ISC_RWLOCK_USEATOMIC)
 	/*
 	 * When some atomic instructions with hardware assistance are
 	 * available, rwlock will use those so that concurrent readers do not
@@ -62,15 +56,9 @@ struct isc_rwlock {
 	 */

 	/* Read or modified atomically. */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 	atomic_int_fast32_t	write_requests;
 	atomic_int_fast32_t	write_completions;
 	atomic_int_fast32_t	cnt_and_flag;
-#else
-	isc_int32_t		write_requests;
-	isc_int32_t		write_completions;
-	isc_int32_t		cnt_and_flag;
-#endif

 	/* Locked by lock. */
 	isc_condition_t		readable;
@@ -82,30 +70,6 @@ struct isc_rwlock {

 	/* Unlocked. */
 	unsigned int		write_quota;
-
-#else  /* ISC_RWLOCK_USEATOMIC */
-
-	/*%< Locked by lock. */
-	isc_condition_t		readable;
-	isc_condition_t		writeable;
-	isc_rwlocktype_t	type;
-
-	/*% The number of threads that have the lock. */
-	unsigned int		active;
-
-	/*%
-	 * The number of lock grants made since the lock was last switched
-	 * from reading to writing or vice versa; used in determining
-	 * when the quota is reached and it is time to switch.
-	 */
-	unsigned int		granted;
-
-	unsigned int		readers_waiting;
-	unsigned int		writers_waiting;
-	unsigned int		read_quota;
-	unsigned int		write_quota;
-	isc_rwlocktype_t	original;
-#endif  /* ISC_RWLOCK_USEATOMIC */
 };
 #else /* ISC_PLATFORM_USETHREADS */
 struct isc_rwlock {
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#ifdef ISC_PLATFORM_USEGCCASM
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- */
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, int val) {
-	isc_int32_t orig;
-
-	__asm__ __volatile__ (
-	"	.set	push		\n"
-	"	.set	mips2		\n"
-	"	.set	noreorder	\n"
-	"	.set	noat		\n"
-	"1:	ll	$1, %1		\n"
-	"	addu	%0, $1, %2	\n"
-	"	sc	%0, %1		\n"
-	"	beqz	%0, 1b		\n"
-	"	move	%0, $1		\n"
-	"	.set	pop		\n"
-	: "=&r" (orig), "+R" (*p)
-	: "r" (val)
-	: "memory");
-
-	return (orig);
-}
-
-/*
- * This routine atomically stores the value 'val' in 'p'.
- */
-static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	*p = val;
-}
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, int cmpval, int val) {
-	isc_int32_t orig;
-	isc_int32_t tmp;
-
-	__asm__ __volatile__ (
-	"	.set	push		\n"
-	"	.set	mips2		\n"
-	"	.set	noreorder	\n"
-	"	.set	noat		\n"
-	"1:	ll	$1, %1		\n"
-	"	bne	$1, %3, 2f	\n"
-	"	move	%2, %4		\n"
-	"	sc	%2, %1		\n"
-	"	beqz	%2, 1b		\n"
-	"2:	move	%0, $1		\n"
-	"	.set	pop		\n"
-	: "=&r"(orig), "+R" (*p), "=r" (tmp)
-	: "r"(cmpval), "r"(val)
-	: "memory");
-
-	return (orig);
-}
-
-#else /* !ISC_PLATFORM_USEGCCASM */
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-#endif /* ISC_ATOMIC_H */
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,18 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-/* This file is inherently empty. */
-
-#endif /* ISC_ATOMIC_H */
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,191 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-/*!\file
- * static inline isc_int32_t
- * isc_atomic_xadd(isc_int32_t *p, isc_int32_t val);
- *
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- *
- * static inline void
- * isc_atomic_store(void *p, isc_int32_t val);
- *
- * This routine atomically stores the value 'val' in 'p'.
- *
- * static inline isc_int32_t
- * isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val);
- *
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-
-#if defined(_AIX)
-
-#include <sys/atomic_op.h>
-
-#define isc_atomic_store(p, v) _clear_lock(p, v)
-
-#ifdef __GNUC__
-static inline isc_int32_t
-#else
-static isc_int32_t
-#endif
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	int ret;
-
-#ifdef __GNUC__
-	asm("ics");
-#else
-	 __isync();
-#endif
-
-	ret = fetch_and_add((atomic_p)p, (int)val);
-
-#ifdef __GNUC__
-	asm("ics");
-#else
-	 __isync();
-#endif
-
-	 return (ret);
-}
-
-#ifdef __GNUC__
-static inline int
-#else
-static int
-#endif
-isc_atomic_cmpxchg(atomic_p p, int old, int replacement) {
-	int orig = old;
-
-#ifdef __GNUC__
-	asm("ics");
-#else
-	 __isync();
-#endif
-	if (compare_and_swap(p, &orig, replacement))
-		orig = old;
-
-#ifdef __GNUC__
-	asm("ics");
-#else
-	 __isync();
-#endif
-
-	return (orig);
-}
-
-#elif defined(ISC_PLATFORM_USEGCCASM) || defined(ISC_PLATFORM_USEMACASM)
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t orig;
-
-	__asm__ volatile (
-#ifdef ISC_PLATFORM_USEMACASM
-		"1:"
-		"lwarx r6, 0, %1\n"
-		"mr %0, r6\n"
-		"add r6, r6, %2\n"
-		"stwcx. r6, 0, %1\n"
-		"bne- 1b\n"
-		"sync"
-#else
-		"1:"
-		"lwarx 6, 0, %1\n"
-		"mr %0, 6\n"
-		"add 6, 6, %2\n"
-		"stwcx. 6, 0, %1\n"
-		"bne- 1b\n"
-		"sync"
-#endif
-		: "=&r"(orig)
-		: "r"(p), "r"(val)
-		: "r6", "memory"
-		);
-
-	return (orig);
-}
-
-static inline void
-isc_atomic_store(void *p, isc_int32_t val) {
-	__asm__ volatile (
-#ifdef ISC_PLATFORM_USEMACASM
-		"1:"
-		"lwarx r6, 0, %0\n"
-		"lwz r6, %1\n"
-		"stwcx. r6, 0, %0\n"
-		"bne- 1b\n"
-		"sync"
-#else
-		"1:"
-		"lwarx 6, 0, %0\n"
-		"lwz 6, %1\n"
-		"stwcx. 6, 0, %0\n"
-		"bne- 1b\n"
-		"sync"
-#endif
-		:
-		: "r"(p), "m"(val)
-		: "r6", "memory"
-		);
-}
-
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	isc_int32_t orig;
-
-	__asm__ volatile (
-#ifdef ISC_PLATFORM_USEMACASM
-		"1:"
-		"lwarx r6, 0, %1\n"
-		"mr %0,r6\n"
-		"cmpw r6, %2\n"
-		"bne 2f\n"
-		"mr r6, %3\n"
-		"stwcx. r6, 0, %1\n"
-		"bne- 1b\n"
-		"2:\n"
-		"sync"
-#else
-		"1:"
-		"lwarx 6, 0, %1\n"
-		"mr %0,6\n"
-		"cmpw 6, %2\n"
-		"bne 2f\n"
-		"mr 6, %3\n"
-		"stwcx. 6, 0, %1\n"
-		"bne- 1b\n"
-		"2:\n"
-		"sync"
-#endif
-		: "=&r" (orig)
-		: "r"(p), "r"(cmpval), "r"(val)
-		: "r6", "memory"
-		);
-
-	return (orig);
-}
-
-#else
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-#endif /* ISC_ATOMIC_H */
@@ -76,14 +76,14 @@ _new_prefix(isc_mem_t *mctx, isc_prefix_t **target, int family, void *dest,

 static void
 _deref_prefix(isc_prefix_t *prefix) {
-	int refs;
+	int_fast32_t refs;

 	if (prefix == NULL)
 		return;

-	isc_refcount_decrement(&prefix->refcount, &refs);
+	refs = isc_refcount_decrement(&prefix->refcount);

-	if (refs <= 0) {
+	if (refs == 1) {
 		isc_refcount_destroy(&prefix->refcount);
 		isc_mem_putanddetach(&prefix->mctx, prefix,
 				     sizeof(isc_prefix_t));
@@ -110,7 +110,7 @@ _ref_prefix(isc_mem_t *mctx, isc_prefix_t **target, isc_prefix_t *prefix) {
 		return (ret);
 	}

-	isc_refcount_increment(&prefix->refcount, NULL);
+	isc_refcount_increment(&prefix->refcount);

 	*target = prefix;
 	return (ISC_R_SUCCESS);
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#include <config.h>
-
-#include <stddef.h>
-
-#include <isc/mutex.h>
-#include <isc/refcount.h>
-#include <isc/result.h>
-#include <isc/util.h>
-
-isc_result_t
-isc_refcount_init(isc_refcount_t *ref, unsigned int n) {
-	REQUIRE(ref != NULL);
-
-	ref->refs = n;
-#if defined(ISC_PLATFORM_USETHREADS) && !defined(ISC_REFCOUNT_HAVEATOMIC)
-	return (isc_mutex_init(&ref->lock));
-#else
-	return (ISC_R_SUCCESS);
-#endif
-}
@@ -16,7 +16,6 @@

 #include <stddef.h>

-#include <isc/atomic.h>
 #include <isc/magic.h>
 #include <isc/msgs.h>
 #include <isc/platform.h>
@@ -41,10 +40,8 @@
 #define RWLOCK_MAX_ADAPTIVE_COUNT 100
 #endif

-#if defined(ISC_RWLOCK_USEATOMIC)
 static isc_result_t
 isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);
-#endif

 #ifdef ISC_RWLOCK_TRACE
 #include <stdio.h>		/* Required for fprintf/stderr. */
@@ -52,7 +49,6 @@ isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type);

 static void
 print_lock(const char *operation, isc_rwlock_t *rwl, isc_rwlocktype_t type) {
-#if defined(ISC_RWLOCK_USEATOMIC)
 	fprintf(stderr,
 		isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
 			       ISC_MSG_PRINTLOCK2,
@@ -69,26 +65,6 @@ print_lock(const char *operation, isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 		rwl->write_requests, rwl->write_completions,
 		rwl->cnt_and_flag, rwl->readers_waiting,
 		rwl->write_granted, rwl->write_quota);
-#else
-	fprintf(stderr,
-		isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-			       ISC_MSG_PRINTLOCK,
-			       "rwlock %p thread %lu %s(%s): %s, %u active, "
-			       "%u granted, %u rwaiting, %u wwaiting\n"),
-		rwl, isc_thread_self(), operation,
-		(type == isc_rwlocktype_read ?
-		 isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				ISC_MSG_READ, "read") :
-		 isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				ISC_MSG_WRITE, "write")),
-		(rwl->type == isc_rwlocktype_read ?
-		 isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				ISC_MSG_READING, "reading") :
-		 isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				ISC_MSG_WRITING, "writing")),
-		rwl->active, rwl->granted,
-		rwl->readers_waiting, rwl->writers_waiting);
-#endif
 }
 #endif /* ISC_RWLOCK_TRACE */

@@ -107,7 +83,6 @@ isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
 	rwl->magic = 0;

 	rwl->spins = 0;
-#if defined(ISC_RWLOCK_USEATOMIC)
 	rwl->write_requests = 0;
 	rwl->write_completions = 0;
 	rwl->cnt_and_flag = 0;
@@ -120,20 +95,6 @@ isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
 	if (write_quota == 0)
 		write_quota = RWLOCK_DEFAULT_WRITE_QUOTA;
 	rwl->write_quota = write_quota;
-#else
-	rwl->type = isc_rwlocktype_read;
-	rwl->original = isc_rwlocktype_none;
-	rwl->active = 0;
-	rwl->granted = 0;
-	rwl->readers_waiting = 0;
-	rwl->writers_waiting = 0;
-	if (read_quota == 0)
-		read_quota = RWLOCK_DEFAULT_READ_QUOTA;
-	rwl->read_quota = read_quota;
-	if (write_quota == 0)
-		write_quota = RWLOCK_DEFAULT_WRITE_QUOTA;
-	rwl->write_quota = write_quota;
-#endif

 	result = isc_mutex_init(&rwl->lock);
 	if (result != ISC_R_SUCCESS)
@@ -176,16 +137,8 @@ void
 isc_rwlock_destroy(isc_rwlock_t *rwl) {
 	REQUIRE(VALID_RWLOCK(rwl));

-#if defined(ISC_RWLOCK_USEATOMIC)
 	REQUIRE(rwl->write_requests == rwl->write_completions &&
 		rwl->cnt_and_flag == 0 && rwl->readers_waiting == 0);
-#else
-	LOCK(&rwl->lock);
-	REQUIRE(rwl->active == 0 &&
-		rwl->readers_waiting == 0 &&
-		rwl->writers_waiting == 0);
-	UNLOCK(&rwl->lock);
-#endif

 	rwl->magic = 0;
 	(void)isc_condition_destroy(&rwl->readable);
@@ -193,8 +146,6 @@ isc_rwlock_destroy(isc_rwlock_t *rwl) {
 	DESTROYLOCK(&rwl->lock);
 }

-#if defined(ISC_RWLOCK_USEATOMIC)
-
 /*
 * When some architecture-dependent atomic operations are available,
 * rwlock can be more efficient than the generic algorithm defined below.
@@ -283,13 +234,9 @@ isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 			UNLOCK(&rwl->lock);
 		}

-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		cntflag = atomic_fetch_add_explicit(&rwl->cnt_and_flag,
 						    READER_INCR,
 						    memory_order_relaxed);
-#else
-		cntflag = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
-#endif
 		POST(cntflag);
 		while (1) {
 			if ((rwl->cnt_and_flag & WRITER_ACTIVE) == 0)
@@ -339,12 +286,8 @@ isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 		isc_int32_t prev_writer;

 		/* enter the waiting queue, and wait for our turn */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		prev_writer = atomic_fetch_add_explicit(&rwl->write_requests, 1,
 							memory_order_relaxed);
-#else
-		prev_writer = isc_atomic_xadd(&rwl->write_requests, 1);
-#endif
 		while (rwl->write_completions != prev_writer) {
 			LOCK(&rwl->lock);
 			if (rwl->write_completions != prev_writer) {
@@ -357,16 +300,10 @@ isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 		}

 		while (1) {
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 			int_fast32_t cntflag2 = 0;
 			atomic_compare_exchange_strong_explicit
 				(&rwl->cnt_and_flag, &cntflag2, WRITER_ACTIVE,
 				 memory_order_relaxed, memory_order_relaxed);
-#else
-			isc_int32_t cntflag2;
-			cntflag2 = isc_atomic_cmpxchg(&rwl->cnt_and_flag, 0,
-						      WRITER_ACTIVE);
-#endif

 			if (cntflag2 == 0)
 				break;
@@ -431,26 +368,17 @@ isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 			return (ISC_R_LOCKBUSY);

 		/* Otherwise, be ready for reading. */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		cntflag = atomic_fetch_add_explicit(&rwl->cnt_and_flag,
 						    READER_INCR,
 						    memory_order_relaxed);
-#else
-		cntflag = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
-#endif
 		if ((cntflag & WRITER_ACTIVE) != 0) {
 			/*
 			 * A writer is working.  We lose, and cancel the read
 			 * request.
 			 */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 			cntflag = atomic_fetch_sub_explicit
 				(&rwl->cnt_and_flag, READER_INCR,
 				 memory_order_relaxed);
-#else
-			cntflag = isc_atomic_xadd(&rwl->cnt_and_flag,
-						  -READER_INCR);
-#endif
 			/*
 			 * If no other readers are waiting and we've suspended
 			 * new writers in this short period, wake them up.
@@ -466,29 +394,18 @@ isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 		}
 	} else {
 		/* Try locking without entering the waiting queue. */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		int_fast32_t zero = 0;
 		if (!atomic_compare_exchange_strong_explicit
 		    (&rwl->cnt_and_flag, &zero, WRITER_ACTIVE,
 		     memory_order_relaxed, memory_order_relaxed))
 			return (ISC_R_LOCKBUSY);
-#else
-		cntflag = isc_atomic_cmpxchg(&rwl->cnt_and_flag, 0,
-					     WRITER_ACTIVE);
-		if (cntflag != 0)
-			return (ISC_R_LOCKBUSY);
-#endif

 		/*
 		 * XXXJT: jump into the queue, possibly breaking the writer
 		 * order.
 		 */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		atomic_fetch_sub_explicit(&rwl->write_completions, 1,
 					  memory_order_relaxed);
-#else
-		(void)isc_atomic_xadd(&rwl->write_completions, -1);
-#endif

 		rwl->write_granted++;
 	}
@@ -505,7 +422,6 @@ isc_result_t
 isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
 	REQUIRE(VALID_RWLOCK(rwl));

-#if defined(ISC_RWLOCK_USESTDATOMIC)
 	{
 		int_fast32_t reader_incr = READER_INCR;

@@ -531,30 +447,6 @@ isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
 			return (ISC_R_LOCKBUSY);

 	}
-#else
-	{
-		isc_int32_t prevcnt;
-
-		/* Try to acquire write access. */
-		prevcnt = isc_atomic_cmpxchg(&rwl->cnt_and_flag,
-					     READER_INCR, WRITER_ACTIVE);
-		/*
-		 * There must have been no writer, and there must have
-		 * been at least one reader.
-		 */
-		INSIST((prevcnt & WRITER_ACTIVE) == 0 &&
-		       (prevcnt & ~WRITER_ACTIVE) != 0);
-
-		if (prevcnt == READER_INCR) {
-			/*
-			 * We are the only reader and have been upgraded.
-			 * Now jump into the head of the writer waiting queue.
-			 */
-			(void)isc_atomic_xadd(&rwl->write_completions, -1);
-		} else
-			return (ISC_R_LOCKBUSY);
-	}
-#endif

 	return (ISC_R_SUCCESS);
 }
@@ -565,7 +457,6 @@ isc_rwlock_downgrade(isc_rwlock_t *rwl) {

 	REQUIRE(VALID_RWLOCK(rwl));

-#if defined(ISC_RWLOCK_USESTDATOMIC)
 	{
 		/* Become an active reader. */
 		prev_readers = atomic_fetch_add_explicit(&rwl->cnt_and_flag,
@@ -580,18 +471,6 @@ isc_rwlock_downgrade(isc_rwlock_t *rwl) {
 		atomic_fetch_add_explicit(&rwl->write_completions, 1,
 					  memory_order_relaxed);
 	}
-#else
-	{
-		/* Become an active reader. */
-		prev_readers = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);
-		/* We must have been a writer. */
-		INSIST((prev_readers & WRITER_ACTIVE) != 0);
-
-		/* Complete write */
-		(void)isc_atomic_xadd(&rwl->cnt_and_flag, -WRITER_ACTIVE);
-		(void)isc_atomic_xadd(&rwl->write_completions, 1);
-	}
-#endif

 	/* Resume other readers */
 	LOCK(&rwl->lock);
@@ -612,13 +491,9 @@ isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 #endif

 	if (type == isc_rwlocktype_read) {
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		prev_cnt = atomic_fetch_sub_explicit(&rwl->cnt_and_flag,
 						     READER_INCR,
 						     memory_order_relaxed);
-#else
-		prev_cnt = isc_atomic_xadd(&rwl->cnt_and_flag, -READER_INCR);
-#endif
 		/*
 		 * If we're the last reader and any writers are waiting, wake
 		 * them up.  We need to wake up all of them to ensure the
@@ -637,15 +512,10 @@ isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 		 * Reset the flag, and (implicitly) tell other writers
 		 * we are done.
 		 */
-#if defined(ISC_RWLOCK_USESTDATOMIC)
 		atomic_fetch_sub_explicit(&rwl->cnt_and_flag, WRITER_ACTIVE,
 					  memory_order_relaxed);
 		atomic_fetch_add_explicit(&rwl->write_completions, 1,
 					  memory_order_relaxed);
-#else
-		(void)isc_atomic_xadd(&rwl->cnt_and_flag, -WRITER_ACTIVE);
-		(void)isc_atomic_xadd(&rwl->write_completions, 1);
-#endif

 		if (rwl->write_granted >= rwl->write_quota ||
 		    rwl->write_requests == rwl->write_completions ||
@@ -683,213 +553,6 @@ isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 	return (ISC_R_SUCCESS);
 }

-#else /* ISC_RWLOCK_USEATOMIC */
-
-static isc_result_t
-doit(isc_rwlock_t *rwl, isc_rwlocktype_t type, isc_boolean_t nonblock) {
-	isc_boolean_t skip = ISC_FALSE;
-	isc_boolean_t done = ISC_FALSE;
-	isc_result_t result = ISC_R_SUCCESS;
-
-	REQUIRE(VALID_RWLOCK(rwl));
-
-	LOCK(&rwl->lock);
-
-#ifdef ISC_RWLOCK_TRACE
-	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				  ISC_MSG_PRELOCK, "prelock"), rwl, type);
-#endif
-
-	if (type == isc_rwlocktype_read) {
-		if (rwl->readers_waiting != 0)
-			skip = ISC_TRUE;
-		while (!done) {
-			if (!skip &&
-			    ((rwl->active == 0 ||
-			      (rwl->type == isc_rwlocktype_read &&
-			       (rwl->writers_waiting == 0 ||
-				rwl->granted < rwl->read_quota)))))
-			{
-				rwl->type = isc_rwlocktype_read;
-				rwl->active++;
-				rwl->granted++;
-				done = ISC_TRUE;
-			} else if (nonblock) {
-				result = ISC_R_LOCKBUSY;
-				done = ISC_TRUE;
-			} else {
-				skip = ISC_FALSE;
-				rwl->readers_waiting++;
-				WAIT(&rwl->readable, &rwl->lock);
-				rwl->readers_waiting--;
-			}
-		}
-	} else {
-		if (rwl->writers_waiting != 0)
-			skip = ISC_TRUE;
-		while (!done) {
-			if (!skip && rwl->active == 0) {
-				rwl->type = isc_rwlocktype_write;
-				rwl->active = 1;
-				rwl->granted++;
-				done = ISC_TRUE;
-			} else if (nonblock) {
-				result = ISC_R_LOCKBUSY;
-				done = ISC_TRUE;
-			} else {
-				skip = ISC_FALSE;
-				rwl->writers_waiting++;
-				WAIT(&rwl->writeable, &rwl->lock);
-				rwl->writers_waiting--;
-			}
-		}
-	}
-
-#ifdef ISC_RWLOCK_TRACE
-	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				  ISC_MSG_POSTLOCK, "postlock"), rwl, type);
-#endif
-
-	UNLOCK(&rwl->lock);
-
-	return (result);
-}
-
-isc_result_t
-isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
-	isc_int32_t cnt = 0;
-	isc_int32_t max_cnt = rwl->spins * 2 + 10;
-	isc_result_t result = ISC_R_SUCCESS;
-
-	if (max_cnt > RWLOCK_MAX_ADAPTIVE_COUNT)
-		max_cnt = RWLOCK_MAX_ADAPTIVE_COUNT;
-
-	do {
-		if (cnt++ >= max_cnt) {
-			result = doit(rwl, type, ISC_FALSE);
-			break;
-		}
-#ifdef ISC_PLATFORM_BUSYWAITNOP
-		ISC_PLATFORM_BUSYWAITNOP;
-#endif
-	} while (doit(rwl, type, ISC_TRUE) != ISC_R_SUCCESS);
-
-	rwl->spins += (cnt - rwl->spins) / 8;
-
-	return (result);
-}
-
-isc_result_t
-isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
-	return (doit(rwl, type, ISC_TRUE));
-}
-
-isc_result_t
-isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
-	isc_result_t result = ISC_R_SUCCESS;
-
-	REQUIRE(VALID_RWLOCK(rwl));
-	LOCK(&rwl->lock);
-	REQUIRE(rwl->type == isc_rwlocktype_read);
-	REQUIRE(rwl->active != 0);
-
-	/* If we are the only reader then succeed. */
-	if (rwl->active == 1) {
-		rwl->original = (rwl->original == isc_rwlocktype_none) ?
-				isc_rwlocktype_read : isc_rwlocktype_none;
-		rwl->type = isc_rwlocktype_write;
-	} else
-		result = ISC_R_LOCKBUSY;
-
-	UNLOCK(&rwl->lock);
-	return (result);
-}
-
-void
-isc_rwlock_downgrade(isc_rwlock_t *rwl) {
-
-	REQUIRE(VALID_RWLOCK(rwl));
-	LOCK(&rwl->lock);
-	REQUIRE(rwl->type == isc_rwlocktype_write);
-	REQUIRE(rwl->active == 1);
-
-	rwl->type = isc_rwlocktype_read;
-	rwl->original = (rwl->original == isc_rwlocktype_none) ?
-			isc_rwlocktype_write : isc_rwlocktype_none;
-	/*
-	 * Resume processing any read request that were blocked when
-	 * we upgraded.
-	 */
-	if (rwl->original == isc_rwlocktype_none &&
-	    (rwl->writers_waiting == 0 || rwl->granted < rwl->read_quota) &&
-	    rwl->readers_waiting > 0)
-		BROADCAST(&rwl->readable);
-
-	UNLOCK(&rwl->lock);
-}
-
-isc_result_t
-isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
-
-	REQUIRE(VALID_RWLOCK(rwl));
-	LOCK(&rwl->lock);
-	REQUIRE(rwl->type == type);
-
-	UNUSED(type);
-
-#ifdef ISC_RWLOCK_TRACE
-	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				  ISC_MSG_PREUNLOCK, "preunlock"), rwl, type);
-#endif
-
-	INSIST(rwl->active > 0);
-	rwl->active--;
-	if (rwl->active == 0) {
-		if (rwl->original != isc_rwlocktype_none) {
-			rwl->type = rwl->original;
-			rwl->original = isc_rwlocktype_none;
-		}
-		if (rwl->type == isc_rwlocktype_read) {
-			rwl->granted = 0;
-			if (rwl->writers_waiting > 0) {
-				rwl->type = isc_rwlocktype_write;
-				SIGNAL(&rwl->writeable);
-			} else if (rwl->readers_waiting > 0) {
-				/* Does this case ever happen? */
-				BROADCAST(&rwl->readable);
-			}
-		} else {
-			if (rwl->readers_waiting > 0) {
-				if (rwl->writers_waiting > 0 &&
-				    rwl->granted < rwl->write_quota) {
-					SIGNAL(&rwl->writeable);
-				} else {
-					rwl->granted = 0;
-					rwl->type = isc_rwlocktype_read;
-					BROADCAST(&rwl->readable);
-				}
-			} else if (rwl->writers_waiting > 0) {
-				rwl->granted = 0;
-				SIGNAL(&rwl->writeable);
-			} else {
-				rwl->granted = 0;
-			}
-		}
-	}
-	INSIST(rwl->original == isc_rwlocktype_none);
-
-#ifdef ISC_RWLOCK_TRACE
-	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,
-				  ISC_MSG_POSTUNLOCK, "postunlock"),
-		   rwl, type);
-#endif
-
-	UNLOCK(&rwl->lock);
-
-	return (ISC_R_SUCCESS);
-}
-
-#endif /* ISC_RWLOCK_USEATOMIC */
 #else /* ISC_PLATFORM_USETHREADS */

 isc_result_t
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,29 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
@@ -1,120 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-/*
- * This code was written based on FreeBSD's kernel source whose copyright
- * follows:
- */
-
-/*-
- * Copyright (c) 1998 Doug Rabson.
- * Copyright (c) 2001 Jake Burkholder.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	from: FreeBSD: src/sys/i386/include/atomic.h,v 1.20 2001/02/11
- * $FreeBSD: src/sys/sparc64/include/atomic.h,v 1.8 2004/05/22 00:52:16 marius Exp $
- */
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#define	ASI_P	0x80		/* Primary Address Space Identifier */
-
-#ifdef ISC_PLATFORM_USEGCCASM
-
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- */
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t prev, swapped;
-
-	for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
-		swapped = prev + val;
-		__asm__ volatile(
-			"casa [%2] %3, %4, %0"
-			: "+r"(swapped), "=m"(*p)
-			: "r"(p), "n"(ASI_P), "r"(prev), "m"(*p));
-		if (swapped == prev)
-			break;
-	}
-
-	return (prev);
-}
-
-/*
- * This routine atomically stores the value 'val' in 'p'.
- */
-static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t prev, swapped;
-
-	for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
-		swapped = val;
-		__asm__ volatile(
-			"casa [%2] %3, %4, %0"
-			: "+r"(swapped), "=m"(*p)
-			: "r"(p), "n"(ASI_P), "r"(prev), "m"(*p));
-		if (swapped == prev)
-			break;
-	}
-}
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	isc_int32_t temp = val;
-
-	__asm__ volatile(
-		"casa [%2] %3, %4, %0"
-		: "+r"(temp), "=m"(*p)
-		: "r"(p), "n"(ASI_P), "r"(cmpval), "m"(*p));
-
-	return (temp);
-}
-
-#else  /* ISC_PLATFORM_USEGCCASM */
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif /* ISC_PLATFORM_USEGCCASM */
-
-#endif /* ISC_ATOMIC_H */
@@ -16,17 +16,17 @@

 #include <string.h>

-#include <isc/atomic.h>
 #include <isc/buffer.h>
 #include <isc/magic.h>
 #include <isc/mem.h>
 #include <isc/platform.h>
 #include <isc/print.h>
+#include <isc/refcount.h>
 #include <isc/rwlock.h>
 #include <isc/stats.h>
 #include <isc/util.h>

-#if defined(ISC_PLATFORM_HAVESTDATOMIC)
+#ifdef ISC_PLATFORM_USETHREADS
 #include <stdatomic.h>
 #endif

@@ -34,68 +34,16 @@
 #define ISC_STATS_VALID(x)		ISC_MAGIC_VALID(x, ISC_STATS_MAGIC)

 /*%
- * Local macro confirming prescence of 64-bit
- * increment and store operations, just to make
- * the later macros simpler
+ * `ISC_STATS_LOCKCOUNTERS` indicates if the complete set of statistics
+ * counters have to be locked before update, so that an instantaneous
+ * snapshot of them can be dumped.
 */
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_LONG_LOCK_FREE)) || \
-	(defined(ISC_PLATFORM_HAVEXADDQ) && defined(ISC_PLATFORM_HAVEATOMICSTOREQ))
-#define ISC_STATS_HAVEATOMICQ 1
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_LONG_LOCK_FREE))
-#define ISC_STATS_HAVESTDATOMICQ 1
-#endif
-#else
-#define ISC_STATS_HAVEATOMICQ 0
-#endif
-
-/*%
- * Only lock the counters if 64-bit atomic operations are
- * not available but cheap atomic lock operations are.
- * On a modern 64-bit system this should never be the case.
- *
- * Normal locks are too expensive to be used whenever a counter
- * is updated.
- */
-#if !ISC_STATS_HAVEATOMICQ && defined(ISC_RWLOCK_HAVEATOMIC)
-#define ISC_STATS_LOCKCOUNTERS 1
-#else
 #define ISC_STATS_LOCKCOUNTERS 0
-#endif

-/*%
- * If 64-bit atomic operations are not available but
- * 32-bit operations are then split the counter into two,
- * using the atomic operations to try to ensure that any carry
- * from the low word is correctly carried into the high word.
- *
- * Otherwise, just rely on standard 64-bit data types
- * and operations
- */
-#if !ISC_STATS_HAVEATOMICQ && ((defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE)) || defined(ISC_PLATFORM_HAVEXADD))
-#define ISC_STATS_USEMULTIFIELDS 1
-#if (defined(ISC_PLATFORM_HAVESTDATOMIC) && defined(ATOMIC_INT_LOCK_FREE))
-#define ISC_STATS_HAVESTDATOMIC 1
-#endif
-#else
-#define ISC_STATS_USEMULTIFIELDS 0
-#endif
-
-#if ISC_STATS_USEMULTIFIELDS
-typedef struct {
-#if defined(ISC_STATS_HAVESTDATOMIC)
-	atomic_int_fast32_t hi;
-	atomic_int_fast32_t lo;
-#else
-	isc_uint32_t hi;
-	isc_uint32_t lo;
-#endif
-} isc_stat_t;
-#else
-#if defined(ISC_STATS_HAVESTDATOMICQ)
+#ifdef ISC_PLATFORM_USETHREADS
 typedef atomic_int_fast64_t isc_stat_t;
 #else
-typedef isc_uint64_t isc_stat_t;
-#endif
+typedef isc_int64_t isc_stat_t;
 #endif

 struct isc_stats {
@@ -104,16 +52,8 @@ struct isc_stats {
 	isc_mem_t	*mctx;
 	int		ncounters;

-	isc_mutex_t	lock;
-	unsigned int	references; /* locked by lock */
+	isc_refcount_t	references;

-	/*%
-	 * Locked by counterlock or unlocked if efficient rwlock is not
-	 * available.
-	 */
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_t	counterlock;
-#endif
 	isc_stat_t	*counters;

 	/*%
@@ -130,8 +70,47 @@ struct isc_stats {
 	isc_uint64_t	*copiedcounters;
 };

-static isc_result_t
-create_stats(isc_mem_t *mctx, int ncounters, isc_stats_t **statsp) {
+void
+isc_stats_attach(isc_stats_t *stats, isc_stats_t **statsp) {
+	REQUIRE(ISC_STATS_VALID(stats));
+	REQUIRE(statsp != NULL && *statsp == NULL);
+
+	isc_refcount_increment(&stats->references);
+
+	*statsp = stats;
+}
+
+void
+isc_stats_detach(isc_stats_t **statsp) {
+	isc_stats_t *stats;
+	int_fast32_t refcount;
+
+	REQUIRE(statsp != NULL && ISC_STATS_VALID(*statsp));
+
+	stats = *statsp;
+	*statsp = NULL;
+
+	refcount = isc_refcount_decrement(&stats->references);
+
+	if (refcount == 1) {
+		isc_mem_put(stats->mctx, stats->copiedcounters,
+			    sizeof(isc_stat_t) * stats->ncounters);
+		isc_mem_put(stats->mctx, stats->counters,
+			    sizeof(isc_stat_t) * stats->ncounters);
+		isc_mem_putanddetach(&stats->mctx, stats, sizeof(*stats));
+		return;
+	}
+}
+
+int
+isc_stats_ncounters(isc_stats_t *stats) {
+	REQUIRE(ISC_STATS_VALID(stats));
+
+	return (stats->ncounters);
+}
+
+isc_result_t
+isc_stats_create(isc_mem_t *mctx, isc_stats_t **statsp, int ncounters) {
 	isc_stats_t *stats;
 	isc_result_t result = ISC_R_SUCCESS;

@@ -141,15 +120,12 @@ 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;
-
 	stats->counters = isc_mem_get(mctx, sizeof(isc_stat_t) * ncounters);
 	if (stats->counters == NULL) {
 		result = ISC_R_NOMEMORY;
-		goto clean_mutex;
+		goto clean_stats;
 	}
+
 	stats->copiedcounters = isc_mem_get(mctx,
 					    sizeof(isc_uint64_t) * ncounters);
 	if (stats->copiedcounters == NULL) {
@@ -157,13 +133,7 @@ create_stats(isc_mem_t *mctx, int ncounters, isc_stats_t **statsp) {
 		goto clean_counters;
 	}

-#if ISC_STATS_LOCKCOUNTERS
-	result = isc_rwlock_init(&stats->counterlock, 0, 0);
-	if (result != ISC_R_SUCCESS)
-		goto clean_copiedcounters;
-#endif
-
-	stats->references = 1;
+	isc_refcount_init(&stats->references, 1);
 	memset(stats->counters, 0, sizeof(isc_stat_t) * ncounters);
 	stats->mctx = NULL;
 	isc_mem_attach(mctx, &stats->mctx);
@@ -177,215 +147,22 @@ create_stats(isc_mem_t *mctx, int ncounters, isc_stats_t **statsp) {
 clean_counters:
 	isc_mem_put(mctx, stats->counters, sizeof(isc_stat_t) * ncounters);

-#if ISC_STATS_LOCKCOUNTERS
-clean_copiedcounters:
-	isc_mem_put(mctx, stats->copiedcounters,
-		    sizeof(isc_stat_t) * ncounters);
-#endif
-
-clean_mutex:
-	DESTROYLOCK(&stats->lock);
-
 clean_stats:
 	isc_mem_put(mctx, stats, sizeof(*stats));

 	return (result);
 }

-void
-isc_stats_attach(isc_stats_t *stats, isc_stats_t **statsp) {
-	REQUIRE(ISC_STATS_VALID(stats));
-	REQUIRE(statsp != NULL && *statsp == NULL);
-
-	LOCK(&stats->lock);
-	stats->references++;
-	UNLOCK(&stats->lock);
-
-	*statsp = stats;
-}
-
-void
-isc_stats_detach(isc_stats_t **statsp) {
-	isc_stats_t *stats;
-
-	REQUIRE(statsp != NULL && ISC_STATS_VALID(*statsp));
-
-	stats = *statsp;
-	*statsp = NULL;
-
-	LOCK(&stats->lock);
-	stats->references--;
-
-	if (stats->references == 0) {
-		isc_mem_put(stats->mctx, stats->copiedcounters,
-			    sizeof(isc_stat_t) * stats->ncounters);
-		isc_mem_put(stats->mctx, stats->counters,
-			    sizeof(isc_stat_t) * stats->ncounters);
-		UNLOCK(&stats->lock);
-		DESTROYLOCK(&stats->lock);
-#if ISC_STATS_LOCKCOUNTERS
-		isc_rwlock_destroy(&stats->counterlock);
-#endif
-		isc_mem_putanddetach(&stats->mctx, stats, sizeof(*stats));
-		return;
-	}
-
-	UNLOCK(&stats->lock);
-}
-
-int
-isc_stats_ncounters(isc_stats_t *stats) {
-	REQUIRE(ISC_STATS_VALID(stats));
-
-	return (stats->ncounters);
-}
-
-static inline void
-incrementcounter(isc_stats_t *stats, int counter) {
-	isc_int32_t prev;
-
-#if ISC_STATS_LOCKCOUNTERS
-	/*
-	 * We use a "read" lock to prevent other threads from reading the
-	 * counter while we "writing" a counter field.  The write access itself
-	 * is protected by the atomic operation.
-	 */
-	isc_rwlock_lock(&stats->counterlock, isc_rwlocktype_read);
-#endif
-
-#if ISC_STATS_USEMULTIFIELDS
-#if defined(ISC_STATS_HAVESTDATOMIC)
-	prev = atomic_fetch_add_explicit(&stats->counters[counter].lo, 1,
-					 memory_order_relaxed);
-#else
-	prev = isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].lo, 1);
-#endif
-	/*
-	 * If the lower 32-bit field overflows, increment the higher field.
-	 * Note that it's *theoretically* possible that the lower field
-	 * overlaps again before the higher field is incremented.  It doesn't
-	 * matter, however, because we don't read the value until
-	 * isc_stats_copy() is called where the whole process is protected
-	 * by the write (exclusive) lock.
-	 */
-	if (prev == (isc_int32_t)0xffffffff) {
-#if defined(ISC_STATS_HAVESTDATOMIC)
-		atomic_fetch_add_explicit(&stats->counters[counter].hi, 1,
-					  memory_order_relaxed);
-#else
-		isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].hi, 1);
-#endif
-	}
-#elif ISC_STATS_HAVEATOMICQ
-	UNUSED(prev);
-#if defined(ISC_STATS_HAVESTDATOMICQ)
-	atomic_fetch_add_explicit(&stats->counters[counter], 1,
-				  memory_order_relaxed);
-#else
-	isc_atomic_xaddq((isc_int64_t *)&stats->counters[counter], 1);
-#endif
-#else
-	UNUSED(prev);
-	stats->counters[counter]++;
-#endif
-
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_unlock(&stats->counterlock, isc_rwlocktype_read);
-#endif
-}
-
-static inline void
-decrementcounter(isc_stats_t *stats, int counter) {
-	isc_int32_t prev;
-
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_lock(&stats->counterlock, isc_rwlocktype_read);
-#endif
-
-#if ISC_STATS_USEMULTIFIELDS
-#if defined(ISC_STATS_HAVESTDATOMIC)
-	prev = atomic_fetch_sub_explicit(&stats->counters[counter].lo, 1,
-					 memory_order_relaxed);
-#else
-	prev = isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].lo, -1);
-#endif
-	if (prev == 0) {
-#if defined(ISC_STATS_HAVESTDATOMIC)
-		atomic_fetch_sub_explicit(&stats->counters[counter].hi, 1,
-					  memory_order_relaxed);
-#else
-		isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].hi,
-				-1);
-#endif
-	}
-#elif ISC_STATS_HAVEATOMICQ
-	UNUSED(prev);
-#if defined(ISC_STATS_HAVESTDATOMICQ)
-	atomic_fetch_sub_explicit(&stats->counters[counter], 1,
-				  memory_order_relaxed);
-#else
-	isc_atomic_xaddq((isc_int64_t *)&stats->counters[counter], -1);
-#endif
-#else
-	UNUSED(prev);
-	stats->counters[counter]--;
-#endif
-
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_unlock(&stats->counterlock, isc_rwlocktype_read);
-#endif
-}
-
-static void
-copy_counters(isc_stats_t *stats) {
-	int i;
-
-#if ISC_STATS_LOCKCOUNTERS
-	/*
-	 * We use a "write" lock before "reading" the statistics counters as
-	 * an exclusive lock.
-	 */
-	isc_rwlock_lock(&stats->counterlock, isc_rwlocktype_write);
-#endif
-
-	for (i = 0; i < stats->ncounters; i++) {
-#if ISC_STATS_USEMULTIFIELDS
-		stats->copiedcounters[i] =
-			(isc_uint64_t)(stats->counters[i].hi) << 32 |
-			stats->counters[i].lo;
-#elif ISC_STATS_HAVEATOMICQ
-#if defined(ISC_STATS_HAVESTDATOMICQ)
-		stats->copiedcounters[i] =
-			atomic_load_explicit(&stats->counters[i],
-					     memory_order_relaxed);
-#else
-		/* use xaddq(..., 0) as an atomic load */
-		stats->copiedcounters[i] =
-			(isc_uint64_t)isc_atomic_xaddq((isc_int64_t *)&stats->counters[i], 0);
-#endif
-#else
-		stats->copiedcounters[i] = stats->counters[i];
-#endif
-	}
-
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_unlock(&stats->counterlock, isc_rwlocktype_write);
-#endif
-}
-
-isc_result_t
-isc_stats_create(isc_mem_t *mctx, isc_stats_t **statsp, int ncounters) {
-	REQUIRE(statsp != NULL && *statsp == NULL);
-
-	return (create_stats(mctx, ncounters, statsp));
-}
-
 void
 isc_stats_increment(isc_stats_t *stats, isc_statscounter_t counter) {
 	REQUIRE(ISC_STATS_VALID(stats));
 	REQUIRE(counter < stats->ncounters);
-
-	incrementcounter(stats, (int)counter);
+#ifdef ISC_PLATFORM_USETHREADS
+	atomic_fetch_add_explicit(&stats->counters[counter], 1,
+				  memory_order_release);
+#else /* ISC_PLATFORM_USETHREADS */
+	stats->counters[counter]++;
+#endif /* ISC_PLATFORM_USETHREADS */
 }

 void
@@ -393,7 +170,12 @@ isc_stats_decrement(isc_stats_t *stats, isc_statscounter_t counter) {
 	REQUIRE(ISC_STATS_VALID(stats));
 	REQUIRE(counter < stats->ncounters);

-	decrementcounter(stats, (int)counter);
+#ifdef ISC_PLATFORM_USETHREADS
+	atomic_fetch_sub_explicit(&stats->counters[counter], 1,
+				  memory_order_release);
+#else /* ISC_PLATFORM_USETHREADS */
+	stats->counters[counter]--;
+#endif /* ISC_PLATFORM_USETHREADS */
 }

 void
@@ -404,7 +186,12 @@ isc_stats_dump(isc_stats_t *stats, isc_stats_dumper_t dump_fn,

 	REQUIRE(ISC_STATS_VALID(stats));

-	copy_counters(stats);
+#ifdef ISC_PLATFORM_USETHREADS
+	for (i = 0; i < stats->ncounters; i++) {
+		stats->copiedcounters[i] =
+			atomic_load_explicit(&stats->counters[i],
+					     memory_order_acquire);
+	}

 	for (i = 0; i < stats->ncounters; i++) {
 		if ((options & ISC_STATSDUMP_VERBOSE) == 0 &&
@@ -412,6 +199,14 @@ isc_stats_dump(isc_stats_t *stats, isc_stats_dumper_t dump_fn,
 				continue;
 		dump_fn((isc_statscounter_t)i, stats->copiedcounters[i], arg);
 	}
+#else /* ISC_PLATFORM_USETHREADS */
+	for (i = 0; i < stats->ncounters; i++) {
+		if ((options & ISC_STATSDUMP_VERBOSE) == 0 &&
+		    stats->counters[i] == 0)
+				continue;
+		dump_fn((isc_statscounter_t)i, stats->counters[i], arg);
+	}
+#endif /* ISC_PLATFORM_USETHREADS */
 }

 void
@@ -421,29 +216,10 @@ isc_stats_set(isc_stats_t *stats, isc_uint64_t val,
 	REQUIRE(ISC_STATS_VALID(stats));
 	REQUIRE(counter < stats->ncounters);

-#if ISC_STATS_LOCKCOUNTERS
-	/*
-	 * We use a "write" lock before "reading" the statistics counters as
-	 * an exclusive lock.
-	 */
-	isc_rwlock_lock(&stats->counterlock, isc_rwlocktype_write);
-#endif
-
-#if ISC_STATS_USEMULTIFIELDS
-	stats->counters[counter].hi = (isc_uint32_t)((val >> 32) & 0xffffffff);
-	stats->counters[counter].lo = (isc_uint32_t)(val & 0xffffffff);
-#elif ISC_STATS_HAVEATOMICQ
-#if defined(ISC_STATS_HAVESTDATOMICQ)
+#ifdef ISC_PLATFORM_USETHREADS
 	atomic_store_explicit(&stats->counters[counter], val,
-			      memory_order_relaxed);
-#else
-	isc_atomic_storeq((isc_int64_t *)&stats->counters[counter], val);
-#endif
-#else
+			      memory_order_release);
+#else /* ISC_PLATFORM_USETHREADS */
 	stats->counters[counter] = val;
-#endif
-
-#if ISC_STATS_LOCKCOUNTERS
-	isc_rwlock_unlock(&stats->counterlock, isc_rwlocktype_write);
-#endif
+#endif /* ISC_PLATFORM_USETHREADS */
 }
@@ -2,7 +2,6 @@ syntax(2)
 test_suite('bind9')

 atf_test_program{name='aes_test'}
-atf_test_program{name='atomic_test'}
 atf_test_program{name='buffer_test'}
 atf_test_program{name='counter_test'}
 atf_test_program{name='errno_test'}
@@ -28,7 +28,7 @@ ISCDEPLIBS =	../libisc.@A@
 LIBS =		@LIBS@ @ATFLIBS@

 OBJS =		isctest.@O@
-SRCS =		isctest.c aes_test.c atomic_test.c buffer_test.c \
+SRCS =		isctest.c aes_test.c buffer_test.c \
 		counter_test.c errno_test.c file_test.c hash_test.c \
 		heap_test.c ht_test.c inet_ntop_test.c lex_test.c \
 		mem_test.c netaddr_test.c parse_test.c pool_test.c \
@@ -38,7 +38,7 @@ SRCS =		isctest.c aes_test.c atomic_test.c buffer_test.c \
 		taskpool_test.c time_test.c timer_test.c

 SUBDIRS =
-TARGETS =	aes_test@EXEEXT@ atomic_test@EXEEXT@ buffer_test@EXEEXT@ \
+TARGETS =	aes_test@EXEEXT@ buffer_test@EXEEXT@ \
 		counter_test@EXEEXT@ errno_test@EXEEXT@ file_test@EXEEXT@ \
 		hash_test@EXEEXT@ heap_test@EXEEXT@ ht_test@EXEEXT@ \
 		inet_ntop_test@EXEEXT@ lex_test@EXEEXT@ mem_test@EXEEXT@ \
@@ -51,10 +51,6 @@ TARGETS =	aes_test@EXEEXT@ atomic_test@EXEEXT@ buffer_test@EXEEXT@ \

@BIND9_MAKE_RULES@

-atomic_test@EXEEXT@: atomic_test.@O@ isctest.@O@ ${ISCDEPLIBS}
-	${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \
-			atomic_test.@O@ isctest.@O@ ${ISCLIBS} ${LIBS}
-
 aes_test@EXEEXT@: aes_test.@O@ ${ISCDEPLIBS}
 	${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \
 			aes_test.@O@ ${ISCLIBS} ${LIBS}
@@ -1,352 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-#include <config.h>
-#include <stdlib.h>
-
-#include <atf-c.h>
-
-#include <isc/atomic.h>
-#include <isc/print.h>
-#include <isc/result.h>
-
-#include "isctest.h"
-
-#define TASKS 32
-#define ITERATIONS 1000
-#define COUNTS_PER_ITERATION 1000
-#define INCREMENT_64 (isc_int64_t)0x0000000010000000
-#define EXPECTED_COUNT_32 (TASKS * ITERATIONS * COUNTS_PER_ITERATION)
-#define EXPECTED_COUNT_64 (TASKS * ITERATIONS * COUNTS_PER_ITERATION * INCREMENT_64)
-
-typedef struct {
-	isc_uint32_t iteration;
-} counter_t;
-
-counter_t counters[TASKS];
-
-#if defined(ISC_PLATFORM_HAVEXADD)
-static isc_int32_t counter_32;
-
-static void
-do_xadd(isc_task_t *task, isc_event_t *ev) {
-	counter_t *state = (counter_t *)ev->ev_arg;
-	int i;
-
-	for (i = 0 ; i < COUNTS_PER_ITERATION ; i++) {
-		isc_atomic_xadd(&counter_32, 1);
-	}
-
-	state->iteration++;
-	if (state->iteration < ITERATIONS) {
-		isc_task_send(task, &ev);
-	} else {
-		isc_event_free(&ev);
-	}
-}
-
-ATF_TC(atomic_xadd);
-ATF_TC_HEAD(atomic_xadd, tc) {
-	atf_tc_set_md_var(tc, "descr", "atomic XADD");
-}
-ATF_TC_BODY(atomic_xadd, tc) {
-	isc_result_t result;
-	isc_task_t *tasks[TASKS];
-	isc_event_t *event = NULL;
-	int i;
-
-	UNUSED(tc);
-
-	result = isc_test_begin(NULL, ISC_TRUE, 0);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
-	memset(counters, 0, sizeof(counters));
-	counter_32 = 0;
-
-	/*
-	 * Create our tasks, and allocate an event to get the counters going.
-	 */
-	for (i = 0 ; i < TASKS ; i++) {
-		tasks[i] = NULL;
-		ATF_REQUIRE_EQ(isc_task_create(taskmgr, 0, &tasks[i]),
-			       ISC_R_SUCCESS);
-		event = isc_event_allocate(mctx, NULL, 1000, do_xadd,
-					   &counters[i],
-					   sizeof(struct isc_event));
-		ATF_REQUIRE(event != NULL);
-		isc_task_sendanddetach(&tasks[i], &event);
-	}
-
-	isc_test_end();
-
-	printf("32-bit counter %d, expected %d\n",
-	       counter_32, EXPECTED_COUNT_32);
-
-	ATF_CHECK_EQ(counter_32, EXPECTED_COUNT_32);
-	counter_32 = 0;
-}
-#endif
-
-#if defined(ISC_PLATFORM_HAVEXADDQ)
-static isc_int64_t counter_64;
-
-static void
-do_xaddq(isc_task_t *task, isc_event_t *ev) {
-	counter_t *state = (counter_t *)ev->ev_arg;
-	int i;
-
-	for (i = 0 ; i < COUNTS_PER_ITERATION ; i++) {
-		isc_atomic_xaddq(&counter_64, INCREMENT_64);
-	}
-
-	state->iteration++;
-	if (state->iteration < ITERATIONS) {
-		isc_task_send(task, &ev);
-	} else {
-		isc_event_free(&ev);
-	}
-}
-
-ATF_TC(atomic_xaddq);
-ATF_TC_HEAD(atomic_xaddq, tc) {
-	atf_tc_set_md_var(tc, "descr", "atomic XADDQ");
-}
-ATF_TC_BODY(atomic_xaddq, tc) {
-	isc_result_t result;
-	isc_task_t *tasks[TASKS];
-	isc_event_t *event = NULL;
-	int i;
-
-	UNUSED(tc);
-
-	result = isc_test_begin(NULL, ISC_TRUE, 0);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
-	memset(counters, 0, sizeof(counters));
-	counter_64 = 0;
-
-	/*
-	 * Create our tasks, and allocate an event to get the counters going.
-	 */
-	for (i = 0 ; i < TASKS ; i++) {
-		tasks[i] = NULL;
-		ATF_REQUIRE_EQ(isc_task_create(taskmgr, 0, &tasks[i]),
-			       ISC_R_SUCCESS);
-		event = isc_event_allocate(mctx, NULL, 1000, do_xaddq,
-					   &counters[i],
-					   sizeof(struct isc_event));
-		ATF_REQUIRE(event != NULL);
-		isc_task_sendanddetach(&tasks[i], &event);
-	}
-
-	isc_test_end();
-
-	printf("64-bit counter %"ISC_PRINT_QUADFORMAT"d, "
-	       "expected %"ISC_PRINT_QUADFORMAT"d\n",
-	       counter_64, EXPECTED_COUNT_64);
-
-	ATF_CHECK_EQ(counter_64, EXPECTED_COUNT_64);
-	counter_32 = 0;
-}
-#endif
-
-#if defined(ISC_PLATFORM_HAVEATOMICSTORE)
-static isc_int32_t store_32;
-
-static void
-do_store(isc_task_t *task, isc_event_t *ev) {
-	counter_t *state = (counter_t *)ev->ev_arg;
-	int i;
-	isc_uint32_t r;
-	isc_uint32_t val;
-
-	r = random() % 256;
-	val = (r << 24) | (r << 16) | (r << 8) | r;
-
-	for (i = 0 ; i < COUNTS_PER_ITERATION ; i++) {
-		isc_atomic_store(&store_32, val);
-	}
-
-	state->iteration++;
-	if (state->iteration < ITERATIONS) {
-		isc_task_send(task, &ev);
-	} else {
-		isc_event_free(&ev);
-	}
-}
-
-ATF_TC(atomic_store);
-ATF_TC_HEAD(atomic_store, tc) {
-	atf_tc_set_md_var(tc, "descr", "atomic STORE");
-}
-ATF_TC_BODY(atomic_store, tc) {
-	isc_result_t result;
-	isc_task_t *tasks[TASKS];
-	isc_event_t *event = NULL;
-	isc_uint32_t val;
-	isc_uint32_t r;
-	int i;
-
-	UNUSED(tc);
-
-	result = isc_test_begin(NULL, ISC_TRUE, 0);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
-	memset(counters, 0, sizeof(counters));
-	store_32 = 0;
-
-	/*
-	 * Create our tasks, and allocate an event to get the counters
-	 * going.
-	 */
-	for (i = 0 ; i < TASKS ; i++) {
-		tasks[i] = NULL;
-		ATF_REQUIRE_EQ(isc_task_create(taskmgr, 0, &tasks[i]),
-			       ISC_R_SUCCESS);
-		event = isc_event_allocate(mctx, NULL, 1000, do_store,
-					   &counters[i],
-					   sizeof(struct isc_event));
-		ATF_REQUIRE(event != NULL);
-		isc_task_sendanddetach(&tasks[i], &event);
-	}
-
-	isc_test_end();
-
-	r = store_32 & 0xff;
-	val = (r << 24) | (r << 16) | (r << 8) | r;
-
-	printf("32-bit store 0x%x, expected 0x%x\n",
-	       (isc_uint32_t) store_32, val);
-
-	ATF_CHECK_EQ((isc_uint32_t) store_32, val);
-	store_32 = 0;
-}
-#endif
-
-#if defined(ISC_PLATFORM_HAVEATOMICSTOREQ)
-static isc_int64_t store_64;
-
-static void
-do_storeq(isc_task_t *task, isc_event_t *ev) {
-	counter_t *state = (counter_t *)ev->ev_arg;
-	int i;
-	isc_uint8_t r;
-	isc_uint64_t val;
-
-	r = random() % 256;
-	val = (((isc_uint64_t) r << 24) |
-	       ((isc_uint64_t) r << 16) |
-	       ((isc_uint64_t) r << 8) |
-	       (isc_uint64_t) r);
-	val |= ((isc_uint64_t) val << 32);
-
-	for (i = 0 ; i < COUNTS_PER_ITERATION ; i++) {
-		isc_atomic_storeq(&store_64, val);
-	}
-
-	state->iteration++;
-	if (state->iteration < ITERATIONS) {
-		isc_task_send(task, &ev);
-	} else {
-		isc_event_free(&ev);
-	}
-}
-
-ATF_TC(atomic_storeq);
-ATF_TC_HEAD(atomic_storeq, tc) {
-	atf_tc_set_md_var(tc, "descr", "atomic STOREQ");
-}
-ATF_TC_BODY(atomic_storeq, tc) {
-	isc_result_t result;
-	isc_task_t *tasks[TASKS];
-	isc_event_t *event = NULL;
-	isc_uint64_t val;
-	isc_uint32_t r;
-	int i;
-
-	UNUSED(tc);
-
-	result = isc_test_begin(NULL, ISC_TRUE, 0);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
-	memset(counters, 0, sizeof(counters));
-	store_64 = 0;
-
-	/*
-	 * Create our tasks, and allocate an event to get the counters
-	 * going.
-	 */
-	for (i = 0 ; i < TASKS ; i++) {
-		tasks[i] = NULL;
-		ATF_REQUIRE_EQ(isc_task_create(taskmgr, 0, &tasks[i]),
-			       ISC_R_SUCCESS);
-		event = isc_event_allocate(mctx, NULL, 1000, do_storeq,
-					   &counters[i],
-					   sizeof(struct isc_event));
-		ATF_REQUIRE(event != NULL);
-		isc_task_sendanddetach(&tasks[i], &event);
-	}
-
-	isc_test_end();
-
-	r = store_64 & 0xff;
-	val = (((isc_uint64_t) r << 24) |
-	       ((isc_uint64_t) r << 16) |
-	       ((isc_uint64_t) r << 8) |
-	       (isc_uint64_t) r);
-	val |= ((isc_uint64_t) val << 32);
-
-	printf("64-bit store 0x%"ISC_PRINT_QUADFORMAT"x, "
-	       "expected 0x%"ISC_PRINT_QUADFORMAT"x\n",
-	       (isc_uint64_t) store_64, val);
-
-	ATF_CHECK_EQ((isc_uint64_t) store_64, val);
-	store_64 = 0;
-}
-#endif
-
-#if !defined(ISC_PLATFORM_HAVEXADD) && \
-    !defined(ISC_PLATFORM_HAVEXADDQ) && \
-    !defined(ISC_PLATFORM_HAVEATOMICSTOREQ)
-ATF_TC(untested);
-ATF_TC_HEAD(untested, tc) {
-	atf_tc_set_md_var(tc, "descr", "skipping aes test");
-}
-ATF_TC_BODY(untested, tc) {
-	UNUSED(tc);
-	atf_tc_skip("AES not available");
-}
-#endif /* !HAVEXADD, !HAVEXADDQ, !HAVEATOMICSTOREQ */
-
-/*
- * Main
- */
-ATF_TP_ADD_TCS(tp) {
-#if defined(ISC_PLATFORM_HAVEXADD)
-	ATF_TP_ADD_TC(tp, atomic_xadd);
-#endif
-#if defined(ISC_PLATFORM_HAVEXADDQ)
-	ATF_TP_ADD_TC(tp, atomic_xaddq);
-#endif
-#ifdef ISC_PLATFORM_HAVEATOMICSTORE
-	ATF_TP_ADD_TC(tp, atomic_store);
-#endif
-#if defined(ISC_PLATFORM_HAVEATOMICSTOREQ)
-	ATF_TP_ADD_TC(tp, atomic_storeq);
-#endif
-#if !defined(ISC_PLATFORM_HAVEXADD) && \
-    !defined(ISC_PLATFORM_HAVEXADDQ) && \
-    !defined(ISC_PLATFORM_HAVEATOMICSTOREQ)
-	ATF_TP_ADD_TC(tp, untested);
-#endif
-
-	return (atf_no_error());
-}
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <config.h>
-#include <isc/platform.h>
-#include <isc/types.h>
-
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- */
-#ifdef ISC_PLATFORM_HAVEXADD
-static __inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	return (isc_int32_t) _InterlockedExchangeAdd((long *)p, (long)val);
-}
-#endif
-
-#ifdef ISC_PLATFORM_HAVEXADDQ
-static __inline isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
-	return (isc_int64_t) _InterlockedExchangeAdd64((__int64 *)p,
-						       (__int64) val);
-}
-#endif
-
-/*
- * This routine atomically stores the value 'val' in 'p' (32-bit version).
- */
-#ifdef ISC_PLATFORM_HAVEATOMICSTORE
-static __inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	(void) _InterlockedExchange((long *)p, (long)val);
-}
-#endif
-
-/*
- * This routine atomically stores the value 'val' in 'p' (64-bit version).
- */
-#ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
-static __inline void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
-	(void) _InterlockedExchange64((__int64 *)p, (__int64)val);
-}
-#endif
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-#ifdef ISC_PLATFORM_HAVECMPXCHG
-static __inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	/* beware: swap arguments */
-	return (isc_int32_t) _InterlockedCompareExchange((long *)p,
-							 (long)val,
-							 (long)cmpval);
-}
-#endif
-
-#endif /* ISC_ATOMIC_H */
@@ -97,30 +97,6 @@
 */
@ISC_PLATFORM_WANTAES@

-/*
- * If the "xadd" operation is available on this architecture,
- * ISC_PLATFORM_HAVEXADD will be defined.
- */
-@ISC_PLATFORM_HAVEXADD@
-
-/*
- * If the "xaddq" operation (64bit xadd) is available on this architecture,
- * ISC_PLATFORM_HAVEXADDQ will be defined.
- */
-@ISC_PLATFORM_HAVEXADDQ@
-
-/*
- * If the "atomic swap" operation is available on this architecture,
- * ISC_PLATFORM_HAVEATOMICSTORE" will be defined.
- */
-@ISC_PLATFORM_HAVEATOMICSTORE@
-
-/*
- * If the "compare-and-exchange" operation is available on this architecture,
- * ISC_PLATFORM_HAVECMPXCHG will be defined.
- */
-@ISC_PLATFORM_HAVECMPXCHG@
-
 /*
 * Define with the busy wait nop asm or function call.
 */
@@ -374,11 +374,6 @@
      <Filter>Win32 Header Files</Filter>
    </ClInclude>
@END PKCS11
-@IF ATOMIC
-    <ClInclude Include="include\isc\atomic.h">
-@ELSE ATOMIC
-    <ClInclude Include="..\noatomic\include\isc\atomic.h">
-@END ATOMIC
      <Filter>Library Header Files</Filter>
    </ClInclude>
    <ClInclude Include="..\..\..\config.h">
@@ -597,9 +592,6 @@
    <ClCompile Include="..\ratelimiter.c">
      <Filter>Library Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\refcount.c">
-      <Filter>Library Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="..\regex.c">
      <Filter>Library Source Files</Filter>
    </ClCompile>
@@ -386,11 +386,6 @@ copy InstallFiles ..\Build\Release\
    <ClInclude Include="..\include\pkcs11\pkcs11f.h" />
    <ClInclude Include="..\include\pkcs11\pkcs11t.h" />
@END PKCS11
-@IF ATOMIC
-    <ClInclude Include="include\isc\atomic.h" />
-@ELSE ATOMIC
-    <ClInclude Include="..\noatomic\include\isc\atomic.h" />
-@END ATOMIC
    <ClInclude Include="errno2result.h" />
    <ClInclude Include="include\isc\bindevt.h" />
    <ClInclude Include="include\isc\bind_registry.h" />
@@ -465,7 +460,6 @@ copy InstallFiles ..\Build\Release\
    <ClCompile Include="..\radix.c" />
    <ClCompile Include="..\random.c" />
    <ClCompile Include="..\ratelimiter.c" />
-    <ClCompile Include="..\refcount.c" />
    <ClCompile Include="..\regex.c" />
    <ClCompile Include="..\region.c" />
    <ClCompile Include="..\result.c" />
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 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/.
+ *
+ * See the COPYRIGHT file distributed with this work for additional
+ * information regarding copyright ownership.
+ */
+
+#pragma once
+
+/** \file
+ *  \brief a light stdatomic.h compatibility wrapper for Win32
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <windows.h>
+
+/* does nothing */
+typedef enum
+{
+	memory_order_relaxed,
+	memory_order_consume,
+	memory_order_acquire,
+	memory_order_release,
+	memory_order_acq_rel,
+	memory_order_seq_cst
+} memory_order;
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+#define ATOMIC_VAR_INIT(value)			\
+	(value)
+
+#define atomic_init(object, value)				\
+	atomic_store(object, value)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order)		\
+	MemoryBarrier();
+
+#define atomic_signal_fence(order)		\
+	((void)NULL)
+
+#define atomic_is_lock_free(obj) 0
+
+#define atomic_store(object, desired)			\
+	do {						\
+		*(object) = (desired);			\
+		MemoryBarrier(); \
+	} while(0);
+#define atomic_store_explicit(object, desired, order)	\
+	atomic_store(object, desired)
+
+#define atomic_load(object)			\
+	(MemoryBarrier(), *(object))
+#define atomic_load_explicit(object, order)	\
+	atomic_load(object)
+
+#define atomic_exchange_explicit(object, desired)	\
+	InterlockedExchangePointer(object, desired);
+#define atomic_exchange_explicit(object, desired, order)	\
+	atomic_exchange(object, desired)
+
+static inline bool atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+						  intptr_t desired)
+{
+	intptr_t stored = *expected;
+	*expected = (intptr_t)InterlockedCompareExchangePointer((PVOID *)object,
+								(PVOID)desired, (PVOID)stored);
+	return !!(*expected == stored);
+}
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+	atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired)		\
+	atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+	atomic_compare_exchange_weak(object, expected, desired)
+
+#ifdef _WIN64
+#define atomic_fetch_add(object, operand)		\
+	InterlockedExchangeAdd64(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+	InterlockedExchangeAdd64(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+	InterlockedOr64(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+	InterlockedXor64(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+	InterlockedAnd64(object, operand)
+#else /* _WIN64 */
+#define atomic_fetch_add(object, operand) \
+	InterlockedExchangeAdd(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+	InterlockedExchangeAdd(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+	InterlockedOr(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+	InterlockedXor(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+	InterlockedAnd(object, operand)
+#endif /* _WIN64 */
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+	atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+	atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+	atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+	atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+	atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+	atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+	atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+	atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+	atomic_flag_clear(object)
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,190 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#ifdef ISC_PLATFORM_USEGCCASM
-/*
- * This routine atomically increments the value stored in 'p' by 'val', and
- * returns the previous value.
- */
-static __inline__ isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	isc_int32_t prev = val;
-
-	__asm__ volatile(
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xadd %0, %1"
-		:"=q"(prev)
-		:"m"(*p), "0"(prev)
-		:"memory", "cc");
-
-	return (prev);
-}
-
-#ifdef ISC_PLATFORM_HAVEXADDQ
-static __inline__ isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
-	isc_int64_t prev = val;
-
-	__asm__ volatile(
-#ifdef ISC_PLATFORM_USETHREADS
-	    "lock;"
-#endif
-	    "xaddq %0, %1"
-	    :"=q"(prev)
-	    :"m"(*p), "0"(prev)
-	    :"memory", "cc");
-
-	return (prev);
-}
-#endif /* ISC_PLATFORM_HAVEXADDQ */
-
-/*
- * This routine atomically stores the value 'val' in 'p' (32-bit version).
- */
-static __inline__ void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	__asm__ volatile(
-#ifdef ISC_PLATFORM_USETHREADS
-		/*
-		 * xchg should automatically lock memory, but we add it
-		 * explicitly just in case (it at least doesn't harm)
-		 */
-		"lock;"
-#endif
-
-		"xchgl %1, %0"
-		:
-		: "r"(val), "m"(*p)
-		: "memory");
-}
-
-#ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
-/*
- * This routine atomically stores the value 'val' in 'p' (64-bit version).
- */
-static __inline__ void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
-	__asm__ volatile(
-#ifdef ISC_PLATFORM_USETHREADS
-		/*
-		 * xchg should automatically lock memory, but we add it
-		 * explicitly just in case (it at least doesn't harm)
-		 */
-		"lock;"
-#endif
-
-		"xchgq %1, %0"
-		:
-		: "r"(val), "m"(*p)
-		: "memory");
-}
-#endif /* ISC_PLATFORM_HAVEATOMICSTOREQ */
-
-/*
- * This routine atomically replaces the value in 'p' with 'val', if the
- * original value is equal to 'cmpval'.  The original value is returned in any
- * case.
- */
-static __inline__ isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	__asm__ volatile(
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"cmpxchgl %1, %2"
-		: "=a"(cmpval)
-		: "r"(val), "m"(*p), "a"(cmpval)
-		: "memory");
-
-	return (cmpval);
-}
-
-#elif defined(ISC_PLATFORM_USESTDASM)
-/*
- * The followings are "generic" assembly code which implements the same
- * functionality in case the gcc extension cannot be used.  It should be
- * better to avoid inlining below, since we directly refer to specific
- * positions of the stack frame, which would not actually point to the
- * intended address in the embedded mnemonic.
- */
-static isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movl 8(%ebp), %ecx\n"
-		"movl 12(%ebp), %edx\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xadd %edx, (%ecx)\n"
-
-		/*
-		 * set the return value directly in the register so that we
-		 * can avoid guessing the correct position in the stack for a
-		 * local variable.
-		 */
-		"movl %edx, %eax"
-		);
-}
-
-static void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movl 8(%ebp), %ecx\n"
-		"movl 12(%ebp), %edx\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xchgl (%ecx), %edx\n"
-		);
-}
-
-static isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	(void)(p);
-	(void)(cmpval);
-	(void)(val);
-
-	__asm (
-		"movl 8(%ebp), %ecx\n"
-		"movl 12(%ebp), %eax\n"	/* must be %eax for cmpxchgl */
-		"movl 16(%ebp), %edx\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-
-		/*
-		 * If (%ecx) == %eax then (%ecx) := %edx.
-		 % %eax is set to old (%ecx), which will be the return value.
-		 */
-		"cmpxchgl %edx, (%ecx)"
-		);
-}
-#else /* !ISC_PLATFORM_USEGCCASM && !ISC_PLATFORM_USESTDASM */
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-#endif /* ISC_ATOMIC_H */
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	include
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,17 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-SUBDIRS =	isc
-TARGETS =
-
-@BIND9_MAKE_RULES@
@@ -1,34 +0,0 @@
-# Copyright (C) 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/.
-#
-# See the COPYRIGHT file distributed with this work for additional
-# information regarding copyright ownership.
-
-srcdir =	@srcdir@
-VPATH =		@srcdir@
-top_srcdir =	@top_srcdir@
-
-VERSION=@BIND9_VERSION@
-
-HEADERS =	atomic.h
-
-SUBDIRS =
-TARGETS =
-
-@BIND9_MAKE_RULES@
-
-installdirs:
-	$(SHELL) ${top_srcdir}/mkinstalldirs ${DESTDIR}${includedir}/isc
-
-install:: installdirs
-	for i in ${HEADERS}; do \
-		${INSTALL_DATA} $(srcdir)/$$i ${DESTDIR}${includedir}/isc ; \
-	done
-
-uninstall::
-	for i in ${HEADERS}; do \
-		rm -f ${DESTDIR}${includedir}/isc/$$i ; \
-	done
@@ -1,137 +0,0 @@
-/*
- * Copyright (C) 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/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_ATOMIC_H
-#define ISC_ATOMIC_H 1
-
-#include <isc/platform.h>
-#include <isc/types.h>
-
-#ifdef ISC_PLATFORM_USEGCCASM
-
-/* We share the gcc-version with x86_32 */
-#error "impossible case.  check build configuration"
-
-#elif defined(ISC_PLATFORM_USESTDASM)
-/*
- * The followings are "generic" assembly code which implements the same
- * functionality in case the gcc extension cannot be used.  It should be
- * better to avoid inlining below, since we directly refer to specific
- * registers for arguments, which would not actually correspond to the
- * intended address or value in the embedded mnemonic.
- */
-
-static isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movq %rdi, %rdx\n"
-		"movl %esi, %eax\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xadd %eax, (%rdx)\n"
-		/*
-		 * XXX: assume %eax will be used as the return value.
-		 */
-		);
-}
-
-#ifdef ISC_PLATFORM_HAVEXADDQ
-static isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movq %rdi, %rdx\n"
-		"movq %rsi, %rax\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xaddq %rax, (%rdx)\n"
-		/*
-		 * XXX: assume %rax will be used as the return value.
-		 */
-		);
-}
-#endif
-
-static void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movq %rdi, %rax\n"
-		"movl %esi, %edx\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xchgl (%rax), %edx\n"
-		);
-}
-
-#ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
-static void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
-	(void)(p);
-	(void)(val);
-
-	__asm (
-		"movq %rdi, %rax\n"
-		"movq %rsi, %rdx\n"
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		"xchgq (%rax), %rdx\n"
-		);
-}
-#endif
-
-static isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
-	(void)(p);
-	(void)(cmpval);
-	(void)(val);
-
-	__asm (
-		/*
-		 * p is %rdi, cmpval is %esi, val is %edx.
-		 */
-		"movl %edx, %ecx\n"
-		"movl %esi, %eax\n"
-		"movq %rdi, %rdx\n"
-
-#ifdef ISC_PLATFORM_USETHREADS
-		"lock;"
-#endif
-		/*
-		 * If [%rdi] == %eax then [%rdi] := %ecx (equal to %edx
-		 * from above), and %eax is untouched (equal to %esi)
-		 * from above.
-		 *
-		 * Else if [%rdi] != %eax then [%rdi] := [%rdi]
-		 * (rewritten in write cycle) and %eax := [%rdi].
-		 */
-		"cmpxchgl %ecx, (%rdx)"
-		);
-}
-
-#else /* !ISC_PLATFORM_USEGCCASM && !ISC_PLATFORM_USESTDASM */
-
-#error "unsupported compiler.  disable atomic ops by --disable-atomic"
-
-#endif
-#endif /* ISC_ATOMIC_H */
@@ -68,7 +68,7 @@ cfg_aclconfctx_attach(cfg_aclconfctx_t *src, cfg_aclconfctx_t **dest) {
 	REQUIRE(src != NULL);
 	REQUIRE(dest != NULL && *dest == NULL);

-	isc_refcount_increment(&src->references, NULL);
+	isc_refcount_increment(&src->references);
 	*dest = src;
 }

@@ -76,14 +76,14 @@ void
 cfg_aclconfctx_detach(cfg_aclconfctx_t **actxp) {
 	cfg_aclconfctx_t *actx;
 	dns_acl_t *dacl, *next;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(actxp != NULL && *actxp != NULL);

 	actx = *actxp;

-	isc_refcount_decrement(&actx->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&actx->references);
+	if (refs == 1) {
 		for (dacl = ISC_LIST_HEAD(actx->named_acl_cache);
 		     dacl != NULL;
 		     dacl = next)
@@ -657,22 +657,22 @@ cfg_parser_attach(cfg_parser_t *src, cfg_parser_t **dest) {
 	REQUIRE(src != NULL);
 	REQUIRE(dest != NULL && *dest == NULL);

-	isc_refcount_increment(&src->references, NULL);
+	isc_refcount_increment(&src->references);
 	*dest = src;
 }

 void
 cfg_parser_destroy(cfg_parser_t **pctxp) {
 	cfg_parser_t *pctx;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(pctxp != NULL && *pctxp != NULL);

 	pctx = *pctxp;
 	*pctxp = NULL;

-	isc_refcount_decrement(&pctx->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&pctx->references);
+	if (refs == 1) {
 		isc_lex_destroy(&pctx->lexer);
 		/*
 		 * Cleaning up open_files does not
@@ -3125,15 +3125,15 @@ cfg_obj_istype(const cfg_obj_t *obj, const cfg_type_t *type) {
 void
 cfg_obj_destroy(cfg_parser_t *pctx, cfg_obj_t **objp) {
 	cfg_obj_t *obj;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(objp != NULL && *objp != NULL);
 	REQUIRE(pctx != NULL);

 	obj = *objp;

-	isc_refcount_decrement(&obj->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&obj->references);
+	if (refs == 1) {
 		obj->type->rep->free(pctx, obj);
 		isc_refcount_destroy(&obj->references);
 		isc_mem_put(pctx->mctx, obj, sizeof(cfg_obj_t));
@@ -3143,11 +3143,11 @@ cfg_obj_destroy(cfg_parser_t *pctx, cfg_obj_t **objp) {

 void
 cfg_obj_attach(cfg_obj_t *src, cfg_obj_t **dest) {
-    REQUIRE(src != NULL);
-    REQUIRE(dest != NULL && *dest == NULL);
+	REQUIRE(src != NULL);
+	REQUIRE(dest != NULL && *dest == NULL);

-    isc_refcount_increment(&src->references, NULL);
-    *dest = src;
+	isc_refcount_increment(&src->references);
+	*dest = src;
 }

 static void
@@ -122,7 +122,7 @@ ns_server_attach(ns_server_t *src, ns_server_t **dest) {
 	REQUIRE(SCTX_VALID(src));
 	REQUIRE(dest != NULL && *dest == NULL);

-	isc_refcount_increment(&src->references, NULL);
+	isc_refcount_increment(&src->references);

 	*dest = src;
 }
@@ -130,14 +130,14 @@ ns_server_attach(ns_server_t *src, ns_server_t **dest) {
 void
 ns_server_detach(ns_server_t **sctxp) {
 	ns_server_t *sctx;
-	unsigned int refs;
+	int_fast32_t refs;

 	REQUIRE(sctxp != NULL);
 	sctx = *sctxp;
 	REQUIRE(SCTX_VALID(sctx));

-	isc_refcount_decrement(&sctx->references, &refs);
-	if (refs == 0) {
+	refs = isc_refcount_decrement(&sctx->references);
+	if (refs == 1) {
 		ns_altsecret_t *altsecret;

 		sctx->magic = 0;
@@ -17,8 +17,7 @@ ISC_INCLUDES = @BIND9_ISC_BUILDINCLUDE@ \
 	-I${top_srcdir}/lib/isc \
 	-I${top_srcdir}/lib/isc/include \
 	-I${top_srcdir}/lib/isc/unix/include \
-	-I${top_srcdir}/lib/isc/@ISC_THREAD_DIR@/include \
-	-I${top_srcdir}/lib/isc/@ISC_ARCH_DIR@/include
+	-I${top_srcdir}/lib/isc/@ISC_THREAD_DIR@/include

 ISCCC_INCLUDES = @BIND9_ISCCC_BUILDINCLUDE@ \
       -I${top_srcdir}/lib/isccc/include
@@ -3809,6 +3809,7 @@
 ./lib/isc/win32/pk11_api.c			C	2014,2016,2018
 ./lib/isc/win32/resource.c			C	2000,2001,2004,2007,2008,2016,2018
 ./lib/isc/win32/socket.c			C	2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018
+./lib/isc/win32/stdatomic.h			C	2018
 ./lib/isc/win32/stdio.c				C	2000,2001,2004,2007,2013,2016,2018
 ./lib/isc/win32/stdtime.c			C	1999,2000,2001,2004,2007,2013,2016,2018
 ./lib/isc/win32/strerror.c			C	2001,2002,2004,2007,2016,2018
@@ -229,11 +229,6 @@ my @substdefh = ("AES_CC",
 my %configdefp;

 my @substdefp = ("ISC_PLATFORM_BUSYWAITNOP",
-                 "ISC_PLATFORM_HAVEATOMICSTORE",
-                 "ISC_PLATFORM_HAVEATOMICSTOREQ",
-                 "ISC_PLATFORM_HAVECMPXCHG",
-                 "ISC_PLATFORM_HAVEXADD",
-                 "ISC_PLATFORM_HAVEXADDQ",
                 "ISC_PLATFORM_NEEDSTRCASESTR",
                 "ISC_PLATFORM_USEBACKTRACE",
                 "ISC_PLATFORM_WANTAES");
@@ -338,7 +333,6 @@ my @substdefd = ("CRYPTO",
 my %configcond;

 my @substcond = ("AES",
-                 "ATOMIC",
                 "GSSAPI",
                 "GEOIP",
                 "IDNKIT",
@@ -1288,16 +1282,8 @@ EOF

 # enable-intrinsics
 if ($enable_intrinsics eq "yes") {
-    $configcond{"ATOMIC"} = 1;
    $configvar{"INTRINSIC"} = "true";
    $configvar{"COPTI"} = "/Oi";
-    $configdefp{"ISC_PLATFORM_HAVEXADD"} = 1;
-    if ($want_x64 eq "yes") {
-        $configdefp{"ISC_PLATFORM_HAVEXADDQ"} = 1;
-        $configdefp{"ISC_PLATFORM_HAVEATOMICSTOREQ"} = 1;
-    }
-    $configdefp{"ISC_PLATFORM_HAVEATOMICSTORE"} = 1;
-    $configdefp{"ISC_PLATFORM_HAVECMPXCHG"} = 1;
 } else {
    $configvar{"INTRINSIC"} = "false";
 }
@@ -61,9 +61,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BINDInstall", "..\bin\win32
 		{403FD4B1-A4F9-4159-9013-5860E3A4417D} = {403FD4B1-A4F9-4159-9013-5860E3A4417D}
@END PKCS11
@IF TESTS
-@IF ATOMIC
-		{EC6ECB35-58C0-48EC-BAC9-9A652D9406C9} = {EC6ECB35-58C0-48EC-BAC9-9A652D9406C9}
-@END ATOMIC
 		{E6338E67-3224-4E66-9463-7AD719DA9346} = {E6338E67-3224-4E66-9463-7AD719DA9346}
 		{EE9B94CF-7C33-4F3B-A674-FB756D422C54} = {EE9B94CF-7C33-4F3B-A674-FB756D422C54}
 		{5DC2F8D3-9373-41BB-B3AB-78F2E12F1E5E} = {5DC2F8D3-9373-41BB-B3AB-78F2E12F1E5E}
@@ -791,12 +788,6 @@ Global
 		{403FD4B1-A4F9-4159-9013-5860E3A4417D}.Release|@PLATFORM@.Build.0 = Release|@PLATFORM@
@END PKCS11
@IF TESTS
-@IF ATOMIC
-		{EC6ECB35-58C0-48EC-BAC9-9A652D9406C9}.Debug|@PLATFORM@.ActiveCfg = Debug|@PLATFORM@
-		{EC6ECB35-58C0-48EC-BAC9-9A652D9406C9}.Debug|@PLATFORM@.Build.0 = Debug|@PLATFORM@
-		{EC6ECB35-58C0-48EC-BAC9-9A652D9406C9}.Release|@PLATFORM@.ActiveCfg = Release|@PLATFORM@
-		{EC6ECB35-58C0-48EC-BAC9-9A652D9406C9}.Release|@PLATFORM@.Build.0 = Release|@PLATFORM@
-@END ATOMIC
 		{E6338E67-3224-4E66-9463-7AD719DA9346}.Debug|@PLATFORM@.ActiveCfg = Debug|@PLATFORM@
 		{E6338E67-3224-4E66-9463-7AD719DA9346}.Debug|@PLATFORM@.Build.0 = Debug|@PLATFORM@
 		{E6338E67-3224-4E66-9463-7AD719DA9346}.Release|@PLATFORM@.ActiveCfg = Release|@PLATFORM@
Author	SHA1	Message	Date
Ondřej Surý	8039f3c00f	Rewrite isc_refcount API after stdatomics and use release-acquire memory barriers	2018-05-24 18:22:56 +02:00
Ondřej Surý	7f7f1868c2	Add compatibility stdatomic.h header for Windows	2018-05-24 16:36:07 +02:00
Ondřej Surý	1721667a01	Only require stdatomic.h when compiled with threading support	2018-05-24 10:37:46 +02:00
Mukund SivaramanandOndřej Surý	bcb011a306	Various fixes to lib/isc/stats.c * Re-introduce ISC_STATS_LOCKCOUNTERS so that it is an optional feature (it adds lock contention) * Fix desired rwlock type in lock calls (they were opposite of what should be used) * Add locking to isc_stats_set() * Inline create_stats()	2018-05-24 10:37:46 +02:00
Ondřej Surý	41b34f7416	Reintroduce the rwlock needed for dumping stats consistently	2018-05-24 10:37:46 +02:00
Ondřej Surý	4f03d524f7	Cleanup atomic from Windows build files	2018-05-24 10:37:45 +02:00
Ondřej Surý	158986c5e9	Unwrap isc_refcount_t from struct isc_refcount as it is always a simple type now	2018-05-24 10:37:06 +02:00
Ondřej Surý	dcd64fac19	Remove local locking macros as they are always RWLOCK now	2018-05-24 10:36:23 +02:00
Ondřej Surý	ef368be4d1	Remove extra incrementcounter / decrementcounter functions	2018-05-24 10:36:23 +02:00
Ondřej Surý	42dccefb37	C compiler standard atomics support is now required to compile	2018-05-24 10:36:23 +02:00