 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_threadpool.c,v 1.20 2021/01/13 02:19:08 riastradh Exp $	*/
+/*	$NetBSD: kern_threadpool.c,v 1.21 2021/01/13 02:20:15 riastradh Exp $	*/
 /*-
  * Copyright (c) 2014, 2018 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Taylor R. Campbell and Jason R. Thorpe.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -23,75 +23,75 @@
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Thread pools.
+ *
  * A thread pool is a collection of worker threads idle or running
- * jobs, together with an overseer thread that does not run jobs but
+ * jobs, together with an dispatcher thread that does not run jobs but
  * can be given jobs to assign to a worker thread.  Scheduling a job in
  * a thread pool does not allocate or even sleep at all, except perhaps
  * on an adaptive lock, unlike kthread_create.  Jobs reuse threads, so
  * they do not incur the expense of creating and destroying kthreads
  * unless there is not much work to be done.
+ *
  * A per-CPU thread pool (threadpool_percpu) is a collection of thread
  * pools, one per CPU bound to that CPU.  For each priority level in
  * use, there is one shared unbound thread pool (i.e., pool of threads
  * not bound to any CPU) and one shared per-CPU thread pool.
+ *
  * To use the unbound thread pool at priority pri, call
  * threadpool_get(&pool, pri).  When you're done, call
  * threadpool_put(pool, pri).
+ *
  * To use the per-CPU thread pools at priority pri, call
  * threadpool_percpu_get(&pool_percpu, pri), and then use the thread
  * pool returned by threadpool_percpu_ref(pool_percpu) for the current
  * CPU, or by threadpool_percpu_ref_remote(pool_percpu, ci) for another
  * CPU.  When you're done, call threadpool_percpu_put(pool_percpu,
  * pri).
+ *
- * +--MACHINE-----------------------------------------------+
+ * +--MACHINE-----------------------------------------------------+
- * | +--CPU 0-------+ +--CPU 1-------+     +--CPU n-------+ |
+ * | +--CPU 0---------+ +--CPU 1---------+     +--CPU n---------+ |
- * | | <overseer 0> | | <overseer 1> | ... | <overseer n> | |
+ * | | <dispatcher 0> | | <dispatcher 1> | ... | <dispatcher n> | |
- * | | <idle 0a>    | | <running 1a> | ... | <idle na>    | |
+ * | | <idle 0a>      | | <running 1a>   | ... | <idle na>      | |
- * | | <running 0b> | | <running 1b> | ... | <idle nb>    | |
+ * | | <running 0b>   | | <running 1b>   | ... | <idle nb>      | |
- * | | .            | | .            | ... | .            | |
+ * | | .              | | .              | ... | .              | |
- * | | .            | | .            | ... | .            | |
+ * | | .              | | .              | ... | .              | |
- * | | .            | | .            | ... | .            | |
+ * | | .              | | .              | ... | .              | |
- * | +--------------+ +--------------+     +--------------+ |
+ * | +----------------+ +----------------+     +----------------+ |
- * |            +--unbound---------+                        |
+ * |            +--unbound-----------+                            |
- * |            | <overseer n+1>   |                        |
+ * |            | <dispatcher n+1>   |                            |
- * |            | <idle (n+1)a>    |                        |
+ * |            | <idle (n+1)a>      |                            |
- * |            | <running (n+1)b> |                        |
+ * |            | <running (n+1)b>   |                            |
- * |            +------------------+                        |
+ * |            +--------------------+                            |
- * +--------------------------------------------------------+
+ * +--------------------------------------------------------------+
+ *
- * XXX Why one overseer per CPU?  I did that originally to avoid
+ * XXX Why one dispatcher per CPU?  I did that originally to avoid
  * touching remote CPUs' memory when scheduling a job, but that still
  * requires interprocessor synchronization.  Perhaps we could get by
- * with a single overseer thread, at the expense of another pointer in
+ * with a single dispatcher thread, at the expense of another pointer
- * struct threadpool_job to identify the CPU on which it must run
+ * in struct threadpool_job to identify the CPU on which it must run in
- * in order for the overseer to schedule it correctly.
+ * order for the dispatcher to schedule it correctly.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_threadpool.c,v 1.20 2021/01/13 02:19:08 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_threadpool.c,v 1.21 2021/01/13 02:20:15 riastradh Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/condvar.h>
 #include <sys/cpu.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 #include <sys/once.h>
 #include <sys/percpu.h>
 #include <sys/pool.h>
 @@ -131,47 +131,47 @@ SDT_PROBE_DEFINE2(sdt, kernel, threadpoo
 SDT_PROBE_DEFINE3(sdt, kernel, threadpool, create__success,
     "struct cpu_info *"/*ci*/, "pri_t"/*pri*/, "struct threadpool *"/*pool*/);
 SDT_PROBE_DEFINE3(sdt, kernel, threadpool, create__failure,
     "struct cpu_info *"/*ci*/, "pri_t"/*pri*/, "int"/*error*/);
 SDT_PROBE_DEFINE1(sdt, kernel, threadpool, destroy,
     "struct threadpool *"/*pool*/);
 SDT_PROBE_DEFINE2(sdt, kernel, threadpool, destroy__wait,
     "struct threadpool *"/*pool*/, "uint64_t"/*refcnt*/);
 SDT_PROBE_DEFINE2(sdt, kernel, threadpool, schedule__job,
     "struct threadpool *"/*pool*/, "struct threadpool_job *"/*job*/);
 SDT_PROBE_DEFINE2(sdt, kernel, threadpool, schedule__job__running,
     "struct threadpool *"/*pool*/, "struct threadpool_job *"/*job*/);
-SDT_PROBE_DEFINE2(sdt, kernel, threadpool, schedule__job__overseer,
+SDT_PROBE_DEFINE2(sdt, kernel, threadpool, schedule__job__dispatcher,
     "struct threadpool *"/*pool*/, "struct threadpool_job *"/*job*/);
 SDT_PROBE_DEFINE3(sdt, kernel, threadpool, schedule__job__thread,
     "struct threadpool *"/*pool*/,
     "struct threadpool_job *"/*job*/,
     "struct lwp *"/*thread*/);
-SDT_PROBE_DEFINE1(sdt, kernel, threadpool, overseer__start,
+SDT_PROBE_DEFINE1(sdt, kernel, threadpool, dispatcher__start,
     "struct threadpool *"/*pool*/);
-SDT_PROBE_DEFINE1(sdt, kernel, threadpool, overseer__dying,
+SDT_PROBE_DEFINE1(sdt, kernel, threadpool, dispatcher__dying,
     "struct threadpool *"/*pool*/);
-SDT_PROBE_DEFINE1(sdt, kernel, threadpool, overseer__spawn,
+SDT_PROBE_DEFINE1(sdt, kernel, threadpool, dispatcher__spawn,
     "struct threadpool *"/*pool*/);
-SDT_PROBE_DEFINE2(sdt, kernel, threadpool, overseer__race,
+SDT_PROBE_DEFINE2(sdt, kernel, threadpool, dispatcher__race,
     "struct threadpool *"/*pool*/,
     "struct threadpool_job *"/*job*/);
-SDT_PROBE_DEFINE3(sdt, kernel, threadpool, overseer__assign,
+SDT_PROBE_DEFINE3(sdt, kernel, threadpool, dispatcher__assign,
     "struct threadpool *"/*pool*/,
     "struct threadpool_job *"/*job*/,
     "struct lwp *"/*thread*/);
-SDT_PROBE_DEFINE1(sdt, kernel, threadpool, overseer__exit,
+SDT_PROBE_DEFINE1(sdt, kernel, threadpool, dispatcher__exit,
     "struct threadpool *"/*pool*/);
 SDT_PROBE_DEFINE1(sdt, kernel, threadpool, thread__start,
     "struct threadpool *"/*pool*/);
 SDT_PROBE_DEFINE1(sdt, kernel, threadpool, thread__dying,
     "struct threadpool *"/*pool*/);
 SDT_PROBE_DEFINE2(sdt, kernel, threadpool, thread__job,
     "struct threadpool *"/*pool*/, "struct threadpool_job *"/*job*/);
 SDT_PROBE_DEFINE1(sdt, kernel, threadpool, thread__exit,
     "struct threadpool *"/*pool*/);
 /* Data structures */
 @@ -179,51 +179,51 @@ TAILQ_HEAD(job_head, threadpool_job);
 TAILQ_HEAD(thread_head, threadpool_thread);
 struct threadpool_thread {
 	struct lwp			*tpt_lwp;
 	char				*tpt_lwp_savedname;
 	struct threadpool		*tpt_pool;
 	struct threadpool_job		*tpt_job;
 	kcondvar_t			tpt_cv;
 	TAILQ_ENTRY(threadpool_thread)	tpt_entry;
 };
 struct threadpool {
 	kmutex_t			tp_lock;
-	struct threadpool_thread	tp_overseer;
+	struct threadpool_thread	tp_dispatcher;
 	struct job_head			tp_jobs;
 	struct thread_head		tp_idle_threads;
 	uint64_t			tp_refcnt;
 	int				tp_flags;
 #define	THREADPOOL_DYING	0x01
 	struct cpu_info			*tp_cpu;
 	pri_t				tp_pri;
 };
 static void	threadpool_hold(struct threadpool *);
 static void	threadpool_rele(struct threadpool *);
 static int	threadpool_percpu_create(struct threadpool_percpu **, pri_t);
 static void	threadpool_percpu_destroy(struct threadpool_percpu *);
 static void	threadpool_percpu_init(void *, void *, struct cpu_info *);
 static void	threadpool_percpu_ok(void *, void *, struct cpu_info *);
 static void	threadpool_percpu_fini(void *, void *, struct cpu_info *);
 static threadpool_job_fn_t threadpool_job_dead;
 static void	threadpool_job_hold(struct threadpool_job *);
 static void	threadpool_job_rele(struct threadpool_job *);
-static void	threadpool_overseer_thread(void *) __dead;
+static void	threadpool_dispatcher_thread(void *) __dead;
 static void	threadpool_thread(void *) __dead;
 static pool_cache_t	threadpool_thread_pc __read_mostly;
 static kmutex_t		threadpools_lock __cacheline_aligned;
 	/* Default to 30 second idle timeout for pool threads. */
 static int	threadpool_idle_time_ms = 30 * 1000;
 struct threadpool_unbound {
 	struct threadpool		tpu_pool;
 	/* protected by threadpools_lock */
 @@ -346,143 +346,156 @@ SYSCTL_SETUP(sysctl_threadpool_setup,
 void
 threadpools_init(void)
+{
 	threadpool_thread_pc =
 	    pool_cache_init(sizeof(struct threadpool_thread), 0, 0, 0,
 		"thplthrd", NULL, IPL_NONE, NULL, NULL, NULL);
 	LIST_INIT(&unbound_threadpools);
 	LIST_INIT(&percpu_threadpools);
 	mutex_init(&threadpools_lock, MUTEX_DEFAULT, IPL_NONE);
+}
 static void
 threadnamesuffix(char *buf, size_t buflen, struct cpu_info *ci, int pri)
+{
 	buf[0] = '\0';
 	if (ci)
 		snprintf(buf + strlen(buf), buflen - strlen(buf), "/%d",
 		    cpu_index(ci));
 	if (pri != PRI_NONE)
 		snprintf(buf + strlen(buf), buflen - strlen(buf), "@%d", pri);
+}
 /* Thread pool creation */
 static bool
 threadpool_pri_is_valid(pri_t pri)
+{
 	return (pri == PRI_NONE || (pri >= PRI_USER && pri < PRI_COUNT));
+}
 static int
 threadpool_create(struct threadpool *const pool, struct cpu_info *ci,
     pri_t pri)
+{
 	struct lwp *lwp;
 	char suffix[16];
 	int ktflags;
 	int error;
 	KASSERT(threadpool_pri_is_valid(pri));
 	SDT_PROBE2(sdt, kernel, threadpool, create,  ci, pri);
 	mutex_init(&pool->tp_lock, MUTEX_DEFAULT, IPL_VM);
-	/* XXX overseer */
+	/* XXX dispatcher */
 	TAILQ_INIT(&pool->tp_jobs);
 	TAILQ_INIT(&pool->tp_idle_threads);
-	pool->tp_refcnt = 1;		/* overseer's reference */
+	pool->tp_refcnt = 1;		/* dispatcher's reference */
 	pool->tp_flags = 0;
 	pool->tp_cpu = ci;
 	pool->tp_pri = pri;
-	pool->tp_overseer.tpt_lwp = NULL;
+	pool->tp_dispatcher.tpt_lwp = NULL;
-	pool->tp_overseer.tpt_pool = pool;
+	pool->tp_dispatcher.tpt_pool = pool;
-	pool->tp_overseer.tpt_job = NULL;
+	pool->tp_dispatcher.tpt_job = NULL;
-	cv_init(&pool->tp_overseer.tpt_cv, "poolover");
+	cv_init(&pool->tp_dispatcher.tpt_cv, "pooldisp");
 	ktflags = 0;
 	ktflags |= KTHREAD_MPSAFE;
 	if (pri < PRI_KERNEL)
 		ktflags |= KTHREAD_TS;
-	error = kthread_create(pri, ktflags, ci, &threadpool_overseer_thread,
+	threadnamesuffix(suffix, sizeof(suffix), ci, pri);
-	    &pool->tp_overseer, &lwp,
+	error = kthread_create(pri, ktflags, ci, &threadpool_dispatcher_thread,
-	    "pooloverseer/%d@%d", (ci ? cpu_index(ci) : -1), (int)pri);
+	    &pool->tp_dispatcher, &lwp, "pooldisp%s", suffix);
 	if (error)
 		goto fail0;
 	mutex_spin_enter(&pool->tp_lock);
-	pool->tp_overseer.tpt_lwp = lwp;
+	pool->tp_dispatcher.tpt_lwp = lwp;
-	cv_broadcast(&pool->tp_overseer.tpt_cv);
+	cv_broadcast(&pool->tp_dispatcher.tpt_cv);
 	mutex_spin_exit(&pool->tp_lock);
 	SDT_PROBE3(sdt, kernel, threadpool, create__success,  ci, pri, pool);
 	return 0;
 fail0:	KASSERT(error);
-	KASSERT(pool->tp_overseer.tpt_job == NULL);
+	KASSERT(pool->tp_dispatcher.tpt_job == NULL);
-	KASSERT(pool->tp_overseer.tpt_pool == pool);
+	KASSERT(pool->tp_dispatcher.tpt_pool == pool);
 	KASSERT(pool->tp_flags == 0);
 	KASSERT(pool->tp_refcnt == 0);
 	KASSERT(TAILQ_EMPTY(&pool->tp_idle_threads));
 	KASSERT(TAILQ_EMPTY(&pool->tp_jobs));
-	KASSERT(!cv_has_waiters(&pool->tp_overseer.tpt_cv));
+	KASSERT(!cv_has_waiters(&pool->tp_dispatcher.tpt_cv));
-	cv_destroy(&pool->tp_overseer.tpt_cv);
+	cv_destroy(&pool->tp_dispatcher.tpt_cv);
 	mutex_destroy(&pool->tp_lock);
 	SDT_PROBE3(sdt, kernel, threadpool, create__failure,  ci, pri, error);
 	return error;
+}
 /* Thread pool destruction */
 static void
 threadpool_destroy(struct threadpool *pool)
+{
 	struct threadpool_thread *thread;
 	SDT_PROBE1(sdt, kernel, threadpool, destroy,  pool);
 	/* Mark the pool dying and wait for threads to commit suicide.  */
 	mutex_spin_enter(&pool->tp_lock);
 	KASSERT(TAILQ_EMPTY(&pool->tp_jobs));
 	pool->tp_flags |= THREADPOOL_DYING;
-	cv_broadcast(&pool->tp_overseer.tpt_cv);
+	cv_broadcast(&pool->tp_dispatcher.tpt_cv);
 	TAILQ_FOREACH(thread, &pool->tp_idle_threads, tpt_entry)
 		cv_broadcast(&thread->tpt_cv);
 	while (0 < pool->tp_refcnt) {
 		SDT_PROBE2(sdt, kernel, threadpool, destroy__wait,
 		    pool, pool->tp_refcnt);
-		cv_wait(&pool->tp_overseer.tpt_cv, &pool->tp_lock);
+		cv_wait(&pool->tp_dispatcher.tpt_cv, &pool->tp_lock);
+	}
 	mutex_spin_exit(&pool->tp_lock);
-	KASSERT(pool->tp_overseer.tpt_job == NULL);
+	KASSERT(pool->tp_dispatcher.tpt_job == NULL);
-	KASSERT(pool->tp_overseer.tpt_pool == pool);
+	KASSERT(pool->tp_dispatcher.tpt_pool == pool);
 	KASSERT(pool->tp_flags == THREADPOOL_DYING);
 	KASSERT(pool->tp_refcnt == 0);
 	KASSERT(TAILQ_EMPTY(&pool->tp_idle_threads));
 	KASSERT(TAILQ_EMPTY(&pool->tp_jobs));
-	KASSERT(!cv_has_waiters(&pool->tp_overseer.tpt_cv));
+	KASSERT(!cv_has_waiters(&pool->tp_dispatcher.tpt_cv));
-	cv_destroy(&pool->tp_overseer.tpt_cv);
+	cv_destroy(&pool->tp_dispatcher.tpt_cv);
 	mutex_destroy(&pool->tp_lock);
+}
 static void
 threadpool_hold(struct threadpool *pool)
+{
 	KASSERT(mutex_owned(&pool->tp_lock));
 	pool->tp_refcnt++;
 	KASSERT(pool->tp_refcnt != 0);
+}
 static void
 threadpool_rele(struct threadpool *pool)
+{
 	KASSERT(mutex_owned(&pool->tp_lock));
 	KASSERT(0 < pool->tp_refcnt);
 	if (--pool->tp_refcnt == 0)
-		cv_broadcast(&pool->tp_overseer.tpt_cv);
+		cv_broadcast(&pool->tp_dispatcher.tpt_cv);
+}
 /* Unbound thread pools */
 int
 threadpool_get(struct threadpool **poolp, pri_t pri)
+{
 	struct threadpool_unbound *tpu, *tmp = NULL;
 	int error;
 	ASSERT_SLEEPABLE();
 	SDT_PROBE1(sdt, kernel, threadpool, get,  pri);
 @@ -849,78 +862,78 @@ threadpool_schedule_job(struct threadpoo
 	 * to NULL under the interlock.
 	 */
 	if (__predict_true(job->job_thread != NULL)) {
 		SDT_PROBE2(sdt, kernel, threadpool, schedule__job__running,
 		    pool, job);
 		return;
+	}
 	threadpool_job_hold(job);
 	/* Otherwise, try to assign a thread to the job.  */
 	mutex_spin_enter(&pool->tp_lock);
 	if (__predict_false(TAILQ_EMPTY(&pool->tp_idle_threads))) {
-		/* Nobody's idle.  Give it to the overseer.  */
+		/* Nobody's idle.  Give it to the dispatcher.  */
-		SDT_PROBE2(sdt, kernel, threadpool, schedule__job__overseer,
+		SDT_PROBE2(sdt, kernel, threadpool, schedule__job__dispatcher,
 		    pool, job);
-		job->job_thread = &pool->tp_overseer;
+		job->job_thread = &pool->tp_dispatcher;
 		TAILQ_INSERT_TAIL(&pool->tp_jobs, job, job_entry);
 	} else {
 		/* Assign it to the first idle thread.  */
 		job->job_thread = TAILQ_FIRST(&pool->tp_idle_threads);
 		SDT_PROBE3(sdt, kernel, threadpool, schedule__job__thread,
 		    pool, job, job->job_thread->tpt_lwp);
 		TAILQ_REMOVE(&pool->tp_idle_threads, job->job_thread,
 		    tpt_entry);
 		job->job_thread->tpt_job = job;
+	}
-	/* Notify whomever we gave it to, overseer or idle thread.  */
+	/* Notify whomever we gave it to, dispatcher or idle thread.  */
 	KASSERT(job->job_thread != NULL);
 	cv_broadcast(&job->job_thread->tpt_cv);
 	mutex_spin_exit(&pool->tp_lock);
+}
 bool
 threadpool_cancel_job_async(struct threadpool *pool, struct threadpool_job *job)
+{
 	KASSERT(mutex_owned(job->job_lock));
 	/*
 	 * XXXJRT This fails (albeit safely) when all of the following
 	 * are true:
+	 *
 	 *	=> "pool" is something other than what the job was
 	 *	   scheduled on.  This can legitimately occur if,
 	 *	   for example, a job is percpu-scheduled on CPU0
 	 *	   and then CPU1 attempts to cancel it without taking
 	 *	   a remote pool reference.  (this might happen by
 	 *	   "luck of the draw").
+	 *
 	 *	=> "job" is not yet running, but is assigned to the
-	 *	   overseer.
+	 *	   dispatcher.
+	 *
 	 * When this happens, this code makes the determination that
 	 * the job is already running.  The failure mode is that the
 	 * caller is told the job is running, and thus has to wait.
-	 * The overseer will eventually get to it and the job will
+	 * The dispatcher will eventually get to it and the job will
 	 * proceed as if it had been already running.
 	 */
 	if (job->job_thread == NULL) {
 		/* Nothing to do.  Guaranteed not running.  */
 		return true;
-	} else if (job->job_thread == &pool->tp_overseer) {
+	} else if (job->job_thread == &pool->tp_dispatcher) {
 		/* Take it off the list to guarantee it won't run.  */
 		job->job_thread = NULL;
 		mutex_spin_enter(&pool->tp_lock);
 		TAILQ_REMOVE(&pool->tp_jobs, job, job_entry);
 		mutex_spin_exit(&pool->tp_lock);
 		threadpool_job_rele(job);
 		return true;
 	} else {
 		/* Too late -- already running.  */
 		return false;
+	}
+}
 @@ -935,83 +948,84 @@ threadpool_cancel_job(struct threadpool
 	 * as a false-positive.
 	 */
 	KASSERT(mutex_owned(job->job_lock));
 	if (threadpool_cancel_job_async(pool, job))
 		return;
 	/* Already running.  Wait for it to complete.  */
 	while (job->job_thread != NULL)
 		cv_wait(&job->job_cv, job->job_lock);
+}
-/* Thread pool overseer thread */
+/* Thread pool dispatcher thread */
 static void __dead
-threadpool_overseer_thread(void *arg)
+threadpool_dispatcher_thread(void *arg)
+{
-	struct threadpool_thread *const overseer = arg;
+	struct threadpool_thread *const dispatcher = arg;
-	struct threadpool *const pool = overseer->tpt_pool;
+	struct threadpool *const pool = dispatcher->tpt_pool;
 	struct lwp *lwp = NULL;
 	int ktflags;
 	char suffix[16];
 	int error;
 	KASSERT((pool->tp_cpu == NULL) || (pool->tp_cpu == curcpu()));
 	KASSERT((pool->tp_cpu == NULL) || (curlwp->l_pflag & LP_BOUND));
 	/* Wait until we're initialized.  */
 	mutex_spin_enter(&pool->tp_lock);
-	while (overseer->tpt_lwp == NULL)
+	while (dispatcher->tpt_lwp == NULL)
-		cv_wait(&overseer->tpt_cv, &pool->tp_lock);
+		cv_wait(&dispatcher->tpt_cv, &pool->tp_lock);
-	SDT_PROBE1(sdt, kernel, threadpool, overseer__start,  pool);
+	SDT_PROBE1(sdt, kernel, threadpool, dispatcher__start,  pool);
 	for (;;) {
 		/* Wait until there's a job.  */
 		while (TAILQ_EMPTY(&pool->tp_jobs)) {
 			if (ISSET(pool->tp_flags, THREADPOOL_DYING)) {
 				SDT_PROBE1(sdt, kernel, threadpool,
-				    overseer__dying,  pool);
+				    dispatcher__dying,  pool);
 				break;
+			}
-			cv_wait(&overseer->tpt_cv, &pool->tp_lock);
+			cv_wait(&dispatcher->tpt_cv, &pool->tp_lock);
+		}
 		if (__predict_false(TAILQ_EMPTY(&pool->tp_jobs)))
 			break;
 		/* If there are no threads, we'll have to try to start one.  */
 		if (TAILQ_EMPTY(&pool->tp_idle_threads)) {
-			SDT_PROBE1(sdt, kernel, threadpool, overseer__spawn,
+			SDT_PROBE1(sdt, kernel, threadpool, dispatcher__spawn,
 			    pool);
 			threadpool_hold(pool);
 			mutex_spin_exit(&pool->tp_lock);
 			struct threadpool_thread *const thread =
 			    pool_cache_get(threadpool_thread_pc, PR_WAITOK);
 			thread->tpt_lwp = NULL;
 			thread->tpt_pool = pool;
 			thread->tpt_job = NULL;
-			cv_init(&thread->tpt_cv, "poolthrd");
+			cv_init(&thread->tpt_cv, "pooljob");
 			ktflags = 0;
 			ktflags |= KTHREAD_MPSAFE;
 			if (pool->tp_pri < PRI_KERNEL)
 				ktflags |= KTHREAD_TS;
 			threadnamesuffix(suffix, sizeof(suffix), pool->tp_cpu,
 			    pool->tp_pri);
 			error = kthread_create(pool->tp_pri, ktflags,
 			    pool->tp_cpu, &threadpool_thread, thread, &lwp,
-			    "poolthread/%d@%d",
+			    "poolthread%s", suffix);
 			    (pool->tp_cpu ? cpu_index(pool->tp_cpu) : -1),
 			    (int)pool->tp_pri);
 			mutex_spin_enter(&pool->tp_lock);
 			if (error) {
 				pool_cache_put(threadpool_thread_pc, thread);
 				threadpool_rele(pool);
 				/* XXX What to do to wait for memory?  */
 				(void)kpause("thrdplcr", false, hz,
 				    &pool->tp_lock);
 				continue;
+			}
 			/*
 			 * New kthread now owns the reference to the pool
 			 * taken above.
 @@ -1027,66 +1041,66 @@ threadpool_overseer_thread(void *arg)
 		/* There are idle threads, so try giving one a job.  */
 		struct threadpool_job *const job = TAILQ_FIRST(&pool->tp_jobs);
 		TAILQ_REMOVE(&pool->tp_jobs, job, job_entry);
 		/*
 		 * Take an extra reference on the job temporarily so that
 		 * it won't disappear on us while we have both locks dropped.
 		 */
 		threadpool_job_hold(job);
 		mutex_spin_exit(&pool->tp_lock);
 		mutex_enter(job->job_lock);
 		/* If the job was cancelled, we'll no longer be its thread.  */
-		if (__predict_true(job->job_thread == overseer)) {
+		if (__predict_true(job->job_thread == dispatcher)) {
 			mutex_spin_enter(&pool->tp_lock);
 			if (__predict_false(
 				    TAILQ_EMPTY(&pool->tp_idle_threads))) {
 				/*
 				 * Someone else snagged the thread
 				 * first.  We'll have to try again.
 				 */
 				SDT_PROBE2(sdt, kernel, threadpool,
-				    overseer__race,  pool, job);
+				    dispatcher__race,  pool, job);
 				TAILQ_INSERT_HEAD(&pool->tp_jobs, job,
 				    job_entry);
 			} else {
 				/*
 				 * Assign the job to the thread and
 				 * wake the thread so it starts work.
 				 */
 				struct threadpool_thread *const thread =
 				    TAILQ_FIRST(&pool->tp_idle_threads);
 				SDT_PROBE2(sdt, kernel, threadpool,
-				    overseer__assign,  job, thread->tpt_lwp);
+				    dispatcher__assign,  job, thread->tpt_lwp);
 				KASSERT(thread->tpt_job == NULL);
 				TAILQ_REMOVE(&pool->tp_idle_threads, thread,
 				    tpt_entry);
 				thread->tpt_job = job;
 				job->job_thread = thread;
 				cv_broadcast(&thread->tpt_cv);
+			}
 			mutex_spin_exit(&pool->tp_lock);
+		}
 		threadpool_job_rele(job);
 		mutex_exit(job->job_lock);
 		mutex_spin_enter(&pool->tp_lock);
+	}
 	threadpool_rele(pool);
 	mutex_spin_exit(&pool->tp_lock);
-	SDT_PROBE1(sdt, kernel, threadpool, overseer__exit,  pool);
+	SDT_PROBE1(sdt, kernel, threadpool, dispatcher__exit,  pool);
 	kthread_exit(0);
+}
 /* Thread pool thread */
 static void __dead
 threadpool_thread(void *arg)
+{
 	struct threadpool_thread *const thread = arg;
 	struct threadpool *const pool = thread->tpt_pool;
 	KASSERT((pool->tp_cpu == NULL) || (pool->tp_cpu == curcpu()));