/*

* 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 "MemSpyDriverInspectedProcess.h"

// System includes

#include <kern_priv.h>

#include <nk_trace.h>

#include <u32hal.h>

#ifdef __MARM__

#include "kdebug.h"

#endif //__MARM__

// User includes

#include "MemSpyDriverUtils.h"

#include "MemSpyDriverDevice.h"

#include "MemSpyDriverOSAdaption.h"

#include "MemSpyDriverInspectedProcessManager.h"

// Constants

_LIT8( KMemSpyLitDollarHeap, "$HEAP" );

_LIT8( KMemSpyLitDollarDllData, "DLL$DATA" );

_LIT8( KMemSpyLitDollarDat, "$DAT" );

_LIT( KMemSpyInspectedProcessMutexName, "MemSpyInspectedProcess_0x" );

DMemSpyInspectedProcess::DMemSpyInspectedProcess( DMemSpyDriverDevice& aDevice )

:   iDevice( aDevice )

	{

	}

DMemSpyInspectedProcess::~DMemSpyInspectedProcess()

	{

    TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - START - this: 0x%08x, %O", this, iProcess ));

	EventMonitor().RequestEventsCancel( *this );

    TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling NotifyOnChangeCancel..." ) );

    NotifyOnChangeCancel();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling ResetTrackedList..." ) );

    ResetTrackedList();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling ResetPendingChanges..." ) );

    ResetPendingChanges();

	if  ( iLock )

		{

        TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closing mutex..." ) );

		iLock->Close(NULL);

		}

    if  ( iProcess )

        {

        TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closing process..." ) );

	    Kern::SafeClose( (DObject*&) iProcess, NULL );

        TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closed process!" ) );

        }

    TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - END - this: 0x%08x", this ) );

	}

TInt DMemSpyInspectedProcess::Open( DProcess* aProcess )

    {

	__ASSERT_CRITICAL;

    TRACE( Kern::Printf("DMemSpyInspectedProcess::Open() - START - this: 0x%08x, aProcess: 0x%08x (%O)", this, aProcess, aProcess ));

    TInt error = KErrNone;

    //

    iProcess = aProcess;

    error = iProcess->Open();

    //

    if  ( error == KErrNone )

        {

        iProcessId = iDevice.OSAdaption().DProcess().GetId( *aProcess );

        // Create mutex

        TName name( KMemSpyInspectedProcessMutexName );

        name.AppendNumFixedWidth( (TUint) this, EHex, 8 );

        error = Kern::MutexCreate( iLock, name, KMutexOrdNone );

        //

        if  ( error == KErrNone )

            {

            // Get size of all stacks (user & supervsior) for process. Also

            // updates iUserThreadStackSize with the current size of just

            // the user-side thread stacks.

            iInfoCurrent.iMemoryStack = StackSize( *aProcess );

            // Request events

            EventMonitor().RequestEvents( *this );

            // Find initial chunks that are mapped into process

            FindChunks( *aProcess );

            // Indicate that we have data waiting for client. This will

            // cause the client's RS to be completed as soon as it 

            // registers with us...

            UpdateStatistics();

            CompleteClientsRequest( KErrNone, &iInfoCurrent );

            }

        }

    //

    TRACE( Kern::Printf("DMemSpyInspectedProcess::Open() - END - this: 0x%08x, error: %d", this, error ));

    return error;

    }

TInt DMemSpyInspectedProcess::NotifyOnChange( DThread* aThread, TRequestStatus* aRequestStatus, TMemSpyDriverProcessInspectionInfo* aInfo )

    {

	Lock();

    TInt err = KErrInUse;

    const TBool notificationQueued = NotifyOnChangeQueued();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - START - this: 0x%08x, iAmDead: %d, aRequestStatus: 0x%08x, notificationQueued: %d, iChangeObserverThread: 0x%08x (%O)", this, iAmDead, aRequestStatus, notificationQueued, iChangeObserverThread, iChangeObserverThread ) );

    //

    if  ( notificationQueued == EFalse )

        {

        TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - Saving client RS..." ) );

        iChangeObserverThread = aThread;

        iChangeObserverRS = aRequestStatus;

        iChangeObserverInfo = aInfo;

        // Whilst we still have items in the buffer, we let the client drain them fully.

        // However, if the process is now marked as dead and the buffer is exhausted,

        // we indicate this via KErrDied completion which will cause the client to

        // stop requesting any more changes.

        if	( !iPendingChanges.IsEmpty() )

			{

            TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - Have buffered changes - SENDING TO CLIENT IMMEDIATELY..." ) );

            // We have something in the pending buffer so we can

			// give it back to the client immediately.

	        TMemSpyTrackedChunkChangeInfo* cachedChange = _LOFF( iPendingChanges.First(), TMemSpyTrackedChunkChangeInfo, iLink );

			cachedChange->iLink.Deque();

            // Notify about change			

			CompleteClientsRequest( KErrNone, &cachedChange->iInfo );

			// Discard cached entry

			delete cachedChange;

			}

        else if ( iAmDead )

            {

            // We must stop listening outside of an event monitor callback...

    	    EventMonitor().RequestEventsCancel( *this );

			CompleteClientsRequest( KErrDied );

            }

        //

		err = KErrNone;

        }

	//

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - END - this: 0x%08x, err: %d", this, err ) );

	Unlock();

    return err;

    }

TInt DMemSpyInspectedProcess::NotifyOnChangeCancel()

    {

	Lock();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - START - this: 0x%08x, queued: %d, iChangeObserverThread: 0x%08x, iChangeObserverRS: 0x%08x", this, NotifyOnChangeQueued(), iChangeObserverThread, iChangeObserverRS ) );

    //

    if  ( NotifyOnChangeQueued() )

        {

        TRACE( Kern::Printf( "DMemSpyInspectedProcess::NotifyOnChangeCancel() - this: 0x%08x, iChangeObserverRS: 0x%08x, iProcessId: %d (0x%04x)", this, iChangeObserverRS, iProcessId, iProcessId ) );

		Kern::RequestComplete( iChangeObserverThread, iChangeObserverRS, KErrCancel );

        iChangeObserverThread = NULL;

        iChangeObserverRS = NULL;

        iChangeObserverInfo = NULL;

        }

	//

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - END - this: 0x%08x", this ) );

	Unlock();

    return KErrNone;

    }

TBool DMemSpyInspectedProcess::NotifyOnChangeQueued() const

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - START - this: 0x%08x", this ) );

    //

	Lock();

    const TBool queued = ( iChangeObserverRS != NULL );

	Unlock();

    //

    TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - END - this: 0x%08x, queued: %d", this, queued ) );

    return queued;

    }

void DMemSpyInspectedProcess::CompleteClientsRequest( TInt aCompletionCode, TMemSpyDriverProcessInspectionInfo* aInfo )

    {

    const TBool notificationQueued = NotifyOnChangeQueued();

    TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - START - this: 0x%08x, iChangeObserverThread: 0x%08x, iChangeObserverRS: 0x%08x, iChangeObserverInfo: 0x%08x, notificationQueued: %d", this, iChangeObserverThread, iChangeObserverRS, iChangeObserverInfo, notificationQueued ) );

    TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - iAmDead: %d, buffer is empty: %d, aCompletionCode: %d, iProcessId: %d (0x%04x), aInfo: 0x%08x, iChangeDeliveryCounter: %d", iAmDead, iPendingChanges.IsEmpty(), aCompletionCode, iProcessId, iProcessId, aInfo, iChangeDeliveryCounter ) );

    if  ( notificationQueued )

        {

        ++iChangeDeliveryCounter;

        TInt completionCode = aCompletionCode;

        // Write them to client...

        if ( aInfo != NULL )

            {

            const TInt writeErr = Kern::ThreadRawWrite( iChangeObserverThread, iChangeObserverInfo, aInfo, sizeof(TMemSpyDriverProcessInspectionInfo) );

    		if  ( writeErr != KErrNone )

    		    {

                completionCode = writeErr;

    		    }

            }

        // Complete client's async request

        DThread* changeThread = iChangeObserverThread;

        TRequestStatus* changeRS = iChangeObserverRS;

        // Zero these out first to avoid race condition

        iChangeObserverThread = NULL;

        iChangeObserverRS = NULL;

        iChangeObserverInfo = NULL;

        // ...and then tell client.

        TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - SENDING CHANGE [%4d] TO CLIENT [err: %d]", iChangeDeliveryCounter, completionCode ) );

		Kern::RequestComplete( changeThread, changeRS, completionCode );

        }

	else if ( aInfo )

		{

		// Buffer the change for next time around...

        TRACE( Kern::Printf("DMemSpyInspectedProcess::CompleteClientsRequest() - BUFFERING change event whilst client is AWOL...", this ) );

        NKern::ThreadEnterCS();

        TMemSpyTrackedChunkChangeInfo* changeInfo = new TMemSpyTrackedChunkChangeInfo();

        if ( changeInfo )

            {

            changeInfo->iInfo = *aInfo;

            iPendingChanges.Add( &changeInfo->iLink );

            }

        //

        NKern::ThreadLeaveCS();

		}

    TRACE( Kern::Printf("DMemSpyInspectedProcess::CompleteClientsRequest() - END - this: 0x%08x", this ) );

    }

void DMemSpyInspectedProcess::ResetTrackedList()

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetTrackedList() - START - this: 0x%08x", this ) );

    NKern::ThreadEnterCS();

    //

    SDblQueLink* link = iTrackedChunks.GetFirst();

	while( link )

		{

		TMemSpyTrackedChunk* object = _LOFF( link, TMemSpyTrackedChunk, iLink );

        delete object;

        link = iTrackedChunks.GetFirst();

		}

    //

    NKern::ThreadLeaveCS();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetTrackedList() - END - this: 0x%08x", this ) );

    }

void DMemSpyInspectedProcess::SetTrackedListUnused()

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnused() - START - this: 0x%08x", this ) );

	SDblQueLink* anchor = &iTrackedChunks.iA;

	for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)

		{

		TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );

        trackedChunk->SetUnused( ETrue );

		}

    TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnused() - END - this: 0x%08x", this ) );

    }

void DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::TType aType, TBool aUnusedStatus )

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType() - START - this: 0x%08x", this ) );

	SDblQueLink* anchor = &iTrackedChunks.iA;

	for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)

		{

		TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );

		if ( trackedChunk->Type() == aType )

		    {

            trackedChunk->SetUnused( aUnusedStatus );

		    }

		}

    TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType() - END - this: 0x%08x", this ) );

    }

void DMemSpyInspectedProcess::DiscardUnusedTrackListItems()

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::DiscardUnusedTrackListItems() - START - this: 0x%08x", this ) );

    NKern::ThreadEnterCS();

	const SDblQueLink* const anchor = &iTrackedChunks.iA;

    //	

	SDblQueLink* link = iTrackedChunks.First();

	while( link && link != anchor )

		{

		TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );

        const TBool unused = trackedChunk->iUnused;

        //

        link = link->iNext;

        //

        if  ( unused )

            {

    		trackedChunk->iLink.Deque();

            delete trackedChunk;

            }

        else

            {

            trackedChunk->SetUnused( EFalse );

            }

		}

    //

    NKern::ThreadLeaveCS();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::DiscardUnusedTrackListItems() - END - this: 0x%08x", this ) );

    }

void DMemSpyInspectedProcess::AddTrackedChunk( DChunk* aChunk, TMemSpyTrackedChunk::TType aType )

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::AddTrackedChunk() - START - this: 0x%08x, aChunk: 0x%08x (%O)", this, aChunk, aChunk ) );

    NKern::ThreadEnterCS();

    //

    TMemSpyTrackedChunk* wrapper = new TMemSpyTrackedChunk( aChunk, aType );

    if ( wrapper )

        {

        DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();

        const TInt cSize = chunkAdaption.GetSize( *aChunk );

        wrapper->SetSize( cSize );

        iTrackedChunks.Add( &wrapper->iLink );

        }

    //

    NKern::ThreadLeaveCS();

    TRACE( Kern::Printf("DMemSpyInspectedProcess::AddTrackedChunk() - END - this: 0x%08x", this ) );

    }

TMemSpyTrackedChunk* DMemSpyInspectedProcess::TrackedChunkByHandle( TAny* aHandle )

    {

    TRACE( Kern::Printf("DMemSpyInspectedProcess::TrackedChunkByHandle() - START - this: 0x%08x", this ) );

    TMemSpyTrackedChunk* ret = NULL;

    //

	const SDblQueLink* const anchor = &iTrackedChunks.iA;

	for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)

		{

		TMemSpyTrackedChunk* const trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );

		if  ( trackedChunk && trackedChunk->Handle() == aHandle )

			{

			ret = trackedChunk;

            break;

			}

		}

    //

    TRACE( Kern::Printf("DMemSpyInspectedProcess::TrackedChunkByHandle() - END - this: 0x%08x, entry: 0x%08x (%O)", this, ret, ret ? ret->iChunk : NULL ) );

	return ret;

    }

DMemSpyInspectedProcessManager& DMemSpyInspectedProcess::PManager()

    {

    return iDevice.ProcessInspectionManager();

    }

DMemSpyEventMonitor& DMemSpyInspectedProcess::EventMonitor()

    {

    return iDevice.EventMonitor();

    }

TUint DMemSpyInspectedProcess::EMTypeMask() const

    {

    TUint ret = EMemSpyEventThreadAdd     | EMemSpyEventThreadRemove  | EMemSpyEventThreadKill |

                EMemSpyEventProcessUpdate | EMemSpyEventProcessRemove | 

                EMemSpyEventChunkAdd      | EMemSpyEventChunkUpdate   | EMemSpyEventChunkDelete;

    if  ( iAmDead )

        {

        // Not interested anymore...

        ret = 0;

        }

    return ret;

    }

void DMemSpyInspectedProcess::EMHandleProcessUpdated( DProcess& aProcess )

    {

    const TUint procId = iDevice.OSAdaption().DProcess().GetId( aProcess );

    if  ( procId == iProcessId )

        {

	    Lock();

        TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - START - this: 0x%08x, iProcess: 0x%08x (%O)", this, iProcess, iProcess ) );

        // Mark all tracked chunks as dirty whilst we work out

        // what is and isn't mapped into the process

        SetTrackedListUnused();

        SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkGlobalData, EFalse /* global data chunks are still in use */ );

        // Locate any suitable chunks, tagging existing entries as

        // 'in use' so that we can easily spot ones which are no longer

        // mapped into the process.

        FindChunks( *iProcess );

        // Throw away and tracked chunks which aren't mapped into the 

        // process anymore.

        DiscardUnusedTrackListItems();

        // Calculate latest statistics...

        const TBool changeDetected = UpdateStatistics();

        if  ( changeDetected )

            {

            // Inform observer about new results.

            CompleteClientsRequest( KErrNone, &iInfoCurrent );

            }

        TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - END - this: 0x%08x", this ) );

        Unlock();

        }

    }

