/*

* 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/driver/memspydriverclient.h>

// System includes

#include <e32svr.h>

// User includes

#include "MemSpyDriverOpCodes.h"

#include <memspy/driver/memspydriverconstants.h>

#include <memspy/driver/memspydriverobjectsshared.h>

#include "MemSpyDriverStreamReaderImp.h"

#include "MemSpyDriverObjectsInternal.h"

// Constants

const TInt KMemSpyClientBufferGrowSize = 0x1000 * 8; // 32kb

// Forward declarations

static void PrintHeapInfo( const TMemSpyHeapInfo& aInfo );

EXPORT_C TInt RMemSpyDriverClient::Open()

	{

    TInt err = iBuffer.Create( KMemSpyClientBufferGrowSize );

    if  ( err == KErrNone )

        {

        err = User::LoadLogicalDevice( KMemSpyDriverDeviceName );

        if  ( err == KErrNone || err == KErrAlreadyExists )

		    {

		    err = DoCreate( KMemSpyDriverDeviceName, KMemSpyDriverVersion(), KNullUnit, NULL, NULL, EOwnerThread );

            if  ( err == KErrNone )

                {

                TUint heapVTable = RHeapVTable();

 	            err = DoControl( EMemSpyDriverOpCodeMiscSetRHeapVTable, (TAny*) heapVTable );

                }

		    }

        }

    //

    if ( err != KErrNone )

        {

        RDebug::Printf( "[MemSpy] RMemSpyDriverClient::Open() - END - err: %d", err );

        }

    //

	return err;

	}

EXPORT_C void RMemSpyDriverClient::Close()

	{

    RBusLogicalChannel::Close();

    const TInt err = User::FreeLogicalDevice( KMemSpyDriverDeviceName );

    //

    if ( err != KErrNone )

        {

        RDebug::Printf( "[MemSpy] RMemSpyDriverClient::Close() - free logical device error: %d", err );

        }

    //

    iBuffer.Close();

    (void) err;

	}

EXPORT_C void RMemSpyDriverClient::GetVersion( TVersion& aVersion )

    {

    TVersion v = KMemSpyDriverVersion();

    Mem::Copy( (TAny*)&aVersion, (TAny*)&v, sizeof( TVersion ) );

    }

EXPORT_C TInt RMemSpyDriverClient::ReadMemory( TUint aTid, TLinAddr aSrc, TDes8& aDest )

	{

	TMemSpyDriverInternalReadMemParams params;

	params.iTid = aTid;

	params.iAddr = aSrc;

	params.iDes = &aDest;

    aDest.Zero();

    //

	TInt r = DoControl( EMemSpyDriverOpCodeRawMemoryRead, &params, NULL );

    if  ( r >= KErrNone )

        {

        aDest.SetLength( r );

        r = KErrNone;

        }

    //

    return r;

    }

EXPORT_C TInt RMemSpyDriverClient::GetCodeSegs( TAny** aHandleArray, TInt& aHandleCount, TBool aOnlyRamLoaded )

    {

	TMemSpyDriverInternalCodeSnapshotParams params;

	params.iFilter = aOnlyRamLoaded;

	params.iHandles = aHandleArray;

	params.iCountPtr = &aHandleCount;

	params.iMaxCount = aHandleCount;

    //

    aHandleCount = 0;

    //

	return DoControl( EMemSpyDriverOpCodeCodeSegsGetAll, &params, NULL );

    }

EXPORT_C TInt RMemSpyDriverClient::GetCodeSegs( TUint aPid, TAny** aHandleArray, TInt& aHandleCount )

	{

	TMemSpyDriverInternalCodeSnapshotParams params;

	params.iFilter = aPid;

	params.iHandles = aHandleArray;

	params.iCountPtr = &aHandleCount;

	params.iMaxCount = aHandleCount;

    //

    aHandleCount = 0;

    //

	return DoControl( EMemSpyDriverOpCodeCodeSegsGetCodeSegsForProcess, &params, NULL );

	}

EXPORT_C TInt RMemSpyDriverClient::GetCodeSegInfo( TAny* aHandle, TUint aPid, TMemSpyDriverCodeSegInfo& aInfo )

	{

	TMemSpyDriverInternalCodeSegParams params;

	params.iPid = aPid;

	params.iHandle = aHandle;

	params.iInfoPointer = &aInfo;

    //

	const TInt r = DoControl( EMemSpyDriverOpCodeCodeSegsGetCodeSegInfo, &params, NULL );

	return r;

	}

EXPORT_C TInt RMemSpyDriverClient::GetChunkHandles( TAny** aHandleArray, TInt& aHandleCount )

    {

	TMemSpyDriverInternalChunkHandleParams params;

	params.iId = 0;

	params.iType = EMemSpyDriverPrivateObjectTypeAll;

	params.iHandles = aHandleArray;

	params.iCountPtr = &aHandleCount;

    params.iMaxCount = aHandleCount;

    //

    aHandleCount = 0;

	//

	const TInt err = DoControl( EMemSpyDriverOpCodeChunkGetHandles, &params, NULL );

    return err;

    }

EXPORT_C TInt RMemSpyDriverClient::GetChunkInfo( TAny* aHandle, TMemSpyDriverChunkInfo& aInfo )

    {

	TMemSpyDriverInternalChunkInfoParams params;

	TBuf8<KMaxFullName> name;

	params.iHandle = aHandle;

	const TInt r = DoControl( EMemSpyDriverOpCodeChunkGetInfo, &params, NULL );

	//

	if  ( r == KErrNone )

		{

        aInfo.iHandle = aHandle;

		aInfo.iBaseAddress = params.iBaseAddress;

		aInfo.iSize = params.iSize;

		aInfo.iMaxSize = params.iMaxSize;

		aInfo.iOwnerId = params.iOwnerId;

        aInfo.iType = params.iType;

        aInfo.iAttributes = params.iAttributes;

		aInfo.iName.Copy( params.iName );

		}

	//

	return r;

    }

EXPORT_C TInt RMemSpyDriverClient::GetChunkInfo( TAny* aHandle, TMemSpyDriverChunkInfoWithoutName& aInfo )

    {

    TMemSpyDriverChunkInfo info;

    //

    const TInt r = GetChunkInfo( aHandle, info );

    if  ( r == KErrNone )

        {

        aInfo = info;

        }

    //

    return r;

    }

EXPORT_C TInt RMemSpyDriverClient::GetChunkHandlesForProcess( TUint aPid, TAny** aHandleArray, TInt& aHandleCount )

    {

	TMemSpyDriverInternalChunkHandleParams params;

	params.iId = aPid;

	params.iType = EMemSpyDriverPrivateObjectTypeProcess;

	params.iHandles = aHandleArray;

	params.iCountPtr = &aHandleCount;

	params.iMaxCount = aHandleCount;

	//

    aHandleCount = 0;

    //

	return DoControl( EMemSpyDriverOpCodeChunkGetHandles, &params, NULL );

    }

EXPORT_C TInt RMemSpyDriverClient::GetChunkHandlesForThread( TUint aTid, TAny** aHandleArray, TInt& aHandleCount )

    {

	TMemSpyDriverInternalChunkHandleParams params;

	params.iId = aTid;

	params.iType = EMemSpyDriverPrivateObjectTypeThread;

	params.iHandles = aHandleArray;

	params.iCountPtr = &aHandleCount;

	params.iMaxCount = aHandleCount;

	//

    aHandleCount = 0;

    //

	return DoControl( EMemSpyDriverOpCodeChunkGetHandles, &params, NULL );

    }

EXPORT_C TInt RMemSpyDriverClient::GetThreadInfo( TUint aTid, TMemSpyDriverThreadInfo& aInfo )

	{

	TMemSpyDriverInternalThreadInfoParams params;

    params.iRHeapVTable = RHeapVTable();

    params.iDebugAllocator = DebugEUser();

    //

	TInt r = DoControl( EMemSpyDriverOpCodeThreadAndProcessGetInfoThread, (TAny*)aTid, &params);

	//

	if  ( r == KErrNone )

		{

        // Copy common properties

        Mem::Copy( &aInfo, &params, sizeof( TMemSpyDriverThreadInfoBase ) );

        // Copy name

        aInfo.iFullName.Copy( params.iFullName );

        // Get other basic properties via RThread

        RThread thread;

        r = OpenThread( aTid, thread );

        if ( r == KErrNone )

            {

            RProcess process;

            r = thread.Process( process );

            if ( r == KErrNone )

                {

	            aInfo.iPid = process.Id();

                process.Close();

                }

            aInfo.iThreadPriority = thread.Priority();

            aInfo.iExitReason = thread.ExitReason();

            aInfo.iExitType = thread.ExitType();

            aInfo.iExitCategory = thread.ExitCategory();

            thread.Close();

            }

        }

    return r;

	}

EXPORT_C TInt RMemSpyDriverClient::GetProcessInfo( TUint aPid, TMemSpyDriverProcessInfo& aInfo )

    {

	TInt r = DoControl( EMemSpyDriverOpCodeThreadAndProcessGetInfoProcess, (TAny*)aPid, &aInfo);

    // Get other properties via RProcess.

    if  ( r == KErrNone )

        {

        RProcess process;

        r = OpenProcess( aPid, process );

        if  ( r == KErrNone )

            {

            aInfo.iUids = process.Type();

            aInfo.iPriority = process.Priority();

            //

            process.Close();

            }

        }

    return r;

    }

EXPORT_C TInt RMemSpyDriverClient::ProcessThreadsSuspend( TUint aPid )

    {

	return DoControl( EMemSpyDriverOpCodeThreadAndProcessSuspendAllThreads, (TAny*) aPid, NULL );

    }

EXPORT_C TInt RMemSpyDriverClient::ProcessThreadsResume( TUint aPid )

    {

	return DoControl( EMemSpyDriverOpCodeThreadAndProcessResumeAllThreads, (TAny*) aPid, NULL );

    }

EXPORT_C TInt RMemSpyDriverClient::ThreadEnd( TUint aId, TExitType aType )

    {

    TInt err = KErrNone;

    //

    if  ( aType == EExitPending )

        {

        err = KErrArgument;

        }

    else

        {

        err = DoControl( EMemSpyDriverOpCodeThreadAndProcessEndThread, (TAny*) aId, (TAny*) aType );

        }

    //

    return err;

    }

EXPORT_C TInt RMemSpyDriverClient::OpenThread( TUint aId, RThread& aThread )

    {

    TInt ret = KErrNone;

    aThread.Close();

    //

    const TInt err = DoControl( EMemSpyDriverOpCodeThreadAndProcessOpenThread, (TAny*) aId );

    if  ( err > 0 )

        {

        aThread.SetHandle( err );

        ret = KErrNone;

        }

    else

        {

        ret = err;

        }

    //

    return ret;

    }

EXPORT_C TInt RMemSpyDriverClient::OpenProcess( TUint aId, RProcess& aProcess )

    {

    TInt ret = KErrNone;

    aProcess.Close();

    //

    const TInt err = DoControl( EMemSpyDriverOpCodeThreadAndProcessOpenProcess, (TAny*) aId );

    if  ( err > 0 )

        {

        aProcess.SetHandle( err );

        ret = KErrNone;

        }

    else

        {

        ret = err;

        }

    //

    return ret;

    }

EXPORT_C void RMemSpyDriverClient::GetThreadsL( const TProcessId& aId, RArray<TThreadId>& aThreads )

    {

	aThreads.Reset();

    //

    ResetStreamBuffer();

    const TInt err = DoControl( EMemSpyDriverOpCodeThreadAndProcessGetThreads, (TAny*) (TUint) aId, (TAny*) &iBuffer );

    User::LeaveIfError( err );

    // Open stream

    RMemSpyMemStreamReader stream = StreamOpenL();

    CleanupClosePushL( stream );

    // Extract thread ids

    const TInt threadCount = stream.ReadInt32L();

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

        {

        const TThreadId id( stream.ReadUint32L() );

        aThreads.AppendL( id );

        }

    // Tidy up

    CleanupStack::PopAndDestroy( &stream );

    }

EXPORT_C TInt RMemSpyDriverClient::SetPriority( TUint aId, TThreadPriority aPriority )

    {

    // The kernel side API to set thread priority expects a value in the range of 0-63, i.e. an absolute

    // NThread priority. In order to support process-relative thread priorities, we'd need to duplicate

    // the kernel priority mapping tables - not a good idea - therefore we'll only support absolute values.

    TInt err = KErrNone;

    if  ( aPriority < EPriorityAbsoluteVeryLow )

        {

        err = KErrArgument;

        }

    else

        {

        err = DoControl( EMemSpyDriverOpCodeThreadAndProcessSetPriorityThread, (TAny*) aId, (TAny*) aPriority );

        }

    //

    return err;

    }

EXPORT_C TInt RMemSpyDriverClient::GetHeapInfoUser( TMemSpyHeapInfo& aInfo, TUint aTid )

    {

    TMemSpyDriverInternalHeapRequestParameters params;

    //

    params.iTid = aTid;

    params.iRHeapVTable = RHeapVTable();

    params.iDebugAllocator = DebugEUser();

    params.iMasterInfo = &aInfo;

    //

	TInt r = DoControl( EMemSpyDriverOpCodeHeapInfoGetUser, &params, NULL );

	//

	if  ( r == KErrNone )

    	{

        PrintHeapInfo( aInfo );

        // Need to do this on the user-side

        if  ( aInfo.Type() == TMemSpyHeapInfo::ETypeRHeap )

            {

            TMemSpyHeapInfoRHeap& rHeapInfo = aInfo.AsRHeap();

            TMemSpyHeapMetaDataRHeap& metaData = rHeapInfo.MetaData();

            metaData.SetVTable( RHeapVTable() );

            }

        }

    else if ( r == KErrNotSupported )

        {

        aInfo.SetType( TMemSpyHeapInfo::ETypeUnknown );

        r = KErrNone;

        }

	//

	return r;

    }