The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/raidframe/rf_interdecluster.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: rf_interdecluster.c,v 1.9 2003/01/20 05:30:08 simonb Exp $     */
    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 #include <sys/cdefs.h>
   36 __KERNEL_RCSID(0, "$NetBSD: rf_interdecluster.c,v 1.9 2003/01/20 05:30:08 simonb Exp $");
   37 
   38 #include "rf_archs.h"
   39 
   40 #if RF_INCLUDE_INTERDECLUSTER > 0
   41 
   42 #include <dev/raidframe/raidframevar.h>
   43 
   44 #include "rf_raid.h"
   45 #include "rf_interdecluster.h"
   46 #include "rf_dag.h"
   47 #include "rf_dagutils.h"
   48 #include "rf_dagfuncs.h"
   49 #include "rf_general.h"
   50 #include "rf_utils.h"
   51 #include "rf_dagffrd.h"
   52 #include "rf_dagdegrd.h"
   53 #include "rf_dagffwr.h"
   54 #include "rf_dagdegwr.h"
   55 
   56 typedef struct RF_InterdeclusterConfigInfo_s {
   57         RF_RowCol_t **stripeIdentifier; /* filled in at config time and used
   58                                          * by IdentifyStripe */
   59         RF_StripeCount_t numSparingRegions;
   60         RF_StripeCount_t stripeUnitsPerSparingRegion;
   61         RF_SectorNum_t mirrorStripeOffset;
   62 }       RF_InterdeclusterConfigInfo_t;
   63 
   64 int 
   65 rf_ConfigureInterDecluster(
   66     RF_ShutdownList_t ** listp,
   67     RF_Raid_t * raidPtr,
   68     RF_Config_t * cfgPtr)
   69 {
   70         RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
   71         RF_StripeCount_t num_used_stripeUnitsPerDisk;
   72         RF_InterdeclusterConfigInfo_t *info;
   73         RF_RowCol_t i, tmp, SUs_per_region;
   74 
   75         /* create an Interleaved Declustering configuration structure */
   76         RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t), (RF_InterdeclusterConfigInfo_t *),
   77             raidPtr->cleanupList);
   78         if (info == NULL)
   79                 return (ENOMEM);
   80         layoutPtr->layoutSpecificInfo = (void *) info;
   81 
   82         /* fill in the config structure.  */
   83         SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1);
   84         info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2, raidPtr->cleanupList);
   85         if (info->stripeIdentifier == NULL)
   86                 return (ENOMEM);
   87         for (i = 0; i < SUs_per_region; i++) {
   88                 info->stripeIdentifier[i][0] = i / (raidPtr->numCol - 1);
   89                 tmp = i / raidPtr->numCol;
   90                 info->stripeIdentifier[i][1] = (i + 1 + tmp) % raidPtr->numCol;
   91         }
   92 
   93         /* no spare tables */
   94         RF_ASSERT(raidPtr->numRow == 1);
   95 
   96         /* fill in the remaining layout parameters */
   97 
   98         /* total number of stripes should a multiple of 2*numCol: Each sparing
   99          * region consists of 2*numCol stripes: n-1 primary copy, n-1
  100          * secondary copy and 2 for spare .. */
  101         num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk %
  102             (2 * raidPtr->numCol));
  103         info->numSparingRegions = num_used_stripeUnitsPerDisk / (2 * raidPtr->numCol);
  104         /* this is in fact the number of stripe units (that are primary data
  105          * copies) in the sparing region */
  106         info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1);
  107         info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol + 1);
  108         layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion;
  109         layoutPtr->numDataCol = 1;
  110         layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
  111         layoutPtr->numParityCol = 1;
  112 
  113         layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
  114 
  115         raidPtr->sectorsPerDisk =
  116             num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
  117 
  118         raidPtr->totalSectors =
  119             (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
  120 
  121         layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
  122 
  123         return (0);
  124 }
  125 
  126 int 
  127 rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t * raidPtr)
  128 {
  129         return (30);
  130 }
  131 
  132 RF_HeadSepLimit_t 
  133 rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t * raidPtr)
  134 {
  135         return (raidPtr->sectorsPerDisk);
  136 }
  137 
  138 RF_ReconUnitCount_t 
  139 rf_GetNumSpareRUsInterDecluster(
  140     RF_Raid_t * raidPtr)
  141 {
  142         RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
  143 
  144         return (2 * ((RF_ReconUnitCount_t) info->numSparingRegions));
  145         /* the layout uses two stripe units per disk as spare within each
  146          * sparing region */
  147 }
  148 /* Maps to the primary copy of the data, i.e. the first mirror pair */
  149 void 
  150 rf_MapSectorInterDecluster(
  151     RF_Raid_t * raidPtr,
  152     RF_RaidAddr_t raidSector,
  153     RF_RowCol_t * row,
  154     RF_RowCol_t * col,
  155     RF_SectorNum_t * diskSector,
  156     int remap)
  157 {
  158         RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
  159         RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
  160         RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk;
  161         RF_StripeNum_t sparing_region_id, index_within_region;
  162         int     col_before_remap;
  163 
  164         *row = 0;
  165         sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
  166         index_within_region = SUID % info->stripeUnitsPerSparingRegion;
  167         su_offset_into_disk = index_within_region % (raidPtr->numCol - 1);
  168         mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
  169         col_before_remap = index_within_region / (raidPtr->numCol - 1);
  170 
  171         if (!remap) {
  172                 *col = col_before_remap;
  173                 *diskSector = (su_offset_into_disk + ((raidPtr->numCol - 1) * sparing_region_id)) *
  174                     raidPtr->Layout.sectorsPerStripeUnit;
  175                 *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  176         } else {
  177                 /* remap sector to spare space... */
  178                 *diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
  179                 *diskSector += (raidPtr->numCol - 1) * raidPtr->Layout.sectorsPerStripeUnit;
  180                 *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  181                 *col = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
  182                 *col = (*col + 1) % raidPtr->numCol;
  183                 if (*col == col_before_remap)
  184                         *col = (*col + 1) % raidPtr->numCol;
  185         }
  186 }
  187 /* Maps to the second copy of the mirror pair. */
  188 void 
  189 rf_MapParityInterDecluster(
  190     RF_Raid_t * raidPtr,
  191     RF_RaidAddr_t raidSector,
  192     RF_RowCol_t * row,
  193     RF_RowCol_t * col,
  194     RF_SectorNum_t * diskSector,
  195     int remap)
  196 {
  197         RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
  198         RF_StripeNum_t sparing_region_id, index_within_region, mirror_su_offset_into_disk;
  199         RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
  200         int     col_before_remap;
  201 
  202         sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
  203         index_within_region = SUID % info->stripeUnitsPerSparingRegion;
  204         mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
  205         col_before_remap = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
  206 
  207         *row = 0;
  208         if (!remap) {
  209                 *col = col_before_remap;
  210                 *diskSector = info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit;
  211                 *diskSector += sparing_region_id * (raidPtr->numCol - 1) * raidPtr->Layout.sectorsPerStripeUnit;
  212                 *diskSector += mirror_su_offset_into_disk * raidPtr->Layout.sectorsPerStripeUnit;
  213                 *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  214         } else {
  215                 /* remap parity to spare space ... */
  216                 *diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
  217                 *diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
  218                 *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
  219                 *col = index_within_region / (raidPtr->numCol - 1);
  220                 *col = (*col + 1) % raidPtr->numCol;
  221                 if (*col == col_before_remap)
  222                         *col = (*col + 1) % raidPtr->numCol;
  223         }
  224 }
  225 
  226 void 
  227 rf_IdentifyStripeInterDecluster(
  228     RF_Raid_t * raidPtr,
  229     RF_RaidAddr_t addr,
  230     RF_RowCol_t ** diskids,
  231     RF_RowCol_t * outRow)
  232 {
  233         RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
  234         RF_StripeNum_t SUID;
  235 
  236         SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
  237         SUID = SUID % info->stripeUnitsPerSparingRegion;
  238 
  239         *outRow = 0;
  240         *diskids = info->stripeIdentifier[SUID];
  241 }
  242 
  243 void 
  244 rf_MapSIDToPSIDInterDecluster(
  245     RF_RaidLayout_t * layoutPtr,
  246     RF_StripeNum_t stripeID,
  247     RF_StripeNum_t * psID,
  248     RF_ReconUnitNum_t * which_ru)
  249 {
  250         *which_ru = 0;
  251         *psID = stripeID;
  252 }
  253 /******************************************************************************
  254  * select a graph to perform a single-stripe access
  255  *
  256  * Parameters:  raidPtr    - description of the physical array
  257  *              type       - type of operation (read or write) requested
  258  *              asmap      - logical & physical addresses for this access
  259  *              createFunc - name of function to use to create the graph
  260  *****************************************************************************/
  261 
  262 void 
  263 rf_RAIDIDagSelect(
  264     RF_Raid_t * raidPtr,
  265     RF_IoType_t type,
  266     RF_AccessStripeMap_t * asmap,
  267     RF_VoidFuncPtr * createFunc)
  268 {
  269         RF_ASSERT(RF_IO_IS_R_OR_W(type));
  270 
  271         if (asmap->numDataFailed + asmap->numParityFailed > 1) {
  272                 RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
  273                 *createFunc = NULL;
  274                 return;
  275         }
  276         *createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
  277         if (type == RF_IO_TYPE_READ) {
  278                 if (asmap->numDataFailed == 0)
  279                         *createFunc = (RF_VoidFuncPtr) rf_CreateMirrorPartitionReadDAG;
  280                 else
  281                         *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
  282         } else
  283                 *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
  284 }
  285 #endif /* RF_INCLUDE_INTERDECLUSTER > 0 */

Cache object: 6f1ebb4857275e0c14d06fa14c650423


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.