 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_workqueue.c,v 1.37 2018/06/13 05:26:12 ozaki-r Exp $	*/
+/*	$NetBSD: subr_workqueue.c,v 1.37.6.1 2024/04/18 15:51:35 martin Exp $	*/
 /*-
  * Copyright (c)2002, 2005, 2006, 2007 YAMAMOTO Takashi,
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,69 +17,113 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_workqueue.c,v 1.37 2018/06/13 05:26:12 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_workqueue.c,v 1.37.6.1 2024/04/18 15:51:35 martin Exp $");
 #include <sys/param.h>
 #include <sys/condvar.h>
 #include <sys/cpu.h>
 #include <sys/systm.h>
 #include <sys/kthread.h>
 #include <sys/kmem.h>
-#include <sys/proc.h>
+#include <sys/kthread.h>
 #include <sys/workqueue.h>
 #include <sys/mutex.h>
-#include <sys/condvar.h>
+#include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/sdt.h>
 #include <sys/systm.h>
 #include <sys/workqueue.h>
 typedef struct work_impl {
 	SIMPLEQ_ENTRY(work_impl) wk_entry;
 } work_impl_t;
 SIMPLEQ_HEAD(workqhead, work_impl);
 struct workqueue_queue {
 	kmutex_t q_mutex;
 	kcondvar_t q_cv;
 	struct workqhead q_queue_pending;
-	struct workqhead q_queue_running;
+	uint64_t q_gen;
 	lwp_t *q_worker;
 	work_impl_t *q_waiter;
 };
 struct workqueue {
 	void (*wq_func)(struct work *, void *);
 	void *wq_arg;
 	int wq_flags;
 	char wq_name[MAXCOMLEN];
 	pri_t wq_prio;
 	void *wq_ptr;
 };
 #define	WQ_SIZE		(roundup2(sizeof(struct workqueue), coherency_unit))
 #define	WQ_QUEUE_SIZE	(roundup2(sizeof(struct workqueue_queue), coherency_unit))
 #define	POISON	0xaabbccdd
 SDT_PROBE_DEFINE7(sdt, kernel, workqueue, create,
     "struct workqueue *"/*wq*/,
     "const char *"/*name*/,
     "void (*)(struct work *, void *)"/*func*/,
     "void *"/*arg*/,
     "pri_t"/*prio*/,
     "int"/*ipl*/,
     "int"/*flags*/);
 SDT_PROBE_DEFINE1(sdt, kernel, workqueue, destroy,
     "struct workqueue *"/*wq*/);
 SDT_PROBE_DEFINE3(sdt, kernel, workqueue, enqueue,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/,
     "struct cpu_info *"/*ci*/);
 SDT_PROBE_DEFINE4(sdt, kernel, workqueue, entry,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/,
     "void (*)(struct work *, void *)"/*func*/,
     "void *"/*arg*/);
 SDT_PROBE_DEFINE4(sdt, kernel, workqueue, return,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/,
     "void (*)(struct work *, void *)"/*func*/,
     "void *"/*arg*/);
 SDT_PROBE_DEFINE2(sdt, kernel, workqueue, wait__start,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/);
 SDT_PROBE_DEFINE2(sdt, kernel, workqueue, wait__self,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/);
 SDT_PROBE_DEFINE2(sdt, kernel, workqueue, wait__hit,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/);
 SDT_PROBE_DEFINE2(sdt, kernel, workqueue, wait__done,
     "struct workqueue *"/*wq*/,
     "struct work *"/*wk*/);
 SDT_PROBE_DEFINE1(sdt, kernel, workqueue, exit__start,
     "struct workqueue *"/*wq*/);
 SDT_PROBE_DEFINE1(sdt, kernel, workqueue, exit__done,
     "struct workqueue *"/*wq*/);
 static size_t
 workqueue_size(int flags)
+{
 	return WQ_SIZE
 	    + ((flags & WQ_PERCPU) != 0 ? ncpu : 1) * WQ_QUEUE_SIZE
 	    + coherency_unit;
+}
 static struct workqueue_queue *
 workqueue_queue_lookup(struct workqueue *wq, struct cpu_info *ci)
