/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
// INCLUDE FILES
#include <bldvariant.hrh>
#include <featmgr.h>
#include <centralrepository.h>
// USER INCLUDES
#include "GSWatchDog.h"
#include "GsLogger.h"
#include "settingsinternalcrkeys.h"
#include "SettingsPrivateCRKeys.h"
#include <eikenv.h>
#include <s32mem.h>
#include <centralrepository.h>
using namespace NCentralRepositoryConstants;
// CONSTANTS
// ========================= MEMBER FUNCTIONS ================================
// ----------------------------------------------------------------------------
// CGSWatchDog::NewL
//
// EPOC two-phased constructor
// ----------------------------------------------------------------------------
//
CGSWatchDog* CGSWatchDog::NewL()
{
CGSWatchDog* self = new( ELeave ) CGSWatchDog;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// CGSWatchDog::ConstructL
//
// EPOC default constructor can leave.
// ----------------------------------------------------------------------------
//
void CGSWatchDog::ConstructL()
{
__GSLOGSTRING( "[CGSWatchDog] ConstructL()" );
iStore = CRepository::NewL( KCRUidMiscSettings );
// Read last stored state for watchdog...
ReadStateL();
// If GS crashed last time, activate watchdog, reset run counter. Watchdog
// will be active as long as exit was not clean (panicked).
if( !WasCleanExitL() &&
iWatchdogActivationLimit != KGSWatchdogActivationDisabled )
{
iCrashCounter++;
iIsActive = ETrue;
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
#pragma message("-CGSWachDog verbose traces activated-")
User::InfoPrint( _L("Watchdog activated!") );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
if( iQuarantine.Count() > 0 )
{
for( TInt i = 0; i < iQuarantine.Count(); i++ )
{
// If plugin is not already in blacklist, move it there from
// quarantinelist.
if( !IsInBlackList( iQuarantine[i] ) )
{
TGSPluginQuarantine quarantinedPlugin;
quarantinedPlugin.iRunsAfterCrash = 0;
quarantinedPlugin.iUid = iQuarantine[i];
iBlackList.AppendL( quarantinedPlugin );
iQuarantine.Remove( i );
}
}
}
}
else
{
iIsActive = EFalse;
iCrashCounter = 0;
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
User::InfoPrint( _L("Watchdog disabled.") );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
// Clean run -> empty quarantine.
iQuarantine.Reset();
}
// Continue normal progress, set application to run state...
iGSAppRunning = ETrue;
// Store watchdog state at this point as panic will not call normal
// destructors and data would be otherwise lost in case of panic.
StoreStateL();
}
// ---------------------------------------------------------------------------
// CGSWatchDog::CGSWatchDog
//
// C++ constructor
// ---------------------------------------------------------------------------
CGSWatchDog::CGSWatchDog()
{
}
// ---------------------------------------------------------------------------
// CGSWatchDog::~CGSWatchDog
//
// Destructor
// ---------------------------------------------------------------------------
CGSWatchDog::~CGSWatchDog()
{
// Update all blacklisted plugins in case no crash FIRST, then store...
UpdateBlackListedPluginRunCounters();
TRAP_IGNORE( StoreStateL(); );
iBlackList.Close();
iQuarantine.Close();
delete iStore;
}
// ---------------------------------------------------------------------------
// CGSWatchDog::Quarantine
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::QuarantineL( TUid aPluginUid )
{
if( iIsActive )
{
iQuarantine.AppendL( aPluginUid );
StoreQuarantineL(); // Store to persistent storage
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
__GSLOGSTRING1( "[CGSWatchDog] Quarantined:0x%X", aPluginUid.iUid );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
}
}
// ---------------------------------------------------------------------------
// CGSWatchDog::RemoveFromQuarantine
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::RemoveFromQuarantineL( TUid aPluginUid )
{
if( iIsActive )
{
for( TInt i = 0; i < iQuarantine.Count(); i++ )
{
if( iQuarantine[i] == aPluginUid )
{
iQuarantine.Remove( i );
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
__GSLOGSTRING1( "[CGSWatchDog] Removed from quarantine:0x%X", aPluginUid.iUid );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
StoreQuarantineL();
break;
}
}
}
}
// ---------------------------------------------------------------------------
// CGSWatchDog::WasCleanExit
//
//
// ---------------------------------------------------------------------------
TBool CGSWatchDog::WasCleanExitL()
{
return !iGSAppRunning;
}
// ---------------------------------------------------------------------------
// CGSWatchDog::ReportCleanExit
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::ReportCleanExitL()
{
iGSAppRunning = EFalse;
iStore->Set( KWatchDogGSRunning, iGSAppRunning );
}
// ---------------------------------------------------------------------------
// CGSWatchDog::IsInBlackList
//
//
// ---------------------------------------------------------------------------
TBool CGSWatchDog::IsInBlackList( TUid aPluginUid )
{
TBool found = EFalse;
if( iIsActive )
{
for( TInt i = 0; i < iBlackList.Count(); i++ )
{
if( iBlackList[i].iUid == aPluginUid )
{
found = ETrue;
break;
}
}
}
return found;
}
// ---------------------------------------------------------------------------
// CGSWatchDog::StoreStateL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::StoreStateL()
{
//iStore->Set( KWatchDogIsActive, iIsActive );
iStore->Set( KWatchDogGSRunning, iGSAppRunning );
iStore->Set( KWatchDogCrashCounter, iCrashCounter );
iStore->Set( KWatchdogActivationLimit, iWatchdogActivationLimit );
iStore->Set( KWatchdogMaxPluginBlackListedRuns, iMaxPluginBlackListedRuns );
StoreQuarantineL();
StoreBlackListL();
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
// The following is just for debug trace:
__GSLOGSTRING( "[CGSWatchDog] Storing state:" );
__GSLOGSTRING1( " iIsActive: %d", iIsActive );
__GSLOGSTRING1( " iGSAppRunning: %d", iGSAppRunning );
__GSLOGSTRING1( " iCrashCounter: %d", iCrashCounter );
__GSLOGSTRING1( " iWatchdogActivationLimit: %d", iWatchdogActivationLimit );
__GSLOGSTRING1( " iMaxPluginBlackListedRuns: %d", iMaxPluginBlackListedRuns );
__GSLOGSTRING( "[CGSWatchDog] Stored plugins from quarantine:" );
for( TInt i = 0; i < iQuarantine.Count(); i++ )
{
__GSLOGSTRING1( " 0x%X", iQuarantine[i].iUid );
}
__GSLOGSTRING( "-" );
__GSLOGSTRING( "[CGSWatchDog] Stored plugins from blacklist:" );
for( TInt i = 0; i < iBlackList.Count(); i++ )
{
__GSLOGSTRING2( " 0x%X %d runs", iBlackList[i].iUid.iUid, iBlackList[i].iRunsAfterCrash );
}
__GSLOGSTRING( "-" );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
}
// ---------------------------------------------------------------------------
// CGSWatchDog::ReadStateL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::ReadStateL()
{
/*TInt isActive = EFalse; // Needed for mapping to TBool value
TInt err = iStore->Get( KWatchDogIsActive, isActive );
if( isActive == 1 )
{
iIsActive = ETrue;
}
else
{
iIsActive = EFalse;
}*/
TInt appRunning; // Needed for mapping to TBool value
TInt err = iStore->Get( KWatchDogGSRunning, appRunning );
if( err )
{
// CenRep values are uninitialized: first runtime of watchdog
// -> init values
InitStateL();
}
if( appRunning )
{
iGSAppRunning = ETrue;
}
else
{
iGSAppRunning = EFalse;
}
iStore->Get( KWatchDogCrashCounter, iCrashCounter );
iStore->Get( KWatchdogActivationLimit, iWatchdogActivationLimit );
iStore->Get( KWatchdogMaxPluginBlackListedRuns, iMaxPluginBlackListedRuns );
ReadQuarantineL();
ReadBlackListL();
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
// The following is just for debug trace:
__GSLOGSTRING( "[CGSWatchDog] Read state:" );
__GSLOGSTRING1( " iIsActive: %d", iIsActive );
__GSLOGSTRING1( " iGSAppRunning: %d", iGSAppRunning );
__GSLOGSTRING1( " iCrashCounter: %d", iCrashCounter );
__GSLOGSTRING1( " iWatchdogActivationLimit: %d", iWatchdogActivationLimit );
__GSLOGSTRING1( " iMaxPluginBlackListedRuns: %d", iMaxPluginBlackListedRuns );
__GSLOGSTRING( "[CGSWatchDog] Read plugins from quarantine:" );
for( TInt i = 0; i < iQuarantine.Count(); i++ )
{
__GSLOGSTRING1( " 0x%X", iQuarantine[i].iUid );
}
__GSLOGSTRING( "-" );
__GSLOGSTRING( "[CGSWatchDog] Read plugins from blacklist:" );
for( TInt i = 0; i < iBlackList.Count(); i++ )
{
__GSLOGSTRING2( " 0x%X %d runs", iBlackList[i].iUid.iUid, iBlackList[i].iRunsAfterCrash );
}
__GSLOGSTRING( "-" );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
}
// ---------------------------------------------------------------------------
// CGSWatchDog::InitStateL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::InitStateL()
{
__GSLOGSTRING( "[CGSWatchDog] initializing state..." );
iIsActive = EFalse;
iGSAppRunning = EFalse;
iCrashCounter = 0;
// Check CenRep, if values do not exist, use default values:
TInt err;
err = iStore->Get( KWatchDogCrashCounter, iWatchdogActivationLimit );
if( err )
{
iWatchdogActivationLimit = KGSDefaultWatchdogActivationLimit;
}
err = iStore->Get( KWatchdogMaxPluginBlackListedRuns, iMaxPluginBlackListedRuns);
if( err )
{
iMaxPluginBlackListedRuns = KGSDefaultMaxPluginBlackListedRuns;
}
StoreStateL();
}
// ---------------------------------------------------------------------------
// CGSWatchDog::ReadQuarantineL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::ReadQuarantineL()
{
HBufC8* buf = HBufC8::NewLC( KMaxBinaryLength );
TPtr8 serializedArr = buf->Des();
iStore->Get( KWatchDogQuarantine, serializedArr );
RDesReadStream stream;
stream.Open( serializedArr );
CleanupClosePushL( stream );
// In case CenRep value is uninitialized (less than 16 bits), don't try
//reading it
TInt count = 0;
if( buf->Size() > 0 )
{
count = stream.ReadUint16L();
}
for( TInt i = 0; i < count; i++ )
{
TUid uid;
uid.iUid = stream.ReadInt32L();
iQuarantine.AppendL( uid );
}
//stream.Close();
CleanupStack::PopAndDestroy( &stream );
CleanupStack::PopAndDestroy( buf );
}
// ---------------------------------------------------------------------------
// CGSWatchDog::StoreQuarantineL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::StoreQuarantineL()
{
// Hmmm. KMaxBinaryLength = 1024*2 unicode characters (16bit)
// = 1024*2*16 bits = 32768.
// 32768 - 16(count) bits reserved for 32 bit TUids = 1023.5 TUids
// -> We can store 1023 UIds in quarantine. Should be enought as we have
// about ~50 plugins at the moment and each plugin ought to be listed in
// quarantine only once at a specific point of time.
HBufC8* buf = HBufC8::NewLC( KMaxBinaryLength );
TPtr8 serializedArr = buf->Des();
RDesWriteStream stream;
stream.Open( serializedArr );
CleanupClosePushL( stream );
stream.WriteUint16L( iQuarantine.Count() );
for( TInt i = 0; i < iQuarantine.Count(); i++ )
{
stream.WriteInt32L( iQuarantine[i].iUid );
}
// This also flushes the stream:
CleanupStack::PopAndDestroy( &stream );
iStore->Set( KWatchDogQuarantine, serializedArr );
CleanupStack::PopAndDestroy( buf );
}
// ---------------------------------------------------------------------------
// CGSWatchDog::ReadBlackListL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::ReadBlackListL()
{
HBufC8* buf = HBufC8::NewLC( KMaxBinaryLength );
TPtr8 serializedArr = buf->Des();
iStore->Get( KWatchDogBlackList, serializedArr );
RDesReadStream stream;
stream.Open( serializedArr );
CleanupClosePushL( stream );
// In case CenRep value is uninitialized (less than 16 bits), don't try
//reading it
TInt count = 0;
if( buf->Size() > 0 )
{
count = stream.ReadUint16L();
}
for( TInt i = 0; i < count; i++ )
{
TGSPluginQuarantine plugin;
plugin.InternalizeL( stream );
iBlackList.AppendL( plugin );
}
//stream.Close();
CleanupStack::PopAndDestroy( &stream );
CleanupStack::PopAndDestroy( buf );
}
// ---------------------------------------------------------------------------
// CGSWatchDog::StoreBlackListL
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::StoreBlackListL()
{
HBufC8* buf = HBufC8::NewLC( KMaxBinaryLength );
TPtr8 serializedArr = buf->Des();
RDesWriteStream stream;
stream.Open( serializedArr );
CleanupClosePushL( stream );
stream.WriteUint16L( iBlackList.Count() );
for( TInt i = 0; i < iBlackList.Count(); i++ )
{
iBlackList[i].ExternalizeL( stream );
#ifdef _GS_WATCHDOG_VERBOSE_TRACES
__GSLOGSTRING1( "[CGSWatchDog] Written to blacklist 0x%X",
iBlackList[i].iUid.iUid );
#endif //_GS_WATCHDOG_VERBOSE_TRACES
}
// This also flushes the stream:
CleanupStack::PopAndDestroy( &stream );
iStore->Set( KWatchDogBlackList, serializedArr );
CleanupStack::PopAndDestroy( buf );
}
// ---------------------------------------------------------------------------
// CGSWatchDog::UpdateBlackListedPluginRunCounters
//
//
// ---------------------------------------------------------------------------
void CGSWatchDog::UpdateBlackListedPluginRunCounters()
{
TInt count = iBlackList.Count();
for( TInt i = 0; i < count; i++ )
{
iBlackList[i].iRunsAfterCrash++;
if( iBlackList[i].iRunsAfterCrash > iMaxPluginBlackListedRuns )
{
//__GSLOGSTRING2( "[CGSWatchDog] 0x%X removed from blacklist (%d runs)", iBlackList[i].iUid.iUid, iBlackList[i].iRunsAfterCrash );
iBlackList.Remove( i );
i--; // Item in index i has been removed
count--;// One item has been removed from the array
}
}
}
// ---------------------------------------------------------------------------
// TGSPluginQuarantine::InternalizeL
//
//
// ---------------------------------------------------------------------------
void TGSPluginQuarantine::InternalizeL( RReadStream& aStream )
{
iUid.iUid = aStream.ReadInt32L();
iRunsAfterCrash = aStream.ReadInt16L();
}
// ---------------------------------------------------------------------------
// TGSPluginQuarantine::ExternalizeL
//
//
// ---------------------------------------------------------------------------
void TGSPluginQuarantine::ExternalizeL( RWriteStream& aStream ) const
{
aStream.WriteInt32L( iUid.iUid );
aStream.WriteInt16L( iRunsAfterCrash );
}
//End of File