 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_copyback.c,v 1.42 2009/11/17 18:54:26 jld Exp $	*/
+/*	$NetBSD: rf_copyback.c,v 1.43 2010/11/01 02:35:25 mrg Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland
+ *
  * 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"
 @@ -28,27 +28,27 @@
 /*****************************************************************************
+ *
  * copyback.c -- code to copy reconstructed data back from spare space to
  *               the replaced disk.
+ *
  * the code operates using callbacks on the I/Os to continue with the
  * next unit to be copied back.  We do this because a simple loop
  * containing blocking I/Os will not work in the simulator.
+ *
  ****************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_copyback.c,v 1.42 2009/11/17 18:54:26 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_copyback.c,v 1.43 2010/11/01 02:35:25 mrg Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include <sys/time.h>
 #include <sys/buf.h>
 #include "rf_raid.h"
 #include "rf_mcpair.h"
 #include "rf_acctrace.h"
 #include "rf_etimer.h"
 #include "rf_general.h"
 #include "rf_utils.h"
 #include "rf_copyback.h"
 #include "rf_decluster.h"
 @@ -203,26 +203,27 @@ rf_CopybackReconstructedData(RF_Raid_t *
 	RF_GETTIME(desc->starttime);
 	rf_ContinueCopyback(desc);
 	/* Data has been restored.  Fix up the component label. */
 	/* Don't actually need the read here.. */
 	c_label = raidget_component_label(raidPtr, fcol);
 	raid_init_component_label(raidPtr, c_label);
 	c_label->row = 0;
 	c_label->column = fcol;
 	c_label->partitionSize = raidPtr->Disks[fcol].partitionSize;
 	c_label->partitionSizeHi = raidPtr->Disks[fcol].partitionSize >> 32;
 	raidflush_component_label(raidPtr, fcol);
 	/* XXXjld why is this here? */
 	rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
+}
 /*
  * invoked via callback after a copyback I/O has completed to
  * continue on with the next one
  */
 void

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_disks.c,v 1.73 2010/03/01 21:10:26 jld Exp $	*/
+/*	$NetBSD: rf_disks.c,v 1.74 2010/11/01 02:35:25 mrg Exp $	*/
 /*-
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster
+ *
  * 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
 @@ -50,27 +50,27 @@
  *  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_disks.c -- code to perform operations on the actual disks
  ***************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_disks.c,v 1.73 2010/03/01 21:10:26 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_disks.c,v 1.74 2010/11/01 02:35:25 mrg Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include "rf_raid.h"
 #include "rf_alloclist.h"
 #include "rf_utils.h"
 #include "rf_general.h"
 #include "rf_options.h"
 #include "rf_kintf.h"
 #include "rf_netbsd.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 @@ -445,26 +445,28 @@ rf_AutoConfigureDisks(RF_Raid_t *raidPtr
 					break;
+				}
 				ac=ac->next;
+			}
+		}
 		if (ac!=NULL) {
 			/* Found it.  Configure it.. */
 			diskPtr->blockSize = ac->clabel->blockSize;
 			diskPtr->numBlocks = ac->clabel->numBlocks;
 			diskPtr->numBlocks |=
 			    (uint64_t)ac->clabel->numBlocksHi << 32;
 			/* Note: rf_protectedSectors is already
 			   factored into numBlocks here */
 			raidPtr->raid_cinfo[c].ci_vp = ac->vp;
 			raidPtr->raid_cinfo[c].ci_dev = ac->dev;
 			memcpy(raidget_component_label(raidPtr, c),
 			    ac->clabel, sizeof(*ac->clabel));
 			snprintf(diskPtr->devname, sizeof(diskPtr->devname),
 			    "/dev/%s", ac->devname);
 			/* note the fact that this component was
 			   autoconfigured.  You'll need this info
 			   later.  Trust me :) */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.274 2010/08/08 18:25:14 chs Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.275 2010/11/01 02:35:25 mrg 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
 @@ -129,27 +129,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.274 2010/08/08 18:25:14 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.275 2010/11/01 02:35:25 mrg 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>
 @@ -1926,26 +1926,27 @@ raidinit(RF_Raid_t *raidPtr)
 		printf("raid%d: config_attach_pseudo failed\n",
 		    raidPtr->raidid);
 		rs->sc_flags &= ~RAIDF_INITED;
 		free(cf, M_RAIDFRAME);
 		return;
