 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_driver.c,v 1.126 2011/04/30 01:44:36 mrg Exp $	*/
+/*	$NetBSD: rf_driver.c,v 1.127 2011/05/05 07:12:58 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.126 2011/04/30 01:44:36 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.127 2011/05/05 07:12:58 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"
 @@ -126,30 +126,31 @@ char    rf_panicbuf[2048];	/* a buffer t
 /* main configuration routines */
 static int raidframe_booted = 0;
 static void rf_ConfigureDebug(RF_Config_t * cfgPtr);
 static void set_debug_option(char *name, long val);
 static void rf_UnconfigureArray(void);
 static void rf_ShutdownRDFreeList(void *);
 static int rf_ConfigureRDFreeList(RF_ShutdownList_t **);
 rf_declare_mutex2(rf_printf_mutex);	/* debug only:  avoids interleaved
 					 * printfs by different stripes */
-#define SIGNAL_QUIESCENT_COND(_raid_)  wakeup(&((_raid_)->accesses_suspended))
+#define SIGNAL_QUIESCENT_COND(_raid_) \
 	rf_broadcast_cond2((_raid_)->access_suspend_cv)
 #define WAIT_FOR_QUIESCENCE(_raid_) \
-	ltsleep(&((_raid_)->accesses_suspended), PRIBIO, \
+	rf_wait_cond2((_raid_)->access_suspend_cv, \
-		"raidframe quiesce", 0, &((_raid_)->access_suspend_mutex))
+		      (_raid_)->access_suspend_mutex)
 static int configureCount = 0;	/* number of active configurations */
 static int isconfigged = 0;	/* is basic raidframe (non per-array)
 				 * stuff configured */
 static rf_declare_mutex2(configureMutex); /* used to lock the configuration
 					   * stuff */
 static RF_ShutdownList_t *globalShutdown;	/* non array-specific
 						 * stuff */
 static int rf_ConfigureRDFreeList(RF_ShutdownList_t ** listp);
 static int rf_AllocEmergBuffers(RF_Raid_t *);
 static void rf_FreeEmergBuffers(RF_Raid_t *);
 @@ -242,26 +243,29 @@ rf_Shutdown(RF_Raid_t *raidPtr)
 	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);
 	rf_destroy_mutex2(raidPtr->access_suspend_mutex);
 	rf_destroy_cond2(raidPtr->access_suspend_cv);
 	rf_destroy_cond2(raidPtr->outstandingCond);
 	rf_destroy_mutex2(raidPtr->rad_lock);
 	rf_UnconfigureArray();
 	return (0);
+}
 #define DO_INIT_CONFIGURE(f) { \
 	rc = f (&globalShutdown); \
 	if (rc) { \
 		RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \
 @@ -278,30 +282,26 @@ rf_Shutdown(RF_Raid_t *raidPtr)
 	rf_ShutdownList(&raidPtr->shutdownList); \
 	rf_UnconfigureArray(); \
+}
 #define DO_RAID_INIT_CONFIGURE(f) { \
 	rc = f (&raidPtr->shutdownList, raidPtr, cfgPtr); \
 	if (rc) { \
 		RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \
 		DO_RAID_FAIL(); \
 		return(rc); \
 	} \
+}
 #define DO_RAID_MUTEX(_m_) { \
 	rf_mutex_init((_m_)); \
 int
 rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
+{
 	RF_RowCol_t col;
 	int rc;
 	rf_lock_mutex2(configureMutex);
 	configureCount++;
 	if (isconfigged == 0) {
 		rf_init_mutex2(rf_printf_mutex, IPL_VM);
 		/* initialize globals */
 @@ -323,27 +323,27 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Conf
 		DO_INIT_CONFIGURE(rf_ConfigureNWayXor);
 		DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList);
 		DO_INIT_CONFIGURE(rf_ConfigureMCPair);
 		DO_INIT_CONFIGURE(rf_ConfigureDAGs);
 		DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs);
 		DO_INIT_CONFIGURE(rf_ConfigureReconstruction);
 		DO_INIT_CONFIGURE(rf_ConfigureCopyback);
 		DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem);
 		DO_INIT_CONFIGURE(rf_ConfigurePSStatus);
 		isconfigged = 1;
+	}
 	rf_unlock_mutex2(configureMutex);
