Add NS_CLIENT_MOCKREPLY - if defined, BIND will reply with empty

answers to each query, without doing any processing. This can
be used to test network stack performance.

bin/delv/delv.c

@@ -1623,7 +1623,7 @@ main(int argc, char *argv[]) {
 		fatal("failed to create mctx");
 
 	CHECK(isc_appctx_create(mctx, &actx));
-	CHECK(isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr));
+	CHECK(isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr));
 	CHECK(isc_socketmgr_createinctx(mctx, actx, &socketmgr));
 	CHECK(isc_timermgr_createinctx(mctx, actx, &timermgr));
 

bin/dig/dighost.c

@@ -1363,7 +1363,7 @@ setup_libs(void) {
 
 	isc_log_setdebuglevel(lctx, 0);
 
-	result = isc_taskmgr_create(mctx, 1, &taskmgr);
+	result = isc_taskmgr_create(mctx, 1, 0, &taskmgr);
 	check_result(result, "isc_taskmgr_create");
 
 	result = isc_task_create(taskmgr, 0, &global_task);

bin/dnssec/dnssec-signzone.c

@@ -3853,7 +3853,7 @@ main(int argc, char *argv[]) {
 	print_time(outfp);
 	print_version(outfp);
 
-	result = isc_taskmgr_create(mctx, ntasks, &taskmgr);
+	result = isc_taskmgr_create(mctx, ntasks, 0, &taskmgr);
 	if (result != ISC_R_SUCCESS)
 		fatal("failed to create task manager: %s",
 		      isc_result_totext(result));

bin/named/main.c

@@ -803,7 +803,7 @@ create_managers(void) {
 		      "using %u UDP listener%s per interface",
 		      named_g_udpdisp, named_g_udpdisp == 1 ? "" : "s");
 
-	result = isc_taskmgr_create(named_g_mctx, named_g_cpus,
+	result = isc_taskmgr_create(named_g_mctx, named_g_cpus, 0,
 				    &named_g_taskmgr);
 	if (result != ISC_R_SUCCESS) {
 		UNEXPECTED_ERROR(__FILE__, __LINE__,

bin/nsupdate/nsupdate.c

@@ -885,7 +885,7 @@ setup_system(void) {
 	result = isc_timermgr_create(gmctx, &timermgr);
 	check_result(result, "dns_timermgr_create");
 
-	result = isc_taskmgr_create(gmctx, 1, &taskmgr);
+	result = isc_taskmgr_create(gmctx, 1, 0, &taskmgr);
 	check_result(result, "isc_taskmgr_create");
 
 	result = isc_task_create(taskmgr, 0, &global_task);

bin/rndc/rndc.c

@@ -934,7 +934,7 @@ main(int argc, char **argv) {
 
 	DO("create memory context", isc_mem_create(0, 0, &rndc_mctx));
 	DO("create socket manager", isc_socketmgr_create(rndc_mctx, &socketmgr));
-	DO("create task manager", isc_taskmgr_create(rndc_mctx, 1, &taskmgr));
+	DO("create task manager", isc_taskmgr_create(rndc_mctx, 1, 0, &taskmgr));
 	DO("create task", isc_task_create(taskmgr, 0, &task));
 
 	DO("create logging context", isc_log_create(rndc_mctx, &log, &logconfig));

bin/tests/optional/adb_test.c

@@ -146,7 +146,7 @@ create_managers(void) {
 	isc_result_t result;
 
 	taskmgr = NULL;
-	result = isc_taskmgr_create(mctx, 5, &taskmgr);
+	result = isc_taskmgr_create(mctx, 5, 0, &taskmgr);
 	check_result(result, "isc_taskmgr_create");
 
 	timermgr = NULL;

bin/tests/optional/byaddr_test.c

@@ -114,7 +114,7 @@ main(int argc, char *argv[]) {
 	}
 
 	taskmgr = NULL;
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &taskmgr)
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr)
 		      == ISC_R_SUCCESS);
 	task = NULL;
 	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task)

bin/tests/optional/byname_test.c

@@ -228,7 +228,7 @@ main(int argc, char *argv[]) {
 	}
 
 	taskmgr = NULL;
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &taskmgr) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr) ==
 		      ISC_R_SUCCESS);
 	task = NULL;
 	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task) ==

bin/tests/optional/gsstest.c

@@ -472,7 +472,7 @@ main(int argc, char *argv[]) {
 	RUNCHECK(dst_lib_init(mctx, NULL));
 
 	taskmgr = NULL;
-	RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
+	RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;

bin/tests/optional/ratelimiter_test.c

@@ -104,7 +104,8 @@ main(int argc, char *argv[]) {
 	isc_interval_set(&linterval, 1, 0);
 
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, 3, &taskmgr) == ISC_R_SUCCESS);
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, 3, 0, &taskmgr) ==
+		      ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) ==
 		      ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &g_task) ==

bin/tests/optional/shutdown_test.c

@@ -183,7 +183,7 @@ main(int argc, char *argv[]) {
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
 	mctx2 = NULL;
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx2) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &task_manager) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &task_manager) ==
 		      ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_timermgr_create(mctx, &timer_manager) ==
 		      ISC_R_SUCCESS);

bin/tests/optional/sig0_test.c

@@ -228,7 +228,8 @@ main(int argc, char *argv[]) {
 	dst_result_register();
 
 	taskmgr = NULL;
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, &taskmgr) == ISC_R_SUCCESS);
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, 0, &taskmgr) ==
+		      ISC_R_SUCCESS);
 	task1 = NULL;
 	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task1) == ISC_R_SUCCESS);
 

bin/tests/optional/sock_test.c

@@ -297,7 +297,7 @@ main(int argc, char *argv[]) {
 	 * The task manager is independent (other than memory context)
 	 */
 	manager = NULL;
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &manager) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
 		      ISC_R_SUCCESS);
 
 	/*

bin/tests/optional/task_test.c

@@ -81,7 +81,7 @@ main(int argc, char *argv[]) {
 
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
 
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &manager) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
 		      ISC_R_SUCCESS);
 
 	RUNTIME_CHECK(isc_task_create(manager, 0, &t1) == ISC_R_SUCCESS);

bin/tests/optional/timer_test.c

@@ -110,7 +110,7 @@ main(int argc, char *argv[]) {
 	printf("%u workers\n", workers);
 
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx1) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_taskmgr_create(mctx1, workers, &manager) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx1, workers, 0, &manager) ==
 		      ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_timermgr_create(mctx1, &timgr) == ISC_R_SUCCESS);
 

bin/tests/optional/zone_test.c

@@ -284,7 +284,7 @@ main(int argc, char **argv) {
 
 	RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, &taskmgr) ==
+	RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, 0, &taskmgr) ==
 		      ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) == ISC_R_SUCCESS);
 	RUNTIME_CHECK(isc_socketmgr_create(mctx, &socketmgr) == ISC_R_SUCCESS);

bin/tests/system/pipelined/pipequeries.c

@@ -279,7 +279,7 @@ main(int argc, char *argv[]) {
 	RUNCHECK(dst_lib_init(mctx, NULL));
 
 	taskmgr = NULL;
-	RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
+	RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;

bin/tests/system/tkey/keycreate.c

@@ -239,7 +239,7 @@ main(int argc, char *argv[]) {
 	RUNCHECK(dst_lib_init(mctx, NULL));
 
 	taskmgr = NULL;
-	RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
+	RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;

bin/tests/system/tkey/keydelete.c

@@ -178,7 +178,7 @@ main(int argc, char **argv) {
 	RUNCHECK(dst_lib_init(mctx, NULL));
 
 	taskmgr = NULL;
-	RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
+	RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;

bin/tools/mdig.c

@@ -1981,7 +1981,7 @@ main(int argc, char *argv[]) {
 		fatal("can't choose between IPv4 and IPv6");
 
 	taskmgr = NULL;
-	RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
+	RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;

lib/dns/client.c

@@ -379,7 +379,7 @@ dns_client_create(dns_client_t **clientp, unsigned int options) {
 	result = isc_app_ctxstart(actx);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
-	result = isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr);
+	result = isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 	result = isc_socketmgr_createinctx(mctx, actx, &socketmgr);

lib/dns/tests/dnstest.c

@@ -109,7 +109,7 @@ create_managers(void) {
 	isc_result_t result;
 	ncpus = isc_os_ncpus();
 
-	CHECK(isc_taskmgr_create(mctx, ncpus, &taskmgr));
+	CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
 	CHECK(isc_timermgr_create(mctx, &timermgr));
 	CHECK(isc_socketmgr_create(mctx, &socketmgr));
 	CHECK(isc_task_create(taskmgr, 0, &maintask));

lib/irs/context.c

@@ -104,7 +104,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
 	if (result != ISC_R_SUCCESS)
 		goto fail;
 
-	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
+	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
 	if (result != ISC_R_SUCCESS)
 		goto fail;
 

lib/isc/include/isc/task.h

@@ -631,10 +631,11 @@ isc_task_privilege(isc_task_t *task);
 
 isc_result_t
 isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
-			unsigned int workers, isc_taskmgr_t **managerp);
+			unsigned int workers, unsigned int default_quantum,
+			isc_taskmgr_t **managerp);
 isc_result_t
 isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
-		   isc_taskmgr_t **managerp);
+		   unsigned int default_quantum, isc_taskmgr_t **managerp);
 /*%<
  * Create a new task manager.  isc_taskmgr_createinctx() also associates
  * the new manager with the specified application context.
@@ -647,6 +648,10 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
  *	create 'workers' threads, but if at least one thread creation
  *	succeeds, isc_taskmgr_create() may return ISC_R_SUCCESS.
  *
+ *\li	If 'default_quantum' is non-zero, then it will be used as the default
+ *	quantum value when tasks are created.  If zero, then an implementation
+ *	defined default quantum will be used.
+ *
  * Requires:
  *
  *\li      'mctx' is a valid memory context.

lib/isc/rwlock.c

@@ -44,9 +44,11 @@
 #if defined(_MSC_VER)
 # include <intrin.h>
 # define isc_rwlock_pause() YieldProcessor()
-#elif defined(__x86_64__) || defined(__i386__)
+#elif defined(__x86_64__)
 # include <immintrin.h>
 # define isc_rwlock_pause() _mm_pause()
+#elif defined(__i386__)
+# define isc_rwlock_pause() __asm__ __volatile__ ("rep; nop")
 #elif defined(__ia64__)
 # define isc_rwlock_pause() __asm__ __volatile__ ("hint @pause")
 #elif defined(__arm__)

lib/isc/task.c

@@ -134,8 +134,6 @@ struct isc__taskqueue {
 	isc_condition_t			work_available;
 	isc_thread_t			thread;
 	unsigned int			threadid;
-	unsigned int			tasks_waiting;
-	bool				running;
 	isc__taskmgr_t			*manager;
 };
 
@@ -147,10 +145,13 @@ struct isc__taskmgr {
 	isc_mutex_t			halt_lock;
 	isc_condition_t			halt_cond;
 	unsigned int			workers;
+	atomic_uint_fast32_t		tasks_running;
+	atomic_uint_fast32_t		tasks_ready;
 	atomic_uint_fast32_t		curq;
 	isc__taskqueue_t		*queues;
 
 	/* Locked by task manager lock. */
+	unsigned int			default_quantum;
 	LIST(isc__task_t)		tasks;
 	isc_taskmgrmode_t		mode;
 	bool				pause_requested;
@@ -175,7 +176,7 @@ void
 isc__taskmgr_resume(isc_taskmgr_t *manager0);
 
 
-#define DEFAULT_QUANTUM			25
+#define DEFAULT_DEFAULT_QUANTUM		25
 #define FINISHED(m)			((m)->exiting && EMPTY((m)->tasks))
 
 /*%
@@ -291,7 +292,7 @@ isc_task_create_bound(isc_taskmgr_t *manager0, unsigned int quantum,
 	INIT_LIST(task->events);
 	INIT_LIST(task->on_shutdown);
 	task->nevents = 0;
-	task->quantum = quantum;
+	task->quantum = (quantum > 0) ? quantum : manager->default_quantum;
 	task->flags = 0;
 	task->now = 0;
 	isc_time_settoepoch(&task->tnow);
@@ -931,8 +932,6 @@ pop_readyq(isc__taskmgr_t *manager, int c) {
 
 	if (task != NULL) {
 		DEQUEUE(manager->queues[c].ready_tasks, task, ready_link);
-		INSIST(manager->queues[c].tasks_waiting > 0);
-		manager->queues[c].tasks_waiting--;
 		if (ISC_LINK_LINKED(task, ready_priority_link)) {
 			DEQUEUE(manager->queues[c].ready_priority_tasks, task,
 				ready_priority_link);
@@ -951,11 +950,12 @@ pop_readyq(isc__taskmgr_t *manager, int c) {
 static inline void
 push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c) {
 	ENQUEUE(manager->queues[c].ready_tasks, task, ready_link);
-	manager->queues[c].tasks_waiting++;
 	if ((task->flags & TASK_F_PRIVILEGED) != 0) {
 		ENQUEUE(manager->queues[c].ready_priority_tasks, task,
 			ready_priority_link);
 	}
+	atomic_fetch_add_explicit(&manager->tasks_ready, 1,
+				  memory_order_acquire);
 }
 
 static void
@@ -1095,7 +1095,6 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 		task = pop_readyq(manager, threadid);
 		if (task != NULL) {
 			unsigned int dispatch_count = 0;
-			unsigned int quantum = (task->quantum > 0) ? task->quantum : DEFAULT_QUANTUM;
 			bool done = false;
 			bool requeue = false;
 			bool finished = false;
@@ -1108,8 +1107,12 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 			 * have a task to do.  We must reacquire the queue
 			 * lock before exiting the 'if (task != NULL)' block.
 			 */
-			manager->queues[threadid].running = true;
 			UNLOCK(&manager->queues[threadid].lock);
+			RUNTIME_CHECK(
+			      atomic_fetch_sub_explicit(&manager->tasks_ready,
+						1, memory_order_release) > 0);
+			atomic_fetch_add_explicit(&manager->tasks_running, 1,
+						  memory_order_acquire);
 
 			LOCK(&task->lock);
 			INSIST(task->state == task_state_ready);
@@ -1198,7 +1201,7 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 					} else
 						task->state = task_state_idle;
 					done = true;
-				} else if (dispatch_count >= quantum) {
+				} else if (dispatch_count >= task->quantum) {
 					/*
 					 * Our quantum has expired, but
 					 * there is more work to be done.
@@ -1223,8 +1226,10 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 			if (finished)
 				task_finished(task);
 
+			RUNTIME_CHECK(
+			      atomic_fetch_sub_explicit(&manager->tasks_running,
+						1, memory_order_release) > 0);
 			LOCK(&manager->queues[threadid].lock);
-			manager->queues[threadid].running = false;
 			if (requeue) {
 				/*
 				 * We know we're awake, so we don't have
@@ -1251,14 +1256,13 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 
 		/*
 		 * If we are in privileged execution mode and there are no
-		 * tasks remaining on the current ready queue, we need to check
-		 * if maybe we need to drop from privileged to normal mode.
-		 * This might seem too heavy with all the locking but
-		 * privileged mode is used only during startup and dropped
-		 * once - after that this code is never executed.
+		 * tasks remaining on the current ready queue, then
+		 * we're stuck.  Automatically drop privileges at that
+		 * point and continue with the regular ready queue.
 		 */
 		if (manager->mode != isc_taskmgrmode_normal &&
-		    empty_readyq(manager, threadid))
+		    atomic_load_explicit(&manager->tasks_running,
+					 memory_order_acquire) == 0)
 		{
 			UNLOCK(&manager->queues[threadid].lock);
 			LOCK(&manager->lock);
@@ -1269,14 +1273,16 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
 			 * we'll end up in a deadlock over queue locks.
 			 *
 			 */
-			if (manager->mode != isc_taskmgrmode_normal) {
+			if (manager->mode != isc_taskmgrmode_normal &&
+			    atomic_load_explicit(&manager->tasks_running,
+						 memory_order_acquire) == 0)
+			{
 				bool empty = true;
 				unsigned int i;
 				for (i = 0; i < manager->workers && empty; i++)
 				{
 					LOCK(&manager->queues[i].lock);
-					empty &= empty_readyq(manager, i) &&
-						 !manager->queues[i].running;
+					empty &= empty_readyq(manager, i);
 					UNLOCK(&manager->queues[i].lock);
 				}
 				if (empty) {
@@ -1337,7 +1343,7 @@ manager_free(isc__taskmgr_t *manager) {
 
 isc_result_t
 isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
-		   isc_taskmgr_t **managerp)
+		    unsigned int default_quantum, isc_taskmgr_t **managerp)
 {
 	unsigned int i;
 	isc__taskmgr_t *manager;
@@ -1363,10 +1369,16 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 
 	manager->workers = workers;
 
+	if (default_quantum == 0) {
+		default_quantum = DEFAULT_DEFAULT_QUANTUM;
+	}
+	manager->default_quantum = default_quantum;
 	INIT_LIST(manager->tasks);
 	manager->queues = isc_mem_get(mctx, workers * sizeof(isc__taskqueue_t));
 	RUNTIME_CHECK(manager->queues != NULL);
 
+	manager->tasks_running = 0;
+	manager->tasks_ready = 0;
 	manager->curq = 0;
 	manager->exiting = false;
 	manager->excl = NULL;
@@ -1388,8 +1400,6 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 
 		manager->queues[i].manager = manager;
 		manager->queues[i].threadid = i;
-		manager->queues[i].tasks_waiting = 0;
-		manager->queues[i].running = false;
 		RUNTIME_CHECK(isc_thread_create(run, &manager->queues[i],
 						&manager->queues[i].thread)
 			      == ISC_R_SUCCESS);
@@ -1698,6 +1708,21 @@ isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
 	TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->workers));
 	TRY0(xmlTextWriterEndElement(writer)); /* worker-threads */
 
+	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "default-quantum"));
+	TRY0(xmlTextWriterWriteFormatString(writer, "%d",
+					    mgr->default_quantum));
+	TRY0(xmlTextWriterEndElement(writer)); /* default-quantum */
+
+	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks-running"));
+	TRY0(xmlTextWriterWriteFormatString(writer, "%d",
+					    (int) mgr->tasks_running));
+	TRY0(xmlTextWriterEndElement(writer)); /* tasks-running */
+
+	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks-ready"));
+	TRY0(xmlTextWriterWriteFormatString(writer, "%d",
+					    (int) mgr->tasks_ready));
+	TRY0(xmlTextWriterEndElement(writer)); /* tasks-ready */
+
 	TRY0(xmlTextWriterEndElement(writer)); /* thread-model */
 
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks"));
@@ -1784,6 +1809,18 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
 	CHECKMEM(obj);
 	json_object_object_add(tasks, "worker-threads", obj);
 
+	obj = json_object_new_int(mgr->default_quantum);
+	CHECKMEM(obj);
+	json_object_object_add(tasks, "default-quantum", obj);
+
+	obj = json_object_new_int(mgr->tasks_running);
+	CHECKMEM(obj);
+	json_object_object_add(tasks, "tasks-running", obj);
+
+	obj = json_object_new_int(mgr->tasks_ready);
+	CHECKMEM(obj);
+	json_object_object_add(tasks, "tasks-ready", obj);
+
 	array = json_object_new_array();
 	CHECKMEM(array);
 
@@ -1848,11 +1885,13 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
 
 isc_result_t
 isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
-			unsigned int workers, isc_taskmgr_t **managerp)
+			unsigned int workers, unsigned int default_quantum,
+			isc_taskmgr_t **managerp)
 {
 	isc_result_t result;
 
-	result = isc_taskmgr_create(mctx, workers, managerp);
+	result = isc_taskmgr_create(mctx, workers, default_quantum,
+				       managerp);
 
 	if (result == ISC_R_SUCCESS)
 		isc_appctx_settaskmgr(actx, *managerp);

lib/isc/tests/isctest.c

@@ -86,7 +86,7 @@ create_managers(unsigned int workers) {
 		workers = atoi(p);
 	}
 
-	CHECK(isc_taskmgr_create(mctx, workers, &taskmgr));
+	CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr));
 	CHECK(isc_task_create(taskmgr, 0, &maintask));
 	isc_taskmgr_setexcltask(taskmgr, maintask);
 

lib/isc/tests/task_test.c

