1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/featuremgmt/featuremgr/src/serverexe/burstate.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,417 @@
1.4 +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +/**
1.20 + @file
1.21 +*/
1.22 +
1.23 +#include "burstate.h"
1.24 +#include <babackup.h>
1.25 +#include "featmgrdebug.h"
1.26 +#include "featmgrserver.h"
1.27 +
1.28 +CBurState::CBurState()
1.29 + {
1.30 + return;
1.31 + }
1.32 +
1.33 +/**
1.34 + * The Backup and Restore state machine.
1.35 + * This state machine has two state tables. The first table defines the correct modes of operation
1.36 + * and the second describe the pathways arrising from error conditions. By seperating the normal
1.37 + * pathways from the error pathways we can simplify the state machine into two parts. The function
1.38 + * SetUpBurStruct() will define the pathways for both these tables.
1.39 + * Each table has three items per row: a current state, an ending state, and a pointer to a function
1.40 + * that transforms between these two states safely.
1.41 + * Given that we already know where we are, and where we are told to goto, the state machine
1.42 + * function BUR_StateMachine() will search the normal operation table for a match, and then apply
1.43 + * the function through the pointer. If no match is found, then the goto state is set to Error, and
1.44 + * the error table is searched and applied. Because all the state are covered within the error table
1.45 + * we can always return to a normal more of operation through the application of the error
1.46 + * functions.
1.47 + */
1.48 +CBurState::CBurState(CFeatMgrServer* aServer) : iCurrentBURStatus( EFeatMgrBURState_None ), iServer( aServer )
1.49 + {
1.50 + SetUpBurStruct();
1.51 + return;
1.52 + }
1.53 +
1.54 +CBurState::~CBurState()
1.55 + {
1.56 + return;
1.57 + }
1.58 +
1.59 +CBurState* CBurState::NewLC()
1.60 + {
1.61 + CBurState* self = new (ELeave)CBurState();
1.62 + CleanupStack::PushL(self);
1.63 + self->ConstructL();
1.64 + return self;
1.65 + }
1.66 +
1.67 +CBurState* CBurState::NewL()
1.68 + {
1.69 + CBurState* self=CBurState::NewLC();
1.70 + CleanupStack::Pop(); // self;
1.71 + return self;
1.72 + }
1.73 +
1.74 +void CBurState::ConstructL()
1.75 + {
1.76 + return;
1.77 + }
1.78 +
1.79 +/**
1.80 + * This function checks the arguments that are passed into HandleBackupOperationEventL.
1.81 + * The TBackupOperationAttributes are checked against known values and an error is returned if
1.82 + * the Feature Manager doesn't recognise the events.
1.83 + */
1.84 +TInt CBurState::CheckBURArguments( const TBackupOperationAttributes& aBackupOperationAttributes )
1.85 + {
1.86 + TInt error( KErrNone );
1.87 + iBURLockFlag = aBackupOperationAttributes.iFileFlag;
1.88 + iBUROpType = aBackupOperationAttributes.iOperation;
1.89 +
1.90 + // determine the operation type (backup or restore)
1.91 + switch( iBURLockFlag )
1.92 + {
1.93 + case MBackupObserver::EReleaseLockReadOnly:
1.94 + INFO_LOG( "MBackupObserver::EReleaseLockReadOnly" );
1.95 + break;
1.96 + case MBackupObserver::EReleaseLockNoAccess:
1.97 + INFO_LOG( "MBackupObserver::EReleaseLockNoAccess" );
1.98 + break;
1.99 + case MBackupObserver::ETakeLock:
1.100 + INFO_LOG( "MBackupObserver::ETakeLock" );
1.101 + break;
1.102 + default:
1.103 + INFO_LOG( "CheckBURArguments iBURLockFlag default" );
1.104 + error = KErrNotFound;
1.105 + break;
1.106 + }
1.107 +
1.108 + // determine the operation status (e.g. starting, ending)
1.109 + switch( iBUROpType )
1.110 + {
1.111 + case MBackupOperationObserver::ENone:
1.112 + INFO_LOG( "ENone" );
1.113 + break;
1.114 + case MBackupOperationObserver::EStart:
1.115 + INFO_LOG( "EStart" );
1.116 + break;
1.117 + case MBackupOperationObserver::EEnd:
1.118 + INFO_LOG( "EEnd" );
1.119 + break;
1.120 + case MBackupOperationObserver::EAbort:
1.121 + INFO_LOG( "EAbort" );
1.122 + break;
1.123 + default:
1.124 + INFO_LOG( "CheckBURArguments iOperation default" );
1.125 + error = KErrNotFound;
1.126 + break;
1.127 + }
1.128 +
1.129 + return error;
1.130 + }
1.131 +
1.132 +/**
1.133 + * Sets up the array entries for the possible backup/restore state vectors.
1.134 + * from -> to : function
1.135 + * State vector: None -> BackupStarted : Goto_StartBackupState
1.136 + * State vector: BackupStarted -> BackupEnded : EndBackupState
1.137 + * State vector: BackupEnded -> None : Goto_NormalState
1.138 + * State vector: None -> RestoreStarted : Goto_StartRestoreState
1.139 + * State vector: RestoreStarted -> RestoreEnded : Goto_EndRestoreState
1.140 + * State vector: RestoreEnded -> None : Goto_NormalState
1.141 + */
1.142 +void CBurState::SetUpBurStruct()
1.143 + {
1.144 + BURStruct bStruct;
1.145 +
1.146 + // Backup states
1.147 +
1.148 + // State vector: None -> BackupStarted : Goto_StartBackupState
1.149 + bStruct.iCurrent = EFeatMgrBURState_None;
1.150 + bStruct.iGoto = EFeatMgrBURState_BackupStarted;
1.151 + bStruct.iFunc = &CFeatMgrServer::Goto_StartBackupState;
1.152 + iBURStructArray[0] = bStruct;
1.153 +
1.154 + // State vector: BackupStarted -> BackupEnded : EndBackupState
1.155 + bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
1.156 + bStruct.iGoto = EFeatMgrBURState_BackupEnded;
1.157 + bStruct.iFunc = &CFeatMgrServer::Goto_EndBackupState;
1.158 + iBURStructArray[1] = bStruct;
1.159 +
1.160 + // State vector: BackupEnded -> None : Goto_NormalState
1.161 + bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
1.162 + bStruct.iGoto = EFeatMgrBURState_None;
1.163 + bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
1.164 + iBURStructArray[2] = bStruct;
1.165 +
1.166 + // Valid restore states
1.167 +
1.168 + // State vector: None -> RestoreStarted : Goto_StartRestoreState
1.169 + bStruct.iCurrent = EFeatMgrBURState_None;
1.170 + bStruct.iGoto = EFeatMgrBURState_RestoreStarted;
1.171 + bStruct.iFunc = &CFeatMgrServer::Goto_StartRestoreState;
1.172 + iBURStructArray[3] = bStruct;
1.173 +
1.174 + // State vector: RestoreStarted -> RestoreEnded : Goto_EndRestoreState
1.175 + bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
1.176 + bStruct.iGoto = EFeatMgrBURState_RestoreEnded;
1.177 + bStruct.iFunc = &CFeatMgrServer::Goto_EndRestoreState;
1.178 + iBURStructArray[4] = bStruct;
1.179 +
1.180 + // State vector: RestoreEnded -> None : Goto_NormalState
1.181 + bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
1.182 + bStruct.iGoto = EFeatMgrBURState_None;
1.183 + bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
1.184 + iBURStructArray[6] = bStruct;
1.185 +
1.186 + // State vector: None -> None : Goto_NormalState
1.187 + bStruct.iCurrent = EFeatMgrBURState_None;
1.188 + bStruct.iGoto = EFeatMgrBURState_None;
1.189 + bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
1.190 + iBURStructArray[5] = bStruct;
1.191 +
1.192 +
1.193 + //
1.194 + // Error states
1.195 +
1.196 + // State vector: RestoreStarted -> Error : Goto_ErrorState
1.197 + bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
1.198 + bStruct.iGoto = EFeatMgrBURState_Error;
1.199 + bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
1.200 + iBURStructErrorArray[0] = bStruct;
1.201 +
1.202 + // State vector: RestoreEnded -> Error : Goto_ErrorState
1.203 + bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
1.204 + bStruct.iGoto = EFeatMgrBURState_Error;
1.205 + bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
1.206 + iBURStructErrorArray[1] = bStruct;
1.207 +
1.208 + // State vector: BackupStarted -> None : Goto_ErrorState
1.209 + bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
1.210 + bStruct.iGoto = EFeatMgrBURState_Error;
1.211 + bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
1.212 + iBURStructErrorArray[2] = bStruct;
1.213 +
1.214 + // State vector: BackupEnded -> None : Goto_ErrorState
1.215 + bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
1.216 + bStruct.iGoto = EFeatMgrBURState_Error;
1.217 + bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
1.218 + iBURStructErrorArray[3] = bStruct;
1.219 +
1.220 + // State vector: Error -> None : Goto_NormalState
1.221 + bStruct.iCurrent = EFeatMgrBURState_Error;
1.222 + bStruct.iGoto = EFeatMgrBURState_None;
1.223 + bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
1.224 + iBURStructErrorArray[4] = bStruct;
1.225 +
1.226 + return;
1.227 + }
1.228 +
1.229 +/**
1.230 + * Convert from the type provided in TBackupOperationAttributes into more sensible BUR types that
1.231 + * can be handles by the BUR_StateMachine. This step is necessary for two reasons, the first is
1.232 + * simplification and the second is a lexical check for invalid type MBackupObserver::TFileLockFlags.
1.233 + */
1.234 +BURStatus CBurState::ConvertToBURState( const TBackupOperationAttributes& aBackupOperationAttributes )
1.235 + {
1.236 + BURStatus status = EFeatMgrBURState_Error;
1.237 + iBURLockFlag = aBackupOperationAttributes.iFileFlag;
1.238 + iBUROpType = aBackupOperationAttributes.iOperation;
1.239 + // we ignore the iOperation state
1.240 +
1.241 + if( iBURLockFlag == MBackupObserver::ETakeLock )
1.242 + {
1.243 + // ending (this doesn't define whether it was a backup
1.244 + // or a restore ending, just that file writing can now start
1.245 + // again).
1.246 + INFO_LOG("ChangeFileLockL() BUR ending");
1.247 + switch( iCurrentBURStatus )
1.248 + {
1.249 + case( EFeatMgrBURState_BackupStarted ):
1.250 + status = EFeatMgrBURState_BackupEnded;
1.251 + break;
1.252 + case( EFeatMgrBURState_RestoreStarted ):
1.253 + status = EFeatMgrBURState_RestoreEnded;
1.254 + break;
1.255 + case( EFeatMgrBURState_None ):
1.256 + status = EFeatMgrBURState_None;
1.257 + break;
1.258 + default:
1.259 + status = EFeatMgrBURState_Error;
1.260 + break;
1.261 + }
1.262 + }
1.263 + else if( (iBURLockFlag & MBackupObserver::EReleaseLockReadOnly) &&
1.264 + (iBURLockFlag & ~MBackupObserver::EReleaseLockNoAccess) )
1.265 + {
1.266 + // starting (making the file read-only is a sign that we are
1.267 + // in "backup" mode).
1.268 + INFO_LOG("ChangeFileLockL() backup starting");
1.269 + status = EFeatMgrBURState_BackupStarted;
1.270 + }
1.271 + else if( iBURLockFlag & MBackupObserver::EReleaseLockNoAccess )
1.272 + {
1.273 + // starting (now read/write access is used to signify that a
1.274 + // restore has been started).
1.275 + INFO_LOG("ChangeFileLockL() restore starting");
1.276 + status = EFeatMgrBURState_RestoreStarted;
1.277 + }
1.278 + else
1.279 + {
1.280 + // unhandled flag states
1.281 + INFO_LOG("ChangeFileLockL() error state");
1.282 + status = EFeatMgrBURState_Error;
1.283 + }
1.284 +
1.285 + return status;
1.286 + }
1.287 +
1.288 +/**
1.289 + * This function is called from within featmgr server when a backup event occurs
1.290 + * There are two state variables coming into Feature Manager as types MBackupObserver::TFileLockFlags
1.291 + * and TOperationType. Only certain combinations of these two state variables are valid for Feature
1.292 + * Manager and if the combination is not valid (because there is no way of returning an error)
1.293 + * it will just set the internal state machine into an "error" state.
1.294 + * Given our current state and our goto state (i.e. where we are at the moment and where we want to goto)
1.295 + * the state machine checks that this is a valid path in our state machine and then perform the correct
1.296 + * operations to get us to the next valid state.
1.297 + */
1.298 +void CBurState::BUROperationL( const TBackupOperationAttributes& aBackupOperationAttributes )
1.299 + {
1.300 + BURStatus gotoState = EFeatMgrBURState_Error; // fail safe
1.301 + BURStatus currentState = iCurrentBURStatus; // where in the state machine we are at the moment
1.302 +
1.303 + // Check that the arguments are within valid limits
1.304 + if( KErrNone == CheckBURArguments( aBackupOperationAttributes ) )
1.305 + {
1.306 + // Now convert into states that the Feature Manager understands.
1.307 + gotoState = ConvertToBURState( aBackupOperationAttributes );
1.308 + }
1.309 +
1.310 + // Check that this is a valid path and then perform the correct operations to get to the next valid state
1.311 + iCurrentBURStatus = BUR_StateMachine( currentState, gotoState );
1.312 +
1.313 + return;
1.314 + }
1.315 +
1.316 +/**
1.317 + * The state machine for the backup and restore of the featmgr
1.318 + * The logic that goes into changing states in the state machine.
1.319 + */
1.320 +BURStatus CBurState::BUR_StateMachine( BURStatus aCurrent, BURStatus aGoto )
1.321 + {
1.322 + TInt count = 0;
1.323 + TBool found = EFalse;
1.324 +
1.325 + // Fail safe default state values
1.326 + BURStatus newState = EFeatMgrBURState_Error;
1.327 + BURStatus stateTableGoto = EFeatMgrBURState_Error;
1.328 + BURStatus stateTableCurrent = EFeatMgrBURState_Error;
1.329 +
1.330 + // Normal operation
1.331 + //
1.332 + do
1.333 + {
1.334 + // Get the n-th state table [current,goto] state vector
1.335 + stateTableCurrent = iBURStructArray[count].iCurrent;
1.336 + stateTableGoto = iBURStructArray[count].iGoto;
1.337 +
1.338 + // if the state table matches what we are given
1.339 + if( (aCurrent == stateTableCurrent) &&
1.340 + (aGoto == stateTableGoto) )
1.341 + {
1.342 + // process the relevant state function
1.343 + if( NULL != iBURStructArray[count].iFunc )
1.344 + {
1.345 + newState = (iServer->*iBURStructArray[count].iFunc)( aCurrent );
1.346 +
1.347 + // check result: when from the state machine is not what we expected from the state table
1.348 + if( newState != stateTableGoto )
1.349 + {
1.350 + // put state machine into an error state and break "normal" loop
1.351 + aCurrent = newState;
1.352 + aGoto = EFeatMgrBURState_Error;
1.353 + break;
1.354 + }
1.355 + else
1.356 + {
1.357 + found = ETrue;
1.358 + }
1.359 + }
1.360 +
1.361 + // self-perpetuate in certain cases
1.362 + if( (EFeatMgrBURState_BackupEnded == newState) ||
1.363 + (EFeatMgrBURState_RestoreEnded == newState) )
1.364 + {
1.365 + aCurrent = newState;
1.366 + aGoto = EFeatMgrBURState_None;
1.367 + found = EFalse;
1.368 + count = 0;
1.369 + }
1.370 + }
1.371 + count++;
1.372 + }
1.373 + while( (!found) && count < KBURArrayLength );
1.374 +
1.375 +
1.376 + // Error recovery
1.377 + //
1.378 + if( EFeatMgrBURState_Error == aGoto ||
1.379 + EFalse == found )
1.380 + {
1.381 + // reset
1.382 + aGoto = EFeatMgrBURState_Error;
1.383 + count = 0;
1.384 + found = EFalse;
1.385 +
1.386 + do
1.387 + {
1.388 + // Get the n-th state table [current,goto] state vector in the error array
1.389 + stateTableCurrent = iBURStructErrorArray[count].iCurrent;
1.390 + stateTableGoto = iBURStructErrorArray[count].iGoto;
1.391 +
1.392 + // if the state table matches what we are given
1.393 + if( ((aCurrent == stateTableCurrent) && (aGoto == stateTableGoto)) )
1.394 + {
1.395 + // process the relevant state function
1.396 + if( NULL != iBURStructErrorArray[count].iFunc )
1.397 + {
1.398 + newState = (iServer->*iBURStructErrorArray[count].iFunc)( aCurrent );
1.399 + // there is no error recovery from error recovery.
1.400 + found = ETrue;
1.401 + }
1.402 +
1.403 + // self-perpetuate in certain cases
1.404 + if( EFeatMgrBURState_Error == newState )
1.405 + {
1.406 + aCurrent = newState;
1.407 + aGoto = EFeatMgrBURState_None;
1.408 + found = EFalse;
1.409 + count = 0;
1.410 + }
1.411 + }
1.412 + count++;
1.413 + }
1.414 + while( (!found) && count < KBURErrorArrayLength );
1.415 +
1.416 + }
1.417 +
1.418 + return newState;
1.419 + }
1.420 +