// Copyright (c) 1995-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:

// e32\kernel\scodeseg.cpp

// 

//

#include <kernel/kern_priv.h>

#include <e32uid.h>

#include "execs.h"

extern void InvalidExecHandler();

// Compare code segments by name

TInt CompareCodeSegsByName(const DCodeSeg& aA, const DCodeSeg& aB)

	{

	TLinAddr aa = (TLinAddr)&aA;

	const TDesC8* pA = (aa & 1) ? (const TDesC8*)(aa&~3) : &aA.iRootName;

	return pA->CompareF(aB.iRootName);

	}

//

// DCodeSeg::RCodeSegsByAddress

//

DCodeSeg::RCodeSegsByAddress::RCodeSegsByAddress(TInt aMinGrowBy, TInt aFactor)

	: iActive(0)

	{

	new (iArray+0) RPointerArray<DCodeSeg>(aMinGrowBy, aFactor);

	new (iArray+1) RPointerArray<DCodeSeg>(aMinGrowBy, aFactor);

	}

TInt DCodeSeg::RCodeSegsByAddress::Add(DCodeSeg* aCodeSeg)

	{

	TInt r = iArray[iActive^1].InsertInOrder(aCodeSeg, Compare);

	if(r!=KErrNone)

		return r;

	NKern::LockSystem();

	iActive^=1;

	NKern::UnlockSystem();

	r = iArray[iActive^1].InsertInOrder(aCodeSeg, Compare);

	if(r!=KErrNone)

		Remove(aCodeSeg);

	return r;

	}

TInt DCodeSeg::RCodeSegsByAddress::Remove(DCodeSeg* aCodeseg)

	{

	TInt result = KErrNotFound;

	TInt active = iActive;

	for(;;)

		{

		RPointerArray<DCodeSeg>& array = iArray[iActive^1];

		TInt first = array.SpecificFindInOrder(aCodeseg, Compare, EArrayFindMode_First);

		TInt last = array.SpecificFindInOrder(aCodeseg, Compare, EArrayFindMode_Last);

		for(; first >= 0 && first < last; ++first)

			if(array[first]==aCodeseg)

				{

				array.Remove(first);

				result = KErrNone;

				break;

				}

		if(active!=iActive)

			return result;

		NKern::LockSystem();

		iActive ^= 1;

		NKern::UnlockSystem();

		}

	}

DCodeSeg* DCodeSeg::RCodeSegsByAddress::Find(TLinAddr aAddress)

	{

	DCodeSeg* s = NULL;

	DCodeSeg* st = (DCodeSeg*)(TLinAddr(&aAddress)+1);

	RPointerArray<DCodeSeg>& array = iArray[iActive];

	TInt ix;

	array.SpecificFindInOrder(st, ix, Compare, EArrayFindMode_Last);

	if (ix)

		{

		s = array[ix-1];

		if (aAddress<s->iRunAddress || (aAddress-s->iRunAddress) >= s->iSize)

			s = NULL;

		}

	return s;

	}

TInt DCodeSeg::RCodeSegsByAddress::Compare(const DCodeSeg& aA, const DCodeSeg& aB)

	{

	TLinAddr aa = (TLinAddr)&aA;

	TLinAddr a = (aa&1) ? *(TLinAddr*)(aa&~3) : aA.iRunAddress;

	TLinAddr b = aB.iRunAddress;

	if (a > b)

		return 1;

	else if (a < b)

		return -1;

	return 0;

	}

inline TBool CheckUid(const TUid aUid, const TUid aRequestedUid)

	{

	return (aRequestedUid.iUid==0 || aRequestedUid.iUid==aUid.iUid);

	}

TBool K::CheckUids(const TUidType& aUids, const TUidType& aRequestedUids)

	{

	return CheckUid(aUids.iUid[0],aRequestedUids.iUid[0]) && 

			CheckUid(aUids.iUid[1],aRequestedUids.iUid[1]) && 

			CheckUid(aUids.iUid[2],aRequestedUids.iUid[2]);

	}

/** Enters thread critical section and acquires code segment mutex.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

*/

EXPORT_C void Kern::AccessCode()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Kern::AccessCode");

	NKern::ThreadEnterCS();

	DCodeSeg::Wait();

	}

/** Exits thread critical section and releases code segment mutex.

@pre No fast mutex can be held.

@pre Call in a thread context.

@pre Kernel must be unlocked

@pre interrupts enabled

@pre Calling thread must be in a critical section

*/

EXPORT_C void Kern::EndAccessCode()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::EndAccessCode");

	DCodeSeg::Signal();

	NKern::ThreadLeaveCS();

	}

/** Accessor function for the kernel's code segment list.

	@return Pointer to the code segment list.

*/

EXPORT_C SDblQue* Kern::CodeSegList()

	{

	return &DCodeSeg::GlobalList;

	}

/** Accessor function for the kernel's code segment list mutex.

	@return Pointer to the code segment list mutex.

*/

EXPORT_C DMutex* Kern::CodeSegLock()

	{

	return DCodeSeg::CodeSegLock;

	}

#ifdef KDLL

GLDEF_C void DumpCodeSegCreateInfo(TCodeSegCreateInfo& a)

	{

	Kern::Printf("UIDS: %08x %08x %08x",a.iUids.iUid[0],a.iUids.iUid[1],a.iUids.iUid[2]);

	Kern::Printf("Attr: %08x",a.iAttr);

	Kern::Printf("Code size: %08x",a.iCodeSize);

	Kern::Printf("Text size: %08x",a.iTextSize);

	Kern::Printf("Data size: %08x",a.iDataSize);

	Kern::Printf("Bss size: %08x",a.iBssSize);

	Kern::Printf("Total data size: %08x",a.iTotalDataSize);

	Kern::Printf("Entry Point Veneer: %08x",a.iEntryPtVeneer);

	Kern::Printf("File Entry Point: %08x",a.iFileEntryPoint);

	Kern::Printf("DepCount: %d",a.iDepCount);

	Kern::Printf("ExportDir: %08x",a.iExportDir);

	Kern::Printf("ExportDirCount: %08x",a.iExportDirCount);

	Kern::Printf("CodeLoad: %08x",a.iCodeLoadAddress);

	Kern::Printf("CodeRun: %08x",a.iCodeRunAddress);

	Kern::Printf("DataLoad: %08x",a.iDataLoadAddress);

	Kern::Printf("DataRun: %08x",a.iDataRunAddress);

	Kern::Printf("RootName off: %d len: %d",a.iRootNameOffset,a.iRootNameLength);

	Kern::Printf("Ext offset: %d",a.iExtOffset);

	Kern::Printf("Ver: %08x",a.iModuleVersion);

	Kern::Printf("SID: %08x",a.iS.iSecureId);

	Kern::Printf("Cap: %08x %08x",a.iS.iCaps[1],a.iS.iCaps[0]);

	Kern::Printf("Handle: %08x",a.iHandle);

	Kern::Printf("Client Process Handle: %08x",a.iClientProcessHandle);

	Kern::Printf("CodeRelocTable: %d bytes at %08x", a.iCodeRelocTableSize, a.iCodeRelocTable);

	Kern::Printf("ImportFixupTabl: %d bytes at %08x", a.iImportFixupTableSize, a.iImportFixupTable);

	Kern::Printf("CodeDelta: %08x", a.iCodeDelta);

	Kern::Printf("DataDelta: %08x", a.iDataDelta);

	Kern::Printf("UseCodePaging: %d", a.iUseCodePaging);

	}

GLDEF_C void DumpProcessCreateInfo(TProcessCreateInfo& a)

	{

	DumpCodeSegCreateInfo(a);

	Kern::Printf("HeapSizeMin: %08x", a.iHeapSizeMin);

	Kern::Printf("HeapSizeMax: %08x", a.iHeapSizeMax);

	Kern::Printf("StackSize: %08x", a.iStackSize);

	Kern::Printf("Client Handle: %08x",a.iClientHandle);

	Kern::Printf("Process Handle: %08x",a.iProcessHandle);

	Kern::Printf("Final Handle: %08x",a.iFinalHandle);

	Kern::Printf("OwnerType: %08x",a.iOwnerType);

	Kern::Printf("Priority: %08x",a.iPriority);

	Kern::Printf("Debug Attributes: %08x", a.iDebugAttributes);

	}

