Annotation of sys/dev/raidframe/rf_chaindecluster.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: rf_chaindecluster.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $ */
! 2: /* $NetBSD: rf_chaindecluster.c,v 1.4 2000/01/07 03:40:56 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Khalil Amiri
! 9: *
! 10: * Permission to use, copy, modify and distribute this software and
! 11: * its documentation is hereby granted, provided that both the copyright
! 12: * notice and this permission notice appear in all copies of the
! 13: * software, derivative works or modified versions, and any portions
! 14: * thereof, and that both notices appear in supporting documentation.
! 15: *
! 16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 19: *
! 20: * Carnegie Mellon requests users of this software to return to
! 21: *
! 22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 23: * School of Computer Science
! 24: * Carnegie Mellon University
! 25: * Pittsburgh PA 15213-3890
! 26: *
! 27: * any improvements or extensions that they make and grant Carnegie the
! 28: * rights to redistribute these changes.
! 29: */
! 30:
! 31: /*****************************************************************************
! 32: *
! 33: * rf_chaindecluster.c -- implements chained declustering
! 34: *
! 35: *****************************************************************************/
! 36:
! 37: #include "rf_archs.h"
! 38: #include "rf_types.h"
! 39: #include "rf_raid.h"
! 40: #include "rf_chaindecluster.h"
! 41: #include "rf_dag.h"
! 42: #include "rf_dagutils.h"
! 43: #include "rf_dagffrd.h"
! 44: #include "rf_dagffwr.h"
! 45: #include "rf_dagdegrd.h"
! 46: #include "rf_dagfuncs.h"
! 47: #include "rf_general.h"
! 48: #include "rf_utils.h"
! 49:
! 50: typedef struct RF_ChaindeclusterConfigInfo_s {
! 51: RF_RowCol_t **stripeIdentifier; /*
! 52: * Filled in at config time and
! 53: * used by IdentifyStripe.
! 54: */
! 55: RF_StripeCount_t numSparingRegions;
! 56: RF_StripeCount_t stripeUnitsPerSparingRegion;
! 57: RF_SectorNum_t mirrorStripeOffset;
! 58: } RF_ChaindeclusterConfigInfo_t;
! 59:
! 60:
! 61: int
! 62: rf_ConfigureChainDecluster(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
! 63: RF_Config_t *cfgPtr)
! 64: {
! 65: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
! 66: RF_StripeCount_t num_used_stripeUnitsPerDisk;
! 67: RF_ChaindeclusterConfigInfo_t *info;
! 68: RF_RowCol_t i;
! 69:
! 70: /* Create a Chained Declustering configuration structure. */
! 71: RF_MallocAndAdd(info, sizeof(RF_ChaindeclusterConfigInfo_t),
! 72: (RF_ChaindeclusterConfigInfo_t *), raidPtr->cleanupList);
! 73: if (info == NULL)
! 74: return (ENOMEM);
! 75: layoutPtr->layoutSpecificInfo = (void *) info;
! 76:
! 77: /* Fill in the config structure. */
! 78: info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, 2,
! 79: raidPtr->cleanupList);
! 80: if (info->stripeIdentifier == NULL)
! 81: return (ENOMEM);
! 82: for (i = 0; i < raidPtr->numCol; i++) {
! 83: info->stripeIdentifier[i][0] = i % raidPtr->numCol;
! 84: info->stripeIdentifier[i][1] = (i + 1) % raidPtr->numCol;
! 85: }
! 86:
! 87: RF_ASSERT(raidPtr->numRow == 1);
! 88:
! 89: /* Fill in the remaining layout parameters. */
! 90: num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk -
! 91: (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol - 2));
! 92: info->numSparingRegions = num_used_stripeUnitsPerDisk /
! 93: (2 * raidPtr->numCol - 2);
! 94: info->stripeUnitsPerSparingRegion = raidPtr->numCol *
! 95: (raidPtr->numCol - 1);
! 96: info->mirrorStripeOffset = info->numSparingRegions *
! 97: (raidPtr->numCol - 1);
! 98: layoutPtr->numStripe = info->numSparingRegions *
! 99: info->stripeUnitsPerSparingRegion;
! 100: layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
! 101: raidPtr->logBytesPerSector;
! 102: layoutPtr->numDataCol = 1;
! 103: layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
! 104: layoutPtr->sectorsPerStripeUnit;
! 105: layoutPtr->numParityCol = 1;
! 106:
! 107: layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
! 108:
! 109: raidPtr->sectorsPerDisk = num_used_stripeUnitsPerDisk *
! 110: layoutPtr->sectorsPerStripeUnit;
! 111:
! 112: raidPtr->totalSectors = (layoutPtr->numStripe) *
! 113: layoutPtr->sectorsPerStripeUnit;
! 114:
! 115: layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
! 116: layoutPtr->sectorsPerStripeUnit;
! 117:
! 118: return (0);
! 119: }
! 120:
! 121: RF_ReconUnitCount_t
! 122: rf_GetNumSpareRUsChainDecluster(RF_Raid_t *raidPtr)
! 123: {
! 124: RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
! 125: raidPtr->Layout.layoutSpecificInfo;
! 126:
! 127: /*
! 128: * The layout uses two stripe units per disk as spare within each
! 129: * sparing region.
! 130: */
! 131: return (2 * info->numSparingRegions);
! 132: }
! 133:
! 134:
! 135: /* Maps to the primary copy of the data, i.e. the first mirror pair. */
! 136: void
! 137: rf_MapSectorChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
! 138: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
! 139: {
! 140: RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
! 141: raidPtr->Layout.layoutSpecificInfo;
! 142: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
! 143: RF_SectorNum_t index_within_region, index_within_disk;
! 144: RF_StripeNum_t sparing_region_id;
! 145: int col_before_remap;
! 146:
! 147: *row = 0;
! 148: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
! 149: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
! 150: index_within_disk = index_within_region / raidPtr->numCol;
! 151: col_before_remap = SUID % raidPtr->numCol;
! 152:
! 153: if (!remap) {
! 154: *col = col_before_remap;
! 155: *diskSector = (index_within_disk + ((raidPtr->numCol - 1) *
! 156: sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
! 157: *diskSector += (raidSector %
! 158: raidPtr->Layout.sectorsPerStripeUnit);
! 159: } else {
! 160: /* Remap sector to spare space... */
! 161: *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
! 162: raidPtr->Layout.sectorsPerStripeUnit;
! 163: *diskSector += (raidPtr->numCol - 1) *
! 164: raidPtr->Layout.sectorsPerStripeUnit;
! 165: *diskSector += (raidSector %
! 166: raidPtr->Layout.sectorsPerStripeUnit);
! 167: index_within_disk = index_within_region / raidPtr->numCol;
! 168: if (index_within_disk < col_before_remap)
! 169: *col = index_within_disk;
! 170: else
! 171: if (index_within_disk == raidPtr->numCol - 2) {
! 172: *col = (col_before_remap + raidPtr->numCol - 1)
! 173: % raidPtr->numCol;
! 174: *diskSector +=
! 175: raidPtr->Layout.sectorsPerStripeUnit;
! 176: } else
! 177: *col = (index_within_disk + 2) %
! 178: raidPtr->numCol;
! 179: }
! 180:
! 181: }
! 182:
! 183:
! 184: /*
! 185: * Maps to the second copy of the mirror pair, which is chain declustered.
! 186: * The second copy is contained in the next disk (mod numCol) after the disk
! 187: * containing the primary copy.
! 188: * The offset into the disk is one-half disk down.
! 189: */
! 190: void
! 191: rf_MapParityChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
! 192: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
! 193: {
! 194: RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
! 195: raidPtr->Layout.layoutSpecificInfo;
! 196: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
! 197: RF_SectorNum_t index_within_region, index_within_disk;
! 198: RF_StripeNum_t sparing_region_id;
! 199: int col_before_remap;
! 200:
! 201: *row = 0;
! 202: if (!remap) {
! 203: *col = SUID % raidPtr->numCol;
! 204: *col = (*col + 1) % raidPtr->numCol;
! 205: *diskSector = info->mirrorStripeOffset *
! 206: raidPtr->Layout.sectorsPerStripeUnit;
! 207: *diskSector += (SUID / raidPtr->numCol) *
! 208: raidPtr->Layout.sectorsPerStripeUnit;
! 209: *diskSector += (raidSector %
! 210: raidPtr->Layout.sectorsPerStripeUnit);
! 211: } else {
! 212: /* Remap parity to spare space... */
! 213: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
! 214: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
! 215: index_within_disk = index_within_region / raidPtr->numCol;
! 216: *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
! 217: raidPtr->Layout.sectorsPerStripeUnit;
! 218: *diskSector += (raidPtr->numCol) *
! 219: raidPtr->Layout.sectorsPerStripeUnit;
! 220: *diskSector += (raidSector %
! 221: raidPtr->Layout.sectorsPerStripeUnit);
! 222: col_before_remap = SUID % raidPtr->numCol;
! 223: if (index_within_disk < col_before_remap)
! 224: *col = index_within_disk;
! 225: else
! 226: if (index_within_disk == raidPtr->numCol - 2) {
! 227: *col = (col_before_remap + 2) % raidPtr->numCol;
! 228: *diskSector -=
! 229: raidPtr->Layout.sectorsPerStripeUnit;
! 230: } else
! 231: *col = (index_within_disk + 2) %
! 232: raidPtr->numCol;
! 233: }
! 234: }
! 235:
! 236: void
! 237: rf_IdentifyStripeChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
! 238: RF_RowCol_t **diskids, RF_RowCol_t *outRow)
! 239: {
! 240: RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
! 241: raidPtr->Layout.layoutSpecificInfo;
! 242: RF_StripeNum_t SUID;
! 243: RF_RowCol_t col;
! 244:
! 245: SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
! 246: col = SUID % raidPtr->numCol;
! 247: *outRow = 0;
! 248: *diskids = info->stripeIdentifier[col];
! 249: }
! 250:
! 251: void
! 252: rf_MapSIDToPSIDChainDecluster(RF_RaidLayout_t *layoutPtr,
! 253: RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
! 254: {
! 255: *which_ru = 0;
! 256: *psID = stripeID;
! 257: }
! 258:
! 259:
! 260: /****************************************************************************
! 261: * Select a graph to perform a single-stripe access.
! 262: *
! 263: * Parameters: raidPtr - description of the physical array
! 264: * type - type of operation (read or write) requested
! 265: * asmap - logical & physical addresses for this access
! 266: * createFunc - function to use to create the graph (return value)
! 267: *****************************************************************************/
! 268:
! 269: void
! 270: rf_RAIDCDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
! 271: RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
! 272: {
! 273: RF_ASSERT(RF_IO_IS_R_OR_W(type));
! 274: RF_ASSERT(raidPtr->numRow == 1);
! 275:
! 276: if (asmap->numDataFailed + asmap->numParityFailed > 1) {
! 277: RF_ERRORMSG("Multiple disks failed in a single group !"
! 278: " Aborting I/O operation.\n");
! 279: *createFunc = NULL;
! 280: return;
! 281: }
! 282: *createFunc = (type == RF_IO_TYPE_READ) ?
! 283: (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG :
! 284: (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
! 285:
! 286: if (type == RF_IO_TYPE_READ) {
! 287: if ((raidPtr->status[0] == rf_rs_degraded) ||
! 288: (raidPtr->status[0] == rf_rs_reconstructing))
! 289: /*
! 290: * Array status is degraded,
! 291: * implement workload shifting.
! 292: */
! 293: *createFunc = (RF_VoidFuncPtr)
! 294: rf_CreateRaidCDegradedReadDAG;
! 295: else
! 296: /*
! 297: * Array status not degraded,
! 298: * so use mirror partition dag.
! 299: */
! 300: *createFunc = (RF_VoidFuncPtr)
! 301: rf_CreateMirrorPartitionReadDAG;
! 302: } else
! 303: *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
! 304: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_chaindecluster.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe