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>