// Copyright (c) 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\demandpaging\t_pagetable_limit.cpp

 // Tests to expose the limit of page table virtual address space.

 // 

 //

 //! @SYMTestCaseID			KBASE-T_PAGETABLE_LIMIT

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1490

 //! @SYMTestCaseDesc		Tests to expose the limit of page table virtual address space.

 //! @SYMTestActions			Test that a paged page table can always be acquired.

 //! @SYMTestExpectedResults All tests should pass.

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <dptest.h>

 #include <e32svr.h>

 #include <u32std.h>

 #include <hal.h>

 #include "t_dpcmn.h"

 RTest test(_L("T_PAGETABLE_LIMIT"));

 _LIT(KClientPtServerName, "CClientPtServer");

 _LIT(KClientProcessName, "T_PAGETABLE_LIMIT");

 enum TClientMsgType

 	{

 	EClientConnect = -1,

 	EClientDisconnect = -2,

 	EClientGetChunk = 0,

 	EClientReadChunks = 1,

 	};

 class RDataPagingSession : public RSessionBase

 	{

 public:

 	TInt CreateSession(const TDesC& aServerName, TInt aMsgSlots) 

 		{ 

 		return RSessionBase::CreateSession(aServerName,User::Version(),aMsgSlots);

 		}

 	TInt PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr)

 		{

 		return (SendReceive(aFunction, aPtr));

 		}

 	TInt PublicSend(TInt aFunction, const TIpcArgs &aPtr)

 		{

 		return (Send(aFunction, aPtr));

 		}

 	};

 TInt ClientProcess(TInt aLen)

 	{

 	// Read the command line to get the number of chunk to map and whether or 

 	// not to access their data.

 	HBufC* buf = HBufC::New(aLen);

 	test(buf != NULL);

 	TPtr ptr = buf->Des();

 	User::CommandLine(ptr);

 	TLex lex(ptr);

 	TInt chunkCount;

 	TInt r = lex.Val(chunkCount);

 	test_KErrNone(r);

 	lex.SkipSpace();

 	TBool accessData;

 	r = lex.Val(accessData);

 	test_KErrNone(r);

 	RDataPagingSession session;

 	test_KErrNone(session.CreateSession(KClientPtServerName, 1));

 	RChunk* chunks = new RChunk[chunkCount];

 	for (TInt i = 0; i < chunkCount; i++)

 		{

 		TInt r = chunks[i].SetReturnedHandle(session.PublicSendReceive(EClientGetChunk, TIpcArgs(i)));

 		if (r != KErrNone)

 			{

 			test.Printf(_L("Failed to create a handle to the server's chunk r=%d\n"), r);

 			for (TInt j = 0; j < i; j++)

 				chunks[j].Close();

 			session.Close();

 			return r;

 			}

 		test_Value(chunks[i].Size(), chunks[i].Size() >= gPageSize);

 		}

 	if (!accessData)

 		{

 		// Touch the 1st page of each of the chunks.

 		for (TInt i = 0; i < chunkCount; i++)

 			{

 			// Write the chunk data from top to bottom of the chunk's first page.

 			TUint8* base = chunks[i].Base();

 			TUint8* end = base + gPageSize - 1;

 			*base = *end;

 			}

 		// Tell parent we've touched each chunk.

 		TInt r =  (TThreadId)session.PublicSendReceive(EClientReadChunks,TIpcArgs());	// Assumes id is only 32-bit.

 		test_KErrNone(r);

 		for(;;)

 			{// Wake up every 100ms to be killed by the main process.

 			User::After(100000);

 			}

 		}

 	else

 		{

 		for (;;)

 			{

 			TInt offset = 0;

 			for (TInt i = 0; i < chunkCount; i++)

 				{

 				// Write the chunk data from top to bottom of the chunk's first page.

 				TUint8* base = chunks[i].Base();

 				TUint8* end = base + gPageSize - 1;

 				*(base + offset) = *(end - offset);

 				}

 			if (++offset >= (gPageSize >> 1))

 				offset = 0;

 			}

 		}

 	}

 void TestMaxPt()

 	{

 	// Flexible memory model reserves 0xF800000-0xFFF00000 for page tables

 	// this allows 130,048 pages tables.  Therefore mapping 1000 one 

 	// page chunks into 256 processes would require 256,000 page tables, i.e.

 	// more than enough to hit the limit.  So that the limit is reached in the middle,

 	// map 500 unpaged and 500 paged chunks in each process.

 	const TUint KNumChunks = 1000;

 	const TUint KPagedChunksStart = (KNumChunks >> 1);

 	const TUint KNumProcesses = 256;

 	const TInt KMinFreeRam = (1000 * gPageSize) + (130048 * (gPageSize>>2));

 	TInt freeRam;

 	HAL::Get(HALData::EMemoryRAMFree, freeRam);

 	if (freeRam < KMinFreeRam)

 		{

 		test.Printf(_L("Only 0x%x bytes of free RAM not enough to perform the test.  Skipping test.\n"), freeRam);

 		return;

 		}

 	// Remove the maximum limit on the cache size as the test requires that it can

 	// allocate as many page tables as possible but without stealing any pages as

 	// stealing pages may indirectly steal paged page table pages.

 	TUint minCacheSize, maxCacheSize, currentCacheSize;

 	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);

 	test_KErrNone(DPTest::SetCacheSize(minCacheSize, KMaxTUint));

 	RServer2 ptServer;

 	TInt r = ptServer.CreateGlobal(KClientPtServerName);

 	test_KErrNone(r);

 	// Create the global unpaged chunks.  They have one page committed

 	// but have a maximum size large enough to prevent their page tables being

 	// shared between the chunks.  On arm with 4KB pages each page table maps 1MB

 	// so make chunk 1MB+4KB so chunk requires 2 page tables and is not aligned on

 	// a 1MB boundary so it is a fine memory object.

 	const TUint KChunkSize = (1024 * 1024) + gPageSize;

 	RChunk* chunks = new RChunk[KNumChunks];

 	TChunkCreateInfo createInfo;

 	createInfo.SetNormal(gPageSize, KChunkSize);

 	createInfo.SetGlobal(KNullDesC);

 	createInfo.SetPaging(TChunkCreateInfo::EUnpaged);

 	TUint i = 0;

 	for (; i < KPagedChunksStart; i++)

 		{

 		r = chunks[i].Create(createInfo);

 		test_KErrNone(r);

 		}

 	// Create paged chunks.

 	createInfo.SetPaging(TChunkCreateInfo::EPaged);

 	for (; i< KNumChunks; i++)

 		{

 		r = chunks[i].Create(createInfo);

 		test_KErrNone(r);

 		}

 	// Start remote processes, giving each process handles to each chunk.

 	RProcess* processes = new RProcess[KNumProcesses];

 	RMessage2 ptMessage;

 	TUint processIndex = 0;

 	TUint processLimit = 0;

 	for (; processIndex < KNumProcesses; processIndex++)

 		{

 		// Start the process.

 		test.Printf(_L("Creating process %d\n"), processIndex);

 		TBuf<80> args;

 		args.AppendFormat(_L("%d %d"), KNumChunks, EFalse);

 		r = processes[processIndex].Create(KClientProcessName, args);

 		test_KErrNone(r);

 		TRequestStatus s;

 		processes[processIndex].Logon(s);

 		test_Equal(KRequestPending, s.Int());

 		processes[processIndex].Resume();

 		ptServer.Receive(ptMessage);

 		test_Equal(EClientConnect, ptMessage.Function());

 		ptMessage.Complete(KErrNone);

 		TInt func = EClientGetChunk;

 		TUint chunkIndex = 0;

 		for (; chunkIndex < KNumChunks && func == EClientGetChunk; chunkIndex++)

 			{// Pass handles to all the unpaged chunks to the new process.

 			ptServer.Receive(ptMessage);

 			func = ptMessage.Function();

 			if (func == EClientGetChunk)

 				{

 				TUint index = ptMessage.Int0();

 				ptMessage.Complete(chunks[index]);

 				}

 			}

 		if (func != EClientGetChunk)

 			{

 			// Should hit the limit of page tables and this process instance should exit

 			// sending a disconnect message in the process.

 			test_Equal(EClientDisconnect, func);

 			// Should only fail when mapping unpaged chunks.

 			test_Value(chunkIndex, chunkIndex < (KNumChunks >> 1));

 			break;

 			}

 		// Wait for the process to access all the chunks and therefore 

 		// allocate the paged page tables before moving onto the next process.

 		ptServer.Receive(ptMessage);

 		func = ptMessage.Function();

 		test_Equal(EClientReadChunks, func);

 		ptMessage.Complete(KErrNone);

 		// Should have mapped all the required chunks.

 		test_Equal(KNumChunks, chunkIndex);

 		}

 	// Should hit page table limit before KNumProcesses have been created.

 	test_Value(processIndex, processIndex < KNumProcesses - 1);

 	processLimit = processIndex;

 	// Now create more processes to access paged data even though the page table 

 	// address space has been exhausted.  Limit to 10 more processes as test takes 

 	// long enough already.

 	processIndex++;

 	TUint excessProcesses = KNumProcesses - processIndex;

 	TUint pagedIndexEnd = (excessProcesses > 10)? processIndex + 10 : processIndex + excessProcesses;

 	for (; processIndex < pagedIndexEnd; processIndex++)

 		{

 		// Start the process.

 		test.Printf(_L("Creating process %d\n"), processIndex);

 		TBuf<80> args;

 		args.AppendFormat(_L("%d %d"), KNumChunks-KPagedChunksStart, ETrue);

 		r = processes[processIndex].Create(KClientProcessName, args);

 		if (r != KErrNone)

 			{// Have hit the limit of processes.

 			processIndex--;

 			// Should have created at least one more process.

 			test_Value(processIndex, processIndex > processLimit);

 			break;

 			}

 		TRequestStatus s;

 		processes[processIndex].Logon(s);

 		test_Equal(KRequestPending, s.Int());

 		processes[processIndex].Resume();

 		ptServer.Receive(ptMessage);

 		test_Equal(EClientConnect, ptMessage.Function());

 		ptMessage.Complete(KErrNone);

 		TInt func = EClientGetChunk;

 		TUint chunkIndex = KPagedChunksStart;

 		for (; chunkIndex < KNumChunks && func == EClientGetChunk; chunkIndex++)

 			{// Pass handles to all the unpaged chunks to the new process.

 			ptServer.Receive(ptMessage);

 			func = ptMessage.Function();

 			if (func == EClientGetChunk)

 				{

 				TUint index = ptMessage.Int0() + KPagedChunksStart;

 				ptMessage.Complete(chunks[index]);

 				}

 			}

 		if (func != EClientGetChunk)

 			{// Reached memory limits so exit.

 			test_Equal(EClientDisconnect, func);

 			// Should have created at least one more process.

 			test_Value(processIndex, processIndex > processLimit+1);

 			break;

 			}

 		// Should have mapped all the required chunks.

 		test_Equal(KNumChunks, chunkIndex);

 		}

 	// If we reached the end of then ensure that we kill only the running processes.

 	if (processIndex == pagedIndexEnd)

 		processIndex--;

 	// Kill all the remote processes

 	for(TInt j = processIndex; j >= 0; j--)

 		{

 		test.Printf(_L("killing process %d\n"), j);

 		TRequestStatus req;

 		processes[j].Logon(req);

 		if (req == KRequestPending)

 			{

 			processes[j].Kill(KErrNone);

 			User::WaitForRequest(req);

 			}

 		processes[j].Close();

 		}

 	delete[] processes;

 	// Close the chunks.

 	for (TUint k = 0; k < KNumChunks; k++)

 		chunks[k].Close();

 	delete[] chunks;

 	test_KErrNone(DPTest::SetCacheSize(minCacheSize, maxCacheSize));

 	}

 TInt E32Main()

 	{

 	test_KErrNone(UserHal::PageSizeInBytes(gPageSize));

 	TUint len = User::CommandLineLength();

 	if (len > 0)

 		{

 		return ClientProcess(len);

 		}

 	test.Title();

 	test_KErrNone(GetGlobalPolicies());

 	if (!gDataPagingSupported)

 		{

 		test.Printf(_L("Data paging not enabled so skipping test...\n"));

 		return KErrNone;

 		}

 	test.Start(_L("Test the system can always acquire a paged page table"));

 	TestMaxPt();

 	test.End();

 	return KErrNone;

 	}