// 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_ldrtst2.cpp

// 

//

#include "t_ldrtst.h"

extern TInt GetModuleFlags(TInt);

inline TBool AlwaysLoaded(TInt aModule)

	{

#ifdef __EPOC32__

	TUint32 f=GetModuleFlags(aModule);

	return ( (f&(KModuleFlagExe|KModuleFlagDataInTree|KModuleFlagXIP)) == (TUint32)KModuleFlagXIP );

#else

	TUint32 f=GetModuleFlags(aModule);

	return ( (f&(KModuleFlagExe|KModuleFlagDataInTree)) == 0 );

#endif

	}

TInt Order(const SModuleInstance& m1, const SModuleInstance& m2)

	{

	return TInt(m1.iCodeSeg)-TInt(m2.iCodeSeg);

	}

CGlobalModuleList::CGlobalModuleList()

	:	 iModules(KNumModules)

	{

	}

CGlobalModuleList::~CGlobalModuleList()

	{

	iModules.Close();

	User::Free(iModuleAlloc);

	TInt i;

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

		{

		delete iPPInfo[i];

		}

	}

void CGlobalModuleList::Init()

	{

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

	TInt i;

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

		{

		TUint32 f=GetModuleFlags(i);

		if (f&KModuleFlagExe)

			{

			++iNumExes;

			if (!proc_sym && (f&KModuleFlagFixed))

				++iFixedExes;

			}

		}

	iMaxModules=(1+iFixedExes)*(KNumModules-iNumExes)+iNumExes;

	test.Printf(_L("iNumExes=%d iFixedExes=%d iMaxModules=%d\n"),iNumExes,iFixedExes,iMaxModules);

	SModuleInstance* mi=(SModuleInstance*)User::Alloc(iMaxModules*sizeof(SModuleInstance));

	test(mi!=NULL);

	iFreeModules=mi;

	iModuleAlloc=mi;

	SModuleInstance* miE=mi+iMaxModules;

	for (; mi<miE; ++mi)

		{

		SModuleInstance* miN=mi+1;

		mi->iCodeSeg=(miN<miE)?miN:NULL;

		}

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

		{

		TUint32 f=GetModuleFlags(i);

		if (f&KModuleFlagExe)

			{

			CPerProcessInfo* p=CPerProcessInfo::New(i,*this);

			iPPInfo[i]=p;

			}

		}

	}

CGlobalModuleList* CGlobalModuleList::New(const LoaderTest& a)

	{

	CGlobalModuleList* p=new CGlobalModuleList;

	test(p!=NULL);

	test.Printf(_L("CGlobalModuleList at %08x\n"),p);

	p->iDev=a.iDev;

	p->iMemModelAtt=a.iMemModelAtt;

	p->Init();

	return p;

	}

void CGlobalModuleList::Free(SModuleInstance* a)

	{

	a->iCodeSeg=iFreeModules;

	iFreeModules=a;

	}

SModuleInstance* CGlobalModuleList::GetMI()

	{

	SModuleInstance* p=iFreeModules;

	test(p!=NULL);

	iFreeModules=(SModuleInstance*)p->iCodeSeg;

	return p;

	}

TAny* CGlobalModuleList::CodeSegFromHandle(TModuleHandle aModHandle)

	{

	return iDev.ModuleCodeSeg(aModHandle);

	}

void CGlobalModuleList::Close(SModuleInstance* a)

	{

	test.Printf(_L("Module %d@%08x Close(%d)\n"),a->iModNum,a->iCodeSeg,a->iAccessCount);

	if (!--a->iAccessCount)

		{

		TCodeSegCreateInfo codeSeg;

		TInt r=iDev.GetCodeSegInfo(a->iCodeSeg, codeSeg);

		test(r==KErrArgument);

		r=iModules.FindInOrder(a, Order);

		test(r>=0);

		iModules.Remove(r);

		Free(a);

		}

	}

void CGlobalModuleList::CheckAll()

	{

	TInt i;

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

		{

		if (iPPInfo[i])

			iPPInfo[i]->Check();

		}

	}

TInt CGlobalModuleList::Load(TInt aExeNum, TInt aDllNum)

	{

	return iPPInfo[aExeNum]->Load(aDllNum);

	}

TInt CGlobalModuleList::CloseHandle(TInt aExeNum, TInt aDllNum)

	{

	CPerProcessInfo* p=iPPInfo[aExeNum];

	TInt i;

	for (i=0; i<KMaxHandles && p->iModuleNum[i]!=aDllNum; ++i) {}

	if (i==KMaxHandles)

		return KErrNotFound;

	return p->CloseHandle(i);

	}

CPerProcessInfo::CPerProcessInfo()

	{

	Mem::Fill(iModuleNum, sizeof(iModuleNum), 0xff);

	}

CPerProcessInfo::~CPerProcessInfo()

	{

	if (iSession.Handle())

		{

		iSession.Exit();

		iSession.Close();

		User::WaitForRequest(iStatus);

		test(iProcess.ExitType()==EExitKill);

		test(iProcess.ExitReason()==KErrNone);

		}

	iProcess.Close();

	}

CPerProcessInfo* CPerProcessInfo::New(TInt aExeNum, CGlobalModuleList& aG)

	{

	CPerProcessInfo* p=new CPerProcessInfo;

	test(p!=NULL);

	test.Printf(_L("CPerProcessInfo for %d at %08x\n"),aExeNum,p);

	p->iExeNum=aExeNum;

	p->iDev=aG.iDev;

	p->iGlobalList=&aG;

	TInt r = p->Init();

	if (r==KErrNone)

		return p;

	delete p;

	return NULL;

	}

TInt CPerProcessInfo::Init()

	{

	TUint32 tt;

	TInt r=LoadExe(iExeNum, 0, iProcess, tt);

	test.Printf(_L("LoadExe(%d)->%d\n"),iExeNum,r);

#ifdef __EPOC32__

	test(r==KErrNone);

	test.Printf(_L("BENCHMARK: LoadExe(%d)->%dms\n"),iExeNum,tt);

#else

	test(r==KErrNone || r==KErrNotSupported);

	if (r!=KErrNone)

		return r;

#endif

	iProcess.Logon(iStatus);

	test(iStatus==KRequestPending);

	r=iSession.Connect(iExeNum);

	test.Printf(_L("Connect(%d)->%d\n"),iExeNum,r);

	test(r==KErrNone);

	TModuleList exe_info;

	r=iSession.GetExeDepList(exe_info.iInfo);

	exe_info.SetCount();

	test.Printf(_L("GetExeDepList(%d)->%d count %d\n"),iExeNum,r,exe_info.iCount);

	test(r==KErrNone);

	r=AddModules(iExeNum, NULL, &exe_info);

	test.Printf(_L("AddModules->%d\n"),r);

	test(r==KErrNone);

	return KErrNone;

	}

void CPerProcessInfo::GetModuleSet(TModuleSet& aSet)

	{

	TInt m;

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

		{

		if (iHandleCount[m]==0 && m!=iExeNum)

			continue;

		aSet.Add(m);

		const TInt* deps=ModuleDependencies[m];

		TInt ndeps=*deps++;

		TInt i;

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

			{

			TInt dm=*deps++;

#ifndef __EPOC32__

			// Emulator doesn't register subtrees without data

			TInt f = GetModuleFlags(dm);

			if (f & KModuleFlagDataInTree)

#endif

			aSet.Add(dm);

			}

		}

	}

void CPerProcessInfo::Check()

	{

	test.Printf(_L("%d:Check\n"),iExeNum);

	TBool code_prot=iGlobalList->iMemModelAtt&EMemModelAttrRamCodeProt;

	TBool data_prot=iGlobalList->iMemModelAtt&EMemModelAttrProcessProt;

	TInt mmtype=iGlobalList->iMemModelAtt&EMemModelTypeMask;

	TModuleSet set;

	GetModuleSet(set);

	TInt m;

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

		{

		TUint32 f=GetModuleFlags(m);

		if (set.Present(m))

			{

			test.Printf(_L("%d "),m);

			SModuleInstance* pM=iModules[m];

			test(pM!=NULL);

			test(iSession.CheckReadable(pM->iEntryPointAddress)==KErrNone);

			if (f&KModuleFlagData)

				test(iSession.CheckReadable(pM->iData)==KErrNone);

			}

		else

			{

			SModuleInstance* pM=iModules[m];

			test(pM==NULL);

			}

		}

	TInt ix;

	TInt c=iGlobalList->iModules.Count();

	test.Printf(_L("\n%d:CheckNP\n"),iExeNum);

	for (ix=0; ix<c; ++ix)

		{

		const SModuleInstance* pM=iGlobalList->iModules[ix];

		if (set.Present(pM->iModNum))

			continue;

		test.Printf(_L("%d "),pM->iModNum);

		TUint32 f=GetModuleFlags(pM->iModNum);

		if (!(f&KModuleFlagXIP) && code_prot)

			{

			if(mmtype==EMemModelTypeFlexible && (f&KModuleFlagExe))

				{

				// don't test EXEs on FlexibleMM because they don't live at unique addresses

				}

			else

				{

				// check code not loaded into this porcess....

				test(iSession.CheckReadable(pM->iEntryPointAddress)==KErrGeneral);

				}

			}

		TBool check_data=(f&(KModuleFlagData|KModuleFlagExe))==(TUint32)KModuleFlagData;

		if (check_data && mmtype==EMemModelTypeMoving)

			{

			if (f&KModuleFlagXIP)

				{

				const TInt* exeinfo=ModuleExeInfo[pM->iModNum];

				TInt attp=exeinfo[0];

				if (attp>=0 && (GetModuleFlags(attp)&KModuleFlagFixed))

					check_data=EFalse;

				}

			}

		if (check_data && data_prot)

			test(iSession.CheckReadable(pM->iData)==KErrGeneral);

		}

	TInt h;

	for (h=0; h<KMaxHandles; ++h)

		{

		m=iModuleNum[h];

		if (m<0)

			continue;

		test(set.Present(m));

		TInt y=++iGlobalList->iParam;

		TInt r=iSession.CallRBlkI(h,y);

		r-=y;

		r/=INC_BLOCK_SZ;

		test.Printf(_L("DLL %d RBlkI->%d\n"),m,r);

		y=ModuleRBlkIParams[m][1]+ModuleRBlkIParams[m][0]*DLLNUMOFFSET;

		test(r==y);

		}

	}

void CPerProcessInfo::Unlink(const SDllInfo& a, TModuleList& aList)

	{

	test.Printf(_L("%d:Unlink %d %08x\n"),iExeNum,a.iDllNum,a.iModuleHandle);

	test(iHandleCount[a.iDllNum]==0);

	TBool code_prot=iGlobalList->iMemModelAtt&EMemModelAttrRamCodeProt;

	TBool data_prot=iGlobalList->iMemModelAtt&EMemModelAttrProcessProt;

	TInt mmtype=iGlobalList->iMemModelAtt&EMemModelTypeMask;

	TModuleSet set;

	GetModuleSet(set);

	set.Display(_L("set: "));

	TInt m;

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

		{

		if (set.Present(m))

			continue;

		SModuleInstance* pM=iModules[m];

		if (!pM)

			continue;

		iModules[m]=NULL;

		TUint32 f=GetModuleFlags(m);

		SDllInfo info;

		info.iDllNum=m;

		info.iEntryPointAddress=pM->iEntryPointAddress;

		info.iModuleHandle=pM->iModuleHandle;

		aList.Add(info);

		test(pM->iModNum==m);

		if (!(f&KModuleFlagXIP) && code_prot)

			test(iSession.CheckReadable(pM->iEntryPointAddress)==KErrGeneral);

		TBool check_data=f&KModuleFlagData;

		if (check_data && mmtype==EMemModelTypeMoving)

			{

			if (f&KModuleFlagXIP)

				{

				const TInt* exeinfo=ModuleExeInfo[pM->iModNum];

				TInt attp=exeinfo[0];

				if (attp>=0 && (GetModuleFlags(attp)&KModuleFlagFixed))

					check_data=EFalse;

				}

			}

		if (check_data && data_prot)

			test(iSession.CheckReadable(pM->iData)==KErrGeneral);

		iGlobalList->Close(pM);

		}

	}

TInt CPerProcessInfo::CloseHandle(TInt aHandle)

	{

	TInt m=iModuleNum[aHandle];

	test(m>=0);

	iModuleNum[aHandle]=-1;

	SModuleInstance* pM=iModules[m];

	test(pM!=NULL);

	SDllInfo dll_info;

	dll_info.iDllNum=m;

	dll_info.iEntryPointAddress=pM->iEntryPointAddress;

	dll_info.iModuleHandle=pM->iModuleHandle;

	TModuleList d_list;

	TInt r=iSession.CloseDll(aHandle);

	test(r==KErrNone);

	r=iSession.GetCDList(d_list.iInfo);

	test(r==KErrNone);

	d_list.SetCount();

	if (--iHandleCount[m])

		{

		test(d_list.iCount==0);

		return KErrNone;

		}

	TModuleList xd_list;

	if (!AlwaysLoaded(m))

		Unlink(dll_info, xd_list);

	TInt i;

	TInt dcount=0;

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

		{

		TInt mn=xd_list.iInfo[i].iDllNum;

		TUint32 f=GetModuleFlags(mn);

		if (f&KModuleFlagData)

			{

			++dcount;

			test(d_list.IsPresent(mn));

			}

		}

	d_list.Display(_L("d_list:  "));

	xd_list.Display(_L("xd_list: "));

	test(dcount==d_list.iCount);

	return KErrNone;

	}

TInt CPerProcessInfo::Load(TInt aDllNum)

	{

	TModuleList init_list;

	TModuleList c_list;

	TInt h=iSession.LoadDll(aDllNum, init_list.iInfo);

	init_list.SetCount();

	test.Printf(_L("%d:Load(%d)->%d Icount %d\n"),iExeNum,aDllNum,h,init_list.iCount);

	if (h<0)

		{

		return h;

		}

	test(iSession.GetCDList(c_list.iInfo)==KErrNone);

	c_list.SetCount();

	iModuleNum[h]=aDllNum;

	return AddModules(aDllNum, &c_list, &init_list);

	}

TInt CPerProcessInfo::AddModules(TInt aDllNum, TModuleList* aCList, TModuleList* aIList)

	{

	TInt r=0;

	if (++iHandleCount[aDllNum]>1)

		{

		if (aCList)

			test(aCList->iCount==0);

		return KErrNone;

		}

	TModuleSet set;

	if (!iModules[aDllNum] && !AlwaysLoaded(aDllNum))

		set.Add(aDllNum);

	const TInt* deps=ModuleDependencies[aDllNum];

	TInt ndeps=*deps++;

	TInt i;

	TInt ccount=0;

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

		{

		TInt dm=*deps++;

		if (!iModules[dm] && !AlwaysLoaded(dm))

			{

			set.Add(dm);

			if (GetModuleFlags(dm)&KModuleFlagData)

				++ccount;

			}

		}

	if (aCList)

		test(ccount==aCList->iCount);

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

		{

		if (!set.Present(i))

			continue;

		SModuleInstance mi;

		mi.iAccessCount=1;

		mi.iModNum=i;

		if (GetModuleFlags(i)&KModuleFlagData)

			{

			if (aCList)

				test(aCList->Find(i)>=0);

			}

		TInt j=aIList->Find(i);

		test(j>=0);

		mi.iEntryPointAddress=aIList->iInfo[j].iEntryPointAddress;

		mi.iModuleHandle=aIList->iInfo[j].iModuleHandle;

		mi.iCodeSeg=iGlobalList->CodeSegFromHandle(mi.iModuleHandle);

		test(mi.iCodeSeg!=NULL);

		if (GetModuleFlags(i)&KModuleFlagData)

			{

			TCodeSegCreateInfo cs_info;

			r=iDev.GetCodeSegInfo(mi.iCodeSeg, cs_info);

			test(r==KErrNone);

			mi.iData=cs_info.iDataRunAddress;

			}

		else

			{

			mi.iData=0;

			}

		r=iGlobalList->iModules.FindInOrder(&mi, Order);

		if (r>=0)

			{

			test.Printf(_L("Module %d@%08x already exists\n"),mi.iModNum,mi.iCodeSeg);

			SModuleInstance& mi0=*iGlobalList->iModules[r];

			++mi0.iAccessCount;

			test(mi.iEntryPointAddress==mi0.iEntryPointAddress);

			test(mi.iModuleHandle==mi0.iModuleHandle);

			test(mi.iData==mi0.iData);

			test(mi.iModNum==mi0.iModNum);

			iModules[i]=&mi0;

			}

		else

			{

			test.Printf(_L("Module %d@%08x new\n"),mi.iModNum,mi.iCodeSeg);

			SModuleInstance* pM=iGlobalList->GetMI();

			test(pM!=NULL);

			*pM=mi;

			iModules[i]=pM;

			r=iGlobalList->iModules.InsertInOrder(pM, Order);

			test(r==KErrNone);

			}

		}

	return KErrNone;

	}

void LoaderTest::TestMultipleLoads()

	{

	CGlobalModuleList* p=CGlobalModuleList::New(*this);

	p->CheckAll();

#ifdef __WINS__

	const TInt* multiLoad[] = {TC_MultLoad,0};

#else

	const TInt* multiLoad[] = {TC_MultLoad,TC_MultLoadTargetOnly,0};

#endif

	const TInt** multiLoadLists = multiLoad;

	const TInt* tests;