 @@ -1,1387 +1,1387 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.273 2010/03/14 21:11:41 jld Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.274 2010/08/08 18:25:14 chs Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2008 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.
  * 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.
  */
 /*
  * Copyright (c) 1990, 1993
  *      The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department.
+ *
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ *
  * from: Utah $Hdr: cd.c 1.6 90/11/28$
+ *
  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
  */
 /*
  * Copyright (c) 1988 University of Utah.
+ *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department.
+ *
  * 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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by the University of
  *      California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ *
  * from: Utah $Hdr: cd.c 1.6 90/11/28$
+ *
  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
  */
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Authors: Mark Holland, Jim Zelenka
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  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.273 2010/03/14 21:11:41 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.274 2010/08/08 18:25:14 chs Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_raid_autoconfig.h"
 #include "raid.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>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/systm.h>
 #include <sys/vnode.h>
 #include <sys/disklabel.h>
 #include <sys/conf.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/reboot.h>
 #include <sys/kauth.h>
 #include <prop/proplib.h>
 #include <dev/raidframe/raidframevar.h>
 #include <dev/raidframe/raidframeio.h>
 #include <dev/raidframe/rf_paritymap.h>
 #include "rf_raid.h"
 #include "rf_copyback.h"
 #include "rf_dag.h"
 #include "rf_dagflags.h"
 #include "rf_desc.h"
 #include "rf_diskqueue.h"
 #include "rf_etimer.h"
 #include "rf_general.h"
 #include "rf_kintf.h"
 #include "rf_options.h"
 #include "rf_driver.h"
 #include "rf_parityscan.h"
 #include "rf_threadstuff.h"
 #ifdef COMPAT_50
 #include "rf_compat50.h"
 #endif
 #ifdef DEBUG
 int     rf_kdebug_level = 0;
 #define db1_printf(a) if (rf_kdebug_level > 0) printf a
 #else				/* DEBUG */
 #define db1_printf(a) { }
 #endif				/* DEBUG */
 static RF_Raid_t **raidPtrs;	/* global raid device descriptors */
 #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
 RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex)
 static RF_SparetWait_t *rf_sparet_wait_queue;	/* requests to install a
 						 * spare table */
 static RF_SparetWait_t *rf_sparet_resp_queue;	/* responses from
 						 * installation process */
 #endif
 MALLOC_DEFINE(M_RAIDFRAME, "RAIDframe", "RAIDframe structures");
 /* prototypes */
 static void KernelWakeupFunc(struct buf *);
 static void InitBP(struct buf *, struct vnode *, unsigned,
     dev_t, RF_SectorNum_t, RF_SectorCount_t, void *, void (*) (struct buf *),
     void *, int, struct proc *);
 static void raidinit(RF_Raid_t *);
 void raidattach(int);
 static int raid_match(device_t, cfdata_t, void *);
 static void raid_attach(device_t, device_t, void *);
 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(dev_t, struct vnode *,
     RF_ComponentLabel_t *);
 static int raidread_component_label(dev_t, struct vnode *,
     RF_ComponentLabel_t *);
 dev_type_open(raidopen);
 dev_type_close(raidclose);
 dev_type_read(raidread);
 dev_type_write(raidwrite);
 dev_type_ioctl(raidioctl);
 dev_type_strategy(raidstrategy);
 dev_type_dump(raiddump);
 dev_type_size(raidsize);
 const struct bdevsw raid_bdevsw = {
 	raidopen, raidclose, raidstrategy, raidioctl,
 	raiddump, raidsize, D_DISK
 };
 const struct cdevsw raid_cdevsw = {
 	raidopen, raidclose, raidread, raidwrite, raidioctl,
 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
 };
 static struct dkdriver rf_dkdriver = { raidstrategy, minphys };
 /* XXX Not sure if the following should be replacing the raidPtrs above,
    or if it should be used in conjunction with that...
 */
 struct raid_softc {
 	device_t sc_dev;
 	int     sc_flags;	/* flags */
 	int     sc_cflags;	/* configuration flags */
 	uint64_t sc_size;	/* size of the raid device */
 	char    sc_xname[20];	/* XXX external name */
 	struct disk sc_dkdev;	/* generic disk device info */
 	struct bufq_state *buf_queue;	/* used for the device queue */
 };
 /* sc_flags */
 #define RAIDF_INITED	0x01	/* unit has been initialized */
 #define RAIDF_WLABEL	0x02	/* label area is writable */
 #define RAIDF_LABELLING	0x04	/* unit is currently being labelled */
 #define RAIDF_SHUTDOWN	0x08	/* unit is being shutdown */
 #define RAIDF_WANTED	0x40	/* someone is waiting to obtain a lock */
 #define RAIDF_LOCKED	0x80	/* unit is locked */
 #define	raidunit(x)	DISKUNIT(x)
 int numraid = 0;
 extern struct cfdriver raid_cd;
 CFATTACH_DECL3_NEW(raid, sizeof(struct raid_softc),
     raid_match, raid_attach, raid_detach, NULL, NULL, NULL,
     DVF_DETACH_SHUTDOWN);
 /*
  * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
  * Be aware that large numbers can allow the driver to consume a lot of
  * kernel memory, especially on writes, and in degraded mode reads.
+ *
  * For example: with a stripe width of 64 blocks (32k) and 5 disks,
  * a single 64K write will typically require 64K for the old data,
  * 64K for the old parity, and 64K for the new parity, for a total
  * of 192K (if the parity buffer is not re-used immediately).
  * Even it if is used immediately, that's still 128K, which when multiplied
  * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
+ *
  * Now in degraded mode, for example, a 64K read on the above setup may
  * require data reconstruction, which will require *all* of the 4 remaining
  * disks to participate -- 4 * 32K/disk == 128K again.
  */
 #ifndef RAIDOUTSTANDING
 #define RAIDOUTSTANDING   6
 #endif
 #define RAIDLABELDEV(dev)	\
 	(MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
 /* declared here, and made public, for the benefit of KVM stuff.. */
 struct raid_softc *raid_softc;
 static void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *,
 				     struct disklabel *);
 static void raidgetdisklabel(dev_t);
 static void raidmakedisklabel(struct raid_softc *);
 static int raidlock(struct raid_softc *);
 static void raidunlock(struct raid_softc *);
 static int raid_detach_unlocked(struct raid_softc *);
 static void rf_markalldirty(RF_Raid_t *);
 static void rf_set_properties(struct raid_softc *, RF_Raid_t *);
 void rf_ReconThread(struct rf_recon_req *);
 void rf_RewriteParityThread(RF_Raid_t *raidPtr);
 void rf_CopybackThread(RF_Raid_t *raidPtr);
 void rf_ReconstructInPlaceThread(struct rf_recon_req *);
 int rf_autoconfig(device_t);
 void rf_buildroothack(RF_ConfigSet_t *);
 RF_AutoConfig_t *rf_find_raid_components(void);
 RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
 static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
 static int rf_reasonable_label(RF_ComponentLabel_t *);
 void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *, RF_Raid_t *);
 int rf_set_autoconfig(RF_Raid_t *, int);
 int rf_set_rootpartition(RF_Raid_t *, int);
 void rf_release_all_vps(RF_ConfigSet_t *);
 void rf_cleanup_config_set(RF_ConfigSet_t *);
 int rf_have_enough_components(RF_ConfigSet_t *);
 int rf_auto_config_set(RF_ConfigSet_t *, int *);
 static int raidautoconfig = 0; /* Debugging, mostly.  Set to 0 to not
 				  allow autoconfig to take place.
 				  Note that this is overridden by having
 				  RAID_AUTOCONFIG as an option in the
 				  kernel config file.  */
 struct RF_Pools_s rf_pools;
 void
 raidattach(int num)
+{
 	int raidID;
 	int i, rc;
 	aprint_debug("raidattach: Asked for %d units\n", num);
 	if (num <= 0) {
 #ifdef DIAGNOSTIC
 		panic("raidattach: count <= 0");
 #endif
 		return;
+	}
 	/* This is where all the initialization stuff gets done. */
 	numraid = num;
 	/* Make some space for requested number of units... */
 	RF_Malloc(raidPtrs, num * sizeof(RF_Raid_t *), (RF_Raid_t **));
 	if (raidPtrs == NULL) {
 		panic("raidPtrs is NULL!!");
+	}
 #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
 	rf_mutex_init(&rf_sparet_wait_mutex);
 	rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
 #endif
 	for (i = 0; i < num; i++)
 		raidPtrs[i] = NULL;
 	rc = rf_BootRaidframe();
 	if (rc == 0)
-		aprint_normal("Kernelized RAIDframe activated\n");
+		aprint_verbose("Kernelized RAIDframe activated\n");
 	else
 		panic("Serious error booting RAID!!");
 	/* put together some datastructures like the CCD device does.. This
 	 * lets us lock the device and what-not when it gets opened. */
 	raid_softc = (struct raid_softc *)
 		malloc(num * sizeof(struct raid_softc),
 		       M_RAIDFRAME, M_NOWAIT);
 	if (raid_softc == NULL) {
 		aprint_error("WARNING: no memory for RAIDframe driver\n");
 		return;
+	}
 	memset(raid_softc, 0, num * sizeof(struct raid_softc));
 	for (raidID = 0; raidID < num; raidID++) {
 		bufq_alloc(&raid_softc[raidID].buf_queue, "fcfs", 0);
 		RF_Malloc(raidPtrs[raidID], sizeof(RF_Raid_t),
 			  (RF_Raid_t *));
 		if (raidPtrs[raidID] == NULL) {
 			aprint_error("WARNING: raidPtrs[%d] is NULL\n", raidID);
 			numraid = raidID;
 			return;
+		}
+	}
 	if (config_cfattach_attach(raid_cd.cd_name, &raid_ca)) {
 		aprint_error("raidattach: config_cfattach_attach failed?\n");
+	}
 #ifdef RAID_AUTOCONFIG
 	raidautoconfig = 1;
 #endif
 	/*
 	 * Register a finalizer which will be used to auto-config RAID
 	 * sets once all real hardware devices have been found.
 	 */
 	if (config_finalize_register(NULL, rf_autoconfig) != 0)
 		aprint_error("WARNING: unable to register RAIDframe finalizer\n");
+}
 int
 rf_autoconfig(device_t self)
