Tue Dec 25 02:17:07 2018 UTC ()

Fix !DIAGNOSTIC builds.


(kre)

diff -r1.1 -r1.2 src/sys/kern/kern_threadpool.c

--- src/sys/kern/kern_threadpool.c 2018/12/24 16:58:54	1.1
+++ src/sys/kern/kern_threadpool.c 2018/12/25 02:17:07	1.2

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_threadpool.c,v 1.1 2018/12/24 16:58:54 thorpej Exp $	*/
+/*	$NetBSD: kern_threadpool.c,v 1.2 2018/12/25 02:17:07 kre 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.
 @@ -71,54 +71,61 @@
  * |            | <running (n+1)b> |                        |
  * |            +------------------+                        |
  * +--------------------------------------------------------+
+ *
  * XXX Why one overseer 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
  * struct threadpool_job_impl to identify the CPU on which it must run
  * in order for the overseer to schedule it correctly.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_threadpool.c,v 1.1 2018/12/24 16:58:54 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_threadpool.c,v 1.2 2018/12/25 02:17:07 kre 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>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/systm.h>
 #include <sys/threadpool.h>
 static ONCE_DECL(threadpool_init_once)
 #ifdef DIAGNOSTIC
 #define	THREADPOOL_INIT()					\
 do {								\
 	int threadpool_init_error =				\
 	    RUN_ONCE(&threadpool_init_once, threadpools_init);	\
 	KASSERT(threadpool_init_error == 0);			\
 } while (/*CONSTCOND*/0)
 #else
 #define	THREADPOOL_INIT()					\
 do {								\
 	RUN_ONCE(&threadpool_init_once, threadpools_init);	\
 } while (/*CONSTCOND*/0)
 #endif
 /* Data structures */
 TAILQ_HEAD(job_head, threadpool_job_impl);
 TAILQ_HEAD(thread_head, threadpool_thread);
 typedef struct threadpool_job_impl {
 	kmutex_t			*job_lock;		/* 1 */
 	struct threadpool_thread	*job_thread;		/* 1 */
 	TAILQ_ENTRY(threadpool_job_impl) job_entry;		/* 2 */
 	volatile unsigned int		job_refcnt;		/* 1 */
 				/* implicit pad on _LP64 */
 	kcondvar_t			job_cv;			/* 3 */
 @@ -714,27 +721,27 @@ threadpool_job_destroy(threadpool_job_t
 	(void)strlcpy(job->job_name, "deadjob", sizeof(job->job_name));
+}
 static int
 threadpool_job_hold(threadpool_job_impl_t *job)
+{
 	unsigned int refcnt;
 	do {
 		refcnt = job->job_refcnt;
 		if (refcnt == UINT_MAX)
 			return EBUSY;
 	} while (atomic_cas_uint(&job->job_refcnt, refcnt, (refcnt + 1))
 	    != refcnt);
 	return 0;
+}
 static void
 threadpool_job_rele(threadpool_job_impl_t *job)
+{
 	unsigned int refcnt;
 	do {
 		refcnt = job->job_refcnt;
 		KASSERT(0 < refcnt);
 		if (refcnt == 1) {
 			mutex_enter(job->job_lock);