Annotation of src/sys/dev/raidframe/raidframevar.h, revision 1.25

1.25    ! tls         1: /*     $NetBSD: raidframevar.h,v 1.24 2026/10/18 14:56:32 tls Exp $ */
1.1       oster       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:  *
                     18:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     19:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     20:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     21:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     22:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     23:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     24:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     25:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     26:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     27:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     28:  * POSSIBILITY OF SUCH DAMAGE.
                     29:  */
                     30: /*
                     31:  * Copyright (c) 1995 Carnegie-Mellon University.
                     32:  * All rights reserved.
                     33:  *
                     34:  * Author: Mark Holland
                     35:  *
                     36:  * Permission to use, copy, modify and distribute this software and
                     37:  * its documentation is hereby granted, provided that both the copyright
                     38:  * notice and this permission notice appear in all copies of the
                     39:  * software, derivative works or modified versions, and any portions
                     40:  * thereof, and that both notices appear in supporting documentation.
                     41:  *
                     42:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
                     43:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
                     44:  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
                     45:  *
                     46:  * Carnegie Mellon requests users of this software to return to
                     47:  *
                     48:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
                     49:  *  School of Computer Science
                     50:  *  Carnegie Mellon University
                     51:  *  Pittsburgh PA 15213-3890
                     52:  *
                     53:  * any improvements or extensions that they make and grant Carnegie the
                     54:  * rights to redistribute these changes.
                     55:  */
                     56: 
                     57: /*
                     58:  * Copyright (c) 1995 Carnegie-Mellon University.
                     59:  * All rights reserved.
                     60:  *
                     61:  * Author: Jim Zelenka
                     62:  *
                     63:  * Permission to use, copy, modify and distribute this software and
                     64:  * its documentation is hereby granted, provided that both the copyright
                     65:  * notice and this permission notice appear in all copies of the
                     66:  * software, derivative works or modified versions, and any portions
                     67:  * thereof, and that both notices appear in supporting documentation.
                     68:  *
                     69:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
                     70:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
                     71:  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
                     72:  *
                     73:  * Carnegie Mellon requests users of this software to return to
                     74:  *
                     75:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
                     76:  *  School of Computer Science
                     77:  *  Carnegie Mellon University
                     78:  *  Pittsburgh PA 15213-3890
                     79:  *
                     80:  * any improvements or extensions that they make and grant Carnegie the
                     81:  * rights to redistribute these changes.
                     82:  */
                     83: 
                     84: /*****************************************************
                     85:  *
                     86:  * raidframevar.h
                     87:  *
                     88:  * main header file for using raidframe in the kernel.
                     89:  *
                     90:  *****************************************************/
                     91: 
                     92: 
                     93: #ifndef _RF_RAIDFRAMEVAR_H_
                     94: #define _RF_RAIDFRAMEVAR_H_
                     95: 
1.4       dsl        96: #ifndef _STANDALONE
1.1       oster      97: #include <sys/ioctl.h>
                     98: 
                     99: #include <sys/errno.h>
                    100: #include <sys/types.h>
                    101: 
                    102: #include <sys/uio.h>
                    103: #include <sys/param.h>
                    104: #include <sys/proc.h>
                    105: 
1.2       thorpej   106: #include <sys/mallocvar.h>
1.4       dsl       107: #endif
1.2       thorpej   108: 
1.1       oster     109: /*
                    110:  * First, define system-dependent types and constants.
                    111:  *
                    112:  * If the machine is big-endian, RF_BIG_ENDIAN should be 1.
                    113:  * Otherwise, it should be 0.
                    114:  *
                    115:  * The various integer types should be self-explanatory; we
                    116:  * use these elsewhere to avoid size confusion.
                    117:  *
                    118:  * LONGSHIFT is lg(sizeof(long)) (that is, log base two of sizeof(long)
                    119:  *
                    120:  */
                    121: 
                    122: #include <sys/types.h>
                    123: #include <machine/endian.h>
                    124: #include <machine/limits.h>
                    125: 
                    126: #if BYTE_ORDER == BIG_ENDIAN
                    127: #define RF_IS_BIG_ENDIAN    1
                    128: #elif BYTE_ORDER == LITTLE_ENDIAN
                    129: #define RF_IS_BIG_ENDIAN    0
                    130: #else
                    131: #error byte order not defined
                    132: #endif
                    133: typedef int8_t RF_int8;
                    134: typedef u_int8_t RF_uint8;
                    135: typedef int16_t RF_int16;
                    136: typedef u_int16_t RF_uint16;
                    137: typedef int32_t RF_int32;
                    138: typedef u_int32_t RF_uint32;
                    139: typedef int64_t RF_int64;
                    140: typedef u_int64_t RF_uint64;
                    141: #if LONG_BIT == 32
                    142: #define RF_LONGSHIFT        2
                    143: #elif LONG_BIT == 64
                    144: #define RF_LONGSHIFT        3
                    145: #else
                    146: #error word size not defined
                    147: #endif
                    148: 
                    149: /*
                    150:  * These are just zero and non-zero. We don't use "TRUE"
                    151:  * and "FALSE" because there's too much nonsense trying
                    152:  * to get them defined exactly once on every platform, given
                    153:  * the different places they may be defined in system header
                    154:  * files.
                    155:  */
                    156: #define RF_TRUE  1
                    157: #define RF_FALSE 0
1.2       thorpej   158: 
                    159: /* Malloc types. */
1.3       tron      160: #ifdef _KERNEL
1.2       thorpej   161: MALLOC_DECLARE(M_RAIDFRAME);
1.3       tron      162: #endif
1.1       oster     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;
1.21      christos  213: typedef struct RF_CallbackFuncDesc_s RF_CallbackFuncDesc_t;
                    214: typedef struct RF_CallbackValueDesc_s RF_CallbackValueDesc_t;
1.1       oster     215: typedef struct RF_ChunkDesc_s RF_ChunkDesc_t;
                    216: typedef struct RF_CommonLogData_s RF_CommonLogData_t;
                    217: typedef struct RF_Config_s RF_Config_t;
                    218: typedef struct RF_CumulativeStats_s RF_CumulativeStats_t;
                    219: typedef struct RF_DagHeader_s RF_DagHeader_t;
                    220: typedef struct RF_DagList_s RF_DagList_t;
                    221: typedef struct RF_DagNode_s RF_DagNode_t;
                    222: typedef struct RF_DeclusteredConfigInfo_s RF_DeclusteredConfigInfo_t;
                    223: typedef struct RF_DiskId_s RF_DiskId_t;
                    224: typedef struct RF_DiskMap_s RF_DiskMap_t;
                    225: typedef struct RF_DiskQueue_s RF_DiskQueue_t;
                    226: typedef struct RF_DiskQueueData_s RF_DiskQueueData_t;
                    227: typedef struct RF_DiskQueueSW_s RF_DiskQueueSW_t;
                    228: typedef struct RF_Etimer_s RF_Etimer_t;
                    229: typedef struct RF_EventCreate_s RF_EventCreate_t;
                    230: typedef struct RF_FreeList_s RF_FreeList_t;
                    231: typedef struct RF_LockReqDesc_s RF_LockReqDesc_t;
                    232: typedef struct RF_LockTableEntry_s RF_LockTableEntry_t;
                    233: typedef struct RF_MCPair_s RF_MCPair_t;
                    234: typedef struct RF_OwnerInfo_s RF_OwnerInfo_t;
                    235: typedef struct RF_ParityLog_s RF_ParityLog_t;
                    236: typedef struct RF_ParityLogAppendQueue_s RF_ParityLogAppendQueue_t;
                    237: typedef struct RF_ParityLogData_s RF_ParityLogData_t;
                    238: typedef struct RF_ParityLogDiskQueue_s RF_ParityLogDiskQueue_t;
                    239: typedef struct RF_ParityLogQueue_s RF_ParityLogQueue_t;
                    240: typedef struct RF_ParityLogRecord_s RF_ParityLogRecord_t;
                    241: typedef struct RF_PerDiskReconCtrl_s RF_PerDiskReconCtrl_t;
                    242: typedef struct RF_PSStatusHeader_s RF_PSStatusHeader_t;
                    243: typedef struct RF_PhysDiskAddr_s RF_PhysDiskAddr_t;
                    244: typedef struct RF_PropHeader_s RF_PropHeader_t;
                    245: typedef struct RF_Raid_s RF_Raid_t;
                    246: typedef struct RF_RaidAccessDesc_s RF_RaidAccessDesc_t;
                    247: typedef struct RF_RaidDisk_s RF_RaidDisk_t;
                    248: typedef struct RF_RaidLayout_s RF_RaidLayout_t;
                    249: typedef struct RF_RaidReconDesc_s RF_RaidReconDesc_t;
                    250: typedef struct RF_ReconBuffer_s RF_ReconBuffer_t;
                    251: typedef struct RF_ReconConfig_s RF_ReconConfig_t;
                    252: typedef struct RF_ReconCtrl_s RF_ReconCtrl_t;
                    253: typedef struct RF_ReconDoneProc_s RF_ReconDoneProc_t;
                    254: typedef struct RF_ReconEvent_s RF_ReconEvent_t;
                    255: typedef struct RF_ReconMap_s RF_ReconMap_t;
                    256: typedef struct RF_ReconMapListElem_s RF_ReconMapListElem_t;
                    257: typedef struct RF_ReconParityStripeStatus_s RF_ReconParityStripeStatus_t;
                    258: typedef struct RF_RedFuncs_s RF_RedFuncs_t;
                    259: typedef struct RF_RegionBufferQueue_s RF_RegionBufferQueue_t;
                    260: typedef struct RF_RegionInfo_s RF_RegionInfo_t;
                    261: typedef struct RF_ShutdownList_s RF_ShutdownList_t;
                    262: typedef struct RF_SpareTableEntry_s RF_SpareTableEntry_t;
                    263: typedef struct RF_SparetWait_s RF_SparetWait_t;
                    264: typedef struct RF_StripeLockDesc_s RF_StripeLockDesc_t;
                    265: typedef struct RF_ThreadGroup_s RF_ThreadGroup_t;
                    266: typedef struct RF_ThroughputStats_s RF_ThroughputStats_t;
                    267: 
1.13      jld       268: struct rf_paritymap;
                    269: struct rf_paritymap_ondisk;
                    270: 
1.1       oster     271: /*
                    272:  * Important assumptions regarding ordering of the states in this list
1.8       perry     273:  * have been made!!!  Before disturbing this ordering, look at code in
1.1       oster     274:  * sys/dev/raidframe/rf_states.c
                    275:  */
                    276: typedef enum RF_AccessState_e {
                    277:        /* original states */
                    278:        rf_QuiesceState,            /* handles queisence for reconstruction */
                    279:        rf_IncrAccessesCountState,  /* count accesses in flight */
                    280:        rf_MapState,                /* map access to disk addresses */
                    281:        rf_LockState,               /* take stripe locks */
                    282:        rf_CreateDAGState,          /* create DAGs */
                    283:        rf_ExecuteDAGState,         /* execute DAGs */
                    284:        rf_ProcessDAGState,         /* DAGs are completing- check if correct,
                    285:                                     * or if we need to retry */
                    286:        rf_CleanupState,            /* release stripe locks, clean up */
1.6       oster     287:        rf_DecrAccessesCountState,
1.1       oster     288:        rf_LastState                /* must be the last state */
                    289: }       RF_AccessState_t;
                    290: 
                    291: 
1.8       perry     292: /* Some constants related to RAIDframe.  These are arbitrary and
1.1       oster     293:    can be modified at will. */
                    294: 
                    295: #define RF_MAXROW    10
                    296: #define RF_MAXCOL    40
                    297: #define RF_MAXSPARE  10
                    298: #define RF_MAXDBGV   75                    /* max number of debug variables */
                    299: #define RF_MAX_DISKS 128           /* max disks per array */
                    300: #define RF_SPAREMAP_NAME_LEN 128
                    301: #define RF_PROTECTED_SECTORS 64L    /* # of sectors at start of disk to
                    302:                                       exclude from RAID address space */
                    303: 
                    304: struct RF_SpareTableEntry_s {
                    305:         u_int   spareDisk;          /* disk to which this block is spared */
                    306:         u_int   spareBlockOffsetInSUs;  /* offset into spare table for that
                    307:                                          * disk */
                    308: };
                    309: 
                    310: union RF_GenericParam_u {
                    311:        void   *p;
                    312:        RF_uint64 v;
                    313: };
                    314: typedef union RF_GenericParam_u RF_DagParam_t;
                    315: typedef union RF_GenericParam_u RF_CBParam_t;
                    316: 
                    317: /* the raidframe configuration, passed down through an ioctl.
                    318:  * the driver can be reconfigured (with total loss of data) at any time,
                    319:  * but it must be shut down first.
                    320:  */
                    321: struct RF_Config_s {
1.18      mrg       322:        RF_RowCol_t numCol, numSpare;           /* number of columns,
1.1       oster     323:                                                 * and spare disks */
                    324:        dev_t   devs[RF_MAXROW][RF_MAXCOL];     /* device numbers for disks
                    325:                                                 * comprising array */
                    326:        char    devnames[RF_MAXROW][RF_MAXCOL][50];     /* device names */
                    327:        dev_t   spare_devs[RF_MAXSPARE];        /* device numbers for spare
                    328:                                                 * disks */
                    329:        char    spare_names[RF_MAXSPARE][50];   /* device names */
                    330:        RF_SectorNum_t sectPerSU;       /* sectors per stripe unit */
                    331:        RF_StripeNum_t SUsPerPU;/* stripe units per parity unit */
                    332:        RF_StripeNum_t SUsPerRU;/* stripe units per reconstruction unit */
                    333:        RF_ParityConfig_t parityConfig; /* identifies the RAID architecture to
                    334:                                         * be used */
1.24      tls       335:        RF_DiskQueueType_t diskQueueType;       /* 'f' = fifo, 'c' = cvscan */
1.25    ! tls       336:        uint8_t maxOutstandingDiskReqs; /* # concurrent reqs to be sent to a
1.24      tls       337:                                         * disk (uint8_t, 1..255). */
                    338: #define RF_MAX_QUEUE_DEPTH     255
                    339: #define RF_DEFAULT_QUEUE_DEPTH 100
1.1       oster     340:        char    debugVars[RF_MAXDBGV][50];      /* space for specifying debug
                    341:                                                 * variables & their values */
                    342:        unsigned int layoutSpecificSize;        /* size in bytes of
                    343:                                                 * layout-specific info */
                    344:        void   *layoutSpecific; /* a pointer to a layout-specific structure to
                    345:                                 * be copied in */
                    346:        int     force;                          /* if !0, ignore many fatal
                    347:                                                   configuration conditions */
1.8       perry     348:        /*
                    349:           "force" is used to override cases where the component labels would
                    350:           indicate that configuration should not proceed without user
1.1       oster     351:           intervention
                    352:         */
                    353: };
                    354: 
                    355: typedef RF_uint32 RF_ReconReqFlags_t;
                    356: /* flags that can be put in the rf_recon_req structure */
                    357: #define RF_FDFLAGS_NONE   0x0  /* just fail the disk */
                    358: #define RF_FDFLAGS_RECON  0x1  /* fail and initiate recon */
1.22      oster     359: #define RF_FDFLAGS_RECON_FORCE  0x2    /* fail and initiate recon, ignoring errors */
1.1       oster     360: 
                    361: struct rf_recon_req {          /* used to tell the kernel to fail a disk */
1.18      mrg       362:        RF_RowCol_t col;
1.1       oster     363:        RF_ReconReqFlags_t flags;
                    364: };
                    365: 
                    366: struct RF_SparetWait_s {
                    367:        int     C, G, fcol;     /* C = # disks in row, G = # units in stripe,
                    368:                                 * fcol = which disk has failed */
                    369: 
                    370:        RF_StripeCount_t SUsPerPU;      /* this stuff is the info required to
                    371:                                         * create a spare table */
                    372:        int     TablesPerSpareRegion;
                    373:        int     BlocksPerTable;
                    374:        RF_StripeCount_t TableDepthInPUs;
                    375:        RF_StripeCount_t SpareSpaceDepthPerRegionInSUs;
                    376: 
                    377:        RF_SparetWait_t *next;  /* used internally; need not be set at ioctl
                    378:                                 * time */
                    379: };
                    380: /*
                    381:  * A physical disk can be in one of several states:
                    382:  * IF YOU ADD A STATE, CHECK TO SEE IF YOU NEED TO MODIFY RF_DEAD_DISK().
                    383:  */
                    384: enum RF_DiskStatus_e {
1.17      oster     385:        rf_ds_optimal,          /* no problems */
                    386:        rf_ds_failed,           /* disk has failed */
                    387:        rf_ds_reconstructing,   /* reconstruction ongoing */
                    388:        rf_ds_dist_spared,      /* reconstruction complete to distributed
1.1       oster     389:                                  * spare space, dead disk not yet replaced */
1.17      oster     390:        rf_ds_spared,           /* reconstruction complete, dead disk not 
                    391:                                   yet replaced */
                    392:        rf_ds_spare,            /* an available spare disk */
                    393:        rf_ds_used_spare,       /* a spare which has been used, and hence is
1.1       oster     394:                                  * not available */
1.17      oster     395:        rf_ds_rebuilding_spare  /* a spare which is being rebuilt to */
1.1       oster     396: };
                    397: typedef enum RF_DiskStatus_e RF_DiskStatus_t;
                    398: 
                    399: struct RF_RaidDisk_s {
                    400:         char    devname[56];    /* name of device file */
                    401:         RF_DiskStatus_t status; /* whether it is up or down */
                    402:         RF_RowCol_t spareCol;   /* if in status "spared", this identifies the
                    403:                                  * spare disk */
1.18      mrg       404:         int     blockSize;
                    405:         int     auto_configured;/* 1 if this component was autoconfigured.
                    406:                                    0 otherwise. */
1.1       oster     407:         RF_SectorCount_t numBlocks;     /* number of blocks, obtained via READ
                    408:                                          * CAPACITY */
1.8       perry     409:         RF_SectorCount_t partitionSize; /* The *actual* and *full* size of
1.1       oster     410:                                            the partition, from the disklabel */
                    411:         dev_t   dev;
                    412: };
1.18      mrg       413: #if 0
1.1       oster     414: /* The per-component label information that the user can set */
                    415: typedef struct RF_ComponentInfo_s {
                    416:        int row;              /* the row number of this component */
                    417:        int column;           /* the column number of this component */
                    418:        int serial_number;    /* a user-specified serial number for this
                    419:                                 RAID set */
                    420: } RF_ComponentInfo_t;
1.18      mrg       421: #endif
1.1       oster     422: 
                    423: /* The per-component label information */
                    424: typedef struct RF_ComponentLabel_s {
                    425:        int version;          /* The version of this label. */
                    426:        int serial_number;    /* a user-specified serial number for this
                    427:                                 RAID set */
                    428:        int mod_counter;      /* modification counter.  Changed (usually
1.8       perry     429:                                 by incrementing) every time the label
1.1       oster     430:                                 is changed */
                    431:        int row;              /* the row number of this component */
                    432:        int column;           /* the column number of this component */
                    433:        int num_rows;         /* number of rows in this RAID set */
                    434:        int num_columns;      /* number of columns in this RAID set */
                    435:        int clean;            /* 1 when clean, 0 when dirty */
                    436:        int status;           /* rf_ds_optimal, rf_ds_dist_spared, whatever. */
                    437:        /* stuff that will be in version 2 of the label */
                    438:        int sectPerSU;        /* Sectors per Stripe Unit */
                    439:        int SUsPerPU;         /* Stripe Units per Parity Units */
                    440:        int SUsPerRU;         /* Stripe Units per Reconstruction Units */
                    441:        int parityConfig;     /* '0' == RAID0, '1' == RAID1, etc. */
                    442:        int maxOutstanding;   /* maxOutstanding disk requests */
1.8       perry     443:        int blockSize;        /* size of component block.
1.1       oster     444:                                 (disklabel->d_secsize) */
1.15      enami     445:        u_int __numBlocks;    /* number of blocks on this component.  May
1.1       oster     446:                                 be smaller than the partition size. */
1.15      enami     447:        u_int __partitionSize;/* number of blocks on this *partition*.
1.1       oster     448:                                 Must exactly match the partition size
                    449:                                 from the disklabel. */
1.13      jld       450:        /* Parity map stuff. */
                    451:        int parity_map_modcount; /* If equal to mod_counter, then the last
                    452:                                    kernel to touch this label was
                    453:                                    parity-map-enabled. */
                    454:        u_int parity_map_flags;  /* See top of rf_paritymap.h */
                    455:        int parity_map_tickms; /* Length of parity map cooldown ticks. */
                    456:        int parity_map_ntick;  /* Number of parity map cooldown ticks. */
                    457:        u_int parity_map_regions; /* Number of parity map regions. */
                    458:        int future_use[28];   /* Future expansion */
                    459: 
1.8       perry     460:        int autoconfigure;    /* automatically configure this RAID set.
1.1       oster     461:                                 0 == no, 1 == yes */
                    462:        int root_partition;   /* Use this set as /
                    463:                                 0 == no, 1 == yes*/
1.8       perry     464:        int last_unit;        /* last unit number (e.g. 0 for /dev/raid0)
1.1       oster     465:                                 of this component.  Used for autoconfigure
                    466:                                 only. */
                    467:        int config_order;     /* 0 .. n.  The order in which the component
1.8       perry     468:                                 should be auto-configured.  E.g. 0 is will
1.1       oster     469:                                 done first, (and would become raid0).
                    470:                                 This may be in conflict with last_unit!!?! */
                    471:                              /* Not currently used. */
1.14      mrg       472:        u_int numBlocksHi;    /* The top 32-bits of the numBlocks member. */
                    473:        u_int partitionSizeHi;/* The top 32-bits of the partitionSize member. */
                    474:        int future_use2[42];  /* More future expansion */
1.1       oster     475: } RF_ComponentLabel_t;
                    476: 
1.15      enami     477: /*
                    478:  * Following four functions are access macros for the number of blocks
                    479:  * and partition size in component label.
                    480:  */
1.19      christos  481: static __inline RF_SectorCount_t
1.15      enami     482: rf_component_label_numblocks(const RF_ComponentLabel_t *cl)
                    483: {
                    484: 
                    485:        return ((RF_SectorCount_t)cl->numBlocksHi << 32) |
                    486:            cl->__numBlocks;
                    487: }
                    488: 
1.19      christos  489: static __inline void
1.15      enami     490: rf_component_label_set_numblocks(RF_ComponentLabel_t *cl, RF_SectorCount_t siz)
                    491: {
                    492: 
                    493:        cl->numBlocksHi = siz >> 32;
                    494:        cl->__numBlocks = siz;
                    495: }
                    496: 
1.19      christos  497: static __inline RF_SectorCount_t
1.15      enami     498: rf_component_label_partitionsize(const RF_ComponentLabel_t *cl)
                    499: {
                    500: 
                    501:        return ((RF_SectorCount_t)cl->partitionSizeHi << 32) |
                    502:            cl->__partitionSize;
                    503: }
                    504: 
1.19      christos  505: static __inline void
1.15      enami     506: rf_component_label_set_partitionsize(RF_ComponentLabel_t *cl,
                    507:     RF_SectorCount_t siz)
                    508: {
                    509: 
                    510:        cl->partitionSizeHi = siz >> 32;
                    511:        cl->__partitionSize = siz;
                    512: }
                    513: 
1.1       oster     514: typedef struct RF_SingleComponent_s {
1.18      mrg       515:        int row;                /* obsolete */
1.1       oster     516:        int column;
                    517:        char component_name[50]; /* name of the component */
1.8       perry     518: } RF_SingleComponent_t;
1.1       oster     519: 
                    520: typedef struct RF_DeviceConfig_s {
                    521:        u_int   cols;
                    522:        u_int   maxqdepth;
                    523:        int     ndevs;
                    524:        RF_RaidDisk_t devs[RF_MAX_DISKS];
1.20      christos  525:        u_int    nspares;
1.1       oster     526:        RF_RaidDisk_t spares[RF_MAX_DISKS];
                    527: }       RF_DeviceConfig_t;
                    528: 
                    529: typedef struct RF_ProgressInfo_s {
                    530:        RF_uint64 remaining;
                    531:        RF_uint64 completed;
                    532:        RF_uint64 total;
                    533: } RF_ProgressInfo_t;
                    534: 
1.4       dsl       535: #ifndef _STANDALONE
1.1       oster     536: typedef struct RF_LayoutSW_s {
                    537:        RF_ParityConfig_t parityConfig;
                    538:        const char *configName;
                    539: 
                    540: #ifndef _KERNEL
                    541:        /* layout-specific parsing */
1.8       perry     542:        int     (*MakeLayoutSpecific) (FILE * fp, RF_Config_t * cfgPtr,
1.1       oster     543:                                       void *arg);
                    544:        void   *makeLayoutSpecificArg;
                    545: #else                          /* !KERNEL */
                    546: 
                    547:        /* initialization routine */
1.8       perry     548:        int     (*Configure) (RF_ShutdownList_t ** shutdownListp,
1.1       oster     549:                              RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
                    550: 
1.18      mrg       551:        /* routine to map RAID sector address -> physical (col, offset) */
1.1       oster     552:        void    (*MapSector) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
1.8       perry     553:                              RF_RowCol_t * col,
1.1       oster     554:                              RF_SectorNum_t * diskSector, int remap);
                    555: 
1.18      mrg       556:        /* routine to map RAID sector address -> physical (c,o) of parity
1.1       oster     557:         * unit */
                    558:        void    (*MapParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
1.8       perry     559:                              RF_RowCol_t * col,
1.1       oster     560:                              RF_SectorNum_t * diskSector, int remap);
                    561: 
1.18      mrg       562:        /* routine to map RAID sector address -> physical (c,o) of Q unit */
1.8       perry     563:        void    (*MapQ) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
                    564:                         RF_RowCol_t * col,
1.1       oster     565:                         RF_SectorNum_t * diskSector, int remap);
                    566: 
                    567:        /* routine to identify the disks comprising a stripe */
                    568:        void    (*IdentifyStripe) (RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
1.5       oster     569:                                   RF_RowCol_t ** diskids);
1.1       oster     570: 
                    571:        /* routine to select a dag */
                    572:        void    (*SelectionFunc) (RF_Raid_t * raidPtr, RF_IoType_t type,
                    573:                                  RF_AccessStripeMap_t * asmap,
                    574:                                  RF_VoidFuncPtr *);
                    575: 
                    576:        /* map a stripe ID to a parity stripe ID.  This is typically the
                    577:         * identity mapping */
1.8       perry     578:        void    (*MapSIDToPSID) (RF_RaidLayout_t * layoutPtr,
1.1       oster     579:                                 RF_StripeNum_t stripeID,
1.8       perry     580:                                 RF_StripeNum_t * psID,
1.1       oster     581:                                 RF_ReconUnitNum_t * which_ru);
                    582: 
                    583:        /* get default head separation limit (may be NULL) */
                    584:        RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr);
                    585: 
                    586:        /* get default num recon buffers (may be NULL) */
                    587:        int     (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr);
                    588: 
                    589:        /* get number of spare recon units (may be NULL) */
                    590:        RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr);
                    591: 
                    592:        /* spare table installation (may be NULL) */
1.18      mrg       593:        int     (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t fcol);
1.1       oster     594: 
                    595:        /* recon buffer submission function */
                    596:        int     (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it,
                    597:                                      int use_committed);
                    598: 
                    599:        /*
                    600:          * verify that parity information for a stripe is correct
                    601:          * see rf_parityscan.h for return vals
                    602:          */
                    603:        int     (*VerifyParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
1.8       perry     604:                                 RF_PhysDiskAddr_t * parityPDA,
1.1       oster     605:                                 int correct_it, RF_RaidAccessFlags_t flags);
                    606: 
                    607:        /* number of faults tolerated by this mapping */
                    608:        int     faultsTolerated;
                    609: 
                    610:        /* states to step through in an access. Must end with "LastState". The
                    611:         * default is DefaultStates in rf_layout.c */
1.7       drochner  612:        const RF_AccessState_t *states;
1.1       oster     613: 
                    614:        RF_AccessStripeMapFlags_t flags;
                    615: #endif                         /* !KERNEL */
                    616: }       RF_LayoutSW_t;
1.4       dsl       617: #endif
1.1       oster     618: 
1.13      jld       619: 
                    620: /* Parity map declarations. */
                    621: #define RF_PARITYMAP_NREG 4096
                    622: #define RF_PARITYMAP_NBYTE howmany(RF_PARITYMAP_NREG, NBBY)
                    623: 
                    624: struct rf_pmctrs {
                    625:        uint64_t nwrite, ncachesync, nclearing;
                    626: };
                    627: 
                    628: struct rf_pmparams {
                    629:        int cooldown, tickms;
                    630:        u_int regions;
                    631: };
                    632: 
                    633: struct rf_pmstat {
                    634:        int enabled; /* if not set, rest of struct is zeroed */
                    635:        struct rf_pmparams params;
                    636:        daddr_t region_size;
                    637:        char dirty[RF_PARITYMAP_NBYTE];
                    638:        struct rf_pmctrs ctrs;
                    639: };
                    640: 
                    641: 
                    642: 
1.1       oster     643: #endif                         /* !_RF_RAIDFRAMEVAR_H_ */

CVSweb <webmaster@jp.NetBSD.org>