// Copyright (c) 2005-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_demandpaging.cpp

// 

//

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

#include "d_demandpaging.h"

/// Page attributes, cut-n-paste'd from mmubase.h

enum TType

	{

//	EInvalid=0,			// No physical RAM exists for this page

//	EFixed=1,			// RAM fixed at boot time

//	EUnused=2,			// Page is unused

//	EChunk=3,

//	ECodeSeg=4,

//	EHwChunk=5,

//	EPageTable=6,

//	EPageDir=7,

//	EPtInfo=8,

//	EShadow=9,

	EPagedROM=10,

	EPagedCode=11,

	EPagedData=12,

	EPagedCache=13,

	EPagedFree=14,

	};

enum TState

	{

	EStateNormal = 0,		// no special state

	EStatePagedYoung = 1,

	EStatePagedOld = 2,

	EStatePagedDead = 3,

	EStatePagedLocked = 4

	};

//

// Class definitions

//

class DDemandPagingTestFactory : public DLogicalDevice

	{

public:

	~DDemandPagingTestFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

class DDemandPagingTestChannel : public DLogicalChannelBase

	{

public:

	DDemandPagingTestChannel();

	~DDemandPagingTestChannel();

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	TInt LockTest(const TAny* aBuffer, TInt aSize);

	TInt LockTest2();

	TInt DoConsumeContiguousRamTest(TInt aAlign, TInt aPages);

	TInt DoCreatePlatHwChunk(TInt aSize, TAny* aLinAddr);

	TInt DoDestroyPlatHwChunk();

	TInt ReadHoldingMutexTest(TAny* aDest);

	TBool CheckPagedIn(TLinAddr aAddress);

	TBool CheckPagedOut(TLinAddr aAddress);

	TBool CheckLocked(TLinAddr aAddress);

	TInt FreeRam();

public:

	DDemandPagingTestFactory*	iFactory;

	DDemandPagingLock iLock;

	DPlatChunkHw* iHwChunk;

    TInt iChunkSize;

	TPhysAddr iPhysBase;		// This will be base physical address of the chunk

    TLinAddr iLinearBase;		// This will be base linear address of the chunk

	};

//

// DDemandPagingTestFactory

//

TInt DDemandPagingTestFactory::Install()

	{

	return SetName(&KDemandPagingTestLddName);

	}

DDemandPagingTestFactory::~DDemandPagingTestFactory()

	{

	}

void DDemandPagingTestFactory::GetCaps(TDes8& /*aDes*/) const

	{

	// Not used but required as DLogicalDevice::GetCaps is pure virtual

	}

TInt DDemandPagingTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = NULL;

	DDemandPagingTestChannel* channel=new DDemandPagingTestChannel;

	if(!channel)

		return KErrNoMemory;

	channel->iFactory = this;

	aChannel = channel;

	return KErrNone;

	}

DECLARE_STANDARD_LDD()

	{

	return new DDemandPagingTestFactory;

	}

//

// DDemandPagingTestChannel

//

TInt DDemandPagingTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	return KErrNone;

	}

DDemandPagingTestChannel::DDemandPagingTestChannel()

	{

	}

DDemandPagingTestChannel::~DDemandPagingTestChannel()

	{

	DoDestroyPlatHwChunk();

	}

TInt DDemandPagingTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	switch(aFunction)

		{

	case RDemandPagingTestLdd::ELockTest:

		{

		TInt r = LockTest(a1,(TInt)a2);

		if (r == KErrNone)

			r = LockTest2();

		return r;

		}

	case RDemandPagingTestLdd::ESetRealtimeTrace:

		{

#if defined(_DEBUG)

		TUint32 bit = TUint32(1<<(KREALTIME&31));

		__e32_atomic_axo_ord32(&Kern::SuperPage().iDebugMask[KREALTIME>>5], ~bit, a1?bit:0);

#if 0 // can enable this to help debugging

		bit = (1<<(KPAGING&31));

		__e32_atomic_axo_ord32(&Kern::SuperPage().iDebugMask[KPAGING>>5], ~bit, a1?bit:0);

#endif

#endif //_DEBUG

		}

		return KErrNone;

	case RDemandPagingTestLdd::EDoConsumeContiguousRamTest:

		{

		return DDemandPagingTestChannel::DoConsumeContiguousRamTest((TInt)a1, (TInt)a2);

		}

	case RDemandPagingTestLdd::ECreatePlatHwChunk:

		{

		return DDemandPagingTestChannel::DoCreatePlatHwChunk((TInt)a1, a2);

		}

	case RDemandPagingTestLdd::EDestroyPlatHwChunk:

		{

		return DDemandPagingTestChannel::DoDestroyPlatHwChunk();

		}

	case RDemandPagingTestLdd::ELock:

		{

		TInt r=iLock.Alloc((TInt)a2);

		if(r!=KErrNone)

			return r;

		return iLock.Lock(&Kern::CurrentThread(),(TLinAddr)a1,(TInt)a2);

		}

	case RDemandPagingTestLdd::EUnlock:

		{

		iLock.Free();

		return KErrNone;

		}

	case RDemandPagingTestLdd::EReadHoldingMutexTest:

		return ReadHoldingMutexTest((TAny*)a1);

	default:

		return KErrNotSupported;

		}

	}

// 

// DDemandPagingTestChannel::DoCreatePlatHwChunk

//

// For some of the tests of IPC from demand-paged memory, we need a writable

// globally-mapped buffer; so this function creates a suitable chunk and

// returns its (global, virtual) address to the userland caller.  The caller

// should call DoDestroyPlatHwChunk() to release the memory when the tests

// are finished.

//

TInt DDemandPagingTestChannel::DoCreatePlatHwChunk(TInt aSize, TAny* aLinAddr)

	{

	TInt mapAttr = EMapAttrUserRw;		// Supervisor and user both have read/write permissions

	NKern::ThreadEnterCS();

	if (iHwChunk)						// Only one chunk at a atime

		{

		NKern::ThreadLeaveCS();

		return KErrAlreadyExists;

		}

	iChunkSize = Kern::RoundToPageSize(aSize);

	Kern::Printf("*** Attempting to allocate contiguous physical RAM ***");

	TInt free = Kern::FreeRamInBytes();

	Kern::Printf("      requested:  %08x", iChunkSize);

	Kern::Printf("      total free: %08x", free);

	TInt r = Epoc::AllocPhysicalRam(iChunkSize, iPhysBase, 0);	// Allocate RAM; result in iPhysBase

	if (r)

		{

		NKern::ThreadLeaveCS();

		Kern::Printf("      failed with error %d", r);

		return r;

		}

	else

		Kern::Printf("      success");

	r = DPlatChunkHw::New(iHwChunk, iPhysBase, iChunkSize, mapAttr);	// Create chunk

	if (r)

		{

		Epoc::FreePhysicalRam(iPhysBase, iChunkSize);

		iHwChunk = 0;

		NKern::ThreadLeaveCS();

		return r;

		}

	NKern::ThreadLeaveCS();

	// Return the virtual address to userland

	iLinearBase = iHwChunk->LinearAddress();

	kumemput(aLinAddr, &iLinearBase, sizeof(iLinearBase));

	Kern::Printf("CreatePlatHwChunk@%08x: iLinearBase %08x, iPhysBase %08x, size %d",

		iHwChunk, iLinearBase, iPhysBase, iChunkSize);

	return KErrNone;

	}

TInt DDemandPagingTestChannel::DoDestroyPlatHwChunk()

	{

	Kern::Printf("DestroyPlatHwChunk@%08x: iLinearBase %08x, iPhysBase %08x, size %d",

		iHwChunk, iLinearBase, iPhysBase, iChunkSize);

	NKern::ThreadEnterCS();

	if (iHwChunk)

		{

		iHwChunk->Close(NULL);

		Epoc::FreePhysicalRam(iPhysBase, iChunkSize);

		iPhysBase = 0;

		iChunkSize = 0;

		iHwChunk = 0;

		}

	NKern::ThreadLeaveCS();

	return KErrNone;

	}

// 

// DDemandPagingTestChannel::DoConsumeContiguousRamTest

//

// This test attempts to consume all available Contiguous Ram until we need to ask the 

// demand paging code to release memory for it.

// 

// On completion free all the memory allocated.

//

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

TInt DDemandPagingTestChannel::DoConsumeContiguousRamTest(TInt aAlign, TInt aSize)

	{

	TInt retVal = KErrNone;

	TInt initialFreeRam = FreeRam();

	TInt totalBlocks = initialFreeRam/aSize;

	NKern::ThreadEnterCS();

	TPhysAddr*	 pAddrArray = (TPhysAddr *)Kern::Alloc(sizeof(TPhysAddr) * totalBlocks);

	NKern::ThreadLeaveCS();

	CHECK(pAddrArray);

	if(!pAddrArray)

		return retVal;

	SVMCacheInfo tempPages;

	// get the initial free ram again as the heap may have grabbed a page during the alloc

	initialFreeRam = FreeRam();

	Kern::Printf("ConsumeContiguousRamTest: align %d size %d initialFreeRam %d", aAlign, aSize, initialFreeRam);

	CHECK(Kern::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0) == KErrNone);

	Kern::Printf("Start cache info: iMinSize %d iMaxSize %d iCurrentSize %d iMaxFreeSize %d",

				 tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize ,tempPages.iMaxFreeSize);

	TInt initialFreePages = tempPages.iMaxFreeSize;

	CHECK(initialFreePages != 0);

	// allocate blocks to use up RAM until we fail to allocate any further...

	TBool freedPagesToAlloc = EFalse;

	TInt index;

	TUint32 alignMask = (1 << aAlign) - 1;

	for (index = 0; index < totalBlocks; )

		{

		CHECK(Kern::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0) == KErrNone);

		TInt beforePages = tempPages.iMaxFreeSize;

		NKern::ThreadEnterCS();

		TInt r = Epoc::AllocPhysicalRam(aSize, pAddrArray[index], aAlign);

		if(r==KErrNone)

			{

			// check the alignment of the returned pages

			CHECK((pAddrArray[index] & alignMask) == 0);

			++index;

			}

		NKern::ThreadLeaveCS();

		if(r!=KErrNone)

			{

			break;

			}

		CHECK(Kern::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0) == KErrNone);

		TInt afterPages = tempPages.iMaxFreeSize;

		if (afterPages != beforePages)

			freedPagesToAlloc = ETrue; // the alloc reclaimed memory from the paging cache

		}

	if (!index)

		Kern::Printf("WARNING : DoConsumeContiguousRamTest no allocations were successful");

	// free the memory we allocated...

	while(--index>=0)

		{

		NKern::ThreadEnterCS();

		TInt r = Epoc::FreePhysicalRam(pAddrArray[index], aSize);

		NKern::ThreadLeaveCS();

		CHECK(r==KErrNone);

		}

	CHECK(FreeRam() == initialFreeRam);

	NKern::ThreadEnterCS();

	Kern::Free(pAddrArray);

	NKern::ThreadLeaveCS();

	CHECK(Kern::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0) == KErrNone);

	Kern::Printf("End cache info: iMinSize %d iMaxSize %d iCurrentSize %d iMaxFreeSize %d",

				 tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize ,tempPages.iMaxFreeSize);

	if (!freedPagesToAlloc)

		Kern::Printf("WARNING : DoConsumeContiguousRamTest freedPagesToAlloc was eFalse");

	//CHECK(freedPagesToAlloc);		

	return retVal;

	}

#undef CHECK

TUint8 ReadByte(volatile TUint8* aPtr)

	{

	return *aPtr;

	}

#define CHECK(c) { if(!(c)) return __LINE__; }

#define READ(a) ReadByte((volatile TUint8*)(a))

TInt DDemandPagingTestChannel::LockTest(const TAny* aBuffer, TInt aSize)

	{

	// Get page size info

	TInt pageSize = 0;

	CHECK(Kern::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0)==KErrNone);

	TInt pageMask = pageSize-1;

	// See if were running of the Flexible Memory Model

  	TUint32 memModelAttrib = (TUint32)Kern::HalFunction(EHalGroupKernel,EKernelHalMemModelInfo,0,0);	

	TBool fmm = (memModelAttrib&EMemModelTypeMask)==EMemModelTypeFlexible;

	// Round buffer to page boundaries

	TLinAddr start = ((TLinAddr)aBuffer+pageMask)&~pageMask;

	TLinAddr end = ((TLinAddr)aBuffer+aSize)&~pageMask;

	aSize = end-start;

	Kern::Printf("Test buffer is %08x, %x\n",start,aSize);

	CHECK(aSize>pageSize*2);

	// Flush all paged memory

	Kern::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);

	TInt initialFreeRam;

	TInt freeRam1;

	TInt freeRam2;

	TLinAddr addr;

	TUint lockBytesUsed = fmm ? 0 : 0; // free ram change on locking (zero or aSize depending on implementation)

	{ // this brace is essential for correctness

	DDemandPagingLock lock2; // construct a lock;

	Kern::Printf("Check reading from buffer pages it in\n");

	for(addr=start; addr<end; addr+=pageSize) READ(addr);

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckPagedIn(addr));

	initialFreeRam = FreeRam();

	Kern::Printf("Check Alloc reserves pages\n");

	CHECK(iLock.Alloc(aSize)==KErrNone);

	freeRam1 = FreeRam();

	Kern::Printf("Check flushing pages out the buffer\n");

	Kern::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckPagedOut(addr));

	Kern::Printf("Check Lock\n");

	CHECK(iLock.Lock(&Kern::CurrentThread(),start,aSize));

	CHECK((TUint)FreeRam()==TUint(freeRam1-lockBytesUsed));

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckLocked(addr));

	Kern::Printf("Check flushing doesn't page out the buffer\n");

	Kern::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckLocked(addr));

	CHECK((TUint)FreeRam()==TUint(freeRam1-lockBytesUsed));

	Kern::Printf("Check second Alloc\n");

	CHECK(lock2.Alloc(aSize)==KErrNone);

	freeRam2 = FreeRam();

	Kern::Printf("Check second Lock\n");

	CHECK(lock2.Lock(&Kern::CurrentThread(),start,aSize));

	CHECK(FreeRam()==freeRam2);

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckLocked(addr));

	Kern::Printf("Check deleting second lock\n");

	// lock2 is deleted here because it goes out of scope...

	} // this brace is essential for correctness

	CHECK((TUint)FreeRam()==TUint(freeRam1-lockBytesUsed));

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckLocked(addr));

	Kern::Printf("Check Unlock\n");

	iLock.Unlock();

	CHECK(FreeRam()==freeRam1);

	for(addr=start; addr<end; addr+=pageSize) CHECK(CheckPagedIn(addr));

	iLock.Unlock();

	CHECK(FreeRam()==initialFreeRam);

	Kern::Printf("Check Free\n");

	iLock.Free();

	CHECK(FreeRam()==initialFreeRam);

	iLock.Free();

	CHECK(FreeRam()==initialFreeRam);

	return KErrNone;

	}

#undef CHECK

#define CHECK(c) { if(!(c)) { r = __LINE__; goto cleanup; } }

TInt DDemandPagingTestChannel::LockTest2()

	{

	Kern::Printf("Check allocating locks eventually increases size of live list\n");

	TInt r = KErrNone;

	DDemandPagingLock* lock = NULL;

	RPointerArray<DDemandPagingLock> lockArray;

	const TInt KLockMax = 1000; // make this a bit bigger than current min page count?

	TInt i;

	NKern::ThreadEnterCS();

	for (i = 0 ; i < KLockMax ; ++i)

		{

		lock = new DDemandPagingLock;

		CHECK(lock);

		CHECK(lockArray.Append(lock) == KErrNone);

		lock = NULL;

		TInt initialFreeRam = FreeRam();

		CHECK(lockArray[i]->Alloc(1) == KErrNone);

		if (FreeRam() < initialFreeRam)

			{

			Kern::Printf("Live list size increased after %d locks allocated", i + 1);

			break;

			}

		}

	CHECK(i < KLockMax);

cleanup:

	delete lock;

	lock = NULL;

	for (i = 0 ; i < lockArray.Count() ; ++i)

		{

		delete lockArray[i];

		lockArray[i] = NULL;

		}

	lockArray.Reset();

	NKern::ThreadLeaveCS();

	return r;

	}

TInt DDemandPagingTestChannel::FreeRam()

	{

	Kern::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

	TInt freeRam = Kern::FreeRamInBytes();

	Kern::Printf("...free RAM: %x\n",freeRam);

	return freeRam;

	}

TUint32 PageState(TLinAddr aAddress)

	{

	TUint32 state = Kern::HalFunction(EHalGroupVM, EVMPageState, (TAny*)aAddress, 0);

	Kern::Printf("PageState: %08x=%08x",aAddress,state);

	return state;

	}

TBool DDemandPagingTestChannel::CheckPagedIn(TLinAddr aAddress)

	{

	TUint32 state = PageState(aAddress);

	return (state&0xff00) == (EStatePagedYoung<<8);

	}

TBool DDemandPagingTestChannel::CheckPagedOut(TLinAddr aAddress)

	{

	TUint32 state = PageState(aAddress);

	return (state&0xffff) == 0;

	}

TInt DDemandPagingTestChannel::CheckLocked(TLinAddr aAddress)

	{

	TUint32 state = PageState(aAddress);

	return (state&0xff00) == (EStatePagedLocked<<8);

	}

TInt DDemandPagingTestChannel::ReadHoldingMutexTest(TAny* aDest)

	{

	_LIT(KMutexName, "DPTestMutex");

	NKern::ThreadEnterCS();

	DMutex* mutex;

	TInt r = Kern::MutexCreate(mutex, KMutexName, KMutexOrdDebug);  // Mutex order < demand paging

	if (r != KErrNone)

		{

		NKern::ThreadLeaveCS();

		return r;

		}

	Kern::MutexWait(*mutex);

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

	TLinAddr unpagedRomStart = (TLinAddr)&romHeader;

	TLinAddr unpagedRomEnd;

	if (romHeader.iPageableRomStart)

		unpagedRomEnd = unpagedRomStart + romHeader.iPageableRomStart;

	else

		unpagedRomEnd = unpagedRomStart + romHeader.iUncompressedSize;

	const TInt length = 16;

	TUint8 localBuf[length];

	if(!aDest)

		aDest = localBuf;

	Kern::Printf("Local buffer at %08x", aDest);

	TAny* src1 = (TAny*)unpagedRomStart;

	TAny* src2 = (TAny*)(unpagedRomEnd - length);

	DThread* thread = &Kern::CurrentThread();

	Kern::Printf("Attempting to access %08x", src1);

	Kern::ThreadRawWrite(thread, aDest, src1, length);

	Kern::Printf("Attempting to access %08x", src2);

	Kern::ThreadRawWrite(thread, aDest, src2, length);

	TUint8 stackData[length];

	Kern::Printf("Attempting to access %08x", stackData);

	Kern::ThreadRawWrite(thread, aDest, stackData, length);

	TAny* heapData = Kern::Alloc(length);

	if (heapData)

		{

		Kern::Printf("Attempting to access %08x", heapData);

		Kern::ThreadRawWrite(thread, aDest, heapData, length);

		Kern::Free(heapData);

		}

	else

		r = KErrNoMemory;

	Kern::MutexSignal(*mutex);

	mutex->Close(NULL);

	NKern::ThreadLeaveCS();

	return r;  // a kernel fault indicates that the test failed

	}