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

// f32test\demandpaging\loader\t_pageldrtst.cpp

// Demand Paging Loader Stress Tests

// Demand Paging Loader stress tests attempt to cause as much paging as possible

// whilst putting the system various types of load.

// t_pageldrtst.exe is the root of the tests, it in turn will start copies of 

// itself stored in various types of media (t_pageldrtst_rom.exe for example).

// It also loads DLLs from various media, each DLL containing simple functions 

// that are aligned on page boundaries, so each function call is likely to 

// cause a page fault.

// Usage:

// t_pageldrtst and t_pageldrtst_rom

// Common command lines:

// t_pageldrtst - run the auto test suite

// t_pageldrtst lowmem - run the low memory tests

// t_pageldrtst chunks - run the chunk tests

// t_pageldrtst chunks+ - run the chunk tests (same as used in autotest)

// t_pageldrtst echunks - run the really stressful chunk tests

// t_pageldrtst auto debug - run the autotest but with debug output to the serial port

// t_pageldrtst d_exc - run the d_exc tests

// Arguments:

// single - run the tests in a single thread

// multiple <numThreads> - run the tests in multiple threads where <numThreads>

// auto - dummy param to trick the tests into running the auto test suite with extra params

// fullauto - param to make the tests perform the full automatic stress test

// interleave - force thread interleaving

// prio - each thread reschedules in between each function call, causes lots of context changes

// media - perform media access during the tests, very stressful

// mmc - only use the mmc media for media access to test file caching

// min - min cache size in pages

// max - max cache size in pages

// chunks - simple chunk stress tests

// chunks+ - the chunk auto tests

// echunks - extremem chunks tests

// nochunkdata - don't check the integrity of the data in the chunks

// lowmem - low memory tests

// dll - only load dll's

// exe - only start exe's (t_pagestress)

// self - only start copies of self (t_pageldrtst from various media)

// complete - dll, exe and self.

// rom - only load from ROM

// base - only load the base DLL and exe's (from code)

// mixed - rom and base.

// all_media - load dlls and exes from all media

// debug - switch on debugging information

// silent - no output to the screen or serial port

// noclean - don't delete copied files on exit

// d_exc - run the d_exc tests

// global - load dlls once globally

// thread - load dlls once per thread

// func - load dlls in the test function (default and most stressful)

// forward - patern in which to execute function calls 

// backward - patern in which to execute function calls 			

// random - patern in which to execute function calls 			

// all - patern in which to execute function calls (forward, backward and random)

// inst - for debugging a parameter passed to a spawned exe to give it an id.

// iters <count> - the number of times to loop (a '-' means run forever)

// reaper - test the reaper.

// btrace - test the btrace code.

// defrag - test the ram defrag code.

// stressfree - set the page cache to stress free size and run tests.

// t_pageldrtst causes a large ammount of paging by repeatedly calling 

// functions from multiple DLLs which include 64 functions which have 

// been aligned on page boundaries from multiple threads, whilst causing 

// background paging by spawning copies of itself and t_pagestress.

// The test also endeavours to stress the loader by loading and unloading

// DLLs from multiple threads from various types of media at the same 

// time as stressing the media, testing chunks, the reaper and changing

// thread priorities.

// 002 Load thrashing, test rapid loading and unloading of DLLs from 

// multiple threads (DEF100158)

// 003 Multiple threads loading DLLs in random pattern

// 004 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in thread with prio change

// 005 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded globally with prio change

// 006 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in func with process interleaving

// 007 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in func with process interleaving, prio change

// and media access

// 008 Low Memory setup test

// 009 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 

// pattern, loaded in func.

// 010 Low Memory setup test

// 011 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 

// pattern, loaded in func with process interleaving, 

// prio change and media access

// 012 Close test driver

// 013 Chunk tests, Multiple threads loading EXE, SELF and DLLs in random 

// pattern with ROM / ROFS media, loaded in func with prio change 

// 014 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 

// pattern with all media 

// 015 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 

// pattern with all media, prio change and process interleaving

// 016 d_exc check test

// 

//

//! @SYMTestCaseID			KBASE-T_PAGELDRTST-0326

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Loader Stress Tests

//! @SYMTestActions			001 Demand Paging loader stress tests...

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#include <e32test.h>

#include <e32rom.h>

#include <e32svr.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include <e32msgqueue.h>

#include <e32math.h>

#include <e32btrace.h>

#include <d32btrace.h>

#include <d32locd.h>

#include <hal.h>

#include "t_hash.h"

#include "paging_info.h"

#ifndef TEST_AUTOTEST

#define TEST_RUN_REAPERTEST

#define TEST_RUN_LOWMEMTEST

#define TEST_RUN_DEFRAGTEST

#define TEST_RUN_D_EXCTEST

#define TEST_RUN_CHUNKTEST

#define TEST_RUN_AUTOTEST

RTest test(_L("T_PAGELDRTST"));

#else

#ifdef TEST_RUN_REAPERTEST

RTest test(_L("T_PAGELDRTST_REAPER"));

#endif

#ifdef TEST_RUN_LOWMEMTEST

RTest test(_L("T_PAGELDRTST_LOWMEM"));

#endif

#ifdef TEST_RUN_DEFRAGTEST

RTest test(_L("T_PAGELDRTST_DEFRAG"));

#endif

#ifdef TEST_RUN_D_EXCTEST

RTest test(_L("T_PAGELDRTST_D_EXC"));

#endif

#ifdef TEST_RUN_CHUNKTEST

RTest test(_L("T_PAGELDRTST_CHUNK"));

#endif

#ifdef TEST_RUN_AUTOTEST

RTest test(_L("T_PAGELDRTST_AUTO"));

#endif

#endif //TEST_AUTOTEST

const TInt KMessageBufSize = 80;

typedef TBuf<KMessageBufSize> TMessageBuf;

//#define TEST_SHORT_TEST

//#define TEST_THRASHING_TEST

//#define TEST_ADD_FAT_MEDIA

#define TEST_DONT_RESET_STATS

#define TEST_MINIMAL_STATS

//#define TEST_KERN_HEAP

#define TEST_ADD_FRAGD_MEDIA

#ifdef TEST_ADD_FRAGD_MEDIA

#endif

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

//#define WANT_FS_CACHE_STATS 

#endif

#ifdef __X86__

#define TEST_ON_UNPAGED

#define TEST_NO_DEXC_IN_AUTO

#endif

#include "t_pagestress.h"

#include "t_pageldrtstdll.h"

#include "t_ramstress.h"

TBool		TestDebug					= EFalse;

TBool		TestSilent					= EFalse;

TBool		TestExit					= EFalse;

#define TEST_EXE			0x01

#define TEST_DLL			0x02

#define TEST_SELF			0x04

#define TEST_EXE_SELF		(TEST_EXE | TEST_SELF)

#define TEST_EXE_SELF_DLL	(TEST_EXE | TEST_SELF | TEST_DLL)

TInt		TestLoading				    = TEST_EXE_SELF_DLL;

#define TEST_MEDIA_BASE			(1 << KTestMediaBase)

#define TEST_MEDIA_ROM			(1 << KTestMediaRom)

#define TEST_MEDIA_ROFS			(1 << KTestMediaRofs)

#define TEST_MEDIA_EXT			(1 << KTestMediaExt)

#define TEST_MEDIA_FAT			(1 << KTestMediaFat)

#define TEST_MEDIA_MMC			(1 << KTestMediaMmc)

#define TEST_MEDIA_ROM_BASE		(TEST_MEDIA_ROM | TEST_MEDIA_BASE)

#define TEST_MEDIA_ALL		(TEST_MEDIA_ROM | TEST_MEDIA_BASE | TEST_MEDIA_ROFS | TEST_MEDIA_EXT | TEST_MEDIA_MMC)

typedef enum

{

	KTestMediaBase = 0,

	KTestMediaRom,

	KTestMediaExt,

	KTestMediaRofs,

#ifdef TEST_ADD_FAT_MEDIA

	KTestMediaFat,  // this is the last one that is always present.

#endif

	KTestMediaMmc,

#ifdef TEST_ADD_FRAGD_MEDIA

	KTestMediaNandFrag,

	KTestMediaMmcFrag,

#endif

	KTestMediaCOUNT,

}ETestMediaType;

#ifdef TEST_ADD_FAT_MEDIA

#define TEST_MEDIA_COUNT_HACK   (KTestMediaFat + 1)

#else

#define TEST_MEDIA_COUNT_HACK   (KTestMediaRofs + 1)

#endif

typedef enum

{

	KTestMediaAccessNone = 0,

	KTestMediaAccessBasic,

	KTestMediaAccessMultipleThreads,

	KTestMediaAccessMultiplePattern,

	KTestMediaAccessMixed,

	KTestMediaAccessCOUNT,

}ETestMediaAccess;

TInt		TestWhichMedia			    = TEST_MEDIA_ROM_BASE;

TInt		DriveNumber=-1;   // Parameter - Which drive?  -1 = autodetect.

TBool		TestSingle					= EFalse;

TBool		TestMultiple				= EFalse;

TInt		TestMaxLoops				= 20;

#define TEST_2MEDIA_THREADS		20

#define TEST_ALLMEDIA_THREADS	20

TInt		TestMultipleThreadCount		= TEST_2MEDIA_THREADS;

TInt		TestInstanceId				= 0;

TBool		TestWeAreTheTestBase        = EFalse;

TBool		TestBootedFromMmc			= EFalse;

TBool		TestOnlyFromMmc				= EFalse;

TBool		TestD_Exc					= EFalse;

TBool		TestNoClean					= EFalse;

TBool		TestFullAutoTest			= EFalse;

#define TEST_DLL_GLOBAL		0x01

#define TEST_DLL_THREAD		0x02

#define TEST_DLL_FUNC		0x04

TInt		TestLoadDllHow				= TEST_DLL_FUNC;

TBool		TestIsAutomated				= EFalse;

#define TEST_INTERLEAVE_PRIO		EPriorityMore//EPriorityRealTime //23 // KNandThreadPriority - 1

TBool		TestInterleave				= EFalse;

TFileName	TestNameBuffer;

TBool		TestPrioChange				= EFalse;

volatile TBool		TestStopMedia				= EFalse;

ETestMediaAccess TestMediaAccess        = KTestMediaAccessNone;

#define TEST_NUM_FILES		5

RSemaphore	TestMultiSem;

RMsgQueue<TMessageBuf> TestMsgQueue;

#define TEST_LM_NUM_FREE	0

#define TEST_LM_BLOCKSIZE	1

#define TEST_LM_BLOCKS_FREE	4

TBool		TestLowMem					= EFalse;

TBool		TestingLowMem				= EFalse;

RPageStressTestLdd PagestressLdd;

RRamStressTestLdd  RamstressLdd;

TBool		TestBtrace					= EFalse;

TBool		TestDefrag					= EFalse;

TBool		TestChunks					= EFalse;

TBool		TestChunksPlus				= EFalse;

TBool		TestExtremeChunks			= EFalse;

TBool		TestChunkData				= ETrue;

TBool		TestingChunks				= EFalse;

volatile TBool		TestDefragTestEnd			= EFalse;

TBool		TestingDefrag				= EFalse;

volatile TBool		TestThreadsExit				= EFalse;

TInt		TestPageSize				= 4096;

RChunk		TestChunk;

TInt		TestCommitEnd = 0;

TUint8*		TestChunkBase = NULL;

#define TEST_NUM_PAGES			64

#define TEST_NUM_CHUNK_PAGES	(TEST_NUM_PAGES * 2)

TBool		TestChunkPageState[TEST_NUM_CHUNK_PAGES];

TBool		TestReaper					= EFalse;

TBool		TestingReaper				= EFalse;

TBool		TestingReaperCleaningFiles  = EFalse;

#define TEST_REAPER_ITERS			20

#define TEST_DOT_PERIOD				30

TBool		TestStressFree				= EFalse;

TInt		TestMinCacheSize = 64 * 4096;

TInt		TestMaxCacheSize = 128 * 4096;

TBool		TestIsDemandPaged = ETrue;

#define TEST_MAX_ZONE_THREADS		8

TUint		TestZoneCount = 0;

TInt TickPeriod = 15625;

#define TEST_NONE		0x0

#define TEST_THRASH		0x1

#define TEST_FORWARD	0x2

#define TEST_BACKWARD	0x4

#define TEST_RANDOM		0x8

#define TEST_ALL		(TEST_RANDOM | TEST_BACKWARD | TEST_FORWARD)

TUint32	TestWhichTests				= TEST_ALL;

_LIT(KRomPath, "z:\\sys\\bin\\");

_LIT(KMmcDefaultPath, "d:\\sys\\bin\\");

#define EXISTS(__val) ((__val == KErrNone) ? &KFileExists : &KFileMissing)

_LIT(KSysHash,"?:\\Sys\\Hash\\");

_LIT(KTestBlank, "");

_LIT(KFileExists, "Exists");

_LIT(KFileMissing, "Missing");

_LIT(KMultipleTest, "Multiple");

_LIT(KSingleTest,   "Single  ");

_LIT(KTestExe, "Exe ");

_LIT(KTestDll, "Dll ");

_LIT(KTestSelf, "Self ");

_LIT(KTestBase, "Base ");

_LIT(KTestRom, "ROM ");

_LIT(KTestAll, "All ");

_LIT(KTestGlobal, "Global");

_LIT(KTestThread, "Thread");

_LIT(KTestFunc,  "Func");

_LIT(KTestInter, "Interleave ");

_LIT(KTestPrio, "Prio ");

_LIT(KTestMedia, "Media ");

_LIT(KTestLowMem, "LowMem ");

_LIT(KTestChunking, "Chunks ");

_LIT(KTestEChunking, "EChunks ");

_LIT(KTestChunkingPlus, "Chunks+ ");

_LIT(KTestReaper, "Reaper ");

_LIT(KTestThrash, "Thrash ");

_LIT(KTestForward, "Forward ");

_LIT(KTestBackward, "Backward ");

_LIT(KTestRandom, "Random ");

typedef struct 

	{

	TBool				testFullAutoOnly;

	TInt				testLoading;

	TInt				testWhichMedia;

	TBool				testMultiple;

	TInt				testMaxLoops;

	TInt				testMultipleThreadCount;

	TBool				testLoadDllHow;

	TBool				testInterleave;

	TBool				testPrioChange;

	ETestMediaAccess	testMediaAccess;

	TUint32				testWhichTests;

	TBool				testLowMem;

	TInt				testFreeRam;

	}TTheTests; 

typedef struct

	{

	TInt	ok;

	TInt	fail;

	}TChunkTestPair;

typedef struct

	{

	TChunkTestPair	lock;

	TChunkTestPair	unlock;

	TChunkTestPair	decommit;

	TChunkTestPair	commit;

	TChunkTestPair	check;

	}

TChunkTestStats;

TChunkTestStats	TestChunkStats[TEST_NUM_CHUNK_PAGES];

TPtrC TestPsExeNames[KTestMediaCOUNT] = {	_L("t_pagestress.exe"), 

											_L("t_pagestress_rom.exe"), 

											_L("t_pagestress_ext.exe"), 

											_L("t_pagestress_rofs.exe"), 

#ifdef TEST_ADD_FAT_MEDIA

											_L("t_pagestress_fat.exe"),

#endif

											_L("t_pagestress_mmc.exe"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("t_pagestress_nfr.exe"),

											_L("t_pagestress_mfr.exe"),

#endif

											};

TPtrC TestPlExeNames[KTestMediaCOUNT] = {	_L("t_pageldrtst.exe"), 

											_L("t_pageldrtst_rom.exe"), 

											_L("t_pageldrtst_ext.exe"), 

											_L("t_pageldrtst_rofs.exe"), 

#ifdef TEST_ADD_FAT_MEDIA

											_L("t_pageldrtst_fat.exe"),

#endif

											_L("t_pageldrtst_mmc.exe"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("t_pageldrtst_nfr.exe"),

											_L("t_pageldrtst_mfr.exe"),

#endif

											};

_LIT(KDllBaseName,   "t_pageldrtst");

TPtrC TestPlExtNames[KTestMediaCOUNT] = {	_L(".dll"),

											_L("_rom.dll"),

											_L("_ext.dll"),

											_L("_rofs.dll"),

#ifdef TEST_ADD_FAT_MEDIA

											_L("_fat.dll"),

#endif

											_L("_mmc.dll"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("_nfr.dll"),

											_L("_mfr.dll"),

#endif

											};

TBool TestDllExesExist[KTestMediaCOUNT] = { EFalse, 

											EFalse,

											EFalse,

											EFalse,

#ifdef TEST_ADD_FAT_MEDIA

											EFalse,

#endif

											EFalse,

#ifdef TEST_ADD_FRAGD_MEDIA

											EFalse,

											EFalse,

#endif

											};

#define DBGS_PRINT(__args)\

	if (!TestSilent) test.Printf __args;

#define DBGD_PRINT(__args)\

	if (TestDebug) test.Printf __args;

void SendDebugMessage(RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 

					  TMessageBuf            *aBuffer = NULL,

					  RSemaphore	 		 *aTheSem = NULL)

	{

	for (;;)

		{

		aTheSem->Wait();

		TInt r = aMsgQueue->Send(*aBuffer);

		aTheSem->Signal();

		if (r != KErrOverflow)

			return;

		User::After(0);

		}

	}

#define DEBUG_PRINT(__args)\

if (!TestSilent) \

	{\

	if (aMsgQueue && aBuffer && aTheSem)\

		{\

		aBuffer->Zero();\

		aBuffer->Format __args ;\

		SendDebugMessage(aMsgQueue, aBuffer, aTheSem);\

		}\

	else\

		{\

		test.Printf __args ;\

		}\

	}

#define RUNTEST(__test, __error)\

	if (!TestSilent)\

		test(__test == __error);\

	else\

		__test;

#define RUNTEST1(__test)\

	if (!TestSilent)\

		test(__test);

#define DEBUG_PRINT1(__args)\

if (TestDebug)\

	{\

	DEBUG_PRINT(__args)\

	}

#define DOTEST(__operation, __condition)\

	if (aLowMem) \

		{\

		__operation;\

		while (!__condition)\

			{\

			DBGD_PRINT((_L("Releasing some memory on line %d\n"), __LINE__));\

			if (pTheSem)\

				pTheSem->Wait();\

			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			if (pTheSem)\

				pTheSem->Signal();\

			__operation;\

			}\

		RUNTEST1(__condition);\

		}\

	else\

		{\

		__operation;\

		RUNTEST1(__condition);\

		}

#define DOTEST1(__var, __func, __ok, __fail)\

	if (aLowMem) \

		{\

		__var = __func;\

		while (__var == __fail)\

			{\

			DBGD_PRINT((_L("Releasing some memory on line %d\n"), __LINE__));\

			if (pTheSem)\

				pTheSem->Wait();\

			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			if (pTheSem)\

				pTheSem->Signal();\

			__var = __func;\

			}\

		if (__var != __ok)\

			DBGS_PRINT((_L("Failing on line %d with error %d\n"), __LINE__, __var));\

		RUNTEST1(__var == __ok);\

		}\

	else\

		{\

		__var = __func;\

		RUNTEST1(__var == __ok);\

		}

#define DOLOADALLOC(__numDlls, __pTheLibs, __theSem)\

	if (TestingLowMem)\

		{\

		__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\

		while (__pTheLibs == NULL)\

			{\

			DEBUG_PRINT1((_L("Releasing some memory for alloc on line %d\n"), __LINE__));\

			if (__theSem)\

				__theSem->Wait();\

			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			if (__theSem)\

				__theSem->Signal();\

			__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\

			}\

		}\

	else\

		{\

		__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\

		if (__pTheLibs == NULL)\

			return KErrGeneral;\

		}

#define TEST_NEXT(__args) \

	if (!TestSilent)\

		test.Next __args;

void DoStats();

void CheckFilePresence(TBool aDoFileCopy);

void CleanupFiles(TBool silent);

typedef TInt (*TCallFunction)(TUint32 funcIndex, TInt param1, TInt param2);

class PageLdrRLibrary : public RLibrary

	{

public:

	TInt TestLoadLibrary(const TDesC& aFileName, TInt aThreadIndex, RMsgQueue<TMessageBuf> *aMsgQueue, TMessageBuf *aBuffer, RSemaphore  *aTheSem);

	TInt CloseLibrary();

public:	

	TBool				iInUse;

	TUint32				iFuncCount;

	TLibraryFunction	iInitFunc;

	TLibraryFunction	iFunctionCountFunc;

	TCallFunction       iCallFunctionFunc;

	TLibraryFunction	iSetCloseFunc;

	};

TInt PageLdrRLibrary::CloseLibrary()

	{

	if (iInUse)

		{

		if (iSetCloseFunc)

			(iSetCloseFunc)();

		Close();

		iFuncCount = 0;

		iInitFunc = NULL;

		iFunctionCountFunc = NULL;

		iCallFunctionFunc = NULL;

		iSetCloseFunc = NULL;

		iInUse = EFalse;

		}

	return KErrNone;

	}

PageLdrRLibrary		theGlobalLibs[PAGELDRTST_MAX_DLLS * KTestMediaCOUNT];

////////////////////////////////////////////////////////////

// Template functions encapsulating ControlIo magic

//

GLDEF_D template <class C>

GLDEF_C TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)

{

    TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));

    TInt r = fs.ControlIo(drv, fkn, ptrC);

    return r;

}

