Annotation of sys/dev/raidframe/rf_reconutil.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_reconutil.c,v 1.3 2002/12/16 07:01:05 tdeval Exp $ */
2: /* $NetBSD: rf_reconutil.c,v 1.3 1999/02/05 00:06:17 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Mark Holland
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_reconutil.c -- Reconstruction utilities.
33: **********************************************/
34:
35: #include "rf_types.h"
36: #include "rf_raid.h"
37: #include "rf_desc.h"
38: #include "rf_reconutil.h"
39: #include "rf_reconbuffer.h"
40: #include "rf_general.h"
41: #include "rf_decluster.h"
42: #include "rf_raid5_rotatedspare.h"
43: #include "rf_interdecluster.h"
44: #include "rf_chaindecluster.h"
45:
46:
47: /*********************************************************************
48: * Allocates/frees the reconstruction control information structures.
49: *********************************************************************/
50: RF_ReconCtrl_t *
51: rf_MakeReconControl(
52: RF_RaidReconDesc_t *reconDesc,
53: RF_RowCol_t frow, /* Failed row and column. */
54: RF_RowCol_t fcol,
55: RF_RowCol_t srow, /* Identifies which spare we're using. */
56: RF_RowCol_t scol
57: )
58: {
59: RF_Raid_t *raidPtr = reconDesc->raidPtr;
60: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
61: RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU /
62: layoutPtr->SUsPerRU;
63: RF_ReconUnitCount_t numSpareRUs;
64: RF_ReconCtrl_t *reconCtrlPtr;
65: RF_ReconBuffer_t *rbuf;
66: RF_LayoutSW_t *lp;
67: int retcode, rc;
68: RF_RowCol_t i;
69:
70: lp = raidPtr->Layout.map;
71:
72: /*
73: * Make and zero the global reconstruction structure and the per-disk
74: * structure.
75: */
76: RF_Calloc(reconCtrlPtr, 1, sizeof(RF_ReconCtrl_t), (RF_ReconCtrl_t *));
77: /* This zeros it. */
78: RF_Calloc(reconCtrlPtr->perDiskInfo, raidPtr->numCol,
79: sizeof(RF_PerDiskReconCtrl_t), (RF_PerDiskReconCtrl_t *));
80: reconCtrlPtr->reconDesc = reconDesc;
81: reconCtrlPtr->fcol = fcol;
82: reconCtrlPtr->spareRow = srow;
83: reconCtrlPtr->spareCol = scol;
84: reconCtrlPtr->lastPSID = layoutPtr->numStripe / layoutPtr->SUsPerPU;
85: reconCtrlPtr->percentComplete = 0;
86:
87: /* Initialize each per-disk recon information structure. */
88: for (i = 0; i < raidPtr->numCol; i++) {
89: reconCtrlPtr->perDiskInfo[i].reconCtrl = reconCtrlPtr;
90: reconCtrlPtr->perDiskInfo[i].row = frow;
91: reconCtrlPtr->perDiskInfo[i].col = i;
92: /* Make it appear as if we just finished an RU. */
93: reconCtrlPtr->perDiskInfo[i].curPSID = -1;
94: reconCtrlPtr->perDiskInfo[i].ru_count = RUsPerPU - 1;
95: }
96:
97: /*
98: * Get the number of spare units per disk and the sparemap in case
99: * spare is distributed.
100: */
101:
102: if (lp->GetNumSpareRUs) {
103: numSpareRUs = lp->GetNumSpareRUs(raidPtr);
104: } else {
105: numSpareRUs = 0;
106: }
107:
108: /*
109: * Not all distributed sparing archs need dynamic mappings.
110: */
111: if (lp->InstallSpareTable) {
112: retcode = rf_InstallSpareTable(raidPtr, frow, fcol);
113: if (retcode) {
114: RF_PANIC(); /* XXX Fix this. */
115: }
116: }
117: /* Make the reconstruction map. */
118: reconCtrlPtr->reconMap = rf_MakeReconMap(raidPtr,
119: (int) (layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit),
120: raidPtr->sectorsPerDisk, numSpareRUs);
121:
122: /* Make the per-disk reconstruction buffers. */
123: for (i = 0; i < raidPtr->numCol; i++) {
124: reconCtrlPtr->perDiskInfo[i].rbuf = (i == fcol) ? NULL :
125: rf_MakeReconBuffer(raidPtr, frow, i,
126: RF_RBUF_TYPE_EXCLUSIVE);
127: }
128:
129: /* Initialize the event queue. */
130: rc = rf_mutex_init(&reconCtrlPtr->eq_mutex);
131: if (rc) {
132: /* XXX Deallocate, cleanup. */
133: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
134: __FILE__, __LINE__, rc);
135: return (NULL);
136: }
137: rc = rf_cond_init(&reconCtrlPtr->eq_cond);
138: if (rc) {
139: /* XXX Deallocate, cleanup. */
140: RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d.\n",
141: __FILE__, __LINE__, rc);
142: return (NULL);
143: }
144: reconCtrlPtr->eventQueue = NULL;
145: reconCtrlPtr->eq_count = 0;
146:
147: /* Make the floating recon buffers and append them to the free list. */
148: rc = rf_mutex_init(&reconCtrlPtr->rb_mutex);
149: if (rc) {
150: /* XXX Deallocate, cleanup. */
151: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
152: __FILE__, __LINE__, rc);
153: return (NULL);
154: }
155: reconCtrlPtr->fullBufferList = NULL;
156: reconCtrlPtr->priorityList = NULL;
157: reconCtrlPtr->floatingRbufs = NULL;
158: reconCtrlPtr->committedRbufs = NULL;
159: for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
160: rbuf = rf_MakeReconBuffer(raidPtr, frow, fcol,
161: RF_RBUF_TYPE_FLOATING);
162: rbuf->next = reconCtrlPtr->floatingRbufs;
163: reconCtrlPtr->floatingRbufs = rbuf;
164: }
165:
166: /* Create the parity stripe status table. */
167: reconCtrlPtr->pssTable = rf_MakeParityStripeStatusTable(raidPtr);
168:
169: /* Set the initial min head sep counter val. */
170: reconCtrlPtr->minHeadSepCounter = 0;
171:
172: return (reconCtrlPtr);
173: }
174:
175: void
176: rf_FreeReconControl(RF_Raid_t *raidPtr, RF_RowCol_t row)
177: {
178: RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
179: RF_ReconBuffer_t *t;
180: RF_ReconUnitNum_t i;
181:
182: RF_ASSERT(reconCtrlPtr);
183: for (i = 0; i < raidPtr->numCol; i++)
184: if (reconCtrlPtr->perDiskInfo[i].rbuf)
185: rf_FreeReconBuffer(reconCtrlPtr->perDiskInfo[i].rbuf);
186: for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
187: t = reconCtrlPtr->floatingRbufs;
188: RF_ASSERT(t);
189: reconCtrlPtr->floatingRbufs = t->next;
190: rf_FreeReconBuffer(t);
191: }
192: rf_mutex_destroy(&reconCtrlPtr->rb_mutex);
193: rf_mutex_destroy(&reconCtrlPtr->eq_mutex);
194: rf_cond_destroy(&reconCtrlPtr->eq_cond);
195: rf_FreeReconMap(reconCtrlPtr->reconMap);
196: rf_FreeParityStripeStatusTable(raidPtr, reconCtrlPtr->pssTable);
197: RF_Free(reconCtrlPtr->perDiskInfo, raidPtr->numCol *
198: sizeof(RF_PerDiskReconCtrl_t));
199: RF_Free(reconCtrlPtr, sizeof(*reconCtrlPtr));
200: }
201:
202:
203: /*****************************************************************************
204: * Computes the default head separation limit.
205: *****************************************************************************/
206: RF_HeadSepLimit_t
207: rf_GetDefaultHeadSepLimit(RF_Raid_t *raidPtr)
208: {
209: RF_HeadSepLimit_t hsl;
210: RF_LayoutSW_t *lp;
211:
212: lp = raidPtr->Layout.map;
213: if (lp->GetDefaultHeadSepLimit == NULL)
214: return (-1);
215: hsl = lp->GetDefaultHeadSepLimit(raidPtr);
216: return (hsl);
217: }
218:
219:
220: /*****************************************************************************
221: * Computes the default number of floating recon buffers.
222: *****************************************************************************/
223: int
224: rf_GetDefaultNumFloatingReconBuffers(RF_Raid_t *raidPtr)
225: {
226: RF_LayoutSW_t *lp;
227: int nrb;
228:
229: lp = raidPtr->Layout.map;
230: if (lp->GetDefaultNumFloatingReconBuffers == NULL)
231: return (3 * raidPtr->numCol);
232: nrb = lp->GetDefaultNumFloatingReconBuffers(raidPtr);
233: return (nrb);
234: }
235:
236:
237: /*****************************************************************************
238: * Creates and initializes a reconstruction buffer.
239: *****************************************************************************/
240: RF_ReconBuffer_t *
241: rf_MakeReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
242: RF_RbufType_t type)
243: {
244: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
245: RF_ReconBuffer_t *t;
246: u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
247: layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit);
248:
249: RF_Malloc(t, sizeof(RF_ReconBuffer_t), (RF_ReconBuffer_t *));
250: RF_Malloc(t->buffer, recon_buffer_size, (caddr_t));
251: RF_Malloc(t->arrived, raidPtr->numCol * sizeof(char), (char *));
252: t->raidPtr = raidPtr;
253: t->row = row;
254: t->col = col;
255: t->priority = RF_IO_RECON_PRIORITY;
256: t->type = type;
257: t->pssPtr = NULL;
258: t->next = NULL;
259: return (t);
260: }
261:
262:
263: /*****************************************************************************
264: * Frees a reconstruction buffer.
265: *****************************************************************************/
266: void
267: rf_FreeReconBuffer(RF_ReconBuffer_t *rbuf)
268: {
269: RF_Raid_t *raidPtr = rbuf->raidPtr;
270: u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
271: raidPtr->Layout.SUsPerRU * raidPtr->Layout.sectorsPerStripeUnit);
272:
273: RF_Free(rbuf->arrived, raidPtr->numCol * sizeof(char));
274: RF_Free(rbuf->buffer, recon_buffer_size);
275: RF_Free(rbuf, sizeof(*rbuf));
276: }
277:
278:
279: /*****************************************************************************
280: * Debug only: Sanity check the number of floating recon bufs in use.
281: *****************************************************************************/
282: void
283: rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock)
284: {
285: RF_ReconParityStripeStatus_t *p;
286: RF_PSStatusHeader_t *pssTable;
287: RF_ReconBuffer_t *rbuf;
288: int i, j, sum = 0;
289: RF_RowCol_t frow = 0;
290:
291: for (i = 0; i < raidPtr->numRow; i++)
292: if (raidPtr->reconControl[i]) {
293: frow = i;
294: break;
295: }
296: RF_ASSERT(frow >= 0);
297:
298: if (dolock)
299: RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
300: pssTable = raidPtr->reconControl[frow]->pssTable;
301:
302: for (i = 0; i < raidPtr->pssTableSize; i++) {
303: RF_LOCK_MUTEX(pssTable[i].mutex);
304: for (p = pssTable[i].chain; p; p = p->next) {
305: rbuf = (RF_ReconBuffer_t *) p->rbuf;
306: if (rbuf && rbuf->type == RF_RBUF_TYPE_FLOATING)
307: sum++;
308:
309: rbuf = (RF_ReconBuffer_t *) p->writeRbuf;
310: if (rbuf && rbuf->type == RF_RBUF_TYPE_FLOATING)
311: sum++;
312:
313: for (j = 0; j < p->xorBufCount; j++) {
314: rbuf = (RF_ReconBuffer_t *) p->rbufsForXor[j];
315: RF_ASSERT(rbuf);
316: if (rbuf->type == RF_RBUF_TYPE_FLOATING)
317: sum++;
318: }
319: }
320: RF_UNLOCK_MUTEX(pssTable[i].mutex);
321: }
322:
323: for (rbuf = raidPtr->reconControl[frow]->floatingRbufs; rbuf;
324: rbuf = rbuf->next) {
325: if (rbuf->type == RF_RBUF_TYPE_FLOATING)
326: sum++;
327: }
328: for (rbuf = raidPtr->reconControl[frow]->committedRbufs; rbuf;
329: rbuf = rbuf->next) {
330: if (rbuf->type == RF_RBUF_TYPE_FLOATING)
331: sum++;
332: }
333: for (rbuf = raidPtr->reconControl[frow]->fullBufferList; rbuf;
334: rbuf = rbuf->next) {
335: if (rbuf->type == RF_RBUF_TYPE_FLOATING)
336: sum++;
337: }
338: for (rbuf = raidPtr->reconControl[frow]->priorityList; rbuf;
339: rbuf = rbuf->next) {
340: if (rbuf->type == RF_RBUF_TYPE_FLOATING)
341: sum++;
342: }
343:
344: RF_ASSERT(sum == raidPtr->numFloatingReconBufs);
345:
346: if (dolock)
347: RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
348: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_reconutil.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe