sys/dev/raidframe/rf_raid0.c

   1 /*      $NetBSD: rf_raid0.c,v 1.4 2000/01/07 03:41:02 oster Exp $       */
   2
   3 #include <sys/cdefs.h>
   4 __FBSDID("$FreeBSD$");
   5 /*
   6  * Copyright (c) 1995 Carnegie-Mellon University.
   7  * All rights reserved.
   8  *
   9  * Author: Mark Holland
  10  *
  11  * Permission to use, copy, modify and distribute this software and
  12  * its documentation is hereby granted, provided that both the copyright
  13  * notice and this permission notice appear in all copies of the
  14  * software, derivative works or modified versions, and any portions
  15  * thereof, and that both notices appear in supporting documentation.
  16  *
  17  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  18  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  19  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  20  *
  21  * Carnegie Mellon requests users of this software to return to
  22  *
  23  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  24  *  School of Computer Science
  25  *  Carnegie Mellon University
  26  *  Pittsburgh PA 15213-3890
  27  *
  28  * any improvements or extensions that they make and grant Carnegie the
  29  * rights to redistribute these changes.
  30  */
  31
  32 /***************************************
  33  *
  34  * rf_raid0.c -- implements RAID Level 0
  35  *
  36  ***************************************/
  37
  38 #include <dev/raidframe/rf_types.h>
  39 #include <dev/raidframe/rf_raid.h>
  40 #include <dev/raidframe/rf_raid0.h>
  41 #include <dev/raidframe/rf_dag.h>
  42 #include <dev/raidframe/rf_dagffrd.h>
  43 #include <dev/raidframe/rf_dagffwr.h>
  44 #include <dev/raidframe/rf_dagutils.h>
  45 #include <dev/raidframe/rf_dagfuncs.h>
  46 #include <dev/raidframe/rf_general.h>
  47 #include <dev/raidframe/rf_configure.h>
  48 #include <dev/raidframe/rf_parityscan.h>
  49
  50 typedef struct RF_Raid0ConfigInfo_s {
  51         RF_RowCol_t *stripeIdentifier;
  52 }       RF_Raid0ConfigInfo_t;
  53
  54 int
  55 rf_ConfigureRAID0(
  56     RF_ShutdownList_t ** listp,
  57     RF_Raid_t * raidPtr,
  58     RF_Config_t * cfgPtr)
  59 {
  60         RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
  61         RF_Raid0ConfigInfo_t *info;
  62         RF_RowCol_t i;
  63
  64         /* create a RAID level 0 configuration structure */
  65         RF_MallocAndAdd(info, sizeof(RF_Raid0ConfigInfo_t), (RF_Raid0ConfigInfo_t *), raidPtr->cleanupList);
  66         if (info == NULL)
  67                 return (ENOMEM);
  68         layoutPtr->layoutSpecificInfo = (void *) info;
  69
  70         RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol * sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
  71         if (info->stripeIdentifier == NULL)
  72                 return (ENOMEM);
  73         for (i = 0; i < raidPtr->numCol; i++)
  74                 info->stripeIdentifier[i] = i;
  75
  76         RF_ASSERT(raidPtr->numRow == 1);
  77         raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
  78         layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
  79         layoutPtr->dataSectorsPerStripe = raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
  80         layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
  81         layoutPtr->numDataCol = raidPtr->numCol;
  82         layoutPtr->numParityCol = 0;
  83         return (0);
  84 }
  85
  86 void
  87 rf_MapSectorRAID0(
  88     RF_Raid_t * raidPtr,
  89     RF_RaidAddr_t raidSector,
  90     RF_RowCol_t * row,
  91     RF_RowCol_t * col,
  92     RF_SectorNum_t * diskSector,
  93     int remap)
  94 {
  95         RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
  96         *row = 0;
  97         *col = SUID % raidPtr->numCol;
  98         *diskSector = (SUID / raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit +
  99             (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 100 }
 101
 102 void
 103 rf_MapParityRAID0(
 104     RF_Raid_t * raidPtr,
 105     RF_RaidAddr_t raidSector,
 106     RF_RowCol_t * row,
 107     RF_RowCol_t * col,
 108     RF_SectorNum_t * diskSector,
 109     int remap)
 110 {
 111         *row = *col = 0;
 112         *diskSector = 0;
 113 }
 114
 115 void
 116 rf_IdentifyStripeRAID0(
 117     RF_Raid_t * raidPtr,
 118     RF_RaidAddr_t addr,
 119     RF_RowCol_t ** diskids,
 120     RF_RowCol_t * outRow)
 121 {
 122         RF_Raid0ConfigInfo_t *info;
 123
 124         info = raidPtr->Layout.layoutSpecificInfo;
 125         *diskids = info->stripeIdentifier;
 126         *outRow = 0;
 127 }
 128
 129 void
 130 rf_MapSIDToPSIDRAID0(
 131     RF_RaidLayout_t * layoutPtr,
 132     RF_StripeNum_t stripeID,
 133     RF_StripeNum_t * psID,
 134     RF_ReconUnitNum_t * which_ru)
 135 {
 136         *which_ru = 0;
 137         *psID = stripeID;
 138 }
 139
 140 void
 141 rf_RAID0DagSelect(
 142     RF_Raid_t * raidPtr,
 143     RF_IoType_t type,
 144     RF_AccessStripeMap_t * asmap,
 145     RF_VoidFuncPtr * createFunc)
 146 {
 147         *createFunc = ((type == RF_IO_TYPE_READ) ?
 148             (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr) rf_CreateRAID0WriteDAG);
 149 }
 150
 151 int
 152 rf_VerifyParityRAID0(
 153     RF_Raid_t * raidPtr,
 154     RF_RaidAddr_t raidAddr,
 155     RF_PhysDiskAddr_t * parityPDA,
 156     int correct_it,
 157     RF_RaidAccessFlags_t flags)
 158 {
 159         /*
 160          * No parity is always okay.
 161          */
 162         return (RF_PARITY_OKAY);
 163 }