Lines Matching defs:raidPtr
65 static void FreeRegionInfo(RF_Raid_t * raidPtr, RF_RegionId_t regionID);
76 RF_Raid_t * raidPtr,
82 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
97 raidPtr->numSectorsPerLog = RF_DEFAULT_NUM_SECTORS_PER_LOG;
100 info = RF_MallocAndAdd(sizeof(*info), raidPtr->cleanupList);
107 info->stripeIdentifier = rf_make_2d_array((raidPtr->numCol),
108 (raidPtr->numCol),
109 raidPtr->cleanupList);
114 for (i = 0; i < (raidPtr->numCol); i++) {
115 for (j = 0; j < (raidPtr->numCol); j++) {
117 (raidPtr->numCol - 1);
120 startdisk = raidPtr->numCol - 1 - 1;
127 layoutPtr->numDataCol = raidPtr->numCol - layoutPtr->numParityCol -
132 raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
135 raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
161 raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
163 printf("bytes per sector %d\n", raidPtr->bytesPerSector);
168 fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
170 for (i = 1; i < (raidPtr->numSectorsPerLog / 2); i++) {
172 raidPtr->numSectorsPerLog) < fragmentation) {
174 raidPtr->regionLogCapacity = totalLogCapacity /
176 fragmentation = raidPtr->regionLogCapacity %
177 raidPtr->numSectorsPerLog;
180 raidPtr->numSectorsPerLog) < fragmentation) {
182 raidPtr->regionLogCapacity = totalLogCapacity /
184 fragmentation = raidPtr->regionLogCapacity %
185 raidPtr->numSectorsPerLog;
189 raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity /
190 raidPtr->numSectorsPerLog) *
191 raidPtr->numSectorsPerLog;
193 raidPtr->numParityLogs = rf_totalInCoreLogCapacity /
194 (raidPtr->bytesPerSector * raidPtr->numSectorsPerLog);
197 if (raidPtr->numParityLogs < rf_numParityRegions)
198 raidPtr->numParityLogs = rf_numParityRegions;
203 raidPtr->regionInfo = RF_Malloc(
204 rf_numParityRegions * sizeof(*raidPtr->regionInfo));
205 if (raidPtr->regionInfo == NULL)
209 lastRegionCapacity = raidPtr->regionLogCapacity;
210 while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity +
213 raidPtr->numSectorsPerLog;
215 raidPtr->regionParityRange = raidPtr->sectorsPerDisk /
217 maxRegionParityRange = raidPtr->regionParityRange;
220 /* if (raidPtr->sectorsPerDisk % rf_numParityRegions > 0)
225 raidPtr->numParityLogs * raidPtr->numSectorsPerLog *
226 raidPtr->bytesPerSector,
227 raidPtr->numParityLogs);
228 raidPtr->parityLogBufferHeap = RF_Malloc(raidPtr->numParityLogs
229 * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
230 if (raidPtr->parityLogBufferHeap == NULL)
232 lHeapPtr = raidPtr->parityLogBufferHeap;
233 rf_init_mutex2(raidPtr->parityLogPool.mutex, IPL_VM);
234 for (i = 0; i < raidPtr->numParityLogs; i++) {
236 raidPtr->parityLogPool.parityLogs =
238 sizeof(*raidPtr->parityLogPool.parityLogs));
239 if (raidPtr->parityLogPool.parityLogs == NULL) {
240 RF_Free(raidPtr->parityLogBufferHeap,
241 raidPtr->numParityLogs *
242 raidPtr->numSectorsPerLog *
243 raidPtr->bytesPerSector);
246 l = raidPtr->parityLogPool.parityLogs;
250 RF_Free(raidPtr->parityLogBufferHeap,
251 raidPtr->numParityLogs *
252 raidPtr->numSectorsPerLog *
253 raidPtr->bytesPerSector);
254 for (l = raidPtr->parityLogPool.parityLogs;
259 RF_Free(l->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)));
267 lHeapPtr = (char *)lHeapPtr + raidPtr->numSectorsPerLog *
268 raidPtr->bytesPerSector;
269 l->records = RF_Malloc(raidPtr->numSectorsPerLog *
272 RF_Free(raidPtr->parityLogBufferHeap,
273 raidPtr->numParityLogs *
274 raidPtr->numSectorsPerLog *
275 raidPtr->bytesPerSector);
276 for (l = raidPtr->parityLogPool.parityLogs;
282 (raidPtr->numSectorsPerLog *
289 rf_ShutdownCreate(listp, rf_ShutdownParityLoggingPool, raidPtr);
291 rf_init_mutex2(raidPtr->regionBufferPool.mutex, IPL_VM);
292 rf_init_cond2(raidPtr->regionBufferPool.cond, "rfrbpl");
293 raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity *
294 raidPtr->bytesPerSector;
296 raidPtr->regionBufferPool.bufferSize);
299 raidPtr->regionBufferPool.totalBuffers = 1;
301 raidPtr->regionBufferPool.availableBuffers =
302 raidPtr->regionBufferPool.totalBuffers;
303 raidPtr->regionBufferPool.availBuffersIndex = 0;
304 raidPtr->regionBufferPool.emptyBuffersIndex = 0;
306 (int) (raidPtr->regionBufferPool.totalBuffers *
308 raidPtr->regionBufferPool.buffers = RF_Malloc(
309 raidPtr->regionBufferPool.totalBuffers *
310 sizeof(*raidPtr->regionBufferPool.buffers));
311 if (raidPtr->regionBufferPool.buffers == NULL) {
314 for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
316 (int) (raidPtr->regionBufferPool.bufferSize *
318 raidPtr->regionBufferPool.buffers[i] =
319 RF_Malloc(raidPtr->regionBufferPool.bufferSize);
320 if (raidPtr->regionBufferPool.buffers[i] == NULL) {
322 RF_Free(raidPtr->regionBufferPool.buffers[i],
323 raidPtr->regionBufferPool.bufferSize *
326 RF_Free(raidPtr->regionBufferPool.buffers,
327 raidPtr->regionBufferPool.totalBuffers *
331 printf("raidPtr->regionBufferPool.buffers[%d] = %lx\n", i,
332 (long) raidPtr->regionBufferPool.buffers[i]);
336 raidPtr);
339 rf_init_mutex2(raidPtr->parityBufferPool.mutex, IPL_VM);
340 rf_init_cond2(raidPtr->parityBufferPool.cond, "rfpbpl");
341 raidPtr->parityBufferPool.bufferSize = parityBufferCapacity *
342 raidPtr->bytesPerSector;
344 raidPtr->parityBufferPool.bufferSize);
347 raidPtr->parityBufferPool.totalBuffers = 1;
349 raidPtr->parityBufferPool.availableBuffers =
350 raidPtr->parityBufferPool.totalBuffers;
351 raidPtr->parityBufferPool.availBuffersIndex = 0;
352 raidPtr->parityBufferPool.emptyBuffersIndex = 0;
354 (int) (raidPtr->parityBufferPool.totalBuffers *
356 raidPtr->parityBufferPool.totalBuffers );
357 raidPtr->parityBufferPool.buffers = RF_Malloc(
358 raidPtr->parityBufferPool.totalBuffers *
359 sizeof(*raidPtr->parityBufferPool.buffers));
360 if (raidPtr->parityBufferPool.buffers == NULL) {
363 for (i = 0; i < raidPtr->parityBufferPool.totalBuffers; i++) {
365 (int) (raidPtr->parityBufferPool.bufferSize *
367 raidPtr->parityBufferPool.buffers[i] = RF_Malloc(
368 raidPtr->parityBufferPool.bufferSize);
369 if (raidPtr->parityBufferPool.buffers == NULL) {
371 RF_Free(raidPtr->parityBufferPool.buffers[i],
372 raidPtr->regionBufferPool.bufferSize *
375 RF_Free(raidPtr->parityBufferPool.buffers,
376 raidPtr->regionBufferPool.totalBuffers *
381 (long) raidPtr->parityBufferPool.buffers[i]);
385 raidPtr);
387 rf_init_mutex2(raidPtr->parityLogDiskQueue.mutex, IPL_VM);
388 rf_init_cond2(raidPtr->parityLogDiskQueue.cond, "rfpldq");
389 raidPtr->parityLogDiskQueue.flushQueue = NULL;
390 raidPtr->parityLogDiskQueue.reintQueue = NULL;
391 raidPtr->parityLogDiskQueue.bufHead = NULL;
392 raidPtr->parityLogDiskQueue.bufTail = NULL;
393 raidPtr->parityLogDiskQueue.reintHead = NULL;
394 raidPtr->parityLogDiskQueue.reintTail = NULL;
395 raidPtr->parityLogDiskQueue.logBlockHead = NULL;
396 raidPtr->parityLogDiskQueue.logBlockTail = NULL;
397 raidPtr->parityLogDiskQueue.reintBlockHead = NULL;
398 raidPtr->parityLogDiskQueue.reintBlockTail = NULL;
399 raidPtr->parityLogDiskQueue.freeDataList = NULL;
400 raidPtr->parityLogDiskQueue.freeCommonList = NULL;
404 raidPtr);
406 rf_init_mutex2(raidPtr->regionInfo[i].mutex, IPL_VM);
407 rf_init_mutex2(raidPtr->regionInfo[i].reintMutex, IPL_VM);
408 raidPtr->regionInfo[i].reintInProgress = RF_FALSE;
409 raidPtr->regionInfo[i].regionStartAddr =
410 raidPtr->regionLogCapacity * i;
411 raidPtr->regionInfo[i].parityStartAddr =
412 raidPtr->regionParityRange * i;
414 raidPtr->regionInfo[i].capacity =
415 raidPtr->regionLogCapacity;
416 raidPtr->regionInfo[i].numSectorsParity =
417 raidPtr->regionParityRange;
419 raidPtr->regionInfo[i].capacity =
421 raidPtr->regionInfo[i].numSectorsParity =
422 raidPtr->sectorsPerDisk -
423 raidPtr->regionParityRange * i;
424 if (raidPtr->regionInfo[i].numSectorsParity >
427 raidPtr->regionInfo[i].numSectorsParity;
429 raidPtr->regionInfo[i].diskCount = 0;
430 RF_ASSERT(raidPtr->regionInfo[i].capacity +
431 raidPtr->regionInfo[i].regionStartAddr <=
433 RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr +
434 raidPtr->regionInfo[i].numSectorsParity <=
435 raidPtr->sectorsPerDisk);
437 (int) (raidPtr->regionInfo[i].capacity *
439 raidPtr->regionInfo[i].diskMap = RF_Malloc(
440 raidPtr->regionInfo[i].capacity *
441 sizeof(*raidPtr->regionInfo[i].diskMap));
442 if (raidPtr
444 FreeRegionInfo(raidPtr, j);
445 RF_Free(raidPtr->regionInfo,
450 raidPtr->regionInfo[i].loggingEnabled = RF_FALSE;
451 raidPtr->regionInfo[i].coreLog = NULL;
455 raidPtr);
456 RF_ASSERT(raidPtr->parityLogDiskQueue.threadState == 0);
457 raidPtr->parityLogDiskQueue.threadState = RF_PLOG_CREATED;
458 rc = RF_CREATE_THREAD(raidPtr->pLogDiskThreadHandle,
459 rf_ParityLoggingDiskManager, raidPtr,"rf_log");
461 raidPtr->parityLogDiskQueue.threadState = 0;
467 rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
468 while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
469 rf_wait_cond2(raidPtr->parityLogDiskQueue.cond,
470 raidPtr->parityLogDiskQueue.mutex);
472 rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
474 rf_ShutdownCreate(listp, rf_ShutdownParityLogging, raidPtr);
479 printf(" nominal sectors of log per parity region is %d\n", (int) raidPtr->regionLogCapacity);
481 printf(" total number of parity logs is %d\n", raidPtr->numParityLogs);
482 printf(" parity log size is %d sectors\n", raidPtr->numSectorsPerLog);
485 rf_EnableParityLogging(raidPtr);
492 RF_Raid_t * raidPtr,
495 RF_Free(raidPtr->regionInfo[regionID].diskMap,
496 (raidPtr->regionInfo[regionID].capacity *
498 if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
499 rf_ReleaseParityLogs(raidPtr,
500 raidPtr->regionInfo[regionID].coreLog);
501 raidPtr->regionInfo[regionID].coreLog = NULL;
503 RF_ASSERT(raidPtr->regionInfo[regionID].coreLog == NULL);
504 RF_ASSERT(raidPtr->regionInfo[regionID].diskCount == 0);
506 rf_destroy_mutex2(raidPtr->regionInfo[regionID].reintMutex);
507 rf_destroy_mutex2(raidPtr->regionInfo[regionID].mutex);
512 FreeParityLogQueue(RF_Raid_t * raidPtr)
516 l1 = raidPtr->parityLogPool.parityLogs;
520 RF_Free(l2->records, (raidPtr->numSectorsPerLog *
524 rf_destroy_mutex2(raidPtr->parityLogPool.mutex);
547 RF_Raid_t *raidPtr;
550 raidPtr = (RF_Raid_t *) arg;
553 raidPtr->raidid);
557 FreeRegionInfo(raidPtr, i);
558 RF_Free(raidPtr->regionInfo, (rf_numParityRegions *
559 sizeof(raidPtr->regionInfo)));
560 raidPtr->regionInfo = NULL;
566 RF_Raid_t *raidPtr;
568 raidPtr = (RF_Raid_t *) arg;
570 printf("raid%d: ShutdownParityLoggingPool\n", raidPtr->raidid);
573 FreeParityLogQueue(raidPtr);
574 RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
575 raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
581 RF_Raid_t *raidPtr;
583 raidPtr = (RF_Raid_t *) arg;
586 raidPtr->raidid);
588 FreeRegionBufferQueue(&raidPtr->regionBufferPool);
594 RF_Raid_t *raidPtr;
596 raidPtr = (RF_Raid_t *) arg;
599 raidPtr->raidid);
601 FreeRegionBufferQueue(&raidPtr->parityBufferPool);
609 RF_Raid_t *raidPtr;
611 raidPtr = (RF_Raid_t *) arg;
614 raidPtr->raidid);
617 RF_ASSERT(raidPtr->parityLogDiskQueue.bufHead == NULL);
618 RF_ASSERT(raidPtr->parityLogDiskQueue.bufTail == NULL);
619 RF_ASSERT(raidPtr->parityLogDiskQueue.reintHead == NULL);
620 RF_ASSERT(raidPtr->parityLogDiskQueue.reintTail == NULL);
621 while (raidPtr->parityLogDiskQueue.freeDataList) {
622 d = raidPtr->parityLogDiskQueue.freeDataList;
623 raidPtr->parityLogDiskQueue.freeDataList =
624 raidPtr->parityLogDiskQueue.freeDataList->next;
627 while (raidPtr->parityLogDiskQueue.freeCommonList) {
628 c = raidPtr->parityLogDiskQueue.freeCommonList;
629 raidPtr->parityLogDiskQueue.freeCommonList = c->next;
635 rf_destroy_mutex2(raidPtr->parityLogDiskQueue.mutex);
636 rf_destroy_cond2(raidPtr->parityLogDiskQueue.cond);
642 RF_Raid_t *raidPtr;
644 raidPtr = (RF_Raid_t *) arg;
646 printf("raid%d: ShutdownParityLogging\n", raidPtr->raidid);
653 rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
654 raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_TERMINATE;
655 rf_signal_cond2(raidPtr->parityLogDiskQueue.cond);
656 rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
661 rf_lock_mutex2(raidPtr->parityLogDiskQueue.mutex);
662 while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
663 rf_wait_cond2(raidPtr->parityLogDiskQueue.cond,
664 raidPtr->parityLogDiskQueue.mutex);
666 rf_unlock_mutex2(raidPtr->parityLogDiskQueue.mutex);
668 printf("raid%d: ShutdownParityLogging done (thread completed)\n", raidPtr->raidid);
673 rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t * raidPtr)
679 rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t * raidPtr)
686 RF_Raid_t * raidPtr,
691 /* regionID = address / (raidPtr->regionParityRange * raidPtr->Layout.numDataCol); */
692 regionID = address / raidPtr->regionParityRange;
697 RF_ASSERT(address >= raidPtr->regionInfo[regionID].parityStartAddr);
698 RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr +
699 raidPtr->regionInfo[regionID].numSectorsParity);
708 RF_Raid_t * raidPtr,
715 raidPtr->Layout.sectorsPerStripeUnit;
716 /* *col = (SUID % (raidPtr->numCol -
717 * raidPtr->Layout.numParityLogCol)); */
718 *col = SUID % raidPtr->Layout.numDataCol;
719 *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
720 raidPtr->Layout.sectorsPerStripeUnit +
721 (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
728 RF_Raid_t * raidPtr,
735 raidPtr->Layout.sectorsPerStripeUnit;
738 * raidPtr->Layout.numDataCol-(SUID/raidPtr->Layout.numDataCol)%(raidPt
739 * r->numCol - raidPtr->Layout.numParityLogCol); */
740 *col = raidPtr->Layout.numDataCol;
741 *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
742 raidPtr->Layout.sectorsPerStripeUnit +
743 (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
750 RF_Raid_t * raidPtr,
756 *col = raidPtr->numCol - 1;
757 *startSector = raidPtr->regionInfo[regionID].regionStartAddr + regionOffset;
765 RF_Raid_t * raidPtr,
771 *col = raidPtr->numCol - 2;
772 *startSector = raidPtr->regionInfo[regionID].parityStartAddr;
773 *numSector = raidPtr->regionInfo[regionID].numSectorsParity;
781 RF_Raid_t * raidPtr,
785 RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
788 raidPtr->Layout.layoutSpecificInfo;
789 *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
811 RF_Raid_t * raidPtr,
816 RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
836 rstat = raidPtr->status;
839 rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, failedPDA->startSector) : 0
851 (layoutPtr->map->MapParity) (raidPtr, failedPDA->raidAddress,
871 (layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress,
879 failedPDA->col = raidPtr->Disks[fcol].spareCol;
898 raidPtr->raidid, type, oc, (long) oo, failedPDA->col, (long) failedPDA->startSector);
926 rf_CheckStripeForFailures(raidPtr, asmp)) {
Indexes created Sat Sep 27 14:09:57 GMT 2025