fixup! Remove unthreaded support

Remove unthreaded support
2018-08-15 11:36:35 +02:00 · 2018-08-14 20:55:48 +02:00
50 changed files with 1423 additions and 2756 deletions
@@ -289,6 +289,7 @@ AS_VAR_IF([$1], [""], [$5], [$4])dnl
 ])dnl PKG_CHECK_VAR
 m4_include([m4/ax_check_openssl.m4])
 m4_include([m4/ax_pthread.m4])
 m4_include([m4/libtool.m4])
 m4_include([m4/ltoptions.m4])
 m4_include([m4/ltsugar.m4])
@@ -263,7 +263,7 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
 			printf(";; Query time: %ld msec\n", (long) diff / 1000);
 		printf(";; SERVER: %s(%s)\n", fromtext, query->servname);
 		time(&tnow);
-#if defined(ISC_PLATFORM_USETHREADS) && !defined(WIN32)
+#if !defined(WIN32)
 		(void)localtime_r(&tnow, &tmnow);
 #else
 		tmnow  = *localtime(&tnow);
@@ -720,11 +720,7 @@ parse_command_line(int argc, char *argv[]) {
 			printf("linked to zlib version: %s\n",
 			       zlibVersion());
 #endif
 #ifdef ISC_PLATFORM_USETHREADS
 			printf("threads support is enabled\n");
 #else
 			printf("threads support is disabled\n");
 #endif
 			exit(0);
 		case 'x':
 			/* Obsolete. No longer in use. Ignore. */
@@ -776,7 +772,6 @@ create_managers(void) {
 	INSIST(named_g_cpus_detected > 0);
 #ifdef ISC_PLATFORM_USETHREADS
 	if (named_g_cpus == 0)
 		named_g_cpus = named_g_cpus_detected;
 	isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@@ -785,9 +780,6 @@ create_managers(void) {
 		      named_g_cpus_detected,
 		      named_g_cpus_detected == 1 ? "" : "s",
 		      named_g_cpus, named_g_cpus == 1 ? "" : "s");
 #else
 	named_g_cpus = 1;
 #endif
 #ifdef WIN32
 	named_g_udpdisp = 1;
 #else
@@ -800,12 +792,10 @@ create_managers(void) {
 	if (named_g_udpdisp > named_g_cpus)
 		named_g_udpdisp = named_g_cpus;
 #endif
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
 		      NAMED_LOGMODULE_SERVER, ISC_LOG_INFO,
 		      "using %u UDP listener%s per interface",
 		      named_g_udpdisp, named_g_udpdisp == 1 ? "" : "s");
 #endif
 	result = isc_taskmgr_create(named_g_mctx, named_g_cpus, 0,
 				    &named_g_taskmgr);
@@ -917,12 +907,10 @@ setup(void) {
 		isc_mem_free(named_g_mctx, instance);
 #endif /* HAVE_LIBSCF */
 #ifdef ISC_PLATFORM_USETHREADS
 	/*
 	 * Check for the number of cpu's before named_os_chroot().
 	 */
 	named_g_cpus_detected = isc_os_ncpus();
 #endif
 	named_os_chroot(named_g_chrootdir);
@@ -11208,7 +11208,6 @@ named_server_status(named_server_t *server, isc_buffer_t **text) {
 	}
 	CHECK(putstr(text, line));
 #ifdef ISC_PLATFORM_USETHREADS
 	snprintf(line, sizeof(line), "CPUs found: %u\n", named_g_cpus_detected);
 	CHECK(putstr(text, line));
@@ -11218,10 +11217,6 @@ named_server_status(named_server_t *server, isc_buffer_t **text) {
 	snprintf(line, sizeof(line), "UDP listeners per interface: %u\n",
 		 named_g_udpdisp);
 	CHECK(putstr(text, line));
 #else
 	snprintf(line, sizeof(line), "CPUs found: N/A (threads disabled)\n");
 	CHECK(putstr(text, line));
 #endif
 	snprintf(line, sizeof(line), "number of zones: %u (%u automatic)\n",
 		     zonecount, automatic);
@@ -25,8 +25,6 @@
 #define sleep(x)	Sleep(1000 * x)
 #endif
 #ifdef ISC_PLATFORM_USETHREADS
 isc_rwlock_t lock;
 static isc_threadresult_t
@@ -130,15 +128,3 @@ main(int argc, char *argv[]) {
 	return (0);
 }
 #else
 int
 main(int argc, char *argv[]) {
 	UNUSED(argc);
 	UNUSED(argv);
 	fprintf(stderr, "This test requires threads.\n");
 	return(1);
 }
 #endif
@@ -326,36 +326,21 @@ int sigwait(const unsigned int *set, int *sig);
 /* Define to 1 if you have the <krb5/krb5.h> header file. */
 #undef HAVE_KRB5_KRB5_H
 /* Define to 1 if you have the `c' library (-lc). */
 #undef HAVE_LIBC
 /* if system have backtrace function */
 #undef HAVE_LIBCTRACE
 /* Define to 1 if you have the `c_r' library (-lc_r). */
 #undef HAVE_LIBC_R
 /* Define if libidn2 was found */
 #undef HAVE_LIBIDN2
 /* Define to 1 if you have the `nsl' library (-lnsl). */
 #undef HAVE_LIBNSL
 /* Define to 1 if you have the `pthread' library (-lpthread). */
 #undef HAVE_LIBPTHREAD
 /* Define to 1 if you have the `rt' library (-lrt). */
 #undef HAVE_LIBRT
 /* Define to 1 if you have the `scf' library (-lscf). */
 #undef HAVE_LIBSCF
 /* Define to 1 if you have the `socket' library (-lsocket). */
 #undef HAVE_LIBSOCKET
 /* Define to 1 if you have the `thr' library (-lthr). */
 #undef HAVE_LIBTHR
 /* Define if libxml2 was found */
 #undef HAVE_LIBXML2
@@ -389,12 +374,24 @@ int sigwait(const unsigned int *set, int *sig);
 /* define if OpenSSL supports Ed25519 */
 #undef HAVE_OPENSSL_ED25519
 /* Define if you have POSIX threads libraries and header files. */
 #undef HAVE_PTHREAD
 /* Define to 1 if you have the `pthread_attr_getstacksize' function. */
 #undef HAVE_PTHREAD_ATTR_GETSTACKSIZE
 /* Define to 1 if you have the `pthread_attr_setstacksize' function. */
 #undef HAVE_PTHREAD_ATTR_SETSTACKSIZE
 /* Support for PTHREAD_MUTEX_ADAPTIVE_NP */
 #undef HAVE_PTHREAD_MUTEX_ADAPTIVE_NP
 /* Define to 1 if you have the <pthread_np.h> header file. */
 #undef HAVE_PTHREAD_NP_H
 /* Have PTHREAD_PRIO_INHERIT. */
 #undef HAVE_PTHREAD_PRIO_INHERIT
 /* Define to 1 if you have the `pthread_setname_np' function. */
 #undef HAVE_PTHREAD_SETNAME_NP
@@ -443,6 +440,9 @@ int sigwait(const unsigned int *set, int *sig);
 /* Define to 1 if you have the `setresuid' function. */
 #undef HAVE_SETRESUID
 /* Define to 1 if you have the `sigwait' function. */
 #undef HAVE_SIGWAIT
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
@@ -589,6 +589,10 @@ int sigwait(const unsigned int *set, int *sig);
   (O_NDELAY/O_NONBLOCK). */
 #undef PORT_NONBLOCK
 /* Define to necessary symbol if this constant uses a non-standard name on
   your system. */
 #undef PTHREAD_CREATE_JOINABLE
 /* The size of `void *', as computed by sizeof. */
 #undef SIZEOF_VOID_P
@@ -105,11 +105,6 @@ AC_ARG_ENABLE(afl,
 				[default=no]]),
 	      [AC_DEFINE([ENABLE_AFL], [1],
 			 [Define to enable American Fuzzy Lop test harness])])
 case "$enable_afl" in
 yes)
 	LIBS="$LIBS -lpthread"
 	;;
 esac
 #
 # Make very sure that these are the first files processed by
@@ -842,191 +837,113 @@ AC_SUBST(CHECK_DSA)
 #
 AC_CHECK_FUNCS(arc4random arc4random_buf arc4random_uniform getrandom)
-sinclude(config.threads.in)dnl
+AX_PTHREAD
-if $use_threads
+LIBS="$PTHREAD_LIBS $LIBS"
-then
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-	if test "X$GCC" = "Xyes"; then
+CC="$PTHREAD_CC"
-		case "$host" in
+
-		*-freebsd*)
+#
-			CC="$CC -pthread"
+# We'd like to use sigwait() too
-			CCOPT="$CCOPT -pthread"
+#
-			CCNOOPT="$CCNOOPT -pthread"
+AC_CHECK_FUNCS([sigwait pthread_attr_getstacksize pthread_attr_setstacksize])
-			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
+
-			;;
+AC_ARG_WITH([locktype],
-		*-openbsd*)
+	    AS_HELP_STRING([--with-locktype=ARG],
-			CC="$CC -pthread"
+			   [Specify mutex lock type
-			CCOPT="$CCOPT -pthread"
+			    (adaptive or standard)]),
-			CCNOOPT="$CCNOOPT -pthread"
+	    [], [with_locktype="adaptive"])
-			;;
+
-		*-solaris*)
+AS_CASE([$with_locktype],
-			LIBS="$LIBS -lthread"
+	[adaptive],[
-			;;
+	  AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])
-		*-ibm-aix*)
+	  AC_COMPILE_IFELSE(
-			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
+	    [AC_LANG_PROGRAM(
-			;;
+	       [[
-		esac
+		 #ifndef _GNU_SOURCE
-	else
+		 #define _GNU_SOURCE
 		 #endif
 		 #include <pthread.h>
 	       ]],
 	       [[
 		 return (PTHREAD_MUTEX_ADAPTIVE_NP);
 	       ]]
 	     )],
 	    [AC_MSG_RESULT([using adaptive lock type])
 	     AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1,
 		       [Support for PTHREAD_MUTEX_ADAPTIVE_NP]) ],
 	    [AC_MSG_RESULT([using standard lock type])]
 	  )],
 	[standard],[AC_MSG_RESULT([using standard lock type])],
 	[AC_MSG_ERROR([You must specify "adaptive" or "standard" for --with-locktype.])]
       )
 AC_CHECK_HEADERS([sched.h])
 AC_SEARCH_LIBS([sched_yield],[rt])
 AC_CHECK_FUNCS([sched_yield pthread_yield pthread_yield_np])
 #
 # Additional OS-specific issues related to pthreads and sigwait.
 #
 case "$host" in
 	#
 	# One more place to look for sigwait.
 	#
 	*-freebsd*)
 		AC_CHECK_LIB(c_r, sigwait, AC_DEFINE(HAVE_SIGWAIT),)
 		case $host in
-		*-dec-osf*)
+		*-freebsd5.[[012]]|*-freebsd5.[[012]].*);;
-			CC="$CC -pthread"
+		*-freebsd5.[[3456789]]|*-freebsd5.[[3456789]].*)
-			CCOPT="$CCOPT -pthread"
+			AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
 			CCNOOPT="$CCNOOPT -pthread"
 			;;
-		*-solaris*)
+		*-freebsd6.*)
-			CC="$CC -mt"
+			AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
 			CCOPT="$CCOPT -mt"
 			CCNOOPT="$CCNOOPT -mt"
 			;;
 		*-ibm-aix*)
 			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
 			;;
 		*-sco-sysv*uw*|*-*-sysv*UnixWare*)
 			CC="$CC -Kthread"
 			CCOPT="$CCOPT -Kthread"
 			CCNOOPT="$CCNOOPT -Kthread"
 			;;
 		*-*-sysv*OpenUNIX*)
 			CC="$CC -Kpthread"
 			CCOPT="$CCOPT -Kpthread"
 			CCNOOPT="$CCNOOPT -Kpthread"
 			;;
 		esac
 	fi
 	ALWAYS_DEFINES="-D_REENTRANT"
 	ISC_PLATFORM_USETHREADS="#define ISC_PLATFORM_USETHREADS 1"
 	THREADOPTOBJS='${THREADOPTOBJS}'
 	THREADOPTSRCS='${THREADOPTSRCS}'
 	thread_dir=pthreads
 	#
 	# We'd like to use sigwait() too
 	#
 	AC_CHECK_FUNC(sigwait,
 		      AC_DEFINE(HAVE_SIGWAIT),
 		      AC_CHECK_LIB(c, sigwait,
 		      AC_DEFINE(HAVE_SIGWAIT),
 		      AC_CHECK_LIB(pthread, sigwait,
 				   AC_DEFINE(HAVE_SIGWAIT),
 				   AC_CHECK_LIB(pthread, _Psigwait,
 						AC_DEFINE(HAVE_SIGWAIT),))))
 	AC_CHECK_FUNC(pthread_attr_getstacksize,
 		      AC_DEFINE(HAVE_PTHREAD_ATTR_GETSTACKSIZE),)
 	AC_CHECK_FUNC(pthread_attr_setstacksize,
 		      AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE),)
 	AC_ARG_WITH(locktype,
 		    AS_HELP_STRING([--with-locktype=ARG],
 				   [Specify mutex lock type
 					(adaptive or standard)]),
 		    locktype="$withval", locktype="adaptive")
 	case "$locktype" in
 		adaptive)
 			AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])
 			AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 			  #ifndef _GNU_SOURCE
 			  #define _GNU_SOURCE
 			  #endif
 			  #include <pthread.h>
 			]], [[
 			  return (PTHREAD_MUTEX_ADAPTIVE_NP);
 			]])],
 			[ AC_MSG_RESULT(using adaptive lock type)
 			  AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1,
 				    [Support for PTHREAD_MUTEX_ADAPTIVE_NP]) ],
 			[ AC_MSG_RESULT(using standard lock type) ])
 			;;
 		standard)
 			AC_MSG_RESULT(using standard lock type)
 			;;
 		*)
 			AC_MSG_ERROR([You must specify "adaptive" or "standard" for --with-locktype.])
 			;;
 	esac
 	AC_CHECK_HEADERS(sched.h)
 	case "$host" in
 	*solaris-*)
 		AC_CHECK_LIB(rt, sched_yield)
 		;;
 	esac
 	AC_CHECK_FUNCS(sched_yield pthread_yield pthread_yield_np)
 	#
-	# Additional OS-specific issues related to pthreads and sigwait.
+	# BSDI 3.0 through 4.0.1 needs pthread_init() to be
 	# called before certain pthreads calls.	 This is deprecated
 	# in BSD/OS 4.1.
 	#
-	case "$host" in
+	*-bsdi3.*|*-bsdi4.0*)
-		#
+		AC_DEFINE(NEED_PTHREAD_INIT)
-		# One more place to look for sigwait.
+		;;
 		#
 		*-freebsd*)
 			AC_CHECK_LIB(c_r, sigwait, AC_DEFINE(HAVE_SIGWAIT),)
 			case $host in
 			*-freebsd5.[[012]]|*-freebsd5.[[012]].*);;
 			*-freebsd5.[[3456789]]|*-freebsd5.[[3456789]].*)
 				AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
 				;;
 			*-freebsd6.*)
 				AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
 				;;
 			esac
 			;;
 		#
 		# BSDI 3.0 through 4.0.1 needs pthread_init() to be
 		# called before certain pthreads calls.	 This is deprecated
 		# in BSD/OS 4.1.
 		#
 		*-bsdi3.*|*-bsdi4.0*)
 			AC_DEFINE(NEED_PTHREAD_INIT)
 			;;
 		#
 		# LinuxThreads requires some changes to the way we
 		# deal with signals.
 		#
 		*-linux*)
 			AC_DEFINE(HAVE_LINUXTHREADS)
 			;;
 		#
 		# Ensure the right sigwait() semantics on Solaris and make
 		# sure we call pthread_setconcurrency.
 		#
 		*-solaris*)
 			AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 			AC_CHECK_FUNC(pthread_setconcurrency,
 				      AC_DEFINE(CALL_PTHREAD_SETCONCURRENCY))
 			;;
 		#
 		# UnixWare does things its own way.
 		#
 		*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
 			AC_DEFINE(HAVE_UNIXWARE_SIGWAIT)
 			;;
 	esac
 	# Look for functions relating to thread naming
 	AC_CHECK_FUNCS(pthread_setname_np pthread_set_name_np)
 	AC_CHECK_HEADERS([pthread_np.h], [], [], [#include <pthread.h>])
 	#
-	# Look for sysconf to allow detection of the number of processors.
+	# LinuxThreads requires some changes to the way we
 	# deal with signals.
 	#
-	AC_CHECK_FUNC(sysconf, AC_DEFINE(HAVE_SYSCONF),)
+	*-linux*)
 		AC_DEFINE(HAVE_LINUXTHREADS)
 		;;
 	#
 	# Ensure the right sigwait() semantics on Solaris and make
 	# sure we call pthread_setconcurrency.
 	#
 	*-solaris*)
 		AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 		AC_CHECK_FUNC(pthread_setconcurrency,
 			      AC_DEFINE(CALL_PTHREAD_SETCONCURRENCY))
 		;;
 	#
 	# UnixWare does things its own way.
 	#
 	*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
 		AC_DEFINE(HAVE_UNIXWARE_SIGWAIT)
 		;;
 esac
