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

// System includes
#include <memspy/driver/memspydriverenumerationsshared.h>

// User includes
#include "MemSpyDriverUtils.h"
#include "MemSpyDriverDevice.h"
#include "MemSpyDriverOSAdaption.h"
#include "MemSpyDriverEventMonitor.h"

// Literal constants
_LIT( KMemSpyDriverClientEMMutexName, "MemSpyDriverClientEM_0x" );




DMemSpyDriverClientEMManager::DMemSpyDriverClientEMManager( DMemSpyDriverDevice& aDevice )
:   iDevice( aDevice )
    {
    }


DMemSpyDriverClientEMManager::~DMemSpyDriverClientEMManager()
	{
	TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::~DMemSpyDriverClientEMManager() - START"));

    NKern::ThreadEnterCS();
    FreeAllInstances();
    NKern::ThreadLeaveCS();

	TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::~DMemSpyDriverClientEMManager() - END"));
	}


TInt DMemSpyDriverClientEMManager::Create()
    {
    return KErrNone;
    }


DMemSpyDriverClientEM* DMemSpyDriverClientEMManager::EMOpen()
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMOpen() - START - iNextHandle: %d, iDevice: 0x%08x", iNextHandle+1, &iDevice ) );
    NKern::ThreadEnterCS();
    //
    DMemSpyDriverClientEM* object = new DMemSpyDriverClientEM( iDevice, ++iNextHandle );
    if  ( object != NULL )
        {
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMOpen() - calling create..." ) );
        const TInt error = object->Create();
        if ( error != KErrNone )
            {
            TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMOpen() - creation error: %d", error ) );
            delete object;
            object = NULL;
            }
        else
            {
            iEMInstances.Add( &object->iLink );
            }
        }
    //
    NKern::ThreadLeaveCS();
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMOpen() - END - object: 0x%08x", object ) );
    //
    return object;
    }


TInt DMemSpyDriverClientEMManager::EMClose( TUint aHandle )
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMClose() - START - aHandle: 0x%08x", aHandle ) );
    TInt error = KErrNotFound;
    //
    DMemSpyDriverClientEM* object = EMInstance( aHandle );
    if  ( object != NULL )
        {
        NKern::ThreadEnterCS();
        object->iLink.Deque();
        delete object;
        NKern::ThreadLeaveCS();
        error = KErrNone;
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMClose() - END - error: %d", error ) );
    return error;
    }


DMemSpyDriverClientEM* DMemSpyDriverClientEMManager::EMInstance( TUint aHandle )
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMInstance() - START - aHandle: 0x%08x", aHandle ) );
    DMemSpyDriverClientEM* ret = NULL;
    //
	const SDblQueLink* const anchor = &iEMInstances.iA;
	for (SDblQueLink* link = iEMInstances.First(); link != anchor; link = link->iNext )
		{
		DMemSpyDriverClientEM* object = _LOFF( link, DMemSpyDriverClientEM, iLink );
        //
        if  ( object->Handle() == aHandle )
            {
            ret = object;
            break;
            }
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::EMInstance() - END - aHandle: 0x%08x, ret: 0x%08x", aHandle, ret ) );
    return ret;
    }


void DMemSpyDriverClientEMManager::FreeAllInstances()
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::FreeAllInstances() - START") );
	
    SDblQueLink* link = iEMInstances.GetFirst();
	while( link )
		{
		DMemSpyDriverClientEM* object = _LOFF( link, DMemSpyDriverClientEM, iLink );
        delete object;
        link = iEMInstances.GetFirst();
		}

    TRACE_EM( Kern::Printf("DMemSpyDriverClientEMManager::FreeAllInstances() - END") );
    }





























DMemSpyDriverClientEM::DMemSpyDriverClientEM( DMemSpyDriverDevice& aDevice, TUint aHandle )
:   iDevice( aDevice ), iHandle( aHandle )
    {
    }


DMemSpyDriverClientEM::~DMemSpyDriverClientEM()
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::~DMemSpyDriverClientEM() - START - this: 0x%08x", this ));
	iDevice.EventMonitor().RequestEventsCancel( *this );

    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::~DMemSpyDriverClientEM() - calling NotifyChangesCancel..." ) );
    NotifyChangesCancel();
    
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::~DMemSpyDriverClientEM() - calling ResetPendingChanges..." ) );
    ResetPendingChanges();

	if  ( iLock )
		{
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::~DMemSpyDriverClientEM() - closing mutex..." ) );
		iLock->Close(NULL);
		}

    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::~DMemSpyDriverClientEM() - END - this: 0x%08x" ));
    }


TInt DMemSpyDriverClientEM::Create()
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::Create() - START - handle: 0x%08x", Handle() ) );

    // Create mutex
    TName name( KMemSpyDriverClientEMMutexName );
    name.AppendNumFixedWidth( (TUint) this, EHex, 8 );
    TInt error = Kern::MutexCreate( iLock, name, KMutexOrdNone );
    //
    if  ( error == KErrNone )
        {
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::Create() - calling global device driver event monitor...") );
        iDevice.EventMonitor().RequestEvents( *this );
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::Create() - END - handle: 0x%08x, err: %d", Handle(), error ) );
    return error;
    }