//

// FreeRam

//

// Get available free ram.

//

TInt FreeRam()

	{

	// wait for any async cleanup in the supervisor to finish first...

	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

	TMemoryInfoV1Buf meminfo;

	TInt r=UserHal::MemoryInfo(meminfo);

	test (r==KErrNone);

	return meminfo().iFreeRamInBytes;

	}

//

// FindFsNANDDrive

//

// Find the NAND drive

//

static TInt FindFsNANDDrive(RFs& aFs)

	{

	TDriveList driveList;

	TDriveInfo driveInfo;

	TInt r=aFs.DriveList(driveList);

    if (r == KErrNone)

		{

		for (TInt drvNum= (DriveNumber<0)?0:DriveNumber; drvNum<KMaxDrives; ++drvNum)

			{

			if(!driveList[drvNum])

				continue;   //-- skip unexisting drive

			if (aFs.Drive(driveInfo, drvNum) == KErrNone)

				{

				if(driveInfo.iMediaAtt&KMediaAttPageable)

					{

					TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;		// skip ROFS partitions

					if(!readOnly && (driveInfo.iType != EMediaHardDisk))

						{

						if ((drvNum==DriveNumber) || (DriveNumber<0))		// only test if running on this drive

							{

							return (drvNum);

							}

						}

					}

				}

			}

		}

	return (-1);

	}

//

// FindMMCDriveNumber

// 

// Find the first read write drive.

//

TInt FindMMCDriveNumber(RFs& aFs)

	{

	TDriveInfo driveInfo;

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

		{

		TInt r = aFs.Drive(driveInfo, drvNum);

		if (r >= 0)

			{

			if (driveInfo.iType == EMediaHardDisk)

				return (drvNum);

			}

		}

	return -1;

	}

//

// PageLdrRLibrary::TestLoadLibrary

//

// Load a library and initialise information about that library

//