-else
+# Look for functions relating to thread naming
-	ISC_PLATFORM_USETHREADS="#undef ISC_PLATFORM_USETHREADS"
+AC_CHECK_FUNCS([pthread_setname_np pthread_set_name_np])
-	thread_dir=nothreads
+AC_CHECK_HEADERS([pthread_np.h], [], [], [#include <pthread.h>])
-	THREADOPTOBJS=""
+
-	THREADOPTSRCS=""
+#
-	ALWAYS_DEFINES=""
+# Look for sysconf to allow detection of the number of processors.
-fi
+#
 AC_CHECK_FUNC(sysconf, AC_DEFINE(HAVE_SYSCONF),)
 AC_SUBST(ALWAYS_DEFINES)
 AC_SUBST(ISC_PLATFORM_USETHREADS)
 AC_SUBST(THREADOPTOBJS)
 AC_SUBST(THREADOPTSRCS)
 ISC_THREAD_DIR=$thread_dir
@@ -1807,20 +1724,6 @@ AC_CHECK_LIB(scf, smf_enable_instance)
 AC_CHECK_FUNC(flockfile, AC_DEFINE(HAVE_FLOCKFILE),)
 AC_CHECK_FUNC(getc_unlocked, AC_DEFINE(HAVE_GETCUNLOCKED),)
 # 
 # Indicate what the final decision was regarding threads.
 #
 AC_MSG_CHECKING(whether to build with threads)
 if $use_threads; then
 	AC_MSG_RESULT(yes)
 else
 	AC_MSG_RESULT(no)
 fi
 # 
 # End of pthreads stuff.
 #
 #
 # Large File
 #
@@ -3304,52 +3207,49 @@ fi
 #
 # CPU relax (for spin locks)
 #
-if $use_threads
+case "$host" in
-then
+[i[3456]86-*])
-	case "$host" in
+	# x86_32
-	[i[3456]86-*])
+	AC_MSG_CHECKING([if asm("rep; nop"); works])
-		# x86_32
+	AC_TRY_COMPILE(,[asm("rep; nop");],
-		AC_MSG_CHECKING([if asm("rep; nop"); works])
+	[AC_MSG_RESULT(yes)
-		AC_TRY_COMPILE(,[asm("rep; nop");],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
-		[AC_MSG_RESULT(yes)
+	[AC_MSG_RESULT(no)],
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
+	[AC_MSG_RESULT([cross compile, assume yes])
-		[AC_MSG_RESULT(no)],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
-		[AC_MSG_RESULT([cross compile, assume yes])
+	;;
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
+x86_64-*|amd64-*)
-		;;
+	# x86_64
-	x86_64-*|amd64-*)
+	AC_MSG_CHECKING([if asm("rep; nop"); works])
-		# x86_64
+	AC_TRY_COMPILE(,[asm("rep; nop");],
-		AC_MSG_CHECKING([if asm("rep; nop"); works])
+	[AC_MSG_RESULT(yes)
-		AC_TRY_COMPILE(,[asm("rep; nop");],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
-		[AC_MSG_RESULT(yes)
+	[AC_MSG_RESULT(no)],
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
+	[AC_MSG_RESULT([cross compile, assume yes])
-		[AC_MSG_RESULT(no)],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
-		[AC_MSG_RESULT([cross compile, assume yes])
+	;;
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
+ia64-*)
-		;;
+	# ia64
-	ia64-*)
+	AC_MSG_CHECKING([if asm("hint @pause"); works])
-		# ia64
+	AC_TRY_COMPILE(,[asm("hint @pause");],
-		AC_MSG_CHECKING([if asm("hint @pause"); works])
+	[AC_MSG_RESULT(yes)
-		AC_TRY_COMPILE(,[asm("hint @pause");],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"],
-		[AC_MSG_RESULT(yes)
+	[AC_MSG_RESULT(no)],
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"],
+	[AC_MSG_RESULT([cross compile, assume yes])
-		[AC_MSG_RESULT(no)],
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"])
-		[AC_MSG_RESULT([cross compile, assume yes])
+	;;
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"])
+sparc-*)
-		;;
+	# sparc
-	sparc-*)
+	AC_MSG_CHECKING([if cpu_relax(); or __cpu_relax(); works])
-		# sparc
+	AC_CHECK_FUNC(cpu_relax,
-		AC_MSG_CHECKING([if cpu_relax(); or __cpu_relax(); works])
+	[AC_MSG_RESULT(yes)
-		AC_CHECK_FUNC(cpu_relax,
+	 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP cpu_relax()"],
-		[AC_MSG_RESULT(yes)
+	 [AC_CHECK_FUNC(__cpu_relax,
-		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP cpu_relax()"],
+	  [AC_MSG_RESULT(yes)
-		 [AC_CHECK_FUNC(__cpu_relax,
+	   ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP __cpu_relax()"],
-		  [AC_MSG_RESULT(yes)
+	   [AC_MSG_RESULT(no)])])
-		   ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP __cpu_relax()"],
+	;;
-		   [AC_MSG_RESULT(no)])])
+esac
 		;;
 	esac
 fi
 AC_SUBST(ISC_PLATFORM_BUSYWAITNOP)
@@ -3484,9 +3384,6 @@ DNSTAPOBJS=
 DNSTAPTARGETS=
 DNSTAP_PB_C_H=
 if test "x$use_dnstap" != "xno"; then
 	if ! $use_threads; then
 		AC_MSG_ERROR([Dnstap requires threads.])
 	fi
 	AC_ARG_WITH([protobuf-c],
 		    AS_HELP_STRING([--with-protobuf-c=path],
 				   [Path where protobuf-c is installed, for dnstap]), [
@@ -3858,9 +3755,6 @@ AC_ARG_WITH(tuning,
 case "$use_tuning" in
 	large)
 		if ! $use_threads; then
 			AC_MSG_ERROR([Large-system tuning requires threads.])
 		fi
 		AC_DEFINE(TUNE_LARGE, 1, [Define to use large-system tuning.])
 		AC_MSG_RESULT(using large-system tuning)
 		;;
@@ -4480,11 +4374,8 @@ report() {
    echo "Configuration summary:"
    echo "-------------------------------------------------------------------------------"
    echo "Optional features enabled:"
-    if $use_threads; then
+    if test "yes" = "$enable_full_report" -o "standard" = "$locktype"; then
-	echo "    Multiprocessing support (--enable-threads)"
+	echo "        Mutex lock type: $locktype"
 	if test "yes" = "$enable_full_report" -o "standard" = "$locktype"; then
 	    echo "        Mutex lock type: $locktype"
 	fi
    fi
    test "large" = "$use_tuning" && echo "    Large-system tuning (--with-tuning)"
    test "no" = "$use_dnstap" || \
@@ -4549,7 +4440,6 @@ report() {
    echo "-------------------------------------------------------------------------------"
    echo "Features disabled or unavailable on this platform:"
    $use_threads || echo "    Multiprocessing support (--enable-threads)"
    test "no" = "$enable_ipv6" -o "no" = "$found_ipv6" && \
 	    echo "    IPv6 support (--enable-ipv6)"
    test "large" = "$use_tuning" || echo "    Large-system tuning (--with-tuning)"
@@ -66,11 +66,7 @@
 static dns_sdlzimplementation_t *dlz_bdb = NULL;
 /* should the bdb driver use threads. */
 #ifdef ISC_PLATFORM_USETHREADS
 #define bdb_threads DB_THREAD
 #else
 #define bdb_threads 0
 #endif
 /* BDB database names */
 #define dlz_data "dns_data"
@@ -66,11 +66,7 @@
 static dns_sdlzimplementation_t *dlz_bdbhpt = NULL;
 /* should the bdb driver use threads. */
 #ifdef ISC_PLATFORM_USETHREADS
 #define bdbhpt_threads DB_THREAD
 #else
 #define bdbhpt_threads 0
 #endif
 /* bdbhpt database names */
 #define dlz_data "dns_data"
@@ -94,11 +94,7 @@ static dns_sdlzimplementation_t *dlz_ldap = NULL;
 */
 typedef struct {
 #ifdef ISC_PLATFORM_USETHREADS
 	db_list_t    *db; /*%< handle to a list of DB */
 #else
 	dbinstance_t *db; /*%< handle to db */
 #endif
 	int method;	/*%< security authentication method */
 	char *user;	/*%< who is authenticating */
 	char *cred;	/*%< password for simple authentication method */
@@ -244,9 +240,6 @@ dlz_ldap_connect(ldap_instance_t *dbi, dbinstance_t *dbc) {
 	return (result);
 }
 #ifdef ISC_PLATFORM_USETHREADS
 /*%
 * Properly cleans up a list of database instances.
 * This function is only used when the driver is compiled for
@@ -316,7 +309,6 @@ ldap_find_avail_conn(db_list_t *dblist) {
 		      count);
 	return (NULL);
 }
 #endif /* ISC_PLATFORM_USETHREADS */
 static isc_result_t
 ldap_process_results(LDAP *dbc, LDAPMessage *msg, char ** attrs,
@@ -569,22 +561,10 @@ ldap_get_results(const char *zone, const char *record,
 	int entries;
 	/* get db instance / connection */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* find an available DBI from the list */
 	dbi = ldap_find_avail_conn((db_list_t *)
 				   ((ldap_instance_t *)dbdata)->db);
 #else /* ISC_PLATFORM_USETHREADS */
 	/*
 	 * only 1 DBI - no need to lock instance lock either
 	 * only 1 thread in the whole process, no possible contention.
 	 */
 	dbi =  (dbinstance_t *) ((ldap_instance_t *)dbdata)->db;
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* if DBI is null, can't do anything else */
 	if (dbi == NULL)
 		return (ISC_R_FAILURE);
@@ -845,13 +825,9 @@ ldap_get_results(const char *zone, const char *record,
 	if (dbi->client != NULL)
 		isc_mem_free(named_g_mctx, dbi->client);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* release the lock so another thread can use this dbi */
 	isc_mutex_unlock(&dbi->instance_lock);
 #endif /* ISC_PLATFORM_USETHREADS */
        /* release query string */
 	if (querystring  != NULL)
 		isc_mem_free(named_g_mctx, querystring );
@@ -939,30 +915,19 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 	dbinstance_t *dbi = NULL;
 	int protocol;
 	int method;
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if multi-threaded, we need a few extra variables. */
 	int dbcount;
 	char *endp;
 /* db_list_t *dblist = NULL; */
 	int i;
 #endif /* ISC_PLATFORM_USETHREADS */
 	UNUSED(dlzname);
 	UNUSED(driverarg);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if debugging, let user know we are multithreaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "LDAP driver running multithreaded");
 #else /* ISC_PLATFORM_USETHREADS */
 	/* if debugging, let user know we are single threaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "LDAP driver running single threaded");
 #endif /* ISC_PLATFORM_USETHREADS */
 	if (argc < 9) {
 		isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
@@ -1010,9 +975,6 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 		return (ISC_R_FAILURE);
 	}
 	/* multithreaded build can have multiple DB connections */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* check how many db connections we should create */
 	dbcount = strtol(argv[1], &endp, 10);
 	if (*endp != '\0' || dbcount < 0) {
@@ -1022,7 +984,6 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 			      "must be positive.");
 		return (ISC_R_FAILURE);
 	}
 #endif
 	/* check that LDAP URL parameters make sense */
 	switch(argc) {
@@ -1078,7 +1039,6 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 		goto cleanup;
 	}
 #ifdef ISC_PLATFORM_USETHREADS
 	/* allocate memory for database connection list */
 	ldap_inst->db = isc_mem_get(named_g_mctx, sizeof(db_list_t));
 	if (ldap_inst->db == NULL) {
@@ -1095,8 +1055,6 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 	 */
 	for (i = 0; i < dbcount; i++) {
 #endif /* ISC_PLATFORM_USETHREADS */
 		/* how many queries were passed in from config file? */
 		switch(argc) {
 		case 9:
@@ -1138,18 +1096,9 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 			goto cleanup;
 		}
 #ifdef ISC_PLATFORM_USETHREADS
 		/* when multithreaded, build a list of DBI's */
 		ISC_LINK_INIT(dbi, link);
 		ISC_LIST_APPEND(*(ldap_inst->db), dbi, link);
 #else
 		/*
 		 * when single threaded, hold onto the one connection
 		 * instance.
 		 */
 		ldap_inst->db = dbi;
 #endif
 		/* attempt to connect */
 		result = dlz_ldap_connect(ldap_inst, dbi);
@@ -1166,18 +1115,11 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 			 * allocate memory
 			 */
 		case ISC_R_NOMEMORY:
 #ifdef ISC_PLATFORM_USETHREADS
 			isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 				      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 				      "LDAP driver could not allocate memory "
 				      "for connection number %u",
 				      i+1);
 #else
 			isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 				      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 				      "LDAP driver could not allocate memory "
 				      "for connection");
 #endif
 			goto cleanup;
 			break;
 			/*
@@ -1194,18 +1136,11 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 			break;
 			/* failure means couldn't connect to ldap server */
 		case ISC_R_FAILURE:
 #ifdef ISC_PLATFORM_USETHREADS
 			isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 				      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 				      "LDAP driver could not "
 				      "bind connection number %u to server.",
 				      i+1);
 #else
 			isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 				      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 				      "LDAP driver could not "
 				      "bind connection to server.");
 #endif
 			goto cleanup;
 			break;
 			/*
@@ -1221,15 +1156,10 @@ dlz_ldap_create(const char *dlzname, unsigned int argc, char *argv[],
 			break;
 		} /* end switch(result) */
 #ifdef ISC_PLATFORM_USETHREADS
 		/* set DBI = null for next loop through. */
 		dbi = NULL;
 	}	/* end for loop */
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* set dbdata to the ldap_instance we created. */
 	*dbdata = ldap_inst;
@@ -1248,20 +1178,10 @@ dlz_ldap_destroy(void *driverarg, void *dbdata) {
 	UNUSED(driverarg);
 	if (dbdata != NULL) {
 #ifdef ISC_PLATFORM_USETHREADS
 		/* cleanup the list of DBI's */
 		ldap_destroy_dblist((db_list_t *)
 				    ((ldap_instance_t *)dbdata)->db);
 #else /* ISC_PLATFORM_USETHREADS */
 		if (((ldap_instance_t *)dbdata)->db->dbconn != NULL)
 			ldap_unbind_s((LDAP *)
 				      ((ldap_instance_t *)dbdata)->db->dbconn);
 		/* destroy single DB instance */
 		destroy_sqldbinstance(((ldap_instance_t *)dbdata)->db);
 #endif /* ISC_PLATFORM_USETHREADS */
 		if (((ldap_instance_t *)dbdata)->hosts != NULL)
 			isc_mem_free(named_g_mctx,
 				     ((ldap_instance_t *)dbdata)->hosts);
@@ -99,17 +99,7 @@ typedef struct{
 */
 typedef struct {
 #ifdef ISC_PLATFORM_USETHREADS
    db_list_t    *db;       /* handle to a list of DB */
 #else
    dbinstance_t *db;       /* handle to db */
 #endif
    SQLHENV      sql_env;  /* handle to SQL environment */
    SQLCHAR      *dsn;
    SQLCHAR      *user;
@@ -136,9 +126,6 @@ safeLen(void *a) {
 static void
 destroy_odbc_instance(odbc_instance_t *odbc_inst) {
 #ifdef ISC_PLATFORM_USETHREADS
 	dbinstance_t *ndbi = NULL;
 	dbinstance_t *dbi = NULL;
@@ -180,34 +167,6 @@ destroy_odbc_instance(odbc_instance_t *odbc_inst) {
 	/* release memory for the list structure */
 	isc_mem_put(named_g_mctx, odbc_inst->db, sizeof(db_list_t));
 #else /* ISC_PLATFORM_USETHREADS */
 	/* free statement handle */
 	if (((odbc_db_t *) (odbc_inst->db->dbconn))->stmnt != NULL) {
 		SQLFreeHandle(SQL_HANDLE_STMT,
 			      ((odbc_db_t *) (odbc_inst->db->dbconn))->stmnt);
 		((odbc_db_t *) (odbc_inst->db->dbconn))->stmnt = NULL;
 	}
 	/* disconnect from database, free connection handle */
 	if (((odbc_db_t *) (odbc_inst->db->dbconn))->dbc != NULL) {
 		SQLDisconnect(((odbc_db_t *) (odbc_inst->db->dbconn))->dbc);
 		SQLFreeHandle(SQL_HANDLE_DBC,
 			      ((odbc_db_t *) (odbc_inst->db->dbconn))->dbc);
 		((odbc_db_t *) (odbc_inst->db->dbconn))->dbc = NULL;
 	}
 	/*	free mem for the odbc_db_t structure held in db */
 	if (((odbc_db_t *) odbc_inst->db->dbconn) != NULL) {
 		isc_mem_free(named_g_mctx, odbc_inst->db->dbconn);
 		odbc_inst->db->dbconn = NULL;
 	}
 	if (odbc_inst->db != NULL)
 		destroy_sqldbinstance(odbc_inst->db);
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* free sql environment */
 	if (odbc_inst->sql_env != NULL)
 		SQLFreeHandle(SQL_HANDLE_ENV, odbc_inst->sql_env);
@@ -327,8 +286,6 @@ odbc_connect(odbc_instance_t *dbi, odbc_db_t **dbc) {
 * multithreaded operation.
 */
 #ifdef ISC_PLATFORM_USETHREADS
 static dbinstance_t *
 odbc_find_avail_conn(db_list_t *dblist)
 {
@@ -362,8 +319,6 @@ odbc_find_avail_conn(db_list_t *dblist)
 	return NULL;
 }
 #endif /* ISC_PLATFORM_USETHREADS */
 /*% Allocates memory for a new string, and then constructs the new
 * string by "escaping" the input string.  The new string is
 * safe to be used in queries.  This is necessary because we cannot
@@ -482,21 +437,10 @@ odbc_get_resultset(const char *zone, const char *record,
 	REQUIRE(*r_dbi == NULL);
 	/* get db instance / connection */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* find an available DBI from the list */
 	dbi = odbc_find_avail_conn(((odbc_instance_t *) dbdata)->db);
 #else /* ISC_PLATFORM_USETHREADS */
 	/*
 	 * only 1 DBI - no need to lock instance lock either
 	 * only 1 thread in the whole process, no possible contention.
 	 */
 	dbi =  (dbinstance_t *) ((odbc_instance_t *) dbdata)->db;
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* if DBI is null, can't do anything else */
 	if (dbi == NULL) {
 		result = ISC_R_FAILURE;
@@ -698,14 +642,10 @@ odbc_get_resultset(const char *zone, const char *record,
 	if (dbi->client != NULL)
 		isc_mem_free(named_g_mctx, dbi->client);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if we are done using this dbi, release the lock */
 	if (result != ISC_R_SUCCESS)
 		isc_mutex_unlock(&dbi->instance_lock);
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* release query string */
 	if (querystring  != NULL)
 		isc_mem_free(named_g_mctx, querystring );
@@ -937,13 +877,9 @@ odbc_process_rs(dns_sdlzlookup_t *lookup, dbinstance_t *dbi)
 	/* close cursor */
 	SQLCloseCursor(((odbc_db_t *) (dbi->dbconn))->stmnt);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* free lock on dbi so someone else can use it. */
 	isc_mutex_unlock(&dbi->instance_lock);
 #endif
 	return result;
 }
@@ -980,11 +916,8 @@ odbc_findzone(void *driverarg, void *dbdata, const char *name,
 		/* get rid of result set, we are done with it. */
 		SQLCloseCursor(((odbc_db_t *) (dbi->dbconn))->stmnt);
 #ifdef ISC_PLATFORM_USETHREADS
 		/* free lock on dbi so someone else can use it. */
 		isc_mutex_unlock(&dbi->instance_lock);
 #endif
 	}
 	return result;
@@ -1032,11 +965,8 @@ odbc_allowzonexfr(void *driverarg, void *dbdata, const char *name,
 		/* get rid of result set, we are done with it. */
 		SQLCloseCursor(((odbc_db_t *) (dbi->dbconn))->stmnt);
 #ifdef ISC_PLATFORM_USETHREADS
 		/* free lock on dbi so someone else can use it. */
 		isc_mutex_unlock(&dbi->instance_lock);
 #endif
 	}
@@ -1167,13 +1097,9 @@ odbc_allnodes(const char *zone, void *driverarg, void *dbdata,
 	/* close cursor */
 	SQLCloseCursor(((odbc_db_t *) (dbi->dbconn))->stmnt);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* free lock on dbi so someone else can use it. */
 	isc_mutex_unlock(&dbi->instance_lock);
 #endif
 	return result;
 }
@@ -1252,29 +1178,17 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 	odbc_instance_t *odbc_inst = NULL;
 	dbinstance_t *db = NULL;
 	SQLRETURN sqlRes;
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if multi-threaded, we need a few extra variables. */
 	int dbcount;
 	int i;
 	char *endp;
 #endif /* ISC_PLATFORM_USETHREADS */
 	UNUSED(dlzname);
 	UNUSED(driverarg);
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if debugging, let user know we are multithreaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "Odbc driver running multithreaded");
 #else /* ISC_PLATFORM_USETHREADS */
 	/* if debugging, let user know we are single threaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "Odbc driver running single threaded");
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* verify we have at least 5 arg's passed to the driver */
 	if (argc < 5) {
@@ -1295,8 +1209,6 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 	}
 	/* multithreaded build can have multiple DB connections */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* check how many db connections we should create */
 	dbcount = strtol(argv[1], &endp, 10);
 	if (*endp != '\0' || dbcount < 0) {
@@ -1307,8 +1219,6 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 		return (ISC_R_FAILURE);
 	}
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* allocate memory for odbc instance */
 	odbc_inst = isc_mem_get(named_g_mctx, sizeof(odbc_instance_t));
 	if (odbc_inst == NULL)
@@ -1361,8 +1271,6 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 		}
 	}
 #ifdef ISC_PLATFORM_USETHREADS
 	/* allocate memory for database connection list */
 	odbc_inst->db = isc_mem_get(named_g_mctx, sizeof(db_list_t));
 	if (odbc_inst->db == NULL) {
@@ -1378,8 +1286,6 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 	/* append each new DBI to the end of the list */
 	for (i=0; i < dbcount; i++) {
 #endif /* ISC_PLATFORM_USETHREADS */
 		/* how many queries were passed in from config file? */
 		switch(argc) {
 		case 5:
@@ -1416,20 +1322,14 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 			goto cleanup;
 		}
 #ifdef ISC_PLATFORM_USETHREADS
 		/* when multithreaded, build a list of DBI's */
 		ISC_LINK_INIT(db, link);
 		ISC_LIST_APPEND(*odbc_inst->db, db, link);
 #endif
 		result = odbc_connect(odbc_inst, (odbc_db_t **) &(db->dbconn));
 		if (result != ISC_R_SUCCESS) {
 #ifdef ISC_PLATFORM_USETHREADS
 			/*
 			 * if multi threaded, let user know which
 			 * connection failed.  user could be
@@ -1442,28 +1342,14 @@ odbc_create(const char *dlzname, unsigned int argc, char *argv[],
 				      "Odbc driver failed to create database "
 				      "connection number %u after 3 attempts",
 				      i+1);
 #else
 			isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 				      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 				      "Odbc driver failed to create database "
 				      "connection after 3 attempts");
 #endif
 			goto cleanup;
 		}
 #ifdef ISC_PLATFORM_USETHREADS
 		/* set DB = null for next loop through. */
 		db = NULL;
 	}	/* end for loop */
 #else
 	/* tell odbc_inst about the db connection we just created. */
 	odbc_inst->db = db;
 #endif
 	/* set dbdata to the odbc_instance we created. */
 	*dbdata = odbc_inst;
@@ -149,8 +149,6 @@ postgres_makesafe(char *to, const char *from, size_t length)
 	return target - to;
 }
 #ifdef ISC_PLATFORM_USETHREADS
 /*%
 * Properly cleans up a list of database instances.
 * This function is only used when the driver is compiled for
@@ -225,8 +223,6 @@ postgres_find_avail_conn(db_list_t *dblist)
 	return NULL;
 }
 #endif /* ISC_PLATFORM_USETHREADS */
 /*%
 * Allocates memory for a new string, and then constructs the new
 * string by "escaping" the input string.  The new string is
@@ -298,21 +294,10 @@ postgres_get_resultset(const char *zone, const char *record,
 #endif
 	/* get db instance / connection */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* find an available DBI from the list */
 	dbi = postgres_find_avail_conn((db_list_t *) dbdata);
 #else /* ISC_PLATFORM_USETHREADS */
 	/*
 	 * only 1 DBI - no need to lock instance lock either
 	 * only 1 thread in the whole process, no possible contention.
 	 */
 	dbi =  (dbinstance_t *) dbdata;
 #endif /* ISC_PLATFORM_USETHREADS */
 #if 0
 	/* temporary logging message */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
@@ -599,8 +584,6 @@ postgres_get_resultset(const char *zone, const char *record,
 	if (dbi->client != NULL)
 		isc_mem_free(named_g_mctx, dbi->client);
 #ifdef ISC_PLATFORM_USETHREADS
 #if 0
 	/* temporary logging message */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
@@ -611,8 +594,6 @@ postgres_get_resultset(const char *zone, const char *record,
 	/* release the lock so another thread can use this dbi */
 	isc_mutex_unlock(&dbi->instance_lock);
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* release query string */
 	if (querystring  != NULL)
 		isc_mem_free(named_g_mctx, querystring );
@@ -1058,15 +1039,12 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 	dbinstance_t *dbi = NULL;
 	unsigned int j;
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if multi-threaded, we need a few extra variables. */
 	int dbcount;
 	db_list_t *dblist = NULL;
 	int i;
 	char *endp;
 #endif /* ISC_PLATFORM_USETHREADS */
 	UNUSED(driverarg);
 	UNUSED(dlzname);
@@ -1074,17 +1052,10 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 	srand( (unsigned)time( NULL ) );
 #ifdef ISC_PLATFORM_USETHREADS
 	/* if debugging, let user know we are multithreaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "Postgres driver running multithreaded");
 #else /* ISC_PLATFORM_USETHREADS */
 	/* if debugging, let user know we are single threaded. */
 	isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 		      DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1),
 		      "Postgres driver running single threaded");
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* verify we have at least 5 arg's passed to the driver */
 	if (argc < 5) {
@@ -1105,7 +1076,6 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 	}
 	/* multithreaded build can have multiple DB connections */
 #ifdef ISC_PLATFORM_USETHREADS
 	/* check how many db connections we should create */
 	dbcount = strtol(argv[1], &endp, 10);
@@ -1131,8 +1101,6 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 	 */
 	for (i=0; i < dbcount; i++) {
 #endif /* ISC_PLATFORM_USETHREADS */
 		/* how many queries were passed in from config file? */
 		switch(argc) {
 		case 5:
@@ -1174,14 +1142,10 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 			goto cleanup;
 		}
 #ifdef ISC_PLATFORM_USETHREADS
 		/* when multithreaded, build a list of DBI's */
 		ISC_LINK_INIT(dbi, link);
 		ISC_LIST_APPEND(*dblist, dbi, link);
 #endif
 		/* create and set db connection */
 		dbi->dbconn = PQconnectdb(argv[2]);
 		/*
@@ -1204,8 +1168,6 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 			PQreset((PGconn *) dbi->dbconn);
 #ifdef ISC_PLATFORM_USETHREADS
 		/*
 		 * if multi threaded, let user know which connection
 		 * failed.  user could be attempting to create 10 db
@@ -1229,30 +1191,11 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 		/* set dbdata to the list we created. */
 	*dbdata = dblist;
 #else /* ISC_PLATFORM_USETHREADS */
 	/* if single threaded, just let user know we couldn't connect. */
 	if (PQstatus((PGconn *) dbi->dbconn) != CONNECTION_OK) {
 		isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 			      DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
 			      "Postgres driver failed to create database "
 			      "connection after 4 attempts");
 		goto cleanup;
 	}
 	/*
 	 * single threaded build can only use 1 db connection, return
 	 * it via dbdata
 	 */
 	*dbdata = dbi;
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* hey, we got through all of that ok, return success. */
 	return(ISC_R_SUCCESS);
 cleanup:
 #ifdef ISC_PLATFORM_USETHREADS
 	/*
 	 * if multithreaded, we could fail because only 1 connection
 	 * couldn't be made.  We should cleanup the other successful
@@ -1260,11 +1203,6 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 	 */
 	postgres_destroy_dblist(dblist);
 #else /* ISC_PLATFORM_USETHREADS */
 	if (dbi != NULL)
 		destroy_sqldbinstance(dbi);
 #endif /* ISC_PLATFORM_USETHREADS */
 	return(ISC_R_FAILURE);
 }
@@ -1277,29 +1215,9 @@ postgres_create(const char *dlzname, unsigned int argc, char *argv[],
 static void
 postgres_destroy(void *driverarg, void *dbdata)
 {
 #ifdef ISC_PLATFORM_USETHREADS
 	UNUSED(driverarg);
 	/* cleanup the list of DBI's */
 	postgres_destroy_dblist((db_list_t *) dbdata);
 #else /* ISC_PLATFORM_USETHREADS */
 	dbinstance_t *dbi;
 	UNUSED(driverarg);
 	dbi = (dbinstance_t *) dbdata;
 	/* release DB connection */
 	if (dbi->dbconn != NULL)
 		PQfinish((PGconn *) dbi->dbconn);
 	/* destroy single DB instance */
 	destroy_sqldbinstance(dbi);
 #endif /* ISC_PLATFORM_USETHREADS */
 }
 /* pointers to all our runtime methods. */
@@ -68,11 +68,7 @@
 #include "dlz_minimal.h"
 /* should the bdb driver use threads. */
 #ifdef ISC_PLATFORM_USETHREADS
 #define bdbhpt_threads DB_THREAD
 #else
 #define bdbhpt_threads 0
 #endif
 /* bdbhpt database names */
 #define dlz_data   "dns_data"
@@ -1562,11 +1562,7 @@ issymmetric(const dst_key_t *key) {
 static void
 printtime(const dst_key_t *key, int type, const char *tag, FILE *stream) {
 	isc_result_t result;
 #ifdef ISC_PLATFORM_USETHREADS
 	char output[26]; /* Minimum buffer as per ctime_r() specification. */
 #else
 	const char *output;
 #endif
 	isc_stdtime_t when;
 	time_t t;
 	char utc[sizeof("YYYYMMDDHHSSMM")];
@@ -1579,7 +1575,6 @@ printtime(const dst_key_t *key, int type, const char *tag, FILE *stream) {
 	/* time_t and isc_stdtime_t might be different sizes */
 	t = when;
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef WIN32
 	if (ctime_s(output, sizeof(output), &t) != 0)
 		goto error;
@@ -1587,9 +1582,6 @@ printtime(const dst_key_t *key, int type, const char *tag, FILE *stream) {
 	if (ctime_r(&t, output) == NULL)
 		goto error;
 #endif
 #else
 	output = ctime(&t);
 #endif
 	isc_buffer_init(&b, utc, sizeof(utc));
 	result = dns_time32_totext(when, &b);
@@ -78,7 +78,6 @@ typedef struct geoip_state {
 	isc_mem_t *mctx;
 } geoip_state_t;
 #ifdef ISC_PLATFORM_USETHREADS
 static isc_mutex_t key_mutex;
 static bool state_key_initialized = false;
 static isc_thread_key_t state_key;
@@ -133,9 +132,6 @@ state_key_init(void) {
 	return (result);
 }
 #else
 static geoip_state_t saved_state;
 #endif
 static void
 clean_state(geoip_state_t *state) {
@@ -165,7 +161,6 @@ set_state(unsigned int family, uint32_t ipnum, const geoipv6_t *ipnum6,
 	  GeoIPRegion *region, char *name, const char *text, int id)
 {
 	geoip_state_t *state = NULL;
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_result_t result;
 	result = state_key_init();
@@ -189,10 +184,6 @@ set_state(unsigned int family, uint32_t ipnum, const geoipv6_t *ipnum6,
 		isc_mem_attach(state_mctx, &state->mctx);
 	} else
 		clean_state(state);
 #else
 	state = &saved_state;
 	clean_state(state);
 #endif
 	if (family == AF_INET) {
 		state->ipnum = ipnum;
@@ -218,7 +209,6 @@ get_state_for(unsigned int family, uint32_t ipnum,
 {
 	geoip_state_t *state;
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_result_t result;
 	result = state_key_init();
@@ -228,9 +218,6 @@ get_state_for(unsigned int family, uint32_t ipnum,
 	state = (geoip_state_t *) isc_thread_key_getspecific(state_key);
 	if (state == NULL)
 		return (NULL);
 #else
 	state = &saved_state;
 #endif
 	if (state->family == family &&
 	    ((state->family == AF_INET && state->ipnum == ipnum) ||
@@ -830,10 +817,8 @@ void
 dns_geoip_shutdown(void) {
 #ifdef HAVE_GEOIP
 	GeoIP_cleanup();
 #ifdef ISC_PLATFORM_USETHREADS
 	if (state_mctx != NULL)
 		isc_mem_detach(&state_mctx);
 #endif
 #else
 	return;
 #endif
@@ -165,15 +165,11 @@ LIBDNS_EXTERNAL_DATA const dns_name_t *dns_wildcardname = &wild;
 /*
 * dns_name_t to text post-conversion procedure.
 */
 #ifdef ISC_PLATFORM_USETHREADS
 static int thread_key_initialized = 0;
 static isc_mutex_t thread_key_mutex;
 static isc_mem_t *thread_key_mctx = NULL;
 static isc_thread_key_t totext_filter_proc_key;
 static isc_once_t once = ISC_ONCE_INIT;
 #else
 static dns_name_totextfilter_t totext_filter_proc = NULL;
 #endif
 static void
 set_offsets(const dns_name_t *name, unsigned char *offsets,
@@ -1277,7 +1273,6 @@ dns_name_fromtext(dns_name_t *name, isc_buffer_t *source,
 	return (ISC_R_SUCCESS);
 }
 #ifdef ISC_PLATFORM_USETHREADS
 static void
 free_specific(void *arg) {
 	dns_name_totextfilter_t *mem = arg;
@@ -1324,7 +1319,6 @@ totext_filter_proc_key_init(void) {
 	}
 	return (result);
 }
 #endif
 isc_result_t
 dns_name_totext(const dns_name_t *name, bool omit_final_dot,
@@ -1354,11 +1348,9 @@ dns_name_totext2(const dns_name_t *name, unsigned int options,
 	unsigned int labels;
 	bool saw_root = false;
 	unsigned int oused = target->used;
 #ifdef ISC_PLATFORM_USETHREADS
 	dns_name_totextfilter_t *mem;
 	dns_name_totextfilter_t totext_filter_proc = NULL;
 	isc_result_t result;
 #endif
 	bool omit_final_dot = (options & DNS_NAME_OMITFINALDOT);
 	/*
@@ -1368,11 +1360,9 @@ dns_name_totext2(const dns_name_t *name, unsigned int options,
 	REQUIRE(VALID_NAME(name));
 	REQUIRE(ISC_BUFFER_VALID(target));
 #ifdef ISC_PLATFORM_USETHREADS
 	result = totext_filter_proc_key_init();
 	if (result != ISC_R_SUCCESS)
 		return (result);
 #endif
 	ndata = name->ndata;
 	nlen = name->length;
 	labels = name->labels;
@@ -1512,11 +1502,9 @@ dns_name_totext2(const dns_name_t *name, unsigned int options,
 	}
 	isc_buffer_add(target, tlen - trem);
 #ifdef ISC_PLATFORM_USETHREADS
 	mem = isc_thread_key_getspecific(totext_filter_proc_key);
 	if (mem != NULL)
 		totext_filter_proc = *mem;
 #endif
 	if (totext_filter_proc != NULL)
 		return ((*totext_filter_proc)(target, oused));
@@ -2338,7 +2326,6 @@ dns_name_print(const dns_name_t *name, FILE *stream) {
 isc_result_t
 dns_name_settotextfilter(dns_name_totextfilter_t proc) {
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_result_t result;
 	dns_name_totextfilter_t *mem;
 	int res;
@@ -2374,10 +2361,6 @@ dns_name_settotextfilter(dns_name_totextfilter_t proc) {
 		result = ISC_R_UNEXPECTED;
 	}
 	return (result);
 #else
 	totext_filter_proc = proc;
 	return (ISC_R_SUCCESS);
 #endif
 }
 void
@@ -2527,7 +2510,6 @@ dns_name_copy(const dns_name_t *source, dns_name_t *dest, isc_buffer_t *target)
 void
 dns_name_destroy(void) {
 #ifdef ISC_PLATFORM_USETHREADS
 	RUNTIME_CHECK(isc_once_do(&once, thread_key_mutex_init)
 				  == ISC_R_SUCCESS);
@@ -2539,7 +2521,6 @@ dns_name_destroy(void) {
 	}
 	UNLOCK(&thread_key_mutex);
 #endif
 }
 /*
@@ -9856,7 +9856,6 @@ dns_resolver_create(dns_view_t *view,
 		}
 		res->buckets[i].mctx = NULL;
 		snprintf(name, sizeof(name), "res%u", i);
 #ifdef ISC_PLATFORM_USETHREADS
 		/*
 		 * Use a separate memory context for each bucket to reduce
 		 * contention among multiple threads.  Do this only when
@@ -9869,9 +9868,6 @@ dns_resolver_create(dns_view_t *view,
 			goto cleanup_buckets;
 		}
 		isc_mem_setname(res->buckets[i].mctx, name, NULL);
 #else
 		isc_mem_attach(view->mctx, &res->buckets[i].mctx);
 #endif
 		isc_task_setname(res->buckets[i].task, name, res);
 		ISC_LIST_INIT(res->buckets[i].fctxs);
 		res->buckets[i].exiting = false;
@@ -92,11 +92,7 @@ cleanup_managers(void) {
 static isc_result_t
 create_managers(void) {
 	isc_result_t result;
 #ifdef ISC_PLATFORM_USETHREADS
 	ncpus = isc_os_ncpus();
 #else
 	ncpus = 1;
 #endif
 	CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
 	CHECK(isc_timermgr_create(mctx, &timermgr));
@@ -648,7 +648,6 @@ ATF_TC_BODY(getlabelsequence, tc) {
 	}
 }
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef DNS_BENCHMARK_TESTS
 /*
@@ -744,7 +743,6 @@ ATF_TC_BODY(benchmark, tc) {
 }
 #endif /* DNS_BENCHMARK_TESTS */
 #endif /* ISC_PLATFORM_USETHREADS */
 /*
 * Main
@@ -762,11 +760,9 @@ ATF_TP_ADD_TCS(tp) {
 	ATF_TP_ADD_TC(tp, countlabels);
 	ATF_TP_ADD_TC(tp, getlabel);
 	ATF_TP_ADD_TC(tp, getlabelsequence);
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef DNS_BENCHMARK_TESTS
 	ATF_TP_ADD_TC(tp, benchmark);
 #endif /* DNS_BENCHMARK_TESTS */
 #endif /* ISC_PLATFORM_USETHREADS */
 	return (atf_no_error());
 }
@@ -1276,7 +1276,6 @@ ATF_TC_BODY(rbt_nodechain, tc) {
 	dns_test_end();
 }
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef DNS_BENCHMARK_TESTS
 /*
@@ -1404,7 +1403,6 @@ ATF_TC_BODY(benchmark, tc) {
 }
 #endif /* DNS_BENCHMARK_TESTS */
 #endif /* ISC_PLATFORM_USETHREADS */
 /*
 * Main
@@ -1422,11 +1420,9 @@ ATF_TP_ADD_TCS(tp) {
 	ATF_TP_ADD_TC(tp, rbt_addname);
 	ATF_TP_ADD_TC(tp, rbt_deletename);
 	ATF_TP_ADD_TC(tp, rbt_nodechain);
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef DNS_BENCHMARK_TESTS
 	ATF_TP_ADD_TC(tp, benchmark);
 #endif /* DNS_BENCHMARK_TESTS */
 #endif /* ISC_PLATFORM_USETHREADS */
 	return (atf_no_error());
 }
@@ -2055,7 +2055,7 @@ static isc_stdtime_t
 epoch_to_yyyymmdd(time_t when) {
 	struct tm *tm;
-#if defined(ISC_PLATFORM_USETHREADS) && !defined(WIN32)
+#if !defined(WIN32)
 	struct tm tm0;
 	tm = localtime_r(&when, &tm0);
 #else
@@ -10166,9 +10166,6 @@ dns_zone_markdirty(dns_zone_t *zone) {
 			if (result != ISC_R_SUCCESS) {
 				UNLOCK_ZONE(zone);
 				secure = NULL;
 #ifdef ISC_PLATFORM_USETHREADS
 				isc_thread_yield();
 #endif
 				goto again;
 			}
@@ -10434,9 +10431,6 @@ dump_done(void *arg, isc_result_t result) {
 			if (result != ISC_R_SUCCESS) {
 				UNLOCK_ZONE(zone);
 				secure = NULL;
 #if ISC_PLATFORM_USETHREADS
 				isc_thread_yield();
 #endif
 				goto again;
 			}
 		}
@@ -14967,9 +14961,6 @@ dns_zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump) {
 		if (result != ISC_R_SUCCESS) {
 			UNLOCK_ZONE(zone);
 			secure = NULL;
 #if ISC_PLATFORM_USETHREADS
 			isc_thread_yield();
 #endif
 			goto again;
 		}
 	}
@@ -15203,9 +15194,6 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
 		if (result != ISC_R_SUCCESS) {
 			UNLOCK_ZONE(zone);
 			secure = NULL;
 #if ISC_PLATFORM_USETHREADS
 			isc_thread_yield();
 #endif
 			goto again;
 		}
 	}
@@ -15468,9 +15456,6 @@ zone_loaddone(void *arg, isc_result_t result) {
 		if (result != ISC_R_SUCCESS) {
 			UNLOCK_ZONE(zone);
 			secure = NULL;
 #if ISC_PLATFORM_USETHREADS
 			isc_thread_yield();
 #endif
 			goto again;
 		}
 	}
@@ -18513,9 +18498,6 @@ dns_zone_dlzpostload(dns_zone_t *zone, dns_db_t *db)
 		if (result != ISC_R_SUCCESS) {
 			UNLOCK_ZONE(zone);
 			secure = NULL;
 #if ISC_PLATFORM_USETHREADS
 			isc_thread_yield();
 #endif
 			goto again;
 		}
 	}
@@ -45,14 +45,10 @@
 #define DNS_CONF "/etc/dns.conf"
 #endif
 #ifndef ISC_PLATFORM_USETHREADS
 irs_context_t *irs_g_context = NULL;
 #else
 static bool thread_key_initialized = false;
 static isc_mutex_t thread_key_mutex;
 static isc_thread_key_t irs_context_key;
 static isc_once_t once = ISC_ONCE_INIT;
 #endif
 struct irs_context {
@@ -128,7 +124,6 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
 	return (result);
 }
 #ifdef ISC_PLATFORM_USETHREADS
 static void
 free_specific_context(void *arg) {
 	irs_context_t *context = arg;
@@ -166,7 +161,6 @@ thread_key_init(void) {
 	return (result);
 }
 #endif /* ISC_PLATFORM_USETHREADS */
 isc_result_t
 irs_context_get(irs_context_t **contextp) {
@@ -175,15 +169,6 @@ irs_context_get(irs_context_t **contextp) {
 	REQUIRE(contextp != NULL && *contextp == NULL);
 #ifndef ISC_PLATFORM_USETHREADS
 	if (irs_g_context == NULL) {
 		result = irs_context_create(&irs_g_context);
 		if (result != ISC_R_SUCCESS)
 			return (result);
 	}
 	context = irs_g_context;
 #else
 	result = thread_key_init();
 	if (result != ISC_R_SUCCESS)
 		return (result);
@@ -199,7 +184,6 @@ irs_context_get(irs_context_t **contextp) {
 			return (result);
 		}
 	}
 #endif /* ISC_PLATFORM_USETHREADS */
 	*contextp = context;
@@ -328,11 +312,7 @@ irs_context_destroy(irs_context_t **contextp) {
 	*contextp = NULL;
 #ifndef ISC_PLATFORM_USETHREADS
 	irs_g_context = NULL;
 #else
 	(void)isc_thread_key_setspecific(irs_context_key, NULL);
 #endif
 }
 isc_mem_t *
@@ -18,7 +18,7 @@ VERSION=@BIND9_VERSION@
@BIND9_MAKE_INCLUDES@
 CINCLUDES =	-I${srcdir}/unix/include \
-		-I${srcdir}/@ISC_THREAD_DIR@/include \
+		-I${srcdir}/pthreads/include \
 		-I${srcdir}/@ISC_ARCH_DIR@/include \
 		-I./include \
 		-I${srcdir}/include ${DNS_INCLUDES} @OPENSSL_INCLUDES@
@@ -36,9 +36,9 @@ UNIXOBJS =	@ISC_ISCIPV6_O@ unix/pk11_api.@O@ \
 NLSOBJS =	nls/msgcat.@O@
-THREADOPTOBJS = @ISC_THREAD_DIR@/condition.@O@ @ISC_THREAD_DIR@/mutex.@O@
+THREADOPTOBJS = pthreads/condition.@O@ pthreads/mutex.@O@
-THREADOBJS =	@THREADOPTOBJS@ @ISC_THREAD_DIR@/thread.@O@
+THREADOBJS =	@THREADOPTOBJS@ pthreads/thread.@O@
 WIN32OBJS = 	win32/condition.@O@ win32/dir.@O@ win32/errno.@O@ \
 		win32/file.@O@ win32/fsaccess.@O@ \
@@ -85,7 +85,7 @@ LIBS =		@OPENSSL_LIBS@ @LIBS@
 # Attempt to disable parallel processing.
 .NOTPARALLEL:
 .NO_PARALLEL:
-SUBDIRS =	include unix nls @ISC_THREAD_DIR@ @ISC_ARCH_DIR@
+SUBDIRS =	include unix nls pthreads @ISC_ARCH_DIR@
 TARGETS =	timestamp
 TESTDIRS =	@UNITTESTS@
@@ -194,11 +194,6 @@
 *** Miscellaneous.
 ***/
 /*
 * Defined if we are using threads.
 */
@ISC_PLATFORM_USETHREADS@
 /*
 * Defined if unistd.h does not cause fd_set to be delared.
 */
@@ -94,7 +94,6 @@ 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))
@@ -253,44 +252,6 @@ typedef struct isc_refcount {
 	} 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))
 #define isc_refcount_increment0(rp, tp)					\
 	do {								\
 		unsigned int *_tmp = (unsigned int *)(tp);		\
 		int _n = ++(rp)->refs;					\
 		if (_tmp != NULL)					\
 			*_tmp = _n;					\
 	} while (0)
 #define isc_refcount_increment(rp, 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;					\
 		if (_tmp != NULL)					\
 			*_tmp = _n;					\
 	} while (0)
 #endif /* ISC_PLATFORM_USETHREADS */
 isc_result_t
 isc_refcount_init(isc_refcount_t *ref, unsigned int n);
@@ -34,7 +34,6 @@ typedef enum {
 	isc_rwlocktype_write
 } 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))
@@ -108,14 +107,6 @@ struct isc_rwlock {
 	isc_rwlocktype_t	original;
 #endif  /* ISC_RWLOCK_USEATOMIC */
 };
 #else /* ISC_PLATFORM_USETHREADS */
 struct isc_rwlock {
 	unsigned int		magic;
 	isc_rwlocktype_t	type;
 	unsigned int		active;
 };
 #endif /* ISC_PLATFORM_USETHREADS */
 isc_result_t
 isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
@@ -826,19 +826,11 @@ isc__task_register(void);
 * These functions allow unit tests to manipulate the processing
 * of the task queue. They are not intended as part of the public API.
 */
 #if defined(ISC_PLATFORM_USETHREADS)
 void
 isc__taskmgr_pause(isc_taskmgr_t *taskmgr);
 void
 isc__taskmgr_resume(isc_taskmgr_t *taskmgr);
 #else
 bool
 isc__taskmgr_ready(isc_taskmgr_t *taskmgr);
 isc_result_t
 isc__taskmgr_dispatch(isc_taskmgr_t *taskmgr);
 #endif /* !ISC_PLATFORM_USETHREADS */
 ISC_LANG_ENDDECLS
@@ -24,7 +24,7 @@ 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)
+#if !defined(ISC_REFCOUNT_HAVEATOMIC)
 	return (isc_mutex_init(&ref->lock));
 #else
 	return (ISC_R_SUCCESS);
@@ -29,8 +29,6 @@
 #define RWLOCK_MAGIC		ISC_MAGIC('R', 'W', 'L', 'k')
 #define VALID_RWLOCK(rwl)	ISC_MAGIC_VALID(rwl, RWLOCK_MAGIC)
 #ifdef ISC_PLATFORM_USETHREADS
 #ifndef RWLOCK_DEFAULT_READ_QUOTA
 #define RWLOCK_DEFAULT_READ_QUOTA 4
 #endif
@@ -892,91 +890,3 @@ isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 }
 #endif /* ISC_RWLOCK_USEATOMIC */
 #else /* ISC_PLATFORM_USETHREADS */
 isc_result_t
 isc_rwlock_init(isc_rwlock_t *rwl, unsigned int read_quota,
 		unsigned int write_quota)
 {
 	REQUIRE(rwl != NULL);
 	UNUSED(read_quota);
 	UNUSED(write_quota);
 	rwl->type = isc_rwlocktype_read;
 	rwl->active = 0;
 	rwl->magic = RWLOCK_MAGIC;
 	return (ISC_R_SUCCESS);
 }
 isc_result_t
 isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 	REQUIRE(VALID_RWLOCK(rwl));
 	if (type == isc_rwlocktype_read) {
 		if (rwl->type != isc_rwlocktype_read && rwl->active != 0)
 			return (ISC_R_LOCKBUSY);
 		rwl->type = isc_rwlocktype_read;
 		rwl->active++;
 	} else {
 		if (rwl->active != 0)
 			return (ISC_R_LOCKBUSY);
 		rwl->type = isc_rwlocktype_write;
 		rwl->active = 1;
 	}
 	return (ISC_R_SUCCESS);
 }
 isc_result_t
 isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 	return (isc_rwlock_lock(rwl, type));
 }
 isc_result_t
 isc_rwlock_tryupgrade(isc_rwlock_t *rwl) {
 	isc_result_t result = ISC_R_SUCCESS;
 	REQUIRE(VALID_RWLOCK(rwl));
 	REQUIRE(rwl->type == isc_rwlocktype_read);
 	REQUIRE(rwl->active != 0);
 	/* If we are the only reader then succeed. */
 	if (rwl->active == 1)
 		rwl->type = isc_rwlocktype_write;
 	else
 		result = ISC_R_LOCKBUSY;
 	return (result);
 }
 void
 isc_rwlock_downgrade(isc_rwlock_t *rwl) {
 	REQUIRE(VALID_RWLOCK(rwl));
 	REQUIRE(rwl->type == isc_rwlocktype_write);
 	REQUIRE(rwl->active == 1);
 	rwl->type = isc_rwlocktype_read;
 }
 isc_result_t
 isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
 	REQUIRE(VALID_RWLOCK(rwl));
 	REQUIRE(rwl->type == type);
 	UNUSED(type);
 	INSIST(rwl->active > 0);
 	rwl->active--;
 	return (ISC_R_SUCCESS);
 }
 void
 isc_rwlock_destroy(isc_rwlock_t *rwl) {
 	REQUIRE(rwl != NULL);
 	REQUIRE(rwl->active == 0);
 	rwl->magic = 0;
 }
 #endif /* ISC_PLATFORM_USETHREADS */
@@ -53,12 +53,6 @@
 * is expected to have a separate manager; no "worker threads" are shared by
 * the application threads.
 */
 #ifdef ISC_PLATFORM_USETHREADS
 #define USE_WORKER_THREADS
 #else
 #define USE_SHARED_MANAGER
 #endif	/* ISC_PLATFORM_USETHREADS */
 #ifdef ISC_TASK_TRACE
 #define XTRACE(m)		fprintf(stderr, "task %p thread %lu: %s\n", \
 				       task, isc_thread_self(), (m))
@@ -132,21 +126,17 @@ struct isc__taskmgr {
 	isc_taskmgr_t			common;
 	isc_mem_t *			mctx;
 	isc_mutex_t			lock;
 #ifdef ISC_PLATFORM_USETHREADS
 	unsigned int			workers;
 	isc_thread_t *			threads;
 #endif /* ISC_PLATFORM_USETHREADS */
 	/* Locked by task manager lock. */
 	unsigned int			default_quantum;
 	LIST(isc__task_t)		tasks;
 	isc__tasklist_t			ready_tasks;
 	isc__tasklist_t			ready_priority_tasks;
 	isc_taskmgrmode_t		mode;
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_condition_t			work_available;
 	isc_condition_t			exclusive_granted;
 	isc_condition_t			paused;
 #endif /* ISC_PLATFORM_USETHREADS */
 	unsigned int			tasks_running;
 	unsigned int			tasks_ready;
 	bool			pause_requested;
@@ -160,19 +150,12 @@ struct isc__taskmgr {
 	 */
 	isc_mutex_t			excl_lock;
 	isc__task_t			*excl;
 #ifdef USE_SHARED_MANAGER
 	unsigned int			refs;
 #endif /* ISC_PLATFORM_USETHREADS */
 };
 #define DEFAULT_TASKMGR_QUANTUM		10
 #define DEFAULT_DEFAULT_QUANTUM		5
 #define FINISHED(m)			((m)->exiting && EMPTY((m)->tasks))
 #ifdef USE_SHARED_MANAGER
 static isc__taskmgr_t *taskmgr = NULL;
 #endif /* USE_SHARED_MANAGER */
 /*%
 * The following are intended for internal use (indicated by "isc__"
 * prefix) but are not declared as static, allowing direct access from
@@ -314,7 +297,6 @@ task_finished(isc__task_t *task) {
 	LOCK(&manager->lock);
 	UNLINK(manager->tasks, task, link);
 #ifdef USE_WORKER_THREADS
 	if (FINISHED(manager)) {
 		/*
 		 * All tasks have completed and the
@@ -324,7 +306,6 @@ task_finished(isc__task_t *task) {
 		 */
 		BROADCAST(&manager->work_available);
 	}
 #endif /* USE_WORKER_THREADS */
 	UNLOCK(&manager->lock);
 	DESTROYLOCK(&task->lock);
@@ -461,9 +442,7 @@ task_shutdown(isc__task_t *task) {
 static inline void
 task_ready(isc__task_t *task) {
 	isc__taskmgr_t *manager = task->manager;
 #ifdef USE_WORKER_THREADS
 	bool has_privilege = isc__task_privilege((isc_task_t *) task);
 #endif /* USE_WORKER_THREADS */
 	REQUIRE(VALID_MANAGER(manager));
 	REQUIRE(task->state == task_state_ready);
@@ -472,10 +451,8 @@ task_ready(isc__task_t *task) {
 	LOCK(&manager->lock);
 	push_readyq(manager, task);
 #ifdef USE_WORKER_THREADS
 	if (manager->mode == isc_taskmgrmode_normal || has_privilege)
 		SIGNAL(&manager->work_available);
 #endif /* USE_WORKER_THREADS */
 	UNLOCK(&manager->lock);
 }
@@ -1001,12 +978,6 @@ push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
 static void
 dispatch(isc__taskmgr_t *manager) {
 	isc__task_t *task;
 #ifndef USE_WORKER_THREADS
 	unsigned int total_dispatch_count = 0;
 	isc__tasklist_t new_ready_tasks;
 	isc__tasklist_t new_priority_tasks;
 	unsigned int tasks_ready = 0;
 #endif /* USE_WORKER_THREADS */
 	REQUIRE(VALID_MANAGER(manager));
@@ -1060,14 +1031,9 @@ dispatch(isc__taskmgr_t *manager) {
 	 * unlocks.  The while expression is always protected by the lock.
 	 */
 #ifndef USE_WORKER_THREADS
 	ISC_LIST_INIT(new_ready_tasks);
 	ISC_LIST_INIT(new_priority_tasks);
 #endif
 	LOCK(&manager->lock);
 	while (!FINISHED(manager)) {
 #ifdef USE_WORKER_THREADS
 		/*
 		 * For reasons similar to those given in the comment in
 		 * isc_task_send() above, it is safe for us to dequeue
@@ -1089,11 +1055,6 @@ dispatch(isc__taskmgr_t *manager) {
 						    ISC_MSGSET_TASK,
 						    ISC_MSG_AWAKE, "awake"));
 		}
 #else /* USE_WORKER_THREADS */
 		if (total_dispatch_count >= DEFAULT_TASKMGR_QUANTUM ||
 		    empty_readyq(manager))
 			break;
 #endif /* USE_WORKER_THREADS */
 		XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TASK,
 					    ISC_MSG_WORKING, "working"));
@@ -1144,9 +1105,6 @@ dispatch(isc__taskmgr_t *manager) {
 						LOCK(&task->lock);
 					}
 					dispatch_count++;
 #ifndef USE_WORKER_THREADS
 					total_dispatch_count++;
 #endif /* USE_WORKER_THREADS */
 				}
 				if (task->references == 0 &&
@@ -1231,7 +1189,6 @@ dispatch(isc__taskmgr_t *manager) {
 			LOCK(&manager->lock);
 			manager->tasks_running--;
 #ifdef USE_WORKER_THREADS
 			if (manager->exclusive_requested &&
 			    manager->tasks_running == 1) {
 				SIGNAL(&manager->exclusive_granted);
@@ -1239,7 +1196,6 @@ dispatch(isc__taskmgr_t *manager) {
 				   manager->tasks_running == 0) {
 				SIGNAL(&manager->paused);
 			}
 #endif /* USE_WORKER_THREADS */
 			if (requeue) {
 				/*
 				 * We know we're awake, so we don't have
@@ -1260,19 +1216,10 @@ dispatch(isc__taskmgr_t *manager) {
 				 * were usually nonempty, the 'optimization'
 				 * might even hurt rather than help.
 				 */
 #ifdef USE_WORKER_THREADS
 				push_readyq(manager, task);
 #else
 				ENQUEUE(new_ready_tasks, task, ready_link);
 				if ((task->flags & TASK_F_PRIVILEGED) != 0)
 					ENQUEUE(new_priority_tasks, task,
 						ready_priority_link);
 				tasks_ready++;
 #endif
 			}
 		}
 #ifdef USE_WORKER_THREADS
 		/*
 		 * If we are in privileged execution mode and there are no
 		 * tasks remaining on the current ready queue, then
@@ -1284,22 +1231,11 @@ dispatch(isc__taskmgr_t *manager) {
 			if (!empty_readyq(manager))
 				BROADCAST(&manager->work_available);
 		}
 #endif
 	}
 #ifndef USE_WORKER_THREADS
 	ISC_LIST_APPENDLIST(manager->ready_tasks, new_ready_tasks, ready_link);
 	ISC_LIST_APPENDLIST(manager->ready_priority_tasks, new_priority_tasks,
 			    ready_priority_link);
 	manager->tasks_ready += tasks_ready;
 	if (empty_readyq(manager))
 		manager->mode = isc_taskmgrmode_normal;
 #endif
 	UNLOCK(&manager->lock);
 }
 #ifdef USE_WORKER_THREADS
 static isc_threadresult_t
 #ifdef _WIN32
 WINAPI
@@ -1321,18 +1257,15 @@ run(void *uap) {
 	return ((isc_threadresult_t)0);
 }
 #endif /* USE_WORKER_THREADS */
 static void
 manager_free(isc__taskmgr_t *manager) {
 	isc_mem_t *mctx;
 #ifdef USE_WORKER_THREADS
 	(void)isc_condition_destroy(&manager->exclusive_granted);
 	(void)isc_condition_destroy(&manager->work_available);
 	(void)isc_condition_destroy(&manager->paused);
 	isc_mem_free(manager->mctx, manager->threads);
 #endif /* USE_WORKER_THREADS */
 	DESTROYLOCK(&manager->lock);
 	DESTROYLOCK(&manager->excl_lock);
 	manager->common.impmagic = 0;
@@ -1340,10 +1273,6 @@ manager_free(isc__taskmgr_t *manager) {
 	mctx = manager->mctx;
 	isc_mem_put(mctx, manager, sizeof(*manager));
 	isc_mem_detach(&mctx);
 #ifdef USE_SHARED_MANAGER
 	taskmgr = NULL;
 #endif	/* USE_SHARED_MANAGER */
 }
 isc_result_t
@@ -1361,21 +1290,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	REQUIRE(workers > 0);
 	REQUIRE(managerp != NULL && *managerp == NULL);
 #ifndef USE_WORKER_THREADS
 	UNUSED(i);
 	UNUSED(started);
 #endif
 #ifdef USE_SHARED_MANAGER
 	if (taskmgr != NULL) {
 		if (taskmgr->refs == 0)
 			return (ISC_R_SHUTTINGDOWN);
 		taskmgr->refs++;
 		*managerp = (isc_taskmgr_t *)taskmgr;
 		return (ISC_R_SUCCESS);
 	}
 #endif /* USE_SHARED_MANAGER */
 	manager = isc_mem_get(mctx, sizeof(*manager));
 	if (manager == NULL)
 		return (ISC_R_NOMEMORY);
@@ -1393,7 +1307,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 		goto cleanup_mgr;
 	}
 #ifdef USE_WORKER_THREADS
 	manager->workers = 0;
 	manager->threads = isc_mem_allocate(mctx,
 					    workers * sizeof(isc_thread_t));
@@ -1425,7 +1338,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 		result = ISC_R_UNEXPECTED;
 		goto cleanup_exclusivegranted;
 	}
 #endif /* USE_WORKER_THREADS */
 	if (default_quantum == 0)
 		default_quantum = DEFAULT_DEFAULT_QUANTUM;
 	manager->default_quantum = default_quantum;
@@ -1441,7 +1353,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	isc_mem_attach(mctx, &manager->mctx);
 #ifdef USE_WORKER_THREADS
 	LOCK(&manager->lock);
 	/*
 	 * Start workers.
@@ -1465,17 +1376,11 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 		return (ISC_R_NOTHREADS);
 	}
 	isc_thread_setconcurrency(workers);
 #endif /* USE_WORKER_THREADS */
 #ifdef USE_SHARED_MANAGER
 	manager->refs = 1;
 	taskmgr = manager;
 #endif /* USE_SHARED_MANAGER */
 	*managerp = (isc_taskmgr_t *)manager;
 	return (ISC_R_SUCCESS);
 #ifdef USE_WORKER_THREADS
 cleanup_exclusivegranted:
 	(void)isc_condition_destroy(&manager->exclusive_granted);
 cleanup_workavailable:
@@ -1484,7 +1389,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	isc_mem_free(mctx, manager->threads);
 cleanup_lock:
 	DESTROYLOCK(&manager->lock);
 #endif
 cleanup_mgr:
 	isc_mem_put(mctx, manager, sizeof(*manager));
 	return (result);
@@ -1504,18 +1408,6 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
 	manager = (isc__taskmgr_t *)*managerp;
 	REQUIRE(VALID_MANAGER(manager));
 #ifndef USE_WORKER_THREADS
 	UNUSED(i);
 #endif /* USE_WORKER_THREADS */
 #ifdef USE_SHARED_MANAGER
 	manager->refs--;
 	if (manager->refs > 0) {
 		*managerp = NULL;
 		return;
 	}
 #endif
 	XTHREADTRACE("isc_taskmgr_destroy");
 	/*
 	 * Only one non-worker thread may ever call this routine.
@@ -1567,7 +1459,6 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
 			push_readyq(manager, task);
 		UNLOCK(&task->lock);
 	}
 #ifdef USE_WORKER_THREADS
 	/*
 	 * Wake up any sleeping workers.  This ensures we get work done if
 	 * there's work left to do, and if there are already no tasks left
@@ -1581,28 +1472,6 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
 	 */
 	for (i = 0; i < manager->workers; i++)
 		(void)isc_thread_join(manager->threads[i], NULL);
 #else /* USE_WORKER_THREADS */
 	/*
 	 * Dispatch the shutdown events.
 	 */
 	UNLOCK(&manager->lock);
 	while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
 		(void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
 	if (!ISC_LIST_EMPTY(manager->tasks)) {
 		isc__task_t *t;
 		isc_mem_printallactive(stderr);
 		for (t = ISC_LIST_HEAD(manager->tasks);
 		     t != NULL;
 		     t = ISC_LIST_NEXT(t, link))
 		{
 			fprintf(stderr, "task: %p (%s)\n", t, t->name);
 		}
 	}
 	INSIST(ISC_LIST_EMPTY(manager->tasks));
 #ifdef USE_SHARED_MANAGER
 	taskmgr = NULL;
 #endif
 #endif /* USE_WORKER_THREADS */
 	manager_free(manager);
@@ -1628,43 +1497,6 @@ isc__taskmgr_mode(isc_taskmgr_t *manager0) {
 	return (mode);
 }
 #ifndef USE_WORKER_THREADS
 bool
 isc__taskmgr_ready(isc_taskmgr_t *manager0) {
 	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
 	bool is_ready;
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = taskmgr;
 #endif
 	if (manager == NULL)
 		return (false);
 	LOCK(&manager->lock);
 	is_ready = !empty_readyq(manager);
 	UNLOCK(&manager->lock);
 	return (is_ready);
 }
 isc_result_t
 isc__taskmgr_dispatch(isc_taskmgr_t *manager0) {
 	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = taskmgr;
 #endif
 	if (manager == NULL)
 		return (ISC_R_NOTFOUND);
 	dispatch(manager);
 	return (ISC_R_SUCCESS);
 }
 #else
 void
 isc__taskmgr_pause(isc_taskmgr_t *manager0) {
 	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
@@ -1687,7 +1519,6 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0) {
 	}
 	UNLOCK(&manager->lock);
 }
 #endif /* USE_WORKER_THREADS */
 void
 isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
@@ -1723,7 +1554,6 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
 isc_result_t
 isc__task_beginexclusive(isc_task_t *task0) {
 #ifdef USE_WORKER_THREADS
 	isc__task_t *task = (isc__task_t *)task0;
 	isc__taskmgr_t *manager = task->manager;
@@ -1743,15 +1573,11 @@ isc__task_beginexclusive(isc_task_t *task0) {
 		WAIT(&manager->exclusive_granted, &manager->lock);
 	}
 	UNLOCK(&manager->lock);
 #else
 	UNUSED(task0);
 #endif
 	return (ISC_R_SUCCESS);
 }
 void
 isc__task_endexclusive(isc_task_t *task0) {
 #ifdef USE_WORKER_THREADS
 	isc__task_t *task = (isc__task_t *)task0;
 	isc__taskmgr_t *manager = task->manager;
@@ -1761,9 +1587,6 @@ isc__task_endexclusive(isc_task_t *task0) {
 	manager->exclusive_requested = false;
 	BROADCAST(&manager->work_available);
 	UNLOCK(&manager->lock);
 #else
 	UNUSED(task0);
 #endif
 }
 void
@@ -1833,7 +1656,6 @@ isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
 	 * on which type is enabled.
 	 */
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "thread-model"));
 #ifdef ISC_PLATFORM_USETHREADS
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "type"));
 	TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "threaded"));
 	TRY0(xmlTextWriterEndElement(writer)); /* type */
@@ -1841,15 +1663,6 @@ isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "worker-threads"));
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->workers));
 	TRY0(xmlTextWriterEndElement(writer)); /* worker-threads */
 #else /* ISC_PLATFORM_USETHREADS */
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "type"));
 	TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "non-threaded"));
 	TRY0(xmlTextWriterEndElement(writer)); /* type */
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "references"));
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->refs));
 	TRY0(xmlTextWriterEndElement(writer)); /* references */
 #endif /* ISC_PLATFORM_USETHREADS */
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "default-quantum"));
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d",
@@ -1942,7 +1755,6 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
 	 * Write out the thread-model, and some details about each depending
 	 * on which type is enabled.
 	 */
 #ifdef ISC_PLATFORM_USETHREADS
 	obj = json_object_new_string("threaded");
 	CHECKMEM(obj);
 	json_object_object_add(tasks, "thread-model", obj);
@@ -1950,15 +1762,6 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
 	obj = json_object_new_int(mgr->workers);
 	CHECKMEM(obj);
 	json_object_object_add(tasks, "worker-threads", obj);
 #else /* ISC_PLATFORM_USETHREADS */
 	obj = json_object_new_string("non-threaded");
 	CHECKMEM(obj);
 	json_object_object_add(tasks, "thread-model", obj);
 	obj = json_object_new_int(mgr->refs);
 	CHECKMEM(obj);
 	json_object_object_add(tasks, "references", obj);
 #endif /* ISC_PLATFORM_USETHREADS */
 	obj = json_object_new_int(mgr->default_quantum);
 	CHECKMEM(obj);
@@ -72,11 +72,7 @@ create_managers(unsigned int workers) {
 	char *p;
 	if (workers == 0) {
 #ifdef ISC_PLATFORM_USETHREADS
 		workers = isc_os_ncpus();
 #else
 		workers = 1;
 #endif
 	}
 	p = getenv("ISC_TASK_WORKERS");
@@ -125,11 +121,7 @@ isc_test_begin(FILE *logfile, bool start_managers,
 		CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL));
 	}
 #ifdef ISC_PLATFORM_USETHREADS
 	ncpus = isc_os_ncpus();
 #else
 	ncpus = 1;
 #endif
 	if (start_managers) {
 		CHECK(create_managers(workers));
@@ -86,10 +86,6 @@ static isc_result_t
 waitfor(completion_t *completion) {
 	int i = 0;
 	while (!completion->done && i++ < 5000) {
 #ifndef ISC_PLATFORM_USETHREADS
 		while (isc__taskmgr_ready(taskmgr))
 			isc__taskmgr_dispatch(taskmgr);
 #endif
 		isc_test_nap(1000);
 	}
 	if (completion->done)
@@ -112,19 +108,6 @@ waitfor(completion_t *completion) {
 static void
 waitbody(void) {
 #ifndef ISC_PLATFORM_USETHREADS
 	struct timeval tv;
 	isc_socketwait_t *swait = NULL;
 	while (isc__taskmgr_ready(taskmgr))
 		isc__taskmgr_dispatch(taskmgr);
 	if (socketmgr != NULL) {
 		tv.tv_sec = 0;
 		tv.tv_usec = 1000 ;
 		if (isc__socketmgr_waitevents(socketmgr, &tv, &swait) > 0)
 			isc__socketmgr_dispatch(socketmgr, swait);
 	} else
 #endif
 		isc_test_nap(1000);
 }
@@ -40,9 +40,7 @@ int counter = 0;
 static int active[10];
 static bool done = false;
 #ifdef ISC_PLATFORM_USETHREADS
 static isc_condition_t cv;
 #endif
 static void
 set(isc_task_t *task, isc_event_t *event) {
@@ -138,10 +136,6 @@ ATF_TC_BODY(all_events, tc) {
 	isc_task_send(task, &event);
 	while ((a == 0 || b == 0) && i++ < 5000) {
 #ifndef ISC_PLATFORM_USETHREADS
 		while (isc__taskmgr_ready(taskmgr))
 			isc__taskmgr_dispatch(taskmgr);
 #endif
 		isc_test_nap(1000);
 	}
@@ -175,13 +169,11 @@ ATF_TC_BODY(privileged_events, tc) {
 	result = isc_test_begin(NULL, true, 0);
 	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 #ifdef ISC_PLATFORM_USETHREADS
 	/*
 	 * Pause the task manager so we can fill up the work queue
 	 * without things happening while we do it.
 	 */
 	isc__taskmgr_pause(taskmgr);
 #endif
 	result = isc_task_create(taskmgr, 0, &task1);
 	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
@@ -239,16 +231,10 @@ ATF_TC_BODY(privileged_events, tc) {
 	isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged);
 	ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
 #ifdef ISC_PLATFORM_USETHREADS
 	isc__taskmgr_resume(taskmgr);
 #endif
 	/* We're waiting for *all* variables to be set */
 	while ((a == 0 || b == 0 || c == 0 || d == 0 || e == 0) && i++ < 5000) {
 #ifndef ISC_PLATFORM_USETHREADS
 		while (isc__taskmgr_ready(taskmgr))
 			isc__taskmgr_dispatch(taskmgr);
 #endif
 		isc_test_nap(1000);
 	}
@@ -304,13 +290,11 @@ ATF_TC_BODY(privilege_drop, tc) {
 	result = isc_test_begin(NULL, true, 0);
 	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 #ifdef ISC_PLATFORM_USETHREADS
 	/*
 	 * Pause the task manager so we can fill up the work queue
 	 * without things happening while we do it.
 	 */
 	isc__taskmgr_pause(taskmgr);
 #endif
 	result = isc_task_create(taskmgr, 0, &task1);
 	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
@@ -368,17 +352,11 @@ ATF_TC_BODY(privilege_drop, tc) {
 	isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged);
 	ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
 #ifdef ISC_PLATFORM_USETHREADS
 	isc__taskmgr_resume(taskmgr);
 #endif
 	/* We're waiting for all variables to be set. */
 	while ((a == -1 || b == -1 || c == -1 || d == -1 || e == -1) &&
 	       i++ < 5000) {
 #ifndef ISC_PLATFORM_USETHREADS
 		while (isc__taskmgr_ready(taskmgr))
 			isc__taskmgr_dispatch(taskmgr);
 #endif
 		isc_test_nap(1000);
 	}
@@ -645,10 +623,6 @@ ATF_TC_BODY(task_exclusive, tc) {
 	isc_test_end();
 }
 /*
 * The remainder of these tests require threads
 */
 #ifdef ISC_PLATFORM_USETHREADS
 /*
 * Max tasks test:
 * The task system can create and execute many tasks. Tests with 10000.
@@ -1446,7 +1420,6 @@ ATF_TC_HEAD(purgeevent_notpurge, tc) {
 ATF_TC_BODY(purgeevent_notpurge, tc) {
 	try_purgeevent(false);
 }
 #endif
 /*
 * Main
@@ -1458,8 +1431,6 @@ ATF_TP_ADD_TCS(tp) {
 	ATF_TP_ADD_TC(tp, privilege_drop);
 	ATF_TP_ADD_TC(tp, basic);
 	ATF_TP_ADD_TC(tp, task_exclusive);
 #ifdef ISC_PLATFORM_USETHREADS
 	ATF_TP_ADD_TC(tp, manytasks);
 	ATF_TP_ADD_TC(tp, shutdown);
 	ATF_TP_ADD_TC(tp, post_shutdown);
@@ -1467,8 +1438,6 @@ ATF_TP_ADD_TCS(tp) {
 	ATF_TP_ADD_TC(tp, purgerange);
 	ATF_TP_ADD_TC(tp, purgeevent);
 	ATF_TP_ADD_TC(tp, purgeevent_notpurge);
 #endif
 	return (atf_no_error());
 }
@@ -29,11 +29,6 @@
 #include "isctest.h"
 /*
 * This entire test requires threads.
 */
 #ifdef ISC_PLATFORM_USETHREADS
 /*
 * Helper functions
 */
@@ -564,30 +559,15 @@ ATF_TC_BODY(purge, tc) {
 	isc_test_end();
 }
 #else
 ATF_TC(untested);
 ATF_TC_HEAD(untested, tc) {
 	atf_tc_set_md_var(tc, "descr", "skipping nsec3 test");
 }
 ATF_TC_BODY(untested, tc) {
 	UNUSED(tc);
 	atf_tc_skip("DNSSEC not available");
 }
 #endif
 /*
 * Main
 */
 ATF_TP_ADD_TCS(tp) {
 #ifdef ISC_PLATFORM_USETHREADS
 	ATF_TP_ADD_TC(tp, ticker);
 	ATF_TP_ADD_TC(tp, once_life);
 	ATF_TP_ADD_TC(tp, once_idle);
 	ATF_TP_ADD_TC(tp, reset);
 	ATF_TP_ADD_TC(tp, purge);
 #else
 	ATF_TP_ADD_TC(tp, untested);
 #endif
 	return (atf_no_error());
 }
@@ -36,17 +36,6 @@
 #include <openssl/err.h>
 #endif
 /* See task.c about the following definition: */
 #ifdef ISC_PLATFORM_USETHREADS
 #define USE_TIMER_THREAD
 #else
 #define USE_SHARED_MANAGER
 #endif	/* ISC_PLATFORM_USETHREADS */
 #ifndef USE_TIMER_THREAD
 #include "timer_p.h"
 #endif /* USE_TIMER_THREAD */
 #ifdef ISC_TIMER_TRACE
 #define XTRACE(s)			fprintf(stderr, "%s\n", (s))
 #define XTRACEID(s, t)			fprintf(stderr, "%s %p\n", (s), (t))
@@ -103,13 +92,8 @@ struct isc__timermgr {
 	LIST(isc__timer_t)		timers;
 	unsigned int			nscheduled;
 	isc_time_t			due;
 #ifdef USE_TIMER_THREAD
 	isc_condition_t			wakeup;
 	isc_thread_t			thread;
 #endif	/* USE_TIMER_THREAD */
 #ifdef USE_SHARED_MANAGER
 	unsigned int			refs;
 #endif /* USE_SHARED_MANAGER */
 	isc_heap_t *			heap;
 };
@@ -171,22 +155,13 @@ static struct isc__timermgrmethods {
 	(void *)isc_timermgr_poke
 };
 #ifdef USE_SHARED_MANAGER
 /*!
 * If the manager is supposed to be shared, there can be only one.
 */
 static isc__timermgr_t *timermgr = NULL;
 #endif /* USE_SHARED_MANAGER */
 static inline isc_result_t
 schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
 	isc_result_t result;
 	isc__timermgr_t *manager;
 	isc_time_t due;
 	int cmp;
 #ifdef USE_TIMER_THREAD
 	bool timedwait;
 #endif
 	/*!
 	 * Note: the caller must ensure locking.
@@ -194,20 +169,16 @@ schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
 	REQUIRE(timer->type != isc_timertype_inactive);
 #ifndef USE_TIMER_THREAD
 	UNUSED(signal_ok);
 #endif /* USE_TIMER_THREAD */
 	manager = timer->manager;
 #ifdef USE_TIMER_THREAD
 	/*!
 	 * If the manager was timed wait, we may need to signal the
 	 * manager to force a wakeup.
 	 */
 	timedwait = (manager->nscheduled > 0 &&
 		     isc_time_seconds(&manager->due) != 0);
 #endif
 	/*
 	 * Compute the new due time.
@@ -270,7 +241,6 @@ schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
 	 * the current "next" timer.  We do this either by waking up the
 	 * run thread, or explicitly setting the value in the manager.
 	 */
 #ifdef USE_TIMER_THREAD
 	/*
 	 * This is a temporary (probably) hack to fix a bug on tru64 5.1
@@ -303,20 +273,13 @@ schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
 				      "signal (schedule)"));
 		SIGNAL(&manager->wakeup);
 	}
 #else /* USE_TIMER_THREAD */
 	if (timer->index == 1 &&
 	    isc_time_compare(&timer->due, &manager->due) < 0)
 		manager->due = timer->due;
 #endif /* USE_TIMER_THREAD */
 	return (ISC_R_SUCCESS);
 }
 static inline void
 deschedule(isc__timer_t *timer) {
 #ifdef USE_TIMER_THREAD
 	bool need_wakeup = false;
 #endif
 	isc__timermgr_t *manager;
 	/*
@@ -325,22 +288,18 @@ deschedule(isc__timer_t *timer) {
 	manager = timer->manager;
 	if (timer->index > 0) {
 #ifdef USE_TIMER_THREAD
 		if (timer->index == 1)
 			need_wakeup = true;
 #endif
 		isc_heap_delete(manager->heap, timer->index);
 		timer->index = 0;
 		INSIST(manager->nscheduled > 0);
 		manager->nscheduled--;
 #ifdef USE_TIMER_THREAD
 		if (need_wakeup) {
 			XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 					      ISC_MSG_SIGNALDESCHED,
 					      "signal (deschedule)"));
 			SIGNAL(&manager->wakeup);
 		}
 #endif /* USE_TIMER_THREAD */
 	}
 }
@@ -777,7 +736,6 @@ dispatch(isc__timermgr_t *manager, isc_time_t *now) {
 	}
 }
 #ifdef USE_TIMER_THREAD
 static isc_threadresult_t
 #ifdef _WIN32			/* XXXDCL */
 WINAPI
@@ -822,7 +780,6 @@ run(void *uap) {
 	return ((isc_threadresult_t)0);
 }
 #endif /* USE_TIMER_THREAD */
 static bool
 sooner(void *v1, void *v2) {
@@ -859,14 +816,6 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 	REQUIRE(managerp != NULL && *managerp == NULL);
 #ifdef USE_SHARED_MANAGER
 	if (timermgr != NULL) {
 		timermgr->refs++;
 		*managerp = (isc_timermgr_t *)timermgr;
 		return (ISC_R_SUCCESS);
 	}
 #endif /* USE_SHARED_MANAGER */
 	manager = isc_mem_get(mctx, sizeof(*manager));
 	if (manager == NULL)
 		return (ISC_R_NOMEMORY);
@@ -893,7 +842,6 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 		return (result);
 	}
 	isc_mem_attach(mctx, &manager->mctx);
 #ifdef USE_TIMER_THREAD
 	if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
 		isc_mem_detach(&manager->mctx);
 		DESTROYLOCK(&manager->lock);
@@ -919,11 +867,6 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 		return (ISC_R_UNEXPECTED);
 	}
 	isc_thread_setname(manager->thread, "isc-timer");
 #endif
 #ifdef USE_SHARED_MANAGER
 	manager->refs = 1;
 	timermgr = manager;
 #endif /* USE_SHARED_MANAGER */
 	*managerp = (isc_timermgr_t *)manager;
@@ -932,15 +875,11 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 void
 isc_timermgr_poke(isc_timermgr_t *manager0) {
 #ifdef USE_TIMER_THREAD
 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
 	REQUIRE(VALID_MANAGER(manager));
 	SIGNAL(&manager->wakeup);
 #else
 	UNUSED(manager0);
 #endif
 }
 void
@@ -958,32 +897,15 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 	LOCK(&manager->lock);
 #ifdef USE_SHARED_MANAGER
 	manager->refs--;
 	if (manager->refs > 0) {
 		UNLOCK(&manager->lock);
 		*managerp = NULL;
 		return;
 	}
 	timermgr = NULL;
 #endif /* USE_SHARED_MANAGER */
 #ifndef USE_TIMER_THREAD
 	isc__timermgr_dispatch((isc_timermgr_t *)manager);
 #endif
 	REQUIRE(EMPTY(manager->timers));
 	manager->done = true;
 #ifdef USE_TIMER_THREAD
 	XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 			      ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
 	SIGNAL(&manager->wakeup);
 #endif /* USE_TIMER_THREAD */
 	UNLOCK(&manager->lock);
 #ifdef USE_TIMER_THREAD
 	/*
 	 * Wait for thread to exit.
 	 */
@@ -992,14 +914,11 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 				 "isc_thread_join() %s",
 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 						ISC_MSG_FAILED, "failed"));
 #endif /* USE_TIMER_THREAD */
 	/*
 	 * Clean up.
 	 */
 #ifdef USE_TIMER_THREAD
 	(void)isc_condition_destroy(&manager->wakeup);
 #endif /* USE_TIMER_THREAD */
 	DESTROYLOCK(&manager->lock);
 	isc_heap_destroy(&manager->heap);
 	manager->common.impmagic = 0;
@@ -1010,42 +929,8 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
 	*managerp = NULL;
 #ifdef USE_SHARED_MANAGER
 	timermgr = NULL;
 #endif
 }
 #ifndef USE_TIMER_THREAD
 isc_result_t
 isc__timermgr_nextevent(isc_timermgr_t *manager0, isc_time_t *when) {
 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = timermgr;
 #endif
 	if (manager == NULL || manager->nscheduled == 0)
 		return (ISC_R_NOTFOUND);
 	*when = manager->due;
 	return (ISC_R_SUCCESS);
 }
 void
 isc__timermgr_dispatch(isc_timermgr_t *manager0) {
 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
 	isc_time_t now;
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = timermgr;
 #endif
 	if (manager == NULL)
 		return;
 	TIME_NOW(&now);
 	dispatch(manager, &now);
 }
 #endif /* USE_TIMER_THREAD */
 isc_result_t
 isc__timer_register(void) {
 	return (isc_timer_register(isc__timermgr_create));
@@ -12,7 +12,7 @@ VPATH =		@srcdir@
 top_srcdir =	@top_srcdir@
 CINCLUDES =	-I${srcdir}/include \
-		-I${srcdir}/../@ISC_THREAD_DIR@/include \
+		-I${srcdir}/../pthreads/include \
 		-I../include \
 		-I${srcdir}/../include \
 		-I${srcdir}/.. @OPENSSL_INCLUDES@
@@ -41,9 +41,7 @@
 #include <isc/time.h>
 #include <isc/util.h>
 #ifdef ISC_PLATFORM_USETHREADS
 #include <pthread.h>
 #endif
 /*%
 * For BIND9 internal applications built with threads, we use a single app
@@ -51,14 +49,7 @@
 * For other cases (including BIND9 built without threads) an app context acts
 * as an event loop dispatching various events.
 */
 #ifndef ISC_PLATFORM_USETHREADS
 #include "../timer_p.h"
 #include "socket_p.h"
 #endif /* ISC_PLATFORM_USETHREADS */
 #ifdef ISC_PLATFORM_USETHREADS
 static pthread_t		blockedthread;
 #endif /* ISC_PLATFORM_USETHREADS */
 /*%
 * The following are intended for internal use (indicated by "isc__"
@@ -117,10 +108,8 @@ typedef struct isc__appctx {
 	isc_taskmgr_t		*taskmgr;
 	isc_socketmgr_t		*socketmgr;
 	isc_timermgr_t		*timermgr;
 #ifdef ISC_PLATFORM_USETHREADS
 	isc_mutex_t		readylock;
 	isc_condition_t		ready;
 #endif /* ISC_PLATFORM_USETHREADS */
 } isc__appctx_t;
 static isc__appctx_t isc_g_appctx;
@@ -231,7 +220,6 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
 	}
 #endif
 #ifdef ISC_PLATFORM_USETHREADS
 #ifdef HAVE_LINUXTHREADS
 	main_thread = pthread_self();
 #endif /* HAVE_LINUXTHREADS */
@@ -244,14 +232,9 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_rlock;
 	result = isc_mutex_init(&ctx->lock);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_rcond;
 #else /* ISC_PLATFORM_USETHREADS */
 	result = isc_mutex_init(&ctx->lock);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 #endif /* ISC_PLATFORM_USETHREADS */
 	ISC_LIST_INIT(ctx->on_run);
@@ -306,7 +289,6 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
 		goto cleanup;
 #endif
 #ifdef ISC_PLATFORM_USETHREADS
 	/*
 	 * Block SIGHUP, SIGINT, SIGTERM.
 	 *
@@ -335,44 +317,14 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
 		result = ISC_R_UNEXPECTED;
 		goto cleanup;
 	}
 #else /* ISC_PLATFORM_USETHREADS */
 	/*
 	 * Unblock SIGHUP, SIGINT, SIGTERM.
 	 *
 	 * If we're not using threads, we need to make sure that SIGHUP,
 	 * SIGINT and SIGTERM are not inherited as blocked from the parent
 	 * process.
 	 */
 	if (sigemptyset(&sset) != 0 ||
 	    sigaddset(&sset, SIGHUP) != 0 ||
 	    sigaddset(&sset, SIGINT) != 0 ||
 	    sigaddset(&sset, SIGTERM) != 0) {
 		isc__strerror(errno, strbuf, sizeof(strbuf));
 		UNEXPECTED_ERROR(__FILE__, __LINE__,
 				 "isc_app_start() sigsetops: %s", strbuf);
 		result = ISC_R_UNEXPECTED;
 		goto cleanup;
 	}
 	presult = sigprocmask(SIG_UNBLOCK, &sset, NULL);
 	if (presult != 0) {
 		isc__strerror(errno, strbuf, sizeof(strbuf));
 		UNEXPECTED_ERROR(__FILE__, __LINE__,
 				 "isc_app_start() sigprocmask: %s", strbuf);
 		result = ISC_R_UNEXPECTED;
 		goto cleanup;
 	}
 #endif /* ISC_PLATFORM_USETHREADS */
 	return (ISC_R_SUCCESS);
 cleanup:
 #ifdef ISC_PLATFORM_USETHREADS
 cleanup_rcond:
 	(void)isc_condition_destroy(&ctx->ready);
 cleanup_rlock:
 	(void)isc_mutex_destroy(&ctx->readylock);
 #endif /* ISC_PLATFORM_USETHREADS */
 	return (result);
 }
@@ -434,159 +386,17 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
 	return (result);
 }
 #ifndef ISC_PLATFORM_USETHREADS
 /*!
 * Event loop for nonthreaded programs.
 */
 static isc_result_t
 evloop(isc__appctx_t *ctx) {
 	isc_result_t result;
 	while (!ctx->want_shutdown) {
 		int n;
 		isc_time_t when, now;
 		struct timeval tv, *tvp;
 		isc_socketwait_t *swait;
 		bool readytasks;
 		bool call_timer_dispatch = false;
 		/*
 		 * Check the reload (or suspend) case first for exiting the
 		 * loop as fast as possible in case:
 		 *   - the direct call to isc__taskmgr_dispatch() in
 		 *     isc__app_ctxrun() completes all the tasks so far,
 		 *   - there is thus currently no active task, and
 		 *   - there is a timer event
 		 */
 		if (ctx->want_reload) {
 			ctx->want_reload = false;
 			return (ISC_R_RELOAD);
 		}
 		readytasks = isc__taskmgr_ready(ctx->taskmgr);
 		if (readytasks) {
 			tv.tv_sec = 0;
 			tv.tv_usec = 0;
 			tvp = &tv;
 			call_timer_dispatch = true;
 		} else {
 			result = isc__timermgr_nextevent(ctx->timermgr, &when);
 			if (result != ISC_R_SUCCESS)
 				tvp = NULL;
 			else {
 				uint64_t us;
 				TIME_NOW(&now);
 				us = isc_time_microdiff(&when, &now);
 				if (us == 0)
 					call_timer_dispatch = true;
 				tv.tv_sec = us / 1000000;
 				tv.tv_usec = us % 1000000;
 				tvp = &tv;
 			}
 		}
 		swait = NULL;
 		n = isc__socketmgr_waitevents(ctx->socketmgr, tvp, &swait);
 		if (n == 0 || call_timer_dispatch) {
 			/*
 			 * We call isc__timermgr_dispatch() only when
 			 * necessary, in order to reduce overhead.  If the
 			 * select() call indicates a timeout, we need the
 			 * dispatch.  Even if not, if we set the 0-timeout
 			 * for the select() call, we need to check the timer
 			 * events.  In the 'readytasks' case, there may be no
 			 * timeout event actually, but there is no other way
 			 * to reduce the overhead.
 			 * Note that we do not have to worry about the case
 			 * where a new timer is inserted during the select()
 			 * call, since this loop only runs in the non-thread
 			 * mode.
 			 */
 			isc__timermgr_dispatch(ctx->timermgr);
 		}
 		if (n > 0)
 			(void)isc__socketmgr_dispatch(ctx->socketmgr, swait);
 		(void)isc__taskmgr_dispatch(ctx->taskmgr);
 	}
 	return (ISC_R_SUCCESS);
 }
 /*
 * This is a gross hack to support waiting for condition
 * variables in nonthreaded programs in a limited way;
 * see lib/isc/nothreads/include/isc/condition.h.
 * We implement isc_condition_wait() by entering the
 * event loop recursively until the want_shutdown flag
 * is set by isc_condition_signal().
 */
 /*!
 * \brief True if we are currently executing in the recursive
 * event loop.
 */
 static bool in_recursive_evloop = false;
 /*!
 * \brief True if we are exiting the event loop as the result of
 * a call to isc_condition_signal() rather than a shutdown
 * or reload.
 */
 static bool signalled = false;
 isc_result_t
 isc__nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) {
 	isc_result_t result;
 	UNUSED(cp);
 	UNUSED(mp);
 	INSIST(!in_recursive_evloop);
 	in_recursive_evloop = true;
 	INSIST(*mp == 1); /* Mutex must be locked on entry. */
 	--*mp;
 	result = evloop(&isc_g_appctx);
 	if (result == ISC_R_RELOAD)
 		isc_g_appctx.want_reload = true;
 	if (signalled) {
 		isc_g_appctx.want_shutdown = false;
 		signalled = false;
 	}
 	++*mp;
 	in_recursive_evloop = false;
 	return (ISC_R_SUCCESS);
 }
 isc_result_t
 isc__nothread_signal_hack(isc_condition_t *cp) {
 	UNUSED(cp);
 	INSIST(in_recursive_evloop);
 	isc_g_appctx.want_shutdown = true;
 	signalled = true;
 	return (ISC_R_SUCCESS);
 }
 #endif /* ISC_PLATFORM_USETHREADS */
 isc_result_t
 isc__app_ctxrun(isc_appctx_t *ctx0) {
 	isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
 	int result;
 	isc_event_t *event, *next_event;
 	isc_task_t *task;
 #ifdef ISC_PLATFORM_USETHREADS
 	sigset_t sset;
 	char strbuf[ISC_STRERRORSIZE];
 #ifdef HAVE_SIGWAIT
 	int sig;
 #endif /* HAVE_SIGWAIT */
 #endif /* ISC_PLATFORM_USETHREADS */
 	REQUIRE(VALID_APPCTX(ctx));
@@ -616,17 +426,6 @@ isc__app_ctxrun(isc_appctx_t *ctx0) {
 	UNLOCK(&ctx->lock);
 #ifndef ISC_PLATFORM_USETHREADS
 	if (isc_bind9 && ctx == &isc_g_appctx) {
 		result = handle_signal(SIGHUP, reload_action);
 		if (result != ISC_R_SUCCESS)
 			return (ISC_R_SUCCESS);
 	}
 	(void) isc__taskmgr_dispatch(ctx->taskmgr);
 	result = evloop(ctx);
 	return (result);
 #else /* ISC_PLATFORM_USETHREADS */
 	/*
 	 * BIND9 internal tools using multiple contexts do not
 	 * rely on signal.
@@ -746,7 +545,6 @@ isc__app_ctxrun(isc_appctx_t *ctx0) {
 	}
 	return (ISC_R_SUCCESS);
 #endif /* ISC_PLATFORM_USETHREADS */
 }
 isc_result_t
@@ -758,9 +556,7 @@ isc_result_t
 isc__app_ctxshutdown(isc_appctx_t *ctx0) {
 	isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
 	bool want_kill = true;
 #ifdef ISC_PLATFORM_USETHREADS
 	char strbuf[ISC_STRERRORSIZE];
 #endif /* ISC_PLATFORM_USETHREADS */
 	REQUIRE(VALID_APPCTX(ctx));
@@ -780,9 +576,6 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) {
 			/* BIND9 internal, but using multiple contexts */
 			ctx->want_shutdown = true;
 		else {
 #ifndef ISC_PLATFORM_USETHREADS
 			ctx->want_shutdown = true;
 #else /* ISC_PLATFORM_USETHREADS */
 #ifdef HAVE_LINUXTHREADS
 			if (isc_bind9) {
 				/* BIND9 internal, single context */
@@ -819,7 +612,6 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) {
 				UNLOCK(&ctx->readylock);
 				SIGNAL(&ctx->ready);
 			}
 #endif /* ISC_PLATFORM_USETHREADS */
 		}
 	}
@@ -835,9 +627,7 @@ isc_result_t
 isc__app_ctxsuspend(isc_appctx_t *ctx0) {
 	isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
 	bool want_kill = true;
 #ifdef ISC_PLATFORM_USETHREADS
 	char strbuf[ISC_STRERRORSIZE];
 #endif
 	REQUIRE(VALID_APPCTX(ctx));
@@ -858,9 +648,6 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) {
 			/* BIND9 internal, but using multiple contexts */
 			ctx->want_reload = true;
 		else {
 #ifndef ISC_PLATFORM_USETHREADS
 			ctx->want_reload = true;
 #else /* ISC_PLATFORM_USETHREADS */
 #ifdef HAVE_LINUXTHREADS
 			if (isc_bind9) {
 				/* BIND9 internal, single context */
@@ -897,7 +684,6 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) {
 				UNLOCK(&ctx->readylock);
 				SIGNAL(&ctx->ready);
 			}
 #endif /* ISC_PLATFORM_USETHREADS */
 		}
 	}
@@ -925,41 +711,33 @@ isc__app_finish(void) {
 void
 isc__app_block(void) {
 #ifdef ISC_PLATFORM_USETHREADS
 	sigset_t sset;
 #endif /* ISC_PLATFORM_USETHREADS */
 	REQUIRE(isc_g_appctx.running);
 	REQUIRE(!isc_g_appctx.blocked);
 	isc_g_appctx.blocked = true;
 #ifdef ISC_PLATFORM_USETHREADS
 	blockedthread = pthread_self();
 	RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
 		      sigaddset(&sset, SIGINT) == 0 &&
 		      sigaddset(&sset, SIGTERM) == 0);
 	RUNTIME_CHECK(pthread_sigmask(SIG_UNBLOCK, &sset, NULL) == 0);
 #endif /* ISC_PLATFORM_USETHREADS */
 }
 void
 isc__app_unblock(void) {
 #ifdef ISC_PLATFORM_USETHREADS
 	sigset_t sset;
 #endif /* ISC_PLATFORM_USETHREADS */
 	REQUIRE(isc_g_appctx.running);
 	REQUIRE(isc_g_appctx.blocked);
 	isc_g_appctx.blocked = false;
 #ifdef ISC_PLATFORM_USETHREADS
 	REQUIRE(blockedthread == pthread_self());
 	RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
 		      sigaddset(&sset, SIGINT) == 0 &&
 		      sigaddset(&sset, SIGTERM) == 0);
 	RUNTIME_CHECK(pthread_sigmask(SIG_BLOCK, &sset, NULL) == 0);
 #endif /* ISC_PLATFORM_USETHREADS */
 }
 isc_result_t
@@ -84,17 +84,6 @@
 #include "errno2result.h"
 /* See task.c about the following definition: */
 #ifdef ISC_PLATFORM_USETHREADS
 #define USE_WATCHER_THREAD
 #else
 #define USE_SHARED_MANAGER
 #endif	/* ISC_PLATFORM_USETHREADS */
 #ifndef USE_WATCHER_THREAD
 #include "socket_p.h"
 #endif /* USE_WATCHER_THREAD */
 #if defined(SO_BSDCOMPAT) && defined(__linux__)
 #include <sys/utsname.h>
 #endif
@@ -120,21 +109,6 @@ typedef struct {
 #define USE_SELECT
 #endif	/* ISC_PLATFORM_HAVEKQUEUE */
 #ifndef USE_WATCHER_THREAD
 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
 struct isc_socketwait {
 	int nevents;
 };
 #elif defined (USE_SELECT)
 struct isc_socketwait {
 	fd_set *readset;
 	fd_set *writeset;
 	int nfds;
 	int maxfd;
 };
 #endif	/* USE_KQUEUE */
 #endif /* !USE_WATCHER_THREAD */
 /*
 * Set by the -T dscp option on the command line. If set to a value
 * other than -1, we check to make sure DSCP values match it, and
@@ -215,13 +189,8 @@ typedef enum { poll_idle, poll_active, poll_checking } pollstate_t;
 /*%
 * Size of per-FD lock buckets.
 */
 #ifdef ISC_PLATFORM_USETHREADS
 #define FDLOCK_COUNT		1024
 #define FDLOCK_ID(fd)		((fd) % FDLOCK_COUNT)
 #else
 #define FDLOCK_COUNT		1
 #define FDLOCK_ID(fd)		0
 #endif	/* ISC_PLATFORM_USETHREADS */
 /*%
 * Maximum number of events communicated with the kernel.  There should normally
@@ -443,9 +412,7 @@ struct isc__socketmgr {
 	int			fd_bufsize;
 #endif	/* USE_SELECT */
 	unsigned int		maxsocks;
 #ifdef ISC_PLATFORM_USETHREADS
 	int			pipe_fds[2];
 #endif
 	/* Locked by fdlock. */
 	isc__socket_t	       **fds;
@@ -467,19 +434,11 @@ struct isc__socketmgr {
 	int			maxfd;
 #endif	/* USE_SELECT */
 	int			reserved;	/* unlocked */
 #ifdef USE_WATCHER_THREAD
 	isc_thread_t		watcher;
 	isc_condition_t		shutdown_ok;
 #else /* USE_WATCHER_THREAD */
 	unsigned int		refs;
 #endif /* USE_WATCHER_THREAD */
 	int			maxudp;
 };
 #ifdef USE_SHARED_MANAGER
 static isc__socketmgr_t *socketmgr = NULL;
 #endif /* USE_SHARED_MANAGER */
 #define CLOSED			0	/* this one must be zero */
 #define MANAGED			1
 #define CLOSE_PENDING		2
@@ -516,9 +475,7 @@ static void build_msghdr_send(isc__socket_t *, char *, isc_socketevent_t *,
 			      struct msghdr *, struct iovec *, size_t *);
 static void build_msghdr_recv(isc__socket_t *, char *, isc_socketevent_t *,
 			      struct msghdr *, struct iovec *, size_t *);
 #ifdef USE_WATCHER_THREAD
 static bool process_ctlfd(isc__socketmgr_t *manager);
 #endif
 static void setdscp(isc__socket_t *sock, isc_dscp_t dscp);
 /*%
@@ -809,8 +766,6 @@ static const isc_statscounter_t rawstatsindex[] = {
 	isc_sockstatscounter_rawactive
 };
 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL) || \
    defined(USE_WATCHER_THREAD)
 static void
 manager_log(isc__socketmgr_t *sockmgr,
 	    isc_logcategory_t *category, isc_logmodule_t *module, int level,
@@ -833,7 +788,6 @@ manager_log(isc__socketmgr_t *sockmgr,
 	isc_log_write(isc_lctx, category, module, level,
 		      "sockmgr %p: %s", sockmgr, msgbuf);
 }
 #endif
 static void
 socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
@@ -1159,7 +1113,6 @@ wakeup_socket(isc__socketmgr_t *manager, int fd, int msg) {
 	}
 }
 #ifdef USE_WATCHER_THREAD
 /*
 * Poke the select loop when there is something for us to do.
 * The write is required (by POSIX) to complete.  That is, we
@@ -1230,19 +1183,6 @@ select_readmsg(isc__socketmgr_t *mgr, int *fd, int *msg) {
 	*fd = buf[0];
 	*msg = buf[1];
 }
 #else /* USE_WATCHER_THREAD */
 /*
 * Update the state of the socketmgr when something changes.
 */
 static void
 select_poke(isc__socketmgr_t *manager, int fd, int msg) {
 	if (msg == SELECT_POKE_SHUTDOWN)
 		return;
 	else if (fd >= 0)
 		wakeup_socket(manager, fd, msg);
 	return;
 }
 #endif /* USE_WATCHER_THREAD */
 /*
 * Make a fd non-blocking.
@@ -2263,10 +2203,8 @@ socketclose(isc__socketmgr_t *manager, isc__socket_t *sock, int fd) {
 			}
 			UNLOCK(&manager->fdlock[lockid]);
 		}
 #ifdef ISC_PLATFORM_USETHREADS
 		if (manager->maxfd < manager->pipe_fds[0])
 			manager->maxfd = manager->pipe_fds[0];
 #endif
 	}
 	UNLOCK(&manager->lock);
@@ -2298,10 +2236,8 @@ destroy(isc__socket_t **sockp) {
 	ISC_LIST_UNLINK(manager->socklist, sock, link);
 #ifdef USE_WATCHER_THREAD
 	if (ISC_LIST_EMPTY(manager->socklist))
 		SIGNAL(&manager->shutdown_ok);
 #endif /* USE_WATCHER_THREAD */
 	/* can't unlock manager as its memory context is still used */
 	free_socket(sockp);
@@ -4028,9 +3964,7 @@ process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) {
 	int i;
 	bool readable, writable;
 	bool done = false;
 #ifdef USE_WATCHER_THREAD
 	bool have_ctlevent = false;
 #endif
 	if (nevents == manager->nevents) {
 		/*
@@ -4046,21 +3980,17 @@ process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) {
 	for (i = 0; i < nevents; i++) {
 		REQUIRE(events[i].ident < manager->maxsocks);
 #ifdef USE_WATCHER_THREAD
 		if (events[i].ident == (uintptr_t)manager->pipe_fds[0]) {
 			have_ctlevent = true;
 			continue;
 		}
 #endif
 		readable = (events[i].filter == EVFILT_READ);
 		writable = (events[i].filter == EVFILT_WRITE);
 		process_fd(manager, events[i].ident, readable, writable);
 	}
 #ifdef USE_WATCHER_THREAD
 	if (have_ctlevent)
 		done = process_ctlfd(manager);
 #endif
 	return (done);
 }
@@ -4070,9 +4000,7 @@ process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
 {
 	int i;
 	bool done = false;
 #ifdef USE_WATCHER_THREAD
 	bool have_ctlevent = false;
 #endif
 	if (nevents == manager->nevents) {
 		manager_log(manager, ISC_LOGCATEGORY_GENERAL,
@@ -4083,12 +4011,10 @@ process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
 	for (i = 0; i < nevents; i++) {
 		REQUIRE(events[i].data.fd < (int)manager->maxsocks);
 #ifdef USE_WATCHER_THREAD
 		if (events[i].data.fd == manager->pipe_fds[0]) {
 			have_ctlevent = true;
 			continue;
 		}
 #endif
 		if ((events[i].events & EPOLLERR) != 0 ||
 		    (events[i].events & EPOLLHUP) != 0) {
 			/*
@@ -4106,10 +4032,8 @@ process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
 			   (events[i].events & EPOLLOUT) != 0);
 	}
 #ifdef USE_WATCHER_THREAD
 	if (have_ctlevent)
 		done = process_ctlfd(manager);
 #endif
 	return (done);
 }
@@ -4118,9 +4042,7 @@ static bool
 process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) {
 	int i;
 	bool done = false;
 #ifdef USE_WATCHER_THREAD
 	bool have_ctlevent = false;
 #endif
 	if (nevents == manager->nevents) {
 		manager_log(manager, ISC_LOGCATEGORY_GENERAL,
@@ -4131,21 +4053,17 @@ process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) {
 	for (i = 0; i < nevents; i++) {
 		REQUIRE(events[i].fd < (int)manager->maxsocks);
 #ifdef USE_WATCHER_THREAD
 		if (events[i].fd == manager->pipe_fds[0]) {
 			have_ctlevent = true;
 			continue;
 		}
 #endif
 		process_fd(manager, events[i].fd,
 			   (events[i].events & POLLIN) != 0,
 			   (events[i].events & POLLOUT) != 0);
 	}
 #ifdef USE_WATCHER_THREAD
 	if (have_ctlevent)
 		done = process_ctlfd(manager);
 #endif
 	return (done);
 }
@@ -4159,17 +4077,14 @@ process_fds(isc__socketmgr_t *manager, int maxfd, fd_set *readfds,
 	REQUIRE(maxfd <= (int)manager->maxsocks);
 	for (i = 0; i < maxfd; i++) {
 #ifdef USE_WATCHER_THREAD
 		if (i == manager->pipe_fds[0] || i == manager->pipe_fds[1])
 			continue;
 #endif /* USE_WATCHER_THREAD */
 		process_fd(manager, i, FD_ISSET(i, readfds),
 			   FD_ISSET(i, writefds));
 	}
 }
 #endif
 #ifdef USE_WATCHER_THREAD
 static bool
 process_ctlfd(isc__socketmgr_t *manager) {
 	int msg, fd;
@@ -4366,7 +4281,6 @@ watcher(void *uap) {
 	return ((isc_threadresult_t)0);
 }
 #endif /* USE_WATCHER_THREAD */
 void
 isc__socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
@@ -4417,7 +4331,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 		return (result);
 	}
 #ifdef USE_WATCHER_THREAD
 	result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
 	if (result != ISC_R_SUCCESS) {
 		close(manager->kqueue_fd);
@@ -4425,7 +4338,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 			    sizeof(struct kevent) * manager->nevents);
 		return (result);
 	}
 #endif	/* USE_WATCHER_THREAD */
 #elif defined(USE_EPOLL)
 	manager->nevents = ISC_SOCKET_MAXEVENTS;
 	manager->events = isc_mem_get(mctx, sizeof(struct epoll_event) *
@@ -4445,7 +4357,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 			    sizeof(struct epoll_event) * manager->nevents);
 		return (result);
 	}
 #ifdef USE_WATCHER_THREAD
 	result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
 	if (result != ISC_R_SUCCESS) {
 		close(manager->epoll_fd);
@@ -4453,7 +4364,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 			    sizeof(struct epoll_event) * manager->nevents);
 		return (result);
 	}
 #endif	/* USE_WATCHER_THREAD */
 #elif defined(USE_DEVPOLL)
 	manager->nevents = ISC_SOCKET_MAXEVENTS;
 	result = isc_resource_getcurlimit(isc_resource_openfiles,
@@ -4492,7 +4402,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 			    sizeof(pollinfo_t) * manager->maxsocks);
 		return (result);
 	}
 #ifdef USE_WATCHER_THREAD
 	result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
 	if (result != ISC_R_SUCCESS) {
 		close(manager->devpoll_fd);
@@ -4502,7 +4411,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 			    sizeof(pollinfo_t) * manager->maxsocks);
 		return (result);
 	}
 #endif	/* USE_WATCHER_THREAD */
 #elif defined(USE_SELECT)
 	UNUSED(result);
@@ -4550,12 +4458,8 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 	memset(manager->read_fds, 0, manager->fd_bufsize);
 	memset(manager->write_fds, 0, manager->fd_bufsize);
 #ifdef USE_WATCHER_THREAD
 	(void)watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
 	manager->maxfd = manager->pipe_fds[0];
 #else /* USE_WATCHER_THREAD */
 	manager->maxfd = 0;
 #endif /* USE_WATCHER_THREAD */
 #endif	/* USE_KQUEUE */
 	return (ISC_R_SUCCESS);
@@ -4563,7 +4467,6 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 static void
 cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 #ifdef USE_WATCHER_THREAD
 	isc_result_t result;
 	result = unwatch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
@@ -4573,7 +4476,6 @@ cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 						ISC_MSG_FAILED, "failed"));
 	}
 #endif	/* USE_WATCHER_THREAD */
 #ifdef USE_KQUEUE
 	close(manager->kqueue_fd);
@@ -4612,25 +4514,11 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 {
 	int i;
 	isc__socketmgr_t *manager;
 #ifdef USE_WATCHER_THREAD
 	char strbuf[ISC_STRERRORSIZE];
 #endif
 	isc_result_t result;
 	REQUIRE(managerp != NULL && *managerp == NULL);
 #ifdef USE_SHARED_MANAGER
 	if (socketmgr != NULL) {
 		/* Don't allow maxsocks to be updated */
 		if (maxsocks > 0 && socketmgr->maxsocks != maxsocks)
 			return (ISC_R_EXISTS);
 		socketmgr->refs++;
 		*managerp = (isc_socketmgr_t *)socketmgr;
 		return (ISC_R_SUCCESS);
 	}
 #endif /* USE_SHARED_MANAGER */
 	if (maxsocks == 0)
 		maxsocks = ISC_SOCKET_MAXSOCKETS;
@@ -4691,7 +4579,6 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 		}
 	}
 #ifdef USE_WATCHER_THREAD
 	if (isc_condition_init(&manager->shutdown_ok) != ISC_R_SUCCESS) {
 		UNEXPECTED_ERROR(__FILE__, __LINE__,
 				 "isc_condition_init() %s",
@@ -4717,14 +4604,6 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 	}
 	RUNTIME_CHECK(make_nonblock(manager->pipe_fds[0]) == ISC_R_SUCCESS);
 #if 0
 	RUNTIME_CHECK(make_nonblock(manager->pipe_fds[1]) == ISC_R_SUCCESS);
 #endif
 #endif	/* USE_WATCHER_THREAD */
 #ifdef USE_SHARED_MANAGER
 	manager->refs = 1;
 #endif /* USE_SHARED_MANAGER */
 	/*
 	 * Set up initial state for the select loop
@@ -4735,7 +4614,6 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 	memset(manager->fdstate, 0, manager->maxsocks * sizeof(int));
 #ifdef USE_WATCHER_THREAD
 	/*
 	 * Start up the select/poll thread.
 	 */
@@ -4750,26 +4628,18 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
 		goto cleanup;
 	}
 	isc_thread_setname(manager->watcher, "isc-socket");
 #endif /* USE_WATCHER_THREAD */
 	isc_mem_attach(mctx, &manager->mctx);
 #ifdef USE_SHARED_MANAGER
 	socketmgr = manager;
 #endif /* USE_SHARED_MANAGER */
 	*managerp = (isc_socketmgr_t *)manager;
 	return (ISC_R_SUCCESS);
 cleanup:
 #ifdef USE_WATCHER_THREAD
 	(void)close(manager->pipe_fds[0]);
 	(void)close(manager->pipe_fds[1]);
 #endif	/* USE_WATCHER_THREAD */
 #ifdef USE_WATCHER_THREAD
 cleanup_condition:
 	(void)isc_condition_destroy(&manager->shutdown_ok);
 #endif	/* USE_WATCHER_THREAD */
 cleanup_lock:
@@ -4840,32 +4710,17 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
 	manager = (isc__socketmgr_t *)*managerp;
 	REQUIRE(VALID_MANAGER(manager));
 #ifdef USE_SHARED_MANAGER
 	manager->refs--;
 	if (manager->refs > 0) {
 		*managerp = NULL;
 		return;
 	}
 	socketmgr = NULL;
 #endif /* USE_SHARED_MANAGER */
 	LOCK(&manager->lock);
 	/*
 	 * Wait for all sockets to be destroyed.
 	 */
 	while (!ISC_LIST_EMPTY(manager->socklist)) {
 #ifdef USE_WATCHER_THREAD
 		manager_log(manager, CREATION, "%s",
 			    isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
 					   ISC_MSG_SOCKETSREMAIN,
 					   "sockets exist"));
 		WAIT(&manager->shutdown_ok, &manager->lock);
 #else /* USE_WATCHER_THREAD */
 		UNLOCK(&manager->lock);
 		isc__taskmgr_dispatch(NULL);
 		LOCK(&manager->lock);
 #endif /* USE_WATCHER_THREAD */
 	}
 	UNLOCK(&manager->lock);
@@ -4877,7 +4732,6 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
 	 */
 	select_poke(manager, 0, SELECT_POKE_SHUTDOWN);
 #ifdef USE_WATCHER_THREAD
 	/*
 	 * Wait for thread to exit.
 	 */
