#include "../mmu/freeram.h"

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

	EClientGetParentProcess = 2,

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

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

	// data.

	TLex lex(ptr);

	RChunk* chunks = NULL;

	RDataPagingSession session;

	RProcess parent;

	TRequestStatus parentStatus;

	TInt offset = 0;

	TInt i;

	CLIENT_TEST(r == KErrNone, r);	

	chunks = new RChunk[chunkCount];

	CLIENT_TEST(chunks, KErrNoMemory);

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

			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 (TUint j = 0 ; j < KPageTablesPerChunk ; j++)

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

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

	}

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

	// Ensure enough RAM available

	PrintFreeRam();

	TInt freeRam = FreeRam();

	test.Printf(_L("Start server\n"));

	r = ptServer.CreateGlobal(KClientPtServerName);

	test.Printf(_L("Create chunks\n"));

	const TUint KPagedChunksStart = (KChunksPerProcess >> 1);

	RChunk* chunks = new RChunk[KChunksPerProcess];

	test_NotNull(chunks);

	for (i = 0 ; i< KChunksPerProcess; i++)

		CreateChunk(chunks[i], i, KPageTablesPerChunk, i >= KPagedChunksStart);

	test.Printf(_L("Start remote processes\n"));

	test_NotNull(processes);

	TRequestStatus* statuses = new TRequestStatus[KNumProcesses];

	test_NotNull(statuses);

	TUint processIndex = 0;	

		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess, EFalse);

		// logon to process

		processes[processIndex].Logon(statuses[processIndex]);

		test_Equal(KRequestPending, statuses[processIndex].Int());

		// wait for connect message

		RMessage2 ptMessage;

		// pass client a handle to this process

		ptServer.Receive(ptMessage);

		test_Equal(EClientGetParentProcess, ptMessage.Function());

		ptMessage.Complete(RProcess());

		// pass client chunk handles

		TInt func;

		for (; chunkIndex < KChunksPerProcess ; chunkIndex++)

			if (func != EClientGetChunk)

				break;

			ptMessage.Complete(chunks[ptMessage.Int0()]);

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

		test_Equal(KChunksPerProcess, chunkIndex);

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

		// start the process.

		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess-KPagedChunksStart, ETrue);

		// logon to process

		processes[processIndex].Logon(statuses[processIndex]);

		test_Equal(KRequestPending, statuses[processIndex].Int());

		// wait for connect message

		RMessage2 ptMessage;

		// pass client a handle to this process

		ptServer.Receive(ptMessage);

		test_Equal(EClientGetParentProcess, ptMessage.Function());

		ptMessage.Complete(RProcess());

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

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

		test_Equal(KChunksPerProcess, chunkIndex);

	// Let the accessor processes run awhile

	test.Printf(_L("Waiting...\n"));

	User::After(10 * 1000000);

	test.Printf(_L("Killing processes...\n"));

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

		if (statuses[j] == KRequestPending)

		User::WaitForRequest(statuses[j]);

	delete [] processes;

	delete [] statuses;

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

	// Reset live list size