 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_driver.c,v 1.122 2009/11/17 18:54:26 jld Exp $	*/
+/*	$NetBSD: rf_driver.c,v 1.123 2011/04/23 06:29:05 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
 @@ -56,27 +56,27 @@
  * rights to redistribute these changes.
  */
 /******************************************************************************
+ *
  * rf_driver.c -- main setup, teardown, and access routines for the RAID driver
+ *
  * all routines are prefixed with rf_ (raidframe), to avoid conficts.
+ *
  ******************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.122 2009/11/17 18:54:26 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.123 2011/04/23 06:29:05 mrg Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_raid_diagnostic.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include "rf_archs.h"
 @@ -230,26 +230,29 @@ rf_Shutdown(RF_Raid_t *raidPtr)
 		       raidPtr->raidid);
 		tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO,
 		       "rfprwshutdown", 0);
+	}
 	/* Wait for any reconstruction to stop... */
 	while (raidPtr->reconInProgress) {
 		printf("raid%d: Waiting for reconstruction to stop...\n",
 		       raidPtr->raidid);
 		tsleep(&raidPtr->waitForReconCond, PRIBIO,
 		       "rfreshutdown",0);
+	}
 	mutex_destroy(&raidPtr->iodone_lock);
 	cv_destroy(&raidPtr->iodone_cv);
 	raidPtr->valid = 0;
 	if (raidPtr->parity_map != NULL)
 		rf_paritymap_detach(raidPtr);
 	rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE);
 	rf_UnconfigureVnodes(raidPtr);
 	rf_FreeEmergBuffers(raidPtr);
 	rf_ShutdownList(&raidPtr->shutdownList);
 @@ -341,27 +344,28 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Conf
 		return (ENOMEM);
+	}
 	rf_ShutdownCreate(&raidPtr->shutdownList,
 			  (void (*) (void *)) rf_FreeAllocList,
 			  raidPtr->cleanupList);
 	raidPtr->numCol = cfgPtr->numCol;
 	raidPtr->numSpare = cfgPtr->numSpare;
 	raidPtr->status = rf_rs_optimal;
 	raidPtr->reconControl = NULL;
 	TAILQ_INIT(&(raidPtr->iodone));
-	simple_lock_init(&(raidPtr->iodone_lock));
+	mutex_init(&raidPtr->iodone_lock, MUTEX_DEFAULT, IPL_VM);
 	cv_init(&raidPtr->iodone_cv, "raidiow");
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
 	raidPtr->outstandingCond = 0;
 	raidPtr->nAccOutstanding = 0;
 	raidPtr->waitShutdown = 0;
 	DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
 	raidPtr->waitForReconCond = 0;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_engine.c,v 1.41 2010/09/13 08:43:06 drochner Exp $	*/
+/*	$NetBSD: rf_engine.c,v 1.42 2011/04/23 06:29:05 mrg Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: William V. Courtright II, Mark Holland, Rachad Youssef
+ *
  * 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"
 @@ -45,27 +45,27 @@
  *   Terminator nodes are never fired, but rather cause the callback        *
  *   associated with the DAG to be invoked.                                 *
  *                                                                          *
  *   If a node fails, the dag either rolls forward to the completion or     *
  *   rolls back, undoing previously-completed nodes and fails atomically.   *
  *   The direction of recovery is determined by the location of the failed  *
  *   node in the graph.  If the failure occurred before the commit node in   *
  *   the graph, backward recovery is used.  Otherwise, forward recovery is  *
  *   used.                                                                  *
  *                                                                          *
  ****************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_engine.c,v 1.41 2010/09/13 08:43:06 drochner Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_engine.c,v 1.42 2011/04/23 06:29:05 mrg Exp $");
 #include <sys/errno.h>
 #include "rf_threadstuff.h"
 #include "rf_dag.h"
 #include "rf_engine.h"
 #include "rf_etimer.h"
 #include "rf_general.h"
 #include "rf_dagutils.h"
 #include "rf_shutdown.h"
 #include "rf_raid.h"
 #include "rf_kintf.h"
 #include "rf_paritymap.h"
 @@ -93,37 +93,36 @@ do { \
 #define	DO_SIGNAL(_r_) \
 	RF_BROADCAST_COND((_r_)->node_queue)	/* XXX RF_SIGNAL_COND? */
 static void
 rf_ShutdownEngine(void *arg)
