/*

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

*

*/

#include "analyzetoolmainallocator.h"

#include "atlog.h"

#include "analyzetooleventhandler.h"

#include "analyzetoolmemoryallocator.h"

#include "analyzetoolpanics.pan"

#include "analyzetoolfastlog.h"

#include <e32svr.h>

// CONSTANTS

// The name of the memoryhook dll

_LIT8( KMemoryHook, "AToolMemoryHook.dll" );

// Length of the callstack address

const TUint32 KAddressLength = 4;

// Thread count

const TInt KThreadCount = 1;

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

// RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator()

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

// might leave.

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

//

RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator( TBool aNotFirst, 

    RAnalyzeToolMemoryAllocator( aNotFirst ),

    iAnalyzeToolOpen( EFalse ),

    iDeviceDriverLoaded( EFalse ),

    iCodeblocks( KATMaxCallstackLength ),

    iThreadArray( KATMaxCallstackLength ),

    iLogOption( aLogOption ),

    iProcessId( RProcess().Id().operator TUint() ),

    iAllocMaxCallStack( aAllocCallStackSize ),

    iFreeMaxCallStack( aFreeCallStackSize )

    {

    LOGSTR1( "ATMH RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator()" );

    // Basic error variable used in method.

    TInt error( KErrNone );

    // Create mutex for schedule access to shared resources

    error = iMutex.CreateLocal();

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

    LOGSTR2( "ATMH Creating mutex error %i", error );

    // Load the kernel side device driver

    error = User::LoadLogicalDevice( KAnalyzeToolLddName );

    if ( error != KErrNone && error != KErrAlreadyExists )

        {

        __ASSERT_ALWAYS( EFalse, AssertPanic( ECantLoadDeviceDriver ) );

        }

    else

        {

        iDeviceDriverLoaded = ETrue;

        }

    LOGSTR2( "ATMH Loading device driver error %i", error );

    // Open handle to the kernel sidedevice driver

    error = iAnalyzeTool.Open();

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

    if ( KErrNone == error )

        {

        iAnalyzeToolOpen = ETrue;

        }

    LOGSTR2( "ATMH Opening RAnalyzeTool handle %i error", error );

    // Set memory model by asking kernel side device driver

    if ( iAnalyzeToolOpen )

        {

        TATMemoryModelBuf model;

        if ( KErrNone == iAnalyzeTool.GetMemoryModel( model ) )

            {

            iMemoryModel = model().iMemoryModel;

            LOGSTR2( "ATMH AnalyzeTool MemoryModel: %i", iMemoryModel );

            }

        else

            LOGSTR2( "ATMH AnalyzeTool GetMemoryModel error: %i", error );

        }

    // Retrieve the initial process information

    // Create handler for receiving kernel events

    iEventHandler = new CLibraryEventHandler( iAnalyzeTool,

                                              iCodeblocks,

                                              iProcessId,

                                              iMutex, 

                                              *this,

    __ASSERT_ALWAYS( iEventHandler != NULL, AssertPanic( ENoMemory ) );

    }

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

// RAnalyzeToolMainAllocator::~RAnalyzeToolMainAllocator()

// Destructor.

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

//

RAnalyzeToolMainAllocator::~RAnalyzeToolMainAllocator()

    {

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

    TUint handleLeakCount( 0 );

    if ( iAnalyzeToolOpen && iThreadArray.Count() > 0 )

        {

        TProcessHandleInfoBuf params;

        params().iProcessId = iProcessId;

        TInt error( iAnalyzeTool.GetProcessHandleInfo( params ) );

        handleLeakCount = params().iThreadHandleCount;

        }

    // Close handle for process memory blocks

    iCodeblocks.Close();

    // Delete the eventhandler

    delete iEventHandler;

    // The count of device driver users

    TClientCountBuf count;

    // Check the flag

    if ( iAnalyzeToolOpen )

        {

        TInt error  = iAnalyzeTool.ClientCount( count );

        LOGSTR2( "ATMH closing analyze tool handle error: %i", error );

        iAnalyzeTool.Close();

        }

    // Check the flag

    if ( iDeviceDriverLoaded )

        {

        LOGSTR2( "ATMH device driver client count: %i", count().iClientCount );

        // Check if there is another user for device driver

        if ( count().iClientCount <= 1 )

            {

            // There was no other users -> unload the device driver

            TInt error = User::FreeLogicalDevice( KAnalyzeToolLddName );

            LOGSTR2( "ATMH Unloading ldd error: %i", error );

            }

        }

    // Close the thread array

    iThreadArray.Close();

        {

        }

    // Close the mutex

    iMutex.Close();

    }

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

// RAnalyzeToolMainAllocator::ShareHeap()

// Share heap with other thread

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

//

void RAnalyzeToolMainAllocator::ShareHeap()

    {

    LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ShareHeap()" );

    // Call the overwrited Open function

    Open();

    }

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

// RAnalyzeToolMainAllocator::Uninstall()

// Uninstalls the current allocator

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

//

void RAnalyzeToolMainAllocator::Uninstall()

    {

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

    // Acquire the mutex

    iMutex.Wait();

    TMainThreadParamsBuf params;

    params().iProcessId = iProcessId;

    iAnalyzeTool.MainThreadAlloctor( params );

    // Release the mutex

    iMutex.Signal();

    // Check if this is shared allocator between threads

    if ( iThreadArray.Count() > KThreadCount && !params().iAlone )

        {

        // Close the shared allocator

        Close();

        LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Uninstall() - Close called" );

        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__

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

// RAnalyzeToolMainAllocator::Alloc() WINS version

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

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

//

UEXPORT_C TAny* RAnalyzeToolMainAllocator::Alloc( TInt aSize )

    {

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

    // Acquire the mutex

    iMutex.Wait();

    // Alloc memory from the original allocator

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

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

            aSize,  (TUint32) p );

    // Release the mutex

    iMutex.Signal();

    return p;

    }

#else

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

// RAnalyzeToolMainAllocator::Alloc() ARMV5 version

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

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

//

TAny* RAnalyzeToolMainAllocator::Alloc( TInt aSize )

    {

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

    // acquire the mutex

    iMutex.Wait();

    // Alloc memory from the original allocator

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

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

            aSize,  (TUint32) p );

    // Release the mutex

    iMutex.Signal();

    // Return the allocatated memory

    return p;

    }

#endif // __WINS__

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

// RAnalyzeToolMainAllocator::Free()

// Frees the allocated memory

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

//

void RAnalyzeToolMainAllocator::Free( TAny* aPtr )

    {

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

    // Acquire the mutex

    iMutex.Wait();