// Copyright (c) 1999-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\loader\t_ldrtst.cpp

// 

//

#define __E32TEST_EXTENSION__

#include "t_hash.h"

#include "t_ldrtst.h"

#include "../../../e32test/mmu/d_memorytest.h"

#if defined(__WINS__)

	#include <e32wins.h>

	#include <emulator.h>

#elif defined(__EPOC32__)

	#include <f32image.h>

#endif

const TInt KNumberOfCorruptFiles = 2;

RTest test(_L("T_LDRTST"));

LoaderTest* TheLoaderTest;

RFs Fs;

#if defined (__X86__) || defined(__WINS__)

TBool NoRemovable=ETrue;

#else

TBool NoRemovable=EFalse;

#endif

/** Error code of simulated RFs error */

const TInt KRFsError = -99;

/**

	Number of drives which are identified by a numeric value,

	which means, e.g., run from an internal pageable drive.

 */

const TInt KSpecialDriveCount = 2;

/** The real drive letters corresponding to each special drive. */

static TFixedArray<TText, KSpecialDriveCount> SpecialDrives;

/** Bitmask of paged and unpaged module flags. */

const TUint32 KModulePagedCodeFlags = (KModuleFlagPagedCode | KModuleFlagUnpagedCode);

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

TInt GetModuleFlags(TInt aModule)

	{

	TInt f = ModuleFlags[aModule];

#ifdef __WINS__

	// paged and unpaged flags are not supported on the emulator

	f &= ~KModulePagedCodeFlags;

	// On emulator, treat all modules as XIP, all EXEs as fixed

	f |= KModuleFlagXIP;

	if (f & KModuleFlagExe)

		f|=KModuleFlagFixed;

#endif	// #ifdef __EPOC32__

	return f;

	}

TModuleSet::TModuleSet()

	{

	Mem::FillZ(this,sizeof(TModuleSet));

	}

void TModuleSet::Add(TInt aModule)

	{

	TUint8 m=(TUint8)(1<<(aModule&7));

	TInt i=aModule>>3;

	if (!(iBitMap[i]&m))

		{

		iBitMap[i]|=m;

		++iCount;

		}

	}

void TModuleSet::Remove(TInt aModule)

	{

	TUint8 m=(TUint8)(1<<(aModule&7));

	TInt i=aModule>>3;

	if (iBitMap[i]&m)

		{

		iBitMap[i]&=~m;

		--iCount;

		}

	}

TModuleSet::TModuleSet(const TModuleList& aList, TInt aMask, TInt aVal)

	{

	Mem::FillZ(this,sizeof(TModuleSet));

	TInt i;

	for (i=0; i<aList.iCount; ++i)

		{

		TInt m=aList.iInfo[i].iDllNum;

		if (((GetModuleFlags(m)&aMask)^aVal)==0)

			Add(aList.iInfo[i].iDllNum);

		}

	}

void TModuleSet::Remove(const TModuleList& aList)

	{

	TInt i;

	for (i=0; i<aList.iCount; ++i)

		Remove(aList.iInfo[i].iDllNum);

	}

void TModuleSet::Display(const TDesC& aTitle) const

	{

	TBuf<256> s=aTitle;

	TInt i;

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

		{

		if (Present(i))

			s.AppendFormat(_L("%3d "),i);

		}

	test.Printf(_L("%S\n"),&s);

	}

TModuleList::TModuleList()

	{

	iCount=0;

	Mem::Fill(iInfo, KNumModules*sizeof(SDllInfo), 0xff);

	}

void TModuleList::SetCount()

	{

	TInt i;

	for (i=0; i<KNumModules && iInfo[i].iDllNum>=0; ++i) {}

	iCount=i;

	}

void TModuleList::Display(const TDesC& aTitle) const

	{

	TBuf<256> s=aTitle;

	TInt i;

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

		{

		TInt modnum=iInfo[i].iDllNum;

		s.AppendFormat(_L("%3d "),modnum);

		}

	test.Printf(_L("%S\n"),&s);

	}

TBool TModuleList::IsPresent(TInt aModNum) const

	{

	return Find(aModNum)>=0;

	}

TInt TModuleList::Find(TInt aModNum) const

	{

	TInt i;

	for (i=iCount-1; i>=0 && iInfo[i].iDllNum!=aModNum; --i) {}

	return i;

	}

void TModuleList::Add(const SDllInfo& a)

	{

	iInfo[iCount++]=a;

	}

RMemoryTestLdd TestLdd;

TBool AddressReadable(TLinAddr a)

	{

	TUint32 value;

	return TestLdd.ReadMemory((TAny*)a,value)==KErrNone;

	}

TInt LoaderTest::DetermineDllLoadResult(TInt aDllNum, TInt aExeNum)

	{

	TBool proc_sym=(iMemModelAtt & (EMemModelAttrSameVA|EMemModelAttrSupportFixed))==EMemModelAttrSameVA;

	const TInt* exeinfo=ModuleExeInfo[aDllNum];

	TInt attp=exeinfo[0];

	TInt linkexe=exeinfo[1];

	TInt dllflags=GetModuleFlags(aDllNum);

	TInt exeflags=GetModuleFlags(aExeNum);

#ifdef __EPOC32__

	// if NP and DEFAULTPAGED or DEFAULTUNPAGED (not NOPAGING or ALWAYSPAGE) then

	// executable identified as corrupt, unless previous conditions in S3.1.3.2 cause

	// it to be paged or unpaged without examining the flags.

	TUint32 policy = E32Loader::PagingPolicy();

	test.Printf(_L("DetermineDllLoadResult,dll=%d,exe=%d,dllflags=0x%x,policy=0x%x\n"), aDllNum, aExeNum, dllflags, policy);

	TBool flagsChecked =

			policy != EKernelConfigCodePagingPolicyNoPaging					// 3.1.3.2.1, policy != no paging

		&&	(dllflags & KModuleFlagIDrive) != 0							// 3.1.3.2.2-3, pageable drive

		&&	(dllflags & (KModuleFlagUncompressed | KModuleFlagBytePair)) != 0	// 3.1.3.2.4 pageable format

		&&	policy != EKernelConfigCodePagingPolicyAlwaysPage;				// 3.1.3.2.5, policy != ALWAYS

	if (flagsChecked && (dllflags & KModulePagedCodeFlags) == KModulePagedCodeFlags)

		{

		TBool codePolDefUnpaged = (policy == EKernelConfigCodePagingPolicyDefaultUnpaged);

		TBool codePolDefPaged = (policy == EKernelConfigCodePagingPolicyDefaultPaged);

		if (codePolDefPaged || codePolDefUnpaged)

			return KErrCorrupt;

		}

#endif

	if (linkexe>=0 && linkexe!=aExeNum)

		return KErrNotSupported;	// if DLL links to a different EXE, no good

	if (!(dllflags&KModuleFlagDataInTree))

		return KErrNone;			// if no data in DLL tree, OK

	if (proc_sym)

		return KErrNone;			// if all user processes equivalent, OK

	if (!(dllflags&KModuleFlagXIPDataInTree))

		return KErrNone;			// if no XIP modules with data in DLL tree, OK

#ifdef __EPOC32__

	if (attp<0 || !(GetModuleFlags(attp)&KModuleFlagFixed))

		{

		// moving processes only

		if (!(exeflags&KModuleFlagFixed))

			return KErrNone;

		return KErrNotSupported;

		}

	// fixed attach process only

	if (aExeNum!=attp)

		return KErrNotSupported;

#else

	(void)attp;

	(void)exeflags;

#endif

	return KErrNone;

	}

TInt LoaderTest::DetermineDllLoadResult(TInt aDllNum, TInt aExeNum1, TInt aExeNum2)

	{

	// Determine result of loading aDllNum into aExeNum2 given that it's already loaded into aExeNum1

	// return KErrNone if code segment can be shared, 1 if it must be duplicated

	TBool proc_sym=(iMemModelAtt & (EMemModelAttrSameVA|EMemModelAttrSupportFixed))==EMemModelAttrSameVA;

	const TInt* exeinfo=ModuleExeInfo[aDllNum];

//	TInt attp=exeinfo[0];

	TInt linkexe=exeinfo[1];

	TInt dllflags=GetModuleFlags(aDllNum);

	TInt exe1flags=GetModuleFlags(aExeNum1);

	TInt exe2flags=GetModuleFlags(aExeNum2);

	if (linkexe>=0 && linkexe!=aExeNum2)

		return KErrNotSupported;	// if DLL links to a different EXE, no good

	if (!(dllflags&KModuleFlagDataInTree))

		return KErrNone;			// if no data in DLL tree, OK

	if (proc_sym)

		return KErrNone;			// if all user processes equivalent, OK

	if (!((exe1flags|exe2flags)&KModuleFlagFixed))

		return KErrNone;			// if neither process fixed, OK

	if (!(dllflags&KModuleFlagXIPDataInTree))

		return 1;					// if no XIP modules with data in DLL tree, OK but can't share

#ifdef __WINS__

	return KErrNone;

#else

	return KErrNotSupported;

#endif

	}

TBool LoaderTest::IsRomAddress(TLinAddr a)

	{

	const TRomHeader& rh=*(const TRomHeader*)UserSvr::RomHeaderAddress();

	return (a>=rh.iRomBase && (a-rh.iRomBase)<rh.iRomSize);

	}

TBool LoaderTest::IsRamCodeAddress(TLinAddr a)

	{

	switch (iMemModelAtt & EMemModelTypeMask)

		{

		case EMemModelTypeDirect:

			return ETrue;

		case EMemModelTypeMoving:

			return (a>=0xc0000000u);

		case EMemModelTypeMultiple:

			return (a<0x80000000u);

		case EMemModelTypeFlexible:

			return (a<0x80000000u);

		case EMemModelTypeEmul:

			return (a<0x80000000u);

		default:

			return EFalse;

		}

	}

TBool LoaderTest::CheckDataAddress(TLinAddr a, TInt aDllNum, TInt aExeNum)

	{

	TInt xf=GetModuleFlags(aExeNum);

	TInt df=GetModuleFlags(aDllNum);

	switch (iMemModelAtt & EMemModelTypeMask)

		{

		case EMemModelTypeDirect:

			return ETrue;

		case EMemModelTypeMoving:

			{

			const TRomHeader& rh=*(const TRomHeader*)UserSvr::RomHeaderAddress();

			if (!(xf&KModuleFlagFixed))

				return (a<0x40000000u);

			if ((xf&KModuleFlagXIP) && (df&KModuleFlagXIP))

				return (a>=rh.iKernDataAddress && a<rh.iKernelLimit);

			return (a>=rh.iKernelLimit && a<0xc0000000u);

			}

		case EMemModelTypeMultiple:

			return (a<0x80000000u);

		case EMemModelTypeFlexible:

			return (a<0x80000000u);

		case EMemModelTypeEmul:

			return (a<0x80000000u);

		default:

			return EFalse;

		}

	}

void LoaderTest::DumpModuleInfo(const SDllInfo& aInfo, TInt aExeNum)

	{

	TInt flags=GetModuleFlags(aInfo.iDllNum);

	TUint32 mmtype=iMemModelAtt & EMemModelTypeMask;

	TAny* h=iDev.ModuleCodeSeg(aInfo.iModuleHandle);

	if (!h)

		{

#ifdef __EPOC32__

		test(flags & KModuleFlagXIP);

		test(IsRomAddress(aInfo.iEntryPointAddress));

		test.Printf(_L("Module handle %08x ROM XIP\n"),aInfo.iModuleHandle);

#endif

		test(!(flags & KModuleFlagData));

		return;

		}

	TCodeSegCreateInfo info;

	TInt r=iDev.GetCodeSegInfo(h, info);

	TFileName fn;

	fn.Copy(info.iFileName);

	test.Printf(_L("DCodeSeg@%08x Data=%08x+%x,%x File %S,attr=0x%x\n"),h,info.iDataRunAddress,info.iDataSize,info.iBssSize,&fn,info.iAttr);

	TInt total_data_size=info.iDataSize+info.iBssSize;

#ifndef __WINS__

	// Don't do check below for WINS because:

	// a. It doesn't work on code warrior since it puts constants into .data

	// b. On MSCV with c++ exceptions enabled we also get data

	if (flags & KModuleFlagData)

		test(total_data_size!=0);

	else

		test(total_data_size==0);

	// ensure code paged iff expected.  This implements the logic from

	// PREQ1110 Design Sketch SGL.TS0022.008 v1.0 S3.1.3.2

	TUint policy = E32Loader::PagingPolicy();

	TBool expected;

	TBool isCodePaged = (info.iAttr & ECodeSegAttCodePaged)!=0;

	// 1. If paging policy is NOPAGING then executable is Unpaged.

	TUint32 memModelAttributes=UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);

	if (policy == EKernelConfigCodePagingPolicyNoPaging || !(memModelAttributes&EMemModelAttrCodePaging))

		{

		test.Printf(_L("sbcpexp,1\n"));

		expected = false;

		}

	// 2. If ... media ... doesn't have Pageable Media Attribute then it is Unpaged.

	// (this has been superseded by BlockMap check on filesystem / media.  During these

	// tests, only the internal media supports paging.)

	else if ((flags & KModuleFlagIDrive) == 0)

		{

		test.Printf(_L("sbcpexp,2\n"));

		expected = false;

		}

	// 3. If ... removable media then it is Unpaged.

	// Not tested here because removable media (drive 1) covered by above case.

//	else if (MODULE_FILENAME(aInfo.iDllNum)[0] == '1')

//		{

//		test.Printf(_L("sbcpexp,2\n"));

//		expected = false;

//		}

	// 4. [If not bytepair [or uncompressed]] then Unpaged

	else if ((flags & (KModuleFlagBytePair | KModuleFlagUncompressed)) == 0)

		{

		test.Printf(_L("sbcpexp,3\n"));

		expected = false;

		}

	// 5. If the Paging Policy is ALWAYSPAGE then the executable is Paged.

	else if (policy == EKernelConfigCodePagingPolicyAlwaysPage)

		{

		test.Printf(_L("sbcpexp,4\n"));

		expected = true;

		}

	// 6. if KImageCodePaged and KImageCodePaged both set, should not reach here

	//	because load will have failed with KErrCorrupt.  If Paged on its own

	//	then paged; if unpaged on its own then unpaged

	else if ((flags & KModuleFlagPagedCode) != 0)

		{

		test.Printf(_L("sbcpexp,5\n"));

		expected = true;

		}

	else if ((flags & KModuleFlagUnpagedCode) != 0)

		{

		test.Printf(_L("sbcpexp,6\n"));

		expected = false;

		}

	// 7. Otherwise the PagingPolicy (DEFAULTPAGED or DEFAULTUNPAGED) determines

	//	how the executable is treated

	else

		{

		test.Printf(_L("sbcpexp,7\n"));

		expected = (policy == EKernelConfigCodePagingPolicyDefaultPaged);

		}

	test(expected == isCodePaged);

#endif

	if ((flags & KModuleFlagXIP) && mmtype!=EMemModelTypeEmul)

	else

		{

		if(mmtype==EMemModelTypeFlexible)

			{

			// can't make assumtions about current processes address space

			}

		else if (mmtype==EMemModelTypeMultiple)

			{

			}

		else

			{

			}

		}

	if (total_data_size!=0)

		test(CheckDataAddress(info.iDataRunAddress, aInfo.iDllNum, aExeNum));

	}

void LoaderTest::DumpModuleList(const TModuleList& aList, TInt aExeNum)

	{

	TInt i;

	for (i=0; i<aList.iCount; ++i)

		{

		TInt modnum=aList.iInfo[i].iDllNum;

		TInt entry=aList.iInfo[i].iEntryPointAddress;

		test.Printf(_L("MODULE %3d: ENTRY %08x "),modnum,entry);

		DumpModuleInfo(aList.iInfo[i],aExeNum);

		}

	}

void LoaderTest::CheckModuleList(TInt aRoot, const TModuleList& aList)

	{

	const TInt* deps=ModuleDependencies[aRoot];

	TInt ndeps=*deps++;

	TInt f=0;

	TInt i;

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

		{

		TInt m=deps[i];

		f|=GetModuleFlags(m);

		}

	if (!(f&KModuleFlagDllInCycle))

		{

		i=0;		// indexes aList

		TInt j=0;	// indexes deps

		while(i<KNumModules)

			{

			if (j<ndeps)

				{

				if (!(GetModuleFlags(deps[j])&KModuleFlagExe))

					{

					++i;

					}

				++j;

				}

			else if (j==ndeps)

				{

				++i;

				++j;

				}

			else

				{

				++i;

				}

			}

		}

	TModuleSet ml;

	TInt nd=ndeps;

	TBool root_included=EFalse;

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

		{

		if (deps[i]==aRoot)

			root_included=ETrue;

		if (!(GetModuleFlags(deps[i])&KModuleFlagExe))

			ml.Add(deps[i]);

		else

			--nd;

		}

	test(ml.iCount==nd);

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

		{

		if (i<nd)

			{

			ml.Remove(aList.iInfo[i].iDllNum);

			}

		else if (i==nd && !root_included)

		else

		}

	test(ml.iCount==0);