+{
 	RF_Raid_t *raidPtr;
 	int ks;
 	raidPtr = (RF_Raid_t *) arg;
 	/* Tell the rf_RaidIOThread to shutdown */
-	simple_lock(&(raidPtr->iodone_lock));
+	mutex_enter(&raidPtr->iodone_lock);
 	raidPtr->shutdown_raidio = 1;
-	wakeup(&(raidPtr->iodone));
+	cv_signal(&raidPtr->iodone_cv);
 	/* ...and wait for it to tell us it has finished */
 	while (raidPtr->shutdown_raidio)
- 		ltsleep(&(raidPtr->shutdown_raidio), PRIBIO, "raidshutdown", 0,
+		cv_wait(&raidPtr->iodone_cv, &raidPtr->iodone_lock);
 			&(raidPtr->iodone_lock));
-	simple_unlock(&(raidPtr->iodone_lock));
+	mutex_exit(&raidPtr->iodone_lock);
  	/* Now shut down the DAG execution engine. */
  	DO_LOCK(raidPtr);
   	raidPtr->shutdown_engine = 1;
   	DO_SIGNAL(raidPtr);
  	DO_UNLOCK(raidPtr);
+}
 int
 rf_ConfigureEngine(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
 		   RF_Config_t *cfgPtr)
+{
 @@ -838,55 +837,54 @@ DAGExecutionThread(RF_ThreadArg_t arg)
  * request, and by calling any required CompleteFunc for the request.
  */
 static void
 rf_RaidIOThread(RF_ThreadArg_t arg)
+{
 	RF_Raid_t *raidPtr;
 	RF_DiskQueueData_t *req;
 	int s;
 	raidPtr = (RF_Raid_t *) arg;
 	s = splbio();
-	simple_lock(&(raidPtr->iodone_lock));
+	mutex_enter(&raidPtr->iodone_lock);
 	while (!raidPtr->shutdown_raidio) {
 		/* if there is nothing to do, then snooze. */
 		if (TAILQ_EMPTY(&(raidPtr->iodone)) &&
 		    rf_buf_queue_check(raidPtr->raidid)) {
-			ltsleep(&(raidPtr->iodone), PRIBIO, "raidiow", 0,
+			cv_wait(&raidPtr->iodone_cv, &raidPtr->iodone_lock);
 				&(raidPtr->iodone_lock));
+		}
 		/* Check for deferred parity-map-related work. */
 		if (raidPtr->parity_map != NULL) {
-			simple_unlock(&(raidPtr->iodone_lock));
+			mutex_exit(&raidPtr->iodone_lock);
 			rf_paritymap_checkwork(raidPtr->parity_map);
-			simple_lock(&(raidPtr->iodone_lock));
+			mutex_enter(&raidPtr->iodone_lock);
+		}
 		/* See what I/Os, if any, have arrived */
 		while ((req = TAILQ_FIRST(&(raidPtr->iodone))) != NULL) {
 			TAILQ_REMOVE(&(raidPtr->iodone), req, iodone_entries);
-			simple_unlock(&(raidPtr->iodone_lock));
+			mutex_exit(&raidPtr->iodone_lock);
 			rf_DiskIOComplete(req->queue, req, req->error);
 			(req->CompleteFunc) (req->argument, req->error);
-			simple_lock(&(raidPtr->iodone_lock));
+			mutex_enter(&raidPtr->iodone_lock);
+		}
 		/* process any pending outgoing IO */
-		simple_unlock(&(raidPtr->iodone_lock));
+		mutex_exit(&raidPtr->iodone_lock);
 		raidstart(raidPtr);
-		simple_lock(&(raidPtr->iodone_lock));
+		mutex_enter(&raidPtr->iodone_lock);
+	}
 	/* Let rf_ShutdownEngine know that we're done... */
 	raidPtr->shutdown_raidio = 0;
-	wakeup(&(raidPtr->shutdown_raidio));
+	cv_signal(&raidPtr->iodone_cv);
-	simple_unlock(&(raidPtr->iodone_lock));
+	mutex_exit(&raidPtr->iodone_lock);
 	splx(s);
 	kthread_exit(0);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.284 2011/03/18 23:53:26 mrg Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.285 2011/04/23 06:29:05 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.
 @@ -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.284 2011/03/18 23:53:26 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.285 2011/04/23 06:29:05 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>
 @@ -819,28 +819,26 @@ raidclose(dev_t dev, int flags, int fmt,
 		/* 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;
+	}
 @@ -870,37 +868,38 @@ raidstrategy(struct buf *bp)
 			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();
 	mutex_enter(&raidPtr->iodone_lock);
 	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));
+	cv_signal(&raidPtr->iodone_cv);
 	mutex_exit(&raidPtr->iodone_lock);
 	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;
 @@ -2150,34 +2149,35 @@ rf_DispatchKernelIO(RF_DiskQueue_t *queu
+	}
 	db1_printf(("Exiting from DispatchKernelIO\n"));
 	return (0);
+}
 /* this is the callback function associated with a I/O invoked from
    kernel code.
  */
 static void
 KernelWakeupFunc(struct buf *bp)
+{
 	RF_DiskQueueData_t *req = NULL;
 	RF_DiskQueue_t *queue;
 	int s;
 	s = splbio();
 	db1_printf(("recovering the request queue:\n"));
 	req = bp->b_private;
 	queue = (RF_DiskQueue_t *) req->queue;
 	mutex_enter(&queue->raidPtr->iodone_lock);
 #if RF_ACC_TRACE > 0
 	if (req->tracerec) {
 		RF_ETIMER_STOP(req->tracerec->timer);
 		RF_ETIMER_EVAL(req->tracerec->timer);
 		RF_LOCK_MUTEX(rf_tracing_mutex);
 		req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer);
 		req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer);
 		req->tracerec->num_phys_ios++;
 		RF_UNLOCK_MUTEX(rf_tracing_mutex);
+	}
 #endif
 	/* XXX Ok, let's get aggressive... If b_error is set, let's go
 @@ -2199,44 +2199,38 @@ KernelWakeupFunc(struct buf *bp)
 			       queue->raidPtr->Disks[queue->col].devname);
 			queue->raidPtr->Disks[queue->col].status =
 			    rf_ds_failed;
 			queue->raidPtr->status = rf_rs_degraded;
 			queue->raidPtr->numFailures++;
 			queue->raidPtr->numNewFailures++;
 		} else {	/* Disk is already dead... */
 			/* printf("Disk already marked as dead!\n"); */
+		}
+	}
 	/* Fill in the error value */
 	req->error = bp->b_error;
 	simple_lock(&queue->raidPtr->iodone_lock);
 	/* Drop this one on the "finished" queue... */
 	TAILQ_INSERT_TAIL(&(queue->raidPtr->iodone), req, iodone_entries);
 	/* Let the raidio thread know there is work to be done. */
