![[BACK]](/icons/back.gif){kind=icon}
Return to rf_states.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_states.c CVS log | Up to [local] / sys / dev / raidframe |
1.1 nbrk 1: /* $OpenBSD: rf_states.c,v 1.9 2002/12/16 07:01:05 tdeval Exp $ */
2: /* $NetBSD: rf_states.c,v 1.15 2000/10/20 02:24:45 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Mark Holland, William V. Courtright II, Robby Findler
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 <sys/errno.h>
32:
33: #include "rf_archs.h"
34: #include "rf_threadstuff.h"
35: #include "rf_raid.h"
36: #include "rf_dag.h"
37: #include "rf_desc.h"
38: #include "rf_aselect.h"
39: #include "rf_general.h"
40: #include "rf_states.h"
41: #include "rf_dagutils.h"
42: #include "rf_driver.h"
43: #include "rf_engine.h"
44: #include "rf_map.h"
45: #include "rf_etimer.h"
46: #include "rf_kintf.h"
47:
48: /*
49: * Prototypes for some of the available states.
50: *
51: * States must:
52: *
53: * - not block.
54: *
55: * - either schedule rf_ContinueRaidAccess as a callback and return
56: * RF_TRUE, or complete all of their work and return RF_FALSE.
57: *
58: * - increment desc->state when they have finished their work.
59: */
60:
61: char *StateName(RF_AccessState_t);
62:
63: char *
64: StateName(RF_AccessState_t state)
65: {
66: switch (state) {
67: case rf_QuiesceState:return "QuiesceState";
68: case rf_MapState:
69: return "MapState";
70: case rf_LockState:
71: return "LockState";
72: case rf_CreateDAGState:
73: return "CreateDAGState";
74: case rf_ExecuteDAGState:
75: return "ExecuteDAGState";
76: case rf_ProcessDAGState:
77: return "ProcessDAGState";
78: case rf_CleanupState:
79: return "CleanupState";
80: case rf_LastState:
81: return "LastState";
82: case rf_IncrAccessesCountState:
83: return "IncrAccessesCountState";
84: case rf_DecrAccessesCountState:
85: return "DecrAccessesCountState";
86: default:
87: return "!!! UnnamedState !!!";
88: }
89: }
90:
91: void
92: rf_ContinueRaidAccess(RF_RaidAccessDesc_t *desc)
93: {
94: int suspended = RF_FALSE;
95: int current_state_index = desc->state;
96: RF_AccessState_t current_state = desc->states[current_state_index];
97: int unit = desc->raidPtr->raidid;
98:
99: do {
100: current_state_index = desc->state;
101: current_state = desc->states[current_state_index];
102:
103: switch (current_state) {
104:
105: case rf_QuiesceState:
106: suspended = rf_State_Quiesce(desc);
107: break;
108: case rf_IncrAccessesCountState:
109: suspended = rf_State_IncrAccessCount(desc);
110: break;
111: case rf_MapState:
112: suspended = rf_State_Map(desc);
113: break;
114: case rf_LockState:
115: suspended = rf_State_Lock(desc);
116: break;
117: case rf_CreateDAGState:
118: suspended = rf_State_CreateDAG(desc);
119: break;
120: case rf_ExecuteDAGState:
121: suspended = rf_State_ExecuteDAG(desc);
122: break;
123: case rf_ProcessDAGState:
124: suspended = rf_State_ProcessDAG(desc);
125: break;
126: case rf_CleanupState:
127: suspended = rf_State_Cleanup(desc);
128: break;
129: case rf_DecrAccessesCountState:
130: suspended = rf_State_DecrAccessCount(desc);
131: break;
132: case rf_LastState:
133: suspended = rf_State_LastState(desc);
134: break;
135: }
136:
137: /*
138: * After this point, we cannot dereference desc since desc may
139: * have been freed. desc is only freed in LastState, so if we
140: * reenter this function or loop back up, desc should be valid.
141: */
142:
143: if (rf_printStatesDebug) {
144: printf("raid%d: State: %-24s StateIndex: %3i desc:"
145: " 0x%ld %s.\n", unit, StateName(current_state),
146: current_state_index, (long) desc, suspended ?
147: "callback scheduled" : "looping");
148: }
149: } while (!suspended && current_state != rf_LastState);
150:
151: return;
152: }
153:
154:
155: void
156: rf_ContinueDagAccess(RF_DagList_t *dagList)
157: {
158: RF_AccTraceEntry_t *tracerec = &(dagList->desc->tracerec);
159: RF_RaidAccessDesc_t *desc;
160: RF_DagHeader_t *dag_h;
161: RF_Etimer_t timer;
162: int i;
163:
164: desc = dagList->desc;
165:
166: timer = tracerec->timer;
167: RF_ETIMER_STOP(timer);
168: RF_ETIMER_EVAL(timer);
169: tracerec->specific.user.exec_us = RF_ETIMER_VAL_US(timer);
170: RF_ETIMER_START(tracerec->timer);
171:
172: /* Skip to dag which just finished. */
173: dag_h = dagList->dags;
174: for (i = 0; i < dagList->numDagsDone; i++) {
175: dag_h = dag_h->next;
176: }
177:
178: /* Check to see if retry is required. */
179: if (dag_h->status == rf_rollBackward) {
180: /*
181: * When a dag fails, mark desc status as bad and allow all
182: * other dags in the desc to execute to completion. Then,
183: * free all dags and start over.
184: */
185: desc->status = 1; /* Bad status. */
186: {
187: printf("raid%d: DAG failure: %c addr 0x%lx (%ld)"
188: " nblk 0x%x (%d) buf 0x%lx.\n",
189: desc->raidPtr->raidid, desc->type,
190: (long) desc->raidAddress,
191: (long) desc->raidAddress,
192: (int) desc->numBlocks, (int) desc->numBlocks,
193: (unsigned long) (desc->bufPtr));
194: }
195: }
196: dagList->numDagsDone++;
197: rf_ContinueRaidAccess(desc);
198: }
199:
200: int
201: rf_State_LastState(RF_RaidAccessDesc_t *desc)
202: {
203: void (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc;
204: RF_CBParam_t callbackArg;
205:
206: callbackArg.p = desc->callbackArg;
207:
208: /*
209: * If this is not an async request, wake up the caller.
210: */
211: if (desc->async_flag == 0)
212: wakeup(desc->bp);
213:
214: /*
215: * That's all the IO for this one... Unbusy the 'disk'.
216: */
217:
218: rf_disk_unbusy(desc);
219:
220: /*
221: * Wakeup any requests waiting to go.
222: */
223:
224: RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
225: ((RF_Raid_t *) desc->raidPtr)->openings++;
226: RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
227:
228: /* Wake up any pending I/O. */
229: raidstart(((RF_Raid_t *) desc->raidPtr));
230:
231: /* printf("%s: Calling biodone on 0x%x.\n", __func__, desc->bp); */
232: splassert(IPL_BIO);
233: biodone(desc->bp); /* Access came through ioctl. */
234:
235: if (callbackFunc)
236: callbackFunc(callbackArg);
237: rf_FreeRaidAccDesc(desc);
238:
239: return RF_FALSE;
240: }
241:
242: int
243: rf_State_IncrAccessCount(RF_RaidAccessDesc_t *desc)
244: {
245: RF_Raid_t *raidPtr;
246:
247: raidPtr = desc->raidPtr;
248: /*
249: * Bummer. We have to do this to be 100% safe w.r.t. the increment
250: * below.
251: */
252: RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
253: raidPtr->accs_in_flight++; /* Used to detect quiescence. */
254: RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
255:
256: desc->state++;
257: return RF_FALSE;
258: }
259:
260: int
261: rf_State_DecrAccessCount(RF_RaidAccessDesc_t *desc)
262: {
263: RF_Raid_t *raidPtr;
264:
265: raidPtr = desc->raidPtr;
266:
267: RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
268: raidPtr->accs_in_flight--;
269: if (raidPtr->accesses_suspended && raidPtr->accs_in_flight == 0) {
270: rf_SignalQuiescenceLock(raidPtr, raidPtr->reconDesc);
271: }
272: rf_UpdateUserStats(raidPtr, RF_ETIMER_VAL_US(desc->timer),
273: desc->numBlocks);
274: RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
275:
276: desc->state++;
277: return RF_FALSE;
278: }
279:
280: int
281: rf_State_Quiesce(RF_RaidAccessDesc_t *desc)
282: {
283: RF_AccTraceEntry_t *tracerec = &desc->tracerec;
284: RF_Etimer_t timer;
285: int suspended = RF_FALSE;
286: RF_Raid_t *raidPtr;
287:
288: raidPtr = desc->raidPtr;
289:
290: RF_ETIMER_START(timer);
291: RF_ETIMER_START(desc->timer);
292:
293: RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
294: if (raidPtr->accesses_suspended) {
295: RF_CallbackDesc_t *cb;
296: cb = rf_AllocCallbackDesc();
297: /*
298: * XXX The following cast is quite bogus...
299: * rf_ContinueRaidAccess takes a (RF_RaidAccessDesc_t *)
300: * as an argument... GO
301: */
302: cb->callbackFunc = (void (*) (RF_CBParam_t))
303: rf_ContinueRaidAccess;
304: cb->callbackArg.p = (void *) desc;
305: cb->next = raidPtr->quiesce_wait_list;
306: raidPtr->quiesce_wait_list = cb;
307: suspended = RF_TRUE;
308: }
309: RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
310:
311: RF_ETIMER_STOP(timer);
312: RF_ETIMER_EVAL(timer);
313: tracerec->specific.user.suspend_ovhd_us += RF_ETIMER_VAL_US(timer);
314:
315: if (suspended && rf_quiesceDebug)
316: printf("Stalling access due to quiescence lock.\n");
317:
318: desc->state++;
319: return suspended;
320: }
321:
322: int
323: rf_State_Map(RF_RaidAccessDesc_t *desc)
324: {
325: RF_Raid_t *raidPtr = desc->raidPtr;
326: RF_AccTraceEntry_t *tracerec = &desc->tracerec;
327: RF_Etimer_t timer;
328:
329: RF_ETIMER_START(timer);
330:
331: if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress,
332: desc->numBlocks, desc->bufPtr, RF_DONT_REMAP)))
333: RF_PANIC();
334:
335: RF_ETIMER_STOP(timer);
336: RF_ETIMER_EVAL(timer);
337: tracerec->specific.user.map_us = RF_ETIMER_VAL_US(timer);
338:
339: desc->state++;
340: return RF_FALSE;
341: }
342:
343: int
344: rf_State_Lock(RF_RaidAccessDesc_t *desc)
345: {
346: RF_AccTraceEntry_t *tracerec = &desc->tracerec;
347: RF_Raid_t *raidPtr = desc->raidPtr;
348: RF_AccessStripeMapHeader_t *asmh = desc->asmap;
349: RF_AccessStripeMap_t *asm_p;
350: RF_Etimer_t timer;
351: int suspended = RF_FALSE;
352:
353: RF_ETIMER_START(timer);
354: if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
355: RF_StripeNum_t lastStripeID = -1;
356:
357: /* Acquire each lock that we don't already hold. */
358: for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) {
359: RF_ASSERT(RF_IO_IS_R_OR_W(desc->type));
360: if (!rf_suppressLocksAndLargeWrites &&
361: asm_p->parityInfo &&
362: !(desc->flags & RF_DAG_SUPPRESS_LOCKS) &&
363: !(asm_p->flags & RF_ASM_FLAGS_LOCK_TRIED)) {
364: asm_p->flags |= RF_ASM_FLAGS_LOCK_TRIED;
365: /* Locks must be acquired hierarchically. */
366: RF_ASSERT(asm_p->stripeID > lastStripeID);
367: lastStripeID = asm_p->stripeID;
368: /*
369: * XXX The cast to (void (*)(RF_CBParam_t))
370: * below is bogus ! GO
371: */
372: RF_INIT_LOCK_REQ_DESC(asm_p->lockReqDesc,
373: desc->type, (void (*) (struct buf *))
374: rf_ContinueRaidAccess, desc, asm_p,
375: raidPtr->Layout.dataSectorsPerStripe);
376: if (rf_AcquireStripeLock(raidPtr->lockTable,
377: asm_p->stripeID, &asm_p->lockReqDesc)) {
378: suspended = RF_TRUE;
379: break;
380: }
381: }
382: if (desc->type == RF_IO_TYPE_WRITE &&
383: raidPtr->status[asm_p->physInfo->row] ==
384: rf_rs_reconstructing) {
385: if (!(asm_p->flags & RF_ASM_FLAGS_FORCE_TRIED))
386: {
387: int val;
388:
389: asm_p->flags |=
390: RF_ASM_FLAGS_FORCE_TRIED;
391: /*
392: * XXX The cast below is quite
393: * bogus !!! XXX GO
394: */
395: val = rf_ForceOrBlockRecon(raidPtr,
396: asm_p,
397: (void (*) (RF_Raid_t *, void *))
398: rf_ContinueRaidAccess, desc);
399: if (val == 0) {
400: asm_p->flags |=
401: RF_ASM_FLAGS_RECON_BLOCKED;
402: } else {
403: suspended = RF_TRUE;
404: break;
405: }
406: } else {
407: if (rf_pssDebug) {
408: printf("raid%d: skipping"
409: " force/block because"
410: " already done, psid"
411: " %ld.\n",
412: desc->raidPtr->raidid,
413: (long) asm_p->stripeID);
414: }
415: }
416: } else {
417: if (rf_pssDebug) {
418: printf("raid%d: skipping force/block"
419: " because not write or not"
420: " under recon, psid %ld.\n",
421: desc->raidPtr->raidid,
422: (long) asm_p->stripeID);
423: }
424: }
425: }
426:
427: RF_ETIMER_STOP(timer);
428: RF_ETIMER_EVAL(timer);
429: tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer);
430:
431: if (suspended)
432: return (RF_TRUE);
433: }
434: desc->state++;
435: return (RF_FALSE);
436: }
437:
438: /*
439: * The following three states create, execute, and post-process DAGs.
440: * The error recovery unit is a single DAG.
441: * By default, SelectAlgorithm creates an array of DAGs, one per parity stripe.
442: * In some tricky cases, multiple dags per stripe are created.
443: * - DAGs within a parity stripe are executed sequentially (arbitrary order).
444: * - DAGs for distinct parity stripes are executed concurrently.
445: *
446: * Repeat until all DAGs complete successfully -or- DAG selection fails.
447: *
448: * while !done
449: * create dag(s) (SelectAlgorithm)
450: * if dag
451: * execute dag (DispatchDAG)
452: * if dag successful
453: * done (SUCCESS)
454: * else
455: * !done (RETRY - start over with new dags)
456: * else
457: * done (FAIL)
458: */
459: int
460: rf_State_CreateDAG(RF_RaidAccessDesc_t *desc)
461: {
462: RF_AccTraceEntry_t *tracerec = &desc->tracerec;
463: RF_Etimer_t timer;
464: RF_DagHeader_t *dag_h;
465: int i, selectStatus;
466:
467: /*
468: * Generate a dag for the access, and fire it off. When the dag
469: * completes, we'll get re-invoked in the next state.
470: */
471: RF_ETIMER_START(timer);
472: /* SelectAlgorithm returns one or more dags. */
473: selectStatus = rf_SelectAlgorithm(desc,
474: desc->flags | RF_DAG_SUPPRESS_LOCKS);
475: if (rf_printDAGsDebug)
476: for (i = 0; i < desc->numStripes; i++)
477: rf_PrintDAGList(desc->dagArray[i].dags);
478: RF_ETIMER_STOP(timer);
479: RF_ETIMER_EVAL(timer);
480: /* Update time to create all dags. */
481: tracerec->specific.user.dag_create_us = RF_ETIMER_VAL_US(timer);
482:
483: desc->status = 0; /* Good status. */
484:
485: if (selectStatus) {
486: /* Failed to create a dag. */
487: /*
488: * This happens when there are too many faults or incomplete
489: * dag libraries.
490: */
491: printf("[Failed to create a DAG]\n");
492: RF_PANIC();
493: } else {
494: /* Bind dags to desc. */
495: for (i = 0; i < desc->numStripes; i++) {
496: dag_h = desc->dagArray[i].dags;
497: while (dag_h) {
498: dag_h->bp = (struct buf *) desc->bp;
499: dag_h->tracerec = tracerec;
500: dag_h = dag_h->next;
501: }
502: }
503: desc->flags |= RF_DAG_DISPATCH_RETURNED;
504: desc->state++; /* Next state should be rf_State_ExecuteDAG. */
505: }
506: return RF_FALSE;
507: }
508:
509:
510: /*
511: * The access has an array of dagLists, one dagList per parity stripe.
512: * Fire the first DAG in each parity stripe (dagList).
513: * DAGs within a stripe (dagList) must be executed sequentially.
514: * - This preserves atomic parity update.
515: * DAGs for independents parity groups (stripes) are fired concurrently.
516: */
517: int
518: rf_State_ExecuteDAG(RF_RaidAccessDesc_t *desc)
519: {
520: int i;
521: RF_DagHeader_t *dag_h;
522: RF_DagList_t *dagArray = desc->dagArray;
523:
524: /*
525: * Next state is always rf_State_ProcessDAG. Important to do this
526: * before firing the first dag (it may finish before we leave this
527: * routine).
528: */
529: desc->state++;
530:
531: /*
532: * Sweep dag array, a stripe at a time, firing the first dag in each
533: * stripe.
534: */
535: for (i = 0; i < desc->numStripes; i++) {
536: RF_ASSERT(dagArray[i].numDags > 0);
537: RF_ASSERT(dagArray[i].numDagsDone == 0);
538: RF_ASSERT(dagArray[i].numDagsFired == 0);
539: RF_ETIMER_START(dagArray[i].tracerec.timer);
540: /* Fire first dag in this stripe. */
541: dag_h = dagArray[i].dags;
542: RF_ASSERT(dag_h);
543: dagArray[i].numDagsFired++;
544: /*
545: * XXX Yet another case where we pass in a conflicting
546: * function pointer :-( XXX GO
547: */
548: rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess,
549: &dagArray[i]);
550: }
551:
552: /*
553: * The DAG will always call the callback, even if there was no
554: * blocking, so we are always suspended in this state.
555: */
556: return RF_TRUE;
557: }
558:
559:
560: /*
561: * rf_State_ProcessDAG is entered when a dag completes.
562: * First, check that all DAGs in the access have completed.
563: * If not, fire as many DAGs as possible.
564: */
565: int
566: rf_State_ProcessDAG(RF_RaidAccessDesc_t *desc)
567: {
568: RF_AccessStripeMapHeader_t *asmh = desc->asmap;
569: RF_Raid_t *raidPtr = desc->raidPtr;
570: RF_DagHeader_t *dag_h;
571: int i, j, done = RF_TRUE;
572: RF_DagList_t *dagArray = desc->dagArray;
573: RF_Etimer_t timer;
574:
575: /* Check to see if this is the last dag. */
576: for (i = 0; i < desc->numStripes; i++)
577: if (dagArray[i].numDags != dagArray[i].numDagsDone)
578: done = RF_FALSE;
579:
580: if (done) {
581: if (desc->status) {
582: /* A dag failed, retry. */
583: RF_ETIMER_START(timer);
584: /* Free all dags. */
585: for (i = 0; i < desc->numStripes; i++) {
586: rf_FreeDAG(desc->dagArray[i].dags);
587: }
588: rf_MarkFailuresInASMList(raidPtr, asmh);
589: /* Back up to rf_State_CreateDAG. */
590: desc->state = desc->state - 2;
591: return RF_FALSE;
592: } else {
593: /* Move on to rf_State_Cleanup. */
594: desc->state++;
595: }
596: return RF_FALSE;
597: } else {
598: /* More dags to execute. */
599: /* See if any are ready to be fired. If so, fire them. */
600: /*
601: * Don't fire the initial dag in a list, it's fired in
602: * rf_State_ExecuteDAG.
603: */
604: for (i = 0; i < desc->numStripes; i++) {
605: if ((dagArray[i].numDagsDone < dagArray[i].numDags) &&
606: (dagArray[i].numDagsDone ==
607: dagArray[i].numDagsFired) &&
608: (dagArray[i].numDagsFired > 0)) {
609: RF_ETIMER_START(dagArray[i].tracerec.timer);
610: /* Fire next dag in this stripe. */
611: /*
612: * First, skip to next dag awaiting execution.
613: */
614: dag_h = dagArray[i].dags;
615: for (j = 0; j < dagArray[i].numDagsDone; j++)
616: dag_h = dag_h->next;
617: dagArray[i].numDagsFired++;
618: /*
619: * XXX And again we pass a different function
620: * pointer... GO
621: */
622: rf_DispatchDAG(dag_h, (void (*) (void *))
623: rf_ContinueDagAccess, &dagArray[i]);
624: }
625: }
626: return RF_TRUE;
627: }
628: }
629:
630: /* Only make it this far if all dags complete successfully. */
631: int
632: rf_State_Cleanup(RF_RaidAccessDesc_t *desc)
633: {
634: RF_AccTraceEntry_t *tracerec = &desc->tracerec;
635: RF_AccessStripeMapHeader_t *asmh = desc->asmap;
636: RF_Raid_t *raidPtr = desc->raidPtr;
637: RF_AccessStripeMap_t *asm_p;
638: RF_DagHeader_t *dag_h;
639: RF_Etimer_t timer;
640: int i;
641:
642: desc->state++;
643:
644: timer = tracerec->timer;
645: RF_ETIMER_STOP(timer);
646: RF_ETIMER_EVAL(timer);
647: tracerec->specific.user.dag_retry_us = RF_ETIMER_VAL_US(timer);
648:
649: /* The RAID I/O is complete. Clean up. */
650: tracerec->specific.user.dag_retry_us = 0;
651:
652: RF_ETIMER_START(timer);
653: if (desc->flags & RF_DAG_RETURN_DAG) {
654: /* Copy dags into paramDAG. */
655: *(desc->paramDAG) = desc->dagArray[0].dags;
656: dag_h = *(desc->paramDAG);
657: for (i = 1; i < desc->numStripes; i++) {
658: /* Concatenate dags from remaining stripes. */
659: RF_ASSERT(dag_h);
660: while (dag_h->next)
661: dag_h = dag_h->next;
662: dag_h->next = desc->dagArray[i].dags;
663: }
664: } else {
665: /* Free all dags. */
666: for (i = 0; i < desc->numStripes; i++) {
667: rf_FreeDAG(desc->dagArray[i].dags);
668: }
669: }
670:
671: RF_ETIMER_STOP(timer);
672: RF_ETIMER_EVAL(timer);
673: tracerec->specific.user.cleanup_us = RF_ETIMER_VAL_US(timer);
674:
675: RF_ETIMER_START(timer);
676: if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
677: for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) {
678: if (!rf_suppressLocksAndLargeWrites &&
679: asm_p->parityInfo &&
680: !(desc->flags & RF_DAG_SUPPRESS_LOCKS)) {
681: RF_ASSERT_VALID_LOCKREQ(&asm_p->lockReqDesc);
682: rf_ReleaseStripeLock(raidPtr->lockTable,
683: asm_p->stripeID, &asm_p->lockReqDesc);
684: }
685: if (asm_p->flags & RF_ASM_FLAGS_RECON_BLOCKED) {
686: rf_UnblockRecon(raidPtr, asm_p);
687: }
688: }
689: }
690: RF_ETIMER_STOP(timer);
691: RF_ETIMER_EVAL(timer);
692: tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer);
693:
694: RF_ETIMER_START(timer);
695: if (desc->flags & RF_DAG_RETURN_ASM)
696: *(desc->paramASM) = asmh;
697: else
698: rf_FreeAccessStripeMap(asmh);
699: RF_ETIMER_STOP(timer);
700: RF_ETIMER_EVAL(timer);
701: tracerec->specific.user.cleanup_us += RF_ETIMER_VAL_US(timer);
702:
703: RF_ETIMER_STOP(desc->timer);
704: RF_ETIMER_EVAL(desc->timer);
705:
706: timer = desc->tracerec.tot_timer;
707: RF_ETIMER_STOP(timer);
708: RF_ETIMER_EVAL(timer);
709: desc->tracerec.total_us = RF_ETIMER_VAL_US(timer);
710:
711: rf_LogTraceRec(raidPtr, tracerec);
712:
713: desc->flags |= RF_DAG_ACCESS_COMPLETE;
714:
715: return RF_FALSE;
716: }