// 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\mmu\t_codepaging.cpp

// This test relies on four dlls which it loads dynamically:

// - t_codepaging_dll		Very simple dll, contains a single function.  Used for testing state

// changes	of pages

// - t_codepaging_dll2	 	Contains 8 pages of data, used for testing the correct data is paged

// - t_codepaging_dll3		Statically links to t_codepaging_sll, used for testing ReadExportDir

// - t_codepaging_dll4		Large dll, used for testing code segment that span more than one page

// table

// - t_codepaging_dll5		Contains relocatable const data.

// - t_codepaging_dll6		Contains relocatable writable data.

// - t_codepaging_dll7		Statically linked to t_codepaging_dll5 to check dependent DLLs

// are initialised correctly.

// Suite of tests specifically to test the code paging portion of demand 

// paging.

// 002 Exercise ReadExportDir with one code seg mapped already into current process

// 003 Exercise ReadExportDir with one code seg mapped into different process

// 004 Check locking of code which then gets unloaded

// 004.01 Load test driver...

// 004.02 Load/unload dll

// 004.03 Load dll again

// 004.04 Get data from DLL

// 004.05 Lock DLL data

// 004.06 Check DLL data

// 004.07 Close DLL

// 004.08 Check DLL loaded at different address

// 004.09 Unlock DLL data

// 004.10 Check DLL loaded at original address

// 004.11 Cleanup

// 005 Test writing to paged code

// 005.01 Load DLL

// 005.02 Get data from DLL

// 005.03 Write to pages in DLL

// 006 Running tests on drive I:

// 007 Test accessing pages by executing code

// 008 Test accessing pages by reading code

// 009 Test accessing pages by reading code from another process via an alias

// 010 Test unmapping paged code

// 011 Test interactions between two processes

// 012 Test that the contents of a paged DLL are as expected

// 013 Test relocated const data in DLL

// 014 Test relocated writable data in DLL

// 015 Test relocated writable data in dependent DLL

// 016 Test relocated writable data in preloaded dependent DLL

// 017 Test relocated writable data in preloaded dependent DLL opened in other process

// 018 Test killing a thread while it is taking paging faults

// 019 Test unloading a library while another thread is executing it

// 020 Test random access to a large dll

// 021 Test accessing paged code from 2 processes at 1 priority level(s) for 5 seconds

// 022 Test accessing paged code from 5 processes at 1 priority level(s) for 10 seconds

// 023 Test accessing paged code from 10 processes at 1 priority level(s) for 20 seconds

// 024 Test accessing paged code from 5 processes at 2 priority level(s) for 10 seconds

// 025 Test accessing paged code from 50 processes at 1 priority level(s) for 2 seconds

// 026 Running tests on drive Z:

// 027 Test accessing pages by executing code

// 028 Test accessing pages by reading code

// 029 Test accessing pages by reading code from another process via an alias

// 030 Test unmapping paged code

// 031 Test interactions between two processes

// 032 Test that the contents of a paged DLL are as expected

// 033 Test relocated const data in DLL

// 034 Test relocated writable data in DLL

// 035 Test relocated writable data in dependent DLL

// 036 Test relocated writable data in preloaded dependent DLL

// 037 Test relocated writable data in preloaded dependent DLL opened in other process

// 038 Test killing a thread while it is taking paging faults

// 039 Test unloading a library while another thread is executing it

// 040 Test random access to a large dll

// 041 Test accessing paged code from 2 processes at 1 priority level(s) for 5 seconds

// 042 Test accessing paged code from 5 processes at 1 priority level(s) for 10 seconds

// 043 Test accessing paged code from 10 processes at 1 priority level(s) for 20 seconds

// 044 Test accessing paged code from 5 processes at 2 priority level(s) for 10 seconds

// 045 Test accessing paged code from 50 processes at 1 priority level(s) for 2 seconds

// 

//

//! @SYMTestCaseID			KBASE-T_CODEPAGING-0335

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Code Paging tests.

//! @SYMTestActions			001 Code paging tests

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <f32file.h>

#include <e32math.h>

#include <dptest.h>

#include "mmudetect.h"

#include "d_memorytest.h"

#include "d_demandpaging.h"

#include "t_codepaging_dll.h"

#include "paging_info.h"

