Import of CMU's RAIDframe via NetBSD.

1 files changed, 361 insertions, 0 deletions

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;
+}