// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// e32test\mmu\d_memorytest.cpp
// 
//

#include <kernel/kern_priv.h>
#include <kernel/cache.h>
#include "d_memorytest.h"

//
// Class definitions
//

class DMemoryTestFactory : public DLogicalDevice
	{
public:
	~DMemoryTestFactory();
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

class DMemoryTestChannel : public DLogicalChannelBase
	{
public:
	DMemoryTestChannel();
	~DMemoryTestChannel();
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);
private:
	TInt TestAllocZerosMemory();
	TInt TestReAllocZerosMemory();
	TInt AllocTest1();
	TInt ReAllocTest1();
	TInt ReAllocTest2(TUint8*& mem1, TUint8*& mem2, TUint8*& mem3);
	TInt AllocPhysTest(TUint32 aIters, TUint32 aSize); 
	TInt AllocPhysTest1(TUint32 aIters, TUint32 aSize); 
public:
	DMemoryTestFactory*	iFactory;
	TVirtualPinObject* iVirtualPinObject;
	
	struct{
		TPhysicalPinObject* iObject;
		TPhysAddr iPhysAddr;
		TPhysAddr iPhysPageList[KUCPageCount];
		TUint 	iColour;
		TUint32 iActualMapAttr;
		}iPhysicalPinning;

	struct{
		TKernelMapObject* iObject;
		TPhysAddr iPhysPageList[KUCPageCount];
		TLinAddr iLinAddr;
		}iKernelMapping;

	TUint32 iPageSize;
	};

//
// DMemoryTestFactory
//

TInt DMemoryTestFactory::Install()
	{
	return SetName(&KMemoryTestLddName);
	}

DMemoryTestFactory::~DMemoryTestFactory()
	{
	}

void DMemoryTestFactory::GetCaps(TDes8& /*aDes*/) const
	{
	// Not used but required as DLogicalDevice::GetCaps is pure virtual
	}

TInt DMemoryTestFactory::Create(DLogicalChannelBase*& aChannel)
	{
	aChannel = NULL;
	DMemoryTestChannel* channel=new DMemoryTestChannel;
	if(!channel)
		return KErrNoMemory;
	channel->iFactory = this;
	aChannel = channel;
	return KErrNone;
	}

DECLARE_STANDARD_LDD()
	{
	return new DMemoryTestFactory;
	}

//
// DMemoryTestChannel
//

TInt DMemoryTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
	return KErrNone;
	}

DMemoryTestChannel::DMemoryTestChannel()
	{
	iPageSize = Kern::RoundToPageSize(1);
	}

DMemoryTestChannel::~DMemoryTestChannel()
	{
	Kern::DestroyVirtualPinObject(iVirtualPinObject);
	}


