// Copyright (c) 2006-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\defrag\t_pagemove.cpp

//

//--------------------------------------------------------------------------------------------------

//! @SYMTestCaseID			KBASE-T_PAGEMOVE-0572

//! @SYMTestType			UT

//! @SYMPREQ				PREQ308

//! @SYMTestCaseDesc		Test physical page moving

//!							t_pagemove loads and opens the logical device driver ("D_PAGEMOVE.LDD"). 

//!							Following this, it requests that the driver attempt to move  

//!							various kinds of pages directly. 

//!

//!							API Information:

//!								RBusLogicalChannel

//!

//!							Platforms/Drives/Compatibility:

//!								Hardware only. No defrag support on emulator. 

//!

//! @SYMTestActions			1  -  Move regular local data pages

//! 						2  -  Move regular global data pages

//! 						3  -  Move DLL writable static data pages

//! 						4  -  Move user self-modifying code chunk pages

//! 						5  -  Move RAM drive pages

//!							6  -  Move kernel heap pages (*********DISABLED************)

//! 						7  -  Move kernel stack pages

//! 						8  -  Move kernel code pages

//! 						9  -  Move regular code pages

//! 						10 -  Move code whilst the page is being modified

//! 						11 -  Move code (async) whilst the page is being modified

//! 						12 -  Move ROM locale DLL pages

//! 						13 -  Move RAM locale DLL pages

//! 						14 -  Moving pages whilst they are being virtually pinned and unpinned.

//! 						15 -  Moving pages whilst they are being physically pinned and unpinned.

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//--------------------------------------------------------------------------------------------------

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32math.h>

#include <e32uid.h>

#include <e32hal.h>

#include <e32std.h>

#include <e32std_private.h>

#include <dptest.h>

#include "d_pagemove.h"

#include "t_pagemove_dll.h"

#include "t_pmwsd.h"

//#define _DEBUG_MSG

#ifdef _DEBUG_MSG

#define _R_PRINTF(x) 	RDebug::Printf(x)

#define _T_PRINTF(x)	test.Printf(x)

#else

#define _R_PRINTF(x)

#define _T_PRINTF(x)

#endif

LOCAL_D RTest test(_L("T_PAGEMOVE"));

_LIT(ELOCL_DEFAULT, "");

_LIT(ELOCLUS, "T_LOCLUS_RAM");

_LIT(ELOCLUS_ROM, "T_LOCLUS");

LOCAL_C TInt E32TestLocale(TInt);

RCodeModifierDevice Device;

extern TInt TestCodeModFunc();

extern TInt Increment(TInt);

extern TUint Increment_Length();

extern TInt Decrement(TInt);

extern TUint Decrement_Length();

typedef TInt (*PFI)(TInt);

LOCAL_C void StartCodeModifierDriver();

LOCAL_C void StopCodeModifierDriver();

LOCAL_C TInt TestCodeModification(RPageMove &);

LOCAL_C TInt TestCodeModificationAsync(RPageMove& pagemove);

const TPtrC KLddFileName=_L("D_PAGEMOVE.LDD");

TInt Repitions=4000;

TInt PageSize;

TUint NumberOfCpus;

volatile TBool ThreadDie;

TBool gDataPagingSupported;

TBool gRomPagingSupported;

TBool gCodePagingSupported;

TBool gPinningSupported;

// This executable is ram loaded (see mmp file) so this function will do fine

// as a test of RAM-loaded code.

TInt RamLoadedFunction()

	{

	return KArbitraryNumber;

	}

struct SPinThreadArgs

	{

	TLinAddr iLinAddr;

	TTestFunction iTestFunc;

	RThread iParentThread;

	User::TRealtimeState iRealtimeState;

	};

void StartThreads(	TUint aNumThreads, RThread* aThreads, TRequestStatus* aStatus, 

					TThreadFunction aThreadFunc, SPinThreadArgs& aThreadArgs)

	{

	for (TUint i = 0; i < aNumThreads; i++)

		{

		test_KErrNone(aThreads[i].Create(KNullDesC, aThreadFunc, KDefaultStackSize, NULL, &aThreadArgs));

		aThreads[i].Logon(aStatus[i]);

		TRequestStatus threadInitialised;

		aThreads[i].Rendezvous(threadInitialised);

		aThreads[i].Resume();

		_T_PRINTF(_L("wait for child\n"));

		User::WaitForRequest(threadInitialised);

		test_KErrNone(threadInitialised.Int());

		}

	}

