// 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\memmodel\epoc\pcodeseg.cpp

// 

//

#include "plat_priv.h"

#include <e32uid.h>

TLinAddr DCodeSeg::ExceptionDescriptor()

	{

	DEpocCodeSeg* s = (DEpocCodeSeg*)this;

	if (s->iXIP)

		return s->RomInfo().iExceptionDescriptor;

	return s->RamInfo().iExceptionDescriptor;

	}

DEpocCodeSeg::~DEpocCodeSeg()

	{

	if (!iXIP && iMemory)

		{

		iMemory->iCodeSeg = 0;

		iMemory->Close();

		iMemory = NULL;

		}

	}

void DEpocCodeSeg::Destruct()

	{

	DCodeSeg::Wait();

	if (iLoaderCookie!=NULL)

		{

		if ((TInt) iLoaderCookie&1) // Not set fully loaded

			{

			iLoaderCookie = (TCodeSegLoaderCookieList*) ( ((TInt) iLoaderCookie) & ~1);

			delete iLoaderCookie;

			iLoaderCookie=NULL;

			}

		else

			{

			// Notify reaper of destruction

			NKern::LockSystem();

			if (DestructNotifyRequest->IsReady())

				{

				DThread* t = DestructNotifyThread;

				DestructNotifyThread = NULL;				

				Kern::QueueRequestComplete(t, DestructNotifyRequest,KErrNone);

				}

			NKern::UnlockSystem();

			iLoaderCookie->iNext=DestructNotifyList;

			DestructNotifyList=iLoaderCookie;

			iLoaderCookie=NULL;

			}

		}

	DCodeSeg::Signal();

	DCodeSeg::Destruct();

	}

void DEpocCodeSeg::Info(TCodeSegCreateInfo& aInfo)

	{

	CHECK_PAGING_SAFE;

	if (iXIP)

		{

		const TRomImageHeader& rih=RomInfo();

		aInfo.iCodeSize=rih.iCodeSize;

		aInfo.iTextSize=rih.iTextSize;

		aInfo.iDataSize=rih.iDataSize;

		aInfo.iBssSize=rih.iBssSize;

		aInfo.iTotalDataSize=rih.iTotalDataSize;

		aInfo.iExportDir=rih.iExportDir;

		aInfo.iExportDirCount=rih.iExportDirCount;

		aInfo.iCodeLoadAddress=rih.iCodeAddress;

		aInfo.iCodeRunAddress=rih.iCodeAddress;

		aInfo.iDataLoadAddress=rih.iDataAddress;

		aInfo.iDataRunAddress=rih.iDataBssLinearBase;

		aInfo.iExceptionDescriptor = rih.iExceptionDescriptor;

		}

	else

		{

		const SRamCodeInfo& ri=RamInfo();

		aInfo.iCodeSize=ri.iCodeSize;

		aInfo.iTextSize=ri.iTextSize;

		aInfo.iDataSize=ri.iDataSize;

		aInfo.iBssSize=ri.iBssSize;

		aInfo.iTotalDataSize=ri.iDataSize+ri.iBssSize;

		aInfo.iExportDir=ri.iExportDir;

		aInfo.iExportDirCount=ri.iExportDirCount;

		aInfo.iCodeLoadAddress=ri.iCodeLoadAddr;

		aInfo.iCodeRunAddress=ri.iCodeRunAddr;

		aInfo.iDataLoadAddress=ri.iDataLoadAddr;

		aInfo.iDataRunAddress=ri.iDataRunAddr;

		aInfo.iExceptionDescriptor = ri.iExceptionDescriptor;

		}

	DCodeSeg::Info(aInfo);

	}

void DEpocCodeSeg::GetDataSizeAndBase(TInt& aTotalDataSizeOut, TLinAddr& aDataBaseOut)

	{

	if (iXIP)

		{

		aTotalDataSizeOut=RomInfo().iTotalDataSize;

		aDataBaseOut=RomInfo().iDataBssLinearBase;

		}

	else

		{

		aTotalDataSizeOut=RamInfo().iDataSize+RamInfo().iBssSize;

		aDataBaseOut=RamInfo().iDataRunAddr;

		}	

	}

TLibraryFunction DEpocCodeSeg::Lookup(TInt aOrdinal)

	{

	CHECK_PAGING_SAFE;

	// return NULL for -ve ordinal or 0th ordinal when not stddll/stdexe

	if (aOrdinal<0 || (aOrdinal==0 && !(iAttr&ECodeSegAttNmdExpData)))

		return NULL;

	TInt xdc;

	TLinAddr* xd;	// points to the 0th ordinal of export table

	if (iXIP)

		{

		const TRomImageHeader& rih=RomInfo();

		xdc=rih.iExportDirCount;

		xd=(TLinAddr*)rih.iExportDir - 1;

		}

	else

		{

		SRamCodeInfo& ri=RamInfo();

		xdc=ri.iExportDirCount;

		xd=(TLinAddr*)ri.iExportDir - 1;

		}

	if (aOrdinal <= xdc)

		{

		UNLOCK_USER_MEMORY();

		TLibraryFunction f=(TLibraryFunction)xd[aOrdinal];

		LOCK_USER_MEMORY();

		if ((TLinAddr)f == iFileEntryPoint)

			f = NULL;

		__KTRACE_OPT(KDLL,Kern::Printf("Lookup(%d)->%08x",aOrdinal,f));

		return f;

		}

	__KTRACE_OPT(KDLL,Kern::Printf("Lookup(%d)->NULL",aOrdinal));

	return NULL;

	}

TInt DEpocCodeSeg::GetMemoryInfo(TModuleMemoryInfo& aInfo, DProcess*)

	{

	CHECK_PAGING_SAFE;

	if (iXIP)

		{

		const TRomImageHeader& rih		= RomInfo();

		aInfo.iCodeBase					= rih.iCodeAddress;

		aInfo.iCodeSize					= rih.iTextSize;

		aInfo.iConstDataSize			= rih.iCodeSize - aInfo.iCodeSize;

		aInfo.iConstDataBase			= (aInfo.iConstDataSize > 0) ? (aInfo.iCodeBase + aInfo.iCodeSize) : 0;

		aInfo.iInitialisedDataBase		= rih.iDataBssLinearBase;

		aInfo.iInitialisedDataSize		= rih.iDataSize;

		aInfo.iUninitialisedDataSize	= rih.iBssSize;

		aInfo.iUninitialisedDataBase	= aInfo.iInitialisedDataBase+aInfo.iInitialisedDataSize;

		}

	else

		{

		const SRamCodeInfo& ri			= RamInfo();

		aInfo.iCodeBase					= ri.iCodeRunAddr;

		aInfo.iCodeSize					= ri.iTextSize;

		aInfo.iConstDataSize			= ri.iCodeSize - aInfo.iCodeSize;

		aInfo.iConstDataBase			= (aInfo.iConstDataSize > 0) ? (aInfo.iCodeBase + aInfo.iCodeSize) : 0;

		aInfo.iInitialisedDataBase		= ri.iDataRunAddr;

		aInfo.iInitialisedDataSize		= ri.iDataSize;

		aInfo.iUninitialisedDataSize	= ri.iBssSize;

		aInfo.iUninitialisedDataBase	= aInfo.iInitialisedDataBase + aInfo.iInitialisedDataSize;

		}

	return KErrNone;

	}

//const TUint32 KRomImageFlagsAlwaysLoaded=KRomImageFlagPrimary|KRomImageFlagVariant|KRomImageFlagExtension;

const TUint32 KRomImageDataFlags=(KRomImageFlagData|KRomImageFlagDataInit|KRomImageFlagDataPresent);

TInt DEpocCodeSeg::DoCreate(TCodeSegCreateInfo& aInfo, DProcess* aProcess)

	{

	__KTRACE_OPT(KDLL,Kern::Printf(">DEpocCodeSeg::DoCreate code_addr=%08x",aInfo.iCodeLoadAddress));

	CHECK_PAGING_SAFE;

	TInt r=KErrNone;

	TBool exeSeg=(iExeCodeSeg==this);

	TBool kp=exeSeg && (aProcess->iAttributes&DProcess::ESupervisor);

	TBool user_proc=exeSeg && !kp;

	if (aInfo.iCodeLoadAddress)

		{

		iXIP=ETrue;

		iInfo=(const TAny*)aInfo.iCodeLoadAddress;

		}

	if (user_proc)

		{

		r=aProcess->CreateDataBssStackArea((TProcessCreateInfo&)aInfo);

		if (r!=KErrNone)

			return r;

		}

	if (iXIP)

		{

		const TRomImageHeader& rih=RomInfo();

		iXIP=ETrue;

		if ( (rih.iFlags & (KRomImageFlagExeInTree|KRomImageFlagDll)) == (KRomImageFlagExeInTree|KRomImageFlagDll))

			{

			const TRomImageHeader* exeRIH=rih.iDllRefTable->iEntry[0];	// EXE is always first entry

			if (aProcess)

				{

				DEpocCodeSeg* pS=(DEpocCodeSeg*)aProcess->CodeSeg();

				if (!pS->iXIP || &pS->RomInfo()!=exeRIH)

					return KErrNotSupported;

				iExeCodeSeg=pS;

				}

			}

		iMark |= (rih.iFlags & KRomImageDataFlags);

		iMark |= EMarkRecursiveFlagsValid;

		__KTRACE_OPT(KDLL,Kern::Printf("ROM Code Seg: mark %08x attr=%02x",iMark,iAttr));

		aInfo.iFileEntryPoint=rih.iEntryPoint;

		aInfo.iExportDir=rih.iExportDir;

		aInfo.iCodeLoadAddress=rih.iCodeAddress;

		aInfo.iCodeRunAddress=rih.iCodeAddress;

		iRunAddress = rih.iCodeAddress;

		iSize = rih.iCodeSize;

		aInfo.iDataLoadAddress=rih.iDataAddress;

		if (aInfo.iTotalDataSize && user_proc && aProcess->iDataBssRunAddress!=rih.iDataBssLinearBase)

			K::Fault(K::EProcessDataAddressInvalid);

		aInfo.iDataRunAddress=rih.iDataBssLinearBase;

		aInfo.iExceptionDescriptor = rih.iExceptionDescriptor;

		r=DoCreateXIP(aProcess);

		return r;

		}

	iMemory = DEpocCodeSegMemory::New(this);

	if (!iMemory)

		return KErrNoMemory;

	iInfo = &iMemory->iRamInfo;

	if (aInfo.iUseCodePaging)

		{

		if ((aInfo.iCodeBlockMapEntries==NULL) || (aInfo.iCodeBlockMapCommon.iLocalDriveNumber<0) ||

		(((TInt64) (aInfo.iFileClamp.iCookie[0] | aInfo.iFileClamp.iCookie[1]))==0))

				return KErrArgument;

		iLoaderCookie = new TCodeSegLoaderCookieList();

		if (!iLoaderCookie)

			return KErrNoMemory;

		SBlockMapInfoBase* cbm = &aInfo.iCodeBlockMapCommon;

		TUint startBlock;

		kumemget32(&startBlock, &aInfo.iCodeBlockMapEntries->iStartBlock, sizeof(TUint));

		iLoaderCookie->iCookie.iDriveNumber = cbm->iLocalDriveNumber;

		iLoaderCookie->iCookie.iStartAddress =	cbm->iStartBlockAddress +

												startBlock *

												cbm->iBlockGranularity +

												cbm->iBlockStartOffset;

		iLoaderCookie->iCookie.iFileClamp = aInfo.iFileClamp;

		// Mark cookie not to be closed yet

		iLoaderCookie = (TCodeSegLoaderCookieList*) ( ((TInt) iLoaderCookie) | 1);

		}

	SRamCodeInfo& ri=RamInfo();

	ri.iCodeSize=aInfo.iCodeSize;

	ri.iTextSize=aInfo.iTextSize;

	ri.iDataSize=aInfo.iDataSize;

	ri.iBssSize=aInfo.iBssSize;

	TInt total_data_size=ri.iDataSize+ri.iBssSize;

	ri.iExportDirCount=aInfo.iExportDirCount;

	if (total_data_size!=0)

		{

		iMark|=(EMarkData|EMarkDataPresent);

		if (!exeSeg)

			iMark|=EMarkDataInit;

		}

	// if this DLL/EXE doesn't have data, don't set valid bit since we don't yet know about its dependencies

	if (exeSeg)

		ri.iDataRunAddr=aProcess->iDataBssRunAddress;

	r=DoCreateRam(aInfo, aProcess);

	if (r==KErrNone)

		{

		aInfo.iFileEntryPoint+=ri.iCodeRunAddr;

		aInfo.iExportDir+=ri.iCodeRunAddr;

		ri.iExportDir=aInfo.iExportDir;

		aInfo.iCodeLoadAddress=ri.iCodeLoadAddr;

		aInfo.iCodeRunAddress=ri.iCodeRunAddr;

		aInfo.iDataLoadAddress=ri.iDataLoadAddr;

		aInfo.iDataRunAddress=ri.iDataRunAddr;

		TUint32 xd = aInfo.iExceptionDescriptor;

		ri.iExceptionDescriptor = xd ? (xd + ri.iCodeRunAddr) : 0;

		aInfo.iExceptionDescriptor = ri.iExceptionDescriptor;

		iRunAddress = ri.iCodeRunAddr;

		}

	__KTRACE_OPT(KDLL,Kern::Printf("RAM Code Seg: mark %08x attr=%02x xd=%08x",iMark,iAttr,ri.iExceptionDescriptor));

	__KTRACE_OPT(KDLL,Kern::Printf("<DEpocCodeSeg::DoCreate %d",r));

	return r;

	}