@@ -712,7 +712,7 @@ manytasks(void **state) {
 	result = isc_mem_create(0, 0, &mctx);
 	assert_int_equal(result, ISC_R_SUCCESS);
 
-	result = isc_taskmgr_create(mctx, 4, &taskmgr);
+	result = isc_taskmgr_create(mctx, 4, 0, &taskmgr);
 	assert_int_equal(result, ISC_R_SUCCESS);
 
 	done = false;

lib/isc/unix/socket.c

@@ -335,6 +335,7 @@ struct isc__socket {
 	/* Not locked. */
 	isc_socket_t		common;
 	isc__socketmgr_t	*manager;
+	isc_mutex_t		lock;
 	isc_sockettype_t	type;
 	const isc_statscounter_t	*statsindex;
 	isc_refcount_t		references;
@@ -347,12 +348,10 @@ struct isc__socket {
 	char				name[16];
 	void *				tag;
 
-	isc_mutex_t		rdlock;
 	ISC_LIST(isc_socketevent_t)		send_list;
 	ISC_LIST(isc_socketevent_t)		recv_list;
 	ISC_LIST(isc_socket_newconnev_t)	accept_list;
 	ISC_LIST(isc_socket_connev_t)		connect_list;
-	isc_mutex_t		wrlock;
 
 	isc_sockaddr_t		peer_address;       /* remote address */
 
@@ -772,9 +771,7 @@ watch_fd(isc__socketthread_t *thread, int fd, int msg) {
 static inline isc_result_t
 unwatch_fd(isc__socketthread_t *thread, int fd, int msg) {
 	isc_result_t result = ISC_R_SUCCESS;
-	if (fd <= 0) {
-		return (ISC_R_SUCCESS);
-	}
+
 #ifdef USE_KQUEUE
 	struct kevent evchange;
 
@@ -1938,8 +1935,7 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
 	/*
 	 * Initialize the lock.
 	 */
-	isc_mutex_init(&sock->rdlock);
-	isc_mutex_init(&sock->wrlock);
+	isc_mutex_init(&sock->lock);
 
 	sock->common.magic = ISCAPI_SOCKET_MAGIC;
 	sock->common.impmagic = SOCKET_MAGIC;
@@ -1971,8 +1967,7 @@ free_socket(isc__socket_t **socketp) {
 	sock->common.magic = 0;
 	sock->common.impmagic = 0;
 
-	isc_mutex_destroy(&sock->rdlock);
-	isc_mutex_destroy(&sock->wrlock);
+	isc_mutex_destroy(&sock->lock);
 
 	isc_mem_put(sock->manager->mctx, sock, sizeof(*sock));
 
@@ -2761,8 +2756,7 @@ isc_socket_close(isc_socket_t *sock0) {
 	fflush(stdout);
 	REQUIRE(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	REQUIRE(sock->fd >= 0 && sock->fd < (int)sock->manager->maxsocks);
 
@@ -2787,8 +2781,7 @@ isc_socket_close(isc_socket_t *sock0) {
 	sock->bound = 0;
 	isc_sockaddr_any(&sock->peer_address);
 
-	UNLOCK(&sock->wrlock);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 
 	socketclose(thread, sock, fd);
 
@@ -2896,7 +2889,7 @@ internal_accept(isc__socket_t *sock) {
 
 	INSIST(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
+	LOCK(&sock->lock);
 	socket_log(sock, NULL, TRACE,
 		   isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_ACCEPTLOCK,
 		   "internal_accept called, locked socket");
@@ -2914,7 +2907,7 @@ internal_accept(isc__socket_t *sock) {
 	dev = ISC_LIST_HEAD(sock->accept_list);
 	if (dev == NULL) {
 		unwatch_fd(thread, sock->fd, SELECT_POKE_ACCEPT);
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		return;
 	}
 
@@ -3043,7 +3036,7 @@ internal_accept(isc__socket_t *sock) {
 		unwatch_fd(thread, sock->fd,
 			   SELECT_POKE_ACCEPT);
 
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 
 	if (fd != -1) {
 		result = make_nonblock(fd);
@@ -3130,7 +3123,7 @@ internal_accept(isc__socket_t *sock) {
 
  soft_error:
 	watch_fd(thread, sock->fd, SELECT_POKE_ACCEPT);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 
 	inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
 	return;
@@ -3142,7 +3135,7 @@ internal_recv(isc__socket_t *sock) {
 
 	INSIST(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
+	LOCK(&sock->lock);
 	dev = ISC_LIST_HEAD(sock->recv_list);
 	if (dev == NULL) {
 		goto finish;
@@ -3179,6 +3172,7 @@ internal_recv(isc__socket_t *sock) {
 			send_recvdone_event(sock, &dev);
 			break;
 		}
+
 		dev = ISC_LIST_HEAD(sock->recv_list);
 	}
 
@@ -3187,7 +3181,7 @@ internal_recv(isc__socket_t *sock) {
 		unwatch_fd(&sock->manager->threads[sock->threadid], sock->fd,
 			   SELECT_POKE_READ);
 	}
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 }
 
 static void
@@ -3196,7 +3190,7 @@ internal_send(isc__socket_t *sock) {
 
 	INSIST(VALID_SOCKET(sock));
 
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 	dev = ISC_LIST_HEAD(sock->send_list);
 	if (dev == NULL) {
 		goto finish;
@@ -3219,6 +3213,7 @@ internal_send(isc__socket_t *sock) {
 			send_senddone_event(sock, &dev);
 			break;
 		}
+
 		dev = ISC_LIST_HEAD(sock->send_list);
 	}
 
@@ -3227,7 +3222,7 @@ internal_send(isc__socket_t *sock) {
 		unwatch_fd(&sock->manager->threads[sock->threadid],
 			   sock->fd, SELECT_POKE_WRITE);
 	}
-	UNLOCK(&sock->wrlock);
+	UNLOCK(&sock->lock);
 }
 
 /*
@@ -4076,7 +4071,7 @@ socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 	if (sock->type == isc_sockettype_udp) {
 		io_state = doio_recv(sock, dev);
 	} else {
-		LOCK(&sock->rdlock);
+		LOCK(&sock->lock);
 		have_lock = true;
 
 		if (ISC_LIST_EMPTY(sock->recv_list)) {
@@ -4098,7 +4093,7 @@ socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 		dev->attributes |= ISC_SOCKEVENTATTR_ATTACHED;
 
 		if (!have_lock) {
-			LOCK(&sock->rdlock);
+			LOCK(&sock->lock);
 			have_lock = true;
 		}
 
@@ -4135,7 +4130,7 @@ socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 	}
 
 	if (have_lock) {
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 	}
 
 	return (result);
@@ -4230,7 +4225,7 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 	if (sock->type == isc_sockettype_udp) {
 		io_state = doio_send(sock, dev);
 	} else {
-		LOCK(&sock->wrlock);
+		LOCK(&sock->lock);
 		have_lock = true;
 
 		if (ISC_LIST_EMPTY(sock->send_list)) {
@@ -4251,7 +4246,7 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 			dev->attributes |= ISC_SOCKEVENTATTR_ATTACHED;
 
 			if (!have_lock) {
-				LOCK(&sock->wrlock);
+				LOCK(&sock->lock);
 				have_lock = true;
 			}
 
@@ -4261,16 +4256,6 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 			 * paying attention to it.
 			 */
 			bool do_poke = ISC_LIST_EMPTY(sock->send_list);
-			if (do_poke) {
-				io_state = doio_send(sock, dev);
-				if (io_state == DOIO_HARD || io_state == DOIO_SUCCESS) {
-					if ((flags & ISC_SOCKFLAG_IMMEDIATE) == 0) {
-						send_senddone_event(sock, &dev);
-					}
-					break;
-				}
-			}
-
 			ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
 			if (do_poke) {
 				select_poke(sock->manager, sock->threadid,
@@ -4298,7 +4283,7 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
 	}
 
 	if (have_lock) {
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 	}
 
 	return (result);
@@ -4562,13 +4547,13 @@ isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
 
 	REQUIRE(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
+	LOCK(&sock->lock);
 
 	INSIST(!sock->bound);
 	INSIST(!sock->dupped);
 
 	if (sock->pf != sockaddr->type.sa.sa_family) {
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		return (ISC_R_FAMILYMISMATCH);
 	}
 
@@ -4608,7 +4593,7 @@ isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
 		inc_stats(sock->manager->stats,
 			  sock->statsindex[STATID_BINDFAIL]);
 
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		switch (errno) {
 		case EACCES:
 			return (ISC_R_NOPERM);
@@ -4630,7 +4615,7 @@ isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
 		   isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_BOUND, "bound");
 	sock->bound = 1;
 
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 	return (ISC_R_SUCCESS);
 }
 
@@ -4751,7 +4736,7 @@ isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
 
 	REQUIRE(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
+	LOCK(&sock->lock);
 
 	REQUIRE(!sock->listener);
 	REQUIRE(sock->bound);
@@ -4762,7 +4747,7 @@ isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
 		backlog = SOMAXCONN;
 
 	if (listen(sock->fd, (int)backlog) < 0) {
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		strerror_r(errno, strbuf, sizeof(strbuf));
 
 		UNEXPECTED_ERROR(__FILE__, __LINE__, "listen: %s", strbuf);
@@ -4774,7 +4759,7 @@ isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
 
 	sock->listener = 1;
 
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 	return (ISC_R_SUCCESS);
 }
 
@@ -4797,7 +4782,7 @@ isc_socket_accept(isc_socket_t *sock0,
 	manager = sock->manager;
 	REQUIRE(VALID_MANAGER(manager));
 
-	LOCK(&sock->rdlock);
+	LOCK(&sock->lock);
 
 	REQUIRE(sock->listener);
 
@@ -4810,7 +4795,7 @@ isc_socket_accept(isc_socket_t *sock0,
 		isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN,
 				   action, arg, sizeof(*dev));
 	if (dev == NULL) {
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		return (ISC_R_NOMEMORY);
 	}
 	ISC_LINK_INIT(dev, ev_link);
@@ -4818,7 +4803,7 @@ isc_socket_accept(isc_socket_t *sock0,
 	result = allocate_socket(manager, sock->type, &nsock);
 	if (result != ISC_R_SUCCESS) {
 		isc_event_free(ISC_EVENT_PTR(&dev));
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		return (result);
 	}
 
@@ -4830,7 +4815,7 @@ isc_socket_accept(isc_socket_t *sock0,
 		free_socket(&nsock);
 		isc_task_detach(&ntask);
 		isc_event_free(ISC_EVENT_PTR(&dev));
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		return (ISC_R_SHUTTINGDOWN);
 	}
 	isc_refcount_increment(&nsock->references);
@@ -4850,7 +4835,7 @@ isc_socket_accept(isc_socket_t *sock0,
 		select_poke(manager, sock->threadid, sock->fd,
 			    SELECT_POKE_ACCEPT);
 	}
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 	return (ISC_R_SUCCESS);
 }
 
@@ -4878,14 +4863,14 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 	if (isc_sockaddr_ismulticast(addr))
 		return (ISC_R_MULTICAST);
 
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	dev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
 							ISC_SOCKEVENT_CONNECT,
 							action,	arg,
 							sizeof(*dev));
 	if (dev == NULL) {
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 		return (ISC_R_NOMEMORY);
 	}
 	ISC_LINK_INIT(dev, ev_link);
@@ -4900,7 +4885,7 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 		dev->result = ISC_R_SUCCESS;
 		isc_task_sendto(task, ISC_EVENT_PTR(&dev), sock->threadid);
 
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 
 		return (ISC_R_SUCCESS);
 	}
@@ -4954,7 +4939,7 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 		UNEXPECTED_ERROR(__FILE__, __LINE__, "connect(%s) %d/%s",
 				 addrbuf, errno, strbuf);
 
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 		inc_stats(sock->manager->stats,
 			  sock->statsindex[STATID_CONNECTFAIL]);
 		isc_event_free(ISC_EVENT_PTR(&dev));
@@ -4964,7 +4949,7 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 		sock->connected = 0;
 		isc_task_sendto(task, ISC_EVENT_PTR(&dev), sock->threadid);
 
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 		inc_stats(sock->manager->stats,
 			  sock->statsindex[STATID_CONNECTFAIL]);
 		return (ISC_R_SUCCESS);
@@ -4980,7 +4965,7 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 		dev->result = ISC_R_SUCCESS;
 		isc_task_sendto(task, ISC_EVENT_PTR(&dev), sock->threadid);
 
-		UNLOCK(&sock->wrlock);
+		UNLOCK(&sock->lock);
 
 		inc_stats(sock->manager->stats,
 			  sock->statsindex[STATID_CONNECT]);
@@ -5010,7 +4995,7 @@ isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
 			    SELECT_POKE_CONNECT);
 	}
 
-	UNLOCK(&sock->wrlock);
+	UNLOCK(&sock->lock);
 	return (ISC_R_SUCCESS);
 }
 
@@ -5028,7 +5013,7 @@ internal_connect(isc__socket_t *sock) {
 
 	INSIST(VALID_SOCKET(sock));
 
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	/*
 	 * Get the first item off the connect list.
@@ -5060,7 +5045,7 @@ internal_connect(isc__socket_t *sock) {
 		 */
 		if (SOFT_ERROR(errno) || errno == EINPROGRESS) {
 			sock->connecting = 1;
-			UNLOCK(&sock->wrlock);
+			UNLOCK(&sock->lock);
 			return;
 		}
 
@@ -5114,7 +5099,7 @@ internal_connect(isc__socket_t *sock) {
 	unwatch_fd(&sock->manager->threads[sock->threadid], sock->fd,
 		   SELECT_POKE_CONNECT);
 
-	UNLOCK(&sock->wrlock);
+	UNLOCK(&sock->lock);
 }
 
 isc_result_t
@@ -5125,8 +5110,7 @@ isc_socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
 	REQUIRE(VALID_SOCKET(sock));
 	REQUIRE(addressp != NULL);
 
-	LOCK(&sock->rdlock);
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	if (sock->connected) {
 		*addressp = sock->peer_address;
@@ -5135,8 +5119,7 @@ isc_socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
 		result = ISC_R_NOTCONNECTED;
 	}
 
-	UNLOCK(&sock->wrlock);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 
 	return (result);
 }
@@ -5151,8 +5134,7 @@ isc_socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
 	REQUIRE(VALID_SOCKET(sock));
 	REQUIRE(addressp != NULL);
 
-	LOCK(&sock->rdlock);
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	if (!sock->bound) {
 		result = ISC_R_NOTBOUND;
@@ -5172,8 +5154,7 @@ isc_socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
 	addressp->length = (unsigned int)len;
 
  out:
-	UNLOCK(&sock->wrlock);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 
 	return (result);
 }
@@ -5195,8 +5176,7 @@ isc_socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
 	if (how == 0)
 		return;
 
-	LOCK(&sock->rdlock);
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 
 	/*
 	 * All of these do the same thing, more or less.
@@ -5300,8 +5280,7 @@ isc_socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
 		}
 	}
 
-	UNLOCK(&sock->wrlock);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 }
 
 isc_sockettype_t
@@ -5433,12 +5412,10 @@ isc_socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
 
 	REQUIRE(VALID_SOCKET(sock));
 
-	LOCK(&sock->rdlock);
-	LOCK(&sock->wrlock);
+	LOCK(&sock->lock);
 	strlcpy(sock->name, name, sizeof(sock->name));
 	sock->tag = tag;
-	UNLOCK(&sock->wrlock);
-	UNLOCK(&sock->rdlock);
+	UNLOCK(&sock->lock);
 }
 
 const char *
@@ -5538,8 +5515,7 @@ isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer) {
 	TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "sockets"));
 	sock = ISC_LIST_HEAD(mgr->socklist);
 	while (sock != NULL) {
-		LOCK(&sock->rdlock);
-		LOCK(&sock->wrlock);
+		LOCK(&sock->lock);
 		TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "socket"));
 
 		TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "id"));
@@ -5601,17 +5577,15 @@ isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer) {
 
 		TRY0(xmlTextWriterEndElement(writer)); /* socket */
 
-		UNLOCK(&sock->wrlock);
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		sock = ISC_LIST_NEXT(sock, link);
 	}
 	TRY0(xmlTextWriterEndElement(writer)); /* sockets */
 
  error:
-	if (sock != NULL) {
-		UNLOCK(&sock->wrlock);
-		UNLOCK(&sock->rdlock);
-	}
+	if (sock != NULL)
+		UNLOCK(&sock->lock);
+
 	UNLOCK(&mgr->lock);
 
 	return (xmlrc);
@@ -5648,8 +5622,7 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
 		CHECKMEM(entry);
 		json_object_array_add(array, entry);
 
-		LOCK(&sock->rdlock);
-		LOCK(&sock->wrlock);
+		LOCK(&sock->lock);
 
 		snprintf(buf, sizeof(buf), "%p", sock);
 		obj = json_object_new_string(buf);
@@ -5715,8 +5688,7 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
 			json_object_array_add(states, obj);
 		}
 
-		UNLOCK(&sock->wrlock);
-		UNLOCK(&sock->rdlock);
+		UNLOCK(&sock->lock);
 		sock = ISC_LIST_NEXT(sock, link);
 	}
 
@@ -5728,10 +5700,9 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
 	if (array != NULL)
 		json_object_put(array);
 
-	if (sock != NULL) {
-		UNLOCK(&sock->wrlock);
-		UNLOCK(&sock->rdlock);
-	}
+	if (sock != NULL)
+		UNLOCK(&sock->lock);
+
 	UNLOCK(&mgr->lock);
 
 	return (result);

lib/isc/win32/condition.c

@@ -40,7 +40,7 @@ isc_condition_init(isc_condition_t *cond) {
 		char strbuf[ISC_STRERRORSIZE];
 		DWORD err = GetLastError();
 		strerror_r(err, strbuf, sizeof(strbuf));
-		isc_error_fatal(__FILE__, __LINE,
+		isc_error_fatal(__FILE__, __LINE__,
 				"CreateEvent failed: %s", strbuf);
 	}
 	cond->events[LSIGNAL] = h;

lib/ns/client.c

@@ -1049,9 +1049,9 @@ ns_client_sendraw(ns_client_t *client, dns_message_t *message) {
 	ns_client_next(client, result);
 }
 
-#ifdef PSEUDOSEND
-static void
-client_pseudosend(ns_client_t *client, uint16_t id) {
+#ifdef NS_CLIENT_MOCKREPLY
+static isc_result_t
+client_mockreply(ns_client_t *client, uint16_t id) {
 	isc_result_t result;
 	unsigned char *data;
 	isc_buffer_t buffer;
@@ -1082,7 +1082,7 @@ client_pseudosend(ns_client_t *client, uint16_t id) {
 		result = client_sendpkg(client, &buffer);
 	}
 	if (result == ISC_R_SUCCESS) {
-		return;
+		return (ISC_R_SUCCESS);
 	}
 done:
 	if (client->tcpbuf != NULL) {
@@ -1090,7 +1090,7 @@ done:
 		client->tcpbuf = NULL;
 	}
 	ns_client_next(client, result);
-
+	return (ISC_R_SUCCESS);
 }
 #endif
 
@@ -2380,7 +2380,7 @@ ns__client_request(isc_task_t *task, isc_event_t *event) {
 		return;
 	}
 
-#ifdef PSEUDOSEND
+#ifdef NS_CLIENT_MOCKREPLY
 	result = dns_message_peekheader(buffer, &id, &flags);
 	if (result != ISC_R_SUCCESS) {
 		/*
@@ -2390,8 +2390,14 @@ ns__client_request(isc_task_t *task, isc_event_t *event) {
 		ns_client_next(client, result);
 		return;
 	}
-	client_pseudosend(client, id);
-	return;
+	/*
+	 * client_mockreply always return success, but we want to
+	 * make the return conditional to fool compilers that the
+	 * code below is reachable.
+	 */
+	if (client_mockreply(client, id) == ISC_R_SUCCESS) {
+		return;
+	}
 #endif
 
 	isc_netaddr_fromsockaddr(&netaddr, &client->peeraddr);

lib/ns/tests/nstest.c

@@ -182,7 +182,7 @@ create_managers(void) {
 	isc_event_t *event = NULL;
 	ncpus = isc_os_ncpus();
 
-	CHECK(isc_taskmgr_create(mctx, ncpus, &taskmgr));
+	CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
 	CHECK(isc_task_create(taskmgr, 0, &maintask));
 	isc_taskmgr_setexcltask(taskmgr, maintask);
 	CHECK(isc_task_onshutdown(maintask, shutdown_managers, NULL));

lib/samples/nsprobe.c

@@ -226,7 +226,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
 	if (result != ISC_R_SUCCESS)
 		goto fail;
 
-	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
+	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
 	if (result != ISC_R_SUCCESS)
 		goto fail;
 

lib/samples/resolve.c

@@ -381,7 +381,7 @@ main(int argc, char *argv[]) {
 	result = isc_app_ctxstart(actx);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
-	result = isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr);
+	result = isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 	result = isc_socketmgr_createinctx(mctx, actx, &socketmgr);

lib/samples/sample-async.c

@@ -108,7 +108,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
 	if (result != ISC_R_SUCCESS)
 		goto fail;
 
-	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
+	result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
 	if (result != ISC_R_SUCCESS)
 		goto fail;