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