diff options
Diffstat (limited to 'sys/dev/raidframe')
| -rw-r--r-- | sys/dev/raidframe/rf_copyback.c | 12 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_dagutils.c | 20 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_disks.c | 27 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_driver.c | 33 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_engine.c | 6 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_map.c | 12 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_netbsdkintf.c | 44 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_paritylog.h | 4 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_raid.h | 10 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_reconstruct.c | 106 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_reconutil.c | 8 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_states.c | 10 | ||||
| -rw-r--r-- | sys/dev/raidframe/rf_threadstuff.h | 19 |
13 files changed, 153 insertions, 158 deletions
diff --git a/sys/dev/raidframe/rf_copyback.c b/sys/dev/raidframe/rf_copyback.c index 594d82d9b2c..33bc638fefa 100644 --- a/sys/dev/raidframe/rf_copyback.c +++ b/sys/dev/raidframe/rf_copyback.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_copyback.c,v 1.46 2011/05/01 01:09:05 mrg Exp $ */ +/* $NetBSD: rf_copyback.c,v 1.47 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -38,7 +38,7 @@ ****************************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_copyback.c,v 1.46 2011/05/01 01:09:05 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_copyback.c,v 1.47 2011/05/11 18:13:12 mrg Exp $"); #include <dev/raidframe/raidframevar.h> @@ -205,11 +205,11 @@ rf_CopybackReconstructedData(RF_Raid_t *raidPtr) rf_SuspendNewRequestsAndWait(raidPtr); /* adjust state of the array and of the disks */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->Disks[desc->fcol].status = rf_ds_optimal; raidPtr->status = rf_rs_optimal; rf_copyback_in_progress = 1; /* debug only */ - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); RF_GETTIME(desc->starttime); rf_ContinueCopyback(desc); @@ -404,14 +404,14 @@ rf_CopybackComplete(RF_CopybackDesc_t *desc, int status) struct timeval t, diff; if (!status) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) { RF_ASSERT(raidPtr->Layout.map->parityConfig == 'D'); rf_FreeSpareTable(raidPtr); } else { raidPtr->Disks[desc->spCol].status = rf_ds_spare; } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); RF_GETTIME(t); RF_TIMEVAL_DIFF(&desc->starttime, &t, &diff); diff --git a/sys/dev/raidframe/rf_dagutils.c b/sys/dev/raidframe/rf_dagutils.c index 553793273c7..2df7f1490a3 100644 --- a/sys/dev/raidframe/rf_dagutils.c +++ b/sys/dev/raidframe/rf_dagutils.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_dagutils.c,v 1.52 2009/03/15 17:17:23 cegger Exp $ */ +/* $NetBSD: rf_dagutils.c,v 1.53 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -33,7 +33,7 @@ *****************************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_dagutils.c,v 1.52 2009/03/15 17:17:23 cegger Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_dagutils.c,v 1.53 2011/05/11 18:13:12 mrg Exp $"); #include <dev/raidframe/raidframevar.h> @@ -359,7 +359,7 @@ rf_AllocStripeBuffer(RF_Raid_t *raidPtr, RF_DagHeader_t *dag_h, raidPtr->logBytesPerSector), M_RAIDFRAME, M_NOWAIT); if (!p) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->stripebuf_count > 0) { vple = raidPtr->stripebuf; raidPtr->stripebuf = vple->next; @@ -371,7 +371,7 @@ rf_AllocStripeBuffer(RF_Raid_t *raidPtr, RF_DagHeader_t *dag_h, printf("raid%d: Help! Out of emergency full-stripe buffers!\n", raidPtr->raidid); #endif } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); if (!p) { /* We didn't get a buffer... not much we can do other than wait, and hope that someone frees up memory for us.. */ @@ -393,7 +393,7 @@ rf_AllocStripeBuffer(RF_Raid_t *raidPtr, RF_DagHeader_t *dag_h, void rf_FreeStripeBuffer(RF_Raid_t *raidPtr, RF_VoidPointerListElem_t *vple) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->stripebuf_count < raidPtr->numEmergencyStripeBuffers) { /* just tack it in */ vple->next = raidPtr->stripebuf; @@ -403,7 +403,7 @@ rf_FreeStripeBuffer(RF_Raid_t *raidPtr, RF_VoidPointerListElem_t *vple) free(vple->p, M_RAIDFRAME); rf_FreeVPListElem(vple); } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); } /* allocates a buffer big enough to hold the data described by the @@ -438,7 +438,7 @@ rf_AllocIOBuffer(RF_Raid_t *raidPtr, int size) raidPtr->logBytesPerSector, M_RAIDFRAME, M_NOWAIT); if (!p) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->iobuf_count > 0) { vple = raidPtr->iobuf; raidPtr->iobuf = vple->next; @@ -450,7 +450,7 @@ rf_AllocIOBuffer(RF_Raid_t *raidPtr, int size) printf("raid%d: Help! Out of emergency buffers!\n", raidPtr->raidid); #endif } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); if (!p) { /* We didn't get a buffer... not much we can do other than wait, and hope that someone frees up memory for us.. */ @@ -466,7 +466,7 @@ rf_AllocIOBuffer(RF_Raid_t *raidPtr, int size) void rf_FreeIOBuffer(RF_Raid_t *raidPtr, RF_VoidPointerListElem_t *vple) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->iobuf_count < raidPtr->numEmergencyBuffers) { /* just tack it in */ vple->next = raidPtr->iobuf; @@ -476,7 +476,7 @@ rf_FreeIOBuffer(RF_Raid_t *raidPtr, RF_VoidPointerListElem_t *vple) free(vple->p, M_RAIDFRAME); rf_FreeVPListElem(vple); } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); } diff --git a/sys/dev/raidframe/rf_disks.c b/sys/dev/raidframe/rf_disks.c index cd82b73b81a..e60e3da0902 100644 --- a/sys/dev/raidframe/rf_disks.c +++ b/sys/dev/raidframe/rf_disks.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_disks.c,v 1.78 2011/02/19 07:11:09 enami Exp $ */ +/* $NetBSD: rf_disks.c,v 1.79 2011/05/11 18:13:12 mrg Exp $ */ /*- * Copyright (c) 1999 The NetBSD Foundation, Inc. * All rights reserved. @@ -60,7 +60,7 @@ ***************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_disks.c,v 1.78 2011/02/19 07:11:09 enami Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_disks.c,v 1.79 2011/05/11 18:13:12 mrg Exp $"); #include <dev/raidframe/raidframevar.h> @@ -972,13 +972,12 @@ rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr) return(EINVAL); } - RF_LOCK_MUTEX(raidPtr->mutex); - while (raidPtr->adding_hot_spare==1) { - ltsleep(&(raidPtr->adding_hot_spare), PRIBIO, "raidhs", 0, - &(raidPtr->mutex)); + rf_lock_mutex2(raidPtr->mutex); + while (raidPtr->adding_hot_spare == 1) { + rf_wait_cond2(raidPtr->adding_hot_spare_cv, raidPtr->mutex); } - raidPtr->adding_hot_spare=1; - RF_UNLOCK_MUTEX(raidPtr->mutex); + raidPtr->adding_hot_spare = 1; + rf_unlock_mutex2(raidPtr->mutex); /* the beginning of the spares... */ disks = &raidPtr->Disks[raidPtr->numCol]; @@ -1048,15 +1047,15 @@ rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr) &raidPtr->shutdownList, raidPtr->cleanupList); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->numSpare++; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); fail: - RF_LOCK_MUTEX(raidPtr->mutex); - raidPtr->adding_hot_spare=0; - wakeup(&(raidPtr->adding_hot_spare)); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); + raidPtr->adding_hot_spare = 0; + rf_signal_cond2(raidPtr->adding_hot_spare_cv); + rf_unlock_mutex2(raidPtr->mutex); return(ret); } diff --git a/sys/dev/raidframe/rf_driver.c b/sys/dev/raidframe/rf_driver.c index e1792101958..5ef81bb062d 100644 --- a/sys/dev/raidframe/rf_driver.c +++ b/sys/dev/raidframe/rf_driver.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_driver.c,v 1.127 2011/05/05 07:12:58 mrg Exp $ */ +/* $NetBSD: rf_driver.c,v 1.128 2011/05/11 18:13:12 mrg Exp $ */ /*- * Copyright (c) 1999 The NetBSD Foundation, Inc. * All rights reserved. @@ -66,7 +66,7 @@ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.127 2011/05/05 07:12:58 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_driver.c,v 1.128 2011/05/11 18:13:12 mrg Exp $"); #ifdef _KERNEL_OPT #include "opt_raid_diagnostic.h" @@ -233,12 +233,13 @@ rf_Shutdown(RF_Raid_t *raidPtr) } /* Wait for any reconstruction to stop... */ + rf_lock_mutex2(raidPtr->mutex); while (raidPtr->reconInProgress) { printf("raid%d: Waiting for reconstruction to stop...\n", raidPtr->raidid); - tsleep(&raidPtr->waitForReconCond, PRIBIO, - "rfreshutdown",0); + rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex); } + rf_unlock_mutex2(raidPtr->mutex); raidPtr->valid = 0; @@ -253,12 +254,17 @@ rf_Shutdown(RF_Raid_t *raidPtr) rf_ShutdownList(&raidPtr->shutdownList); + rf_destroy_cond2(raidPtr->waitForReconCond); + rf_destroy_cond2(raidPtr->adding_hot_spare_cv); + 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_destroy_mutex2(raidPtr->mutex); + rf_UnconfigureArray(); return (0); @@ -333,7 +339,7 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac) } rf_unlock_mutex2(configureMutex); - rf_mutex_init(&raidPtr->mutex); + rf_init_mutex2(raidPtr->mutex, IPL_VM); /* set up the cleanup list. Do this after ConfigureDebug so that * value of memDebug will be set */ @@ -364,7 +370,7 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac) rf_init_mutex2(raidPtr->access_suspend_mutex, IPL_VM); rf_init_cond2(raidPtr->access_suspend_cv, "rfquiesce"); - raidPtr->waitForReconCond = 0; + rf_init_cond2(raidPtr->waitForReconCond, "rfrcnw"); if (ac!=NULL) { /* We have an AutoConfig structure.. Don't do the @@ -397,6 +403,9 @@ rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac) raidPtr->parity_rewrite_in_progress = 0; raidPtr->adding_hot_spare = 0; raidPtr->recon_in_progress = 0; + + rf_init_cond2(raidPtr->adding_hot_spare_cv, "raidhs"); + raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs; /* autoconfigure and root_partition will actually get filled in @@ -703,7 +712,7 @@ rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int col) printf("Can't set reconfigured mode in dedicated-spare array\n"); RF_PANIC(); } - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->numFailures++; raidPtr->Disks[col].status = rf_ds_dist_spared; raidPtr->status = rf_rs_reconfigured; @@ -712,7 +721,7 @@ rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int col) * architecture. */ if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED) rf_InstallSpareTable(raidPtr, col); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (0); } #endif @@ -727,7 +736,7 @@ rf_FailDisk(RF_Raid_t *raidPtr, int fcol, int initRecon) rf_SuspendNewRequestsAndWait(raidPtr); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->Disks[fcol].status != rf_ds_failed) { /* must be failing something that is valid, or else it's already marked as failed (in which case we don't @@ -736,7 +745,7 @@ rf_FailDisk(RF_Raid_t *raidPtr, int fcol, int initRecon) raidPtr->Disks[fcol].status = rf_ds_failed; raidPtr->status = rf_rs_degraded; } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); @@ -746,14 +755,14 @@ rf_FailDisk(RF_Raid_t *raidPtr, int fcol, int initRecon) rf_close_component(raidPtr, raidPtr->raid_cinfo[fcol].ci_vp, raidPtr->Disks[fcol].auto_configured); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->raid_cinfo[fcol].ci_vp = NULL; /* Need to mark the component as not being auto_configured (in case it was previously). */ raidPtr->Disks[fcol].auto_configured = 0; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* now we can allow IO to continue -- we'll be suspending it again in rf_ReconstructFailedDisk() if we have to.. */ diff --git a/sys/dev/raidframe/rf_engine.c b/sys/dev/raidframe/rf_engine.c index 09089162a9f..9a0c5e44894 100644 --- a/sys/dev/raidframe/rf_engine.c +++ b/sys/dev/raidframe/rf_engine.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_engine.c,v 1.45 2011/05/02 01:14:06 mrg Exp $ */ +/* $NetBSD: rf_engine.c,v 1.46 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -55,7 +55,7 @@ ****************************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_engine.c,v 1.45 2011/05/02 01:14:06 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_engine.c,v 1.46 2011/05/11 18:13:12 mrg Exp $"); #include <sys/errno.h> @@ -86,7 +86,7 @@ static void rf_RaidIOThread(RF_ThreadArg_t arg); rf_wait_cond2((_r_)->node_queue_cv, (_r_)->node_queue_mutex) #define DO_SIGNAL(_r_) \ - rf_broadcast_cond2((_r_)->node_queue_cv) /* XXX RF_SIGNAL_COND? */ + rf_broadcast_cond2((_r_)->node_queue_cv) /* XXX rf_signal_cond2? */ static void rf_ShutdownEngine(void *arg) diff --git a/sys/dev/raidframe/rf_map.c b/sys/dev/raidframe/rf_map.c index 5586a6f5714..bf7571506cf 100644 --- a/sys/dev/raidframe/rf_map.c +++ b/sys/dev/raidframe/rf_map.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $ */ +/* $NetBSD: rf_map.c,v 1.45 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -33,7 +33,7 @@ **************************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.45 2011/05/11 18:13:12 mrg Exp $"); #include <dev/raidframe/raidframevar.h> @@ -632,9 +632,9 @@ rf_CheckStripeForFailures(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap) RF_SectorNum_t diskOffset, poffset; /* quick out in the fault-free case. */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); numFailures = raidPtr->numFailures; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); if (numFailures == 0) return (0); @@ -683,9 +683,9 @@ rf_NumFailedDataUnitsInStripe(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap) int numFailures; /* quick out in the fault-free case. */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); numFailures = raidPtr->numFailures; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); if (numFailures == 0) return (0); numFailures = 0; diff --git a/sys/dev/raidframe/rf_netbsdkintf.c b/sys/dev/raidframe/rf_netbsdkintf.c index 7df73fade03..7cda280f9c8 100644 --- a/sys/dev/raidframe/rf_netbsdkintf.c +++ b/sys/dev/raidframe/rf_netbsdkintf.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_netbsdkintf.c,v 1.290 2011/05/10 05:08:51 mrg Exp $ */ +/* $NetBSD: rf_netbsdkintf.c,v 1.291 2011/05/11 18:13:12 mrg Exp $ */ /*- * Copyright (c) 1996, 1997, 1998, 2008 The NetBSD Foundation, Inc. @@ -101,7 +101,7 @@ ***********************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.290 2011/05/10 05:08:51 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.291 2011/05/11 18:13:12 mrg Exp $"); #ifdef _KERNEL_OPT #include "opt_compat_netbsd.h" @@ -1392,7 +1392,7 @@ raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) return(EINVAL); } - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if ((raidPtr->Disks[column].status == rf_ds_optimal) && (raidPtr->numFailures > 0)) { /* XXX 0 above shouldn't be constant!!! */ @@ -1403,7 +1403,7 @@ raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) raidPtr->raidid); printf("raid%d: Col: %d Too many failures.\n", raidPtr->raidid, column); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } if (raidPtr->Disks[column].status == @@ -1412,14 +1412,14 @@ raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) raidPtr->raidid); printf("raid%d: Col: %d Reconstruction already occuring!\n", raidPtr->raidid, column); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } if (raidPtr->Disks[column].status == rf_ds_spared) { - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *)); if (rrcopy == NULL) @@ -1532,26 +1532,26 @@ raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) return (EINVAL); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->status == rf_rs_reconstructing) { /* you can't fail a disk while we're reconstructing! */ /* XXX wrong for RAID6 */ - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } if ((raidPtr->Disks[rr->col].status == rf_ds_optimal) && (raidPtr->numFailures > 0)) { /* some other component has failed. Let's not make things worse. XXX wrong for RAID6 */ - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } if (raidPtr->Disks[rr->col].status == rf_ds_spared) { /* Can't fail a spared disk! */ - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* make a copy of the recon request so that we don't rely on * the user's buffer */ @@ -1974,18 +1974,18 @@ raidstart(RF_Raid_t *raidPtr) rs = &raid_softc[unit]; /* quick check to see if anything has died recently */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); if (raidPtr->numNewFailures > 0) { - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->numNewFailures--; } /* Check to see if we're at the limit... */ while (raidPtr->openings > 0) { - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* get the next item, if any, from the queue */ if ((bp = bufq_get(rs->buf_queue)) == NULL) { @@ -2026,7 +2026,7 @@ raidstart(RF_Raid_t *raidPtr) bp->b_error = ENOSPC; bp->b_resid = bp->b_bcount; biodone(bp); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); continue; } /* @@ -2037,16 +2037,16 @@ raidstart(RF_Raid_t *raidPtr) bp->b_error = EINVAL; bp->b_resid = bp->b_bcount; biodone(bp); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); continue; } db1_printf(("Calling DoAccess..\n")); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->openings--; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* * Everything is async. @@ -2073,9 +2073,9 @@ raidstart(RF_Raid_t *raidPtr) /* continue loop */ } - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); } - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); } diff --git a/sys/dev/raidframe/rf_paritylog.h b/sys/dev/raidframe/rf_paritylog.h index e97f28a8387..2323b8c19ab 100644 --- a/sys/dev/raidframe/rf_paritylog.h +++ b/sys/dev/raidframe/rf_paritylog.h @@ -1,4 +1,4 @@ -/* $NetBSD: rf_paritylog.h,v 1.11 2011/05/11 06:20:33 mrg Exp $ */ +/* $NetBSD: rf_paritylog.h,v 1.12 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -71,7 +71,7 @@ struct RF_ParityLogData_s { }; struct RF_ParityLogAppendQueue_s { - RF_DECLARE_MUTEX(mutex) + rf_declare_mutex2(mutex); }; struct RF_ParityLogRecord_s { diff --git a/sys/dev/raidframe/rf_raid.h b/sys/dev/raidframe/rf_raid.h index 3cbe87f8ece..0e2717a5611 100644 --- a/sys/dev/raidframe/rf_raid.h +++ b/sys/dev/raidframe/rf_raid.h @@ -1,4 +1,4 @@ -/* $NetBSD: rf_raid.h,v 1.42 2011/05/05 07:12:58 mrg Exp $ */ +/* $NetBSD: rf_raid.h,v 1.43 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -84,7 +84,7 @@ struct RF_CumulativeStats_s { }; struct RF_ThroughputStats_s { - RF_DECLARE_MUTEX(mutex) /* a mutex used to lock the configuration + rf_declare_mutex2(mutex);/* a mutex used to lock the configuration * stuff */ struct timeval start; /* timer started when numOutstandingRequests * moves from 0 to 1 */ @@ -124,7 +124,7 @@ struct RF_Raid_s { * local copy of this pointer for the actual accesses. */ /* The remainder of the structure can change, and therefore requires * locking on reads and updates */ - RF_DECLARE_MUTEX(mutex) /* mutex used to serialize access to + rf_declare_mutex2(mutex);/* mutex used to serialize access to * the fields below */ RF_RowStatus_t status; /* the status of each row in the array */ int valid; /* indicates successful configuration */ @@ -187,7 +187,7 @@ struct RF_Raid_s { RF_HeadSepLimit_t headSepLimit; int numFloatingReconBufs; int reconInProgress; - RF_DECLARE_COND(waitForReconCond) + rf_declare_cond2(waitForReconCond); /* goes with raidPtr->mutex */ RF_RaidReconDesc_t *reconDesc; /* reconstruction descriptor */ RF_ReconCtrl_t *reconControl; /* reconstruction control structure * pointers for each row in the array */ @@ -214,6 +214,8 @@ struct RF_Raid_s { int copyback_in_progress; int adding_hot_spare; + rf_declare_cond2(adding_hot_spare_cv); + /* * Engine thread control */ diff --git a/sys/dev/raidframe/rf_reconstruct.c b/sys/dev/raidframe/rf_reconstruct.c index 69b47ea3370..45a5061eced 100644 --- a/sys/dev/raidframe/rf_reconstruct.c +++ b/sys/dev/raidframe/rf_reconstruct.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_reconstruct.c,v 1.112 2011/05/02 07:29:18 mrg Exp $ */ +/* $NetBSD: rf_reconstruct.c,v 1.113 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -33,7 +33,7 @@ ************************************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.112 2011/05/02 07:29:18 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.113 2011/05/11 18:13:12 mrg Exp $"); #include <sys/param.h> #include <sys/time.h> @@ -213,22 +213,23 @@ rf_ReconstructFailedDisk(RF_Raid_t *raidPtr, RF_RowCol_t col) * The current infrastructure only supports reconstructing one * disk at a time for each array. */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); while (raidPtr->reconInProgress) { - RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex); + rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex); } raidPtr->reconInProgress++; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); rc = rf_ReconstructFailedDiskBasic(raidPtr, col); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); } else { RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n", lp->parityConfig); rc = EIO; + rf_lock_mutex2(raidPtr->mutex); } - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return (rc); } @@ -245,13 +246,13 @@ rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t col) /* spare disk descriptors are stored in row 0. This may have to * change eventually */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); RF_ASSERT(raidPtr->Disks[col].status == rf_ds_failed); #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0 if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) { if (raidPtr->status != rf_rs_degraded) { RF_ERRORMSG1("Unable to reconstruct disk at col %d because status not degraded\n", col); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } scol = (-1); @@ -266,14 +267,14 @@ rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t col) } if (!spareDiskPtr) { RF_ERRORMSG1("Unable to reconstruct disk at col %d because no spares are available\n", col); - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); return (ENOSPC); } printf("RECON: initiating reconstruction on col %d -> spare at col %d\n", col, scol); #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0 } #endif - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); reconDesc = AllocRaidReconDesc((void *) raidPtr, col, spareDiskPtr, numDisksDone, scol); raidPtr->reconDesc = (void *) reconDesc; @@ -306,9 +307,9 @@ rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t col) /* XXX doesn't hold for RAID 6!!*/ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->parity_good = RF_RAID_CLEAN; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* XXXX MORE NEEDED HERE */ @@ -316,13 +317,13 @@ rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t col) } else { /* Reconstruct failed. */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); /* Failed disk goes back to "failed" status */ raidPtr->Disks[col].status = rf_ds_failed; /* Spare disk goes back to "spare" status. */ spareDiskPtr->status = rf_ds_spare; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); } rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); @@ -354,12 +355,14 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) int retcode; int ac; + rf_lock_mutex2(raidPtr->mutex); lp = raidPtr->Layout.map; if (!lp->SubmitReconBuffer) { RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n", lp->parityConfig); /* wakeup anyone who might be waiting to do a reconstruct */ - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return(EIO); } @@ -367,21 +370,20 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) * The current infrastructure only supports reconstructing one * disk at a time for each array. */ - RF_LOCK_MUTEX(raidPtr->mutex); if (raidPtr->Disks[col].status != rf_ds_failed) { /* "It's gone..." */ raidPtr->numFailures++; raidPtr->Disks[col].status = rf_ds_failed; raidPtr->status = rf_rs_degraded; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); } while (raidPtr->reconInProgress) { - RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex); + rf_wait_cond2(raidPtr->waitForReconCond, raidPtr->mutex); } raidPtr->reconInProgress++; @@ -400,8 +402,8 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) RF_ERRORMSG1("Unable to reconstruct to disk at col %d: operation not supported for RF_DISTRIBUTE_SPARE\n", col); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return (EINVAL); } #endif @@ -416,9 +418,9 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) #endif vp = raidPtr->raid_cinfo[col].ci_vp; ac = raidPtr->Disks[col].auto_configured; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); rf_close_component(raidPtr, vp, ac); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->raid_cinfo[col].ci_vp = NULL; } /* note that this disk was *not* auto_configured (any longer)*/ @@ -428,7 +430,7 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) printf("About to (re-)open the device for rebuilding: %s\n", raidPtr->Disks[col].devname); #endif - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); pb = pathbuf_create(raidPtr->Disks[col].devname); if (pb == NULL) { retcode = ENOMEM; @@ -443,10 +445,10 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) /* the component isn't responding properly... must be still dead :-( */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return(retcode); } @@ -454,22 +456,22 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) How about actually getting a vp for it? */ if ((retcode = VOP_GETATTR(vp, &va, curlwp->l_cred)) != 0) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return(retcode); } retcode = VOP_IOCTL(vp, DIOCGPART, &dpart, FREAD, curlwp->l_cred); if (retcode) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); - RF_SIGNAL_COND(raidPtr->waitForReconCond); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); return(retcode); } - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->Disks[col].blockSize = dpart.disklab->d_secsize; raidPtr->Disks[col].numBlocks = dpart.part->p_size - @@ -485,7 +487,7 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) it speeds up * the parity scan */ raidPtr->Disks[col].numBlocks = raidPtr->Disks[col].numBlocks * rf_sizePercentage / 100; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); spareDiskPtr = &raidPtr->Disks[col]; spareDiskPtr->status = rf_ds_used_spare; @@ -507,19 +509,19 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) rc = rf_ContinueReconstructFailedDisk(reconDesc); if (!rc) { - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); /* Need to set these here, as at this point it'll be claiming that the disk is in rf_ds_spared! But we know better :-) */ raidPtr->Disks[col].status = rf_ds_optimal; raidPtr->status = rf_rs_optimal; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* fix up the component label */ /* Don't actually need the read here.. */ c_label = raidget_component_label(raidPtr, col); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raid_init_component_label(raidPtr, c_label); c_label->row = 0; @@ -532,24 +534,24 @@ rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t col) /* XXX doesn't hold for RAID 6!!*/ raidPtr->parity_good = RF_RAID_CLEAN; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); raidflush_component_label(raidPtr, col); } else { /* Reconstruct-in-place failed. Disk goes back to "failed" status, regardless of what it was before. */ - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->Disks[col].status = rf_ds_failed; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); } rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->reconInProgress--; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_signal_cond2(raidPtr->waitForReconCond); + rf_unlock_mutex2(raidPtr->mutex); - RF_SIGNAL_COND(raidPtr->waitForReconCond); return (rc); } @@ -588,7 +590,7 @@ rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc) /* allocate our RF_ReconCTRL_t before we protect raidPtr->reconControl[row] */ tmp_reconctrl = rf_MakeReconControl(reconDesc, col, scol); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); /* create the reconstruction control pointer and install it in * the right slot */ @@ -600,7 +602,7 @@ rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc) raidPtr->Disks[col].status = rf_ds_reconstructing; raidPtr->Disks[col].spareCol = scol; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); RF_GETTIME(raidPtr->reconControl->starttime); @@ -781,7 +783,7 @@ rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc) /* we start by blocking IO to the RAID set. */ rf_SuspendNewRequestsAndWait(raidPtr); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); /* mark set as being degraded, rather than rf_rs_reconstructing as we were before the problem. After this is done we can update status of the @@ -789,7 +791,7 @@ rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc) trying to read from a failed component. */ raidPtr->status = rf_rs_degraded; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); /* resume IO */ rf_ResumeNewRequests(raidPtr); @@ -864,12 +866,12 @@ rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc) rf_SuspendNewRequestsAndWait(raidPtr); - RF_LOCK_MUTEX(raidPtr->mutex); + rf_lock_mutex2(raidPtr->mutex); raidPtr->numFailures--; ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE); raidPtr->Disks[col].status = (ds) ? rf_ds_dist_spared : rf_ds_spared; raidPtr->status = (ds) ? rf_rs_reconfigured : rf_rs_optimal; - RF_UNLOCK_MUTEX(raidPtr->mutex); + rf_unlock_mutex2(raidPtr->mutex); RF_GETTIME(etime); RF_TIMEVAL_DIFF(&(raidPtr->reconControl->starttime), &etime, &elpsd); diff --git a/sys/dev/raidframe/rf_reconutil.c b/sys/dev/raidframe/rf_reconutil.c index f86e74dcd9f..40ea1ded59a 100644 --- a/sys/dev/raidframe/rf_reconutil.c +++ b/sys/dev/raidframe/rf_reconutil.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_reconutil.c,v 1.33 2011/05/02 07:29:18 mrg Exp $ */ +/* $NetBSD: rf_reconutil.c,v 1.34 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -31,7 +31,7 @@ ********************************************/ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_reconutil.c,v 1.33 2011/05/02 07:29:18 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_reconutil.c,v 1.34 2011/05/11 18:13:12 mrg Exp $"); #include <dev/raidframe/raidframevar.h> @@ -274,7 +274,7 @@ rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock) pssTable = raidPtr->reconControl->pssTable; for (i = 0; i < raidPtr->pssTableSize; i++) { - RF_LOCK_MUTEX(pssTable[i].mutex); + rf_lock_mutex2(pssTable[i].mutex); for (p = pssTable[i].chain; p; p = p->next) { rbuf = (RF_ReconBuffer_t *) p->rbuf; if (rbuf && rbuf->type == RF_RBUF_TYPE_FLOATING) @@ -291,7 +291,7 @@ rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock) sum++; } } - RF_UNLOCK_MUTEX(pssTable[i].mutex); + rf_unlock_mutex2(pssTable[i].mutex); } for (rbuf = raidPtr->reconControl->floatingRbufs; rbuf; diff --git a/sys/dev/raidframe/rf_states.c b/sys/dev/raidframe/rf_states.c index 2743bf81f4c..29492a4f8b1 100644 --- a/sys/dev/raidframe/rf_states.c +++ b/sys/dev/raidframe/rf_states.c @@ -1,4 +1,4 @@ -/* $NetBSD: rf_states.c,v 1.48 2011/05/10 07:04:17 mrg Exp $ */ +/* $NetBSD: rf_states.c,v 1.49 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -27,7 +27,7 @@ */ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.48 2011/05/10 07:04:17 mrg Exp $"); +__KERNEL_RCSID(0, "$NetBSD: rf_states.c,v 1.49 2011/05/11 18:13:12 mrg Exp $"); #include <sys/errno.h> @@ -231,9 +231,9 @@ rf_State_LastState(RF_RaidAccessDesc_t *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); + rf_lock_mutex2(desc->raidPtr->mutex); + desc->raidPtr->openings++; + rf_unlock_mutex2(desc->raidPtr->mutex); rf_lock_mutex2(desc->raidPtr->iodone_lock); rf_signal_cond2(desc->raidPtr->iodone_cv); diff --git a/sys/dev/raidframe/rf_threadstuff.h b/sys/dev/raidframe/rf_threadstuff.h index 0eb96ad2faf..0d40c377989 100644 --- a/sys/dev/raidframe/rf_threadstuff.h +++ b/sys/dev/raidframe/rf_threadstuff.h @@ -1,4 +1,4 @@ -/* $NetBSD: rf_threadstuff.h,v 1.32 2011/05/11 05:14:07 mrg Exp $ */ +/* $NetBSD: rf_threadstuff.h,v 1.33 2011/05/11 18:13:12 mrg Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. @@ -54,26 +54,9 @@ #include <dev/raidframe/raidframevar.h> -/* Old school simple_lock */ typedef struct lwp *RF_Thread_t; typedef void *RF_ThreadArg_t; -#define RF_DECLARE_MUTEX(_m_) struct simplelock _m_; - -#define RF_DECLARE_COND(_c_) int _c_; - -#define RF_LOCK_MUTEX(_m_) simple_lock(&(_m_)) -#define RF_UNLOCK_MUTEX(_m_) simple_unlock(&(_m_)) - -#define RF_WAIT_COND(_c_,_m_) \ - ltsleep(&(_c_), PRIBIO, "rfwcond", 0, &(_m_)) -#define RF_SIGNAL_COND(_c_) wakeup_one(&(_c_)) - -#define rf_mutex_init(m) simple_lock_init(m) - - -/* Modern mutex */ -/* Note that rf_declare_{mutex,cond}2() do _NOT_ append the ; */ #define rf_declare_mutex2(_m_) kmutex_t _m_ #define rf_declare_cond2(_c_) kcondvar_t _c_ |
