/*

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

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

//

                                              RArray<TCodeblock>& aCodeblocks, 

                                              RMutex& aMutex,

                                              TUint aProcessId,

                                              RAnalyzeTool& aAnalyzeTool,

                                              TUint32 aLogOption,

                                              TUint32 aAllocCallStackSize,

    RAnalyzeToolMemoryAllocator( aNotFirst ),

    iCodeblocks( aCodeblocks ), 

    iMutex( aMutex ),

    iProcessId( aProcessId ),

    iThreadArray( KATMaxCallstackLength ),

    iAnalyzeTool( aAnalyzeTool ),

    iLogOption( aLogOption ),

    iAllocMaxCallStack( aAllocCallStackSize ),

    {

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

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

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

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