diff -r 4fde310f06fe -r 86a2e675b80a memspy/Driver/Shared/heaputils.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Driver/Shared/heaputils.h	Mon Jun 28 15:36:07 2010 +0300
@@ -0,0 +1,216 @@
+// heaputils.h
+// 
+// Copyright (c) 2010 Accenture. All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the "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:
+// Accenture - Initial contribution
+//
+
+
+#ifndef FSHELL_HEAP_UTILS_H
+#define FSHELL_HEAP_UTILS_H
+
+#include <e32cmn.h>
+
+#ifdef __KERNEL_MODE__
+class DThread;
+class DChunk;
+#else
+class RMemoryAccess;
+#endif // __KERNEL_MODE__
+
+#if defined(STANDALONE_ALLOCHELPER) || defined(__KERNEL_MODE__)
+#define HUIMPORT_C
+#define HUCLASS(x) NONSHARABLE_CLASS(x)
+#else
+#define HUIMPORT_C IMPORT_C
+#define HUCLASS(x) class x
+#endif
+
+namespace LtkUtils
+	{
+
+class THeapInfo;
+	
+HUCLASS(RAllocatorHelper) // class RAllocatorHelper
+	{
+public:
+	HUIMPORT_C RAllocatorHelper();
+#ifdef __KERNEL_MODE__
+	TInt OpenKernelHeap();
+#else
+	HUIMPORT_C TInt Open(RAllocator* aAllocator);
+#endif
+	HUIMPORT_C TInt SetCellNestingLevel(TAny* aCell, TInt aNestingLevel);
+	HUIMPORT_C TInt GetCellNestingLevel(TAny* aCell, TInt& aNestingLevel);
+	HUIMPORT_C TInt AllocCountForCell(TAny* aCell) const;
+	HUIMPORT_C TLinAddr AllocatorAddress() const;
+	HUIMPORT_C TInt RefreshDetails();
+	
+	HUIMPORT_C TInt CommittedSize();
+	HUIMPORT_C TInt AllocatedSize();
+	HUIMPORT_C TInt AllocationCount();
+	HUIMPORT_C TInt MaxCommittedSize();
+	HUIMPORT_C TInt MinCommittedSize();
+	HUIMPORT_C TInt CountUnusedPages();
+	HUIMPORT_C TInt CommittedFreeSpace();
+
+	enum TCellType
+		{
+		EAllocation, EFreeSpace, EBadness
+		};
+
+	enum TExtendedCellType
+		{
+		EAllocationMask = 0xFF,
+		EFreeMask = 0xFF00,
+		EBadnessMask = 0xFF000000,
+
+		EHeapAllocation = 1,
+		EDlaAllocation = 2,
+		EPageAllocation = 3,
+		ESlabAllocation = 4,
+		
+		EHeapFreeCell = 0x0100,
+		EDlaFreeCell = 0x0200,
+		// There is nothing 'free' in the page allocator
+		ESlabFreeCell = 0x0300, // Used to track free cells in partially-filled slabs
+		ESlabFreeSlab = 0x0400, // Used to track entirely empty slabs (that don't have a specific cell size)
+
+		EHeapBadFreeCellAddress = 0x01000000,
+		EHeapBadFreeCellSize = 0x02000000,
+		EHeapBadAllocatedCellSize = 0x03000000,
+		EHeapBadAllocatedCellAddress = 0x04000000,
+		};
+			
+	// TBool WalkFunc(TAny* aContext, TCellType aCellType, TLinAddr aCellPtr, TInt aCellLength)
+	// aCellPtr points to the start of the cell payload for allocated cells (unlike RHeap's walker, which points to the cell header)
+	// aCellLength is the payload length, ie what AllocLen(aCellPtr) would return
+	// return ETrue to continue walking, EFalse to stop the walk
+	typedef TBool (*TWalkFunc)(TAny*, TCellType, TLinAddr, TInt);
+	typedef TBool (*TWalkFunc2)(RAllocatorHelper&, TAny*, TCellType, TLinAddr, TInt);
+	typedef TBool (*TWalkFunc3)(RAllocatorHelper&, TAny*, TExtendedCellType, TLinAddr, TInt);
+	HUIMPORT_C TInt Walk(TWalkFunc aCallbackFn, TAny* aContext);
+	HUIMPORT_C TInt Walk(TWalkFunc2 aCallbackFn, TAny* aContext); // Like the other but the walk func gives you the RAllocatorHelper pointer too
+	HUIMPORT_C TInt Walk(TWalkFunc3 aCallbackFn, TAny* aContext); // Like the other but the walk func gives you more details about the allocation type
+	HUIMPORT_C TInt SizeForCellType(TExtendedCellType aType);
+	HUIMPORT_C TInt CountForCellType(TExtendedCellType aType);
+	HUIMPORT_C TBool AllocatorIsUdeb() const;
+	HUIMPORT_C const TDesC& Description() const;
+	HUIMPORT_C virtual void Close();
+
+#ifdef __KERNEL_MODE__
+	virtual DChunk* OpenUnderlyingChunk(); // Must be in CS
+	enum TType
+		{
+		ETypeUnknown,
+		ETypeRHeap,
+		ETypeRHybridHeap,
+		};
+	TType GetType() const; // This is for information only, nothing should care about the return value
+#endif
+
+protected:
+	TInt FinishConstruction();
+	TInt IdentifyAllocatorType(TBool aAllocatorIsUdeb);
+	TInt OpenChunkHeap(TLinAddr aChunkBase, TInt aChunkMaxSize);
+#ifndef __KERNEL_MODE__
+	static TInt EuserIsUdeb();
+#endif
+	virtual TInt ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const;
+	virtual TInt WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize);
+	virtual TInt TryLock();
+	virtual void TryUnlock();
+
+private:
+	TInt ReadWord(TLinAddr aLocation, TUint32& aResult) const;
+	TInt ReadByte(TLinAddr aLocation, TUint8& aResult) const;
+	TInt WriteWord(TLinAddr aLocation, TUint32 aWord);
+	TInt RefreshDetails(TUint aMask);
+	TInt DoRefreshDetails(TUint aMask);
+	TInt CheckValid(TUint aMask);
+	TInt DoWalk(TWalkFunc3 aCallbackFn, TAny* aContext);
+	TInt OldSkoolWalk(TWalkFunc3 aCallbackFn, TAny* aContext);
+	TInt NewHotnessWalk(TWalkFunc3 aCallbackFn, TAny* aContext);
+	static TBool DispatchClientWalkCallback(RAllocatorHelper& aHelper, TAny* aContext, TExtendedCellType aCellType, TLinAddr aCellPtr, TInt aCellLength);
+	static TBool WalkForStats(RAllocatorHelper& aSelf, TAny* aContext, TExtendedCellType aType, TLinAddr aCellPtr, TInt aCellLength);
+	TUint PageMapOperatorBrackets(unsigned ix, TInt& err) const;
+	TInt PageMapFind(TUint start, TUint bit, TInt& err);
+	TUint PageMapBits(unsigned ix, unsigned len, TInt& err);
+	TUint PagedDecode(TUint pos, TInt& err);
+	TInt TreeWalk(TUint32 aSlabRoot, TInt aSlabType, TWalkFunc3 aCallbackFn, TAny* aContext, TBool& shouldContinue);
+protected:
+	TLinAddr iAllocatorAddress;
+	enum TAllocatorType
+		{
+		EUnknown,
+		EAllocator,
+		EUrelOldRHeap,
+		EUdebOldRHeap,
+		EUrelHybridHeap,
+		EUdebHybridHeap,
+		};
+	TAllocatorType iAllocatorType;
+private:
+	THeapInfo* iInfo;
+	TUint iValidInfo;
+	TUint8* iTempSlabBitmap;
+	mutable TAny* iPageCache;
+	mutable TLinAddr iPageCacheAddr;
+#ifdef __KERNEL_MODE__
+	DChunk* iChunk;
+	//TUint iSpare[0];
+#else
+	TUint iSpare[1];
+#endif
+	};
+
+#ifdef __KERNEL_MODE__
+
+class RKernelSideAllocatorHelper : public RAllocatorHelper
+	{
+public:
+	RKernelSideAllocatorHelper();
+	TInt OpenUserHeap(TUint aThreadId, TLinAddr aAllocatorAddress, TBool aEuserIsUdeb);
+	virtual DChunk* OpenUnderlyingChunk(); // Must be in CS
+	virtual void Close();
+
+protected:
+	virtual TInt ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const;
+	virtual TInt WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize);
+	virtual TInt TryLock();
+	virtual void TryUnlock();
+private:
+	DThread* iThread;
+	};
+
+#else
+
+class RProxyAllocatorHelper : public RAllocatorHelper
+	{
+public:
+	HUIMPORT_C RProxyAllocatorHelper();
+	HUIMPORT_C TInt Open(RMemoryAccess& aMem, TUint aThreadId);
+	HUIMPORT_C TInt OpenChunkHeap(RMemoryAccess& aMem, TAny* aDChunkPtr);
+	HUIMPORT_C virtual void Close();
+
+protected:
+	virtual TInt ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const;
+	virtual TInt WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize);
+	virtual TInt TryLock();
+	virtual void TryUnlock();
+
+private:
+	RMemoryAccess* iMemoryAccess;
+	TUint iThreadId;
+	};
+
+#endif // __KERNEL_MODE__
+
+	} // namespace LtkUtils
+
+#endif