// heaputils.cpp

// 

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

//

#ifdef TEST_HYBRIDHEAP_ASSERTS

#define private public

#include <e32def.h>

#include "slab.h"

#include "page_alloc.h"

#include "heap_hybrid.h"

#endif

#include "heaputils.h"

#ifdef __KERNEL_MODE__

#include <kern_priv.h>

#define MEM Kern

__ASSERT_COMPILE(sizeof(LtkUtils::RKernelSideAllocatorHelper) == 10*4);

#define KERN_ENTER_CS() NKern::ThreadEnterCS()

#define KERN_LEAVE_CS() NKern::ThreadLeaveCS()

#define LOG(args...)

#define HUEXPORT_C

#else

#include <e32std.h>

#define MEM User

#define KERN_ENTER_CS()

#define KERN_LEAVE_CS()

//#include <e32debug.h>

//#define LOG(args...) RDebug::Printf(args)

#define LOG(args...)

#ifdef STANDALONE_ALLOCHELPER

#define HUEXPORT_C

#else

#define HUEXPORT_C EXPORT_C

#endif

#endif // __KERNEL_MODE__

using LtkUtils::RAllocatorHelper;

const TUint KPageSize = 4096;

__ASSERT_COMPILE(sizeof(RAllocatorHelper) == 9*4);

// RAllocatorHelper

HUEXPORT_C RAllocatorHelper::RAllocatorHelper()

	: iAllocatorAddress(0), iAllocatorType(EUnknown), iInfo(NULL), iValidInfo(0), iTempSlabBitmap(NULL), iPageCache(NULL), iPageCacheAddr(0)

#ifdef __KERNEL_MODE__

	, iChunk(NULL)

#endif

	{

	}

namespace LtkUtils

	{

	class THeapInfo

		{

	public:

		THeapInfo()

			{

			ClearStats();

			}

		void ClearStats()

			{

			memclr(this, sizeof(THeapInfo));

			}

		TInt iAllocatedSize; // number of bytes in allocated cells (excludes free cells, cell header overhead)

		TInt iCommittedSize; // amount of memory actually committed (includes cell header overhead, gaps smaller than an MMU page)

		TInt iAllocationCount; // number of allocations currently

		TInt iMaxCommittedSize; // or thereabouts

		TInt iMinCommittedSize;

		TInt iUnusedPages;

		TInt iCommittedFreeSpace;

		// Heap-only stats

		TInt iHeapFreeCellCount;

		// Hybrid-only stats

		TInt iDlaAllocsSize;

		TInt iDlaAllocsCount;

		TInt iDlaFreeSize;

		TInt iDlaFreeCount;

		TInt iSlabAllocsSize;

		TInt iSlabAllocsCount;

		TInt iPageAllocsSize;

		TInt iPageAllocsCount;

		TInt iSlabFreeCellSize;

		TInt iSlabFreeCellCount;

		TInt iSlabFreeSlabSize;

		TInt iSlabFreeSlabCount;

		};

	}

const TInt KTempBitmapSize = 256; // KMaxSlabPayload / mincellsize, technically. Close enough.

#ifdef __KERNEL_MODE__

TInt RAllocatorHelper::OpenKernelHeap()

	{

	_LIT(KName, "SvHeap");

	NKern::ThreadEnterCS();

	DObjectCon* chunkContainer = Kern::Containers()[EChunk];

	chunkContainer->Wait();

	const TInt chunkCount = chunkContainer->Count();

	DChunk* foundChunk = NULL;

	for(TInt i=0; i<chunkCount; i++)

		{

		DChunk* chunk = (DChunk*)(*chunkContainer)[i];

		if (chunk->NameBuf() && chunk->NameBuf()->Find(KName) != KErrNotFound)

			{

			// Found it. No need to open it, we can be fairly confident the kernel heap isn't going to disappear from under us

			foundChunk = chunk;

			break;

			}

		}

	iChunk = foundChunk;

    chunkContainer->Signal();

#ifdef __WINS__

	TInt err = OpenChunkHeap((TLinAddr)foundChunk->Base(), 0); // It looks like DChunk::iBase/DChunk::iFixedBase should both be ok for the kernel chunk

#else

	// Copied from P::KernelInfo

	const TRomHeader& romHdr=Epoc::RomHeader();

	const TRomEntry* primaryEntry=(const TRomEntry*)Kern::SuperPage().iPrimaryEntry;

	const TRomImageHeader* primaryImageHeader=(const TRomImageHeader*)primaryEntry->iAddressLin;

	TLinAddr stack = romHdr.iKernDataAddress + Kern::RoundToPageSize(romHdr.iTotalSvDataSize);

	TLinAddr heap = stack + Kern::RoundToPageSize(primaryImageHeader->iStackSize);

	TInt err = OpenChunkHeap(heap, 0); // aChunkMaxSize is only used for trying the middle of the chunk for hybrid allocatorness, and the kernel heap doesn't use that (thankfully). So we can safely pass in zero.

#endif

	if (!err) err = FinishConstruction();

	NKern::ThreadLeaveCS();

	return err;

	}

#else

HUEXPORT_C TInt RAllocatorHelper::Open(RAllocator* aAllocator)

	{

	iAllocatorAddress = (TLinAddr)aAllocator;

	TInt udeb = EuserIsUdeb();

	if (udeb < 0) return udeb; // error

	TInt err = IdentifyAllocatorType(udeb);

	if (!err)

		{

		err = FinishConstruction(); // Allocate everything up front

		}

	if (!err)

		{

		// We always stealth our own allocations, again to avoid tripping up allocator checks

		SetCellNestingLevel(iInfo, -1);

		SetCellNestingLevel(iTempSlabBitmap, -1);

		SetCellNestingLevel(iPageCache, -1);

		}

	return err;

	}

#endif

TInt RAllocatorHelper::FinishConstruction()

	{

	TInt err = KErrNone;

	KERN_ENTER_CS();

	if (!iInfo)

		{

		iInfo = new THeapInfo;

		if (!iInfo) err = KErrNoMemory;

		}

	if (!err && !iTempSlabBitmap)

		{

		iTempSlabBitmap = (TUint8*)MEM::Alloc(KTempBitmapSize);

		if (!iTempSlabBitmap) err = KErrNoMemory;

		}

	if (!err && !iPageCache)

		{

		iPageCache = MEM::Alloc(KPageSize);

		if (!iPageCache) err = KErrNoMemory;

		}

	if (err)

		{

		delete iInfo;

		iInfo = NULL;

		MEM::Free(iTempSlabBitmap);

		iTempSlabBitmap = NULL;

		MEM::Free(iPageCache);

		iPageCache = NULL;

		}

	KERN_LEAVE_CS();

	return err;

	}

TInt RAllocatorHelper::ReadWord(TLinAddr aLocation, TUint32& aResult) const

	{

	// Check if we can satisfy the read from the cache

	if (aLocation >= iPageCacheAddr)

		{

		TUint offset = aLocation - iPageCacheAddr;

		if (offset < KPageSize)

			{

			aResult = ((TUint32*)iPageCache)[offset >> 2];

			return KErrNone;

			}

		}

	// If we reach here, not in page cache. Try and read in the new page

	if (iPageCache)

		{

		TLinAddr pageAddr = aLocation & ~(KPageSize-1);

		TInt err = ReadData(pageAddr, iPageCache, KPageSize);

		if (!err)

			{

			iPageCacheAddr = pageAddr;

			aResult = ((TUint32*)iPageCache)[(aLocation - iPageCacheAddr) >> 2];

			return KErrNone;

			}

		}

	// All else fails, try just reading it uncached

	return ReadData(aLocation, &aResult, sizeof(TUint32));

	}

TInt RAllocatorHelper::ReadByte(TLinAddr aLocation, TUint8& aResult) const

	{

	// Like ReadWord but 8-bit

	// Check if we can satisfy the read from the cache

	if (aLocation >= iPageCacheAddr)

		{

		TUint offset = aLocation - iPageCacheAddr;

		if (offset < KPageSize)

			{

			aResult = ((TUint8*)iPageCache)[offset];

			return KErrNone;

			}

		}

	// If we reach here, not in page cache. Try and read in the new page

	if (iPageCache)

		{

		TLinAddr pageAddr = aLocation & ~(KPageSize-1);

		TInt err = ReadData(pageAddr, iPageCache, KPageSize);

		if (!err)

			{

			iPageCacheAddr = pageAddr;

			aResult = ((TUint8*)iPageCache)[(aLocation - iPageCacheAddr)];

			return KErrNone;

			}

		}

	// All else fails, try just reading it uncached

	return ReadData(aLocation, &aResult, sizeof(TUint8));

	}

TInt RAllocatorHelper::WriteWord(TLinAddr aLocation, TUint32 aWord)

	{

	// Invalidate the page cache if necessary

	if (aLocation >= iPageCacheAddr && aLocation - iPageCacheAddr < KPageSize)

		{

		iPageCacheAddr = 0;

		}

	return WriteData(aLocation, &aWord, sizeof(TUint32));

	}

TInt RAllocatorHelper::ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const

	{

	// RAllocatorHelper base class impl is for allocators in same address space, so just copy it

	memcpy(aResult, (const TAny*)aLocation, aSize);

	return KErrNone;

	}

TInt RAllocatorHelper::WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize)

	{

	memcpy((TAny*)aLocation, aData, aSize);

	return KErrNone;

	}

#ifdef __KERNEL_MODE__

LtkUtils::RKernelSideAllocatorHelper::RKernelSideAllocatorHelper()

	: iThread(NULL)

	{}

void LtkUtils::RKernelSideAllocatorHelper::Close()

	{

	NKern::ThreadEnterCS();

	if (iThread)

		{

		iThread->Close(NULL);

		}

	iThread = NULL;

	RAllocatorHelper::Close();

	NKern::ThreadLeaveCS();

	}

TInt LtkUtils::RKernelSideAllocatorHelper::ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const

	{

	return Kern::ThreadRawRead(iThread, (const TAny*)aLocation, aResult, aSize);

	}

TInt LtkUtils::RKernelSideAllocatorHelper::WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize)

	{

	return Kern::ThreadRawWrite(iThread, (TAny*)aLocation, aData, aSize);

	}

TInt LtkUtils::RKernelSideAllocatorHelper::TryLock()

	{

	return KErrNotSupported;

	}

void LtkUtils::RKernelSideAllocatorHelper::TryUnlock()

	{

	// Not supported

	}

TInt LtkUtils::RKernelSideAllocatorHelper::OpenUserHeap(TUint aThreadId, TLinAddr aAllocatorAddress, TBool aEuserIsUdeb)

	{

	NKern::ThreadEnterCS();

	DObjectCon* threads = Kern::Containers()[EThread];

	threads->Wait();

	iThread = Kern::ThreadFromId(aThreadId);

	if (iThread && iThread->Open() != KErrNone)

		{

		// Failed to open

		iThread = NULL;

		}

	threads->Signal();

	NKern::ThreadLeaveCS();

	if (!iThread) return KErrNotFound;

	iAllocatorAddress = aAllocatorAddress;

	TInt err = IdentifyAllocatorType(aEuserIsUdeb);

	if (err) Close();

	return err;

	}

#endif // __KERNEL_MODE__

TInt RAllocatorHelper::OpenChunkHeap(TLinAddr aChunkBase, TInt aChunkMaxSize)

	{

	iAllocatorAddress = aChunkBase;

#ifdef __KERNEL_MODE__

	// Must be in CS

	// Assumes that this only ever gets called for the kernel heap. Otherwise goes through RKernelSideAllocatorHelper::OpenUserHeap.

	TInt udeb = EFalse; // We can't figure this out until after we've got the heap

	TBool isTheKernelHeap = ETrue;

#else

	// Assumes the chunk isn't the kernel heap. It's not a good idea to try messing with the kernel heap from user side...

	TInt udeb = EuserIsUdeb();

	if (udeb < 0) return udeb; // error

    TBool isTheKernelHeap = EFalse;

#endif

	TInt err = IdentifyAllocatorType(udeb, isTheKernelHeap);

	if (err == KErrNone && iAllocatorType == EAllocator)

		{

		// We've no reason to assume it's an allocator because we don't know the iAllocatorAddress actually is an RAllocator*

		err = KErrNotFound;

		}

	if (err && aChunkMaxSize > 0)

		{

		TInt oldErr = err;

		TAllocatorType oldType = iAllocatorType;

		// Try middle of chunk, in case it's an RHybridHeap

		iAllocatorAddress += aChunkMaxSize / 2;

		err = IdentifyAllocatorType(udeb, isTheKernelHeap);

		if (err || iAllocatorType == EAllocator)

			{

			// No better than before

			iAllocatorAddress = aChunkBase;

			iAllocatorType = oldType;

			err = oldErr;

			}

		}

#ifdef __KERNEL_MODE__

	if (err == KErrNone)

		{

		// Now we know the allocator, we can figure out the udeb-ness

		RAllocator* kernelAllocator = reinterpret_cast<RAllocator*>(iAllocatorAddress);

		kernelAllocator->DebugFunction(RAllocator::ESetFail, (TAny*)9999, (TAny*)0); // Use an invalid fail reason - this should have no effect on the operation of the heap

		TInt err = kernelAllocator->DebugFunction(7, NULL, NULL); // 7 is RAllocator::TAllocDebugOp::EGetFail

		if (err == 9999)

			{

			// udeb new hybrid heap

			udeb = ETrue;

			}

		else if (err == KErrNotSupported)

			{

			// Old heap - fall back to slightly nasty non-thread-safe method

			kernelAllocator->DebugFunction(RAllocator::ESetFail, (TAny*)RAllocator::EFailNext, (TAny*)1);

			TAny* res = Kern::Alloc(4);

			if (!res) udeb = ETrue;

			Kern::Free(res);

			}

		else

			{

			// it's new urel

			}

		// Put everything back

		kernelAllocator->DebugFunction(RAllocator::ESetFail, (TAny*)RAllocator::ENone, (TAny*)0);

		// And update the type now we know the udeb-ness for certain

		err = IdentifyAllocatorType(udeb, isTheKernelHeap);

		}

#endif

	return err;

	}

// The guts of RAllocatorHelper

enum TWhatToGet

	{

	ECommitted = 1,

	EAllocated = 2,

	ECount = 4,

	EMaxSize = 8,

	EUnusedPages = 16,

	ECommittedFreeSpace = 32,

	EMinSize = 64,

	EHybridStats = 128,

	};

class RHackAllocator : public RAllocator

	{

public:

	using RAllocator::iHandles;

	using RAllocator::iTotalAllocSize;

	using RAllocator::iCellCount;

	};

class RHackHeap : public RHeap

	{

public:

	// Careful, only allowed to use things that are still in the new RHeap, and are still in the same place

	using RHeap::iMaxLength;

	using RHeap::iChunkHandle;

	using RHeap::iLock;

	using RHeap::iBase;

	using RHeap::iAlign;

	using RHeap::iTop;

	};

const TInt KChunkSizeOffset = 30*4;

const TInt KPageMapOffset = 141*4;

//const TInt KDlOnlyOffset = 33*4;

const TInt KMallocStateOffset = 34*4;

const TInt KMallocStateTopSizeOffset = 3*4;

const TInt KMallocStateTopOffset = 5*4;

const TInt KMallocStateSegOffset = 105*4;

const TInt KUserHybridHeapSize = 186*4;

const TInt KSparePageOffset = 167*4;

const TInt KPartialPageOffset = 165*4;

const TInt KFullSlabOffset = 166*4;

const TInt KSlabAllocOffset = 172*4;

const TInt KSlabParentOffset = 1*4;

const TInt KSlabChild1Offset = 2*4;

const TInt KSlabChild2Offset = 3*4;

const TInt KSlabPayloadOffset = 4*4;

const TInt KSlabsetSize = 4;

#ifdef TEST_HYBRIDHEAP_ASSERTS

__ASSERT_COMPILE(_FOFF(RHybridHeap, iChunkSize) == KChunkSizeOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iPageMap) == KPageMapOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iGlobalMallocState) == KMallocStateOffset);

__ASSERT_COMPILE(sizeof(malloc_state) == 107*4);

__ASSERT_COMPILE(_FOFF(malloc_state, iTopSize) == KMallocStateTopSizeOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, iTop) == KMallocStateTopOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, iSeg) == KMallocStateSegOffset);

__ASSERT_COMPILE(sizeof(RHybridHeap) == KUserHybridHeapSize);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iSparePage) == KSparePageOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iPartialPage) == KPartialPageOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iSlabAlloc) == KSlabAllocOffset);

__ASSERT_COMPILE(_FOFF(slab, iParent) == KSlabParentOffset);

__ASSERT_COMPILE(_FOFF(slab, iChild1) == KSlabChild1Offset);

__ASSERT_COMPILE(_FOFF(slab, iChild2) == KSlabChild2Offset);

__ASSERT_COMPILE(_FOFF(slab, iPayload) == KSlabPayloadOffset);

__ASSERT_COMPILE(sizeof(slabset) == KSlabsetSize);

#endif

TInt RAllocatorHelper::TryLock()

	{

#ifdef __KERNEL_MODE__

	NKern::ThreadEnterCS();

	DMutex* m = *(DMutex**)(iAllocatorAddress + _FOFF(RHackHeap, iLock));

	if (m) Kern::MutexWait(*m);

	return KErrNone;

#else

	if (iAllocatorType != EUnknown && iAllocatorType != EAllocator)

		{

		RFastLock& lock = *reinterpret_cast<RFastLock*>(iAllocatorAddress + _FOFF(RHackHeap, iLock));

		lock.Wait();

		return KErrNone;

		}

	return KErrNotSupported;

#endif

	}

void RAllocatorHelper::TryUnlock()

	{

#ifdef __KERNEL_MODE__

	DMutex* m = *(DMutex**)(iAllocatorAddress + _FOFF(RHackHeap, iLock));

	if (m) Kern::MutexSignal(*m);

	NKern::ThreadLeaveCS();

#else

	if (iAllocatorType != EUnknown && iAllocatorType != EAllocator)

		{

		RFastLock& lock = *reinterpret_cast<RFastLock*>(iAllocatorAddress + _FOFF(RHackHeap, iLock));

		lock.Signal();

		}

#endif

	}

HUEXPORT_C void RAllocatorHelper::Close()

	{

	KERN_ENTER_CS();

	iAllocatorType = EUnknown;

	iAllocatorAddress = 0;