![[BACK]](/icons/back.gif){kind=icon}
Return to rf_layout.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_layout.h CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_layout.h,v 1.5 2002/12/16 07:01:04 tdeval Exp $ */
! 2: /* $NetBSD: rf_layout.h,v 1.4 2000/05/23 00:44:38 thorpej 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: * rf_layout.h -- Header file defining layout data structures.
! 33: */
! 34:
! 35: #ifndef _RF__RF_LAYOUT_H_
! 36: #define _RF__RF_LAYOUT_H_
! 37:
! 38: #include "rf_types.h"
! 39: #include "rf_archs.h"
! 40: #include "rf_alloclist.h"
! 41:
! 42: #ifndef _KERNEL
! 43: #include <stdio.h>
! 44: #endif
! 45:
! 46: /*****************************************************************************
! 47: *
! 48: * This structure identifies all layout-specific operations and parameters.
! 49: *
! 50: *****************************************************************************/
! 51:
! 52: typedef struct RF_LayoutSW_s {
! 53: RF_ParityConfig_t parityConfig;
! 54: const char *configName;
! 55:
! 56: #ifndef _KERNEL
! 57: /* Layout-specific parsing. */
! 58: int (*MakeLayoutSpecific)
! 59: (FILE *, RF_Config_t *, void *);
! 60: void *makeLayoutSpecificArg;
! 61: #endif /* !_KERNEL */
! 62:
! 63: #if RF_UTILITY == 0
! 64: /* Initialization routine. */
! 65: int (*Configure)
! 66: (RF_ShutdownList_t **, RF_Raid_t *,
! 67: RF_Config_t *);
! 68:
! 69: /* Routine to map RAID sector address -> physical (row, col, offset). */
! 70: void (*MapSector)
! 71: (RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
! 72: RF_RowCol_t *, RF_SectorNum_t *, int);
! 73:
! 74: /*
! 75: * Routine to map RAID sector address -> physical (r,c,o) of parity
! 76: * unit.
! 77: */
! 78: void (*MapParity)
! 79: (RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
! 80: RF_RowCol_t *, RF_SectorNum_t *, int);
! 81:
! 82: /* Routine to map RAID sector address -> physical (r,c,o) of Q unit. */
! 83: void (*MapQ)
! 84: (RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
! 85: RF_RowCol_t *, RF_SectorNum_t *, int);
! 86:
! 87: /* Routine to identify the disks comprising a stripe. */
! 88: void (*IdentifyStripe)
! 89: (RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t **,
! 90: RF_RowCol_t *);
! 91:
! 92: /* Routine to select a dag. */
! 93: void (*SelectionFunc)
! 94: (RF_Raid_t *, RF_IoType_t,
! 95: RF_AccessStripeMap_t *, RF_VoidFuncPtr *);
! 96: #if 0
! 97: void (**createFunc)
! 98: (RF_Raid_t *, RF_AccessStripeMap_t *,
! 99: RF_DagHeader_t *, void *,
! 100: RF_RaidAccessFlags_t, RF_AllocListElem_t *);
! 101: #endif
! 102:
! 103: /*
! 104: * Map a stripe ID to a parity stripe ID. This is typically the
! 105: * identity mapping.
! 106: */
! 107: void (*MapSIDToPSID)
! 108: (RF_RaidLayout_t *, RF_StripeNum_t,
! 109: RF_StripeNum_t *, RF_ReconUnitNum_t *);
! 110:
! 111: /* Get default head separation limit (may be NULL). */
! 112: RF_HeadSepLimit_t (*GetDefaultHeadSepLimit) (RF_Raid_t *);
! 113:
! 114: /* Get default num recon buffers (may be NULL). */
! 115: int (*GetDefaultNumFloatingReconBuffers)
! 116: (RF_Raid_t *);
! 117:
! 118: /* Get number of spare recon units (may be NULL). */
! 119: RF_ReconUnitCount_t (*GetNumSpareRUs) (RF_Raid_t *);
! 120:
! 121: /* Spare table installation (may be NULL). */
! 122: int (*InstallSpareTable)
! 123: (RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
! 124:
! 125: /* Recon buffer submission function. */
! 126: int (*SubmitReconBuffer)
! 127: (RF_ReconBuffer_t *, int, int);
! 128:
! 129: /*
! 130: * Verify that parity information for a stripe is correct.
! 131: * See rf_parityscan.h for return vals.
! 132: */
! 133: int (*VerifyParity)
! 134: (RF_Raid_t *, RF_RaidAddr_t,
! 135: RF_PhysDiskAddr_t *, int,
! 136: RF_RaidAccessFlags_t);
! 137:
! 138: /* Number of faults tolerated by this mapping. */
! 139: int faultsTolerated;
! 140:
! 141: /*
! 142: * States to step through in an access. Must end with "LastState". The
! 143: * default is DefaultStates in rf_layout.c .
! 144: */
! 145: RF_AccessState_t *states;
! 146:
! 147: RF_AccessStripeMapFlags_t flags;
! 148: #endif /* RF_UTILITY == 0 */
! 149: } RF_LayoutSW_t;
! 150:
! 151: /* Enables remapping to spare location under dist sparing. */
! 152: #define RF_REMAP 1
! 153: #define RF_DONT_REMAP 0
! 154:
! 155: /*
! 156: * Flags values for RF_AccessStripeMapFlags_t.
! 157: */
! 158: #define RF_NO_STRIPE_LOCKS 0x0001 /* Suppress stripe locks. */
! 159: #define RF_DISTRIBUTE_SPARE 0x0002 /*
! 160: * Distribute spare space in
! 161: * archs that support it.
! 162: */
! 163: #define RF_BD_DECLUSTERED 0x0004 /*
! 164: * Declustering uses block
! 165: * designs.
! 166: */
! 167:
! 168: /*************************************************************************
! 169: *
! 170: * This structure forms the layout component of the main Raid
! 171: * structure. It describes everything needed to define and perform
! 172: * the mapping of logical RAID addresses <-> physical disk addresses.
! 173: *
! 174: *************************************************************************/
! 175: struct RF_RaidLayout_s {
! 176: /* Configuration parameters. */
! 177: RF_SectorCount_t sectorsPerStripeUnit;
! 178: /*
! 179: * Number of sectors in one
! 180: * stripe unit.
! 181: */
! 182: RF_StripeCount_t SUsPerPU; /*
! 183: * Stripe units per parity unit.
! 184: */
! 185: RF_StripeCount_t SUsPerRU; /*
! 186: * Stripe units per
! 187: * reconstruction unit.
! 188: */
! 189:
! 190: /*
! 191: * Redundant-but-useful info computed from the above, used in all
! 192: * layouts.
! 193: */
! 194: RF_StripeCount_t numStripe; /*
! 195: * Total number of stripes
! 196: * in the array.
! 197: */
! 198: RF_SectorCount_t dataSectorsPerStripe;
! 199: RF_StripeCount_t dataStripeUnitsPerDisk;
! 200: u_int bytesPerStripeUnit;
! 201: u_int dataBytesPerStripe;
! 202: RF_StripeCount_t numDataCol; /*
! 203: * Number of SUs of data per
! 204: * stripe.
! 205: * (name here is a la RAID4)
! 206: */
! 207: RF_StripeCount_t numParityCol; /*
! 208: * Number of SUs of parity
! 209: * per stripe.
! 210: * Always 1 for now.
! 211: */
! 212: RF_StripeCount_t numParityLogCol;
! 213: /*
! 214: * Number of SUs of parity log
! 215: * per stripe.
! 216: * Always 1 for now.
! 217: */
! 218: RF_StripeCount_t stripeUnitsPerDisk;
! 219:
! 220: RF_LayoutSW_t *map; /*
! 221: * Pointer to struct holding
! 222: * mapping fns and information.
! 223: */
! 224: void *layoutSpecificInfo;
! 225: /* Pointer to a struct holding
! 226: * layout-specific params.
! 227: */
! 228: };
! 229:
! 230: /*****************************************************************************
! 231: *
! 232: * The mapping code returns a pointer to a list of AccessStripeMap
! 233: * structures, which describes all the mapping information about an access.
! 234: * The list contains one AccessStripeMap structure per stripe touched by
! 235: * the access. Each element in the list contains a stripe identifier and
! 236: * a pointer to a list of PhysDiskAddr structuress. Each element in this
! 237: * latter list describes the physical location of a stripe unit accessed
! 238: * within the corresponding stripe.
! 239: *
! 240: *****************************************************************************/
! 241:
! 242: #define RF_PDA_TYPE_DATA 0
! 243: #define RF_PDA_TYPE_PARITY 1
! 244: #define RF_PDA_TYPE_Q 2
! 245:
! 246: struct RF_PhysDiskAddr_s {
! 247: RF_RowCol_t row, col; /* Disk identifier. */
! 248: RF_SectorNum_t startSector; /*
! 249: * Sector offset into the disk.
! 250: */
! 251: RF_SectorCount_t numSector; /*
! 252: * Number of sectors accessed.
! 253: */
! 254: int type; /*
! 255: * Used by higher levels:
! 256: * currently data, parity,
! 257: * or q.
! 258: */
! 259: caddr_t bufPtr; /*
! 260: * Pointer to buffer
! 261: * supplying/receiving data.
! 262: */
! 263: RF_RaidAddr_t raidAddress; /*
! 264: * Raid address corresponding
! 265: * to this physical disk
! 266: * address.
! 267: */
! 268: RF_PhysDiskAddr_t *next;
! 269: };
! 270: #define RF_MAX_FAILED_PDA RF_MAXCOL
! 271:
! 272: struct RF_AccessStripeMap_s {
! 273: RF_StripeNum_t stripeID; /* The stripe index. */
! 274: RF_RaidAddr_t raidAddress; /*
! 275: * The starting raid address
! 276: * within this stripe.
! 277: */
! 278: RF_RaidAddr_t endRaidAddress;/*
! 279: * Raid address one sector past
! 280: * the end of the access.
! 281: */
! 282: RF_SectorCount_t totalSectorsAccessed;
! 283: /*
! 284: * Total num sectors
! 285: * identified in physInfo list.
! 286: */
! 287: RF_StripeCount_t numStripeUnitsAccessed;
! 288: /*
! 289: * Total num elements in
! 290: * physInfo list.
! 291: */
! 292: int numDataFailed; /*
! 293: * Number of failed data disks
! 294: * accessed.
! 295: */
! 296: int numParityFailed;
! 297: /*
! 298: * Number of failed parity
! 299: * disks accessed (0 or 1).
! 300: */
! 301: int numQFailed; /*
! 302: * Number of failed Q units
! 303: * accessed (0 or 1).
! 304: */
! 305: RF_AccessStripeMapFlags_t flags; /* Various flags. */
! 306: #if 0
! 307: RF_PhysDiskAddr_t *failedPDA; /*
! 308: * Points to the PDA that
! 309: * has failed.
! 310: */
! 311: RF_PhysDiskAddr_t *failedPDAtwo; /*
! 312: * Points to the second PDA
! 313: * that has failed, if any.
! 314: */
! 315: #else
! 316: int numFailedPDAs; /*
! 317: * Number of failed phys addrs.
! 318: */
! 319: RF_PhysDiskAddr_t *failedPDAs[RF_MAX_FAILED_PDA];
! 320: /*
! 321: * Array of failed phys addrs.
! 322: */
! 323: #endif
! 324: RF_PhysDiskAddr_t *physInfo; /*
! 325: * A list of PhysDiskAddr
! 326: * structs.
! 327: */
! 328: RF_PhysDiskAddr_t *parityInfo; /*
! 329: * List of physical addrs for
! 330: * the parity (P of P + Q).
! 331: */
! 332: RF_PhysDiskAddr_t *qInfo; /*
! 333: * List of physical addrs for
! 334: * the Q of P + Q.
! 335: */
! 336: RF_LockReqDesc_t lockReqDesc; /* Used for stripe locking. */
! 337: RF_RowCol_t origRow; /*
! 338: * The original row: we may
! 339: * redirect the acc to a
! 340: * different row.
! 341: */
! 342: RF_AccessStripeMap_t *next;
! 343: };
! 344: /* Flag values. */
! 345: #define RF_ASM_REDIR_LARGE_WRITE 0x00000001 /*
! 346: * Allows large-write
! 347: * creation code to
! 348: * redirect failed
! 349: * accs.
! 350: */
! 351: #define RF_ASM_BAILOUT_DAG_USED 0x00000002 /*
! 352: * Allows us to detect
! 353: * recursive calls to
! 354: * the bailout write
! 355: * dag.
! 356: */
! 357: #define RF_ASM_FLAGS_LOCK_TRIED 0x00000004 /*
! 358: * We've acquired the
! 359: * lock on the first
! 360: * parity range in
! 361: * this parity stripe.
! 362: */
! 363: #define RF_ASM_FLAGS_LOCK_TRIED2 0x00000008 /*
! 364: * we've acquired the
! 365: * lock on the 2nd
! 366: * parity range in this
! 367: * parity stripe.
! 368: */
! 369: #define RF_ASM_FLAGS_FORCE_TRIED 0x00000010 /*
! 370: * We've done the
! 371: * force-recon call on
! 372: * this parity stripe.
! 373: */
! 374: #define RF_ASM_FLAGS_RECON_BLOCKED 0x00000020 /*
! 375: * We blocked recon
! 376: * => we must unblock
! 377: * it later.
! 378: */
! 379:
! 380: struct RF_AccessStripeMapHeader_s {
! 381: RF_StripeCount_t numStripes; /*
! 382: * Total number of stripes
! 383: * touched by this access.
! 384: */
! 385: RF_AccessStripeMap_t *stripeMap; /*
! 386: * Pointer to the actual map.
! 387: * Also used for making lists.
! 388: */
! 389: RF_AccessStripeMapHeader_t *next;
! 390: };
! 391:
! 392:
! 393: /*****************************************************************************
! 394: *
! 395: * Various routines mapping addresses in the RAID address space. These work
! 396: * across all layouts. DON'T PUT ANY LAYOUT-SPECIFIC CODE HERE.
! 397: *
! 398: *****************************************************************************/
! 399:
! 400: /* Return the identifier of the stripe containing the given address. */
! 401: #define rf_RaidAddressToStripeID(_layoutPtr_,_addr_) \
! 402: (((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) / \
! 403: (_layoutPtr_)->numDataCol)
! 404:
! 405: /* Return the raid address of the start of the indicates stripe ID. */
! 406: #define rf_StripeIDToRaidAddress(_layoutPtr_,_sid_) \
! 407: (((_sid_) * (_layoutPtr_)->sectorsPerStripeUnit) * \
! 408: (_layoutPtr_)->numDataCol)
! 409:
! 410: /* Return the identifier of the stripe containing the given stripe unit ID. */
! 411: #define rf_StripeUnitIDToStripeID(_layoutPtr_,_addr_) \
! 412: ((_addr_) / (_layoutPtr_)->numDataCol)
! 413:
! 414: /* Return the identifier of the stripe unit containing the given address. */
! 415: #define rf_RaidAddressToStripeUnitID(_layoutPtr_,_addr_) \
! 416: (((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit))
! 417:
! 418: /* Return the RAID address of next stripe boundary beyond the given address. */
! 419: #define rf_RaidAddressOfNextStripeBoundary(_layoutPtr_,_addr_) \
! 420: ((((_addr_) / (_layoutPtr_)->dataSectorsPerStripe) + 1) * \
! 421: (_layoutPtr_)->dataSectorsPerStripe)
! 422:
! 423: /*
! 424: * Return the RAID address of the start of the stripe containing the
! 425: * given address.
! 426: */
! 427: #define rf_RaidAddressOfPrevStripeBoundary(_layoutPtr_,_addr_) \
! 428: ((((_addr_) / (_layoutPtr_)->dataSectorsPerStripe) + 0) * \
! 429: (_layoutPtr_)->dataSectorsPerStripe)
! 430:
! 431: /*
! 432: * Return the RAID address of next stripe unit boundary beyond the
! 433: * given address.
! 434: */
! 435: #define rf_RaidAddressOfNextStripeUnitBoundary(_layoutPtr_,_addr_) \
! 436: ((((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) + 1L) * \
! 437: (_layoutPtr_)->sectorsPerStripeUnit)
! 438:
! 439: /*
! 440: * Return the RAID address of the start of the stripe unit containing
! 441: * RAID address _addr_.
! 442: */
! 443: #define rf_RaidAddressOfPrevStripeUnitBoundary(_layoutPtr_,_addr_) \
! 444: ((((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) + 0) * \
! 445: (_layoutPtr_)->sectorsPerStripeUnit)
! 446:
! 447: /* Returns the offset into the stripe. Used by RaidAddressStripeAligned. */
! 448: #define rf_RaidAddressStripeOffset(_layoutPtr_,_addr_) \
! 449: ((_addr_) % (_layoutPtr_)->dataSectorsPerStripe)
! 450:
! 451: /* Returns the offset into the stripe unit. */
! 452: #define rf_StripeUnitOffset(_layoutPtr_,_addr_) \
! 453: ((_addr_) % (_layoutPtr_)->sectorsPerStripeUnit)
! 454:
! 455: /* Returns nonzero if the given RAID address is stripe-aligned. */
! 456: #define rf_RaidAddressStripeAligned(__layoutPtr__,__addr__) \
! 457: (rf_RaidAddressStripeOffset(__layoutPtr__, __addr__) == 0)
! 458:
! 459: /* Returns nonzero if the given address is stripe-unit aligned. */
! 460: #define rf_StripeUnitAligned(__layoutPtr__,__addr__) \
! 461: (rf_StripeUnitOffset(__layoutPtr__, __addr__) == 0)
! 462:
! 463: /*
! 464: * Convert an address expressed in RAID blocks to/from an addr expressed
! 465: * in bytes.
! 466: */
! 467: #define rf_RaidAddressToByte(_raidPtr_,_addr_) \
! 468: ((_addr_) << (_raidPtr_)->logBytesPerSector)
! 469:
! 470: #define rf_ByteToRaidAddress(_raidPtr_,_addr_) \
! 471: ((_addr_) >> (_raidPtr_)->logBytesPerSector)
! 472:
! 473: /*
! 474: * Convert a raid address to/from a parity stripe ID. Conversion to raid
! 475: * address is easy, since we're asking for the address of the first sector
! 476: * in the parity stripe. Conversion to a parity stripe ID is more complex,
! 477: * since stripes are not contiguously allocated in parity stripes.
! 478: */
! 479: #define rf_RaidAddressToParityStripeID(_layoutPtr_,_addr_,_ru_num_) \
! 480: rf_MapStripeIDToParityStripeID((_layoutPtr_), \
! 481: rf_RaidAddressToStripeID((_layoutPtr_), (_addr_)), (_ru_num_))
! 482:
! 483: #define rf_ParityStripeIDToRaidAddress(_layoutPtr_,_psid_) \
! 484: ((_psid_) * (_layoutPtr_)->SUsPerPU * \
! 485: (_layoutPtr_)->numDataCol * (_layoutPtr_)->sectorsPerStripeUnit)
! 486:
! 487: RF_LayoutSW_t *rf_GetLayout(RF_ParityConfig_t);
! 488: int rf_ConfigureLayout(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
! 489: RF_StripeNum_t rf_MapStripeIDToParityStripeID(RF_RaidLayout_t *,
! 490: RF_StripeNum_t, RF_ReconUnitNum_t *);
! 491:
! 492: #endif /* !_RF__RF_LAYOUT_H_ */