+	}
 	/* disk_attach actually creates space for the CPU disklabel, among
 	 * other things, so it's critical to call this *BEFORE* we try putzing
 	 * with disklabels. */
 	disk_init(&rs->sc_dkdev, rs->sc_xname, &rf_dkdriver);
 	disk_attach(&rs->sc_dkdev);
 	disk_blocksize(&rs->sc_dkdev, raidPtr->bytesPerSector);
 	/* XXX There may be a weird interaction here between this, and
 	 * protectedSectors, as used in RAIDframe.  */
 	rs->sc_size = raidPtr->totalSectors;
 	dkwedge_discover(&rs->sc_dkdev);
 	rf_set_properties(rs, raidPtr);
+}
 #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0)
 /* wake up the daemon & tell it to get us a spare table
 @@ -2021,27 +2022,27 @@ raidstart(RF_Raid_t *raidPtr)
 	while (raidPtr->openings > 0) {
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 		/* get the next item, if any, from the queue */
 		if ((bp = bufq_get(rs->buf_queue)) == NULL) {
 			/* nothing more to do */
 			return;
+		}
 		/* Ok, for the bp we have here, bp->b_blkno is relative to the
 		 * partition.. Need to make it absolute to the underlying
 		 * device.. */
-		blocknum = bp->b_blkno;
+		blocknum = bp->b_blkno << DEV_BSHIFT >> raidPtr->logBytesPerSector;
 		if (DISKPART(bp->b_dev) != RAW_PART) {
 			pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
 			blocknum += pp->p_offset;
+		}
 		db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno,
 			    (int) blocknum));
 		db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
 		db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
 		/* *THIS* is where we adjust what block we're going to...
 		 * but DO NOT TOUCH bp->b_blkno!!! */
 @@ -2273,27 +2274,27 @@ InitBP(struct buf *bp, struct vnode *b_v
        RF_SectorNum_t startSect, RF_SectorCount_t numSect, void *bf,
        void (*cbFunc) (struct buf *), void *cbArg, int logBytesPerSector,
        struct proc *b_proc)
+{
 	/* bp->b_flags       = B_PHYS | rw_flag; */
 	bp->b_flags = rw_flag;	/* XXX need B_PHYS here too??? */
 	bp->b_oflags = 0;
 	bp->b_cflags = 0;
 	bp->b_bcount = numSect << logBytesPerSector;
 	bp->b_bufsize = bp->b_bcount;
 	bp->b_error = 0;
 	bp->b_dev = dev;
 	bp->b_data = bf;
-	bp->b_blkno = startSect;
+	bp->b_blkno = startSect << logBytesPerSector >> DEV_BSHIFT;
 	bp->b_resid = bp->b_bcount;	/* XXX is this right!??!?!! */
 	if (bp->b_bcount == 0) {
 		panic("bp->b_bcount is zero in InitBP!!");
+	}
 	bp->b_proc = b_proc;
 	bp->b_iodone = cbFunc;
 	bp->b_private = cbArg;
+}
 static void
 raidgetdefaultlabel(RF_Raid_t *raidPtr, struct raid_softc *rs,
 		    struct disklabel *lp)
+{
 @@ -3126,39 +3127,42 @@ rf_reasonable_label(RF_ComponentLabel_t
 	    clabel->blockSize > 0 &&
 	    clabel->numBlocks > 0) {
 		/* label looks reasonable enough... */
 		return(1);
+	}
 	return(0);
+}
 #ifdef DEBUG
 void
 rf_print_component_label(RF_ComponentLabel_t *clabel)
