Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert rb_mutex to a kmutex/cv.

This commit is contained in:
mrg 2011-05-02 07:29:18 +00:00
parent d06a811310
commit 02d186e1e2
5 changed files with 71 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
sys/dev/raidframe/rf_raid1.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: rf_raid1.c,v 1.33 2011/05/01 01:09:05 mrg Exp $ */
/* $NetBSD: rf_raid1.c,v 1.34 2011/05/02 07:29:18 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@ -33,7 +33,7 @@
*****************************************************************************/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rf_raid1.c,v 1.33 2011/05/01 01:09:05 mrg Exp $");
__KERNEL_RCSID(0, "$NetBSD: rf_raid1.c,v 1.34 2011/05/02 07:29:18 mrg Exp $");
#include "rf_raid.h"
#include "rf_raid1.h"
@ -581,12 +581,12 @@ rf_SubmitReconBufferRAID1(RF_ReconBuffer_t *rbuf, int keep_it,
}
RF_LOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
while(reconCtrlPtr->rb_lock) {
ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlcnmhs", 0, &reconCtrlPtr->rb_mutex);
rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
}
reconCtrlPtr->rb_lock = 1;
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, NULL);
@ -688,10 +688,10 @@ rf_SubmitReconBufferRAID1(RF_ReconBuffer_t *rbuf, int keep_it,
out:
RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
#if RF_DEBUG_RECON
if (rf_reconbufferDebug) {
printf("raid%d: RAID1 rbuf submission: returning %d\n",

34
sys/dev/raidframe/rf_reconbuffer.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: rf_reconbuffer.c,v 1.24 2007/03/04 06:02:39 christos Exp $ */
/* $NetBSD: rf_reconbuffer.c,v 1.25 2011/05/02 07:29:18 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@ -33,7 +33,7 @@
***************************************************/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rf_reconbuffer.c,v 1.24 2007/03/04 06:02:39 christos Exp $");
__KERNEL_RCSID(0, "$NetBSD: rf_reconbuffer.c,v 1.25 2011/05/02 07:29:18 mrg Exp $");
#include "rf_raid.h"
#include "rf_reconbuffer.h"
@ -140,12 +140,12 @@ rf_SubmitReconBufferBasic(RF_ReconBuffer_t *rbuf, int keep_it,
RF_LOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
while(reconCtrlPtr->rb_lock) {
ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlcnmhs", 0, &reconCtrlPtr->rb_mutex);
rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
}
reconCtrlPtr->rb_lock = 1;
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable, rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, NULL);
RF_ASSERT(pssPtr); /* if it didn't exist, we wouldn't have gotten
@ -193,10 +193,10 @@ rf_SubmitReconBufferBasic(RF_ReconBuffer_t *rbuf, int keep_it,
}
if (keep_it) {
RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
rf_FreeReconBuffer(rbuf);
return (retcode);
}
@ -286,10 +286,10 @@ rf_SubmitReconBufferBasic(RF_ReconBuffer_t *rbuf, int keep_it,
out:
RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID);
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
return (retcode);
}
/* pssPtr - the pss descriptor for this parity stripe */
@ -339,21 +339,21 @@ rf_GetFullReconBuffer(RF_ReconCtrl_t *reconCtrlPtr)
{
RF_ReconBuffer_t *p;
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
while(reconCtrlPtr->rb_lock) {
ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlcnmhs", 0, &reconCtrlPtr->rb_mutex);
rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
}
reconCtrlPtr->rb_lock = 1;
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
if ((p = reconCtrlPtr->fullBufferList) != NULL) {
reconCtrlPtr->fullBufferList = p->next;
p->next = NULL;
}
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
return (p);
}

68
sys/dev/raidframe/rf_reconstruct.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: rf_reconstruct.c,v 1.111 2011/02/19 07:11:09 enami Exp $ */
/* $NetBSD: rf_reconstruct.c,v 1.112 2011/05/02 07:29:18 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.111 2011/02/19 07:11:09 enami Exp $");
__KERNEL_RCSID(0, "$NetBSD: rf_reconstruct.c,v 1.112 2011/05/02 07:29:18 mrg Exp $");
#include <sys/param.h>
#include <sys/time.h>
@ -952,26 +952,26 @@ ProcessReconEvent(RF_Raid_t *raidPtr, RF_ReconEvent_t *event)
rbuf->failedDiskSectorOffset, rbuf->failedDiskSectorOffset + sectorsPerRU - 1);
rf_RemoveFromActiveReconTable(raidPtr, rbuf->parityStripeID, rbuf->which_ru);
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->reconControl->pending_writes--;
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
if (rbuf->type == RF_RBUF_TYPE_FLOATING) {
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
while(raidPtr->reconControl->rb_lock) {
ltsleep(&raidPtr->reconControl->rb_lock, PRIBIO, "reconctrlpre1", 0,
&raidPtr->reconControl->rb_mutex);
rf_wait_cond2(raidPtr->reconControl->rb_cv,
raidPtr->reconControl->rb_mutex);
}
raidPtr->reconControl->rb_lock = 1;
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->numFullReconBuffers--;
rf_ReleaseFloatingReconBuffer(raidPtr, rbuf);
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->reconControl->rb_lock = 0;
wakeup(&raidPtr->reconControl->rb_lock);
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_broadcast_cond2(raidPtr->reconControl->rb_cv);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
} else
if (rbuf->type == RF_RBUF_TYPE_FORCED)
rf_FreeReconBuffer(rbuf);
@ -1056,9 +1056,9 @@ ProcessReconEvent(RF_Raid_t *raidPtr, RF_ReconEvent_t *event)
/* This is an error, but it was a pending write.
Account for it. */
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->reconControl->pending_writes--;
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
rbuf = (RF_ReconBuffer_t *) event->arg;
@ -1442,9 +1442,9 @@ IssueNextWriteRequest(RF_Raid_t *raidPtr)
(void *) raidPtr, 0, NULL, PR_WAITOK);
rbuf->arg = (void *) req;
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->reconControl->pending_writes++;
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spCol], req, RF_IO_RECON_PRIORITY);
return (0);
@ -1531,12 +1531,12 @@ CheckForNewMinHeadSep(RF_Raid_t *raidPtr, RF_HeadSepLimit_t hsCtr)
* of a minimum */
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
while(reconCtrlPtr->rb_lock) {
ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlcnmhs", 0, &reconCtrlPtr->rb_mutex);
rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
}
reconCtrlPtr->rb_lock = 1;
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
new_min = ~(1L << (8 * sizeof(long) - 1)); /* 0x7FFF....FFF */
for (i = 0; i < raidPtr->numCol; i++)
@ -1559,10 +1559,10 @@ CheckForNewMinHeadSep(RF_Raid_t *raidPtr, RF_HeadSepLimit_t hsCtr)
}
}
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
}
/*
@ -1594,12 +1594,12 @@ CheckHeadSeparation(RF_Raid_t *raidPtr, RF_PerDiskReconCtrl_t *ctrl,
* separation before we'll wake up.
*
*/
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
while(reconCtrlPtr->rb_lock) {
ltsleep(&reconCtrlPtr->rb_lock, PRIBIO, "reconctlchs", 0, &reconCtrlPtr->rb_mutex);
rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex);
}
reconCtrlPtr->rb_lock = 1;
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
if ((raidPtr->headSepLimit >= 0) &&
((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) > raidPtr->headSepLimit)) {
Dprintf5("raid%d: RECON: head sep stall: col %d hsCtr %ld minHSCtr %ld limit %ld\n",
@ -1632,10 +1632,10 @@ CheckHeadSeparation(RF_Raid_t *raidPtr, RF_PerDiskReconCtrl_t *ctrl,
ctrl->reconCtrl->reconDesc->hsStallCount++;
#endif /* RF_RECON_STATS > 0 */
}
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_lock_mutex2(reconCtrlPtr->rb_mutex);
reconCtrlPtr->rb_lock = 0;
wakeup(&reconCtrlPtr->rb_lock);
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
rf_broadcast_cond2(reconCtrlPtr->rb_cv);
rf_unlock_mutex2(reconCtrlPtr->rb_mutex);
return (retval);
}
@ -1878,14 +1878,14 @@ rf_WakeupHeadSepCBWaiters(RF_Raid_t *raidPtr)
{
RF_CallbackDesc_t *p;
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
while(raidPtr->reconControl->rb_lock) {
ltsleep(&raidPtr->reconControl->rb_lock, PRIBIO,
"rf_wakeuphscbw", 0, &raidPtr->reconControl->rb_mutex);
rf_wait_cond2(raidPtr->reconControl->rb_cv,
raidPtr->reconControl->rb_mutex);
}
raidPtr->reconControl->rb_lock = 1;
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
while (raidPtr->reconControl->headSepCBList) {
p = raidPtr->reconControl->headSepCBList;
@ -1894,10 +1894,10 @@ rf_WakeupHeadSepCBWaiters(RF_Raid_t *raidPtr)
rf_CauseReconEvent(raidPtr, p->col, NULL, RF_REVENT_HEADSEPCLEAR);
rf_FreeCallbackDesc(p);
}
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
raidPtr->reconControl->rb_lock = 0;
wakeup(&raidPtr->reconControl->rb_lock);
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_broadcast_cond2(raidPtr->reconControl->rb_cv);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
}

6
sys/dev/raidframe/rf_reconstruct.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: rf_reconstruct.h,v 1.27 2011/05/02 01:07:24 mrg Exp $ */
/* $NetBSD: rf_reconstruct.h,v 1.28 2011/05/02 07:29:18 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@ -142,8 +142,8 @@ struct RF_ReconCtrl_s {
int eq_count; /* debug only */
/* reconstruction buffer management */
RF_DECLARE_MUTEX(rb_mutex) /* mutex for messing around
* with recon buffers */
rf_declare_mutex2(rb_mutex); /* mutex/cv for messing */
rf_declare_cond2(rb_cv); /* around with recon buffers */
int rb_lock; /* 1 if someone is mucking
with recon buffers,
0 otherwise */

14
sys/dev/raidframe/rf_reconutil.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: rf_reconutil.c,v 1.32 2011/05/02 01:07:24 mrg Exp $ */
/* $NetBSD: rf_reconutil.c,v 1.33 2011/05/02 07:29:18 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.32 2011/05/02 01:07:24 mrg Exp $");
__KERNEL_RCSID(0, "$NetBSD: rf_reconutil.c,v 1.33 2011/05/02 07:29:18 mrg Exp $");
#include <dev/raidframe/raidframevar.h>
@ -132,7 +132,8 @@ rf_MakeReconControl(RF_RaidReconDesc_t *reconDesc,
reconCtrlPtr->eq_count = 0;
/* make the floating recon buffers and append them to the free list */
rf_mutex_init(&reconCtrlPtr->rb_mutex);
rf_init_mutex2(reconCtrlPtr->rb_mutex, IPL_VM);
rf_init_cond2(reconCtrlPtr->rb_cv, "rfrcw");
reconCtrlPtr->fullBufferList = NULL;
reconCtrlPtr->floatingRbufs = NULL;
@ -175,6 +176,9 @@ rf_FreeReconControl(RF_Raid_t *raidPtr)
rf_destroy_mutex2(reconCtrlPtr->eq_mutex);
rf_destroy_cond2(reconCtrlPtr->eq_cv);
rf_destroy_mutex2(reconCtrlPtr->rb_mutex);
rf_destroy_cond2(reconCtrlPtr->rb_cv);
rf_FreeReconMap(reconCtrlPtr->reconMap);
rf_FreeParityStripeStatusTable(raidPtr, reconCtrlPtr->pssTable);
RF_Free(reconCtrlPtr->perDiskInfo,
@ -266,7 +270,7 @@ rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock)
int i, j, sum = 0;
if (dolock)
RF_LOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_lock_mutex2(raidPtr->reconControl->rb_mutex);
pssTable = raidPtr->reconControl->pssTable;
for (i = 0; i < raidPtr->pssTableSize; i++) {
@ -308,7 +312,7 @@ rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock)
RF_ASSERT(sum == raidPtr->numFloatingReconBufs);
if (dolock)
RF_UNLOCK_MUTEX(raidPtr->reconControl->rb_mutex);
rf_unlock_mutex2(raidPtr->reconControl->rb_mutex);
}
#endif