/*

* 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 <memspy/engine/memspyengineobjectcontainer.h>

// System includes

#include <e32svr.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperstack.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

// Literal constants

_LIT(KProcessFilter, "*");

_LIT(KEKernProcessName, "ekern");

CMemSpyEngineObjectContainer::CMemSpyEngineObjectContainer( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

	/*

    TFindProcess procFinder( KProcessFilter );

    TFullName nextMatch;

    //

    while( procFinder.Next( nextMatch ) == KErrNone )

        {

        _LIT(KProcListing, "%S");

        RDebug::Print(KProcListing, &nextMatch);

        _LIT(KFindMask, "*");

        nextMatch += KFindMask;

        //

        TFindThread threadFinder( nextMatch );

        //

        while( threadFinder.Next( nextMatch ) == KErrNone )

            {

            _LIT(KThreadListing, "+--- %S");

            RDebug::Print(KThreadListing, &nextMatch);

            }

        }

	*/

    }

CMemSpyEngineObjectContainer::~CMemSpyEngineObjectContainer()

    {

    DestroyProcesses( iGarbage );

    DestroyProcesses( iProcesses );

    delete iUndertaker;

    delete iMidwife;

    delete iIdleNotifyContainerChanged;

    }

void CMemSpyEngineObjectContainer::ConstructL( const TDesC& aFilter )

    {

    iUndertaker = CMemSpyEngineUndertaker::NewL( iEngine.Driver() );

    iUndertaker->AddObserverL( *this );

    //

    iMidwife = CMemSpyEngineMidwife::NewL( iEngine.Driver() );

    iMidwife->AddObserverL( *this );

    //

    iIdleNotifyContainerChanged = CIdle::NewL( CActive::EPriorityIdle );

    //

    RefreshL( aFilter );

    }

CMemSpyEngineObjectContainer* CMemSpyEngineObjectContainer::NewL( CMemSpyEngine& aEngine )

    {

    return NewL( KProcessFilter, aEngine );

    }

CMemSpyEngineObjectContainer* CMemSpyEngineObjectContainer::NewL( const TDesC& aFilter, CMemSpyEngine& aEngine )

    {

    CMemSpyEngineObjectContainer* self = new(ELeave) CMemSpyEngineObjectContainer( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aFilter );

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::Count() const

    {

    return iProcesses.Count();

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::CountAll() const

    {

    TInt ret = 0;

    //

    const TInt count = iProcesses.Count();

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

        {

        CMemSpyProcess* process = iProcesses[ i ];

        ret += process->Count();

        }

    //

    return ret;

    }

EXPORT_C void CMemSpyEngineObjectContainer::RefreshL()

    {

    RefreshL( KProcessFilter );

    }

EXPORT_C void CMemSpyEngineObjectContainer::RefreshL( const TDesC& aFilter )

    {

    LocateProcessesL( aFilter );

    }

EXPORT_C CMemSpyProcess& CMemSpyEngineObjectContainer::At( TInt aIndex ) const

    {

    CMemSpyProcess* ret = iProcesses[ aIndex ];

    return *ret;

    }

EXPORT_C CMemSpyProcess& CMemSpyEngineObjectContainer::ProcessByIdL( TProcessId aId ) const

    {

    CMemSpyProcess* ret = NULL;

    //

    const TInt count = iProcesses.Count();

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

        {

        CMemSpyProcess* process = iProcesses[ i ];

        if  ( process->Id() == aId )

            {

            ret = process;

            break;

            }

        }

    //

    if  ( ret == NULL )

        {

        User::Leave( KErrNotFound );

        }

    //

    return *ret;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::ProcessIndexById( TProcessId aId ) const

    {

    TInt index = KErrNotFound;

    //

    const TInt count = iProcesses.Count();

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

        {

        const CMemSpyProcess* process = iProcesses[ i ];

        if  ( process->Id() == aId )

            {

            index = i;

            break;

            }

        }

    //

    return index;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::ProcessAndThreadByThreadId( TThreadId aTid, CMemSpyProcess*& aProcess, CMemSpyThread*& aThread ) const

    {

    aProcess = NULL;

    aThread = NULL;

    TInt error = KErrNotFound;

    //

    const TInt count = iProcesses.Count();

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

        {

        CMemSpyProcess* process = iProcesses[ i ];

        // Check whether this process contains the thread we are looking for...

        const TInt index = process->ThreadIndexById( aTid );

        if  ( index >= 0 )

            {

            // Found it

            aProcess = process;

            aThread = &process->At( index );

            error = KErrNone;

            break;

            }

        }

    //

    if  ( error == KErrNotFound )

        {

        CMemSpyEngineObjectContainer* self = const_cast< CMemSpyEngineObjectContainer* >( this );

        TRAP( error, self->TryToCreateProcessAndThreadL( aTid, aProcess, aThread ) );

        }

    //

    return error;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::ProcessAndThreadByFullName( const TDesC& aFullName, CMemSpyProcess*& aProcess, CMemSpyThread*& aThread ) const

    {

    aProcess = NULL;

    aThread = NULL;

    TInt error = KErrNotFound;

    //

    const TInt count = iProcesses.Count();

    for( TInt i=0; i<count && aThread == NULL; i++ )

        {

        CMemSpyProcess& process = *iProcesses[ i ];

        const TInt threadCount = process.Count();

        //

        for(TInt j=0; j<threadCount; j++)

            {

            CMemSpyThread& thread = process.At( j );

            const TFullName threadName( thread.FullName() );

            //

            if  ( threadName.CompareF( aFullName ) == 0 )

                {

                // Found it

                aProcess = &process;

                aThread = &thread;

                error = KErrNone;

                break;

                }

            }

        }

    //

    if  ( error == KErrNotFound )

        {

        // NB: cannot use driver API as we must open thread by name, and that only supports opening

        // by id.

        RThread thread;

        error = thread.Open( aFullName );

        if ( error == KErrNone )

            {

            const TThreadId threadId = thread.Id();

            thread.Close();

            CMemSpyEngineObjectContainer* self = const_cast< CMemSpyEngineObjectContainer* >( this );

            TRAP( error, self->TryToCreateProcessAndThreadL( threadId, aProcess, aThread ) );

            }

        }

    //

    return error;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::ProcessAndThreadByPartialName( const TDesC& aPartialName, CMemSpyProcess*& aProcess, CMemSpyThread*& aThread ) const

    {

    aProcess = NULL;

    aThread = NULL;

    TInt error = KErrNotFound;

    //

    const TInt count = iProcesses.Count();

    for( TInt i=0; i<count && aThread == NULL; i++ )

        {

        CMemSpyProcess& process = *iProcesses[ i ];

        const TInt threadCount = process.Count();

        //

        for(TInt j=0; j<threadCount; j++)

            {

            CMemSpyThread& thread = process.At( j );

            const TFullName threadName( thread.FullName() );

            //

            if  ( threadName.FindF( aPartialName ) >= 0 )

                {

                // Found it

                aProcess = &process;

                aThread = &thread;

                error = KErrNone;

                break;

                }

            }

        }

    //

    return error;

    }

EXPORT_C TBool CMemSpyEngineObjectContainer::IsAlive( TProcessId aPid ) const

    {

    const TInt processIndex = ProcessIndexById( aPid );

    return ( processIndex >= 0 );

    }

EXPORT_C TBool CMemSpyEngineObjectContainer::IsAlive( TProcessId aPid, TThreadId aTid ) const

    {

    TBool isAlive = IsAlive( aPid );

    if  ( isAlive )

        {

        const TInt processIndex = ProcessIndexById( aPid );

        const CMemSpyProcess& process = At( processIndex );

        // Check whether the thread is alive

        isAlive = ( process.ThreadIndexById( aTid ) >= 0 );

        }

    //

    return isAlive;

    }

EXPORT_C TInt CMemSpyEngineObjectContainer::MdcaCount() const

    {

    return iProcesses.Count();

    }

EXPORT_C TPtrC CMemSpyEngineObjectContainer::MdcaPoint(TInt aIndex) const

    {

    const CMemSpyProcess* process = iProcesses[ aIndex ];

    return TPtrC( process->NameForListBox() );

    }

void CMemSpyEngineObjectContainer::LocateProcessesL( const TDesC& aFilter )

    {

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineObjectContainer::LocateProcessesL() - START" );

#endif

    DestroyProcesses( iProcesses );

    //

    const TProcessId myProcessId = RProcess().Id();

	//

    TFindProcess finder( aFilter );

    TFullName nextMatch;

    //

    while( finder.Next( nextMatch ) == KErrNone )

        {

        if  ( nextMatch.FindF(KEKernProcessName) == KErrNotFound )

            {

#ifdef _DEBUG

            RDebug::Print(_L( "CMemSpyEngineObjectContainer::LocateProcessesL() - found Proc: %S"), &nextMatch );

#endif

            RProcess p;

            const TInt r = p.Open( nextMatch );

            TProcessId processId( KNullProcessId );

            if ( r == KErrNone )

                {

                processId = p.Id();

                }

            p.Close();

#ifdef _DEBUG

            RDebug::Printf( "CMemSpyEngineObjectContainer::LocateProcessesL() - open err: %d", r );

#endif

            if  ( r == KErrNone )

                {

                if  ( processId != myProcessId )

                    {

                    TRAPD( err, CreateProcessL( processId ) );

#ifdef _DEBUG

                    RDebug::Printf( "CMemSpyEngineObjectContainer::LocateProcessesL() - CreateProcessL err: %d", err );

#endif

                    err = err;

                    }

                }

            }

        }

    //

    SortByName();

#ifdef _DEBUG

    RDebug::Printf( "CMemSpyEngineObjectContainer::LocateProcessesL() - END" );

#endif

    }

CMemSpyProcess* CMemSpyEngineObjectContainer::CreateProcessL( const TProcessId& aId )

    {

#ifdef _DEBUG

	RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::CreateProcessL() - START - pid: 0x%04x", (TUint) aId );

#endif

    CMemSpyProcess* processObj = CMemSpyProcess::NewLC( aId, iEngine );

    const TPtrC pName( processObj->Name() );

    if  ( pName.FindF( KEKernProcessName ) == KErrNotFound )

        {

        if  ( processObj->Count() == 0 )

            {

            // Calls delete

#ifdef _DEBUG

	        RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::CreateProcessL() - process has no threads... deleting it!" );

#endif

            processObj->Close();

            processObj = NULL;

            }

        else

            {

            // Make sure we don't add duplicate processes...

            AppendL( processObj );

            }

        }

    else

        {

        // We don't support kernel-side threads

#ifdef _DEBUG

        RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::CreateProcessL() - kernel process... deleting it!" );

#endif

        processObj->Close();

        processObj = NULL;

        }

    CleanupStack::Pop();

#ifdef _DEBUG

    RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::CreateProcessL() - END - pid: 0x%04x, processObj: 0x%08x", (TUint) aId, processObj );

#endif

    return processObj;

    }

void CMemSpyEngineObjectContainer::DestroyProcesses( RArray< CMemSpyProcess* >& aList )

    {

    while( aList.Count() ) 

        {

        CMemSpyProcess* process = aList[ 0 ];

        aList.Remove( 0 );

        process->Close();

        }

    aList.Close();

    }

void CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL( const TThreadId& aTid, CMemSpyProcess*& aProcess, CMemSpyThread*& aThread )

    {

#ifdef _DEBUG

    RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(1) - START - aTid: 0x%04x", (TUint) aTid );

#endif

    // Must open thread and process in order to get process id.

    RThread thread;

    User::LeaveIfError( iEngine.Driver().OpenThread( aTid, thread ) );

    CleanupClosePushL( thread );

    RProcess process;

    User::LeaveIfError( thread.Process( process ) );

    const TProcessId processId = process.Id();

    process.Close();

    // Call overload

    TryToCreateProcessAndThreadL( thread, aProcess, aThread );

    CleanupStack::PopAndDestroy( &thread );

#ifdef _DEBUG

    RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(1) - END - aTid: 0x%04x", (TUint) aTid );

#endif

    }

void CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL( const RThread& aRThread, CMemSpyProcess*& aProcess, CMemSpyThread*& aThread )

    {

#ifdef _DEBUG

    RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - START - aTid: 0x%04x", (TUint) aRThread.Id() );

#endif

    // Full name of process

    TFullName* name = new(ELeave) TFullName();

    CleanupStack::PushL( name );

    // Must open thread and process in order to get process id.

    RProcess process;

    User::LeaveIfError( aRThread.Process( process ) );

    process.FullName( *name );

    const TProcessId processId = process.Id();

    process.Close();

    const TBool isKernel = ( name->FindF( KEKernProcessName ) >= KErrNone );

#ifdef _DEBUG

    RDebug::Print( _L("[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - pid: 0x%04x, name: %S"), (TUint) processId, name );

#endif

    CleanupStack::PopAndDestroy( name );

    // See if we have already created a process for this process id...

    CMemSpyProcess* processObj = NULL;

    const TInt procIndex = ProcessIndexById( processId );

#ifdef _DEBUG

    RDebug::Print( _L("[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - pid: 0x%04x, index: %d"), (TUint) processId, procIndex );

#endif

    if  ( isKernel )

        {

#ifdef _DEBUG

        RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - caller requested a kernel thread/process..." );

#endif

        __ASSERT_ALWAYS( procIndex == KErrNotFound, MemSpyEngineUtils::Panic( EMemSpyEnginePanicEncounteredKernelUnexpectedly ) );

#ifdef _DEBUG

        RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - leaving with KErrNotSupported" );

#endif

        User::Leave( KErrNotSupported );

        }

    else if ( aRThread.Id() == RThread().Id() )

        {

        TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineObjectContainer::TryToCreateProcessAndThreadL(2) - trying to create MemSpy -> leaving with KErrNotSupported" ) );