+{
 	u_int idx = 0;
 @@ -87,70 +131,75 @@ workqueue_queue_lookup(struct workqueue
 	if (wq->wq_flags & WQ_PERCPU) {
 		idx = ci ? cpu_index(ci) : cpu_index(curcpu());
+	}
 	return (void *)((uintptr_t)(wq) + WQ_SIZE + (idx * WQ_QUEUE_SIZE));
+}
 static void
 workqueue_runlist(struct workqueue *wq, struct workqhead *list)
+{
 	work_impl_t *wk;
 	work_impl_t *next;
 	/*
 	 * note that "list" is not a complete SIMPLEQ.
 	 */
 	for (wk = SIMPLEQ_FIRST(list); wk != NULL; wk = next) {
 		next = SIMPLEQ_NEXT(wk, wk_entry);
 		SDT_PROBE4(sdt, kernel, workqueue, entry,
 		    wq, wk, wq->wq_func, wq->wq_arg);
 		(*wq->wq_func)((void *)wk, wq->wq_arg);
 		SDT_PROBE4(sdt, kernel, workqueue, return,
 		    wq, wk, wq->wq_func, wq->wq_arg);
+	}
+}
 static void
 workqueue_worker(void *cookie)
+{
 	struct workqueue *wq = cookie;
 	struct workqueue_queue *q;
 	/* find the workqueue of this kthread */
 	q = workqueue_queue_lookup(wq, curlwp->l_cpu);
 	mutex_enter(&q->q_mutex);
 	for (;;) {
-		/*
+		struct workqhead tmp;
 		 * we violate abstraction of SIMPLEQ.
-		 */
+		SIMPLEQ_INIT(&tmp);
 		mutex_enter(&q->q_mutex);
 		while (SIMPLEQ_EMPTY(&q->q_queue_pending))
 			cv_wait(&q->q_cv, &q->q_mutex);
-		KASSERT(SIMPLEQ_EMPTY(&q->q_queue_running));
+		SIMPLEQ_CONCAT(&tmp, &q->q_queue_pending);
 		q->q_queue_running.sqh_first =
 		    q->q_queue_pending.sqh_first; /* XXX */
 		SIMPLEQ_INIT(&q->q_queue_pending);
 		/*
 		 * Mark the queue as actively running a batch of work
 		 * by setting the generation number odd.
 		 */
 		q->q_gen |= 1;
 		mutex_exit(&q->q_mutex);
-		workqueue_runlist(wq, &q->q_queue_running);
+		workqueue_runlist(wq, &tmp);
 		/*
 		 * Notify workqueue_wait that we have completed a batch
 		 * of work by incrementing the generation number.
 		 */
 		mutex_enter(&q->q_mutex);
-		KASSERT(!SIMPLEQ_EMPTY(&q->q_queue_running));
+		KASSERTMSG(q->q_gen & 1, "q=%p gen=%"PRIu64, q, q->q_gen);
-		SIMPLEQ_INIT(&q->q_queue_running);
+		q->q_gen++;
-		if (__predict_false(q->q_waiter != NULL)) {
+		cv_broadcast(&q->q_cv);
 			/* Wake up workqueue_wait */
 			cv_signal(&q->q_cv);
 		mutex_exit(&q->q_mutex);
+	}
 	mutex_exit(&q->q_mutex);
+}
 static void
 workqueue_init(struct workqueue *wq, const char *name,
     void (*callback_func)(struct work *, void *), void *callback_arg,
     pri_t prio, int ipl)
+{
 	KASSERT(sizeof(wq->wq_name) > strlen(name));
 	strncpy(wq->wq_name, name, sizeof(wq->wq_name));
 	wq->wq_prio = prio;
 	wq->wq_func = callback_func;
 @@ -158,27 +207,27 @@ workqueue_init(struct workqueue *wq, con
+}
 static int
 workqueue_initqueue(struct workqueue *wq, struct workqueue_queue *q,
     int ipl, struct cpu_info *ci)
+{
 	int error, ktf;
 	KASSERT(q->q_worker == NULL);
 	mutex_init(&q->q_mutex, MUTEX_DEFAULT, ipl);
 	cv_init(&q->q_cv, wq->wq_name);
 	SIMPLEQ_INIT(&q->q_queue_pending);
-	SIMPLEQ_INIT(&q->q_queue_running);
+	q->q_gen = 0;
 	ktf = ((wq->wq_flags & WQ_MPSAFE) != 0 ? KTHREAD_MPSAFE : 0);
 	if (wq->wq_prio < PRI_KERNEL)
 		ktf |= KTHREAD_TS;
 	if (ci) {
 		error = kthread_create(wq->wq_prio, ktf, ci, workqueue_worker,
 		    wq, &q->q_worker, "%s/%u", wq->wq_name, ci->ci_index);
 	} else {
 		error = kthread_create(wq->wq_prio, ktf, ci, workqueue_worker,
 		    wq, &q->q_worker, "%s", wq->wq_name);
+	}
 	if (error != 0) {
 		mutex_destroy(&q->q_mutex);
 		cv_destroy(&q->q_cv);
 @@ -196,44 +245,44 @@ static void
 workqueue_exit(struct work *wk, void *arg)
+{
 	struct workqueue_exitargs *wqe = (void *)wk;
 	struct workqueue_queue *q = wqe->wqe_q;
 	/*
 	 * only competition at this point is workqueue_finiqueue.
 	 */
 	KASSERT(q->q_worker == curlwp);
 	KASSERT(SIMPLEQ_EMPTY(&q->q_queue_pending));
 	mutex_enter(&q->q_mutex);
 	q->q_worker = NULL;
-	cv_signal(&q->q_cv);
+	cv_broadcast(&q->q_cv);
 	mutex_exit(&q->q_mutex);
 	kthread_exit(0);
+}
 static void
 workqueue_finiqueue(struct workqueue *wq, struct workqueue_queue *q)
+{
 	struct workqueue_exitargs wqe;
 	KASSERT(wq->wq_func == workqueue_exit);
 	wqe.wqe_q = q;
 	KASSERT(SIMPLEQ_EMPTY(&q->q_queue_pending));
 	KASSERT(q->q_worker != NULL);
 	mutex_enter(&q->q_mutex);
 	SIMPLEQ_INSERT_TAIL(&q->q_queue_pending, &wqe.wqe_wk, wk_entry);
-	cv_signal(&q->q_cv);
+	cv_broadcast(&q->q_cv);
 	while (q->q_worker != NULL) {
 		cv_wait(&q->q_cv, &q->q_mutex);
+	}
 	mutex_exit(&q->q_mutex);
 	mutex_destroy(&q->q_mutex);
 	cv_destroy(&q->q_cv);
+}
 /* --- */
 int
 workqueue_create(struct workqueue **wqp, const char *name,
     void (*callback_func)(struct work *, void *), void *callback_arg,
 @@ -271,121 +320,153 @@ workqueue_create(struct workqueue **wqp,
 		error = workqueue_initqueue(wq, q, ipl, NULL);
+	}
 	if (error != 0) {
 		workqueue_destroy(wq);
 	} else {
 		*wqp = wq;
+	}
 	return error;
+}
 static bool
-workqueue_q_wait(struct workqueue_queue *q, work_impl_t *wk_target)
+workqueue_q_wait(struct workqueue *wq, struct workqueue_queue *q,
     work_impl_t *wk_target)
+{
 	work_impl_t *wk;
 	bool found = false;
 	uint64_t gen;
 	mutex_enter(&q->q_mutex);
 	if (q->q_worker == curlwp)
 	/*
 	 * Avoid a deadlock scenario.  We can't guarantee that
 	 * wk_target has completed at this point, but we can't wait for
 	 * it either, so do nothing.
+	 *
 	 * XXX Are there use-cases that require this semantics?
 	 */
 	if (q->q_worker == curlwp) {
 		SDT_PROBE2(sdt, kernel, workqueue, wait__self,  wq, wk_target);
 		goto out;
+	}
 	/*
 	 * Wait until the target is no longer pending.  If we find it
 	 * on this queue, the caller can stop looking in other queues.
 	 * If we don't find it in this queue, however, we can't skip
 	 * waiting -- it may be hidden in the running queue which we
 	 * have no access to.
 	 */
     again:
 	SIMPLEQ_FOREACH(wk, &q->q_queue_pending, wk_entry) {
-		if (wk == wk_target)
+		if (wk == wk_target) {
-			goto found;
+			SDT_PROBE2(sdt, kernel, workqueue, wait__hit,  wq, wk);
 			found = true;
 			cv_wait(&q->q_cv, &q->q_mutex);
 			goto again;
+		}
+	}
 	SIMPLEQ_FOREACH(wk, &q->q_queue_running, wk_entry) {
-		if (wk == wk_target)
+	/*
-			goto found;
+	 * The target may be in the batch of work currently running,
 	 * but we can't touch that queue.  So if there's anything
-    found:
+	 * running, wait until the generation changes.
-	if (wk != NULL) {
+	 */
-		found = true;
+	gen = q->q_gen;
-		KASSERT(q->q_waiter == NULL);
+	if (gen & 1) {
-		q->q_waiter = wk;
+		do
-		cv_wait(&q->q_cv, &q->q_mutex);
+			cv_wait(&q->q_cv, &q->q_mutex);
-		goto again;
+		while (gen == q->q_gen);
+	}
 	if (q->q_waiter != NULL)
 		q->q_waiter = NULL;
     out:
 	mutex_exit(&q->q_mutex);
 	return found;
+}
 /*
  * Wait for a specified work to finish.  The caller must ensure that no new
  * work will be enqueued before calling workqueue_wait.  Note that if the
  * workqueue is WQ_PERCPU, the caller can enqueue a new work to another queue
  * other than the waiting queue.
  */
 void
 workqueue_wait(struct workqueue *wq, struct work *wk)
+{
 	struct workqueue_queue *q;
 	bool found;
 	ASSERT_SLEEPABLE();
 	SDT_PROBE2(sdt, kernel, workqueue, wait__start,  wq, wk);
 	if (ISSET(wq->wq_flags, WQ_PERCPU)) {
 		struct cpu_info *ci;
 		CPU_INFO_ITERATOR cii;
 		for (CPU_INFO_FOREACH(cii, ci)) {
 			q = workqueue_queue_lookup(wq, ci);
-			found = workqueue_q_wait(q, (work_impl_t *)wk);
+			found = workqueue_q_wait(wq, q, (work_impl_t *)wk);
 			if (found)
 				break;
+		}
 	} else {
 		q = workqueue_queue_lookup(wq, NULL);
-		(void) workqueue_q_wait(q, (work_impl_t *)wk);
+		(void)workqueue_q_wait(wq, q, (work_impl_t *)wk);
+	}
 	SDT_PROBE2(sdt, kernel, workqueue, wait__done,  wq, wk);
+}
 void
 workqueue_destroy(struct workqueue *wq)
+{
 	struct workqueue_queue *q;
 	struct cpu_info *ci;
 	CPU_INFO_ITERATOR cii;
 	ASSERT_SLEEPABLE();
 	SDT_PROBE1(sdt, kernel, workqueue, exit__start,  wq);
 	wq->wq_func = workqueue_exit;
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		q = workqueue_queue_lookup(wq, ci);
 		if (q->q_worker != NULL) {
 			workqueue_finiqueue(wq, q);
+		}
+	}
 	SDT_PROBE1(sdt, kernel, workqueue, exit__done,  wq);
 	kmem_free(wq->wq_ptr, workqueue_size(wq->wq_flags));
+}
 #ifdef DEBUG
 static void
 workqueue_check_duplication(struct workqueue_queue *q, work_impl_t *wk)
+{
 	work_impl_t *_wk;
 	SIMPLEQ_FOREACH(_wk, &q->q_queue_pending, wk_entry) {
 		if (_wk == wk)
 			panic("%s: tried to enqueue a queued work", __func__);
+	}
+}
 #endif
 void
 workqueue_enqueue(struct workqueue *wq, struct work *wk0, struct cpu_info *ci)
+{
 	struct workqueue_queue *q;
 	work_impl_t *wk = (void *)wk0;
 	SDT_PROBE3(sdt, kernel, workqueue, enqueue,  wq, wk0, ci);
 	KASSERT(wq->wq_flags & WQ_PERCPU || ci == NULL);
 	q = workqueue_queue_lookup(wq, ci);
 	mutex_enter(&q->q_mutex);
 	KASSERT(q->q_waiter == NULL);
 #ifdef DEBUG
 	workqueue_check_duplication(q, wk);
 #endif
 	SIMPLEQ_INSERT_TAIL(&q->q_queue_pending, wk, wk_entry);
-	cv_signal(&q->q_cv);
+	cv_broadcast(&q->q_cv);
 	mutex_exit(&q->q_mutex);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: workqueue.c,v 1.6 2017/12/28 07:46:34 ozaki-r Exp $	*/
+/*	$NetBSD: workqueue.c,v 1.6.8.1 2024/04/18 15:51:35 martin Exp $	*/
 /*-
  * Copyright (c) 2017 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -19,52 +19,58 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if !defined(lint)
-__RCSID("$NetBSD: workqueue.c,v 1.6 2017/12/28 07:46:34 ozaki-r Exp $");
+__RCSID("$NetBSD: workqueue.c,v 1.6.8.1 2024/04/18 15:51:35 martin Exp $");
 #endif /* !lint */
 #include <sys/param.h>
 #include <sys/condvar.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 #include <sys/workqueue.h>
 #include "kernspace.h"
 struct test_softc {
 	kmutex_t mtx;
 	kcondvar_t cv;
 	struct workqueue *wq;
 	struct work wk;
 	int counter;
-};
+	bool pause;
 };
 static void
 rump_work1(struct work *wk, void *arg)
+{
 	struct test_softc *sc = arg;
 	memset(wk, 0x5a, sizeof(*wk));
 	if (sc->pause)
 		kpause("tstwk1", /*intr*/false, /*timo*/2, /*lock*/NULL);
 	mutex_enter(&sc->mtx);
 	++sc->counter;
 	cv_broadcast(&sc->cv);
 	mutex_exit(&sc->mtx);
+}
 static struct test_softc *
 create_sc(void)
+{
 	int rv;
 	struct test_softc *sc;
 	sc = kmem_zalloc(sizeof(*sc), KM_SLEEP);
 @@ -127,13 +133,44 @@ rumptest_workqueue_wait(void)
 		workqueue_enqueue(sc->wq, &sc->wk, NULL);
 		workqueue_wait(sc->wq, &sc->wk);
 		KASSERT(sc->counter == (i + 1));
+	}
 	KASSERT(sc->counter == ITERATIONS);
 	/* Wait for a work that is not enqueued. Just return immediately. */
 	workqueue_wait(sc->wq, &dummy);
 	destroy_sc(sc);
 #undef ITERATIONS
+}
 void
 rumptest_workqueue_wait_pause(void)
+{
 	struct test_softc *sc;
 	struct work dummy;
 	sc = create_sc();
 	sc->pause = true;
 #define ITERATIONS 1
 	for (size_t i = 0; i < ITERATIONS; ++i) {
 		struct work wk;
 		KASSERT(sc->counter == i);
 		workqueue_enqueue(sc->wq, &wk, NULL);
 		workqueue_enqueue(sc->wq, &sc->wk, NULL);
 		kpause("tstwk2", /*intr*/false, /*timo*/1, /*lock*/NULL);
 		workqueue_wait(sc->wq, &sc->wk);
 		workqueue_wait(sc->wq, &wk);
 		KASSERT(sc->counter == (i + 2));
+	}
 	KASSERT(sc->counter == 2*ITERATIONS);
 	/* Wait for a work that is not enqueued. Just return immediately. */
 	workqueue_wait(sc->wq, &dummy);
 	destroy_sc(sc);
 #undef ITERATIONS
+}

 @@ -1,14 +1,14 @@
-.\"	$NetBSD: workqueue.9,v 1.12 2017/12/28 07:00:52 ozaki-r Exp $
+.\"	$NetBSD: workqueue.9,v 1.12.6.1 2024/04/18 15:51:36 martin Exp $
 .\"
 .\" Copyright (c)2005 YAMAMOTO Takashi,
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 @@ -118,31 +118,31 @@ must be
 The enqueued work will be processed in a thread context.
 A work must not be enqueued again until the callback is called by
 the
 .Nm
 framework.
 .Pp
 .\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 .Fn workqueue_wait
 waits for a specified work
 .Fa wk
 on the workqueue
 .Fa wq
 to finish.
-The caller must ensure that no new work will be enqueued to the workqueue
+The caller must ensure that
-beforehand.
+.Fa wk
-Note that if the workqueue is
+will not be enqueued to the workqueue again until after
-.Dv WQ_PERCPU ,
+.Fn workqueue_wait
-the caller can enqueue a new work to another queue other than the waiting queue.
+returns.
 .Pp
 .\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 .Fn workqueue_destroy
 destroys a workqueue and frees associated resources.
 The caller should ensure that the workqueue has no work enqueued beforehand.
 .\" ------------------------------------------------------------
 .Sh RETURN VALUES
 .Fn workqueue_create
 returns 0 on success.
 Otherwise, it returns an
 .Xr errno 2 .
 .\" ------------------------------------------------------------
 .Sh CODE REFERENCES

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kernspace.h,v 1.8 2018/12/28 19:54:36 thorpej Exp $	*/
+/*	$NetBSD: kernspace.h,v 1.8.2.1 2024/04/18 15:51:35 martin Exp $	*/
 /*-
  * Copyright (c) 2010, 2018 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -32,25 +32,26 @@
 enum locktest { LOCKME_MTX, LOCKME_RWDOUBLEX, LOCKME_RWRX, LOCKME_RWXR,
 	LOCKME_DESTROYHELD, LOCKME_DOUBLEINIT, LOCKME_DOUBLEFREE,
 	LOCKME_MEMFREE };
 void rumptest_busypage(void);
 void rumptest_threadjoin(void);
 void rumptest_thread(void);
 void rumptest_tsleep(void);
 void rumptest_alloc(size_t);
 void rumptest_lockme(enum locktest);
 void rumptest_workqueue1(void);
 void rumptest_workqueue_wait(void);
 void rumptest_workqueue_wait_pause(void);
 void rumptest_sendsig(char *);
 void rumptest_localsig(int);
 void rumptest_threadpool_unbound_lifecycle(void);
 void rumptest_threadpool_percpu_lifecycle(void);
 void rumptest_threadpool_unbound_schedule(void);
 void rumptest_threadpool_percpu_schedule(void);
 void rumptest_threadpool_job_cancel(void);
 void rumptest_threadpool_job_cancelthrash(void);
 #endif /* _TESTS_RUMP_KERNSPACE_KERNSPACE_H_ */

 @@ -1,33 +1,33 @@
-# $NetBSD: Makefile,v 1.18 2018/12/26 14:27:23 thorpej Exp $
+# $NetBSD: Makefile,v 1.18.2.1 2024/04/18 15:51:35 martin Exp $
 .include <bsd.own.mk>
 TESTSDIR=	${TESTSBASE}/rump/rumpkern
 TESTS_C=	t_copy
 TESTS_C+=	t_kern
 TESTS_C+=	t_lwproc
 TESTS_C+=	t_modcmd
 TESTS_C+=	t_modlinkset
 TESTS_C+=	t_signals
 TESTS_C+=	t_threads
 TESTS_C+=	t_threadpool
 TESTS_C+=	t_tsleep
 TESTS_C+=	t_workqueue
 TESTS_C+=	t_vm
 TESTS_SH=	t_sp
 SUBDIR+=	h_client h_server
 ADD_TO_LD=	-lrumpvfs -lrump -lrumpuser -lrump -lpthread
 LDADD.t_modlinkset+=	-lukfs -lrumpdev_disk -lrumpdev -lrumpfs_msdos
 LDADD.t_modlinkset+=	-lrumpfs_cd9660 ${ADD_TO_LD}
 LDADD+=			${ADD_TO_LD}
-KERNSPACE != cd ${.CURDIR}/../kernspace && ${PRINTOBJDIR}
+PROGDPLIBS+=	kernspace	${.CURDIR}/../kernspace
-LDADD+=	-L${KERNSPACE} -lkernspace -lrump
+LDADD+=		-lrump
 WARNS=	4
 .include <bsd.test.mk>

 @@ -1,14 +1,14 @@
-/*	$NetBSD: t_workqueue.c,v 1.2 2017/12/28 07:10:26 ozaki-r Exp $	*/
+/*	$NetBSD: t_workqueue.c,v 1.2.8.1 2024/04/18 15:51:35 martin Exp $	*/
 /*-
  * Copyright (c) 2017 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -62,20 +62,46 @@ ATF_TC_HEAD(workqueue_wait, tc)
 	atf_tc_set_md_var(tc, "descr", "Checks workqueue_wait");
+}
 ATF_TC_BODY(workqueue_wait, tc)
+{
 	rump_init();
 	rump_schedule();
 	rumptest_workqueue_wait(); /* panics if fails */
 	rump_unschedule();
+}
 static void
 sigsegv(int signo)
+{
 	atf_tc_fail("SIGSEGV");
+}
 ATF_TC(workqueue_wait_pause);
 ATF_TC_HEAD(workqueue_wait_pause, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks workqueue_wait with pause");
+}
 ATF_TC_BODY(workqueue_wait_pause, tc)
+{
 	REQUIRE_LIBC(signal(SIGSEGV, &sigsegv), SIG_ERR);
 	rump_init();
 	rump_schedule();
 	rumptest_workqueue_wait_pause(); /* panics or SIGSEGVs if fails */
 	rump_unschedule();
+}
 ATF_TP_ADD_TCS(tp)
+{
 	ATF_TP_ADD_TC(tp, workqueue1);
 	ATF_TP_ADD_TC(tp, workqueue_wait);
 	ATF_TP_ADD_TC(tp, workqueue_wait_pause);
 	return atf_no_error();
+}