/*

* 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:  Definitions for the class RAnalyzeToolAllocator.

*

*/

#include "analyzetoolallocator.h"

#include "analyzetoolmemoryallocator.h"

#include "atlog.h"

#include "analyzetoolpanics.pan"

#include "analyzetoolfastlog.h"

#include <e32svr.h>

// CONSTANTS

// Length of the callstack address

const TUint32 KAddressLength = 4;

// Thread count

const TInt KThreadCount = 1;

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::RAnalyzeToolAllocator()

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

RAnalyzeToolAllocator::RAnalyzeToolAllocator( TBool aNotFirst,

                                              RArray<TCodeblock>& aCodeblocks, 

                                              RMutex& aMutex,

                                              TUint aProcessId,

                                              RAnalyzeTool& aAnalyzeTool,

                                              TUint32 aLogOption,

                                              TUint32 aAllocCallStackSize,

                                              TUint32 aFreeCallStackSize,

                                              RATFileLog& aLogFile ) :

    RAnalyzeToolMemoryAllocator( aNotFirst ),

    iCodeblocks( aCodeblocks ), 

    iMutex( aMutex ),

    iProcessId( aProcessId ),

    iThreadArray( KATMaxCallstackLength ),

    iAnalyzeTool( aAnalyzeTool ),

    iLogOption( aLogOption ),

    iAllocMaxCallStack( aAllocCallStackSize ),

    iFreeMaxCallStack( aFreeCallStackSize ),

    iLogFile ( aLogFile )

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::RAnalyzeToolAllocator()" );

    // Append thread to array of the users of this allocator

    TThreadParamsBuf params;

    params().iThreadId = RThread().Id().operator TUint();

    TInt error = iAnalyzeTool.ThreadStack( params );

    if ( KErrNone == error )

        {

        LOGSTR2( "ATMH Thread stack address: %x", params().iStackAddress );

        LOGSTR2( "ATMH Thread stack size:    %x", params().iStackSize );

        error = iThreadArray.Append( TThreadStack( RThread().Id(), 

                             params().iStackAddress + params().iStackSize ) );

        if ( iLogOption == EATLogToTraceFast )

        	{

            // log thread added

            ATFastLogThreadStarted( aProcessId, RThread().Id().operator TUint() ); 

        	}

        else if ( iLogOption == EATLogToFile )

        	{

            iLogFile.ATFileLogThreadStarted( RThread().Id().operator TUint() );

        	}

        }

    __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) ); 

    }

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::~RAnalyzeToolAllocator()

// Destructor.

// -----------------------------------------------------------------------------

//

RAnalyzeToolAllocator::~RAnalyzeToolAllocator()

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::~RAnalyzeToolAllocator()" );

    for( TInt i=0; i<iThreadArray.Count(); i++)

    	{

        // log thread removed

        if ( iLogOption == EATLogToTraceFast )

        	{

            ATFastLogThreadEnded( RProcess().Id().operator TUint(), RThread().Id().operator TUint() ); 

            }

        else if ( iLogOption == EATLogToFile )

        	{

            iLogFile.ATFileLogThreadEnded( RThread().Id().operator TUint() );

        	}

         }

    // Close the thread array 

    iThreadArray.Close();

    }

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Uninstall()

// Uninstalls the current allocator

// -----------------------------------------------------------------------------

//

void RAnalyzeToolAllocator::Uninstall()

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Uninstall()" );

    // Switch back to the original allocator

    SwitchOriginalAllocator();

    // Check if this is shared allocator between threads

    if ( iThreadArray.Count() > KThreadCount )

        {

        // Close the shared allocator

        Close();

        return;

        }

#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 )

    #ifndef __WINS__ 

    // Remove dummy Tls handle

    UserSvr::DllFreeTls( KDummyHandle );

    #endif

#endif

    // Since this is the last thread using this allocator it can be deleted

    delete this;

    }

#ifdef __WINS__

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Alloc() WINS version

// Allocates a cell of specified size from the heap.

// -----------------------------------------------------------------------------

//

