diff -r 000000000000 -r a03f92240627 memspy/Driver/Kernel/Include/MemSpyDriverHeap.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Driver/Kernel/Include/MemSpyDriverHeap.h	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,253 @@
+/*
+* 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
+     */
+    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; }
+        };
+
+private:
+    RHeapK* iKernelHeap;
+    DChunk* iChunk;
+    };
+
+	
+#endif