TInt DMemoryTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)
	{
	TInt r=KErrNotSupported;

	switch(aFunction)
		{
	case RMemoryTestLdd::EReadWriteMemory:
	case RMemoryTestLdd::EReadMemory:
	case RMemoryTestLdd::EWriteMemory:
		{
		TUint32 value=(TUint32)a2;
#ifdef _DEBUG
		TInt debugMask = Kern::CurrentThread().iDebugMask;
		Kern::CurrentThread().iDebugMask = debugMask&~(1<<KPANIC);
#endif
		XTRAP(r, XT_DEFAULT,
			if(aFunction==RMemoryTestLdd::EReadWriteMemory)
				{
				kumemget32(&value,a1,4);
				kumemput32(a1,&value,4);
				}
			else if(aFunction==RMemoryTestLdd::EReadMemory)
				kumemget32(&value,a1,4);
			else if(aFunction==RMemoryTestLdd::EWriteMemory)
				kumemput32(a1,&value,4);
			);
#ifdef _DEBUG
		Kern::CurrentThread().iDebugMask = debugMask;
#endif
		if(aFunction==RMemoryTestLdd::EReadMemory)
			kumemput32(a2,&value,sizeof(value));

		return r;
		}

	case RMemoryTestLdd::ETestAllocZerosMemory:
	case RMemoryTestLdd::ETestReAllocZerosMemory:
		{
		NKern::ThreadEnterCS();		
		TInt r;
		if (aFunction==RMemoryTestLdd::ETestAllocZerosMemory)
			r=TestAllocZerosMemory();
		else
			r=TestReAllocZerosMemory();
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::ETestAllocPhysTest:
		{
		NKern::ThreadEnterCS();
		r=AllocPhysTest((TUint32)a1,(TUint32)a2);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::ETestAllocPhysTest1:
		{
		NKern::ThreadEnterCS();
		r=AllocPhysTest1((TUint32)a1,(TUint32)a2);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::ECreateVirtualPinObject:
		{
		NKern::ThreadEnterCS();
		r=Kern::CreateVirtualPinObject(iVirtualPinObject);
		NKern::ThreadLeaveCS();
		return r;
		}
		
	case RMemoryTestLdd::EPinVirtualMemory:
		return Kern::PinVirtualMemory(iVirtualPinObject, (TLinAddr)a1, (TUint)a2);

	case RMemoryTestLdd::EUnpinVirtualMemory:
		Kern::UnpinVirtualMemory(iVirtualPinObject);
		return KErrNone;

	case RMemoryTestLdd::EDestroyVirtualPinObject:
		{
		NKern::ThreadEnterCS();
		Kern::DestroyVirtualPinObject(iVirtualPinObject);
		NKern::ThreadLeaveCS();
		return KErrNone;
		}

	case RMemoryTestLdd::ESetPanicTrace:
		{
		TBool old = false;
#ifdef _DEBUG
		DThread& thread = Kern::CurrentThread();
		TInt debugMask = thread.iDebugMask;
		if(debugMask&(1<<KPANIC))
			old = true;
		if(a1)
			debugMask |= (1<<KPANIC);
		else
			debugMask &= ~(1<<KPANIC);
		thread.iDebugMask = debugMask;
#endif
		return old;
		}

	case RMemoryTestLdd::EIsMemoryPresent:
#ifndef __WINS__
		return Epoc::LinearToPhysical((TLinAddr)a1) != KPhysAddrInvalid;
#else
		Kern::PanicCurrentThread(_L("IsMemoryPresent should not be used on the emulator"), KErrNotSupported);
		return KErrNotSupported;
#endif

	case RMemoryTestLdd::ECreatePhysicalPinObject:
		{
		NKern::ThreadEnterCS();
		r=Kern::CreatePhysicalPinObject(iPhysicalPinning.iObject);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::EPinPhysicalMemory:
		return Kern::PinPhysicalMemory(iPhysicalPinning.iObject, (TLinAddr)a1, (TUint)a2, EFalse, iPhysicalPinning.iPhysAddr,
							iPhysicalPinning.iPhysPageList, iPhysicalPinning.iActualMapAttr, iPhysicalPinning.iColour, NULL);

	case RMemoryTestLdd::EPinPhysicalMemoryRO:
		return Kern::PinPhysicalMemory(iPhysicalPinning.iObject, (TLinAddr)a1, (TUint)a2, ETrue, iPhysicalPinning.iPhysAddr,
							iPhysicalPinning.iPhysPageList, iPhysicalPinning.iActualMapAttr, iPhysicalPinning.iColour, NULL);

	case RMemoryTestLdd::ECheckPageList:
		{
#ifdef __WINS__
		return KErrNotSupported;
#else
		TInt i;
		for (i=0;i<KUCPageCount; i++)
			{
			TPhysAddr addr = Epoc::LinearToPhysical((TLinAddr)a1 + i*iPageSize);
			if (addr==KPhysAddrInvalid) 				 return KErrGeneral;
			if (addr!=iPhysicalPinning.iPhysPageList[i]) return KErrNotFound;
			}
		return KErrNone;
#endif		
		}

	case RMemoryTestLdd::ESyncPinnedPhysicalMemory:
		return Cache::SyncPhysicalMemoryBeforeDmaWrite(iPhysicalPinning.iPhysPageList,
									iPhysicalPinning.iColour, (TUint)a1, (TUint)a2, iPhysicalPinning.iActualMapAttr);

	case RMemoryTestLdd::EMovePinnedPhysicalMemory:
		{
#ifdef __WINS__
		return KErrNotSupported;
#else
		TPhysAddr newPage;
		NKern::ThreadEnterCS();
		r = Epoc::MovePhysicalPage(iPhysicalPinning.iPhysPageList[(TUint)a1], newPage);		
		NKern::ThreadLeaveCS();
		return r;
#endif
		}

	case RMemoryTestLdd::EInvalidatePinnedPhysicalMemory:
		{
		r = Cache::SyncPhysicalMemoryBeforeDmaRead(iPhysicalPinning.iPhysPageList,
									iPhysicalPinning.iColour, (TUint)a1, (TUint)a2, iPhysicalPinning.iActualMapAttr);
		if (r==KErrNone)
			r = Cache::SyncPhysicalMemoryAfterDmaRead(iPhysicalPinning.iPhysPageList,
										iPhysicalPinning.iColour, (TUint)a1, (TUint)a2, iPhysicalPinning.iActualMapAttr);
		return r;	
		}
		
	case RMemoryTestLdd::EUnpinPhysicalMemory:
		return Kern::UnpinPhysicalMemory(iPhysicalPinning.iObject);

	case RMemoryTestLdd::EDestroyPhysicalPinObject:
		{
		NKern::ThreadEnterCS();
		r=Kern::DestroyPhysicalPinObject(iPhysicalPinning.iObject);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::EPinKernelPhysicalMemory:
		{
		TPhysicalPinObject* pinObject;
		TPhysAddr aAddress;
		TPhysAddr aPages[2];
		TUint aColour=0;
		TUint32 actualMemAttr;
		NKern::ThreadEnterCS();
		Kern::CreatePhysicalPinObject(pinObject);
		r = Kern::PinPhysicalMemory(pinObject, (TLinAddr)&aAddress, 4, EFalse, aAddress, aPages, actualMemAttr, aColour, NULL);
		Cache::SyncPhysicalMemoryBeforeDmaWrite(aPages, aColour, 10, 30, actualMemAttr);
		Kern::UnpinPhysicalMemory(pinObject);
		Kern::DestroyPhysicalPinObject(pinObject);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::ECreateKernelMapObject:
		{
		NKern::ThreadEnterCS();
		r=Kern::CreateKernelMapObject(iKernelMapping.iObject, (TUint)a1);
		NKern::ThreadLeaveCS();
		return r;
		}

	case RMemoryTestLdd::EKernelMapMemory:
		return Kern::MapAndPinMemory(	iKernelMapping.iObject, NULL, (TLinAddr)a1, (TUint)a2, 0,
										iKernelMapping.iLinAddr, iKernelMapping.iPhysPageList);

	case RMemoryTestLdd::EKernelMapMemoryRO:
		return Kern::MapAndPinMemory(	iKernelMapping.iObject, NULL, (TLinAddr)a1, (TUint)a2, Kern::EKernelMap_ReadOnly,
										iKernelMapping.iLinAddr, iKernelMapping.iPhysPageList);

	case RMemoryTestLdd::EKernelMapMemoryInvalid:
		return Kern::MapAndPinMemory(	iKernelMapping.iObject, NULL, (TLinAddr)a1, (TUint)a2, (TUint)~Kern::EKernelMap_ReadOnly,
										iKernelMapping.iLinAddr, iKernelMapping.iPhysPageList);

	case RMemoryTestLdd::EKernelMapCheckPageList:
		{
#ifdef __WINS__
		return KErrNotSupported;
#else
		TUint i = 0;
		for (; i < (TUint)KUCPageCount; i++)
			{
			// Compare the user side address to physical addresses
			TPhysAddr addr = Epoc::LinearToPhysical((TLinAddr)a1 + i*iPageSize);
			if (addr == KPhysAddrInvalid) 				 
				return KErrGeneral;
			if (addr != iKernelMapping.iPhysPageList[i]) 
				return KErrNotFound;
			// Compare the kernel side address to physical addresses
			addr = Epoc::LinearToPhysical(iKernelMapping.iLinAddr + i*iPageSize);
			if (addr == KPhysAddrInvalid) 				 
				return KErrGeneral;
			if (addr != iKernelMapping.iPhysPageList[i])
				return KErrNotFound;
			}
		return KErrNone;
#endif		
		}

	case RMemoryTestLdd::EKernelMapSyncMemory:
		Cache::SyncMemoryBeforeDmaWrite(iKernelMapping.iLinAddr, KUCPageCount*iPageSize);
		return KErrNone;

	case RMemoryTestLdd::EKernelMapInvalidateMemory:
		{
		Cache::SyncMemoryBeforeDmaRead(iKernelMapping.iLinAddr, KUCPageCount*iPageSize);
		Cache::SyncMemoryAfterDmaRead(iKernelMapping.iLinAddr, KUCPageCount*iPageSize);
		return KErrNone;
		}

	case RMemoryTestLdd::EKernelMapMoveMemory:
		{
#ifdef __WINS__
		return KErrNotSupported;
#else
		TPhysAddr newPage;
		NKern::ThreadEnterCS();
		r = Epoc::MovePhysicalPage(iKernelMapping.iPhysPageList[(TUint)a1], newPage);		
		NKern::ThreadLeaveCS();
		return r;
#endif
		}

	case RMemoryTestLdd::EKernelMapReadModifyMemory:
		{
		TUint8* p = (TUint8*)iKernelMapping.iLinAddr;
		// Verify the contents of the data when accessed via the kernel mapping.
		TUint i = 0;
		for (i = 0; i < KUCPageCount*iPageSize; i++)
			{
			if (*p++ != (TUint8)i)
				return KErrCorrupt;
			}
		// Modify the data via the kernel mapping.
		p = (TUint8*)iKernelMapping.iLinAddr;
		for (i = 0; i < KUCPageCount*iPageSize; i++)
			{
			*p++ = (TUint8)(i + 1);
			}
		return KErrNone;
		}
		
	case RMemoryTestLdd::EKernelUnmapMemory:
		Kern::UnmapAndUnpinMemory(iKernelMapping.iObject);
		return KErrNone;

	case RMemoryTestLdd::EDestroyKernelMapObject:
		{
		NKern::ThreadEnterCS();
		Kern::DestroyKernelMapObject(iKernelMapping.iObject);
		NKern::ThreadLeaveCS();
		return KErrNone;
		}
		
	default:
		return KErrNotSupported;
		}
	}

// Fail a test by returning an error code indicating the problem
#define FAIL_ALLOC_TEST(testIndex, byteOffset, unexepectedValue) \
	err = ((testIndex) << 16) | ((byteOffset) << 8) | (unexepectedValue)

TInt DMemoryTestChannel::TestAllocZerosMemory()
	{
	TInt count = 100;
	TInt r = KErrNotSupported;

	do	{	//re-try up to 100 times if memory conditions are not correct
		r=AllocTest1();
		} while(((r == KErrNoMemory)||(r == KErrUnknown)) && --count);

	return r;
	}

TInt DMemoryTestChannel::AllocTest1()
	{
	const TInt KSize = 256;
	TInt err = KErrNone;
	TUint8* mem1 = (TUint8*)Kern::Alloc(KSize);
	if (!mem1)
		return KErrNoMemory;
	memset(mem1, KSize, 0xff);
	Kern::Free(mem1);
	TUint8* mem2 = (TUint8*)Kern::Alloc(KSize);
	if (!mem2)
		return KErrNoMemory;
	if (mem1 != mem2)
		err = KErrUnknown;	// Test inconclusive, can retry
	for (TInt i = 0 ; i<KSize && err==KErrNone; ++i)
		{
		if (mem2[i] != 0)
			FAIL_ALLOC_TEST(1, i, mem2[i]);
		}
	Kern::Free(mem2);

	return err;
	}

TInt DMemoryTestChannel::TestReAllocZerosMemory()
	{
	TInt count = 100;
	TInt r = KErrNotSupported;

	do	{	//re-try up to 100 times if memory conditions are not correct
		r=ReAllocTest1();
		} while(((r == KErrNoMemory)||(r == KErrUnknown)) && --count);

	if (r!=KErrNone)	
		return r;

	count = 100;
	do	{	//	re-try up to 100 times if memory conditions are not correct
		TUint8* mem1 = NULL;
		TUint8* mem2 = NULL;
		TUint8* mem3 = NULL;
		r=ReAllocTest2(mem1, mem2, mem3);
		if (mem1)
			Kern::Free(mem1);
		if (mem2)
			Kern::Free(mem2);
		if (mem3)
			Kern::Free(mem3);
		} while(((r == KErrNoMemory)||(r == KErrUnknown)) && --count);
	
	return r;
	}

// The actual size of the block allocated given the size requested.
#define ALIGNED_SIZE(aReqSize) (_ALIGN_UP(aReqSize + RHeap::EAllocCellSize, RHeap::ECellAlignment) - RHeap::EAllocCellSize)

// We only acllocate blocks where the size we get is the size we ask for - this
// just makes testing easier.
const TInt KSize = ALIGNED_SIZE(200), KHalfSize = ALIGNED_SIZE(100), KSmallSize = ALIGNED_SIZE(50);

TInt DMemoryTestChannel::ReAllocTest1()
	{
	// Test case where cell grows
	// 
	// Expected heap layout:
	//   1: [-mem1-------]
	//   2: [-mem1-]
	//   3: [-mem1-------]

	TInt err = KErrNone;
	TUint8* mem1 = (TUint8*)Kern::Alloc(KSize); // 1
	if (!mem1)
		return KErrNoMemory;
	memset(mem1, 0xff, KSize);
	TUint8* mem2 = (TUint8*)Kern::ReAlloc(mem1, KHalfSize); // 2
	if (mem1 != mem2)
		{
		mem1 = 0;
		Kern::Free(mem2);
		return KErrUnknown; // Don't expect move on shrink
		}
	mem2 = (TUint8*)Kern::ReAlloc(mem1, KSize); // 3
	if (mem1 != mem2)
		{
		mem1 = 0;
		Kern::Free(mem2);
		return KErrUnknown; // Expect growth into original area
		}
	
	TInt i;
	for (i = 0 ; i<KHalfSize && err==KErrNone; ++i)
		{
		if (mem1[i] != 0xff)
			FAIL_ALLOC_TEST(2, i, mem1[i]);
		}
	for (i = KHalfSize ; i<KSize && err==KErrNone; ++i)
		{
		if (mem1[i] != 0)
			FAIL_ALLOC_TEST(3, i, mem1[i]);
		}

	Kern::Free(mem1);
	return err;
	}

TInt DMemoryTestChannel::ReAllocTest2(TUint8*& mem1, TUint8*& mem2, TUint8*& mem3)
	{	
	// Test case where cell is moved
	// 
	// Expected heap layout:
	//   1: [ mem1 ]
	//   2: [ mem1 ] [ mem2 ]
	//   3: [ mem1 ] [ mem2 ] [ mem3       ]
	//   4:          [ mem2 ] [ mem1       ] 

	mem1 = (TUint8*)Kern::Alloc(KSmallSize); // 1
	if (!mem1)
		return KErrNoMemory;
	memset(mem1, 0xff, KSmallSize);	
	mem2 = (TUint8*)Kern::Alloc(KSmallSize); // 2
	if (!mem2)
		return KErrNoMemory;
	if (mem2 <= (mem1 + KSmallSize))
		return KErrUnknown;	// Expect mem2 higher than mem1
	memset(mem2, 0xee, KSmallSize);		
	mem3 = (TUint8*)Kern::Alloc(KSize); // 3
	if (!mem3)
		return KErrNoMemory;
	if (mem3 <= (mem2 + KSmallSize))
		return KErrUnknown;	// Expect mem3 higher than mem2
	memset(mem3, 0xdd, KSize);
	Kern::Free(mem3);
	TUint8* m3 = mem3;
	mem3 = NULL;
	TUint8* mem4 = (TUint8*)Kern::ReAlloc(mem1, KSize); // 4
	if (!mem4)
		return KErrNoMemory;	
	if (mem4 == mem1)
		return KErrUnknown; // Expect move on grow
	mem1=mem4;
	if (mem4 != m3)
		return KErrUnknown; // Expect to realloc to use old mem3 space
	
	TInt i;
	TInt err = KErrNone;
	for (i = 0 ; i<KSmallSize && err==KErrNone; ++i)
		{
		if (mem1[i] != 0xff)
			FAIL_ALLOC_TEST(4, i, mem1[i]);
		}
	for (i = KSmallSize; i<KSize && err==KErrNone; ++i)
		{
		if (mem1[i] != 0)
			FAIL_ALLOC_TEST(5, i, mem1[i]);
		}

	return err;
	}

#ifdef __EPOC32__
#define CHECK(c) { if(!(c)) { Kern::Printf("Fail  %d", __LINE__); ; ret = __LINE__;} }

TInt DMemoryTestChannel::AllocPhysTest(TUint32 aIters, TUint32 aSize)
	{
	TInt	ret = KErrNone;
	TUint32	index;

	TUint32  pageSize = 0;
	CHECK(Kern::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0)==KErrNone);
	TUint32  numPages = aSize / pageSize;
	TUint32  pageIndex;
	TPhysAddr*	 addrArray = (TPhysAddr *)Kern::AllocZ(sizeof(TPhysAddr) * numPages);
	CHECK(addrArray);
	if(!addrArray)
		{
		return KErrNoMemory;
		}

	for (index = 0; index < aIters; index ++)
		{
		for (pageIndex = 0; pageIndex < numPages; pageIndex ++)
			{
			ret = Epoc::AllocPhysicalRam(pageSize, addrArray[pageIndex], 0);
			if (ret != KErrNone)
				{
				break;
				}
			}
		for (pageIndex = 0; pageIndex < numPages; pageIndex ++)
			{
			if (addrArray[pageIndex])
				{
				Epoc::FreePhysicalRam(addrArray[pageIndex], pageSize);
				addrArray[pageIndex] = NULL;
				}
			}
		if (ret != KErrNone)
			{
			break;
			}
		}

	Kern::Free(addrArray);
	return ret;
	}

#else

TInt DMemoryTestChannel::AllocPhysTest(TUint32 , TUint32 )
	{
	return KErrNone;
	}

#endif

#ifdef __EPOC32__

TInt DMemoryTestChannel::AllocPhysTest1(TUint32 aIters, TUint32 aSize)
	{
	TInt	ret = KErrNone;
	TUint32	index;

	TUint32  pageSize = 0;
	CHECK(Kern::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0)==KErrNone);
	TUint32 numPages = aSize / pageSize;
	TPhysAddr*	 addrArray = (TPhysAddr *)Kern::AllocZ(sizeof(TPhysAddr) * numPages);
	for (index = 0; index < aIters; index ++)
		{
		ret = Epoc::AllocPhysicalRam(numPages, addrArray);
		if (ret != KErrNone)
			{
			break;
			}
		Epoc::FreePhysicalRam(numPages, addrArray);
		}
	Kern::Free(addrArray);
	return ret;
	}
#else

TInt DMemoryTestChannel::AllocPhysTest1(TUint32 , TUint32 )
	{
	return KErrNone;
	}

#endif