TInt PageLdrRLibrary::TestLoadLibrary(const TDesC&           aFileName,

									  TInt					 aThreadIndex,

									  RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 

									  TMessageBuf           *aBuffer = NULL,

									  RSemaphore			*aTheSem = NULL)

	{

	TInt retVal = KErrNone;

	if (TestingLowMem)

		{

		TBool whinged = EFalse;

		TInt initialFreeRam = 0;

		TInt freeRam = 0;

		while (1)

			{

			initialFreeRam = FreeRam();

			retVal = Load(aFileName);

			freeRam = FreeRam();

			if (retVal == KErrNoMemory)

				{

				if (!whinged && (freeRam > (4 * TestPageSize)))

					{

					whinged = ETrue;

					DEBUG_PRINT1((_L("Load() %d pages %S\n"), (freeRam / TestPageSize), &aFileName));

					if (TestIsDemandPaged)

						{

						SVMCacheInfo  tempPages;

						UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

						DEBUG_PRINT1((_L("DPC : min %d max %d curr %d\n"), 

									tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize));

						DEBUG_PRINT1((_L("    : maxFree %d freeRam %d\n"),

									tempPages.iMaxFreeSize, FreeRam()));

						}

					}

				DEBUG_PRINT1((_L("Load() releasing some memory for %S (%d)\n"), &aFileName, retVal));

				if (aTheSem)

					aTheSem->Wait();

				PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);

				if (aTheSem)

					aTheSem->Signal();

				}

			else

				{

				if (whinged)

					{

					DEBUG_PRINT((_L("Load() Ok %d pages (%d) %S\n"), ((initialFreeRam - freeRam) / TestPageSize), (freeRam / TestPageSize), &aFileName));

					}

				break;

				}

			}

		}

	else

		{

		DEBUG_PRINT1((_L("Loading %S (%d)\n"), &aFileName, aThreadIndex));	 

		retVal = Load(aFileName);

		if (retVal != KErrNone)

			{

			DEBUG_PRINT1((_L("Load failed %S (%d)\n"), &aFileName, aThreadIndex));	 

			if (TestingReaper )

				{

				TInt tempIndex = 0;

				TBool whinged = EFalse;

				while (    (   (retVal == KErrNotFound) 

							|| (retVal == KErrPermissionDenied) 

							|| (retVal == KErrCorrupt) 

							|| (retVal == KErrInUse)) 

						&& (    TestingReaperCleaningFiles

							|| (tempIndex < TEST_REAPER_ITERS)))

					{

					User::After(2000000);

					if (!whinged)

						{

						DEBUG_PRINT((_L("Load() retrying load for %S (%d)\n"), &aFileName, retVal));

						whinged = ETrue;

						}

					retVal = Load(aFileName);

					if (!TestingReaperCleaningFiles)

						{

						tempIndex ++;

						}

					}

				if (retVal != KErrNone)

					{

					DEBUG_PRINT((_L("Load() failing for %S (%d) idx %d\n"), &aFileName, retVal, tempIndex));

					}

				}

			else if (TestingDefrag)

				{

				TInt tempIndex = 0;

				TBool whinged = EFalse;

				while ((retVal == KErrGeneral) && (tempIndex < 10))

					{

					User::After(20000);

					if (!whinged)

						{

						DEBUG_PRINT((_L("Load() retrying load for %S (%d)\n"), &aFileName, retVal));

						whinged = ETrue;

						}

					retVal = Load(aFileName);

					tempIndex ++;

					}

				if (retVal != KErrNone)

					{

					DEBUG_PRINT((_L("Load() failing for %S (%d) idx %d\n"), &aFileName, retVal, tempIndex));

					}

				}

			}

		}

	DEBUG_PRINT1((_L("Loaded %S (%d)\n"), &aFileName, aThreadIndex));	 

	if (retVal == KErrNone)

		{

		iInUse = ETrue;

		iInitFunc = Lookup(PAGELDRTST_FUNC_Init);

		iFunctionCountFunc = Lookup(PAGELDRTST_FUNC_FunctionCount);

		iCallFunctionFunc = (TCallFunction)Lookup(PAGELDRTST_FUNC_CallFunction);

		iSetCloseFunc = Lookup(PAGELDRTST_FUNC_SetClose);

		if (   (iInitFunc != NULL)

			&& (iFunctionCountFunc != NULL)

			&& (iCallFunctionFunc != NULL)

			&& (iSetCloseFunc != NULL))

			{

			retVal = (iInitFunc)();

			if (retVal == KErrNone)

				{

				iFuncCount = (iFunctionCountFunc)();

				if (iFuncCount != 0)

					{

					DEBUG_PRINT1((_L("Loaded ok %S (%d)\n"), &aFileName, aThreadIndex));	 

					return KErrNone;	

					}

				retVal = KErrGeneral;

				DEBUG_PRINT((_L("!!! bad count %S (%d)\n"), &aFileName, aThreadIndex));	 

				}

			else

				{

				DEBUG_PRINT((_L("!!! init failed %S (%d)\n"), &aFileName, aThreadIndex));	 

				retVal = KErrGeneral;

				}

			}

		else

			{

			DEBUG_PRINT((_L("!!! missing %S (%d)\n"), &aFileName, aThreadIndex));	 

			retVal = KErrGeneral;

			}

		}

	else

		{

		DEBUG_PRINT((_L("Load() failed %S %d\n"), &aFileName, retVal));

#ifdef WANT_FS_CACHE_STATS

		RFs			 fs;

		if (KErrNone != fs.Connect())

			{

			DEBUG_PRINT(_L("TestLoadLibrary : Can't connect to the FS\n"));

			}

		else

			{

			TFileCacheStats stats1;

			TInt drvNum = FindMMCDriveNumber(fs); 

			controlIo(fs,drvNum, KControlIoFileCacheStats, stats1);

			DEBUG_PRINT((_L("FSC: drv %d %c free %d used %d locked %d\n"),

						drvNum, 'a' + drvNum,

						stats1.iFreeCount,

						stats1.iUsedCount,

						stats1.iLockedSegmentCount));

			DEBUG_PRINT((_L("   : alloc %d lock %d closed %d\n"),

						stats1.iAllocatedSegmentCount,

						stats1.iFileCount,

						stats1.iFilesOnClosedQueue));

			fs.Close();

			}

#endif //WANT_FS_CACHE_STATS 

		if (TestIsDemandPaged)

			{

			SVMCacheInfo  tempPages;

			UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

			DEBUG_PRINT((_L("DPC : min %d max %d curr %d\n"), 

						tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize));

			DEBUG_PRINT((_L("    : maxFree %d freeRam %d\n"),

						tempPages.iMaxFreeSize, FreeRam()));

			}

		}

	return retVal;

	}