@@ -4886,18 +4740,15 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
 				 "isc_thread_join() %s",
 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 						ISC_MSG_FAILED, "failed"));
 #endif /* USE_WATCHER_THREAD */
 	/*
 	 * Clean up.
 	 */
 	cleanup_watcher(manager->mctx, manager);
 #ifdef USE_WATCHER_THREAD
 	(void)close(manager->pipe_fds[0]);
 	(void)close(manager->pipe_fds[1]);
 	(void)isc_condition_destroy(&manager->shutdown_ok);
 #endif /* USE_WATCHER_THREAD */
 	for (i = 0; i < (int)manager->maxsocks; i++)
 		if (manager->fdstate[i] == CLOSE_PENDING) /* no need to lock */
@@ -4931,9 +4782,6 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
 	*managerp = NULL;
 #ifdef USE_SHARED_MANAGER
 	socketmgr = NULL;
 #endif
 }
 static isc_result_t
@@ -6402,137 +6250,6 @@ isc_socket_socketevent(isc_mem_t *mctx, void *sender,
 	return (allocate_socketevent(mctx, sender, eventtype, action, arg));
 }
 #ifndef USE_WATCHER_THREAD
 /*
 * In our assumed scenario, we can simply use a single static object.
 * XXX: this is not true if the application uses multiple threads with
 *      'multi-context' mode.  Fixing this is a future TODO item.
 */
 static isc_socketwait_t swait_private;
 int
 isc__socketmgr_waitevents(isc_socketmgr_t *manager0, struct timeval *tvp,
 			  isc_socketwait_t **swaitp)
 {
 	isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
 	int n;
 #ifdef USE_KQUEUE
 	struct timespec ts, *tsp;
 #endif
 #ifdef USE_EPOLL
 	int timeout;
 #endif
 #ifdef USE_DEVPOLL
 	isc_result_t result;
 	int pass;
 	struct dvpoll dvp;
 #endif
 	REQUIRE(swaitp != NULL && *swaitp == NULL);
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = socketmgr;
 #endif
 	if (manager == NULL)
 		return (0);
 #ifdef USE_KQUEUE
 	if (tvp != NULL) {
 		ts.tv_sec = tvp->tv_sec;
 		ts.tv_nsec = tvp->tv_usec * 1000;
 		tsp = &ts;
 	} else
 		tsp = NULL;
 	swait_private.nevents = kevent(manager->kqueue_fd, NULL, 0,
 				       manager->events, manager->nevents,
 				       tsp);
 	n = swait_private.nevents;
 #elif defined(USE_EPOLL)
 	if (tvp != NULL)
 		timeout = tvp->tv_sec * 1000 + (tvp->tv_usec + 999) / 1000;
 	else
 		timeout = -1;
 	swait_private.nevents = epoll_wait(manager->epoll_fd,
 					   manager->events,
 					   manager->nevents, timeout);
 	n = swait_private.nevents;
 #elif defined(USE_DEVPOLL)
 	/*
 	 * Re-probe every thousand calls.
 	 */
 	if (manager->calls++ > 1000U) {
 		result = isc_resource_getcurlimit(isc_resource_openfiles,
 						  &manager->open_max);
 		if (result != ISC_R_SUCCESS)
 			manager->open_max = 64;
 		manager->calls = 0;
 	}
 	for (pass = 0; pass < 2; pass++) {
 		dvp.dp_fds = manager->events;
 		dvp.dp_nfds = manager->nevents;
 		if (dvp.dp_nfds >= manager->open_max)
 			dvp.dp_nfds = manager->open_max - 1;
 		if (tvp != NULL) {
 			dvp.dp_timeout = tvp->tv_sec * 1000 +
 				(tvp->tv_usec + 999) / 1000;
 		} else
 			dvp.dp_timeout = -1;
 		n = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
 		if (n == -1 && errno == EINVAL) {
 			/*
 			 * {OPEN_MAX} may have dropped.  Look
 			 * up the current value and try again.
 			 */
 			result = isc_resource_getcurlimit(
 							isc_resource_openfiles,
 							&manager->open_max);
 			if (result != ISC_R_SUCCESS)
 				manager->open_max = 64;
 		} else
 			break;
 	}
 	swait_private.nevents = n;
 #elif defined(USE_SELECT)
 	memmove(manager->read_fds_copy, manager->read_fds, manager->fd_bufsize);
 	memmove(manager->write_fds_copy, manager->write_fds,
 		manager->fd_bufsize);
 	swait_private.readset = manager->read_fds_copy;
 	swait_private.writeset = manager->write_fds_copy;
 	swait_private.maxfd = manager->maxfd + 1;
 	n = select(swait_private.maxfd, swait_private.readset,
 		   swait_private.writeset, NULL, tvp);
 #endif
 	*swaitp = &swait_private;
 	return (n);
 }
 isc_result_t
 isc__socketmgr_dispatch(isc_socketmgr_t *manager0, isc_socketwait_t *swait) {
 	isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
 	REQUIRE(swait == &swait_private);
 #ifdef USE_SHARED_MANAGER
 	if (manager == NULL)
 		manager = socketmgr;
 #endif
 	if (manager == NULL)
 		return (ISC_R_NOTFOUND);
 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
 	(void)process_fds(manager, manager->events, swait->nevents);
 	return (ISC_R_SUCCESS);
 #elif defined(USE_SELECT)
 	process_fds(manager, swait->maxfd, swait->readset, swait->writeset);
 	return (ISC_R_SUCCESS);
 #endif
 }
 #endif /* USE_WATCHER_THREAD */
 void
 isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
 	isc__socket_t *sock = (isc__socket_t *)socket0;
@@ -6605,12 +6322,6 @@ isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer) {
 	LOCK(&mgr->lock);
 #ifdef USE_SHARED_MANAGER
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "references"));
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->refs));
 	TRY0(xmlTextWriterEndElement(writer));
 #endif	/* USE_SHARED_MANAGER */
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "sockets"));
 	sock = ISC_LIST_HEAD(mgr->socklist);
 	while (sock != NULL) {
@@ -6725,12 +6436,6 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
 	LOCK(&mgr->lock);
 #ifdef USE_SHARED_MANAGER
 	obj = json_object_new_int(mgr->refs);
 	CHECKMEM(obj);
 	json_object_object_add(stats, "references", obj);
 #endif	/* USE_SHARED_MANAGER */
 	sock = ISC_LIST_HEAD(mgr->socklist);
 	while (sock != NULL) {
 		json_object *states, *entry = json_object_new_object();
@@ -381,9 +381,7 @@ void
 isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -391,11 +389,7 @@ isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 	REQUIRE(len > 0);
 	now = (time_t) t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%d-%b-%Y %X", localtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%d-%b-%Y %X", localtime(&now));
 #endif
 	INSIST(flen < len);
 	if (flen != 0)
 		snprintf(buf + flen, len - flen,
@@ -409,9 +403,7 @@ void
 isc_time_formathttptimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -422,12 +414,8 @@ isc_time_formathttptimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 	 * 5 spaces, 1 comma, 3 GMT, 2 %d, 4 %Y, 8 %H:%M:%S, 3+ %a, 3+ %b (29+)
 	 */
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%a, %d %b %Y %H:%M:%S GMT",
 			gmtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(&now));
 #endif
 	INSIST(flen < len);
 }
