Return to rf_raid0.c CVS log

Up to [local] / sys / dev / raidframe

Annotation of sys/dev/raidframe/rf_raid0.c, Revision 1.1

1.1     ! nbrk        1: /*     $OpenBSD: rf_raid0.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $     */
        !             2: /*     $NetBSD: rf_raid0.c,v 1.4 2000/01/07 03:41:02 oster Exp $       */
        !             3:
        !             4: /*
        !             5:  * Copyright (c) 1995 Carnegie-Mellon University.
        !             6:  * All rights reserved.
        !             7:  *
        !             8:  * Author: Mark Holland
        !             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_raid0.c -- Implements RAID Level 0.
        !            34:  *
        !            35:  *****************************************/
        !            36:
        !            37: #include "rf_types.h"
        !            38: #include "rf_raid.h"
        !            39: #include "rf_raid0.h"
        !            40: #include "rf_dag.h"
        !            41: #include "rf_dagffrd.h"
        !            42: #include "rf_dagffwr.h"
        !            43: #include "rf_dagutils.h"
        !            44: #include "rf_dagfuncs.h"
        !            45: #include "rf_general.h"
        !            46: #include "rf_configure.h"
        !            47: #include "rf_parityscan.h"
        !            48:
        !            49: typedef struct RF_Raid0ConfigInfo_s {
        !            50:        RF_RowCol_t *stripeIdentifier;
        !            51: } RF_Raid0ConfigInfo_t;
        !            52:
        !            53: int
        !            54: rf_ConfigureRAID0(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
        !            55:     RF_Config_t *cfgPtr)
        !            56: {
        !            57:        RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
        !            58:        RF_Raid0ConfigInfo_t *info;
        !            59:        RF_RowCol_t i;
        !            60:
        !            61:        /* Create a RAID level 0 configuration structure. */
        !            62:        RF_MallocAndAdd(info, sizeof(RF_Raid0ConfigInfo_t),
        !            63:            (RF_Raid0ConfigInfo_t *), raidPtr->cleanupList);
        !            64:        if (info == NULL)
        !            65:                return (ENOMEM);
        !            66:        layoutPtr->layoutSpecificInfo = (void *) info;
        !            67:
        !            68:        RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol *
        !            69:            sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
        !            70:        if (info->stripeIdentifier == NULL)
        !            71:                return (ENOMEM);
        !            72:        for (i = 0; i < raidPtr->numCol; i++)
        !            73:                info->stripeIdentifier[i] = i;
        !            74:
        !            75:        RF_ASSERT(raidPtr->numRow == 1);
        !            76:        raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
        !            77:            raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
        !            78:        layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
        !            79:        layoutPtr->dataSectorsPerStripe = raidPtr->numCol *
        !            80:            layoutPtr->sectorsPerStripeUnit;
        !            81:        layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
        !            82:            raidPtr->logBytesPerSector;
        !            83:        layoutPtr->numDataCol = raidPtr->numCol;
        !            84:        layoutPtr->numParityCol = 0;
        !            85:        return (0);
        !            86: }
        !            87:
        !            88: void
        !            89: rf_MapSectorRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
        !            90:     RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
        !            91: {
        !            92:        RF_StripeNum_t SUID =
        !            93:            raidSector / raidPtr->Layout.sectorsPerStripeUnit;
        !            94:        *row = 0;
        !            95:        *col = SUID % raidPtr->numCol;
        !            96:        *diskSector = (SUID / raidPtr->numCol) *
        !            97:            raidPtr->Layout.sectorsPerStripeUnit +
        !            98:            (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
        !            99: }
        !           100:
        !           101: void
        !           102: rf_MapParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
        !           103:     RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
        !           104: {
        !           105:        *row = *col = 0;
        !           106:        *diskSector = 0;
        !           107: }
        !           108:
        !           109: void
        !           110: rf_IdentifyStripeRAID0( RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
        !           111:     RF_RowCol_t **diskids, RF_RowCol_t *outRow)
        !           112: {
        !           113:        RF_Raid0ConfigInfo_t *info;
        !           114:
        !           115:        info = raidPtr->Layout.layoutSpecificInfo;
        !           116:        *diskids = info->stripeIdentifier;
        !           117:        *outRow = 0;
        !           118: }
        !           119:
        !           120: void
        !           121: rf_MapSIDToPSIDRAID0(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
        !           122:     RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
        !           123: {
        !           124:        *which_ru = 0;
        !           125:        *psID = stripeID;
        !           126: }
        !           127:
        !           128: void
        !           129: rf_RAID0DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
        !           130:     RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
        !           131: {
        !           132:        *createFunc = ((type == RF_IO_TYPE_READ) ?
        !           133:            (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG :
        !           134:            (RF_VoidFuncPtr) rf_CreateRAID0WriteDAG);
        !           135: }
        !           136:
        !           137: int
        !           138: rf_VerifyParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
        !           139:     RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
        !           140: {
        !           141:        /*
        !           142:         * No parity is always okay.
        !           143:         */
        !           144:        return (RF_PARITY_OKAY);
        !           145: }