/* $OpenBSD: rf_states.c,v 1.4 1999/08/04 13:10:55 peter Exp $ */ /* $NetBSD: rf_states.c,v 1.7 1999/07/08 00:45:24 oster Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. * * Author: Mark Holland, William V. Courtright II, Robby Findler * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ #include #include "rf_archs.h" #include "rf_threadstuff.h" #include "rf_raid.h" #include "rf_dag.h" #include "rf_desc.h" #include "rf_aselect.h" #include "rf_threadid.h" #include "rf_general.h" #include "rf_states.h" #include "rf_dagutils.h" #include "rf_driver.h" #include "rf_engine.h" #include "rf_map.h" #include "rf_etimer.h" #if defined(_KERNEL) && (DKUSAGE > 0) #include #include #include #include #include #endif /* _KERNEL && DKUSAGE > 0 */ /* prototypes for some of the available states. States must: - not block. - either schedule rf_ContinueRaidAccess as a callback and return RF_TRUE, or complete all of their work and return RF_FALSE. - increment desc->state when they have finished their work. */ static char * StateName(RF_AccessState_t state) { switch (state) { case rf_QuiesceState:return "QuiesceState"; case rf_MapState: return "MapState"; case rf_LockState: return "LockState"; case rf_CreateDAGState: return "CreateDAGState"; case rf_ExecuteDAGState: return "ExecuteDAGState"; case rf_ProcessDAGState: return "ProcessDAGState"; case rf_CleanupState: return "CleanupState"; case rf_LastState: return "LastState"; case rf_IncrAccessesCountState: return "IncrAccessesCountState"; case rf_DecrAccessesCountState: return "DecrAccessesCountState"; default: return "!!! UnnamedState !!!"; } } void rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc) { int suspended = RF_FALSE; int current_state_index = desc->state; RF_AccessState_t current_state = desc->states[current_state_index]; do { current_state_index = desc->state; current_state = desc->states[current_state_index]; switch (current_state) { case rf_QuiesceState: suspended = rf_State_Quiesce(desc); break; case rf_IncrAccessesCountState: suspended = rf_State_IncrAccessCount(desc); break; case rf_MapState: suspended = rf_State_Map(desc); break; case rf_LockState: suspended = rf_State_Lock(desc); break; case rf_CreateDAGState: suspended = rf_State_CreateDAG(desc); break; case rf_ExecuteDAGState: suspended = rf_State_ExecuteDAG(desc); break; case rf_ProcessDAGState: suspended = rf_State_ProcessDAG(desc); break; case rf_CleanupState: suspended = rf_State_Cleanup(desc); break; case rf_DecrAccessesCountState: suspended = rf_State_DecrAccessCount(desc); break; case rf_LastState: suspended = rf_State_LastState(desc); break; } /* after this point, we cannot dereference desc since desc may * have been freed. desc is only freed in LastState, so if we * renter this function or loop back up, desc should be valid. */ if (rf_printStatesDebug) { int tid; rf_get_threadid(tid); printf("[%d] State: %-24s StateIndex: %3i desc: 0x%ld %s\n", tid, StateName(current_state), current_state_index, (long) desc, suspended ? "callback scheduled" : "looping"); } } while (!suspended && current_state != rf_LastState); return; } void rf_ContinueDagAccess(RF_DagList_t * dagList) { RF_AccTraceEntry_t *tracerec = &(dagList->desc->tracerec); RF_RaidAccessDesc_t *desc; RF_DagHeader_t *dag_h; RF_Etimer_t timer; int i; desc = dagList->desc; timer = tracerec->timer; RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.exec_us = RF_ETIMER_VAL_US(timer); RF_ETIMER_START(tracerec->timer); /* skip to dag which just finished */ dag_h = dagList->dags; for (i = 0; i < dagList->numDagsDone; i++) { dag_h = dag_h->next; } /* check to see if retry is required */ if (dag_h->status == rf_rollBackward) { /* when a dag fails, mark desc status as bad and allow all * other dags in the desc to execute to completion. then, * free all dags and start over */ desc->status = 1; /* bad status */ { printf("[%d] DAG failure: %c addr 0x%lx (%ld) nblk 0x%x (%d) buf 0x%lx\n", desc->tid, desc->type, (long) desc->raidAddress, (long) desc->raidAddress, (int) desc->numBlocks, (int) desc->numBlocks, (unsigned long) (desc->bufPtr)); } } dagList->numDagsDone++; rf_ContinueRaidAccess(desc); } int rf_State_LastState(RF_RaidAccessDesc_t * desc) { void (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc; RF_CBParam_t callbackArg; callbackArg.p = desc->callbackArg; if (!(desc->flags & RF_DAG_TEST_ACCESS)) { /* don't biodone if this */ #if DKUSAGE > 0 RF_DKU_END_IO(((RF_Raid_t *) desc->raidPtr)->raidid, (struct buf *) desc->bp); #else RF_DKU_END_IO(((RF_Raid_t *) desc->raidPtr)->raidid); #endif /* DKUSAGE > 0 */ /* * If this is not an async request, wake up the caller */ if (desc->async_flag == 0) wakeup(desc->bp); /* * Wakeup any requests waiting to go. */ RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex); ((RF_Raid_t *) desc->raidPtr)->openings++; wakeup(&(((RF_Raid_t *) desc->raidPtr)->openings)); RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex); /* printf("Calling biodone on 0x%x\n",desc->bp); */ biodone(desc->bp); /* access came through ioctl */ } if (callbackFunc) callbackFunc(callbackArg); rf_FreeRaidAccDesc(desc); return RF_FALSE; } int rf_State_IncrAccessCount(RF_RaidAccessDesc_t * desc) { RF_Raid_t *raidPtr; raidPtr = desc->raidPtr; /* Bummer. We have to do this to be 100% safe w.r.t. the increment * below */ RF_LOCK_MUTEX(raidPtr->access_suspend_mutex); raidPtr->accs_in_flight++; /* used to detect quiescence */ RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex); desc->state++; return RF_FALSE; } int rf_State_DecrAccessCount(RF_RaidAccessDesc_t * desc) { RF_Raid_t *raidPtr; raidPtr = desc->raidPtr; RF_LOCK_MUTEX(raidPtr->access_suspend_mutex); raidPtr->accs_in_flight--; if (raidPtr->accesses_suspended && raidPtr->accs_in_flight == 0) { rf_SignalQuiescenceLock(raidPtr, raidPtr->reconDesc); } rf_UpdateUserStats(raidPtr, RF_ETIMER_VAL_US(desc->timer), desc->numBlocks); RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex); desc->state++; return RF_FALSE; } int rf_State_Quiesce(RF_RaidAccessDesc_t * desc) { RF_AccTraceEntry_t *tracerec = &desc->tracerec; RF_Etimer_t timer; int suspended = RF_FALSE; RF_Raid_t *raidPtr; raidPtr = desc->raidPtr; RF_ETIMER_START(timer); RF_ETIMER_START(desc->timer); RF_LOCK_MUTEX(raidPtr->access_suspend_mutex); if (raidPtr->accesses_suspended) { RF_CallbackDesc_t *cb; cb = rf_AllocCallbackDesc(); /* XXX the following cast is quite bogus... * rf_ContinueRaidAccess takes a (RF_RaidAccessDesc_t *) as an * argument.. GO */ cb->callbackFunc = (void (*) (RF_CBParam_t)) rf_ContinueRaidAccess; cb->callbackArg.p = (void *) desc; cb->next = raidPtr->quiesce_wait_list; raidPtr->quiesce_wait_list = cb; suspended = RF_TRUE; } RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex); RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.suspend_ovhd_us += RF_ETIMER_VAL_US(timer); if (suspended && rf_quiesceDebug) printf("Stalling access due to quiescence lock\n"); desc->state++; return suspended; } int rf_State_Map(RF_RaidAccessDesc_t * desc) { RF_Raid_t *raidPtr = desc->raidPtr; RF_AccTraceEntry_t *tracerec = &desc->tracerec; RF_Etimer_t timer; RF_ETIMER_START(timer); if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress, desc->numBlocks, desc->bufPtr, RF_DONT_REMAP))) RF_PANIC(); RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.map_us = RF_ETIMER_VAL_US(timer); desc->state++; return RF_FALSE; } int rf_State_Lock(RF_RaidAccessDesc_t * desc) { RF_AccTraceEntry_t *tracerec = &desc->tracerec; RF_Raid_t *raidPtr = desc->raidPtr; RF_AccessStripeMapHeader_t *asmh = desc->asmap; RF_AccessStripeMap_t *asm_p; RF_Etimer_t timer; int suspended = RF_FALSE; RF_ETIMER_START(timer); if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) { RF_StripeNum_t lastStripeID = -1; /* acquire each lock that we don't already hold */ for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) { RF_ASSERT(RF_IO_IS_R_OR_W(desc->type)); if (!rf_suppressLocksAndLargeWrites && asm_p->parityInfo && !(desc->flags & RF_DAG_SUPPRESS_LOCKS) && !(asm_p->flags & RF_ASM_FLAGS_LOCK_TRIED)) { asm_p->flags |= RF_ASM_FLAGS_LOCK_TRIED; RF_ASSERT(asm_p->stripeID > lastStripeID); /* locks must be * acquired * hierarchically */ lastStripeID = asm_p->stripeID; /* XXX the cast to (void (*)(RF_CBParam_t)) * below is bogus! GO */ RF_INIT_LOCK_REQ_DESC(asm_p->lockReqDesc, desc->type, (void (*) (struct buf *)) rf_ContinueRaidAccess, desc, asm_p, raidPtr->Layout.dataSectorsPerStripe); if (rf_AcquireStripeLock(raidPtr->lockTable, asm_p->stripeID, &asm_p->lockReqDesc)) { suspended = RF_TRUE; break; } } if (desc->type == RF_IO_TYPE_WRITE && raidPtr->status[asm_p->physInfo->row] == rf_rs_reconstructing) { if (!(asm_p->flags & RF_ASM_FLAGS_FORCE_TRIED)) { int val; asm_p->flags |= RF_ASM_FLAGS_FORCE_TRIED; /* XXX the cast below is quite * bogus!!! XXX GO */ val = rf_ForceOrBlockRecon(raidPtr, asm_p, (void (*) (RF_Raid_t *, void *)) rf_ContinueRaidAccess, desc); if (val == 0) { asm_p->flags |= RF_ASM_FLAGS_RECON_BLOCKED; } else { suspended = RF_TRUE; break; } } else { if (rf_pssDebug) { printf("[%d] skipping force/block because already done, psid %ld\n", desc->tid, (long) asm_p->stripeID); } } } else { if (rf_pssDebug) { printf("[%d] skipping force/block because not write or not under recon, psid %ld\n", desc->tid, (long) asm_p->stripeID); } } } RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer); if (suspended) return (RF_TRUE); } desc->state++; return (RF_FALSE); } /* * the following three states create, execute, and post-process dags * the error recovery unit is a single dag. * by default, SelectAlgorithm creates an array of dags, one per parity stripe * in some tricky cases, multiple dags per stripe are created * - dags within a parity stripe are executed sequentially (arbitrary order) * - dags for distinct parity stripes are executed concurrently * * repeat until all dags complete successfully -or- dag selection fails * * while !done * create dag(s) (SelectAlgorithm) * if dag * execute dag (DispatchDAG) * if dag successful * done (SUCCESS) * else * !done (RETRY - start over with new dags) * else * done (FAIL) */ int rf_State_CreateDAG(RF_RaidAccessDesc_t * desc) { RF_AccTraceEntry_t *tracerec = &desc->tracerec; RF_Etimer_t timer; RF_DagHeader_t *dag_h; int i, selectStatus; /* generate a dag for the access, and fire it off. When the dag * completes, we'll get re-invoked in the next state. */ RF_ETIMER_START(timer); /* SelectAlgorithm returns one or more dags */ selectStatus = rf_SelectAlgorithm(desc, desc->flags | RF_DAG_SUPPRESS_LOCKS); if (rf_printDAGsDebug) for (i = 0; i < desc->numStripes; i++) rf_PrintDAGList(desc->dagArray[i].dags); RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); /* update time to create all dags */ tracerec->specific.user.dag_create_us = RF_ETIMER_VAL_US(timer); desc->status = 0; /* good status */ if (selectStatus) { /* failed to create a dag */ /* this happens when there are too many faults or incomplete * dag libraries */ printf("[Failed to create a DAG\n]"); RF_PANIC(); } else { /* bind dags to desc */ for (i = 0; i < desc->numStripes; i++) { dag_h = desc->dagArray[i].dags; while (dag_h) { dag_h->bp = (struct buf *) desc->bp; dag_h->tracerec = tracerec; dag_h = dag_h->next; } } desc->flags |= RF_DAG_DISPATCH_RETURNED; desc->state++; /* next state should be rf_State_ExecuteDAG */ } return RF_FALSE; } /* the access has an array of dagLists, one dagList per parity stripe. * fire the first dag in each parity stripe (dagList). * dags within a stripe (dagList) must be executed sequentially * - this preserves atomic parity update * dags for independents parity groups (stripes) are fired concurrently */ int rf_State_ExecuteDAG(RF_RaidAccessDesc_t * desc) { int i; RF_DagHeader_t *dag_h; RF_DagList_t *dagArray = desc->dagArray; /* next state is always rf_State_ProcessDAG important to do this * before firing the first dag (it may finish before we leave this * routine) */ desc->state++; /* sweep dag array, a stripe at a time, firing the first dag in each * stripe */ for (i = 0; i < desc->numStripes; i++) { RF_ASSERT(dagArray[i].numDags > 0); RF_ASSERT(dagArray[i].numDagsDone == 0); RF_ASSERT(dagArray[i].numDagsFired == 0); RF_ETIMER_START(dagArray[i].tracerec.timer); /* fire first dag in this stripe */ dag_h = dagArray[i].dags; RF_ASSERT(dag_h); dagArray[i].numDagsFired++; /* XXX Yet another case where we pass in a conflicting * function pointer :-( XXX GO */ rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess, &dagArray[i]); } /* the DAG will always call the callback, even if there was no * blocking, so we are always suspended in this state */ return RF_TRUE; } /* rf_State_ProcessDAG is entered when a dag completes. * first, check to all dags in the access have completed * if not, fire as many dags as possible */ int rf_State_ProcessDAG(RF_RaidAccessDesc_t * desc) { RF_AccessStripeMapHeader_t *asmh = desc->asmap; RF_Raid_t *raidPtr = desc->raidPtr; RF_DagHeader_t *dag_h; int i, j, done = RF_TRUE; RF_DagList_t *dagArray = desc->dagArray; RF_Etimer_t timer; /* check to see if this is the last dag */ for (i = 0; i < desc->numStripes; i++) if (dagArray[i].numDags != dagArray[i].numDagsDone) done = RF_FALSE; if (done) { if (desc->status) { /* a dag failed, retry */ RF_ETIMER_START(timer); /* free all dags */ for (i = 0; i < desc->numStripes; i++) { rf_FreeDAG(desc->dagArray[i].dags); } rf_MarkFailuresInASMList(raidPtr, asmh); /* back up to rf_State_CreateDAG */ desc->state = desc->state - 2; return RF_FALSE; } else { /* move on to rf_State_Cleanup */ desc->state++; } return RF_FALSE; } else { /* more dags to execute */ /* see if any are ready to be fired. if so, fire them */ /* don't fire the initial dag in a list, it's fired in * rf_State_ExecuteDAG */ for (i = 0; i < desc->numStripes; i++) { if ((dagArray[i].numDagsDone < dagArray[i].numDags) && (dagArray[i].numDagsDone == dagArray[i].numDagsFired) && (dagArray[i].numDagsFired > 0)) { RF_ETIMER_START(dagArray[i].tracerec.timer); /* fire next dag in this stripe */ /* first, skip to next dag awaiting execution */ dag_h = dagArray[i].dags; for (j = 0; j < dagArray[i].numDagsDone; j++) dag_h = dag_h->next; dagArray[i].numDagsFired++; /* XXX and again we pass a different function * pointer.. GO */ rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess, &dagArray[i]); } } return RF_TRUE; } } /* only make it this far if all dags complete successfully */ int rf_State_Cleanup(RF_RaidAccessDesc_t * desc) { RF_AccTraceEntry_t *tracerec = &desc->tracerec; RF_AccessStripeMapHeader_t *asmh = desc->asmap; RF_Raid_t *raidPtr = desc->raidPtr; RF_AccessStripeMap_t *asm_p; RF_DagHeader_t *dag_h; RF_Etimer_t timer; int tid, i; desc->state++; rf_get_threadid(tid); timer = tracerec->timer; RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.dag_retry_us = RF_ETIMER_VAL_US(timer); /* the RAID I/O is complete. Clean up. */ tracerec->specific.user.dag_retry_us = 0; RF_ETIMER_START(timer); if (desc->flags & RF_DAG_RETURN_DAG) { /* copy dags into paramDAG */ *(desc->paramDAG) = desc->dagArray[0].dags; dag_h = *(desc->paramDAG); for (i = 1; i < desc->numStripes; i++) { /* concatenate dags from remaining stripes */ RF_ASSERT(dag_h); while (dag_h->next) dag_h = dag_h->next; dag_h->next = desc->dagArray[i].dags; } } else { /* free all dags */ for (i = 0; i < desc->numStripes; i++) { rf_FreeDAG(desc->dagArray[i].dags); } } RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.cleanup_us = RF_ETIMER_VAL_US(timer); RF_ETIMER_START(timer); if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) { for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) { if (!rf_suppressLocksAndLargeWrites && asm_p->parityInfo && !(desc->flags & RF_DAG_SUPPRESS_LOCKS)) { RF_ASSERT_VALID_LOCKREQ(&asm_p->lockReqDesc); rf_ReleaseStripeLock(raidPtr->lockTable, asm_p->stripeID, &asm_p->lockReqDesc); } if (asm_p->flags & RF_ASM_FLAGS_RECON_BLOCKED) { rf_UnblockRecon(raidPtr, asm_p); } } } RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer); RF_ETIMER_START(timer); if (desc->flags & RF_DAG_RETURN_ASM) *(desc->paramASM) = asmh; else rf_FreeAccessStripeMap(asmh); RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); tracerec->specific.user.cleanup_us += RF_ETIMER_VAL_US(timer); RF_ETIMER_STOP(desc->timer); RF_ETIMER_EVAL(desc->timer); timer = desc->tracerec.tot_timer; RF_ETIMER_STOP(timer); RF_ETIMER_EVAL(timer); desc->tracerec.total_us = RF_ETIMER_VAL_US(timer); rf_LogTraceRec(raidPtr, tracerec); desc->flags |= RF_DAG_ACCESS_COMPLETE; return RF_FALSE; }