#endif

/******************************************************************************

 * DCodeSeg class

 ******************************************************************************/

void DCodeSeg::Wait()

	{

	if (CodeSegLock)

		Kern::MutexWait(*CodeSegLock);

	}

void DCodeSeg::Signal()

	{

	if (CodeSegLock)

		Kern::MutexSignal(*CodeSegLock);

	}

/**	Verifies that a code segment handle is valid.

	@param	aHandle	The code segment handle to check.

	@return	A pointer to the code segment if the handle is valid;

	        NULL, if the handle is invalid.

	@pre Call in a thread context.

 */

EXPORT_C DCodeSeg* DCodeSeg::VerifyHandle(TAny* aHandle)

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_NOT_IDFC,"DCodeSeg::VerifyHandle");		

	DCodeSeg* pS=NULL;

	if (K::IsInKernelHeap(aHandle,sizeof(DCodeSeg)))

		{

		TUint32 cs_buf[sizeof(DCodeSeg)/sizeof(TUint32)];

		if (!Kern::SafeRead(aHandle,cs_buf,sizeof(DCodeSeg)))

			{

			DCodeSeg& cs=*(DCodeSeg*)cs_buf;

			TInt32 uid1=cs.iUids.iUid[0].iUid;

			if (cs.iAsyncDeleteNext==aHandle && (uid1==KDynamicLibraryUidValue || uid1==KExecutableImageUidValue))

				pS=(DCodeSeg*)aHandle;

			}

		}

	return pS;

	}

DCodeSeg* DCodeSeg::VerifyHandleP(TAny* aHandle)

	{

	DCodeSeg* pS=VerifyHandle(aHandle);

	if (!pS)

		K::PanicKernExec(EBadCodeSegHandle);

	return pS;

	}

DCodeSeg* DCodeSeg::VerifyCallerAndHandle(TAny* aHandle)

	{

	K::CheckFileServerAccess();

	return VerifyHandleP(aHandle);

	}

DCodeSeg* DCodeSeg::FindCodeSeg(const TFindCodeSeg& aFind)

	{

	if (GlobalList.IsEmpty())

		return NULL;

	DCodeSeg* st = (DCodeSeg*)(TLinAddr(&aFind.iName)+1);

	TBool newExe = (aFind.iUids.iUid[0].iUid==KExecutableImageUidValue);

	DProcess* pP = (DProcess*)aFind.iProcess;

	TInt first = CodeSegsByName.SpecificFindInOrder(st, &CompareCodeSegsByName, EArrayFindMode_First);

	TInt last = CodeSegsByName.SpecificFindInOrder(st, &CompareCodeSegsByName, EArrayFindMode_Last);

	__KTRACE_OPT(KDLL, Kern::Printf("FindCodeSeg %S first=%d last=%d", &aFind.iName, first, last));

	for (; first >= 0 && first < last; ++first)

		{

		DCodeSeg* pS = CodeSegsByName[first];

		if (!(pS->iMark&EMarkLoaded))

			continue;

	    if (((pS->iAttr ^ aFind.iAttrVal) & aFind.iAttrMask) != 0 || !K::CheckUids(pS->iUids,aFind.iUids) )

	          continue;

		if (aFind.iS.iSecureId && aFind.iS.iSecureId != pS->iS.iSecureId)

			continue;

		if (aFind.iModuleVersion!=KModuleVersionWild && aFind.iModuleVersion!=pS->iModuleVersion)

			continue;

		TUint32 c = 0;

		TInt i;

		for (i=0; i<SCapabilitySet::ENCapW; ++i)

			c |= (aFind.iS.iCaps[i] &~ pS->iS.iCaps[i]);

		if (c)

			continue;

		if ((pP||newExe) && !pS->FindCheck(pP))

			continue;

		return pS;

		}

	return NULL;

	}

/**	Removes a specified set of mark bits from every code segment in the system.

	@param	aMask	The mask of bits to reset.

    @pre Calling thread must be in a critical section.

    @pre No fast mutex can be held.

	@pre Call in a thread context.

	@pre Code segment lock mutex held.

	@pre Kernel must be unlocked

	@pre interrupts enabled

 */

EXPORT_C void DCodeSeg::UnmarkAll(TUint32 aMask)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DCodeSeg::UnmarkAll");		

	__ASSERT_WITH_MESSAGE_MUTEX(CodeSegLock,"Code segment lock mutex held","DCodeSeg::UnmarkAll");

	__KTRACE_OPT(KDLL,Kern::Printf("DCodeSeg::UnmarkAll %08x",aMask));

	SDblQueLink* anchor=&GlobalList.iA;

	SDblQueLink* pL=anchor->iNext;

	for (; pL!=anchor; pL=pL->iNext)

		_LOFF(pL,DCodeSeg,iLink)->iMark &= ~aMask;

	}

void DCodeSeg::UnmarkAndCloseAll(TUint32 aMask)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DCodeSeg::UnmarkAndCloseAll %08x",aMask));

	SDblQueLink* anchor=&GlobalList.iA;

	SDblQueLink* pL=anchor->iNext;

	SDblQueLink* pN=pL->iNext;

	for (; pL!=anchor; pL=pN, pN=pN->iNext)

		{

		DCodeSeg* pS=_LOFF(pL,DCodeSeg,iLink);

		if (pS->iMark & aMask)

			{

			pS->iMark &= ~aMask;

			pS->Close();

			}

		}

	}

TInt DCodeSeg::ListMarked(SDblQue& aQ, TUint32 aMask)

	{

	__KTRACE_OPT(KDLL,Kern::Printf(">DCodeSeg::ListMarked %08x",aMask));

	TInt n=0;

	SDblQueLink* anchor=&GlobalList.iA;

	SDblQueLink* pL=anchor->iNext;

	for (; pL!=anchor; pL=pL->iNext)

		{

		DCodeSeg* pS=_LOFF(pL,DCodeSeg,iLink);

		if (pS->iMark & aMask)

			{

			aQ.Add(&pS->iTempLink);

			++n;

			}

		}

	__KTRACE_OPT(KDLL,Kern::Printf("<DCodeSeg::ListMarked %d",n));

	return n;

	}

/** Removes all code segments from a queue and clear specified mark(s).

	@param aQ	Queue to iterate.  Code segments are linked together via DCodeSeg::iTempLink.

	@param aMask Bits to clear in DCodeSeg::iMark fields of iterated code segments.

	@pre DCodeSeg::CodeSegLock mutex held

	@post DCodeSeg::CodeSegLock mutex held

	@publishedPartner

	@released

 */

EXPORT_C void DCodeSeg::EmptyQueue(SDblQue& aQ, TUint32 aMask)

	{

	__ASSERT_WITH_MESSAGE_MUTEX(CodeSegLock,"Code segment lock mutex held","DCodeSeg::EmptyQueue");

	while(!aQ.IsEmpty())

		{

		DCodeSeg* pS=_LOFF(aQ.First()->Deque(), DCodeSeg, iTempLink);

		pS->iTempLink.iNext=NULL;

		pS->iMark &= ~aMask;

		}

	}

void DCodeSeg::DoKernelCleanup(TAny*)

	{

	// Clean up kernel-side code segments

	// Runs in supervisor thread

	__KTRACE_OPT(KDLL,Kern::Printf("DCodeSeg::DoKernelCleanup"));

	DCodeSeg::Wait();

	while(!KernelGarbageList.IsEmpty())

		{

		// if system has not gone idle since next codeseg was queued...

		DCodeSeg* pS = _LOFF(KernelGarbageList.First(),DCodeSeg,iGbgLink);

		TUint32 idleGenerationCount = pS->iGbgIdleGenerationCount;

		if(idleGenerationCount==NKern::IdleGenerationCount())

			{

			// then queue cleanup again for later...

			QueueKernelCleanup();

			break;

			}

		// close all codesegs with the same iGbgIdleGenerationCount...

		do

			{

			// deque and close codeseg...

			pS->iGbgLink.Deque();

			pS->iGbgLink.iNext = NULL;

			__NK_ASSERT_DEBUG(pS->iAccessCount>0);

			pS->CheckedClose();

			// get next codeseg...

			if(KernelGarbageList.IsEmpty())

				break;

			pS = _LOFF(KernelGarbageList.First(),DCodeSeg,iGbgLink);

			}

		while(pS->iGbgIdleGenerationCount==idleGenerationCount);

		}

	DCodeSeg::Signal();

	}

void DCodeSeg::EmptyGarbageList()

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DCodeSeg::EmptyGarbageList"));

	while(!GarbageList.IsEmpty())

		{

		DCodeSeg* pS=_LOFF(GarbageList.First()->Deque(),DCodeSeg,iGbgLink);

		__NK_ASSERT_DEBUG(pS->iAccessCount==0);

		pS->iGbgLink.iNext=NULL;

		delete pS;

		}

	}

void DCodeSeg::DeferDeletes()

	{

	++DeleteLock;

	}

void DCodeSeg::EndDeferDeletes()

	{

	if (--DeleteLock==0)

		EmptyGarbageList();

	}

TInt DCodeSeg::WriteCallList(SDblQue& aList, TLinAddr* aEpList, TBool aInitData)

	{

	__KTRACE_OPT(KDLL,Kern::Printf(">DCodeSeg::WriteCallList"));

	SDblQueLink* anchor=&aList.iA;

	SDblQueLink* pL=aList.First();

	TAny* p=NULL;

	for (; !p && pL!=anchor; pL=pL->iNext, ++aEpList)

		{

		DCodeSeg* pS=_LOFF(pL, DCodeSeg, iTempLink);

		if (aInitData)

			pS->InitData();

		TLinAddr ep=pS->iEntryPtVeneer;

		__KTRACE_OPT(KDLL,Kern::Printf("Writing EP %08x->%08x",ep,aEpList));

		p=Kern::KUSafeWrite(aEpList, &ep, sizeof(TLinAddr));

		}

	TInt r=p?ECausedException:0;

	__KTRACE_OPT(KDLL,Kern::Printf("<DCodeSeg::WriteCallList %d",r));

	return r;

	}

/**	Finds a code segment by its entry point address.

	@param	aEntryPoint	The entry point to search for.

	@return	A pointer to the code segment if it exists;

	        NULL if the entry point does not match any code segment.

    @pre Calling thread must be in a critical section.

    @pre No fast mutex can be held.

	@pre Call in a thread context.

	@pre Code segment lock mutex held.

	@pre Kernel must be unlocked

	@pre interrupts enabled

 */

EXPORT_C DCodeSeg* DCodeSeg::CodeSegFromEntryPoint(TInt aEntryPoint)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DCodeSeg::CodeSegFromEntryPoint");		

	__ASSERT_WITH_MESSAGE_MUTEX(CodeSegLock,"Code segment lock mutex held","DCodeSeg::CodeSegFromEntryPoint");

	DCodeSeg* s = Kern::CodeSegFromAddress( (TLinAddr)aEntryPoint, TheCurrentThread->iOwningProcess );

	if (s && s->iFileEntryPoint == TLinAddr(aEntryPoint))

		return s;

	return NULL;

	}

DCodeSeg::DCodeSeg()

	:	iAccessCount(1), iMark(EMarkLdr)

	{

	iLink.iNext=NULL;

	iTempLink.iNext=NULL;

	iGbgLink.iNext=NULL;

	}

void DCodeSeg::Destruct()

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DCodeSeg::Destruct %C", this));

#ifdef BTRACE_CODESEGS

	BTrace4(BTrace::ECodeSegs,BTrace::ECodeSegDestroyed,this);

#endif

	Wait();

	TInt first = CodeSegsByName.SpecificFindInOrder(this, &CompareCodeSegsByName, EArrayFindMode_First);

	TInt last = CodeSegsByName.SpecificFindInOrder(this, &CompareCodeSegsByName, EArrayFindMode_Last);

	for (; first >= 0 && first < last; ++first)

		{

		if (CodeSegsByName[first] == this)

			{

			CodeSegsByName.Remove(first);

			__KTRACE_OPT(KDLL,Kern::Printf("CodeSeg @%08x Removed By Name", this));

			break;

			}

		}

	if(CodeSegsByAddress.Remove(this)==KErrNone)

		{