-	DO_RAID_MUTEX(&raidPtr->mutex);
+	rf_mutex_init(&raidPtr->mutex);
 	/* set up the cleanup list.  Do this after ConfigureDebug so that
 	 * value of memDebug will be set */
 	rf_MakeAllocList(raidPtr->cleanupList);
 	if (raidPtr->cleanupList == NULL) {
 		DO_RAID_FAIL();
 		return (ENOMEM);
+	}
 	rf_ShutdownCreate(&raidPtr->shutdownList,
 			  (void (*) (void *)) rf_FreeAllocList,
 			  raidPtr->cleanupList);
 	raidPtr->numCol = cfgPtr->numCol;
 @@ -351,27 +351,28 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Conf
 	raidPtr->status = rf_rs_optimal;
 	raidPtr->reconControl = NULL;
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
 	rf_init_cond2(raidPtr->outstandingCond, "rfocond");
 	rf_init_mutex2(raidPtr->rad_lock, IPL_VM);
 	raidPtr->nAccOutstanding = 0;
 	raidPtr->waitShutdown = 0;
-	DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
+	rf_init_mutex2(raidPtr->access_suspend_mutex, IPL_VM);
 	rf_init_cond2(raidPtr->access_suspend_cv, "rfquiesce");
 	raidPtr->waitForReconCond = 0;
 	if (ac!=NULL) {
 		/* We have an AutoConfig structure..  Don't do the
 		   normal disk configuration... call the auto config
 		   stuff */
 		rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
 	} else {
 		DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks);
 		DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks);
+	}
 	/* do this after ConfigureDisks & ConfigureSpareDisks to be sure dev
 @@ -778,67 +779,67 @@ rf_SignalQuiescenceLock(RF_Raid_t *raidP
 	if (raidPtr->waiting_for_quiescence) {
 		SIGNAL_QUIESCENT_COND(raidPtr);
+	}
+}
 /* suspends all new requests to the array.  No effect on accesses that are in flight.  */
 int
 rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr)
+{
 #if RF_DEBUG_QUIESCE
 	if (rf_quiesceDebug)
 		printf("raid%d: Suspending new reqs\n", raidPtr->raidid);
 #endif
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	raidPtr->accesses_suspended++;
 	raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1;
 	if (raidPtr->waiting_for_quiescence) {
 		raidPtr->access_suspend_release = 0;
 		while (!raidPtr->access_suspend_release) {
 #if RF_DEBUG_QUIESCE
 			printf("raid%d: Suspending: Waiting for Quiescence\n",
 			       raidPtr->raidid);
 #endif
 			WAIT_FOR_QUIESCENCE(raidPtr);
 			raidPtr->waiting_for_quiescence = 0;
+		}
+	}
 #if RF_DEBUG_QUIESCE
 	printf("raid%d: Quiescence reached..\n", raidPtr->raidid);
 #endif
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	return (raidPtr->waiting_for_quiescence);
+}
 /* wake up everyone waiting for quiescence to be released */
 void
 rf_ResumeNewRequests(RF_Raid_t *raidPtr)
+{
 	RF_CallbackDesc_t *t, *cb;
 #if RF_DEBUG_QUIESCE
 	if (rf_quiesceDebug)
 		printf("raid%d: Resuming new requests\n", raidPtr->raidid);
 #endif
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	raidPtr->accesses_suspended--;
 	if (raidPtr->accesses_suspended == 0)
 		cb = raidPtr->quiesce_wait_list;
 	else
 		cb = NULL;
 	raidPtr->quiesce_wait_list = NULL;
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	while (cb) {
 		t = cb;
 		cb = cb->next;
 		(t->callbackFunc) (t->callbackArg);
 		rf_FreeCallbackDesc(t);
+	}
+}
 /*****************************************************************************************
+ *
  * debug routines
+ *
  ****************************************************************************************/

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_states.c,v 1.46 2011/04/27 07:55:15 mrg Exp $	*/
+/*	$NetBSD: rf_states.c,v 1.47 2011/05/05 07:12:58 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.46 2011/04/27 07:55:15 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.47 2011/05/05 07:12:58 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"
 @@ -257,47 +257,47 @@ rf_State_LastState(RF_RaidAccessDesc_t *
 	rf_FreeRaidAccDesc(desc);
 	return RF_FALSE;
+}
 int
 rf_State_IncrAccessCount(RF_RaidAccessDesc_t *desc)
+{
 	RF_Raid_t *raidPtr;
 	raidPtr = desc->raidPtr;
 	/* Bummer. We have to do this to be 100% safe w.r.t. the increment
 	 * below */
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	raidPtr->accs_in_flight++;	/* used to detect quiescence */
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	desc->state++;
 	return RF_FALSE;
