// 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"
#include "../mmu/freeram.h"

RTest test(_L("T_PAGETABLE_LIMIT"));

// The flexible memory model reserves 0xF800000-0xFFF00000 for page tables, which allows 130,048
// pages tables.
//
// We attempt to map 40 * 40 * 100 == 160,000 page tables.
// 
// So that the limit is reached in the middle, half the chunks are mapped as paged and half as
// unpaged.

const TUint KPageTablesPerChunk = 40;
const TUint KChunksPerProcess = 40;
const TUint KNumProcesses = 100;

const TUint KSizeMappedByPageTable = 1024 * 1024;  // the amount of RAM mapped by one page table


_LIT(KClientPtServerName, "CClientPtServer");
_LIT(KClientProcessName, "T_PAGETABLE_LIMIT");

enum TClientMsgType
	{
	EClientConnect = -1,
	EClientDisconnect = -2,
	EClientGetChunk = 0,
	EClientReadChunks = 1,
	EClientGetParentProcess = 2,
	};

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);
		}
	};

#define CLIENT_TEST_IMPL(condition, code, line)			\
	if (!(condition))									\
		{												\
		RDebug::Printf("Test %s failed at line %d");	\
		r = (code);										\
		goto exit;										\
		}

#define CLIENT_TEST(condition, code) CLIENT_TEST_IMPL(condition, code, __LINE__)

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

	RChunk* chunks = NULL;
	RDataPagingSession session;
	RProcess parent;
	TRequestStatus parentStatus;
	TInt offset = 0;
	TInt i;
	
	TInt chunkCount;
	TInt r = lex.Val(chunkCount);
	CLIENT_TEST(r == KErrNone, r);	
	lex.SkipSpace();
	chunks = new RChunk[chunkCount];
	CLIENT_TEST(chunks, KErrNoMemory);

	TBool accessData;
	r = lex.Val(accessData);
	CLIENT_TEST(r == KErrNone, r);

	r = session.CreateSession(KClientPtServerName, 1);
	CLIENT_TEST(r == KErrNone, r);

	r = parent.SetReturnedHandle(session.PublicSendReceive(EClientGetParentProcess, TIpcArgs()));
	CLIENT_TEST(r == KErrNone, r);
	
	for (i = 0; i < chunkCount; i++)
		{
		r = chunks[i].SetReturnedHandle(session.PublicSendReceive(EClientGetChunk, TIpcArgs(i)));
		if (r != KErrNone)
			{
			RDebug::Printf("Failed to create a handle to chunk %d r=%d", i, r);
			goto exit;
			}
		CLIENT_TEST(chunks[i].Size() >= gPageSize, KErrGeneral);
		}

	// Logon to parent process
	parent.Logon(parentStatus);

	// Touch each mapped page of all of the chunks.
	do
		{
		for (TInt i = 0; i < chunkCount; i++)
			{
			for (TUint j = 0 ; j < KPageTablesPerChunk ; j++)
				{
				// Write the chunk data from top to bottom of the chunk's first page.
				TUint8* base = chunks[i].Base() + j * KSizeMappedByPageTable;
				TUint8* end = base + gPageSize - 1;
				*(base + offset) = *(end - offset);

				User::After(0);

				// Check whether main process is still running
				if (parentStatus != KRequestPending)
					{
					// if we get here the test failed and the main process exited without killing
					// us, so just exit quietly
					User::WaitForRequest(parentStatus);
					r = KErrGeneral;
					goto exit;
					}
				}
			}
		offset = (offset + 1) % (gPageSize / 2);
		}
	while (accessData);

	// Tell parent we've touched each page.
	r = (TThreadId)session.PublicSendReceive(EClientReadChunks,TIpcArgs());	
	CLIENT_TEST(r == KErrNone, r);
		
	// Wait till we get killed by the main process or the main process dies
	User::WaitForRequest(parentStatus);
	// if we get here the test failed and the main process exited without killing us, so just exit
	r = KErrGeneral;

exit:
	if (chunks)
		{
		for (TInt i = 0 ; i < chunkCount; ++i)
			chunks[i].Close();
		}
	session.Close();
	parent.Close();
			
	return r;
	}

TInt FreeSwap()
	{
	SVMSwapInfo swapInfo;
	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
	return swapInfo.iSwapFree;
	}

void PrintFreeRam()
	{
	test.Printf(_L("%d KB RAM / %d KB swap free\n"), FreeRam() / 1024, FreeSwap() / 1024);
	}

void CreateChunk(RChunk& aChunk, TInt aChunkIndex, TInt aPageTables, TBool aPaged)
	{
	// Creates a global chunk.
	//
	// The chunk uses KPageTablesPerChunk page tables by committing that number of pages at 1MB
	// intervals.  Its max size is set so that it is not a multiple of 1MB and hence the FMM will
	// use a fine mapping objects whose page tables are not shared between processes.
	
	test.Printf(_L("  creating chunk %d: "), aChunkIndex);
	PrintFreeRam();
	
	TChunkCreateInfo createInfo;
	createInfo.SetDisconnected(0, 0, aPageTables * KSizeMappedByPageTable + gPageSize);
	createInfo.SetPaging(aPaged ? TChunkCreateInfo::EPaged : TChunkCreateInfo::EUnpaged);
	TBuf<32> name;
	name.AppendFormat(_L("t_pagetable_limit chunk %d"), aChunkIndex);
	createInfo.SetGlobal(name);
	test_KErrNone(aChunk.Create(createInfo));
	for (TInt i = 0 ; i < aPageTables ; ++i)
		test_KErrNone(aChunk.Commit(i * KSizeMappedByPageTable, gPageSize));
	}

void CreateProcess(RProcess& aProcess, TInt aProcessIndex, TInt aNumChunks, TBool aAccessData)
	{
	test.Printf(_L("  creating process %d: "), aProcessIndex);
	PrintFreeRam();
	
	TBuf<80> args;
	args.AppendFormat(_L("%d %d"), aNumChunks, aAccessData);
	test_KErrNone(aProcess.Create(KClientProcessName, args));
	aProcess.SetPriority(EPriorityLow);
	}

void TestMaxPt()
	{
	test.Printf(_L("Waiting for system idle and kernel cleanup\n"));
	// If this test was run previously, there may be lots of dead processes waiting to be cleaned up
	TInt r;
	while((r = FreeRam(10 * 1000)), r == KErrTimedOut)
		{
		test.Printf(_L("  waiting: "));
		PrintFreeRam();
		}

	// 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.
	test.Printf(_L("Set paging cache max size unlimited\n"));
	TUint minCacheSize, maxCacheSize, currentCacheSize;
	test_KErrNone(DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize));
	test_KErrNone(DPTest::SetCacheSize(minCacheSize, KMaxTUint));

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

	// Ensure enough RAM available
	PrintFreeRam();
	TInt freeRam = 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;
		}

	test.Printf(_L("Start server\n"));
	RServer2 ptServer;
	r = ptServer.CreateGlobal(KClientPtServerName);
	test_KErrNone(r);

	test.Printf(_L("Create chunks\n"));
	const TUint KPagedChunksStart = (KChunksPerProcess >> 1);
	RChunk* chunks = new RChunk[KChunksPerProcess];
	test_NotNull(chunks);
	TUint i = 0;
	for (i = 0 ; i< KChunksPerProcess; i++)
		CreateChunk(chunks[i], i, KPageTablesPerChunk, i >= KPagedChunksStart);

	// Start remote processes, giving each process handles to each chunk.
	test.Printf(_L("Start remote processes\n"));
	RProcess* processes = new RProcess[KNumProcesses];
	test_NotNull(processes);
	TRequestStatus* statuses = new TRequestStatus[KNumProcesses];
	test_NotNull(statuses);
	TUint processIndex = 0;	
	for (; processIndex < KNumProcesses; processIndex++)
		{
		// Start the process.
		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess, EFalse);
		
		// logon to process
		processes[processIndex].Logon(statuses[processIndex]);
		test_Equal(KRequestPending, statuses[processIndex].Int());
		processes[processIndex].Resume();

		// wait for connect message
		RMessage2 ptMessage;
		ptServer.Receive(ptMessage);
		test_Equal(EClientConnect, ptMessage.Function());
		ptMessage.Complete(KErrNone);

		// pass client a handle to this process
		ptServer.Receive(ptMessage);
		test_Equal(EClientGetParentProcess, ptMessage.Function());
		ptMessage.Complete(RProcess());

		// pass client chunk handles
		TInt func;
		TUint chunkIndex = 0;
		for (; chunkIndex < KChunksPerProcess ; chunkIndex++)
			{// Pass handles to all the unpaged chunks to the new process.
			ptServer.Receive(ptMessage);
			func = ptMessage.Function();
			if (func != EClientGetChunk)
				break;
			ptMessage.Complete(chunks[ptMessage.Int0()]);
			}
		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 < (KChunksPerProcess >> 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(KChunksPerProcess, chunkIndex);
		}
	
	// Should hit page table limit before KNumProcesses have been created.
	test_Value(processIndex, processIndex < KNumProcesses - 1);
	TUint 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.
	test.Printf(_L("Start accessor processes\n"));
	processIndex++;
	TUint excessProcesses = KNumProcesses - processIndex;
	TUint pagedIndexEnd = (excessProcesses > 10)? processIndex + 10 : processIndex + excessProcesses;
	for (; processIndex < pagedIndexEnd; processIndex++)
		{
		// start the process.
		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess-KPagedChunksStart, ETrue);

		// logon to process
		processes[processIndex].Logon(statuses[processIndex]);
		test_Equal(KRequestPending, statuses[processIndex].Int());
		processes[processIndex].Resume();

		// wait for connect message
		RMessage2 ptMessage;
		ptServer.Receive(ptMessage);
		test_Equal(EClientConnect, ptMessage.Function());
		ptMessage.Complete(KErrNone);

		// pass client a handle to this process
		ptServer.Receive(ptMessage);
		test_Equal(EClientGetParentProcess, ptMessage.Function());
		ptMessage.Complete(RProcess());
		
		TInt func = EClientGetChunk;
		TUint chunkIndex = KPagedChunksStart;
		for (; chunkIndex < KChunksPerProcess && func == EClientGetChunk; chunkIndex++)
			{// Pass handles to all the paged 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(KChunksPerProcess, chunkIndex);
		}
	
	// If we reached the end of then ensure that we kill only the running processes.
	if (processIndex == pagedIndexEnd)
		processIndex--;

	// Let the accessor processes run awhile
	test.Printf(_L("Waiting...\n"));
	User::After(10 * 1000000);
	
	// Kill all the remote processes
	test.Printf(_L("Killing processes...\n"));
	for(TInt j = processIndex; j >= 0; j--)
		{
		test.Printf(_L("  killing process %d\n"), j);
		if (statuses[j] == KRequestPending)
			processes[j].Kill(KErrNone);
		processes[j].Close();
		User::WaitForRequest(statuses[j]);
		}
	delete [] processes;
	delete [] statuses;
	
	// Close the chunks.
	for (TUint k = 0; k < KChunksPerProcess; k++)
		chunks[k].Close();
	delete[] chunks;

	// Reset live list size
	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;
	}