/*

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

*

*/

#include <memspy/engine/memspyenginehelperheap.h>

// System includes

#include <s32mem.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyenginehelperrom.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/driver/memspydriverenumerationsshared.h>

// Constants

const TBool KMemSpyHeapDumpCreateOwnDataStream = ETrue;

// Literal constants

_LIT( KCellTypeGoodAllocatedCell,        "[Allocated Cell]            ");

_LIT( KCellTypeGoodFreeCell,             "[Free Cell]                 ");

_LIT( KCellTypeBadAllocatedCellSize,     "[Bad Allocated Cell Size]   ");

_LIT( KCellTypeBadAllocatedCellAddress,  "[Bad Allocated Cell Address]");

_LIT( KCellTypeBadFreeCellAddress,       "[Bad Free Cell Address]     ");

_LIT( KCellTypeBadFreeCellSize,          "[Bad Free Cell Size]        ");

_LIT( KCellTypeBad,                      "[Bad Cell]                  ");

_LIT( KCellTypeUnknown,                  "[Unknown!]                  ");

_LIT( KCellListLineFormat, "%S cell: 0x%08x, cellLen: %8d, allocNum: %8d, nestingLev: %8d, cellData: 0x%08x, cellDataAddr: 0x%08x, headerSize: %02d");

_LIT( KMemSpyMarkerHeapData, "<%SMEMSPY_HEAP_DATA_%03d>" );

_LIT( KMemSpyMarkerCSV, "<%SMEMSPY_HEAP_CSV>" );

_LIT( KMemSpyPrefixHeapData, "HeapData - %S - ");

_LIT( KMemSpyPrefixCellList, "CellList - %S - ");

_LIT( KMemSpyPrefixCSV, "CSV - " );

CMemSpyEngineHelperHeap::CMemSpyEngineHelperHeap( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperHeap::~CMemSpyEngineHelperHeap()

    {

    }

void CMemSpyEngineHelperHeap::ConstructL()

    {

    }

CMemSpyEngineHelperHeap* CMemSpyEngineHelperHeap::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperHeap* self = new(ELeave) CMemSpyEngineHelperHeap( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C void CMemSpyEngineHelperHeap::OutputCellListingUserL( const CMemSpyThread& aThread )

    {

    // Suspend the process

    iEngine.ProcessSuspendLC( aThread.Process().Id() );

    // Free cells

    RArray<TMemSpyDriverFreeCell> freeCells;

    CleanupClosePushL( freeCells );

    // Info section

    TMemSpyHeapInfo heapInfo;

    const TInt error = iEngine.Driver().GetHeapInfoUser( heapInfo, aThread.Id(), freeCells );

    if ( error == KErrNone )

        {

        UpdateSharedHeapInfoL( aThread.Process().Id(), aThread.Id(), heapInfo );

        }

    if  ( error == KErrNone && heapInfo.Type() != TMemSpyHeapInfo::ETypeUnknown )

        {

        // Get thread name for context

        const TFullName pName( aThread.FullName() );

        // Begin a new data stream

        _LIT( KMemSpyFolder, "Heap\\Cell List" );

        _LIT( KMemSpyContext, "Cell List - %S" );

        HBufC* context = HBufC::NewLC( KMaxFileName );

        TPtr pContext( context->Des() );

        pContext.Format( KMemSpyContext, &pName );

        iEngine.Sink().DataStreamBeginL( pContext, KMemSpyFolder );

        CleanupStack::PopAndDestroy( context );

        // Set prefix for overall listing

        iEngine.Sink().OutputPrefixSetFormattedLC( KMemSpyPrefixCellList, &pName );

        // Start new section

        _LIT(KHeader, "CELL LISTING");

        iEngine.Sink().OutputSectionHeadingL( KHeader, '=' );

        // Prepare temp buffers

        TBuf<KMaxFullName + 100> printFormat;

        HBufC* tempBuffer = HBufC::NewLC( 2048 );

        TPtr pTempBuffer( tempBuffer->Des() );

        // Print initial info

        OutputHeapInfoL( heapInfo, pName, &freeCells );

        // Code segments (needed for map file reading...)

        _LIT(KCellListCodeSegInfoFormat, "CodeSegs - ");

        iEngine.HelperCodeSegment().OutputCodeSegmentsL( aThread.Process().Id(), printFormat, KCellListCodeSegInfoFormat, '-', ETrue );

        // Now walk the heap!

        TInt r = iEngine.Driver().WalkHeapInit( aThread.Id() );

        if  ( r == KErrNone )

            {

             _LIT(KHeader2, "Cells");

            iEngine.Sink().OutputSectionHeadingL( KHeader2, '-' );

            TMemSpyDriverCellType cellType;

            TAny* cellAddress;

            TInt cellLength;

            TInt cellNestingLevel;

            TInt cellAllocationNumber;

            TInt cellHeaderSize;

            TAny* cellPayloadAddress;

            TBuf8<4> cellData;

            //

            r = iEngine.Driver().WalkHeapNextCell( aThread.Id(), cellType, cellAddress, cellLength, cellNestingLevel, cellAllocationNumber, cellHeaderSize, cellPayloadAddress );

            while( r == KErrNone )

                {

                TUint fourByteCellData = 0;

                TPtrC pType(KNullDesC);

                //

				if (cellType & EMemSpyDriverAllocatedCellMask)

					{

                    r = iEngine.Driver().WalkHeapReadCellData( cellAddress, cellData, 4 );

                    if  ( r == KErrNone )

                        {

                        fourByteCellData = DescriptorAsDWORD( cellData );

                        }

                    pType.Set(KCellTypeGoodAllocatedCell);

                    }

				else if (cellType & EMemSpyDriverFreeCellMask)

					{

                    pType.Set(KCellTypeGoodFreeCell);

					}

				else if (cellType & EMemSpyDriverBadCellMask)

					{

					switch (cellType)

						{

					case EMemSpyDriverHeapBadAllocatedCellSize:

						pType.Set(KCellTypeBadAllocatedCellSize);

						break;

					case EMemSpyDriverHeapBadAllocatedCellAddress:

						pType.Set(KCellTypeBadAllocatedCellAddress);

						break;

					case EMemSpyDriverHeapBadFreeCellAddress:

						pType.Set(KCellTypeBadFreeCellAddress);

						break;

					case EMemSpyDriverHeapBadFreeCellSize:

						pType.Set(KCellTypeBadFreeCellSize);

						break;

					default:

						pType.Set(KCellTypeBad);

						break;

						}

					}

				else

					{

                    pType.Set(KCellTypeUnknown);

                    }

                if  ( r == KErrNone )

                    {

                    pTempBuffer.Format( KCellListLineFormat, &pType, cellAddress, cellLength, cellAllocationNumber, cellNestingLevel, fourByteCellData, cellPayloadAddress, cellHeaderSize );

                    iEngine.Sink().OutputLineL( pTempBuffer );

                    //

                    r = iEngine.Driver().WalkHeapNextCell( aThread.Id(), cellType, cellAddress, cellLength, cellNestingLevel, cellAllocationNumber, cellHeaderSize, cellPayloadAddress );

                    }

                }

            //

            iEngine.Driver().WalkHeapClose();

            }

        CleanupStack::PopAndDestroy( tempBuffer );

        CleanupStack::PopAndDestroy(); // clear prefix

        iEngine.Sink().DataStreamEndL();

        }

    CleanupStack::PopAndDestroy( &freeCells );

    CleanupStack::PopAndDestroy(); // resume process

    }

EXPORT_C void CMemSpyEngineHelperHeap::OutputHeapDataUserL( const CMemSpyThread& aThread )

    {

    OutputHeapDataUserL( aThread, KMemSpyHeapDumpCreateOwnDataStream );

    }

void CMemSpyEngineHelperHeap::OutputHeapDataUserL( const CMemSpyThread& aThread, TBool aCreateDataStream )

    {

    // Make sure the process is suspended for the entire time we are manipulating it's heap

    iEngine.ProcessSuspendLC( aThread.Process().Id() );

    // Get the heap info, including cell information

    RArray<TMemSpyDriverCell> cells;

    CleanupClosePushL( cells );

    TMemSpyHeapInfo heapInfo;

    TRACE( RDebug::Printf( "CMemSpyEngineHelperHeap::OutputHeapDataUserL() - checksum1: 0x%08x", heapInfo.AsRHeap().Statistics().StatsFree().Checksum() ) );

    GetHeapInfoUserL(aThread.Process().Id(), aThread.Id(), heapInfo, &cells, ETrue);

    TRACE( RDebug::Printf( "CMemSpyEngineHelperHeap::OutputHeapDataUserL() - checksum2: 0x%08x", heapInfo.AsRHeap().Statistics().StatsFree().Checksum() ) );

    // Get the heap data

    const TFullName pName( aThread.FullName() );

    OutputHeapDataUserL( aThread.Process().Id(), aThread.Id(), pName, heapInfo, aCreateDataStream, &cells );

    CleanupStack::PopAndDestroy( &cells );

    // Resume process

    CleanupStack::PopAndDestroy();

    }

EXPORT_C void CMemSpyEngineHelperHeap::OutputHeapDataUserL(const TProcessId& aPid, const TThreadId& aTid, const TDesC& aThreadName, const TMemSpyHeapInfo& aInfo, const RArray<TMemSpyDriverCell>* aCells)

    {

    OutputHeapDataUserL(aPid, aTid, aThreadName, aInfo, ETrue, aCells);

    }

void CMemSpyEngineHelperHeap::OutputHeapDataUserL( const TProcessId& aPid, const TThreadId& aTid, const TDesC& aThreadName, const TMemSpyHeapInfo& aInfo, TBool aCreateDataStream, const RArray<TMemSpyDriverCell>* aCells )

    {

    TBuf<KMaxFullName + 100> printFormat;

    // Begin a new data stream

    if  ( aCreateDataStream )

        {

        _LIT( KMemSpyFolder, "Heap\\Data" );

        _LIT( KMemSpyContext, "Heap Data - %S" );

        HBufC* context = HBufC::NewLC( KMaxFileName );

        TPtr pContext( context->Des() );

        pContext.Format( KMemSpyContext, &aThreadName );

        iEngine.Sink().DataStreamBeginL( pContext, KMemSpyFolder );

        CleanupStack::PopAndDestroy( context );

        }

    // Get the heap info first of all

    iEngine.ProcessSuspendLC( aPid );

    // Start marker

    iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KNullDesC, (TUint) aTid );

    // Set overall prefix

    iEngine.Sink().OutputPrefixSetFormattedLC( KMemSpyPrefixHeapData, &aThreadName );

    // Info section

    OutputHeapInfoL( aInfo, aThreadName, aCells );

    // Code segments (needed for map file reading...)

    _LIT(KCellListCodeSegInfoFormat, "CodeSegs - ");

    iEngine.HelperCodeSegment().OutputCodeSegmentsL( aPid, printFormat, KCellListCodeSegInfoFormat, '-', ETrue );

    // Dump section

    _LIT(KHeaderDump, "Heap Data");

    iEngine.Sink().OutputSectionHeadingL( KHeaderDump, '-' );

    HBufC8* data = HBufC8::NewLC( 4096 * 12 );

    TPtr8 pData(data->Des());

    TUint remaining = 0;

    TUint readAddress = 0;

    // When we obtained the heap info, we also obtained a checksum of all the free cells

    // within the specified heap. We validate that this hasn't changed at the time we

    // request the heap data for paranoia purposes (There have been "Issues" with MemSpy

    // not actually suspending a process between fetching heap info & heap data, causing

    // a mismatch in free cell information).

    const TUint32 checksum = aInfo.AsRHeap().Statistics().StatsFree().Checksum();

    TRACE( RDebug::Printf( "CMemSpyEngineHelperHeap::OutputHeapDataUserL() - checksum: 0x%08x", checksum ) );

    TInt r = iEngine.Driver().GetHeapData( aTid, checksum, pData, readAddress, remaining );

	TUint prevEndAddress = readAddress + pData.Length();

    if (r == KErrNone)

        {

        while (r == KErrNone)

            {

			if (readAddress > prevEndAddress)

				{

				// We've hit a discontinuity, ie one or more unmapped pages

				_LIT(KBreak, "........");

				iEngine.Sink().OutputLineL(KBreak);

				}

            _LIT(KHeapDumpDataFormat, "%S");

            iEngine.Sink().OutputBinaryDataL(KHeapDumpDataFormat, pData.Ptr(), (const TUint8*) readAddress, pData.Length());

			readAddress += pData.Length();

            if (remaining > 0)

				{

				prevEndAddress = readAddress;

                r = iEngine.Driver().GetHeapDataNext(aTid, pData, readAddress, remaining);

				}

            else

                break;

            }

        }

    else

        {

        _LIT( KHeapFetchError, "Heap error: %d");

        iEngine.Sink().OutputLineFormattedL( KHeapFetchError, r );

        }

    CleanupStack::PopAndDestroy( data );

    CleanupStack::PopAndDestroy(); // clear prefix

    CleanupStack::PopAndDestroy(); // resume process

    // End marker

    iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KMemSpySinkTagClose, (TUint) aTid );

    if  ( aCreateDataStream )

        {

        iEngine.Sink().DataStreamEndL();

        }

    }

EXPORT_C void CMemSpyEngineHelperHeap::OutputHeapInfoL( const TMemSpyHeapInfo& aInfo, const TDesC& aThreadName, const RArray<TMemSpyDriverCell>* aCells )

	{

    CMemSpyEngineOutputList* list = NewHeapSummaryExtendedLC(aInfo, aCells);

    // Format the thread name according to upper/lower case request parameters

    _LIT( KOverallCaption1, "HEAP INFO FOR THREAD '%S'");

    list->InsertItemFormatUCL( 0, KOverallCaption1, &aThreadName );

    list->InsertUnderlineForItemAtL( 0 );

    // Print it

    list->PrintL();

    // Tidy up

    CleanupStack::PopAndDestroy( list );

    }

void CMemSpyEngineHelperHeap::OutputCSVEntryL( TInt aIndex, const TMemSpyHeapInfo& aInfo, const TDesC& aThreadName, const TDesC& aProcessName )

    {

    const TMemSpyHeapInfoRHeap& rHeapInfo = aInfo.AsRHeap();

    const TMemSpyHeapMetaDataRHeap& rHeapMetaData = rHeapInfo.MetaData();

    const TMemSpyHeapStatisticsRHeap& rHeapStats = rHeapInfo.Statistics();

    // Example:

    //

    //  <ENTRY_001>

    //      <THREAD_NAME_001>ESock_IP</THREAD_NAME_001>

    //      <PROCESS_NAME_001>c32exe.exe[101f7989]0001</PROCESS_NAME_001>

    //      <CHUNK_NAME_001>Local-c812ba58</CHUNK_NAME_001>

    //      <FIELDS_001>1,0x12400000,0x00c00074,36744,4092,524288,0x00c011a4,0,13,6872,1368,1680,2584,219,40,28996,0</FIELDS_001>

    //  </ENTRY_001>

    _LIT( KFmtTagOpenAndClose, "<%S_%04d>%S</%S_%04d>" );

    _LIT( KFmtEntryId, "<%SENTRY_%04d>");

    _LIT( KFmtNameThread, "THREAD_NAME");

    _LIT( KFmtNameProcess, "PROCESS_NAME");

    _LIT( KFmtNameChunk, "CHUNK_NAME");

    _LIT( KFmtFields, "FIELDS");

    _LIT( KFmtFieldContent , "<%S_%04d>%06d,0x%08x,0x%08x,%d,%d,%d,0x%08x,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d</%S_%04d>");

    // <ENTRY_001>

    iEngine.Sink().OutputLineFormattedL( KFmtEntryId, &KNullDesC, aIndex );

    //      <THREAD_NAME_001>ESock_IP</THREAD_NAME_001>

    iEngine.Sink().OutputLineFormattedL( KFmtTagOpenAndClose, &KFmtNameThread, aIndex, &aThreadName, &KFmtNameThread, aIndex );

    //      <PROCESS_NAME_001>c32exe.exe[101f7989]0001</PROCESS_NAME_001>

    iEngine.Sink().OutputLineFormattedL( KFmtTagOpenAndClose, &KFmtNameProcess, aIndex, &aProcessName, &KFmtNameProcess, aIndex );

    //      <CHUNK_NAME_001>Local-c812ba58</CHUNK_NAME_001>

    const TPtrC pChunkName( rHeapMetaData.ChunkName() );

    iEngine.Sink().OutputLineFormattedL( KFmtTagOpenAndClose, &KFmtNameChunk, aIndex, &pChunkName, &KFmtNameChunk, aIndex );

    // Fields

    iEngine.Sink().OutputLineFormattedL( KFmtFieldContent,

                                         &KFmtFields,

                                         aIndex,

                                         aInfo.Tid(),

                                         rHeapMetaData.ChunkHandle(),

                                         rHeapMetaData.iAllocatorAddress,

                                         rHeapMetaData.iHeapSize,

                                         rHeapMetaData.iMinHeapSize,

                                         rHeapMetaData.iMaxHeapSize,

                                         NULL, // there's no longer a free list so we can't return the next ptr

                                         0, // there's no longer a free list so we can't return it's length

                                         rHeapStats.StatsFree().TypeCount(),

                                         rHeapStats.StatsFree().TypeSize(),

                                         rHeapStats.StatsFree().SlackSpaceCellSize(),

                                         rHeapStats.StatsFree().LargestCellSize(),

                                         rHeapStats.StatsAllocated().LargestCellSize(),

                                         rHeapStats.StatsAllocated().TypeCount(),

                                         0, // min cell no longer makes sense

                                         rHeapStats.StatsAllocated().TypeSize(),

                                         rHeapMetaData.IsSharedHeap(),

                                         &KFmtFields,

                                         aIndex

                                         );

    // </ENTRY_001>

    iEngine.Sink().OutputLineFormattedL( KFmtEntryId, &KMemSpySinkTagClose, aIndex );

    }

EXPORT_C void CMemSpyEngineHelperHeap::OutputHeapInfoForDeviceL( TBool aIncludeKernel )

    {

    // NB: The goal here is to minimise the line length. We already look like we

    // could exceed the available RDebug::Print length...

    const TInt count = iEngine.Container().Count();

    TInt index = 0;

    //

    HBufC* buf = HBufC::NewLC( 1024 );

    TPtr pBuf(buf->Des());

    //

    _LIT( KMemSpyFolder, "Heap\\Compact" );

    _LIT( KMemSpyContext, "Heap Compact" );

    _LIT( KMemSpyExtension, ".log" );

    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder, KMemSpyExtension );

    // Start marker

    iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerCSV, &KNullDesC );

    // Set overall prefix

    iEngine.Sink().OutputPrefixSetLC( KMemSpyPrefixCSV );

    // Output version info

    _LIT( KVersionNumber, "<VERSION>1</VERSION>" );

    iEngine.Sink().OutputLineL( KVersionNumber );

    // Output time stamp

    _LIT( KTimeStamp, "<TIMESTAMP>%u</TIMESTAMP>" );

    iEngine.Sink().OutputLineFormattedL( KTimeStamp, User::FastCounter() );

    // Heap info we'll populate by calling the driver