sl@0: // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // e32test\mmu\t_pin.cpp
sl@0: // Tests kernel APIs for logical pinning by pinning memory and using a realtime thread to check that
sl@0: // no page faults are taken while accessing it.
sl@0: // 
sl@0: //
sl@0: 
sl@0: #define __E32TEST_EXTENSION__
sl@0: #include <e32test.h>
sl@0: #include <e32svr.h>
sl@0: #include <e32rom.h>
sl@0: #include <e32kpan.h>
sl@0: #include <u32hal.h>
sl@0: #include <dptest.h>
sl@0: #include "d_memorytest.h"
sl@0: #include "t_codepaging_dll.h"
sl@0: #include "mmudetect.h"
sl@0: #include "freeram.h"
sl@0: 
sl@0: RTest test(_L("T_PIN"));
sl@0: 
sl@0: _LIT(KTCodePagingDll4, "t_codepaging_dll4.dll");
sl@0: const TInt KMinBufferSize = 16384;
sl@0: 
sl@0: RMemoryTestLdd Ldd;
sl@0: RMemoryTestLdd Ldd2;
sl@0: RLibrary PagedLibrary;
sl@0: const TUint8* PagedBuffer = NULL;
sl@0: const TUint8* UnpagedBuffer = NULL;
sl@0: TInt PageSize;
sl@0: 
sl@0: TInt FreeRamNoWait()
sl@0: 	{
sl@0: 	TMemoryInfoV1Buf meminfo;
sl@0: 	UserHal::MemoryInfo(meminfo);
sl@0: 	return meminfo().iFreeRamInBytes;
sl@0: 	}
sl@0: 
sl@0: void CheckMemoryPresent(const TUint8* aBuffer, TInt aSize, TBool aExpected)
sl@0: 	{
sl@0: 	if (aExpected)
sl@0: 		test.Printf(_L("  Checking memory at %08x is present\n"), aBuffer);
sl@0: 	else
sl@0: 		test.Printf(_L("  Checking memory at %08x is not present\n"), aBuffer);
sl@0: 	for (TInt i = 0 ; i < aSize ; i += PageSize)
sl@0: 		test_Equal(aExpected, Ldd.IsMemoryPresent(aBuffer + i));
sl@0: 	}
sl@0: 
sl@0: void FlushPagingCache()
sl@0: 	{
sl@0: 	test_KErrNone(DPTest::FlushCache());
sl@0: 	}
sl@0: 
sl@0: void TestPinVirtualMemoryUnpaged()
sl@0: 	{
sl@0: 	test.Printf(_L("Create logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.CreateVirtualPinObject());
sl@0: #ifdef __EPOC32__
sl@0: 	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
sl@0: 	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, 0));
sl@0: 	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());
sl@0: 	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
sl@0: 	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, KMinBufferSize));
sl@0: 	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());
sl@0: 	CheckMemoryPresent(UnpagedBuffer, KMinBufferSize, ETrue);
sl@0: #else
sl@0: 	// Don't check for memory presence on emulator as paging not supported.
sl@0: 	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, 0));
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());
sl@0: 	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)UnpagedBuffer, KMinBufferSize));
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());
sl@0: #endif
sl@0: 	test.Printf(_L("Perform logical unpin operation (again)\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());	// test double unpin ok
sl@0: 	test.Printf(_L("Destroy logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.DestroyVirtualPinObject());
sl@0: 	test.Printf(_L("Destroy logical pin object (again)\n"));
sl@0: 	test_KErrNone(Ldd.DestroyVirtualPinObject());  // test double destroy ok
sl@0: 	}
sl@0: 
sl@0: void TestPinPhysicalMemory()
sl@0: 	{
sl@0: 	
sl@0: 	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
sl@0: 	if (mm < EMemModelTypeFlexible)
sl@0: 		{
sl@0: 		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
sl@0: 		return;
sl@0: 		}
sl@0: 	TInt i;
sl@0: 	TInt8* UCBase;
sl@0: 	RChunk chunk;
sl@0: 
sl@0: 	test.Printf(_L("Allocate user chunk\n"));
sl@0: 	TChunkCreateInfo createInfo;
sl@0: 	createInfo.SetDisconnected(0,KUCPageCount*PageSize,KUCPageCount*PageSize);
sl@0: 	createInfo.SetPaging(TChunkCreateInfo::EPaged);
sl@0: 	test_KErrNone(chunk.Create(createInfo));
sl@0: 	UCBase = (TInt8*)chunk.Base();
sl@0: 	
sl@0: 	test.Printf(_L("Create physical pin object\n"));
sl@0: 	test_KErrNone(Ldd.CreatePhysicalPinObject());
sl@0: 
sl@0: 	test.Printf(_L("Perform physical pin operation on zero-length buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinPhysicalMemory((TLinAddr)UCBase, 0));	
sl@0: 
sl@0: 	test.Printf(_L("Perform physical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinPhysicalMemory());	
sl@0: 
sl@0: 	test.Printf(_L("Perform Physical pin operation on the chunk\n"));
sl@0: 	test_KErrNone(Ldd.PinPhysicalMemory((TLinAddr)UCBase, KUCPageCount*PageSize));	
sl@0: 
sl@0: 	test.Printf(_L("Test that pinned physical memory preserves its mapping when recommited\n"));
sl@0: 	test_KErrNone(chunk.Decommit(0,KUCPageCount*PageSize));							 //Decommit all
sl@0: 	for (i=KUCPageCount-1;i>=0;i--) test_KErrNone(chunk.Commit(i*PageSize,PageSize)); //Commit in reverse order
sl@0: 	for (i=0;i<KUCPageCount;i++) // Recommited memory is not paged in. So, write into each page, before driver 
sl@0: 		{						// calls Kern::LinearToPhysical or it will get KErrInvalidMemory in return.
sl@0: 		volatile TInt8* ptr = (volatile TInt8*)(UCBase+i*PageSize);
sl@0: 		*ptr = 10;
sl@0: 		}
sl@0: 	test_KErrNone(Ldd.CheckPageList(chunk.Base())); 					// Check that the mapping is preserved. 	
sl@0: 	
sl@0: 	test.Printf(_L("Sync cache & memory of User Chunk\n"));//Test Cache::SyncPhysicalMemoryBeforeDmaWrite
sl@0: 	test_KErrNone(Ldd.SyncPinnedPhysicalMemory(0,KUCPageCount*PageSize));
sl@0: 
sl@0: 	test.Printf(_L("Invalidate cache of User Chunk\n"));//Test Cache::SyncPhysicalMemoryBefore/AfterDmaRead
sl@0: 	test_KErrNone(Ldd.InvalidatePinnedPhysicalMemory(0,KUCPageCount*PageSize));
sl@0: 	
sl@0: 	test.Printf(_L("Try to move pinned phys. memory...\n")); //RAM defrag should return error code here.
sl@0: 	i = Ldd.MovePinnedPhysicalMemory(0);
sl@0: 	test.Printf(_L("...returned %d\n"),i);
sl@0: 	test(i!=KErrNone);
sl@0: 
sl@0: 	test.Printf(_L("Close the chunk\n")); // Phys. memory is pinned and shouldn't be ...
sl@0: 	chunk.Close();						  // ... mapped to another virtual memory.
sl@0: 
sl@0: 	test.Printf(_L("Allocate & initilise the second chunk\n"));// Kernel sholudn't commit pinned physical memory ...
sl@0: 	test_KErrNone(chunk.CreateLocal(KUCPageCount*PageSize,KUCPageCount*PageSize));   // ...that has been just decommited from the first chunk.
sl@0: 	UCBase = (TInt8*)chunk.Base();
sl@0: 	for (i=0;i<KUCPageCount*PageSize;i++) UCBase[i]=0; //Initialise user buffer
sl@0: 
sl@0: 	test.Printf(_L("Invalidate cache of pinned memory\n"));//This shouldn't affect the second chunk.
sl@0: 	test_KErrNone(Ldd.InvalidatePinnedPhysicalMemory(0,KUCPageCount*PageSize));
sl@0: 
sl@0: 	test.Printf(_L("Check data in the second chunk is unaffected\n"));
sl@0: 	for (i=0;i<KUCPageCount*PageSize;i++) test(UCBase[i]==0);
sl@0: 	
sl@0: 	test.Printf(_L("Close the second chunk\n"));
sl@0: 	chunk.Close();
sl@0: 
sl@0: 	test.Printf(_L("Perform physical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinPhysicalMemory());	
sl@0: 
sl@0: 	test.Printf(_L("Perform physical unpin operation (again)\n"));
sl@0: 	test_KErrNone(Ldd.UnpinPhysicalMemory());	// test double unpin ok
sl@0: 
sl@0: 	test.Printf(_L("Destroy physical pin object\n"));
sl@0: 	test_KErrNone(Ldd.DestroyPhysicalPinObject());
sl@0: 
sl@0: 	test.Printf(_L("Destroy physical pin object (again)\n"));
sl@0: 	test_KErrNone(Ldd.DestroyPhysicalPinObject());  // test double destroy ok
sl@0: 
sl@0: 	test.Printf(_L("Test phys. pinning and sync of kernel memory.\n"));
sl@0: 	test_KErrNone(Ldd.PinKernelPhysicalMemory());// Simple test of phys. pinning of kernel memory
sl@0: 	}
sl@0: 
sl@0: void TestPhysicalPinOutOfMemory()
sl@0: 	{
sl@0: 	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
sl@0: 	if (mm < EMemModelTypeFlexible)
sl@0: 		{
sl@0: 		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	TInt8* UCBase;
sl@0: 	RChunk chunk;
sl@0: 
sl@0: 	test.Printf(_L("Allocate user chunk\n"));
sl@0: 	test_KErrNone(chunk.CreateDisconnectedLocal(0,KUCPageCount*PageSize,KUCPageCount*PageSize));
sl@0: 	UCBase = (TInt8*)chunk.Base();
sl@0: 	
sl@0: 	const TInt KMaxKernelAllocations = 1024;
sl@0: 	TInt r=KErrNoMemory;
sl@0: 	TInt i;
sl@0: 
sl@0: 	__KHEAP_MARK;
sl@0: 	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
sl@0: 		{
sl@0: 		__KHEAP_FAILNEXT(i);
sl@0: 		test.Printf(_L("Create physical pin object\n"));
sl@0: 		r = Ldd.CreatePhysicalPinObject();
sl@0: 		__KHEAP_RESET;
sl@0: 		}
sl@0: 	test.Printf(_L("Create physical pin object took %d tries\n"),i);
sl@0: 	test_KErrNone(r);
sl@0: 
sl@0: 	r = KErrNoMemory;
sl@0: 
sl@0: 	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
sl@0: 		{
sl@0: 		__KHEAP_FAILNEXT(i);
sl@0: 		test.Printf(_L("Perform physical pin operation\n"));
sl@0: 		r = Ldd.PinPhysicalMemory((TLinAddr)UCBase, KUCPageCount*PageSize);
sl@0: 		__KHEAP_RESET;
sl@0: 		}
sl@0: 	test.Printf(_L("Perform physical pin operation took %d tries\n"),i);
sl@0: 	if (r == KErrNone)
sl@0: 		{
sl@0: 		test.Printf(_L("Perform physical unpin operation\n"));
sl@0: 		Ldd.UnpinPhysicalMemory();
sl@0: 		}
sl@0: 
sl@0: 	test.Printf(_L("Destroy physical pin object\n"));
sl@0: 	Ldd.DestroyPhysicalPinObject();
sl@0: 
sl@0: 	// wait for any async cleanup in the supervisor to finish first...
sl@0: 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
sl@0: 	__KHEAP_MARKEND;
sl@0: 
sl@0: 	test.Printf(_L("Close the chunk\n"));
sl@0: 	chunk.Close();
sl@0: 	
sl@0: 	test_KErrNone(r);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void TestPinVirtualMemoryInvalid()
sl@0: 	{
sl@0: 	test.Printf(_L("Create logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.CreateVirtualPinObject());
sl@0: 	test.Printf(_L("Attempt logical pin on bad memory address\n"));
sl@0: 	TLinAddr bad = (TLinAddr)0x10000;
sl@0: 	TInt r = Ldd.PinVirtualMemory(bad,KMinBufferSize);
sl@0: 	test.Printf(_L("%08x r=%d"),bad,r);
sl@0: 	if(r==KErrNone)
sl@0: 		test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 	if ((MemModelAttributes() & EMemModelTypeMask) == EMemModelTypeMultiple)
sl@0: 		{
sl@0: 		// test unused part of code chunk...
sl@0: 		bad = (TLinAddr)0x7f000000;
sl@0: 		r = Ldd.PinVirtualMemory(bad,KMinBufferSize);
sl@0: 		test.Printf(_L("%08x r=%d"),bad,r);
sl@0: 		if(r==KErrNone)
sl@0: 			test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 		}
sl@0: 	test.Printf(_L("Destroy logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.DestroyVirtualPinObject());
sl@0: 	}
sl@0: 
sl@0: void TestPinVirtualMemoryPaged()
sl@0: 	{
sl@0: 	test.Printf(_L("Create logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.CreateVirtualPinObject());
sl@0: 	FlushPagingCache();
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
sl@0: 	test.Printf(_L("Perform logical pin operation on zero-length buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)PagedBuffer, 0));	
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
sl@0: 	test.Printf(_L("Perform logical pin operation on whole buffer\n"));
sl@0: 	test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)PagedBuffer, KMinBufferSize));	
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
sl@0: 	FlushPagingCache();
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
sl@0: 	test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, ETrue);
sl@0: 	FlushPagingCache();
sl@0: 	CheckMemoryPresent(PagedBuffer, KMinBufferSize, EFalse);
sl@0: 	test.Printf(_L("Perform logical unpin operation (again)\n"));
sl@0: 	test_KErrNone(Ldd.UnpinVirtualMemory());	// test double unpin ok
sl@0: 	test.Printf(_L("Destroy logical pin object\n"));
sl@0: 	test_KErrNone(Ldd.DestroyVirtualPinObject());
sl@0: 	test.Printf(_L("Destroy logical pin object (again)\n"));
sl@0: 	test_KErrNone(Ldd.DestroyVirtualPinObject());  // test double destroy ok
sl@0: 	}
sl@0: 
sl@0: 
sl@0: volatile TBool SoakEnd = false;
sl@0: 
sl@0: class TRandom
sl@0: 	{
sl@0: public:
sl@0: 	TRandom(TUint32 aSeed)
sl@0: 		: iSeed(aSeed) {};
sl@0: 	inline TUint32 Next()
sl@0: 		{ iSeed = iSeed*69069+1; return iSeed; }
sl@0: 	TUint32 operator()(TUint32 aRange)
sl@0: 		{ return (TUint32)((TUint64(Next())*TUint64(aRange))>>32); }
sl@0: private:
sl@0: 	TUint iSeed;
sl@0: 	};
sl@0: 
sl@0: #define SOAK_CHECK(r)												\
sl@0: 	if(r!=KErrNone)													\
sl@0: 		{															\
sl@0: 		RDebug::Printf("SOAK_CHECK fail at line %d",__LINE__);		\
sl@0: 		return r;													\
sl@0: 		}															\
sl@0: 
sl@0: TInt SoakThread(TAny*)
sl@0: 	{
sl@0: 	RMemoryTestLdd ldd;
sl@0: 	TInt r = ldd.Open();
sl@0: 	SOAK_CHECK(r)
sl@0: 
sl@0: 	r = ldd.CreateVirtualPinObject();
sl@0: 	SOAK_CHECK(r)
sl@0: 
sl@0: 	TRandom random((TUint32)&ldd);
sl@0: 
sl@0: 	while(!SoakEnd)
sl@0: 		{
sl@0: 		TUint start = random(KMinBufferSize);
sl@0: 		TUint end = random(KMinBufferSize);
sl@0: 		if(start>end)
sl@0: 			{
sl@0: 			TUint temp = start;
sl@0: 			start = end;
sl@0: 			end = temp;
sl@0: 			}
sl@0: 		const TUint32 KPageMask = 0xfff;
sl@0: 		start &= ~KPageMask;
sl@0: 		end = (end+KPageMask)&~KPageMask;
sl@0: 
sl@0: 		r = ldd.PinVirtualMemory((TLinAddr)(PagedBuffer+start),end-start);
sl@0: 		SOAK_CHECK(r)
sl@0: 
sl@0: 		r = ldd.UnpinVirtualMemory();
sl@0: 		SOAK_CHECK(r)
sl@0: 		}
sl@0: 
sl@0: 	r = ldd.DestroyVirtualPinObject();
sl@0: 	SOAK_CHECK(r)
sl@0: 
sl@0: 	CLOSE_AND_WAIT(ldd);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void TestPinVirtualMemoryPagedSoak()
sl@0: 	{
sl@0: 	test.Start(_L("Create timer"));
sl@0: 	RTimer timer;
sl@0: 	test_KErrNone(timer.CreateLocal());
sl@0: 
sl@0: 	test.Next(_L("Create threads"));
sl@0: 	const TUint KNumThreads = 4;
sl@0: 	TRequestStatus status[KNumThreads];
sl@0: 	RThread thread[KNumThreads];
sl@0: 	TUint i;
sl@0: 	for(i=0; i<KNumThreads; i++)
sl@0: 		{
sl@0: 		test_KErrNone(thread[i].Create(KNullDesC, SoakThread, 0x1000, NULL, 0));
sl@0: 		thread[i].Logon(status[i]);
sl@0: 		test(status[i].Int()==KRequestPending);
sl@0: 		}
sl@0: 
sl@0: 	test.Next(_L("Start threads"));
sl@0: 	RThread().SetPriority(EPriorityMore); // make sure we are higher priority than soak threads
sl@0: 	for(i=0; i<KNumThreads; i++)
sl@0: 		thread[i].Resume();
sl@0: 
sl@0: 	test.Next(_L("Wait..."));
sl@0: 	TRequestStatus timeoutStatus;
sl@0: 	timer.After(timeoutStatus,10*1000000);
sl@0: 	User::WaitForAnyRequest();
sl@0: 	test_KErrNone(timeoutStatus.Int()); // we should have timed out if soak threads are still running OK
sl@0: 
sl@0: 	test.Next(_L("Stop threads and check results"));
sl@0: 	for(i=0; i<KNumThreads; i++)
sl@0: 		test_Equal(KRequestPending,status[i].Int());
sl@0: 	SoakEnd = true;
sl@0: 	timer.After(timeoutStatus,10*1000000);
sl@0: 	for(i=0; i<KNumThreads; i++)
sl@0: 		{
sl@0: 		User::WaitForAnyRequest();
sl@0: 		test_Equal(KRequestPending,timeoutStatus.Int());
sl@0: 		}
sl@0: 	timer.Cancel();
sl@0: 	User::WaitForRequest(timeoutStatus);
sl@0: 	RThread().SetPriority(EPriorityNormal); // restore thread priority
sl@0: 
sl@0: 	// cleanup...
sl@0: 	CLOSE_AND_WAIT(timer);
sl@0: 	for(i=0; i<KNumThreads; i++)
sl@0: 		CLOSE_AND_WAIT(thread[i]);
sl@0: 
sl@0: 	test.End();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void TestPinVirtualMemoryDecommit()
sl@0: 	{
sl@0: 	const TInt KChunk = 4*1024*1024; // offset of page table boundary on X86 and ARM
sl@0: 	const TInt KPage = PageSize;
sl@0: 	const TInt TestData[][2] =
sl@0: 		{
sl@0: 			{0,				KPage},
sl@0: 			{KPage,			KPage},
sl@0: 			{KPage,			2*KPage},
sl@0: 			{KChunk-KPage,	KPage},
sl@0: 			{KChunk-2*KPage,2*KPage},
sl@0: 			{KChunk-KPage,	2*KPage},
sl@0: 			{0,0} // end marker
sl@0: 		};
sl@0: 
sl@0: 	for(TInt i=0; TestData[i][1]; ++i)
sl@0: 		{
sl@0: 		TInt commitOffset = TestData[i][0];
sl@0: 		TInt commitSize = TestData[i][1];
sl@0: 		test.Printf(_L("Create chunk 0x%x+0x%x\n"),commitOffset,commitSize);
sl@0: 
sl@0: 		TChunkCreateInfo createInfo;
sl@0: 		createInfo.SetDisconnected(commitOffset,commitOffset+commitSize,commitOffset+commitSize);
sl@0: 		createInfo.SetPaging(TChunkCreateInfo::EPaged);
sl@0: 		RChunk chunk;
sl@0: 		test_KErrNone(chunk.Create(createInfo));
sl@0: 		TUint8* buffer = chunk.Base()+commitOffset;
sl@0: 		TUint bufferSize = commitSize;
sl@0: 		FlushPagingCache(); // start with blank slate as far as paged memory is concerned
sl@0: 
sl@0: 		test.Printf(_L("Create virtual pin object\n"));
sl@0: 		test_KErrNone(Ldd.CreateVirtualPinObject());
sl@0: 		test_KErrNone(Ldd2.CreateVirtualPinObject());
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		TInt initialFreeRam = FreeRam();
sl@0: 
sl@0: 		test.Printf(_L("Pin memory\n"));
sl@0: 		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		TInt pinnedFreeRam = FreeRam();
sl@0: 		test_Compare(pinnedFreeRam,<,initialFreeRam);
sl@0: 		TUint8 c = *buffer;
sl@0: 		memset(buffer,~c,bufferSize); // invert memory
sl@0: 
sl@0: 		test.Printf(_L("Decommit pinned memory\n"));
sl@0: 		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam()); // decommited memory should not be freed as it is pinned
sl@0: 
sl@0: 		test.Printf(_L("Unpin memory\n"));
sl@0: 		test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed
sl@0: 
sl@0: 		//
sl@0: 		// test recommitting decommitted pinned memory...
sl@0: 		//
sl@0: 
sl@0: 		test.Printf(_L("Commit memory\n"));
sl@0: 		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(initialFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Read memory\n"));
sl@0: 		volatile TUint8* p = buffer;
sl@0: 		volatile TUint8* pEnd = buffer+bufferSize;
sl@0: 		while(p<pEnd)
sl@0: 			test_Equal(c,*p++); // memory should have been wiped
sl@0: 		test_Equal(initialFreeRam,FreeRam()); // memory now paged in
sl@0: 
sl@0: 		test.Printf(_L("Pin memory which is already paged in\n"));
sl@0: 		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 		memset(buffer,~c,bufferSize); // invert memory
sl@0: 
sl@0: 		test.Printf(_L("Decommit pinned memory\n"));
sl@0: 		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Commit pinned memory again\n"));
sl@0: 		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 		p = buffer;
sl@0: 		pEnd = buffer+bufferSize;
sl@0: 		while(p<pEnd)
sl@0: 			test_Equal(c,*p++); // memory should have been wiped
sl@0: 
sl@0: 		test.Printf(_L("Unpin memory\n"));
sl@0: 		test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		test_Equal(initialFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Decommit memory\n"));
sl@0: 		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Compare(FreeRam(),<=,initialFreeRam);
sl@0: 
sl@0: 		//
sl@0: 		// test pin twice...
sl@0: 		//
sl@0: 
sl@0: 		test.Printf(_L("Commit memory\n"));
sl@0: 		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(initialFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Pin memory\n"));
sl@0: 		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Pin memory again\n"));
sl@0: 		test_KErrNone(Ldd2.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Decommit pinned memory\n"));
sl@0: 		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam()); // decommited memory should not be freed as it is pinned
sl@0: 
sl@0: 		test.Printf(_L("Unpin memory\n"));
sl@0: 		test_KErrNone(Ldd2.UnpinVirtualMemory());	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam()); // memory shouldn't be freed as another pin exists
sl@0: 
sl@0: 		test.Printf(_L("Unpin memory again\n"));
sl@0: 		test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed
sl@0: 
sl@0: 		//
sl@0: 		// test page stealing of decommited memory
sl@0: 		//
sl@0: 
sl@0: 		test.Printf(_L("Commit memory\n"));
sl@0: 		test_KErrNone(chunk.Commit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(initialFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Pin memory\n"));
sl@0: 		test_KErrNone(Ldd.PinVirtualMemory((TLinAddr)buffer, bufferSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, ETrue);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Decommit pinned memory\n"));
sl@0: 		test_KErrNone(chunk.Decommit(commitOffset,commitSize));	
sl@0: 		CheckMemoryPresent(buffer, bufferSize, EFalse);
sl@0: 		test_Equal(pinnedFreeRam,FreeRam());
sl@0: 
sl@0: 		test.Printf(_L("Unpin memory a higher priority that supervisor thread\n"));
sl@0: 		RThread().SetPriority(EPriorityRealTime);
sl@0: 		test_KErrNone(Ldd.UnpinVirtualMemory());	
sl@0: 		// on single core system, supervisor thread can't run and free pages yet
sl@0: 		// because we're a higher priority...
sl@0: 		test.Printf(_L("memory freed = %d\n"),initialFreeRam==FreeRamNoWait());
sl@0: 
sl@0: 		test.Printf(_L("Force decommited unpinned pages out of live list\n"));
sl@0: 		FlushPagingCache();
sl@0: 		RThread().SetPriority(EPriorityNormal);
sl@0: 		test_Equal(initialFreeRam,FreeRam()); // memory should be now freed
sl@0: 
sl@0: 		//
sl@0: 		// cleanup...
sl@0: 		//
sl@0: 
sl@0: 		test.Printf(_L("Destroy pin object\n"));
sl@0: 		test_KErrNone(Ldd.DestroyVirtualPinObject());
sl@0: 		test_KErrNone(Ldd2.DestroyVirtualPinObject());
sl@0: 		chunk.Close();
sl@0: 		}
sl@0: 
sl@0: 	test.Printf(_L("Flush paging cache\n"));
sl@0: 	FlushPagingCache(); // this is a test that has shown up bugs in the past
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void TestPinOutOfMemory()
sl@0: 	{
sl@0: 	// Ensure that if pinning fails with KErrNoMemory,
sl@0: 	// there isn't a memory leak
sl@0: 	const TInt KMaxKernelAllocations = 1024;
sl@0: 	TInt r=KErrNoMemory;
sl@0: 	TInt i;
sl@0: 	const TUint8* buffer = NULL;
sl@0: 	if (PagedBuffer)
sl@0: 		{
sl@0: 		buffer = PagedBuffer;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		buffer = UnpagedBuffer;
sl@0: 		}
sl@0: 	test_NotNull(buffer);
sl@0: 
sl@0: 	__KHEAP_MARK;
sl@0: 	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
sl@0: 		{
sl@0: 		__KHEAP_FAILNEXT(i);
sl@0: 		test.Printf(_L("Create logical pin object\n"));
sl@0: 		r = Ldd.CreateVirtualPinObject();
sl@0: 		__KHEAP_RESET;
sl@0: 		}
sl@0: 	test.Printf(_L("Create logical pin object took %d tries\n"),i);
sl@0: 	test_KErrNone(r);
sl@0: 
sl@0: 	r = KErrNoMemory;
sl@0: 	for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
sl@0: 		{
sl@0: 		__KHEAP_FAILNEXT(i);
sl@0: 		test.Printf(_L("Perform logical pin operation\n"));
sl@0: 		r = Ldd.PinVirtualMemory((TLinAddr)buffer, KMinBufferSize);
sl@0: 		__KHEAP_RESET;
sl@0: 		}
sl@0: 	test.Printf(_L("Perform logical pin operation took %d tries\n"),i);
sl@0: 	if (r == KErrNone)
sl@0: 		{
sl@0: 		test.Printf(_L("Perform logical unpin operation\n"));
sl@0: 		Ldd.UnpinVirtualMemory();
sl@0: 		}
sl@0: 	
sl@0: 	test.Printf(_L("Destroy logical pin object\n"));
sl@0: 	Ldd.DestroyVirtualPinObject();
sl@0: 	// wait for any async cleanup in the supervisor to finish first...
sl@0: 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
sl@0: 	__KHEAP_MARKEND;
sl@0: 
sl@0: 	test_KErrNone(r);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt KernelModifyData(TAny*)
sl@0: 	{
sl@0: 	Ldd.KernelMapReadAndModifyMemory();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: void TestMapAndPinMemory()
sl@0: 	{
sl@0: 	
sl@0: 	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
sl@0: 	if (mm < EMemModelTypeFlexible)
sl@0: 		{
sl@0: 		test.Printf(_L("Memory model (%d) doesn't support physical pining\n"),mm);
sl@0: 		return;
sl@0: 		}
sl@0: 	TInt i;
sl@0: 	TUint KUCBytes = KUCPageCount * PageSize;
sl@0: 	RChunk chunk;
sl@0: 
sl@0: 	test.Printf(_L("Allocate user chunk\n"));
sl@0: 	TChunkCreateInfo createInfo;
sl@0: 	createInfo.SetDisconnected(0, KUCBytes, KUCBytes);
sl@0: 	createInfo.SetPaging(TChunkCreateInfo::EPaged);
sl@0: 	test_KErrNone(chunk.Create(createInfo));
sl@0: 	TUint8* chunkBase = (TUint8*)chunk.Base();
sl@0: 	
sl@0: 	test.Printf(_L("Create kernel map object\n"));
sl@0: 	test_KErrNone(Ldd.CreateKernelMapObject(0));
sl@0: 
sl@0: 	test.Printf(_L("Perform kernel map operation on zero-length buffer\n"));
sl@0: 	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunkBase, 0));	
sl@0: 
sl@0: 	test.Printf(_L("Perform kernel unmap operation\n"));
sl@0: 	test_KErrNone(Ldd.KernelUnmapMemory());	
sl@0: 
sl@0: 	test.Printf(_L("Perform kernel map operation on the chunk\n"));
sl@0: 	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunkBase, KUCBytes));
sl@0: 
sl@0: 	test.Printf(_L("Attempt to map the memory again while already mapped\n"));
sl@0: 	test_Equal(KErrInUse, Ldd.KernelMapMemory((TLinAddr)chunkBase, KUCBytes));
sl@0: 
sl@0: 	test.Printf(_L("Use the kernel mapping to modify the data and verify it\n"));
sl@0: 	TUint8* p = chunkBase;
sl@0: 	for (i = 0; i < (TInt)KUCBytes; i++)
sl@0: 		*p++ = (TUint8)i;
sl@0: 	test_KErrNone(Ldd.KernelMapReadAndModifyMemory());
sl@0: 	p = chunkBase;
sl@0: 	for (i = 0; i < (TInt)KUCBytes; i++)
sl@0: 		test_Equal((TUint8)(i + 1), *p++);	
sl@0: 
sl@0: 	test.Printf(_L("Test that kernel mapped memory preserves its mapping when recommited\n"));
sl@0: 	test_KErrNone(chunk.Decommit(0,KUCPageCount*PageSize));							 //Decommit all
sl@0: 	for (i=KUCPageCount-1;i>=0;i--) test_KErrNone(chunk.Commit(i*PageSize,PageSize)); //Commit in reverse order
sl@0: 	for (i=0;i<KUCPageCount;i++) // Recommited memory is not paged in. So, write into each page, before driver 
sl@0: 		{						// calls Kern::LinearToPhysical or it will get KErrInvalidMemory in return.
sl@0: 		volatile TInt8* ptr = (volatile TInt8*)(chunkBase+i*PageSize);
sl@0: 		*ptr = 10;
sl@0: 		}
sl@0: 	test_KErrNone(Ldd.KernelMapCheckPageList(chunkBase)); 	// Check that the mapping is preserved. 	
sl@0: 	
sl@0: 	test.Printf(_L("Sync cache & memory of User Chunk\n"));	//Test Cache::SyncMemoryBeforeDmaWrite
sl@0: 	test_KErrNone(Ldd.KernelMapSyncMemory());
sl@0: 
sl@0: 	test.Printf(_L("Invalidate cache of User Chunk\n"));//Test Cache::SyncMemoryBefore/AfterDmaRead
sl@0: 	test_KErrNone(Ldd.KernelMapInvalidateMemory());
sl@0: 	
sl@0: 	test.Printf(_L("Try to move kernel map memory...\n")); //RAM defrag should return error code here.
sl@0: 	for (i = 0; i < KUCPageCount; i++)
sl@0: 		{
sl@0: 		TInt r = Ldd.KernelMapMoveMemory(0);
sl@0: 		test.Printf(_L("...[%d] returned %d\n"), i, r);
sl@0: 		test(r != KErrNone);
sl@0: 		}
sl@0: 
sl@0: 	test.Printf(_L("Unmap the memory and attempt to map with invalid attributes\n"));
sl@0: 	test_KErrNone(Ldd.KernelUnmapMemory());
sl@0: 	test_Equal(KErrArgument, Ldd.KernelMapMemoryInvalid((TLinAddr)chunkBase, KUCBytes));
sl@0: 
sl@0: 	test.Printf(_L("Map the memory read only and attempt to modify it kernel side\n"));
sl@0: 	test_KErrNone(Ldd.KernelMapMemoryRO((TLinAddr)chunkBase, KUCBytes));
sl@0: 	// Reset the contents of the memory.
sl@0: 	p = chunkBase;
sl@0: 	for (i = 0; i < (TInt)KUCBytes; i++)
sl@0: 		*p++ = (TUint8)i;
sl@0: 
sl@0: 	RThread modThread;
sl@0: 	test_KErrNone(modThread.Create(KNullDesC, KernelModifyData, PageSize, PageSize, PageSize, (TAny*)NULL));
sl@0: 	TRequestStatus status;
sl@0: 	modThread.Logon(status);
sl@0: 	test_Equal(KRequestPending, status.Int());
sl@0: 	modThread.Resume();
sl@0: 	User::WaitForRequest(status);
sl@0: 	test_Equal(EExitPanic, modThread.ExitType());
sl@0: 	test(modThread.ExitCategory() == _L("KERN-EXEC"));
sl@0: 	test_Equal(ECausedException, modThread.ExitReason());
sl@0: 	CLOSE_AND_WAIT(modThread);
sl@0: 
sl@0: 	test.Printf(_L("Close the chunk\n")); // Phys. memory is pinned and shouldn't be ...
sl@0: 	chunk.Close();						  // ... mapped to another virtual memory.
sl@0: 
sl@0: 	test.Printf(_L("Allocate & initilise the second chunk\n"));// Kernel shouldn't commit pinned physical memory ...
sl@0: 	test_KErrNone(chunk.CreateLocal(KUCBytes, KUCBytes));   // ...that has just been decommited from the first chunk.
sl@0: 	chunkBase = (TUint8*)chunk.Base();
sl@0: 	for (i = 0; i < KUCPageCount * PageSize; i++) 
sl@0: 		chunkBase[i] = 0; //Initialise user buffer
sl@0: 
sl@0: 	test.Printf(_L("Invalidate cache of pinned memory\n"));//This shouldn't affect the second chunk.
sl@0: 	test_KErrNone(Ldd.KernelMapInvalidateMemory());
sl@0: 
sl@0: 	test.Printf(_L("Check data in the second chunk is unaffected\n"));
sl@0: 	for (i=0; i < KUCPageCount * PageSize; i++) 
sl@0: 		test(chunkBase[i]==0);
sl@0: 	
sl@0: 	test.Printf(_L("Close the second chunk\n"));
sl@0: 	chunk.Close();
sl@0: 
sl@0: 	test.Printf(_L("Perform kernel unmap operation\n"));
sl@0: 	test_KErrNone(Ldd.KernelUnmapMemory());	
sl@0: 
sl@0: 	test.Printf(_L("Perform physical unpin operation (again)\n"));
sl@0: 	test_KErrNone(Ldd.KernelUnmapMemory());	// test double unpin ok
sl@0: 
sl@0: 	test.Printf(_L("Destroy physical pin object\n"));
sl@0: 	test_KErrNone(Ldd.DestroyKernelMapObject());
sl@0: 
sl@0: 	test.Printf(_L("Destroy physical pin object (again)\n"));
sl@0: 	test_KErrNone(Ldd.DestroyKernelMapObject());  // test double destroy ok
sl@0: 
sl@0: 	//
sl@0: 	//	Test a kernel mapping with preserved resources doesn't allocate when mapping and pinning.
sl@0: 	//
sl@0: 	test.Printf(_L("Create a pre-reserving kernel mapping object\n"));
sl@0: 	TUint mappingSize = KUCBytes>>1;
sl@0: 	// This test step relies on mapping objet being smaller than the user chunk
sl@0: 	// and as mapping object will always be >=2 pages, user chunk must be at least 4.
sl@0: 	__ASSERT_COMPILE(KUCPageCount >= 4);
sl@0: 	test_KErrNone(Ldd.CreateKernelMapObject(mappingSize));
sl@0: 	TChunkCreateInfo chunkInfo;
sl@0: 	chunkInfo.SetNormal(KUCBytes, KUCBytes);
sl@0: 	chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged);
sl@0: 	test_KErrNone(chunk.Create(chunkInfo));
sl@0: 
sl@0: 	test.Printf(_L("Map and pin an unpaged chunk with pre-reserved resources\n"));
sl@0: 	__KHEAP_FAILNEXT(1);	// Ensure any attempted kernel heap allocations fail.
sl@0: 	test_KErrNone(Ldd.KernelMapMemory((TLinAddr)chunk.Base(), mappingSize));
sl@0: 	test_KErrNone(Ldd.KernelUnmapMemory());
sl@0: 
sl@0: 	test.Printf(_L("Map more memory than we have pre-reserved resources for\n"));
sl@0: 	test_Equal(KErrArgument, Ldd.KernelMapMemory((TLinAddr)chunk.Base(), mappingSize*2));
sl@0: 
sl@0: 	test.Printf(_L("Destroy the kernel map object with pre-reserved resources\n"));
sl@0: 	test_KErrNone(Ldd.DestroyKernelMapObject());	// This will also unpin the memory.
sl@0: 	// Clear the kernel heap fail next.
sl@0: 	__KHEAP_RESET;
sl@0: 	chunk.Close();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	test.Title();
sl@0: 	test.Start(_L("Test kernel pinning APIs"));
sl@0: 
sl@0: 	if (DPTest::Attributes() & DPTest::ERomPaging)
sl@0: 		test.Printf(_L("Rom paging supported\n"));
sl@0: 	if (DPTest::Attributes() & DPTest::ECodePaging)
sl@0: 		test.Printf(_L("Code paging supported\n"));
sl@0: 	if (DPTest::Attributes() & DPTest::EDataPaging)
sl@0: 		test.Printf(_L("Data paging supported\n"));
sl@0: 	
sl@0: 	test.Next(_L("Loading test drivers"));
sl@0: 	test_KErrNone(Ldd.Open());
sl@0: 	test_KErrNone(Ldd2.Open());
sl@0: 
sl@0: 	test.Next(_L("Getting page size"));
sl@0: 	test_KErrNone(UserSvr::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&PageSize,0));
sl@0: 	
sl@0: 	test.Next(_L("Setting up paged and unpaged buffers"));
sl@0: 
sl@0: #ifdef __EPOC32__
sl@0: 	// Use unpaged rom for our unpaged buffer
sl@0: 	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
sl@0: 	UnpagedBuffer = (TUint8*)romHeader;
sl@0: 	TInt size = romHeader->iPageableRomStart ? romHeader->iPageableRomStart : romHeader->iUncompressedSize;
sl@0: 	test(size >= KMinBufferSize);
sl@0: 	
sl@0: 	if (DPTest::Attributes() & DPTest::ERomPaging)
sl@0: 		{
sl@0: 		// Use end of paged ROM for our paged buffer
sl@0: 		test(romHeader->iPageableRomStart);
sl@0: 		TInt offset = romHeader->iPageableRomStart + romHeader->iPageableRomSize - KMinBufferSize;
sl@0: 		offset &= ~0xfff;
sl@0: 		test(offset>=romHeader->iPageableRomStart);
sl@0: 		PagedBuffer = (TUint8*)romHeader + offset;
sl@0: 		}
sl@0: 	else if (DPTest::Attributes() & DPTest::ECodePaging)
sl@0: 		{
sl@0: 		// Use code paged DLL for our paged buffer
sl@0: 		test_KErrNone(PagedLibrary.Load(KTCodePagingDll4));		
sl@0: 		TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)PagedLibrary.Lookup(KGetAddressOfDataFunctionOrdinal);
sl@0: 		TInt size;
sl@0: 		PagedBuffer = (TUint8*)func(size);
sl@0: 		test_NotNull(PagedBuffer);
sl@0: 		test(size >= KMinBufferSize);
sl@0: 		}
sl@0: #else
sl@0: 	UnpagedBuffer = (TUint8*)User::Alloc(KMinBufferSize);
sl@0: 	test_NotNull(UnpagedBuffer);
sl@0: #endif
sl@0: 
sl@0: 	RDebug::Printf("UnpagedBuffer=%x\n",UnpagedBuffer);
sl@0: 	RDebug::Printf("PagedBuffer=%x\n",PagedBuffer);
sl@0: 
sl@0: 	__KHEAP_MARK;
sl@0: 	
sl@0: 	test.Next(_L("Logical pin unpaged memory"));
sl@0: 	TestPinVirtualMemoryUnpaged();
sl@0: 
sl@0: 	test.Next(_L("Logical pin invalid memory"));
sl@0: 	TestPinVirtualMemoryInvalid();
sl@0: 
sl@0: 	test.Next(_L("Physical pinning"));
sl@0: 	TestPinPhysicalMemory();
sl@0: 	
sl@0: 	test.Next(_L("Physical pinning OOM"));
sl@0: 	TestPhysicalPinOutOfMemory();
sl@0: 
sl@0: 	test.Next(_L("Kernel pin mapping"));
sl@0: 	TestMapAndPinMemory();
sl@0: 
sl@0: 	test.Next(_L("Pin OOM Tests"));
sl@0: 	TestPinOutOfMemory();
sl@0: 
sl@0: 	if (PagedBuffer)
sl@0: 		{
sl@0: 		test.Next(_L("Logical pin paged memory"));
sl@0: 		TestPinVirtualMemoryPaged();
sl@0: 
sl@0: 		test.Next(_L("Logical pin paged memory soak test"));
sl@0: 		TestPinVirtualMemoryPagedSoak();
sl@0: 		}
sl@0: 
sl@0: 	if (DPTest::Attributes() & DPTest::EDataPaging)
sl@0: 		{
sl@0: 		test.Next(_L("Logical pin then decommit memory"));
sl@0: 		TestPinVirtualMemoryDecommit();
sl@0: 		}
sl@0: 
sl@0: 	// wait for any async cleanup in the supervisor to finish first...
sl@0: 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);	
sl@0: 	__KHEAP_MARKEND;
sl@0: 
sl@0: #ifndef __EPOC32__
sl@0: 	User::Free((TAny*)UnpagedBuffer);
sl@0: #endif
sl@0: 
sl@0: 	PagedLibrary.Close();
sl@0: 	Ldd.Close();
sl@0: 	Ldd2.Close();
sl@0: 	test.End();
sl@0: 
sl@0: 	return KErrNone;
sl@0: 	}