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

//

#include "heaputils.h"

#ifdef __KERNEL_MODE__

#include <kern_priv.h>

#define MEM Kern

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

#define KERN_ENTER_CS() NKern::ThreadEnterCS()

#define KERN_LEAVE_CS() NKern::ThreadLeaveCS()

#define LOG(args...)

#define HUEXPORT_C

#include <e32std.h>

#define MEM User

#define KERN_ENTER_CS()

#define KERN_LEAVE_CS()

#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()

#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__

TLinAddr LtkUtils::RAllocatorHelper::GetKernelAllocator(DChunk* aKernelChunk) 

    {    

    TLinAddr allocatorAddress;

#ifdef __WINS__

    allocatorAddress = (TLinAddr)aKernelChunk->Base();

#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);

    allocatorAddress = heap;

#endif

    return allocatorAddress;

    }

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();

    iAllocatorAddress = GetKernelAllocator(foundChunk);

    // It looks like DChunk::iBase/DChunk::iFixedBase should both be ok for the kernel chunk

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

	TInt err = OpenChunkHeap((TLinAddr)foundChunk->Base(), 0); 

	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::RUserAllocatorHelper::RUserAllocatorHelper()

	: iThread(NULL)

	{}

void LtkUtils::RUserAllocatorHelper::Close()

	{

	NKern::ThreadEnterCS();

	if (iThread)

		{

		iThread->Close(NULL);

		}

	iThread = NULL;

	RAllocatorHelper::Close();

	NKern::ThreadLeaveCS();

	}

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

	{

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

	}

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

	{

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

	}

TInt LtkUtils::RUserAllocatorHelper::TryLock()

	{

	return KErrNotSupported;

	}

void LtkUtils::RUserAllocatorHelper::TryUnlock()

	{

	// Not supported

	}

TInt LtkUtils::RUserAllocatorHelper::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;

	}

LtkUtils::RKernelCopyAllocatorHelper::RKernelCopyAllocatorHelper()

    : iCopiedChunk(NULL), iOffset(0)

TInt LtkUtils::RKernelCopyAllocatorHelper::OpenCopiedHeap(DChunk* aOriginalChunk, DChunk* aCopiedChunk, TInt aOffset)

    {

    TInt err = aCopiedChunk->Open();

    if (!err)

        {

        iCopiedChunk = aCopiedChunk;

        iOffset = aOffset;

        // We need to set iAllocatorAddress to point to the allocator in the original chunk and not the copy

        // because all the internal pointers will be relative to that. Instead we use iOffset in the Read / Write Data 

        // calls

        iAllocatorAddress = GetKernelAllocator(aOriginalChunk);

        // It looks like DChunk::iBase/DChunk::iFixedBase should both be ok for the kernel chunk

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

        err = OpenChunkHeap((TLinAddr)aCopiedChunk->Base(), 0);

        }

    return err;

    }

DChunk* LtkUtils::RKernelCopyAllocatorHelper::OpenUnderlyingChunk()

    {

    // We should never get here

    __NK_ASSERT_ALWAYS(EFalse);

    return NULL;

    }

void LtkUtils::RKernelCopyAllocatorHelper::Close()

    {

    if (iCopiedChunk)

        {

        NKern::ThreadEnterCS();

        iCopiedChunk->Close(NULL);

        iCopiedChunk = NULL;

        NKern::ThreadLeaveCS();

        }

    iOffset = 0;

    RAllocatorHelper::Close();

    }

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

    {

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

    return KErrNone;

    }

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

    {

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

    return KErrNone;

    }

TInt LtkUtils::RKernelCopyAllocatorHelper::TryLock()

    {

    return KErrNotSupported;

    }

void LtkUtils::RKernelCopyAllocatorHelper::TryUnlock()

    {

    // Not supported

    }

#endif // __KERNEL_MODE__

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

	{

#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);

		{

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

		err = KErrNotFound;

		}

		{

		TInt oldErr = err;

		TAllocatorType oldType = iAllocatorType;

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

		iAllocatorAddress += aChunkMaxSize / 2;

		err = IdentifyAllocatorType(udeb, isTheKernelHeap);

			{

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