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
133typedef int8_t RF_int8;
134typedef u_int8_t RF_uint8;
135typedef int16_t RF_int16;
136typedef u_int16_t RF_uint16;
137typedef int32_t RF_int32;
138typedef u_int32_t RF_uint32;
139typedef int64_t RF_int64;
140typedef 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
161MALLOC_DECLARE(M_RAIDFRAME);
162#endif
163
164/*
165 * Now, some generic types
166 */
167typedef RF_uint64 RF_IoCount_t;
168typedef RF_uint64 RF_Offset_t;
169typedef RF_uint32 RF_PSSFlags_t;
170typedef RF_uint64 RF_SectorCount_t;
171typedef RF_uint64 RF_StripeCount_t;
172typedef RF_int64 RF_SectorNum_t;/* these are unsigned so we can set them to
173 * (-1) for "uninitialized" */
174typedef RF_int64 RF_StripeNum_t;
175typedef RF_int64 RF_RaidAddr_t;
176typedef int RF_RowCol_t; /* unsigned so it can be (-1) */
177typedef RF_int64 RF_HeadSepLimit_t;
178typedef RF_int64 RF_ReconUnitCount_t;
179typedef int RF_ReconUnitNum_t;
180
181typedef char RF_ParityConfig_t;
182
183typedef char RF_DiskQueueType_t[1024];
184#define RF_DISK_QUEUE_TYPE_NONE ""
185
186/* values for the 'type' field in a reconstruction buffer */
187typedef 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
194typedef 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
201typedef void (*RF_VoidFuncPtr) (void *,...);
202
203typedef RF_uint32 RF_AccessStripeMapFlags_t;
204typedef RF_uint32 RF_DiskQueueDataFlags_t;
205typedef RF_uint32 RF_DiskQueueFlags_t;
206typedef RF_uint32 RF_RaidAccessFlags_t;
207
208#define RF_DISKQUEUE_DATA_FLAGS_NONE ((RF_DiskQueueDataFlags_t)0)
209
210typedef struct RF_AccessStripeMap_s RF_AccessStripeMap_t;
211typedef struct RF_AccessStripeMapHeader_s RF_AccessStripeMapHeader_t;
212typedef struct RF_AllocListElem_s RF_AllocListElem_t;
213typedef struct RF_CallbackFuncDesc_s RF_CallbackFuncDesc_t;
214typedef struct RF_CallbackValueDesc_s RF_CallbackValueDesc_t;
215typedef struct RF_ChunkDesc_s RF_ChunkDesc_t;
216typedef struct RF_CommonLogData_s RF_CommonLogData_t;
217typedef struct RF_Config_s RF_Config_t;
218typedef struct RF_CumulativeStats_s RF_CumulativeStats_t;
219typedef struct RF_DagHeader_s RF_DagHeader_t;
220typedef struct RF_DagList_s RF_DagList_t;
221typedef struct RF_DagNode_s RF_DagNode_t;
222typedef struct RF_DeclusteredConfigInfo_s RF_DeclusteredConfigInfo_t;
223typedef struct RF_DiskId_s RF_DiskId_t;
224typedef struct RF_DiskMap_s RF_DiskMap_t;
225typedef struct RF_DiskQueue_s RF_DiskQueue_t;
226typedef struct RF_DiskQueueData_s RF_DiskQueueData_t;
227typedef struct RF_DiskQueueSW_s RF_DiskQueueSW_t;
228typedef struct RF_Etimer_s RF_Etimer_t;
229typedef struct RF_EventCreate_s RF_EventCreate_t;
230typedef struct RF_FreeList_s RF_FreeList_t;
231typedef struct RF_LockReqDesc_s RF_LockReqDesc_t;
232typedef struct RF_LockTableEntry_s RF_LockTableEntry_t;
233typedef struct RF_MCPair_s RF_MCPair_t;
234typedef struct RF_OwnerInfo_s RF_OwnerInfo_t;
235typedef struct RF_ParityLog_s RF_ParityLog_t;
236typedef struct RF_ParityLogAppendQueue_s RF_ParityLogAppendQueue_t;
237typedef struct RF_ParityLogData_s RF_ParityLogData_t;
238typedef struct RF_ParityLogDiskQueue_s RF_ParityLogDiskQueue_t;
239typedef struct RF_ParityLogQueue_s RF_ParityLogQueue_t;
240typedef struct RF_ParityLogRecord_s RF_ParityLogRecord_t;
241typedef struct RF_PerDiskReconCtrl_s RF_PerDiskReconCtrl_t;
242typedef struct RF_PSStatusHeader_s RF_PSStatusHeader_t;
243typedef struct RF_PhysDiskAddr_s RF_PhysDiskAddr_t;
244typedef struct RF_PropHeader_s RF_PropHeader_t;
245typedef struct RF_Raid_s RF_Raid_t;
246typedef struct RF_RaidAccessDesc_s RF_RaidAccessDesc_t;
247typedef struct RF_RaidDisk_s RF_RaidDisk_t;
248typedef struct RF_RaidLayout_s RF_RaidLayout_t;
249typedef struct RF_RaidReconDesc_s RF_RaidReconDesc_t;
250typedef struct RF_ReconBuffer_s RF_ReconBuffer_t;
251typedef struct RF_ReconConfig_s RF_ReconConfig_t;
252typedef struct RF_ReconCtrl_s RF_ReconCtrl_t;
253typedef struct RF_ReconDoneProc_s RF_ReconDoneProc_t;
254typedef struct RF_ReconEvent_s RF_ReconEvent_t;
255typedef struct RF_ReconMap_s RF_ReconMap_t;
256typedef struct RF_ReconMapListElem_s RF_ReconMapListElem_t;
257typedef struct RF_ReconParityStripeStatus_s RF_ReconParityStripeStatus_t;
258typedef struct RF_RedFuncs_s RF_RedFuncs_t;
259typedef struct RF_RegionBufferQueue_s RF_RegionBufferQueue_t;
260typedef struct RF_RegionInfo_s RF_RegionInfo_t;
261typedef struct RF_ShutdownList_s RF_ShutdownList_t;
262typedef struct RF_SpareTableEntry_s RF_SpareTableEntry_t;
263typedef struct RF_SparetWait_s RF_SparetWait_t;
264typedef struct RF_StripeLockDesc_s RF_StripeLockDesc_t;
265typedef struct RF_ThreadGroup_s RF_ThreadGroup_t;
266typedef struct RF_ThroughputStats_s RF_ThroughputStats_t;
267
268struct rf_paritymap;
269struct 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 */
276typedef 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
304struct 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
310union RF_GenericParam_u {
311 void *p;
312 RF_uint64 v;
313};
314typedef union RF_GenericParam_u RF_DagParam_t;
315typedef 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 */
321struct 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
354typedef 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
360struct rf_recon_req { /* used to tell the kernel to fail a disk */
361 RF_RowCol_t col;
362 RF_ReconReqFlags_t flags;
363};
364
365struct 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 */
383enum 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};
396typedef enum RF_DiskStatus_e RF_DiskStatus_t;
397
398struct 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 */
414typedef 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 */
423typedef 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 */
480static __inline RF_SectorCount_t
481rf_component_label_numblocks(const RF_ComponentLabel_t *cl)
482{
483
484 return ((RF_SectorCount_t)cl->numBlocksHi << 32) |
485 cl->__numBlocks;
486}
487
488static __inline void
489rf_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
496static __inline RF_SectorCount_t
497rf_component_label_partitionsize(const RF_ComponentLabel_t *cl)
498{
499
500 return ((RF_SectorCount_t)cl->partitionSizeHi << 32) |
501 cl->__partitionSize;
502}
503
504static __inline void
505rf_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
513typedef 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
519typedef 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
528typedef struct RF_ProgressInfo_s {
529 RF_uint64 remaining;
530 RF_uint64 completed;
531 RF_uint64 total;
532} RF_ProgressInfo_t;
533
534#ifndef _STANDALONE
535typedef 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
623struct rf_pmctrs {
624 uint64_t nwrite, ncachesync, nclearing;
625};
626
627struct rf_pmparams {
628 int cooldown, tickms;
629 u_int regions;
630};
631
632struct 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_ */