raidPtr 65 dev/raidframe/rf_aselect.c rf_InitHdrNode(RF_DagHeader_t **hdr, RF_Raid_t *raidPtr, int memChunkEnable)
raidPtr 76 dev/raidframe/rf_aselect.c (*hdr)->raidPtr = raidPtr;
raidPtr 218 dev/raidframe/rf_aselect.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 263 dev/raidframe/rf_aselect.c (raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_p,
raidPtr 314 dev/raidframe/rf_aselect.c rf_MapAccess(raidPtr, address, length,
raidPtr 322 dev/raidframe/rf_aselect.c (raidPtr->Layout.map->SelectionFunc) (raidPtr,
raidPtr 346 dev/raidframe/rf_aselect.c raidPtr->Layout.numDataCol,
raidPtr 354 dev/raidframe/rf_aselect.c raidPtr->Layout.numDataCol,
raidPtr 388 dev/raidframe/rf_aselect.c raidPtr->logBytesPerSector));
raidPtr 391 dev/raidframe/rf_aselect.c = rf_MapAccess(raidPtr,
raidPtr 401 dev/raidframe/rf_aselect.c (raidPtr->Layout.map->
raidPtr 402 dev/raidframe/rf_aselect.c SelectionFunc) (raidPtr,
raidPtr 489 dev/raidframe/rf_aselect.c raidPtr,
raidPtr 508 dev/raidframe/rf_aselect.c (*bFunc) (raidPtr,
raidPtr 520 dev/raidframe/rf_aselect.c raidPtr, rf_useMemChunks);
raidPtr 532 dev/raidframe/rf_aselect.c (*uFunc) (raidPtr, asm_up,
raidPtr 545 dev/raidframe/rf_aselect.c rf_InitHdrNode(&tempdag_h, raidPtr,
raidPtr 555 dev/raidframe/rf_aselect.c (stripeFuncs[i]) (raidPtr, asm_p, tempdag_h,
raidPtr 648 dev/raidframe/rf_aselect.c RF_Free(blockFuncs, raidPtr->Layout.numDataCol
raidPtr 651 dev/raidframe/rf_aselect.c RF_Free(asmh_b, raidPtr->Layout.numDataCol *
raidPtr 62 dev/raidframe/rf_chaindecluster.c rf_ConfigureChainDecluster(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 65 dev/raidframe/rf_chaindecluster.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 72 dev/raidframe/rf_chaindecluster.c (RF_ChaindeclusterConfigInfo_t *), raidPtr->cleanupList);
raidPtr 78 dev/raidframe/rf_chaindecluster.c info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, 2,
raidPtr 79 dev/raidframe/rf_chaindecluster.c raidPtr->cleanupList);
raidPtr 82 dev/raidframe/rf_chaindecluster.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 83 dev/raidframe/rf_chaindecluster.c info->stripeIdentifier[i][0] = i % raidPtr->numCol;
raidPtr 84 dev/raidframe/rf_chaindecluster.c info->stripeIdentifier[i][1] = (i + 1) % raidPtr->numCol;
raidPtr 87 dev/raidframe/rf_chaindecluster.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 91 dev/raidframe/rf_chaindecluster.c (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol - 2));
raidPtr 93 dev/raidframe/rf_chaindecluster.c (2 * raidPtr->numCol - 2);
raidPtr 94 dev/raidframe/rf_chaindecluster.c info->stripeUnitsPerSparingRegion = raidPtr->numCol *
raidPtr 95 dev/raidframe/rf_chaindecluster.c (raidPtr->numCol - 1);
raidPtr 97 dev/raidframe/rf_chaindecluster.c (raidPtr->numCol - 1);
raidPtr 101 dev/raidframe/rf_chaindecluster.c raidPtr->logBytesPerSector;
raidPtr 109 dev/raidframe/rf_chaindecluster.c raidPtr->sectorsPerDisk = num_used_stripeUnitsPerDisk *
raidPtr 112 dev/raidframe/rf_chaindecluster.c raidPtr->totalSectors = (layoutPtr->numStripe) *
raidPtr 115 dev/raidframe/rf_chaindecluster.c layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
raidPtr 122 dev/raidframe/rf_chaindecluster.c rf_GetNumSpareRUsChainDecluster(RF_Raid_t *raidPtr)
raidPtr 125 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 137 dev/raidframe/rf_chaindecluster.c rf_MapSectorChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 141 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 142 dev/raidframe/rf_chaindecluster.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 150 dev/raidframe/rf_chaindecluster.c index_within_disk = index_within_region / raidPtr->numCol;
raidPtr 151 dev/raidframe/rf_chaindecluster.c col_before_remap = SUID % raidPtr->numCol;
raidPtr 155 dev/raidframe/rf_chaindecluster.c *diskSector = (index_within_disk + ((raidPtr->numCol - 1) *
raidPtr 156 dev/raidframe/rf_chaindecluster.c sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 158 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 161 dev/raidframe/rf_chaindecluster.c *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
raidPtr 162 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 163 dev/raidframe/rf_chaindecluster.c *diskSector += (raidPtr->numCol - 1) *
raidPtr 164 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 166 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 167 dev/raidframe/rf_chaindecluster.c index_within_disk = index_within_region / raidPtr->numCol;
raidPtr 171 dev/raidframe/rf_chaindecluster.c if (index_within_disk == raidPtr->numCol - 2) {
raidPtr 172 dev/raidframe/rf_chaindecluster.c *col = (col_before_remap + raidPtr->numCol - 1)
raidPtr 173 dev/raidframe/rf_chaindecluster.c % raidPtr->numCol;
raidPtr 175 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 178 dev/raidframe/rf_chaindecluster.c raidPtr->numCol;
raidPtr 191 dev/raidframe/rf_chaindecluster.c rf_MapParityChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 195 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 196 dev/raidframe/rf_chaindecluster.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 203 dev/raidframe/rf_chaindecluster.c *col = SUID % raidPtr->numCol;
raidPtr 204 dev/raidframe/rf_chaindecluster.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 206 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 207 dev/raidframe/rf_chaindecluster.c *diskSector += (SUID / raidPtr->numCol) *
raidPtr 208 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 210 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 215 dev/raidframe/rf_chaindecluster.c index_within_disk = index_within_region / raidPtr->numCol;
raidPtr 216 dev/raidframe/rf_chaindecluster.c *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
raidPtr 217 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 218 dev/raidframe/rf_chaindecluster.c *diskSector += (raidPtr->numCol) *
raidPtr 219 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 221 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 222 dev/raidframe/rf_chaindecluster.c col_before_remap = SUID % raidPtr->numCol;
raidPtr 226 dev/raidframe/rf_chaindecluster.c if (index_within_disk == raidPtr->numCol - 2) {
raidPtr 227 dev/raidframe/rf_chaindecluster.c *col = (col_before_remap + 2) % raidPtr->numCol;
raidPtr 229 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 232 dev/raidframe/rf_chaindecluster.c raidPtr->numCol;
raidPtr 237 dev/raidframe/rf_chaindecluster.c rf_IdentifyStripeChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 241 dev/raidframe/rf_chaindecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 245 dev/raidframe/rf_chaindecluster.c SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 246 dev/raidframe/rf_chaindecluster.c col = SUID % raidPtr->numCol;
raidPtr 270 dev/raidframe/rf_chaindecluster.c rf_RAIDCDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 274 dev/raidframe/rf_chaindecluster.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 287 dev/raidframe/rf_chaindecluster.c if ((raidPtr->status[0] == rf_rs_degraded) ||
raidPtr 288 dev/raidframe/rf_chaindecluster.c (raidPtr->status[0] == rf_rs_reconstructing))
raidPtr 90 dev/raidframe/rf_copyback.c rf_CopybackReconstructedData(RF_Raid_t *raidPtr)
raidPtr 108 dev/raidframe/rf_copyback.c for (frow = 0; frow < raidPtr->numRow; frow++) {
raidPtr 109 dev/raidframe/rf_copyback.c for (fcol = 0; fcol < raidPtr->numCol; fcol++) {
raidPtr 110 dev/raidframe/rf_copyback.c if (raidPtr->Disks[frow][fcol].status ==
raidPtr 112 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].status ==
raidPtr 122 dev/raidframe/rf_copyback.c if (frow == raidPtr->numRow) {
raidPtr 126 dev/raidframe/rf_copyback.c badDisk = &raidPtr->Disks[frow][fcol];
raidPtr 128 dev/raidframe/rf_copyback.c proc = raidPtr->engine_thread;
raidPtr 135 dev/raidframe/rf_copyback.c if (raidPtr->raid_cinfo[frow][fcol].ci_vp != NULL) {
raidPtr 137 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].devname);
raidPtr 138 dev/raidframe/rf_copyback.c vp = raidPtr->raid_cinfo[frow][fcol].ci_vp;
raidPtr 139 dev/raidframe/rf_copyback.c ac = raidPtr->Disks[frow][fcol].auto_configured;
raidPtr 140 dev/raidframe/rf_copyback.c rf_close_component(raidPtr, vp, ac);
raidPtr 141 dev/raidframe/rf_copyback.c raidPtr->raid_cinfo[frow][fcol].ci_vp = NULL;
raidPtr 145 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].auto_configured = 0;
raidPtr 148 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].devname);
raidPtr 150 dev/raidframe/rf_copyback.c retcode = raidlookup(raidPtr->Disks[frow][fcol].devname, proc, &vp);
raidPtr 154 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].devname, retcode);
raidPtr 178 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].blockSize = dpart.disklab->d_secsize;
raidPtr 180 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].numBlocks = DL_GETPSIZE(dpart.part) -
raidPtr 183 dev/raidframe/rf_copyback.c raidPtr->raid_cinfo[frow][fcol].ci_vp = vp;
raidPtr 184 dev/raidframe/rf_copyback.c raidPtr->raid_cinfo[frow][fcol].ci_dev = va.va_rdev;
raidPtr 187 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].dev = va.va_rdev;
raidPtr 194 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].numBlocks =
raidPtr 195 dev/raidframe/rf_copyback.c raidPtr->Disks[frow][fcol].numBlocks *
raidPtr 220 dev/raidframe/rf_copyback.c RF_Malloc(databuf, rf_RaidAddressToByte(raidPtr,
raidPtr 221 dev/raidframe/rf_copyback.c raidPtr->Layout.sectorsPerStripeUnit), (char *));
raidPtr 225 dev/raidframe/rf_copyback.c desc->raidPtr = raidPtr;
raidPtr 232 dev/raidframe/rf_copyback.c desc->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 233 dev/raidframe/rf_copyback.c desc->sectPerStripe = raidPtr->Layout.sectorsPerStripeUnit *
raidPtr 234 dev/raidframe/rf_copyback.c raidPtr->Layout.numDataCol;
raidPtr 243 dev/raidframe/rf_copyback.c rf_SuspendNewRequestsAndWait(raidPtr);
raidPtr 246 dev/raidframe/rf_copyback.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 247 dev/raidframe/rf_copyback.c raidPtr->Disks[desc->frow][desc->fcol].status = rf_ds_optimal;
raidPtr 248 dev/raidframe/rf_copyback.c raidPtr->status[desc->frow] = rf_rs_optimal;
raidPtr 250 dev/raidframe/rf_copyback.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 261 dev/raidframe/rf_copyback.c raidread_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
raidPtr 262 dev/raidframe/rf_copyback.c raidPtr->raid_cinfo[frow][fcol].ci_vp,
raidPtr 265 dev/raidframe/rf_copyback.c raid_init_component_label(raidPtr, &c_label);
raidPtr 270 dev/raidframe/rf_copyback.c raidwrite_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
raidPtr 271 dev/raidframe/rf_copyback.c raidPtr->raid_cinfo[frow][fcol].ci_vp,
raidPtr 284 dev/raidframe/rf_copyback.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 293 dev/raidframe/rf_copyback.c desc->raidPtr->copyback_stripes_done = stripeAddr /
raidPtr 297 dev/raidframe/rf_copyback.c raidPtr->totalSectors;
raidPtr 302 dev/raidframe/rf_copyback.c raidPtr->totalSectors;
raidPtr 310 dev/raidframe/rf_copyback.c if (stripeAddr >= raidPtr->totalSectors) {
raidPtr 320 dev/raidframe/rf_copyback.c (raidPtr->Layout.map->MapSector) (raidPtr, addr,
raidPtr 341 dev/raidframe/rf_copyback.c (raidPtr->Layout.map->MapParity) (raidPtr, stripeAddr,
raidPtr 368 dev/raidframe/rf_copyback.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 374 dev/raidframe/rf_copyback.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 376 dev/raidframe/rf_copyback.c raidPtr->Layout.map->MapSector(raidPtr, addr, &spRow,
raidPtr 379 dev/raidframe/rf_copyback.c raidPtr->Layout.map->MapParity(raidPtr, addr, &spRow,
raidPtr 388 dev/raidframe/rf_copyback.c rf_CopybackReadDoneProc, desc, NULL, NULL, (void *) raidPtr,
raidPtr 392 dev/raidframe/rf_copyback.c rf_CopybackWriteDoneProc, desc, NULL, NULL, (void *) raidPtr,
raidPtr 407 dev/raidframe/rf_copyback.c rf_DiskIOEnqueue(&raidPtr->Queues[spRow][spCol], desc->readreq,
raidPtr 431 dev/raidframe/rf_copyback.c rf_DiskIOEnqueue(&(desc->raidPtr
raidPtr 462 dev/raidframe/rf_copyback.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 466 dev/raidframe/rf_copyback.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 467 dev/raidframe/rf_copyback.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 468 dev/raidframe/rf_copyback.c RF_ASSERT(raidPtr->Layout.map->parityConfig == 'D');
raidPtr 469 dev/raidframe/rf_copyback.c rf_FreeSpareTable(raidPtr);
raidPtr 471 dev/raidframe/rf_copyback.c raidPtr->Disks[desc->spRow][desc->spCol].status =
raidPtr 474 dev/raidframe/rf_copyback.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 483 dev/raidframe/rf_copyback.c RF_Free(desc->databuf, rf_RaidAddressToByte(raidPtr, desc->sectPerSU));
raidPtr 488 dev/raidframe/rf_copyback.c rf_ResumeNewRequests(raidPtr);
raidPtr 40 dev/raidframe/rf_copyback.h RF_Raid_t *raidPtr;
raidPtr 268 dev/raidframe/rf_dag.h RF_Raid_t *raidPtr; /*
raidPtr 343 dev/raidframe/rf_dag.h RF_Raid_t *raidPtr, \
raidPtr 78 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 85 dev/raidframe/rf_dagdegrd.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 115 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 129 dev/raidframe/rf_dagdegrd.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 259 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 281 dev/raidframe/rf_dagdegrd.c layoutPtr = &(raidPtr->Layout);
raidPtr 305 dev/raidframe/rf_dagdegrd.c rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h,
raidPtr 453 dev/raidframe/rf_dagdegrd.c rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
raidPtr 470 dev/raidframe/rf_dagdegrd.c xorNode->params[paramNum++].p = raidPtr;
raidPtr 479 dev/raidframe/rf_dagdegrd.c RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
raidPtr 561 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 581 dev/raidframe/rf_dagdegrd.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 634 dev/raidframe/rf_dagdegrd.c if (shiftable && rf_compute_workload_shift(raidPtr, pda)) {
raidPtr 694 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 703 dev/raidframe/rf_dagdegrd.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 734 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,num),(char *), allocList); \
raidPtr 842 dev/raidframe/rf_dagdegrd.c firstDataCol = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 851 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
raidPtr 854 dev/raidframe/rf_dagdegrd.c if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
raidPtr 862 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 868 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, secPerSU),
raidPtr 876 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 881 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 888 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 915 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 919 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 932 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 936 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 948 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 952 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 961 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector)
raidPtr 962 dev/raidframe/rf_dagdegrd.c (raidPtr, pda_p->raidAddress,
raidPtr 966 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 984 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector)
raidPtr 985 dev/raidframe/rf_dagdegrd.c (raidPtr, pda_p->raidAddress,
raidPtr 989 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 1004 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector)
raidPtr 1005 dev/raidframe/rf_dagdegrd.c (raidPtr, pda_p->raidAddress,
raidPtr 1009 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 1026 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector)
raidPtr 1027 dev/raidframe/rf_dagdegrd.c (raidPtr, pda_p->raidAddress,
raidPtr 1031 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 1046 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector)
raidPtr 1047 dev/raidframe/rf_dagdegrd.c (raidPtr, pda_p->raidAddress,
raidPtr 1051 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr,
raidPtr 1069 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
raidPtr 1072 dev/raidframe/rf_dagdegrd.c if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
raidPtr 1080 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 1086 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, secPerSU),
raidPtr 1094 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 1099 dev/raidframe/rf_dagdegrd.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 1106 dev/raidframe/rf_dagdegrd.c rf_RaidAddressToByte(raidPtr, pda_p->numSector),
raidPtr 1139 dev/raidframe/rf_dagdegrd.c RF_Raid_t *raidPtr,
raidPtr 1150 dev/raidframe/rf_dagdegrd.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 1165 dev/raidframe/rf_dagdegrd.c rf_DD_GenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes,
raidPtr 1288 dev/raidframe/rf_dagdegrd.c recoveryNode->params[i++].p = (void *) raidPtr;
raidPtr 79 dev/raidframe/rf_dagdegwr.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 84 dev/raidframe/rf_dagdegwr.c rf_CreateDegradedWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 88 dev/raidframe/rf_dagdegwr.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 107 dev/raidframe/rf_dagdegwr.c rf_CreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 154 dev/raidframe/rf_dagdegwr.c rf_CommonCreateSimpleDegradedWriteDAG(RF_Raid_t *raidPtr,
raidPtr 176 dev/raidframe/rf_dagdegwr.c layoutPtr = &(raidPtr->Layout);
raidPtr 199 dev/raidframe/rf_dagdegwr.c rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h,
raidPtr 361 dev/raidframe/rf_dagdegwr.c RF_CallocAndAdd(xorTargetBuf, 1, rf_RaidAddressToByte(raidPtr,
raidPtr 392 dev/raidframe/rf_dagdegwr.c rf_RaidAddressToByte(raidPtr, failedPDA->numSector),
raidPtr 441 dev/raidframe/rf_dagdegwr.c rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
raidPtr 463 dev/raidframe/rf_dagdegwr.c xorNode->params[paramNum++].p = raidPtr;
raidPtr 558 dev/raidframe/rf_dagdegwr.c rf_RaidAddressToByte(raidPtr,num),(char *), allocList); \
raidPtr 562 dev/raidframe/rf_dagdegwr.c rf_WriteGenerateFailedAccessASMs(RF_Raid_t *raidPtr,
raidPtr 566 dev/raidframe/rf_dagdegwr.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 659 dev/raidframe/rf_dagdegwr.c (raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
raidPtr 662 dev/raidframe/rf_dagdegwr.c if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
raidPtr 670 dev/raidframe/rf_dagdegwr.c raidPtr, pda_p->numSector), (char *), allocList);
raidPtr 675 dev/raidframe/rf_dagdegwr.c raidPtr, secPerSU), (char *), allocList);
raidPtr 682 dev/raidframe/rf_dagdegwr.c raidPtr, pda_p->numSector), (char *), allocList);
raidPtr 686 dev/raidframe/rf_dagdegwr.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 693 dev/raidframe/rf_dagdegwr.c raidPtr, pda_p->numSector), (char *), allocList);
raidPtr 716 dev/raidframe/rf_dagdegwr.c rf_DoubleDegSmallWrite(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 722 dev/raidframe/rf_dagdegwr.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 752 dev/raidframe/rf_dagdegwr.c rf_WriteGenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes,
raidPtr 863 dev/raidframe/rf_dagdegwr.c recoveryNode->params[nReadNodes + nWudNodes + 1].p = raidPtr;
raidPtr 82 dev/raidframe/rf_dagffrd.c RF_Raid_t *raidPtr,
raidPtr 90 dev/raidframe/rf_dagffrd.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 137 dev/raidframe/rf_dagffrd.c RF_Raid_t *raidPtr,
raidPtr 324 dev/raidframe/rf_dagffrd.c RF_Raid_t *raidPtr,
raidPtr 435 dev/raidframe/rf_dagffrd.c RF_Raid_t *raidPtr,
raidPtr 443 dev/raidframe/rf_dagffrd.c rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 449 dev/raidframe/rf_dagffrd.c RF_Raid_t *raidPtr,
raidPtr 457 dev/raidframe/rf_dagffrd.c rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 79 dev/raidframe/rf_dagffwr.c rf_CreateNonRedundantWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 83 dev/raidframe/rf_dagffwr.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 88 dev/raidframe/rf_dagffwr.c rf_CreateRAID0WriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 92 dev/raidframe/rf_dagffwr.c rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 97 dev/raidframe/rf_dagffwr.c rf_CreateSmallWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 102 dev/raidframe/rf_dagffwr.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 107 dev/raidframe/rf_dagffwr.c rf_CreateLargeWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 112 dev/raidframe/rf_dagffwr.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 156 dev/raidframe/rf_dagffwr.c rf_CommonCreateLargeWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 171 dev/raidframe/rf_dagffwr.c layoutPtr = &(raidPtr->Layout);
raidPtr 207 dev/raidframe/rf_dagffwr.c rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
raidPtr 297 dev/raidframe/rf_dagffwr.c xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
raidPtr 308 dev/raidframe/rf_dagffwr.c ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 314 dev/raidframe/rf_dagffwr.c rf_RaidAddressToByte(raidPtr,
raidPtr 315 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit),
raidPtr 341 dev/raidframe/rf_dagffwr.c rf_RaidAddressToByte(raidPtr,
raidPtr 342 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit),
raidPtr 467 dev/raidframe/rf_dagffwr.c rf_CommonCreateSmallWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 489 dev/raidframe/rf_dagffwr.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 606 dev/raidframe/rf_dagffwr.c readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
raidPtr 628 dev/raidframe/rf_dagffwr.c readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
raidPtr 651 dev/raidframe/rf_dagffwr.c readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
raidPtr 707 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit))) {
raidPtr 748 dev/raidframe/rf_dagffwr.c xorNodes[i].params[6].p = raidPtr;
raidPtr 767 dev/raidframe/rf_dagffwr.c qNodes[i].params[6].p = raidPtr;
raidPtr 796 dev/raidframe/rf_dagffwr.c raidPtr;
raidPtr 828 dev/raidframe/rf_dagffwr.c [2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;
raidPtr 1132 dev/raidframe/rf_dagffwr.c rf_CreateRaidOneWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 1143 dev/raidframe/rf_dagffwr.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 1292 dev/raidframe/rf_dagffwr.c rf_CommonCreateLargeWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 1307 dev/raidframe/rf_dagffwr.c layoutPtr = &(raidPtr->Layout);
raidPtr 1308 dev/raidframe/rf_dagffwr.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 1342 dev/raidframe/rf_dagffwr.c rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
raidPtr 1427 dev/raidframe/rf_dagffwr.c xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
raidPtr 1438 dev/raidframe/rf_dagffwr.c ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 1443 dev/raidframe/rf_dagffwr.c rf_RaidAddressToByte(raidPtr,
raidPtr 1444 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit),
raidPtr 1469 dev/raidframe/rf_dagffwr.c rf_RaidAddressToByte(raidPtr,
raidPtr 1470 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit),
raidPtr 1598 dev/raidframe/rf_dagffwr.c rf_CommonCreateSmallWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 1620 dev/raidframe/rf_dagffwr.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 1726 dev/raidframe/rf_dagffwr.c readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
raidPtr 1747 dev/raidframe/rf_dagffwr.c readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
raidPtr 1769 dev/raidframe/rf_dagffwr.c readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
raidPtr 1824 dev/raidframe/rf_dagffwr.c raidPtr->Layout.sectorsPerStripeUnit))) {
raidPtr 1858 dev/raidframe/rf_dagffwr.c xorNodes[i].params[6].p = raidPtr;
raidPtr 1877 dev/raidframe/rf_dagffwr.c qNodes[i].params[6].p = raidPtr;
raidPtr 1905 dev/raidframe/rf_dagffwr.c raidPtr; /* xor node needs to get at RAID information */
raidPtr 1941 dev/raidframe/rf_dagffwr.c raidPtr;
raidPtr 2229 dev/raidframe/rf_dagffwr.c rf_CreateRaidOneWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 2240 dev/raidframe/rf_dagffwr.c parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 183 dev/raidframe/rf_dagfuncs.c (RF_Raid_t *) (node->dagHdr->raidPtr),
raidPtr 214 dev/raidframe/rf_dagfuncs.c (RF_Raid_t *) (node->dagHdr->raidPtr), node->wakeFunc,
raidPtr 289 dev/raidframe/rf_dagfuncs.c RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
raidPtr 303 dev/raidframe/rf_dagfuncs.c (void *) (node->dagHdr->raidPtr), flags, b_proc);
raidPtr 331 dev/raidframe/rf_dagfuncs.c RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
raidPtr 344 dev/raidframe/rf_dagfuncs.c node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
raidPtr 366 dev/raidframe/rf_dagfuncs.c RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
raidPtr 370 dev/raidframe/rf_dagfuncs.c NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
raidPtr 391 dev/raidframe/rf_dagfuncs.c RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
raidPtr 395 dev/raidframe/rf_dagfuncs.c NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
raidPtr 480 dev/raidframe/rf_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 491 dev/raidframe/rf_dagfuncs.c retcode = rf_XorIntoBuffer(raidPtr,
raidPtr 509 dev/raidframe/rf_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 522 dev/raidframe/rf_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 546 dev/raidframe/rf_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 547 dev/raidframe/rf_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 567 dev/raidframe/rf_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 570 dev/raidframe/rf_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 596 dev/raidframe/rf_dagfuncs.c rf_XorIntoBuffer(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, char *srcbuf,
raidPtr 600 dev/raidframe/rf_dagfuncs.c int sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 606 dev/raidframe/rf_dagfuncs.c targptr = targbuf + rf_RaidAddressToByte(raidPtr, SUOffset);
raidPtr 607 dev/raidframe/rf_dagfuncs.c length = rf_RaidAddressToByte(raidPtr, pda->numSector);
raidPtr 262 dev/raidframe/rf_dagutils.c rf_AllocBuffer(RF_Raid_t *raidPtr, RF_DagHeader_t *dag_h,
raidPtr 267 dev/raidframe/rf_dagutils.c RF_MallocAndAdd(p, pda->numSector << raidPtr->logBytesPerSector,
raidPtr 757 dev/raidframe/rf_dagutils.c rf_redirect_asm(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
raidPtr 759 dev/raidframe/rf_dagutils.c int ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) ? 1 : 0;
raidPtr 761 dev/raidframe/rf_dagutils.c int fcol = raidPtr->reconControl[row]->fcol;
raidPtr 762 dev/raidframe/rf_dagutils.c int srow = raidPtr->reconControl[row]->spareRow;
raidPtr 763 dev/raidframe/rf_dagutils.c int scol = raidPtr->reconControl[row]->spareCol;
raidPtr 766 dev/raidframe/rf_dagutils.c RF_ASSERT(raidPtr->status[row] == rf_rs_reconstructing);
raidPtr 771 dev/raidframe/rf_dagutils.c raidPtr->reconControl[row]->reconMap,
raidPtr 778 dev/raidframe/rf_dagutils.c raidPtr->Layout.map->MapSector(raidPtr,
raidPtr 791 dev/raidframe/rf_dagutils.c raidPtr->reconControl[row]->reconMap,
raidPtr 798 dev/raidframe/rf_dagutils.c (raidPtr->Layout.map->MapParity) (raidPtr,
raidPtr 820 dev/raidframe/rf_dagutils.c RF_Raid_t *raidPtr,
raidPtr 851 dev/raidframe/rf_dagutils.c RF_MallocAndAdd(*sosBuffer, rf_RaidAddressToByte(raidPtr,
raidPtr 853 dev/raidframe/rf_dagutils.c new_asm_h[0] = rf_MapAccess(raidPtr, sosRaidAddress,
raidPtr 862 dev/raidframe/rf_dagutils.c rf_redirect_asm(raidPtr, new_asm_h[0]->stripeMap);
raidPtr 872 dev/raidframe/rf_dagutils.c RF_MallocAndAdd(*eosBuffer, rf_RaidAddressToByte(raidPtr,
raidPtr 874 dev/raidframe/rf_dagutils.c new_asm_h[1] = rf_MapAccess(raidPtr, eosRaidAddress,
raidPtr 883 dev/raidframe/rf_dagutils.c rf_redirect_asm(raidPtr, new_asm_h[1]->stripeMap);
raidPtr 940 dev/raidframe/rf_dagutils.c RF_Raid_t *raidPtr,
raidPtr 951 dev/raidframe/rf_dagutils.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 988 dev/raidframe/rf_dagutils.c rf_MapAccess(raidPtr, sosAddr, sosEndAddr - sosAddr, NULL,
raidPtr 991 dev/raidframe/rf_dagutils.c rf_MapAccess(raidPtr, eosStartAddr, eosAddr - eosStartAddr, NULL,
raidPtr 1006 dev/raidframe/rf_dagutils.c rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
raidPtr 1016 dev/raidframe/rf_dagutils.c rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
raidPtr 1030 dev/raidframe/rf_dagutils.c RF_MallocAndAdd(rdBuf, rf_RaidAddressToByte(raidPtr,
raidPtr 1036 dev/raidframe/rf_dagutils.c (int) rf_RaidAddressToByte(raidPtr,
raidPtr 1051 dev/raidframe/rf_dagutils.c bufP += rf_RaidAddressToByte(raidPtr, pda->numSector);
raidPtr 1059 dev/raidframe/rf_dagutils.c bufP += rf_RaidAddressToByte(raidPtr, pda->numSector);
raidPtr 1128 dev/raidframe/rf_dagutils.c rf_RangeRestrictPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *src,
raidPtr 1131 dev/raidframe/rf_dagutils.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 1151 dev/raidframe/rf_dagutils.c rf_RaidAddressToByte(raidPtr, soffs - doffs) : 0;
raidPtr 1176 dev/raidframe/rf_dagutils.c rf_compute_workload_shift(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda)
raidPtr 1193 dev/raidframe/rf_dagutils.c n = raidPtr->numCol;
raidPtr 1199 dev/raidframe/rf_dagutils.c for (f = 0; ((!RF_DEAD_DISK(raidPtr->Disks[row][f].status)) &&
raidPtr 1234 dev/raidframe/rf_dagutils.c raidPtr->hist_diskreq[row][d]++;
raidPtr 1235 dev/raidframe/rf_dagutils.c if (raidPtr->hist_diskreq[row][d] > v) {
raidPtr 1243 dev/raidframe/rf_dagutils.c raidPtr->hist_diskreq[row][d]);
raidPtr 1246 dev/raidframe/rf_dagutils.c if (raidPtr->hist_diskreq[row][d] >= k) {
raidPtr 1248 dev/raidframe/rf_dagutils.c raidPtr->hist_diskreq[row][d] = 0;
raidPtr 1265 dev/raidframe/rf_dagutils.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr;
raidPtr 1271 dev/raidframe/rf_dagutils.c RF_RaidDisk_t **disks = raidPtr->Disks;
raidPtr 1272 dev/raidframe/rf_dagutils.c RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue;
raidPtr 1303 dev/raidframe/rf_dagutils.c if (raidPtr->parity_good == RF_RAID_DIRTY) {
raidPtr 1346 dev/raidframe/rf_dagutils.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr;
raidPtr 1351 dev/raidframe/rf_dagutils.c RF_RaidDisk_t **disks = raidPtr->Disks;
raidPtr 1352 dev/raidframe/rf_dagutils.c RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue;
raidPtr 1370 dev/raidframe/rf_dagutils.c if (raidPtr->parity_good == RF_RAID_DIRTY) {
raidPtr 71 dev/raidframe/rf_decluster.c rf_ConfigureDeclustered(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 74 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 93 dev/raidframe/rf_decluster.c (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
raidPtr 115 dev/raidframe/rf_decluster.c raidPtr->noRotate = *((int *) cfgBuf);
raidPtr 124 dev/raidframe/rf_decluster.c raidPtr->noRotate) {
raidPtr 128 dev/raidframe/rf_decluster.c if (raidPtr->numCol != v) {
raidPtr 130 dev/raidframe/rf_decluster.c " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
raidPtr 154 dev/raidframe/rf_decluster.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 182 dev/raidframe/rf_decluster.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 212 dev/raidframe/rf_decluster.c complete_FT_count = raidPtr->numRow *
raidPtr 228 dev/raidframe/rf_decluster.c ((complete_FT_count / raidPtr->numRow) *
raidPtr 254 dev/raidframe/rf_decluster.c info->FullTableDepthInPUs) * raidPtr->numRow;
raidPtr 263 dev/raidframe/rf_decluster.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 270 dev/raidframe/rf_decluster.c numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
raidPtr 273 dev/raidframe/rf_decluster.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 285 dev/raidframe/rf_decluster.c info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
raidPtr 288 dev/raidframe/rf_decluster.c info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
raidPtr 292 dev/raidframe/rf_decluster.c layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
raidPtr 328 dev/raidframe/rf_decluster.c raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
raidPtr 331 dev/raidframe/rf_decluster.c layoutPtr->numStripe = (raidPtr->totalSectors /
raidPtr 342 dev/raidframe/rf_decluster.c raidPtr->logBytesPerSector;
raidPtr 355 dev/raidframe/rf_decluster.c RF_Raid_t *raidPtr;
raidPtr 357 dev/raidframe/rf_decluster.c raidPtr = (RF_Raid_t *) arg;
raidPtr 359 dev/raidframe/rf_decluster.c (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 361 dev/raidframe/rf_decluster.c rf_FreeSpareTable(raidPtr);
raidPtr 365 dev/raidframe/rf_decluster.c rf_ConfigureDeclusteredDS(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 370 dev/raidframe/rf_decluster.c rc = rf_ConfigureDeclustered(listp, raidPtr, cfgPtr);
raidPtr 374 dev/raidframe/rf_decluster.c rc = rf_ShutdownCreate(listp, rf_ShutdownDeclusteredDS, raidPtr);
raidPtr 378 dev/raidframe/rf_decluster.c rf_ShutdownDeclusteredDS(raidPtr);
raidPtr 386 dev/raidframe/rf_decluster.c rf_MapSectorDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 389 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 405 dev/raidframe/rf_decluster.c if (raidPtr->numRow == 1)
raidPtr 408 dev/raidframe/rf_decluster.c *row = FullTableID % raidPtr->numRow;
raidPtr 410 dev/raidframe/rf_decluster.c FullTableID /= raidPtr->numRow;
raidPtr 412 dev/raidframe/rf_decluster.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 423 dev/raidframe/rf_decluster.c if (!raidPtr->noRotate)
raidPtr 429 dev/raidframe/rf_decluster.c RF_ASSERT(raidPtr->Disks[*row][*col].status ==
raidPtr 431 dev/raidframe/rf_decluster.c raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
raidPtr 433 dev/raidframe/rf_decluster.c raidPtr->Disks[*row][*col].status == rf_ds_optimal));
raidPtr 468 dev/raidframe/rf_decluster.c rf_MapParityDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 471 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 487 dev/raidframe/rf_decluster.c if (raidPtr->numRow == 1)
raidPtr 490 dev/raidframe/rf_decluster.c *row = FullTableID % raidPtr->numRow;
raidPtr 492 dev/raidframe/rf_decluster.c FullTableID /= raidPtr->numRow;
raidPtr 494 dev/raidframe/rf_decluster.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 511 dev/raidframe/rf_decluster.c RepIndex = (raidPtr->noRotate) ?
raidPtr 516 dev/raidframe/rf_decluster.c RF_ASSERT(raidPtr->Disks[*row][*col].status ==
raidPtr 518 dev/raidframe/rf_decluster.c raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
raidPtr 520 dev/raidframe/rf_decluster.c raidPtr->Disks[*row][*col].status == rf_ds_optimal));
raidPtr 551 dev/raidframe/rf_decluster.c rf_IdentifyStripeDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 554 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 569 dev/raidframe/rf_decluster.c *outRow = FullTableID % raidPtr->numRow;
raidPtr 602 dev/raidframe/rf_decluster.c rf_GetDefaultHeadSepLimitDeclustered(RF_Raid_t *raidPtr)
raidPtr 605 dev/raidframe/rf_decluster.c (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 607 dev/raidframe/rf_decluster.c return (info->Lambda * raidPtr->numFloatingReconBufs /
raidPtr 618 dev/raidframe/rf_decluster.c rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t *raidPtr)
raidPtr 746 dev/raidframe/rf_decluster.c rf_InstallSpareTable(RF_Raid_t *raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol)
raidPtr 749 dev/raidframe/rf_decluster.c (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 754 dev/raidframe/rf_decluster.c req->C = raidPtr->numCol;
raidPtr 755 dev/raidframe/rf_decluster.c req->G = raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol;
raidPtr 757 dev/raidframe/rf_decluster.c req->SUsPerPU = raidPtr->Layout.SUsPerPU;
raidPtr 775 dev/raidframe/rf_decluster.c rf_SetSpareTable(RF_Raid_t *raidPtr, void *data)
raidPtr 778 dev/raidframe/rf_decluster.c (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 821 dev/raidframe/rf_decluster.c rf_GetNumSpareRUsDeclustered(RF_Raid_t *raidPtr)
raidPtr 823 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 831 dev/raidframe/rf_decluster.c rf_FreeSpareTable(RF_Raid_t *raidPtr)
raidPtr 834 dev/raidframe/rf_decluster.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 53 dev/raidframe/rf_declusterPQ.c rf_ConfigureDeclusteredPQ(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 56 dev/raidframe/rf_declusterPQ.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 81 dev/raidframe/rf_declusterPQ.c raidPtr->noRotate = *((int *) cfgBuf);
raidPtr 92 dev/raidframe/rf_declusterPQ.c (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
raidPtr 102 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) &&
raidPtr 103 dev/raidframe/rf_declusterPQ.c raidPtr->noRotate) {
raidPtr 107 dev/raidframe/rf_declusterPQ.c if (raidPtr->numCol != v) {
raidPtr 109 dev/raidframe/rf_declusterPQ.c " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
raidPtr 132 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 159 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 188 dev/raidframe/rf_declusterPQ.c complete_FT_count = raidPtr->numRow *
raidPtr 204 dev/raidframe/rf_declusterPQ.c ((complete_FT_count / raidPtr->numRow) *
raidPtr 230 dev/raidframe/rf_declusterPQ.c raidPtr->numRow;
raidPtr 238 dev/raidframe/rf_declusterPQ.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 245 dev/raidframe/rf_declusterPQ.c numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
raidPtr 248 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 260 dev/raidframe/rf_declusterPQ.c info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
raidPtr 264 dev/raidframe/rf_declusterPQ.c info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
raidPtr 269 dev/raidframe/rf_declusterPQ.c layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
raidPtr 305 dev/raidframe/rf_declusterPQ.c raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
raidPtr 308 dev/raidframe/rf_declusterPQ.c layoutPtr->numStripe = (raidPtr->totalSectors /
raidPtr 319 dev/raidframe/rf_declusterPQ.c raidPtr->logBytesPerSector;
raidPtr 327 dev/raidframe/rf_declusterPQ.c rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t *raidPtr)
raidPtr 331 dev/raidframe/rf_declusterPQ.c def_decl = rf_GetDefaultNumFloatingReconBuffersDeclustered(raidPtr);
raidPtr 332 dev/raidframe/rf_declusterPQ.c return (RF_MAX(3 * raidPtr->numCol, def_decl));
raidPtr 336 dev/raidframe/rf_declusterPQ.c rf_MapSectorDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 339 dev/raidframe/rf_declusterPQ.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 355 dev/raidframe/rf_declusterPQ.c *row = FullTableID % raidPtr->numRow;
raidPtr 358 dev/raidframe/rf_declusterPQ.c FullTableID /= raidPtr->numRow;
raidPtr 360 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 379 dev/raidframe/rf_declusterPQ.c if (!raidPtr->noRotate) {
raidPtr 421 dev/raidframe/rf_declusterPQ.c rf_MapParityDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 424 dev/raidframe/rf_declusterPQ.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 440 dev/raidframe/rf_declusterPQ.c *row = FullTableID % raidPtr->numRow;
raidPtr 442 dev/raidframe/rf_declusterPQ.c FullTableID /= raidPtr->numRow;
raidPtr 443 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 456 dev/raidframe/rf_declusterPQ.c RepIndex = (raidPtr->noRotate) ?
raidPtr 479 dev/raidframe/rf_declusterPQ.c rf_MapQDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 482 dev/raidframe/rf_declusterPQ.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 498 dev/raidframe/rf_declusterPQ.c *row = FullTableID % raidPtr->numRow;
raidPtr 500 dev/raidframe/rf_declusterPQ.c FullTableID /= raidPtr->numRow;
raidPtr 501 dev/raidframe/rf_declusterPQ.c if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 514 dev/raidframe/rf_declusterPQ.c RepIndex = (raidPtr->noRotate) ?
raidPtr 543 dev/raidframe/rf_declusterPQ.c rf_IdentifyStripeDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 546 dev/raidframe/rf_declusterPQ.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 561 dev/raidframe/rf_declusterPQ.c *outRow = FullTableID % raidPtr->numRow;
raidPtr 40 dev/raidframe/rf_desc.h RF_Raid_t *raidPtr; /* Raid device descriptor. */
raidPtr 80 dev/raidframe/rf_desc.h RF_Raid_t *raidPtr; /* Raid device descriptor. */
raidPtr 186 dev/raidframe/rf_diskqueue.c RF_Raid_t *raidPtr,
raidPtr 214 dev/raidframe/rf_diskqueue.c diskqueue->raidPtr = raidPtr;
raidPtr 215 dev/raidframe/rf_diskqueue.c diskqueue->rf_cinfo = &raidPtr->raid_cinfo[r][c];
raidPtr 260 dev/raidframe/rf_diskqueue.c rf_ConfigureDiskQueues(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 268 dev/raidframe/rf_diskqueue.c raidPtr->maxQueueDepth = cfgPtr->maxOutstandingDiskReqs;
raidPtr 281 dev/raidframe/rf_diskqueue.c raidPtr->qType = p;
raidPtr 282 dev/raidframe/rf_diskqueue.c RF_CallocAndAdd(diskQueues, raidPtr->numRow, sizeof(RF_DiskQueue_t *),
raidPtr 283 dev/raidframe/rf_diskqueue.c (RF_DiskQueue_t **), raidPtr->cleanupList);
raidPtr 287 dev/raidframe/rf_diskqueue.c raidPtr->Queues = diskQueues;
raidPtr 288 dev/raidframe/rf_diskqueue.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 289 dev/raidframe/rf_diskqueue.c RF_CallocAndAdd(diskQueues[r], raidPtr->numCol +
raidPtr 292 dev/raidframe/rf_diskqueue.c raidPtr->cleanupList);
raidPtr 295 dev/raidframe/rf_diskqueue.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 296 dev/raidframe/rf_diskqueue.c rc = rf_ConfigureDiskQueue(raidPtr, &diskQueues[r][c],
raidPtr 297 dev/raidframe/rf_diskqueue.c r, c, p, raidPtr->sectorsPerDisk,
raidPtr 298 dev/raidframe/rf_diskqueue.c raidPtr->Disks[r][c].dev,
raidPtr 300 dev/raidframe/rf_diskqueue.c raidPtr->cleanupList);
raidPtr 306 dev/raidframe/rf_diskqueue.c spareQueues = &raidPtr->Queues[0][raidPtr->numCol];
raidPtr 307 dev/raidframe/rf_diskqueue.c for (r = 0; r < raidPtr->numSpare; r++) {
raidPtr 308 dev/raidframe/rf_diskqueue.c rc = rf_ConfigureDiskQueue(raidPtr, &spareQueues[r], 0,
raidPtr 309 dev/raidframe/rf_diskqueue.c raidPtr->numCol + r, p, raidPtr->sectorsPerDisk,
raidPtr 310 dev/raidframe/rf_diskqueue.c raidPtr->Disks[0][raidPtr->numCol + r].dev,
raidPtr 312 dev/raidframe/rf_diskqueue.c raidPtr->cleanupList);
raidPtr 583 dev/raidframe/rf_diskqueue.c void *raidPtr,
raidPtr 606 dev/raidframe/rf_diskqueue.c p->raidPtr = raidPtr;
raidPtr 627 dev/raidframe/rf_diskqueue.c void *raidPtr,
raidPtr 650 dev/raidframe/rf_diskqueue.c p->raidPtr = raidPtr;
raidPtr 88 dev/raidframe/rf_diskqueue.h RF_Raid_t *raidPtr; /* Needed for simulation. */
raidPtr 187 dev/raidframe/rf_diskqueue.h RF_Raid_t *raidPtr; /* Associated array. */
raidPtr 118 dev/raidframe/rf_disks.c rf_ConfigureDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 130 dev/raidframe/rf_disks.c ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
raidPtr 134 dev/raidframe/rf_disks.c disks = raidPtr->Disks;
raidPtr 136 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 138 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 139 dev/raidframe/rf_disks.c ret = rf_ConfigureDisk(raidPtr,
raidPtr 147 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[r][c].ci_dev,
raidPtr 148 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr 149 dev/raidframe/rf_disks.c &raidPtr->raid_cinfo[r][c].ci_label);
raidPtr 172 dev/raidframe/rf_disks.c raidPtr->status[r] = rf_rs_degraded;
raidPtr 179 dev/raidframe/rf_disks.c for (foundone = r = 0; !foundone && r < raidPtr->numRow; r++) {
raidPtr 180 dev/raidframe/rf_disks.c for (c = 0; !foundone && c < raidPtr->numCol; c++) {
raidPtr 203 dev/raidframe/rf_disks.c if (rf_CheckLabels(raidPtr, cfgPtr)) {
raidPtr 204 dev/raidframe/rf_disks.c printf("raid%d: There were fatal errors\n", raidPtr->raidid);
raidPtr 207 dev/raidframe/rf_disks.c raidPtr->raidid);
raidPtr 214 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 215 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 234 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk = min_numblks;
raidPtr 235 dev/raidframe/rf_disks.c raidPtr->logBytesPerSector = ffs(bs) - 1;
raidPtr 236 dev/raidframe/rf_disks.c raidPtr->bytesPerSector = bs;
raidPtr 237 dev/raidframe/rf_disks.c raidPtr->sectorMask = bs - 1;
raidPtr 241 dev/raidframe/rf_disks.c rf_UnconfigureVnodes(raidPtr);
raidPtr 253 dev/raidframe/rf_disks.c rf_ConfigureSpareDisks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
raidPtr 268 dev/raidframe/rf_disks.c disks = &raidPtr->Disks[0][raidPtr->numCol];
raidPtr 269 dev/raidframe/rf_disks.c for (i = 0; i < raidPtr->numSpare; i++) {
raidPtr 270 dev/raidframe/rf_disks.c ret = rf_ConfigureDisk(raidPtr, &cfgPtr->spare_names[i][0],
raidPtr 271 dev/raidframe/rf_disks.c &disks[i], 0, raidPtr->numCol + i);
raidPtr 290 dev/raidframe/rf_disks.c bs = 1 << raidPtr->logBytesPerSector;
raidPtr 291 dev/raidframe/rf_disks.c for (i = 0; i < raidPtr->numSpare; i++) {
raidPtr 299 dev/raidframe/rf_disks.c if (disks[i].numBlocks < raidPtr->sectorsPerDisk) {
raidPtr 303 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk);
raidPtr 307 dev/raidframe/rf_disks.c if (disks[i].numBlocks > raidPtr->sectorsPerDisk) {
raidPtr 310 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk);
raidPtr 312 dev/raidframe/rf_disks.c disks[i].numBlocks = raidPtr->sectorsPerDisk;
raidPtr 331 dev/raidframe/rf_disks.c rf_UnconfigureVnodes(raidPtr);
raidPtr 337 dev/raidframe/rf_disks.c rf_AllocDiskStructures(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
raidPtr 343 dev/raidframe/rf_disks.c RF_CallocAndAdd(disks, raidPtr->numRow, sizeof(RF_RaidDisk_t *),
raidPtr 344 dev/raidframe/rf_disks.c (RF_RaidDisk_t **), raidPtr->cleanupList);
raidPtr 349 dev/raidframe/rf_disks.c raidPtr->Disks = disks;
raidPtr 351 dev/raidframe/rf_disks.c RF_CallocAndAdd(raidPtr->raid_cinfo, raidPtr->numRow,
raidPtr 353 dev/raidframe/rf_disks.c raidPtr->cleanupList);
raidPtr 354 dev/raidframe/rf_disks.c if (raidPtr->raid_cinfo == NULL) {
raidPtr 359 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 364 dev/raidframe/rf_disks.c RF_CallocAndAdd(disks[r], raidPtr->numCol +
raidPtr 366 dev/raidframe/rf_disks.c (RF_RaidDisk_t *), raidPtr->cleanupList);
raidPtr 372 dev/raidframe/rf_disks.c RF_CallocAndAdd(raidPtr->raid_cinfo[r], raidPtr->numCol +
raidPtr 373 dev/raidframe/rf_disks.c ((r == 0) ? raidPtr->numSpare : 0),
raidPtr 375 dev/raidframe/rf_disks.c raidPtr->cleanupList);
raidPtr 376 dev/raidframe/rf_disks.c if (raidPtr->raid_cinfo[r] == NULL) {
raidPtr 383 dev/raidframe/rf_disks.c rf_UnconfigureVnodes(raidPtr);
raidPtr 391 dev/raidframe/rf_disks.c rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr,
raidPtr 411 dev/raidframe/rf_disks.c ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
raidPtr 415 dev/raidframe/rf_disks.c disks = raidPtr->Disks;
raidPtr 436 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 438 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 516 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[r][c].ci_vp = ac->vp;
raidPtr 517 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[r][c].ci_dev = ac->dev;
raidPtr 519 dev/raidframe/rf_disks.c memcpy(&raidPtr->raid_cinfo[r][c].ci_label,
raidPtr 558 dev/raidframe/rf_disks.c raidPtr->serial_number =
raidPtr 589 dev/raidframe/rf_disks.c r * raidPtr->numCol + c);
raidPtr 599 dev/raidframe/rf_disks.c raidPtr->status[r] = rf_rs_degraded;
raidPtr 618 dev/raidframe/rf_disks.c raidPtr->mod_counter = mod_counter;
raidPtr 621 dev/raidframe/rf_disks.c raidPtr->parity_good = parity_good;
raidPtr 622 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk = min_numblks;
raidPtr 623 dev/raidframe/rf_disks.c raidPtr->logBytesPerSector = ffs(bs) - 1;
raidPtr 624 dev/raidframe/rf_disks.c raidPtr->bytesPerSector = bs;
raidPtr 625 dev/raidframe/rf_disks.c raidPtr->sectorMask = bs - 1;
raidPtr 630 dev/raidframe/rf_disks.c rf_UnconfigureVnodes(raidPtr);
raidPtr 638 dev/raidframe/rf_disks.c rf_ConfigureDisk(RF_Raid_t *raidPtr, char *buf, RF_RaidDisk_t *diskPtr,
raidPtr 658 dev/raidframe/rf_disks.c proc = raidPtr->engine_thread;
raidPtr 663 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[row][col].ci_vp = NULL;
raidPtr 664 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[row][col].ci_dev = NULL;
raidPtr 691 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[row][col].ci_vp = vp;
raidPtr 692 dev/raidframe/rf_disks.c raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev;
raidPtr 710 dev/raidframe/rf_disks.c rf_print_label_status(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
raidPtr 715 dev/raidframe/rf_disks.c raidPtr->raidid, dev_name, row, column);
raidPtr 726 dev/raidframe/rf_disks.c rf_check_label_vitals(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
raidPtr 749 dev/raidframe/rf_disks.c if (raidPtr->numRow != ci_label->num_rows) {
raidPtr 753 dev/raidframe/rf_disks.c if (raidPtr->numCol != ci_label->num_columns) {
raidPtr 773 dev/raidframe/rf_disks.c rf_CheckLabels(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
raidPtr 818 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow && !fatal_error; r++) {
raidPtr 819 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 820 dev/raidframe/rf_disks.c ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
raidPtr 858 dev/raidframe/rf_disks.c printf("raid%d: Summary of serial numbers:\n", raidPtr->raidid);
raidPtr 862 dev/raidframe/rf_disks.c printf("raid%d: Summary of mod counters:\n", raidPtr->raidid);
raidPtr 874 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 875 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 877 dev/raidframe/rf_disks.c &raidPtr->raid_cinfo[r][c].ci_label;
raidPtr 894 dev/raidframe/rf_disks.c raidPtr->Disks[hosed_row][hosed_column].status
raidPtr 896 dev/raidframe/rf_disks.c raidPtr->numFailures++;
raidPtr 897 dev/raidframe/rf_disks.c raidPtr->status[hosed_row] = rf_rs_degraded;
raidPtr 917 dev/raidframe/rf_disks.c raidPtr->serial_number = serial_number;
raidPtr 941 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow && !too_fatal; r++) {
raidPtr 942 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 944 dev/raidframe/rf_disks.c &raidPtr->raid_cinfo[r][c].ci_label;
raidPtr 972 dev/raidframe/rf_disks.c if (raidPtr
raidPtr 975 dev/raidframe/rf_disks.c raidPtr->Disks[hosed_row]
raidPtr 978 dev/raidframe/rf_disks.c raidPtr->numFailures++;
raidPtr 979 dev/raidframe/rf_disks.c raidPtr->status[hosed_row] =
raidPtr 995 dev/raidframe/rf_disks.c raidPtr->mod_counter = mod_number;
raidPtr 1010 dev/raidframe/rf_disks.c raidPtr->raidid);
raidPtr 1015 dev/raidframe/rf_disks.c raidPtr->raidid);
raidPtr 1024 dev/raidframe/rf_disks.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 1025 dev/raidframe/rf_disks.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 1027 dev/raidframe/rf_disks.c ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
raidPtr 1031 dev/raidframe/rf_disks.c raidPtr->raidid, dev_name);
raidPtr 1033 dev/raidframe/rf_disks.c rf_print_label_status(raidPtr, r, c, dev_name,
raidPtr 1035 dev/raidframe/rf_disks.c if (rf_check_label_vitals(raidPtr, r, c,
raidPtr 1051 dev/raidframe/rf_disks.c raidPtr->parity_good = parity_good;
raidPtr 1057 dev/raidframe/rf_disks.c rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
raidPtr 1066 dev/raidframe/rf_disks.c printf("Just in rf_add_hot_spare: %d.\n", raidPtr->numSpare);
raidPtr 1067 dev/raidframe/rf_disks.c printf("Num col: %d.\n", raidPtr->numCol);
raidPtr 1069 dev/raidframe/rf_disks.c if (raidPtr->numSpare >= RF_MAXSPARE) {
raidPtr 1070 dev/raidframe/rf_disks.c RF_ERRORMSG1("Too many spares: %d.\n", raidPtr->numSpare);
raidPtr 1074 dev/raidframe/rf_disks.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1077 dev/raidframe/rf_disks.c disks = &raidPtr->Disks[0][raidPtr->numCol];
raidPtr 1079 dev/raidframe/rf_disks.c spare_number = raidPtr->numSpare;
raidPtr 1081 dev/raidframe/rf_disks.c ret = rf_ConfigureDisk(raidPtr, sparePtr->component_name,
raidPtr 1082 dev/raidframe/rf_disks.c &disks[spare_number], 0, raidPtr->numCol + spare_number);
raidPtr 1103 dev/raidframe/rf_disks.c bs = 1 << raidPtr->logBytesPerSector;
raidPtr 1112 dev/raidframe/rf_disks.c if (disks[spare_number].numBlocks < raidPtr->sectorsPerDisk) {
raidPtr 1116 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk);
raidPtr 1121 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk) {
raidPtr 1124 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk);
raidPtr 1126 dev/raidframe/rf_disks.c disks[spare_number].numBlocks = raidPtr->sectorsPerDisk;
raidPtr 1130 dev/raidframe/rf_disks.c spareQueues = &raidPtr->Queues[0][raidPtr->numCol];
raidPtr 1131 dev/raidframe/rf_disks.c ret = rf_ConfigureDiskQueue(raidPtr, &spareQueues[spare_number],
raidPtr 1132 dev/raidframe/rf_disks.c 0, raidPtr->numCol + spare_number, raidPtr->qType,
raidPtr 1133 dev/raidframe/rf_disks.c raidPtr->sectorsPerDisk, raidPtr->Disks[0][raidPtr->numCol +
raidPtr 1134 dev/raidframe/rf_disks.c spare_number].dev, raidPtr->maxOutstanding,
raidPtr 1135 dev/raidframe/rf_disks.c &raidPtr->shutdownList, raidPtr->cleanupList);
raidPtr 1138 dev/raidframe/rf_disks.c raidPtr->numSpare++;
raidPtr 1139 dev/raidframe/rf_disks.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1143 dev/raidframe/rf_disks.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1148 dev/raidframe/rf_disks.c rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
raidPtr 1152 dev/raidframe/rf_disks.c if (raidPtr->numSpare == 0) {
raidPtr 1161 dev/raidframe/rf_disks.c if (spare_number < 0 || spare_number > raidPtr->numSpare) {
raidPtr 1169 dev/raidframe/rf_disks.c raidPtr->numSpare--;
raidPtr 1176 dev/raidframe/rf_disks.c rf_delete_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
raidPtr 1181 dev/raidframe/rf_disks.c (component->row >= raidPtr->numRow) ||
raidPtr 1183 dev/raidframe/rf_disks.c (component->column >= raidPtr->numCol)) {
raidPtr 1187 dev/raidframe/rf_disks.c disks = &raidPtr->Disks[component->row][component->column];
raidPtr 1195 dev/raidframe/rf_disks.c rf_incorporate_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
raidPtr 265 dev/raidframe/rf_driver.c rf_Shutdown(RF_Raid_t *raidPtr)
raidPtr 267 dev/raidframe/rf_driver.c if (!raidPtr->valid) {
raidPtr 281 dev/raidframe/rf_driver.c if (raidPtr->waitShutdown) {
raidPtr 285 dev/raidframe/rf_driver.c raidPtr->waitShutdown = 1;
raidPtr 286 dev/raidframe/rf_driver.c while (raidPtr->nAccOutstanding) {
raidPtr 287 dev/raidframe/rf_driver.c RF_WAIT_COND(raidPtr->outstandingCond, RF_FREELIST_MUTEX_OF(rf_rad_freelist));
raidPtr 292 dev/raidframe/rf_driver.c while (raidPtr->parity_rewrite_in_progress) {
raidPtr 294 dev/raidframe/rf_driver.c tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO,
raidPtr 298 dev/raidframe/rf_driver.c raidPtr->valid = 0;
raidPtr 300 dev/raidframe/rf_driver.c rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE);
raidPtr 302 dev/raidframe/rf_driver.c rf_UnconfigureVnodes(raidPtr);
raidPtr 304 dev/raidframe/rf_driver.c rf_ShutdownList(&raidPtr->shutdownList);
raidPtr 326 dev/raidframe/rf_driver.c rf_UnconfigureVnodes(raidPtr); \
raidPtr 327 dev/raidframe/rf_driver.c rf_ShutdownList(&raidPtr->shutdownList); \
raidPtr 333 dev/raidframe/rf_driver.c rc = (f)(&raidPtr->shutdownList, raidPtr, cfgPtr); \
raidPtr 344 dev/raidframe/rf_driver.c rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_)); \
raidPtr 355 dev/raidframe/rf_driver.c rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_)); \
raidPtr 365 dev/raidframe/rf_driver.c rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
raidPtr 375 dev/raidframe/rf_driver.c if (raidPtr->valid) {
raidPtr 425 dev/raidframe/rf_driver.c DO_RAID_MUTEX(&raidPtr->mutex);
raidPtr 431 dev/raidframe/rf_driver.c rf_MakeAllocList(raidPtr->cleanupList);
raidPtr 432 dev/raidframe/rf_driver.c if (raidPtr->cleanupList == NULL) {
raidPtr 436 dev/raidframe/rf_driver.c rc = rf_ShutdownCreate(&raidPtr->shutdownList,
raidPtr 437 dev/raidframe/rf_driver.c (void (*) (void *)) rf_FreeAllocList, raidPtr->cleanupList);
raidPtr 444 dev/raidframe/rf_driver.c raidPtr->numRow = cfgPtr->numRow;
raidPtr 445 dev/raidframe/rf_driver.c raidPtr->numCol = cfgPtr->numCol;
raidPtr 446 dev/raidframe/rf_driver.c raidPtr->numSpare = cfgPtr->numSpare;
raidPtr 452 dev/raidframe/rf_driver.c if (raidPtr->numRow != 1) {
raidPtr 457 dev/raidframe/rf_driver.c RF_CallocAndAdd(raidPtr->status, raidPtr->numRow,
raidPtr 458 dev/raidframe/rf_driver.c sizeof(RF_RowStatus_t), (RF_RowStatus_t *), raidPtr->cleanupList);
raidPtr 459 dev/raidframe/rf_driver.c if (raidPtr->status == NULL) {
raidPtr 463 dev/raidframe/rf_driver.c RF_CallocAndAdd(raidPtr->reconControl, raidPtr->numRow,
raidPtr 464 dev/raidframe/rf_driver.c sizeof(RF_ReconCtrl_t *), (RF_ReconCtrl_t **), raidPtr->cleanupList);
raidPtr 465 dev/raidframe/rf_driver.c if (raidPtr->reconControl == NULL) {
raidPtr 469 dev/raidframe/rf_driver.c for (i = 0; i < raidPtr->numRow; i++) {
raidPtr 470 dev/raidframe/rf_driver.c raidPtr->status[i] = rf_rs_optimal;
raidPtr 471 dev/raidframe/rf_driver.c raidPtr->reconControl[i] = NULL;
raidPtr 477 dev/raidframe/rf_driver.c DO_RAID_COND(&raidPtr->outstandingCond);
raidPtr 479 dev/raidframe/rf_driver.c raidPtr->nAccOutstanding = 0;
raidPtr 480 dev/raidframe/rf_driver.c raidPtr->waitShutdown = 0;
raidPtr 482 dev/raidframe/rf_driver.c DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
raidPtr 483 dev/raidframe/rf_driver.c DO_RAID_COND(&raidPtr->quiescent_cond);
raidPtr 485 dev/raidframe/rf_driver.c DO_RAID_COND(&raidPtr->waitForReconCond);
raidPtr 487 dev/raidframe/rf_driver.c DO_RAID_MUTEX(&raidPtr->recon_done_proc_mutex);
raidPtr 495 dev/raidframe/rf_driver.c rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
raidPtr 510 dev/raidframe/rf_driver.c for (row = 0; row < raidPtr->numRow; row++) {
raidPtr 511 dev/raidframe/rf_driver.c for (col = 0; col < raidPtr->numCol; col++) {
raidPtr 515 dev/raidframe/rf_driver.c raidPtr->hist_diskreq[row][col] = 0;
raidPtr 519 dev/raidframe/rf_driver.c raidPtr->numNewFailures = 0;
raidPtr 520 dev/raidframe/rf_driver.c raidPtr->copyback_in_progress = 0;
raidPtr 521 dev/raidframe/rf_driver.c raidPtr->parity_rewrite_in_progress = 0;
raidPtr 522 dev/raidframe/rf_driver.c raidPtr->recon_in_progress = 0;
raidPtr 523 dev/raidframe/rf_driver.c raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
raidPtr 529 dev/raidframe/rf_driver.c raidPtr->autoconfigure = 0;
raidPtr 530 dev/raidframe/rf_driver.c raidPtr->root_partition = 0;
raidPtr 531 dev/raidframe/rf_driver.c raidPtr->last_unit = raidPtr->raidid;
raidPtr 532 dev/raidframe/rf_driver.c raidPtr->config_order = 0;
raidPtr 535 dev/raidframe/rf_driver.c raidPtr->keep_acc_totals = 1;
raidPtr 537 dev/raidframe/rf_driver.c rf_StartUserStats(raidPtr);
raidPtr 539 dev/raidframe/rf_driver.c raidPtr->valid = 1;
raidPtr 602 dev/raidframe/rf_driver.c RF_Raid_t *raidPtr,
raidPtr 620 dev/raidframe/rf_driver.c if (raidPtr->waitShutdown) {
raidPtr 630 dev/raidframe/rf_driver.c raidPtr->nAccOutstanding++;
raidPtr 633 dev/raidframe/rf_driver.c desc->raidPtr = (void *) raidPtr;
raidPtr 660 dev/raidframe/rf_driver.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 666 dev/raidframe/rf_driver.c raidPtr->nAccOutstanding--;
raidPtr 667 dev/raidframe/rf_driver.c if (raidPtr->waitShutdown) {
raidPtr 668 dev/raidframe/rf_driver.c RF_SIGNAL_COND(raidPtr->outstandingCond);
raidPtr 682 dev/raidframe/rf_driver.c RF_Raid_t *raidPtr,
raidPtr 711 dev/raidframe/rf_driver.c if (!raidPtr->valid) {
raidPtr 720 dev/raidframe/rf_driver.c printf("logBytes is: %d %d %d.\n", raidPtr->raidid,
raidPtr 721 dev/raidframe/rf_driver.c raidPtr->logBytesPerSector,
raidPtr 722 dev/raidframe/rf_driver.c (int) rf_RaidAddressToByte(raidPtr, numBlocks));
raidPtr 723 dev/raidframe/rf_driver.c printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx.\n", raidPtr->raidid,
raidPtr 725 dev/raidframe/rf_driver.c (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress),
raidPtr 726 dev/raidframe/rf_driver.c (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1),
raidPtr 728 dev/raidframe/rf_driver.c (int) rf_RaidAddressToByte(raidPtr, numBlocks),
raidPtr 731 dev/raidframe/rf_driver.c if (raidAddress + numBlocks > raidPtr->totalSectors) {
raidPtr 734 dev/raidframe/rf_driver.c (u_long) raidAddress, (u_long) numBlocks, (u_long) raidPtr->totalSectors);
raidPtr 739 dev/raidframe/rf_driver.c desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress,
raidPtr 741 dev/raidframe/rf_driver.c flags, cbF, cbA, raidPtr->Layout.map->states);
raidPtr 758 dev/raidframe/rf_driver.c rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int row, int col)
raidPtr 760 dev/raidframe/rf_driver.c if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
raidPtr 765 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 766 dev/raidframe/rf_driver.c raidPtr->numFailures++;
raidPtr 767 dev/raidframe/rf_driver.c raidPtr->Disks[row][col].status = rf_ds_dist_spared;
raidPtr 768 dev/raidframe/rf_driver.c raidPtr->status[row] = rf_rs_reconfigured;
raidPtr 769 dev/raidframe/rf_driver.c rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
raidPtr 774 dev/raidframe/rf_driver.c if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED)
raidPtr 775 dev/raidframe/rf_driver.c rf_InstallSpareTable(raidPtr, row, col);
raidPtr 776 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 784 dev/raidframe/rf_driver.c rf_FailDisk(RF_Raid_t *raidPtr, int frow, int fcol, int initRecon)
raidPtr 786 dev/raidframe/rf_driver.c printf("raid%d: Failing disk r%d c%d.\n", raidPtr->raidid, frow, fcol);
raidPtr 787 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 788 dev/raidframe/rf_driver.c raidPtr->numFailures++;
raidPtr 789 dev/raidframe/rf_driver.c raidPtr->Disks[frow][fcol].status = rf_ds_failed;
raidPtr 790 dev/raidframe/rf_driver.c raidPtr->status[frow] = rf_rs_degraded;
raidPtr 791 dev/raidframe/rf_driver.c rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
raidPtr 792 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 794 dev/raidframe/rf_driver.c rf_ReconstructFailedDisk(raidPtr, frow, fcol);
raidPtr 804 dev/raidframe/rf_driver.c rf_SignalQuiescenceLock(RF_Raid_t *raidPtr, RF_RaidReconDesc_t *reconDesc)
raidPtr 808 dev/raidframe/rf_driver.c raidPtr->raidid);
raidPtr 810 dev/raidframe/rf_driver.c raidPtr->access_suspend_release = 1;
raidPtr 812 dev/raidframe/rf_driver.c if (raidPtr->waiting_for_quiescence) {
raidPtr 813 dev/raidframe/rf_driver.c SIGNAL_QUIESCENT_COND(raidPtr);
raidPtr 823 dev/raidframe/rf_driver.c rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr)
raidPtr 828 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 829 dev/raidframe/rf_driver.c raidPtr->accesses_suspended++;
raidPtr 830 dev/raidframe/rf_driver.c raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1;
raidPtr 832 dev/raidframe/rf_driver.c if (raidPtr->waiting_for_quiescence) {
raidPtr 833 dev/raidframe/rf_driver.c raidPtr->access_suspend_release = 0;
raidPtr 834 dev/raidframe/rf_driver.c while (!raidPtr->access_suspend_release) {
raidPtr 836 dev/raidframe/rf_driver.c WAIT_FOR_QUIESCENCE(raidPtr);
raidPtr 837 dev/raidframe/rf_driver.c raidPtr->waiting_for_quiescence = 0;
raidPtr 842 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 843 dev/raidframe/rf_driver.c return (raidPtr->waiting_for_quiescence);
raidPtr 849 dev/raidframe/rf_driver.c rf_ResumeNewRequests(RF_Raid_t *raidPtr)
raidPtr 856 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 857 dev/raidframe/rf_driver.c raidPtr->accesses_suspended--;
raidPtr 858 dev/raidframe/rf_driver.c if (raidPtr->accesses_suspended == 0)
raidPtr 859 dev/raidframe/rf_driver.c cb = raidPtr->quiesce_wait_list;
raidPtr 862 dev/raidframe/rf_driver.c raidPtr->quiesce_wait_list = NULL;
raidPtr 863 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 932 dev/raidframe/rf_driver.c rf_InitThroughputStats(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 938 dev/raidframe/rf_driver.c rc = rf_create_managed_mutex(listp, &raidPtr->throughputstats.mutex);
raidPtr 944 dev/raidframe/rf_driver.c raidPtr->throughputstats.sum_io_us = 0;
raidPtr 945 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_ios = 0;
raidPtr 946 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_out_ios = 0;
raidPtr 951 dev/raidframe/rf_driver.c rf_StartThroughputStats(RF_Raid_t *raidPtr)
raidPtr 953 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr 954 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_ios++;
raidPtr 955 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_out_ios++;
raidPtr 956 dev/raidframe/rf_driver.c if (raidPtr->throughputstats.num_out_ios == 1)
raidPtr 957 dev/raidframe/rf_driver.c RF_GETTIME(raidPtr->throughputstats.start);
raidPtr 958 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr 962 dev/raidframe/rf_driver.c rf_StopThroughputStats(RF_Raid_t *raidPtr)
raidPtr 966 dev/raidframe/rf_driver.c RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr 967 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_out_ios--;
raidPtr 968 dev/raidframe/rf_driver.c if (raidPtr->throughputstats.num_out_ios == 0) {
raidPtr 969 dev/raidframe/rf_driver.c RF_GETTIME(raidPtr->throughputstats.stop);
raidPtr 970 dev/raidframe/rf_driver.c RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start,
raidPtr 971 dev/raidframe/rf_driver.c &raidPtr->throughputstats.stop, &diff);
raidPtr 972 dev/raidframe/rf_driver.c raidPtr->throughputstats.sum_io_us += RF_TIMEVAL_TO_US(diff);
raidPtr 974 dev/raidframe/rf_driver.c RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
raidPtr 978 dev/raidframe/rf_driver.c rf_PrintThroughputStats(RF_Raid_t *raidPtr)
raidPtr 980 dev/raidframe/rf_driver.c RF_ASSERT(raidPtr->throughputstats.num_out_ios == 0);
raidPtr 981 dev/raidframe/rf_driver.c if (raidPtr->throughputstats.sum_io_us != 0) {
raidPtr 983 dev/raidframe/rf_driver.c raidPtr->throughputstats.num_ios /
raidPtr 984 dev/raidframe/rf_driver.c (raidPtr->throughputstats.sum_io_us / 1000000.0));
raidPtr 991 dev/raidframe/rf_driver.c rf_StartUserStats(RF_Raid_t *raidPtr)
raidPtr 993 dev/raidframe/rf_driver.c RF_GETTIME(raidPtr->userstats.start);
raidPtr 994 dev/raidframe/rf_driver.c raidPtr->userstats.sum_io_us = 0;
raidPtr 995 dev/raidframe/rf_driver.c raidPtr->userstats.num_ios = 0;
raidPtr 996 dev/raidframe/rf_driver.c raidPtr->userstats.num_sect_moved = 0;
raidPtr 1000 dev/raidframe/rf_driver.c rf_StopUserStats(RF_Raid_t *raidPtr)
raidPtr 1002 dev/raidframe/rf_driver.c RF_GETTIME(raidPtr->userstats.stop);
raidPtr 1007 dev/raidframe/rf_driver.c RF_Raid_t *raidPtr,
raidPtr 1012 dev/raidframe/rf_driver.c raidPtr->userstats.sum_io_us += rt;
raidPtr 1013 dev/raidframe/rf_driver.c raidPtr->userstats.num_ios++;
raidPtr 1014 dev/raidframe/rf_driver.c raidPtr->userstats.num_sect_moved += numsect;
raidPtr 1018 dev/raidframe/rf_driver.c rf_PrintUserStats(RF_Raid_t *raidPtr)
raidPtr 1023 dev/raidframe/rf_driver.c RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop,
raidPtr 1029 dev/raidframe/rf_driver.c mbs = (raidPtr->userstats.num_sect_moved / 2000) /
raidPtr 1036 dev/raidframe/rf_driver.c mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) /
raidPtr 1043 dev/raidframe/rf_driver.c raidPtr->userstats.num_ios);
raidPtr 1047 dev/raidframe/rf_driver.c RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000)));
raidPtr 1049 dev/raidframe/rf_driver.c RF_DB0_CHECK(raidPtr->userstats.sum_io_us,
raidPtr 1050 dev/raidframe/rf_driver.c raidPtr->userstats.num_ios));
raidPtr 1052 dev/raidframe/rf_driver.c raidPtr->userstats.num_sect_moved);
raidPtr 1054 dev/raidframe/rf_driver.c RF_DB0_CHECK(raidPtr->userstats.num_sect_moved,
raidPtr 1055 dev/raidframe/rf_driver.c raidPtr->userstats.num_ios));
raidPtr 133 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 135 dev/raidframe/rf_engine.c raidPtr = (RF_Raid_t *) arg;
raidPtr 136 dev/raidframe/rf_engine.c raidPtr->shutdown_engine = 1;
raidPtr 137 dev/raidframe/rf_engine.c DO_SIGNAL(raidPtr);
raidPtr 141 dev/raidframe/rf_engine.c rf_ConfigureEngine(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 147 dev/raidframe/rf_engine.c DO_INIT(listp, raidPtr);
raidPtr 149 dev/raidframe/rf_engine.c raidPtr->node_queue = NULL;
raidPtr 150 dev/raidframe/rf_engine.c raidPtr->dags_in_flight = 0;
raidPtr 152 dev/raidframe/rf_engine.c rc = rf_init_managed_threadgroup(listp, &raidPtr->engine_tg);
raidPtr 162 dev/raidframe/rf_engine.c printf("raid%d: %s engine thread\n", raidPtr->raidid,
raidPtr 175 dev/raidframe/rf_engine.c rf_hook_cookies[raidPtr->raidid] =
raidPtr 177 dev/raidframe/rf_engine.c raidPtr);
raidPtr 180 dev/raidframe/rf_engine.c snprintf(&raidname[0], 16, "raid%d", raidPtr->raidid);
raidPtr 181 dev/raidframe/rf_engine.c if (RF_CREATE_THREAD(raidPtr->engine_thread,
raidPtr 182 dev/raidframe/rf_engine.c rf_DAGExecutionThread, raidPtr, &raidname[0])) {
raidPtr 189 dev/raidframe/rf_engine.c raidPtr->raidid);
raidPtr 191 dev/raidframe/rf_engine.c RF_THREADGROUP_STARTED(&raidPtr->engine_tg);
raidPtr 202 dev/raidframe/rf_engine.c raidPtr->raidid);
raidPtr 204 dev/raidframe/rf_engine.c rc = rf_ShutdownCreate(listp, rf_ShutdownEngine, raidPtr);
raidPtr 312 dev/raidframe/rf_engine.c node->dagHdr->raidPtr->raidid,
raidPtr 333 dev/raidframe/rf_engine.c node->dagHdr->raidPtr->raidid,
raidPtr 472 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 482 dev/raidframe/rf_engine.c raidPtr = node->dagHdr->raidPtr;
raidPtr 484 dev/raidframe/rf_engine.c DO_LOCK(raidPtr);
raidPtr 574 dev/raidframe/rf_engine.c q->next = raidPtr->node_queue;
raidPtr 575 dev/raidframe/rf_engine.c raidPtr->node_queue = qh;
raidPtr 576 dev/raidframe/rf_engine.c DO_SIGNAL(raidPtr);
raidPtr 578 dev/raidframe/rf_engine.c DO_UNLOCK(raidPtr);
raidPtr 668 dev/raidframe/rf_engine.c q->next = raidPtr->node_queue;
raidPtr 669 dev/raidframe/rf_engine.c raidPtr->node_queue = qh;
raidPtr 670 dev/raidframe/rf_engine.c DO_SIGNAL(raidPtr);
raidPtr 672 dev/raidframe/rf_engine.c DO_UNLOCK(raidPtr);
raidPtr 709 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 711 dev/raidframe/rf_engine.c raidPtr = node->dagHdr->raidPtr;
raidPtr 724 dev/raidframe/rf_engine.c " rolling forward\n", raidPtr->raidid,
raidPtr 732 dev/raidframe/rf_engine.c " rolling backward\n", raidPtr->raidid,
raidPtr 792 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 794 dev/raidframe/rf_engine.c raidPtr = dag->raidPtr;
raidPtr 803 dev/raidframe/rf_engine.c printf("raid%d: Entering DispatchDAG\n", raidPtr->raidid);
raidPtr 805 dev/raidframe/rf_engine.c raidPtr->dags_in_flight++; /*
raidPtr 835 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 839 dev/raidframe/rf_engine.c raidPtr = (RF_Raid_t *) arg;
raidPtr 842 dev/raidframe/rf_engine.c printf("raid%d: Starting engine thread\n", raidPtr->raidid);
raidPtr 845 dev/raidframe/rf_engine.c lastpid = RF_ENGINE_PID + raidPtr->raidid - 1;
raidPtr 846 dev/raidframe/rf_engine.c snprintf(raidname, sizeof raidname, "raid%d", raidPtr->raidid);
raidPtr 848 dev/raidframe/rf_engine.c if (RF_CREATE_THREAD(raidPtr->engine_thread, rf_DAGExecutionThread,
raidPtr 849 dev/raidframe/rf_engine.c raidPtr, &raidname[0])) {
raidPtr 856 dev/raidframe/rf_engine.c printf("raid%d: Engine thread started\n", raidPtr->raidid);
raidPtr 858 dev/raidframe/rf_engine.c RF_THREADGROUP_STARTED(&raidPtr->engine_tg);
raidPtr 866 dev/raidframe/rf_engine.c RF_Raid_t *raidPtr;
raidPtr 870 dev/raidframe/rf_engine.c raidPtr = (RF_Raid_t *) arg;
raidPtr 872 dev/raidframe/rf_engine.c while (!(&raidPtr->engine_tg)->created)
raidPtr 873 dev/raidframe/rf_engine.c (void) tsleep((void *)&(&raidPtr->engine_tg)->created, PWAIT,
raidPtr 877 dev/raidframe/rf_engine.c printf("raid%d: Engine thread is running\n", raidPtr->raidid);
raidPtr 883 dev/raidframe/rf_engine.c RF_THREADGROUP_RUNNING(&raidPtr->engine_tg);
raidPtr 885 dev/raidframe/rf_engine.c rf_hook_cookies[raidPtr->raidid] =
raidPtr 886 dev/raidframe/rf_engine.c shutdownhook_establish(rf_shutdown_hook, (void *)raidPtr);
raidPtr 888 dev/raidframe/rf_engine.c DO_LOCK(raidPtr);
raidPtr 889 dev/raidframe/rf_engine.c while (!raidPtr->shutdown_engine) {
raidPtr 891 dev/raidframe/rf_engine.c while (raidPtr->node_queue != NULL) {
raidPtr 892 dev/raidframe/rf_engine.c local_nq = raidPtr->node_queue;
raidPtr 895 dev/raidframe/rf_engine.c raidPtr->node_queue = NULL;
raidPtr 896 dev/raidframe/rf_engine.c DO_UNLOCK(raidPtr);
raidPtr 953 dev/raidframe/rf_engine.c raidPtr->dags_in_flight--; /* Debug only. */
raidPtr 959 dev/raidframe/rf_engine.c DO_LOCK(raidPtr);
raidPtr 961 dev/raidframe/rf_engine.c while (!raidPtr->shutdown_engine && raidPtr->node_queue == NULL)
raidPtr 962 dev/raidframe/rf_engine.c DO_WAIT(raidPtr);
raidPtr 964 dev/raidframe/rf_engine.c DO_UNLOCK(raidPtr);
raidPtr 966 dev/raidframe/rf_engine.c if (rf_hook_cookies && rf_hook_cookies[raidPtr->raidid] != NULL) {
raidPtr 967 dev/raidframe/rf_engine.c shutdownhook_disestablish(rf_hook_cookies[raidPtr->raidid]);
raidPtr 968 dev/raidframe/rf_engine.c rf_hook_cookies[raidPtr->raidid] = NULL;
raidPtr 971 dev/raidframe/rf_engine.c RF_THREADGROUP_DONE(&raidPtr->engine_tg);
raidPtr 72 dev/raidframe/rf_evenodd.c rf_ConfigureEvenOdd(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 75 dev/raidframe/rf_evenodd.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 80 dev/raidframe/rf_evenodd.c (RF_EvenOddConfigInfo_t *), raidPtr->cleanupList);
raidPtr 83 dev/raidframe/rf_evenodd.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 85 dev/raidframe/rf_evenodd.c info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol,
raidPtr 86 dev/raidframe/rf_evenodd.c raidPtr->numCol, raidPtr->cleanupList);
raidPtr 88 dev/raidframe/rf_evenodd.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 89 dev/raidframe/rf_evenodd.c for (j = 0; j < raidPtr->numCol; j++) {
raidPtr 91 dev/raidframe/rf_evenodd.c raidPtr->numCol;
raidPtr 94 dev/raidframe/rf_evenodd.c startdisk += raidPtr->numCol;
raidPtr 100 dev/raidframe/rf_evenodd.c raidPtr->logBytesPerSector;
raidPtr 101 dev/raidframe/rf_evenodd.c layoutPtr->numDataCol = raidPtr->numCol - 2; /*
raidPtr 107 dev/raidframe/rf_evenodd.c if (raidPtr->numCol <= 17) {
raidPtr 115 dev/raidframe/rf_evenodd.c if (raidPtr->numCol > 17) {
raidPtr 127 dev/raidframe/rf_evenodd.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 130 dev/raidframe/rf_evenodd.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 137 dev/raidframe/rf_evenodd.c rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t *raidPtr)
raidPtr 143 dev/raidframe/rf_evenodd.c rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t *raidPtr)
raidPtr 149 dev/raidframe/rf_evenodd.c rf_IdentifyStripeEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 152 dev/raidframe/rf_evenodd.c RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
raidPtr 155 dev/raidframe/rf_evenodd.c (RF_EvenOddConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 158 dev/raidframe/rf_evenodd.c *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
raidPtr 182 dev/raidframe/rf_evenodd.c RF_Raid_t *raidPtr,
raidPtr 190 dev/raidframe/rf_evenodd.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 192 dev/raidframe/rf_evenodd.c (SUID / raidPtr->Layout.numDataCol + 1) *
raidPtr 193 dev/raidframe/rf_evenodd.c raidPtr->Layout.numDataCol - 1;
raidPtr 196 dev/raidframe/rf_evenodd.c *col = (endSUIDofthisStrip + 2) % raidPtr->numCol;
raidPtr 197 dev/raidframe/rf_evenodd.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 198 dev/raidframe/rf_evenodd.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 199 dev/raidframe/rf_evenodd.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 204 dev/raidframe/rf_evenodd.c RF_Raid_t *raidPtr,
raidPtr 212 dev/raidframe/rf_evenodd.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 214 dev/raidframe/rf_evenodd.c (SUID / raidPtr->Layout.numDataCol + 1) *
raidPtr 215 dev/raidframe/rf_evenodd.c raidPtr->Layout.numDataCol - 1;
raidPtr 218 dev/raidframe/rf_evenodd.c *col = (endSUIDofthisStrip + 1) % raidPtr->numCol;
raidPtr 219 dev/raidframe/rf_evenodd.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 220 dev/raidframe/rf_evenodd.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 221 dev/raidframe/rf_evenodd.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 226 dev/raidframe/rf_evenodd.c RF_Raid_t *raidPtr,
raidPtr 232 dev/raidframe/rf_evenodd.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 273 dev/raidframe/rf_evenodd.c if (rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 298 dev/raidframe/rf_evenodd.c rf_CheckStripeForFailures(raidPtr, asmap))) {
raidPtr 320 dev/raidframe/rf_evenodd.c rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 333 dev/raidframe/rf_evenodd.c rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 347 dev/raidframe/rf_evenodd.c if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
raidPtr 438 dev/raidframe/rf_evenodd.c RF_Raid_t *raidPtr,
raidPtr 445 dev/raidframe/rf_evenodd.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 449 dev/raidframe/rf_evenodd.c int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
raidPtr 482 dev/raidframe/rf_evenodd.c rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
raidPtr 489 dev/raidframe/rf_evenodd.c asm_h = rf_MapAccess(raidPtr, startAddr,
raidPtr 496 dev/raidframe/rf_evenodd.c rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
raidPtr 498 dev/raidframe/rf_evenodd.c if (rf_TryToRedirectPDA(raidPtr, pda, 0))
raidPtr 511 dev/raidframe/rf_evenodd.c rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
raidPtr 513 dev/raidframe/rf_evenodd.c if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
raidPtr 519 dev/raidframe/rf_evenodd.c rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->qInfo, 0, 1);
raidPtr 521 dev/raidframe/rf_evenodd.c if (rf_TryToRedirectPDA(raidPtr, asmap->qInfo, 1))
raidPtr 553 dev/raidframe/rf_evenodd.c rf_e_encToBuf(raidPtr, i, p, RF_EO_MATRIX_DIM - 2,
raidPtr 595 dev/raidframe/rf_evenodd.c wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
raidPtr 627 dev/raidframe/rf_evenodd.c wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes,
raidPtr 114 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 115 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 142 dev/raidframe/rf_evenodd_dagfuncs.c length = rf_RaidAddressToByte(raidPtr,
raidPtr 160 dev/raidframe/rf_evenodd_dagfuncs.c rf_RaidAddressToByte(raidPtr, suoffset);
raidPtr 161 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, srcbuf,
raidPtr 169 dev/raidframe/rf_evenodd_dagfuncs.c length = rf_RaidAddressToByte(raidPtr,
raidPtr 186 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 187 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 201 dev/raidframe/rf_evenodd_dagfuncs.c length = rf_RaidAddressToByte(raidPtr,
raidPtr 214 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
raidPtr 238 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 239 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 254 dev/raidframe/rf_evenodd_dagfuncs.c destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset);
raidPtr 255 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
raidPtr 294 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 295 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 311 dev/raidframe/rf_evenodd_dagfuncs.c destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
raidPtr 312 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
raidPtr 423 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(RF_Raid_t *raidPtr, RF_RowCol_t srcLogicCol, char *srcbuf,
raidPtr 426 dev/raidframe/rf_evenodd_dagfuncs.c int i, bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
raidPtr 444 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 445 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 457 dev/raidframe/rf_evenodd_dagfuncs.c bzero((char *) node->results[0], rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
raidPtr 470 dev/raidframe/rf_evenodd_dagfuncs.c destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
raidPtr 471 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, srcbuf, fcol, destbuf, pda->numSector);
raidPtr 502 dev/raidframe/rf_evenodd_dagfuncs.c rf_doubleEOdecode(RF_Raid_t *raidPtr, char **rrdbuf, char **dest,
raidPtr 505 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
raidPtr 508 dev/raidframe/rf_evenodd_dagfuncs.c int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
raidPtr 714 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
raidPtr 715 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
raidPtr 723 dev/raidframe/rf_evenodd_dagfuncs.c int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
raidPtr 795 dev/raidframe/rf_evenodd_dagfuncs.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 799 dev/raidframe/rf_evenodd_dagfuncs.c if (RF_DEAD_DISK(raidPtr
raidPtr 859 dev/raidframe/rf_evenodd_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 872 dev/raidframe/rf_evenodd_dagfuncs.c rf_RaidAddressToByte(raidPtr, sector - fsuoff[0]);
raidPtr 881 dev/raidframe/rf_evenodd_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 891 dev/raidframe/rf_evenodd_dagfuncs.c rf_RaidAddressToByte(raidPtr,
raidPtr 900 dev/raidframe/rf_evenodd_dagfuncs.c pbuf = ppda->bufPtr + rf_RaidAddressToByte(raidPtr,
raidPtr 902 dev/raidframe/rf_evenodd_dagfuncs.c ebuf = epda->bufPtr + rf_RaidAddressToByte(raidPtr,
raidPtr 908 dev/raidframe/rf_evenodd_dagfuncs.c rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
raidPtr 950 dev/raidframe/rf_evenodd_dagfuncs.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
raidPtr 951 dev/raidframe/rf_evenodd_dagfuncs.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
raidPtr 957 dev/raidframe/rf_evenodd_dagfuncs.c unsigned bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
raidPtr 1017 dev/raidframe/rf_evenodd_dagfuncs.c (raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress,
raidPtr 1020 dev/raidframe/rf_evenodd_dagfuncs.c if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
raidPtr 1040 dev/raidframe/rf_evenodd_dagfuncs.c rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
raidPtr 1080 dev/raidframe/rf_evenodd_dagfuncs.c rf_e_encToBuf(raidPtr, scol, olddata[0], RF_EO_MATRIX_DIM - 2,
raidPtr 61 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 71 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 87 dev/raidframe/rf_evenodd_dags.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 96 dev/raidframe/rf_evenodd_dags.c rf_EO_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
raidPtr 104 dev/raidframe/rf_evenodd_dags.c rf_EOCreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 112 dev/raidframe/rf_evenodd_dags.c raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 114 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 124 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 133 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 148 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 163 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 169 dev/raidframe/rf_evenodd_dags.c rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 179 dev/raidframe/rf_evenodd_dags.c raidPtr->Layout.sectorsPerStripeUnit) {
raidPtr 186 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 196 dev/raidframe/rf_evenodd_dags.c raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 198 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 204 dev/raidframe/rf_evenodd_dags.c rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 210 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 216 dev/raidframe/rf_evenodd_dags.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 222 dev/raidframe/rf_evenodd_dags.c rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 89 dev/raidframe/rf_fifo.c elem->raidPtr->raidid);
raidPtr 139 dev/raidframe/rf_fifo.c nd->raidPtr->raidid, (long) nd);
raidPtr 60 dev/raidframe/rf_interdecluster.c rf_ConfigureInterDecluster(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 63 dev/raidframe/rf_interdecluster.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 70 dev/raidframe/rf_interdecluster.c (RF_InterdeclusterConfigInfo_t *), raidPtr->cleanupList);
raidPtr 76 dev/raidframe/rf_interdecluster.c SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1);
raidPtr 78 dev/raidframe/rf_interdecluster.c raidPtr->cleanupList);
raidPtr 82 dev/raidframe/rf_interdecluster.c info->stripeIdentifier[i][0] = i / (raidPtr->numCol - 1);
raidPtr 83 dev/raidframe/rf_interdecluster.c tmp = i / raidPtr->numCol;
raidPtr 84 dev/raidframe/rf_interdecluster.c info->stripeIdentifier[i][1] = (i + 1 + tmp) % raidPtr->numCol;
raidPtr 88 dev/raidframe/rf_interdecluster.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 98 dev/raidframe/rf_interdecluster.c (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol));
raidPtr 100 dev/raidframe/rf_interdecluster.c (2 * raidPtr->numCol);
raidPtr 105 dev/raidframe/rf_interdecluster.c info->stripeUnitsPerSparingRegion = raidPtr->numCol *
raidPtr 106 dev/raidframe/rf_interdecluster.c (raidPtr->numCol - 1);
raidPtr 108 dev/raidframe/rf_interdecluster.c (raidPtr->numCol + 1);
raidPtr 112 dev/raidframe/rf_interdecluster.c raidPtr->logBytesPerSector;
raidPtr 120 dev/raidframe/rf_interdecluster.c raidPtr->sectorsPerDisk =
raidPtr 123 dev/raidframe/rf_interdecluster.c raidPtr->totalSectors =
raidPtr 126 dev/raidframe/rf_interdecluster.c layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
raidPtr 133 dev/raidframe/rf_interdecluster.c rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr)
raidPtr 139 dev/raidframe/rf_interdecluster.c rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr)
raidPtr 141 dev/raidframe/rf_interdecluster.c return (raidPtr->sectorsPerDisk);
raidPtr 145 dev/raidframe/rf_interdecluster.c rf_GetNumSpareRUsInterDecluster(RF_Raid_t *raidPtr)
raidPtr 148 dev/raidframe/rf_interdecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 159 dev/raidframe/rf_interdecluster.c rf_MapSectorInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 163 dev/raidframe/rf_interdecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 164 dev/raidframe/rf_interdecluster.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 172 dev/raidframe/rf_interdecluster.c su_offset_into_disk = index_within_region % (raidPtr->numCol - 1);
raidPtr 173 dev/raidframe/rf_interdecluster.c mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
raidPtr 174 dev/raidframe/rf_interdecluster.c col_before_remap = index_within_region / (raidPtr->numCol - 1);
raidPtr 178 dev/raidframe/rf_interdecluster.c *diskSector = (su_offset_into_disk + ((raidPtr->numCol - 1) *
raidPtr 179 dev/raidframe/rf_interdecluster.c sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 181 dev/raidframe/rf_interdecluster.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 184 dev/raidframe/rf_interdecluster.c *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
raidPtr 185 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 186 dev/raidframe/rf_interdecluster.c *diskSector += (raidPtr->numCol - 1) *
raidPtr 187 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 189 dev/raidframe/rf_interdecluster.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 191 dev/raidframe/rf_interdecluster.c raidPtr->numCol;
raidPtr 192 dev/raidframe/rf_interdecluster.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 194 dev/raidframe/rf_interdecluster.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 200 dev/raidframe/rf_interdecluster.c rf_MapParityInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 204 dev/raidframe/rf_interdecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 207 dev/raidframe/rf_interdecluster.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 212 dev/raidframe/rf_interdecluster.c mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
raidPtr 214 dev/raidframe/rf_interdecluster.c mirror_su_offset_into_disk) % raidPtr->numCol;
raidPtr 220 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 221 dev/raidframe/rf_interdecluster.c *diskSector += sparing_region_id * (raidPtr->numCol - 1) *
raidPtr 222 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 224 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 226 dev/raidframe/rf_interdecluster.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 229 dev/raidframe/rf_interdecluster.c *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
raidPtr 230 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 231 dev/raidframe/rf_interdecluster.c *diskSector += (raidPtr->numCol) *
raidPtr 232 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 234 dev/raidframe/rf_interdecluster.c raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 235 dev/raidframe/rf_interdecluster.c *col = index_within_region / (raidPtr->numCol - 1);
raidPtr 236 dev/raidframe/rf_interdecluster.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 238 dev/raidframe/rf_interdecluster.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 243 dev/raidframe/rf_interdecluster.c rf_IdentifyStripeInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 247 dev/raidframe/rf_interdecluster.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 250 dev/raidframe/rf_interdecluster.c SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 276 dev/raidframe/rf_interdecluster.c rf_RAIDIDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 42 dev/raidframe/rf_kintf.h void raidstart(RF_Raid_t *raidPtr);
raidPtr 438 dev/raidframe/rf_layout.c rf_ConfigureLayout(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 441 dev/raidframe/rf_layout.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 453 dev/raidframe/rf_layout.c raidPtr->raidid, (int)layoutPtr->sectorsPerStripeUnit);
raidPtr 457 dev/raidframe/rf_layout.c layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
raidPtr 470 dev/raidframe/rf_layout.c retval = (p->Configure) (listp, raidPtr, cfgPtr);
raidPtr 476 dev/raidframe/rf_layout.c raidPtr->logBytesPerSector;
raidPtr 477 dev/raidframe/rf_layout.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 481 dev/raidframe/rf_layout.c raidPtr->numFloatingReconBufs = rf_forceNumFloatingReconBufs;
raidPtr 483 dev/raidframe/rf_layout.c raidPtr->numFloatingReconBufs =
raidPtr 484 dev/raidframe/rf_layout.c rf_GetDefaultNumFloatingReconBuffers(raidPtr);
raidPtr 488 dev/raidframe/rf_layout.c raidPtr->headSepLimit = rf_forceHeadSepLimit;
raidPtr 490 dev/raidframe/rf_layout.c raidPtr->headSepLimit = rf_GetDefaultHeadSepLimit(raidPtr);
raidPtr 494 dev/raidframe/rf_layout.c if (raidPtr->headSepLimit >= 0) {
raidPtr 497 dev/raidframe/rf_layout.c (long) raidPtr->numFloatingReconBufs,
raidPtr 498 dev/raidframe/rf_layout.c (long) raidPtr->headSepLimit);
raidPtr 502 dev/raidframe/rf_layout.c (long) raidPtr->numFloatingReconBufs);
raidPtr 78 dev/raidframe/rf_map.c RF_Raid_t *raidPtr,
raidPtr 93 dev/raidframe/rf_map.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 100 dev/raidframe/rf_map.c RF_RaidDisk_t **disks = raidPtr->Disks;
raidPtr 127 dev/raidframe/rf_map.c if (raidAddress + numBlocks > raidPtr->totalSectors) {
raidPtr 133 dev/raidframe/rf_map.c rf_PrintRaidAddressInfo(raidPtr, raidAddress, numBlocks);
raidPtr 179 dev/raidframe/rf_map.c (layoutPtr->map->MapSector) (raidPtr, raidAddress,
raidPtr 199 dev/raidframe/rf_map.c rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 0);
raidPtr 200 dev/raidframe/rf_map.c pda_p->bufPtr = buffer + rf_RaidAddressToByte(raidPtr,
raidPtr 230 dev/raidframe/rf_map.c (layoutPtr->map->MapParity) (raidPtr,
raidPtr 241 dev/raidframe/rf_map.c rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
raidPtr 259 dev/raidframe/rf_map.c (layoutPtr->map->MapParity) (raidPtr,
raidPtr 263 dev/raidframe/rf_map.c (layoutPtr->map->MapQ) (raidPtr,
raidPtr 279 dev/raidframe/rf_map.c rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
raidPtr 280 dev/raidframe/rf_map.c rf_ASMCheckStatus(raidPtr, pda_q, asm_p, disks, 1);
raidPtr 309 dev/raidframe/rf_map.c rf_MarkFailuresInASMList(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asm_h)
raidPtr 311 dev/raidframe/rf_map.c RF_RaidDisk_t **disks = raidPtr->Disks;
raidPtr 672 dev/raidframe/rf_map.c rf_CheckStripeForFailures(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
raidPtr 675 dev/raidframe/rf_map.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 683 dev/raidframe/rf_map.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 684 dev/raidframe/rf_map.c numFailures = raidPtr->numFailures;
raidPtr 685 dev/raidframe/rf_map.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 692 dev/raidframe/rf_map.c (layoutPtr->map->IdentifyStripe) (raidPtr, asmap->raidAddress,
raidPtr 694 dev/raidframe/rf_map.c (layoutPtr->map->MapParity) (raidPtr, asmap->raidAddress,
raidPtr 705 dev/raidframe/rf_map.c if (RF_DEAD_DISK(raidPtr
raidPtr 707 dev/raidframe/rf_map.c if (raidPtr->status[testrow] !=
raidPtr 711 dev/raidframe/rf_map.c raidPtr->reconControl[testrow]->fcol ==
raidPtr 713 dev/raidframe/rf_map.c layoutPtr->map->MapSector(raidPtr,
raidPtr 719 dev/raidframe/rf_map.c if (!rf_CheckRUReconstructed(raidPtr
raidPtr 736 dev/raidframe/rf_map.c rf_NumFailedDataUnitsInStripe(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
raidPtr 738 dev/raidframe/rf_map.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 745 dev/raidframe/rf_map.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 746 dev/raidframe/rf_map.c numFailures = raidPtr->numFailures;
raidPtr 747 dev/raidframe/rf_map.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 756 dev/raidframe/rf_map.c (layoutPtr->map->MapSector) (raidPtr, sosAddr + i *
raidPtr 759 dev/raidframe/rf_map.c if (RF_DEAD_DISK(raidPtr->Disks[trow][tcol].status))
raidPtr 844 dev/raidframe/rf_map.c rf_PrintRaidAddressInfo(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
raidPtr 847 dev/raidframe/rf_map.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 943 dev/raidframe/rf_map.c RF_Raid_t *raidPtr,
raidPtr 968 dev/raidframe/rf_map.c raidPtr->Layout.map->MapSector(raidPtr,
raidPtr 972 dev/raidframe/rf_map.c raidPtr->Layout.map->MapParity(raidPtr,
raidPtr 1015 dev/raidframe/rf_map.c RF_ASSERT(rf_RaidAddressToStripeUnitID(&raidPtr->Layout,
raidPtr 1017 dev/raidframe/rf_map.c rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress +
raidPtr 288 dev/raidframe/rf_openbsdkintf.c void rf_RewriteParityThread(RF_Raid_t *raidPtr);
raidPtr 289 dev/raidframe/rf_openbsdkintf.c void rf_CopybackThread(RF_Raid_t *raidPtr);
raidPtr 548 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 554 dev/raidframe/rf_openbsdkintf.c raidPtr = (RF_Raid_t *) arg;
raidPtr 555 dev/raidframe/rf_openbsdkintf.c unit = raidPtr->raidid;
raidPtr 563 dev/raidframe/rf_openbsdkintf.c rf_Shutdown(raidPtr);
raidPtr 750 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 771 dev/raidframe/rf_openbsdkintf.c raidPtr = raidPtrs[raidID];
raidPtr 772 dev/raidframe/rf_openbsdkintf.c if (!raidPtr->valid) {
raidPtr 857 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 878 dev/raidframe/rf_openbsdkintf.c raidPtr = raidPtrs[unit];
raidPtr 934 dev/raidframe/rf_openbsdkintf.c if (raidPtr->valid) {
raidPtr 995 dev/raidframe/rf_openbsdkintf.c bzero((char *) raidPtr, sizeof(RF_Raid_t));
raidPtr 998 dev/raidframe/rf_openbsdkintf.c raidPtr->raidid = unit;
raidPtr 1000 dev/raidframe/rf_openbsdkintf.c retcode = rf_Configure(raidPtr, k_cfg, NULL);
raidPtr 1008 dev/raidframe/rf_openbsdkintf.c raidPtr->openings = RAIDOUTSTANDING;
raidPtr 1010 dev/raidframe/rf_openbsdkintf.c raidinit(raidPtr);
raidPtr 1011 dev/raidframe/rf_openbsdkintf.c rf_markalldirty(raidPtr);
raidPtr 1042 dev/raidframe/rf_openbsdkintf.c if ((retcode = rf_Shutdown(raidPtr)) == 0) {
raidPtr 1089 dev/raidframe/rf_openbsdkintf.c if ((row < 0) || (row >= raidPtr->numRow) ||
raidPtr 1090 dev/raidframe/rf_openbsdkintf.c (column < 0) || (column >= raidPtr->numCol)) {
raidPtr 1095 dev/raidframe/rf_openbsdkintf.c raidread_component_label(raidPtr->Disks[row][column].dev,
raidPtr 1096 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[row][column].ci_vp, clabel );
raidPtr 1130 dev/raidframe/rf_openbsdkintf.c if ((row < 0) || (row >= raidPtr->numRow) ||
raidPtr 1131 dev/raidframe/rf_openbsdkintf.c (column < 0) || (column >= raidPtr->numCol)) {
raidPtr 1137 dev/raidframe/rf_openbsdkintf.c raidwrite_component_label(raidPtr->Disks[row][column].dev,
raidPtr 1138 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[row][column].ci_vp, clabel );
raidPtr 1151 dev/raidframe/rf_openbsdkintf.c raidPtr->serial_number = clabel->serial_number;
raidPtr 1153 dev/raidframe/rf_openbsdkintf.c raid_init_component_label(raidPtr, &ci_label);
raidPtr 1156 dev/raidframe/rf_openbsdkintf.c for(row=0;row<raidPtr->numRow;row++) {
raidPtr 1158 dev/raidframe/rf_openbsdkintf.c for(column=0;column<raidPtr->numCol;column++) {
raidPtr 1159 dev/raidframe/rf_openbsdkintf.c diskPtr = &raidPtr->Disks[row][column];
raidPtr 1165 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[row][column].dev,
raidPtr 1166 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[row][column].ci_vp,
raidPtr 1176 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1178 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_good = RF_RAID_CLEAN;
raidPtr 1183 dev/raidframe/rf_openbsdkintf.c if (raidPtr->parity_rewrite_in_progress == 1) {
raidPtr 1188 dev/raidframe/rf_openbsdkintf.c retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
raidPtr 1190 dev/raidframe/rf_openbsdkintf.c raidPtr,"raid_parity");
raidPtr 1195 dev/raidframe/rf_openbsdkintf.c d = rf_set_autoconfig(raidPtr, *(int *) data);
raidPtr 1201 dev/raidframe/rf_openbsdkintf.c d = rf_set_rootpartition(raidPtr, *(int *) data);
raidPtr 1210 dev/raidframe/rf_openbsdkintf.c retcode = rf_add_hot_spare(raidPtr, &hot_spare);
raidPtr 1220 dev/raidframe/rf_openbsdkintf.c retcode = rf_delete_component(raidPtr, &component);
raidPtr 1227 dev/raidframe/rf_openbsdkintf.c retcode = rf_incorporate_hot_spare(raidPtr, &component);
raidPtr 1232 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1237 dev/raidframe/rf_openbsdkintf.c if (raidPtr->recon_in_progress == 1) {
raidPtr 1248 dev/raidframe/rf_openbsdkintf.c if ((row < 0) || (row >= raidPtr->numRow) ||
raidPtr 1249 dev/raidframe/rf_openbsdkintf.c (column < 0) || (column >= raidPtr->numCol)) {
raidPtr 1257 dev/raidframe/rf_openbsdkintf.c rrcopy->raidPtr = (void *) raidPtr;
raidPtr 1261 dev/raidframe/rf_openbsdkintf.c retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
raidPtr 1268 dev/raidframe/rf_openbsdkintf.c if (!raidPtr->valid)
raidPtr 1276 dev/raidframe/rf_openbsdkintf.c d_cfg->rows = raidPtr->numRow;
raidPtr 1277 dev/raidframe/rf_openbsdkintf.c d_cfg->cols = raidPtr->numCol;
raidPtr 1278 dev/raidframe/rf_openbsdkintf.c d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol;
raidPtr 1283 dev/raidframe/rf_openbsdkintf.c d_cfg->nspares = raidPtr->numSpare;
raidPtr 1288 dev/raidframe/rf_openbsdkintf.c d_cfg->maxqdepth = raidPtr->maxQueueDepth;
raidPtr 1292 dev/raidframe/rf_openbsdkintf.c d_cfg->devs[d] = raidPtr->Disks[i][j];
raidPtr 1297 dev/raidframe/rf_openbsdkintf.c d_cfg->spares[i] = raidPtr->Disks[0][j];
raidPtr 1306 dev/raidframe/rf_openbsdkintf.c *(int *) data = raidPtr->parity_good;
raidPtr 1310 dev/raidframe/rf_openbsdkintf.c bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals));
raidPtr 1315 dev/raidframe/rf_openbsdkintf.c *totals = raidPtr->acc_totals;
raidPtr 1319 dev/raidframe/rf_openbsdkintf.c raidPtr->keep_acc_totals = *(int *)data;
raidPtr 1323 dev/raidframe/rf_openbsdkintf.c *(int *) data = raidPtr->totalSectors;
raidPtr 1330 dev/raidframe/rf_openbsdkintf.c if (rr->row < 0 || rr->row >= raidPtr->numRow ||
raidPtr 1331 dev/raidframe/rf_openbsdkintf.c rr->col < 0 || rr->col >= raidPtr->numCol)
raidPtr 1345 dev/raidframe/rf_openbsdkintf.c rrcopy->raidPtr = (void *)raidPtr;
raidPtr 1347 dev/raidframe/rf_openbsdkintf.c retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
raidPtr 1357 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1362 dev/raidframe/rf_openbsdkintf.c if (raidPtr->copyback_in_progress == 1) {
raidPtr 1367 dev/raidframe/rf_openbsdkintf.c retcode = RF_CREATE_THREAD(raidPtr->copyback_thread,
raidPtr 1369 dev/raidframe/rf_openbsdkintf.c raidPtr,"raid_copyback");
raidPtr 1374 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1383 dev/raidframe/rf_openbsdkintf.c if (raidPtr->status[row] != rf_rs_reconstructing)
raidPtr 1387 dev/raidframe/rf_openbsdkintf.c raidPtr->reconControl[row]->percentComplete;
raidPtr 1393 dev/raidframe/rf_openbsdkintf.c if (raidPtr->status[row] != rf_rs_reconstructing) {
raidPtr 1399 dev/raidframe/rf_openbsdkintf.c raidPtr->reconControl[row]->numRUsTotal;
raidPtr 1401 dev/raidframe/rf_openbsdkintf.c raidPtr->reconControl[row]->numRUsComplete;
raidPtr 1411 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1419 dev/raidframe/rf_openbsdkintf.c if (raidPtr->parity_rewrite_in_progress == 1) {
raidPtr 1421 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_rewrite_stripes_done /
raidPtr 1422 dev/raidframe/rf_openbsdkintf.c raidPtr->Layout.numStripe;
raidPtr 1430 dev/raidframe/rf_openbsdkintf.c if (raidPtr->parity_rewrite_in_progress == 1) {
raidPtr 1431 dev/raidframe/rf_openbsdkintf.c progressInfo.total = raidPtr->Layout.numStripe;
raidPtr 1433 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_rewrite_stripes_done;
raidPtr 1447 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 1452 dev/raidframe/rf_openbsdkintf.c if (raidPtr->copyback_in_progress == 1) {
raidPtr 1453 dev/raidframe/rf_openbsdkintf.c *(int *) data = 100 * raidPtr->copyback_stripes_done /
raidPtr 1454 dev/raidframe/rf_openbsdkintf.c raidPtr->Layout.numStripe;
raidPtr 1462 dev/raidframe/rf_openbsdkintf.c if (raidPtr->copyback_in_progress == 1) {
raidPtr 1463 dev/raidframe/rf_openbsdkintf.c progressInfo.total = raidPtr->Layout.numStripe;
raidPtr 1465 dev/raidframe/rf_openbsdkintf.c raidPtr->copyback_stripes_done;
raidPtr 1527 dev/raidframe/rf_openbsdkintf.c retcode = rf_SetSpareTable(raidPtr,*(void **)data);
raidPtr 1548 dev/raidframe/rf_openbsdkintf.c if (!raidPtr->valid)
raidPtr 1615 dev/raidframe/rf_openbsdkintf.c raidinit(RF_Raid_t *raidPtr)
raidPtr 1621 dev/raidframe/rf_openbsdkintf.c unit = raidPtr->raidid;
raidPtr 1646 dev/raidframe/rf_openbsdkintf.c rs->sc_size = raidPtr->totalSectors;
raidPtr 1711 dev/raidframe/rf_openbsdkintf.c raidstart(RF_Raid_t *raidPtr)
raidPtr 1723 dev/raidframe/rf_openbsdkintf.c unit = raidPtr->raidid;
raidPtr 1727 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1728 dev/raidframe/rf_openbsdkintf.c if (raidPtr->numNewFailures > 0) {
raidPtr 1729 dev/raidframe/rf_openbsdkintf.c rf_update_component_labels(raidPtr,
raidPtr 1731 dev/raidframe/rf_openbsdkintf.c raidPtr->numNewFailures--;
raidPtr 1733 dev/raidframe/rf_openbsdkintf.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1736 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1737 dev/raidframe/rf_openbsdkintf.c while (raidPtr->openings > 0) {
raidPtr 1738 dev/raidframe/rf_openbsdkintf.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1771 dev/raidframe/rf_openbsdkintf.c num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
raidPtr 1772 dev/raidframe/rf_openbsdkintf.c pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
raidPtr 1779 dev/raidframe/rf_openbsdkintf.c if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
raidPtr 1788 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1795 dev/raidframe/rf_openbsdkintf.c if (bp->b_bcount & raidPtr->sectorMask) {
raidPtr 1803 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1810 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1811 dev/raidframe/rf_openbsdkintf.c raidPtr->openings--;
raidPtr 1812 dev/raidframe/rf_openbsdkintf.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1831 dev/raidframe/rf_openbsdkintf.c retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
raidPtr 1837 dev/raidframe/rf_openbsdkintf.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 1839 dev/raidframe/rf_openbsdkintf.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 1860 dev/raidframe/rf_openbsdkintf.c unit = queue->raidPtr->raidid;
raidPtr 1932 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->logBytesPerSector, req->b_proc);
raidPtr 1951 dev/raidframe/rf_openbsdkintf.c (int)(req->numSector << queue->raidPtr->logBytesPerSector),
raidPtr 1952 dev/raidframe/rf_openbsdkintf.c (int)queue->raidPtr->logBytesPerSector));
raidPtr 2016 dev/raidframe/rf_openbsdkintf.c unit = queue->raidPtr->raidid; /* *Much* simpler :-> */
raidPtr 2024 dev/raidframe/rf_openbsdkintf.c if (queue->raidPtr->Disks[queue->row][queue->col].status ==
raidPtr 2028 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->
raidPtr 2030 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->Disks[queue->row][queue->col].status =
raidPtr 2032 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->status[queue->row] = rf_rs_degraded;
raidPtr 2033 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->numFailures++;
raidPtr 2034 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->numNewFailures++;
raidPtr 2087 dev/raidframe/rf_openbsdkintf.c raidgetdefaultlabel(RF_Raid_t *raidPtr, struct raid_softc *rs,
raidPtr 2094 dev/raidframe/rf_openbsdkintf.c DL_SETDSIZE(lp, raidPtr->totalSectors);
raidPtr 2095 dev/raidframe/rf_openbsdkintf.c lp->d_secsize = raidPtr->bytesPerSector;
raidPtr 2096 dev/raidframe/rf_openbsdkintf.c lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe;
raidPtr 2097 dev/raidframe/rf_openbsdkintf.c lp->d_ntracks = 4 * raidPtr->numCol;
raidPtr 2098 dev/raidframe/rf_openbsdkintf.c lp->d_ncylinders = raidPtr->totalSectors /
raidPtr 2111 dev/raidframe/rf_openbsdkintf.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], raidPtr->totalSectors);
raidPtr 2130 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 2138 dev/raidframe/rf_openbsdkintf.c raidPtr = raidPtrs[unit];
raidPtr 2140 dev/raidframe/rf_openbsdkintf.c raidgetdefaultlabel(raidPtr, rs, lp);
raidPtr 2361 dev/raidframe/rf_openbsdkintf.c rf_markalldirty(RF_Raid_t *raidPtr)
raidPtr 2366 dev/raidframe/rf_openbsdkintf.c raidPtr->mod_counter++;
raidPtr 2367 dev/raidframe/rf_openbsdkintf.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 2368 dev/raidframe/rf_openbsdkintf.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 2373 dev/raidframe/rf_openbsdkintf.c if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) {
raidPtr 2375 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2376 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp, &clabel);
raidPtr 2386 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].status;
raidPtr 2388 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2389 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr 2393 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2394 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr 2395 dev/raidframe/rf_openbsdkintf.c raidPtr->mod_counter);
raidPtr 2402 dev/raidframe/rf_openbsdkintf.c for( c = 0; c < raidPtr->numSpare ; c++) {
raidPtr 2403 dev/raidframe/rf_openbsdkintf.c sparecol = raidPtr->numCol + c;
raidPtr 2404 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) {
raidPtr 2416 dev/raidframe/rf_openbsdkintf.c for(i=0;i<raidPtr->numRow;i++) {
raidPtr 2417 dev/raidframe/rf_openbsdkintf.c for(j=0;j<raidPtr->numCol;j++) {
raidPtr 2418 dev/raidframe/rf_openbsdkintf.c if ((raidPtr->Disks[i][j].spareRow ==
raidPtr 2420 dev/raidframe/rf_openbsdkintf.c (raidPtr->Disks[i][j].spareCol ==
raidPtr 2430 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][sparecol].dev,
raidPtr 2431 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
raidPtr 2434 dev/raidframe/rf_openbsdkintf.c clabel.mod_counter = raidPtr->mod_counter;
raidPtr 2435 dev/raidframe/rf_openbsdkintf.c clabel.serial_number = raidPtr->serial_number;
raidPtr 2438 dev/raidframe/rf_openbsdkintf.c clabel.num_rows = raidPtr->numRow;
raidPtr 2439 dev/raidframe/rf_openbsdkintf.c clabel.num_columns = raidPtr->numCol;
raidPtr 2443 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][sparecol].dev,
raidPtr 2444 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
raidPtr 2445 dev/raidframe/rf_openbsdkintf.c raidmarkclean( raidPtr->Disks[r][sparecol].dev,
raidPtr 2446 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][sparecol].ci_vp);
raidPtr 2455 dev/raidframe/rf_openbsdkintf.c rf_update_component_labels(RF_Raid_t *raidPtr, int final)
raidPtr 2471 dev/raidframe/rf_openbsdkintf.c raidPtr->mod_counter++;
raidPtr 2473 dev/raidframe/rf_openbsdkintf.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 2474 dev/raidframe/rf_openbsdkintf.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 2475 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Disks[r][c].status == rf_ds_optimal) {
raidPtr 2477 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2478 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr 2483 dev/raidframe/rf_openbsdkintf.c clabel.mod_counter = raidPtr->mod_counter;
raidPtr 2486 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2487 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp,
raidPtr 2490 dev/raidframe/rf_openbsdkintf.c if (raidPtr->parity_good ==
raidPtr 2493 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].dev,
raidPtr 2494 dev/raidframe/rf_openbsdkintf.c raidPtr->
raidPtr 2496 dev/raidframe/rf_openbsdkintf.c raidPtr->mod_counter);
raidPtr 2504 dev/raidframe/rf_openbsdkintf.c for( c = 0; c < raidPtr->numSpare ; c++) {
raidPtr 2505 dev/raidframe/rf_openbsdkintf.c sparecol = raidPtr->numCol + c;
raidPtr 2506 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
raidPtr 2514 dev/raidframe/rf_openbsdkintf.c for(i=0;i<raidPtr->numRow;i++) {
raidPtr 2515 dev/raidframe/rf_openbsdkintf.c for(j=0;j<raidPtr->numCol;j++) {
raidPtr 2516 dev/raidframe/rf_openbsdkintf.c if ((raidPtr->Disks[i][j].spareRow ==
raidPtr 2518 dev/raidframe/rf_openbsdkintf.c (raidPtr->Disks[i][j].spareCol ==
raidPtr 2529 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[0][sparecol].dev,
raidPtr 2530 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
raidPtr 2533 dev/raidframe/rf_openbsdkintf.c raid_init_component_label(raidPtr, &clabel);
raidPtr 2535 dev/raidframe/rf_openbsdkintf.c clabel.mod_counter = raidPtr->mod_counter;
raidPtr 2541 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[0][sparecol].dev,
raidPtr 2542 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
raidPtr 2544 dev/raidframe/rf_openbsdkintf.c if (raidPtr->parity_good == RF_RAID_CLEAN) {
raidPtr 2545 dev/raidframe/rf_openbsdkintf.c raidmarkclean(raidPtr->
raidPtr 2547 dev/raidframe/rf_openbsdkintf.c raidPtr->
raidPtr 2549 dev/raidframe/rf_openbsdkintf.c raidPtr->mod_counter);
raidPtr 2558 dev/raidframe/rf_openbsdkintf.c rf_close_component(RF_Raid_t *raidPtr, struct vnode *vp, int auto_configured)
raidPtr 2577 dev/raidframe/rf_openbsdkintf.c rf_UnconfigureVnodes(RF_Raid_t *raidPtr)
raidPtr 2586 dev/raidframe/rf_openbsdkintf.c for (r = 0; r < raidPtr->numRow; r++) {
raidPtr 2587 dev/raidframe/rf_openbsdkintf.c for (c = 0; c < raidPtr->numCol; c++) {
raidPtr 2590 dev/raidframe/rf_openbsdkintf.c vp = raidPtr->raid_cinfo[r][c].ci_vp;
raidPtr 2591 dev/raidframe/rf_openbsdkintf.c acd = raidPtr->Disks[r][c].auto_configured;
raidPtr 2592 dev/raidframe/rf_openbsdkintf.c rf_close_component(raidPtr, vp, acd);
raidPtr 2593 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[r][c].ci_vp = NULL;
raidPtr 2594 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[r][c].auto_configured = 0;
raidPtr 2597 dev/raidframe/rf_openbsdkintf.c for (r = 0; r < raidPtr->numSpare; r++) {
raidPtr 2599 dev/raidframe/rf_openbsdkintf.c vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp;
raidPtr 2600 dev/raidframe/rf_openbsdkintf.c acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured;
raidPtr 2601 dev/raidframe/rf_openbsdkintf.c rf_close_component(raidPtr, vp, acd);
raidPtr 2602 dev/raidframe/rf_openbsdkintf.c raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL;
raidPtr 2603 dev/raidframe/rf_openbsdkintf.c raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0;
raidPtr 2612 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 2615 dev/raidframe/rf_openbsdkintf.c raidPtr = (RF_Raid_t *) req->raidPtr;
raidPtr 2616 dev/raidframe/rf_openbsdkintf.c raidPtr->recon_in_progress = 1;
raidPtr 2618 dev/raidframe/rf_openbsdkintf.c rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
raidPtr 2624 dev/raidframe/rf_openbsdkintf.c raidPtr->recon_in_progress = 0;
raidPtr 2632 dev/raidframe/rf_openbsdkintf.c rf_RewriteParityThread(RF_Raid_t *raidPtr)
raidPtr 2638 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_rewrite_in_progress = 1;
raidPtr 2639 dev/raidframe/rf_openbsdkintf.c retcode = rf_RewriteParity(raidPtr);
raidPtr 2641 dev/raidframe/rf_openbsdkintf.c printf("raid%d: Error re-writing parity!\n",raidPtr->raidid);
raidPtr 2648 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_good = RF_RAID_CLEAN;
raidPtr 2650 dev/raidframe/rf_openbsdkintf.c raidPtr->parity_rewrite_in_progress = 0;
raidPtr 2654 dev/raidframe/rf_openbsdkintf.c if (raidPtr->waitShutdown) {
raidPtr 2655 dev/raidframe/rf_openbsdkintf.c wakeup(&raidPtr->parity_rewrite_in_progress);
raidPtr 2664 dev/raidframe/rf_openbsdkintf.c rf_CopybackThread(RF_Raid_t *raidPtr)
raidPtr 2669 dev/raidframe/rf_openbsdkintf.c raidPtr->copyback_in_progress = 1;
raidPtr 2670 dev/raidframe/rf_openbsdkintf.c rf_CopybackReconstructedData(raidPtr);
raidPtr 2671 dev/raidframe/rf_openbsdkintf.c raidPtr->copyback_in_progress = 0;
raidPtr 2684 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 2687 dev/raidframe/rf_openbsdkintf.c raidPtr = req->raidPtr;
raidPtr 2688 dev/raidframe/rf_openbsdkintf.c raidPtr->recon_in_progress = 1;
raidPtr 2689 dev/raidframe/rf_openbsdkintf.c retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col);
raidPtr 2691 dev/raidframe/rf_openbsdkintf.c raidPtr->recon_in_progress = 0;
raidPtr 3154 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr)
raidPtr 3298 dev/raidframe/rf_openbsdkintf.c rf_set_autoconfig(RF_Raid_t *raidPtr, int new_value)
raidPtr 3305 dev/raidframe/rf_openbsdkintf.c raidPtr->autoconfigure = new_value;
raidPtr 3306 dev/raidframe/rf_openbsdkintf.c for(row=0; row<raidPtr->numRow; row++) {
raidPtr 3307 dev/raidframe/rf_openbsdkintf.c for(column=0; column<raidPtr->numCol; column++) {
raidPtr 3308 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Disks[row][column].status ==
raidPtr 3310 dev/raidframe/rf_openbsdkintf.c dev = raidPtr->Disks[row][column].dev;
raidPtr 3311 dev/raidframe/rf_openbsdkintf.c vp = raidPtr->raid_cinfo[row][column].ci_vp;
raidPtr 3322 dev/raidframe/rf_openbsdkintf.c rf_set_rootpartition(RF_Raid_t *raidPtr, int new_value)
raidPtr 3329 dev/raidframe/rf_openbsdkintf.c raidPtr->root_partition = new_value;
raidPtr 3330 dev/raidframe/rf_openbsdkintf.c for(row=0; row<raidPtr->numRow; row++) {
raidPtr 3331 dev/raidframe/rf_openbsdkintf.c for(column=0; column<raidPtr->numCol; column++) {
raidPtr 3332 dev/raidframe/rf_openbsdkintf.c if (raidPtr->Disks[row][column].status ==
raidPtr 3334 dev/raidframe/rf_openbsdkintf.c dev = raidPtr->Disks[row][column].dev;
raidPtr 3335 dev/raidframe/rf_openbsdkintf.c vp = raidPtr->raid_cinfo[row][column].ci_vp;
raidPtr 3385 dev/raidframe/rf_openbsdkintf.c raid_init_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
raidPtr 3389 dev/raidframe/rf_openbsdkintf.c clabel->serial_number = raidPtr->serial_number;
raidPtr 3390 dev/raidframe/rf_openbsdkintf.c clabel->mod_counter = raidPtr->mod_counter;
raidPtr 3391 dev/raidframe/rf_openbsdkintf.c clabel->num_rows = raidPtr->numRow;
raidPtr 3392 dev/raidframe/rf_openbsdkintf.c clabel->num_columns = raidPtr->numCol;
raidPtr 3396 dev/raidframe/rf_openbsdkintf.c clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 3397 dev/raidframe/rf_openbsdkintf.c clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
raidPtr 3398 dev/raidframe/rf_openbsdkintf.c clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
raidPtr 3400 dev/raidframe/rf_openbsdkintf.c clabel->blockSize = raidPtr->bytesPerSector;
raidPtr 3401 dev/raidframe/rf_openbsdkintf.c clabel->numBlocks = raidPtr->sectorsPerDisk;
raidPtr 3404 dev/raidframe/rf_openbsdkintf.c clabel->parityConfig = raidPtr->Layout.map->parityConfig;
raidPtr 3405 dev/raidframe/rf_openbsdkintf.c clabel->maxOutstanding = raidPtr->maxOutstanding;
raidPtr 3406 dev/raidframe/rf_openbsdkintf.c clabel->autoconfigure = raidPtr->autoconfigure;
raidPtr 3407 dev/raidframe/rf_openbsdkintf.c clabel->root_partition = raidPtr->root_partition;
raidPtr 3408 dev/raidframe/rf_openbsdkintf.c clabel->last_unit = raidPtr->raidid;
raidPtr 3409 dev/raidframe/rf_openbsdkintf.c clabel->config_order = raidPtr->config_order;
raidPtr 3415 dev/raidframe/rf_openbsdkintf.c RF_Raid_t *raidPtr;
raidPtr 3472 dev/raidframe/rf_openbsdkintf.c raidPtr = raidPtrs[raidID];
raidPtr 3475 dev/raidframe/rf_openbsdkintf.c raidPtr->raidid = raidID;
raidPtr 3476 dev/raidframe/rf_openbsdkintf.c raidPtr->openings = RAIDOUTSTANDING;
raidPtr 3479 dev/raidframe/rf_openbsdkintf.c rf_create_configuration(cset->ac, config, raidPtr);
raidPtr 3482 dev/raidframe/rf_openbsdkintf.c retcode = rf_Configure(raidPtr, config, cset->ac);
raidPtr 3521 dev/raidframe/rf_openbsdkintf.c disk_unbusy(&raid_softc[desc->raidPtr->raidid].sc_dkdev,
raidPtr 77 dev/raidframe/rf_paritylog.c rf_AllocParityLogCommonData(RF_Raid_t *raidPtr)
raidPtr 88 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 89 dev/raidframe/rf_paritylog.c if (raidPtr->parityLogDiskQueue.freeCommonList) {
raidPtr 90 dev/raidframe/rf_paritylog.c common = raidPtr->parityLogDiskQueue.freeCommonList;
raidPtr 91 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeCommonList =
raidPtr 92 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeCommonList->next;
raidPtr 93 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 95 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 113 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 121 dev/raidframe/rf_paritylog.c raidPtr = common->raidPtr;
raidPtr 122 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 123 dev/raidframe/rf_paritylog.c common->next = raidPtr->parityLogDiskQueue.freeCommonList;
raidPtr 124 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeCommonList = common;
raidPtr 125 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 129 dev/raidframe/rf_paritylog.c rf_AllocParityLogData(RF_Raid_t *raidPtr)
raidPtr 139 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 140 dev/raidframe/rf_paritylog.c if (raidPtr->parityLogDiskQueue.freeDataList) {
raidPtr 141 dev/raidframe/rf_paritylog.c data = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr 142 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeDataList =
raidPtr 143 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeDataList->next;
raidPtr 144 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 146 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 160 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 168 dev/raidframe/rf_paritylog.c raidPtr = data->common->raidPtr;
raidPtr 169 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 172 dev/raidframe/rf_paritylog.c data->next = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr 173 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.freeDataList = data;
raidPtr 176 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 184 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 191 dev/raidframe/rf_paritylog.c raidPtr = data->common->raidPtr;
raidPtr 199 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 216 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 220 dev/raidframe/rf_paritylog.c rf_DequeueParityLogData(RF_Raid_t *raidPtr, RF_ParityLogData_t **head,
raidPtr 232 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 258 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 267 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 274 dev/raidframe/rf_paritylog.c raidPtr = data->common->raidPtr;
raidPtr 281 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 297 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 302 dev/raidframe/rf_paritylog.c caddr_t bufPtr, RF_Raid_t *raidPtr,
raidPtr 319 dev/raidframe/rf_paritylog.c common = rf_AllocParityLogCommonData(raidPtr);
raidPtr 324 dev/raidframe/rf_paritylog.c common->raidPtr = raidPtr;
raidPtr 335 dev/raidframe/rf_paritylog.c data = rf_AllocParityLogData(raidPtr);
raidPtr 340 dev/raidframe/rf_paritylog.c data->regionID = rf_MapRegionIDParityLogging(raidPtr,
raidPtr 342 dev/raidframe/rf_paritylog.c if (data->regionID == rf_MapRegionIDParityLogging(raidPtr,
raidPtr 356 dev/raidframe/rf_paritylog.c rf_MapRegionIDParityLogging(raidPtr,
raidPtr 378 dev/raidframe/rf_paritylog.c rf_SearchAndDequeueParityLogData(RF_Raid_t *raidPtr, int regionID,
raidPtr 395 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 443 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 448 dev/raidframe/rf_paritylog.c rf_DequeueMatchingLogData(RF_Raid_t *raidPtr, RF_ParityLogData_t **head,
raidPtr 462 dev/raidframe/rf_paritylog.c logDataList = rf_DequeueParityLogData(raidPtr, head, tail, RF_TRUE);
raidPtr 466 dev/raidframe/rf_paritylog.c logData->next = rf_SearchAndDequeueParityLogData(raidPtr,
raidPtr 471 dev/raidframe/rf_paritylog.c rf_SearchAndDequeueParityLogData(raidPtr, regionID,
raidPtr 483 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 489 dev/raidframe/rf_paritylog.c raidPtr = logData->common->raidPtr;
raidPtr 490 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 491 dev/raidframe/rf_paritylog.c if (raidPtr->parityLogPool.parityLogs) {
raidPtr 492 dev/raidframe/rf_paritylog.c log = raidPtr->parityLogPool.parityLogs;
raidPtr 493 dev/raidframe/rf_paritylog.c raidPtr->parityLogPool.parityLogs =
raidPtr 494 dev/raidframe/rf_paritylog.c raidPtr->parityLogPool.parityLogs->next;
raidPtr 498 dev/raidframe/rf_paritylog.c raidPtr->logsInUse++;
raidPtr 499 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->logsInUse >= 0 &&
raidPtr 500 dev/raidframe/rf_paritylog.c raidPtr->logsInUse <= raidPtr->numParityLogs);
raidPtr 513 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockHead,
raidPtr 514 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockTail);
raidPtr 517 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockHead,
raidPtr 518 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockTail);
raidPtr 520 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 525 dev/raidframe/rf_paritylog.c rf_ReleaseParityLogs(RF_Raid_t *raidPtr, RF_ParityLog_t *firstLog)
raidPtr 545 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 546 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 547 dev/raidframe/rf_paritylog.c logDataList = rf_DequeueMatchingLogData(raidPtr,
raidPtr 548 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockHead,
raidPtr 549 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockTail);
raidPtr 556 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 557 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 570 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 571 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 573 dev/raidframe/rf_paritylog.c logDataList = rf_DequeueMatchingLogData(raidPtr,
raidPtr 574 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockHead,
raidPtr 575 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.logBlockTail);
raidPtr 584 dev/raidframe/rf_paritylog.c raidPtr->logsInUse--;
raidPtr 585 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->logsInUse >= 0 &&
raidPtr 586 dev/raidframe/rf_paritylog.c raidPtr->logsInUse <= raidPtr->numParityLogs);
raidPtr 589 dev/raidframe/rf_paritylog.c raidPtr->logsInUse--;
raidPtr 590 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->logsInUse >= 0 &&
raidPtr 591 dev/raidframe/rf_paritylog.c raidPtr->logsInUse <= raidPtr->numParityLogs);
raidPtr 593 dev/raidframe/rf_paritylog.c lastLog->next = raidPtr->parityLogPool.parityLogs;
raidPtr 594 dev/raidframe/rf_paritylog.c raidPtr->parityLogPool.parityLogs = firstLog;
raidPtr 596 dev/raidframe/rf_paritylog.c log = raidPtr->parityLogPool.parityLogs;
raidPtr 601 dev/raidframe/rf_paritylog.c RF_ASSERT(cnt + raidPtr->logsInUse == raidPtr->numParityLogs);
raidPtr 603 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
raidPtr 604 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 608 dev/raidframe/rf_paritylog.c rf_ReintLog(RF_Raid_t *raidPtr, int regionID, RF_ParityLog_t *log)
raidPtr 619 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 621 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].reintInProgress = RF_TRUE;
raidPtr 627 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 628 dev/raidframe/rf_paritylog.c log->next = raidPtr->parityLogDiskQueue.reintQueue;
raidPtr 629 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.reintQueue = log;
raidPtr 630 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 631 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 632 dev/raidframe/rf_paritylog.c RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
raidPtr 636 dev/raidframe/rf_paritylog.c rf_FlushLog(RF_Raid_t *raidPtr, RF_ParityLog_t *log)
raidPtr 645 dev/raidframe/rf_paritylog.c RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
raidPtr 648 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 649 dev/raidframe/rf_paritylog.c log->next = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr 650 dev/raidframe/rf_paritylog.c raidPtr->parityLogDiskQueue.flushQueue = log;
raidPtr 651 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 652 dev/raidframe/rf_paritylog.c RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
raidPtr 660 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 662 dev/raidframe/rf_paritylog.c raidPtr = logData->common->raidPtr;
raidPtr 679 dev/raidframe/rf_paritylog.c log = raidPtr->regionInfo[regionID].coreLog;
raidPtr 680 dev/raidframe/rf_paritylog.c RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
raidPtr 684 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 685 dev/raidframe/rf_paritylog.c if (raidPtr->regionInfo[regionID].reintInProgress) {
raidPtr 700 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.reintBlockHead,
raidPtr 701 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.reintBlockTail);
raidPtr 704 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.reintBlockHead,
raidPtr 705 dev/raidframe/rf_paritylog.c &raidPtr->parityLogDiskQueue.reintBlockTail);
raidPtr 706 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 709 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 710 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].coreLog = NULL;
raidPtr 711 dev/raidframe/rf_paritylog.c if ((raidPtr->regionInfo[regionID].diskCount) <
raidPtr 712 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].capacity)
raidPtr 719 dev/raidframe/rf_paritylog.c diskCount = raidPtr->regionInfo[regionID].diskCount;
raidPtr 720 dev/raidframe/rf_paritylog.c for (i = 0; i < raidPtr->numSectorsPerLog; i++) {
raidPtr 721 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].diskMap[i + diskCount]
raidPtr 723 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].diskMap[i + diskCount]
raidPtr 727 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].diskCount +=
raidPtr 728 dev/raidframe/rf_paritylog.c raidPtr->numSectorsPerLog;
raidPtr 729 dev/raidframe/rf_paritylog.c rf_FlushLog(raidPtr, log);
raidPtr 735 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].diskCount ==
raidPtr 736 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].capacity);
raidPtr 737 dev/raidframe/rf_paritylog.c rf_ReintLog(raidPtr, regionID, log);
raidPtr 753 dev/raidframe/rf_paritylog.c RF_Raid_t *raidPtr;
raidPtr 776 dev/raidframe/rf_paritylog.c raidPtr = logData->common->raidPtr;
raidPtr 780 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 781 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].loggingEnabled);
raidPtr 789 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 790 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 791 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].reintInProgress ==
raidPtr 793 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].diskCount = 0;
raidPtr 794 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].reintInProgress = RF_FALSE;
raidPtr 796 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 797 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 815 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 817 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 818 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].loggingEnabled);
raidPtr 839 dev/raidframe/rf_paritylog.c if (!raidPtr->regionInfo[regionID].coreLog) {
raidPtr 849 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 851 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 856 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 861 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].coreLog =
raidPtr 868 dev/raidframe/rf_paritylog.c if (!raidPtr->regionInfo[regionID].coreLog)
raidPtr 871 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].coreLog
raidPtr 881 dev/raidframe/rf_paritylog.c if (raidPtr->regionInfo[regionID].coreLog
raidPtr 882 dev/raidframe/rf_paritylog.c ->numRecords == raidPtr->numSectorsPerLog)
raidPtr 899 dev/raidframe/rf_paritylog.c raidPtr->
raidPtr 902 dev/raidframe/rf_paritylog.c raidPtr->
raidPtr 908 dev/raidframe/rf_paritylog.c raidPtr->
raidPtr 913 dev/raidframe/rf_paritylog.c raidPtr->regionInfo
raidPtr 922 dev/raidframe/rf_paritylog.c if (!raidPtr->regionInfo
raidPtr 937 dev/raidframe/rf_paritylog.c RF_ASSERT(raidPtr->regionInfo[regionID].coreLog
raidPtr 944 dev/raidframe/rf_paritylog.c log = raidPtr->regionInfo[regionID].coreLog;
raidPtr 946 dev/raidframe/rf_paritylog.c raidPtr->numSectorsPerLog);
raidPtr 952 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 956 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 958 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID]
raidPtr 965 dev/raidframe/rf_paritylog.c item->common->raidPtr->logBytesPerSector))),
raidPtr 967 dev/raidframe/rf_paritylog.c item->common->raidPtr->logBytesPerSector)),
raidPtr 968 dev/raidframe/rf_paritylog.c (1 << item->common->raidPtr
raidPtr 1014 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 1022 dev/raidframe/rf_paritylog.c rf_EnableParityLogging(RF_Raid_t *raidPtr)
raidPtr 1027 dev/raidframe/rf_paritylog.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 1028 dev/raidframe/rf_paritylog.c raidPtr->regionInfo[regionID].loggingEnabled = RF_TRUE;
raidPtr 1029 dev/raidframe/rf_paritylog.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 53 dev/raidframe/rf_paritylog.h RF_Raid_t *raidPtr;
raidPtr 124 dev/raidframe/rf_paritylogDiskMgr.c caddr_t regionBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **rrd_dag_h,
raidPtr 139 dev/raidframe/rf_paritylogDiskMgr.c *rrd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, regionBuffer,
raidPtr 147 dev/raidframe/rf_paritylogDiskMgr.c rf_MapLogParityLogging(raidPtr, regionID, 0, &((*rrd_pda)->row),
raidPtr 149 dev/raidframe/rf_paritylogDiskMgr.c (*rrd_pda)->numSector = raidPtr->regionInfo[regionID].capacity;
raidPtr 174 dev/raidframe/rf_paritylogDiskMgr.c RF_Raid_t *raidPtr, RF_DagHeader_t **fwr_dag_h,
raidPtr 191 dev/raidframe/rf_paritylogDiskMgr.c *fwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, log->bufPtr,
raidPtr 200 dev/raidframe/rf_paritylogDiskMgr.c rf_MapLogParityLogging(raidPtr, regionID, regionOffset,
raidPtr 202 dev/raidframe/rf_paritylogDiskMgr.c (*fwr_pda)->numSector = raidPtr->numSectorsPerLog;
raidPtr 223 dev/raidframe/rf_paritylogDiskMgr.c caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **prd_dag_h,
raidPtr 238 dev/raidframe/rf_paritylogDiskMgr.c *prd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, NULL, rf_DiskReadFunc,
raidPtr 246 dev/raidframe/rf_paritylogDiskMgr.c rf_MapRegionParity(raidPtr, regionID, &((*prd_pda)->row),
raidPtr 275 dev/raidframe/rf_paritylogDiskMgr.c caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **pwr_dag_h,
raidPtr 290 dev/raidframe/rf_paritylogDiskMgr.c *pwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, parityBuffer,
raidPtr 298 dev/raidframe/rf_paritylogDiskMgr.c rf_MapRegionParity(raidPtr, regionID, &((*pwr_pda)->row),
raidPtr 319 dev/raidframe/rf_paritylogDiskMgr.c rf_FlushLogsToDisk(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
raidPtr 353 dev/raidframe/rf_paritylogDiskMgr.c rf_WriteCoreLog(log, fwr_mcpair, raidPtr, &fwr_dag_h,
raidPtr 373 dev/raidframe/rf_paritylogDiskMgr.c rf_ReleaseParityLogs(raidPtr, logList);
raidPtr 377 dev/raidframe/rf_paritylogDiskMgr.c rf_ReintegrateRegion(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
raidPtr 405 dev/raidframe/rf_paritylogDiskMgr.c parityBuffer = rf_AcquireReintBuffer(&raidPtr->parityBufferPool);
raidPtr 409 dev/raidframe/rf_paritylogDiskMgr.c rf_ReadRegionParity(regionID, prd_mcpair, parityBuffer, raidPtr,
raidPtr 413 dev/raidframe/rf_paritylogDiskMgr.c if (raidPtr->regionInfo[regionID].diskCount > 0) {
raidPtr 418 dev/raidframe/rf_paritylogDiskMgr.c rf_AcquireReintBuffer(&raidPtr->regionBufferPool);
raidPtr 422 dev/raidframe/rf_paritylogDiskMgr.c rf_ReadRegionLog(regionID, rrd_mcpair, regionBuffer, raidPtr,
raidPtr 438 dev/raidframe/rf_paritylogDiskMgr.c if (raidPtr->regionInfo[regionID].diskCount > 0) {
raidPtr 456 dev/raidframe/rf_paritylogDiskMgr.c rf_ReleaseReintBuffer(&raidPtr->regionBufferPool, regionBuffer);
raidPtr 465 dev/raidframe/rf_paritylogDiskMgr.c rf_WriteRegionParity(regionID, pwr_mcpair, parityBuffer, raidPtr,
raidPtr 483 dev/raidframe/rf_paritylogDiskMgr.c rf_ReleaseReintBuffer(&raidPtr->parityBufferPool, parityBuffer);
raidPtr 496 dev/raidframe/rf_paritylogDiskMgr.c rf_ReintegrateLogs(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
raidPtr 508 dev/raidframe/rf_paritylogDiskMgr.c rf_ReintegrateRegion(raidPtr, regionID, log);
raidPtr 515 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 516 dev/raidframe/rf_paritylogDiskMgr.c logData = rf_SearchAndDequeueParityLogData(raidPtr, regionID,
raidPtr 517 dev/raidframe/rf_paritylogDiskMgr.c &raidPtr->parityLogDiskQueue.reintBlockHead,
raidPtr 518 dev/raidframe/rf_paritylogDiskMgr.c &raidPtr->parityLogDiskQueue.reintBlockTail, RF_TRUE);
raidPtr 522 dev/raidframe/rf_paritylogDiskMgr.c rf_SearchAndDequeueParityLogData(raidPtr, regionID,
raidPtr 523 dev/raidframe/rf_paritylogDiskMgr.c &raidPtr->parityLogDiskQueue.reintBlockHead,
raidPtr 524 dev/raidframe/rf_paritylogDiskMgr.c &raidPtr->parityLogDiskQueue.reintBlockTail,
raidPtr 528 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 542 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 543 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
raidPtr 544 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 545 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->regionInfo[regionID].diskCount = 0;
raidPtr 546 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->regionInfo[regionID].reintInProgress =
raidPtr 548 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 549 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID]
raidPtr 551 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 563 dev/raidframe/rf_paritylogDiskMgr.c rf_ReleaseParityLogs(raidPtr, freeLogList);
raidPtr 567 dev/raidframe/rf_paritylogDiskMgr.c rf_ShutdownLogging(RF_Raid_t *raidPtr)
raidPtr 587 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 588 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->regionInfo[regionID].loggingEnabled = RF_FALSE;
raidPtr 589 dev/raidframe/rf_paritylogDiskMgr.c log = raidPtr->regionInfo[regionID].coreLog;
raidPtr 590 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->regionInfo[regionID].coreLog = NULL;
raidPtr 591 dev/raidframe/rf_paritylogDiskMgr.c diskCount = raidPtr->regionInfo[regionID].diskCount;
raidPtr 592 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 594 dev/raidframe/rf_paritylogDiskMgr.c rf_ReintegrateRegion(raidPtr, regionID, log);
raidPtr 596 dev/raidframe/rf_paritylogDiskMgr.c rf_ReleaseParityLogs(raidPtr, log);
raidPtr 607 dev/raidframe/rf_paritylogDiskMgr.c rf_ParityLoggingDiskManager(RF_Raid_t *raidPtr)
raidPtr 624 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 631 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_RUNNING;
raidPtr 632 dev/raidframe/rf_paritylogDiskMgr.c RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
raidPtr 635 dev/raidframe/rf_paritylogDiskMgr.c flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr 636 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr 637 dev/raidframe/rf_paritylogDiskMgr.c reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
raidPtr 638 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr 659 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 666 dev/raidframe/rf_paritylogDiskMgr.c rf_FlushLogsToDisk(raidPtr, flushQueue);
raidPtr 672 dev/raidframe/rf_paritylogDiskMgr.c rf_ReintegrateLogs(raidPtr, reintQueue);
raidPtr 674 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 675 dev/raidframe/rf_paritylogDiskMgr.c flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr 676 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr 677 dev/raidframe/rf_paritylogDiskMgr.c reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
raidPtr 678 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr 682 dev/raidframe/rf_paritylogDiskMgr.c if (raidPtr->parityLogDiskQueue.threadState & RF_PLOG_TERMINATE) {
raidPtr 689 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 690 dev/raidframe/rf_paritylogDiskMgr.c rf_ShutdownLogging(raidPtr);
raidPtr 697 dev/raidframe/rf_paritylogDiskMgr.c RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
raidPtr 698 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.mutex);
raidPtr 702 dev/raidframe/rf_paritylogDiskMgr.c flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
raidPtr 703 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr 704 dev/raidframe/rf_paritylogDiskMgr.c reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
raidPtr 705 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr 712 dev/raidframe/rf_paritylogDiskMgr.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 713 dev/raidframe/rf_paritylogDiskMgr.c raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_SHUTDOWN;
raidPtr 714 dev/raidframe/rf_paritylogDiskMgr.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 715 dev/raidframe/rf_paritylogDiskMgr.c RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
raidPtr 77 dev/raidframe/rf_paritylogging.c rf_ConfigureParityLogging(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 83 dev/raidframe/rf_paritylogging.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 98 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog = RF_DEFAULT_NUM_SECTORS_PER_LOG;
raidPtr 103 dev/raidframe/rf_paritylogging.c raidPtr->cleanupList);
raidPtr 108 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 114 dev/raidframe/rf_paritylogging.c info->stripeIdentifier = rf_make_2d_array((raidPtr->numCol),
raidPtr 115 dev/raidframe/rf_paritylogging.c (raidPtr->numCol),
raidPtr 116 dev/raidframe/rf_paritylogging.c raidPtr->cleanupList);
raidPtr 121 dev/raidframe/rf_paritylogging.c for (i = 0; i < (raidPtr->numCol); i++) {
raidPtr 122 dev/raidframe/rf_paritylogging.c for (j = 0; j < (raidPtr->numCol); j++) {
raidPtr 124 dev/raidframe/rf_paritylogging.c (raidPtr->numCol - 1);
raidPtr 127 dev/raidframe/rf_paritylogging.c startdisk = raidPtr->numCol - 1 - 1;
raidPtr 133 dev/raidframe/rf_paritylogging.c raidPtr->logBytesPerSector;
raidPtr 136 dev/raidframe/rf_paritylogging.c layoutPtr->numDataCol = raidPtr->numCol - layoutPtr->numParityCol -
raidPtr 141 dev/raidframe/rf_paritylogging.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 144 dev/raidframe/rf_paritylogging.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 172 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
raidPtr 174 dev/raidframe/rf_paritylogging.c printf("bytes per sector %d\n", raidPtr->bytesPerSector);
raidPtr 181 dev/raidframe/rf_paritylogging.c fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
raidPtr 183 dev/raidframe/rf_paritylogging.c for (i = 1; i < (raidPtr->numSectorsPerLog / 2); i++) {
raidPtr 185 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog) < fragmentation) {
raidPtr 187 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity = totalLogCapacity /
raidPtr 189 dev/raidframe/rf_paritylogging.c fragmentation = raidPtr->regionLogCapacity %
raidPtr 190 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog;
raidPtr 193 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog) < fragmentation) {
raidPtr 195 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity = totalLogCapacity /
raidPtr 197 dev/raidframe/rf_paritylogging.c fragmentation = raidPtr->regionLogCapacity %
raidPtr 198 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog;
raidPtr 202 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity /
raidPtr 203 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog) * raidPtr->numSectorsPerLog;
raidPtr 205 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs = rf_totalInCoreLogCapacity /
raidPtr 206 dev/raidframe/rf_paritylogging.c (raidPtr->bytesPerSector * raidPtr->numSectorsPerLog);
raidPtr 211 dev/raidframe/rf_paritylogging.c if (raidPtr->numParityLogs < rf_numParityRegions)
raidPtr 212 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs = rf_numParityRegions;
raidPtr 217 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->regionInfo,
raidPtr 220 dev/raidframe/rf_paritylogging.c if (raidPtr->regionInfo == NULL)
raidPtr 224 dev/raidframe/rf_paritylogging.c lastRegionCapacity = raidPtr->regionLogCapacity;
raidPtr 225 dev/raidframe/rf_paritylogging.c while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity +
raidPtr 228 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog;
raidPtr 230 dev/raidframe/rf_paritylogging.c raidPtr->regionParityRange = raidPtr->sectorsPerDisk /
raidPtr 232 dev/raidframe/rf_paritylogging.c maxRegionParityRange = raidPtr->regionParityRange;
raidPtr 240 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs * raidPtr->numSectorsPerLog *
raidPtr 241 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector,
raidPtr 242 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs);
raidPtr 243 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr 244 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog * raidPtr->bytesPerSector,
raidPtr 246 dev/raidframe/rf_paritylogging.c if (raidPtr->parityLogBufferHeap == NULL)
raidPtr 248 dev/raidframe/rf_paritylogging.c lHeapPtr = raidPtr->parityLogBufferHeap;
raidPtr 249 dev/raidframe/rf_paritylogging.c rc = rf_mutex_init(&raidPtr->parityLogPool.mutex);
raidPtr 253 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr 254 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
raidPtr 257 dev/raidframe/rf_paritylogging.c for (i = 0; i < raidPtr->numParityLogs; i++) {
raidPtr 259 dev/raidframe/rf_paritylogging.c RF_Calloc(raidPtr->parityLogPool.parityLogs, 1,
raidPtr 261 dev/raidframe/rf_paritylogging.c if (raidPtr->parityLogPool.parityLogs == NULL) {
raidPtr 262 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityLogBufferHeap,
raidPtr 263 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs *
raidPtr 264 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog *
raidPtr 265 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector);
raidPtr 268 dev/raidframe/rf_paritylogging.c l = raidPtr->parityLogPool.parityLogs;
raidPtr 273 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityLogBufferHeap,
raidPtr 274 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs *
raidPtr 275 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog *
raidPtr 276 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector);
raidPtr 277 dev/raidframe/rf_paritylogging.c for (l = raidPtr->parityLogPool.parityLogs;
raidPtr 283 dev/raidframe/rf_paritylogging.c (raidPtr->numSectorsPerLog *
raidPtr 292 dev/raidframe/rf_paritylogging.c lHeapPtr += raidPtr->numSectorsPerLog *
raidPtr 293 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector;
raidPtr 294 dev/raidframe/rf_paritylogging.c RF_Malloc(l->records, (raidPtr->numSectorsPerLog *
raidPtr 298 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityLogBufferHeap,
raidPtr 299 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs *
raidPtr 300 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog *
raidPtr 301 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector);
raidPtr 302 dev/raidframe/rf_paritylogging.c for (l = raidPtr->parityLogPool.parityLogs;
raidPtr 308 dev/raidframe/rf_paritylogging.c (raidPtr->numSectorsPerLog *
raidPtr 315 dev/raidframe/rf_paritylogging.c rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingPool, raidPtr);
raidPtr 319 dev/raidframe/rf_paritylogging.c rf_ShutdownParityLoggingPool(raidPtr);
raidPtr 323 dev/raidframe/rf_paritylogging.c rc = rf_mutex_init(&raidPtr->regionBufferPool.mutex);
raidPtr 329 dev/raidframe/rf_paritylogging.c rc = rf_cond_init(&raidPtr->regionBufferPool.cond);
raidPtr 333 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
raidPtr 336 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity *
raidPtr 337 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector;
raidPtr 339 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.bufferSize);
raidPtr 342 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.totalBuffers = 1;
raidPtr 344 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.availableBuffers =
raidPtr 345 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.totalBuffers;
raidPtr 346 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.availBuffersIndex = 0;
raidPtr 347 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.emptyBuffersIndex = 0;
raidPtr 349 dev/raidframe/rf_paritylogging.c (int) (raidPtr->regionBufferPool.totalBuffers *
raidPtr 351 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->regionBufferPool.buffers,
raidPtr 352 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t),
raidPtr 354 dev/raidframe/rf_paritylogging.c if (raidPtr->regionBufferPool.buffers == NULL) {
raidPtr 355 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
raidPtr 356 dev/raidframe/rf_paritylogging.c rf_cond_destroy(&raidPtr->regionBufferPool.cond);
raidPtr 359 dev/raidframe/rf_paritylogging.c for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
raidPtr 361 dev/raidframe/rf_paritylogging.c (int) (raidPtr->regionBufferPool.bufferSize *
raidPtr 363 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->regionBufferPool.buffers[i],
raidPtr 364 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.bufferSize * sizeof(char),
raidPtr 366 dev/raidframe/rf_paritylogging.c if (raidPtr->regionBufferPool.buffers[i] == NULL) {
raidPtr 367 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
raidPtr 368 dev/raidframe/rf_paritylogging.c rf_cond_destroy(&raidPtr->regionBufferPool.cond);
raidPtr 370 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionBufferPool.buffers[i],
raidPtr 371 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.bufferSize *
raidPtr 374 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionBufferPool.buffers,
raidPtr 375 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.totalBuffers *
raidPtr 380 dev/raidframe/rf_paritylogging.c (long) raidPtr->regionBufferPool.buffers[i]);
raidPtr 384 dev/raidframe/rf_paritylogging.c raidPtr);
raidPtr 388 dev/raidframe/rf_paritylogging.c rf_ShutdownParityLoggingRegionBufferPool(raidPtr);
raidPtr 393 dev/raidframe/rf_paritylogging.c rc = rf_mutex_init(&raidPtr->parityBufferPool.mutex);
raidPtr 399 dev/raidframe/rf_paritylogging.c rc = rf_cond_init(&raidPtr->parityBufferPool.cond);
raidPtr 403 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
raidPtr 406 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.bufferSize = parityBufferCapacity *
raidPtr 407 dev/raidframe/rf_paritylogging.c raidPtr->bytesPerSector;
raidPtr 409 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.bufferSize);
raidPtr 412 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.totalBuffers = 1;
raidPtr 414 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.availableBuffers =
raidPtr 415 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.totalBuffers;
raidPtr 416 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.availBuffersIndex = 0;
raidPtr 417 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.emptyBuffersIndex = 0;
raidPtr 419 dev/raidframe/rf_paritylogging.c (int) (raidPtr->parityBufferPool.totalBuffers *
raidPtr 421 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.totalBuffers);
raidPtr 422 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->parityBufferPool.buffers,
raidPtr 423 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t),
raidPtr 425 dev/raidframe/rf_paritylogging.c if (raidPtr->parityBufferPool.buffers == NULL) {
raidPtr 426 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
raidPtr 427 dev/raidframe/rf_paritylogging.c rf_cond_destroy(&raidPtr->parityBufferPool.cond);
raidPtr 430 dev/raidframe/rf_paritylogging.c for (i = 0; i < raidPtr->parityBufferPool.totalBuffers; i++) {
raidPtr 432 dev/raidframe/rf_paritylogging.c (int) (raidPtr->parityBufferPool.bufferSize *
raidPtr 434 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->parityBufferPool.buffers[i],
raidPtr 435 dev/raidframe/rf_paritylogging.c raidPtr->parityBufferPool.bufferSize * sizeof(char),
raidPtr 437 dev/raidframe/rf_paritylogging.c if (raidPtr->parityBufferPool.buffers == NULL) {
raidPtr 438 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
raidPtr 439 dev/raidframe/rf_paritylogging.c rf_cond_destroy(&raidPtr->parityBufferPool.cond);
raidPtr 441 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityBufferPool.buffers[i],
raidPtr 442 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.bufferSize *
raidPtr 445 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityBufferPool.buffers,
raidPtr 446 dev/raidframe/rf_paritylogging.c raidPtr->regionBufferPool.totalBuffers *
raidPtr 451 dev/raidframe/rf_paritylogging.c (long) raidPtr->parityBufferPool.buffers[i]);
raidPtr 455 dev/raidframe/rf_paritylogging.c raidPtr);
raidPtr 459 dev/raidframe/rf_paritylogging.c rf_ShutdownParityLoggingParityBufferPool(raidPtr);
raidPtr 464 dev/raidframe/rf_paritylogging.c &raidPtr->parityLogDiskQueue.mutex);
raidPtr 470 dev/raidframe/rf_paritylogging.c rc = rf_create_managed_cond(listp, &raidPtr->parityLogDiskQueue.cond);
raidPtr 476 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.flushQueue = NULL;
raidPtr 477 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.reintQueue = NULL;
raidPtr 478 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.bufHead = NULL;
raidPtr 479 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.bufTail = NULL;
raidPtr 480 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.reintHead = NULL;
raidPtr 481 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.reintTail = NULL;
raidPtr 482 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.logBlockHead = NULL;
raidPtr 483 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.logBlockTail = NULL;
raidPtr 484 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.reintBlockHead = NULL;
raidPtr 485 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.reintBlockTail = NULL;
raidPtr 486 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeDataList = NULL;
raidPtr 487 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeCommonList = NULL;
raidPtr 491 dev/raidframe/rf_paritylogging.c raidPtr);
raidPtr 498 dev/raidframe/rf_paritylogging.c rc = rf_mutex_init(&raidPtr->regionInfo[i].mutex);
raidPtr 503 dev/raidframe/rf_paritylogging.c rf_FreeRegionInfo(raidPtr, j);
raidPtr 504 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionInfo,
raidPtr 509 dev/raidframe/rf_paritylogging.c rc = rf_mutex_init(&raidPtr->regionInfo[i].reintMutex);
raidPtr 513 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
raidPtr 515 dev/raidframe/rf_paritylogging.c rf_FreeRegionInfo(raidPtr, j);
raidPtr 516 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionInfo,
raidPtr 521 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].reintInProgress = RF_FALSE;
raidPtr 522 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].regionStartAddr =
raidPtr 523 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity * i;
raidPtr 524 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].parityStartAddr =
raidPtr 525 dev/raidframe/rf_paritylogging.c raidPtr->regionParityRange * i;
raidPtr 527 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].capacity =
raidPtr 528 dev/raidframe/rf_paritylogging.c raidPtr->regionLogCapacity;
raidPtr 529 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].numSectorsParity =
raidPtr 530 dev/raidframe/rf_paritylogging.c raidPtr->regionParityRange;
raidPtr 532 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].capacity = lastRegionCapacity;
raidPtr 533 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].numSectorsParity =
raidPtr 534 dev/raidframe/rf_paritylogging.c raidPtr->sectorsPerDisk -
raidPtr 535 dev/raidframe/rf_paritylogging.c raidPtr->regionParityRange * i;
raidPtr 536 dev/raidframe/rf_paritylogging.c if (raidPtr->regionInfo[i].numSectorsParity >
raidPtr 539 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].numSectorsParity;
raidPtr 541 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].diskCount = 0;
raidPtr 542 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->regionInfo[i].capacity +
raidPtr 543 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].regionStartAddr <=
raidPtr 545 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr +
raidPtr 546 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].numSectorsParity <=
raidPtr 547 dev/raidframe/rf_paritylogging.c raidPtr->sectorsPerDisk);
raidPtr 549 dev/raidframe/rf_paritylogging.c (int) (raidPtr->regionInfo[i].capacity *
raidPtr 551 dev/raidframe/rf_paritylogging.c RF_Malloc(raidPtr->regionInfo[i].diskMap,
raidPtr 552 dev/raidframe/rf_paritylogging.c (raidPtr->regionInfo[i].capacity *
raidPtr 555 dev/raidframe/rf_paritylogging.c if (raidPtr->regionInfo[i].diskMap == NULL) {
raidPtr 556 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
raidPtr 557 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionInfo[i].reintMutex);
raidPtr 559 dev/raidframe/rf_paritylogging.c rf_FreeRegionInfo(raidPtr, j);
raidPtr 560 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionInfo,
raidPtr 565 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].loggingEnabled = RF_FALSE;
raidPtr 566 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[i].coreLog = NULL;
raidPtr 570 dev/raidframe/rf_paritylogging.c raidPtr);
raidPtr 574 dev/raidframe/rf_paritylogging.c rf_ShutdownParityLoggingRegionInfo(raidPtr);
raidPtr 577 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->parityLogDiskQueue.threadState == 0);
raidPtr 578 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.threadState = RF_PLOG_CREATED;
raidPtr 579 dev/raidframe/rf_paritylogging.c rc = RF_CREATE_THREAD(raidPtr->pLogDiskThreadHandle,
raidPtr 580 dev/raidframe/rf_paritylogging.c rf_ParityLoggingDiskManager, raidPtr, "rf_log");
raidPtr 582 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.threadState = 0;
raidPtr 589 dev/raidframe/rf_paritylogging.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 590 dev/raidframe/rf_paritylogging.c while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
raidPtr 591 dev/raidframe/rf_paritylogging.c RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
raidPtr 592 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.mutex);
raidPtr 594 dev/raidframe/rf_paritylogging.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 596 dev/raidframe/rf_paritylogging.c rc = rf_ShutdownCreate(listp, rf_ShutdownParityLogging, raidPtr);
raidPtr 600 dev/raidframe/rf_paritylogging.c rf_ShutdownParityLogging(raidPtr);
raidPtr 609 dev/raidframe/rf_paritylogging.c (int) raidPtr->regionLogCapacity);
raidPtr 613 dev/raidframe/rf_paritylogging.c raidPtr->numParityLogs);
raidPtr 615 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog);
raidPtr 619 dev/raidframe/rf_paritylogging.c rf_EnableParityLogging(raidPtr);
raidPtr 626 dev/raidframe/rf_paritylogging.c rf_FreeRegionInfo(RF_Raid_t *raidPtr, RF_RegionId_t regionID)
raidPtr 628 dev/raidframe/rf_paritylogging.c RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 629 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionInfo[regionID].diskMap,
raidPtr 630 dev/raidframe/rf_paritylogging.c (raidPtr->regionInfo[regionID].capacity *
raidPtr 632 dev/raidframe/rf_paritylogging.c if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
raidPtr 633 dev/raidframe/rf_paritylogging.c rf_ReleaseParityLogs(raidPtr,
raidPtr 634 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[regionID].coreLog);
raidPtr 635 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[regionID].coreLog = NULL;
raidPtr 637 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->regionInfo[regionID].coreLog == NULL);
raidPtr 638 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->regionInfo[regionID].diskCount == 0);
raidPtr 640 dev/raidframe/rf_paritylogging.c RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
raidPtr 641 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionInfo[regionID].mutex);
raidPtr 642 dev/raidframe/rf_paritylogging.c rf_mutex_destroy(&raidPtr->regionInfo[regionID].reintMutex);
raidPtr 647 dev/raidframe/rf_paritylogging.c rf_FreeParityLogQueue(RF_Raid_t *raidPtr, RF_ParityLogQueue_t *queue)
raidPtr 656 dev/raidframe/rf_paritylogging.c RF_Free(l2->records, (raidPtr->numSectorsPerLog *
raidPtr 686 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 689 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 692 dev/raidframe/rf_paritylogging.c raidPtr->raidid);
raidPtr 696 dev/raidframe/rf_paritylogging.c rf_FreeRegionInfo(raidPtr, i);
raidPtr 697 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->regionInfo, (rf_numParityRegions *
raidPtr 698 dev/raidframe/rf_paritylogging.c sizeof(raidPtr->regionInfo)));
raidPtr 699 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo = NULL;
raidPtr 706 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 708 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 710 dev/raidframe/rf_paritylogging.c printf("raid%d: ShutdownParityLoggingPool\n", raidPtr->raidid);
raidPtr 713 dev/raidframe/rf_paritylogging.c rf_FreeParityLogQueue(raidPtr, &raidPtr->parityLogPool);
raidPtr 714 dev/raidframe/rf_paritylogging.c RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
raidPtr 715 dev/raidframe/rf_paritylogging.c raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
raidPtr 722 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 724 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 727 dev/raidframe/rf_paritylogging.c raidPtr->raidid);
raidPtr 729 dev/raidframe/rf_paritylogging.c rf_FreeRegionBufferQueue(&raidPtr->regionBufferPool);
raidPtr 736 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 738 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 741 dev/raidframe/rf_paritylogging.c raidPtr->raidid);
raidPtr 743 dev/raidframe/rf_paritylogging.c rf_FreeRegionBufferQueue(&raidPtr->parityBufferPool);
raidPtr 752 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 754 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 757 dev/raidframe/rf_paritylogging.c raidPtr->raidid);
raidPtr 760 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->parityLogDiskQueue.bufHead == NULL);
raidPtr 761 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->parityLogDiskQueue.bufTail == NULL);
raidPtr 762 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->parityLogDiskQueue.reintHead == NULL);
raidPtr 763 dev/raidframe/rf_paritylogging.c RF_ASSERT(raidPtr->parityLogDiskQueue.reintTail == NULL);
raidPtr 764 dev/raidframe/rf_paritylogging.c while (raidPtr->parityLogDiskQueue.freeDataList) {
raidPtr 765 dev/raidframe/rf_paritylogging.c d = raidPtr->parityLogDiskQueue.freeDataList;
raidPtr 766 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeDataList =
raidPtr 767 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeDataList->next;
raidPtr 770 dev/raidframe/rf_paritylogging.c while (raidPtr->parityLogDiskQueue.freeCommonList) {
raidPtr 771 dev/raidframe/rf_paritylogging.c c = raidPtr->parityLogDiskQueue.freeCommonList;
raidPtr 773 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeCommonList =
raidPtr 774 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.freeCommonList->next;
raidPtr 783 dev/raidframe/rf_paritylogging.c RF_Raid_t *raidPtr;
raidPtr 785 dev/raidframe/rf_paritylogging.c raidPtr = (RF_Raid_t *) arg;
raidPtr 787 dev/raidframe/rf_paritylogging.c printf("raid%d: ShutdownParityLogging\n", raidPtr->raidid);
raidPtr 796 dev/raidframe/rf_paritylogging.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 797 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_TERMINATE;
raidPtr 798 dev/raidframe/rf_paritylogging.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 799 dev/raidframe/rf_paritylogging.c RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
raidPtr 804 dev/raidframe/rf_paritylogging.c RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 805 dev/raidframe/rf_paritylogging.c while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
raidPtr 806 dev/raidframe/rf_paritylogging.c RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
raidPtr 807 dev/raidframe/rf_paritylogging.c raidPtr->parityLogDiskQueue.mutex);
raidPtr 809 dev/raidframe/rf_paritylogging.c RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
raidPtr 812 dev/raidframe/rf_paritylogging.c " (thread completed)\n", raidPtr->raidid);
raidPtr 818 dev/raidframe/rf_paritylogging.c rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t *raidPtr)
raidPtr 825 dev/raidframe/rf_paritylogging.c rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t *raidPtr)
raidPtr 833 dev/raidframe/rf_paritylogging.c rf_MapRegionIDParityLogging(RF_Raid_t *raidPtr, RF_SectorNum_t address)
raidPtr 839 dev/raidframe/rf_paritylogging.c regionID = address / raidPtr->regionParityRange;
raidPtr 844 dev/raidframe/rf_paritylogging.c RF_ASSERT(address >= raidPtr->regionInfo[regionID].parityStartAddr);
raidPtr 845 dev/raidframe/rf_paritylogging.c RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr +
raidPtr 846 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[regionID].numSectorsParity);
raidPtr 854 dev/raidframe/rf_paritylogging.c rf_MapSectorParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 858 dev/raidframe/rf_paritylogging.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 862 dev/raidframe/rf_paritylogging.c *col = SUID % raidPtr->Layout.numDataCol;
raidPtr 863 dev/raidframe/rf_paritylogging.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 864 dev/raidframe/rf_paritylogging.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 865 dev/raidframe/rf_paritylogging.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 871 dev/raidframe/rf_paritylogging.c rf_MapParityParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 875 dev/raidframe/rf_paritylogging.c raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 881 dev/raidframe/rf_paritylogging.c *col = raidPtr->Layout.numDataCol;
raidPtr 882 dev/raidframe/rf_paritylogging.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 883 dev/raidframe/rf_paritylogging.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 884 dev/raidframe/rf_paritylogging.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 893 dev/raidframe/rf_paritylogging.c rf_MapLogParityLogging(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
raidPtr 898 dev/raidframe/rf_paritylogging.c *col = raidPtr->numCol - 1;
raidPtr 900 dev/raidframe/rf_paritylogging.c raidPtr->regionInfo[regionID].regionStartAddr + regionOffset;
raidPtr 909 dev/raidframe/rf_paritylogging.c rf_MapRegionParity(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
raidPtr 914 dev/raidframe/rf_paritylogging.c *col = raidPtr->numCol - 2;
raidPtr 915 dev/raidframe/rf_paritylogging.c *startSector = raidPtr->regionInfo[regionID].parityStartAddr;
raidPtr 916 dev/raidframe/rf_paritylogging.c *numSector = raidPtr->regionInfo[regionID].numSectorsParity;
raidPtr 925 dev/raidframe/rf_paritylogging.c rf_IdentifyStripeParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 928 dev/raidframe/rf_paritylogging.c RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
raidPtr 931 dev/raidframe/rf_paritylogging.c raidPtr->Layout.layoutSpecificInfo;
raidPtr 933 dev/raidframe/rf_paritylogging.c *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
raidPtr 952 dev/raidframe/rf_paritylogging.c rf_ParityLoggingDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 955 dev/raidframe/rf_paritylogging.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 979 dev/raidframe/rf_paritylogging.c rstat = raidPtr->status[failedPDA->row];
raidPtr 982 dev/raidframe/rf_paritylogging.c rf_CheckRUReconstructed(raidPtr->reconControl[frow]
raidPtr 996 dev/raidframe/rf_paritylogging.c (raidPtr,
raidPtr 1038 dev/raidframe/rf_paritylogging.c (raidPtr,
raidPtr 1050 dev/raidframe/rf_paritylogging.c raidPtr->Disks[frow][fcol].spareRow;
raidPtr 1052 dev/raidframe/rf_paritylogging.c raidPtr->Disks[frow][fcol].spareCol;
raidPtr 1091 dev/raidframe/rf_paritylogging.c " o %ld\n", raidPtr->raidid,
raidPtr 1126 dev/raidframe/rf_paritylogging.c rf_CheckStripeForFailures(raidPtr, asmp)) {
raidPtr 75 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingLargeWriteDAG(RF_Raid_t * raidPtr,
raidPtr 83 dev/raidframe/rf_parityloggingdags.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 90 dev/raidframe/rf_parityloggingdags.c rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 122 dev/raidframe/rf_parityloggingdags.c rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
raidPtr 196 dev/raidframe/rf_parityloggingdags.c xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
raidPtr 206 dev/raidframe/rf_parityloggingdags.c ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 210 dev/raidframe/rf_parityloggingdags.c rf_RaidAddressToByte(raidPtr,
raidPtr 211 dev/raidframe/rf_parityloggingdags.c raidPtr->Layout.sectorsPerStripeUnit), (void *),
raidPtr 349 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingSmallWriteDAG(RF_Raid_t *raidPtr,
raidPtr 367 dev/raidframe/rf_parityloggingdags.c rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
raidPtr 454 dev/raidframe/rf_parityloggingdags.c readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
raidPtr 474 dev/raidframe/rf_parityloggingdags.c readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
raidPtr 527 dev/raidframe/rf_parityloggingdags.c raidPtr->Layout.sectorsPerStripeUnit))) {
raidPtr 560 dev/raidframe/rf_parityloggingdags.c xorNodes[i].params[6].p = raidPtr;
raidPtr 586 dev/raidframe/rf_parityloggingdags.c raidPtr; /* Xor node needs to get at RAID information. */
raidPtr 733 dev/raidframe/rf_parityloggingdags.c rf_CreateParityLoggingSmallWriteDAG(RF_Raid_t *raidPtr,
raidPtr 739 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingSmallWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 745 dev/raidframe/rf_parityloggingdags.c rf_CreateParityLoggingLargeWriteDAG(RF_Raid_t *raidPtr,
raidPtr 751 dev/raidframe/rf_parityloggingdags.c rf_CommonCreateParityLoggingLargeWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 62 dev/raidframe/rf_parityscan.c rf_RewriteParity(RF_Raid_t *raidPtr)
raidPtr 64 dev/raidframe/rf_parityscan.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 71 dev/raidframe/rf_parityscan.c if (raidPtr->Layout.map->faultsTolerated == 0) {
raidPtr 75 dev/raidframe/rf_parityscan.c if (raidPtr->status[0] != rf_rs_optimal) {
raidPtr 87 dev/raidframe/rf_parityscan.c pda.numSector = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 90 dev/raidframe/rf_parityscan.c for (i = 0; i < raidPtr->totalSectors && rc <= RF_PARITY_CORRECTED;
raidPtr 92 dev/raidframe/rf_parityscan.c if (raidPtr->waitShutdown) {
raidPtr 99 dev/raidframe/rf_parityscan.c asm_h = rf_MapAccess(raidPtr, i,
raidPtr 101 dev/raidframe/rf_parityscan.c raidPtr->parity_rewrite_stripes_done =
raidPtr 103 dev/raidframe/rf_parityscan.c rc = rf_VerifyParity(raidPtr, asm_h->stripeMap, 1, 0);
raidPtr 141 dev/raidframe/rf_parityscan.c rf_VerifyParity(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *aasm, int correct_it,
raidPtr 149 dev/raidframe/rf_parityscan.c lp = raidPtr->Layout.map;
raidPtr 161 dev/raidframe/rf_parityscan.c lrc = lp->VerifyParity(raidPtr,
raidPtr 180 dev/raidframe/rf_parityscan.c rf_VerifyParityBasic(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
raidPtr 183 dev/raidframe/rf_parityscan.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 187 dev/raidframe/rf_parityscan.c int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
raidPtr 214 dev/raidframe/rf_parityscan.c rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
raidPtr 221 dev/raidframe/rf_parityscan.c asm_h = rf_MapAccess(raidPtr, startAddr,
raidPtr 228 dev/raidframe/rf_parityscan.c rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
raidPtr 230 dev/raidframe/rf_parityscan.c if (rf_TryToRedirectPDA(raidPtr, pda, 0))
raidPtr 242 dev/raidframe/rf_parityscan.c rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
raidPtr 244 dev/raidframe/rf_parityscan.c if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
raidPtr 292 dev/raidframe/rf_parityscan.c wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
raidPtr 332 dev/raidframe/rf_parityscan.c rf_TryToRedirectPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, int parity)
raidPtr 334 dev/raidframe/rf_parityscan.c if (raidPtr->Disks[pda->row][pda->col].status == rf_ds_reconstructing) {
raidPtr 335 dev/raidframe/rf_parityscan.c if (rf_CheckRUReconstructed(raidPtr->reconControl[pda->row]
raidPtr 337 dev/raidframe/rf_parityscan.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 341 dev/raidframe/rf_parityscan.c (raidPtr->Layout.map->MapParity)
raidPtr 342 dev/raidframe/rf_parityscan.c (raidPtr, pda->raidAddress,
raidPtr 353 dev/raidframe/rf_parityscan.c (raidPtr->Layout.map->MapSector)
raidPtr 354 dev/raidframe/rf_parityscan.c (raidPtr, pda->raidAddress,
raidPtr 367 dev/raidframe/rf_parityscan.c raidPtr->Disks[pda->row][pda->col].spareRow;
raidPtr 369 dev/raidframe/rf_parityscan.c raidPtr->Disks[pda->row][pda->col].spareCol;
raidPtr 375 dev/raidframe/rf_parityscan.c if (RF_DEAD_DISK(raidPtr->Disks[pda->row][pda->col].status))
raidPtr 401 dev/raidframe/rf_parityscan.c rf_VerifyDegrModeWrite(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asmh)
raidPtr 418 dev/raidframe/rf_parityscan.c rf_MakeSimpleDAG(RF_Raid_t *raidPtr, int nNodes, int bytesPerSU, char *databuf,
raidPtr 438 dev/raidframe/rf_parityscan.c dag_h->raidPtr = (void *) raidPtr;
raidPtr 111 dev/raidframe/rf_pq.c rf_PQDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 114 dev/raidframe/rf_pq.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 155 dev/raidframe/rf_pq.c if (rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 181 dev/raidframe/rf_pq.c rf_CheckStripeForFailures(raidPtr, asmap))) {
raidPtr 201 dev/raidframe/rf_pq.c rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 212 dev/raidframe/rf_pq.c rf_NumFailedDataUnitsInStripe(raidPtr,
raidPtr 225 dev/raidframe/rf_pq.c if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
raidPtr 272 dev/raidframe/rf_pq.c rf_PQOne(RF_Raid_t *raidPtr, int *nSucc, int *nAnte,
raidPtr 279 dev/raidframe/rf_pq.c rf_PQOneTwo(RF_Raid_t *raidPtr, int *nSucc, int *nAnte,
raidPtr 289 dev/raidframe/rf_pq.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 298 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
raidPtr 306 dev/raidframe/rf_pq.c unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 324 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 330 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 331 dev/raidframe/rf_pq.c qpbuf = qbuf + rf_RaidAddressToByte(raidPtr,
raidPtr 333 dev/raidframe/rf_pq.c rf_QDelta(qpbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr,
raidPtr 371 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
raidPtr 396 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 402 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 403 dev/raidframe/rf_pq.c rf_QDelta(qbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr,
raidPtr 419 dev/raidframe/rf_pq.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 431 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
raidPtr 432 dev/raidframe/rf_pq.c unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 447 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 453 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 459 dev/raidframe/rf_pq.c qpbuf = qbuf + rf_RaidAddressToByte(raidPtr,
raidPtr 462 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
raidPtr 482 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
raidPtr 483 dev/raidframe/rf_pq.c unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 503 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 509 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 517 dev/raidframe/rf_pq.c qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, j - fail_start);
raidPtr 519 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
raidPtr 632 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 633 dev/raidframe/rf_pq.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
raidPtr 649 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
raidPtr 656 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
raidPtr 657 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 660 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 662 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
raidPtr 665 dev/raidframe/rf_pq.c coeff = (rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 666 dev/raidframe/rf_pq.c failedPDA->startSector) % raidPtr->Layout.numDataCol);
raidPtr 668 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
raidPtr 679 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
raidPtr 680 dev/raidframe/rf_pq.c printf("raid%d: Recovery from PQ not implemented.\n", raidPtr->raidid);
raidPtr 703 dev/raidframe/rf_pq.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
raidPtr 704 dev/raidframe/rf_pq.c unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 724 dev/raidframe/rf_pq.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 730 dev/raidframe/rf_pq.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 733 dev/raidframe/rf_pq.c qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, j - fail_start);
raidPtr 735 dev/raidframe/rf_pq.c rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
raidPtr 72 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 85 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 101 dev/raidframe/rf_pqdeg.c rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 113 dev/raidframe/rf_pqdeg.c rf_PQ_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
raidPtr 119 dev/raidframe/rf_pqdeg.c rf_CreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 131 dev/raidframe/rf_pqdeg.c raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 133 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
raidPtr 146 dev/raidframe/rf_pqdeg.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 153 dev/raidframe/rf_pqdeg.c rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 165 dev/raidframe/rf_pqdeg.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 172 dev/raidframe/rf_pqdeg.c rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 182 dev/raidframe/rf_pqdeg.c rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 200 dev/raidframe/rf_pqdeg.c raidPtr->Layout.sectorsPerStripeUnit) {
raidPtr 207 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 218 dev/raidframe/rf_pqdeg.c raidPtr->Layout.sectorsPerStripeUnit)
raidPtr 220 dev/raidframe/rf_pqdeg.c rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
raidPtr 126 dev/raidframe/rf_pqdegdags.c rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 131 dev/raidframe/rf_pqdegdags.c rf_applyPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda,
raidPtr 134 dev/raidframe/rf_pqdegdags.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 149 dev/raidframe/rf_pqdegdags.c coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 151 dev/raidframe/rf_pqdegdags.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 155 dev/raidframe/rf_pqdegdags.c buf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 162 dev/raidframe/rf_pqdegdags.c pbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 164 dev/raidframe/rf_pqdegdags.c qbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
raidPtr 171 dev/raidframe/rf_pqdegdags.c rf_bxor(buf, pbuf, rf_RaidAddressToByte(raidPtr, len), bp);
raidPtr 175 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, len), coeff);
raidPtr 205 dev/raidframe/rf_pqdegdags.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
raidPtr 206 dev/raidframe/rf_pqdegdags.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
raidPtr 244 dev/raidframe/rf_pqdegdags.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 246 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
raidPtr 248 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
raidPtr 268 dev/raidframe/rf_pqdegdags.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 271 dev/raidframe/rf_pqdegdags.c (raidPtr->Layout.map->MapSector) (raidPtr,
raidPtr 275 dev/raidframe/rf_pqdegdags.c if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col]
raidPtr 291 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, pda->numSector),
raidPtr 298 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, pda->numSector),
raidPtr 343 dev/raidframe/rf_pqdegdags.c RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
raidPtr 344 dev/raidframe/rf_pqdegdags.c RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
raidPtr 361 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, node->params[i].p, ppda, qpda,
raidPtr 371 dev/raidframe/rf_pqdegdags.c coeff = (coeff % raidPtr->Layout.numDataCol);
raidPtr 374 dev/raidframe/rf_pqdegdags.c (raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress,
raidPtr 377 dev/raidframe/rf_pqdegdags.c if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
raidPtr 391 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, pda->numSector), coeff, i);
raidPtr 397 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, pda->numSector), i, coeff);
raidPtr 400 dev/raidframe/rf_pqdegdags.c bzero(qpda->bufPtr, rf_RaidAddressToByte(raidPtr, qpda->numSector));
raidPtr 402 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, qpda->numSector), i);
raidPtr 413 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, qpda->numSector), coeff);
raidPtr 415 dev/raidframe/rf_pqdegdags.c rf_RaidAddressToByte(raidPtr, ppda->numSector), node->dagHdr->bp);
raidPtr 419 dev/raidframe/rf_pqdegdags.c rf_applyPDA(raidPtr, node->params[i].p, ppda, qpda,
raidPtr 466 dev/raidframe/rf_pqdegdags.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 477 dev/raidframe/rf_pqdegdags.c rf_PQ_DDLargeWrite(raidPtr, asmap, dag_h, bp, flags, allocList);
raidPtr 482 dev/raidframe/rf_pqdegdags.c rf_PQ_DDSimpleSmallWrite(raidPtr, asmap, dag_h, bp, flags,
raidPtr 491 dev/raidframe/rf_pqdegdags.c rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
raidPtr 85 dev/raidframe/rf_psstatus.c rf_init_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
raidPtr 87 dev/raidframe/rf_psstatus.c RF_Calloc(p->issued, raidPtr->numCol, sizeof(char), (char *));
raidPtr 94 dev/raidframe/rf_psstatus.c rf_clean_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
raidPtr 96 dev/raidframe/rf_psstatus.c RF_Free(p->issued, raidPtr->numCol * sizeof(char));
raidPtr 102 dev/raidframe/rf_psstatus.c RF_Raid_t *raidPtr = (RF_Raid_t *) arg;
raidPtr 104 dev/raidframe/rf_psstatus.c RF_FREELIST_DESTROY_CLEAN_ARG(raidPtr->pss_freelist, next,
raidPtr 105 dev/raidframe/rf_psstatus.c (RF_ReconParityStripeStatus_t *), rf_clean_pss, raidPtr);
raidPtr 109 dev/raidframe/rf_psstatus.c rf_ConfigurePSStatus(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 114 dev/raidframe/rf_psstatus.c raidPtr->pssTableSize = RF_PSS_DEFAULT_TABLESIZE;
raidPtr 115 dev/raidframe/rf_psstatus.c RF_FREELIST_CREATE(raidPtr->pss_freelist, RF_MAX_FREE_PSS, RF_PSS_INC,
raidPtr 117 dev/raidframe/rf_psstatus.c if (raidPtr->pss_freelist == NULL)
raidPtr 119 dev/raidframe/rf_psstatus.c rc = rf_ShutdownCreate(listp, rf_ShutdownPSStatus, raidPtr);
raidPtr 123 dev/raidframe/rf_psstatus.c rf_ShutdownPSStatus(raidPtr);
raidPtr 126 dev/raidframe/rf_psstatus.c RF_FREELIST_PRIME_INIT_ARG(raidPtr->pss_freelist, RF_PSS_INITIAL, next,
raidPtr 127 dev/raidframe/rf_psstatus.c (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
raidPtr 138 dev/raidframe/rf_psstatus.c rf_MakeParityStripeStatusTable(RF_Raid_t *raidPtr)
raidPtr 143 dev/raidframe/rf_psstatus.c RF_Calloc(pssTable, raidPtr->pssTableSize, sizeof(RF_PSStatusHeader_t),
raidPtr 145 dev/raidframe/rf_psstatus.c for (i = 0; i < raidPtr->pssTableSize; i++) {
raidPtr 154 dev/raidframe/rf_psstatus.c RF_Free(pssTable, raidPtr->pssTableSize *
raidPtr 163 dev/raidframe/rf_psstatus.c rf_FreeParityStripeStatusTable(RF_Raid_t *raidPtr,
raidPtr 169 dev/raidframe/rf_psstatus.c rf_RealPrintPSStatusTable(raidPtr, pssTable);
raidPtr 170 dev/raidframe/rf_psstatus.c for (i = 0; i < raidPtr->pssTableSize; i++) {
raidPtr 177 dev/raidframe/rf_psstatus.c RF_Free(pssTable, raidPtr->pssTableSize * sizeof(RF_PSStatusHeader_t));
raidPtr 193 dev/raidframe/rf_psstatus.c rf_LookupRUStatus(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
raidPtr 197 dev/raidframe/rf_psstatus.c RF_PSStatusHeader_t *hdr = &pssTable[RF_HASH_PSID(raidPtr, psID)];
raidPtr 209 dev/raidframe/rf_psstatus.c p = rf_AllocPSStatus(raidPtr);
raidPtr 239 dev/raidframe/rf_psstatus.c raidPtr->raidid, psID, p->blockCount);
raidPtr 252 dev/raidframe/rf_psstatus.c rf_PSStatusDelete(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
raidPtr 256 dev/raidframe/rf_psstatus.c &(pssTable[RF_HASH_PSID(raidPtr, pssPtr->parityStripeID)]);
raidPtr 266 dev/raidframe/rf_psstatus.c rf_FreePSStatus(raidPtr, p);
raidPtr 281 dev/raidframe/rf_psstatus.c rf_RemoveFromActiveReconTable(RF_Raid_t *raidPtr, RF_RowCol_t row,
raidPtr 285 dev/raidframe/rf_psstatus.c &(raidPtr->reconControl[row]
raidPtr 286 dev/raidframe/rf_psstatus.c ->pssTable[RF_HASH_PSID(raidPtr, psid)]);
raidPtr 296 dev/raidframe/rf_psstatus.c rf_PrintPSStatusTable(raidPtr, row);
raidPtr 329 dev/raidframe/rf_psstatus.c rf_FreePSStatus(raidPtr, p);
raidPtr 333 dev/raidframe/rf_psstatus.c rf_AllocPSStatus(RF_Raid_t *raidPtr)
raidPtr 337 dev/raidframe/rf_psstatus.c RF_FREELIST_GET_INIT_ARG(raidPtr->pss_freelist, p, next,
raidPtr 338 dev/raidframe/rf_psstatus.c (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
raidPtr 340 dev/raidframe/rf_psstatus.c bzero(p->issued, raidPtr->numCol);
raidPtr 351 dev/raidframe/rf_psstatus.c rf_FreePSStatus(RF_Raid_t *raidPtr, RF_ReconParityStripeStatus_t *p)
raidPtr 357 dev/raidframe/rf_psstatus.c RF_FREELIST_FREE_CLEAN_ARG(raidPtr->pss_freelist, p, next,
raidPtr 358 dev/raidframe/rf_psstatus.c rf_clean_pss, raidPtr);
raidPtr 362 dev/raidframe/rf_psstatus.c rf_RealPrintPSStatusTable(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable)
raidPtr 369 dev/raidframe/rf_psstatus.c for (i = 0; i < raidPtr->pssTableSize; i++) {
raidPtr 383 dev/raidframe/rf_psstatus.c for (j = 0; j < raidPtr->numCol; j++)
raidPtr 405 dev/raidframe/rf_psstatus.c rf_PrintPSStatusTable(RF_Raid_t *raidPtr, RF_RowCol_t row)
raidPtr 407 dev/raidframe/rf_psstatus.c RF_PSStatusHeader_t *pssTable = raidPtr->reconControl[row]->pssTable;
raidPtr 408 dev/raidframe/rf_psstatus.c rf_RealPrintPSStatusTable(raidPtr, pssTable);
raidPtr 54 dev/raidframe/rf_raid0.c rf_ConfigureRAID0(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 57 dev/raidframe/rf_raid0.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 63 dev/raidframe/rf_raid0.c (RF_Raid0ConfigInfo_t *), raidPtr->cleanupList);
raidPtr 68 dev/raidframe/rf_raid0.c RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol *
raidPtr 69 dev/raidframe/rf_raid0.c sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
raidPtr 72 dev/raidframe/rf_raid0.c for (i = 0; i < raidPtr->numCol; i++)
raidPtr 75 dev/raidframe/rf_raid0.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 76 dev/raidframe/rf_raid0.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 77 dev/raidframe/rf_raid0.c raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
raidPtr 79 dev/raidframe/rf_raid0.c layoutPtr->dataSectorsPerStripe = raidPtr->numCol *
raidPtr 82 dev/raidframe/rf_raid0.c raidPtr->logBytesPerSector;
raidPtr 83 dev/raidframe/rf_raid0.c layoutPtr->numDataCol = raidPtr->numCol;
raidPtr 89 dev/raidframe/rf_raid0.c rf_MapSectorRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 93 dev/raidframe/rf_raid0.c raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 95 dev/raidframe/rf_raid0.c *col = SUID % raidPtr->numCol;
raidPtr 96 dev/raidframe/rf_raid0.c *diskSector = (SUID / raidPtr->numCol) *
raidPtr 97 dev/raidframe/rf_raid0.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 98 dev/raidframe/rf_raid0.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 102 dev/raidframe/rf_raid0.c rf_MapParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 110 dev/raidframe/rf_raid0.c rf_IdentifyStripeRAID0( RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 115 dev/raidframe/rf_raid0.c info = raidPtr->Layout.layoutSpecificInfo;
raidPtr 129 dev/raidframe/rf_raid0.c rf_RAID0DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 138 dev/raidframe/rf_raid0.c rf_VerifyParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
raidPtr 62 dev/raidframe/rf_raid1.c rf_ConfigureRAID1(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 65 dev/raidframe/rf_raid1.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 71 dev/raidframe/rf_raid1.c (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
raidPtr 77 dev/raidframe/rf_raid1.c info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2,
raidPtr 78 dev/raidframe/rf_raid1.c raidPtr->cleanupList);
raidPtr 81 dev/raidframe/rf_raid1.c for (i = 0; i < (raidPtr->numCol / 2); i++) {
raidPtr 86 dev/raidframe/rf_raid1.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 94 dev/raidframe/rf_raid1.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 95 dev/raidframe/rf_raid1.c (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
raidPtr 97 dev/raidframe/rf_raid1.c (raidPtr->numCol / 2);
raidPtr 100 dev/raidframe/rf_raid1.c raidPtr->logBytesPerSector;
raidPtr 111 dev/raidframe/rf_raid1.c rf_MapSectorRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 114 dev/raidframe/rf_raid1.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 115 dev/raidframe/rf_raid1.c RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
raidPtr 119 dev/raidframe/rf_raid1.c *diskSector = ((SUID / (raidPtr->numCol / 2)) *
raidPtr 120 dev/raidframe/rf_raid1.c raidPtr->Layout.sectorsPerStripeUnit) +
raidPtr 121 dev/raidframe/rf_raid1.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 132 dev/raidframe/rf_raid1.c rf_MapParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 135 dev/raidframe/rf_raid1.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 136 dev/raidframe/rf_raid1.c RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
raidPtr 141 dev/raidframe/rf_raid1.c *diskSector = ((SUID / (raidPtr->numCol / 2)) *
raidPtr 142 dev/raidframe/rf_raid1.c raidPtr->Layout.sectorsPerStripeUnit) +
raidPtr 143 dev/raidframe/rf_raid1.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 153 dev/raidframe/rf_raid1.c rf_IdentifyStripeRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 156 dev/raidframe/rf_raid1.c RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
raidPtr 158 dev/raidframe/rf_raid1.c RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
raidPtr 162 dev/raidframe/rf_raid1.c *diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)];
raidPtr 192 dev/raidframe/rf_raid1.c rf_RAID1DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 222 dev/raidframe/rf_raid1.c rstat = raidPtr->status[frow];
raidPtr 225 dev/raidframe/rf_raid1.c rf_CheckRUReconstructed(raidPtr->reconControl[frow]
raidPtr 236 dev/raidframe/rf_raid1.c failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
raidPtr 237 dev/raidframe/rf_raid1.c failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
raidPtr 260 dev/raidframe/rf_raid1.c raidPtr->raidid, type, or, oc, (long) oo,
raidPtr 280 dev/raidframe/rf_raid1.c rf_VerifyParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
raidPtr 299 dev/raidframe/rf_raid1.c layoutPtr = &raidPtr->Layout;
raidPtr 302 dev/raidframe/rf_raid1.c nbytes = rf_RaidAddressToByte(raidPtr, nsector);
raidPtr 325 dev/raidframe/rf_raid1.c " (%lx - %lx).\n", raidPtr->raidid, (long) buf, bcount,
raidPtr 333 dev/raidframe/rf_raid1.c rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, buf,
raidPtr 346 dev/raidframe/rf_raid1.c asm_h = rf_MapAccess(raidPtr, startAddr,
raidPtr 358 dev/raidframe/rf_raid1.c rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
raidPtr 361 dev/raidframe/rf_raid1.c if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
raidPtr 382 dev/raidframe/rf_raid1.c rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
raidPtr 384 dev/raidframe/rf_raid1.c if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
raidPtr 403 dev/raidframe/rf_raid1.c raidPtr->raidid);
raidPtr 443 dev/raidframe/rf_raid1.c " buf1=%lx buf2=%lx buf=%lx.\n", raidPtr->raidid,
raidPtr 465 dev/raidframe/rf_raid1.c " i=%d.\n", raidPtr->raidid, i);
raidPtr 483 dev/raidframe/rf_raid1.c " parity not correct.\n", raidPtr->raidid);
raidPtr 494 dev/raidframe/rf_raid1.c wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, buf,
raidPtr 552 dev/raidframe/rf_raid1.c raidPtr->raidid, ret);
raidPtr 576 dev/raidframe/rf_raid1.c RF_Raid_t *raidPtr;
raidPtr 582 dev/raidframe/rf_raid1.c raidPtr = rbuf->raidPtr;
raidPtr 583 dev/raidframe/rf_raid1.c layoutPtr = &raidPtr->Layout;
raidPtr 584 dev/raidframe/rf_raid1.c reconCtrlPtr = raidPtr->reconControl[rbuf->row];
raidPtr 591 dev/raidframe/rf_raid1.c " ru%d (failed offset %ld).\n", raidPtr->raidid, rbuf->row,
raidPtr 603 dev/raidframe/rf_raid1.c RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
raidPtr 607 dev/raidframe/rf_raid1.c pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
raidPtr 623 dev/raidframe/rf_raid1.c raidPtr->raidid);
raidPtr 631 dev/raidframe/rf_raid1.c raidPtr->raidid);
raidPtr 642 dev/raidframe/rf_raid1.c raidPtr->raidid);
raidPtr 652 dev/raidframe/rf_raid1.c " waiting for rbuf.\n", raidPtr->raidid);
raidPtr 655 dev/raidframe/rf_raid1.c raidPtr->procsInBufWait++;
raidPtr 656 dev/raidframe/rf_raid1.c if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1))
raidPtr 657 dev/raidframe/rf_raid1.c && (raidPtr->numFullReconBuffers == 0)) {
raidPtr 660 dev/raidframe/rf_raid1.c rf_PrintPSStatusTable(raidPtr, rbuf->row);
raidPtr 707 dev/raidframe/rf_raid1.c rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1);
raidPtr 710 dev/raidframe/rf_raid1.c RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
raidPtr 714 dev/raidframe/rf_raid1.c raidPtr->raidid, retcode);
raidPtr 57 dev/raidframe/rf_raid4.c rf_ConfigureRAID4(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 60 dev/raidframe/rf_raid4.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 66 dev/raidframe/rf_raid4.c (RF_Raid4ConfigInfo_t *), raidPtr->cleanupList);
raidPtr 72 dev/raidframe/rf_raid4.c RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol *
raidPtr 73 dev/raidframe/rf_raid4.c sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
raidPtr 76 dev/raidframe/rf_raid4.c for (i = 0; i < raidPtr->numCol; i++)
raidPtr 79 dev/raidframe/rf_raid4.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 84 dev/raidframe/rf_raid4.c raidPtr->logBytesPerSector;
raidPtr 85 dev/raidframe/rf_raid4.c layoutPtr->numDataCol = raidPtr->numCol - 1;
raidPtr 89 dev/raidframe/rf_raid4.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 96 dev/raidframe/rf_raid4.c rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t *raidPtr)
raidPtr 102 dev/raidframe/rf_raid4.c rf_GetDefaultHeadSepLimitRAID4(RF_Raid_t *raidPtr)
raidPtr 108 dev/raidframe/rf_raid4.c rf_MapSectorRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 111 dev/raidframe/rf_raid4.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 113 dev/raidframe/rf_raid4.c *col = SUID % raidPtr->Layout.numDataCol;
raidPtr 114 dev/raidframe/rf_raid4.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 115 dev/raidframe/rf_raid4.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 116 dev/raidframe/rf_raid4.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 120 dev/raidframe/rf_raid4.c rf_MapParityRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 123 dev/raidframe/rf_raid4.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 126 dev/raidframe/rf_raid4.c *col = raidPtr->Layout.numDataCol;
raidPtr 127 dev/raidframe/rf_raid4.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 128 dev/raidframe/rf_raid4.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 129 dev/raidframe/rf_raid4.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 133 dev/raidframe/rf_raid4.c rf_IdentifyStripeRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 136 dev/raidframe/rf_raid4.c RF_Raid4ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
raidPtr 59 dev/raidframe/rf_raid5.c rf_ConfigureRAID5(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 62 dev/raidframe/rf_raid5.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 68 dev/raidframe/rf_raid5.c (RF_Raid5ConfigInfo_t *), raidPtr->cleanupList);
raidPtr 73 dev/raidframe/rf_raid5.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 79 dev/raidframe/rf_raid5.c info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol,
raidPtr 80 dev/raidframe/rf_raid5.c raidPtr->numCol, raidPtr->cleanupList);
raidPtr 84 dev/raidframe/rf_raid5.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 85 dev/raidframe/rf_raid5.c for (j = 0; j < raidPtr->numCol; j++) {
raidPtr 87 dev/raidframe/rf_raid5.c raidPtr->numCol;
raidPtr 90 dev/raidframe/rf_raid5.c startdisk = raidPtr->numCol - 1;
raidPtr 96 dev/raidframe/rf_raid5.c raidPtr->logBytesPerSector;
raidPtr 97 dev/raidframe/rf_raid5.c layoutPtr->numDataCol = raidPtr->numCol - 1;
raidPtr 103 dev/raidframe/rf_raid5.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 110 dev/raidframe/rf_raid5.c rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t *raidPtr)
raidPtr 116 dev/raidframe/rf_raid5.c rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t *raidPtr)
raidPtr 124 dev/raidframe/rf_raid5.c rf_ShutdownRAID5(RF_Raid_t *raidPtr)
raidPtr 131 dev/raidframe/rf_raid5.c rf_MapSectorRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 134 dev/raidframe/rf_raid5.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 136 dev/raidframe/rf_raid5.c *col = (SUID % raidPtr->numCol);
raidPtr 137 dev/raidframe/rf_raid5.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 138 dev/raidframe/rf_raid5.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 139 dev/raidframe/rf_raid5.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 143 dev/raidframe/rf_raid5.c rf_MapParityRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 146 dev/raidframe/rf_raid5.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 149 dev/raidframe/rf_raid5.c *col = raidPtr->Layout.numDataCol -
raidPtr 150 dev/raidframe/rf_raid5.c (SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
raidPtr 151 dev/raidframe/rf_raid5.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 152 dev/raidframe/rf_raid5.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 153 dev/raidframe/rf_raid5.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 157 dev/raidframe/rf_raid5.c rf_IdentifyStripeRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 161 dev/raidframe/rf_raid5.c rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
raidPtr 163 dev/raidframe/rf_raid5.c (RF_Raid5ConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 166 dev/raidframe/rf_raid5.c *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
raidPtr 184 dev/raidframe/rf_raid5.c rf_RaidFiveDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
raidPtr 187 dev/raidframe/rf_raid5.c RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
raidPtr 211 dev/raidframe/rf_raid5.c rstat = raidPtr->status[failedPDA->row];
raidPtr 214 dev/raidframe/rf_raid5.c rf_CheckRUReconstructed(raidPtr
raidPtr 230 dev/raidframe/rf_raid5.c (raidPtr,
raidPtr 272 dev/raidframe/rf_raid5.c ->MapSector) (raidPtr,
raidPtr 284 dev/raidframe/rf_raid5.c raidPtr->Disks[frow][fcol].spareRow;
raidPtr 286 dev/raidframe/rf_raid5.c raidPtr->Disks[frow][fcol].spareCol;
raidPtr 327 dev/raidframe/rf_raid5.c " o %ld\n", raidPtr->raidid,
raidPtr 366 dev/raidframe/rf_raid5.c rf_CheckStripeForFailures(raidPtr, asmap))) {
raidPtr 54 dev/raidframe/rf_raid5_rotatedspare.c rf_ConfigureRAID5_RS(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 57 dev/raidframe/rf_raid5_rotatedspare.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 63 dev/raidframe/rf_raid5_rotatedspare.c (RF_Raid5RSConfigInfo_t *), raidPtr->cleanupList);
raidPtr 68 dev/raidframe/rf_raid5_rotatedspare.c RF_ASSERT(raidPtr->numRow == 1);
raidPtr 69 dev/raidframe/rf_raid5_rotatedspare.c RF_ASSERT(raidPtr->numCol >= 3);
raidPtr 75 dev/raidframe/rf_raid5_rotatedspare.c info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol,
raidPtr 76 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->numCol, raidPtr->cleanupList);
raidPtr 80 dev/raidframe/rf_raid5_rotatedspare.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 81 dev/raidframe/rf_raid5_rotatedspare.c for (j = 0; j < raidPtr->numCol; j++) {
raidPtr 83 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->numCol;
raidPtr 86 dev/raidframe/rf_raid5_rotatedspare.c startdisk = raidPtr->numCol - 1;
raidPtr 92 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->logBytesPerSector;
raidPtr 93 dev/raidframe/rf_raid5_rotatedspare.c layoutPtr->numDataCol = raidPtr->numCol - 2;
raidPtr 98 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
raidPtr 101 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
raidPtr 108 dev/raidframe/rf_raid5_rotatedspare.c rf_GetNumSpareRUsRAID5_RS(RF_Raid_t *raidPtr)
raidPtr 110 dev/raidframe/rf_raid5_rotatedspare.c return (raidPtr->Layout.stripeUnitsPerDisk / raidPtr->numCol);
raidPtr 114 dev/raidframe/rf_raid5_rotatedspare.c rf_MapSectorRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 117 dev/raidframe/rf_raid5_rotatedspare.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 121 dev/raidframe/rf_raid5_rotatedspare.c *col = raidPtr->numCol - 1 -
raidPtr 122 dev/raidframe/rf_raid5_rotatedspare.c (1 + SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
raidPtr 123 dev/raidframe/rf_raid5_rotatedspare.c *col = (*col + 1) % raidPtr->numCol; /*
raidPtr 129 dev/raidframe/rf_raid5_rotatedspare.c *col = (SUID + (SUID / raidPtr->Layout.numDataCol)) %
raidPtr 130 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->numCol;
raidPtr 132 dev/raidframe/rf_raid5_rotatedspare.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 133 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 134 dev/raidframe/rf_raid5_rotatedspare.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 138 dev/raidframe/rf_raid5_rotatedspare.c rf_MapParityRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
raidPtr 141 dev/raidframe/rf_raid5_rotatedspare.c RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
raidPtr 144 dev/raidframe/rf_raid5_rotatedspare.c *col = raidPtr->numCol - 1 - (1 + SUID / raidPtr->Layout.numDataCol) %
raidPtr 145 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->numCol;
raidPtr 146 dev/raidframe/rf_raid5_rotatedspare.c *diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
raidPtr 147 dev/raidframe/rf_raid5_rotatedspare.c raidPtr->Layout.sectorsPerStripeUnit +
raidPtr 148 dev/raidframe/rf_raid5_rotatedspare.c (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 150 dev/raidframe/rf_raid5_rotatedspare.c *col = (*col + 1) % raidPtr->numCol;
raidPtr 154 dev/raidframe/rf_raid5_rotatedspare.c rf_IdentifyStripeRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
raidPtr 158 dev/raidframe/rf_raid5_rotatedspare.c rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
raidPtr 160 dev/raidframe/rf_raid5_rotatedspare.c (RF_Raid5RSConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
raidPtr 162 dev/raidframe/rf_raid5_rotatedspare.c *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
raidPtr 53 dev/raidframe/rf_raidframe.h void *raidPtr; /*
raidPtr 112 dev/raidframe/rf_reconbuffer.c lp = rbuf->raidPtr->Layout.map;
raidPtr 130 dev/raidframe/rf_reconbuffer.c RF_Raid_t *raidPtr = rbuf->raidPtr;
raidPtr 131 dev/raidframe/rf_reconbuffer.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 132 dev/raidframe/rf_reconbuffer.c RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[rbuf->row];
raidPtr 152 dev/raidframe/rf_reconbuffer.c RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
raidPtr 156 dev/raidframe/rf_reconbuffer.c pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
raidPtr 183 dev/raidframe/rf_reconbuffer.c rf_MultiWayReconXor(raidPtr, pssPtr);
raidPtr 186 dev/raidframe/rf_reconbuffer.c raidPtr->accumXorTimeUs += RF_ETIMER_VAL_US(timer);
raidPtr 188 dev/raidframe/rf_reconbuffer.c raidPtr->recon_tracerecs[rbuf->col].xor_us =
raidPtr 190 dev/raidframe/rf_reconbuffer.c RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col]
raidPtr 192 dev/raidframe/rf_reconbuffer.c RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col]
raidPtr 194 dev/raidframe/rf_reconbuffer.c raidPtr->recon_tracerecs[rbuf->col]
raidPtr 196 dev/raidframe/rf_reconbuffer.c RF_ETIMER_VAL_US(raidPtr
raidPtr 198 dev/raidframe/rf_reconbuffer.c RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col]
raidPtr 201 dev/raidframe/rf_reconbuffer.c rf_LogTraceRec(raidPtr,
raidPtr 202 dev/raidframe/rf_reconbuffer.c &raidPtr->recon_tracerecs[rbuf->col]);
raidPtr 204 dev/raidframe/rf_reconbuffer.c rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
raidPtr 215 dev/raidframe/rf_reconbuffer.c rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
raidPtr 218 dev/raidframe/rf_reconbuffer.c RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row,
raidPtr 254 dev/raidframe/rf_reconbuffer.c raidPtr->procsInBufWait++;
raidPtr 255 dev/raidframe/rf_reconbuffer.c if ((raidPtr->procsInBufWait == raidPtr->numCol - 1) &&
raidPtr 256 dev/raidframe/rf_reconbuffer.c (raidPtr->numFullReconBuffers == 0)) {
raidPtr 258 dev/raidframe/rf_reconbuffer.c rf_PrintPSStatusTable(raidPtr, rbuf->row);
raidPtr 284 dev/raidframe/rf_reconbuffer.c RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
raidPtr 285 dev/raidframe/rf_reconbuffer.c RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
raidPtr 286 dev/raidframe/rf_reconbuffer.c raidPtr->recon_tracerecs[rbuf->col]
raidPtr 288 dev/raidframe/rf_reconbuffer.c RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
raidPtr 289 dev/raidframe/rf_reconbuffer.c RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
raidPtr 291 dev/raidframe/rf_reconbuffer.c rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
raidPtr 321 dev/raidframe/rf_reconbuffer.c rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
raidPtr 325 dev/raidframe/rf_reconbuffer.c RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
raidPtr 332 dev/raidframe/rf_reconbuffer.c RF_Raid_t *raidPtr,
raidPtr 340 dev/raidframe/rf_reconbuffer.c int numBytes = rf_RaidAddressToByte(raidPtr,
raidPtr 341 dev/raidframe/rf_reconbuffer.c raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
raidPtr 367 dev/raidframe/rf_reconbuffer.c rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row,
raidPtr 416 dev/raidframe/rf_reconbuffer.c rf_CheckForFullRbuf(RF_Raid_t *raidPtr, RF_ReconCtrl_t *reconCtrl,
raidPtr 422 dev/raidframe/rf_reconbuffer.c raidPtr->numFullReconBuffers++;
raidPtr 454 dev/raidframe/rf_reconbuffer.c rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL,
raidPtr 466 dev/raidframe/rf_reconbuffer.c rf_ReleaseFloatingReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row,
raidPtr 469 dev/raidframe/rf_reconbuffer.c RF_ReconCtrl_t *rcPtr = raidPtr->reconControl[row];
raidPtr 485 dev/raidframe/rf_reconbuffer.c rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1,
raidPtr 488 dev/raidframe/rf_reconbuffer.c raidPtr->procsInBufWait--;
raidPtr 502 dev/raidframe/rf_reconbuffer.c RF_Raid_t *raidPtr,
raidPtr 515 dev/raidframe/rf_reconbuffer.c rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0,
raidPtr 549 dev/raidframe/rf_reconbuffer.c rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr,
raidPtr 75 dev/raidframe/rf_reconmap.c RF_Raid_t *raidPtr,
raidPtr 87 dev/raidframe/rf_reconmap.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 140 dev/raidframe/rf_reconmap.c rf_ReconMapUpdate(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr,
raidPtr 177 dev/raidframe/rf_reconmap.c rf_compact_stat_entry(raidPtr, mapPtr, i);
raidPtr 202 dev/raidframe/rf_reconmap.c rf_compact_stat_entry(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr, int i)
raidPtr 359 dev/raidframe/rf_reconmap.c rf_PrintReconMap(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr, RF_RowCol_t frow,
raidPtr 210 dev/raidframe/rf_reconstruct.c rf_SignalReconDone(RF_Raid_t *raidPtr)
raidPtr 214 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex);
raidPtr 215 dev/raidframe/rf_reconstruct.c for (p = raidPtr->recon_done_procs; p; p = p->next) {
raidPtr 216 dev/raidframe/rf_reconstruct.c p->proc(raidPtr, p->arg);
raidPtr 218 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex);
raidPtr 222 dev/raidframe/rf_reconstruct.c rf_RegisterReconDoneProc(RF_Raid_t *raidPtr, void (*proc) (RF_Raid_t *, void *),
raidPtr 232 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex);
raidPtr 233 dev/raidframe/rf_reconstruct.c p->next = raidPtr->recon_done_procs;
raidPtr 234 dev/raidframe/rf_reconstruct.c raidPtr->recon_done_procs = p;
raidPtr 235 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex);
raidPtr 284 dev/raidframe/rf_reconstruct.c rf_AllocRaidReconDesc(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
raidPtr 294 dev/raidframe/rf_reconstruct.c reconDesc->raidPtr = raidPtr;
raidPtr 333 dev/raidframe/rf_reconstruct.c rf_ReconstructFailedDisk(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
raidPtr 338 dev/raidframe/rf_reconstruct.c lp = raidPtr->Layout.map;
raidPtr 344 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 345 dev/raidframe/rf_reconstruct.c while (raidPtr->reconInProgress) {
raidPtr 346 dev/raidframe/rf_reconstruct.c RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
raidPtr 348 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress++;
raidPtr 349 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 350 dev/raidframe/rf_reconstruct.c rc = rf_ReconstructFailedDiskBasic(raidPtr, row, col);
raidPtr 351 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 352 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 353 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 359 dev/raidframe/rf_reconstruct.c RF_SIGNAL_COND(raidPtr->waitForReconCond);
raidPtr 360 dev/raidframe/rf_reconstruct.c wakeup(&raidPtr->waitForReconCond); /*
raidPtr 368 dev/raidframe/rf_reconstruct.c rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t row,
raidPtr 383 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 384 dev/raidframe/rf_reconstruct.c RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed);
raidPtr 386 dev/raidframe/rf_reconstruct.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 387 dev/raidframe/rf_reconstruct.c if (raidPtr->status[row] != rf_rs_degraded) {
raidPtr 390 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 397 dev/raidframe/rf_reconstruct.c for (scol = raidPtr->numCol;
raidPtr 398 dev/raidframe/rf_reconstruct.c scol < raidPtr->numCol + raidPtr->numSpare; scol++) {
raidPtr 399 dev/raidframe/rf_reconstruct.c if (raidPtr->Disks[srow][scol].status == rf_ds_spare) {
raidPtr 400 dev/raidframe/rf_reconstruct.c spareDiskPtr = &raidPtr->Disks[srow][scol];
raidPtr 409 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 415 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 417 dev/raidframe/rf_reconstruct.c reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col,
raidPtr 419 dev/raidframe/rf_reconstruct.c raidPtr->reconDesc = (void *) reconDesc;
raidPtr 434 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[srow][scol].ci_dev,
raidPtr 435 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[srow][scol].ci_vp,
raidPtr 438 dev/raidframe/rf_reconstruct.c raid_init_component_label(raidPtr, &c_label);
raidPtr 447 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[srow][scol].ci_dev,
raidPtr 448 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[srow][scol].ci_vp,
raidPtr 466 dev/raidframe/rf_reconstruct.c rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
raidPtr 481 dev/raidframe/rf_reconstruct.c lp = raidPtr->Layout.map;
raidPtr 487 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 488 dev/raidframe/rf_reconstruct.c if ((raidPtr->Disks[row][col].status == rf_ds_optimal) &&
raidPtr 489 dev/raidframe/rf_reconstruct.c (raidPtr->numFailures > 0)) {
raidPtr 501 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 504 dev/raidframe/rf_reconstruct.c if (raidPtr->Disks[row][col].status == rf_ds_reconstructing) {
raidPtr 511 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 516 dev/raidframe/rf_reconstruct.c if (raidPtr->Disks[row][col].status != rf_ds_failed) {
raidPtr 518 dev/raidframe/rf_reconstruct.c raidPtr->numFailures++;
raidPtr 519 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].status = rf_ds_failed;
raidPtr 520 dev/raidframe/rf_reconstruct.c raidPtr->status[row] = rf_rs_degraded;
raidPtr 521 dev/raidframe/rf_reconstruct.c rf_update_component_labels(raidPtr,
raidPtr 525 dev/raidframe/rf_reconstruct.c while (raidPtr->reconInProgress) {
raidPtr 526 dev/raidframe/rf_reconstruct.c RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
raidPtr 529 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress++;
raidPtr 546 dev/raidframe/rf_reconstruct.c if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
raidPtr 551 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 552 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 561 dev/raidframe/rf_reconstruct.c badDisk = &raidPtr->Disks[row][col];
raidPtr 563 dev/raidframe/rf_reconstruct.c proc = raidPtr->recon_thread;
raidPtr 570 dev/raidframe/rf_reconstruct.c if (raidPtr->raid_cinfo[row][col].ci_vp != NULL) {
raidPtr 572 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].devname);
raidPtr 573 dev/raidframe/rf_reconstruct.c vp = raidPtr->raid_cinfo[row][col].ci_vp;
raidPtr 574 dev/raidframe/rf_reconstruct.c ac = raidPtr->Disks[row][col].auto_configured;
raidPtr 575 dev/raidframe/rf_reconstruct.c rf_close_component(raidPtr, vp, ac);
raidPtr 576 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_vp = NULL;
raidPtr 581 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].auto_configured = 0;
raidPtr 584 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].devname);
raidPtr 586 dev/raidframe/rf_reconstruct.c retcode = raidlookup(raidPtr->Disks[row][col].devname,
raidPtr 591 dev/raidframe/rf_reconstruct.c " failed: %d !\n", raidPtr->raidid,
raidPtr 592 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].devname, retcode);
raidPtr 598 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 599 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 611 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 612 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 618 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 619 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 622 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].blockSize =
raidPtr 625 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].numBlocks =
raidPtr 628 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_vp = vp;
raidPtr 629 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev;
raidPtr 631 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].dev = va.va_rdev;
raidPtr 638 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].numBlocks =
raidPtr 639 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].numBlocks *
raidPtr 643 dev/raidframe/rf_reconstruct.c spareDiskPtr = &raidPtr->Disks[row][col];
raidPtr 650 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 652 dev/raidframe/rf_reconstruct.c reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col,
raidPtr 654 dev/raidframe/rf_reconstruct.c raidPtr->reconDesc = (void *) reconDesc;
raidPtr 665 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 666 dev/raidframe/rf_reconstruct.c raidPtr->reconInProgress--;
raidPtr 667 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 674 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 682 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].status = rf_ds_optimal;
raidPtr 683 dev/raidframe/rf_reconstruct.c raidPtr->status[row] = rf_rs_optimal;
raidPtr 688 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_dev,
raidPtr 689 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_vp,
raidPtr 692 dev/raidframe/rf_reconstruct.c raid_init_component_label(raidPtr, &c_label);
raidPtr 697 dev/raidframe/rf_reconstruct.c raidwrite_component_label(raidPtr->raid_cinfo[row][col].ci_dev,
raidPtr 698 dev/raidframe/rf_reconstruct.c raidPtr->raid_cinfo[row][col].ci_vp, &c_label);
raidPtr 701 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 702 dev/raidframe/rf_reconstruct.c RF_SIGNAL_COND(raidPtr->waitForReconCond);
raidPtr 703 dev/raidframe/rf_reconstruct.c wakeup(&raidPtr->waitForReconCond);
raidPtr 711 dev/raidframe/rf_reconstruct.c RF_Raid_t *raidPtr = reconDesc->raidPtr;
raidPtr 725 dev/raidframe/rf_reconstruct.c raidPtr->accumXorTimeUs = 0;
raidPtr 728 dev/raidframe/rf_reconstruct.c RF_Malloc(raidPtr->recon_tracerecs, raidPtr->numCol *
raidPtr 739 dev/raidframe/rf_reconstruct.c retcode = rf_SuspendNewRequestsAndWait(raidPtr);
raidPtr 741 dev/raidframe/rf_reconstruct.c rf_StartUserStats(raidPtr); /*
raidPtr 747 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 753 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row] =
raidPtr 755 dev/raidframe/rf_reconstruct.c mapPtr = raidPtr->reconControl[row]->reconMap;
raidPtr 756 dev/raidframe/rf_reconstruct.c raidPtr->status[row] = rf_rs_reconstructing;
raidPtr 757 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].status = rf_ds_reconstructing;
raidPtr 758 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].spareRow = srow;
raidPtr 759 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].spareCol = scol;
raidPtr 761 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 763 dev/raidframe/rf_reconstruct.c RF_GETTIME(raidPtr->reconControl[row]->starttime);
raidPtr 771 dev/raidframe/rf_reconstruct.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 777 dev/raidframe/rf_reconstruct.c if (rf_IssueNextReadRequest(raidPtr, row, i)) {
raidPtr 789 dev/raidframe/rf_reconstruct.c rf_ResumeNewRequests(raidPtr);
raidPtr 799 dev/raidframe/rf_reconstruct.c mapPtr = raidPtr->reconControl[row]->reconMap;
raidPtr 801 dev/raidframe/rf_reconstruct.c while (reconDesc->numDisksDone < raidPtr->numCol - 1) {
raidPtr 808 dev/raidframe/rf_reconstruct.c if (rf_ProcessReconEvent(raidPtr, row, event))
raidPtr 810 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->numRUsTotal =
raidPtr 812 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->numRUsComplete =
raidPtr 816 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->percentComplete =
raidPtr 817 dev/raidframe/rf_reconstruct.c (raidPtr->reconControl[row]->numRUsComplete * 100 /
raidPtr 818 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->numRUsTotal);
raidPtr 821 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->reconMap,
raidPtr 822 dev/raidframe/rf_reconstruct.c &(raidPtr->reconControl[row]->starttime));
raidPtr 829 dev/raidframe/rf_reconstruct.c mapPtr = raidPtr->reconControl[row]->reconMap;
raidPtr 839 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->reconMap) > 0) {
raidPtr 847 dev/raidframe/rf_reconstruct.c (void) rf_ProcessReconEvent(raidPtr, row, event);
raidPtr 848 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->percentComplete =
raidPtr 853 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->reconMap,
raidPtr 854 dev/raidframe/rf_reconstruct.c &(raidPtr->reconControl[row]->starttime));
raidPtr 869 dev/raidframe/rf_reconstruct.c retcode = rf_SuspendNewRequestsAndWait(raidPtr);
raidPtr 870 dev/raidframe/rf_reconstruct.c rf_StopUserStats(raidPtr);
raidPtr 871 dev/raidframe/rf_reconstruct.c rf_PrintUserStats(raidPtr); /*
raidPtr 879 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->mutex);
raidPtr 880 dev/raidframe/rf_reconstruct.c raidPtr->numFailures--;
raidPtr 881 dev/raidframe/rf_reconstruct.c ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE);
raidPtr 882 dev/raidframe/rf_reconstruct.c raidPtr->Disks[row][col].status = (ds) ? rf_ds_dist_spared :
raidPtr 884 dev/raidframe/rf_reconstruct.c raidPtr->status[row] = (ds) ? rf_rs_reconfigured :
raidPtr 886 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->mutex);
raidPtr 888 dev/raidframe/rf_reconstruct.c RF_TIMEVAL_DIFF(&(raidPtr->reconControl[row]->starttime),
raidPtr 900 dev/raidframe/rf_reconstruct.c rf_ResumeNewRequests(raidPtr);
raidPtr 904 dev/raidframe/rf_reconstruct.c xor_s = raidPtr->accumXorTimeUs / 1000000;
raidPtr 905 dev/raidframe/rf_reconstruct.c xor_resid_us = raidPtr->accumXorTimeUs % 1000000;
raidPtr 908 dev/raidframe/rf_reconstruct.c (int) elpsd.tv_usec, raidPtr->accumXorTimeUs, xor_s,
raidPtr 912 dev/raidframe/rf_reconstruct.c (int) raidPtr->reconControl[row]->starttime.tv_sec,
raidPtr 913 dev/raidframe/rf_reconstruct.c (int) raidPtr->reconControl[row]->starttime.tv_usec,
raidPtr 920 dev/raidframe/rf_reconstruct.c rf_FreeReconControl(raidPtr, row);
raidPtr 921 dev/raidframe/rf_reconstruct.c RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol *
raidPtr 927 dev/raidframe/rf_reconstruct.c rf_SignalReconDone(raidPtr);
raidPtr 938 dev/raidframe/rf_reconstruct.c rf_ProcessReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t frow,
raidPtr 951 dev/raidframe/rf_reconstruct.c rbuf = raidPtr->reconControl[frow]
raidPtr 964 dev/raidframe/rf_reconstruct.c retcode = rf_IssueNextReadRequest(raidPtr, frow,
raidPtr 971 dev/raidframe/rf_reconstruct.c rf_CheckFloatingRbufCount(raidPtr, 1);
raidPtr 973 dev/raidframe/rf_reconstruct.c sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit *
raidPtr 974 dev/raidframe/rf_reconstruct.c raidPtr->Layout.SUsPerRU;
raidPtr 980 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[frow]->percentComplete);
raidPtr 981 dev/raidframe/rf_reconstruct.c rf_ReconMapUpdate(raidPtr, raidPtr->reconControl[frow]
raidPtr 984 dev/raidframe/rf_reconstruct.c rf_RemoveFromActiveReconTable(raidPtr, frow,
raidPtr 988 dev/raidframe/rf_reconstruct.c RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
raidPtr 989 dev/raidframe/rf_reconstruct.c raidPtr->numFullReconBuffers--;
raidPtr 990 dev/raidframe/rf_reconstruct.c rf_ReleaseFloatingReconBuffer(raidPtr, frow, rbuf);
raidPtr 991 dev/raidframe/rf_reconstruct.c RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
raidPtr 1003 dev/raidframe/rf_reconstruct.c submitblocked = rf_SubmitReconBuffer(raidPtr
raidPtr 1011 dev/raidframe/rf_reconstruct.c retcode = rf_IssueNextReadRequest(raidPtr, frow, event->col);
raidPtr 1018 dev/raidframe/rf_reconstruct.c retcode = rf_TryToRead(raidPtr, frow, event->col);
raidPtr 1028 dev/raidframe/rf_reconstruct.c retcode = rf_TryToRead(raidPtr, frow, event->col);
raidPtr 1035 dev/raidframe/rf_reconstruct.c retcode = rf_IssueNextWriteRequest(raidPtr, frow);
raidPtr 1037 dev/raidframe/rf_reconstruct.c rf_CheckFloatingRbufCount(raidPtr, 1);
raidPtr 1048 dev/raidframe/rf_reconstruct.c retcode = rf_IssueNextReadRequest(raidPtr, frow, event->col);
raidPtr 1093 dev/raidframe/rf_reconstruct.c rf_IssueNextReadRequest(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
raidPtr 1096 dev/raidframe/rf_reconstruct.c &raidPtr->reconControl[row]->perDiskInfo[col];
raidPtr 1097 dev/raidframe/rf_reconstruct.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 1110 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->minHeadSepCounter)
raidPtr 1125 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->lastPSID) {
raidPtr 1126 dev/raidframe/rf_reconstruct.c rf_CheckForNewMinHeadSep(raidPtr, row,
raidPtr 1136 dev/raidframe/rf_reconstruct.c status = rf_ComputePSDiskOffsets(raidPtr,
raidPtr 1148 dev/raidframe/rf_reconstruct.c if (rf_CheckRUReconstructed(raidPtr->reconControl[row]
raidPtr 1158 dev/raidframe/rf_reconstruct.c rf_CheckForNewMinHeadSep(raidPtr, row, ctrl->headSepCounter);
raidPtr 1167 dev/raidframe/rf_reconstruct.c bzero((char *) &raidPtr->recon_tracerecs[col],
raidPtr 1168 dev/raidframe/rf_reconstruct.c sizeof(raidPtr->recon_tracerecs[col]));
raidPtr 1169 dev/raidframe/rf_reconstruct.c raidPtr->recon_tracerecs[col].reconacc = 1;
raidPtr 1170 dev/raidframe/rf_reconstruct.c RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
raidPtr 1171 dev/raidframe/rf_reconstruct.c retcode = rf_TryToRead(raidPtr, row, col);
raidPtr 1185 dev/raidframe/rf_reconstruct.c rf_TryToRead(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
raidPtr 1188 dev/raidframe/rf_reconstruct.c &raidPtr->reconControl[row]->perDiskInfo[col];
raidPtr 1190 dev/raidframe/rf_reconstruct.c raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
raidPtr 1201 dev/raidframe/rf_reconstruct.c if (rf_CheckHeadSeparation(raidPtr, ctrl, row, col,
raidPtr 1204 dev/raidframe/rf_reconstruct.c RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1205 dev/raidframe/rf_reconstruct.c pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]
raidPtr 1213 dev/raidframe/rf_reconstruct.c status = rf_CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl,
raidPtr 1221 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent(raidPtr, row, col, NULL,
raidPtr 1234 dev/raidframe/rf_reconstruct.c if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap,
raidPtr 1239 dev/raidframe/rf_reconstruct.c rf_PSStatusDelete(raidPtr,
raidPtr 1240 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->pssTable, pssPtr);
raidPtr 1241 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent(raidPtr, row, col, NULL, RF_REVENT_SKIP);
raidPtr 1248 dev/raidframe/rf_reconstruct.c RF_ETIMER_STOP(raidPtr->recon_tracerecs[col].recon_timer);
raidPtr 1249 dev/raidframe/rf_reconstruct.c RF_ETIMER_EVAL(raidPtr->recon_tracerecs[col].recon_timer);
raidPtr 1250 dev/raidframe/rf_reconstruct.c raidPtr->recon_tracerecs[col].specific.recon.recon_start_to_fetch_us =
raidPtr 1251 dev/raidframe/rf_reconstruct.c RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[col].recon_timer);
raidPtr 1252 dev/raidframe/rf_reconstruct.c RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
raidPtr 1261 dev/raidframe/rf_reconstruct.c &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL);
raidPtr 1266 dev/raidframe/rf_reconstruct.c rf_DiskIOEnqueue(&raidPtr->Queues[row][col], req, RF_IO_RECON_PRIORITY);
raidPtr 1270 dev/raidframe/rf_reconstruct.c RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1302 dev/raidframe/rf_reconstruct.c RF_Raid_t *raidPtr, /* RAID descriptor. */
raidPtr 1322 dev/raidframe/rf_reconstruct.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 1323 dev/raidframe/rf_reconstruct.c RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol;
raidPtr 1337 dev/raidframe/rf_reconstruct.c (layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids,
raidPtr 1361 dev/raidframe/rf_reconstruct.c (layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &prow, &pcol,
raidPtr 1403 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset *
raidPtr 1407 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset *
raidPtr 1414 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset *
raidPtr 1418 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset *
raidPtr 1426 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapParity(raidPtr, sosRaidAddress +
raidPtr 1430 dev/raidframe/rf_reconstruct.c layoutPtr->map->MapSector(raidPtr, sosRaidAddress +
raidPtr 1434 dev/raidframe/rf_reconstruct.c *spRow = raidPtr->reconControl[row]->spareRow;
raidPtr 1435 dev/raidframe/rf_reconstruct.c *spCol = raidPtr->reconControl[row]->spareCol;
raidPtr 1453 dev/raidframe/rf_reconstruct.c rf_IssueNextWriteRequest(RF_Raid_t *raidPtr, RF_RowCol_t row)
raidPtr 1455 dev/raidframe/rf_reconstruct.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 1458 dev/raidframe/rf_reconstruct.c RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol;
raidPtr 1462 dev/raidframe/rf_reconstruct.c rbuf = rf_GetFullReconBuffer(raidPtr->reconControl[row]);
raidPtr 1488 dev/raidframe/rf_reconstruct.c &raidPtr->recon_tracerecs[fcol], (void *) raidPtr, 0, NULL);
raidPtr 1493 dev/raidframe/rf_reconstruct.c rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spRow][rbuf->spCol], req,
raidPtr 1511 dev/raidframe/rf_reconstruct.c RF_Raid_t *raidPtr = ctrl->reconCtrl->reconDesc->raidPtr;
raidPtr 1520 dev/raidframe/rf_reconstruct.c RF_ETIMER_STOP(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
raidPtr 1521 dev/raidframe/rf_reconstruct.c RF_ETIMER_EVAL(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
raidPtr 1522 dev/raidframe/rf_reconstruct.c raidPtr->recon_tracerecs[ctrl->col].specific.recon.
raidPtr 1524 dev/raidframe/rf_reconstruct.c RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
raidPtr 1525 dev/raidframe/rf_reconstruct.c RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
raidPtr 1527 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent(raidPtr, ctrl->row, ctrl->col, NULL,
raidPtr 1551 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col,
raidPtr 1562 dev/raidframe/rf_reconstruct.c rf_CheckForNewMinHeadSep(RF_Raid_t *raidPtr, RF_RowCol_t row,
raidPtr 1565 dev/raidframe/rf_reconstruct.c RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
raidPtr 1576 dev/raidframe/rf_reconstruct.c for (i = 0; i < raidPtr->numCol; i++)
raidPtr 1595 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent(raidPtr, p->row, p->col, NULL,
raidPtr 1618 dev/raidframe/rf_reconstruct.c RF_Raid_t *raidPtr,
raidPtr 1626 dev/raidframe/rf_reconstruct.c RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
raidPtr 1639 dev/raidframe/rf_reconstruct.c if ((raidPtr->headSepLimit >= 0) &&
raidPtr 1641 dev/raidframe/rf_reconstruct.c raidPtr->headSepLimit)) {
raidPtr 1644 dev/raidframe/rf_reconstruct.c raidPtr->raidid, row, col, ctrl->headSepCounter,
raidPtr 1645 dev/raidframe/rf_reconstruct.c reconCtrlPtr->minHeadSepCounter, raidPtr->headSepLimit);
raidPtr 1652 dev/raidframe/rf_reconstruct.c raidPtr->headSepLimit + raidPtr->headSepLimit / 5);
raidPtr 1696 dev/raidframe/rf_reconstruct.c RF_Raid_t *raidPtr,
raidPtr 1745 dev/raidframe/rf_reconstruct.c rf_ForceOrBlockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
raidPtr 1756 dev/raidframe/rf_reconstruct.c RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit *
raidPtr 1757 dev/raidframe/rf_reconstruct.c raidPtr->Layout.SUsPerRU; /* Num sects in one RU. */
raidPtr 1776 dev/raidframe/rf_reconstruct.c psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID,
raidPtr 1779 dev/raidframe/rf_reconstruct.c RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1781 dev/raidframe/rf_reconstruct.c pssPtr = rf_LookupRUStatus(raidPtr,
raidPtr 1782 dev/raidframe/rf_reconstruct.c raidPtr->reconControl[row]->pssTable, psid, which_ru,
raidPtr 1787 dev/raidframe/rf_reconstruct.c RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1806 dev/raidframe/rf_reconstruct.c fcol = raidPtr->reconControl[row]->fcol;
raidPtr 1811 dev/raidframe/rf_reconstruct.c (raidPtr->Layout.map->IdentifyStripe) (raidPtr,
raidPtr 1823 dev/raidframe/rf_reconstruct.c for (i = 0; i < raidPtr->Layout.numDataCol +
raidPtr 1824 dev/raidframe/rf_reconstruct.c raidPtr->Layout.numParityCol; i++)
raidPtr 1827 dev/raidframe/rf_reconstruct.c nPromoted = rf_DiskIOPromote(&raidPtr
raidPtr 1833 dev/raidframe/rf_reconstruct.c raidPtr->raidid, row,
raidPtr 1837 dev/raidframe/rf_reconstruct.c new_rbuf = rf_MakeReconBuffer(raidPtr,
raidPtr 1840 dev/raidframe/rf_reconstruct.c rf_ComputePSDiskOffsets(raidPtr, psid,
raidPtr 1864 dev/raidframe/rf_reconstruct.c NULL, (void *) raidPtr, 0, NULL);
raidPtr 1873 dev/raidframe/rf_reconstruct.c rf_DiskIOEnqueue(&raidPtr
raidPtr 1878 dev/raidframe/rf_reconstruct.c raidPtr->raidid, row, diskno);
raidPtr 1885 dev/raidframe/rf_reconstruct.c if (rf_DiskIOPromote(&raidPtr->Queues[row][fcol],
raidPtr 1888 dev/raidframe/rf_reconstruct.c raidPtr->raidid, row, fcol);
raidPtr 1904 dev/raidframe/rf_reconstruct.c raidPtr->raidid, psid);
raidPtr 1906 dev/raidframe/rf_reconstruct.c RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1926 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col,
raidPtr 1933 dev/raidframe/rf_reconstruct.c rf_UnblockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
raidPtr 1943 dev/raidframe/rf_reconstruct.c psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID,
raidPtr 1945 dev/raidframe/rf_reconstruct.c RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 1946 dev/raidframe/rf_reconstruct.c pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]
raidPtr 1967 dev/raidframe/rf_reconstruct.c raidPtr->raidid, psid, pssPtr->blockCount);
raidPtr 1987 dev/raidframe/rf_reconstruct.c rf_CauseReconEvent(raidPtr, cb->row, cb->col, NULL,
raidPtr 1993 dev/raidframe/rf_reconstruct.c rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]
raidPtr 1998 dev/raidframe/rf_reconstruct.c RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
raidPtr 59 dev/raidframe/rf_reconstruct.h RF_Raid_t *raidPtr; /*
raidPtr 59 dev/raidframe/rf_reconutil.c RF_Raid_t *raidPtr = reconDesc->raidPtr;
raidPtr 60 dev/raidframe/rf_reconutil.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 70 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
raidPtr 78 dev/raidframe/rf_reconutil.c RF_Calloc(reconCtrlPtr->perDiskInfo, raidPtr->numCol,
raidPtr 88 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 103 dev/raidframe/rf_reconutil.c numSpareRUs = lp->GetNumSpareRUs(raidPtr);
raidPtr 112 dev/raidframe/rf_reconutil.c retcode = rf_InstallSpareTable(raidPtr, frow, fcol);
raidPtr 118 dev/raidframe/rf_reconutil.c reconCtrlPtr->reconMap = rf_MakeReconMap(raidPtr,
raidPtr 120 dev/raidframe/rf_reconutil.c raidPtr->sectorsPerDisk, numSpareRUs);
raidPtr 123 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numCol; i++) {
raidPtr 125 dev/raidframe/rf_reconutil.c rf_MakeReconBuffer(raidPtr, frow, i,
raidPtr 159 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
raidPtr 160 dev/raidframe/rf_reconutil.c rbuf = rf_MakeReconBuffer(raidPtr, frow, fcol,
raidPtr 167 dev/raidframe/rf_reconutil.c reconCtrlPtr->pssTable = rf_MakeParityStripeStatusTable(raidPtr);
raidPtr 176 dev/raidframe/rf_reconutil.c rf_FreeReconControl(RF_Raid_t *raidPtr, RF_RowCol_t row)
raidPtr 178 dev/raidframe/rf_reconutil.c RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
raidPtr 183 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numCol; i++)
raidPtr 186 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
raidPtr 196 dev/raidframe/rf_reconutil.c rf_FreeParityStripeStatusTable(raidPtr, reconCtrlPtr->pssTable);
raidPtr 197 dev/raidframe/rf_reconutil.c RF_Free(reconCtrlPtr->perDiskInfo, raidPtr->numCol *
raidPtr 207 dev/raidframe/rf_reconutil.c rf_GetDefaultHeadSepLimit(RF_Raid_t *raidPtr)
raidPtr 212 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
raidPtr 215 dev/raidframe/rf_reconutil.c hsl = lp->GetDefaultHeadSepLimit(raidPtr);
raidPtr 224 dev/raidframe/rf_reconutil.c rf_GetDefaultNumFloatingReconBuffers(RF_Raid_t *raidPtr)
raidPtr 229 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
raidPtr 231 dev/raidframe/rf_reconutil.c return (3 * raidPtr->numCol);
raidPtr 232 dev/raidframe/rf_reconutil.c nrb = lp->GetDefaultNumFloatingReconBuffers(raidPtr);
raidPtr 241 dev/raidframe/rf_reconutil.c rf_MakeReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
raidPtr 244 dev/raidframe/rf_reconutil.c RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
raidPtr 246 dev/raidframe/rf_reconutil.c u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
raidPtr 251 dev/raidframe/rf_reconutil.c RF_Malloc(t->arrived, raidPtr->numCol * sizeof(char), (char *));
raidPtr 252 dev/raidframe/rf_reconutil.c t->raidPtr = raidPtr;
raidPtr 269 dev/raidframe/rf_reconutil.c RF_Raid_t *raidPtr = rbuf->raidPtr;
raidPtr 270 dev/raidframe/rf_reconutil.c u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
raidPtr 271 dev/raidframe/rf_reconutil.c raidPtr->Layout.SUsPerRU * raidPtr->Layout.sectorsPerStripeUnit);
raidPtr 273 dev/raidframe/rf_reconutil.c RF_Free(rbuf->arrived, raidPtr->numCol * sizeof(char));
raidPtr 283 dev/raidframe/rf_reconutil.c rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock)
raidPtr 291 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->numRow; i++)
raidPtr 292 dev/raidframe/rf_reconutil.c if (raidPtr->reconControl[i]) {
raidPtr 299 dev/raidframe/rf_reconutil.c RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
raidPtr 300 dev/raidframe/rf_reconutil.c pssTable = raidPtr->reconControl[frow]->pssTable;
raidPtr 302 dev/raidframe/rf_reconutil.c for (i = 0; i < raidPtr->pssTableSize; i++) {
raidPtr 323 dev/raidframe/rf_reconutil.c for (rbuf = raidPtr->reconControl[frow]->floatingRbufs; rbuf;
raidPtr 328 dev/raidframe/rf_reconutil.c for (rbuf = raidPtr->reconControl[frow]->committedRbufs; rbuf;
raidPtr 333 dev/raidframe/rf_reconutil.c for (rbuf = raidPtr->reconControl[frow]->fullBufferList; rbuf;
raidPtr 338 dev/raidframe/rf_reconutil.c for (rbuf = raidPtr->reconControl[frow]->priorityList; rbuf;
raidPtr 344 dev/raidframe/rf_reconutil.c RF_ASSERT(sum == raidPtr->numFloatingReconBufs);
raidPtr 347 dev/raidframe/rf_reconutil.c RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
raidPtr 103 dev/raidframe/rf_revent.c RF_Raid_t *raidPtr = reconDesc->raidPtr;
raidPtr 104 dev/raidframe/rf_revent.c RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
raidPtr 107 dev/raidframe/rf_revent.c RF_ASSERT(row >= 0 && row <= raidPtr->numRow);
raidPtr 176 dev/raidframe/rf_revent.c rf_CauseReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
raidPtr 179 dev/raidframe/rf_revent.c RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
raidPtr 185 dev/raidframe/rf_revent.c RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 &&
raidPtr 186 dev/raidframe/rf_revent.c col <= raidPtr->numCol);
raidPtr 286 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
raidPtr 311 dev/raidframe/rf_sstf.c printf("raid%d: rf_do_dequeue.\n", req->raidPtr->raidid);
raidPtr 344 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
raidPtr 357 dev/raidframe/rf_sstf.c req->raidPtr->raidid);
raidPtr 364 dev/raidframe/rf_sstf.c " %lx.\n", req->raidPtr->raidid,
raidPtr 406 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
raidPtr 461 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
raidPtr 624 dev/raidframe/rf_sstf.c r->raidPtr->raidid, (long) parityStripeID,
raidPtr 632 dev/raidframe/rf_sstf.c r->raidPtr->raidid, (long) r);
raidPtr 643 dev/raidframe/rf_sstf.c " %d,%d,%d.\n", r->raidPtr->raidid, n, sstfq->left.qlen,
raidPtr 97 dev/raidframe/rf_states.c int unit = desc->raidPtr->raidid;
raidPtr 189 dev/raidframe/rf_states.c desc->raidPtr->raidid, desc->type,
raidPtr 224 dev/raidframe/rf_states.c RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
raidPtr 225 dev/raidframe/rf_states.c ((RF_Raid_t *) desc->raidPtr)->openings++;
raidPtr 226 dev/raidframe/rf_states.c RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
raidPtr 229 dev/raidframe/rf_states.c raidstart(((RF_Raid_t *) desc->raidPtr));
raidPtr 245 dev/raidframe/rf_states.c RF_Raid_t *raidPtr;
raidPtr 247 dev/raidframe/rf_states.c raidPtr = desc->raidPtr;
raidPtr 252 dev/raidframe/rf_states.c RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 253 dev/raidframe/rf_states.c raidPtr->accs_in_flight++; /* Used to detect quiescence. */
raidPtr 254 dev/raidframe/rf_states.c RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 263 dev/raidframe/rf_states.c RF_Raid_t *raidPtr;
raidPtr 265 dev/raidframe/rf_states.c raidPtr = desc->raidPtr;
raidPtr 267 dev/raidframe/rf_states.c RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 268 dev/raidframe/rf_states.c raidPtr->accs_in_flight--;
raidPtr 269 dev/raidframe/rf_states.c if (raidPtr->accesses_suspended && raidPtr->accs_in_flight == 0) {
raidPtr 270 dev/raidframe/rf_states.c rf_SignalQuiescenceLock(raidPtr, raidPtr->reconDesc);
raidPtr 272 dev/raidframe/rf_states.c rf_UpdateUserStats(raidPtr, RF_ETIMER_VAL_US(desc->timer),
raidPtr 274 dev/raidframe/rf_states.c RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 286 dev/raidframe/rf_states.c RF_Raid_t *raidPtr;
raidPtr 288 dev/raidframe/rf_states.c raidPtr = desc->raidPtr;
raidPtr 293 dev/raidframe/rf_states.c RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 294 dev/raidframe/rf_states.c if (raidPtr->accesses_suspended) {
raidPtr 305 dev/raidframe/rf_states.c cb->next = raidPtr->quiesce_wait_list;
raidPtr 306 dev/raidframe/rf_states.c raidPtr->quiesce_wait_list = cb;
raidPtr 309 dev/raidframe/rf_states.c RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
raidPtr 325 dev/raidframe/rf_states.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 331 dev/raidframe/rf_states.c if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress,
raidPtr 347 dev/raidframe/rf_states.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 354 dev/raidframe/rf_states.c if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
raidPtr 375 dev/raidframe/rf_states.c raidPtr->Layout.dataSectorsPerStripe);
raidPtr 376 dev/raidframe/rf_states.c if (rf_AcquireStripeLock(raidPtr->lockTable,
raidPtr 383 dev/raidframe/rf_states.c raidPtr->status[asm_p->physInfo->row] ==
raidPtr 395 dev/raidframe/rf_states.c val = rf_ForceOrBlockRecon(raidPtr,
raidPtr 412 dev/raidframe/rf_states.c desc->raidPtr->raidid,
raidPtr 421 dev/raidframe/rf_states.c desc->raidPtr->raidid,
raidPtr 569 dev/raidframe/rf_states.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 588 dev/raidframe/rf_states.c rf_MarkFailuresInASMList(raidPtr, asmh);
raidPtr 636 dev/raidframe/rf_states.c RF_Raid_t *raidPtr = desc->raidPtr;
raidPtr 676 dev/raidframe/rf_states.c if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
raidPtr 682 dev/raidframe/rf_states.c rf_ReleaseStripeLock(raidPtr->lockTable,
raidPtr 686 dev/raidframe/rf_states.c rf_UnblockRecon(raidPtr, asm_p);
raidPtr 711 dev/raidframe/rf_states.c rf_LogTraceRec(raidPtr, tracerec);
raidPtr 238 dev/raidframe/rf_stripelocks.c RF_Raid_t *raidPtr = (RF_Raid_t *) arg;
raidPtr 239 dev/raidframe/rf_stripelocks.c rf_ShutdownStripeLocks(raidPtr->lockTable);
raidPtr 243 dev/raidframe/rf_stripelocks.c rf_ConfigureStripeLocks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
raidPtr 248 dev/raidframe/rf_stripelocks.c raidPtr->lockTable = rf_MakeLockTable();
raidPtr 249 dev/raidframe/rf_stripelocks.c if (raidPtr->lockTable == NULL)
raidPtr 251 dev/raidframe/rf_stripelocks.c rc = rf_ShutdownCreate(listp, rf_RaidShutdownStripeLocks, raidPtr);
raidPtr 255 dev/raidframe/rf_stripelocks.c rf_ShutdownStripeLocks(raidPtr->lockTable);