Annotation of src/sys/dev/raidframe/raidframevar.h, revision 1.1.2.2
1.1.2.2 ! fvdl 1: /* $NetBSD: raidframevar.h,v 1.1.2.1 2001/10/11 00:02:15 fvdl Exp $ */
! 2: /*-
! 3: * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
! 4: * All rights reserved.
! 5: *
! 6: * This code is derived from software contributed to The NetBSD Foundation
! 7: * by Greg Oster
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. All advertising materials mentioning features or use of this software
! 18: * must display the following acknowledgement:
! 19: * This product includes software developed by the NetBSD
! 20: * Foundation, Inc. and its contributors.
! 21: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 22: * contributors may be used to endorse or promote products derived
! 23: * from this software without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 26: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 27: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 28: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 29: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 30: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 31: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 32: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 33: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 34: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 35: * POSSIBILITY OF SUCH DAMAGE.
! 36: */
! 37: /*
! 38: * Copyright (c) 1995 Carnegie-Mellon University.
! 39: * All rights reserved.
! 40: *
! 41: * Author: Mark Holland
! 42: *
! 43: * Permission to use, copy, modify and distribute this software and
! 44: * its documentation is hereby granted, provided that both the copyright
! 45: * notice and this permission notice appear in all copies of the
! 46: * software, derivative works or modified versions, and any portions
! 47: * thereof, and that both notices appear in supporting documentation.
! 48: *
! 49: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 50: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 51: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 52: *
! 53: * Carnegie Mellon requests users of this software to return to
! 54: *
! 55: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 56: * School of Computer Science
! 57: * Carnegie Mellon University
! 58: * Pittsburgh PA 15213-3890
! 59: *
! 60: * any improvements or extensions that they make and grant Carnegie the
! 61: * rights to redistribute these changes.
! 62: */
! 63:
! 64: /*
! 65: * Copyright (c) 1995 Carnegie-Mellon University.
! 66: * All rights reserved.
! 67: *
! 68: * Author: Jim Zelenka
! 69: *
! 70: * Permission to use, copy, modify and distribute this software and
! 71: * its documentation is hereby granted, provided that both the copyright
! 72: * notice and this permission notice appear in all copies of the
! 73: * software, derivative works or modified versions, and any portions
! 74: * thereof, and that both notices appear in supporting documentation.
! 75: *
! 76: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 77: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
! 78: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 79: *
! 80: * Carnegie Mellon requests users of this software to return to
! 81: *
! 82: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 83: * School of Computer Science
! 84: * Carnegie Mellon University
! 85: * Pittsburgh PA 15213-3890
! 86: *
! 87: * any improvements or extensions that they make and grant Carnegie the
! 88: * rights to redistribute these changes.
! 89: */
! 90:
! 91: /*****************************************************
! 92: *
! 93: * raidframevar.h
! 94: *
! 95: * main header file for using raidframe in the kernel.
! 96: *
! 97: *****************************************************/
! 98:
! 99:
! 100: #ifndef _RF_RAIDFRAMEVAR_H_
! 101: #define _RF_RAIDFRAMEVAR_H_
! 102:
! 103:
! 104: #include <sys/ioctl.h>
! 105:
! 106: #include <sys/errno.h>
! 107: #include <sys/types.h>
! 108:
! 109: #include <sys/uio.h>
! 110: #include <sys/param.h>
! 111: #include <sys/proc.h>
! 112: #include <sys/lock.h>
! 113:
! 114: /*
! 115: * First, define system-dependent types and constants.
! 116: *
! 117: * If the machine is big-endian, RF_BIG_ENDIAN should be 1.
! 118: * Otherwise, it should be 0.
! 119: *
! 120: * The various integer types should be self-explanatory; we
! 121: * use these elsewhere to avoid size confusion.
! 122: *
! 123: * LONGSHIFT is lg(sizeof(long)) (that is, log base two of sizeof(long)
! 124: *
! 125: */
! 126:
! 127: #include <sys/types.h>
! 128: #include <machine/endian.h>
! 129: #include <machine/limits.h>
! 130:
! 131: #if BYTE_ORDER == BIG_ENDIAN
! 132: #define RF_IS_BIG_ENDIAN 1
! 133: #elif BYTE_ORDER == LITTLE_ENDIAN
! 134: #define RF_IS_BIG_ENDIAN 0
! 135: #else
! 136: #error byte order not defined
! 137: #endif
! 138: typedef int8_t RF_int8;
! 139: typedef u_int8_t RF_uint8;
! 140: typedef int16_t RF_int16;
! 141: typedef u_int16_t RF_uint16;
! 142: typedef int32_t RF_int32;
! 143: typedef u_int32_t RF_uint32;
! 144: typedef int64_t RF_int64;
! 145: typedef u_int64_t RF_uint64;
! 146: #if LONG_BIT == 32
! 147: #define RF_LONGSHIFT 2
! 148: #elif LONG_BIT == 64
! 149: #define RF_LONGSHIFT 3
! 150: #else
! 151: #error word size not defined
! 152: #endif
! 153:
! 154: /*
! 155: * These are just zero and non-zero. We don't use "TRUE"
! 156: * and "FALSE" because there's too much nonsense trying
! 157: * to get them defined exactly once on every platform, given
! 158: * the different places they may be defined in system header
! 159: * files.
! 160: */
! 161: #define RF_TRUE 1
! 162: #define RF_FALSE 0
! 163:
! 164: /*
! 165: * Now, some generic types
! 166: */
! 167: typedef RF_uint64 RF_IoCount_t;
! 168: typedef RF_uint64 RF_Offset_t;
! 169: typedef RF_uint32 RF_PSSFlags_t;
! 170: typedef RF_uint64 RF_SectorCount_t;
! 171: typedef RF_uint64 RF_StripeCount_t;
! 172: typedef RF_int64 RF_SectorNum_t;/* these are unsigned so we can set them to
! 173: * (-1) for "uninitialized" */
! 174: typedef RF_int64 RF_StripeNum_t;
! 175: typedef RF_int64 RF_RaidAddr_t;
! 176: typedef int RF_RowCol_t; /* unsigned so it can be (-1) */
! 177: typedef RF_int64 RF_HeadSepLimit_t;
! 178: typedef RF_int64 RF_ReconUnitCount_t;
! 179: typedef int RF_ReconUnitNum_t;
! 180:
! 181: typedef char RF_ParityConfig_t;
! 182:
! 183: typedef char RF_DiskQueueType_t[1024];
! 184: #define RF_DISK_QUEUE_TYPE_NONE ""
! 185:
! 186: /* values for the 'type' field in a reconstruction buffer */
! 187: typedef int RF_RbufType_t;
! 188: #define RF_RBUF_TYPE_EXCLUSIVE 0 /* this buf assigned exclusively to
! 189: * one disk */
! 190: #define RF_RBUF_TYPE_FLOATING 1 /* this is a floating recon buf */
! 191: #define RF_RBUF_TYPE_FORCED 2 /* this rbuf was allocated to complete
! 192: * a forced recon */
! 193:
! 194: typedef char RF_IoType_t;
! 195: #define RF_IO_TYPE_READ 'r'
! 196: #define RF_IO_TYPE_WRITE 'w'
! 197: #define RF_IO_TYPE_NOP 'n'
! 198: #define RF_IO_IS_R_OR_W(_type_) (((_type_) == RF_IO_TYPE_READ) \
! 199: || ((_type_) == RF_IO_TYPE_WRITE))
! 200:
! 201: typedef void (*RF_VoidFuncPtr) (void *,...);
! 202:
! 203: typedef RF_uint32 RF_AccessStripeMapFlags_t;
! 204: typedef RF_uint32 RF_DiskQueueDataFlags_t;
! 205: typedef RF_uint32 RF_DiskQueueFlags_t;
! 206: typedef RF_uint32 RF_RaidAccessFlags_t;
! 207:
! 208: #define RF_DISKQUEUE_DATA_FLAGS_NONE ((RF_DiskQueueDataFlags_t)0)
! 209:
! 210: typedef struct RF_AccessStripeMap_s RF_AccessStripeMap_t;
! 211: typedef struct RF_AccessStripeMapHeader_s RF_AccessStripeMapHeader_t;
! 212: typedef struct RF_AllocListElem_s RF_AllocListElem_t;
! 213: typedef struct RF_CallbackDesc_s RF_CallbackDesc_t;
! 214: typedef struct RF_ChunkDesc_s RF_ChunkDesc_t;
! 215: typedef struct RF_CommonLogData_s RF_CommonLogData_t;
! 216: typedef struct RF_Config_s RF_Config_t;
! 217: typedef struct RF_CumulativeStats_s RF_CumulativeStats_t;
! 218: typedef struct RF_DagHeader_s RF_DagHeader_t;
! 219: typedef struct RF_DagList_s RF_DagList_t;
! 220: typedef struct RF_DagNode_s RF_DagNode_t;
! 221: typedef struct RF_DeclusteredConfigInfo_s RF_DeclusteredConfigInfo_t;
! 222: typedef struct RF_DiskId_s RF_DiskId_t;
! 223: typedef struct RF_DiskMap_s RF_DiskMap_t;
! 224: typedef struct RF_DiskQueue_s RF_DiskQueue_t;
! 225: typedef struct RF_DiskQueueData_s RF_DiskQueueData_t;
! 226: typedef struct RF_DiskQueueSW_s RF_DiskQueueSW_t;
! 227: typedef struct RF_Etimer_s RF_Etimer_t;
! 228: typedef struct RF_EventCreate_s RF_EventCreate_t;
! 229: typedef struct RF_FreeList_s RF_FreeList_t;
! 230: typedef struct RF_LockReqDesc_s RF_LockReqDesc_t;
! 231: typedef struct RF_LockTableEntry_s RF_LockTableEntry_t;
! 232: typedef struct RF_MCPair_s RF_MCPair_t;
! 233: typedef struct RF_OwnerInfo_s RF_OwnerInfo_t;
! 234: typedef struct RF_ParityLog_s RF_ParityLog_t;
! 235: typedef struct RF_ParityLogAppendQueue_s RF_ParityLogAppendQueue_t;
! 236: typedef struct RF_ParityLogData_s RF_ParityLogData_t;
! 237: typedef struct RF_ParityLogDiskQueue_s RF_ParityLogDiskQueue_t;
! 238: typedef struct RF_ParityLogQueue_s RF_ParityLogQueue_t;
! 239: typedef struct RF_ParityLogRecord_s RF_ParityLogRecord_t;
! 240: typedef struct RF_PerDiskReconCtrl_s RF_PerDiskReconCtrl_t;
! 241: typedef struct RF_PSStatusHeader_s RF_PSStatusHeader_t;
! 242: typedef struct RF_PhysDiskAddr_s RF_PhysDiskAddr_t;
! 243: typedef struct RF_PropHeader_s RF_PropHeader_t;
! 244: typedef struct RF_Raid_s RF_Raid_t;
! 245: typedef struct RF_RaidAccessDesc_s RF_RaidAccessDesc_t;
! 246: typedef struct RF_RaidDisk_s RF_RaidDisk_t;
! 247: typedef struct RF_RaidLayout_s RF_RaidLayout_t;
! 248: typedef struct RF_RaidReconDesc_s RF_RaidReconDesc_t;
! 249: typedef struct RF_ReconBuffer_s RF_ReconBuffer_t;
! 250: typedef struct RF_ReconConfig_s RF_ReconConfig_t;
! 251: typedef struct RF_ReconCtrl_s RF_ReconCtrl_t;
! 252: typedef struct RF_ReconDoneProc_s RF_ReconDoneProc_t;
! 253: typedef struct RF_ReconEvent_s RF_ReconEvent_t;
! 254: typedef struct RF_ReconMap_s RF_ReconMap_t;
! 255: typedef struct RF_ReconMapListElem_s RF_ReconMapListElem_t;
! 256: typedef struct RF_ReconParityStripeStatus_s RF_ReconParityStripeStatus_t;
! 257: typedef struct RF_RedFuncs_s RF_RedFuncs_t;
! 258: typedef struct RF_RegionBufferQueue_s RF_RegionBufferQueue_t;
! 259: typedef struct RF_RegionInfo_s RF_RegionInfo_t;
! 260: typedef struct RF_ShutdownList_s RF_ShutdownList_t;
! 261: typedef struct RF_SpareTableEntry_s RF_SpareTableEntry_t;
! 262: typedef struct RF_SparetWait_s RF_SparetWait_t;
! 263: typedef struct RF_StripeLockDesc_s RF_StripeLockDesc_t;
! 264: typedef struct RF_ThreadGroup_s RF_ThreadGroup_t;
! 265: typedef struct RF_ThroughputStats_s RF_ThroughputStats_t;
! 266:
! 267: /*
! 268: * Important assumptions regarding ordering of the states in this list
! 269: * have been made!!! Before disturbing this ordering, look at code in
! 270: * sys/dev/raidframe/rf_states.c
! 271: */
! 272: typedef enum RF_AccessState_e {
! 273: /* original states */
! 274: rf_QuiesceState, /* handles queisence for reconstruction */
! 275: rf_IncrAccessesCountState, /* count accesses in flight */
! 276: rf_DecrAccessesCountState,
! 277: rf_MapState, /* map access to disk addresses */
! 278: rf_LockState, /* take stripe locks */
! 279: rf_CreateDAGState, /* create DAGs */
! 280: rf_ExecuteDAGState, /* execute DAGs */
! 281: rf_ProcessDAGState, /* DAGs are completing- check if correct,
! 282: * or if we need to retry */
! 283: rf_CleanupState, /* release stripe locks, clean up */
! 284: rf_LastState /* must be the last state */
! 285: } RF_AccessState_t;
! 286:
! 287:
! 288: /* Some constants related to RAIDframe. These are arbitrary and
! 289: can be modified at will. */
! 290:
! 291: #define RF_MAXROW 10
! 292: #define RF_MAXCOL 40
! 293: #define RF_MAXSPARE 10
! 294: #define RF_MAXDBGV 75 /* max number of debug variables */
! 295: #define RF_MAX_DISKS 128 /* max disks per array */
! 296: #define RF_SPAREMAP_NAME_LEN 128
! 297: #define RF_PROTECTED_SECTORS 64L /* # of sectors at start of disk to
! 298: exclude from RAID address space */
! 299:
! 300: struct RF_SpareTableEntry_s {
! 301: u_int spareDisk; /* disk to which this block is spared */
! 302: u_int spareBlockOffsetInSUs; /* offset into spare table for that
! 303: * disk */
! 304: };
! 305:
! 306: union RF_GenericParam_u {
! 307: void *p;
! 308: RF_uint64 v;
! 309: };
! 310: typedef union RF_GenericParam_u RF_DagParam_t;
! 311: typedef union RF_GenericParam_u RF_CBParam_t;
! 312:
! 313: /* the raidframe configuration, passed down through an ioctl.
! 314: * the driver can be reconfigured (with total loss of data) at any time,
! 315: * but it must be shut down first.
! 316: */
! 317: struct RF_Config_s {
! 318: RF_RowCol_t numRow, numCol, numSpare; /* number of rows, columns,
! 319: * and spare disks */
! 320: dev_t devs[RF_MAXROW][RF_MAXCOL]; /* device numbers for disks
! 321: * comprising array */
! 322: char devnames[RF_MAXROW][RF_MAXCOL][50]; /* device names */
! 323: dev_t spare_devs[RF_MAXSPARE]; /* device numbers for spare
! 324: * disks */
! 325: char spare_names[RF_MAXSPARE][50]; /* device names */
! 326: RF_SectorNum_t sectPerSU; /* sectors per stripe unit */
! 327: RF_StripeNum_t SUsPerPU;/* stripe units per parity unit */
! 328: RF_StripeNum_t SUsPerRU;/* stripe units per reconstruction unit */
! 329: RF_ParityConfig_t parityConfig; /* identifies the RAID architecture to
! 330: * be used */
! 331: RF_DiskQueueType_t diskQueueType; /* 'f' = fifo, 'c' = cvscan,
! 332: * not used in kernel */
! 333: char maxOutstandingDiskReqs; /* # concurrent reqs to be sent to a
! 334: * disk. not used in kernel. */
! 335: char debugVars[RF_MAXDBGV][50]; /* space for specifying debug
! 336: * variables & their values */
! 337: unsigned int layoutSpecificSize; /* size in bytes of
! 338: * layout-specific info */
! 339: void *layoutSpecific; /* a pointer to a layout-specific structure to
! 340: * be copied in */
! 341: int force; /* if !0, ignore many fatal
! 342: configuration conditions */
! 343: /*
! 344: "force" is used to override cases where the component labels would
! 345: indicate that configuration should not proceed without user
! 346: intervention
! 347: */
! 348: };
! 349:
! 350: typedef RF_uint32 RF_ReconReqFlags_t;
! 351: /* flags that can be put in the rf_recon_req structure */
! 352: #define RF_FDFLAGS_NONE 0x0 /* just fail the disk */
! 353: #define RF_FDFLAGS_RECON 0x1 /* fail and initiate recon */
! 354:
! 355: struct rf_recon_req { /* used to tell the kernel to fail a disk */
! 356: RF_RowCol_t row, col;
! 357: RF_ReconReqFlags_t flags;
! 358: void *raidPtr; /* used internally; need not be set at ioctl
! 359: * time */
! 360: struct rf_recon_req *next; /* used internally; need not be set at
! 361: * ioctl time */
! 362: };
! 363:
! 364: struct RF_SparetWait_s {
! 365: int C, G, fcol; /* C = # disks in row, G = # units in stripe,
! 366: * fcol = which disk has failed */
! 367:
! 368: RF_StripeCount_t SUsPerPU; /* this stuff is the info required to
! 369: * create a spare table */
! 370: int TablesPerSpareRegion;
! 371: int BlocksPerTable;
! 372: RF_StripeCount_t TableDepthInPUs;
! 373: RF_StripeCount_t SpareSpaceDepthPerRegionInSUs;
! 374:
! 375: RF_SparetWait_t *next; /* used internally; need not be set at ioctl
! 376: * time */
! 377: };
! 378: /*
! 379: * A physical disk can be in one of several states:
! 380: * IF YOU ADD A STATE, CHECK TO SEE IF YOU NEED TO MODIFY RF_DEAD_DISK().
! 381: */
! 382: enum RF_DiskStatus_e {
! 383: rf_ds_optimal, /* no problems */
! 384: rf_ds_failed, /* reconstruction ongoing */
! 385: rf_ds_reconstructing, /* reconstruction complete to spare, dead disk
! 386: * not yet replaced */
! 387: rf_ds_dist_spared, /* reconstruction complete to distributed
! 388: * spare space, dead disk not yet replaced */
! 389: rf_ds_spared, /* reconstruction complete to distributed
! 390: * spare space, dead disk not yet replaced */
! 391: rf_ds_spare, /* an available spare disk */
! 392: rf_ds_used_spare /* a spare which has been used, and hence is
! 393: * not available */
! 394: };
! 395: typedef enum RF_DiskStatus_e RF_DiskStatus_t;
! 396:
! 397: struct RF_RaidDisk_s {
! 398: char devname[56]; /* name of device file */
! 399: RF_DiskStatus_t status; /* whether it is up or down */
! 400: RF_RowCol_t spareRow; /* if in status "spared", this identifies the
! 401: * spare disk */
! 402: RF_RowCol_t spareCol; /* if in status "spared", this identifies the
! 403: * spare disk */
! 404: RF_SectorCount_t numBlocks; /* number of blocks, obtained via READ
! 405: * CAPACITY */
! 406: int blockSize;
! 407: RF_SectorCount_t partitionSize; /* The *actual* and *full* size of
! 408: the partition, from the disklabel */
! 409: int auto_configured;/* 1 if this component was autoconfigured.
! 410: 0 otherwise. */
! 411: dev_t dev;
! 412: };
! 413: /* The per-component label information that the user can set */
! 414: typedef struct RF_ComponentInfo_s {
! 415: int row; /* the row number of this component */
! 416: int column; /* the column number of this component */
! 417: int serial_number; /* a user-specified serial number for this
! 418: RAID set */
! 419: } RF_ComponentInfo_t;
! 420:
! 421: /* The per-component label information */
! 422: typedef struct RF_ComponentLabel_s {
! 423: int version; /* The version of this label. */
! 424: int serial_number; /* a user-specified serial number for this
! 425: RAID set */
! 426: int mod_counter; /* modification counter. Changed (usually
! 427: by incrementing) every time the label
! 428: is changed */
! 429: int row; /* the row number of this component */
! 430: int column; /* the column number of this component */
! 431: int num_rows; /* number of rows in this RAID set */
! 432: int num_columns; /* number of columns in this RAID set */
! 433: int clean; /* 1 when clean, 0 when dirty */
! 434: int status; /* rf_ds_optimal, rf_ds_dist_spared, whatever. */
! 435: /* stuff that will be in version 2 of the label */
! 436: int sectPerSU; /* Sectors per Stripe Unit */
! 437: int SUsPerPU; /* Stripe Units per Parity Units */
! 438: int SUsPerRU; /* Stripe Units per Reconstruction Units */
! 439: int parityConfig; /* '0' == RAID0, '1' == RAID1, etc. */
! 440: int maxOutstanding; /* maxOutstanding disk requests */
! 441: int blockSize; /* size of component block.
! 442: (disklabel->d_secsize) */
! 443: int numBlocks; /* number of blocks on this component. May
! 444: be smaller than the partition size. */
! 445: int partitionSize; /* number of blocks on this *partition*.
! 446: Must exactly match the partition size
! 447: from the disklabel. */
! 448: int future_use[33]; /* Future expansion */
! 449: int autoconfigure; /* automatically configure this RAID set.
! 450: 0 == no, 1 == yes */
! 451: int root_partition; /* Use this set as /
! 452: 0 == no, 1 == yes*/
! 453: int last_unit; /* last unit number (e.g. 0 for /dev/raid0)
! 454: of this component. Used for autoconfigure
! 455: only. */
! 456: int config_order; /* 0 .. n. The order in which the component
! 457: should be auto-configured. E.g. 0 is will
! 458: done first, (and would become raid0).
! 459: This may be in conflict with last_unit!!?! */
! 460: /* Not currently used. */
! 461: int future_use2[44]; /* More future expansion */
! 462: } RF_ComponentLabel_t;
! 463:
! 464: typedef struct RF_SingleComponent_s {
! 465: int row;
! 466: int column;
! 467: char component_name[50]; /* name of the component */
! 468: } RF_SingleComponent_t;
! 469:
! 470: typedef struct RF_DeviceConfig_s {
! 471: u_int rows;
! 472: u_int cols;
! 473: u_int maxqdepth;
! 474: int ndevs;
! 475: RF_RaidDisk_t devs[RF_MAX_DISKS];
! 476: int nspares;
! 477: RF_RaidDisk_t spares[RF_MAX_DISKS];
! 478: } RF_DeviceConfig_t;
! 479:
! 480: typedef struct RF_ProgressInfo_s {
! 481: RF_uint64 remaining;
! 482: RF_uint64 completed;
! 483: RF_uint64 total;
! 484: } RF_ProgressInfo_t;
! 485:
! 486: typedef struct RF_LayoutSW_s {
! 487: RF_ParityConfig_t parityConfig;
! 488: const char *configName;
! 489:
! 490: #ifndef _KERNEL
! 491: /* layout-specific parsing */
! 492: int (*MakeLayoutSpecific) (FILE * fp, RF_Config_t * cfgPtr,
! 493: void *arg);
! 494: void *makeLayoutSpecificArg;
! 495: #else /* !KERNEL */
! 496:
! 497: /* initialization routine */
! 498: int (*Configure) (RF_ShutdownList_t ** shutdownListp,
! 499: RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
! 500:
! 501: /* routine to map RAID sector address -> physical (row, col, offset) */
! 502: void (*MapSector) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
! 503: RF_RowCol_t * row, RF_RowCol_t * col,
! 504: RF_SectorNum_t * diskSector, int remap);
! 505:
! 506: /* routine to map RAID sector address -> physical (r,c,o) of parity
! 507: * unit */
! 508: void (*MapParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
! 509: RF_RowCol_t * row, RF_RowCol_t * col,
! 510: RF_SectorNum_t * diskSector, int remap);
! 511:
! 512: /* routine to map RAID sector address -> physical (r,c,o) of Q unit */
! 513: void (*MapQ) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
! 514: RF_RowCol_t * row, RF_RowCol_t * col,
! 515: RF_SectorNum_t * diskSector, int remap);
! 516:
! 517: /* routine to identify the disks comprising a stripe */
! 518: void (*IdentifyStripe) (RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
! 519: RF_RowCol_t ** diskids,
! 520: RF_RowCol_t * outRow);
! 521:
! 522: /* routine to select a dag */
! 523: void (*SelectionFunc) (RF_Raid_t * raidPtr, RF_IoType_t type,
! 524: RF_AccessStripeMap_t * asmap,
! 525: RF_VoidFuncPtr *);
! 526:
! 527: /* map a stripe ID to a parity stripe ID. This is typically the
! 528: * identity mapping */
! 529: void (*MapSIDToPSID) (RF_RaidLayout_t * layoutPtr,
! 530: RF_StripeNum_t stripeID,
! 531: RF_StripeNum_t * psID,
! 532: RF_ReconUnitNum_t * which_ru);
! 533:
! 534: /* get default head separation limit (may be NULL) */
! 535: RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr);
! 536:
! 537: /* get default num recon buffers (may be NULL) */
! 538: int (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr);
! 539:
! 540: /* get number of spare recon units (may be NULL) */
! 541: RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr);
! 542:
! 543: /* spare table installation (may be NULL) */
! 544: int (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t frow,
! 545: RF_RowCol_t fcol);
! 546:
! 547: /* recon buffer submission function */
! 548: int (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it,
! 549: int use_committed);
! 550:
! 551: /*
! 552: * verify that parity information for a stripe is correct
! 553: * see rf_parityscan.h for return vals
! 554: */
! 555: int (*VerifyParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
! 556: RF_PhysDiskAddr_t * parityPDA,
! 557: int correct_it, RF_RaidAccessFlags_t flags);
! 558:
! 559: /* number of faults tolerated by this mapping */
! 560: int faultsTolerated;
! 561:
! 562: /* states to step through in an access. Must end with "LastState". The
! 563: * default is DefaultStates in rf_layout.c */
! 564: RF_AccessState_t *states;
! 565:
! 566: RF_AccessStripeMapFlags_t flags;
! 567: #endif /* !KERNEL */
! 568: } RF_LayoutSW_t;
! 569:
! 570: #endif /* !_RF_RAIDFRAMEVAR_H_ */
CVSweb <webmaster@jp.NetBSD.org>