+{
 	RF_AutoConfig_t *ac_list;
 	RF_ConfigSet_t *config_sets;
 	if (raidautoconfig == 0)
 		return (0);
 	/* XXX This code can only be run once. */
 	raidautoconfig = 0;
 	/* 1. locate all RAID components on the system */
 	aprint_debug("Searching for RAID components...\n");
 	ac_list = rf_find_raid_components();
 	/* 2. Sort them into their respective sets. */
 	config_sets = rf_create_auto_sets(ac_list);
 	/*
 	 * 3. Evaluate each set andconfigure the valid ones.
 	 * This gets done in rf_buildroothack().
 	 */
 	rf_buildroothack(config_sets);
 	return 1;
+}
 void
 rf_buildroothack(RF_ConfigSet_t *config_sets)
+{
 	RF_ConfigSet_t *cset;
 	RF_ConfigSet_t *next_cset;
 	int retcode;
 	int raidID;
 	int rootID;
 	int col;
 	int num_root;
 	char *devname;
 	rootID = 0;
 	num_root = 0;
 	cset = config_sets;
 	while (cset != NULL) {
 		next_cset = cset->next;
 		if (rf_have_enough_components(cset) &&
 		    cset->ac->clabel->autoconfigure==1) {
 			retcode = rf_auto_config_set(cset,&raidID);
 			if (!retcode) {
 				aprint_debug("raid%d: configured ok\n", raidID);
 				if (cset->rootable) {
 					rootID = raidID;
 					num_root++;
+				}
 			} else {
 				/* The autoconfig didn't work :( */
 				aprint_debug("Autoconfig failed with code %d for raid%d\n", retcode, raidID);
 				rf_release_all_vps(cset);
+			}
 		} else {
 			/* we're not autoconfiguring this set...
 			   release the associated resources */
 			rf_release_all_vps(cset);
+		}
 		/* cleanup */
 		rf_cleanup_config_set(cset);
 		cset = next_cset;
+	}
 	/* if the user has specified what the root device should be
 	   then we don't touch booted_device or boothowto... */
 	if (rootspec != NULL)
 		return;
 	/* we found something bootable... */
 	if (num_root == 1) {
 		booted_device = raid_softc[rootID].sc_dev;
 	} else if (num_root > 1) {
 		/*
 		 * Maybe the MD code can help. If it cannot, then
 		 * setroot() will discover that we have no
 		 * booted_device and will ask the user if nothing was
 		 * hardwired in the kernel config file
 		 */
 		if (booted_device == NULL)
 			cpu_rootconf();
 		if (booted_device == NULL)
 			return;
 		num_root = 0;
 		for (raidID = 0; raidID < numraid; raidID++) {
 			if (raidPtrs[raidID]->valid == 0)
 				continue;
 			if (raidPtrs[raidID]->root_partition == 0)
 				continue;
 			for (col = 0; col < raidPtrs[raidID]->numCol; col++) {
 				devname = raidPtrs[raidID]->Disks[col].devname;
 				devname += sizeof("/dev/") - 1;
 				if (strncmp(devname, device_xname(booted_device),
 					    strlen(device_xname(booted_device))) != 0)
 					continue;
 				aprint_debug("raid%d includes boot device %s\n",
 				       raidID, devname);
 				num_root++;
 				rootID = raidID;
+			}
+		}
 		if (num_root == 1) {
 			booted_device = raid_softc[rootID].sc_dev;
 		} else {
 			/* we can't guess.. require the user to answer... */
 			boothowto |= RB_ASKNAME;
+		}
+	}
+}
 int
 raidsize(dev_t dev)
+{
 	struct raid_softc *rs;
 	struct disklabel *lp;
 	int     part, unit, omask, size;
 	unit = raidunit(dev);
 	if (unit >= numraid)
 		return (-1);
 	rs = &raid_softc[unit];
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (-1);
 	part = DISKPART(dev);
 	omask = rs->sc_dkdev.dk_openmask & (1 << part);
 	lp = rs->sc_dkdev.dk_label;
 	if (omask == 0 && raidopen(dev, 0, S_IFBLK, curlwp))
 		return (-1);
 	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
 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 (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	raidPtr = raidPtrs[unit];
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return ENXIO;
 	/* we only support dumping to RAID 1 sets */
 	if (raidPtr->Layout.numDataCol != 1 ||
 	    raidPtr->Layout.numParityCol != 1)
 		return EINVAL;
 	if ((error = raidlock(rs)) != 0)
 		return error;
 	if (size % DEV_BSIZE != 0) {
 		error = EINVAL;
 		goto out;
+	}
 	if (blkno + size / DEV_BSIZE > rs->sc_size) {
 		printf("%s: blkno (%" PRIu64 ") + size / DEV_BSIZE (%zu) > "
 		    "sc->sc_size (%" PRIu64 ")\n", __func__, blkno,
 		    size / DEV_BSIZE, rs->sc_size);
 		error = EINVAL;
 		goto out;
+	}
 	part = DISKPART(dev);
 	lp = rs->sc_dkdev.dk_label;
 	offset = lp->d_partitions[part].p_offset + RF_PROTECTED_SECTORS;
 	/* figure out what device is alive.. */
 	/*
 	   Look for a component to dump to.  The preference for the
 	   component to dump to is as follows:
 ) the master
 ) a used_spare of the master
 ) the slave
 ) a used_spare of the slave
 	*/
 	dumpto = -1;
 	for (c = 0; c < raidPtr->numCol; c++) {
 		if (raidPtr->Disks[c].status == rf_ds_optimal) {
 			/* this might be the one */
 			dumpto = c;
 			break;
+		}
+	}
 	/*
 	   At this point we have possibly selected a live master or a
 	   live slave.  We now check to see if there is a spared
 	   master (or a spared slave), if we didn't find a live master
 	   or a live slave.
 	*/
 	for (c = 0; c < raidPtr->numSpare; c++) {
 		sparecol = raidPtr->numCol + c;
 		if (raidPtr->Disks[sparecol].status ==  rf_ds_used_spare) {
 			/* How about this one? */
 			scol = -1;
 			for(j=0;j<raidPtr->numCol;j++) {
 				if (raidPtr->Disks[j].spareCol == sparecol) {
 					scol = j;
 					break;
+				}
+			}
 			if (scol == 0) {
 				/*
 				   We must have found a spared master!
 				   We'll take that over anything else
 				   found so far.  (We couldn't have
 				   found a real master before, since
 				   this is a used spare, and it's
 				   saying that it's replacing the
 				   master.)  On reboot (with
 				   autoconfiguration turned on)
 				   sparecol will become the 1st
 				   component (component0) of this set.
 				*/
 				dumpto = sparecol;
 				break;
 			} else if (scol != -1) {
 				/*
 				   Must be a spared slave.  We'll dump
 				   to that if we havn't found anything
 				   else so far.
 				*/
 				if (dumpto == -1)
 					dumpto = sparecol;
+			}
+		}
+	}
 	if (dumpto == -1) {
 		/* we couldn't find any live components to dump to!?!?
 		 */
 		error = EINVAL;
 		goto out;
+	}
 	bdev = bdevsw_lookup(raidPtr->Disks[dumpto].dev);
 	/*
 	   Note that blkno is relative to this particular partition.
 	   By adding the offset of this partition in the RAID
 	   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
 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 (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 	if ((rs->sc_flags & RAIDF_SHUTDOWN) != 0) {
 		error = EBUSY;
 		goto bad;
+	}
 	lp = rs->sc_dkdev.dk_label;
 	part = DISKPART(dev);
 	/*
 	 * If there are wedges, and this is not RAW_PART, then we
 	 * need to fail.
 	 */
 	if (rs->sc_dkdev.dk_nwedges != 0 && part != RAW_PART) {
 		error = EBUSY;
 		goto bad;
+	}
 	pmask = (1 << part);
 	if ((rs->sc_flags & RAIDF_INITED) &&
 	    (rs->sc_dkdev.dk_openmask == 0))
 		raidgetdisklabel(dev);
 	/* make sure that this partition exists */
 	if (part != RAW_PART) {
 		if (((rs->sc_flags & RAIDF_INITED) == 0) ||
 		    ((part >= lp->d_npartitions) ||
 			(lp->d_partitions[part].p_fstype == FS_UNUSED))) {
 			error = ENXIO;
 			goto bad;
+		}
+	}
 	/* Prevent this unit from being unconfigured while open. */
 	switch (fmt) {
 	case S_IFCHR:
 		rs->sc_dkdev.dk_copenmask |= pmask;
 		break;
 	case S_IFBLK:
 		rs->sc_dkdev.dk_bopenmask |= pmask;
 		break;
+	}
 	if ((rs->sc_dkdev.dk_openmask == 0) &&
 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
 		/* First one... mark things as dirty... Note that we *MUST*
 		 have done a configure before this.  I DO NOT WANT TO BE
 		 SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
 		 THAT THEY BELONG TOGETHER!!!!! */
 		/* XXX should check to see if we're only open for reading
 		   here... If so, we needn't do this, but then need some
 		   other way of keeping track of what's happened.. */
 		rf_markalldirty(raidPtrs[unit]);
+	}
 	rs->sc_dkdev.dk_openmask =
 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
 bad:
 	raidunlock(rs);
 	return (error);
+}
 /* ARGSUSED */
 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 (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 	part = DISKPART(dev);
 	/* ...that much closer to allowing unconfiguration... */
 	switch (fmt) {
 	case S_IFCHR:
 		rs->sc_dkdev.dk_copenmask &= ~(1 << part);
 		break;
 	case S_IFBLK:
 		rs->sc_dkdev.dk_bopenmask &= ~(1 << part);
 		break;
+	}
 	rs->sc_dkdev.dk_openmask =
 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
 	if ((rs->sc_dkdev.dk_openmask == 0) &&
 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
 		/* Last one... device is not unconfigured yet.
 		   Device shutdown has taken care of setting the
 		   clean bits if RAIDF_INITED is not set
 		   mark things as clean... */
 		rf_update_component_labels(raidPtrs[unit],
 						 RF_FINAL_COMPONENT_UPDATE);
 		/* If the kernel is shutting down, it will detach
 		 * this RAID set soon enough.
 		 */
+	}
 	raidunlock(rs);
 	return (0);
+}
 void
 raidstrategy(struct buf *bp)
+{
 	int s;
 	unsigned int raidID = raidunit(bp->b_dev);
 	RF_Raid_t *raidPtr;
 	struct raid_softc *rs = &raid_softc[raidID];
 	int     wlabel;
 	if ((rs->sc_flags & RAIDF_INITED) ==0) {
 		bp->b_error = ENXIO;
 		goto done;
+	}
 	if (raidID >= numraid || !raidPtrs[raidID]) {
 		bp->b_error = ENODEV;
 		goto done;
+	}
 	raidPtr = raidPtrs[raidID];
 	if (!raidPtr->valid) {
 		bp->b_error = ENODEV;
 		goto done;
+	}
 	if (bp->b_bcount == 0) {
 		db1_printf(("b_bcount is zero..\n"));
 		goto done;
+	}
 	/*
 	 * Do bounds checking and adjust transfer.  If there's an
 	 * error, the bounds check will flag that for us.
 	 */
 	wlabel = rs->sc_flags & (RAIDF_WLABEL | RAIDF_LABELLING);
 	if (DISKPART(bp->b_dev) == RAW_PART) {
 		uint64_t size; /* device size in DEV_BSIZE unit */
 		if (raidPtr->logBytesPerSector > DEV_BSHIFT) {
 			size = raidPtr->totalSectors <<
 			    (raidPtr->logBytesPerSector - DEV_BSHIFT);
 		} else {
 			size = raidPtr->totalSectors >>
 			    (DEV_BSHIFT - raidPtr->logBytesPerSector);
+		}
 		if (bounds_check_with_mediasize(bp, DEV_BSIZE, size) <= 0) {
 			goto done;
+		}
 	} else {
 		if (bounds_check_with_label(&rs->sc_dkdev, bp, wlabel) <= 0) {
 			db1_printf(("Bounds check failed!!:%d %d\n",
 				(int) bp->b_blkno, (int) wlabel));
 			goto done;
+		}
+	}
 	s = splbio();
 	bp->b_resid = 0;
 	/* stuff it onto our queue */
 	bufq_put(rs->buf_queue, bp);
 	/* scheduled the IO to happen at the next convenient time */
 	wakeup(&(raidPtrs[raidID]->iodone));
 	splx(s);
 	return;
 done:
 	bp->b_resid = bp->b_bcount;
 	biodone(bp);
+}
 /* ARGSUSED */
 int
 raidread(dev_t dev, struct uio *uio, int flags)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (ENXIO);
 	return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio));
