 @@ -1,303 +1,303 @@
 /*-
  * Copyright (c) 2010-2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This material is based upon work partially supported by The
  * NetBSD Foundation under a contract with Mindaugas Rasiukevicius.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND 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 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.
  */
 #ifdef _KERNEL
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: npf_worker.c,v 1.9 2020/05/30 20:54:54 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: npf_worker.c,v 1.10 2020/08/27 18:49:36 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/mutex.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/kthread.h>
 #include <sys/cprng.h>
 #endif
 #include "npf_impl.h"
 typedef struct npf_worker {
 	kmutex_t		lock;
 	kcondvar_t		cv;
 	kcondvar_t		exit_cv;
 	bool			exit;
 	LIST_HEAD(, npf)	instances;
 	unsigned		worker_count;
 	lwp_t *			worker[];
 } npf_workerinfo_t;
 #define	NPF_GC_MINWAIT		(10)		// 10 ms
 #define	NPF_GC_MAXWAIT		(10 * 1000)	// 10 sec
 /*
  * Flags for the npf_t::worker_flags field.
  */
 #define	WFLAG_ACTIVE		0x01	// instance enqueued for workers
 #define	WFLAG_INITED		0x02	// worker setup the instance
 #define	WFLAG_REMOVE		0x04	// remove the instance
 static void			npf_worker(void *)	__dead;
 static npf_workerinfo_t *	worker_info		__read_mostly;
 int
 npf_worker_sysinit(unsigned nworkers)
+{
 	const size_t len = offsetof(npf_workerinfo_t, worker[nworkers]);
 	npf_workerinfo_t *winfo;
 	KASSERT(worker_info == NULL);
 	if (!nworkers) {
 		return 0;
+	}
 	winfo = kmem_zalloc(len, KM_SLEEP);
 	winfo->worker_count = nworkers;
 	mutex_init(&winfo->lock, MUTEX_DEFAULT, IPL_SOFTNET);
 	cv_init(&winfo->exit_cv, "npfgcx");
 	cv_init(&winfo->cv, "npfgcw");
 	LIST_INIT(&winfo->instances);
 	worker_info = winfo;
 	for (unsigned i = 0; i < nworkers; i++) {
 		if (kthread_create(PRI_NONE, KTHREAD_MPSAFE | KTHREAD_MUSTJOIN,
 		    NULL, npf_worker, winfo, &winfo->worker[i], "npfgc%u", i)) {
 			npf_worker_sysfini();
 			return ENOMEM;
+		}
+	}
 	return 0;
+}
 void
 npf_worker_sysfini(void)
+{
 	npf_workerinfo_t *winfo = worker_info;
 	unsigned nworkers;
 	if (!winfo) {
 		return;
+	}
 	/* Notify the workers to exit. */
 	mutex_enter(&winfo->lock);
 	winfo->exit = true;
 	cv_broadcast(&winfo->cv);
 	mutex_exit(&winfo->lock);
 	/* Wait for them to finish and then destroy. */
 	nworkers = winfo->worker_count;
 	for (unsigned i = 0; i < nworkers; i++) {
 		lwp_t *worker;
 		if ((worker = winfo->worker[i]) != NULL) {
 			kthread_join(worker);
+		}
+	}
 	cv_destroy(&winfo->cv);
 	cv_destroy(&winfo->exit_cv);
 	mutex_destroy(&winfo->lock);
 	kmem_free(winfo, offsetof(npf_workerinfo_t, worker[nworkers]));
 	worker_info = NULL;
+}
 int
 npf_worker_addfunc(npf_t *npf, npf_workfunc_t work)
+{
 	KASSERTMSG(npf->worker_flags == 0,
 	    "the task must be added before the npf_worker_enlist() call");
 	for (unsigned i = 0; i < NPF_MAX_WORKS; i++) {
 		if (npf->worker_funcs[i] == NULL) {
 			npf->worker_funcs[i] = work;
 			return 0;
+		}
+	}
 	return -1;
+}
 void
 npf_worker_signal(npf_t *npf)
+{
 	npf_workerinfo_t *winfo = worker_info;
 	if ((npf->worker_flags & WFLAG_ACTIVE) == 0) {
 		return;
+	}
 	KASSERT(winfo != NULL);
 	mutex_enter(&winfo->lock);
 	cv_signal(&winfo->cv);
 	mutex_exit(&winfo->lock);
+}
 /*
  * npf_worker_enlist: add the NPF instance for worker(s) to process.
  */
 void
 npf_worker_enlist(npf_t *npf)
