Annotation of sys/dev/raidframe/rf_paritylogDiskMgr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: rf_paritylogDiskMgr.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $ */
! 2: /* $NetBSD: rf_paritylogDiskMgr.c,v 1.10 2000/01/15 01:57:57 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: William V. Courtright II
! 9: *
! 10: * Permission to use, copy, modify and distribute this software and
! 11: * its documentation is hereby granted, provided that both the copyright
! 12: * notice and this permission notice appear in all copies of the
! 13: * software, derivative works or modified versions, and any portions
! 14: * thereof, and that both notices appear in supporting documentation.
! 15: *
! 16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 19: *
! 20: * Carnegie Mellon requests users of this software to return to
! 21: *
! 22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 23: * School of Computer Science
! 24: * Carnegie Mellon University
! 25: * Pittsburgh PA 15213-3890
! 26: *
! 27: * any improvements or extensions that they make and grant Carnegie the
! 28: * rights to redistribute these changes.
! 29: */
! 30: /*
! 31: * Code for flushing and reintegrating operations related to parity logging.
! 32: */
! 33:
! 34: #include "rf_archs.h"
! 35:
! 36: #if RF_INCLUDE_PARITYLOGGING > 0
! 37:
! 38: #include "rf_types.h"
! 39: #include "rf_threadstuff.h"
! 40: #include "rf_mcpair.h"
! 41: #include "rf_raid.h"
! 42: #include "rf_dag.h"
! 43: #include "rf_dagfuncs.h"
! 44: #include "rf_desc.h"
! 45: #include "rf_layout.h"
! 46: #include "rf_diskqueue.h"
! 47: #include "rf_paritylog.h"
! 48: #include "rf_general.h"
! 49: #include "rf_etimer.h"
! 50: #include "rf_paritylogging.h"
! 51: #include "rf_engine.h"
! 52: #include "rf_dagutils.h"
! 53: #include "rf_map.h"
! 54: #include "rf_parityscan.h"
! 55:
! 56: #include "rf_paritylogDiskMgr.h"
! 57:
! 58: caddr_t rf_AcquireReintBuffer(RF_RegionBufferQueue_t *);
! 59: void rf_ReleaseReintBuffer(RF_RegionBufferQueue_t *, caddr_t);
! 60: void rf_ReadRegionLog(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
! 61: RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
! 62: void rf_WriteCoreLog(RF_ParityLog_t *, RF_MCPair_t *, RF_Raid_t *,
! 63: RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
! 64: void rf_ReadRegionParity(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
! 65: RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
! 66: void rf_WriteRegionParity(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
! 67: RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
! 68: void rf_FlushLogsToDisk(RF_Raid_t *, RF_ParityLog_t *);
! 69: void rf_ReintegrateRegion(RF_Raid_t *, RF_RegionId_t, RF_ParityLog_t *);
! 70: void rf_ReintegrateLogs(RF_Raid_t *, RF_ParityLog_t *);
! 71:
! 72:
! 73: caddr_t
! 74: rf_AcquireReintBuffer(RF_RegionBufferQueue_t *pool)
! 75: {
! 76: caddr_t bufPtr = NULL;
! 77:
! 78: /*
! 79: * Return a region buffer from the free list (pool). If the free list
! 80: * is empty, WAIT. BLOCKING
! 81: */
! 82:
! 83: RF_LOCK_MUTEX(pool->mutex);
! 84: if (pool->availableBuffers > 0) {
! 85: bufPtr = pool->buffers[pool->availBuffersIndex];
! 86: pool->availableBuffers--;
! 87: pool->availBuffersIndex++;
! 88: if (pool->availBuffersIndex == pool->totalBuffers)
! 89: pool->availBuffersIndex = 0;
! 90: RF_UNLOCK_MUTEX(pool->mutex);
! 91: } else {
! 92: RF_PANIC(); /*
! 93: * Should never happen in correct config,
! 94: * single reint.
! 95: */
! 96: RF_WAIT_COND(pool->cond, pool->mutex);
! 97: }
! 98: return (bufPtr);
! 99: }
! 100:
! 101:
! 102: void
! 103: rf_ReleaseReintBuffer(RF_RegionBufferQueue_t *pool, caddr_t bufPtr)
! 104: {
! 105: /*
! 106: * Insert a region buffer (bufPtr) into the free list (pool).
! 107: * NON-BLOCKING
! 108: */
! 109:
! 110: RF_LOCK_MUTEX(pool->mutex);
! 111: pool->availableBuffers++;
! 112: pool->buffers[pool->emptyBuffersIndex] = bufPtr;
! 113: pool->emptyBuffersIndex++;
! 114: if (pool->emptyBuffersIndex == pool->totalBuffers)
! 115: pool->emptyBuffersIndex = 0;
! 116: RF_ASSERT(pool->availableBuffers <= pool->totalBuffers);
! 117: RF_UNLOCK_MUTEX(pool->mutex);
! 118: RF_SIGNAL_COND(pool->cond);
! 119: }
! 120:
! 121:
! 122: void
! 123: rf_ReadRegionLog(RF_RegionId_t regionID, RF_MCPair_t *rrd_mcpair,
! 124: caddr_t regionBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **rrd_dag_h,
! 125: RF_AllocListElem_t **rrd_alloclist, RF_PhysDiskAddr_t **rrd_pda)
! 126: {
! 127: /*
! 128: * Initiate the read a region log from disk. Once initiated, return
! 129: * to the calling routine.
! 130: *
! 131: * NON-BLOCKING
! 132: */
! 133:
! 134: RF_AccTraceEntry_t *tracerec;
! 135: RF_DagNode_t *rrd_rdNode;
! 136:
! 137: /* Create DAG to read region log from disk. */
! 138: rf_MakeAllocList(*rrd_alloclist);
! 139: *rrd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, regionBuffer,
! 140: rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rrl", *rrd_alloclist,
! 141: RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
! 142:
! 143: /* Create and initialize PDA for the core log. */
! 144: /* RF_Malloc(*rrd_pda, sizeof(RF_PhysDiskAddr_t),
! 145: * (RF_PhysDiskAddr_t *)); */
! 146: *rrd_pda = rf_AllocPDAList(1);
! 147: rf_MapLogParityLogging(raidPtr, regionID, 0, &((*rrd_pda)->row),
! 148: &((*rrd_pda)->col), &((*rrd_pda)->startSector));
! 149: (*rrd_pda)->numSector = raidPtr->regionInfo[regionID].capacity;
! 150:
! 151: if ((*rrd_pda)->next) {
! 152: (*rrd_pda)->next = NULL;
! 153: printf("set rrd_pda->next to NULL\n");
! 154: }
! 155: /* Initialize DAG parameters. */
! 156: RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
! 157: bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
! 158: (*rrd_dag_h)->tracerec = tracerec;
! 159: rrd_rdNode = (*rrd_dag_h)->succedents[0]->succedents[0];
! 160: rrd_rdNode->params[0].p = *rrd_pda;
! 161: /* rrd_rdNode->params[1] = regionBuffer; */
! 162: rrd_rdNode->params[2].v = 0;
! 163: rrd_rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
! 164: 0, 0, 0);
! 165:
! 166: /* Launch region log read dag. */
! 167: rf_DispatchDAG(*rrd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
! 168: (void *) rrd_mcpair);
! 169: }
! 170:
! 171:
! 172: void
! 173: rf_WriteCoreLog(RF_ParityLog_t *log, RF_MCPair_t *fwr_mcpair,
! 174: RF_Raid_t *raidPtr, RF_DagHeader_t **fwr_dag_h,
! 175: RF_AllocListElem_t **fwr_alloclist, RF_PhysDiskAddr_t **fwr_pda)
! 176: {
! 177: RF_RegionId_t regionID = log->regionID;
! 178: RF_AccTraceEntry_t *tracerec;
! 179: RF_SectorNum_t regionOffset;
! 180: RF_DagNode_t *fwr_wrNode;
! 181:
! 182: /*
! 183: * Initiate the write of a core log to a region log disk. Once
! 184: * initiated, return to the calling routine.
! 185: *
! 186: * NON-BLOCKING
! 187: */
! 188:
! 189: /* Create DAG to write a core log to a region log disk. */
! 190: rf_MakeAllocList(*fwr_alloclist);
! 191: *fwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, log->bufPtr,
! 192: rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wcl", *fwr_alloclist,
! 193: RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
! 194:
! 195: /* Create and initialize PDA for the region log. */
! 196: /* RF_Malloc(*fwr_pda, sizeof(RF_PhysDiskAddr_t),
! 197: * (RF_PhysDiskAddr_t *)); */
! 198: *fwr_pda = rf_AllocPDAList(1);
! 199: regionOffset = log->diskOffset;
! 200: rf_MapLogParityLogging(raidPtr, regionID, regionOffset,
! 201: &((*fwr_pda)->row), &((*fwr_pda)->col), &((*fwr_pda)->startSector));
! 202: (*fwr_pda)->numSector = raidPtr->numSectorsPerLog;
! 203:
! 204: /* Initialize DAG parameters. */
! 205: RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
! 206: bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
! 207: (*fwr_dag_h)->tracerec = tracerec;
! 208: fwr_wrNode = (*fwr_dag_h)->succedents[0]->succedents[0];
! 209: fwr_wrNode->params[0].p = *fwr_pda;
! 210: /* fwr_wrNode->params[1] = log->bufPtr; */
! 211: fwr_wrNode->params[2].v = 0;
! 212: fwr_wrNode->params[3].v =
! 213: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
! 214:
! 215: /* Launch the dag to write the core log to disk. */
! 216: rf_DispatchDAG(*fwr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
! 217: (void *) fwr_mcpair);
! 218: }
! 219:
! 220:
! 221: void
! 222: rf_ReadRegionParity(RF_RegionId_t regionID, RF_MCPair_t *prd_mcpair,
! 223: caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **prd_dag_h,
! 224: RF_AllocListElem_t **prd_alloclist, RF_PhysDiskAddr_t **prd_pda)
! 225: {
! 226: /*
! 227: * Initiate the read region parity from disk. Once initiated, return
! 228: * to the calling routine.
! 229: *
! 230: * NON-BLOCKING
! 231: */
! 232:
! 233: RF_AccTraceEntry_t *tracerec;
! 234: RF_DagNode_t *prd_rdNode;
! 235:
! 236: /* Create DAG to read region parity from disk. */
! 237: rf_MakeAllocList(*prd_alloclist);
! 238: *prd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, NULL, rf_DiskReadFunc,
! 239: rf_DiskReadUndoFunc, "Rrp", *prd_alloclist, RF_DAG_FLAGS_NONE,
! 240: RF_IO_NORMAL_PRIORITY);
! 241:
! 242: /* Create and initialize PDA for region parity. */
! 243: /* RF_Malloc(*prd_pda, sizeof(RF_PhysDiskAddr_t),
! 244: * (RF_PhysDiskAddr_t *)); */
! 245: *prd_pda = rf_AllocPDAList(1);
! 246: rf_MapRegionParity(raidPtr, regionID, &((*prd_pda)->row),
! 247: &((*prd_pda)->col), &((*prd_pda)->startSector),
! 248: &((*prd_pda)->numSector));
! 249: if (rf_parityLogDebug)
! 250: printf("[reading %d sectors of parity from region %d]\n",
! 251: (int) (*prd_pda)->numSector, regionID);
! 252: if ((*prd_pda)->next) {
! 253: (*prd_pda)->next = NULL;
! 254: printf("set prd_pda->next to NULL\n");
! 255: }
! 256: /* Initialize DAG parameters. */
! 257: RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
! 258: bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
! 259: (*prd_dag_h)->tracerec = tracerec;
! 260: prd_rdNode = (*prd_dag_h)->succedents[0]->succedents[0];
! 261: prd_rdNode->params[0].p = *prd_pda;
! 262: prd_rdNode->params[1].p = parityBuffer;
! 263: prd_rdNode->params[2].v = 0;
! 264: prd_rdNode->params[3].v =
! 265: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
! 266: if (rf_validateDAGDebug)
! 267: rf_ValidateDAG(*prd_dag_h);
! 268: /* Launch region parity read dag. */
! 269: rf_DispatchDAG(*prd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
! 270: (void *) prd_mcpair);
! 271: }
! 272:
! 273: void
! 274: rf_WriteRegionParity(RF_RegionId_t regionID, RF_MCPair_t *pwr_mcpair,
! 275: caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **pwr_dag_h,
! 276: RF_AllocListElem_t **pwr_alloclist, RF_PhysDiskAddr_t **pwr_pda)
! 277: {
! 278: /*
! 279: * Initiate the write of region parity to disk. Once initiated, return
! 280: * to the calling routine.
! 281: *
! 282: * NON-BLOCKING
! 283: */
! 284:
! 285: RF_AccTraceEntry_t *tracerec;
! 286: RF_DagNode_t *pwr_wrNode;
! 287:
! 288: /* Create DAG to write region log from disk. */
! 289: rf_MakeAllocList(*pwr_alloclist);
! 290: *pwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, parityBuffer,
! 291: rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wrp", *pwr_alloclist,
! 292: RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
! 293:
! 294: /* Create and initialize PDA for region parity. */
! 295: /* RF_Malloc(*pwr_pda, sizeof(RF_PhysDiskAddr_t),
! 296: * (RF_PhysDiskAddr_t *)); */
! 297: *pwr_pda = rf_AllocPDAList(1);
! 298: rf_MapRegionParity(raidPtr, regionID, &((*pwr_pda)->row),
! 299: &((*pwr_pda)->col), &((*pwr_pda)->startSector),
! 300: &((*pwr_pda)->numSector));
! 301:
! 302: /* Initialize DAG parameters. */
! 303: RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
! 304: bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
! 305: (*pwr_dag_h)->tracerec = tracerec;
! 306: pwr_wrNode = (*pwr_dag_h)->succedents[0]->succedents[0];
! 307: pwr_wrNode->params[0].p = *pwr_pda;
! 308: /* pwr_wrNode->params[1] = parityBuffer; */
! 309: pwr_wrNode->params[2].v = 0;
! 310: pwr_wrNode->params[3].v =
! 311: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
! 312:
! 313: /* Launch the dag to write region parity to disk. */
! 314: rf_DispatchDAG(*pwr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
! 315: (void *) pwr_mcpair);
! 316: }
! 317:
! 318: void
! 319: rf_FlushLogsToDisk(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
! 320: {
! 321: /*
! 322: * Flush a linked list of core logs to the log disk. Logs contain the
! 323: * disk location where they should be written. Logs were written in
! 324: * FIFO order and that order must be preserved.
! 325: *
! 326: * Recommended optimizations:
! 327: * 1) Allow multiple flushes to occur simultaneously.
! 328: * 2) Coalesce contiguous flush operations.
! 329: *
! 330: * BLOCKING
! 331: */
! 332:
! 333: RF_ParityLog_t *log;
! 334: RF_RegionId_t regionID;
! 335: RF_MCPair_t *fwr_mcpair;
! 336: RF_DagHeader_t *fwr_dag_h;
! 337: RF_AllocListElem_t *fwr_alloclist;
! 338: RF_PhysDiskAddr_t *fwr_pda;
! 339:
! 340: fwr_mcpair = rf_AllocMCPair();
! 341: RF_LOCK_MUTEX(fwr_mcpair->mutex);
! 342:
! 343: RF_ASSERT(logList);
! 344: log = logList;
! 345: while (log) {
! 346: regionID = log->regionID;
! 347:
! 348: /* Create and launch a DAG to write the core log. */
! 349: if (rf_parityLogDebug)
! 350: printf("[initiating write of core log for region"
! 351: " %d]\n", regionID);
! 352: fwr_mcpair->flag = RF_FALSE;
! 353: rf_WriteCoreLog(log, fwr_mcpair, raidPtr, &fwr_dag_h,
! 354: &fwr_alloclist, &fwr_pda);
! 355:
! 356: /* Wait for the DAG to complete. */
! 357: while (!fwr_mcpair->flag)
! 358: RF_WAIT_COND(fwr_mcpair->cond, fwr_mcpair->mutex);
! 359: if (fwr_dag_h->status != rf_enable) {
! 360: RF_ERRORMSG1("Unable to write core log to disk"
! 361: " (region %d)\n", regionID);
! 362: RF_ASSERT(0);
! 363: }
! 364: /* RF_Free(fwr_pda, sizeof(RF_PhysDiskAddr_t)); */
! 365: rf_FreePhysDiskAddr(fwr_pda);
! 366: rf_FreeDAG(fwr_dag_h);
! 367: rf_FreeAllocList(fwr_alloclist);
! 368:
! 369: log = log->next;
! 370: }
! 371: RF_UNLOCK_MUTEX(fwr_mcpair->mutex);
! 372: rf_FreeMCPair(fwr_mcpair);
! 373: rf_ReleaseParityLogs(raidPtr, logList);
! 374: }
! 375:
! 376: void
! 377: rf_ReintegrateRegion(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
! 378: RF_ParityLog_t *coreLog)
! 379: {
! 380: RF_MCPair_t *rrd_mcpair = NULL, *prd_mcpair, *pwr_mcpair;
! 381: RF_DagHeader_t *rrd_dag_h, *prd_dag_h, *pwr_dag_h;
! 382: RF_AllocListElem_t *rrd_alloclist, *prd_alloclist, *pwr_alloclist;
! 383: RF_PhysDiskAddr_t *rrd_pda, *prd_pda, *pwr_pda;
! 384: caddr_t parityBuffer, regionBuffer = NULL;
! 385:
! 386: /*
! 387: * Reintegrate a region (regionID).
! 388: *
! 389: * 1. Acquire region and parity buffers.
! 390: * 2. Read log from disk.
! 391: * 3. Read parity from disk.
! 392: * 4. Apply log to parity.
! 393: * 5. Apply core log to parity.
! 394: * 6. Write new parity to disk.
! 395: *
! 396: * BLOCKING
! 397: */
! 398:
! 399: if (rf_parityLogDebug)
! 400: printf("[reintegrating region %d]\n", regionID);
! 401:
! 402: /* Initiate read of region parity. */
! 403: if (rf_parityLogDebug)
! 404: printf("[initiating read of parity for region %d]\n", regionID);
! 405: parityBuffer = rf_AcquireReintBuffer(&raidPtr->parityBufferPool);
! 406: prd_mcpair = rf_AllocMCPair();
! 407: RF_LOCK_MUTEX(prd_mcpair->mutex);
! 408: prd_mcpair->flag = RF_FALSE;
! 409: rf_ReadRegionParity(regionID, prd_mcpair, parityBuffer, raidPtr,
! 410: &prd_dag_h, &prd_alloclist, &prd_pda);
! 411:
! 412: /* If region log nonempty, initiate read. */
! 413: if (raidPtr->regionInfo[regionID].diskCount > 0) {
! 414: if (rf_parityLogDebug)
! 415: printf("[initiating read of disk log for region %d]\n",
! 416: regionID);
! 417: regionBuffer =
! 418: rf_AcquireReintBuffer(&raidPtr->regionBufferPool);
! 419: rrd_mcpair = rf_AllocMCPair();
! 420: RF_LOCK_MUTEX(rrd_mcpair->mutex);
! 421: rrd_mcpair->flag = RF_FALSE;
! 422: rf_ReadRegionLog(regionID, rrd_mcpair, regionBuffer, raidPtr,
! 423: &rrd_dag_h, &rrd_alloclist, &rrd_pda);
! 424: }
! 425: /* Wait on read of region parity to complete. */
! 426: while (!prd_mcpair->flag) {
! 427: RF_WAIT_COND(prd_mcpair->cond, prd_mcpair->mutex);
! 428: }
! 429: RF_UNLOCK_MUTEX(prd_mcpair->mutex);
! 430: if (prd_dag_h->status != rf_enable) {
! 431: RF_ERRORMSG("Unable to read parity from disk\n");
! 432: /* Add code to fail the parity disk. */
! 433: RF_ASSERT(0);
! 434: }
! 435: /* Apply core log to parity. */
! 436: /* if (coreLog) ApplyLogsToParity(coreLog, parityBuffer); */
! 437:
! 438: if (raidPtr->regionInfo[regionID].diskCount > 0) {
! 439: /* Wait on read of region log to complete. */
! 440: while (!rrd_mcpair->flag)
! 441: RF_WAIT_COND(rrd_mcpair->cond, rrd_mcpair->mutex);
! 442: RF_UNLOCK_MUTEX(rrd_mcpair->mutex);
! 443: if (rrd_dag_h->status != rf_enable) {
! 444: RF_ERRORMSG("Unable to read region log from disk\n");
! 445: /* Add code to fail the log disk. */
! 446: RF_ASSERT(0);
! 447: }
! 448: /* Apply region log to parity. */
! 449: /* ApplyRegionToParity(regionID, regionBuffer, parityBuffer); */
! 450: /* Release resources associated with region log. */
! 451: /* RF_Free(rrd_pda, sizeof(RF_PhysDiskAddr_t)); */
! 452: rf_FreePhysDiskAddr(rrd_pda);
! 453: rf_FreeDAG(rrd_dag_h);
! 454: rf_FreeAllocList(rrd_alloclist);
! 455: rf_FreeMCPair(rrd_mcpair);
! 456: rf_ReleaseReintBuffer(&raidPtr->regionBufferPool, regionBuffer);
! 457: }
! 458: /* Write reintegrated parity to disk. */
! 459: if (rf_parityLogDebug)
! 460: printf("[initiating write of parity for region %d]\n",
! 461: regionID);
! 462: pwr_mcpair = rf_AllocMCPair();
! 463: RF_LOCK_MUTEX(pwr_mcpair->mutex);
! 464: pwr_mcpair->flag = RF_FALSE;
! 465: rf_WriteRegionParity(regionID, pwr_mcpair, parityBuffer, raidPtr,
! 466: &pwr_dag_h, &pwr_alloclist, &pwr_pda);
! 467: while (!pwr_mcpair->flag)
! 468: RF_WAIT_COND(pwr_mcpair->cond, pwr_mcpair->mutex);
! 469: RF_UNLOCK_MUTEX(pwr_mcpair->mutex);
! 470: if (pwr_dag_h->status != rf_enable) {
! 471: RF_ERRORMSG("Unable to write parity to disk\n");
! 472: /* Add code to fail the parity disk. */
! 473: RF_ASSERT(0);
! 474: }
! 475: /* Release resources associated with read of old parity. */
! 476: /* RF_Free(prd_pda, sizeof(RF_PhysDiskAddr_t)); */
! 477: rf_FreePhysDiskAddr(prd_pda);
! 478: rf_FreeDAG(prd_dag_h);
! 479: rf_FreeAllocList(prd_alloclist);
! 480: rf_FreeMCPair(prd_mcpair);
! 481:
! 482: /* Release resources associated with write of new parity. */
! 483: rf_ReleaseReintBuffer(&raidPtr->parityBufferPool, parityBuffer);
! 484: /* RF_Free(pwr_pda, sizeof(RF_PhysDiskAddr_t)); */
! 485: rf_FreePhysDiskAddr(pwr_pda);
! 486: rf_FreeDAG(pwr_dag_h);
! 487: rf_FreeAllocList(pwr_alloclist);
! 488: rf_FreeMCPair(pwr_mcpair);
! 489:
! 490: if (rf_parityLogDebug)
! 491: printf("[finished reintegrating region %d]\n", regionID);
! 492: }
! 493:
! 494:
! 495: void
! 496: rf_ReintegrateLogs(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
! 497: {
! 498: RF_ParityLog_t *log, *freeLogList = NULL;
! 499: RF_ParityLogData_t *logData, *logDataList;
! 500: RF_RegionId_t regionID;
! 501:
! 502: RF_ASSERT(logList);
! 503: while (logList) {
! 504: log = logList;
! 505: logList = logList->next;
! 506: log->next = NULL;
! 507: regionID = log->regionID;
! 508: rf_ReintegrateRegion(raidPtr, regionID, log);
! 509: log->numRecords = 0;
! 510:
! 511: /*
! 512: * Remove all items which are blocked on reintegration of this
! 513: * region.
! 514: */
! 515: RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 516: logData = rf_SearchAndDequeueParityLogData(raidPtr, regionID,
! 517: &raidPtr->parityLogDiskQueue.reintBlockHead,
! 518: &raidPtr->parityLogDiskQueue.reintBlockTail, RF_TRUE);
! 519: logDataList = logData;
! 520: while (logData) {
! 521: logData->next =
! 522: rf_SearchAndDequeueParityLogData(raidPtr, regionID,
! 523: &raidPtr->parityLogDiskQueue.reintBlockHead,
! 524: &raidPtr->parityLogDiskQueue.reintBlockTail,
! 525: RF_TRUE);
! 526: logData = logData->next;
! 527: }
! 528: RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 529:
! 530: /*
! 531: * Process blocked log data and clear reintInProgress flag for
! 532: * this region.
! 533: */
! 534: if (logDataList)
! 535: rf_ParityLogAppend(logDataList, RF_TRUE, &log, RF_TRUE);
! 536: else {
! 537: /*
! 538: * Enable flushing for this region. Holding both
! 539: * locks provides a synchronization barrier with
! 540: * DumpParityLogToDisk.
! 541: */
! 542: RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
! 543: RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
! 544: RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 545: raidPtr->regionInfo[regionID].diskCount = 0;
! 546: raidPtr->regionInfo[regionID].reintInProgress =
! 547: RF_FALSE;
! 548: RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
! 549: RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID]
! 550: .reintMutex); /* Flushing is now enabled. */
! 551: RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 552: }
! 553: /*
! 554: * If log wasn't used, attach it to the list of logs to be
! 555: * returned.
! 556: */
! 557: if (log) {
! 558: log->next = freeLogList;
! 559: freeLogList = log;
! 560: }
! 561: }
! 562: if (freeLogList)
! 563: rf_ReleaseParityLogs(raidPtr, freeLogList);
! 564: }
! 565:
! 566: int
! 567: rf_ShutdownLogging(RF_Raid_t *raidPtr)
! 568: {
! 569: /*
! 570: * Shutdown parity logging:
! 571: * 1) Disable parity logging in all regions.
! 572: * 2) Reintegrate all regions.
! 573: */
! 574:
! 575: RF_SectorCount_t diskCount;
! 576: RF_RegionId_t regionID;
! 577: RF_ParityLog_t *log;
! 578:
! 579: if (rf_parityLogDebug)
! 580: printf("[shutting down parity logging]\n");
! 581: /*
! 582: * Since parity log maps are volatile, we must reintegrate all
! 583: * regions.
! 584: */
! 585: if (rf_forceParityLogReint) {
! 586: for (regionID = 0; regionID < rf_numParityRegions; regionID++) {
! 587: RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
! 588: raidPtr->regionInfo[regionID].loggingEnabled = RF_FALSE;
! 589: log = raidPtr->regionInfo[regionID].coreLog;
! 590: raidPtr->regionInfo[regionID].coreLog = NULL;
! 591: diskCount = raidPtr->regionInfo[regionID].diskCount;
! 592: RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
! 593: if (diskCount > 0 || log != NULL)
! 594: rf_ReintegrateRegion(raidPtr, regionID, log);
! 595: if (log != NULL)
! 596: rf_ReleaseParityLogs(raidPtr, log);
! 597: }
! 598: }
! 599: if (rf_parityLogDebug) {
! 600: printf("[parity logging disabled]\n");
! 601: printf("[should be done !]\n");
! 602: }
! 603: return (0);
! 604: }
! 605:
! 606: int
! 607: rf_ParityLoggingDiskManager(RF_Raid_t *raidPtr)
! 608: {
! 609: RF_ParityLog_t *reintQueue, *flushQueue;
! 610: int workNeeded, done = RF_FALSE;
! 611: int s;
! 612:
! 613: /*
! 614: * Main program for parity logging disk thread. This routine waits
! 615: * for work to appear in either the flush or reintegration queues and
! 616: * is responsible for flushing core logs to the log disk as well as
! 617: * reintegrating parity regions.
! 618: *
! 619: * BLOCKING
! 620: */
! 621:
! 622: s = splbio();
! 623:
! 624: RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 625:
! 626: /*
! 627: * Inform our creator that we're running. Don't bother doing the
! 628: * mutex lock/unlock dance: we locked above, and we'll unlock
! 629: * below with nothing to do, yet.
! 630: */
! 631: raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_RUNNING;
! 632: RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
! 633:
! 634: /* Empty the work queues. */
! 635: flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
! 636: raidPtr->parityLogDiskQueue.flushQueue = NULL;
! 637: reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
! 638: raidPtr->parityLogDiskQueue.reintQueue = NULL;
! 639: workNeeded = (flushQueue || reintQueue);
! 640:
! 641: while (!done) {
! 642: while (workNeeded) {
! 643: /*
! 644: * First, flush all logs in the flush queue, freeing
! 645: * buffers. Second, reintegrate all regions that are
! 646: * reported as full. Third, append queued log data
! 647: * until blocked.
! 648: *
! 649: * Note: Incoming appends (ParityLogAppend) can block
! 650: * on either 1. empty buffer pool 2. region under
! 651: * reintegration. To preserve a global FIFO ordering of
! 652: * appends, buffers are not released to the world
! 653: * until those appends blocked on buffers are removed
! 654: * from the append queue. Similarly, regions that are
! 655: * reintegrated are not opened for general use until
! 656: * the append queue has been emptied.
! 657: */
! 658:
! 659: RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 660:
! 661: /*
! 662: * Empty flushQueue, using free'd log buffers to
! 663: * process bufTail.
! 664: */
! 665: if (flushQueue)
! 666: rf_FlushLogsToDisk(raidPtr, flushQueue);
! 667:
! 668: /*
! 669: * Empty reintQueue, flushing from reintTail as we go.
! 670: */
! 671: if (reintQueue)
! 672: rf_ReintegrateLogs(raidPtr, reintQueue);
! 673:
! 674: RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 675: flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
! 676: raidPtr->parityLogDiskQueue.flushQueue = NULL;
! 677: reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
! 678: raidPtr->parityLogDiskQueue.reintQueue = NULL;
! 679: workNeeded = (flushQueue || reintQueue);
! 680: }
! 681: /* No work is needed at this point. */
! 682: if (raidPtr->parityLogDiskQueue.threadState & RF_PLOG_TERMINATE) {
! 683: /*
! 684: * Shutdown parity logging:
! 685: * 1. Disable parity logging in all regions.
! 686: * 2. Reintegrate all regions.
! 687: */
! 688: done = RF_TRUE; /* Thread disabled, no work needed. */
! 689: RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 690: rf_ShutdownLogging(raidPtr);
! 691: }
! 692: if (!done) {
! 693: /* Thread enabled, no work needed, so sleep. */
! 694: if (rf_parityLogDebug)
! 695: printf("[parity logging disk manager"
! 696: " sleeping]\n");
! 697: RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
! 698: raidPtr->parityLogDiskQueue.mutex);
! 699: if (rf_parityLogDebug)
! 700: printf("[parity logging disk manager just"
! 701: " woke up]\n");
! 702: flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
! 703: raidPtr->parityLogDiskQueue.flushQueue = NULL;
! 704: reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
! 705: raidPtr->parityLogDiskQueue.reintQueue = NULL;
! 706: workNeeded = (flushQueue || reintQueue);
! 707: }
! 708: }
! 709: /*
! 710: * Announce that we're done.
! 711: */
! 712: RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 713: raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_SHUTDOWN;
! 714: RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
! 715: RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
! 716:
! 717: splx(s);
! 718:
! 719: /*
! 720: * In the Net- & OpenBSD kernel, the thread must exit; returning would
! 721: * cause the proc trampoline to attempt to return to userspace.
! 722: */
! 723: kthread_exit(0); /* does not return */
! 724: }
! 725: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_paritylogDiskMgr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe