 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.323 2015/04/26 15:15:20 mlelstv Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.324 2015/07/10 09:49:56 mrg Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2008-2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster; 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.
 @@ -91,27 +91,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /***********************************************************
+ *
  * rf_kintf.c -- the kernel interface routines for RAIDframe
+ *
  ***********************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.323 2015/04/26 15:15:20 mlelstv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.324 2015/07/10 09:49:56 mrg Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_raid_autoconfig.h"
 #endif
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/disk.h>
 #include <sys/device.h>
 @@ -185,34 +185,34 @@ static void raid_attach(device_t, device
 static int raid_detach(device_t, int);
 static int raidread_component_area(dev_t, struct vnode *, void *, size_t,
     daddr_t, daddr_t);
 static int raidwrite_component_area(dev_t, struct vnode *, void *, size_t,
     daddr_t, daddr_t, int);
 static int raidwrite_component_label(unsigned,
     dev_t, struct vnode *, RF_ComponentLabel_t *);
 static int raidread_component_label(unsigned,
     dev_t, struct vnode *, RF_ComponentLabel_t *);
-dev_type_open(raidopen);
+static dev_type_open(raidopen);
-dev_type_close(raidclose);
+static dev_type_close(raidclose);
-dev_type_read(raidread);
+static dev_type_read(raidread);
-dev_type_write(raidwrite);
+static dev_type_write(raidwrite);
-dev_type_ioctl(raidioctl);
+static dev_type_ioctl(raidioctl);
-dev_type_strategy(raidstrategy);
+static dev_type_strategy(raidstrategy);
-dev_type_dump(raiddump);
+static dev_type_dump(raiddump);
-dev_type_size(raidsize);
+static dev_type_size(raidsize);
 const struct bdevsw raid_bdevsw = {
 	.d_open = raidopen,
 	.d_close = raidclose,
 	.d_strategy = raidstrategy,
 	.d_ioctl = raidioctl,
 	.d_dump = raiddump,
 	.d_psize = raidsize,
 	.d_discard = nodiscard,
 	.d_flag = D_DISK
 };
 const struct cdevsw raid_cdevsw = {
 @@ -587,28 +587,27 @@ rf_buildroothack(RF_ConfigSet_t *config_
+		}
 		mutex_exit(&raid_lock);
 		if (num_root == 1) {
 			booted_device = rsc->sc_dev;
 			booted_partition = 0;	/* XXX assume 'a' */
 		} else {
 			/* we can't guess.. require the user to answer... */
 			boothowto |= RB_ASKNAME;
+		}
+	}
+}
 static int
 int
 raidsize(dev_t dev)
+{
 	struct raid_softc *rs;
 	struct disklabel *lp;
 	int     part, unit, omask, size;
 	unit = raidunit(dev);
 	if ((rs = raidget(unit)) == NULL)
 		return -1;
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (-1);
 	part = DISKPART(dev);
 @@ -621,27 +620,27 @@ raidsize(dev_t dev)
 	if (lp->d_partitions[part].p_fstype != FS_SWAP)
 		size = -1;
 	else
 		size = lp->d_partitions[part].p_size *
 		    (lp->d_secsize / DEV_BSIZE);
 	if (omask == 0 && raidclose(dev, 0, S_IFBLK, curlwp))
 		return (-1);
 	return (size);
+}
-int
+static int
 raiddump(dev_t dev, daddr_t blkno, void *va, size_t size)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	const struct bdevsw *bdev;
 	struct disklabel *lp;
 	RF_Raid_t *raidPtr;
 	daddr_t offset;
 	int     part, c, sparecol, j, scol, dumpto;
 	int     error = 0;
 	if ((rs = raidget(unit)) == NULL)
 		return ENXIO;
 @@ -757,28 +756,29 @@ raiddump(dev_t dev, daddr_t blkno, void
 	   set, and also adding RF_PROTECTED_SECTORS, we get a
 	   value that is relative to the partition used for the
 	   underlying component.
 	*/
 	error = (*bdev->d_dump)(raidPtr->Disks[dumpto].dev,
 				blkno + offset, va, size);
 out:
 	raidunlock(rs);
 	return error;
+}
 /* ARGSUSED */
-int
+static int
 raidopen(dev_t dev, int flags, int fmt,
     struct lwp *l)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	struct disklabel *lp;
 	int     part, pmask;
 	int     error = 0;
 	if ((rs = raidget(unit)) == NULL)
 		return ENXIO;
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 @@ -842,28 +842,29 @@ raidopen(dev_t dev, int flags, int fmt,
+	}
 	rs->sc_dkdev.dk_openmask =
 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
 bad:
 	raidunlock(rs);
 	return (error);
+}
 /* ARGSUSED */
-int
+static int
 raidclose(dev_t dev, int flags, int fmt, struct lwp *l)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	int     error = 0;
 	int     part;
 	if ((rs = raidget(unit)) == NULL)
 		return ENXIO;
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 @@ -892,27 +893,27 @@ raidclose(dev_t dev, int flags, int fmt,
 		rf_update_component_labels(&rs->sc_r,
 						 RF_FINAL_COMPONENT_UPDATE);
 		/* If the kernel is shutting down, it will detach
 		 * this RAID set soon enough.
 		 */
+	}
 	raidunlock(rs);
 	return (0);
+}
-void
+static void
 raidstrategy(struct buf *bp)
+{
 	unsigned int unit = raidunit(bp->b_dev);
 	RF_Raid_t *raidPtr;
 	int     wlabel;
 	struct raid_softc *rs;
 	if ((rs = raidget(unit)) == NULL) {
 		bp->b_error = ENXIO;
 		goto done;
+	}
 	if ((rs->sc_flags & RAIDF_INITED) == 0) {
 		bp->b_error = ENXIO;
 @@ -962,44 +963,46 @@ raidstrategy(struct buf *bp)
 	/* stuff it onto our queue */
 	bufq_put(rs->buf_queue, bp);
 	/* scheduled the IO to happen at the next convenient time */
 	rf_signal_cond2(raidPtr->iodone_cv);
 	rf_unlock_mutex2(raidPtr->iodone_lock);
 	return;
 done:
 	bp->b_resid = bp->b_bcount;
 	biodone(bp);
+}
 /* ARGSUSED */
-int
+static int
 raidread(dev_t dev, struct uio *uio, int flags)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	if ((rs = raidget(unit)) == NULL)
 		return ENXIO;
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (ENXIO);
 	return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio));
+}
 /* ARGSUSED */
-int
+static int
 raidwrite(dev_t dev, struct uio *uio, int flags)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	if ((rs = raidget(unit)) == NULL)
 		return ENXIO;
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (ENXIO);
 	return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
 @@ -1027,27 +1030,27 @@ raid_detach_unlocked(struct raid_softc *
 	else
 		rs->sc_flags &= ~(RAIDF_INITED|RAIDF_SHUTDOWN);
 	/* Detach the disk. */
 	dkwedge_delall(&rs->sc_dkdev);
 	disk_detach(&rs->sc_dkdev);
 	disk_destroy(&rs->sc_dkdev);
 	aprint_normal_dev(rs->sc_dev, "detached\n");
 	return 0;
+}
-int
+static int
 raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
+{
 	int     unit = raidunit(dev);
 	int     error = 0;
 	int     part, pmask, s;
 	cfdata_t cf;
 	struct raid_softc *rs;
 	RF_Config_t *k_cfg, *u_cfg;
 	RF_Raid_t *raidPtr;
 	RF_RaidDisk_t *diskPtr;
 	RF_AccTotals_t *totals;
 	RF_DeviceConfig_t *d_cfg, **ucfgp;
 	u_char *specific_buf;