UEXPORT_C TAny* RAnalyzeToolAllocator::Alloc( TInt aSize )

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc()" );

    // Acquire the mutex

    iMutex.Wait();

    // get thread ID

    TUint threadId = RThread().Id();

    // Alloc memory from the original allocator

    TAny* p = iAllocator->Alloc( aSize );

    LOGSTR3( "ATMH RAnalyzeToolAllocator::Alloc() - aSize: %i, address: %x", 

             aSize,  (TUint32) p );

	// Reset the callstack

	iCallStack.Reset();

	// Find the current thread callstack start address

	TUint32 stackstart( 0 );

	TBool found( FindCurrentThreadStack( stackstart ) );

	LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );

	TUint32 _sp;

	__asm

		{

		mov [_sp], esp

		}

	// Get codeblocks count

	TInt blocksCount( iCodeblocks.Count() );

	TInt error( KErrNone );

	TUint arrayCounter = 0;

	for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348

		{

		TUint32 addr = (TUint32) *( (TUint32*) i );

		if ( ! IsAddressLoadedCode( addr ) )

			continue;

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

			{

			if ( iCodeblocks[j].CheckAddress( addr ) )

				{

				// To avoid recursive call to ReAlloc specifying granularity

				// Add address to the callstack

				iCallStack[arrayCounter] = ( addr );

				arrayCounter++;

				break;

				}

			}

		if ( arrayCounter == KATMaxCallstackLength ||

			 arrayCounter == iAllocMaxCallStack )

			{

			LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );

			break;

			}

		}

	// Log the memory allocation information

	if ( iLogOption == EATLogToTraceFast )

		{

		// Using fast mode.

		ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize, threadId );

		}

	else if ( iLogOption == EATLogToFile )

		{

		iLogFile.ATFileLogMemoryAllocated( (TUint32) p, iCallStack, aSize, threadId );

		}

    // Release the mutex

    iMutex.Signal();

    return p;

    }

#else

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Alloc() ARMV5 version

// Allocates a cell of specified size from the heap.

// -----------------------------------------------------------------------------

//

TAny* RAnalyzeToolAllocator::Alloc( TInt aSize )

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc()" );

    // Acquire the mutex

    iMutex.Wait();

    // get thread ID

    TUint threadId = RThread().Id();

    // Alloc memory from the original allocator

    TAny* p = iAllocator->Alloc( aSize );

	// Reset the callstack

	iCallStack.Reset(); 

	// Find the current thread callstack start address

	TUint32 stackstart( 0 );

	TBool found( FindCurrentThreadStack( stackstart ) );

	LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );

	// Get codeblocks count

	TInt blocksCount( iCodeblocks.Count() );

	TUint arrayCounter = 0;

	for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348

		{

		TUint32 addr = (TUint32) *( (TUint32*) i );

		if ( ! IsAddressLoadedCode( addr ) )

			continue;

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

			{

			if ( iCodeblocks[j].CheckAddress( addr ) )

				{

				// To avoid recursive call to ReAlloc specifying granularity

				// Add address to the callstack

				iCallStack[arrayCounter] = ( addr );

				arrayCounter++;

				break;

				}

			}

		if ( arrayCounter == KATMaxCallstackLength ||

			 arrayCounter == iAllocMaxCallStack )

			{

			LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );

			break;

			}

		}

	// Log the memory allocation information

	if ( iLogOption == EATLogToTraceFast )

		{

		// Fast mode.

		ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize, threadId );

		} 

	else if ( iLogOption == EATLogToFile )

		{

	    iLogFile.ATFileLogMemoryAllocated( (TUint32) p, iCallStack, aSize, threadId );

		}

    // Release the mutex

    iMutex.Signal(); 

    // Return the allocatated memory

    return p;

    }

#endif // __WINS__

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Free()

// Frees the allocated memory

// -----------------------------------------------------------------------------

//

TAny RAnalyzeToolAllocator::Free( TAny* aPtr )

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Free()" );

    // Acquire the mutex

    iMutex.Wait();

    // get thread ID

    TUint threadId = RThread().Id();

	// Reset the callstack

	iFreeCallStack.Reset();

	if ( iFreeMaxCallStack > 0 )

		{

		// Find the current thread callstack start address

		TUint32 stackstart( 0 );

		TBool found( FindCurrentThreadStack( stackstart ) );

		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );

		TUint32 _sp;

		#ifdef __WINS__

			__asm

				{

				mov [_sp], esp

				}

		#else

			_sp = __current_sp();

		#endif

		// Get codeblocks count

		TInt blocksCount( iCodeblocks.Count() );

		TUint arrayCounter = 0;

		for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348

			{

			TUint32 addr = (TUint32) *( (TUint32*) i );

			if ( ! IsAddressLoadedCode( addr ) )

				continue;

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

				{

				if ( iCodeblocks[j].CheckAddress( addr ) )

					{

					// To avoid recursive call to ReAlloc specifying granularity

					// Add address to the callstack

					iFreeCallStack[arrayCounter] = addr;

					arrayCounter++;

					break;

					}

				}

			if ( arrayCounter == KATMaxFreeCallstackLength ||

				 arrayCounter == iFreeMaxCallStack )

				{

				break;

				}

			}

		LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter );

		}

	// Log freed memory.

	if ( iLogOption == EATLogToTraceFast )

		{

		// Using fast mode.

		ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack, threadId );

		} 

	else if ( iLogOption == EATLogToFile )

		{

		iLogFile.ATFileLogMemoryFreed( (TUint32) aPtr, iFreeCallStack, threadId );

		}

    // Free the memory using original allocator

    iAllocator->Free( aPtr ); 

    LOGSTR2( "ATMH RAnalyzeToolAllocator::Free() - aPtr: %x", (TUint32)aPtr );

    // Release the mutex

    iMutex.Signal();

    }

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Open()

// Opens this heap for shared access. Opening the heap increases 

// the heap's access count by one.

// -----------------------------------------------------------------------------

//

TInt RAnalyzeToolAllocator::Open()

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Open()");

    // Acquire the mutex

    iMutex.Wait();

    // Share the memory using original allocator

    TInt error = iAllocator->Open();

    // If everything is OK add thread to the array which use this allocator

    if ( KErrNone == error )

        {

        TThreadParamsBuf params;

        params().iThreadId = RThread().Id().operator TUint();

        error = iAnalyzeTool.ThreadStack( params );

        __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) );

        if ( KErrNone == error )

            {

            LOGSTR2( "ATMH Thread stack address: %x", params().iStackAddress );

            LOGSTR2( "ATMH Thread stack size:    %x", params().iStackSize );

            iThreadArray.Append( TThreadStack( RThread().Id(), 

                    params().iStackAddress + params().iStackSize ) );

            if ( iLogOption == EATLogToTraceFast )

            	{

                // log thread added

                ATFastLogThreadStarted( RProcess().Id().operator TUint(), RThread().Id().operator TUint()); 

            	}

            else if ( iLogOption == EATLogToFile )

				{

				iLogFile.ATFileLogThreadStarted( RThread().Id().operator TUint() );

				}

            }

        }

    // Release the mutex

    iMutex.Signal();

    // Return the error code

    return error;

    }

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::Close()

// Closes this shared heap. Closing the heap decreases the heap's 

// access count by one.

// -----------------------------------------------------------------------------

//

void RAnalyzeToolAllocator::Close()

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::Close()" );

    // Acquire the mutex

    iMutex.Wait();

    // Close the memory using original allocator

    iAllocator->Close();

    TInt count = iThreadArray.Count();

    // Iterate through array of threads to remove current thread

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

        {

        // Check if this is current thread

        if ( iThreadArray[ i ].Match() )

            {

            // Remove the thread

            iThreadArray.Remove( i );

            if ( iLogOption == EATLogToTraceFast )

            	{

                // log thread removed

                ATFastLogThreadEnded( RProcess().Id().operator TUint(), RThread().Id().operator TUint() ); 

            	}

            else if ( iLogOption == EATLogToFile )

				{

				iLogFile.ATFileLogThreadEnded( RThread().Id().operator TUint() );

				}

            break;

            }

        }

    // Release the mutex

    iMutex.Signal();

    }

#ifdef __WINS__

// -----------------------------------------------------------------------------

// RAnalyzeToolAllocator::ReAlloc()

// Increases or decreases the size of an existing cell.

// -----------------------------------------------------------------------------

//

TAny* RAnalyzeToolAllocator::ReAlloc( TAny* aPtr, TInt aSize, TInt aMode )

    {

    LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc()" );

    // Acquire the mutex

    iMutex.Wait();

    // get thread ID

    TUint threadId = RThread().Id();

    // Realloc the memory using original allocator

    TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode );

    // NULL addresses are not in a process under test

    if ( ptr && !( aMode & ENeverMove ) )

        {

        LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aPtr: %x, ptr: %x", 

                (TUint32)aPtr, (TUint32)ptr );

        LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aSize: %i, aMode: %i", 

                aSize, aMode );

		// Reset the callstack

		iReCallStack.Reset(); 

		// Find the current thread callstack start address

		TUint32 stackstart( 0 ); 

		TBool found( FindCurrentThreadStack( stackstart ) );

		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );

		// Get current sp

		TUint32 _sp( 0 );

		__asm

			{

			mov [_sp], esp

			}

		// Get codeblocks count

		TInt blocksCount( iCodeblocks.Count() );

		TInt error( KErrNone );

		TUint arrayCounter = 0;

		for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348

			{