1 /* $NetBSD: raidframevar.h,v 1.23 2021/08/07 16:19:15 thorpej 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 *
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
96 #ifndef _STANDALONE
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
106 #include <sys/mallocvar.h>
107 #endif
108
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
158
159 /* Malloc types. */
160 #ifdef _KERNEL
161 MALLOC_DECLARE(M_RAIDFRAME);
162 #endif
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_CallbackFuncDesc_s RF_CallbackFuncDesc_t;
214 typedef struct RF_CallbackValueDesc_s RF_CallbackValueDesc_t;
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
268 struct rf_paritymap;
269 struct rf_paritymap_ondisk;
270
271 /*
272 * Important assumptions regarding ordering of the states in this list
273 * have been made!!! Before disturbing this ordering, look at code in
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 */
287 rf_DecrAccessesCountState,
288 rf_LastState /* must be the last state */
289 } RF_AccessState_t;
290
291
292 /* Some constants related to RAIDframe. These are arbitrary and
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 {
322 RF_RowCol_t numCol, numSpare; /* number of columns,
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 */
335 RF_DiskQueueType_t diskQueueType; /* 'f' = fifo, 'c' = cvscan,
336 * not used in kernel */
337 char maxOutstandingDiskReqs; /* # concurrent reqs to be sent to a
338 * disk. not used in kernel. */
339 char debugVars[RF_MAXDBGV][50]; /* space for specifying debug
340 * variables & their values */
341 unsigned int layoutSpecificSize; /* size in bytes of
342 * layout-specific info */
343 void *layoutSpecific; /* a pointer to a layout-specific structure to
344 * be copied in */
345 int force; /* if !0, ignore many fatal
346 configuration conditions */
347 /*
348 "force" is used to override cases where the component labels would
349 indicate that configuration should not proceed without user
350 intervention
351 */
352 };
353
354 typedef RF_uint32 RF_ReconReqFlags_t;
355 /* flags that can be put in the rf_recon_req structure */
356 #define RF_FDFLAGS_NONE 0x0 /* just fail the disk */
357 #define RF_FDFLAGS_RECON 0x1 /* fail and initiate recon */
358 #define RF_FDFLAGS_RECON_FORCE 0x2 /* fail and initiate recon, ignoring errors */
359
360 struct rf_recon_req { /* used to tell the kernel to fail a disk */
361 RF_RowCol_t col;
362 RF_ReconReqFlags_t flags;
363 };
364
365 struct RF_SparetWait_s {
366 int C, G, fcol; /* C = # disks in row, G = # units in stripe,
367 * fcol = which disk has failed */
368
369 RF_StripeCount_t SUsPerPU; /* this stuff is the info required to
370 * create a spare table */
371 int TablesPerSpareRegion;
372 int BlocksPerTable;
373 RF_StripeCount_t TableDepthInPUs;
374 RF_StripeCount_t SpareSpaceDepthPerRegionInSUs;
375
376 RF_SparetWait_t *next; /* used internally; need not be set at ioctl
377 * time */
378 };
379 /*
380 * A physical disk can be in one of several states:
381 * IF YOU ADD A STATE, CHECK TO SEE IF YOU NEED TO MODIFY RF_DEAD_DISK().
382 */
383 enum RF_DiskStatus_e {
384 rf_ds_optimal, /* no problems */
385 rf_ds_failed, /* disk has failed */
386 rf_ds_reconstructing, /* reconstruction ongoing */
387 rf_ds_dist_spared, /* reconstruction complete to distributed
388 * spare space, dead disk not yet replaced */
389 rf_ds_spared, /* reconstruction complete, dead disk not
390 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 rf_ds_rebuilding_spare /* a spare which is being rebuilt to */
395 };
396 typedef enum RF_DiskStatus_e RF_DiskStatus_t;
397
398 struct RF_RaidDisk_s {
399 char devname[56]; /* name of device file */
400 RF_DiskStatus_t status; /* whether it is up or down */
401 RF_RowCol_t spareCol; /* if in status "spared", this identifies the
402 * spare disk */
403 int blockSize;
404 int auto_configured;/* 1 if this component was autoconfigured.
405 0 otherwise. */
406 RF_SectorCount_t numBlocks; /* number of blocks, obtained via READ
407 * CAPACITY */
408 RF_SectorCount_t partitionSize; /* The *actual* and *full* size of
409 the partition, from the disklabel */
410 dev_t dev;
411 };
412 #if 0
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 #endif
421
422 /* The per-component label information */
423 typedef struct RF_ComponentLabel_s {
424 int version; /* The version of this label. */
425 int serial_number; /* a user-specified serial number for this
426 RAID set */
427 int mod_counter; /* modification counter. Changed (usually
428 by incrementing) every time the label
429 is changed */
430 int row; /* the row number of this component */
431 int column; /* the column number of this component */
432 int num_rows; /* number of rows in this RAID set */
433 int num_columns; /* number of columns in this RAID set */
434 int clean; /* 1 when clean, 0 when dirty */
435 int status; /* rf_ds_optimal, rf_ds_dist_spared, whatever. */
436 /* stuff that will be in version 2 of the label */
437 int sectPerSU; /* Sectors per Stripe Unit */
438 int SUsPerPU; /* Stripe Units per Parity Units */
439 int SUsPerRU; /* Stripe Units per Reconstruction Units */
440 int parityConfig; /* '0' == RAID0, '1' == RAID1, etc. */
441 int maxOutstanding; /* maxOutstanding disk requests */
442 int blockSize; /* size of component block.
443 (disklabel->d_secsize) */
444 u_int __numBlocks; /* number of blocks on this component. May
445 be smaller than the partition size. */
446 u_int __partitionSize;/* number of blocks on this *partition*.
447 Must exactly match the partition size
448 from the disklabel. */
449 /* Parity map stuff. */
450 int parity_map_modcount; /* If equal to mod_counter, then the last
451 kernel to touch this label was
452 parity-map-enabled. */
453 u_int parity_map_flags; /* See top of rf_paritymap.h */
454 int parity_map_tickms; /* Length of parity map cooldown ticks. */
455 int parity_map_ntick; /* Number of parity map cooldown ticks. */
456 u_int parity_map_regions; /* Number of parity map regions. */
457 int future_use[28]; /* Future expansion */
458
459 int autoconfigure; /* automatically configure this RAID set.
460 0 == no, 1 == yes */
461 int root_partition; /* Use this set as /
462 0 == no, 1 == yes*/
463 int last_unit; /* last unit number (e.g. 0 for /dev/raid0)
464 of this component. Used for autoconfigure
465 only. */
466 int config_order; /* 0 .. n. The order in which the component
467 should be auto-configured. E.g. 0 is will
468 done first, (and would become raid0).
469 This may be in conflict with last_unit!!?! */
470 /* Not currently used. */
471 u_int numBlocksHi; /* The top 32-bits of the numBlocks member. */
472 u_int partitionSizeHi;/* The top 32-bits of the partitionSize member. */
473 int future_use2[42]; /* More future expansion */
474 } RF_ComponentLabel_t;
475
476 /*
477 * Following four functions are access macros for the number of blocks
478 * and partition size in component label.
479 */
480 static __inline RF_SectorCount_t
rf_component_label_numblocks(const RF_ComponentLabel_t * cl)481 rf_component_label_numblocks(const RF_ComponentLabel_t *cl)
482 {
483
484 return ((RF_SectorCount_t)cl->numBlocksHi << 32) |
485 cl->__numBlocks;
486 }
487
488 static __inline void
rf_component_label_set_numblocks(RF_ComponentLabel_t * cl,RF_SectorCount_t siz)489 rf_component_label_set_numblocks(RF_ComponentLabel_t *cl, RF_SectorCount_t siz)
490 {
491
492 cl->numBlocksHi = siz >> 32;
493 cl->__numBlocks = siz;
494 }
495
496 static __inline RF_SectorCount_t
rf_component_label_partitionsize(const RF_ComponentLabel_t * cl)497 rf_component_label_partitionsize(const RF_ComponentLabel_t *cl)
498 {
499
500 return ((RF_SectorCount_t)cl->partitionSizeHi << 32) |
501 cl->__partitionSize;
502 }
503
504 static __inline void
rf_component_label_set_partitionsize(RF_ComponentLabel_t * cl,RF_SectorCount_t siz)505 rf_component_label_set_partitionsize(RF_ComponentLabel_t *cl,
506 RF_SectorCount_t siz)
507 {
508
509 cl->partitionSizeHi = siz >> 32;
510 cl->__partitionSize = siz;
511 }
512
513 typedef struct RF_SingleComponent_s {
514 int row; /* obsolete */
515 int column;
516 char component_name[50]; /* name of the component */
517 } RF_SingleComponent_t;
518
519 typedef struct RF_DeviceConfig_s {
520 u_int cols;
521 u_int maxqdepth;
522 int ndevs;
523 RF_RaidDisk_t devs[RF_MAX_DISKS];
524 u_int nspares;
525 RF_RaidDisk_t spares[RF_MAX_DISKS];
526 } RF_DeviceConfig_t;
527
528 typedef struct RF_ProgressInfo_s {
529 RF_uint64 remaining;
530 RF_uint64 completed;
531 RF_uint64 total;
532 } RF_ProgressInfo_t;
533
534 #ifndef _STANDALONE
535 typedef struct RF_LayoutSW_s {
536 RF_ParityConfig_t parityConfig;
537 const char *configName;
538
539 #ifndef _KERNEL
540 /* layout-specific parsing */
541 int (*MakeLayoutSpecific) (FILE * fp, RF_Config_t * cfgPtr,
542 void *arg);
543 void *makeLayoutSpecificArg;
544 #else /* !KERNEL */
545
546 /* initialization routine */
547 int (*Configure) (RF_ShutdownList_t ** shutdownListp,
548 RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
549
550 /* routine to map RAID sector address -> physical (col, offset) */
551 void (*MapSector) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
552 RF_RowCol_t * col,
553 RF_SectorNum_t * diskSector, int remap);
554
555 /* routine to map RAID sector address -> physical (c,o) of parity
556 * unit */
557 void (*MapParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
558 RF_RowCol_t * col,
559 RF_SectorNum_t * diskSector, int remap);
560
561 /* routine to map RAID sector address -> physical (c,o) of Q unit */
562 void (*MapQ) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
563 RF_RowCol_t * col,
564 RF_SectorNum_t * diskSector, int remap);
565
566 /* routine to identify the disks comprising a stripe */
567 void (*IdentifyStripe) (RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
568 RF_RowCol_t ** diskids);
569
570 /* routine to select a dag */
571 void (*SelectionFunc) (RF_Raid_t * raidPtr, RF_IoType_t type,
572 RF_AccessStripeMap_t * asmap,
573 RF_VoidFuncPtr *);
574
575 /* map a stripe ID to a parity stripe ID. This is typically the
576 * identity mapping */
577 void (*MapSIDToPSID) (RF_RaidLayout_t * layoutPtr,
578 RF_StripeNum_t stripeID,
579 RF_StripeNum_t * psID,
580 RF_ReconUnitNum_t * which_ru);
581
582 /* get default head separation limit (may be NULL) */
583 RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr);
584
585 /* get default num recon buffers (may be NULL) */
586 int (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr);
587
588 /* get number of spare recon units (may be NULL) */
589 RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr);
590
591 /* spare table installation (may be NULL) */
592 int (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t fcol);
593
594 /* recon buffer submission function */
595 int (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it,
596 int use_committed);
597
598 /*
599 * verify that parity information for a stripe is correct
600 * see rf_parityscan.h for return vals
601 */
602 int (*VerifyParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
603 RF_PhysDiskAddr_t * parityPDA,
604 int correct_it, RF_RaidAccessFlags_t flags);
605
606 /* number of faults tolerated by this mapping */
607 int faultsTolerated;
608
609 /* states to step through in an access. Must end with "LastState". The
610 * default is DefaultStates in rf_layout.c */
611 const RF_AccessState_t *states;
612
613 RF_AccessStripeMapFlags_t flags;
614 #endif /* !KERNEL */
615 } RF_LayoutSW_t;
616 #endif
617
618
619 /* Parity map declarations. */
620 #define RF_PARITYMAP_NREG 4096
621 #define RF_PARITYMAP_NBYTE howmany(RF_PARITYMAP_NREG, NBBY)
622
623 struct rf_pmctrs {
624 uint64_t nwrite, ncachesync, nclearing;
625 };
626
627 struct rf_pmparams {
628 int cooldown, tickms;
629 u_int regions;
630 };
631
632 struct rf_pmstat {
633 int enabled; /* if not set, rest of struct is zeroed */
634 struct rf_pmparams params;
635 daddr_t region_size;
636 char dirty[RF_PARITYMAP_NBYTE];
637 struct rf_pmctrs ctrs;
638 };
639
640
641
642 #endif /* !_RF_RAIDFRAMEVAR_H_ */
643