root/dev/raidframe/rf_declusterPQ.c

DEFINITIONS

1. rf_ConfigureDeclusteredPQ
2. rf_GetDefaultNumFloatingReconBuffersPQ
3. rf_MapSectorDeclusteredPQ
4. rf_MapParityDeclusteredPQ
5. rf_MapQDeclusteredPQ
6. rf_IdentifyStripeDeclusteredPQ

    1 /*      $OpenBSD: rf_declusterPQ.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $       */
    2 /*      $NetBSD: rf_declusterPQ.c,v 1.3 1999/02/05 00:06:09 oster Exp $ */
    4 /*
    5  * Copyright (c) 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Authors: Daniel Stodolsky, Mark Holland, Jim Zelenka
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31 /*****************************************************************************
   32  * rf_declusterPQ.c
   33  *
   34  * Mapping code for declustered P & Q or declustered EvenOdd.
   35  * Much code borrowed from rf_decluster.c
   36  *
   37  *****************************************************************************/
   40 #include "rf_types.h"
   41 #include "rf_raid.h"
   42 #include "rf_configure.h"
   43 #include "rf_decluster.h"
   44 #include "rf_declusterPQ.h"
   45 #include "rf_debugMem.h"
   46 #include "rf_utils.h"
   47 #include "rf_alloclist.h"
   48 #include "rf_general.h"
   50 /* Configuration code. */
   52 int
rf_ConfigureDeclusteredPQ(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
RF_Config_t *cfgPtr)
   55 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
   57         int b, v, k, r, lambda; /* block design params */
   58         int i, j, l;
   59         int *first_avail_slot;
   60         int complete_FT_count, SUID;
RF_DeclusteredConfigInfo_t *info;
   62         int numCompleteFullTablesPerDisk;
   63         int PUsPerDisk, spareRegionDepthInPUs, extraPUsPerDisk;
   64         int numCompleteSpareRegionsPerDisk = 0;
   65         int totSparePUsPerDisk;
   66         int diskOffsetOfLastFullTableInSUs, SpareSpaceInSUs;
   67         char *cfgBuf = (char *)(cfgPtr->layoutSpecific);
cfgBuf += RF_SPAREMAP_NAME_LEN;
b = *((int *) cfgBuf);
cfgBuf += sizeof(int);
v = *((int *) cfgBuf);
cfgBuf += sizeof(int);
k = *((int *) cfgBuf);
cfgBuf += sizeof(int);
r = *((int *) cfgBuf);
cfgBuf += sizeof(int);
lambda = *((int *) cfgBuf);
cfgBuf += sizeof(int);
raidPtr->noRotate = *((int *) cfgBuf);
cfgBuf += sizeof(int);
   84         if (k <= 2) {
   85 #ifdef  RAIDDEBUG
printf("RAIDFRAME: k=%d, minimum value 2\n", k);
   87 #endif  /* RAIDDEBUG */
   88                 return (EINVAL);
   89         }
   90         /* 1. Create layout specific structure. */
RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t),
   92             (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
   93         if (info == NULL)
   94                 return (ENOMEM);
layoutPtr->layoutSpecificInfo = (void *) info;
   97         /*
   98          * 2. The sparemaps are generated assuming that parity is rotated, so
   99          * we issue a warning if both distributed sparing and no-rotate are on
  100          * at the same time.
  101          */
  102         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) &&
raidPtr->noRotate) {
RF_ERRORMSG("Warning:  distributed sparing specified without"
  105                     " parity rotation.\n");
  106         }
  107         if (raidPtr->numCol != v) {
RF_ERRORMSG2("RAID: config error: table element count (%d)"
  109                     " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
  110                 return (EINVAL);
  111         }
  112         /* 3. Set up the values used in devRaidMap. */
info->BlocksPerTable = b;
info->NumParityReps = info->groupSize = k;
info->PUsPerBlock = k - 2;      /* PQ */
info->SUsPerTable = b * info->PUsPerBlock * layoutPtr->SUsPerPU;
  117                 /* b blks, k-1 SUs each. */
info->SUsPerFullTable = k * info->SUsPerTable;  /* Rot k times. */
info->SUsPerBlock = info->PUsPerBlock * layoutPtr->SUsPerPU;
info->TableDepthInPUs = (b * k) / v;
info->FullTableDepthInPUs = info->TableDepthInPUs * k;
  122                 /* k repetitions. */
  124         /* Used only in distributed sparing case. */
info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);
  126                 /* (v-1)/gcd fulltables. */
info->TablesPerSpareRegion = k * info->FullTablesPerSpareRegion;
info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion
  129             / (v - 1)) * layoutPtr->SUsPerPU;
  131         /* Check to make sure the block design is sufficiently small. */
  132         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
  133                 if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU +
info->SpareSpaceDepthPerRegionInSUs >
layoutPtr->stripeUnitsPerDisk) {
RF_ERRORMSG3("RAID: config error: Full Table depth"
  137                             " (%d) + Spare Space (%d) larger than disk size"
  138                             " (%d) (BD too big).\n",
  139                             (int)info->FullTableDepthInPUs,
  140                             (int)info->SpareSpaceDepthPerRegionInSUs,
  141                             (int)layoutPtr->stripeUnitsPerDisk);
  142                         return (EINVAL);
  143                 }
  144         } else {
  145                 if (info->TableDepthInPUs * layoutPtr->SUsPerPU >
layoutPtr->stripeUnitsPerDisk) {
RF_ERRORMSG2("RAID: config error: Table depth (%d)"
  148                             " larger than disk size (%d) (BD too big).\n",
  149                             (int) (info->TableDepthInPUs * layoutPtr->SUsPerPU),
  150                             (int) layoutPtr->stripeUnitsPerDisk);
  151                         return (EINVAL);
  152                 }
  153         }
  155         /*
  156          * Compute the size of each disk, and the number of tables in the last
  157          * fulltable (which need not be complete).
  158          */
  159         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
PUsPerDisk = layoutPtr->stripeUnitsPerDisk /
layoutPtr->SUsPerPU;
spareRegionDepthInPUs = (info->TablesPerSpareRegion *
info->TableDepthInPUs + (info->TablesPerSpareRegion *
info->TableDepthInPUs) / (v - 1));
info->SpareRegionDepthInSUs = spareRegionDepthInPUs *
layoutPtr->SUsPerPU;
numCompleteSpareRegionsPerDisk = PUsPerDisk /
spareRegionDepthInPUs;
info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
  174                 /*
  175                  * Assume conservatively that we need the full amount of spare
  176                  * space in one region in order to provide spares for the
  177                  * partial spare region at the end of the array.  We set "i"
  178                  * to the number of tables in the partial spare region.  This
  179                  * may actually include some fulltables.
  180                  */
extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs /
layoutPtr->SUsPerPU);
  183                 if (extraPUsPerDisk <= 0)
i = 0;
  185                 else
i = extraPUsPerDisk / info->TableDepthInPUs;
complete_FT_count = raidPtr->numRow *
  189                     (numCompleteSpareRegionsPerDisk *
  190                     (info->TablesPerSpareRegion / k) + i / k);
info->FullTableLimitSUID = complete_FT_count *
info->SUsPerFullTable;
info->ExtraTablesPerDisk = i % k;
  195                 /*
  196                  * Note that in the last spare region, the spare space is
  197                  * complete even though data/parity space is not.
  198                  */
totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) *
  200                     (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
info->TotSparePUsPerDisk = totSparePUsPerDisk;
layoutPtr->stripeUnitsPerDisk =
  204                     ((complete_FT_count / raidPtr->numRow) *
info->FullTableDepthInPUs + /* data & parity space */
info->ExtraTablesPerDisk * info->TableDepthInPUs +
totSparePUsPerDisk  /* spare space */
  208                     ) * layoutPtr->SUsPerPU;
layoutPtr->dataStripeUnitsPerDisk =
  210                     (complete_FT_count * info->FullTableDepthInPUs +
info->ExtraTablesPerDisk * info->TableDepthInPUs)
  212                     * layoutPtr->SUsPerPU * (k - 1) / k;
  214         } else {
  215                 /*
  216                  * Non-dist spare case:  force each disk to contain an
  217                  * integral number of tables.
  218                  */
layoutPtr->stripeUnitsPerDisk /=
  220                     (info->TableDepthInPUs * layoutPtr->SUsPerPU);
layoutPtr->stripeUnitsPerDisk *=
  222                     (info->TableDepthInPUs * layoutPtr->SUsPerPU);
  224                 /*
  225                  * Compute the number of tables in the last fulltable, which
  226                  * need not be complete.
  227                  */
complete_FT_count = ((layoutPtr->stripeUnitsPerDisk /
layoutPtr->SUsPerPU) / info->FullTableDepthInPUs) *
raidPtr->numRow;
info->FullTableLimitSUID = complete_FT_count *
info->SUsPerFullTable;
info->ExtraTablesPerDisk = ((layoutPtr->stripeUnitsPerDisk /
layoutPtr->SUsPerPU) / info->TableDepthInPUs) % k;
  236         }
raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
layoutPtr->sectorsPerStripeUnit;
  241         /*
  242          * Find the disk offset of the stripe unit where the last
  243          * fulltable starts.
  244          */
numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk *
info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
  248         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
SpareSpaceInSUs = numCompleteSpareRegionsPerDisk *
info->SpareSpaceDepthPerRegionInSUs;
diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
info->DiskOffsetOfLastSpareSpaceChunkInSUs =
diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk *
info->TableDepthInPUs * layoutPtr->SUsPerPU;
  255         }
info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
  259         /* 4. Create and initialize the lookup tables. */
info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
  261         if (info->LayoutTable == NULL)
  262                 return (ENOMEM);
info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
  265         if (info->OffsetTable == NULL)
  266                 return (ENOMEM);
info->BlockTable = rf_make_2d_array(info->TableDepthInPUs *
layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
  270         if (info->BlockTable == NULL)
  271                 return (ENOMEM);
first_avail_slot = (int *) rf_make_1d_array(v, NULL);
  274         if (first_avail_slot == NULL)
  275                 return (ENOMEM);
  277         for (i = 0; i < b; i++)
  278                 for (j = 0; j < k; j++)
info->LayoutTable[i][j] = *cfgBuf++;
  281         /* Initialize offset table. */
  282         for (i = 0; i < b; i++)
  283                 for (j = 0; j < k; j++) {
info->OffsetTable[i][j] =
first_avail_slot[info->LayoutTable[i][j]];
first_avail_slot[info->LayoutTable[i][j]]++;
  287                 }
  289         /* Initialize block table. */
  290         for (SUID = l = 0; l < layoutPtr->SUsPerPU; l++) {
  291                 for (i = 0; i < b; i++) {
  292                         for (j = 0; j < k; j++) {
info->BlockTable[(info->OffsetTable[i][j] *
layoutPtr->SUsPerPU) + l]
  295                                     [info->LayoutTable[i][j]] = SUID;
  296                         }
SUID++;
  298                 }
  299         }
rf_free_1d_array(first_avail_slot, v);
  303         /* 5. Set up the remaining redundant-but-useful parameters. */
raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
info->ExtraTablesPerDisk) * info->SUsPerTable *
layoutPtr->sectorsPerStripeUnit;
layoutPtr->numStripe = (raidPtr->totalSectors /
layoutPtr->sectorsPerStripeUnit) / (k - 2);
  311         /*
  312          * Strange evaluation order below to try and minimize overflow
  313          * problems.
  314          */
layoutPtr->dataSectorsPerStripe = (k - 2) *
layoutPtr->sectorsPerStripeUnit;
layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
raidPtr->logBytesPerSector;
layoutPtr->numDataCol = k - 2;
layoutPtr->numParityCol = 2;
  323         return (0);
  324 }
  326 int
rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t *raidPtr)
  328 {
  329         int def_decl;
def_decl = rf_GetDefaultNumFloatingReconBuffersDeclustered(raidPtr);
  332         return (RF_MAX(3 * raidPtr->numCol, def_decl));
  333 }
  335 void
rf_MapSectorDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
  338 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_DeclusteredConfigInfo_t *info =
  341             (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
RF_StripeNum_t BlockID, BlockOffset, RepIndex;
RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
layoutPtr->SUsPerPU;
RF_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
  351             &fulltable_depth, &base_suid);
  353         /* Fulltable ID within array (across rows). */
FullTableID = SUID / sus_per_fulltable;
  355         *row = FullTableID % raidPtr->numRow;
  357         /* Convert to fulltable ID on this disk. */
FullTableID /= raidPtr->numRow;
  360         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
  363         }
FullTableOffset = SUID % sus_per_fulltable;
TableID = FullTableOffset / info->SUsPerTable;
TableOffset = FullTableOffset - TableID * info->SUsPerTable;
BlockID = TableOffset / info->PUsPerBlock;
BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
BlockID %= info->BlocksPerTable;
RF_ASSERT(BlockOffset < info->groupSize - 2);
  371         /*
  372          * TableIDs go from 0 .. GroupSize-1 inclusive.
  373          * PUsPerBlock is k-2.
  374          * We want the tableIDs to rotate from the
  375          * right, so use GroupSize.
  376          */
RepIndex = info->groupSize - 1 - TableID;
RF_ASSERT(RepIndex >= 0);
  379         if (!raidPtr->noRotate) {
  380                 if (TableID == 0)
  381                         /* P on last drive, Q on first. */
BlockOffset++;
  383                 else
  384                         /* Skip over PQ. */
BlockOffset += ((BlockOffset >= RepIndex) ? 2 : 0);
RF_ASSERT(BlockOffset < info->groupSize);
  388                 *col = info->LayoutTable[BlockID][BlockOffset];
  389         }
  390         /* Remap to distributed spare space if indicated. */
  391         if (remap) {
rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID,
TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col,
  394                     &outSU);
  395         } else {
outSU = base_suid;
outSU += FullTableID * fulltable_depth;
  399                         /* Offset to strt of FT. */
outSU += SpareSpace;
  401                         /* Skip reserved spare space. */
outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
  403                         /* Offset to start of table. */
outSU += info->OffsetTable[BlockID][BlockOffset] *
layoutPtr->SUsPerPU;
  406                         /* Offset to the PU. */
  407         }
outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
  409                 /* Offset to the SU within a PU. */
  411         /*
  412          * Convert SUs to sectors, and, if not aligned to SU boundary, add in
  413          * offset to sector.
  414          */
  415         *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
  416             (raidSector % layoutPtr->sectorsPerStripeUnit);
  417 }
  420 void
rf_MapParityDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
  423 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_DeclusteredConfigInfo_t *info =
  426             (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
RF_StripeNum_t BlockID, BlockOffset, RepIndex;
RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
layoutPtr->SUsPerPU;
RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
  436             &fulltable_depth, &base_suid);
  438         /* Compute row & (possibly) spare space exactly as before. */
FullTableID = SUID / sus_per_fulltable;
  440         *row = FullTableID % raidPtr->numRow;
  441         /* Convert to fulltable ID on this disk. */
FullTableID /= raidPtr->numRow;
  443         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
  446         }
  447         /* Compute BlockID and RepIndex exactly as before. */
FullTableOffset = SUID % sus_per_fulltable;
TableID = FullTableOffset / info->SUsPerTable;
TableOffset = FullTableOffset - TableID * info->SUsPerTable;
BlockID = TableOffset / info->PUsPerBlock;
BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
BlockID %= info->BlocksPerTable;
  455         /* The parity block is in the position indicated by RepIndex. */
RepIndex = (raidPtr->noRotate) ?
info->PUsPerBlock : info->groupSize - 1 - TableID;
  458         *col = info->LayoutTable[BlockID][RepIndex];
  460         if (remap)
RF_PANIC();
  463         /*
  464          * Compute sector as before, except use RepIndex instead of
  465          * BlockOffset.
  466          */
outSU = base_suid;
outSU += FullTableID * fulltable_depth;
outSU += SpareSpace;    /* skip rsvd spare space */
outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
outSU += info->OffsetTable[BlockID][RepIndex] * layoutPtr->SUsPerPU;
outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
  474         *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
  475             (raidSector % layoutPtr->sectorsPerStripeUnit);
  476 }
  478 void
rf_MapQDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
  481 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_DeclusteredConfigInfo_t *info =
  484             (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
RF_StripeNum_t BlockID, BlockOffset, RepIndex, RepIndexQ;
RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
layoutPtr->SUsPerPU;
RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
  494             &fulltable_depth, &base_suid);
  496         /* Compute row & (possibly) spare space exactly as before. */
FullTableID = SUID / sus_per_fulltable;
  498         *row = FullTableID % raidPtr->numRow;
  499         /* Convert to fulltable ID on this disk. */
FullTableID /= raidPtr->numRow;
  501         if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
  504         }
  505         /* Compute BlockID and RepIndex exactly as before. */
FullTableOffset = SUID % sus_per_fulltable;
TableID = FullTableOffset / info->SUsPerTable;
TableOffset = FullTableOffset - TableID * info->SUsPerTable;
BlockID = TableOffset / info->PUsPerBlock;
BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
BlockID %= info->BlocksPerTable;
  513         /* The q block is in the position indicated by RepIndex. */
RepIndex = (raidPtr->noRotate) ?
info->PUsPerBlock : info->groupSize - 1 - TableID;
RepIndexQ = ((RepIndex == (info->groupSize - 1)) ? 0 : RepIndex + 1);
  517         *col = info->LayoutTable[BlockID][RepIndexQ];
  519         if (remap)
RF_PANIC();
  522         /*
  523          * Compute sector as before, except use RepIndex instead of
  524          * BlockOffset.
  525          */
outSU = base_suid;
outSU += FullTableID * fulltable_depth;
outSU += SpareSpace;    /* skip rsvd spare space */
outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
outSU += info->OffsetTable[BlockID][RepIndexQ] * layoutPtr->SUsPerPU;
  533         *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
  534             (raidSector % layoutPtr->sectorsPerStripeUnit);
  535 }
  537 /*
  538  * Returns an array of ints identifying the disks that comprise the stripe
  539  * containing the indicated address.
  540  * The caller must _never_ attempt to modify this array.
  541  */
  542 void
rf_IdentifyStripeDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
RF_RowCol_t **diskids, RF_RowCol_t *outRow)
  545 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_DeclusteredConfigInfo_t *info =
  548             (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
layoutPtr->SUsPerPU;
RF_StripeNum_t base_suid = 0;
RF_StripeNum_t SUID = rf_RaidAddressToStripeUnitID(layoutPtr, addr);
RF_StripeNum_t stripeID, FullTableID;
  555         int tableOffset;
rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
  558             &fulltable_depth, &base_suid);
  559         /* Fulltable ID within array (across rows). */
FullTableID = SUID / sus_per_fulltable;
  561         *outRow = FullTableID % raidPtr->numRow;
  562         /* Find stripe offset into array. */
stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);
  564         /* Find offset into block design table. */
tableOffset = (stripeID % info->BlocksPerTable);
  566         *diskids = info->LayoutTable[tableOffset];
  567 }