void EndThreads(TUint aNumThreads, RThread* aThreads, TRequestStatus* aStatus)

	{

	for (TUint i = 0; i < aNumThreads; i++)

		{

		User::WaitForRequest(aStatus[i]);

		test_Equal(EExitKill, aThreads[i].ExitType());

		test_KErrNone(aThreads[i].ExitReason());

		aThreads[i].Close();

		}

	}

void Reschedule(TInt64& aSeed)

	{

	if (NumberOfCpus == 1)

		{

		TInt rand = Math::Rand(aSeed);

		if ((rand & 0x5) == 5)

			User::AfterHighRes(rand & 0x7);

		}

	}

TInt ReadWriteByte(TAny* aParam)

	{

	SPinThreadArgs* args = (SPinThreadArgs*)aParam;

	volatile TUint8* byte = (volatile TUint8*)args->iLinAddr;

	TInt64 seed = Math::Random()*Math::Random();

	test_KErrNone(User::SetRealtimeState(args->iRealtimeState));

	// Ensure the the parentThread has moved the page at least once

	// before we start accessing it.

	TRequestStatus status;

	args->iParentThread.Rendezvous(status);

	RThread::Rendezvous(KErrNone);

	_R_PRINTF("wait for parent");

	User::WaitForRequest(status);

	_R_PRINTF("acesssing page");

	FOREVER

		{

		*byte = *byte;

		Reschedule(seed);

		if (ThreadDie)

			break;

		}

	return KErrNone;

	}

TInt RunCodeThread(TAny* aParam)

	{

	TInt64 seed = Math::Random()*Math::Random();

	SPinThreadArgs* args = (SPinThreadArgs*)aParam;

	test_KErrNone(User::SetRealtimeState(args->iRealtimeState));

	// Ensure the the parentThread has moved the page at least once

	// before we start accessing it.

	TRequestStatus status;

	args->iParentThread.Rendezvous(status);

	RThread::Rendezvous(KErrNone);

	_R_PRINTF("wait for parent");

	User::WaitForRequest(status);

	_R_PRINTF("acesssing page");

	FOREVER

		{

		TInt r = args->iTestFunc();

		if (r != KArbitraryNumber)

			return KErrGeneral;

		Reschedule(seed);

		if (ThreadDie)

			break;

		}

	return KErrNone;

	}

TInt VirtualPinPage(TAny* aParam)

	{

	TInt64 seed = Math::Random()*Math::Random();

	SPinThreadArgs* args = (SPinThreadArgs*)aParam;

	RMemoryTestLdd ldd;

	test_KErrNone(ldd.Open());

	test_KErrNone(ldd.CreateVirtualPinObject());

	TBool firstRun = ETrue;

	FOREVER

		{

		// Pin the page of aParam.

		test_KErrNone(ldd.PinVirtualMemory(args->iLinAddr, PageSize));

		if (firstRun)

			{// On the first run ensure that the page is definitely pinned when

			// the parent thread first attempts to move it.

			TRequestStatus status;

			args->iParentThread.Rendezvous(status);

			RThread::Rendezvous(KErrNone);

			User::WaitForRequest(status);

			test_KErrNone(status.Int());

			firstRun = EFalse;

			}

		Reschedule(seed);

		test_KErrNone(ldd.UnpinVirtualMemory());

		if (ThreadDie)

			break;

		}

	test_KErrNone(ldd.DestroyVirtualPinObject());

	ldd.Close();

	return KErrNone;

	}

TInt PhysicalPinPage(TAny* aParam)

	{

	TInt64 seed = Math::Random()*Math::Random();

	SPinThreadArgs* args = (SPinThreadArgs*)aParam;

	RMemoryTestLdd ldd;

	test_KErrNone(ldd.Open());

	test_KErrNone(ldd.CreatePhysicalPinObject());

	TBool firstRun = ETrue;

	FOREVER

		{

		// Pin the page of aParam, use a read only pinning so that pinning code 

		// doesn't return KErrAccessDenied as writable mappings not allowed on code.

		test_KErrNone(ldd.PinPhysicalMemoryRO(args->iLinAddr, PageSize));

		if (firstRun)

			{// On the first run ensure that the page is definitely pinned when

			// the parent thread first attempts to move it.

			TRequestStatus status;

			args->iParentThread.Rendezvous(status);

			RThread::Rendezvous(KErrNone);

			User::WaitForRequest(status);

			test_KErrNone(status.Int());

			firstRun = EFalse;

			}

		Reschedule(seed);

		test_KErrNone(ldd.UnpinPhysicalMemory());

		if (ThreadDie)

			break;

		}

	test_KErrNone(ldd.DestroyPhysicalPinObject());

	ldd.Close();

	return KErrNone;

	}

TInt ModifyCodeThread(TAny* aParam)

	{

	SPinThreadArgs* args = (SPinThreadArgs*)aParam;

	TUint8* p = (TUint8*)args->iLinAddr;

	PFI func = (PFI)p;

	// Ensure the the parentThread has moved the page at least once

	// before we start accessing it.

	TRequestStatus status;

	args->iParentThread.Rendezvous(status);

	RThread::Rendezvous(KErrNone);

	_R_PRINTF("wait for parent");

	User::WaitForRequest(status);

	_R_PRINTF("modifiying page");

	while (!ThreadDie)

		{

		Mem::Copy(p, (TAny*)&Increment, Increment_Length());

		User::IMB_Range(p, p+Increment_Length());

		test_Equal(8, func(7));

		Mem::Copy(p, (TAny*)&Decrement, Decrement_Length());

		User::IMB_Range(p, p+Decrement_Length());

		test_Equal(6, func(7));

		}

	return KErrNone;

	}

enum TMovingPinStage

	{

	ENoPinning,

	EVirtualPinning,

	EPhysicalPinning,

	EMovingPinStages,

	};

void TestUserData(RPageMove& pagemove, TUint8* array, TInt size, TBool aPagedData=EFalse)

	{

	_T_PRINTF(_L("Fill the array with some data\n"));

	for (TInt i=0; i<size; i++) array[i] = i*i;

	TUint8* firstpage = (TUint8*)_ALIGN_DOWN((TLinAddr)array, PageSize);

	RThread thread;

	thread.Open(RThread().Id());

	SPinThreadArgs threadArgs;

	threadArgs.iLinAddr = (TLinAddr)array;

	threadArgs.iParentThread = thread;

	threadArgs.iRealtimeState = User::ERealtimeStateOff;

	TMovingPinStage endStage = EMovingPinStages;

	if (!gPinningSupported)

		endStage = EVirtualPinning;

	for (TUint state = ENoPinning; state < (TUint)endStage; state++)

		{

		TThreadFunction threadFunc = NULL;

		switch (state)

			{

			case ENoPinning:

				test.Printf(_L("Attempt to move pages while they are being modified\n"));

				threadFunc = &ReadWriteByte;

				break;

			case EVirtualPinning:

				test.Printf(_L("Attempt to move pages while they are being virtually pinned\n"));

				threadFunc = &VirtualPinPage;

				break;

			case EPhysicalPinning:

				test.Printf(_L("Attempt to move pages while they are being physically pinned\n"));

				threadFunc = &PhysicalPinPage;

				break;

			}

		ThreadDie = EFalse;

		TUint numThreads = (NumberOfCpus > 1) ? NumberOfCpus - 1 : 1;

		RThread* userDataThread = new RThread[numThreads];

		TRequestStatus* s = new TRequestStatus[numThreads];

		StartThreads(numThreads, userDataThread, s, threadFunc, threadArgs);

		_T_PRINTF(_L("Move first array page repeatedly\n"));

		TBool success=EFalse;

		TUint inuse = 0;

		*(volatile TUint8*)array = *array;	// Ensure the page of the first entry is paged in for the first move.

		for (TInt i=0; i < Repitions*2; i++)

			{

			TInt r = pagemove.TryMovingUserPage(firstpage, ETrue);

			if (i == 0)

				{// If this is the first run allow the pinning threads to 

				// unpin the memory now that we've definitely done at least 

				// one page move with the page pinned.

				_T_PRINTF(_L("signal to child\n"));

				RThread::Rendezvous(KErrNone);

				}

			switch (r)

				{

				case KErrInUse:

					inuse++;

					break;

				case KErrArgument:

					// The page was paged out, this should only happen for paged data.

					test(aPagedData);

					break;

				default:

					test_KErrNone(r);

					success=ETrue;

					break;

				}

			}

		// Can't guarantee that for paged data the page and its page tables will

		// be paged in, in most cases it will be at least once.

		// Pinning the page should always return KErrInUse except for virtually 

		// pinned non-paged memory as virtual pinning is a nop for unpaged memory.

		test.Printf(_L("inuse test removed; inuse %d\n"),inuse);

		//test(inuse || aPagedData || state == EVirtualPinning);

		test(success || state == EPhysicalPinning);

		ThreadDie = ETrue;

		EndThreads(numThreads, userDataThread, s);

		_T_PRINTF(_L("Validate page data\n"));

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

			test_Equal((TUint8)(i*i), array[i]);

		}

	thread.Close();

	}