@@ -454,9 +442,7 @@ void
 isc_time_formatISO8601L(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -464,11 +450,7 @@ isc_time_formatISO8601L(const isc_time_t *t, char *buf, unsigned int len) {
 	REQUIRE(len > 0);
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime(&now));
 #endif
 	INSIST(flen < len);
 }
@@ -476,9 +458,7 @@ void
 isc_time_formatISO8601Lms(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -486,11 +466,7 @@ isc_time_formatISO8601Lms(const isc_time_t *t, char *buf, unsigned int len) {
 	REQUIRE(len > 0);
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime(&now));
 #endif
 	INSIST(flen < len);
 	if (flen > 0U && len - flen >= 6) {
 		snprintf(buf + flen, len - flen, ".%03u",
@@ -502,9 +478,7 @@ void
 isc_time_formatISO8601(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -512,11 +486,7 @@ isc_time_formatISO8601(const isc_time_t *t, char *buf, unsigned int len) {
 	REQUIRE(len > 0);
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
 #endif
 	INSIST(flen < len);
 }
@@ -524,9 +494,7 @@ void
 isc_time_formatISO8601ms(const isc_time_t *t, char *buf, unsigned int len) {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -534,11 +502,7 @@ isc_time_formatISO8601ms(const isc_time_t *t, char *buf, unsigned int len) {
 	REQUIRE(len > 0);
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
 #endif
 	INSIST(flen < len);
 	if (flen > 0U && len - flen >= 5) {
 		flen -= 1; /* rewind one character (Z) */
@@ -552,9 +516,7 @@ isc_time_formatshorttimestamp(const isc_time_t *t, char *buf, unsigned int len)
 {
 	time_t now;
 	unsigned int flen;
 #ifdef ISC_PLATFORM_USETHREADS
 	struct tm tm;
 #endif
 	REQUIRE(t != NULL);
 	INSIST(t->nanoseconds < NS_PER_S);
@@ -562,11 +524,7 @@ isc_time_formatshorttimestamp(const isc_time_t *t, char *buf, unsigned int len)
 	REQUIRE(len > 0);
 	now = (time_t)t->seconds;
 #ifdef ISC_PLATFORM_USETHREADS
 	flen = strftime(buf, len, "%Y%m%d%H%M%S", gmtime_r(&now, &tm));
 #else
 	flen = strftime(buf, len, "%Y%m%d%H%M%S", gmtime(&now));
 #endif
 	INSIST(flen < len);
 	if (flen > 0U && len - flen >= 5) {
 		snprintf(buf + flen, len - flen, "%03u",
@@ -16,8 +16,6 @@
 ***** Platform-dependent defines.
 *****/
 #define ISC_PLATFORM_USETHREADS 1
 /*
 * Some compatibility cludges
 */
@@ -4016,12 +4016,6 @@ isc_socketmgr_renderxml(isc_socketmgr_t *mgr, xmlTextWriterPtr writer)
 	LOCK(&mgr->lock);
 #ifndef ISC_PLATFORM_USETHREADS
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "references"));
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->refs));
 	TRY0(xmlTextWriterEndElement(writer));
 #endif
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "sockets"));
 	sock = ISC_LIST_HEAD(mgr->socklist);
 	while (sock != NULL) {
@@ -28,9 +28,7 @@ isc_atomic_xadd(int32_t *p, int32_t val) {
 	int32_t prev = val;
 	__asm__ volatile(
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"xadd %0, %1"
 		:"=q"(prev)
 		:"m"(*p), "0"(prev)
@@ -45,9 +43,7 @@ isc_atomic_xaddq(int64_t *p, int64_t val) {
 	int64_t prev = val;
 	__asm__ volatile(
 #ifdef ISC_PLATFORM_USETHREADS
 	    "lock;"
 #endif
 	    "xaddq %0, %1"
 	    :"=q"(prev)
 	    :"m"(*p), "0"(prev)
@@ -63,13 +59,11 @@ isc_atomic_xaddq(int64_t *p, int64_t val) {
 static __inline__ void
 isc_atomic_store(int32_t *p, 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"
 		:
@@ -84,13 +78,11 @@ isc_atomic_store(int32_t *p, int32_t val) {
 static __inline__ void
 isc_atomic_storeq(int64_t *p, 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"
 		:
@@ -107,9 +99,7 @@ isc_atomic_storeq(int64_t *p, int64_t val) {
 static __inline__ int32_t
 isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
 	__asm__ volatile(
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"cmpxchgl %1, %2"
 		: "=a"(cmpval)
 		: "r"(val), "m"(*p), "a"(cmpval)
@@ -134,9 +124,7 @@ isc_atomic_xadd(int32_t *p, int32_t val) {
 	__asm (
 		"movl 8(%ebp), %ecx\n"
 		"movl 12(%ebp), %edx\n"
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"xadd %edx, (%ecx)\n"
 		/*
@@ -156,9 +144,7 @@ isc_atomic_store(int32_t *p, int32_t val) {
 	__asm (
 		"movl 8(%ebp), %ecx\n"
 		"movl 12(%ebp), %edx\n"
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"xchgl (%ecx), %edx\n"
 		);
 }
@@ -173,9 +159,7 @@ isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
 		"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.
@@ -40,9 +40,7 @@ isc_atomic_xadd(int32_t *p, int32_t 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.
@@ -59,9 +57,7 @@ isc_atomic_xaddq(int64_t *p, int64_t 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.
@@ -78,9 +74,7 @@ isc_atomic_store(int32_t *p, int32_t val) {
 	__asm (
 		"movq %rdi, %rax\n"
 		"movl %esi, %edx\n"
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"xchgl (%rax), %edx\n"
 		);
 }
@@ -94,9 +88,7 @@ isc_atomic_storeq(int64_t *p, int64_t val) {
 	__asm (
 		"movq %rdi, %rax\n"
 		"movq %rsi, %rdx\n"
 #ifdef ISC_PLATFORM_USETHREADS
 		"lock;"
 #endif
 		"xchgq (%rax), %rdx\n"
 		);
 }
@@ -116,9 +108,7 @@ isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
 		"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)
@@ -34,7 +34,6 @@
 *
 * The state must be seeded so that it is not everywhere zero.
 */
 #if defined(ISC_PLATFORM_USETHREADS)
 #if defined(_WIN32) || defined(_WIN64)
 #include <windows.h>
 static volatile HANDLE _mutex = NULL;
@@ -65,10 +64,6 @@ static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
 #define _LOCK()   pthread_mutex_lock(&_mutex)
 #define _UNLOCK() pthread_mutex_unlock(&_mutex)
 #endif /* defined(_WIN32) || defined(_WIN64) */
 #else /* defined(ISC_PLATFORM_USETHREADS) */
 #define _LOCK()
 #define _UNLOCK()
 #endif
 static inline uint32_t rotl(const uint32_t x, int k) {
 	return (x << k) | (x >> (32 - k));
@@ -102,7 +102,6 @@
 #define SEND_BUFFER_SIZE		4096
 #define RECV_BUFFER_SIZE		4096
 #ifdef ISC_PLATFORM_USETHREADS
 #define NMCTXS				100
 /*%<
 * Number of 'mctx pools' for clients. (Should this be configurable?)
@@ -112,13 +111,6 @@
 * completely avoiding contentions among threads for an authoritative-only
 * server.
 */
 #else
 #define NMCTXS				0
 /*%<
 * If named with built without thread, simply share manager's context.  Using
 * a separate context in this case would simply waste memory.
 */
 #endif
 #define COOKIE_SIZE 24U /* 8 + 4 + 4 + 8 */
 #define ECS_SIZE 20U /* 2 + 1 + 1 + [0..16] */
@@ -142,17 +142,12 @@ cleanup_managers(void) {
 	}
 	while (run_managers && !shutdown_done) {
 #ifndef ISC_PLATFORM_USETHREADS
 		while (isc__taskmgr_ready(taskmgr))
 			isc__taskmgr_dispatch(taskmgr);
 #else
 		/*
 		 * There's no straightforward way to determine
 		 * whether all the clients have shut down, so
 		 * we'll just sleep for a bit and hope.
 		 */
 		ns_test_nap(500000);
 #endif
 	}
 	if (sctx != NULL)
@@ -178,11 +173,7 @@ create_managers(void) {
 	isc_result_t result;
 	ns_listenlist_t *listenon = NULL;
 	isc_event_t *event = NULL;
 #ifdef ISC_PLATFORM_USETHREADS
 	ncpus = isc_os_ncpus();
 #else
 	ncpus = 1;
 #endif
 	CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
 	CHECK(isc_task_create(taskmgr, 0, &maintask));
@@ -212,17 +203,12 @@ create_managers(void) {
 				   scan_interfaces, NULL,
 				   sizeof (isc_event_t));
 	isc_task_send(maintask, &event);
 #ifndef ISC_PLATFORM_USETHREADS
 	while (isc__taskmgr_ready(taskmgr))
 		isc__taskmgr_dispatch(taskmgr);
 #else
 	/*
 	 * There's no straightforward way to determine
 	 * whether the interfaces have been scanned,
 	 * we'll just sleep for a bit and hope.
 	 */
 	ns_test_nap(500000);
 #endif
 	run_managers = true;
@@ -0,0 +1,485 @@
 # ===========================================================================
 #        https://www.gnu.org/software/autoconf-archive/ax_pthread.html
 # ===========================================================================
 #
 # SYNOPSIS
 #
 #   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
 #
 # DESCRIPTION
 #
 #   This macro figures out how to build C programs using POSIX threads. It
 #   sets the PTHREAD_LIBS output variable to the threads library and linker
 #   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
 #   flags that are needed. (The user can also force certain compiler
 #   flags/libs to be tested by setting these environment variables.)
 #
 #   Also sets PTHREAD_CC to any special C compiler that is needed for
 #   multi-threaded programs (defaults to the value of CC otherwise). (This
 #   is necessary on AIX to use the special cc_r compiler alias.)
 #
 #   NOTE: You are assumed to not only compile your program with these flags,
 #   but also to link with them as well. For example, you might link with
 #   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
 #
 #   If you are only building threaded programs, you may wish to use these
 #   variables in your default LIBS, CFLAGS, and CC:
 #
 #     LIBS="$PTHREAD_LIBS $LIBS"
 #     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 #     CC="$PTHREAD_CC"
 #
 #   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
 #   has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to
 #   that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
 #
 #   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
 #   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
 #   PTHREAD_CFLAGS.
 #
 #   ACTION-IF-FOUND is a list of shell commands to run if a threads library
 #   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
 #   is not found. If ACTION-IF-FOUND is not specified, the default action
 #   will define HAVE_PTHREAD.
 #
 #   Please let the authors know if this macro fails on any platform, or if
 #   you have any other suggestions or comments. This macro was based on work
 #   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
 #   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
 #   Alejandro Forero Cuervo to the autoconf macro repository. We are also
 #   grateful for the helpful feedback of numerous users.
 #
 #   Updated for Autoconf 2.68 by Daniel Richard G.
 #
 # LICENSE
 #
 #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
 #   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
 #
 #   This program is free software: you can redistribute it and/or modify it
 #   under the terms of the GNU General Public License as published by the
 #   Free Software Foundation, either version 3 of the License, or (at your
 #   option) any later version.
 #
 #   This program is distributed in the hope that it will be useful, but
 #   WITHOUT ANY WARRANTY; without even the implied warranty of
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 #   Public License for more details.
 #
 #   You should have received a copy of the GNU General Public License along
 #   with this program. If not, see <https://www.gnu.org/licenses/>.
 #
 #   As a special exception, the respective Autoconf Macro's copyright owner
 #   gives unlimited permission to copy, distribute and modify the configure
 #   scripts that are the output of Autoconf when processing the Macro. You
 #   need not follow the terms of the GNU General Public License when using
 #   or distributing such scripts, even though portions of the text of the
 #   Macro appear in them. The GNU General Public License (GPL) does govern
 #   all other use of the material that constitutes the Autoconf Macro.
 #
 #   This special exception to the GPL applies to versions of the Autoconf
 #   Macro released by the Autoconf Archive. When you make and distribute a
 #   modified version of the Autoconf Macro, you may extend this special
 #   exception to the GPL to apply to your modified version as well.
 #serial 24
 AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
 AC_DEFUN([AX_PTHREAD], [
 AC_REQUIRE([AC_CANONICAL_HOST])
 AC_REQUIRE([AC_PROG_CC])
 AC_REQUIRE([AC_PROG_SED])
 AC_LANG_PUSH([C])
 ax_pthread_ok=no
 # We used to check for pthread.h first, but this fails if pthread.h
 # requires special compiler flags (e.g. on Tru64 or Sequent).
 # It gets checked for in the link test anyway.
 # First of all, check if the user has set any of the PTHREAD_LIBS,
 # etcetera environment variables, and if threads linking works using
 # them:
 if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then
        ax_pthread_save_CC="$CC"
        ax_pthread_save_CFLAGS="$CFLAGS"
        ax_pthread_save_LIBS="$LIBS"
        AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"])
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        LIBS="$PTHREAD_LIBS $LIBS"
        AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS])
        AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes])
        AC_MSG_RESULT([$ax_pthread_ok])
        if test "x$ax_pthread_ok" = "xno"; then
                PTHREAD_LIBS=""
                PTHREAD_CFLAGS=""
        fi
        CC="$ax_pthread_save_CC"
        CFLAGS="$ax_pthread_save_CFLAGS"
        LIBS="$ax_pthread_save_LIBS"
 fi
 # We must check for the threads library under a number of different
 # names; the ordering is very important because some systems
 # (e.g. DEC) have both -lpthread and -lpthreads, where one of the
 # libraries is broken (non-POSIX).
 # Create a list of thread flags to try.  Items starting with a "-" are
 # C compiler flags, and other items are library names, except for "none"
 # which indicates that we try without any flags at all, and "pthread-config"
 # which is a program returning the flags for the Pth emulation library.
 ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
 # The ordering *is* (sometimes) important.  Some notes on the
 # individual items follow:
 # pthreads: AIX (must check this before -lpthread)
 # none: in case threads are in libc; should be tried before -Kthread and
 #       other compiler flags to prevent continual compiler warnings
 # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
 # -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64
 #           (Note: HP C rejects this with "bad form for `-t' option")
 # -pthreads: Solaris/gcc (Note: HP C also rejects)
 # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
 #      doesn't hurt to check since this sometimes defines pthreads and
 #      -D_REENTRANT too), HP C (must be checked before -lpthread, which
 #      is present but should not be used directly; and before -mthreads,
 #      because the compiler interprets this as "-mt" + "-hreads")
 # -mthreads: Mingw32/gcc, Lynx/gcc
 # pthread: Linux, etcetera
 # --thread-safe: KAI C++
 # pthread-config: use pthread-config program (for GNU Pth library)
 case $host_os in
        freebsd*)
        # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
        # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
        ax_pthread_flags="-kthread lthread $ax_pthread_flags"
        ;;
        hpux*)
        # From the cc(1) man page: "[-mt] Sets various -D flags to enable
        # multi-threading and also sets -lpthread."
        ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"
        ;;
        openedition*)
        # IBM z/OS requires a feature-test macro to be defined in order to
        # enable POSIX threads at all, so give the user a hint if this is
        # not set. (We don't define these ourselves, as they can affect
        # other portions of the system API in unpredictable ways.)
        AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING],
            [
 #            if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)
             AX_PTHREAD_ZOS_MISSING
 #            endif
            ],
            [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])])
        ;;
        solaris*)
        # On Solaris (at least, for some versions), libc contains stubbed
        # (non-functional) versions of the pthreads routines, so link-based
        # tests will erroneously succeed. (N.B.: The stubs are missing
        # pthread_cleanup_push, or rather a function called by this macro,
        # so we could check for that, but who knows whether they'll stub
        # that too in a future libc.)  So we'll check first for the
        # standard Solaris way of linking pthreads (-mt -lpthread).
        ax_pthread_flags="-mt,pthread pthread $ax_pthread_flags"
        ;;
 esac
 # GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
 AS_IF([test "x$GCC" = "xyes"],
      [ax_pthread_flags="-pthread -pthreads $ax_pthread_flags"])
 # The presence of a feature test macro requesting re-entrant function
 # definitions is, on some systems, a strong hint that pthreads support is
 # correctly enabled
 case $host_os in
        darwin* | hpux* | linux* | osf* | solaris*)
        ax_pthread_check_macro="_REENTRANT"
        ;;
        aix*)
        ax_pthread_check_macro="_THREAD_SAFE"
        ;;
        *)
        ax_pthread_check_macro="--"
        ;;
 esac
 AS_IF([test "x$ax_pthread_check_macro" = "x--"],
      [ax_pthread_check_cond=0],
      [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"])
 # Are we compiling with Clang?
 AC_CACHE_CHECK([whether $CC is Clang],
    [ax_cv_PTHREAD_CLANG],
    [ax_cv_PTHREAD_CLANG=no
     # Note that Autoconf sets GCC=yes for Clang as well as GCC
     if test "x$GCC" = "xyes"; then
        AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG],
            [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */
 #            if defined(__clang__) && defined(__llvm__)
             AX_PTHREAD_CC_IS_CLANG
 #            endif
            ],
            [ax_cv_PTHREAD_CLANG=yes])
     fi
    ])
 ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
 ax_pthread_clang_warning=no
 # Clang needs special handling, because older versions handle the -pthread
 # option in a rather... idiosyncratic way
 if test "x$ax_pthread_clang" = "xyes"; then
        # Clang takes -pthread; it has never supported any other flag
        # (Note 1: This will need to be revisited if a system that Clang
        # supports has POSIX threads in a separate library.  This tends not
        # to be the way of modern systems, but it's conceivable.)
        # (Note 2: On some systems, notably Darwin, -pthread is not needed
        # to get POSIX threads support; the API is always present and
        # active.  We could reasonably leave PTHREAD_CFLAGS empty.  But
        # -pthread does define _REENTRANT, and while the Darwin headers
        # ignore this macro, third-party headers might not.)
        PTHREAD_CFLAGS="-pthread"
        PTHREAD_LIBS=
        ax_pthread_ok=yes
        # However, older versions of Clang make a point of warning the user
        # that, in an invocation where only linking and no compilation is
        # taking place, the -pthread option has no effect ("argument unused
        # during compilation").  They expect -pthread to be passed in only
        # when source code is being compiled.
        #
        # Problem is, this is at odds with the way Automake and most other
        # C build frameworks function, which is that the same flags used in
        # compilation (CFLAGS) are also used in linking.  Many systems
        # supported by AX_PTHREAD require exactly this for POSIX threads
        # support, and in fact it is often not straightforward to specify a
        # flag that is used only in the compilation phase and not in
        # linking.  Such a scenario is extremely rare in practice.
        #
        # Even though use of the -pthread flag in linking would only print
        # a warning, this can be a nuisance for well-run software projects
        # that build with -Werror.  So if the active version of Clang has
        # this misfeature, we search for an option to squash it.
        AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread],
            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG],
            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown
             # Create an alternate version of $ac_link that compiles and
             # links in two steps (.c -> .o, .o -> exe) instead of one
             # (.c -> exe), because the warning occurs only in the second
             # step
             ax_pthread_save_ac_link="$ac_link"
             ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
             ax_pthread_link_step=`$as_echo "$ac_link" | sed "$ax_pthread_sed"`
             ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
             ax_pthread_save_CFLAGS="$CFLAGS"
             for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
                AS_IF([test "x$ax_pthread_try" = "xunknown"], [break])
                CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"
                ac_link="$ax_pthread_save_ac_link"
                AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
                    [ac_link="$ax_pthread_2step_ac_link"
                     AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
                         [break])
                    ])
             done
             ac_link="$ax_pthread_save_ac_link"
             CFLAGS="$ax_pthread_save_CFLAGS"
             AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no])
             ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"
            ])
        case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
                no | unknown) ;;
                *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;
        esac
 fi # $ax_pthread_clang = yes
 if test "x$ax_pthread_ok" = "xno"; then
 for ax_pthread_try_flag in $ax_pthread_flags; do
        case $ax_pthread_try_flag in
                none)
                AC_MSG_CHECKING([whether pthreads work without any flags])
                ;;
                -mt,pthread)
                AC_MSG_CHECKING([whether pthreads work with -mt -lpthread])
                PTHREAD_CFLAGS="-mt"
                PTHREAD_LIBS="-lpthread"
                ;;
                -*)
                AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag])
                PTHREAD_CFLAGS="$ax_pthread_try_flag"
                ;;
                pthread-config)
                AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])
                AS_IF([test "x$ax_pthread_config" = "xno"], [continue])
                PTHREAD_CFLAGS="`pthread-config --cflags`"
                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
                ;;
                *)
                AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag])
                PTHREAD_LIBS="-l$ax_pthread_try_flag"
                ;;
        esac
        ax_pthread_save_CFLAGS="$CFLAGS"
        ax_pthread_save_LIBS="$LIBS"
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        LIBS="$PTHREAD_LIBS $LIBS"
        # Check for various functions.  We must include pthread.h,
        # since some functions may be macros.  (On the Sequent, we
        # need a special flag -Kthread to make this header compile.)
        # We check for pthread_join because it is in -lpthread on IRIX
        # while pthread_create is in libc.  We check for pthread_attr_init
        # due to DEC craziness with -lpthreads.  We check for
        # pthread_cleanup_push because it is one of the few pthread
        # functions on Solaris that doesn't have a non-functional libc stub.
        # We try pthread_create on general principles.
        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
 #                       if $ax_pthread_check_cond
 #                        error "$ax_pthread_check_macro must be defined"
 #                       endif
                        static void routine(void *a) { a = 0; }
                        static void *start_routine(void *a) { return a; }],
                       [pthread_t th; pthread_attr_t attr;
                        pthread_create(&th, 0, start_routine, 0);
                        pthread_join(th, 0);
                        pthread_attr_init(&attr);
                        pthread_cleanup_push(routine, 0);
                        pthread_cleanup_pop(0) /* ; */])],
            [ax_pthread_ok=yes],
            [])
        CFLAGS="$ax_pthread_save_CFLAGS"
        LIBS="$ax_pthread_save_LIBS"
        AC_MSG_RESULT([$ax_pthread_ok])
        AS_IF([test "x$ax_pthread_ok" = "xyes"], [break])
        PTHREAD_LIBS=""
        PTHREAD_CFLAGS=""
 done
 fi
 # Various other checks:
 if test "x$ax_pthread_ok" = "xyes"; then
        ax_pthread_save_CFLAGS="$CFLAGS"
        ax_pthread_save_LIBS="$LIBS"
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
        LIBS="$PTHREAD_LIBS $LIBS"
        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
        AC_CACHE_CHECK([for joinable pthread attribute],
            [ax_cv_PTHREAD_JOINABLE_ATTR],
            [ax_cv_PTHREAD_JOINABLE_ATTR=unknown
             for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
                 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
                                                 [int attr = $ax_pthread_attr; return attr /* ; */])],
                                [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break],
                                [])
             done
            ])
        AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
               test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
               test "x$ax_pthread_joinable_attr_defined" != "xyes"],
              [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE],
                                  [$ax_cv_PTHREAD_JOINABLE_ATTR],
                                  [Define to necessary symbol if this constant
                                   uses a non-standard name on your system.])
               ax_pthread_joinable_attr_defined=yes
              ])
        AC_CACHE_CHECK([whether more special flags are required for pthreads],
            [ax_cv_PTHREAD_SPECIAL_FLAGS],
            [ax_cv_PTHREAD_SPECIAL_FLAGS=no
             case $host_os in
             solaris*)
             ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"
             ;;
             esac
            ])
        AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
               test "x$ax_pthread_special_flags_added" != "xyes"],
              [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"
               ax_pthread_special_flags_added=yes])
        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
            [ax_cv_PTHREAD_PRIO_INHERIT],
            [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],
                                             [[int i = PTHREAD_PRIO_INHERIT;]])],
                            [ax_cv_PTHREAD_PRIO_INHERIT=yes],
                            [ax_cv_PTHREAD_PRIO_INHERIT=no])
            ])
        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
               test "x$ax_pthread_prio_inherit_defined" != "xyes"],
              [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])
               ax_pthread_prio_inherit_defined=yes
              ])
        CFLAGS="$ax_pthread_save_CFLAGS"
        LIBS="$ax_pthread_save_LIBS"
        # More AIX lossage: compile with *_r variant
        if test "x$GCC" != "xyes"; then
            case $host_os in
                aix*)
                AS_CASE(["x/$CC"],
                    [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
                    [#handle absolute path differently from PATH based program lookup
                     AS_CASE(["x$CC"],
                         [x/*],
                         [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
                         [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
                ;;
            esac
        fi
 fi
 test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
 AC_SUBST([PTHREAD_LIBS])
 AC_SUBST([PTHREAD_CFLAGS])
 AC_SUBST([PTHREAD_CC])
 # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
 if test "x$ax_pthread_ok" = "xyes"; then
        ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
        :
 else
        ax_pthread_ok=no
        $2
 fi
 AC_LANG_POP
 ])dnl AX_PTHREAD
@@ -3913,6 +3913,7 @@
 ./lib/win32/bindevt/bindevt.vcxproj.user	X	2013,2018
 ./ltmain.sh					X	1999,2000,2001,2003,2004,2006,2009,2012,2018
 ./m4/ax_check_openssl.m4			X	2018
 ./m4/ax_pthread.m4				X	2018
 ./m4/libtool.m4					X	2012,2018
 ./m4/ltoptions.m4				X	2012,2018
 ./m4/ltsugar.m4					X	2012,2018
Author	SHA1	Message	Date
Ondřej Surý	3b70beca17	fixup! Remove unthreaded support	2018-08-15 11:36:35 +02:00
Witold Kręcicki	b3a2a9beee	Remove unthreaded support	2018-08-14 20:55:48 +02:00