 @@ -1,14 +1,14 @@
-/* $NetBSD: subr_autoconf.c,v 1.247 2016/07/19 07:44:03 msaitoh Exp $ */
+/* $NetBSD: subr_autoconf.c,v 1.248 2017/03/20 00:30:03 riastradh Exp $ */
 /*
  * Copyright (c) 1996, 2000 Christopher G. Demetriou
  * 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.
 @@ -67,27 +67,27 @@
  * 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.
+ *
  * from: Header: subr_autoconf.c,v 1.12 93/02/01 19:31:48 torek Exp  (LBL)
+ *
  *	@(#)subr_autoconf.c	8.3 (Berkeley) 5/17/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_autoconf.c,v 1.247 2016/07/19 07:44:03 msaitoh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_autoconf.c,v 1.248 2017/03/20 00:30:03 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "drvctl.h"
 #endif
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/disklabel.h>
 #include <sys/conf.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/systm.h>
 @@ -2771,136 +2771,147 @@ deviter_visits(const deviter_t *di, devi
  * Device iteration does not return device_t's in any particular
  * order.  An iterator will never return the same device_t twice.
  * Device iteration is guaranteed to complete---i.e., if deviter_next(di)
  * is called repeatedly on the same `di', it will eventually return
  * NULL.  It is ok to attach/detach devices during device iteration.
  */
 void
 deviter_init(deviter_t *di, deviter_flags_t flags)
+{
 	device_t dv;
 	memset(di, 0, sizeof(*di));
 	mutex_enter(&alldevs_mtx);
 	if ((flags & DEVITER_F_SHUTDOWN) != 0)
 		flags |= DEVITER_F_RW;
 	mutex_enter(&alldevs_mtx);
 	if ((flags & DEVITER_F_RW) != 0)
 		alldevs_nwrite++;
 	else
 		alldevs_nread++;
 	di->di_gen = alldevs_gen++;
 	mutex_exit(&alldevs_mtx);
 	di->di_flags = flags;
 	switch (di->di_flags & (DEVITER_F_LEAVES_FIRST|DEVITER_F_ROOT_FIRST)) {
 	case DEVITER_F_LEAVES_FIRST:
 		TAILQ_FOREACH(dv, &alldevs, dv_list) {
 			if (!deviter_visits(di, dv))
 				continue;
 			di->di_curdepth = MAX(di->di_curdepth, dv->dv_depth);
+		}
 		break;
 	case DEVITER_F_ROOT_FIRST:
 		TAILQ_FOREACH(dv, &alldevs, dv_list) {
 			if (!deviter_visits(di, dv))
 				continue;
 			di->di_maxdepth = MAX(di->di_maxdepth, dv->dv_depth);
+		}
 		break;
 	default:
 		break;
+	}
 	deviter_reinit(di);
 	mutex_exit(&alldevs_mtx);
+}
 static void
 deviter_reinit(deviter_t *di)
+{
 	KASSERT(mutex_owned(&alldevs_mtx));
 	if ((di->di_flags & DEVITER_F_RW) != 0)
 		di->di_prev = TAILQ_LAST(&alldevs, devicelist);
 	else
 		di->di_prev = TAILQ_FIRST(&alldevs);
+}
 device_t
 deviter_first(deviter_t *di, deviter_flags_t flags)
+{
 	deviter_init(di, flags);
 	return deviter_next(di);
+}
 static device_t
 deviter_next2(deviter_t *di)
+{
 	device_t dv;
 	KASSERT(mutex_owned(&alldevs_mtx));
 	dv = di->di_prev;
 	if (dv == NULL)
 		return NULL;
 	if ((di->di_flags & DEVITER_F_RW) != 0)
 		di->di_prev = TAILQ_PREV(dv, devicelist, dv_list);
 	else
 		di->di_prev = TAILQ_NEXT(dv, dv_list);
 	return dv;
+}
 static device_t
 deviter_next1(deviter_t *di)
+{
 	device_t dv;
 	KASSERT(mutex_owned(&alldevs_mtx));
 	do {
 		dv = deviter_next2(di);
 	} while (dv != NULL && !deviter_visits(di, dv));
 	return dv;
+}
 device_t
 deviter_next(deviter_t *di)
+{
 	device_t dv = NULL;
 	mutex_enter(&alldevs_mtx);
 	switch (di->di_flags & (DEVITER_F_LEAVES_FIRST|DEVITER_F_ROOT_FIRST)) {
 	case 0:
-		return deviter_next1(di);
+		dv = deviter_next1(di);
 		break;
 	case DEVITER_F_LEAVES_FIRST:
 		while (di->di_curdepth >= 0) {
 			if ((dv = deviter_next1(di)) == NULL) {
 				di->di_curdepth--;
 				deviter_reinit(di);
 			} else if (dv->dv_depth == di->di_curdepth)
 				break;
+		}
-		return dv;
+		break;
 	case DEVITER_F_ROOT_FIRST:
 		while (di->di_curdepth <= di->di_maxdepth) {
 			if ((dv = deviter_next1(di)) == NULL) {
 				di->di_curdepth++;
 				deviter_reinit(di);
 			} else if (dv->dv_depth == di->di_curdepth)
 				break;
+		}
-		return dv;
+		break;
 	default:
-		return NULL;
+		break;
+	}
 	mutex_exit(&alldevs_mtx);
 	return dv;
+}
 void
 deviter_release(deviter_t *di)
+{
 	bool rw = (di->di_flags & DEVITER_F_RW) != 0;
 	mutex_enter(&alldevs_mtx);
 	if (rw)
 		--alldevs_nwrite;
 	else
 		--alldevs_nread;
 	/* XXX wake a garbage-collection thread */