From 5a29b52d01b420bb61a3112d2d44740a0fa99601 Mon Sep 17 00:00:00 2001 From: Niklas Hallqvist Date: Mon, 11 Jan 1999 14:29:56 +0000 Subject: Import of CMU's RAIDframe via NetBSD. --- sys/dev/raidframe/rf_interdecluster.c | 361 ++++++++++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 sys/dev/raidframe/rf_interdecluster.c (limited to 'sys/dev/raidframe/rf_interdecluster.c') diff --git a/sys/dev/raidframe/rf_interdecluster.c b/sys/dev/raidframe/rf_interdecluster.c new file mode 100644 index 00000000000..3ce97d075ee --- /dev/null +++ b/sys/dev/raidframe/rf_interdecluster.c @@ -0,0 +1,361 @@ +/* $OpenBSD: rf_interdecluster.c,v 1.1 1999/01/11 14:29:26 niklas Exp $ */ +/* $NetBSD: rf_interdecluster.c,v 1.1 1998/11/13 04:20:30 oster Exp $ */ +/* + * Copyright (c) 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Khalil Amiri + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +/************************************************************ + * + * rf_interdecluster.c -- implements interleaved declustering + * + ************************************************************/ + +/* : + * Log: rf_interdecluster.c,v + * Revision 1.24 1996/08/02 13:20:38 jimz + * get rid of bogus (long) casts + * + * Revision 1.23 1996/07/31 16:56:18 jimz + * dataBytesPerStripe, sectorsPerDisk init arch-indep. + * + * Revision 1.22 1996/07/29 14:05:12 jimz + * fix numPUs/numRUs confusion (everything is now numRUs) + * clean up some commenting, return values + * + * Revision 1.21 1996/07/22 19:52:16 jimz + * switched node params to RF_DagParam_t, a union of + * a 64-bit int and a void *, for better portability + * attempted hpux port, but failed partway through for + * lack of a single C compiler capable of compiling all + * source files + * + * Revision 1.20 1996/07/18 22:57:14 jimz + * port simulator to AIX + * + * Revision 1.19 1996/07/13 00:00:59 jimz + * sanitized generalized reconstruction architecture + * cleaned up head sep, rbuf problems + * + * Revision 1.18 1996/06/19 17:53:48 jimz + * move GetNumSparePUs, InstallSpareTable ops into layout switch + * + * Revision 1.17 1996/06/11 15:17:55 wvcii + * added include of rf_interdecluster.h + * fixed parameter list of rf_ConfigureInterDecluster + * fixed return type of rf_GetNumSparePUsInterDecluster + * removed include of rf_raid1.h + * + * Revision 1.16 1996/06/11 08:55:15 jimz + * improved error-checking at configuration time + * + * Revision 1.15 1996/06/10 11:55:47 jimz + * Straightened out some per-array/not-per-array distinctions, fixed + * a couple bugs related to confusion. Added shutdown lists. Removed + * layout shutdown function (now subsumed by shutdown lists). + * + * Revision 1.14 1996/06/07 22:26:27 jimz + * type-ify which_ru (RF_ReconUnitNum_t) + * + * Revision 1.13 1996/06/07 21:33:04 jimz + * begin using consistent types for sector numbers, + * stripe numbers, row+col numbers, recon unit numbers + * + * Revision 1.12 1996/06/06 18:41:48 jimz + * add interleaved declustering dag selection + * + * Revision 1.11 1996/06/02 17:31:48 jimz + * Moved a lot of global stuff into array structure, where it belongs. + * Fixed up paritylogging, pss modules in this manner. Some general + * code cleanup. Removed lots of dead code, some dead files. + * + * Revision 1.10 1996/05/31 22:26:54 jimz + * fix a lot of mapping problems, memory allocation problems + * found some weird lock issues, fixed 'em + * more code cleanup + * + * Revision 1.9 1996/05/31 05:03:01 amiri + * fixed a bug related to sparing layout. + * + * Revision 1.8 1996/05/27 18:56:37 jimz + * more code cleanup + * better typing + * compiles in all 3 environments + * + * Revision 1.7 1996/05/24 01:59:45 jimz + * another checkpoint in code cleanup for release + * time to sync kernel tree + * + * Revision 1.6 1996/05/23 00:33:23 jimz + * code cleanup: move all debug decls to rf_options.c, all extern + * debug decls to rf_options.h, all debug vars preceded by rf_ + * + * Revision 1.5 1996/05/18 19:51:34 jimz + * major code cleanup- fix syntax, make some types consistent, + * add prototypes, clean out dead code, et cetera + * + * Revision 1.4 1996/05/03 19:50:38 wvcii + * removed include of rf_redstripe.h + * fixed change log parameters in header + * + */ + +#include "rf_types.h" +#include "rf_raid.h" +#include "rf_interdecluster.h" +#include "rf_dag.h" +#include "rf_dagutils.h" +#include "rf_dagfuncs.h" +#include "rf_threadid.h" +#include "rf_general.h" +#include "rf_utils.h" +#include "rf_dagffrd.h" +#include "rf_dagdegrd.h" +#include "rf_dagffwr.h" +#include "rf_dagdegwr.h" + +typedef struct RF_InterdeclusterConfigInfo_s { + RF_RowCol_t **stripeIdentifier; /* filled in at config time + * and used by IdentifyStripe */ + RF_StripeCount_t numSparingRegions; + RF_StripeCount_t stripeUnitsPerSparingRegion; + RF_SectorNum_t mirrorStripeOffset; +} RF_InterdeclusterConfigInfo_t; + +int rf_ConfigureInterDecluster( + RF_ShutdownList_t **listp, + RF_Raid_t *raidPtr, + RF_Config_t *cfgPtr) +{ + RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; + RF_StripeCount_t num_used_stripeUnitsPerDisk; + RF_InterdeclusterConfigInfo_t *info; + RF_RowCol_t i, tmp, SUs_per_region; + + /* create an Interleaved Declustering configuration structure */ + RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t), (RF_InterdeclusterConfigInfo_t *), + raidPtr->cleanupList); + if (info == NULL) + return(ENOMEM); + layoutPtr->layoutSpecificInfo = (void *) info; + + /* fill in the config structure. */ + SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1); + info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2 , raidPtr->cleanupList); + if (info->stripeIdentifier == NULL) + return(ENOMEM); + for (i=0; i< SUs_per_region; i++) { + info->stripeIdentifier[i][0] = i / (raidPtr->numCol-1); + tmp = i / raidPtr->numCol; + info->stripeIdentifier[i][1] = (i+1+tmp) % raidPtr->numCol; + } + + /* no spare tables */ + RF_ASSERT(raidPtr->numRow == 1); + + /* fill in the remaining layout parameters */ + + /* total number of stripes should a multiple of 2*numCol: Each sparing region consists of + 2*numCol stripes: n-1 primary copy, n-1 secondary copy and 2 for spare .. */ + num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk % + (2*raidPtr->numCol) ); + info->numSparingRegions = num_used_stripeUnitsPerDisk / (2*raidPtr->numCol); + /* this is in fact the number of stripe units (that are primary data copies) in the sparing region */ + info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1); + info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol+1); + layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion; + layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector; + layoutPtr->numDataCol = 1; + layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit; + layoutPtr->numParityCol = 1; + + layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk; + + raidPtr->sectorsPerDisk = + num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit; + + raidPtr->totalSectors = + (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit; + + layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit; + + return(0); +} + +int rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr) +{ + return(30); +} + +RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr) +{ + return(raidPtr->sectorsPerDisk); +} + +RF_ReconUnitCount_t rf_GetNumSpareRUsInterDecluster( + RF_Raid_t *raidPtr) +{ + RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo; + + return ( 2 * ((RF_ReconUnitCount_t) info->numSparingRegions) ); + /* the layout uses two stripe units per disk as spare within each sparing region */ +} + +/* Maps to the primary copy of the data, i.e. the first mirror pair */ +void rf_MapSectorInterDecluster( + RF_Raid_t *raidPtr, + RF_RaidAddr_t raidSector, + RF_RowCol_t *row, + RF_RowCol_t *col, + RF_SectorNum_t *diskSector, + int remap) +{ + RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo; + RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit; + RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk; + RF_StripeNum_t sparing_region_id, index_within_region; + int col_before_remap; + + *row = 0; + sparing_region_id = SUID / info->stripeUnitsPerSparingRegion; + index_within_region = SUID % info->stripeUnitsPerSparingRegion; + su_offset_into_disk = index_within_region % (raidPtr->numCol-1); + mirror_su_offset_into_disk = index_within_region / raidPtr->numCol; + col_before_remap = index_within_region / (raidPtr->numCol-1); + + if (!remap) { + *col = col_before_remap;; + *diskSector = ( su_offset_into_disk + ( (raidPtr->numCol-1) * sparing_region_id) ) * + raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit); + } + else { + /* remap sector to spare space...*/ + *diskSector = sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidPtr->numCol-1) * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit); + *col = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol; + *col = (*col + 1) % raidPtr->numCol; + if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol; + } +} + +/* Maps to the second copy of the mirror pair. */ +void rf_MapParityInterDecluster( + RF_Raid_t *raidPtr, + RF_RaidAddr_t raidSector, + RF_RowCol_t *row, + RF_RowCol_t *col, + RF_SectorNum_t *diskSector, + int remap) +{ + RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo; + RF_StripeNum_t sparing_region_id, index_within_region, mirror_su_offset_into_disk; + RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit; + int col_before_remap; + + sparing_region_id = SUID / info->stripeUnitsPerSparingRegion; + index_within_region = SUID % info->stripeUnitsPerSparingRegion; + mirror_su_offset_into_disk = index_within_region / raidPtr->numCol; + col_before_remap = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol; + + *row = 0; + if (!remap) { + *col = col_before_remap; + *diskSector = info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += sparing_region_id * (raidPtr->numCol-1) * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += mirror_su_offset_into_disk * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit); + } + else { + /* remap parity to spare space ... */ + *diskSector = sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit; + *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit); + *col = index_within_region / (raidPtr->numCol-1); + *col = (*col + 1) % raidPtr->numCol; + if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol; + } +} + +void rf_IdentifyStripeInterDecluster( + RF_Raid_t *raidPtr, + RF_RaidAddr_t addr, + RF_RowCol_t **diskids, + RF_RowCol_t *outRow) +{ + RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo; + RF_StripeNum_t SUID; + + SUID = addr / raidPtr->Layout.sectorsPerStripeUnit; + SUID = SUID % info->stripeUnitsPerSparingRegion; + + *outRow = 0; + *diskids = info->stripeIdentifier[ SUID ]; +} + +void rf_MapSIDToPSIDInterDecluster( + RF_RaidLayout_t *layoutPtr, + RF_StripeNum_t stripeID, + RF_StripeNum_t *psID, + RF_ReconUnitNum_t *which_ru) +{ + *which_ru = 0; + *psID = stripeID; +} + +/****************************************************************************** + * select a graph to perform a single-stripe access + * + * Parameters: raidPtr - description of the physical array + * type - type of operation (read or write) requested + * asmap - logical & physical addresses for this access + * createFunc - name of function to use to create the graph + *****************************************************************************/ + +void rf_RAIDIDagSelect( + RF_Raid_t *raidPtr, + RF_IoType_t type, + RF_AccessStripeMap_t *asmap, + RF_VoidFuncPtr *createFunc) +{ + RF_ASSERT(RF_IO_IS_R_OR_W(type)); + + if (asmap->numDataFailed + asmap->numParityFailed > 1) { + RF_ERRORMSG("Multiple disks failed in a single group! Aborting I/O operation.\n"); + *createFunc = NULL; + return; + } + + *createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr)rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG; + if (type == RF_IO_TYPE_READ) { + if (asmap->numDataFailed == 0) + *createFunc = (RF_VoidFuncPtr)rf_CreateMirrorPartitionReadDAG; + else + *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneDegradedReadDAG; + } + else + *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG; +} -- cgit v1.2.3