// Copyright (c) 2008-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\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()

	{

	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;

	}