Module Name: src
Committed By: mrg
Date: Wed May 11 03:23:26 UTC 2011
Modified Files:
src/sys/dev/raidframe: rf_paritylog.c rf_paritylog.h
rf_paritylogDiskMgr.c rf_paritylogging.c
Log Message:
convert parityLogDiskQueue.mutex to a kmutex/cv.
XXX: some splbio() usage to clean up here
To generate a diff of this commit:
cvs rdiff -u -r1.14 -r1.15 src/sys/dev/raidframe/rf_paritylog.c
cvs rdiff -u -r1.6 -r1.7 src/sys/dev/raidframe/rf_paritylog.h
cvs rdiff -u -r1.24 -r1.25 src/sys/dev/raidframe/rf_paritylogDiskMgr.c
cvs rdiff -u -r1.29 -r1.30 src/sys/dev/raidframe/rf_paritylogging.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/dev/raidframe/rf_paritylog.c
diff -u src/sys/dev/raidframe/rf_paritylog.c:1.14 src/sys/dev/raidframe/rf_paritylog.c:1.15
--- src/sys/dev/raidframe/rf_paritylog.c:1.14 Tue May 10 07:04:17 2011
+++ src/sys/dev/raidframe/rf_paritylog.c Wed May 11 03:23:26 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rf_paritylog.c,v 1.14 2011/05/10 07:04:17 mrg Exp $ */
+/* $NetBSD: rf_paritylog.c,v 1.15 2011/05/11 03:23:26 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@@ -31,7 +31,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_paritylog.c,v 1.14 2011/05/10 07:04:17 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_paritylog.c,v 1.15 2011/05/11 03:23:26 mrg Exp $");
#include "rf_archs.h"
@@ -67,13 +67,13 @@
* free list (rf_parityLogDiskQueue.freeCommonList). If the free list
* is empty, call RF_Malloc to create a new structure. NON-BLOCKING */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (raidPtr->parityLogDiskQueue.freeCommonList) {
common = raidPtr->parityLogDiskQueue.freeCommonList;
raidPtr->parityLogDiskQueue.freeCommonList = raidPtr->parityLogDiskQueue.freeCommonList->next;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
} else {
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
RF_Malloc(common, sizeof(RF_CommonLogData_t), (RF_CommonLogData_t *));
/* destroy is in rf_paritylogging.c */
rf_init_mutex2(common->mutex, IPL_VM);
@@ -92,10 +92,10 @@
* NON-BLOCKING */
raidPtr = common->raidPtr;
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
common->next = raidPtr->parityLogDiskQueue.freeCommonList;
raidPtr->parityLogDiskQueue.freeCommonList = common;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
static RF_ParityLogData_t *
@@ -107,13 +107,13 @@
* list (rf_parityLogDiskQueue.freeList). If the free list is empty,
* call RF_Malloc to create a new structure. NON-BLOCKING */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (raidPtr->parityLogDiskQueue.freeDataList) {
data = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr->parityLogDiskQueue.freeDataList = raidPtr->parityLogDiskQueue.freeDataList->next;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
} else {
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
RF_Malloc(data, sizeof(RF_ParityLogData_t), (RF_ParityLogData_t *));
}
data->next = NULL;
@@ -133,14 +133,14 @@
* NON-BLOCKING */
raidPtr = data->common->raidPtr;
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
while (data) {
nextItem = data->next;
data->next = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr->parityLogDiskQueue.freeDataList = data;
data = nextItem;
}
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
@@ -160,7 +160,7 @@
printf("[enqueueing parity log data, region %d, raidAddress %d, numSector %d]\n", data->regionID, (int) data->diskAddress.raidAddress, (int) data->diskAddress.numSector);
RF_ASSERT(data->prev == NULL);
RF_ASSERT(data->next == NULL);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (*head) {
/* insert into head of queue */
RF_ASSERT((*head)->prev == NULL);
@@ -177,7 +177,7 @@
}
RF_ASSERT((*head)->prev == NULL);
RF_ASSERT((*tail)->next == NULL);
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
static RF_ParityLogData_t *
@@ -194,7 +194,7 @@
/* remove from tail, preserving FIFO order */
if (!ignoreLocks)
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
data = *tail;
if (data) {
if (*head == *tail) {
@@ -217,7 +217,7 @@
RF_ASSERT((*tail)->next == NULL);
}
if (!ignoreLocks)
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
return (data);
}
@@ -237,7 +237,7 @@
RF_ASSERT(data);
if (rf_parityLogDebug)
printf("[requeueing parity log data, region %d, raidAddress %d, numSector %d]\n", data->regionID, (int) data->diskAddress.raidAddress, (int) data->diskAddress.numSector);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (*tail) {
/* append to tail of list */
data->prev = *tail;
@@ -253,7 +253,7 @@
}
RF_ASSERT((*head)->prev == NULL);
RF_ASSERT((*tail)->next == NULL);
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
RF_ParityLogData_t *
@@ -350,7 +350,7 @@
/* walk backward through a list, looking for an entry with a matching
* region ID */
if (!ignoreLocks)
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
w = (*tail);
while (w) {
if (w->regionID == regionID) {
@@ -392,7 +392,7 @@
w = w->prev;
}
if (!ignoreLocks)
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
return (NULL);
}
@@ -481,7 +481,7 @@
* which are blocked on logs. Holding mutexes for parityLogPool and
* parityLogDiskQueue forces synchronization with AcquireParityLog(). */
RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
log = firstLog;
if (firstLog)
@@ -490,7 +490,7 @@
log->next = NULL;
while (logDataList && log) {
RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
rf_ParityLogAppend(logDataList, RF_TRUE, &log, RF_FALSE);
if (rf_parityLogDebug)
printf("[finishing up buf-blocked log data, region %d]\n", logDataList->regionID);
@@ -503,7 +503,7 @@
}
}
RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (log)
logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
}
@@ -532,7 +532,7 @@
RF_ASSERT(cnt + raidPtr->logsInUse == raidPtr->numParityLogs);
}
RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
static void
@@ -555,12 +555,12 @@
if (rf_parityLogDebug)
printf("[requesting reintegration of region %d]\n", log->regionID);
/* move record to reintegration queue */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
log->next = raidPtr->parityLogDiskQueue.reintQueue;
raidPtr->parityLogDiskQueue.reintQueue = log;
RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
- RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
+ rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
static void
@@ -576,11 +576,11 @@
RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
RF_ASSERT(log->next == NULL);
/* move log to flush queue */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
log->next = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr->parityLogDiskQueue.flushQueue = log;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
- RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
+ rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
static int
@@ -696,13 +696,15 @@
/* Enable flushing for this region. Holding both locks
* provides a synchronization barrier with DumpParityLogToDisk */
RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ /* XXXmrg need this? */
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
RF_ASSERT(raidPtr->regionInfo[regionID].reintInProgress == RF_TRUE);
raidPtr->regionInfo[regionID].diskCount = 0;
raidPtr->regionInfo[regionID].reintInProgress = RF_FALSE;
RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex); /* flushing is now
* enabled */
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ /* XXXmrg need this? */
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
/* process each item in logData */
while (logData) {
Index: src/sys/dev/raidframe/rf_paritylog.h
diff -u src/sys/dev/raidframe/rf_paritylog.h:1.6 src/sys/dev/raidframe/rf_paritylog.h:1.7
--- src/sys/dev/raidframe/rf_paritylog.h:1.6 Tue May 10 07:04:17 2011
+++ src/sys/dev/raidframe/rf_paritylog.h Wed May 11 03:23:26 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rf_paritylog.h,v 1.6 2011/05/10 07:04:17 mrg Exp $ */
+/* $NetBSD: rf_paritylog.h,v 1.7 2011/05/11 03:23:26 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@@ -109,8 +109,8 @@
#define RF_PLOG_SHUTDOWN (1<<3)/* thread is aware and exiting/exited */
struct RF_ParityLogDiskQueue_s {
- RF_DECLARE_MUTEX(mutex) /* protects all vars in this struct */
- RF_DECLARE_COND(cond)
+ rf_declare_mutex2(mutex);/* protects all vars in this struct */
+ rf_declare_cond2(cond);
int threadState; /* is thread running, should it shutdown (see
* above) */
RF_ParityLog_t *flushQueue; /* list of parity logs to be flushed
Index: src/sys/dev/raidframe/rf_paritylogDiskMgr.c
diff -u src/sys/dev/raidframe/rf_paritylogDiskMgr.c:1.24 src/sys/dev/raidframe/rf_paritylogDiskMgr.c:1.25
--- src/sys/dev/raidframe/rf_paritylogDiskMgr.c:1.24 Thu May 5 04:20:51 2011
+++ src/sys/dev/raidframe/rf_paritylogDiskMgr.c Wed May 11 03:23:26 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rf_paritylogDiskMgr.c,v 1.24 2011/05/05 04:20:51 mrg Exp $ */
+/* $NetBSD: rf_paritylogDiskMgr.c,v 1.25 2011/05/11 03:23:26 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@@ -30,7 +30,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_paritylogDiskMgr.c,v 1.24 2011/05/05 04:20:51 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_paritylogDiskMgr.c,v 1.25 2011/05/11 03:23:26 mrg Exp $");
#include "rf_archs.h"
@@ -510,7 +510,7 @@
/* remove all items which are blocked on reintegration of this
* region */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
logData = rf_SearchAndDequeueParityLogData(raidPtr, regionID,
&raidPtr->parityLogDiskQueue.reintBlockHead,
&raidPtr->parityLogDiskQueue.reintBlockTail,
@@ -524,7 +524,7 @@
RF_TRUE);
logData = logData->next;
}
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
/* process blocked log data and clear reintInProgress flag for
* this region */
@@ -536,13 +536,15 @@
* DumpParityLogToDisk */
RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ /* XXXmrg: don't need this? */
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
raidPtr->regionInfo[regionID].diskCount = 0;
raidPtr->regionInfo[regionID].reintInProgress = RF_FALSE;
RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex); /* flushing is now
* enabled */
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ /* XXXmrg: don't need this? */
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
}
/* if log wasn't used, attach it to the list of logs to be
* returned */
@@ -607,7 +609,7 @@
s = splbio();
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
/*
* Inform our creator that we're running. Don't bother doing the
@@ -615,7 +617,7 @@
* below with nothing to do, yet.
*/
raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_RUNNING;
- RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
+ rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
/* empty the work queues */
flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
@@ -640,7 +642,7 @@
* are reintegrated are not opened for general use
* until the append queue has been emptied. */
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
/* empty flushQueue, using free'd log buffers to
* process bufTail */
@@ -651,7 +653,7 @@
if (reintQueue)
ReintegrateLogs(raidPtr, reintQueue);
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr->parityLogDiskQueue.flushQueue = NULL;
reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
@@ -663,15 +665,15 @@
/* shutdown parity logging 1. disable parity logging
* in all regions 2. reintegrate all regions */
done = RF_TRUE; /* thread disabled, no work needed */
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
rf_ShutdownLogging(raidPtr);
}
if (!done) {
/* thread enabled, no work needed, so sleep */
if (rf_parityLogDebug)
printf("[parity logging disk manager sleeping]\n");
- RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
- raidPtr->parityLogDiskQueue.mutex);
+ rf_wait_cond2(raidPtr->parityLogDiskQueue.cond,
+ raidPtr->parityLogDiskQueue.mutex);
if (rf_parityLogDebug)
printf("[parity logging disk manager just woke up]\n");
flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
@@ -684,10 +686,10 @@
/*
* Announce that we're done.
*/
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_SHUTDOWN;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
- RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
+ rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
splx(s);
Index: src/sys/dev/raidframe/rf_paritylogging.c
diff -u src/sys/dev/raidframe/rf_paritylogging.c:1.29 src/sys/dev/raidframe/rf_paritylogging.c:1.30
--- src/sys/dev/raidframe/rf_paritylogging.c:1.29 Tue May 10 07:04:17 2011
+++ src/sys/dev/raidframe/rf_paritylogging.c Wed May 11 03:23:26 2011
@@ -1,4 +1,4 @@
-/* $NetBSD: rf_paritylogging.c,v 1.29 2011/05/10 07:04:17 mrg Exp $ */
+/* $NetBSD: rf_paritylogging.c,v 1.30 2011/05/11 03:23:26 mrg Exp $ */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
@@ -32,7 +32,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_paritylogging.c,v 1.29 2011/05/10 07:04:17 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_paritylogging.c,v 1.30 2011/05/11 03:23:26 mrg Exp $");
#include "rf_archs.h"
@@ -391,8 +391,8 @@
rf_ShutdownParityLoggingParityBufferPool,
raidPtr);
/* initialize parityLogDiskQueue */
- rf_mutex_init(&raidPtr->parityLogDiskQueue.mutex);
- raidPtr->parityLogDiskQueue.cond = 0;
+ rf_init_mutex2(raidPtr->parityLogDiskQueue.mutex, IPL_VM);
+ rf_init_cond2(raidPtr->parityLogDiskQueue.cond, "rfdskq");
raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr->parityLogDiskQueue.bufHead = NULL;
@@ -472,12 +472,12 @@
return (ENOMEM);
}
/* wait for thread to start */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
- RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
- raidPtr->parityLogDiskQueue.mutex);
+ rf_wait_cond2(raidPtr->parityLogDiskQueue.cond,
+ raidPtr->parityLogDiskQueue.mutex);
}
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
rf_ShutdownCreate(listp, rf_ShutdownParityLogging, raidPtr);
if (rf_parityLogDebug) {
@@ -642,6 +642,9 @@
rf_destroy_mutex2(c->mutex);
RF_Free(c, sizeof(RF_CommonLogData_t));
}
+
+ rf_destroy_mutex2(raidPtr->parityLogDiskQueue.mutex);
+ rf_destroy_cond2(raidPtr->parityLogDiskQueue.cond);
}
static void
@@ -658,20 +661,20 @@
* reintegrated. This is necessary since all parity log maps are
* currently held in volatile memory. */
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_TERMINATE;
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
- RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
+ rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
/*
* pLogDiskThread will now terminate when queues are cleared
* now wait for it to be done
*/
- RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
- RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
- raidPtr->parityLogDiskQueue.mutex);
+ rf_wait_cond2(raidPtr->parityLogDiskQueue.cond,
+ raidPtr->parityLogDiskQueue.mutex);
}
- RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
+ rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
if (rf_parityLogDebug) {
printf("raid%d: ShutdownParityLogging done (thread completed)\n", raidPtr->raidid);
}