+}
 /* ARGSUSED */
 int
 raidwrite(dev_t dev, struct uio *uio, int flags)
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (ENXIO);
 	return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
 static int
 raid_detach_unlocked(struct raid_softc *rs)
+{
 	int error;
 	RF_Raid_t *raidPtr;
 	raidPtr = raidPtrs[device_unit(rs->sc_dev)];
 	/*
 	 * If somebody has a partition mounted, we shouldn't
 	 * shutdown.
 	 */
 	if (rs->sc_dkdev.dk_openmask != 0)
 		return EBUSY;
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		;	/* not initialized: nothing to do */
 	else if ((error = rf_Shutdown(raidPtr)) != 0)
 		return error;
 	else
 		rs->sc_flags &= ~(RAIDF_INITED|RAIDF_SHUTDOWN);
 	/* Detach the disk. */
 	disk_detach(&rs->sc_dkdev);
 	disk_destroy(&rs->sc_dkdev);
 	return 0;
+}
 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;
 	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;
 	int retcode = 0;
 	int column;
 /*	int raidid; */
 	struct rf_recon_req *rrcopy, *rr;
 	RF_ComponentLabel_t *clabel;
 	RF_ComponentLabel_t *ci_label;
 	RF_ComponentLabel_t **clabel_ptr;
 	RF_SingleComponent_t *sparePtr,*componentPtr;
 	RF_SingleComponent_t component;
 	RF_ProgressInfo_t progressInfo, **progressInfoPtr;
 	int i, j, d;
 #ifdef __HAVE_OLD_DISKLABEL
 	struct disklabel newlabel;
 #endif
 	struct dkwedge_info *dkw;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	raidPtr = raidPtrs[unit];
 	db1_printf(("raidioctl: %d %d %d %d\n", (int) dev,
 		(int) DISKPART(dev), (int) unit, (int) cmd));
 	/* Must be open for writes for these commands... */
 	switch (cmd) {
 #ifdef DIOCGSECTORSIZE
 	case DIOCGSECTORSIZE:
 		*(u_int *)data = raidPtr->bytesPerSector;
 		return 0;
 	case DIOCGMEDIASIZE:
 		*(off_t *)data =
 		    (off_t)raidPtr->totalSectors * raidPtr->bytesPerSector;
 		return 0;
 #endif
 	case DIOCSDINFO:
 	case DIOCWDINFO:
 #ifdef __HAVE_OLD_DISKLABEL
 	case ODIOCWDINFO:
 	case ODIOCSDINFO:
 #endif
 	case DIOCWLABEL:
 	case DIOCAWEDGE:
 	case DIOCDWEDGE:
 		if ((flag & FWRITE) == 0)
 			return (EBADF);
+	}
 	/* Must be initialized for these... */
 	switch (cmd) {
 	case DIOCGDINFO:
 	case DIOCSDINFO:
 	case DIOCWDINFO:
 #ifdef __HAVE_OLD_DISKLABEL
 	case ODIOCGDINFO:
 	case ODIOCWDINFO:
 	case ODIOCSDINFO:
 	case ODIOCGDEFLABEL:
 #endif
 	case DIOCGPART:
 	case DIOCWLABEL:
 	case DIOCGDEFLABEL:
 	case DIOCAWEDGE:
 	case DIOCDWEDGE:
 	case DIOCLWEDGES:
 	case DIOCCACHESYNC:
 	case RAIDFRAME_SHUTDOWN:
 	case RAIDFRAME_REWRITEPARITY:
 	case RAIDFRAME_GET_INFO:
 	case RAIDFRAME_RESET_ACCTOTALS:
 	case RAIDFRAME_GET_ACCTOTALS:
 	case RAIDFRAME_KEEP_ACCTOTALS:
 	case RAIDFRAME_GET_SIZE:
 	case RAIDFRAME_FAIL_DISK:
 	case RAIDFRAME_COPYBACK:
 	case RAIDFRAME_CHECK_RECON_STATUS:
 	case RAIDFRAME_CHECK_RECON_STATUS_EXT:
 	case RAIDFRAME_GET_COMPONENT_LABEL:
 	case RAIDFRAME_SET_COMPONENT_LABEL:
 	case RAIDFRAME_ADD_HOT_SPARE:
 	case RAIDFRAME_REMOVE_HOT_SPARE:
 	case RAIDFRAME_INIT_LABELS:
 	case RAIDFRAME_REBUILD_IN_PLACE:
 	case RAIDFRAME_CHECK_PARITY:
 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
 	case RAIDFRAME_CHECK_COPYBACK_STATUS:
 	case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
 	case RAIDFRAME_SET_AUTOCONFIG:
 	case RAIDFRAME_SET_ROOT:
 	case RAIDFRAME_DELETE_COMPONENT:
 	case RAIDFRAME_INCORPORATE_HOT_SPARE:
 	case RAIDFRAME_PARITYMAP_STATUS:
 	case RAIDFRAME_PARITYMAP_GET_DISABLE:
 	case RAIDFRAME_PARITYMAP_SET_DISABLE:
 	case RAIDFRAME_PARITYMAP_SET_PARAMS:
 		if ((rs->sc_flags & RAIDF_INITED) == 0)
 			return (ENXIO);
+	}
 	switch (cmd) {
 #ifdef COMPAT_50
 	case RAIDFRAME_GET_INFO50:
 		return rf_get_info50(raidPtr, data);
 	case RAIDFRAME_CONFIGURE50:
 		if ((retcode = rf_config50(raidPtr, unit, data, &k_cfg)) != 0)
 			return retcode;
 		goto config;
 #endif
 		/* configure the system */
 	case RAIDFRAME_CONFIGURE:
 		if (raidPtr->valid) {
 			/* There is a valid RAID set running on this unit! */
 			printf("raid%d: Device already configured!\n",unit);
 			return(EINVAL);
+		}
 		/* copy-in the configuration information */
 		/* data points to a pointer to the configuration structure */
 		u_cfg = *((RF_Config_t **) data);
 		RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *));
 		if (k_cfg == NULL) {
 			return (ENOMEM);
+		}
 		retcode = copyin(u_cfg, k_cfg, sizeof(RF_Config_t));
 		if (retcode) {
 			RF_Free(k_cfg, sizeof(RF_Config_t));
 			db1_printf(("rf_ioctl: retcode=%d copyin.1\n",
 				retcode));
 			return (retcode);
+		}
 		goto config;
 	config:
 		/* allocate a buffer for the layout-specific data, and copy it
 		 * in */
 		if (k_cfg->layoutSpecificSize) {
 			if (k_cfg->layoutSpecificSize > 10000) {
 				/* sanity check */
 				RF_Free(k_cfg, sizeof(RF_Config_t));
 				return (EINVAL);
+			}
 			RF_Malloc(specific_buf, k_cfg->layoutSpecificSize,
 			    (u_char *));
 			if (specific_buf == NULL) {
 				RF_Free(k_cfg, sizeof(RF_Config_t));
 				return (ENOMEM);
+			}
 			retcode = copyin(k_cfg->layoutSpecific, specific_buf,
 			    k_cfg->layoutSpecificSize);
 			if (retcode) {
 				RF_Free(k_cfg, sizeof(RF_Config_t));
 				RF_Free(specific_buf,
 					k_cfg->layoutSpecificSize);
 				db1_printf(("rf_ioctl: retcode=%d copyin.2\n",
 					retcode));
 				return (retcode);
+			}
 		} else
 			specific_buf = NULL;
 		k_cfg->layoutSpecific = specific_buf;
 		/* should do some kind of sanity check on the configuration.
 		 * Store the sum of all the bytes in the last byte? */
 		/* configure the system */
 		/*
 		 * Clear the entire RAID descriptor, just to make sure
 		 *  there is no stale data left in the case of a
 		 *  reconfiguration
 		 */
 		memset((char *) raidPtr, 0, sizeof(RF_Raid_t));
 		raidPtr->raidid = unit;
 		retcode = rf_Configure(raidPtr, k_cfg, NULL);
 		if (retcode == 0) {
 			/* allow this many simultaneous IO's to
 			   this RAID device */
 			raidPtr->openings = RAIDOUTSTANDING;
 			raidinit(raidPtr);
 			rf_markalldirty(raidPtr);
+		}
 		/* free the buffers.  No return code here. */
 		if (k_cfg->layoutSpecificSize) {
 			RF_Free(specific_buf, k_cfg->layoutSpecificSize);
+		}
 		RF_Free(k_cfg, sizeof(RF_Config_t));
 		return (retcode);
 		/* shutdown the system */
 	case RAIDFRAME_SHUTDOWN:
 		part = DISKPART(dev);
 		pmask = (1 << part);
 		if ((error = raidlock(rs)) != 0)
 			return (error);
 		if ((rs->sc_dkdev.dk_openmask & ~pmask) ||
 		    ((rs->sc_dkdev.dk_bopenmask & pmask) &&
 			(rs->sc_dkdev.dk_copenmask & pmask)))
 			retcode = EBUSY;
 		else {
 			rs->sc_flags |= RAIDF_SHUTDOWN;
 			rs->sc_dkdev.dk_copenmask &= ~pmask;
 			rs->sc_dkdev.dk_bopenmask &= ~pmask;
 			rs->sc_dkdev.dk_openmask &= ~pmask;
 			retcode = 0;
+		}
 		raidunlock(rs);
 		if (retcode != 0)
 			return retcode;
 		/* free the pseudo device attach bits */
 		cf = device_cfdata(rs->sc_dev);
 		if ((retcode = config_detach(rs->sc_dev, DETACH_QUIET)) == 0)
 			free(cf, M_RAIDFRAME);
 		return (retcode);
 	case RAIDFRAME_GET_COMPONENT_LABEL:
 		clabel_ptr = (RF_ComponentLabel_t **) data;
 		/* need to read the component label for the disk indicated
 		   by row,column in clabel */
 		/*
 		 * Perhaps there should be an option to skip the in-core
 		 * copy and hit the disk, as with disklabel(8).
 		 */
 		RF_Malloc(clabel, sizeof(*clabel), (RF_ComponentLabel_t *));
 		retcode = copyin( *clabel_ptr, clabel,
 				  sizeof(RF_ComponentLabel_t));
 		if (retcode) {
 			return(retcode);
+		}
 		clabel->row = 0; /* Don't allow looking at anything else.*/
 		column = clabel->column;
 		if ((column < 0) || (column >= raidPtr->numCol +
 				     raidPtr->numSpare)) {
 			return(EINVAL);
+		}
 		RF_Free(clabel, sizeof(*clabel));
 		clabel = raidget_component_label(raidPtr, column);
 		if (retcode == 0) {
 			retcode = copyout(clabel, *clabel_ptr,
 					  sizeof(RF_ComponentLabel_t));
+		}
 		return (retcode);
 #if 0
 	case RAIDFRAME_SET_COMPONENT_LABEL:
 		clabel = (RF_ComponentLabel_t *) data;
 		/* XXX check the label for valid stuff... */
 		/* Note that some things *should not* get modified --
 		   the user should be re-initing the labels instead of
 		   trying to patch things.
 		   */
 		raidid = raidPtr->raidid;
 #ifdef DEBUG
 		printf("raid%d: Got component label:\n", raidid);
 		printf("raid%d: Version: %d\n", raidid, clabel->version);
 		printf("raid%d: Serial Number: %d\n", raidid, clabel->serial_number);
 		printf("raid%d: Mod counter: %d\n", raidid, clabel->mod_counter);
 		printf("raid%d: Column: %d\n", raidid, clabel->column);
 		printf("raid%d: Num Columns: %d\n", raidid, clabel->num_columns);
 		printf("raid%d: Clean: %d\n", raidid, clabel->clean);
 		printf("raid%d: Status: %d\n", raidid, clabel->status);
 #endif
 		clabel->row = 0;
 		column = clabel->column;
 		if ((column < 0) || (column >= raidPtr->numCol)) {
 			return(EINVAL);
+		}
 		/* XXX this isn't allowed to do anything for now :-) */
 		/* XXX and before it is, we need to fill in the rest
 		   of the fields!?!?!?! */
 		memcpy(raidget_component_label(raidPtr, column),
 		    clabel, sizeof(*clabel));
 		raidflush_component_label(raidPtr, column);
 		return (0);
 #endif
 	case RAIDFRAME_INIT_LABELS:
 		clabel = (RF_ComponentLabel_t *) data;
 		/*
 		   we only want the serial number from
 		   the above.  We get all the rest of the information
 		   from the config that was used to create this RAID
 		   set.
 		   */
 		raidPtr->serial_number = clabel->serial_number;
 		for(column=0;column<raidPtr->numCol;column++) {
 			diskPtr = &raidPtr->Disks[column];
 			if (!RF_DEAD_DISK(diskPtr->status)) {
 				ci_label = raidget_component_label(raidPtr,
 				    column);
 				/* Zeroing this is important. */
 				memset(ci_label, 0, sizeof(*ci_label));
 				raid_init_component_label(raidPtr, ci_label);
 				ci_label->serial_number =
 				    raidPtr->serial_number;
 				ci_label->row = 0; /* we dont' pretend to support more */
 				ci_label->partitionSize =
 				    diskPtr->partitionSize;
 				ci_label->column = column;
 				raidflush_component_label(raidPtr, column);
+			}
 			/* XXXjld what about the spares? */
+		}
 		return (retcode);
 	case RAIDFRAME_SET_AUTOCONFIG:
 		d = rf_set_autoconfig(raidPtr, *(int *) data);
 		printf("raid%d: New autoconfig value is: %d\n",
 		       raidPtr->raidid, d);
 		*(int *) data = d;
 		return (retcode);
 	case RAIDFRAME_SET_ROOT:
 		d = rf_set_rootpartition(raidPtr, *(int *) data);
 		printf("raid%d: New rootpartition value is: %d\n",
 		       raidPtr->raidid, d);
 		*(int *) data = d;
 		return (retcode);
 		/* initialize all parity */
 	case RAIDFRAME_REWRITEPARITY:
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
 			/* Parity for RAID 0 is trivially correct */
 			raidPtr->parity_good = RF_RAID_CLEAN;
 			return(0);
+		}
 		if (raidPtr->parity_rewrite_in_progress == 1) {
 			/* Re-write is already in progress! */
 			return(EINVAL);
+		}
 		retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
 					   rf_RewriteParityThread,
 					   raidPtr,"raid_parity");
 		return (retcode);
 	case RAIDFRAME_ADD_HOT_SPARE:
 		sparePtr = (RF_SingleComponent_t *) data;
 		memcpy( &component, sparePtr, sizeof(RF_SingleComponent_t));
 		retcode = rf_add_hot_spare(raidPtr, &component);