// Copyright (c) 2008-2010 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\t_pin.cpp
// Tests kernel APIs for logical pinning by pinning memory and using a realtime thread to check that
// no page faults are taken while accessing it.
// 
//

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32svr.h>
#include <e32rom.h>
#include <e32kpan.h>
#include <u32hal.h>
#include <dptest.h>
#include "d_memorytest.h"
#include "t_codepaging_dll.h"
#include "mmudetect.h"
#include "freeram.h"

RTest test(_L("T_PIN"));

_LIT(KTCodePagingDll4, "t_codepaging_dll4.dll");
const TInt KMinBufferSize = 16384;

RMemoryTestLdd Ldd;
RMemoryTestLdd Ldd2;
RLibrary PagedLibrary;
const TUint8* PagedBuffer = NULL;
const TUint8* UnpagedBuffer = NULL;
TInt PageSize;

TInt FreeRamNoWait()
	{
	TMemoryInfoV1Buf meminfo;
	UserHal::MemoryInfo(meminfo);
	return meminfo().iFreeRamInBytes;
	}

void CheckMemoryPresent(const TUint8* aBuffer, TInt aSize, TBool aExpected)
	{
	if (aExpected)
		test.Printf(_L("  Checking memory at %08x is present\n"), aBuffer);
	else
		test.Printf(_L("  Checking memory at %08x is not present\n"), aBuffer);
	for (TInt i = 0 ; i < aSize ; i += PageSize)
		test_Equal(aExpected, Ldd.IsMemoryPresent(aBuffer + i));
	}

void FlushPagingCache()
	{
	test_KErrNone(DPTest::FlushCache());
	}

void TestPinVirtualMemoryUnpaged()
	{
	test.Printf(_L("Create logical pin object\n"));
	test_KErrNone(Ldd.CreateVirtualPinObject());
#ifdef __EPOC32__
	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, 0));
	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());
	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, KMinBufferSize));
	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());
	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
#else
	// Don't check for memory presence on emulator as paging not supported.
	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, 0));
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());
	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, KMinBufferSize));
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());
#endif
	test.Printf(_L("Perform logical unpin operation (again)\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());	// test double unpin ok
	test.Printf(_L("Destroy logical pin object\n"));
	test_KErrNone(Ldd.DestroyVirtualPinObject());
	test.Printf(_L("Destroy logical pin object (again)\n"));
	test_KErrNone(Ldd.DestroyVirtualPinObject());  // test double destroy ok
	}

void TestPinPhysicalMemory()
	{
	
	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
	if (mm < EMemModelTypeFlexible)
		{
		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
		return;
		}
	TInt i;
	TInt8* UCBase;
	RChunk chunk;

	test.Printf(_L("Allocate user chunk\n"));
	TChunkCreateInfo createInfo;
	createInfo.SetDisconnected(0,KUCPageCount*PageSize,KUCPageCount*PageSize);
	createInfo.SetPaging(TChunkCreateInfo::EPaged);
	test_KErrNone(chunk.Create(createInfo));
	UCBase = (TInt8*)chunk.Base();
	
	test.Printf(_L("Create physical pin object\n"));
	test_KErrNone(Ldd.CreatePhysicalPinObject());

	test.Printf(_L("Perform physical pin operation on zero-length buffer\n"));
	test_KErrNone(Ldd.PinPhysicalMemory((TLinAddr)UCBase, 0));	

	test.Printf(_L("Perform physical unpin operation\n"));
	test_KErrNone(Ldd.UnpinPhysicalMemory());	

	test.Printf(_L("Perform Physical pin operation on the chunk\n"));
	test_KErrNone(Ldd.PinPhysicalMemory((TLinAddr)UCBase, KUCPageCount*PageSize));	

	test.Printf(_L("Test that pinned physical memory preserves its mapping when recommited\n"));
	test_KErrNone(chunk.Decommit(0,KUCPageCount*PageSize));							 //Decommit all
	for (i=KUCPageCount-1;i>=0;i--) test_KErrNone(chunk.Commit(i*PageSize,PageSize)); //Commit in reverse order
	for (i=0;i<KUCPageCount;i++) // Recommited memory is not paged in. So, write into each page, before driver 
		{						// calls Kern::LinearToPhysical or it will get KErrInvalidMemory in return.
		volatile TInt8* ptr = (volatile TInt8*)(UCBase+i*PageSize);
		*ptr = 10;
		}
	test_KErrNone(Ldd.CheckPageList(chunk.Base())); 					// Check that the mapping is preserved. 	
	
	test.Printf(_L("Sync cache & memory of User Chunk\n"));//Test Cache::SyncPhysicalMemoryBeforeDmaWrite
	test_KErrNone(Ldd.SyncPinnedPhysicalMemory(0,KUCPageCount*PageSize));

	test.Printf(_L("Invalidate cache of User Chunk\n"));//Test Cache::SyncPhysicalMemoryBefore/AfterDmaRead
	test_KErrNone(Ldd.InvalidatePinnedPhysicalMemory(0,KUCPageCount*PageSize));
	
	test.Printf(_L("Try to move pinned phys. memory...\n")); //RAM defrag should return error code here.
	i = Ldd.MovePinnedPhysicalMemory(0);
	test.Printf(_L("...returned %d\n"),i);
	test(i!=KErrNone);

	test.Printf(_L("Close the chunk\n")); // Phys. memory is pinned and shouldn't be ...
	chunk.Close();						  // ... mapped to another virtual memory.

	test.Printf(_L("Allocate & initilise the second chunk\n"));// Kernel sholudn't commit pinned physical memory ...
	test_KErrNone(chunk.CreateLocal(KUCPageCount*PageSize,KUCPageCount*PageSize));   // ...that has been just decommited from the first chunk.
	UCBase = (TInt8*)chunk.Base();
	for (i=0;i<KUCPageCount*PageSize;i++) UCBase[i]=0; //Initialise user buffer

	test.Printf(_L("Invalidate cache of pinned memory\n"));//This shouldn't affect the second chunk.
	test_KErrNone(Ldd.InvalidatePinnedPhysicalMemory(0,KUCPageCount*PageSize));

	test.Printf(_L("Check data in the second chunk is unaffected\n"));
	for (i=0;i<KUCPageCount*PageSize;i++) test(UCBase[i]==0);
	
	test.Printf(_L("Close the second chunk\n"));
	chunk.Close();

	test.Printf(_L("Perform physical unpin operation\n"));
	test_KErrNone(Ldd.UnpinPhysicalMemory());	

	test.Printf(_L("Perform physical unpin operation (again)\n"));
	test_KErrNone(Ldd.UnpinPhysicalMemory());	// test double unpin ok

	test.Printf(_L("Destroy physical pin object\n"));
	test_KErrNone(Ldd.DestroyPhysicalPinObject());

	test.Printf(_L("Destroy physical pin object (again)\n"));
	test_KErrNone(Ldd.DestroyPhysicalPinObject());  // test double destroy ok

	test.Printf(_L("Test phys. pinning and sync of kernel memory.\n"));
	test_KErrNone(Ldd.PinKernelPhysicalMemory());// Simple test of phys. pinning of kernel memory
	}

void TestPhysicalPinOutOfMemory()
	{
	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
	if (mm < EMemModelTypeFlexible)
		{
		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
		return;
		}
	
	TInt8* UCBase;
	RChunk chunk;

	test.Printf(_L("Allocate user chunk\n"));
	test_KErrNone(chunk.CreateDisconnectedLocal(0,KUCPageCount*PageSize,KUCPageCount*PageSize));
	UCBase = (TInt8*)chunk.Base();
	
	const TInt KMaxKernelAllocations = 1024;
	TInt r=KErrNoMemory;
	TInt i;

	__KHEAP_MARK;
	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
		{
		__KHEAP_FAILNEXT(i);
		test.Printf(_L("Create physical pin object\n"));
		r = Ldd.CreatePhysicalPinObject();
		__KHEAP_RESET;
		}
	test.Printf(_L("Create physical pin object took %d tries\n"),i);
	test_KErrNone(r);

	r = KErrNoMemory;

	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
		{
		__KHEAP_FAILNEXT(i);
		test.Printf(_L("Perform physical pin operation\n"));
		r = Ldd.PinPhysicalMemory((TLinAddr)UCBase, KUCPageCount*PageSize);
		__KHEAP_RESET;
		}
	test.Printf(_L("Perform physical pin operation took %d tries\n"),i);
	if (r == KErrNone)
		{
		test.Printf(_L("Perform physical unpin operation\n"));
		Ldd.UnpinPhysicalMemory();
		}

	test.Printf(_L("Destroy physical pin object\n"));
	Ldd.DestroyPhysicalPinObject();

	// wait for any async cleanup in the supervisor to finish first...
	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
	__KHEAP_MARKEND;

	test.Printf(_L("Close the chunk\n"));
	chunk.Close();
	
	test_KErrNone(r);
	}


void TestPinVirtualMemoryInvalid()
	{
	test.Printf(_L("Create logical pin object\n"));
	test_KErrNone(Ldd.CreateVirtualPinObject());
	test.Printf(_L("Attempt logical pin on bad memory address\n"));
	TLinAddr bad = (TLinAddr)0x10000;
	TInt r = Ldd.PinVirtualMemory(bad,KMinBufferSize);
	test.Printf(_L("%08x r=%d"),bad,r);
	if(r==KErrNone)
		test_KErrNone(Ldd.UnpinVirtualMemory());	
	if ((MemModelAttributes() & EMemModelTypeMask) == EMemModelTypeMultiple)
		{
		// test unused part of code chunk...
		bad = (TLinAddr)0x7f000000;
		r = Ldd.PinVirtualMemory(bad,KMinBufferSize);
		test.Printf(_L("%08x r=%d"),bad,r);
		if(r==KErrNone)
			test_KErrNone(Ldd.UnpinVirtualMemory());	
		}
	test.Printf(_L("Destroy logical pin object\n"));
	test_KErrNone(Ldd.DestroyVirtualPinObject());
	}

void TestPinVirtualMemoryPaged()
	{
	test.Printf(_L("Create logical pin object\n"));
	test_KErrNone(Ldd.CreateVirtualPinObject());
	FlushPagingCache();
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)PagedBuffer, 0));	
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());	
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)PagedBuffer, KMinBufferSize));	
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
	FlushPagingCache();
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
	test.Printf(_L("Perform logical unpin operation\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());	
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
	FlushPagingCache();
	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
	test.Printf(_L("Perform logical unpin operation (again)\n"));
	test_KErrNone(Ldd.UnpinVirtualMemory());	// test double unpin ok
	test.Printf(_L("Destroy logical pin object\n"));
	test_KErrNone(Ldd.DestroyVirtualPinObject());
	test.Printf(_L("Destroy logical pin object (again)\n"));
	test_KErrNone(Ldd.DestroyVirtualPinObject());  // test double destroy ok
	}


volatile TBool SoakEnd = false;

class TRandom
	{
public:
	TRandom(TUint32 aSeed)
		: iSeed(aSeed) {};
	inline TUint32 Next()
		{ iSeed = iSeed*69069+1; return iSeed; }
	TUint32 operator()(TUint32 aRange)
		{ return (TUint32)((TUint64(Next())*TUint64(aRange))>>32); }
private:
	TUint iSeed;
	};

#define SOAK_CHECK(r)												\
	if(r!=KErrNone)													\
		{															\
		RDebug::Printf("SOAK_CHECK fail at line %d",__LINE__);		\
		return r;													\
		}															\

TInt SoakThread(TAny*)
	{
	RMemoryTestLdd ldd;
	TInt r = ldd.Open();
	SOAK_CHECK(r)

	r = ldd.CreateVirtualPinObject();
	SOAK_CHECK(r)

	TRandom random((TUint32)&ldd);

	while(!SoakEnd)
		{
		TUint start = random(KMinBufferSize);
		TUint end = random(KMinBufferSize);
		if(start>end)
			{
			TUint temp = start;
			start = end;
			end = temp;
			}
		const TUint32 KPageMask = 0xfff;
		start &= ~KPageMask;
		end = (end+KPageMask)&~KPageMask;

		r = ldd.PinVirtualMemory((TLinAddr)(PagedBuffer+start),end-start);
		SOAK_CHECK(r)

		r = ldd.UnpinVirtualMemory();
		SOAK_CHECK(r)
		}

	r = ldd.DestroyVirtualPinObject();
	SOAK_CHECK(r)

	CLOSE_AND_WAIT(ldd);
	return KErrNone;
	}


void TestPinVirtualMemoryPagedSoak()
	{
	test.Start(_L("Create timer"));
	RTimer timer;
	test_KErrNone(timer.CreateLocal());

	test.Next(_L("Create threads"));
	const TUint KNumThreads = 4;
	TRequestStatus status[KNumThreads];
	RThread thread[KNumThreads];
	TUint i;
	for(i=0; i<KNumThreads; i++)
		{
		test_KErrNone(thread[i].Create(KNullDesC, SoakThread, 0x1000, NULL, 0));
		thread[i].Logon(status[i]);
		test(status[i].Int()==KRequestPending);
		}

	test.Next(_L("Start threads"));
	RThread().SetPriority(EPriorityMore); // make sure we are higher priority than soak threads
	for(i=0; i<KNumThreads; i++)
		thread[i].Resume();

	test.Next(_L("Wait..."));
	TRequestStatus timeoutStatus;
	timer.After(timeoutStatus,10*1000000);
	User::WaitForAnyRequest();
	test_KErrNone(timeoutStatus.Int()); // we should have timed out if soak threads are still running OK

	test.Next(_L("Stop threads and check results"));
	for(i=0; i<KNumThreads; i++)
		test_Equal(KRequestPending,status[i].Int());
	SoakEnd = true;
	timer.After(timeoutStatus,10*1000000);
	for(i=0; i<KNumThreads; i++)
		{
		User::WaitForAnyRequest();
		test_Equal(KRequestPending,timeoutStatus.Int());
		}
	timer.Cancel();
	User::WaitForRequest(timeoutStatus);
	RThread().SetPriority(EPriorityNormal); // restore thread priority

	// cleanup...
	CLOSE_AND_WAIT(timer);
	for(i=0; i<KNumThreads; i++)
		CLOSE_AND_WAIT(thread[i]);

	test.End();
	}


void TestPinVirtualMemoryDecommit()
	{
	const TInt KChunk = 4*1024*1024; // offset of page table boundary on X86 and ARM
	const TInt KPage = PageSize;
	const TInt TestData[][2] =
		{
			{0,				KPage},
			{KPage,			KPage},
			{KPage,			2*KPage},
			{KChunk-KPage,	KPage},
			{KChunk-2*KPage,2*KPage},
			{KChunk-KPage,	2*KPage},
			{0,0} // end marker
		};

	for(TInt i=0; TestData[i][1]; ++i)
		{
		TInt commitOffset = TestData[i][0];
		TInt commitSize = TestData[i][1];
		test.Printf(_L("Create chunk 0x%x+0x%x\n"),commitOffset,commitSize);

		TChunkCreateInfo createInfo;
		createInfo.SetDisconnected(commitOffset,commitOffset+commitSize,commitOffset+commitSize);
		createInfo.SetPaging(TChunkCreateInfo::EPaged);
		RChunk chunk;
		test_KErrNone(chunk.Create(createInfo));
		TUint8* buffer = chunk.Base()+commitOffset;
		TUint bufferSize = commitSize;
		FlushPagingCache(); // start with blank slate as far as paged memory is concerned

		test.Printf(_L("Create virtual pin object\n"));
		test_KErrNone(Ldd.CreateVirtualPinObject());
		test_KErrNone(Ldd2.CreateVirtualPinObject());
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		TInt initialFreeRam = FreeRam();

		test.Printf(_L("Pin memory\n"));
		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		TInt pinnedFreeRam = FreeRam();
		test_Compare(pinnedFreeRam,<,initialFreeRam);
		TUint8 c = *buffer;
		memset(buffer,~c,bufferSize); // invert memory

		test.Printf(_L("Decommit pinned memory\n"));
		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam()); // decommited memory should not be freed as it is pinned

		test.Printf(_L("Unpin memory\n"));
		test_KErrNone(Ldd.UnpinVirtualMemory());	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed

		//
		// test recommitting decommitted pinned memory...
		//

		test.Printf(_L("Commit memory\n"));
		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(initialFreeRam,FreeRam());

		test.Printf(_L("Read memory\n"));
		volatile TUint8* p = buffer;
		volatile TUint8* pEnd = buffer+bufferSize;
		while(p<pEnd)
			test_Equal(c,*p++); // memory should have been wiped
		test_Equal(initialFreeRam,FreeRam()); // memory now paged in

		test.Printf(_L("Pin memory which is already paged in\n"));
		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		test_Equal(pinnedFreeRam,FreeRam());
		memset(buffer,~c,bufferSize); // invert memory

		test.Printf(_L("Decommit pinned memory\n"));
		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam());

		test.Printf(_L("Commit pinned memory again\n"));
		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam());
		p = buffer;
		pEnd = buffer+bufferSize;
		while(p<pEnd)
			test_Equal(c,*p++); // memory should have been wiped

		test.Printf(_L("Unpin memory\n"));
		test_KErrNone(Ldd.UnpinVirtualMemory());	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		test_Equal(initialFreeRam,FreeRam());

		test.Printf(_L("Decommit memory\n"));
		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Compare(FreeRam(),<=,initialFreeRam);

		//
		// test pin twice...
		//

		test.Printf(_L("Commit memory\n"));
		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(initialFreeRam,FreeRam());

		test.Printf(_L("Pin memory\n"));
		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		test_Equal(pinnedFreeRam,FreeRam());

		test.Printf(_L("Pin memory again\n"));
		test_KErrNone(Ldd2.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		test_Equal(pinnedFreeRam,FreeRam());

		test.Printf(_L("Decommit pinned memory\n"));
		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam()); // decommited memory should not be freed as it is pinned

		test.Printf(_L("Unpin memory\n"));
		test_KErrNone(Ldd2.UnpinVirtualMemory());	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam()); // memory shouldn't be freed as another pin exists

		test.Printf(_L("Unpin memory again\n"));
		test_KErrNone(Ldd.UnpinVirtualMemory());	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed

		//
		// test page stealing of decommited memory
		//

		test.Printf(_L("Commit memory\n"));
		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(initialFreeRam,FreeRam());

		test.Printf(_L("Pin memory\n"));
		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
		CheckMemoryPresent(buffer, bufferSize, ETrue);
		test_Equal(pinnedFreeRam,FreeRam());

		test.Printf(_L("Decommit pinned memory\n"));
		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
		CheckMemoryPresent(buffer, bufferSize, EFalse);
		test_Equal(pinnedFreeRam,FreeRam());

		test.Printf(_L("Unpin memory a higher priority that supervisor thread\n"));
		RThread().SetPriority(EPriorityRealTime);
		test_KErrNone(Ldd.UnpinVirtualMemory());	
		// on single core system, supervisor thread can't run and free pages yet
		// because we're a higher priority...
		test.Printf(_L("memory freed = %d\n"),initialFreeRam==FreeRamNoWait());

		test.Printf(_L("Force decommited unpinned pages out of live list\n"));
		FlushPagingCache();
		RThread().SetPriority(EPriorityNormal);
		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed

		//
		// cleanup...
		//

		test.Printf(_L("Destroy pin object\n"));
		test_KErrNone(Ldd.DestroyVirtualPinObject());
		test_KErrNone(Ldd2.DestroyVirtualPinObject());
		chunk.Close();
		}

	test.Printf(_L("Flush paging cache\n"));
	FlushPagingCache(); // this is a test that has shown up bugs in the past
	}


void TestPinOutOfMemory()
	{
	// Ensure that if pinning fails with KErrNoMemory,
	// there isn't a memory leak
	const TInt KMaxKernelAllocations = 1024;
	TInt r=KErrNoMemory;
	TInt i;
	const TUint8* buffer = NULL;
	if (PagedBuffer)
		{
		buffer = PagedBuffer;
		}
	else
		{
		buffer = UnpagedBuffer;
		}
	test_NotNull(buffer);

	__KHEAP_MARK;
	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
		{
		__KHEAP_FAILNEXT(i);
		test.Printf(_L("Create logical pin object\n"));
		r = Ldd.CreateVirtualPinObject();
		__KHEAP_RESET;
		}
	test.Printf(_L("Create logical pin object took %d tries\n"),i);
	test_KErrNone(r);

	r = KErrNoMemory;
	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
		{
		__KHEAP_FAILNEXT(i);
		test.Printf(_L("Perform logical pin operation\n"));
		r = Ldd.PinVirtualMemory((TLinAddr)buffer, KMinBufferSize);
		__KHEAP_RESET;
		}
	test.Printf(_L("Perform logical pin operation took %d tries\n"),i);
	if (r == KErrNone)
		{
		test.Printf(_L("Perform logical unpin operation\n"));
		Ldd.UnpinVirtualMemory();
		}
	
	test.Printf(_L("Destroy logical pin object\n"));
	Ldd.DestroyVirtualPinObject();
	// wait for any async cleanup in the supervisor to finish first...
	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
	__KHEAP_MARKEND;

	test_KErrNone(r);
	}


TInt KernelModifyData(TAny*)
	{
	Ldd.KernelMapReadAndModifyMemory();
	return KErrNone;
	}

void TestMapAndPinMemory()
	{
	
	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
	if (mm < EMemModelTypeFlexible)
		{
		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
		return;
		}
	TInt i;
	TUint KUCBytes = KUCPageCount * PageSize;
	RChunk chunk;

	test.Printf(_L("Allocate user chunk\n"));
	TChunkCreateInfo createInfo;
	createInfo.SetDisconnected(0, KUCBytes, KUCBytes);
	createInfo.SetPaging(TChunkCreateInfo::EPaged);
	test_KErrNone(chunk.Create(createInfo));
	TUint8* chunkBase = (TUint8*)chunk.Base();
	
	test.Printf(_L("Create kernel map object\n"));
	test_KErrNone(Ldd.CreateKernelMapObject(0));

	test.Printf(_L("Perform kernel map operation on zero-length buffer\n"));
	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunkBase, 0));	

	test.Printf(_L("Perform kernel unmap operation\n"));
	test_KErrNone(Ldd.KernelUnmapMemory());	

	test.Printf(_L("Perform kernel map operation on the chunk\n"));
	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunkBase, KUCBytes));

	test.Printf(_L("Attempt to map the memory again while already mapped\n"));
	test_Equal(KErrInUse, Ldd.KernelMapMemory((TLinAddr)chunkBase, KUCBytes));

	test.Printf(_L("Use the kernel mapping to modify the data and verify it\n"));
	TUint8* p = chunkBase;
	for (i = 0; i < (TInt)KUCBytes; i++)
		*p++ = (TUint8)i;
	test_KErrNone(Ldd.KernelMapReadAndModifyMemory());
	p = chunkBase;
	for (i = 0; i < (TInt)KUCBytes; i++)
		test_Equal((TUint8)(i + 1), *p++);	

	test.Printf(_L("Test that kernel mapped memory preserves its mapping when recommited\n"));
	test_KErrNone(chunk.Decommit(0,KUCPageCount*PageSize));							 //Decommit all
	for (i=KUCPageCount-1;i>=0;i--) test_KErrNone(chunk.Commit(i*PageSize,PageSize)); //Commit in reverse order
	for (i=0;i<KUCPageCount;i++) // Recommited memory is not paged in. So, write into each page, before driver 
		{						// calls Kern::LinearToPhysical or it will get KErrInvalidMemory in return.
		volatile TInt8* ptr = (volatile TInt8*)(chunkBase+i*PageSize);
		*ptr = 10;
		}
	test_KErrNone(Ldd.KernelMapCheckPageList(chunkBase)); 	// Check that the mapping is preserved. 	
	
	test.Printf(_L("Sync cache & memory of User Chunk\n"));	//Test Cache::SyncMemoryBeforeDmaWrite
	test_KErrNone(Ldd.KernelMapSyncMemory());

	test.Printf(_L("Invalidate cache of User Chunk\n"));//Test Cache::SyncMemoryBefore/AfterDmaRead
	test_KErrNone(Ldd.KernelMapInvalidateMemory());
	
	test.Printf(_L("Try to move kernel map memory...\n")); //RAM defrag should return error code here.
	for (i = 0; i < KUCPageCount; i++)
		{
		TInt r = Ldd.KernelMapMoveMemory(0);
		test.Printf(_L("...[%d] returned %d\n"), i, r);
		test(r != KErrNone);
		}

	test.Printf(_L("Unmap the memory and attempt to map with invalid attributes\n"));
	test_KErrNone(Ldd.KernelUnmapMemory());
	test_Equal(KErrArgument, Ldd.KernelMapMemoryInvalid((TLinAddr)chunkBase, KUCBytes));

	test.Printf(_L("Map the memory read only and attempt to modify it kernel side\n"));
	test_KErrNone(Ldd.KernelMapMemoryRO((TLinAddr)chunkBase, KUCBytes));
	// Reset the contents of the memory.
	p = chunkBase;
	for (i = 0; i < (TInt)KUCBytes; i++)
		*p++ = (TUint8)i;

	RThread modThread;
	test_KErrNone(modThread.Create(KNullDesC, KernelModifyData, PageSize, PageSize, PageSize, (TAny*)NULL));
	TRequestStatus status;
	modThread.Logon(status);
	test_Equal(KRequestPending, status.Int());
	modThread.Resume();
	User::WaitForRequest(status);
	test_Equal(EExitPanic, modThread.ExitType());
	test(modThread.ExitCategory() == _L("KERN-EXEC"));
	test_Equal(ECausedException, modThread.ExitReason());
	CLOSE_AND_WAIT(modThread);

	test.Printf(_L("Close the chunk\n")); // Phys. memory is pinned and shouldn't be ...
	chunk.Close();						  // ... mapped to another virtual memory.

	test.Printf(_L("Allocate & initilise the second chunk\n"));// Kernel shouldn't commit pinned physical memory ...
	test_KErrNone(chunk.CreateLocal(KUCBytes, KUCBytes));   // ...that has just been decommited from the first chunk.
	chunkBase = (TUint8*)chunk.Base();
	for (i = 0; i < KUCPageCount * PageSize; i++) 
		chunkBase[i] = 0; //Initialise user buffer

	test.Printf(_L("Invalidate cache of pinned memory\n"));//This shouldn't affect the second chunk.
	test_KErrNone(Ldd.KernelMapInvalidateMemory());

	test.Printf(_L("Check data in the second chunk is unaffected\n"));
	for (i=0; i < KUCPageCount * PageSize; i++) 
		test(chunkBase[i]==0);
	
	test.Printf(_L("Close the second chunk\n"));
	chunk.Close();

	test.Printf(_L("Perform kernel unmap operation\n"));
	test_KErrNone(Ldd.KernelUnmapMemory());	

	test.Printf(_L("Perform physical unpin operation (again)\n"));
	test_KErrNone(Ldd.KernelUnmapMemory());	// test double unpin ok

	test.Printf(_L("Destroy physical pin object\n"));
	test_KErrNone(Ldd.DestroyKernelMapObject());

	test.Printf(_L("Destroy physical pin object (again)\n"));
	test_KErrNone(Ldd.DestroyKernelMapObject());  // test double destroy ok

	//
	//	Test a kernel mapping with preserved resources doesn't allocate when mapping and pinning.
	//
	test.Printf(_L("Create a pre-reserving kernel mapping object\n"));
	TUint mappingSize = KUCBytes>>1;
	// This test step relies on mapping objet being smaller than the user chunk
	// and as mapping object will always be >=2 pages, user chunk must be at least 4.
	__ASSERT_COMPILE(KUCPageCount >= 4);
	test_KErrNone(Ldd.CreateKernelMapObject(mappingSize));
	TChunkCreateInfo chunkInfo;
	chunkInfo.SetNormal(KUCBytes, KUCBytes);
	chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged);
	test_KErrNone(chunk.Create(chunkInfo));

	test.Printf(_L("Map and pin an unpaged chunk with pre-reserved resources\n"));
	__KHEAP_FAILNEXT(1);	// Ensure any attempted kernel heap allocations fail.
	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunk.Base(), mappingSize));
	test_KErrNone(Ldd.KernelUnmapMemory());

	test.Printf(_L("Map more memory than we have pre-reserved resources for\n"));
	test_Equal(KErrArgument, Ldd.KernelMapMemory((TLinAddr)chunk.Base(), mappingSize*2));

	test.Printf(_L("Destroy the kernel map object with pre-reserved resources\n"));
	test_KErrNone(Ldd.DestroyKernelMapObject());	// This will also unpin the memory.
	// Clear the kernel heap fail next.
	__KHEAP_RESET;
	chunk.Close();
	}

TInt E32Main()
	{
	COMPLETE_POST_BOOT_SYSTEM_TASKS();
	test.Title();
	test.Start(_L("Test kernel pinning APIs"));

	if (DPTest::Attributes() & DPTest::ERomPaging)
		test.Printf(_L("Rom paging supported\n"));
	if (DPTest::Attributes() & DPTest::ECodePaging)
		test.Printf(_L("Code paging supported\n"));
	if (DPTest::Attributes() & DPTest::EDataPaging)
		test.Printf(_L("Data paging supported\n"));
	
	test.Next(_L("Loading test drivers"));
	test_KErrNone(Ldd.Open());
	test_KErrNone(Ldd2.Open());

	test.Next(_L("Getting page size"));
	test_KErrNone(UserSvr::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&PageSize,0));
	
	test.Next(_L("Setting up paged and unpaged buffers"));

#ifdef __EPOC32__
	// Use unpaged rom for our unpaged buffer
	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
	UnpagedBuffer = (TUint8*)romHeader;
	TInt size = romHeader->iPageableRomStart ? romHeader->iPageableRomStart : romHeader->iUncompressedSize;
	test(size >= KMinBufferSize);
	
	if (DPTest::Attributes() & DPTest::ERomPaging)
		{
		// Use end of paged ROM for our paged buffer
		test(romHeader->iPageableRomStart);
		TInt offset = romHeader->iPageableRomStart + romHeader->iPageableRomSize - KMinBufferSize;
		offset &= ~0xfff;
		test(offset>=romHeader->iPageableRomStart);
		PagedBuffer = (TUint8*)romHeader + offset;
		}
	else if (DPTest::Attributes() & DPTest::ECodePaging)
		{
		// Use code paged DLL for our paged buffer
		test_KErrNone(PagedLibrary.Load(KTCodePagingDll4));		
		TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)PagedLibrary.Lookup(KGetAddressOfDataFunctionOrdinal);
		TInt size;
		PagedBuffer = (TUint8*)func(size);
		test_NotNull(PagedBuffer);
		test(size >= KMinBufferSize);
		}
#else
	UnpagedBuffer = (TUint8*)User::Alloc(KMinBufferSize);
	test_NotNull(UnpagedBuffer);
#endif

	RDebug::Printf("UnpagedBuffer=%x\n",UnpagedBuffer);
	RDebug::Printf("PagedBuffer=%x\n",PagedBuffer);

	__KHEAP_MARK;
	
	test.Next(_L("Logical pin unpaged memory"));
	TestPinVirtualMemoryUnpaged();

	test.Next(_L("Logical pin invalid memory"));
	TestPinVirtualMemoryInvalid();

	test.Next(_L("Physical pinning"));
	TestPinPhysicalMemory();
	
	test.Next(_L("Physical pinning OOM"));
	TestPhysicalPinOutOfMemory();

	test.Next(_L("Kernel pin mapping"));
	TestMapAndPinMemory();

	test.Next(_L("Pin OOM Tests"));
	TestPinOutOfMemory();

	if (PagedBuffer)
		{
		test.Next(_L("Logical pin paged memory"));
		TestPinVirtualMemoryPaged();

		test.Next(_L("Logical pin paged memory soak test"));
		TestPinVirtualMemoryPagedSoak();
		}

	if (DPTest::Attributes() & DPTest::EDataPaging)
		{
		test.Next(_L("Logical pin then decommit memory"));
		TestPinVirtualMemoryDecommit();
		}

	// wait for any async cleanup in the supervisor to finish first...
	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
	__KHEAP_MARKEND;

#ifndef __EPOC32__
	User::Free((TAny*)UnpagedBuffer);
#endif

	PagedLibrary.Close();
	Ldd.Close();
	Ldd2.Close();
	test.End();

	return KErrNone;
	}
