From 553cb3ed4603f4cfcb4af4789780f45ebd26a3ac Mon Sep 17 00:00:00 2001 From: Alex Rønne Petersen Date: Tue, 13 May 2025 01:23:13 +0200 Subject: libc: Add NetBSD system and libc headers from 10.1. sys/param.h was manually adjusted to not define __NetBSD_Version__ since it will be defined by the compiler. --- .../generic-netbsd/dev/raidframe/raidframeio.h | 138 +++++ .../generic-netbsd/dev/raidframe/raidframevar.h | 642 +++++++++++++++++++++ 2 files changed, 780 insertions(+) create mode 100644 lib/libc/include/generic-netbsd/dev/raidframe/raidframeio.h create mode 100644 lib/libc/include/generic-netbsd/dev/raidframe/raidframevar.h (limited to 'lib/libc/include/generic-netbsd/dev/raidframe') diff --git a/lib/libc/include/generic-netbsd/dev/raidframe/raidframeio.h b/lib/libc/include/generic-netbsd/dev/raidframe/raidframeio.h new file mode 100644 index 0000000000..05254e2fbb --- /dev/null +++ b/lib/libc/include/generic-netbsd/dev/raidframe/raidframeio.h @@ -0,0 +1,138 @@ +/* $NetBSD: raidframeio.h,v 1.11.6.1 2024/04/28 12:09:08 martin Exp $ */ +/*- + * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Greg Oster + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Copyright (c) 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Mark Holland + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +/***************************************************** + * + * raidframeio.h + * + * IOCTL's used by RAIDframe. + * + *****************************************************/ + + +#ifndef _RF_RAIDFRAMEIO_H_ +#define _RF_RAIDFRAMEIO_H_ + +#include "raidframevar.h" + +/* 1 was RAIDFRAME_CONFIGURE */ +#define RAIDFRAME_SHUTDOWN _IO ('r', 2) /* shutdown the driver */ +#define RAIDFRAME_TUR _IOW ('r', 3, dev_t) /* debug only: test unit + * ready */ +#define RAIDFRAME_FAIL_DISK _IOW ('r', 5, struct rf_recon_req) /* fail a disk & + * optionally start + * recon */ +#define RAIDFRAME_CHECK_RECON_STATUS _IOWR('r', 6, int) /* get reconstruction % + * complete on indicated + * row */ +#define RAIDFRAME_REWRITEPARITY _IO ('r', 7) /* rewrite (initialize) + * all parity */ +#define RAIDFRAME_COPYBACK _IO ('r', 8) /* copy reconstructed + * data back to replaced + * disk */ +#define RAIDFRAME_SPARET_WAIT _IOR ('r', 9, RF_SparetWait_t) /* does not return until + * kernel needs a spare + * table */ +#define RAIDFRAME_SEND_SPARET _IOW ('r', 10, void *) /* used to send a spare + * table down into the + * kernel */ +#define RAIDFRAME_ABORT_SPARET_WAIT _IO ('r', 11) /* used to wake up the + * sparemap daemon & + * tell it to exit */ +#define RAIDFRAME_START_ATRACE _IO ('r', 12) /* start tracing + * accesses */ +#define RAIDFRAME_STOP_ATRACE _IO ('r', 13) /* stop tracing accesses */ +#define RAIDFRAME_GET_SIZE _IOR ('r', 14, int) /* get size (# sectors) + * in raid device */ +/* 15 was RAIDFRAME_GET_INFO */ +#define RAIDFRAME_RESET_ACCTOTALS _IO ('r', 16) /* reset AccTotals for + * device */ +#define RAIDFRAME_GET_ACCTOTALS _IOR ('r', 17, RF_AccTotals_t) /* retrieve AccTotals + * for device */ +#define RAIDFRAME_KEEP_ACCTOTALS _IOW ('r', 18, int) /* turn AccTotals on or + * off for device */ +#define RAIDFRAME_GET_COMPONENT_LABEL _IOWR ('r', 19, RF_ComponentLabel_t) +#define RAIDFRAME_SET_COMPONENT_LABEL _IOW ('r', 20, RF_ComponentLabel_t) + +#define RAIDFRAME_INIT_LABELS _IOW ('r', 21, RF_ComponentLabel_t) +#define RAIDFRAME_ADD_HOT_SPARE _IOW ('r', 22, RF_SingleComponent_t) +#define RAIDFRAME_REMOVE_COMPONENT _IOW ('r', 23, RF_SingleComponent_t) +#define RAIDFRAME_REMOVE_HOT_SPARE RAIDFRAME_REMOVE_COMPONENT +#define RAIDFRAME_REBUILD_IN_PLACE _IOW ('r', 24, RF_SingleComponent_t) +#define RAIDFRAME_CHECK_PARITY _IOWR ('r', 25, int) +#define RAIDFRAME_CHECK_PARITYREWRITE_STATUS _IOWR ('r', 26, int) +#define RAIDFRAME_CHECK_COPYBACK_STATUS _IOWR ('r', 27, int) +#define RAIDFRAME_SET_AUTOCONFIG _IOWR ('r', 28, int) +#define RAIDFRAME_SET_ROOT _IOWR ('r', 29, int) +#define RAIDFRAME_DELETE_COMPONENT _IOW ('r', 30, RF_SingleComponent_t) +#define RAIDFRAME_INCORPORATE_HOT_SPARE _IOW ('r', 31, RF_SingleComponent_t) +/* 'Extended' status versions */ +#define RAIDFRAME_CHECK_RECON_STATUS_EXT _IOWR('r', 32, RF_ProgressInfo_t) +#define RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT _IOWR ('r', 33, RF_ProgressInfo_t) +#define RAIDFRAME_CHECK_COPYBACK_STATUS_EXT _IOWR ('r', 34, RF_ProgressInfo_t) +/* 35 was RAIDFRAME_CONFIGURE */ +/* 36 was RAIDFRAME_GET_INFO */ + +#define RAIDFRAME_PARITYMAP_STATUS _IOR('r', 37, struct rf_pmstat) +#define RAIDFRAME_PARITYMAP_GET_DISABLE _IOR('r', 38, int) +#define RAIDFRAME_PARITYMAP_SET_DISABLE _IOW('r', 39, int) +#define RAIDFRAME_PARITYMAP_SET_PARAMS _IOW('r', 40, struct rf_pmparams) +#define RAIDFRAME_SET_LAST_UNIT _IOW('r', 41, int) +#define RAIDFRAME_GET_INFO _IOWR('r', 42, RF_DeviceConfig_t *) /* get configuration */ +#define RAIDFRAME_CONFIGURE _IOW ('r', 43, void *) /* configure the driver */ +#define RAIDFRAME_RESCAN _IO ('r', 44) +#endif /* !_RF_RAIDFRAMEIO_H_ */ \ No newline at end of file diff --git a/lib/libc/include/generic-netbsd/dev/raidframe/raidframevar.h b/lib/libc/include/generic-netbsd/dev/raidframe/raidframevar.h new file mode 100644 index 0000000000..12665caea3 --- /dev/null +++ b/lib/libc/include/generic-netbsd/dev/raidframe/raidframevar.h @@ -0,0 +1,642 @@ +/* $NetBSD: raidframevar.h,v 1.23 2021/08/07 16:19:15 thorpej Exp $ */ +/*- + * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Greg Oster + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Copyright (c) 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Mark Holland + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +/* + * Copyright (c) 1995 Carnegie-Mellon University. + * All rights reserved. + * + * Author: Jim Zelenka + * + * Permission to use, copy, modify and distribute this software and + * its documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND + * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie the + * rights to redistribute these changes. + */ + +/***************************************************** + * + * raidframevar.h + * + * main header file for using raidframe in the kernel. + * + *****************************************************/ + + +#ifndef _RF_RAIDFRAMEVAR_H_ +#define _RF_RAIDFRAMEVAR_H_ + +#ifndef _STANDALONE +#include + +#include +#include + +#include +#include +#include + +#include +#endif + +/* + * First, define system-dependent types and constants. + * + * If the machine is big-endian, RF_BIG_ENDIAN should be 1. + * Otherwise, it should be 0. + * + * The various integer types should be self-explanatory; we + * use these elsewhere to avoid size confusion. + * + * LONGSHIFT is lg(sizeof(long)) (that is, log base two of sizeof(long) + * + */ + +#include +#include +#include + +#if BYTE_ORDER == BIG_ENDIAN +#define RF_IS_BIG_ENDIAN 1 +#elif BYTE_ORDER == LITTLE_ENDIAN +#define RF_IS_BIG_ENDIAN 0 +#else +#error byte order not defined +#endif +typedef int8_t RF_int8; +typedef u_int8_t RF_uint8; +typedef int16_t RF_int16; +typedef u_int16_t RF_uint16; +typedef int32_t RF_int32; +typedef u_int32_t RF_uint32; +typedef int64_t RF_int64; +typedef u_int64_t RF_uint64; +#if LONG_BIT == 32 +#define RF_LONGSHIFT 2 +#elif LONG_BIT == 64 +#define RF_LONGSHIFT 3 +#else +#error word size not defined +#endif + +/* + * These are just zero and non-zero. We don't use "TRUE" + * and "FALSE" because there's too much nonsense trying + * to get them defined exactly once on every platform, given + * the different places they may be defined in system header + * files. + */ +#define RF_TRUE 1 +#define RF_FALSE 0 + +/* Malloc types. */ +#ifdef _KERNEL +MALLOC_DECLARE(M_RAIDFRAME); +#endif + +/* + * Now, some generic types + */ +typedef RF_uint64 RF_IoCount_t; +typedef RF_uint64 RF_Offset_t; +typedef RF_uint32 RF_PSSFlags_t; +typedef RF_uint64 RF_SectorCount_t; +typedef RF_uint64 RF_StripeCount_t; +typedef RF_int64 RF_SectorNum_t;/* these are unsigned so we can set them to + * (-1) for "uninitialized" */ +typedef RF_int64 RF_StripeNum_t; +typedef RF_int64 RF_RaidAddr_t; +typedef int RF_RowCol_t; /* unsigned so it can be (-1) */ +typedef RF_int64 RF_HeadSepLimit_t; +typedef RF_int64 RF_ReconUnitCount_t; +typedef int RF_ReconUnitNum_t; + +typedef char RF_ParityConfig_t; + +typedef char RF_DiskQueueType_t[1024]; +#define RF_DISK_QUEUE_TYPE_NONE "" + +/* values for the 'type' field in a reconstruction buffer */ +typedef int RF_RbufType_t; +#define RF_RBUF_TYPE_EXCLUSIVE 0 /* this buf assigned exclusively to + * one disk */ +#define RF_RBUF_TYPE_FLOATING 1 /* this is a floating recon buf */ +#define RF_RBUF_TYPE_FORCED 2 /* this rbuf was allocated to complete + * a forced recon */ + +typedef char RF_IoType_t; +#define RF_IO_TYPE_READ 'r' +#define RF_IO_TYPE_WRITE 'w' +#define RF_IO_TYPE_NOP 'n' +#define RF_IO_IS_R_OR_W(_type_) (((_type_) == RF_IO_TYPE_READ) \ + || ((_type_) == RF_IO_TYPE_WRITE)) + +typedef void (*RF_VoidFuncPtr) (void *,...); + +typedef RF_uint32 RF_AccessStripeMapFlags_t; +typedef RF_uint32 RF_DiskQueueDataFlags_t; +typedef RF_uint32 RF_DiskQueueFlags_t; +typedef RF_uint32 RF_RaidAccessFlags_t; + +#define RF_DISKQUEUE_DATA_FLAGS_NONE ((RF_DiskQueueDataFlags_t)0) + +typedef struct RF_AccessStripeMap_s RF_AccessStripeMap_t; +typedef struct RF_AccessStripeMapHeader_s RF_AccessStripeMapHeader_t; +typedef struct RF_AllocListElem_s RF_AllocListElem_t; +typedef struct RF_CallbackFuncDesc_s RF_CallbackFuncDesc_t; +typedef struct RF_CallbackValueDesc_s RF_CallbackValueDesc_t; +typedef struct RF_ChunkDesc_s RF_ChunkDesc_t; +typedef struct RF_CommonLogData_s RF_CommonLogData_t; +typedef struct RF_Config_s RF_Config_t; +typedef struct RF_CumulativeStats_s RF_CumulativeStats_t; +typedef struct RF_DagHeader_s RF_DagHeader_t; +typedef struct RF_DagList_s RF_DagList_t; +typedef struct RF_DagNode_s RF_DagNode_t; +typedef struct RF_DeclusteredConfigInfo_s RF_DeclusteredConfigInfo_t; +typedef struct RF_DiskId_s RF_DiskId_t; +typedef struct RF_DiskMap_s RF_DiskMap_t; +typedef struct RF_DiskQueue_s RF_DiskQueue_t; +typedef struct RF_DiskQueueData_s RF_DiskQueueData_t; +typedef struct RF_DiskQueueSW_s RF_DiskQueueSW_t; +typedef struct RF_Etimer_s RF_Etimer_t; +typedef struct RF_EventCreate_s RF_EventCreate_t; +typedef struct RF_FreeList_s RF_FreeList_t; +typedef struct RF_LockReqDesc_s RF_LockReqDesc_t; +typedef struct RF_LockTableEntry_s RF_LockTableEntry_t; +typedef struct RF_MCPair_s RF_MCPair_t; +typedef struct RF_OwnerInfo_s RF_OwnerInfo_t; +typedef struct RF_ParityLog_s RF_ParityLog_t; +typedef struct RF_ParityLogAppendQueue_s RF_ParityLogAppendQueue_t; +typedef struct RF_ParityLogData_s RF_ParityLogData_t; +typedef struct RF_ParityLogDiskQueue_s RF_ParityLogDiskQueue_t; +typedef struct RF_ParityLogQueue_s RF_ParityLogQueue_t; +typedef struct RF_ParityLogRecord_s RF_ParityLogRecord_t; +typedef struct RF_PerDiskReconCtrl_s RF_PerDiskReconCtrl_t; +typedef struct RF_PSStatusHeader_s RF_PSStatusHeader_t; +typedef struct RF_PhysDiskAddr_s RF_PhysDiskAddr_t; +typedef struct RF_PropHeader_s RF_PropHeader_t; +typedef struct RF_Raid_s RF_Raid_t; +typedef struct RF_RaidAccessDesc_s RF_RaidAccessDesc_t; +typedef struct RF_RaidDisk_s RF_RaidDisk_t; +typedef struct RF_RaidLayout_s RF_RaidLayout_t; +typedef struct RF_RaidReconDesc_s RF_RaidReconDesc_t; +typedef struct RF_ReconBuffer_s RF_ReconBuffer_t; +typedef struct RF_ReconConfig_s RF_ReconConfig_t; +typedef struct RF_ReconCtrl_s RF_ReconCtrl_t; +typedef struct RF_ReconDoneProc_s RF_ReconDoneProc_t; +typedef struct RF_ReconEvent_s RF_ReconEvent_t; +typedef struct RF_ReconMap_s RF_ReconMap_t; +typedef struct RF_ReconMapListElem_s RF_ReconMapListElem_t; +typedef struct RF_ReconParityStripeStatus_s RF_ReconParityStripeStatus_t; +typedef struct RF_RedFuncs_s RF_RedFuncs_t; +typedef struct RF_RegionBufferQueue_s RF_RegionBufferQueue_t; +typedef struct RF_RegionInfo_s RF_RegionInfo_t; +typedef struct RF_ShutdownList_s RF_ShutdownList_t; +typedef struct RF_SpareTableEntry_s RF_SpareTableEntry_t; +typedef struct RF_SparetWait_s RF_SparetWait_t; +typedef struct RF_StripeLockDesc_s RF_StripeLockDesc_t; +typedef struct RF_ThreadGroup_s RF_ThreadGroup_t; +typedef struct RF_ThroughputStats_s RF_ThroughputStats_t; + +struct rf_paritymap; +struct rf_paritymap_ondisk; + +/* + * Important assumptions regarding ordering of the states in this list + * have been made!!! Before disturbing this ordering, look at code in + * sys/dev/raidframe/rf_states.c + */ +typedef enum RF_AccessState_e { + /* original states */ + rf_QuiesceState, /* handles queisence for reconstruction */ + rf_IncrAccessesCountState, /* count accesses in flight */ + rf_MapState, /* map access to disk addresses */ + rf_LockState, /* take stripe locks */ + rf_CreateDAGState, /* create DAGs */ + rf_ExecuteDAGState, /* execute DAGs */ + rf_ProcessDAGState, /* DAGs are completing- check if correct, + * or if we need to retry */ + rf_CleanupState, /* release stripe locks, clean up */ + rf_DecrAccessesCountState, + rf_LastState /* must be the last state */ +} RF_AccessState_t; + + +/* Some constants related to RAIDframe. These are arbitrary and + can be modified at will. */ + +#define RF_MAXROW 10 +#define RF_MAXCOL 40 +#define RF_MAXSPARE 10 +#define RF_MAXDBGV 75 /* max number of debug variables */ +#define RF_MAX_DISKS 128 /* max disks per array */ +#define RF_SPAREMAP_NAME_LEN 128 +#define RF_PROTECTED_SECTORS 64L /* # of sectors at start of disk to + exclude from RAID address space */ + +struct RF_SpareTableEntry_s { + u_int spareDisk; /* disk to which this block is spared */ + u_int spareBlockOffsetInSUs; /* offset into spare table for that + * disk */ +}; + +union RF_GenericParam_u { + void *p; + RF_uint64 v; +}; +typedef union RF_GenericParam_u RF_DagParam_t; +typedef union RF_GenericParam_u RF_CBParam_t; + +/* the raidframe configuration, passed down through an ioctl. + * the driver can be reconfigured (with total loss of data) at any time, + * but it must be shut down first. + */ +struct RF_Config_s { + RF_RowCol_t numCol, numSpare; /* number of columns, + * and spare disks */ + dev_t devs[RF_MAXROW][RF_MAXCOL]; /* device numbers for disks + * comprising array */ + char devnames[RF_MAXROW][RF_MAXCOL][50]; /* device names */ + dev_t spare_devs[RF_MAXSPARE]; /* device numbers for spare + * disks */ + char spare_names[RF_MAXSPARE][50]; /* device names */ + RF_SectorNum_t sectPerSU; /* sectors per stripe unit */ + RF_StripeNum_t SUsPerPU;/* stripe units per parity unit */ + RF_StripeNum_t SUsPerRU;/* stripe units per reconstruction unit */ + RF_ParityConfig_t parityConfig; /* identifies the RAID architecture to + * be used */ + RF_DiskQueueType_t diskQueueType; /* 'f' = fifo, 'c' = cvscan, + * not used in kernel */ + char maxOutstandingDiskReqs; /* # concurrent reqs to be sent to a + * disk. not used in kernel. */ + char debugVars[RF_MAXDBGV][50]; /* space for specifying debug + * variables & their values */ + unsigned int layoutSpecificSize; /* size in bytes of + * layout-specific info */ + void *layoutSpecific; /* a pointer to a layout-specific structure to + * be copied in */ + int force; /* if !0, ignore many fatal + configuration conditions */ + /* + "force" is used to override cases where the component labels would + indicate that configuration should not proceed without user + intervention + */ +}; + +typedef RF_uint32 RF_ReconReqFlags_t; +/* flags that can be put in the rf_recon_req structure */ +#define RF_FDFLAGS_NONE 0x0 /* just fail the disk */ +#define RF_FDFLAGS_RECON 0x1 /* fail and initiate recon */ +#define RF_FDFLAGS_RECON_FORCE 0x2 /* fail and initiate recon, ignoring errors */ + +struct rf_recon_req { /* used to tell the kernel to fail a disk */ + RF_RowCol_t col; + RF_ReconReqFlags_t flags; +}; + +struct RF_SparetWait_s { + int C, G, fcol; /* C = # disks in row, G = # units in stripe, + * fcol = which disk has failed */ + + RF_StripeCount_t SUsPerPU; /* this stuff is the info required to + * create a spare table */ + int TablesPerSpareRegion; + int BlocksPerTable; + RF_StripeCount_t TableDepthInPUs; + RF_StripeCount_t SpareSpaceDepthPerRegionInSUs; + + RF_SparetWait_t *next; /* used internally; need not be set at ioctl + * time */ +}; +/* + * A physical disk can be in one of several states: + * IF YOU ADD A STATE, CHECK TO SEE IF YOU NEED TO MODIFY RF_DEAD_DISK(). + */ +enum RF_DiskStatus_e { + rf_ds_optimal, /* no problems */ + rf_ds_failed, /* disk has failed */ + rf_ds_reconstructing, /* reconstruction ongoing */ + rf_ds_dist_spared, /* reconstruction complete to distributed + * spare space, dead disk not yet replaced */ + rf_ds_spared, /* reconstruction complete, dead disk not + yet replaced */ + rf_ds_spare, /* an available spare disk */ + rf_ds_used_spare, /* a spare which has been used, and hence is + * not available */ + rf_ds_rebuilding_spare /* a spare which is being rebuilt to */ +}; +typedef enum RF_DiskStatus_e RF_DiskStatus_t; + +struct RF_RaidDisk_s { + char devname[56]; /* name of device file */ + RF_DiskStatus_t status; /* whether it is up or down */ + RF_RowCol_t spareCol; /* if in status "spared", this identifies the + * spare disk */ + int blockSize; + int auto_configured;/* 1 if this component was autoconfigured. + 0 otherwise. */ + RF_SectorCount_t numBlocks; /* number of blocks, obtained via READ + * CAPACITY */ + RF_SectorCount_t partitionSize; /* The *actual* and *full* size of + the partition, from the disklabel */ + dev_t dev; +}; +#if 0 +/* The per-component label information that the user can set */ +typedef struct RF_ComponentInfo_s { + int row; /* the row number of this component */ + int column; /* the column number of this component */ + int serial_number; /* a user-specified serial number for this + RAID set */ +} RF_ComponentInfo_t; +#endif + +/* The per-component label information */ +typedef struct RF_ComponentLabel_s { + int version; /* The version of this label. */ + int serial_number; /* a user-specified serial number for this + RAID set */ + int mod_counter; /* modification counter. Changed (usually + by incrementing) every time the label + is changed */ + int row; /* the row number of this component */ + int column; /* the column number of this component */ + int num_rows; /* number of rows in this RAID set */ + int num_columns; /* number of columns in this RAID set */ + int clean; /* 1 when clean, 0 when dirty */ + int status; /* rf_ds_optimal, rf_ds_dist_spared, whatever. */ + /* stuff that will be in version 2 of the label */ + int sectPerSU; /* Sectors per Stripe Unit */ + int SUsPerPU; /* Stripe Units per Parity Units */ + int SUsPerRU; /* Stripe Units per Reconstruction Units */ + int parityConfig; /* '0' == RAID0, '1' == RAID1, etc. */ + int maxOutstanding; /* maxOutstanding disk requests */ + int blockSize; /* size of component block. + (disklabel->d_secsize) */ + u_int __numBlocks; /* number of blocks on this component. May + be smaller than the partition size. */ + u_int __partitionSize;/* number of blocks on this *partition*. + Must exactly match the partition size + from the disklabel. */ + /* Parity map stuff. */ + int parity_map_modcount; /* If equal to mod_counter, then the last + kernel to touch this label was + parity-map-enabled. */ + u_int parity_map_flags; /* See top of rf_paritymap.h */ + int parity_map_tickms; /* Length of parity map cooldown ticks. */ + int parity_map_ntick; /* Number of parity map cooldown ticks. */ + u_int parity_map_regions; /* Number of parity map regions. */ + int future_use[28]; /* Future expansion */ + + int autoconfigure; /* automatically configure this RAID set. + 0 == no, 1 == yes */ + int root_partition; /* Use this set as / + 0 == no, 1 == yes*/ + int last_unit; /* last unit number (e.g. 0 for /dev/raid0) + of this component. Used for autoconfigure + only. */ + int config_order; /* 0 .. n. The order in which the component + should be auto-configured. E.g. 0 is will + done first, (and would become raid0). + This may be in conflict with last_unit!!?! */ + /* Not currently used. */ + u_int numBlocksHi; /* The top 32-bits of the numBlocks member. */ + u_int partitionSizeHi;/* The top 32-bits of the partitionSize member. */ + int future_use2[42]; /* More future expansion */ +} RF_ComponentLabel_t; + +/* + * Following four functions are access macros for the number of blocks + * and partition size in component label. + */ +static __inline RF_SectorCount_t +rf_component_label_numblocks(const RF_ComponentLabel_t *cl) +{ + + return ((RF_SectorCount_t)cl->numBlocksHi << 32) | + cl->__numBlocks; +} + +static __inline void +rf_component_label_set_numblocks(RF_ComponentLabel_t *cl, RF_SectorCount_t siz) +{ + + cl->numBlocksHi = siz >> 32; + cl->__numBlocks = siz; +} + +static __inline RF_SectorCount_t +rf_component_label_partitionsize(const RF_ComponentLabel_t *cl) +{ + + return ((RF_SectorCount_t)cl->partitionSizeHi << 32) | + cl->__partitionSize; +} + +static __inline void +rf_component_label_set_partitionsize(RF_ComponentLabel_t *cl, + RF_SectorCount_t siz) +{ + + cl->partitionSizeHi = siz >> 32; + cl->__partitionSize = siz; +} + +typedef struct RF_SingleComponent_s { + int row; /* obsolete */ + int column; + char component_name[50]; /* name of the component */ +} RF_SingleComponent_t; + +typedef struct RF_DeviceConfig_s { + u_int cols; + u_int maxqdepth; + int ndevs; + RF_RaidDisk_t devs[RF_MAX_DISKS]; + u_int nspares; + RF_RaidDisk_t spares[RF_MAX_DISKS]; +} RF_DeviceConfig_t; + +typedef struct RF_ProgressInfo_s { + RF_uint64 remaining; + RF_uint64 completed; + RF_uint64 total; +} RF_ProgressInfo_t; + +#ifndef _STANDALONE +typedef struct RF_LayoutSW_s { + RF_ParityConfig_t parityConfig; + const char *configName; + +#ifndef _KERNEL + /* layout-specific parsing */ + int (*MakeLayoutSpecific) (FILE * fp, RF_Config_t * cfgPtr, + void *arg); + void *makeLayoutSpecificArg; +#else /* !KERNEL */ + + /* initialization routine */ + int (*Configure) (RF_ShutdownList_t ** shutdownListp, + RF_Raid_t * raidPtr, RF_Config_t * cfgPtr); + + /* routine to map RAID sector address -> physical (col, offset) */ + void (*MapSector) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector, + RF_RowCol_t * col, + RF_SectorNum_t * diskSector, int remap); + + /* routine to map RAID sector address -> physical (c,o) of parity + * unit */ + void (*MapParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector, + RF_RowCol_t * col, + RF_SectorNum_t * diskSector, int remap); + + /* routine to map RAID sector address -> physical (c,o) of Q unit */ + void (*MapQ) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector, + RF_RowCol_t * col, + RF_SectorNum_t * diskSector, int remap); + + /* routine to identify the disks comprising a stripe */ + void (*IdentifyStripe) (RF_Raid_t * raidPtr, RF_RaidAddr_t addr, + RF_RowCol_t ** diskids); + + /* routine to select a dag */ + void (*SelectionFunc) (RF_Raid_t * raidPtr, RF_IoType_t type, + RF_AccessStripeMap_t * asmap, + RF_VoidFuncPtr *); + + /* map a stripe ID to a parity stripe ID. This is typically the + * identity mapping */ + void (*MapSIDToPSID) (RF_RaidLayout_t * layoutPtr, + RF_StripeNum_t stripeID, + RF_StripeNum_t * psID, + RF_ReconUnitNum_t * which_ru); + + /* get default head separation limit (may be NULL) */ + RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr); + + /* get default num recon buffers (may be NULL) */ + int (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr); + + /* get number of spare recon units (may be NULL) */ + RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr); + + /* spare table installation (may be NULL) */ + int (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t fcol); + + /* recon buffer submission function */ + int (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it, + int use_committed); + + /* + * verify that parity information for a stripe is correct + * see rf_parityscan.h for return vals + */ + int (*VerifyParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr, + RF_PhysDiskAddr_t * parityPDA, + int correct_it, RF_RaidAccessFlags_t flags); + + /* number of faults tolerated by this mapping */ + int faultsTolerated; + + /* states to step through in an access. Must end with "LastState". The + * default is DefaultStates in rf_layout.c */ + const RF_AccessState_t *states; + + RF_AccessStripeMapFlags_t flags; +#endif /* !KERNEL */ +} RF_LayoutSW_t; +#endif + + +/* Parity map declarations. */ +#define RF_PARITYMAP_NREG 4096 +#define RF_PARITYMAP_NBYTE howmany(RF_PARITYMAP_NREG, NBBY) + +struct rf_pmctrs { + uint64_t nwrite, ncachesync, nclearing; +}; + +struct rf_pmparams { + int cooldown, tickms; + u_int regions; +}; + +struct rf_pmstat { + int enabled; /* if not set, rest of struct is zeroed */ + struct rf_pmparams params; + daddr_t region_size; + char dirty[RF_PARITYMAP_NBYTE]; + struct rf_pmctrs ctrs; +}; + + + +#endif /* !_RF_RAIDFRAMEVAR_H_ */ \ No newline at end of file -- cgit v1.2.3