Annotation of src/sys/dev/raidframe/rf_interdecluster.c, revision 1.2

1.2     ! oster       1: /*     $NetBSD: rf_interdecluster.c,v 1.1 1998/11/13 04:20:30 oster Exp $      */
1.1       oster       2: /*
                      3:  * Copyright (c) 1995 Carnegie-Mellon University.
                      4:  * All rights reserved.
                      5:  *
                      6:  * Author: Khalil Amiri
                      7:  *
                      8:  * Permission to use, copy, modify and distribute this software and
                      9:  * its documentation is hereby granted, provided that both the copyright
                     10:  * notice and this permission notice appear in all copies of the
                     11:  * software, derivative works or modified versions, and any portions
                     12:  * thereof, and that both notices appear in supporting documentation.
                     13:  *
                     14:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
                     15:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
                     16:  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
                     17:  *
                     18:  * Carnegie Mellon requests users of this software to return to
                     19:  *
                     20:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
                     21:  *  School of Computer Science
                     22:  *  Carnegie Mellon University
                     23:  *  Pittsburgh PA 15213-3890
                     24:  *
                     25:  * any improvements or extensions that they make and grant Carnegie the
                     26:  * rights to redistribute these changes.
                     27:  */
                     28: 
                     29: /************************************************************
                     30:  *
                     31:  * rf_interdecluster.c -- implements interleaved declustering 
                     32:  *
                     33:  ************************************************************/
                     34: 
                     35: 
                     36: #include "rf_types.h"
                     37: #include "rf_raid.h"
                     38: #include "rf_interdecluster.h"
                     39: #include "rf_dag.h"
                     40: #include "rf_dagutils.h"
                     41: #include "rf_dagfuncs.h"
                     42: #include "rf_threadid.h"
                     43: #include "rf_general.h"
                     44: #include "rf_utils.h"
                     45: #include "rf_dagffrd.h"
                     46: #include "rf_dagdegrd.h"
                     47: #include "rf_dagffwr.h"
                     48: #include "rf_dagdegwr.h"
                     49: 
                     50: typedef struct RF_InterdeclusterConfigInfo_s {
                     51:   RF_RowCol_t       **stripeIdentifier;   /* filled in at config time
                     52:                                            * and used by IdentifyStripe */
                     53:   RF_StripeCount_t    numSparingRegions;
                     54:   RF_StripeCount_t    stripeUnitsPerSparingRegion;
                     55:   RF_SectorNum_t      mirrorStripeOffset;  
                     56: } RF_InterdeclusterConfigInfo_t;
                     57: 
                     58: int rf_ConfigureInterDecluster(
                     59:   RF_ShutdownList_t  **listp,
                     60:   RF_Raid_t           *raidPtr,
                     61:   RF_Config_t         *cfgPtr)
                     62: {
                     63:   RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
                     64:   RF_StripeCount_t num_used_stripeUnitsPerDisk;
                     65:   RF_InterdeclusterConfigInfo_t *info;
                     66:   RF_RowCol_t i, tmp, SUs_per_region;
                     67:   
                     68:   /* create an Interleaved Declustering configuration structure */
                     69:   RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t), (RF_InterdeclusterConfigInfo_t *), 
                     70:                        raidPtr->cleanupList);
                     71:   if (info == NULL)
                     72:     return(ENOMEM);
                     73:   layoutPtr->layoutSpecificInfo = (void *) info;
                     74: 
                     75:   /*  fill in the config structure.  */
                     76:   SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1);
                     77:   info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2 , raidPtr->cleanupList);
                     78:   if (info->stripeIdentifier == NULL)
                     79:     return(ENOMEM);
                     80:   for (i=0; i< SUs_per_region; i++) {
                     81:       info->stripeIdentifier[i][0] = i / (raidPtr->numCol-1);
                     82:       tmp = i / raidPtr->numCol;
                     83:       info->stripeIdentifier[i][1] = (i+1+tmp) % raidPtr->numCol;
                     84:     }
                     85: 
                     86:   /* no spare tables */
                     87:   RF_ASSERT(raidPtr->numRow == 1);
                     88: 
                     89:   /* fill in the remaining layout parameters */
                     90: 
                     91:   /* total number of stripes should a multiple of 2*numCol: Each sparing region consists of
                     92:    2*numCol stripes: n-1 primary copy, n-1 secondary copy and 2 for spare .. */ 
                     93:     num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk %
                     94:        (2*raidPtr->numCol) );
                     95:   info->numSparingRegions = num_used_stripeUnitsPerDisk / (2*raidPtr->numCol);
                     96:   /* this is in fact the number of stripe units (that are primary data copies) in the sparing region */
                     97:   info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1);
                     98:   info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol+1);
                     99:   layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion;
                    100:   layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
                    101:   layoutPtr->numDataCol = 1;
                    102:   layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
                    103:   layoutPtr->numParityCol = 1;
                    104:  
                    105:   layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
                    106: 
                    107:   raidPtr->sectorsPerDisk = 
                    108:     num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
                    109: 
                    110:   raidPtr->totalSectors = 
                    111:     (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
                    112: 
                    113:   layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
                    114: 
                    115:   return(0);
                    116: }
                    117: 
                    118: int rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr)
                    119: {
                    120:   return(30);
                    121: }
                    122: 
                    123: RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr)
                    124: {
                    125:   return(raidPtr->sectorsPerDisk);
                    126: }
                    127: 
                    128: RF_ReconUnitCount_t rf_GetNumSpareRUsInterDecluster(
                    129:   RF_Raid_t  *raidPtr)
                    130: {
                    131:   RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
                    132: 
                    133:   return ( 2 * ((RF_ReconUnitCount_t) info->numSparingRegions) ); 
                    134:        /* the layout uses two stripe units per disk as spare within each sparing region */
                    135: }
                    136: 
                    137: /* Maps to the primary copy of the data, i.e. the first mirror pair */
                    138: void rf_MapSectorInterDecluster(
                    139:   RF_Raid_t         *raidPtr,
                    140:   RF_RaidAddr_t      raidSector,
                    141:   RF_RowCol_t       *row,
                    142:   RF_RowCol_t       *col,
                    143:   RF_SectorNum_t    *diskSector,
                    144:   int                remap)
                    145: {
                    146:  RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
                    147:  RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
                    148:  RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk;
                    149:  RF_StripeNum_t sparing_region_id, index_within_region;
                    150:  int col_before_remap;
                    151: 
                    152:  *row = 0;
                    153:  sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
                    154:  index_within_region = SUID % info->stripeUnitsPerSparingRegion;
                    155:  su_offset_into_disk = index_within_region % (raidPtr->numCol-1);
                    156:  mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
                    157:  col_before_remap = index_within_region / (raidPtr->numCol-1);
                    158: 
                    159:  if (!remap) {
                    160:         *col = col_before_remap;;
                    161:         *diskSector = ( su_offset_into_disk + ( (raidPtr->numCol-1) * sparing_region_id) ) *
                    162:                         raidPtr->Layout.sectorsPerStripeUnit;
                    163:         *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
                    164:       }
                    165:  else {
                    166:       /* remap sector to spare space...*/
                    167:       *diskSector = sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit;
                    168:       *diskSector += (raidPtr->numCol-1) * raidPtr->Layout.sectorsPerStripeUnit;
                    169:       *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
                    170:       *col = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
                    171:       *col = (*col + 1) % raidPtr->numCol;
                    172:       if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol;
                    173:    }
                    174: }
                    175: 
                    176: /* Maps to the second copy of the mirror pair. */
                    177: void rf_MapParityInterDecluster(
                    178:   RF_Raid_t       *raidPtr,
                    179:   RF_RaidAddr_t    raidSector,
                    180:   RF_RowCol_t     *row,
                    181:   RF_RowCol_t     *col,
                    182:   RF_SectorNum_t  *diskSector,
                    183:   int              remap)
                    184: {
                    185:   RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
                    186:   RF_StripeNum_t sparing_region_id, index_within_region, mirror_su_offset_into_disk;
                    187:   RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
                    188:   int col_before_remap;
                    189:   
                    190:   sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
                    191:   index_within_region = SUID % info->stripeUnitsPerSparingRegion;
                    192:   mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
                    193:   col_before_remap = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
                    194: 
                    195:   *row = 0;
                    196:   if (!remap) {
                    197:         *col = col_before_remap;
                    198:         *diskSector =  info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit;
                    199:         *diskSector += sparing_region_id * (raidPtr->numCol-1)  * raidPtr->Layout.sectorsPerStripeUnit;
                    200:         *diskSector += mirror_su_offset_into_disk * raidPtr->Layout.sectorsPerStripeUnit;
                    201:         *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
                    202:        }
                    203:   else {
                    204:         /* remap parity to spare space ... */
                    205:         *diskSector =  sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit;
                    206:         *diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
                    207:         *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
                    208:         *col = index_within_region / (raidPtr->numCol-1);
                    209:         *col = (*col + 1) % raidPtr->numCol;
                    210:         if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol;
                    211:   }
                    212: }
                    213: 
                    214: void rf_IdentifyStripeInterDecluster(
                    215:   RF_Raid_t        *raidPtr,
                    216:   RF_RaidAddr_t     addr,
                    217:   RF_RowCol_t     **diskids,
                    218:   RF_RowCol_t      *outRow)
                    219: {
                    220:   RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
                    221:   RF_StripeNum_t SUID;
                    222: 
                    223:   SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
                    224:   SUID = SUID % info->stripeUnitsPerSparingRegion;
                    225: 
                    226:   *outRow = 0;
                    227:   *diskids = info->stripeIdentifier[ SUID ];
                    228: }
                    229: 
                    230: void rf_MapSIDToPSIDInterDecluster(
                    231:   RF_RaidLayout_t    *layoutPtr,
                    232:   RF_StripeNum_t      stripeID,
                    233:   RF_StripeNum_t     *psID,
                    234:   RF_ReconUnitNum_t  *which_ru)
                    235: {
                    236:   *which_ru = 0;
                    237:   *psID = stripeID;
                    238: }
                    239: 
                    240: /******************************************************************************
                    241:  * select a graph to perform a single-stripe access
                    242:  *
                    243:  * Parameters:  raidPtr    - description of the physical array
                    244:  *              type       - type of operation (read or write) requested
                    245:  *              asmap      - logical & physical addresses for this access
                    246:  *              createFunc - name of function to use to create the graph
                    247:  *****************************************************************************/
                    248: 
                    249: void rf_RAIDIDagSelect(
                    250:   RF_Raid_t             *raidPtr,
                    251:   RF_IoType_t            type,
                    252:   RF_AccessStripeMap_t  *asmap,
                    253:   RF_VoidFuncPtr *createFunc)
                    254: {
                    255:   RF_ASSERT(RF_IO_IS_R_OR_W(type));
                    256: 
                    257:   if (asmap->numDataFailed + asmap->numParityFailed > 1) {
                    258:     RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
                    259:     *createFunc = NULL;
                    260:     return;
                    261:   }
                    262:   
                    263:   *createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr)rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG;
                    264:   if (type == RF_IO_TYPE_READ) {
                    265:     if (asmap->numDataFailed == 0)
                    266:       *createFunc = (RF_VoidFuncPtr)rf_CreateMirrorPartitionReadDAG;
                    267:     else
                    268:       *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneDegradedReadDAG;
                    269:   }
                    270:   else
                    271:     *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG;
                    272: }

CVSweb <webmaster@jp.NetBSD.org>