void TestMovingCode(RPageMove& aPagemove, TTestFunction aFunc, TBool aPaged=EFalse)

	{

	TUint8* firstpage = (TUint8*)_ALIGN_DOWN((TLinAddr)aFunc, PageSize);

	RThread thread;

	thread.Open(RThread().Id());

	SPinThreadArgs threadArgs;

	threadArgs.iLinAddr = (TLinAddr)firstpage;

	threadArgs.iTestFunc = aFunc;

	threadArgs.iParentThread = thread;

	threadArgs.iRealtimeState = User::ERealtimeStateOff;

	TMovingPinStage endStage = EMovingPinStages;

	if (!gPinningSupported)

		endStage = EVirtualPinning;

	for (TUint state = ENoPinning; state < (TUint)endStage; state++)

		{

		TThreadFunction threadFunc = NULL;

		switch (state)

			{

			case ENoPinning:

				test.Printf(_L("Attempt to move pages while they are being executed\n"));

				threadFunc = &RunCodeThread;

				test_Equal(KArbitraryNumber, aFunc()); // Ensure the page is paged in.

				break;

			case EVirtualPinning:

				test.Printf(_L("Attempt to move pages while they are being virtually pinned\n"));

				threadFunc = &VirtualPinPage;

				break;

			case EPhysicalPinning:

				test.Printf(_L("Attempt to move pages while they are being physically pinned\n"));

				threadFunc = &PhysicalPinPage;

				break;

			}

		ThreadDie = EFalse;

		TUint numThreads = (NumberOfCpus > 1) ? NumberOfCpus - 1 : 1;

		RThread* codeRunThread = new RThread[numThreads];

		TRequestStatus* s = new TRequestStatus[numThreads];

		StartThreads(numThreads, codeRunThread, s, threadFunc, threadArgs);

		_T_PRINTF(_L("Move first code page repeatedly\n"));

		test_Equal(KArbitraryNumber, aFunc());	

		TBool inuse=EFalse, success=EFalse;

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

			{

			TInt r = aPagemove.TryMovingUserPage(firstpage, ETrue);

			if (i == 0)

				{// If this is the first run allow the pinning threads to 

				// unpin the memory now that we've definitely done at least 

				// one page move with the page pinned.

				_T_PRINTF(_L("signal to child\n"));

				RThread::Rendezvous(KErrNone);

				}

			switch (r)

				{

				case KErrInUse:

					inuse=ETrue;

					break;

				case KErrArgument:

					// The page was paged out, this should only happen for paged code.

					test(aPaged);

					break;

				default:

					test_KErrNone(r);

					success=ETrue;

					break;

				}

			}

		// Physical pinning or adding a new pinning while a page is being moved

		// should prevent code pages being moved.

		switch (state)

		{

			case ENoPinning :			

				test(!inuse || aPaged);	// Stealing may get KErrInUse but this should only happen for paged code.

			case EVirtualPinning :

				test(success);

				break;

			case EPhysicalPinning :

				break;

		}

		ThreadDie = ETrue;

		EndThreads(numThreads, codeRunThread, s);

		_T_PRINTF(_L("Validate page data\n"));

		test_Equal(KArbitraryNumber, aFunc());		

		}

	thread.Close();

	}

void TestMovingRealtime(RPageMove& aPagemove, TUint8* aArray, TInt aSize, TTestFunction aFunc, TBool aCode, TBool aPaged=EFalse)

	{

	TThreadFunction threadFunc;

	TLinAddr pageAddr;

	RThread thread;

	TUint8* firstpage;

	thread.Open(RThread().Id());

	SPinThreadArgs threadArgs;

	threadArgs.iParentThread = thread;

	if (aCode)

		{

		pageAddr = (TLinAddr)aFunc;

		firstpage = (TUint8*)_ALIGN_DOWN(pageAddr, PageSize);

		threadArgs.iLinAddr = (TLinAddr)firstpage;

		threadFunc = RunCodeThread;

		threadArgs.iTestFunc = aFunc;

		test_Equal(KArbitraryNumber, aFunc());

		}