Annotation of sys/dev/raidframe/rf_pqdeg.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_pqdeg.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $ */
2: /* $NetBSD: rf_pqdeg.c,v 1.5 2000/01/07 03:41:04 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Daniel Stodolsky
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: #include "rf_archs.h"
32:
33: #if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
34:
35: #include "rf_types.h"
36: #include "rf_raid.h"
37: #include "rf_dag.h"
38: #include "rf_dagutils.h"
39: #include "rf_dagfuncs.h"
40: #include "rf_dagffrd.h"
41: #include "rf_dagffwr.h"
42: #include "rf_dagdegrd.h"
43: #include "rf_dagdegwr.h"
44: #include "rf_etimer.h"
45: #include "rf_pqdeg.h"
46: #include "rf_general.h"
47: #include "rf_pqdegdags.h"
48: #include "rf_pq.h"
49:
50: /*
51: * Degraded mode dag functions for P+Q calculations.
52: *
53: * The following nomenclature is used.
54: *
55: * PQ_<D><P><Q>_Create{Large,Small}<Write|Read>DAG
56: *
57: * where <D><P><Q> are single digits representing the number of failed
58: * data units <D> (0,1,2), parity units <P> (0,1), and Q units <Q>, effecting
59: * the I/O. The reads have only PQ_<D><P><Q>_CreateReadDAG variants, while
60: * the single fault writes have both large and small write versions.
61: * Single fault PQ is equivalent to normal mode raid 5 in many aspects.
62: *
63: * Some versions degenerate into the same case, and are grouped together below.
64: */
65:
66:
67: /* Reads, single failure. */
68:
69: /* We have parity, so we can do a raid 5 reconstruct read. */
70: RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateReadDAG)
71: {
72: rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
73: &rf_pRecoveryFuncs);
74: }
75:
76:
77: /* Reads double failure. */
78:
79: /*
80: * Q is lost, but not parity.
81: * So we can a raid 5 reconstruct read.
82: */
83: RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateReadDAG)
84: {
85: rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
86: &rf_pRecoveryFuncs);
87: }
88:
89: /*
90: * Parity is lost, so we need to
91: * do a reconstruct read and recompute
92: * the data with Q.
93: */
94: RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateReadDAG)
95: {
96: RF_PhysDiskAddr_t *temp;
97: /* Swap P and Q pointers to fake out the DegradedReadDAG code. */
98: temp = asmap->parityInfo;
99: asmap->parityInfo = asmap->qInfo;
100: asmap->qInfo = temp;
101: rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
102: &rf_qRecoveryFuncs);
103: }
104:
105: /*
106: * Two data units are dead in this stripe, so we will need read
107: * both P and Q to reconstruct the data. Note that only
108: * one data unit we are reading may actually be missing.
109: */
110: RF_CREATE_DAG_FUNC_DECL(rf_CreateDoubleDegradedReadDAG);
111: RF_CREATE_DAG_FUNC_DECL(rf_CreateDoubleDegradedReadDAG)
112: {
113: rf_PQ_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
114: }
115:
116: RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateReadDAG);
117: RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateReadDAG)
118: {
119: rf_CreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
120: allocList);
121: }
122:
123:
124: /* Writes, single failure. */
125:
126: RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateWriteDAG);
127: RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateWriteDAG)
128: {
129: if (asmap->numStripeUnitsAccessed != 1 &&
130: asmap->failedPDAs[0]->numSector !=
131: raidPtr->Layout.sectorsPerStripeUnit)
132: RF_PANIC();
133: rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
134: flags, allocList, 2, (int (*) (RF_DagNode_t *))
135: rf_Degraded_100_PQFunc, RF_FALSE);
136: }
137:
138: /* Dead P - act like a RAID 5 small write with parity = Q. */
139: RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateSmallWriteDAG)
140: {
141: RF_PhysDiskAddr_t *temp;
142: /* Swap P and Q pointers to fake out the DegradedReadDAG code. */
143: temp = asmap->parityInfo;
144: asmap->parityInfo = asmap->qInfo;
145: asmap->qInfo = temp;
146: rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
147: allocList, &rf_qFuncs, NULL);
148: }
149:
150: /* Dead Q - act like a RAID 5 small write. */
151: RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateSmallWriteDAG)
152: {
153: rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
154: allocList, &rf_pFuncs, NULL);
155: }
156:
157: /* Dead P - act like a RAID 5 large write but for Q. */
158: RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateLargeWriteDAG)
159: {
160: RF_PhysDiskAddr_t *temp;
161: /* Swap P and Q pointers to fake out the code. */
162: temp = asmap->parityInfo;
163: asmap->parityInfo = asmap->qInfo;
164: asmap->qInfo = temp;
165: rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
166: allocList, 1, rf_RegularQFunc, RF_FALSE);
167: }
168:
169: /* Dead Q - act like a RAID 5 large write. */
170: RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateLargeWriteDAG)
171: {
172: rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
173: allocList, 1, rf_RegularPFunc, RF_FALSE);
174: }
175:
176:
177: /* Writes, double failure. */
178:
179: /* Lost P & Q - do a nonredundant write. */
180: RF_CREATE_DAG_FUNC_DECL(rf_PQ_011_CreateWriteDAG)
181: {
182: rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
183: allocList, RF_IO_TYPE_WRITE);
184: }
185:
186:
187: /*
188: * In the two cases below, a nasty case arises when it's a write for a
189: * (strict) portion of a failed stripe unit and parts of another su.
190: * For now, we do not support this.
191: */
192:
193: /* Lost Data and P - do a Q write. */
194: RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateWriteDAG)
195: {
196: RF_PhysDiskAddr_t *temp;
197:
198: if (asmap->numStripeUnitsAccessed != 1 &&
199: asmap->failedPDAs[0]->numSector !=
200: raidPtr->Layout.sectorsPerStripeUnit) {
201: RF_PANIC();
202: }
203: /* Swap P and Q to fake out parity code. */
204: temp = asmap->parityInfo;
205: asmap->parityInfo = asmap->qInfo;
206: asmap->qInfo = temp;
207: rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
208: allocList, 1, (int (*) (RF_DagNode_t *))
209: rf_PQ_DegradedWriteQFunc, RF_FALSE);
210: /* Is the regular Q func the right one to call ? */
211: }
212:
213: /* Lost Data and Q - do degraded mode P write. */
214: RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateWriteDAG)
215: {
216: if (asmap->numStripeUnitsAccessed != 1 &&
217: asmap->failedPDAs[0]->numSector !=
218: raidPtr->Layout.sectorsPerStripeUnit)
219: RF_PANIC();
220: rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
221: allocList, 1, rf_RecoveryXorFunc, RF_FALSE);
222: }
223:
224: #endif /* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_pqdeg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe