Annotation of sys/dev/raidframe/rf_reconbuffer.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_reconbuffer.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $ */
2: /* $NetBSD: rf_reconbuffer.c,v 1.4 2000/03/13 23:52:36 soren 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: *
33: * rf_reconbuffer.c -- Reconstruction buffer manager.
34: *
35: *****************************************************/
36:
37: #include "rf_raid.h"
38: #include "rf_reconbuffer.h"
39: #include "rf_acctrace.h"
40: #include "rf_etimer.h"
41: #include "rf_general.h"
42: #include "rf_debugprint.h"
43: #include "rf_revent.h"
44: #include "rf_reconutil.h"
45: #include "rf_nwayxor.h"
46:
47: #define Dprintf1(s,a) if (rf_reconbufferDebug) printf(s, a)
48: #define Dprintf2(s,a,b) if (rf_reconbufferDebug) printf(s, a, b)
49: #define Dprintf3(s,a,b,c) if (rf_reconbufferDebug) printf(s, a, b, c)
50: #define Dprintf4(s,a,b,c,d) if (rf_reconbufferDebug) printf(s, a, b, c, d)
51: #define Dprintf5(s,a,b,c,d,e) if (rf_reconbufferDebug) printf(s, a, b, c, d, e)
52:
53: /*****************************************************************************
54: *
55: * Submit a reconstruction buffer to the manager for XOR.
56: * We can only submit a buffer if (1) we can xor into an existing buffer,
57: * which means we don't have to acquire a new one, (2) we can acquire a
58: * floating recon buffer, or (3) the caller has indicated that we are allowed
59: * to keep the submitted buffer.
60: *
61: * Returns non-zero if and only if we were not able to submit.
62: * In this case, we append the current disk ID to the wait list on the
63: * indicated RU, so that it will be re-enabled when we acquire a buffer for
64: * this RU.
65: *
66: *****************************************************************************/
67:
68: /* Just to make the code below more readable. */
69: #define BUFWAIT_APPEND(_cb_,_pssPtr_,_row_,_col_) \
70: do { \
71: _cb_ = rf_AllocCallbackDesc(); \
72: (_cb_)->row = (_row_); \
73: (_cb_)->col = (_col_); \
74: (_cb_)->next = (_pssPtr_)->bufWaitList; \
75: (_pssPtr_)->bufWaitList = (_cb_); \
76: } while (0)
77:
78: /*
79: * rf_nWayXorFuncs[i] is a pointer to a function that will xor "i"
80: * bufs into the accumulating sum.
81: */
82: static RF_VoidFuncPtr rf_nWayXorFuncs[] = {
83: NULL,
84: (RF_VoidFuncPtr) rf_nWayXor1,
85: (RF_VoidFuncPtr) rf_nWayXor2,
86: (RF_VoidFuncPtr) rf_nWayXor3,
87: (RF_VoidFuncPtr) rf_nWayXor4,
88: (RF_VoidFuncPtr) rf_nWayXor5,
89: (RF_VoidFuncPtr) rf_nWayXor6,
90: (RF_VoidFuncPtr) rf_nWayXor7,
91: (RF_VoidFuncPtr) rf_nWayXor8,
92: (RF_VoidFuncPtr) rf_nWayXor9
93: };
94:
95:
96: int
97: rf_SubmitReconBuffer(
98: RF_ReconBuffer_t *rbuf, /* The recon buffer to submit. */
99: int keep_it, /*
100: * Whether we can keep this buffer or
101: * we have to return it.
102: */
103: int use_committed /*
104: * Whether to use a committed or an
105: * available recon buffer.
106: */
107: )
108: {
109: RF_LayoutSW_t *lp;
110: int rc;
111:
112: lp = rbuf->raidPtr->Layout.map;
113: rc = lp->SubmitReconBuffer(rbuf, keep_it, use_committed);
114: return (rc);
115: }
116:
117: int
118: rf_SubmitReconBufferBasic(
119: RF_ReconBuffer_t *rbuf, /* The recon buffer to submit. */
120: int keep_it, /*
121: * Whether we can keep this buffer
122: * or we have to return it.
123: */
124: int use_committed /*
125: * Whether to use a committed or
126: * an available recon buffer.
127: */
128: )
129: {
130: RF_Raid_t *raidPtr = rbuf->raidPtr;
131: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
132: RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[rbuf->row];
133: RF_ReconParityStripeStatus_t *pssPtr;
134: /* Temporary rbuf pointers. */
135: RF_ReconBuffer_t *targetRbuf, *t = NULL;
136: /* Temporary data buffer pointer. */
137: caddr_t ta;
138: RF_CallbackDesc_t *cb, *p;
139: int retcode = 0, created = 0;
140:
141: RF_Etimer_t timer;
142:
143: /* Makes no sense to have a submission from the failed disk. */
144: RF_ASSERT(rbuf);
145: RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
146:
147: Dprintf5("RECON: submission by row %d col %d for psid %ld ru %d"
148: " (failed offset %ld).\n", rbuf->row, rbuf->col,
149: (long) rbuf->parityStripeID, rbuf->which_ru,
150: (long) rbuf->failedDiskSectorOffset);
151:
152: RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
153:
154: RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
155:
156: pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
157: rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
158: RF_ASSERT(pssPtr); /*
159: * If it didn't exist, we wouldn't have gotten
160: * an rbuf for it.
161: */
162:
163: /*
164: * Check to see if enough buffers have accumulated to do an XOR. If
165: * so, there's no need to acquire a floating rbuf. Before we can do
166: * any XORing, we must have acquired a destination buffer. If we
167: * have, then we can go ahead and do the XOR if (1) including this
168: * buffer, enough bufs have accumulated, or (2) this is the last
169: * submission for this stripe. Otherwise, we have to go acquire a
170: * floating rbuf.
171: */
172:
173: targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
174: if ((targetRbuf != NULL) &&
175: ((pssPtr->xorBufCount == rf_numBufsToAccumulate - 1) ||
176: (targetRbuf->count + pssPtr->xorBufCount + 1 ==
177: layoutPtr->numDataCol))) {
178: /* Install this buffer. */
179: pssPtr->rbufsForXor[pssPtr->xorBufCount++] = rbuf;
180: Dprintf3("RECON: row %d col %d invoking a %d-way XOR.\n",
181: rbuf->row, rbuf->col, pssPtr->xorBufCount);
182: RF_ETIMER_START(timer);
183: rf_MultiWayReconXor(raidPtr, pssPtr);
184: RF_ETIMER_STOP(timer);
185: RF_ETIMER_EVAL(timer);
186: raidPtr->accumXorTimeUs += RF_ETIMER_VAL_US(timer);
187: if (!keep_it) {
188: raidPtr->recon_tracerecs[rbuf->col].xor_us =
189: RF_ETIMER_VAL_US(timer);
190: RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col]
191: .recon_timer);
192: RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col]
193: .recon_timer);
194: raidPtr->recon_tracerecs[rbuf->col]
195: .specific.recon.recon_return_to_submit_us +=
196: RF_ETIMER_VAL_US(raidPtr
197: ->recon_tracerecs[rbuf->col].recon_timer);
198: RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col]
199: .recon_timer);
200:
201: rf_LogTraceRec(raidPtr,
202: &raidPtr->recon_tracerecs[rbuf->col]);
203: }
204: rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
205: layoutPtr->numDataCol);
206:
207: /*
208: * If use_committed is on, we _must_ consume a buffer off the
209: * committed list.
210: */
211: if (use_committed) {
212: t = reconCtrlPtr->committedRbufs;
213: RF_ASSERT(t);
214: reconCtrlPtr->committedRbufs = t->next;
215: rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
216: }
217: if (keep_it) {
218: RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row,
219: rbuf->parityStripeID);
220: RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
221: rf_FreeReconBuffer(rbuf);
222: return (retcode);
223: }
224: goto out;
225: }
226: /* Set the value of "t", which we'll use as the rbuf from here on. */
227: if (keep_it) {
228: t = rbuf;
229: } else {
230: if (use_committed) {
231: /* If a buffer has been committed to us, use it. */
232:
233: t = reconCtrlPtr->committedRbufs;
234: RF_ASSERT(t);
235: reconCtrlPtr->committedRbufs = t->next;
236: t->next = NULL;
237: } else
238: if (reconCtrlPtr->floatingRbufs) {
239: t = reconCtrlPtr->floatingRbufs;
240: reconCtrlPtr->floatingRbufs = t->next;
241: t->next = NULL;
242: }
243: }
244:
245: /*
246: * If we weren't able to acquire a buffer, append to the end of the
247: * buf list in the recon ctrl struct.
248: */
249: if (!t) {
250: RF_ASSERT(!keep_it && !use_committed);
251: Dprintf2("RECON: row %d col %d failed to acquire floating"
252: " rbuf.\n", rbuf->row, rbuf->col);
253:
254: raidPtr->procsInBufWait++;
255: if ((raidPtr->procsInBufWait == raidPtr->numCol - 1) &&
256: (raidPtr->numFullReconBuffers == 0)) {
257: printf("Buffer wait deadlock detected. Exiting.\n");
258: rf_PrintPSStatusTable(raidPtr, rbuf->row);
259: RF_PANIC();
260: }
261: pssPtr->flags |= RF_PSS_BUFFERWAIT;
262: /* Append to buf wait list in recon ctrl structure. */
263: cb = rf_AllocCallbackDesc();
264: cb->row = rbuf->row;
265: cb->col = rbuf->col;
266: cb->callbackArg.v = rbuf->parityStripeID;
267: cb->callbackArg2.v = rbuf->which_ru;
268: cb->next = NULL;
269: if (!reconCtrlPtr->bufferWaitList)
270: reconCtrlPtr->bufferWaitList = cb;
271: else {
272: /*
273: * Might want to maintain head/tail pointers
274: * here rather than search for end of list.
275: */
276: for (p = reconCtrlPtr->bufferWaitList; p->next;
277: p = p->next);
278: p->next = cb;
279: }
280: retcode = 1;
281: goto out;
282: }
283: Dprintf2("RECON: row %d col %d acquired rbuf.\n", rbuf->row, rbuf->col);
284: RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
285: RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
286: raidPtr->recon_tracerecs[rbuf->col]
287: .specific.recon.recon_return_to_submit_us +=
288: RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
289: RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
290:
291: rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
292:
293: /* Initialize the buffer. */
294: if (t != rbuf) {
295: t->row = rbuf->row;
296: t->col = reconCtrlPtr->fcol;
297: t->parityStripeID = rbuf->parityStripeID;
298: t->which_ru = rbuf->which_ru;
299: t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
300: t->spRow = rbuf->spRow;
301: t->spCol = rbuf->spCol;
302: t->spOffset = rbuf->spOffset;
303:
304: ta = t->buffer;
305: t->buffer = rbuf->buffer;
306: rbuf->buffer = ta; /* Swap buffers. */
307: }
308: /*
309: * The first installation always gets installed as the destination
310: * buffer. Subsequent installations get stacked up to allow for
311: * multi-way XOR.
312: */
313: if (!pssPtr->rbuf) {
314: pssPtr->rbuf = t;
315: t->count = 1;
316: } else
317: /* Install this buffer. */
318: pssPtr->rbufsForXor[pssPtr->xorBufCount++] = t;
319:
320: /* The buffer is full if G=2. */
321: rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
322: layoutPtr->numDataCol);
323:
324: out:
325: RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
326: RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
327: return (retcode);
328: }
329:
330: int
331: rf_MultiWayReconXor(
332: RF_Raid_t *raidPtr,
333: RF_ReconParityStripeStatus_t *pssPtr /*
334: * The pss descriptor for this
335: * parity stripe.
336: */
337: )
338: {
339: int i, numBufs = pssPtr->xorBufCount;
340: int numBytes = rf_RaidAddressToByte(raidPtr,
341: raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
342: RF_ReconBuffer_t **rbufs = (RF_ReconBuffer_t **) pssPtr->rbufsForXor;
343: RF_ReconBuffer_t *targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
344:
345: RF_ASSERT(pssPtr->rbuf != NULL);
346: RF_ASSERT(numBufs > 0 && numBufs < RF_PS_MAX_BUFS);
347: #ifdef _KERNEL
348: #if !defined(__NetBSD__) && !defined(__OpenBSD__)
349: /* Yield the processor before doing a big XOR. */
350: thread_block();
351: #endif
352: #endif /* _KERNEL */
353: /*
354: * XXX
355: *
356: * What if more than 9 bufs ?
357: */
358: rf_nWayXorFuncs[numBufs] (pssPtr->rbufsForXor, targetRbuf,
359: numBytes / sizeof(long));
360:
361: /*
362: * Release all the reconstruction buffers except the last one, which
363: * belongs to the disk whose submission caused this XOR to take place.
364: */
365: for (i = 0; i < numBufs - 1; i++) {
366: if (rbufs[i]->type == RF_RBUF_TYPE_FLOATING)
367: rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row,
368: rbufs[i]);
369: else
370: if (rbufs[i]->type == RF_RBUF_TYPE_FORCED)
371: rf_FreeReconBuffer(rbufs[i]);
372: else
373: RF_ASSERT(0);
374: }
375: targetRbuf->count += pssPtr->xorBufCount;
376: pssPtr->xorBufCount = 0;
377: return (0);
378: }
379:
380:
381: /*
382: * Removes one full buffer from one of the full-buffer lists and returns it.
383: *
384: * ASSUMES THE RB_MUTEX IS UNLOCKED AT ENTRY.
385: */
386: RF_ReconBuffer_t *
387: rf_GetFullReconBuffer(RF_ReconCtrl_t *reconCtrlPtr)
388: {
389: RF_ReconBuffer_t *p;
390:
391: RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
392:
393: if ((p = reconCtrlPtr->priorityList) != NULL) {
394: reconCtrlPtr->priorityList = p->next;
395: p->next = NULL;
396: goto out;
397: }
398: if ((p = reconCtrlPtr->fullBufferList) != NULL) {
399: reconCtrlPtr->fullBufferList = p->next;
400: p->next = NULL;
401: goto out;
402: }
403: out:
404: RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
405: return (p);
406: }
407:
408:
409: /*
410: * If the reconstruction buffer is full, move it to the full list, which
411: * is maintained sorted by failed disk sector offset.
412: *
413: * ASSUMES THE RB_MUTEX IS LOCKED AT ENTRY.
414: */
415: int
416: rf_CheckForFullRbuf(RF_Raid_t *raidPtr, RF_ReconCtrl_t *reconCtrl,
417: RF_ReconParityStripeStatus_t *pssPtr, int numDataCol)
418: {
419: RF_ReconBuffer_t *p, *pt, *rbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
420:
421: if (rbuf->count == numDataCol) {
422: raidPtr->numFullReconBuffers++;
423: Dprintf2("RECON: rbuf for psid %ld ru %d has filled.\n",
424: (long) rbuf->parityStripeID, rbuf->which_ru);
425: if (!reconCtrl->fullBufferList ||
426: (rbuf->failedDiskSectorOffset <
427: reconCtrl->fullBufferList->failedDiskSectorOffset)) {
428: Dprintf2("RECON: rbuf for psid %ld ru %d is head of"
429: " list.\n", (long) rbuf->parityStripeID,
430: rbuf->which_ru);
431: rbuf->next = reconCtrl->fullBufferList;
432: reconCtrl->fullBufferList = rbuf;
433: } else {
434: for (pt = reconCtrl->fullBufferList, p = pt->next;
435: p && p->failedDiskSectorOffset <
436: rbuf->failedDiskSectorOffset;
437: pt = p, p = p->next);
438: rbuf->next = p;
439: pt->next = rbuf;
440: Dprintf2("RECON: rbuf for psid %ld ru %d is in list.\n",
441: (long) rbuf->parityStripeID, rbuf->which_ru);
442: }
443: #if 0
444: pssPtr->writeRbuf = pssPtr->rbuf; /*
445: * DEBUG ONLY: We like
446: * to be able to find
447: * this rbuf while it's
448: * awaiting write.
449: */
450: #else
451: rbuf->pssPtr = pssPtr;
452: #endif
453: pssPtr->rbuf = NULL;
454: rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL,
455: RF_REVENT_BUFREADY);
456: }
457: return (0);
458: }
459:
460:
461: /*
462: * Release a floating recon buffer for someone else to use.
463: * Assumes the rb_mutex is LOCKED at entry.
464: */
465: void
466: rf_ReleaseFloatingReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row,
467: RF_ReconBuffer_t *rbuf)
468: {
469: RF_ReconCtrl_t *rcPtr = raidPtr->reconControl[row];
470: RF_CallbackDesc_t *cb;
471:
472: Dprintf2("RECON: releasing rbuf for psid %ld ru %d.\n",
473: (long) rbuf->parityStripeID, rbuf->which_ru);
474:
475: /*
476: * If anyone is waiting on buffers, wake one of them up. They will
477: * subsequently wake up anyone else waiting on their RU.
478: */
479: if (rcPtr->bufferWaitList) {
480: rbuf->next = rcPtr->committedRbufs;
481: rcPtr->committedRbufs = rbuf;
482: cb = rcPtr->bufferWaitList;
483: rcPtr->bufferWaitList = cb->next;
484: /* arg==1 => We've committed a buffer. */
485: rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1,
486: RF_REVENT_BUFCLEAR);
487: rf_FreeCallbackDesc(cb);
488: raidPtr->procsInBufWait--;
489: } else {
490: rbuf->next = rcPtr->floatingRbufs;
491: rcPtr->floatingRbufs = rbuf;
492: }
493: }
494:
495:
496: /*
497: * Release any disk that is waiting on a buffer for the indicated RU.
498: * Assumes the rb_mutex is LOCKED at entry.
499: */
500: void
501: rf_ReleaseBufferWaiters(
502: RF_Raid_t *raidPtr,
503: RF_ReconParityStripeStatus_t *pssPtr
504: )
505: {
506: RF_CallbackDesc_t *cb1, *cb = pssPtr->bufWaitList;
507:
508: Dprintf2("RECON: releasing buf waiters for psid %ld ru %d.\n",
509: (long) pssPtr->parityStripeID, pssPtr->which_ru);
510: pssPtr->flags &= ~RF_PSS_BUFFERWAIT;
511: while (cb) {
512: cb1 = cb->next;
513: cb->next = NULL;
514: /* arg==0 => We haven't committed a buffer. */
515: rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0,
516: RF_REVENT_BUFCLEAR);
517: rf_FreeCallbackDesc(cb);
518: cb = cb1;
519: }
520: pssPtr->bufWaitList = NULL;
521: }
522:
523:
524: /*
525: * When reconstruction is forced on an RU, there may be some disks waiting to
526: * acquire a buffer for that RU. Since we allocate a new buffer as part of
527: * the forced-reconstruction process, we no longer have to wait for any
528: * buffers, so we wakeup any waiter that we find in the bufferWaitList.
529: *
530: * Assumes the rb_mutex is LOCKED at entry.
531: */
532: void
533: rf_ReleaseBufferWaiter(RF_ReconCtrl_t *rcPtr, RF_ReconBuffer_t *rbuf)
534: {
535: RF_CallbackDesc_t *cb, *cbt;
536:
537: for (cbt = NULL, cb = rcPtr->bufferWaitList; cb;
538: cbt = cb, cb = cb->next) {
539: if ((cb->callbackArg.v == rbuf->parityStripeID) &&
540: (cb->callbackArg2.v == rbuf->which_ru)) {
541: Dprintf2("RECON: Dropping row %d col %d from buffer"
542: " wait list.\n", cb->row, cb->col);
543: if (cbt)
544: cbt->next = cb->next;
545: else
546: rcPtr->bufferWaitList = cb->next;
547:
548: /* arg==0 => No committed buffer. */
549: rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr,
550: cb->row, cb->col, (void *) 0, RF_REVENT_BUFREADY);
551: rf_FreeCallbackDesc(cb);
552: return;
553: }
554: }
555: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_reconbuffer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe