1 /* $NetBSD: rf_raid.h,v 1.12 2000/02/24 17:12:10 oster Exp $ */ 2 /* 3 * Copyright (c) 1995 Carnegie-Mellon University. 4 * All rights reserved. 5 * 6 * Author: Mark Holland 7 * 8 * Permission to use, copy, modify and distribute this software and 9 * its documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation. 13 * 14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 16 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 17 * 18 * Carnegie Mellon requests users of this software to return to 19 * 20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 21 * School of Computer Science 22 * Carnegie Mellon University 23 * Pittsburgh PA 15213-3890 24 * 25 * any improvements or extensions that they make and grant Carnegie the 26 * rights to redistribute these changes. 27 */ 28 29 /********************************************** 30 * rf_raid.h -- main header file for RAID driver 31 **********************************************/ 32 33 34 #ifndef _RF__RF_RAID_H_ 35 #define _RF__RF_RAID_H_ 36 37 #include "rf_archs.h" 38 #include "rf_types.h" 39 #include "rf_threadstuff.h" 40 41 #include "rf_netbsd.h" 42 43 #include <sys/disklabel.h> 44 #include <sys/types.h> 45 46 #include "rf_alloclist.h" 47 #include "rf_stripelocks.h" 48 #include "rf_layout.h" 49 #include "rf_disks.h" 50 #include "rf_debugMem.h" 51 #include "rf_diskqueue.h" 52 #include "rf_reconstruct.h" 53 #include "rf_acctrace.h" 54 55 #if RF_INCLUDE_PARITYLOGGING > 0 56 #include "rf_paritylog.h" 57 #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ 58 59 #define RF_MAX_DISKS 128 /* max disks per array */ 60 #define RF_DEV2RAIDID(_dev) (DISKUNIT(_dev)) 61 62 #define RF_COMPONENT_LABEL_VERSION_1 1 63 #define RF_COMPONENT_LABEL_VERSION 2 64 #define RF_RAID_DIRTY 0 65 #define RF_RAID_CLEAN 1 66 67 68 /* 69 * Each row in the array is a distinct parity group, so 70 * each has it's own status, which is one of the following. 71 */ 72 typedef enum RF_RowStatus_e { 73 rf_rs_optimal, 74 rf_rs_degraded, 75 rf_rs_reconstructing, 76 rf_rs_reconfigured 77 } RF_RowStatus_t; 78 79 struct RF_CumulativeStats_s { 80 struct timeval start; /* the time when the stats were last started */ 81 struct timeval stop; /* the time when the stats were last stopped */ 82 long sum_io_us; /* sum of all user response times (us) */ 83 long num_ios; /* total number of I/Os serviced */ 84 long num_sect_moved; /* total number of sectors read or written */ 85 }; 86 87 struct RF_ThroughputStats_s { 88 RF_DECLARE_MUTEX(mutex) /* a mutex used to lock the configuration 89 * stuff */ 90 struct timeval start; /* timer started when numOutstandingRequests 91 * moves from 0 to 1 */ 92 struct timeval stop; /* timer stopped when numOutstandingRequests 93 * moves from 1 to 0 */ 94 RF_uint64 sum_io_us; /* total time timer is enabled */ 95 RF_uint64 num_ios; /* total number of ios processed by RAIDframe */ 96 long num_out_ios; /* number of outstanding ios */ 97 }; 98 99 struct RF_Raid_s { 100 /* This portion never changes, and can be accessed without locking */ 101 /* an exception is Disks[][].status, which requires locking when it is 102 * changed. XXX this is no longer true. numSpare and friends can 103 * change now. 104 */ 105 u_int numRow; /* number of rows of disks, typically == # of 106 * ranks */ 107 u_int numCol; /* number of columns of disks, typically == # 108 * of disks/rank */ 109 u_int numSpare; /* number of spare disks */ 110 int maxQueueDepth; /* max disk queue depth */ 111 RF_SectorCount_t totalSectors; /* total number of sectors in the 112 * array */ 113 RF_SectorCount_t sectorsPerDisk; /* number of sectors on each 114 * disk */ 115 u_int logBytesPerSector; /* base-2 log of the number of bytes 116 * in a sector */ 117 u_int bytesPerSector; /* bytes in a sector */ 118 RF_int32 sectorMask; /* mask of bytes-per-sector */ 119 120 RF_RaidLayout_t Layout; /* all information related to layout */ 121 RF_RaidDisk_t **Disks; /* all information related to physical disks */ 122 RF_DiskQueue_t **Queues;/* all information related to disk queues */ 123 RF_DiskQueueSW_t *qType;/* pointer to the DiskQueueSW used for the 124 component queues. */ 125 /* NOTE: This is an anchor point via which the queues can be 126 * accessed, but the enqueue/dequeue routines in diskqueue.c use a 127 * local copy of this pointer for the actual accesses. */ 128 /* The remainder of the structure can change, and therefore requires 129 * locking on reads and updates */ 130 RF_DECLARE_MUTEX(mutex) /* mutex used to serialize access to 131 * the fields below */ 132 RF_RowStatus_t *status; /* the status of each row in the array */ 133 int valid; /* indicates successful configuration */ 134 RF_LockTableEntry_t *lockTable; /* stripe-lock table */ 135 RF_LockTableEntry_t *quiesceLock; /* quiesnce table */ 136 int numFailures; /* total number of failures in the array */ 137 int numNewFailures; /* number of *new* failures (that havn't 138 caused a mod_counter update */ 139 140 int parity_good; /* !0 if parity is known to be correct */ 141 int serial_number; /* a "serial number" for this set */ 142 int mod_counter; /* modification counter for component labels */ 143 int clean; /* the clean bit for this array. */ 144 145 int openings; /* Number of IO's which can be scheduled 146 simultaneously (high-level - not a 147 per-component limit)*/ 148 149 int maxOutstanding; /* maxOutstanding requests (per-component) */ 150 int autoconfigure; /* automatically configure this RAID set. 151 0 == no, 1 == yes */ 152 int root_partition; /* Use this set as / 153 0 == no, 1 == yes*/ 154 int last_unit; /* last unit number (e.g. 0 for /dev/raid0) 155 of this component. Used for autoconfigure 156 only. */ 157 int config_order; /* 0 .. n. The order in which the component 158 should be auto-configured. E.g. 0 is will 159 done first, (and would become raid0). 160 This may be in conflict with last_unit!!?! */ 161 /* Not currently used. */ 162 163 /* 164 * Cleanup stuff 165 */ 166 RF_ShutdownList_t *shutdownList; /* shutdown activities */ 167 RF_AllocListElem_t *cleanupList; /* memory to be freed at 168 * shutdown time */ 169 170 /* 171 * Recon stuff 172 */ 173 RF_HeadSepLimit_t headSepLimit; 174 int numFloatingReconBufs; 175 int reconInProgress; 176 RF_DECLARE_COND(waitForReconCond) 177 RF_RaidReconDesc_t *reconDesc; /* reconstruction descriptor */ 178 RF_ReconCtrl_t **reconControl; /* reconstruction control structure 179 * pointers for each row in the array */ 180 181 /* 182 * Array-quiescence stuff 183 */ 184 RF_DECLARE_MUTEX(access_suspend_mutex) 185 RF_DECLARE_COND(quiescent_cond) 186 RF_IoCount_t accesses_suspended; 187 RF_IoCount_t accs_in_flight; 188 int access_suspend_release; 189 int waiting_for_quiescence; 190 RF_CallbackDesc_t *quiesce_wait_list; 191 192 /* 193 * Statistics 194 */ 195 #if !defined(_KERNEL) && !defined(SIMULATE) 196 RF_ThroughputStats_t throughputstats; 197 #endif /* !KERNEL && !SIMULATE */ 198 RF_CumulativeStats_t userstats; 199 int parity_rewrite_stripes_done; 200 int recon_stripes_done; 201 int copyback_stripes_done; 202 203 int recon_in_progress; 204 int parity_rewrite_in_progress; 205 int copyback_in_progress; 206 207 /* 208 * Engine thread control 209 */ 210 RF_DECLARE_MUTEX(node_queue_mutex) 211 RF_DECLARE_COND(node_queue_cond) 212 RF_DagNode_t *node_queue; 213 RF_Thread_t parity_rewrite_thread; 214 RF_Thread_t copyback_thread; 215 RF_Thread_t engine_thread; 216 RF_Thread_t recon_thread; 217 RF_ThreadGroup_t engine_tg; 218 int shutdown_engine; 219 int dags_in_flight; /* debug */ 220 221 /* 222 * PSS (Parity Stripe Status) stuff 223 */ 224 RF_FreeList_t *pss_freelist; 225 long pssTableSize; 226 227 /* 228 * Reconstruction stuff 229 */ 230 int procsInBufWait; 231 int numFullReconBuffers; 232 RF_AccTraceEntry_t *recon_tracerecs; 233 unsigned long accumXorTimeUs; 234 RF_ReconDoneProc_t *recon_done_procs; 235 RF_DECLARE_MUTEX(recon_done_proc_mutex) 236 /* 237 * nAccOutstanding, waitShutdown protected by desc freelist lock 238 * (This may seem strange, since that's a central serialization point 239 * for a per-array piece of data, but otherwise, it'd be an extra 240 * per-array lock, and that'd only be less efficient...) 241 */ 242 RF_DECLARE_COND(outstandingCond) 243 int waitShutdown; 244 int nAccOutstanding; 245 246 RF_DiskId_t **diskids; 247 RF_DiskId_t *sparediskids; 248 249 int raidid; 250 RF_AccTotals_t acc_totals; 251 int keep_acc_totals; 252 253 struct raidcinfo **raid_cinfo; /* array of component info */ 254 255 int terminate_disk_queues; 256 257 /* 258 * XXX 259 * 260 * config-specific information should be moved 261 * somewhere else, or at least hung off this 262 * in some generic way 263 */ 264 265 /* used by rf_compute_workload_shift */ 266 RF_RowCol_t hist_diskreq[RF_MAXROW][RF_MAXCOL]; 267 268 /* used by declustering */ 269 int noRotate; 270 271 #if RF_INCLUDE_PARITYLOGGING > 0 272 /* used by parity logging */ 273 RF_SectorCount_t regionLogCapacity; 274 RF_ParityLogQueue_t parityLogPool; /* pool of unused parity logs */ 275 RF_RegionInfo_t *regionInfo; /* array of region state */ 276 int numParityLogs; 277 int numSectorsPerLog; 278 int regionParityRange; 279 int logsInUse; /* debugging */ 280 RF_ParityLogDiskQueue_t parityLogDiskQueue; /* state of parity 281 * logging disk work */ 282 RF_RegionBufferQueue_t regionBufferPool; /* buffers for holding 283 * region log */ 284 RF_RegionBufferQueue_t parityBufferPool; /* buffers for holding 285 * parity */ 286 caddr_t parityLogBufferHeap; /* pool of unused parity logs */ 287 RF_Thread_t pLogDiskThreadHandle; 288 289 #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ 290 }; 291 #endif /* !_RF__RF_RAID_H_ */ 292