-	wakeup(&(queue->raidPtr->iodone));
+	cv_signal(&queue->raidPtr->iodone_cv);
-	simple_unlock(&queue->raidPtr->iodone_lock);
+	mutex_exit(&queue->raidPtr->iodone_lock);
 	splx(s);
+}
 /*
  * initialize a buf structure for doing an I/O in the kernel.
  */
 static void
 InitBP(struct buf *bp, struct vnode *b_vp, unsigned rw_flag, dev_t dev,
        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;

 @@ -1,14 +1,14 @@
-/* $NetBSD: rf_paritymap.c,v 1.6 2011/03/01 22:51:14 riz Exp $ */
+/* $NetBSD: rf_paritymap.c,v 1.7 2011/04/23 06:29:05 mrg Exp $ */
 /*-
  * Copyright (c) 2009 Jed Davis.
  * 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.
 @@ -17,27 +17,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_paritymap.c,v 1.6 2011/03/01 22:51:14 riz Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_paritymap.c,v 1.7 2011/04/23 06:29:05 mrg Exp $");
 #include <sys/param.h>
 #include <sys/callout.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/rwlock.h>
 #include <sys/systm.h>
 #include <sys/types.h>
 #include <dev/raidframe/rf_paritymap.h>
 #include <dev/raidframe/rf_stripelocks.h>
 #include <dev/raidframe/rf_layout.h>
 #include <dev/raidframe/rf_raid.h>
 @@ -249,27 +249,30 @@ rf_paritymap_forceclean(struct rf_parity
 /*
  * The cooldown callout routine just defers its work to a thread; it can't do
  * the parity map write itself as it would block, and although mutex-induced
  * blocking is permitted it seems wise to avoid tying up the softint.
  */
 static void
 rf_paritymap_tick(void *arg)
+{
 	struct rf_paritymap *pm = arg;
 	mutex_enter(&pm->lk_flags);
 	pm->flags |= TICKED;
 	mutex_exit(&pm->lk_flags);
 	wakeup(&(pm->raid->iodone)); /* XXX */
 	mutex_enter(&pm->raid->iodone_lock);
 	cv_signal(&pm->raid->iodone_cv); /* XXX */
 	mutex_exit(&pm->raid->iodone_lock);
+}
 /*
  * This is where the parity cooling work (and rearming the callout if needed)
  * is done; the raidio thread calls it when woken up, as by the above.
  */
 void
 rf_paritymap_checkwork(struct rf_paritymap *pm)
+{
 	int i, zerop, progressp;
 	mutex_enter(&pm->lk_flags);
 	if (pm->flags & TICKED) {
 @@ -572,30 +575,30 @@ rf_paritymap_merge(struct rf_paritymap_o
+}
 /*
  * Detach a parity map from its RAID.  This is not meant to be applied except
  * when unconfiguring the RAID after all I/O has been resolved, as otherwise
  * an out-of-date parity map could be treated as current.
  */
 void
 rf_paritymap_detach(RF_Raid_t *raidPtr)
+{
 	if (raidPtr->parity_map == NULL)
 		return;
-	simple_lock(&(raidPtr->iodone_lock));
+	mutex_enter(&raidPtr->iodone_lock);
 	struct rf_paritymap *pm = raidPtr->parity_map;
 	raidPtr->parity_map = NULL;
-	simple_unlock(&(raidPtr->iodone_lock));
+	mutex_exit(&raidPtr->iodone_lock);
 	/* XXXjld is that enough locking?  Or too much? */
 	rf_paritymap_destroy(pm, 0);
 	kmem_free(pm, sizeof(*pm));
+}
 /*
  * Is this RAID set ineligible for parity-map use due to not actually
  * having any parity?  (If so, rf_paritymap_attach is a no-op, but
  * rf_paritymap_{get,set}_disable will still pointlessly act on the
  * component labels.)
  */
 int
 rf_paritymap_ineligible(RF_Raid_t *raidPtr)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_raid.h,v 1.38 2009/11/17 18:54:26 jld Exp $	*/
+/*	$NetBSD: rf_raid.h,v 1.39 2011/04/23 06:29:05 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"
 @@ -151,28 +151,29 @@ struct RF_Raid_s {
 	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. */
 	/* queue to gather up requests from KernelWakeupFunc() and let
 	   a kernel thread deal with calling rf_DiskIOComplete and any
 	   callback functions. */
 	TAILQ_HEAD(iodone_q,RF_DiskQueueData_s) iodone;
-	/* and a lock to protect it */
+	/* and a lock/cv to protect it */
-	struct simplelock iodone_lock;
+	kmutex_t iodone_lock;
 	kcondvar_t iodone_cv;
 	RF_VoidPointerListElem_t *iobuf;       /* I/O buffer free list */
 	int iobuf_count;             /* count of I/O buffers on the freelist */
 	int numEmergencyBuffers;     /* number of these buffers to pre-allocate */
 	RF_VoidPointerListElem_t *stripebuf;   /* Full-stripe buffer free list */
 	int stripebuf_count;           /* count of full-stripe buffers on the freelist */
 	int numEmergencyStripeBuffers; /* number of these buffers to pre-allocate */
 	/*
          * Cleanup stuff
          */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_states.c,v 1.44 2009/11/17 18:54:26 jld Exp $	*/
+/*	$NetBSD: rf_states.c,v 1.45 2011/04/23 06:29:05 mrg Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland, William V. Courtright II, Robby Findler
+ *
  * 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"
 @@ -17,27 +17,27 @@
+ *
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.44 2009/11/17 18:54:26 jld Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.45 2011/04/23 06:29:05 mrg Exp $");
 #include <sys/errno.h>
 #include "rf_archs.h"
 #include "rf_threadstuff.h"
 #include "rf_raid.h"
 #include "rf_dag.h"
 #include "rf_desc.h"
 #include "rf_aselect.h"
 #include "rf_general.h"
 #include "rf_states.h"
 #include "rf_dagutils.h"
 #include "rf_driver.h"
 @@ -226,27 +226,29 @@ rf_State_LastState(RF_RaidAccessDesc_t *
 	 * That's all the IO for this one... unbusy the 'disk'.
 	 */
 	rf_disk_unbusy(desc);
 	/*
 	 * Wakeup any requests waiting to go.
 	 */
 	RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
 	((RF_Raid_t *) desc->raidPtr)->openings++;
 	RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
-	wakeup(&(desc->raidPtr->iodone));
+	mutex_enter(&desc->raidPtr->iodone_lock);
 	cv_signal(&desc->raidPtr->iodone_cv);
 	mutex_exit(&desc->raidPtr->iodone_lock);
 	/*
 	 * The parity_map hook has to go here, because the iodone
 	 * callback goes straight into the kintf layer.
 	 */
 	if (desc->raidPtr->parity_map != NULL &&
 	    desc->type == RF_IO_TYPE_WRITE)
 		rf_paritymap_end(desc->raidPtr->parity_map,
 		    desc->raidAddress, desc->numBlocks);
 	/* printf("Calling biodone on 0x%x\n",desc->bp); */
 	biodone(desc->bp);	/* access came through ioctl */