Annotation of sys/dev/raidframe/rf_evenodd_dagfuncs.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_evenodd_dagfuncs.c,v 1.7 2002/12/16 07:01:04 tdeval Exp $ */
2: /* $NetBSD: rf_evenodd_dagfuncs.c,v 1.6 2000/03/30 12:45:40 augustss Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: ChangMing Wu
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: * Code for RAID-EVENODD architecture.
33: */
34:
35: #include "rf_types.h"
36: #include "rf_raid.h"
37: #include "rf_dag.h"
38: #include "rf_dagffrd.h"
39: #include "rf_dagffwr.h"
40: #include "rf_dagdegrd.h"
41: #include "rf_dagdegwr.h"
42: #include "rf_dagutils.h"
43: #include "rf_dagfuncs.h"
44: #include "rf_etimer.h"
45: #include "rf_general.h"
46: #include "rf_configure.h"
47: #include "rf_parityscan.h"
48: #include "rf_evenodd.h"
49: #include "rf_evenodd_dagfuncs.h"
50:
51: /* These redundant functions are for small write. */
52: RF_RedFuncs_t rf_EOSmallWritePFuncs = {
53: rf_RegularXorFunc, "Regular Old-New P",
54: rf_SimpleXorFunc, "Simple Old-New P"
55: };
56: RF_RedFuncs_t rf_EOSmallWriteEFuncs = {
57: rf_RegularONEFunc, "Regular Old-New E",
58: rf_SimpleONEFunc, "Regular Old-New E"
59: };
60: /* These redundant functions are for degraded read. */
61: RF_RedFuncs_t rf_eoPRecoveryFuncs = {
62: rf_RecoveryXorFunc, "Recovery Xr",
63: rf_RecoveryXorFunc, "Recovery Xr"
64: };
65: RF_RedFuncs_t rf_eoERecoveryFuncs = {
66: rf_RecoveryEFunc, "Recovery E Func",
67: rf_RecoveryEFunc, "Recovery E Func"
68: };
69:
70:
71: /*****************************************************************************
72: * The following encoding node functions is used in
73: * EO_000_CreateLargeWriteDAG.
74: *****************************************************************************/
75: int
76: rf_RegularPEFunc(RF_DagNode_t *node)
77: {
78: rf_RegularESubroutine(node, node->results[1]);
79: rf_RegularXorFunc(node); /* Do the wakeup here ! */
80: #if 1
81: return (0); /* XXX This was missing... GO */
82: #endif
83: }
84:
85:
86: /*****************************************************************************
87: * For EO_001_CreateSmallWriteDAG, there are (i) RegularONEFunc() and
88: * (ii) SimpleONEFunc() to be used. The previous case is when write accesses
89: * at least sectors of full stripe unit.
90: * The later function is used when the write accesses two stripe units but
91: * with total sectors less than sectors per SU. In this case, the access of
92: * parity and 'E' are shown as disconnected areas in their stripe unit and
93: * parity write and 'E' write are both divided into two distinct writes
94: * (totally four). This simple old-new write and regular old-new write happen
95: * as in RAID-5.
96: *****************************************************************************/
97:
98: /*
99: * Algorithm:
100: * 1. Store the difference of old data and new data in the Rod buffer.
101: * 2. Then encode this buffer into the buffer that already have old 'E'
102: * information inside it, the result can be shown to be the new 'E'
103: * information.
104: * 3. Xor the Wnd buffer into the difference buffer to recover the original
105: * old data.
106: * Here we have another alternative: to allocate a temporary buffer for
107: * storing the difference of old data and new data, then encode temp buf
108: * into old 'E' buf to form new 'E', but this approach takes the same speed
109: * as the previous, and needs more memory.
110: */
111: int
112: rf_RegularONEFunc(RF_DagNode_t *node)
113: {
114: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
115: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
116: int EpdaIndex = (node->numParams - 1) / 2 - 1; /*
117: * The parameter of node
118: * where you can find
119: * e-pda.
120: */
121: int i, k, retcode = 0;
122: int suoffset, length;
123: RF_RowCol_t scol;
124: char *srcbuf, *destbuf;
125: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
126: RF_Etimer_t timer;
127: RF_PhysDiskAddr_t *pda, *EPDA = (RF_PhysDiskAddr_t *)
128: node->params[EpdaIndex].p;
129: /* Generally zero. */
130: int ESUOffset = rf_StripeUnitOffset(layoutPtr, EPDA->startSector);
131:
132: RF_ASSERT(EPDA->type == RF_PDA_TYPE_Q);
133: RF_ASSERT(ESUOffset == 0);
134:
135: RF_ETIMER_START(timer);
136:
137: /*
138: * Xor the Wnd buffer into Rod buffer. The difference of old data and
139: * new data is stored in Rod buffer.
140: */
141: for (k = 0; k < EpdaIndex; k += 2) {
142: length = rf_RaidAddressToByte(raidPtr,
143: ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
144: retcode = rf_bxor(node->params[k + EpdaIndex + 3].p,
145: node->params[k + 1].p, length, node->dagHdr->bp);
146: }
147: /*
148: * Start to encode the buffer, storing the difference of old data and
149: * new data into 'E' buffer.
150: */
151: for (i = 0; i < EpdaIndex; i += 2)
152: if (node->params[i + 1].p != node->results[0]) {
153: /* results[0] is buf ptr of E. */
154: pda = (RF_PhysDiskAddr_t *) node->params[i].p;
155: srcbuf = (char *) node->params[i + 1].p;
156: scol = rf_EUCol(layoutPtr, pda->raidAddress);
157: suoffset = rf_StripeUnitOffset(layoutPtr,
158: pda->startSector);
159: destbuf = ((char *) node->results[0]) +
160: rf_RaidAddressToByte(raidPtr, suoffset);
161: rf_e_encToBuf(raidPtr, scol, srcbuf,
162: RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
163: }
164: /*
165: * Recover the original old data to be used by parity encoding
166: * function in XorNode.
167: */
168: for (k = 0; k < EpdaIndex; k += 2) {
169: length = rf_RaidAddressToByte(raidPtr,
170: ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
171: retcode = rf_bxor(node->params[k + EpdaIndex + 3].p,
172: node->params[k + 1].p, length, node->dagHdr->bp);
173: }
174: RF_ETIMER_STOP(timer);
175: RF_ETIMER_EVAL(timer);
176: tracerec->q_us += RF_ETIMER_VAL_US(timer);
177: rf_GenericWakeupFunc(node, 0);
178: #if 1
179: return (0); /* XXX This was missing... GO */
180: #endif
181: }
182:
183: int
184: rf_SimpleONEFunc(RF_DagNode_t *node)
185: {
186: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
187: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
188: RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
189: int retcode = 0;
190: char *srcbuf, *destbuf;
191: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
192: int length;
193: RF_RowCol_t scol;
194: RF_Etimer_t timer;
195:
196: RF_ASSERT(((RF_PhysDiskAddr_t *) node->params[2].p)->type ==
197: RF_PDA_TYPE_Q);
198: if (node->dagHdr->status == rf_enable) {
199: RF_ETIMER_START(timer);
200: /* This is a pda of writeDataNodes. */
201: length = rf_RaidAddressToByte(raidPtr,
202: ((RF_PhysDiskAddr_t *) node->params[4].p)->numSector);
203: /* bxor to buffer of readDataNodes. */
204: retcode = rf_bxor(node->params[5].p, node->params[1].p,
205: length, node->dagHdr->bp);
206: /*
207: * Find out the corresponding column in encoding matrix for
208: * write column to be encoded into redundant disk 'E'.
209: */
210: scol = rf_EUCol(layoutPtr, pda->raidAddress);
211: srcbuf = node->params[1].p;
212: destbuf = node->params[3].p;
213: /* Start encoding process. */
214: rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
215: destbuf, pda->numSector);
216: rf_bxor(node->params[5].p, node->params[1].p, length,
217: node->dagHdr->bp);
218: RF_ETIMER_STOP(timer);
219: RF_ETIMER_EVAL(timer);
220: tracerec->q_us += RF_ETIMER_VAL_US(timer);
221:
222: }
223: return (rf_GenericWakeupFunc(node, retcode)); /*
224: * Call wake func
225: * explicitly since no
226: * I/O in this node.
227: */
228: }
229:
230:
231: /*
232: * Called by rf_RegularPEFunc(node) and rf_RegularEFunc(node)
233: * in f.f. large write.
234: */
235: void
236: rf_RegularESubroutine(RF_DagNode_t *node, char *ebuf)
237: {
238: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
239: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
240: RF_PhysDiskAddr_t *pda;
241: int i, suoffset;
242: RF_RowCol_t scol;
243: char *srcbuf, *destbuf;
244: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
245: RF_Etimer_t timer;
246:
247: RF_ETIMER_START(timer);
248: for (i = 0; i < node->numParams - 2; i += 2) {
249: RF_ASSERT(node->params[i + 1].p != ebuf);
250: pda = (RF_PhysDiskAddr_t *) node->params[i].p;
251: suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
252: scol = rf_EUCol(layoutPtr, pda->raidAddress);
253: srcbuf = (char *) node->params[i + 1].p;
254: destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset);
255: rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
256: destbuf, pda->numSector);
257: }
258: RF_ETIMER_STOP(timer);
259: RF_ETIMER_EVAL(timer);
260: tracerec->xor_us += RF_ETIMER_VAL_US(timer);
261: }
262:
263:
264: /*****************************************************************************
265: * Used in EO_001_CreateLargeWriteDAG.
266: *****************************************************************************/
267: int
268: rf_RegularEFunc(RF_DagNode_t *node)
269: {
270: rf_RegularESubroutine(node, node->results[0]);
271: rf_GenericWakeupFunc(node, 0);
272: #if 1
273: return (0); /* XXX This was missing... GO */
274: #endif
275: }
276:
277:
278: /*****************************************************************************
279: * This degraded function allow only two cases:
280: * 1. When write accesses the full failed stripe unit, then the access can
281: * be more than one stripe unit.
282: * 2. When write accesses only part of the failed SU, we assume accesses of
283: * more than one stripe unit are not allowed so that the write can be
284: * dealt with like a large write.
285: * The following function is based on these assumptions. So except in the
286: * second case, it looks the same as a large write encoding function. But
287: * this is not exactly the normal way of doing a degraded write, since
288: * RAIDframe has to break cases of accesses other than the above two into
289: * smaller accesses. We may have to change DegrESubroutin in the future.
290: *****************************************************************************/
291: void
292: rf_DegrESubroutine(RF_DagNode_t *node, char *ebuf)
293: {
294: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
295: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
296: RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
297: RF_PhysDiskAddr_t *pda;
298: int i, suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
299: RF_RowCol_t scol;
300: char *srcbuf, *destbuf;
301: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
302: RF_Etimer_t timer;
303:
304: RF_ETIMER_START(timer);
305: for (i = 0; i < node->numParams - 2; i += 2) {
306: RF_ASSERT(node->params[i + 1].p != ebuf);
307: pda = (RF_PhysDiskAddr_t *) node->params[i].p;
308: suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
309: scol = rf_EUCol(layoutPtr, pda->raidAddress);
310: srcbuf = (char *) node->params[i + 1].p;
311: destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
312: rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
313: }
314:
315: RF_ETIMER_STOP(timer);
316: RF_ETIMER_EVAL(timer);
317: tracerec->q_us += RF_ETIMER_VAL_US(timer);
318: }
319:
320:
321: /*****************************************************************************
322: * This function is used in case where one data disk failed and both redundant
323: * disks are alive. It is used in the EO_100_CreateWriteDAG. Note: if there is
324: * another disk failed in the stripe but not accessed at this time, then we
325: * should, instead, use the rf_EOWriteDoubleRecoveryFunc().
326: *****************************************************************************/
327: int
328: rf_Degraded_100_EOFunc(RF_DagNode_t *node)
329: {
330: rf_DegrESubroutine(node, node->results[1]);
331: rf_RecoveryXorFunc(node); /* Does the wakeup here ! */
332: #if 1
333: return (0); /* XXX This was missing... Should these be
334: * void functions ??? GO */
335: #endif
336: }
337:
338:
339: /*****************************************************************************
340: * This function is to encode one sector in one of the data disks to the E
341: * disk. However, in evenodd this function can also be used as decoding
342: * function to recover data from dead disk in the case of parity failure and
343: * a single data failure.
344: *****************************************************************************/
345: void
346: rf_e_EncOneSect(RF_RowCol_t srcLogicCol, char *srcSecbuf,
347: RF_RowCol_t destLogicCol, char *destSecbuf, int bytesPerSector)
348: {
349: int S_index; /*
350: * Index of the EU in the src col which need
351: * be Xored into all EUs in a dest sector.
352: */
353: int numRowInEncMatrix = (RF_EO_MATRIX_DIM) - 1;
354: RF_RowCol_t j, indexInDest; /*
355: * Row index of an encoding unit in
356: * the destination column of encoding
357: * matrix.
358: */
359: RF_RowCol_t indexInSrc; /*
360: * Row index of an encoding unit in the source
361: * column used for recovery.
362: */
363: int bytesPerEU = bytesPerSector / numRowInEncMatrix;
364:
365: #if RF_EO_MATRIX_DIM > 17
366: int shortsPerEU = bytesPerEU / sizeof(short);
367: short *destShortBuf, *srcShortBuf1, *srcShortBuf2;
368: short temp1;
369: #elif RF_EO_MATRIX_DIM == 17
370: int longsPerEU = bytesPerEU / sizeof(long);
371: long *destLongBuf, *srcLongBuf1, *srcLongBuf2;
372: long temp1;
373: #endif
374:
375: #if RF_EO_MATRIX_DIM > 17
376: RF_ASSERT(sizeof(short) == 2 || sizeof(short) == 1);
377: RF_ASSERT(bytesPerEU % sizeof(short) == 0);
378: #elif RF_EO_MATRIX_DIM == 17
379: RF_ASSERT(sizeof(long) == 8 || sizeof(long) == 4);
380: RF_ASSERT(bytesPerEU % sizeof(long) == 0);
381: #endif
382:
383: S_index = rf_EO_Mod((RF_EO_MATRIX_DIM - 1 + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
384: #if RF_EO_MATRIX_DIM > 17
385: srcShortBuf1 = (short *) (srcSecbuf + S_index * bytesPerEU);
386: #elif RF_EO_MATRIX_DIM == 17
387: srcLongBuf1 = (long *) (srcSecbuf + S_index * bytesPerEU);
388: #endif
389:
390: for (indexInDest = 0; indexInDest < numRowInEncMatrix; indexInDest++) {
391: indexInSrc = rf_EO_Mod((indexInDest + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
392:
393: #if RF_EO_MATRIX_DIM > 17
394: destShortBuf = (short *) (destSecbuf + indexInDest * bytesPerEU);
395: srcShortBuf2 = (short *) (srcSecbuf + indexInSrc * bytesPerEU);
396: for (j = 0; j < shortsPerEU; j++) {
397: temp1 = destShortBuf[j] ^ srcShortBuf1[j];
398: /* Note: S_index won't be at the end row for any src
399: * col ! */
400: if (indexInSrc != RF_EO_MATRIX_DIM - 1)
401: destShortBuf[j] = (srcShortBuf2[j]) ^ temp1;
402: /* if indexInSrc is at the end row, ie.
403: * RF_EO_MATRIX_DIM -1, then all elements are zero ! */
404: else
405: destShortBuf[j] = temp1;
406: }
407:
408: #elif RF_EO_MATRIX_DIM == 17
409: destLongBuf = (long *) (destSecbuf + indexInDest * bytesPerEU);
410: srcLongBuf2 = (long *) (srcSecbuf + indexInSrc * bytesPerEU);
411: for (j = 0; j < longsPerEU; j++) {
412: temp1 = destLongBuf[j] ^ srcLongBuf1[j];
413: if (indexInSrc != RF_EO_MATRIX_DIM - 1)
414: destLongBuf[j] = (srcLongBuf2[j]) ^ temp1;
415: else
416: destLongBuf[j] = temp1;
417: }
418: #endif
419: }
420: }
421:
422: void
423: rf_e_encToBuf(RF_Raid_t *raidPtr, RF_RowCol_t srcLogicCol, char *srcbuf,
424: RF_RowCol_t destLogicCol, char *destbuf, int numSector)
425: {
426: int i, bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
427:
428: for (i = 0; i < numSector; i++) {
429: rf_e_EncOneSect(srcLogicCol, srcbuf, destLogicCol, destbuf, bytesPerSector);
430: srcbuf += bytesPerSector;
431: destbuf += bytesPerSector;
432: }
433: }
434:
435:
436: /*****************************************************************************
437: * when parity die and one data die, We use second redundant information, 'E',
438: * to recover the data in dead disk. This function is used in the recovery node of
439: * for EO_110_CreateReadDAG
440: *****************************************************************************/
441: int
442: rf_RecoveryEFunc(RF_DagNode_t *node)
443: {
444: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
445: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
446: RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
447: RF_RowCol_t scol; /* source logical column */
448: RF_RowCol_t fcol = rf_EUCol(layoutPtr, failedPDA->raidAddress); /* logical column of
449: * failed SU */
450: int i;
451: RF_PhysDiskAddr_t *pda;
452: int suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
453: char *srcbuf, *destbuf;
454: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
455: RF_Etimer_t timer;
456:
457: bzero((char *) node->results[0], rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
458: if (node->dagHdr->status == rf_enable) {
459: RF_ETIMER_START(timer);
460: for (i = 0; i < node->numParams - 2; i += 2)
461: if (node->params[i + 1].p != node->results[0]) {
462: pda = (RF_PhysDiskAddr_t *) node->params[i].p;
463: if (i == node->numParams - 4)
464: scol = RF_EO_MATRIX_DIM - 2; /* the colume of
465: * redundant E */
466: else
467: scol = rf_EUCol(layoutPtr, pda->raidAddress);
468: srcbuf = (char *) node->params[i + 1].p;
469: suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
470: destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
471: rf_e_encToBuf(raidPtr, scol, srcbuf, fcol, destbuf, pda->numSector);
472: }
473: RF_ETIMER_STOP(timer);
474: RF_ETIMER_EVAL(timer);
475: tracerec->xor_us += RF_ETIMER_VAL_US(timer);
476: }
477: return (rf_GenericWakeupFunc(node, 0)); /* node execute successfully */
478: }
479:
480:
481: /*****************************************************************************
482: * This function is used in the case where one data and the parity have filed.
483: * (in EO_110_CreateWriteDAG)
484: *****************************************************************************/
485: int
486: rf_EO_DegradedWriteEFunc(RF_DagNode_t *node)
487: {
488: rf_DegrESubroutine(node, node->results[0]);
489: rf_GenericWakeupFunc(node, 0);
490: #if 1
491: return (0); /* XXX Yet another one !!! GO */
492: #endif
493: }
494:
495:
496:
497: /*****************************************************************************
498: * THE FUNCTION IS FOR DOUBLE DEGRADED READ AND WRITE CASES.
499: *****************************************************************************/
500:
501: void
502: rf_doubleEOdecode(RF_Raid_t *raidPtr, char **rrdbuf, char **dest,
503: RF_RowCol_t *fcol, char *pbuf, char *ebuf)
504: {
505: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
506: int i, j, k, f1, f2, row;
507: int rrdrow, erow, count = 0;
508: int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
509: int numRowInEncMatrix = (RF_EO_MATRIX_DIM) - 1;
510: #if 0
511: int pcol = (RF_EO_MATRIX_DIM) - 1;
512: #endif
513: int ecol = (RF_EO_MATRIX_DIM) - 2;
514: int bytesPerEU = bytesPerSector / numRowInEncMatrix;
515: int numDataCol = layoutPtr->numDataCol;
516: #if RF_EO_MATRIX_DIM > 17
517: int shortsPerEU = bytesPerEU / sizeof(short);
518: short *rrdbuf_current, *pbuf_current, *ebuf_current;
519: short *dest_smaller, *dest_smaller_current;
520: short *dest_larger, *dest_larger_current;
521: short *temp;
522: short *P;
523:
524: RF_ASSERT(bytesPerEU % sizeof(short) == 0);
525: RF_Malloc(P, bytesPerEU, (short *));
526: RF_Malloc(temp, bytesPerEU, (short *));
527: #elif RF_EO_MATRIX_DIM == 17
528: int longsPerEU = bytesPerEU / sizeof(long);
529: long *rrdbuf_current, *pbuf_current, *ebuf_current;
530: long *dest_smaller, *dest_smaller_current;
531: long *dest_larger, *dest_larger_current;
532: long *temp;
533: long *P;
534:
535: RF_ASSERT(bytesPerEU % sizeof(long) == 0);
536: RF_Malloc(P, bytesPerEU, (long *));
537: RF_Malloc(temp, bytesPerEU, (long *));
538: #endif
539: RF_ASSERT(*((long *) dest[0]) == 0);
540: RF_ASSERT(*((long *) dest[1]) == 0);
541: bzero((char *) P, bytesPerEU);
542: bzero((char *) temp, bytesPerEU);
543: RF_ASSERT(*P == 0);
544: /*
545: * Calculate the 'P' parameter, which, not parity, is the Xor of all
546: * elements in the last two column, ie. 'E' and 'parity' columns, see
547: * the Ref. paper by Blaum, et al 1993.
548: */
549: for (i = 0; i < numRowInEncMatrix; i++)
550: for (k = 0; k < longsPerEU; k++) {
551: #if RF_EO_MATRIX_DIM > 17
552: ebuf_current = ((short *) ebuf) + i * shortsPerEU + k;
553: pbuf_current = ((short *) pbuf) + i * shortsPerEU + k;
554: #elif RF_EO_MATRIX_DIM == 17
555: ebuf_current = ((long *) ebuf) + i * longsPerEU + k;
556: pbuf_current = ((long *) pbuf) + i * longsPerEU + k;
557: #endif
558: P[k] ^= *ebuf_current;
559: P[k] ^= *pbuf_current;
560: }
561: RF_ASSERT(fcol[0] != fcol[1]);
562: if (fcol[0] < fcol[1]) {
563: #if RF_EO_MATRIX_DIM > 17
564: dest_smaller = (short *) (dest[0]);
565: dest_larger = (short *) (dest[1]);
566: #elif RF_EO_MATRIX_DIM == 17
567: dest_smaller = (long *) (dest[0]);
568: dest_larger = (long *) (dest[1]);
569: #endif
570: f1 = fcol[0];
571: f2 = fcol[1];
572: } else {
573: #if RF_EO_MATRIX_DIM > 17
574: dest_smaller = (short *) (dest[1]);
575: dest_larger = (short *) (dest[0]);
576: #elif RF_EO_MATRIX_DIM == 17
577: dest_smaller = (long *) (dest[1]);
578: dest_larger = (long *) (dest[0]);
579: #endif
580: f1 = fcol[1];
581: f2 = fcol[0];
582: }
583: row = (RF_EO_MATRIX_DIM) - 1;
584: while ((row = rf_EO_Mod((row + f1 - f2), RF_EO_MATRIX_DIM)) !=
585: ((RF_EO_MATRIX_DIM) - 1)) {
586: #if RF_EO_MATRIX_DIM > 17
587: dest_larger_current = dest_larger + row * shortsPerEU;
588: dest_smaller_current = dest_smaller + row * shortsPerEU;
589: #elif RF_EO_MATRIX_DIM == 17
590: dest_larger_current = dest_larger + row * longsPerEU;
591: dest_smaller_current = dest_smaller + row * longsPerEU;
592: #endif
593: /*
594: * Do the diagonal recovery. Initially, temp[k] = (failed 1),
595: * which is the failed data in the column that has smaller
596: * col index.
597: */
598: /* Step 1: ^(SUM of nonfailed in-diagonal A(rrdrow,0..m-3)) */
599: for (j = 0; j < numDataCol; j++) {
600: if (j == f1 || j == f2)
601: continue;
602: rrdrow = rf_EO_Mod((row + f2 - j), RF_EO_MATRIX_DIM);
603: if (rrdrow != (RF_EO_MATRIX_DIM) - 1) {
604: #if RF_EO_MATRIX_DIM > 17
605: rrdbuf_current = (short *) (rrdbuf[j]) +
606: rrdrow * shortsPerEU;
607: for (k = 0; k < shortsPerEU; k++)
608: temp[k] ^= *(rrdbuf_current + k);
609: #elif RF_EO_MATRIX_DIM == 17
610: rrdbuf_current = (long *) (rrdbuf[j]) +
611: rrdrow * longsPerEU;
612: for (k = 0; k < longsPerEU; k++)
613: temp[k] ^= *(rrdbuf_current + k);
614: #endif
615: }
616: }
617: /*
618: * Step 2: ^E(erow,m-2), If erow is at the bottom row, don't
619: * Xor into it. E(erow,m-2) = (principle diagonal) ^ (failed
620: * 1) ^ (failed 2) ^ (SUM of nonfailed in-diagonal
621: * A(rrdrow,0..m-3))
622: * After this step, temp[k] = (principle diagonal) ^ (failed 2).
623: */
624:
625: erow = rf_EO_Mod((row + f2 - ecol), (RF_EO_MATRIX_DIM));
626: if (erow != (RF_EO_MATRIX_DIM) - 1) {
627: #if RF_EO_MATRIX_DIM > 17
628: ebuf_current = (short *) ebuf + shortsPerEU * erow;
629: for (k = 0; k < shortsPerEU; k++)
630: temp[k] ^= *(ebuf_current + k);
631: #elif RF_EO_MATRIX_DIM == 17
632: ebuf_current = (long *) ebuf + longsPerEU * erow;
633: for (k = 0; k < longsPerEU; k++)
634: temp[k] ^= *(ebuf_current + k);
635: #endif
636: }
637: /*
638: * Step 3: ^P to obtain the failed data (failed 2). P can be
639: * proved to be actually (principal diagonal). After this
640: * step, temp[k] = (failed 2), the failed data to be recovered.
641: */
642: #if RF_EO_MATRIX_DIM > 17
643: for (k = 0; k < shortsPerEU; k++)
644: temp[k] ^= P[k];
645: /* Put the data into the destination buffer. */
646: for (k = 0; k < shortsPerEU; k++)
647: dest_larger_current[k] = temp[k];
648: #elif RF_EO_MATRIX_DIM == 17
649: for (k = 0; k < longsPerEU; k++)
650: temp[k] ^= P[k];
651: /* Put the data into the destination buffer. */
652: for (k = 0; k < longsPerEU; k++)
653: dest_larger_current[k] = temp[k];
654: #endif
655:
656: /* THE FOLLOWING DO THE HORIZONTAL XOR. */
657: /*
658: * Step 1: ^(SUM of A(row,0..m-3)), ie. all nonfailed data
659: * columns.
660: */
661: for (j = 0; j < numDataCol; j++) {
662: if (j == f1 || j == f2)
663: continue;
664: #if RF_EO_MATRIX_DIM > 17
665: rrdbuf_current = (short *) (rrdbuf[j]) +
666: row * shortsPerEU;
667: for (k = 0; k < shortsPerEU; k++)
668: temp[k] ^= *(rrdbuf_current + k);
669: #elif RF_EO_MATRIX_DIM == 17
670: rrdbuf_current = (long *) (rrdbuf[j]) +
671: row * longsPerEU;
672: for (k = 0; k < longsPerEU; k++)
673: temp[k] ^= *(rrdbuf_current + k);
674: #endif
675: }
676: /* Step 2: ^A(row,m-1) */
677: /* Step 3: Put the data into the destination buffer. */
678: #if RF_EO_MATRIX_DIM > 17
679: pbuf_current = (short *) pbuf + shortsPerEU * row;
680: for (k = 0; k < shortsPerEU; k++)
681: temp[k] ^= *(pbuf_current + k);
682: for (k = 0; k < shortsPerEU; k++)
683: dest_smaller_current[k] = temp[k];
684: #elif RF_EO_MATRIX_DIM == 17
685: pbuf_current = (long *) pbuf + longsPerEU * row;
686: for (k = 0; k < longsPerEU; k++)
687: temp[k] ^= *(pbuf_current + k);
688: for (k = 0; k < longsPerEU; k++)
689: dest_smaller_current[k] = temp[k];
690: #endif
691: count++;
692: }
693: /*
694: * Check if all Encoding Unit in the data buffer have been decoded ?
695: * According to EvenOdd theory, if "RF_EO_MATRIX_DIM" is a prime
696: * number, this algorithm will covered all buffer.
697: */
698: RF_ASSERT(count == numRowInEncMatrix);
699: RF_Free((char *) P, bytesPerEU);
700: RF_Free((char *) temp, bytesPerEU);
701: }
702:
703:
704: /*****************************************************************************
705: * This function is called by double degraded read EO_200_CreateReadDAG.
706: *****************************************************************************/
707: int
708: rf_EvenOddDoubleRecoveryFunc(RF_DagNode_t *node)
709: {
710: int ndataParam = 0;
711: int np = node->numParams;
712: RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *)
713: node->params[np - 1].p;
714: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
715: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
716: int i, prm, sector, nresults = node->numResults;
717: RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
718: unsigned sosAddr;
719: int two = 0, mallc_one = 0, mallc_two = 0; /*
720: * Flags to indicate if
721: * memory is allocated.
722: */
723: int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
724: RF_PhysDiskAddr_t *ppda, *ppda2, *epda, *epda2, *pda, *pda0, *pda1,
725: npda;
726: RF_RowCol_t fcol[2], fsuoff[2], fsuend[2],
727: numDataCol = layoutPtr->numDataCol;
728: char **buf, *ebuf, *pbuf, *dest[2];
729: long *suoff = NULL, *suend = NULL, *prmToCol = NULL, psuoff, esuoff;
730: RF_SectorNum_t startSector, endSector;
731: RF_Etimer_t timer;
732: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
733:
734: RF_ETIMER_START(timer);
735:
736: /*
737: * Find out the number of parameters that are pdas for data
738: * information.
739: */
740: for (i = 0; i <= np; i++)
741: if (((RF_PhysDiskAddr_t *) node->params[i].p)->type !=
742: RF_PDA_TYPE_DATA) {
743: ndataParam = i;
744: break;
745: }
746: RF_Malloc(buf, numDataCol * sizeof(char *), (char **));
747: if (ndataParam != 0) {
748: RF_Malloc(suoff, ndataParam * sizeof(long), (long *));
749: RF_Malloc(suend, ndataParam * sizeof(long), (long *));
750: RF_Malloc(prmToCol, ndataParam * sizeof(long), (long *));
751: }
752: if (asmap->failedPDAs[1] &&
753: (asmap->failedPDAs[1]->numSector +
754: asmap->failedPDAs[0]->numSector) < secPerSU) {
755: RF_ASSERT(0); /* Currently, no support for this situation. */
756: ppda = node->params[np - 6].p;
757: ppda2 = node->params[np - 5].p;
758: RF_ASSERT(ppda2->type == RF_PDA_TYPE_PARITY);
759: epda = node->params[np - 4].p;
760: epda2 = node->params[np - 3].p;
761: RF_ASSERT(epda2->type == RF_PDA_TYPE_Q);
762: two = 1;
763: } else {
764: ppda = node->params[np - 4].p;
765: epda = node->params[np - 3].p;
766: psuoff = rf_StripeUnitOffset(layoutPtr, ppda->startSector);
767: esuoff = rf_StripeUnitOffset(layoutPtr, epda->startSector);
768: RF_ASSERT(psuoff == esuoff);
769: }
770: /*
771: * The followings have three goals:
772: * 1. Determine the startSector to begin decoding and endSector
773: * to end decoding.
774: * 2. Determine the column numbers of the two failed disks.
775: * 3. Determine the offset and end offset of the access within
776: * each failed stripe unit.
777: */
778: if (nresults == 1) {
779: /* Find the startSector to begin decoding. */
780: pda = node->results[0];
781: bzero(pda->bufPtr, bytesPerSector * pda->numSector);
782: fsuoff[0] = rf_StripeUnitOffset(layoutPtr, pda->startSector);
783: fsuend[0] = fsuoff[0] + pda->numSector;
784: startSector = fsuoff[0];
785: endSector = fsuend[0];
786:
787: /* Find out the column of failed disk being accessed. */
788: fcol[0] = rf_EUCol(layoutPtr, pda->raidAddress);
789:
790: /* Find out the other failed column not accessed. */
791: sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
792: asmap->raidAddress);
793: for (i = 0; i < numDataCol; i++) {
794: npda.raidAddress = sosAddr + (i * secPerSU);
795: (raidPtr->Layout.map->MapSector) (raidPtr,
796: npda.raidAddress, &(npda.row), &(npda.col),
797: &(npda.startSector), 0);
798: /* Skip over dead disks. */
799: if (RF_DEAD_DISK(raidPtr
800: ->Disks[npda.row][npda.col].status))
801: if (i != fcol[0])
802: break;
803: }
804: RF_ASSERT(i < numDataCol);
805: fcol[1] = i;
806: } else {
807: RF_ASSERT(nresults == 2);
808: pda0 = node->results[0];
809: bzero(pda0->bufPtr, bytesPerSector * pda0->numSector);
810: pda1 = node->results[1];
811: bzero(pda1->bufPtr, bytesPerSector * pda1->numSector);
812: /*
813: * Determine the failed column numbers of the two failed
814: * disks.
815: */
816: fcol[0] = rf_EUCol(layoutPtr, pda0->raidAddress);
817: fcol[1] = rf_EUCol(layoutPtr, pda1->raidAddress);
818: /*
819: * Determine the offset and end offset of the access within
820: * each failed stripe unit.
821: */
822: fsuoff[0] = rf_StripeUnitOffset(layoutPtr, pda0->startSector);
823: fsuend[0] = fsuoff[0] + pda0->numSector;
824: fsuoff[1] = rf_StripeUnitOffset(layoutPtr, pda1->startSector);
825: fsuend[1] = fsuoff[1] + pda1->numSector;
826: /* Determine the startSector to begin decoding. */
827: startSector = RF_MIN(pda0->startSector, pda1->startSector);
828: /* Determine the endSector to end decoding. */
829: endSector = RF_MAX(fsuend[0], fsuend[1]);
830: }
831: /*
832: * Assign the beginning sector and the end sector for each parameter.
833: * Find out the corresponding column # for each parameter.
834: */
835: for (prm = 0; prm < ndataParam; prm++) {
836: pda = node->params[prm].p;
837: suoff[prm] = rf_StripeUnitOffset(layoutPtr, pda->startSector);
838: suend[prm] = suoff[prm] + pda->numSector;
839: prmToCol[prm] = rf_EUCol(layoutPtr, pda->raidAddress);
840: }
841: /*
842: * 'sector' is the sector for the current decoding algorithm. For each
843: * sector in the failed SU
844: * 1. Find out the corresponding parameters that cover the current
845: * sector and that are needed for the decoding of this sector in
846: * failed SU.
847: * 2. Find out if sector is in the shadow of any accessed failed SU.
848: * If not, malloc a temporary space of a sector in size.
849: */
850: for (sector = startSector; sector < endSector; sector++) {
851: if (nresults == 2)
852: if (!(fsuoff[0] <= sector && sector < fsuend[0]) &&
853: !(fsuoff[1] <= sector && sector < fsuend[1]))
854: continue;
855: for (prm = 0; prm < ndataParam; prm++)
856: if (suoff[prm] <= sector && sector < suend[prm])
857: buf[(prmToCol[prm])] = ((RF_PhysDiskAddr_t *)
858: node->params[prm].p)->bufPtr +
859: rf_RaidAddressToByte(raidPtr,
860: sector - suoff[prm]);
861: /*
862: * Find out if sector is in the shadow of any accessed failed
863: * SU. If yes, assign dest[0], dest[1] to point at suitable
864: * position of the buffer corresponding to failed SUs. If no,
865: * malloc a temporary space of a sector in size for
866: * destination of decoding.
867: */
868: RF_ASSERT(nresults == 1 || nresults == 2);
869: if (nresults == 1) {
870: dest[0] = ((RF_PhysDiskAddr_t *)
871: node->results[0])->bufPtr +
872: rf_RaidAddressToByte(raidPtr, sector - fsuoff[0]);
873: /* Always malloc temp buffer to dest[1]. */
874: RF_Malloc(dest[1], bytesPerSector, (char *));
875: bzero(dest[1], bytesPerSector);
876: mallc_two = 1;
877: } else {
878: if (fsuoff[0] <= sector && sector < fsuend[0])
879: dest[0] = ((RF_PhysDiskAddr_t *)
880: node->results[0])->bufPtr +
881: rf_RaidAddressToByte(raidPtr,
882: sector - fsuoff[0]);
883: else {
884: RF_Malloc(dest[0], bytesPerSector, (char *));
885: bzero(dest[0], bytesPerSector);
886: mallc_one = 1;
887: }
888: if (fsuoff[1] <= sector && sector < fsuend[1])
889: dest[1] = ((RF_PhysDiskAddr_t *)
890: node->results[1])->bufPtr +
891: rf_RaidAddressToByte(raidPtr,
892: sector - fsuoff[1]);
893: else {
894: RF_Malloc(dest[1], bytesPerSector, (char *));
895: bzero(dest[1], bytesPerSector);
896: mallc_two = 1;
897: }
898: RF_ASSERT(mallc_one == 0 || mallc_two == 0);
899: }
900: pbuf = ppda->bufPtr + rf_RaidAddressToByte(raidPtr,
901: sector - psuoff);
902: ebuf = epda->bufPtr + rf_RaidAddressToByte(raidPtr,
903: sector - esuoff);
904: /*
905: * After finish finding all needed sectors, call doubleEOdecode
906: * function for decoding one sector to destination.
907: */
908: rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
909: /*
910: * Free all allocated memory, and mark flag to indicate no
911: * memory is being allocated.
912: */
913: if (mallc_one == 1)
914: RF_Free(dest[0], bytesPerSector);
915: if (mallc_two == 1)
916: RF_Free(dest[1], bytesPerSector);
917: mallc_one = mallc_two = 0;
918: }
919: RF_Free(buf, numDataCol * sizeof(char *));
920: if (ndataParam != 0) {
921: RF_Free(suoff, ndataParam * sizeof(long));
922: RF_Free(suend, ndataParam * sizeof(long));
923: RF_Free(prmToCol, ndataParam * sizeof(long));
924: }
925: RF_ETIMER_STOP(timer);
926: RF_ETIMER_EVAL(timer);
927: if (tracerec) {
928: tracerec->q_us += RF_ETIMER_VAL_US(timer);
929: }
930: rf_GenericWakeupFunc(node, 0);
931: #if 1
932: return (0); /* XXX Is this even close !!?!?!!? GO */
933: #endif
934: }
935:
936:
937: /*
938: * Currently, only access of one of the two failed SU is allowed in this
939: * function. Also, asmap->numStripeUnitsAccessed is limited to be one,
940: * the RAIDframe will break large access into many accesses of single
941: * stripe unit.
942: */
943:
944: int
945: rf_EOWriteDoubleRecoveryFunc(RF_DagNode_t *node)
946: {
947: int np = node->numParams;
948: RF_AccessStripeMap_t *asmap =
949: (RF_AccessStripeMap_t *) node->params[np - 1].p;
950: RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
951: RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
952: RF_SectorNum_t sector;
953: RF_RowCol_t col, scol;
954: int prm, i, j;
955: RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
956: unsigned sosAddr;
957: unsigned bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
958: RF_int64 numbytes;
959: RF_SectorNum_t startSector, endSector;
960: RF_PhysDiskAddr_t *ppda, *epda, *pda, *fpda, npda;
961: RF_RowCol_t fcol[2], numDataCol = layoutPtr->numDataCol;
962: char **buf; /*
963: * buf[0], buf[1], buf[2], ... etc, point to
964: * buffer storing data read from col0, col1,
965: * col2.
966: */
967: char *ebuf, *pbuf, *dest[2], *olddata[2];
968: RF_Etimer_t timer;
969: RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
970:
971: RF_ASSERT(asmap->numDataFailed == 1); /*
972: * Currently only support this
973: * case, the other failed SU
974: * is not being accessed.
975: */
976: RF_ETIMER_START(timer);
977: RF_Malloc(buf, numDataCol * sizeof(char *), (char **));
978:
979: ppda = node->results[0]; /*
980: * Instead of being buffers,
981: * node->results[0] and [1]
982: * are Ppda and Epda.
983: */
984: epda = node->results[1];
985: fpda = asmap->failedPDAs[0];
986:
987: /* First, recovery the failed old SU using EvenOdd double decoding. */
988: /* Determine the startSector and endSector for decoding. */
989: startSector = rf_StripeUnitOffset(layoutPtr, fpda->startSector);
990: endSector = startSector + fpda->numSector;
991: /*
992: * Assign buf[col] pointers to point to each non-failed column and
993: * initialize the pbuf and ebuf to point at the beginning of each
994: * source buffers and destination buffers. */
995: for (prm = 0; prm < numDataCol - 2; prm++) {
996: pda = (RF_PhysDiskAddr_t *) node->params[prm].p;
997: col = rf_EUCol(layoutPtr, pda->raidAddress);
998: buf[col] = pda->bufPtr;
999: }
1000: /*
1001: * pbuf and ebuf: They will change values as double recovery decoding
1002: * goes on.
1003: */
1004: pbuf = ppda->bufPtr;
1005: ebuf = epda->bufPtr;
1006: /*
1007: * Find out the logical column numbers in the encoding matrix of the
1008: * two failed columns.
1009: */
1010: fcol[0] = rf_EUCol(layoutPtr, fpda->raidAddress);
1011:
1012: /* Find out the other failed column not accessed this time. */
1013: sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
1014: asmap->raidAddress);
1015: for (i = 0; i < numDataCol; i++) {
1016: npda.raidAddress = sosAddr + (i * secPerSU);
1017: (raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress,
1018: &(npda.row), &(npda.col), &(npda.startSector), 0);
1019: /* Skip over dead disks. */
1020: if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
1021: if (i != fcol[0])
1022: break;
1023: }
1024: RF_ASSERT(i < numDataCol);
1025: fcol[1] = i;
1026: /* Assign temporary space to put recovered failed SU. */
1027: numbytes = fpda->numSector * bytesPerSector;
1028: RF_Malloc(olddata[0], numbytes, (char *));
1029: RF_Malloc(olddata[1], numbytes, (char *));
1030: dest[0] = olddata[0];
1031: dest[1] = olddata[1];
1032: bzero(olddata[0], numbytes);
1033: bzero(olddata[1], numbytes);
1034: /*
1035: * Begin the recovery decoding, initially buf[j], ebuf, pbuf, dest[j]
1036: * have already pointed at the beginning of each source buffers and
1037: * destination buffers.
1038: */
1039: for (sector = startSector, i = 0; sector < endSector; sector++, i++) {
1040: rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
1041: for (j = 0; j < numDataCol; j++)
1042: if ((j != fcol[0]) && (j != fcol[1]))
1043: buf[j] += bytesPerSector;
1044: dest[0] += bytesPerSector;
1045: dest[1] += bytesPerSector;
1046: ebuf += bytesPerSector;
1047: pbuf += bytesPerSector;
1048: }
1049: /*
1050: * After recovery, the buffer pointed by olddata[0] is the old failed
1051: * data. With new writing data and this old data, use small write to
1052: * calculate the new redundant informations.
1053: */
1054: /*
1055: * node->params[ 0, ... PDAPerDisk * (numDataCol - 2)-1 ] are Pdas of
1056: * Rrd; params[ PDAPerDisk*(numDataCol - 2), ... PDAPerDisk*numDataCol
1057: * -1 ] are Pdas of Rp, ( Rp2 ), Re, ( Re2 ) ; params[
1058: * PDAPerDisk*numDataCol, ... PDAPerDisk*numDataCol
1059: * +asmap->numStripeUnitsAccessed -asmap->numDataFailed-1] are Pdas of
1060: * wudNodes; For current implementation, we assume the simplest case:
1061: * asmap->numStripeUnitsAccessed == 1 and asmap->numDataFailed == 1
1062: * ie. PDAPerDisk = 1 then node->params[numDataCol] must be the new
1063: * data to be written to the failed disk. We first bxor the new data
1064: * into the old recovered data, then do the same things as small
1065: * write.
1066: */
1067:
1068: rf_bxor(((RF_PhysDiskAddr_t *) node->params[numDataCol].p)->bufPtr,
1069: olddata[0], numbytes, node->dagHdr->bp);
1070: /* Do new 'E' calculation. */
1071: /*
1072: * Find out the corresponding column in encoding matrix for write
1073: * column to be encoded into redundant disk 'E'.
1074: */
1075: scol = rf_EUCol(layoutPtr, fpda->raidAddress);
1076: /*
1077: * olddata[0] now is source buffer pointer; epda->bufPtr is the dest
1078: * buffer pointer.
1079: */
1080: rf_e_encToBuf(raidPtr, scol, olddata[0], RF_EO_MATRIX_DIM - 2,
1081: epda->bufPtr, fpda->numSector);
1082:
1083: /* Do new 'P' calculation. */
1084: rf_bxor(olddata[0], ppda->bufPtr, numbytes, node->dagHdr->bp);
1085: /* Free the allocated buffer. */
1086: RF_Free(olddata[0], numbytes);
1087: RF_Free(olddata[1], numbytes);
1088: RF_Free(buf, numDataCol * sizeof(char *));
1089:
1090: RF_ETIMER_STOP(timer);
1091: RF_ETIMER_EVAL(timer);
1092: if (tracerec) {
1093: tracerec->q_us += RF_ETIMER_VAL_US(timer);
1094: }
1095: rf_GenericWakeupFunc(node, 0);
1096: return (0);
1097: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_evenodd_dagfuncs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe