Annotation of sys/dev/raidframe/rf_declusterPQ.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_declusterPQ.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $ */
2: /* $NetBSD: rf_declusterPQ.c,v 1.3 1999/02/05 00:06:09 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Authors: Daniel Stodolsky, Mark Holland, Jim Zelenka
9: *
10: * Permission to use, copy, modify and distribute this software and
11: * its documentation is hereby granted, provided that both the copyright
12: * notice and this permission notice appear in all copies of the
13: * software, derivative works or modified versions, and any portions
14: * thereof, and that both notices appear in supporting documentation.
15: *
16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * Carnegie Mellon requests users of this software to return to
21: *
22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
23: * School of Computer Science
24: * Carnegie Mellon University
25: * Pittsburgh PA 15213-3890
26: *
27: * any improvements or extensions that they make and grant Carnegie the
28: * rights to redistribute these changes.
29: */
30:
31: /*****************************************************************************
32: * rf_declusterPQ.c
33: *
34: * Mapping code for declustered P & Q or declustered EvenOdd.
35: * Much code borrowed from rf_decluster.c
36: *
37: *****************************************************************************/
38:
39:
40: #include "rf_types.h"
41: #include "rf_raid.h"
42: #include "rf_configure.h"
43: #include "rf_decluster.h"
44: #include "rf_declusterPQ.h"
45: #include "rf_debugMem.h"
46: #include "rf_utils.h"
47: #include "rf_alloclist.h"
48: #include "rf_general.h"
49:
50: /* Configuration code. */
51:
52: int
53: rf_ConfigureDeclusteredPQ(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
54: RF_Config_t *cfgPtr)
55: {
56: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
57: int b, v, k, r, lambda; /* block design params */
58: int i, j, l;
59: int *first_avail_slot;
60: int complete_FT_count, SUID;
61: RF_DeclusteredConfigInfo_t *info;
62: int numCompleteFullTablesPerDisk;
63: int PUsPerDisk, spareRegionDepthInPUs, extraPUsPerDisk;
64: int numCompleteSpareRegionsPerDisk = 0;
65: int totSparePUsPerDisk;
66: int diskOffsetOfLastFullTableInSUs, SpareSpaceInSUs;
67: char *cfgBuf = (char *)(cfgPtr->layoutSpecific);
68:
69: cfgBuf += RF_SPAREMAP_NAME_LEN;
70:
71: b = *((int *) cfgBuf);
72: cfgBuf += sizeof(int);
73: v = *((int *) cfgBuf);
74: cfgBuf += sizeof(int);
75: k = *((int *) cfgBuf);
76: cfgBuf += sizeof(int);
77: r = *((int *) cfgBuf);
78: cfgBuf += sizeof(int);
79: lambda = *((int *) cfgBuf);
80: cfgBuf += sizeof(int);
81: raidPtr->noRotate = *((int *) cfgBuf);
82: cfgBuf += sizeof(int);
83:
84: if (k <= 2) {
85: #ifdef RAIDDEBUG
86: printf("RAIDFRAME: k=%d, minimum value 2\n", k);
87: #endif /* RAIDDEBUG */
88: return (EINVAL);
89: }
90: /* 1. Create layout specific structure. */
91: RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t),
92: (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
93: if (info == NULL)
94: return (ENOMEM);
95: layoutPtr->layoutSpecificInfo = (void *) info;
96:
97: /*
98: * 2. The sparemaps are generated assuming that parity is rotated, so
99: * we issue a warning if both distributed sparing and no-rotate are on
100: * at the same time.
101: */
102: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) &&
103: raidPtr->noRotate) {
104: RF_ERRORMSG("Warning: distributed sparing specified without"
105: " parity rotation.\n");
106: }
107: if (raidPtr->numCol != v) {
108: RF_ERRORMSG2("RAID: config error: table element count (%d)"
109: " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
110: return (EINVAL);
111: }
112: /* 3. Set up the values used in devRaidMap. */
113: info->BlocksPerTable = b;
114: info->NumParityReps = info->groupSize = k;
115: info->PUsPerBlock = k - 2; /* PQ */
116: info->SUsPerTable = b * info->PUsPerBlock * layoutPtr->SUsPerPU;
117: /* b blks, k-1 SUs each. */
118: info->SUsPerFullTable = k * info->SUsPerTable; /* Rot k times. */
119: info->SUsPerBlock = info->PUsPerBlock * layoutPtr->SUsPerPU;
120: info->TableDepthInPUs = (b * k) / v;
121: info->FullTableDepthInPUs = info->TableDepthInPUs * k;
122: /* k repetitions. */
123:
124: /* Used only in distributed sparing case. */
125: info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);
126: /* (v-1)/gcd fulltables. */
127: info->TablesPerSpareRegion = k * info->FullTablesPerSpareRegion;
128: info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion
129: / (v - 1)) * layoutPtr->SUsPerPU;
130:
131: /* Check to make sure the block design is sufficiently small. */
132: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
133: if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU +
134: info->SpareSpaceDepthPerRegionInSUs >
135: layoutPtr->stripeUnitsPerDisk) {
136: RF_ERRORMSG3("RAID: config error: Full Table depth"
137: " (%d) + Spare Space (%d) larger than disk size"
138: " (%d) (BD too big).\n",
139: (int)info->FullTableDepthInPUs,
140: (int)info->SpareSpaceDepthPerRegionInSUs,
141: (int)layoutPtr->stripeUnitsPerDisk);
142: return (EINVAL);
143: }
144: } else {
145: if (info->TableDepthInPUs * layoutPtr->SUsPerPU >
146: layoutPtr->stripeUnitsPerDisk) {
147: RF_ERRORMSG2("RAID: config error: Table depth (%d)"
148: " larger than disk size (%d) (BD too big).\n",
149: (int) (info->TableDepthInPUs * layoutPtr->SUsPerPU),
150: (int) layoutPtr->stripeUnitsPerDisk);
151: return (EINVAL);
152: }
153: }
154:
155: /*
156: * Compute the size of each disk, and the number of tables in the last
157: * fulltable (which need not be complete).
158: */
159: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
160:
161: PUsPerDisk = layoutPtr->stripeUnitsPerDisk /
162: layoutPtr->SUsPerPU;
163: spareRegionDepthInPUs = (info->TablesPerSpareRegion *
164: info->TableDepthInPUs + (info->TablesPerSpareRegion *
165: info->TableDepthInPUs) / (v - 1));
166: info->SpareRegionDepthInSUs = spareRegionDepthInPUs *
167: layoutPtr->SUsPerPU;
168:
169: numCompleteSpareRegionsPerDisk = PUsPerDisk /
170: spareRegionDepthInPUs;
171: info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
172: extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
173:
174: /*
175: * Assume conservatively that we need the full amount of spare
176: * space in one region in order to provide spares for the
177: * partial spare region at the end of the array. We set "i"
178: * to the number of tables in the partial spare region. This
179: * may actually include some fulltables.
180: */
181: extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs /
182: layoutPtr->SUsPerPU);
183: if (extraPUsPerDisk <= 0)
184: i = 0;
185: else
186: i = extraPUsPerDisk / info->TableDepthInPUs;
187:
188: complete_FT_count = raidPtr->numRow *
189: (numCompleteSpareRegionsPerDisk *
190: (info->TablesPerSpareRegion / k) + i / k);
191: info->FullTableLimitSUID = complete_FT_count *
192: info->SUsPerFullTable;
193: info->ExtraTablesPerDisk = i % k;
194:
195: /*
196: * Note that in the last spare region, the spare space is
197: * complete even though data/parity space is not.
198: */
199: totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) *
200: (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
201: info->TotSparePUsPerDisk = totSparePUsPerDisk;
202:
203: layoutPtr->stripeUnitsPerDisk =
204: ((complete_FT_count / raidPtr->numRow) *
205: info->FullTableDepthInPUs + /* data & parity space */
206: info->ExtraTablesPerDisk * info->TableDepthInPUs +
207: totSparePUsPerDisk /* spare space */
208: ) * layoutPtr->SUsPerPU;
209: layoutPtr->dataStripeUnitsPerDisk =
210: (complete_FT_count * info->FullTableDepthInPUs +
211: info->ExtraTablesPerDisk * info->TableDepthInPUs)
212: * layoutPtr->SUsPerPU * (k - 1) / k;
213:
214: } else {
215: /*
216: * Non-dist spare case: force each disk to contain an
217: * integral number of tables.
218: */
219: layoutPtr->stripeUnitsPerDisk /=
220: (info->TableDepthInPUs * layoutPtr->SUsPerPU);
221: layoutPtr->stripeUnitsPerDisk *=
222: (info->TableDepthInPUs * layoutPtr->SUsPerPU);
223:
224: /*
225: * Compute the number of tables in the last fulltable, which
226: * need not be complete.
227: */
228: complete_FT_count = ((layoutPtr->stripeUnitsPerDisk /
229: layoutPtr->SUsPerPU) / info->FullTableDepthInPUs) *
230: raidPtr->numRow;
231:
232: info->FullTableLimitSUID = complete_FT_count *
233: info->SUsPerFullTable;
234: info->ExtraTablesPerDisk = ((layoutPtr->stripeUnitsPerDisk /
235: layoutPtr->SUsPerPU) / info->TableDepthInPUs) % k;
236: }
237:
238: raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
239: layoutPtr->sectorsPerStripeUnit;
240:
241: /*
242: * Find the disk offset of the stripe unit where the last
243: * fulltable starts.
244: */
245: numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
246: diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk *
247: info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
248: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
249: SpareSpaceInSUs = numCompleteSpareRegionsPerDisk *
250: info->SpareSpaceDepthPerRegionInSUs;
251: diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
252: info->DiskOffsetOfLastSpareSpaceChunkInSUs =
253: diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk *
254: info->TableDepthInPUs * layoutPtr->SUsPerPU;
255: }
256: info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
257: info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
258:
259: /* 4. Create and initialize the lookup tables. */
260: info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
261: if (info->LayoutTable == NULL)
262: return (ENOMEM);
263:
264: info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
265: if (info->OffsetTable == NULL)
266: return (ENOMEM);
267:
268: info->BlockTable = rf_make_2d_array(info->TableDepthInPUs *
269: layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
270: if (info->BlockTable == NULL)
271: return (ENOMEM);
272:
273: first_avail_slot = (int *) rf_make_1d_array(v, NULL);
274: if (first_avail_slot == NULL)
275: return (ENOMEM);
276:
277: for (i = 0; i < b; i++)
278: for (j = 0; j < k; j++)
279: info->LayoutTable[i][j] = *cfgBuf++;
280:
281: /* Initialize offset table. */
282: for (i = 0; i < b; i++)
283: for (j = 0; j < k; j++) {
284: info->OffsetTable[i][j] =
285: first_avail_slot[info->LayoutTable[i][j]];
286: first_avail_slot[info->LayoutTable[i][j]]++;
287: }
288:
289: /* Initialize block table. */
290: for (SUID = l = 0; l < layoutPtr->SUsPerPU; l++) {
291: for (i = 0; i < b; i++) {
292: for (j = 0; j < k; j++) {
293: info->BlockTable[(info->OffsetTable[i][j] *
294: layoutPtr->SUsPerPU) + l]
295: [info->LayoutTable[i][j]] = SUID;
296: }
297: SUID++;
298: }
299: }
300:
301: rf_free_1d_array(first_avail_slot, v);
302:
303: /* 5. Set up the remaining redundant-but-useful parameters. */
304:
305: raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
306: info->ExtraTablesPerDisk) * info->SUsPerTable *
307: layoutPtr->sectorsPerStripeUnit;
308: layoutPtr->numStripe = (raidPtr->totalSectors /
309: layoutPtr->sectorsPerStripeUnit) / (k - 2);
310:
311: /*
312: * Strange evaluation order below to try and minimize overflow
313: * problems.
314: */
315:
316: layoutPtr->dataSectorsPerStripe = (k - 2) *
317: layoutPtr->sectorsPerStripeUnit;
318: layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
319: raidPtr->logBytesPerSector;
320: layoutPtr->numDataCol = k - 2;
321: layoutPtr->numParityCol = 2;
322:
323: return (0);
324: }
325:
326: int
327: rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t *raidPtr)
328: {
329: int def_decl;
330:
331: def_decl = rf_GetDefaultNumFloatingReconBuffersDeclustered(raidPtr);
332: return (RF_MAX(3 * raidPtr->numCol, def_decl));
333: }
334:
335: void
336: rf_MapSectorDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
337: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
338: {
339: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
340: RF_DeclusteredConfigInfo_t *info =
341: (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
342: RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
343: RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
344: RF_StripeNum_t BlockID, BlockOffset, RepIndex;
345: RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
346: RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
347: layoutPtr->SUsPerPU;
348: RF_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
349:
350: rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
351: &fulltable_depth, &base_suid);
352:
353: /* Fulltable ID within array (across rows). */
354: FullTableID = SUID / sus_per_fulltable;
355: *row = FullTableID % raidPtr->numRow;
356:
357: /* Convert to fulltable ID on this disk. */
358: FullTableID /= raidPtr->numRow;
359:
360: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
361: SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
362: SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
363: }
364: FullTableOffset = SUID % sus_per_fulltable;
365: TableID = FullTableOffset / info->SUsPerTable;
366: TableOffset = FullTableOffset - TableID * info->SUsPerTable;
367: BlockID = TableOffset / info->PUsPerBlock;
368: BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
369: BlockID %= info->BlocksPerTable;
370: RF_ASSERT(BlockOffset < info->groupSize - 2);
371: /*
372: * TableIDs go from 0 .. GroupSize-1 inclusive.
373: * PUsPerBlock is k-2.
374: * We want the tableIDs to rotate from the
375: * right, so use GroupSize.
376: */
377: RepIndex = info->groupSize - 1 - TableID;
378: RF_ASSERT(RepIndex >= 0);
379: if (!raidPtr->noRotate) {
380: if (TableID == 0)
381: /* P on last drive, Q on first. */
382: BlockOffset++;
383: else
384: /* Skip over PQ. */
385: BlockOffset += ((BlockOffset >= RepIndex) ? 2 : 0);
386:
387: RF_ASSERT(BlockOffset < info->groupSize);
388: *col = info->LayoutTable[BlockID][BlockOffset];
389: }
390: /* Remap to distributed spare space if indicated. */
391: if (remap) {
392: rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID,
393: TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col,
394: &outSU);
395: } else {
396:
397: outSU = base_suid;
398: outSU += FullTableID * fulltable_depth;
399: /* Offset to strt of FT. */
400: outSU += SpareSpace;
401: /* Skip reserved spare space. */
402: outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
403: /* Offset to start of table. */
404: outSU += info->OffsetTable[BlockID][BlockOffset] *
405: layoutPtr->SUsPerPU;
406: /* Offset to the PU. */
407: }
408: outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
409: /* Offset to the SU within a PU. */
410:
411: /*
412: * Convert SUs to sectors, and, if not aligned to SU boundary, add in
413: * offset to sector.
414: */
415: *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
416: (raidSector % layoutPtr->sectorsPerStripeUnit);
417: }
418:
419:
420: void
421: rf_MapParityDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
422: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
423: {
424: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
425: RF_DeclusteredConfigInfo_t *info =
426: (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
427: RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
428: RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
429: RF_StripeNum_t BlockID, BlockOffset, RepIndex;
430: RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
431: RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
432: layoutPtr->SUsPerPU;
433: RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
434:
435: rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
436: &fulltable_depth, &base_suid);
437:
438: /* Compute row & (possibly) spare space exactly as before. */
439: FullTableID = SUID / sus_per_fulltable;
440: *row = FullTableID % raidPtr->numRow;
441: /* Convert to fulltable ID on this disk. */
442: FullTableID /= raidPtr->numRow;
443: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
444: SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
445: SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
446: }
447: /* Compute BlockID and RepIndex exactly as before. */
448: FullTableOffset = SUID % sus_per_fulltable;
449: TableID = FullTableOffset / info->SUsPerTable;
450: TableOffset = FullTableOffset - TableID * info->SUsPerTable;
451: BlockID = TableOffset / info->PUsPerBlock;
452: BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
453: BlockID %= info->BlocksPerTable;
454:
455: /* The parity block is in the position indicated by RepIndex. */
456: RepIndex = (raidPtr->noRotate) ?
457: info->PUsPerBlock : info->groupSize - 1 - TableID;
458: *col = info->LayoutTable[BlockID][RepIndex];
459:
460: if (remap)
461: RF_PANIC();
462:
463: /*
464: * Compute sector as before, except use RepIndex instead of
465: * BlockOffset.
466: */
467: outSU = base_suid;
468: outSU += FullTableID * fulltable_depth;
469: outSU += SpareSpace; /* skip rsvd spare space */
470: outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
471: outSU += info->OffsetTable[BlockID][RepIndex] * layoutPtr->SUsPerPU;
472: outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
473:
474: *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
475: (raidSector % layoutPtr->sectorsPerStripeUnit);
476: }
477:
478: void
479: rf_MapQDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
480: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
481: {
482: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
483: RF_DeclusteredConfigInfo_t *info =
484: (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
485: RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
486: RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
487: RF_StripeNum_t BlockID, BlockOffset, RepIndex, RepIndexQ;
488: RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
489: RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
490: layoutPtr->SUsPerPU;
491: RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
492:
493: rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
494: &fulltable_depth, &base_suid);
495:
496: /* Compute row & (possibly) spare space exactly as before. */
497: FullTableID = SUID / sus_per_fulltable;
498: *row = FullTableID % raidPtr->numRow;
499: /* Convert to fulltable ID on this disk. */
500: FullTableID /= raidPtr->numRow;
501: if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
502: SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
503: SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
504: }
505: /* Compute BlockID and RepIndex exactly as before. */
506: FullTableOffset = SUID % sus_per_fulltable;
507: TableID = FullTableOffset / info->SUsPerTable;
508: TableOffset = FullTableOffset - TableID * info->SUsPerTable;
509: BlockID = TableOffset / info->PUsPerBlock;
510: BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
511: BlockID %= info->BlocksPerTable;
512:
513: /* The q block is in the position indicated by RepIndex. */
514: RepIndex = (raidPtr->noRotate) ?
515: info->PUsPerBlock : info->groupSize - 1 - TableID;
516: RepIndexQ = ((RepIndex == (info->groupSize - 1)) ? 0 : RepIndex + 1);
517: *col = info->LayoutTable[BlockID][RepIndexQ];
518:
519: if (remap)
520: RF_PANIC();
521:
522: /*
523: * Compute sector as before, except use RepIndex instead of
524: * BlockOffset.
525: */
526: outSU = base_suid;
527: outSU += FullTableID * fulltable_depth;
528: outSU += SpareSpace; /* skip rsvd spare space */
529: outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
530: outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
531:
532: outSU += info->OffsetTable[BlockID][RepIndexQ] * layoutPtr->SUsPerPU;
533: *diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
534: (raidSector % layoutPtr->sectorsPerStripeUnit);
535: }
536:
537: /*
538: * Returns an array of ints identifying the disks that comprise the stripe
539: * containing the indicated address.
540: * The caller must _never_ attempt to modify this array.
541: */
542: void
543: rf_IdentifyStripeDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
544: RF_RowCol_t **diskids, RF_RowCol_t *outRow)
545: {
546: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
547: RF_DeclusteredConfigInfo_t *info =
548: (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
549: RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
550: RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
551: layoutPtr->SUsPerPU;
552: RF_StripeNum_t base_suid = 0;
553: RF_StripeNum_t SUID = rf_RaidAddressToStripeUnitID(layoutPtr, addr);
554: RF_StripeNum_t stripeID, FullTableID;
555: int tableOffset;
556:
557: rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
558: &fulltable_depth, &base_suid);
559: /* Fulltable ID within array (across rows). */
560: FullTableID = SUID / sus_per_fulltable;
561: *outRow = FullTableID % raidPtr->numRow;
562: /* Find stripe offset into array. */
563: stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);
564: /* Find offset into block design table. */
565: tableOffset = (stripeID % info->BlocksPerTable);
566: *diskids = info->LayoutTable[tableOffset];
567: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_declusterPQ.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe