// 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"
#include "..\mmu\mmudetect.h"
#include "..\debug\d_codemodifier.h"
#include "..\mmu\d_memorytest.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;
		array[0] = array[0];	// 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 || aPagedData);

		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"));
		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());
		}
	else
		{
		pageAddr = (TLinAddr)aArray;
		firstpage = (TUint8*)_ALIGN_DOWN(pageAddr, PageSize);
		threadArgs.iLinAddr = (TLinAddr)aArray;
		threadFunc = ReadWriteByte;
		_T_PRINTF(_L("Fill the array with some data\n"));
		for (TInt i=0; i<aSize; i++) aArray[i] = i*i;
		}

	RMemoryTestLdd ldd;

	TMovingPinStage endStage = EMovingPinStages;
	if (gPinningSupported)
		{
		test_KErrNone(ldd.Open());
		test_KErrNone(ldd.CreateVirtualPinObject());
		test_KErrNone(ldd.CreatePhysicalPinObject());
		}
	else
		endStage = EVirtualPinning;

	for (TUint state = ENoPinning; state < (TUint)endStage; state++)
		{
		switch (state)
			{
			case ENoPinning:
				test.Printf(_L("Attempt to move pages while they are being accessed\n"));
				break;
			case EVirtualPinning:
				test.Printf(_L("Attempt to move pages while they are virtually pinned\n"));
				test_KErrNone(ldd.PinVirtualMemory((TLinAddr)firstpage, PageSize));

				break;
			case EPhysicalPinning:
				test.Printf(_L("Attempt to move pages while they are physically pinned\n"));
				test_KErrNone(ldd.PinPhysicalMemoryRO((TLinAddr)firstpage, PageSize));
				break;
			}
		for (	TUint realtimeState = User::ERealtimeStateOff; 
				realtimeState <= User::ERealtimeStateWarn; 
				realtimeState++)
			{
			ThreadDie = EFalse;
			RThread accessThread;
			TRequestStatus s;
			threadArgs.iRealtimeState = (User::TRealtimeState)realtimeState;
			test_KErrNone(accessThread.Create(_L("Realtime Thread"), threadFunc, KDefaultStackSize, NULL, &threadArgs));
			accessThread.Logon(s);
			TRequestStatus threadInitialised;
			accessThread.Rendezvous(threadInitialised);
			accessThread.Resume();

			_T_PRINTF(_L("wait for child\n"));
			User::WaitForRequest(threadInitialised);
			test_KErrNone(threadInitialised.Int());

			_T_PRINTF(_L("Move page repeatedly\n"));
			TBool success=EFalse, pagedOut=EFalse;
			TUint inuse=0;
			if (!aCode)
				aArray[0] = aArray[0];	// Ensure the page of the first entry is paged in for the first move.
			for (TInt i=0; i < Repitions; i++)
				{
				TInt r = aPagemove.TryMovingUserPage(firstpage, ETrue);
				if (i == 0)
					{
					_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 code.
						test(aPaged);
						pagedOut = ETrue;
						break;
					default:
						test_KErrNone(r);
						success=ETrue;
						break;
					}
				}
			ThreadDie = ETrue;
			User::WaitForRequest(s);
			test.Printf(_L("inuse %d\n"),inuse);
			switch (state)
				{
				case ENoPinning :
					test(success || aPaged);
					if (aPaged && realtimeState == User::ERealtimeStateOn)
						{
						test_Equal(EExitPanic, accessThread.ExitType());
						test(accessThread.ExitCategory()==_L("KERN-EXEC"));
						test_Equal(EIllegalFunctionForRealtimeThread, accessThread.ExitReason());
						}
					else
						{
						test_Equal(EExitKill,accessThread.ExitType());
						test_KErrNone(accessThread.ExitReason());
						}
					// Ensure the page is paged in before we attempt to move it again with a different realtime state.
					if (aCode)
						{
						test_Equal(KArbitraryNumber, aFunc());
						}
					else
						*aArray = *aArray;
					break;				
				case EVirtualPinning :
					test(!aCode || !inuse);
					test(success);
					test(!pagedOut);
					test_Equal(EExitKill,accessThread.ExitType());
					test_KErrNone(accessThread.ExitReason());
					break;
				case EPhysicalPinning :
					test(!success);
					break;
				}
			accessThread.Close();
			}
		if (gPinningSupported)
			{
			// Unpin any pinned memory.
			test_KErrNone(ldd.UnpinVirtualMemory());
			test_KErrNone(ldd.UnpinPhysicalMemory());
			}

		_T_PRINTF(_L("Validate page data\n"));
		if (aCode)
			{
			test_Equal(KArbitraryNumber, aFunc());
			}
		else
			{
			for (TInt i=0; i<aSize; i++)
				test_Equal((TUint8)(i*i), aArray[i]);
			}
			
		}
	if (gPinningSupported)
		{
		test_KErrNone(ldd.DestroyVirtualPinObject());
		test_KErrNone(ldd.DestroyPhysicalPinObject());
		ldd.Close();
		}
	thread.Close();
	}