class TPagingDriveInfo

	{

public:

	TChar iDriveLetter;

	TDriveInfo iDriveInfo;

	};

RArray<TPagingDriveInfo> SupportedDrives;

/// Page attributes, cut-n-paste'd from mmubase.h

enum TType

	{

//	EInvalid=0,			// No physical RAM exists for this page

//	EFixed=1,			// RAM fixed at boot time

//	EUnused=2,			// Page is unused

//	EChunk=3,

//	ECodeSeg=4,

//	EHwChunk=5,

//	EPageTable=6,

//	EPageDir=7,

//	EPtInfo=8,

//	EShadow=9,

	EPagedROM=10,

	EPagedCode=11,

	EPagedData=12,

	EPagedCache=13,

	EPagedFree=14,

	};

enum TState

	{

	EStateNormal 			= 0,	// no special state

	EStatePagedYoung 		= 1,

	EStatePagedOld 			= 2,

	EStatePagedDead 		= 3,	// Not possible on the flexible memory model.

	EStatePagedLocked 		= 4,

	EStatePagedOldestClean 	= 5,	// Flexible memory model only.

	EStatePagedOldestDirty 	= 6,	// Flexible memory model only.

	};

/// The possible states for a logical page of RAM loaded code

enum TPageState

	{

	EStateUnmapped,

	EStatePagedOut,

	EStateYoung,

	EStateOld,

	EStateOldestClean,

	EStateOldestDirty,

	ENumPageStates

	};

const TUint KPagedStateShift = 8;

const TUint KPagedStateMask = 0xff00;

/// The possible states for a physical page of RAM loaded code

enum TPhysState

	{

	EPhysNotPresent,

	EPhysYoung,

	EPhysOld,

	EPhysOldestClean,

	EPhysOldestDirty,

	ENumPhysStates

	};

/// Names of the logical page states

const char* StateNames[ENumPageStates] =

	{

	"Unmapped",

	"PagedOut",

	"Young",

	"Old",

	"OldestClean",

	"OldestDirty"

	};

/// Names of the physical page states

const char* PhysStateNames[ENumPhysStates] =

	{

	"NotPresent",

	"Young",

	"Old",

	"OldestClean",

	"OldestDirty"

	};

/// Array of physical page states indexed by logical page state

TPhysState PhysStateFromPageState[ENumPageStates] =

	{

	EPhysNotPresent,

	EPhysNotPresent,

	EPhysYoung,

	EPhysOld,

	EPhysOldestClean,

	EPhysOldestDirty,

	};

/// The expected logical page state bitmask for each state

TInt ExpectedPageState[ENumPageStates] =

	{

	0,

	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged,

	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent | EPageStatePteValid,

	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent,

	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent,

	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent

	};

/// Extra bits we expect to be set on the multiple memory model

TInt ExpectedPageStateMultipleExtra[ENumPageStates] =

	{

	EPageStateCodeChunkPresent,

	EPageStateCodeChunkPresent,

	EPageStateCodeChunkPresent | EPageStatePhysAddrPresent,

	EPageStateCodeChunkPresent | EPageStatePhysAddrPresent

	};

/// Mask for the bits of the page state related to the physicsal page that we check

TInt PhysStateMask = 0xffff;

/// The expected physical page state bitmask for each state

TInt ExpectedPhysState[ENumPhysStates] =

	{

	0,

	EPagedCode | (EStatePagedYoung<<8),

	EPagedCode | (EStatePagedOld<<8),

	EPagedCode | (EStatePagedOldestClean<<8),

	EPagedCode | (EStatePagedOldestDirty<<8)

	};

typedef void (*TFunc)(void);

typedef void (*TFunc1)(TInt aArg1);

typedef TFunc TTransitionTable[ENumPageStates][ENumPageStates];

void LoadLibrary();

void UnloadLibrary();

void AccessPage();

void MakeOld();

void MakeOldest();

void MakePagedOut();

TTransitionTable StateTransitions =

	{

// Current:			Next:	EStateUnmapped	EStatePagedOut	EStateYoung		EStateOld	EStateOldestClean	EStateOldestDirty	

/* EStateUnmapped 	*/	{	0,				LoadLibrary,	0,				0,			0,					0			},

/* EStatePagedOut	*/	{	UnloadLibrary,	0,				AccessPage,		0,			0,					0			},

/* EStateYoung		*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		MakeOld,	0,					0			},

/* EStateOld		*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			MakeOldest,			MakeOldest	},

/* EStateOldestClean*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			0,					0			},

/* EStateOldestDirty*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			0,					0			},

	};

const TInt KMaxPathLen = 16;

typedef TPageState TStatePath[KMaxPathLen];

// Test paths through the possible states that excercises all transitions except those back to unmapped

// Doesn't consider dirty pages.

TStatePath TestPathNoOldest =

	{

	EStateUnmapped,

	EStatePagedOut,

	EStateYoung,

	EStateOld,

	EStateYoung,

	EStateOld,

	EStatePagedOut,

	EStateUnmapped,

	};

TStatePath TestPathOldest =

	{

	EStateUnmapped,

	EStatePagedOut,

	EStateYoung,

	EStateOld,

	EStateOldestClean,

	EStateYoung,

	EStateOld,

	EStateYoung,

	EStateOld,

	EStatePagedOut,

	EStateYoung,

	EStateOld,

	EStateOldestClean,

	EStatePagedOut,

	EStateUnmapped,

	};

TStatePath* TestPath = NULL;

/// The different ways of accessing paged code

enum TAccessMethod

	{

	EAccessExec,

	EAccessRead,

	EAccessAliasRead

	};

_LIT(KLibraryName, "t_codepaging_dll");

_LIT(KSearchPathTemplate, "?:\\sys\\bin");

// RTest stuff /////////////////////////////////////////////////////////////////

RTest test(_L("T_CODEPAGING"));

#define test_noError(x) { TInt _r = (x); if (_r < 0) HandleError(_r, __LINE__); }

#define test_notNull(x) { TAny* _a = (TAny*)(x); if (_a == NULL) HandleNull(__LINE__); }

#define test_equal(e, a) { TInt _e = TInt(e); TInt _a = TInt(a); if (_e != _a) HandleNotEqual(_e, _a, __LINE__); }

void HandleError(TInt aError, TInt aLine)

	{

	test.Printf(_L("Error %d\n"), aError);

	test.operator()(EFalse, aLine);

	}

void HandleNull(TInt aLine)

	{

	test.Printf(_L("Null value\n"));

	test.operator()(EFalse, aLine);

	}

void HandleNotEqual(TInt aExpected, TInt aActual, TInt aLine)

	{

	test.Printf(_L("Expected 0x%x but got 0x%x\n"), aExpected, aActual);

	test.operator()(EFalse, aLine);

	}

//  Server session /////////////////////////////////////////////////////////////

_LIT(KServerName, "t_codepaging_server");

class RTestSession : public RSessionBase

	{

public:

	enum TMessage

		{

		EKill,

		EExec,

		ESetCurrentDrive,

		EDesRead,

		ETestPageState,

		ETestStateTransition,

		EStartRandomAccessThread

		};

public:

	TInt Connect(TInt aProcessNum);

	inline void Kill()

		{ test_noError(RSessionBase::SendReceive(EKill,TIpcArgs())); }

	inline void Exec(TFunc aFunc)

		{ test_noError(RSessionBase::SendReceive(EExec,TIpcArgs((TInt)aFunc))); }

	inline void SetCurrentDrive(TUint16 aDrive)

		{ test_noError(RSessionBase::SendReceive(ESetCurrentDrive,TIpcArgs(aDrive))); }

	inline void DesRead(const TDesC8& aData)

		{ test_noError(RSessionBase::SendReceive(EDesRead,TIpcArgs(&aData))); }

	inline void TestPageState(TPageState aState, TPhysState aPhysState)

		{ test_noError(RSessionBase::SendReceive(ETestPageState,TIpcArgs(aState, aPhysState))); }

	inline void TestStateTransition(TPageState aState)

		{ test_noError(RSessionBase::SendReceive(ETestStateTransition,TIpcArgs(aState))); }

	inline void StartRandomAccessThread(TThreadPriority aPriority)

		{ test_noError(RSessionBase::SendReceive(EStartRandomAccessThread,TIpcArgs(aPriority))); }

	};

TInt RTestSession::Connect(TInt aProcessNum)

	{

	TBuf<32> name;

	name.AppendFormat(_L("%S-%d"), &KServerName, aProcessNum);

	return CreateSession(name,TVersion());

	}

// Global data /////////////////////////////////////////////////////////////////

TBool MovingMemoryModel;

TBool MultipleMemoryModel;

TBool FlexibleMemoryModel;

TBool HaveOldestLists;

TInt ProcessNum;

RTestSession OtherProcess;

RLibrary PagedLibrary;

TBool LibraryLoaded = EFalse;

TTestFunction Library_TestFunction = NULL;

TAccessMethod AccessMethod;

RLibrary LargeLibrary;

TBool LargeLibraryLoaded = EFalse;

const TUint8* LargeDataStart;

const TUint8* LargeDataEnd;

const TUint8* LargeDataPtr;

TInt PagesReadSinceLastAccess = 0;

TInt LiveListSize;

TInt PageSize;

TPageState State;

TPhysState PhysState;

TUint16 CurrentDrive;

TInt LocalDriveNumber;

RThread RandomAccessThread;

volatile TBool RandomAccessKill = EFalse;

TBool CanForcePageOut = ETrue;

// Utility functions ///////////////////////////////////////////////////////////

TPtrC16 GetMediaType(TInt aMediaType)

	{

	_LIT(KMediaNotPresent, "MediaNotPresent");

	_LIT(KMediaUnknown, "MediaUnknown");

	_LIT(KMediaFloppy, "MediaFloppy");

	_LIT(KMediaHardDisk, "MediaHardDisk");

	_LIT(KMediaCdRom, "MediaCdRom");

	_LIT(KMediaRam, "MediaRam");

	_LIT(KMediaFlash, "MediaFlash");

	_LIT(KMediaRom, "MediaRom");

	_LIT(KMediaRemote, "MediaRemote");

	_LIT(KMediaNANDFlash, "MediaNANDFlash");

	_LIT(KMediaUnKnown, "MediaUnKnown");

	switch(aMediaType)

		{

		case EMediaNotPresent:

			return KMediaNotPresent();

		case EMediaUnknown:

			return KMediaUnknown();

		case EMediaFloppy:

			return KMediaFloppy();

		case EMediaHardDisk:

			return KMediaHardDisk();

		case EMediaCdRom:

			return KMediaCdRom();

		case EMediaRam:

			return KMediaRam();

		case EMediaFlash:

			return KMediaFlash();

		case EMediaRom:

			return KMediaRom();

		case EMediaRemote:

			return KMediaRemote();

		case EMediaNANDFlash:

			return KMediaNANDFlash();

		default:

			return KMediaUnKnown();

		}

	}

// Get the list of pageable drives

void GetSupportedDrives(TBool aVerbose = EFalse)

	{

	if (aVerbose)

		{

		test.Printf(_L("Supported drives:\n"));

		test.Printf(_L("     Type             Attr     MedAttr  Filesystem\n"));

		}

	RFs fs;

	test_noError(fs.Connect());

	TDriveList driveList;

	TDriveInfo driveInfo;

	TInt r = fs.DriveList(driveList);

    test_noError(r);

	TBool NandPageableMediaFound = EFalse;

	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)

		{

	    if(!driveList[drvNum])

	        continue;   //-- skip unexisting drive

	    r = fs.Drive(driveInfo, drvNum);

	    test_noError(r);

		TChar ch;

		r = fs.DriveToChar(drvNum, ch);

		test_noError(r);

		TBuf<256> fileSystemName;

		r = fs.FileSystemName(fileSystemName, drvNum);

		test_noError(r);

		if ((driveInfo.iDriveAtt & KDriveAttPageable) && (driveInfo.iType == EMediaNANDFlash))

			NandPageableMediaFound = ETrue;

		TBool pageable = EFalse;

		if (driveInfo.iDriveAtt & KDriveAttPageable)

			pageable = ETrue;

		// If we've already found a pageable NAND drive, 

		// then assume the Z: drive is pageable too if it's got a composite file system

		_LIT(KCompositeName,"Composite");

		if ((fileSystemName == KCompositeName()) && NandPageableMediaFound)

			pageable = ETrue;

		if (pageable)

			{

			TChar ch;

			r = fs.DriveToChar(drvNum, ch);

			test_noError(r);

			TPagingDriveInfo pagingDriveInfo;

			pagingDriveInfo.iDriveLetter = ch;

			pagingDriveInfo.iDriveInfo = driveInfo;