/*

* Copyright (c) 2009 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 "MemSpyEngineHelperSysMemTrackerEntryManager.h"

// System includes

#include <e32debug.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyenginemidwife.h>

#include <memspy/engine/memspyengineundertaker.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyenginehelperfbserv.h>

#include <memspy/engine/memspyenginehelperfilesystem.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/engine/memspyenginehelperkernelcontainers.h>

#include <memspy/engine/memspyenginehelperwindowserver.h>

#include <memspy/engine/memspyenginehelpersysmemtracker.h>

#include "MemSpyEngineHelperSysMemTrackerImp.h"

#include "MemSpyEngineHelperSysMemTrackerLog.h"

#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

#include <memspy/engine/memspyenginehelpersysmemtrackercyclechange.h>

#include "MemSpyEngineHelperSysMemTrackerEntries.h"

#include "MemSpyEngineHelperSysMemTrackerEntryChunk.h"

#include "MemSpyEngineHelperSysMemTrackerEntryGlobalData.h"

#include "MemSpyEngineHelperSysMemTrackerEntryHeap.h"

#include "MemSpyEngineHelperSysMemTrackerEntryRamDrive.h"

#include "MemSpyEngineHelperSysMemTrackerEntryStack.h"

#include "MemSpyEngineHelperSysMemTrackerEntryCode.h"

#include "MemSpyEngineHelperSysMemTrackerEntryHandleGeneric.h"

#include "MemSpyEngineHelperSysMemTrackerEntryHandlePAndS.h"

#include "MemSpyEngineHelperSysMemTrackerEntryOpenFile.h"

#include "MemSpyEngineHelperSysMemTrackerEntryDiskSpace.h"

#include "MemSpyEngineHelperSysMemTrackerEntryBitmap.h"

#include "MemSpyEngineHelperSysMemTrackerEntryFbserv.h"

#include "MemSpyEngineHelperSysMemTrackerEntryFileServerCache.h"

#include "MemSpyEngineHelperSysMemTrackerEntrySystemMemory.h"

#include "MemSpyEngineHelperSysMemTrackerEntryWindowServer.h"

// Constants

// Message printed to RDebug output for some clients that may be reading traces 

_LIT( KMemSpyKeepaliveMessage, "<MEMSPY_PROGRESS>" );

CMemSpyEngineHelperSysMemTrackerEntryManager::CMemSpyEngineHelperSysMemTrackerEntryManager( CMemSpyEngineHelperSysMemTrackerImp& aTracker, CMemSpyEngineHelperSysMemTrackerEntryManager* aMasterList )

:   iTracker( aTracker ), iMasterList( aMasterList )

    {

    }

CMemSpyEngineHelperSysMemTrackerEntryManager::~CMemSpyEngineHelperSysMemTrackerEntryManager()

    {

    iEntries.ResetAndDestroy();

    iEntries.Close();

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::ConstructL()

    {

    CreateSeedItemsL();

    }

CMemSpyEngineHelperSysMemTrackerEntryManager* CMemSpyEngineHelperSysMemTrackerEntryManager::NewL( CMemSpyEngineHelperSysMemTrackerImp& aTracker )

    {

    CMemSpyEngineHelperSysMemTrackerEntryManager* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryManager( aTracker );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CMemSpyEngineHelperSysMemTrackerEntryManager* CMemSpyEngineHelperSysMemTrackerEntryManager::NewL( CMemSpyEngineHelperSysMemTrackerImp& aTracker, CMemSpyEngineHelperSysMemTrackerEntryManager& aMasterList )

    {

    CMemSpyEngineHelperSysMemTrackerEntryManager* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryManager( aTracker, &aMasterList );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::IdentifyChangesL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    {

    // Mark everything in this list (i.e. the master list) as dead.

    MarkEverythingDead();

    // Create a new list which will act as a secondary list. This new list will only contain

    // new entries. Any entries which it attempts to create that already exist in the master list

    // will be discared (after updating the corresponding master list entry with new values).

    CMemSpyEngineHelperSysMemTrackerEntryManager* newEM = CMemSpyEngineHelperSysMemTrackerEntryManager::NewL( iTracker, *this );

    CleanupStack::PushL( newEM );

    // At this point, we have performed several key operations

    // 

    // 1) We have tagged everything that is still alive as "alive".

    // 2) We have left everything that no longer exists as "dead"

    // 3) We have updated all alive entries with new values (if they have changed)

    // 4) We have identified new entries (these are currently orphaned within the secondary list right now).

    //

    // We now need to merge the two lists, i.e. take all the new entries in 'newEM' and merge them

    // into the current master list.

    MergeListIntoMeL( *newEM );

    // We can throw the other list away now as it will be empty.

    CleanupStack::PopAndDestroy( newEM );

    // At this point we have our final new list, but it still contains dead entries.

    // We must next output all the change information required for this cycle.

    ProcessChangesL( aCycle );

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::EverythingHasChangedL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    {

    ProcessChangesL( aCycle );

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::ProcessChangesL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    {

    const TInt count = iEntries.Count();

    for( TInt i=count-1; i>=0; i-- )

        {

        CMemSpyEngineHelperSysMemTrackerEntry* entry = iEntries[ i ];

        // Create any change descriptors etc

        TRAP_IGNORE( entry->HandleNewCycleL( aCycle ) );

        // Destroy the entry if it's no longer needed

        if  ( entry->IsDead() )

            {

            delete entry;

            iEntries.Remove( i );

            }

        else

            {

            // It's not new anymore

            entry->SetNew( EFalse );

            }

        }

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::AddItemAndPopL( CMemSpyEngineHelperSysMemTrackerEntry* aItem )

    {

    // We sort by entry key, we do not allow duplicates

    TLinearOrder<CMemSpyEngineHelperSysMemTrackerEntry> orderer( CompareKey );

    // Before we save the entry we must check to see if the master list knows about it.

    const TUint64 key( aItem->Key() );

    // Operates in one of two ways. If we're in stand-alone mode, then it saves every specified entry.

    // If we're in secondary mode (i.e. we have an associated master list) then it only saves new entries.

    // Entries which are changed are updated (in the master list) and entries that don't exist anymore

    // are tagged as dead.

    //

    if  ( ActingAsSecondaryList() )

        {

        CMemSpyEngineHelperSysMemTrackerEntry* existingEntry = iMasterList->EntryByKey( key );

        if  ( existingEntry )

            {

            // Entry used to exist, still does. Update the master list entry with the information

            // from the transient (new) entry.

            existingEntry->UpdateFromL( *aItem );

            // Entry is still alive. Previously, at the start of the cycle, we'd tagged all master list

            // entries as dead, hence we must undo that if we find the entry really still exists...

            // NB: this also updates the timestamp for the entry, to show when it was last still alive.

            existingEntry->SetAlive();

            // But it definitely isn't new anymore as we've seen it at least once before

            existingEntry->SetNew( EFalse );

            // Transient entry not needed anymore, keep original

            CleanupStack::PopAndDestroy( aItem );

            }

        else

            {

            // Entry didn't exist before - it's a new one

            iEntries.InsertInOrderL( aItem, orderer );

            CleanupStack::Pop( aItem );

            }

        // Any entries in the master list which aren't present anymore in this list (aka, dead entries)

        // will remain tagged as dead and will be filtered out and dealt with shortly...

        }

    else

        {

        // We ARE the master list

        const TInt err = iEntries.InsertInOrder( aItem, orderer );

        if  ( err == KErrAlreadyExists )

            {

            // Don't allow duplicates

            RDebug::Printf( "CMemSpyEngineHelperSysMemTrackerEntryManager::AddItemAndPopL() - ******* duplicate key ******* key: %LU, type: %d, tid: 0x%08x, pid: 0x%08x, handle: 0x%08x", key, aItem->Type(), (TUint32) aItem->ThreadId(), (TUint32) aItem->ProcessId(), aItem->Handle() );

            delete aItem;

            }

        else if ( err != KErrNone )

            {

            User::Leave( err );

            }

        CleanupStack::Pop( aItem );

        }

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::MarkEverythingDead()

    {

    const TInt count = iEntries.Count();

    for( TInt i=count-1; i>=0; i-- )

        {

        CMemSpyEngineHelperSysMemTrackerEntry* entry = iEntries[ i ];

        entry->SetDead();

        }

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::MergeListIntoMeL( CMemSpyEngineHelperSysMemTrackerEntryManager& aOtherList )

    {

    const TInt count = aOtherList.iEntries.Count();

    for( TInt i=count-1; i>=0; i-- )

        {

        CMemSpyEngineHelperSysMemTrackerEntry* entry = aOtherList.iEntries[ i ];

        CleanupStack::PushL( entry );

        aOtherList.iEntries.Remove( i );

        AddItemAndPopL( entry );

        }

    }

TInt CMemSpyEngineHelperSysMemTrackerEntryManager::FindByHandle( TUint aHandle, TMemSpyEngineSysMemTrackerType aType ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = iEntries.Count();

    for( TInt i=0; i<count; i++ )

        {

        const CMemSpyEngineHelperSysMemTrackerEntry* entry = iEntries[ i ];

        if  ( entry->Handle() == aHandle && entry->Type() == aType )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

TInt CMemSpyEngineHelperSysMemTrackerEntryManager::FindByThreadId( const TThreadId& aThreadId ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = iEntries.Count();

    for( TInt i=0; i<count; i++ )

        {

        const CMemSpyEngineHelperSysMemTrackerEntry* entry = iEntries[ i ];

        if  ( entry->ThreadId() == aThreadId )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

CMemSpyEngineHelperSysMemTrackerEntry* CMemSpyEngineHelperSysMemTrackerEntryManager::EntryByKey( const TUint64& aKey )

    {

    TLinearOrder<CMemSpyEngineHelperSysMemTrackerEntry> orderer( CompareKey );

    //

    CMemSpyEngineHelperSysMemTrackerEntryWithSuppliedKey tempEntry( iTracker, aKey );

    const TInt pos = iEntries.FindInOrder( &tempEntry, orderer );

    //

    CMemSpyEngineHelperSysMemTrackerEntry* ret = NULL;

    if  ( pos >= 0 )

        {

        ret = iEntries[ pos ];

        }

    //

    return ret;

    }

TInt CMemSpyEngineHelperSysMemTrackerEntryManager::CompareKey( const CMemSpyEngineHelperSysMemTrackerEntry& aLeft, const CMemSpyEngineHelperSysMemTrackerEntry& aRight )

    {

    TInt ret = -1;

    //

    const TUint64 kLeft( aLeft.Key() );

    const TUint64 kRight( aRight.Key() );

    //

    if  ( kLeft > kRight )

        {

        ret = 1;

        }

    else if ( kLeft == kRight )

        {

        ret = 0;

        }

    //

    return ret;

    }

TInt CMemSpyEngineHelperSysMemTrackerEntryManager::CompareKeyAndTimeStamp( const CMemSpyEngineHelperSysMemTrackerEntry& aLeft, const CMemSpyEngineHelperSysMemTrackerEntry& aRight )

    {

    TInt ret = CompareKey( aLeft, aRight );

    if  ( ret == 0 )

        {

        // Keys are the same, so compare time stamps

        const TTime& tLeft = aLeft.LastUpdateTime();

        const TTime& tRight = aRight.LastUpdateTime();

        //

        ret = -1;

        if  ( tLeft > tRight )

            {

            ret = 1;

            }

        else if ( tLeft == tRight )

            {

            ret = 0;

            }

        }

    //

    return ret;

    }

CMemSpyEngine& CMemSpyEngineHelperSysMemTrackerEntryManager::Engine()

    {

    return iTracker.Engine();

    }

void CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL()

    {

    RDebug::Print( KMemSpyKeepaliveMessage );

    TMemSpyEngineHelperSysMemTrackerConfig config;

    Engine().HelperSysMemTracker().GetConfig( config );

    // Get chunk list for entire device

    CMemSpyEngineChunkList* chunks = Engine().HelperChunk().ListL( );

    CleanupStack::PushL( chunks );

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() - MASTER - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

    if ( config.iEnabledCategories & TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryFileServerCache )

        {

        RDebug::Print( KMemSpyKeepaliveMessage );

        // Extract F32 cache chunk

        CreateSeedItemsFileServerCacheL( *chunks );        

        }

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() -  AFTER F32 CACHE - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() -  AFTER BITMAPS - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

    if ( config.iEnabledCategories & TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryUserHeap )

        {

        RDebug::Print( KMemSpyKeepaliveMessage );

        // Look for user heaps

        CreateSeedItemsHeapUserL( *chunks );

        }

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() -  AFTER USER HEAP - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() -  AFTER KERNEL HEAP - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

    if ( config.iEnabledCategories & TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryLocalChunks )

        {

        RDebug::Print( KMemSpyKeepaliveMessage );

        // Local chunks

        CreateSeedItemsChunkLocalL( *chunks );        

        }

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();

    for( TInt i=chunkCount-1; i>=0; i-- )

        {

        const TMemSpyDriverChunkInfo& info = chunks->At( i ).Info();

        RDebug::Print( _L("CMemSpyEngineHelperSysMemTrackerEntryManager::CreateSeedItemsL() -  AFTER LOCL CHUNK - info[%03d]: type: %d, size: %d, name: %S"), i, info.iType, info.iSize, &info.iName );

        }

    }

#endif

    if ( config.iEnabledCategories & TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryGlobalChunks )

        {

        RDebug::Print( KMemSpyKeepaliveMessage );

        // Global chunks

        CreateSeedItemsChunkGlobalL( *chunks );        

        }

#ifdef SYSMEMTRACKERLOGGING

    {

    const TInt chunkCount = chunks->Count();