void DMemSpyInspectedProcess::EMHandleProcessRemoved( DProcess& aProcess )

    {

    DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();

    const TUint pid = dProcessAdaption.GetId( aProcess );

    if  ( pid == iProcessId )

        {

	    Lock();

        TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessRemoved() - START - this: 0x%08x", this ) );

        // We will implement a multi phased approach to the process being removed.

        //

        // The first notification we will send will show that the process heap and

        // local chunks have been removed, leaving shared chunk sizes intact.

        //

        // We will then send another change, this time setting everything to zero...

        SetTrackedListUnused();

        SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkShared, EFalse /* shared chunks are still in use */ );

        SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkGlobalData, EFalse /* global data chunks are still in use */ );

        DiscardUnusedTrackListItems();

        const TBool changeDetected1 = UpdateStatistics();

        if  ( changeDetected1 )

            {

            // Inform observer about new results.

            CompleteClientsRequest( KErrNone, &iInfoCurrent );

            }

        // Now repeat the exercise, this time removing everything.

        ResetTrackedList();

        // ... including stack

        iInfoCurrent.iMemoryStack = 0;

        const TBool changeDetected2 = UpdateStatistics();

        if  ( changeDetected2 )

            {

            // Inform observer about new results.

            CompleteClientsRequest( KErrNone, &iInfoCurrent );

            }

        // Stop listening to events since we've drained everything now...

        iAmDead = ETrue;