// Only commits and decommits the first page as that is the only page that is being moved.
// Plus this ensures the page table and page directories of the chunk are always allocated
// and therefore prevents Epoc::LinearToPhysical() from crashing the system.
TInt CommitDecommit(TAny* aParam)
	{
	RChunk* chunk = (RChunk*) aParam;
	volatile TUint8* byte = chunk->Base();
	FOREVER
		{
		*byte = *byte;
		User::AfterHighRes(0);
		TInt r = chunk->Decommit(0, PageSize);
		if (r != KErrNone)
			return r;
		User::AfterHighRes(0);
		r = chunk->Commit(0, PageSize);
		if (r != KErrNone)
			return r;
		}
	}

void TestCommitDecommit(RPageMove& pagemove, RChunk& aChunk)
	{
	test.Printf(_L("Attempt to move a page while it is being committed and decommited\n"));
	RThread thread;
	TRequestStatus s;
	test_KErrNone(thread.Create(_L("CommitDecommit"), &CommitDecommit, KDefaultStackSize, NULL, (TAny*)&aChunk));
	thread.Logon(s);
	thread.SetPriority(EPriorityMore);
	thread.Resume();

	TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)aChunk.Base(), PageSize);
	for (TInt i=0; i < Repitions; i++)
		{
		TInt r = pagemove.TryMovingUserPage(firstpage, ETrue);
		// Allow all valid return codes as we are only testing that this doesn't 
		// crash the kernel and the page could be commited, paged out or decommited
		// at any one time.
		test_Value(r, r <= KErrNone);
		}

	thread.Kill(KErrNone);
	User::WaitForRequest(s);
	test_Equal(EExitKill,thread.ExitType());
	test_KErrNone(thread.ExitReason());
	thread.Close();
	}


void TestPageTableDiscard(RPageMove& pagemove, TUint8* array, TUint size)
	{
	_T_PRINTF(_L("Fill the array with some data\n"));
	for (TUint 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 pageTableInfo = 0; pageTableInfo < 2; pageTableInfo++)
		{
		for (TUint state = ENoPinning; state < (TUint)endStage; state++)
			{
			TThreadFunction threadFunc = NULL;
			if (!pageTableInfo)
			{
			switch (state)
				{
				case ENoPinning:
					test.Printf(_L("Attempt to move page tables whilst the pages they map are being modified\n"));
					threadFunc = &ReadWriteByte;
					break;
				case EVirtualPinning:
					test.Printf(_L("Attempt to move page tables whilst the pages they map are being virtually pinned\n"));
					threadFunc = &VirtualPinPage;
					break;
				case EPhysicalPinning:
					test.Printf(_L("Attempt to move page tables whilst the pages they map are being physically pinned\n"));
					threadFunc = &PhysicalPinPage;
					break;
				}
			}
			else
			{
			switch (state)
				{
				case ENoPinning:
					test.Printf(_L("Attempt to move page table infos whilst pages they refer to are being modified\n"));
					threadFunc = &ReadWriteByte;
					break;
				case EVirtualPinning:
					test.Printf(_L("Attempt to move page table infos whilst pages they refer to are being virtually pinned\n"));
					threadFunc = &VirtualPinPage;
					break;
				case EPhysicalPinning:
					test.Printf(_L("Attempt to move page table infos whilst pages they refer to are being physically pinned\n"));
					threadFunc = &PhysicalPinPage;
					break;
				}
			}
			ThreadDie = EFalse;
			TUint numThreads = (NumberOfCpus > 1) ? NumberOfCpus - 1 : 1;
			RThread* threads = new RThread[numThreads];
			TRequestStatus* s = new TRequestStatus[numThreads];
			StartThreads(numThreads, threads, s, threadFunc, threadArgs);

			_T_PRINTF(_L("Move first array page repeatedly\n"));
			TUint inuse = 0;
			for (TInt i=0; i < Repitions; i++)
				{
				TInt r;
				if (!pageTableInfo)
					r = pagemove.TryMovingPageTable(firstpage);
				else
					r = pagemove.TryMovingPageTableInfo(firstpage);					
				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 KErrNotFound:
						// The page table or page table info page was paged out.
						break;
					default:
						test_KErrNone(r);
						break;
					}
				}
			test.Printf(_L("inuse %d\n"),inuse);
			// A virtually pinned page should always return KErrInUse at least once.
			test(state != EVirtualPinning || inuse);

			ThreadDie = ETrue;
			EndThreads(numThreads, threads, s);

			_T_PRINTF(_L("Validate page data\n"));
			for (TUint i=0; i<size; i++)
				test_Equal((TUint8)(i*i), array[i]);
			}
		}
	thread.Close();
	}

// Basic testing of moving rom pages.
void TestMovingRom(RPageMove& aPageMove)
	{
	TUint8* pPage=(TUint8*)User::Alloc(PageSize);
	test(pPage!=NULL);

	TUint romHdr = UserSvr::RomHeaderAddress();

	if (gPinningSupported)
		{
		// Pin an unpaged rom page to get the physical address of the rom page.
		// Pinning unpaged rom actually does nothing except return the physical 
		// address of the page.
		RMemoryTestLdd ldd;
		test_KErrNone(ldd.Open());
		test_KErrNone(ldd.CreatePhysicalPinObject());

		// Save contents of rom page.
		Mem::Move(pPage,(TAny*)romHdr,PageSize);

		test_KErrNone(ldd.PinPhysicalMemoryRO(romHdr, PageSize));
		test_KErrNone(ldd.UnpinPhysicalMemory());

		// Now move the page, d_memorytest saves the address of the pinned page
		// depsite it being unpinned.
		// Will get KErrArgument as rom pages don't have an SPageInfo so memory
		// model doesn't treat rom as though they are in ram, which in most cases 
		// they are.
		test_Equal(KErrArgument, ldd.MovePinnedPhysicalMemory(0));

		test_KErrNone(Mem::Compare((TUint8*)romHdr,PageSize,pPage,PageSize));
		test_KErrNone(ldd.DestroyPhysicalPinObject());
		ldd.Close();
		}

	if (gRomPagingSupported)
		{
		// Use paged part of rom for testing
		TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
		test(romHeader->iPageableRomStart);
		TUint romAddr = (TUint)((TUint8*)romHeader + romHeader->iPageableRomStart + 64 * PageSize);

		// We will use the 64th pagable rom page so check that it exists.
		test(romHeader->iPageableRomSize >= 65 * PageSize);
	
		// Page in the rom page and save it contents.
		Mem::Move(pPage,(TAny*)romAddr,PageSize);
		// This will actually discard the page not move it.
		test_KErrNone(aPageMove.TryMovingUserPage(pPage));

		test_KErrNone(Mem::Compare((TUint8*)romAddr,PageSize,pPage,PageSize));
		}
	}


void TestMovingCodeChunk(RPageMove& pagemove, RChunk aChunk, TBool aPagedData)
	{
	TUint8* p = aChunk.Base();

	TUint8* firstpage = (TUint8*)_ALIGN_DOWN((TLinAddr)p, PageSize);
	RThread thread;
	thread.Open(RThread().Id());
	SPinThreadArgs threadArgs;
	threadArgs.iLinAddr = (TLinAddr)p;
	threadArgs.iParentThread = thread;

	test.Printf(_L("Attempt to move pages while they are being executed and modified\n"));
	ThreadDie = EFalse;
	RThread modCodeThread;
	TRequestStatus s;
	test_KErrNone(modCodeThread.Create(_L("User Data thread"), &ModifyCodeThread, KDefaultStackSize, NULL, &threadArgs));
	modCodeThread.Logon(s);
	TRequestStatus threadInitialised;
	modCodeThread.Rendezvous(threadInitialised);
	modCodeThread.Resume();

	_T_PRINTF(_L("wait for child\n"));
	User::WaitForRequest(threadInitialised);
	test_KErrNone(threadInitialised.Int());

	_T_PRINTF(_L("Move code chunk page repeatedly\n"));
	TBool success=EFalse;
	p[0] = p[0];	// Ensure the page of the first entry is paged in for the first move.
	for (TInt i=0; i < Repitions; i++)
		{
		TInt r = pagemove.TryMovingUserPage(firstpage, ETrue);
		if (i == 0)
			{// If this is the first run allow the modifying thread to run now 
			// we've done one move.
			_T_PRINTF(_L("signal to child\n"));
			RThread::Rendezvous(KErrNone);
			}
		switch (r)
			{
			case KErrInUse:
				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;
			}
		}
	test(success || aPagedData);

	ThreadDie = ETrue;
	User::WaitForRequest(s);
	test_Equal(EExitKill,modCodeThread.ExitType());
	test_KErrNone(modCodeThread.ExitReason());
	modCodeThread.Close();

	thread.Close();
	}

GLDEF_C TInt E32Main()
    {
	test.Title();
	if (!HaveMMU())
		{
		test.Printf(_L("This test requires an MMU\n"));
		return KErrNone;
		}

	test.Start(_L("Load test LDD"));
	TInt r=User::LoadLogicalDevice(KLddFileName);
	test(r==KErrNone || r==KErrAlreadyExists);

	test_KErrNone(UserHal::PageSizeInBytes(PageSize));

	// Determine which types of paging are supported
	TUint32 attrs = DPTest::Attributes();
	gRomPagingSupported = (attrs & DPTest::ERomPaging) != 0;
	gCodePagingSupported = (attrs & DPTest::ECodePaging) != 0;
	gDataPagingSupported = (attrs & DPTest::EDataPaging) != 0;

	// Does this memory model support pinning.
	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
	gPinningSupported = mm >= EMemModelTypeFlexible;

	RPageMove pagemove;
	test.Next(_L("Open test LDD"));
	test_KErrNone(pagemove.Open());

	// Determine whether this is a smp device.
	NumberOfCpus = pagemove.NumberOfCpus();
	if (NumberOfCpus > 1)
		Repitions = 1000;	// SMP system therefore likely to get KErrInUse in less repitions.

	test.Next(_L("Attempting to move regular local data pages"));
		{
		const TInt size=16384;
		TUint8* array = new TUint8[size];
		test_NotNull(array);

		TestUserData(pagemove, array, size);

		_T_PRINTF(_L("Walk heap\n"));
		User::Check();

		delete [] array;
		}

	test.Next(_L("Attempting to move regular global coarse data pages"));
		{
		const TInt size=1<<20;	// Make this chunk multiple of 1MB so it is a coarse memory object on FMM
		RChunk chunk;
		test_KErrNone(chunk.CreateDisconnectedGlobal(_L("Dave"), 0, size, size));
		TUint8* array = chunk.Base();

		TestUserData(pagemove, array, size);
		TestMovingRealtime(pagemove, array, size, NULL, EFalse);
		TestCommitDecommit(pagemove, chunk);

		chunk.Close();
		}

	if (gDataPagingSupported)
		{
		test.Next(_L("Attempting to move demand paged fine local user data pages"));
		const TInt size=16384;
		TChunkCreateInfo createInfo;
		createInfo.SetDisconnected(0, size, size);
		createInfo.SetPaging(TChunkCreateInfo::EPaged);
		RChunk chunk;
		test_KErrNone(chunk.Create(createInfo));
		TUint8* array = chunk.Base();

		TestUserData(pagemove, array, size, ETrue);
		TestMovingRealtime(pagemove, array, size, NULL, EFalse, ETrue);
		TestPageTableDiscard(pagemove, array, size);
		TestCommitDecommit(pagemove, chunk);
		chunk.Close();

		test.Next(_L("Attempting to move demand paged coarse global user data pages"));
		const TInt sizeCoarse = 1 << 20; // Make this chunk multiple of 1MB so it is a coarse memory object on FMM
		TChunkCreateInfo createInfoCoarse;
		createInfoCoarse.SetDisconnected(0, sizeCoarse, sizeCoarse);
		createInfoCoarse.SetGlobal(_L("Dave"));
		createInfoCoarse.SetPaging(TChunkCreateInfo::EPaged);
		RChunk chunkCoarse;
		test_KErrNone(chunkCoarse.Create(createInfoCoarse));
		array = chunkCoarse.Base();

		TestUserData(pagemove, array, sizeCoarse, ETrue);
		TestMovingRealtime(pagemove, array, sizeCoarse, NULL, EFalse, ETrue);
		TestPageTableDiscard(pagemove, array, sizeCoarse);
		TestCommitDecommit(pagemove, chunkCoarse);
		chunkCoarse.Close();
		}

	test.Next(_L("Attempting to move DLL writable static data pages"));
		{
		const TInt size=16384;
		TUint8* array = DllWsd::Address();

		TestUserData(pagemove, array, size);
		}

	test.Next(_L("Attempting to move user self-mod code chunk page when IMB'ing and executing"));
	RChunk codeChunk;
	test_KErrNone(codeChunk.CreateLocalCode(PageSize,PageSize));
	TestMovingCodeChunk(pagemove, codeChunk, EFalse);
	codeChunk.Close();

	if (gDataPagingSupported)
		{
		test.Next(_L("Attempting to move paged user self-mod code chunk page when IMB'ing and executing"));
		TChunkCreateInfo createInfo;
		createInfo.SetCode(PageSize, PageSize);
		createInfo.SetPaging(TChunkCreateInfo::EPaged);

		RChunk pagedCodeChunk;
		test_KErrNone(pagedCodeChunk.Create(createInfo));
		TestMovingCodeChunk(pagemove, pagedCodeChunk, ETrue);
		pagedCodeChunk.Close();
		}

	test.Next(_L("Attempting to move RAM drive"));
	if ((MemModelAttributes()&EMemModelTypeMask) == EMemModelTypeMultiple)
		{
		for (TInt i=0; i<Repitions; i++)
			test_KErrNone(pagemove.TryMovingUserPage((TAny*)0xA0000000));
		}
	else if ((MemModelAttributes()&EMemModelTypeMask) == EMemModelTypeMoving)
		{
		for (TInt i=0; i<Repitions; i++)
			test_KErrNone(pagemove.TryMovingUserPage((TAny*)0x40000000));
		}
	else if ((MemModelAttributes()&EMemModelTypeMask) == EMemModelTypeFlexible)
		{
		// do nothing, RAM drive is not special
		}
	else
		{
		test.Printf(_L("Don't know where the RAM drive is!"));
		test(0);
		}
	
#if 0
	test.Next(_L("Attempting to move kernel heap pages"));
	for (TInt i=0; i<Repitions; i++)
		test_KErrNone(pagemove.TryMovingKHeap());
#endif

	if ((MemModelAttributes()&EMemModelTypeMask) != EMemModelTypeFlexible)
		{// Only the moving and multiple memory models move kernel stack pages.
		test.Next(_L("Attempting to move kernel stack pages"));
		for (TInt i=0; i<Repitions; i++)
			test_KErrNone(pagemove.TryMovingKStack());
		}

	test.Next(_L("Attempting to move ROM pages"));
	TestMovingRom(pagemove);

	test.Next(_L("Attempting to move kernel code pages"));
	for (TInt i=0; i<Repitions; i++)
		test_KErrNone(pagemove.TryMovingKCode());

	test.Next(_L("Attempting to move regular code pages"));
	TestMovingCode(pagemove, RamLoadedFunction);
	TestMovingRealtime(pagemove, NULL, 0, RamLoadedFunction, ETrue, EFalse);

	if (gCodePagingSupported)
		{
		test.Next(_L("Attempting to move demand paged code pages"));
		TestMovingCode(pagemove, DllTestFunction, ETrue);
		TestMovingRealtime(pagemove, NULL, 0, DllTestFunction, ETrue, ETrue);
		}

	/* Setup CodeModifier Test Driver */
	StartCodeModifierDriver();
	test(KErrNone==Device.InitialiseCodeModifier(/* Max break points */ 5 ));

	test.Next(_L("Attempting to move code page being modified\n"));
	test_KErrNone(TestCodeModification(pagemove));

	test.Next(_L("Attempting to move code (async) while page being modified"));
	test_KErrNone(TestCodeModificationAsync(pagemove));

	StopCodeModifierDriver();
	
	test.Next(_L("Attempting to move ROM Locale DLL Page"));
	test_KErrNone(E32TestLocale(1));

	test.Next(_L("Attempting to move RAM Locale DLL Page"));
	test_KErrNone(E32TestLocale(0));

	test.Next(_L("Close test LDD"));
	pagemove.Close();
	User::FreeLogicalDevice(KLddFileName);

	test.End();
	return(KErrNone);
    }


void testUS(const TLocale& aLocale)
{
	test.Printf(_L("Test US\n"));

	test(aLocale.CountryCode()==1);
	test(aLocale.DateFormat()==EDateAmerican);
	test(aLocale.TimeFormat()==ETime12);
	test(aLocale.CurrencySymbolPosition()==ELocaleBefore);
	test(aLocale.CurrencySpaceBetween()==FALSE);
	test(aLocale.CurrencyDecimalPlaces()==2);
	test(aLocale.CurrencyNegativeInBrackets()==EFalse);
	test(aLocale.CurrencyTriadsAllowed()==TRUE);
	test(aLocale.ThousandsSeparator()==',');
	test(aLocale.DecimalSeparator()=='.');
	test(aLocale.DateSeparator(0)==0);
	test(aLocale.DateSeparator(1)=='/');
	test(aLocale.DateSeparator(2)=='/');
	test(aLocale.DateSeparator(3)==0);
	test(aLocale.TimeSeparator(0)==0);
	test(aLocale.TimeSeparator(1)==':');
	test(aLocale.TimeSeparator(2)==':');
	test(aLocale.TimeSeparator(3)==0);
	test(aLocale.AmPmSymbolPosition()==TRUE);
	test(aLocale.AmPmSpaceBetween()==TRUE);
	test(aLocale.HomeDaylightSavingZone()==EDstNorthern);
	test(aLocale.WorkDays()==0x1f);
	test(aLocale.StartOfWeek()==ESunday);
	test(aLocale.ClockFormat()==EClockAnalog);
	test(aLocale.UnitsGeneral()==EUnitsImperial);
	test(aLocale.UnitsDistanceShort()==EUnitsImperial);
	test(aLocale.UnitsDistanceLong()==EUnitsImperial);
}


void testUK(const TLocale& aLocale)
{
//#ifdef __WINS__
	test(aLocale.CountryCode()==44);
	test(aLocale.DateFormat()==EDateEuropean);
	test(aLocale.TimeFormat()==ETime12);
	test(aLocale.CurrencySymbolPosition()==ELocaleBefore);
	test(aLocale.CurrencySpaceBetween()==FALSE);
	test(aLocale.CurrencyDecimalPlaces()==2);
	test(aLocale.CurrencyNegativeInBrackets()==EFalse);
	test(aLocale.CurrencyTriadsAllowed()==TRUE);
	test(aLocale.ThousandsSeparator()==',');
	test(aLocale.DecimalSeparator()=='.');
	test(aLocale.DateSeparator(0)==0);
	test(aLocale.DateSeparator(1)=='/');
	test(aLocale.DateSeparator(2)=='/');
	test(aLocale.DateSeparator(3)==0);
	test(aLocale.TimeSeparator(0)==0);
	test(aLocale.TimeSeparator(1)==':');
	test(aLocale.TimeSeparator(2)==':');
	test(aLocale.TimeSeparator(3)==0);
	test(aLocale.AmPmSymbolPosition()==TRUE);
	test(aLocale.AmPmSpaceBetween()==TRUE);
	test(aLocale.HomeDaylightSavingZone()==EDstEuropean);
	test(aLocale.WorkDays()==0x1f);
	test(aLocale.StartOfWeek()==EMonday);
	test(aLocale.ClockFormat()==EClockAnalog);
	test(aLocale.UnitsGeneral()==EUnitsImperial);
	test(aLocale.UnitsDistanceShort()==EUnitsImperial);
	test(aLocale.UnitsDistanceLong()==EUnitsImperial);
//#endif
}


void testChangeLocale(TInt isrom)
{
	TLocale locale;
	
#ifdef __WINS__
//We get a power-change notification 1 second after switch-on
//So we wait for a second on WINS.
//Should we fix this bug??
	User::After(1000000);
#endif
	RChangeNotifier notifier;
	TInt res=notifier.Create();
	test(res==KErrNone);
	TRequestStatus stat;
	res=notifier.Logon(stat);
	test(res==KErrNone);
	//initial pattern of stat is already tested by t_chnot

	res=notifier.Logon(stat);
	test(res==KErrNone);
	test(stat==KRequestPending);
	if (isrom == 0) 
		{
		test.Printf(_L("Change to RAM US Locale\n")); 	
		res=UserSvr::ChangeLocale(ELOCLUS);
		}
	else
		{
		test.Printf(_L("Change to ROM US Locale\n")); 	
		res=UserSvr::ChangeLocale(ELOCLUS_ROM);
		}
	test.Printf(_L("res=%d\n"),res);
	test(res==KErrNone);
	test(stat.Int() & EChangesLocale);
	res=notifier.Logon(stat);
	test(res==KErrNone);
	test(stat==KRequestPending);
	
	locale.Refresh();
	testUS(locale);
}


LOCAL_C void LocaleLanguageGet(SLocaleLanguage& locale)
{
	TPckg<SLocaleLanguage> localeLanguageBuf(locale);
	TInt r = RProperty::Get(KUidSystemCategory, KLocaleLanguageKey, localeLanguageBuf);
	test(r == KErrNone || r == KErrNotFound);
}

LOCAL_C TInt E32TestLocale(TInt isrom)
{
	TInt r;
	TAny *LocaleAddr;
	TLocale locale;
	
	/* Setup the US Locale DLL and ensure the Locale got modified (testUS) */
	testChangeLocale(isrom);
 
	/* Now get a pointer to some data in the DLL. This will be used to move a
	** page from the dll 
	*/
	SLocaleLanguage localeLanguage;
	LocaleLanguageGet(localeLanguage);
	LocaleAddr = (TAny *) localeLanguage.iDateSuffixTable;
	test(LocaleAddr != NULL);

	RPageMove pagemove;
	r=pagemove.Open();
	test_KErrNone(r);

	r=pagemove.TryMovingLocaleDll(LocaleAddr);
	
	if (isrom == 0) 
		{
		test_KErrNone(r);
		}
	else
		{
		// When the locale is in rom it is in the unpaged part of rom and 
		// Epoc::LinearToPhysical() won't be able to find the address.
		test_Equal(KErrArgument, r)
		}

	test.Printf(_L("Locale Test: Page move done\n"));

	/* Test US again. The kernel should have cached the locale informaton, so this will not
	 * really be testing the pagmove.
	 */
	locale.Refresh();
	testUS(locale);
	
	/* Reload the Default Locale */
	test.Printf(_L("Locale Test: Change to UK Default\n"));
	r=UserSvr::ChangeLocale(ELOCL_DEFAULT);	
	test(r==KErrNone);
	locale.Refresh();
	testUK(locale);	

	/* This will ACTUALLY test the page which was moved by making the kernel reload the Locale
	 * information from the DLL. 
	 */
	if (isrom == 0) 
		{
		test.Printf(_L("RAM Locale Test: Change to US Again\n"));
		r=UserSvr::ChangeLocale(ELOCLUS);	
		}
	else
		{
		test.Printf(_L("ROM Locale Test: Change to US Again\n"));
		r=UserSvr::ChangeLocale(ELOCLUS_ROM);	
		}


	test(r==KErrNone);
	locale.Refresh();
	testUS(locale);

	/* Reset the Locale to the default */
	r=UserSvr::ChangeLocale(ELOCL_DEFAULT);	
	test(r==KErrNone);
	locale.Refresh();
	testUK(locale);	
	return(KErrNone);
}

LOCAL_C void StartCodeModifierDriver()
	{
	test.Printf(_L("Start CodeModifier Driver\n"));
	TInt r = User::LoadLogicalDevice(KCodeModifierName);
	test( r==KErrNone || r==KErrAlreadyExists);
	if((r = Device.Open())!=KErrNone)	
		{
		User::FreeLogicalDevice(KCodeModifierName);
		test.Printf(_L("Could not open LDD"));
		test(0);
		}
	}


LOCAL_C void StopCodeModifierDriver()
	{

	test.Printf(_L("Stop Code Modifier Driver\n"));
	test(KErrNone==Device.CloseCodeModifier());
	Device.Close();
	User::FreeLogicalDevice(KCodeModifierName);
	}


LOCAL_C void TestCodeSetupDrive(RThread &thread)
{
	/* The CodeModifier driver (look in ../debug/d_codemodifier) takes two threads, we just use the
	** first one */
	test(KErrNone==Device.ThreadId(0, thread.Id()));
}


LOCAL_C TUint GetCodeData(TInt *CodePtr, TInt& Ignore, TInt& FirstJump, TInt& SecondJump)
	{ 
	TUint ModAddr;

	Ignore     = *CodePtr++;
	ModAddr    = (TUint)CodePtr;
	FirstJump  = *CodePtr++;
	SecondJump = *CodePtr++;
	return ModAddr;
	}

LOCAL_C TInt TestCodeModification(RPageMove &pagemove)
	{
	TInt Ignore; 
	TUint ModAddr;
	TInt FirstJump;
	TInt SecondJump;
	RThread thread;
	
	ModAddr = GetCodeData((TInt *)TestCodeModFunc, Ignore, FirstJump, SecondJump); 
	
	test.Printf(_L("User Test code Returns = %d\n"), TestCodeModFunc());
	test.Printf(_L("Ignore = %x First Jump = %x Second = %x \n"), Ignore, FirstJump, SecondJump);
	
	TestCodeSetupDrive(thread);

	for (TInt i=0; i<Repitions * 10; i++)
		{
		
		TInt r=Device.WriteCode(0, ModAddr,SecondJump,sizeof(TInt));
		test_KErrNone(r);
		r = TestCodeModFunc();
		test (2 == r);

		test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc));

		r = Device.RestoreCode(0, ModAddr);
		test_KErrNone(r);
		r = TestCodeModFunc();
		test (1 == r);
		
		test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc));

		}

	test.Printf(_L("User Test code = %d\n"), TestCodeModFunc());
	return KErrNone;
	}

LOCAL_C int TestCodeAsync(TAny *NotUsed)
	{
	TInt Ignore; 
	TUint ModAddr;
	TInt FirstJump;
	TInt SecondJump;

	ModAddr = GetCodeData((TInt *)TestCodeModFunc, Ignore, FirstJump, SecondJump); 

	FOREVER
		{
		TInt r = Device.WriteCode(0, ModAddr,SecondJump,sizeof(TInt));
		test_KErrNone(r);
		
		r = TestCodeModFunc();
		test (2 == r);

		r = Device.RestoreCode(0, ModAddr);
	
		test_KErrNone(r);
		r = TestCodeModFunc();
		test (1 == r);
		User::AfterHighRes(10);
		}
	}

/* 
 * Creates a Thread that modifies its code in a tight loop while the main
 * thread moves the functions page around
 */
LOCAL_C TInt TestCodeModificationAsync(RPageMove& pagemove)
	{
	TInt ret;
	RThread CodeThread;
	TRequestStatus s;

	
	/* Create the Thread to modify the code segment */
	test_KErrNone(CodeThread.Create(_L("TestCodeAsync"), TestCodeAsync, KDefaultStackSize, NULL, NULL));
	CodeThread.Logon(s);
	CodeThread.SetPriority(EPriorityMore);
	CodeThread.Resume();

	TestCodeSetupDrive(CodeThread);

	/* Loop trying to move the code page while the thread (CodeThread) modifies it */
	for (TInt i=0; i<Repitions; i++)
		{
		test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc));
		}

	CodeThread.Kill(KErrNone);
	User::WaitForRequest(s);
	test_Equal(EExitKill, CodeThread.ExitType());
	test_KErrNone(CodeThread.ExitReason());
	CodeThread.Close();

	ret = TestCodeModFunc();
	test(ret == 1 || ret == 2);

	return KErrNone;
	}
