/*

* 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, 

                                              RATStorageServer& aStorageServer, 

                                              RArray<TCodeblock>& aCodeblocks, 

                                              RMutex& aMutex,

                                              TUint aProcessId,

                                              RAnalyzeTool& aAnalyzeTool,

                                              TBool aStorageServerOpen,

                                              TUint32 aLogOption,

                                              TUint32 aAllocCallStackSize,

                                              TUint32 aFreeCallStackSize ) :

    RAnalyzeToolMemoryAllocator( aNotFirst ),

    iStorageServer( aStorageServer ), 

    iCodeblocks( aCodeblocks ), 

    iMutex( aMutex ),

    iProcessId( aProcessId ),

    iThreadArray( KATMaxCallstackLength ),

    iAnalyzeTool( aAnalyzeTool ),

    iStorageServerOpen( aStorageServerOpen ),

    iLogOption( aLogOption ),

    iAllocMaxCallStack( aAllocCallStackSize ),

    iFreeMaxCallStack( aFreeCallStackSize )

    {

    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 ) );

        }

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

    }

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

// RAnalyzeToolAllocator::~RAnalyzeToolAllocator()

// Destructor.

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

//

RAnalyzeToolAllocator::~RAnalyzeToolAllocator()

    {

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

    // 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();

    // Alloc memory from the original allocator

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

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

             aSize,  (TUint32) p );

    // Don't collect call stack and log data

    // if storage server not open or logging mode not fast.

    if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )

        {

        // 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 );

            }

        else

            {

            // Using storage server.

            error = iStorageServer.LogMemoryAllocated( (TUint32) p,

                                                       iCallStack,

                                                       aSize );

            if ( KErrNone != error )

                {

                LOGSTR2( "ATMH LogMemoryAllocated error %i", error );

                switch ( error )

                    {

                    case KErrNoMemory:

                    LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case"  );

                    if ( iStorageServerOpen )

                        {

                        iStorageServerOpen = EFalse;

                        LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer"  );

                        iStorageServer.Close();

                        }

                    break;

                    }

                }

            }

        }

    // 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();

    // Alloc memory from the original allocator

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

    // Don't collect call stack and log data

    // if storage server not open or logging mode not fast.

    if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )

        {

        // 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() );

        TInt error( KErrNone );

        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 );

            }

        else

            {

            // Using storage server.

            error = iStorageServer.LogMemoryAllocated( (TUint32) p, 

                                                        iCallStack, 

                                                        aSize );

            if ( KErrNone != error )

                {

                LOGSTR2( "ATMH LogMemoryAllocated error %i", error );

                switch ( error )

                    {

                    case KErrNoMemory:

                    LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc() - KErrNoMemory case"  );

                    if ( iStorageServerOpen )

                        {

                        iStorageServerOpen = EFalse;

                        LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc() - close iStorageServer"  );

                        iStorageServer.Close();

                        }

                    break;

                    }

                }

            }

        }

    // 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();

    // Don't collect or log data if storage server not open or logging mode not fast.

    if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )

        {

        // Reset the callstack

        iFreeCallStack.Reset();

        // Check if trace logging mode because free call stack is not used in other log options.

        if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast )

                && 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 );

            }

        else

            {

            // Using storage server.

            TInt err( iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ) );

            if ( err != KErrNone )

                {

                LOGSTR2( "ATMH > LogMemoryFreed err( %i )", err );

                }

            }

        }

    // 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 ) );

            }

        }

    // 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 );

            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();

    // 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 );

        // Don't collect or log data if storage server not open or logging mode fast.

        if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )

            {

            // 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

                }