+}
 int
 rf_State_DecrAccessCount(RF_RaidAccessDesc_t *desc)
+{
 	RF_Raid_t *raidPtr;
 	raidPtr = desc->raidPtr;
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	raidPtr->accs_in_flight--;
 	if (raidPtr->accesses_suspended && raidPtr->accs_in_flight == 0) {
 		rf_SignalQuiescenceLock(raidPtr);
+	}
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	desc->state++;
 	return RF_FALSE;
+}
 int
 rf_State_Quiesce(RF_RaidAccessDesc_t *desc)
+{
 #if RF_ACC_TRACE > 0
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
 	RF_Etimer_t timer;
 #endif
 	RF_CallbackDesc_t *cb;
 @@ -306,49 +306,49 @@ rf_State_Quiesce(RF_RaidAccessDesc_t *de
 	int need_cb, used_cb;
 	raidPtr = desc->raidPtr;
 #if RF_ACC_TRACE > 0
 	RF_ETIMER_START(timer);
 	RF_ETIMER_START(desc->timer);
 #endif
 	need_cb = 0;
 	used_cb = 0;
 	cb = NULL;
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	/* Do an initial check to see if we might need a callback structure */
 	if (raidPtr->accesses_suspended) {
 		need_cb = 1;
+	}
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	if (need_cb) {
 		/* create a callback if we might need it...
 		   and we likely do. */
 		cb = rf_AllocCallbackDesc();
+	}
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_lock_mutex2(raidPtr->access_suspend_mutex);
 	if (raidPtr->accesses_suspended) {
 		cb->callbackFunc = (void (*) (RF_CBParam_t)) rf_ContinueRaidAccess;
 		cb->callbackArg.p = (void *) desc;
 		cb->next = raidPtr->quiesce_wait_list;
 		raidPtr->quiesce_wait_list = cb;
 		suspended = RF_TRUE;
 		used_cb = 1;
+	}
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
+	rf_unlock_mutex2(raidPtr->access_suspend_mutex);
 	if ((need_cb == 1) && (used_cb == 0)) {
 		rf_FreeCallbackDesc(cb);
+	}
 #if RF_ACC_TRACE > 0
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->specific.user.suspend_ovhd_us += RF_ETIMER_VAL_US(timer);
 #endif
 #if RF_DEBUG_QUIESCE
 	if (suspended && rf_quiesceDebug)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_raid.h,v 1.41 2011/04/30 01:44:36 mrg Exp $	*/
+/*	$NetBSD: rf_raid.h,v 1.42 2011/05/05 07:12:58 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"
 @@ -185,27 +185,28 @@ struct RF_Raid_s {
          * Recon stuff
          */
 	RF_HeadSepLimit_t headSepLimit;
 	int     numFloatingReconBufs;
 	int     reconInProgress;
 	RF_DECLARE_COND(waitForReconCond)
 	RF_RaidReconDesc_t *reconDesc;	/* reconstruction descriptor */
 	RF_ReconCtrl_t *reconControl;	/* reconstruction control structure
 					 * pointers for each row in the array */
 	/*
          * Array-quiescence stuff
          */
-	RF_DECLARE_MUTEX(access_suspend_mutex)
+	rf_declare_mutex2(access_suspend_mutex);
 	rf_declare_cond2(access_suspend_cv);
 	RF_IoCount_t accesses_suspended;
 	RF_IoCount_t accs_in_flight;
 	int     access_suspend_release;
 	int     waiting_for_quiescence;
 	RF_CallbackDesc_t *quiesce_wait_list;
 	/*
          * Statistics
          */
 	RF_StripeCount_t     parity_rewrite_stripes_done;
 	RF_StripeCount_t     copyback_stripes_done;
 	int     recon_in_progress;