+{
 	npf_workerinfo_t *winfo = worker_info;
 	KASSERT(npf->worker_flags == 0);
 	if (!winfo) {
 		return;
+	}
 	mutex_enter(&winfo->lock);
 	LIST_INSERT_HEAD(&winfo->instances, npf, worker_entry);
 	npf->worker_flags |= WFLAG_ACTIVE;
 	mutex_exit(&winfo->lock);
+}
 /*
  * npf_worker_discharge: remove the NPF instance the list for workers.
+ *
  * => May block waiting for a worker to finish processing the instance.
  */
 void
 npf_worker_discharge(npf_t *npf)
+{
 	npf_workerinfo_t *winfo = worker_info;
 	if ((npf->worker_flags & WFLAG_ACTIVE) == 0) {
 		return;
+	}
 	KASSERT(winfo != NULL);
 	/*
 	 * Notify the worker(s) that we are removing this instance.
 	 */
 	mutex_enter(&winfo->lock);
 	KASSERT(npf->worker_flags & WFLAG_ACTIVE);
 	npf->worker_flags |= WFLAG_REMOVE;
 	cv_broadcast(&winfo->cv);
 	/* Wait for a worker to process this request. */
 	while (npf->worker_flags & WFLAG_ACTIVE) {
 		cv_wait(&winfo->exit_cv, &winfo->lock);
+	}
 	mutex_exit(&winfo->lock);
 	KASSERT(npf->worker_flags == 0);
+}
 static void
 remove_npf_instance(npf_workerinfo_t *winfo, npf_t *npf)
+{
 	KASSERT(mutex_owned(&winfo->lock));
 	KASSERT(npf->worker_flags & WFLAG_ACTIVE);
 	KASSERT(npf->worker_flags & WFLAG_REMOVE);
 	/*
 	 * Remove the NPF instance:
 	 * - Release any structures owned by the worker.
 	 * - Remove the instance from the list.
 	 * - Notify any thread waiting for removal to complete.
 	 */
 	if (npf->worker_flags & WFLAG_INITED) {
 		npfk_thread_unregister(npf);
+	}
 	LIST_REMOVE(npf, worker_entry);
 	npf->worker_flags = 0;
 	cv_broadcast(&winfo->exit_cv);
+}
 static unsigned
 process_npf_instance(npf_workerinfo_t *winfo, npf_t *npf)
+{
 	npf_workfunc_t work;
 	KASSERT(mutex_owned(&winfo->lock));
 	if (npf->worker_flags & WFLAG_REMOVE) {
 		remove_npf_instance(winfo, npf);
 		return NPF_GC_MAXWAIT;
+	}
 	if ((npf->worker_flags & WFLAG_INITED) == 0) {
 		npfk_thread_register(npf);
 		npf->worker_flags |= WFLAG_INITED;
+	}
 	/* Run the jobs. */
 	for (unsigned i = 0; i < NPF_MAX_WORKS; i++) {
 		if ((work = npf->worker_funcs[i]) == NULL) {
 			break;
+		}
 		work(npf);
+	}
 	return MAX(MIN(npf->worker_wait_time, NPF_GC_MAXWAIT), NPF_GC_MINWAIT);
+}
 /*
  * npf_worker: the main worker loop, processing enlisted NPF instances.
+ *
  * XXX: Currently, npf_workerinfo_t::lock would serialize all workers,
  * so there is no point to have more than one worker; but there might
  * not be much point anyway.
  */
 static void
 npf_worker(void *arg)
+{
 	npf_workerinfo_t *winfo = arg;
 	npf_t *npf;
 	mutex_enter(&winfo->lock);
-	while (!winfo->exit) {
+	for (;;) {
 		unsigned wait_time = NPF_GC_MAXWAIT;
 		/*
 		 * Iterate all instances.  We do not use LIST_FOREACH here,
 		 * since the instance can be removed.
 		 */
 		npf = LIST_FIRST(&winfo->instances);
 		while (npf) {
 			npf_t *next = LIST_NEXT(npf, worker_entry);
 			unsigned i_wait_time = process_npf_instance(winfo, npf);
 			wait_time = MIN(wait_time, i_wait_time);
 			npf = next;
+		}
 		/*
 		 * Sleep and periodically wake up, unless we get notified.
 		 */
 		if (winfo->exit) {
 			break;
+		}
 		cv_timedwait(&winfo->cv, &winfo->lock, mstohz(wait_time));
+	}
 	mutex_exit(&winfo->lock);
 	KASSERTMSG(LIST_EMPTY(&winfo->instances),
 	    "NPF instances must be discharged before the npfk_sysfini() call");
 	kthread_exit(0);
+}