void DEpocCodeSeg::InitData()

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DEpocCodeSeg::InitData %C", this));

	CHECK_PAGING_SAFE;

	TInt bss_size=0;

	TInt data_size=0;

	TUint8* data_run_ptr=0;

	const TUint8* data_load_ptr=0;

	if (iXIP)

		{

		const TRomImageHeader& rih=RomInfo();

		bss_size=rih.iBssSize;

		data_size=rih.iDataSize;

		data_run_ptr=(TUint8*)rih.iDataBssLinearBase;

		data_load_ptr=(const TUint8*)rih.iDataAddress;

		}

	else

		{

		SRamCodeInfo& ri=RamInfo();

		bss_size=ri.iBssSize;

		data_size=ri.iDataSize;

		data_run_ptr=(TUint8*)ri.iDataRunAddr;

		data_load_ptr=(const TUint8*)ri.iDataLoadAddr;

		}

	UNLOCK_USER_MEMORY();

	if (data_size)

		memcpy(data_run_ptr, data_load_ptr, data_size);

	if (bss_size)

		memclr(data_run_ptr+data_size, bss_size);

	LOCK_USER_MEMORY();

	}

DCodeSeg* DCodeSeg::FindRomCode(const TAny* aRomImgHdr)

	{

	CHECK_PAGING_SAFE;

	const TRomImageHeader& rih = *(const TRomImageHeader*)aRomImgHdr;

	TLinAddr ca = rih.iCodeAddress;

	return CodeSegsByAddress.Find(ca);

	}

void P::NormalizeExecutableFileName(TDes& /*aFileName*/)

	{

	}

TInt DEpocCodeSeg::Loaded(TCodeSegCreateInfo& aInfo)

	{

	iLoaderCookie = (TCodeSegLoaderCookieList*) ( ((TInt) iLoaderCookie) & ~1);

	return DCodeSeg::Loaded(aInfo);

	}

//

// DEpocCodeSegMemory

//

DEpocCodeSegMemory::DEpocCodeSegMemory(DEpocCodeSeg* aCodeSeg)

	: iAccessCount(1), iCodeSeg(aCodeSeg)

	{

	}

TInt DEpocCodeSegMemory::Open()

	{

	return __e32_atomic_tas_ord32(&iAccessCount, 1, 1, 0) ? KErrNone : KErrGeneral;

	}

TInt DEpocCodeSegMemory::Close()

	{

	if (__e32_atomic_tas_ord32(&iAccessCount, 1, -1, 0) == 1)

		{

		AsyncDelete();

		return DObject::EObjectDeleted;

		}

	return 0;

	}