//

// GetNumDlls

//

// Work out how many Dlls we will play with

//

TInt GetNumDlls()

	{

	TInt maxDllIndex;

	switch (TestWhichMedia)

		{

		default:

		case TEST_MEDIA_BASE:	

		case TEST_MEDIA_ROM:

			maxDllIndex = PAGELDRTST_MAX_DLLS;

		break;

		case TEST_MEDIA_ROM_BASE:

			maxDllIndex = PAGELDRTST_MAX_DLLS * 2;

		break;

		case TEST_MEDIA_ALL:

			maxDllIndex = PAGELDRTST_MAX_DLLS * KTestMediaCOUNT;

		break;

		}

	return maxDllIndex;

	}

//

// LoadTheLibs

//

// Open DLLs for use in the tests.

//

TInt LoadTheLibs(PageLdrRLibrary       *aTheLibs,

                 TInt                   aLibCount,

				 TInt				    aThreadIndex, 

                 RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 

				 TMessageBuf           *aBuffer = NULL, 

				 RSemaphore			   *aTheSem = NULL)

	{

	TBuf<128>			nameBuffer;

	TInt				dllIndex = 0;

	TInt				realDllIndex = 0;

	TInt				dllOffset = -1;

	TInt				testWhich;

	RThread				thisThread;

	memset(aTheLibs, 0, sizeof(*aTheLibs) * aLibCount);

	for (dllIndex = 0; dllIndex < aLibCount; dllIndex ++)

		{

		realDllIndex = (dllIndex + aThreadIndex) % PAGELDRTST_MAX_DLLS;

//		realDllIndex = (dllIndex) % PAGELDRTST_MAX_DLLS;

		if (realDllIndex == 0)

			dllOffset ++;

		if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ALL)

			testWhich = (dllIndex + dllOffset) % KTestMediaCOUNT;

		else if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ROM_BASE)

			testWhich = ((dllIndex + dllOffset) & 1) ? KTestMediaBase : KTestMediaRom;

		else if (TestWhichMedia & TEST_MEDIA_BASE )

			testWhich = KTestMediaBase;

		else

			testWhich = KTestMediaRom;

		if (!TestDllExesExist[testWhich])

			testWhich = KTestMediaBase;

		nameBuffer.Format(_L("%S%d%S"), &KDllBaseName, realDllIndex, &TestPlExtNames[testWhich]);

		DEBUG_PRINT1((_L("LoadTheLibs[%02d] - loading %S\n"), aThreadIndex, &nameBuffer));

		TInt theErr = aTheLibs[dllIndex].TestLoadLibrary(nameBuffer, aThreadIndex, aMsgQueue, aBuffer, aTheSem);

		if (theErr != KErrNone)

			{

			DEBUG_PRINT((_L("LoadTheLibs[%02d] - fail %S %d\n"), aThreadIndex, &nameBuffer, theErr));

			return KErrGeneral;

			}

		else

			{

			DEBUG_PRINT1((_L("LoadTheLibs[%02d] - loaded %S OK\n"), aThreadIndex, &nameBuffer));

			}

		if (TestThreadsExit)

			{

			DEBUG_PRINT((_L("LoadTheLibs[%02d] - cancelled\n"), aThreadIndex));

			return KErrCancel;

			}

		if (TestPrioChange)

			{

			TThreadPriority originalThreadPriority = thisThread.Priority();

			DEBUG_PRINT1((_L("LoadTheLibs[%02d] before priority change\n"), aThreadIndex));

			thisThread.SetPriority(EPriorityLess);

			User::AfterHighRes(0);

			thisThread.SetPriority(originalThreadPriority);

			DEBUG_PRINT1((_L("LoadTheLibs[%02d] after priority change\n"), aThreadIndex));

			}

		}

	DEBUG_PRINT((_L("LoadTheLibs[%02d] done\n"), aThreadIndex));

	return KErrNone;