+{
 	uint64_t numBlocks = clabel->numBlocks;
 	numBlocks |= (uint64_t)clabel->numBlocksHi << 32;
 	printf("   Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
 	       clabel->row, clabel->column,
 	       clabel->num_rows, clabel->num_columns);
 	printf("   Version: %d Serial Number: %d Mod Counter: %d\n",
 	       clabel->version, clabel->serial_number,
 	       clabel->mod_counter);
 	printf("   Clean: %s Status: %d\n",
 	       clabel->clean ? "Yes" : "No", clabel->status);
 	printf("   sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
 	       clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
-	printf("   RAID Level: %c  blocksize: %d numBlocks: %d\n",
+	printf("   RAID Level: %c  blocksize: %d numBlocks: %"PRIu64"\n",
-	       (char) clabel->parityConfig, clabel->blockSize,
+	       (char) clabel->parityConfig, clabel->blockSize, numBlocks);
 	       clabel->numBlocks);
 	printf("   Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No");
 	printf("   Contains root partition: %s\n",
 	       clabel->root_partition ? "Yes" : "No");
 	printf("   Last configured as: raid%d\n", clabel->last_unit);
 #if 0
 	   printf("   Config order: %d\n", clabel->config_order);
 #endif
+}
 #endif
 RF_ConfigSet_t *
 rf_create_auto_sets(RF_AutoConfig_t *ac_list)
 @@ -3259,26 +3263,27 @@ rf_does_it_fit(RF_ConfigSet_t *cset, RF_
 	clabel1 = cset->ac->clabel;
 	clabel2 = ac->clabel;
 	if ((clabel1->version == clabel2->version) &&
 	    (clabel1->serial_number == clabel2->serial_number) &&
 	    (clabel1->num_rows == clabel2->num_rows) &&
 	    (clabel1->num_columns == clabel2->num_columns) &&
 	    (clabel1->sectPerSU == clabel2->sectPerSU) &&
 	    (clabel1->SUsPerPU == clabel2->SUsPerPU) &&
 	    (clabel1->SUsPerRU == clabel2->SUsPerRU) &&
 	    (clabel1->parityConfig == clabel2->parityConfig) &&
 	    (clabel1->maxOutstanding == clabel2->maxOutstanding) &&
 	    (clabel1->blockSize == clabel2->blockSize) &&
 	    (clabel1->numBlocks == clabel2->numBlocks) &&
 	    (clabel1->numBlocksHi == clabel2->numBlocksHi) &&
 	    (clabel1->autoconfigure == clabel2->autoconfigure) &&
 	    (clabel1->root_partition == clabel2->root_partition) &&
 	    (clabel1->last_unit == clabel2->last_unit) &&
 	    (clabel1->config_order == clabel2->config_order)) {
 		/* if it get's here, it almost *has* to be a match */
 	} else {
 		/* it's not consistent with somebody in the set..
 		   punt */
 		return(0);
+	}
 	/* all was fine.. it must fit... */
 	return(1);
+}
 @@ -3523,26 +3528,27 @@ raid_init_component_label(RF_Raid_t *rai
 	clabel->mod_counter = raidPtr->mod_counter;
 	clabel->num_rows = 1;
 	clabel->num_columns = raidPtr->numCol;
 	clabel->clean = RF_RAID_DIRTY; /* not clean */
 	clabel->status = rf_ds_optimal; /* "It's good!" */
 	clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
 	clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
 	clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
 	clabel->blockSize = raidPtr->bytesPerSector;
 	clabel->numBlocks = raidPtr->sectorsPerDisk;
 	clabel->numBlocksHi = raidPtr->sectorsPerDisk >> 32;
 	/* XXX not portable */
 	clabel->parityConfig = raidPtr->Layout.map->parityConfig;
 	clabel->maxOutstanding = raidPtr->maxOutstanding;
 	clabel->autoconfigure = raidPtr->autoconfigure;
 	clabel->root_partition = raidPtr->root_partition;
 	clabel->last_unit = raidPtr->raidid;
 	clabel->config_order = raidPtr->config_order;
 #ifndef RF_NO_PARITY_MAP
 	rf_paritymap_init_label(raidPtr->parity_map, clabel);
 #endif
+}
 @@ -3681,43 +3687,35 @@ rf_buf_queue_check(int raidid)
+{
 	if ((bufq_peek(raid_softc[raidid].buf_queue) != NULL) &&
 	    raidPtrs[raidid]->openings > 0) {
 		/* there is work to do */
 		return 0;
+	}
 	/* default is nothing to do */
 	return 1;
+}
 int
 rf_getdisksize(struct vnode *vp, struct lwp *l, RF_RaidDisk_t *diskPtr)
+{
-	struct partinfo dpart;
+	uint64_t numsecs;
-	struct dkwedge_info dkw;
+	unsigned secsize;
 	int error;
-	error = VOP_IOCTL(vp, DIOCGPART, &dpart, FREAD, l->l_cred);
+	error = getdisksize(vp, &numsecs, &secsize);
 	if (error == 0) {
 		diskPtr->blockSize = dpart.disklab->d_secsize;
 		diskPtr->numBlocks = dpart.part->p_size - rf_protectedSectors;
 		diskPtr->partitionSize = dpart.part->p_size;
 		return 0;
 	error = VOP_IOCTL(vp, DIOCGWEDGEINFO, &dkw, FREAD, l->l_cred);
 	if (error == 0) {
-		diskPtr->blockSize = 512;	/* XXX */
+		diskPtr->blockSize = secsize;
-		diskPtr->numBlocks = dkw.dkw_size - rf_protectedSectors;
+		diskPtr->numBlocks = numsecs - rf_protectedSectors;
-		diskPtr->partitionSize = dkw.dkw_size;
+		diskPtr->partitionSize = numsecs;
 		return 0;
+	}
 	return error;
+}
 static int
 raid_match(device_t self, cfdata_t cfdata, void *aux)
+{
 	return 1;
+}
 static void
 raid_attach(device_t parent, device_t self, void *aux)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_reconstruct.c,v 1.108 2009/11/17 18:54:26 jld Exp $	*/
+/*	$NetBSD: rf_reconstruct.c,v 1.109 2010/11/01 02:35:25 mrg Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland
+ *
  * 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"
 @@ -23,27 +23,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /************************************************************
+ *
  * rf_reconstruct.c -- code to perform on-line reconstruction
+ *
  ************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.108 2009/11/17 18:54:26 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.109 2010/11/01 02:35:25 mrg Exp $");
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/buf.h>
 #include <sys/errno.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <dev/raidframe/raidframevar.h>
 #include "rf_raid.h"
 @@ -287,26 +287,28 @@ rf_ReconstructFailedDiskBasic(RF_Raid_t
 	rc = rf_ContinueReconstructFailedDisk(reconDesc);
 	if (!rc) {
 		/* fix up the component label */
 		/* Don't actually need the read here.. */
 		c_label = raidget_component_label(raidPtr, scol);
 		raid_init_component_label(raidPtr, c_label);
 		c_label->row = 0;
 		c_label->column = col;
 		c_label->clean = RF_RAID_DIRTY;
 		c_label->status = rf_ds_optimal;
 		c_label->partitionSize = raidPtr->Disks[scol].partitionSize;
 		c_label->partitionSizeHi =
 		   raidPtr->Disks[scol].partitionSize >> 32;
 		/* We've just done a rebuild based on all the other
 		   disks, so at this point the parity is known to be
 		   clean, even if it wasn't before. */
 		/* XXX doesn't hold for RAID 6!!*/
 		RF_LOCK_MUTEX(raidPtr->mutex);
 		raidPtr->parity_good = RF_RAID_CLEAN;
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 		/* XXXX MORE NEEDED HERE */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: raidframevar.h,v 1.13 2009/11/17 18:54:26 jld Exp $ */
+/*	$NetBSD: raidframevar.h,v 1.14 2010/11/01 02:35:24 mrg Exp $ */
 /*-
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster
+ *
  * 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
 @@ -461,27 +461,29 @@ typedef struct RF_ComponentLabel_s {
 	int autoconfigure;    /* automatically configure this RAID set.
 == no, 1 == yes */
 	int root_partition;   /* Use this set as /
 == no, 1 == yes*/
 	int last_unit;        /* last unit number (e.g. 0 for /dev/raid0)
 				 of this component.  Used for autoconfigure
 				 only. */
 	int config_order;     /* 0 .. n.  The order in which the component
 				 should be auto-configured.  E.g. 0 is will
 				 done first, (and would become raid0).
 				 This may be in conflict with last_unit!!?! */
 	                      /* Not currently used. */
-	int future_use2[44];  /* More future expansion */
+	u_int numBlocksHi;    /* The top 32-bits of the numBlocks member. */
 	u_int partitionSizeHi;/* The top 32-bits of the partitionSize member. */
 	int future_use2[42];  /* More future expansion */
 } RF_ComponentLabel_t;
 typedef struct RF_SingleComponent_s {
 	int row;
 	int column;
 	char component_name[50]; /* name of the component */
 } RF_SingleComponent_t;
 typedef struct RF_DeviceConfig_s {
 	u_int   rows;
 	u_int   cols;
 	u_int   maxqdepth;
 	int     ndevs;