// 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;

	}