/*

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

*

*/

#ifndef MEMSPYDRIVERHEAP_H

#define MEMSPYDRIVERHEAP_H

// System includes

#include <e32cmn.h>

#include <kern_priv.h>

#include <memspy/driver/memspydriverobjectsshared.h>

#include <memspy/driver/memspydriverenumerationsshared.h>

// User includes

#include "MemSpyDriverObjectsInternal.h"

// Constants

const TUint KRHeapObjectSize = 0x74;

const TUint KRAllocatorAndRHeapMemberDataOffset = 4; // 4 bytes past start of allocator address, i.e. skipping the vtable

const TUint KRHeapMemberDataSize = KRHeapObjectSize - KRAllocatorAndRHeapMemberDataOffset;

// Classes referenced

class DMemSpyDriverOSAdaption;

/**

 * Essentially a mirror of RAllocator and RHeap's layout.

 */

class RMemSpyDriverRHeapBase

	{

public:

	struct SCell

        {

        TInt len; 

        SCell* next;

        };

    struct SDebugCell

        {

        TInt len;

        TInt nestingLevel;

        TInt allocCount;

        };

    struct _s_align {char c; double d;};

    struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc;	TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };

    enum {ECellAlignment = sizeof(_s_align)-sizeof(double)};

	enum {EFreeCellSize = sizeof(SCell)};

	enum TDebugOp {EWalk=128};

	enum TCellType

		{EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,

		EBadFreeCellAddress, EBadFreeCellSize};

    enum TDebugHeapId {EUser=0, EKernel=1};

protected:

    RMemSpyDriverRHeapBase();

public: // Inlines

    inline TUint8* Base() const { return iBase; }

    inline TInt Size() const { return iTop - iBase; }

    inline TInt MaxLength() const { return iMaxLength; }

public: // API

    void PrintInfo();

    void CopyObjectDataTo( TMemSpyHeapObjectDataRHeap& aData );

public: // Virtual API

    virtual void Reset();

    virtual void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes ) = 0;

    virtual void DisassociateWithKernelChunk() = 0;

    virtual DChunk& Chunk() = 0;

    virtual const DChunk& Chunk() const = 0;

    virtual TLinAddr ChunkKernelAddress() const = 0;

    virtual TBool ChunkIsInitialised() const = 0;

    virtual TUint ClientToKernelDelta() const = 0;

    virtual void GetHeapSpecificInfo( TMemSpyHeapInfo& /*aInfo*/ ) const { }

public: // Utilities

    TBool CheckCell( TAny* aCellAddress, TInt aLength ) const;

    static TInt AllocatedCellHeaderSize( TBool aDebugLibrary );

    static TInt FreeCellHeaderSize();

    static TInt CellHeaderSize( const TMemSpyDriverInternalWalkHeapParamsCell& aCell, TBool aDebugEUser );

public: // From RAllocator

	TInt iAccessCount;

	TInt iHandleCount;

	TInt* iHandles;

	TUint32 iFlags;

	TInt iCellCount;

	TInt iTotalAllocSize;

public: // From RHeap

	TInt iMinLength;

	TInt iMaxLength;

	TInt iOffset;

	TInt iGrowBy;

	TInt iChunkHandle;

	RFastLock iLock;

	TUint8* iBase;

	TUint8* iTop;

	TInt iAlign;

	TInt iMinCell;

	TInt iPageSize;

	SCell iFree;

	TInt iNestingLevel;

	TInt iAllocCount;

    RAllocator::TAllocFail iFailType;

	TInt iFailRate;

	TBool iFailed;

	TInt iFailAllocCount;

	TInt iRand;

	TAny* iTestData;

    };

class RMemSpyDriverRHeapReadFromCopy : public RMemSpyDriverRHeapBase

	{

protected:

    RMemSpyDriverRHeapReadFromCopy( DMemSpyDriverOSAdaption& aOSAdaption );

public: // New API

    TInt ReadFromUserAllocator( DThread& aThread );

public: // From RMemSpyDriverRHeapBase

    void Reset();

    void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes );

    void DisassociateWithKernelChunk();

    DChunk& Chunk();

    const DChunk& Chunk() const;

    TLinAddr ChunkKernelAddress() const;

    TBool ChunkIsInitialised() const;

    TUint ClientToKernelDelta() const;

protected:

    inline DMemSpyDriverOSAdaption& OSAdaption() { return iOSAdaption; }

private:

    DMemSpyDriverOSAdaption& iOSAdaption;

    // Copy of the client's heap data

    DChunk* iChunk;

    TLinAddr iChunkAddress;

    TUint32 iChunkMappingAttributes;

    // Calculated delta between client's address space values and actual kernel

    // address of the heap chunk.

    TUint iClientToKernelDelta;

    };

class RMemSpyDriverRHeapUser : public RMemSpyDriverRHeapReadFromCopy

	{

public:

    RMemSpyDriverRHeapUser( DMemSpyDriverOSAdaption& aOSAdaption );

public: // New API

    TInt ReadFromUserAllocator( DThread& aThread );

    };

class RMemSpyDriverRHeapKernelFromCopy : public RMemSpyDriverRHeapReadFromCopy

    {

public:

    RMemSpyDriverRHeapKernelFromCopy( DMemSpyDriverOSAdaption& aOSAdaption );

public: // API

    void SetKernelHeap( RHeapK& aKernelHeap );

public: // From RMemSpyDriverRHeapBase

    void DisassociateWithKernelChunk();

    void GetHeapSpecificInfo( TMemSpyHeapInfo& aInfo ) const;

private:

    RHeapK* iKernelHeap;

    };

class RMemSpyDriverRHeapKernelInPlace : public RMemSpyDriverRHeapBase

    {

public:

    RMemSpyDriverRHeapKernelInPlace();

public: // API

    void FailNext();

    void SetKernelHeap( RHeapK& aKernelHeap );

public: // From RMemSpyDriverRHeapBase

    void Reset();

    void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes );

    void DisassociateWithKernelChunk();

    DChunk& Chunk();

    const DChunk& Chunk() const;

    TLinAddr ChunkKernelAddress() const;

    TBool ChunkIsInitialised() const;

    TUint ClientToKernelDelta() const;

    void GetHeapSpecificInfo( TMemSpyHeapInfo& aInfo ) const;

private: // Internal methods

    void CopyMembersFromKernelHeap();

private: // Internal class

    /**

     * Used when opening the kernel heap

     */

#ifndef __SYMBIAN_KERNEL_HYBRID_HEAP__

    class RHeapKExtended : public RHeapK

        {

    public:

        inline void FailNext()

            {

            SetFailType( RAllocator::EFailNext );

            SetFailRate( 1 );

            ResetFailed();

            ResetFailAllocCount();

            }

        inline void SetFailType( TAllocFail aType ) { iFailType = aType; }

        inline void SetFailRate( TInt aRate ) { iFailRate = aRate; }

        inline void ResetFailed() { iFailed = EFalse; }

        inline void ResetFailAllocCount() { iFailAllocCount = 0; }

        };

#endif

private:

    RHeapK* iKernelHeap;

    DChunk* iChunk;

    };

#endif