/*

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

#ifdef __WINSCW__

#include <coemain.h>

#endif

#include <e32svr.h>

// CONSTANTS

// The name of the memoryhook dll

_LIT8( KMemoryHook, "AToolMemoryHook.dll" );

// The name of the storage server dll

_LIT8( KStorageServer, "AToolStorageServerClnt.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, 

    const TFileName aFileName, TUint32 aLogOption, TUint32 aIsDebug,

    TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize ) :

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

    // Connect to the storage server if logging mode not fast xti.

    if ( iLogOption != EATLogToXtiFast )

        {

        error = iStorageServer.Connect();

        LOGSTR2( "ATMH Opening RATStorageServer error %i", error );

        if ( KErrNone == error )

            {

            iStorageServerOpen = ETrue;

            }

        else

            {

            iStorageServerOpen = EFalse;

            }

        if ( KErrNone == error )

            {

            // Make the storage server handle shared between threads

            error = iStorageServer.ShareAuto();

            }

        LOGSTR2( "ATMH Sharing RATStorageServer error %i", error );

        }

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

    LogProcessInformation( aFileName, aLogOption, aIsDebug );

    // Create handler for receiving kernel events

    iEventHandler = new CLibraryEventHandler( iAnalyzeTool,

                                              iCodeblocks,

                                              iStorageServer,

                                              iProcessId,

                                              iMutex, 

                                              *this,

                                              aLogOption);

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

    if ( iStorageServerOpen || iLogOption == EATLogToXtiFast )

        {

        if ( iLogOption == EATLogToXtiFast )

            {

            LOGSTR1( "ATMH ATFastLogProcessEnded()" );

            ATFastLogProcessEnded( iProcessId, handleLeakCount );

            }

        else

            {

            iStorageServerOpen = EFalse;

            // Inform that process has ended and close the handle

            LOGSTR1( "ATMH iStorageServer.LogProcessEnded()" );

            iStorageServer.LogProcessEnded( iProcessId, handleLeakCount );

            // Close the handle

            iStorageServer.Close();

            }

        }

    // Close handle for process handle leaks

    #ifdef __WINSCW__

    // Restore system's exit check

    if ( CCoeEnv::Static() )

        CCoeEnv::Static()->DisableExitChecks( EFalse );

    #endif

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

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

    if ( iStorageServerOpen || iLogOption == EATLogToXtiFast )

        {

        TInt error( KErrNone );

        // Check if eventhandler is active already

        if ( !iEventHandler->IsActive() )

            {

            // Install the eventhandler if needed

            InstallEventHandler();

            }

        // Reset the callstack

        iCallStack.Reset();

        // If we don't want any call stack to be saved skip the next part

        if( iAllocMaxCallStack > 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;

            __asm

                {

                mov [_sp], esp

                }

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

                        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 == EATLogToXtiFast )

            {

            // Using fast xti.

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

            }

        else

            {

            // Using storage server.

            error = iStorageServer.LogMemoryAllocated( (TUint32) p,

                                                       iCallStack,

                                                       aSize );

            if ( KErrNone != error )

                {

                switch ( error )

                    {

                    case KErrNoMemory:

                        {

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

                        // Check if eventhandler is active

                        if ( iEventHandler->IsActive() )

                            {

                            // Cancel iEventHandler because not needed anymore

                            iEventHandler->Cancel();

                            }

                        if ( iStorageServerOpen )

                            {

                            iStorageServerOpen = EFalse;

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

                            iStorageServer.Close();

                            }

                        break;

                        }

                    default:

                        {

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

                        break;

                        }

                    }

                }

            }

        }

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

    TInt error( KErrNone );

    if ( iStorageServerOpen || iLogOption == EATLogToXtiFast )

        {

        // Check if eventhandler is active already

        // IsActive might return false value if a tested software has created many

        // threads which install own CActiveScheduler.

        if ( !iEventHandler->IsStarted() )

            {

            // Install the eventhandler if needed

            InstallEventHandler();

            }

        // Reset the callstack

        iCallStack.Reset();

        // If we don't want any call stack to be saved skip the next part

        if( iAllocMaxCallStack > 0 )

            {

            // Find the current thread callstack start address

            TUint32 stackstart( 0 );

            TBool found( FindCurrentThreadStack( stackstart ) );

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

            TInt blocksCount( iCodeblocks.Count() );

            TUint arrayCounter = 0;

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

                {

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

                    {

                    if ( iCodeblocks[j].CheckAddress( (TUint32) *( (TUint32*) i ) ) )

                        {

                        // To avoid recursive call to ReAlloc specifying granularity

                        // Add address to the callstack

                        iCallStack[arrayCounter] = ( (TUint32) *( (TUint32*) i ) );

                        arrayCounter++;

                        break;

                        }

                    }

                if ( arrayCounter == KATMaxCallstackLength ||

                     arrayCounter == iAllocMaxCallStack )

                    {

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

                    break;

                    }

                }

            }

        // Log the memory allocation information

        if ( iLogOption == EATLogToXtiFast )

            {

            // Using fast xti.

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

            }

        else

            {

            // Using storage server.

            error = iStorageServer.LogMemoryAllocated( (TUint32) p,

                                                       iCallStack,

                                                       aSize );

            if ( KErrNone != error )

                {

                switch ( error )

                    {

                    case KErrNoMemory:

                        {

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

                        // Check if eventhandler is active

                        if ( iEventHandler->IsActive() )

                            {

                            // Cancel ieventhandler because not needed anymore

                            iEventHandler->Cancel();

                            }

                        if ( iStorageServerOpen )

                            {

                            iStorageServerOpen = EFalse;

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

                            iStorageServer.Close();

                            }

                        break;

                        }

                    default:

                        {

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

                        break;

                        }

                    }

                }

            }

        }

    // Release the mutex

    iMutex.Signal();

    // Return the allocatated memory

    return p;