1 /* $NetBSD: rf_layout.h,v 1.14 2004/03/20 04:22:05 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 /* rf_layout.h -- header file defining layout data structures
30 */
31
32 #ifndef _RF__RF_LAYOUT_H_
33 #define _RF__RF_LAYOUT_H_
34
35 #include <dev/raidframe/raidframevar.h>
36 #include "rf_archs.h"
37 #include "rf_alloclist.h"
38
39 /* enables remapping to spare location under dist sparing */
40 #define RF_REMAP 1
41 #define RF_DONT_REMAP 0
42
43 /*
44 * Flags values for RF_AccessStripeMapFlags_t
45 */
46 #define RF_NO_STRIPE_LOCKS 0x0001 /* suppress stripe locks */
47 #define RF_DISTRIBUTE_SPARE 0x0002 /* distribute spare space in archs
48 * that support it */
49 #define RF_BD_DECLUSTERED 0x0004 /* declustering uses block designs */
50
51 /*************************************************************************
52 *
53 * this structure forms the layout component of the main Raid
54 * structure. It describes everything needed to define and perform
55 * the mapping of logical RAID addresses <-> physical disk addresses.
56 *
57 *************************************************************************/
58 struct RF_RaidLayout_s {
59 /* configuration parameters */
60 RF_SectorCount_t sectorsPerStripeUnit; /* number of sectors in one
61 * stripe unit */
62 RF_StripeCount_t SUsPerPU; /* stripe units per parity unit */
63 RF_StripeCount_t SUsPerRU; /* stripe units per reconstruction
64 * unit */
65
66 /* redundant-but-useful info computed from the above, used in all
67 * layouts */
68 RF_StripeCount_t numStripe; /* total number of stripes in the
69 * array */
70 RF_SectorCount_t dataSectorsPerStripe;
71 RF_StripeCount_t dataStripeUnitsPerDisk;
72 RF_StripeCount_t numDataCol; /* number of SUs of data per stripe
73 * (name here is a la RAID4) */
74 RF_StripeCount_t numParityCol; /* number of SUs of parity per stripe.
75 * Always 1 for now */
76 RF_StripeCount_t numParityLogCol; /* number of SUs of parity log
77 * per stripe. Always 1 for
78 * now */
79 RF_StripeCount_t stripeUnitsPerDisk;
80
81 const RF_LayoutSW_t *map; /* ptr to struct holding mapping fns and
82 * information */
83 void *layoutSpecificInfo; /* ptr to a structure holding
84 * layout-specific params */
85 };
86 /*****************************************************************************************
87 *
88 * The mapping code returns a pointer to a list of AccessStripeMap structures, which
89 * describes all the mapping information about an access. The list contains one
90 * AccessStripeMap structure per stripe touched by the access. Each element in the list
91 * contains a stripe identifier and a pointer to a list of PhysDiskAddr structuress. Each
92 * element in this latter list describes the physical location of a stripe unit accessed
93 * within the corresponding stripe.
94 *
95 ****************************************************************************************/
96
97 #define RF_PDA_TYPE_DATA 0
98 #define RF_PDA_TYPE_PARITY 1
99 #define RF_PDA_TYPE_Q 2
100
101 struct RF_PhysDiskAddr_s {
102 RF_RowCol_t col; /* disk identifier */
103 RF_SectorNum_t startSector; /* sector offset into the disk */
104 RF_SectorCount_t numSector; /* number of sectors accessed */
105 int type; /* used by higher levels: currently, data,
106 * parity, or q */
107 caddr_t bufPtr; /* pointer to buffer supplying/receiving data */
108 RF_RaidAddr_t raidAddress; /* raid address corresponding to this
109 * physical disk address */
110 RF_PhysDiskAddr_t *next;
111 };
112 #define RF_MAX_FAILED_PDA RF_MAXCOL
113
114 struct RF_AccessStripeMap_s {
115 RF_StripeNum_t stripeID;/* the stripe index */
116 RF_RaidAddr_t raidAddress; /* the starting raid address within
117 * this stripe */
118 RF_RaidAddr_t endRaidAddress; /* raid address one sector past the
119 * end of the access */
120 RF_SectorCount_t totalSectorsAccessed; /* total num sectors
121 * identified in physInfo list */
122 RF_StripeCount_t numStripeUnitsAccessed; /* total num elements in
123 * physInfo list */
124 int numDataFailed; /* number of failed data disks accessed */
125 int numParityFailed;/* number of failed parity disks accessed (0
126 * or 1) */
127 int numQFailed; /* number of failed Q units accessed (0 or 1) */
128 RF_AccessStripeMapFlags_t flags; /* various flags */
129 int numFailedPDAs; /* number of failed phys addrs */
130 RF_PhysDiskAddr_t *failedPDAs[RF_MAX_FAILED_PDA]; /* array of failed phys
131 * addrs */
132 RF_PhysDiskAddr_t *physInfo; /* a list of PhysDiskAddr structs */
133 RF_PhysDiskAddr_t *parityInfo; /* list of physical addrs for the
134 * parity (P of P + Q ) */
135 RF_PhysDiskAddr_t *qInfo; /* list of physical addrs for the Q of
136 * P + Q */
137 RF_LockReqDesc_t lockReqDesc; /* used for stripe locking */
138 RF_AccessStripeMap_t *next;
139 };
140 /* flag values */
141 #define RF_ASM_REDIR_LARGE_WRITE 0x00000001 /* allows large-write creation
142 * code to redirect failed
143 * accs */
144 #define RF_ASM_BAILOUT_DAG_USED 0x00000002 /* allows us to detect
145 * recursive calls to the
146 * bailout write dag */
147 #define RF_ASM_FLAGS_LOCK_TRIED 0x00000004 /* we've acquired the lock on
148 * the first parity range in
149 * this parity stripe */
150 #define RF_ASM_FLAGS_LOCK_TRIED2 0x00000008 /* we've acquired the lock on
151 * the 2nd parity range in
152 * this parity stripe */
153 #define RF_ASM_FLAGS_FORCE_TRIED 0x00000010 /* we've done the force-recon
154 * call on this parity stripe */
155 #define RF_ASM_FLAGS_RECON_BLOCKED 0x00000020 /* we blocked recon => we must
156 * unblock it later */
157
158 struct RF_AccessStripeMapHeader_s {
159 RF_StripeCount_t numStripes; /* total number of stripes touched by
160 * this acc */
161 RF_AccessStripeMap_t *stripeMap; /* pointer to the actual map.
162 * Also used for making lists */
163 RF_AccessStripeMapHeader_t *next;
164 };
165
166 /* A structure to be used in a linked list to keep track of function pointers. */
167 typedef struct RF_VoidFunctionPointerListElem_s RF_VoidFunctionPointerListElem_t;
168 struct RF_VoidFunctionPointerListElem_s {
169 RF_VoidFuncPtr fn;
170 RF_VoidFunctionPointerListElem_t *next;
171 };
172
173 /* We need something to just be a linked list of anonymous pointers
174 to stuff */
175 typedef struct RF_VoidPointerListElem_s RF_VoidPointerListElem_t;
176 struct RF_VoidPointerListElem_s {
177 void *p;
178 RF_VoidPointerListElem_t *next;
179 };
180
181 /* A structure to be used in a linked list to keep track of ASM Headers */
182 typedef struct RF_ASMHeaderListElem_s RF_ASMHeaderListElem_t;
183 struct RF_ASMHeaderListElem_s {
184 RF_AccessStripeMapHeader_t *asmh;
185 RF_ASMHeaderListElem_t *next;
186 };
187
188 /* A structure to keep track of all the data structures associated with
189 a failed stripe. Used for constructing the appropriate DAGs in
190 rf_SelectAlgorithm() in rf_aselect.c */
191 typedef struct RF_FailedStripe_s RF_FailedStripe_t;
192 struct RF_FailedStripe_s {
193 RF_VoidFunctionPointerListElem_t *vfple; /* linked list of pointers to DAG creation
194 functions for stripes */
195 RF_VoidFunctionPointerListElem_t *bvfple; /* linked list of poitners to DAG creation
196 functions for blocks */
197 RF_ASMHeaderListElem_t *asmh_u; /* Access Stripe Map Headers for regular
198 stripes */
199 RF_ASMHeaderListElem_t *asmh_b; /* Access Stripe Map Headers used for the
200 block functions */
201 RF_FailedStripe_t *next;
202 };
203
204
205
206 /*****************************************************************************************
207 *
208 * various routines mapping addresses in the RAID address space. These work across
209 * all layouts. DON'T PUT ANY LAYOUT-SPECIFIC CODE HERE.
210 *
211 ****************************************************************************************/
212
213 /* return the identifier of the stripe containing the given address */
214 #define rf_RaidAddressToStripeID(_layoutPtr_, _addr_) \
215 ( ((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) / (_layoutPtr_)->numDataCol )
216
217 /* return the raid address of the start of the indicates stripe ID */
218 #define rf_StripeIDToRaidAddress(_layoutPtr_, _sid_) \
219 ( ((_sid_) * (_layoutPtr_)->sectorsPerStripeUnit) * (_layoutPtr_)->numDataCol )
220
221 /* return the identifier of the stripe containing the given stripe unit id */
222 #define rf_StripeUnitIDToStripeID(_layoutPtr_, _addr_) \
223 ( (_addr_) / (_layoutPtr_)->numDataCol )
224
225 /* return the identifier of the stripe unit containing the given address */
226 #define rf_RaidAddressToStripeUnitID(_layoutPtr_, _addr_) \
227 ( ((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) )
228
229 /* return the RAID address of next stripe boundary beyond the given address */
230 #define rf_RaidAddressOfNextStripeBoundary(_layoutPtr_, _addr_) \
231 ( (((_addr_)/(_layoutPtr_)->dataSectorsPerStripe)+1) * (_layoutPtr_)->dataSectorsPerStripe )
232
233 /* return the RAID address of the start of the stripe containing the given address */
234 #define rf_RaidAddressOfPrevStripeBoundary(_layoutPtr_, _addr_) \
235 ( (((_addr_)/(_layoutPtr_)->dataSectorsPerStripe)+0) * (_layoutPtr_)->dataSectorsPerStripe )
236
237 /* return the RAID address of next stripe unit boundary beyond the given address */
238 #define rf_RaidAddressOfNextStripeUnitBoundary(_layoutPtr_, _addr_) \
239 ( (((_addr_)/(_layoutPtr_)->sectorsPerStripeUnit)+1L)*(_layoutPtr_)->sectorsPerStripeUnit )
240
241 /* return the RAID address of the start of the stripe unit containing RAID address _addr_ */
242 #define rf_RaidAddressOfPrevStripeUnitBoundary(_layoutPtr_, _addr_) \
243 ( (((_addr_)/(_layoutPtr_)->sectorsPerStripeUnit)+0)*(_layoutPtr_)->sectorsPerStripeUnit )
244
245 /* returns the offset into the stripe. used by RaidAddressStripeAligned */
246 #define rf_RaidAddressStripeOffset(_layoutPtr_, _addr_) \
247 ( (_addr_) % ((_layoutPtr_)->dataSectorsPerStripe) )
248
249 /* returns the offset into the stripe unit. */
250 #define rf_StripeUnitOffset(_layoutPtr_, _addr_) \
251 ( (_addr_) % ((_layoutPtr_)->sectorsPerStripeUnit) )
252
253 /* returns nonzero if the given RAID address is stripe-aligned */
254 #define rf_RaidAddressStripeAligned( __layoutPtr__, __addr__ ) \
255 ( rf_RaidAddressStripeOffset(__layoutPtr__, __addr__) == 0 )
256
257 /* returns nonzero if the given address is stripe-unit aligned */
258 #define rf_StripeUnitAligned( __layoutPtr__, __addr__ ) \
259 ( rf_StripeUnitOffset(__layoutPtr__, __addr__) == 0 )
260
261 /* convert an address expressed in RAID blocks to/from an addr expressed in bytes */
262 #define rf_RaidAddressToByte(_raidPtr_, _addr_) \
263 ( (_addr_) << ( (_raidPtr_)->logBytesPerSector ) )
264
265 #define rf_ByteToRaidAddress(_raidPtr_, _addr_) \
266 ( (_addr_) >> ( (_raidPtr_)->logBytesPerSector ) )
267
268 /* convert a raid address to/from a parity stripe ID. Conversion to raid address is easy,
269 * since we're asking for the address of the first sector in the parity stripe. Conversion to a
270 * parity stripe ID is more complex, since stripes are not contiguously allocated in
271 * parity stripes.
272 */
273 #define rf_RaidAddressToParityStripeID(_layoutPtr_, _addr_, _ru_num_) \
274 rf_MapStripeIDToParityStripeID( (_layoutPtr_), rf_RaidAddressToStripeID( (_layoutPtr_), (_addr_) ), (_ru_num_) )
275
276 #define rf_ParityStripeIDToRaidAddress(_layoutPtr_, _psid_) \
277 ( (_psid_) * (_layoutPtr_)->SUsPerPU * (_layoutPtr_)->numDataCol * (_layoutPtr_)->sectorsPerStripeUnit )
278
279 const RF_LayoutSW_t *rf_GetLayout(RF_ParityConfig_t parityConfig);
280 int
281 rf_ConfigureLayout(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
282 RF_Config_t * cfgPtr);
283 RF_StripeNum_t
284 rf_MapStripeIDToParityStripeID(RF_RaidLayout_t * layoutPtr,
285 RF_StripeNum_t stripeID, RF_ReconUnitNum_t * which_ru);
286
287 #endif /* !_RF__RF_LAYOUT_H_ */
Cache object: 36c7950b6f296296b0e6f3964c929877
|