TInt DMemSpyDriverClientEM::NotifyChanges( DThread* aClientThread, TRequestStatus* aClientRS, TAny* aClientContext )
    {
	Kern::MutexWait( *iLock );

    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChanges() - START - handle: 0x%08x", Handle() ) );
    TInt r = KErrInUse;
    //
    if  ( iClientRS == NULL )
        {
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChanges() - saving client's request...") );
        iClientThread = aClientThread;
        iClientRS = aClientRS;
        iClientContext = aClientContext;
        //
        if	( !iPendingChanges.IsEmpty() )
			{
            TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::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.
	        DMemSpyDriverClientEM::TChange* cachedChange = _LOFF( iPendingChanges.First(), DMemSpyDriverClientEM::TChange, iLink );
			cachedChange->iLink.Deque();
			
            // Notify about change			
			CompleteClientsRequest( cachedChange->iCompletionCode, cachedChange->iContext );
			
			// Discard cached entry
            NKern::ThreadEnterCS();
			delete cachedChange;
            NKern::ThreadLeaveCS();
			}
        //
        r = KErrNone;
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChanges() - END - handle: 0x%08x, error: %d", Handle(), r ) );
	Kern::MutexSignal( *iLock );
    return r;
    }


TInt DMemSpyDriverClientEM::NotifyChangesCancel()
    {
	Kern::MutexWait( *iLock );
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChangesCancel() - START - handle: 0x%08x, iClientThread: 0x%08x, iClientRS: 0x%08x", Handle(), iClientThread, iClientRS ) );
    //
    TInt r = KErrNotReady;
    //
    if  ( iClientRS != NULL )
        {
        DThread* clientThread = iClientThread;
        TRequestStatus* clientRS = iClientRS;
        //
        iClientThread = NULL;
        iClientRS = NULL;
        iClientContext = NULL;
        //
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChangesCancel() - doing final request complete...") );
		Kern::RequestComplete( clientThread, clientRS, KErrCancel );
        r = KErrNone;
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::NotifyChangesCancel() - END - handle: 0x%08x, error: %d", Handle(), r ) );
	Kern::MutexSignal( *iLock );
    return r;
    }


TUint DMemSpyDriverClientEM::EMTypeMask() const
    {
    const TUint ret = EMemSpyEventThreadAdd  | EMemSpyEventThreadKill |
                      EMemSpyEventProcessAdd | EMemSpyEventProcessRemove | 
                      EMemSpyEventChunkAdd   | EMemSpyEventChunkDelete;
    return ret;
    }


void DMemSpyDriverClientEM::EMHandleProcessAdd( DProcess& aProcess )
    {
    const TUint pid = iDevice.OSAdaption().DProcess().GetId( aProcess );
    //
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeProcessCreate, pid );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::EMHandleProcessRemoved( DProcess& aProcess )
    {
    const TUint pid = iDevice.OSAdaption().DProcess().GetId( aProcess );
    //
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeProcessRemove, pid );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::EMHandleThreadAdd( DThread& aThread )
    {
    const TUint tid = iDevice.OSAdaption().DThread().GetId( aThread );
    //
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeThreadCreate, tid );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::EMHandleThreadKilled( DThread& aThread )
    {
    const TUint tid = iDevice.OSAdaption().DThread().GetId( aThread );
    //
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeThreadKill, tid );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::EMHandleChunkAdd( DChunk& aChunk ) 
    {
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeChunkAdd, (TUint) &aChunk );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::EMHandleChunkDeleted( DChunk& aChunk )
    {
	Kern::MutexWait( *iLock );
    CompleteClientsRequest( EMemSpyDriverEventTypeChunkDestroy, (TUint) &aChunk );
	Kern::MutexSignal( *iLock );
    }


void DMemSpyDriverClientEM::CompleteClientsRequest( TInt aCompletionCode, TUint aContext )
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - START - handle: 0x%08x, iClientThread: 0x%08x, iClientRS: 0x%08x, iClientContext: 0x%08x, aCompletionCode: %d, aContext: %d, changesPending: %d", Handle(), iClientThread, iClientRS, iClientContext, aCompletionCode, aContext, !iPendingChanges.IsEmpty() ) );
    //
    if  ( iClientRS != NULL )
        {
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - attempting to complete client's request...") );

        // First write context info
        const TInt writeErr = Kern::ThreadRawWrite( iClientThread, iClientContext, &aContext, sizeof(TUint) );
		if  ( writeErr != KErrNone )
		    {
            TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - write error: %d", writeErr ) );
            aCompletionCode = writeErr;
		    }

        // Now complete event - avoiding race conditions!
        DThread* clientThread = iClientThread;
        TRequestStatus* clientRS = iClientRS;
        //
        iClientThread = NULL;
        iClientRS = NULL;
        iClientContext = NULL;
        //
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - doing final request complete...") );
		Kern::RequestComplete( clientThread, clientRS, aCompletionCode );
        }
    else
        {
		// Buffer the change for next time around...
        TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - BUFFERING change event whilst client is AWOL...", this ) );
        NKern::ThreadEnterCS();
        
        DMemSpyDriverClientEM::TChange* cachedChange = new DMemSpyDriverClientEM::TChange( aCompletionCode, aContext );
        if  ( cachedChange )
            {
            iPendingChanges.Add( &cachedChange->iLink );
            }
        //
        NKern::ThreadLeaveCS();
        }
    //
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::CompleteClientsRequest() - END - handle: 0x%08x", Handle() ) );
    }


void DMemSpyDriverClientEM::ResetPendingChanges()
    {
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::ResetPendingChanges() - START - this: 0x%08x", this ) );
    NKern::ThreadEnterCS();
    //
    SDblQueLink* link = iPendingChanges.GetFirst();
	while( link )
		{
        DMemSpyDriverClientEM::TChange* cachedChange = _LOFF( link, DMemSpyDriverClientEM::TChange, iLink );
        delete cachedChange;
        link = iPendingChanges.GetFirst();
		}
    //
    NKern::ThreadLeaveCS();
    TRACE_EM( Kern::Printf("DMemSpyDriverClientEM::ResetPendingChanges() - END - this: 0x%08x", this ) );
    }