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

// f32\sfile\sf_lepoc.cpp

// 

//

#include "sf_std.h"

#include <e32std.h>

#include <e32std_private.h>

#include <e32base.h>

#include <e32base_private.h>

#include <e32math.h>

#include <e32svr.h>

#include <e32ver.h>

#include <e32hal.h>

#include <u32exec.h>

#define INCLUDE_E32IMAGEHEADER_IMPLEMENTATION

#include "sf_ldr.h"

#include <f32image.h>

#include "sf_image.h"

#include <e32uid.h>

#include <e32rom.h>

#include "sf_cache.h"

#include "sf_pgcompr.h"

_LIT(KLitFinderInconsistent, "LDR-FINDER-INC");

_LIT(KLitSysBinError, "LDR-SYS\\BIN ERR");

_LIT8(KSysBin,":\\sys\\bin\\");

#ifdef _DEBUG

enum TLdrEpocPanic

	{

	EFuaiNoFixupTable = 0x10,

	EBcbmNotCodePaged = 0x20,

	ELfiCodePagingNotSupported = 0x30,

	EFprUnexpectedFixup = 0x40,

	};

static void Panic(TLdrEpocPanic aPanic)

	{

	_LIT(KPanicCat, "LDR-PNC");

	User::Panic(KPanicCat, aPanic);

	}

extern TRequestStatus* ProcessDestructStatPtr;

extern TBool ProcessCreated;

#endif

extern void DumpImageHeader(const E32ImageHeader*);

extern TDriveCacheHeader* gDriveFileNamesCache[];

TBuf8<KMaxPath> gLoadeePath;

TUint NextCodeSegId;

const TInt KMaxHeaderSize = sizeof(E32ImageHeaderV) + 65536/8;

#ifdef __X86__

extern TInt UseFloppy;

#endif

// -------- demand paging --------

/** Page size as a power of two. */

const TUint32 KPageSizeShift = 12;

/** Page size, as defined for code relocations.  This same page size is used for demand paging. */

const TUint32 KPageSize = 1<<KPageSizeShift;

/** Apply this mask to an address to get the page offset. */

const TUint32 KPageOffsetMask = KPageSize - 1;

/**

Calculate the number of pages required to contain the supplied number of bytes.

@param	aSizeInBytes	Size of are which has to be contained in whole blocks.

@return					Number of KPageSize pages required to contain area.

*/

inline TInt SizeToPageCount(TInt aSizeInBytes)

	{

	return (aSizeInBytes + KPageOffsetMask) >> KPageSizeShift;

	}

/**

Allocate a block which indexes the reallocations by page.  This can be used for demand paging.

@param	aSection			Pointer to relocation section to process.

@param	aAreaSize			Size in bytes of area described by reloc section.

@param  aLoadAddress		Address of relocation section in memory

@param	aProcessedBlock		On success (return == KErrNone) this is set to the processed

							relocation section which is allocated on the current thread's heap.

							The caller takes ownership.  The contents are undefined on failure.

@return						KErrNoMemory if could not allocate memory for processed block

							and auxiliary structures; KErrNone otherwise.

 */

TInt E32Image::AllocateRelocationData(E32RelocSection* aSection, TUint32 aAreaSize, TUint32 aLoadAddress, TUint32*& aProcessedBlock)

	{

	__IF_DEBUG(Printf("AllocateRelocationData"));

	TUint32 sectionSize = aSection->iSize;

	TUint32 numRelocs = aSection->iNumberOfRelocs;

	TInt pageCount = SizeToPageCount(aAreaSize);

	// The file format documentation (SOSI ch10) does not guarantee that each page has

	// relocation information, or that the pages are listed in order, so store them in

	// page order here.

	TUint8** subBlocks = (TUint8**)User::AllocZ(sizeof(TUint8*)*pageCount);

	if(subBlocks == 0)

		return KErrNoMemory;

	const TUint8* subBlockPtr = (TUint8*)(aSection+1);

	while(sectionSize > 0)

		{

		TUint32 pageOffset = *(TUint32*)(subBlockPtr);

		TUint32 subBlockSize = *(TUint32*)(subBlockPtr+4);

		subBlocks[pageOffset >> KPageSizeShift] = (TUint8*)subBlockPtr;

		sectionSize -= subBlockSize;

		subBlockPtr += subBlockSize;	// move to next sub-block

		}

	// now have each relocation page in memory, build lookup table	

	TUint32 indexSize = (pageCount + 1) * sizeof(TUint32);	// include sentinel

	TUint32 totalRelocations = numRelocs;

	iCodeRelocTableSize = indexSize + totalRelocations * sizeof(TUint16);

	TUint8* table = (TUint8*) User::Alloc(iCodeRelocTableSize);

	if(table == 0)

		{

		User::Free(subBlocks);

		return KErrNoMemory;

		}

	// where sub-block positions are written to in the table

	TUint32* destSubBlock = (TUint32*)table;

	// where entries are written to in the table

	TUint16* destEntry = (TUint16*)(table + indexSize);

	TInt i;

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

		{

		*destSubBlock++ = TUint32(destEntry) - TUint32(table);

		// see if a relocation page was defined for this page

		const TUint8* subBlock = subBlocks[i];

		if(subBlock == 0)

			continue;

		// get number of entries in this sub-block, including padding

		TUint32 sbEntryCount;

		TUint32 pageOffset = *(TUint32*)subBlock;	// offset of page from start of section

		sbEntryCount = *(TUint32*)(subBlock + 4);	// sub-block size

		sbEntryCount -= 8;							// exclude sub-block header

		sbEntryCount /= 2;							// each entry is two bytes

		const TUint16* srcEntry = (TUint16*)(subBlock + 8);

		while(sbEntryCount--)

			{

			TUint16 entry = *srcEntry++;

			if(entry==0)		// ignore null padding values

				continue;

			// Replace inferred fixup type with actual fixup type

			TUint type = entry & 0xf000;

			if(type==KInferredRelocType)

				{

				TUint32* ptr = (TUint32*)(aLoadAddress + pageOffset + (entry & 0x0fff));

				TUint32 word = *ptr;

				type = (TUint(word - iHeader->iCodeBase) < TUint(iHeader->iCodeSize)) ? KTextRelocType : KDataRelocType;

				entry = (entry & 0x0fff) | type;

				}

			*destEntry++ = entry;

			}

		}

	// sentinel entry marks the byte following last sub-block in table

	// This gives the size of the last processed sub-block.

	*destSubBlock = TUint32(destEntry) - TUint32(table);

	aProcessedBlock = (TUint32*) table;

	User::Free(subBlocks);

#ifdef _DEBUG

	__IF_DEBUG(Printf("processed reloc table (size=%d,pageCount=%d)", iCodeRelocTableSize, pageCount));

	// dump the import fixup table if loader tracing enabled

	const TUint16* table16 = (const TUint16*)table;

	const TInt halfWordsInTable = iCodeRelocTableSize / 2;

	for(i = 0; i < halfWordsInTable; i += 4)

		{

		__IF_DEBUG(Printf(

			"reloc %04x: %04x %04x %04x %04x",

			i * 2, table16[i+0], table16[i+1], table16[i+2], table16[i+3]));

		}

#endif

	return KErrNone;

	}

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

 * These functions run in supervisor mode since they require access to the

 * chunks of the newly-created process or DLL while they are still in the

 * home section.

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

/**

Vector which ::ExecuteInSupervisorMode invokes.

*/

TInt (*ExecuteInSupervisorModeVector)(TSupervisorFunction, TAny*);

/**

Executute aFunction in supervisor mode (if the memory model requires this.)

*/

TInt ExecuteInSupervisorMode(TSupervisorFunction aFunction, TAny* aParameter)

	{

	return(*ExecuteInSupervisorModeVector)(aFunction, aParameter);

	}

/**

Implementation of ::ExecuteInSupervisorMode which actually executes the

function in user mode.

*/

TInt UserModeExecuteInSupervisorMode(TSupervisorFunction aFunction, TAny* aParameter)

	{

	return (*aFunction)(aParameter);

	}

/**

Decide whether any Loader code actually needs to execute in supervisor mode

and set ::ExecuteInSupervisorModeVector so that invocations of ::ExecuteInSupervisorMode

call the appropriate function.

*/

void InitExecuteInSupervisorMode()

	{

	// work out if we need to really 'execute in supervisor mode'...

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

	TUint32 memModel = memModelAttrs & EMemModelTypeMask;

	if(memModel==EMemModelTypeFlexible)

		{

		// we can do everything user side...

		ExecuteInSupervisorModeVector = UserModeExecuteInSupervisorMode;

		gExecutesInSupervisorMode = EFalse;

		}

	else

		{

		// we need to go kernel side...

		ExecuteInSupervisorModeVector = UserSvr::ExecuteInSupervisorMode;

		gExecutesInSupervisorMode = ETrue;

		}

	}

/**

Arguments for svRelocateSection.

The relocation information (at iRelocsBuf) has list sub blocks, each referring to a 4kB

page within the section. See E32RelocBlock.

*/

struct SRelocateSectionInfo

	{

	E32Image* iImage;		///< The executable being relocated.

	TUint8* iRelocsBuf;		///< Pointer to relocation info.

	TUint32 iNumRelocs;		///< Total number of relocations to apply.

	TUint32 iLoadAddress; 	///< Virtual address where section is currently located in memory.

	};

/**

Apply relocations to a code or data section.

@param aPtr Pointer to SRelocateSectionInfo.

*/

TInt svRelocateSection(TAny* aPtr)

	{

	SRelocateSectionInfo& info=*(SRelocateSectionInfo*)aPtr;

	E32Image& img = *(E32Image*)info.iImage;

	TUint8* relocs = info.iRelocsBuf;

	TUint32 numRelocs = info.iNumRelocs;

	TUint32 loadAddress = info.iLoadAddress;

	TUint32 codeStart = img.iHeader->iCodeBase;

	TUint32 codeFinish = codeStart+img.iHeader->iCodeSize;

	TUint32 codeDelta = img.iCodeDelta;

	TUint32 dataDelta = img.iDataDelta;

	while(numRelocs>0)

		{

		TUint32 pageAddress = ((TUint32*)relocs)[0];

		TUint32 pageSize = ((TUint32*)relocs)[1];

		TUint8* relocsEnd = relocs+pageSize;

		relocs += 8;

		while(relocs<relocsEnd)

			{

			TUint16 relocOffset = *(TUint16*)relocs;

			relocs += 2;

			if(!relocOffset)

				continue;

			TUint32 offset = pageAddress+(TUint32)(relocOffset&0x0fff);

			TUint32* destPtr = (TUint32*)(loadAddress+offset);

			TUint16 relocType = relocOffset&0xf000;

			TUint32 relocAddr = *destPtr;

			if(relocType==KTextRelocType)

				relocAddr += codeDelta; // points to text/rdata section

			else if(relocType==KDataRelocType)

				relocAddr += dataDelta; // points to data section

			else if (relocAddr>=codeStart && relocAddr<codeFinish)

				relocAddr += codeDelta; // points to text/rdata section

			else

				relocAddr += dataDelta; // points to data section

			*destPtr = relocAddr;

			--numRelocs;

			}

		}

	return 0;

	}

/**

Fix up the export directory

Only performed on PE images.  ELF image's exports are marked

as relocatable and therefore relocated by svRelocateSection when the 

text section is relocated up

*/

TInt svRelocateExports(TAny* aPtr)

	{

	E32Image* pI=(E32Image*)aPtr;

	TUint32* destExport=(TUint32*)pI->iExportDirLoad;

	TInt i=pI->iExportDirCount;

	TUint32 codeBase=pI->iCodeRunAddress;

	while (i-->0)

		*destExport+++=codeBase;

	return 0;

	}

struct SFixupImportAddressesInfo

	{

	TUint32* iIat;

	TUint32* iExportDir;

	TUint32 iExportDirEntryDelta;

	TInt iNumImports;

	E32Image* iExporter;

	/**

	For demand paging, this points to the buffer which is populated

	so each page can be fixed up as it is loaded in.

	*/

	TUint64* iFixup64;

	// For ElfDerived...

	TUint32 iCodeLoadAddress;

	TUint32* iImportOffsetList;

	};

/**

Fix up the import address table, used for 'PE derived' executables.

@param aPtr Pointer to function arguments (SFixupImportAddressesInfo structure).

			SFixupImportAddressesInfo::iIat is updated by this function.

*/

TInt svFixupImportAddresses(TAny* aPtr)

	{

	SFixupImportAddressesInfo& info = *(SFixupImportAddressesInfo*)aPtr;

	TUint32 maxOrdinal = (TUint32)info.iExporter->iExportDirCount;

	TUint32 absentOrdinal = (TUint32)info.iExporter->iFileEntryPoint;

	TUint32* exp_dir = info.iExportDir - KOrdinalBase; // address of 0th ordinal

	TUint32 exp_delta = info.iExportDirEntryDelta;

	TUint32* iat = info.iIat;

	TUint32* iatE = iat+info.iNumImports;

	for(; iat<iatE; ++iat)

		{

		TUint32 imp = *iat;

		if(imp>maxOrdinal)

			return KErrNotSupported;

		TUint32 writeValue;

		if(imp==0 && !(info.iExporter->iAttr&ECodeSegAttNmdExpData))

			{

			// attempt to import ordinal zero (symbol name data) from an executable

			// which doesn't export this information, use NULL for imported value in this case...

			writeValue = NULL;

			}

		else

			{

			// get imported value from exporter...

			TUint32 exp_addr = exp_dir[imp];

			if(exp_addr==0 || exp_addr==absentOrdinal)

				return KErrNotSupported;

			writeValue = exp_addr + exp_delta;

			}

		// if not code paging then directly fix up the import...

		if (info.iFixup64 == 0)

			*iat = writeValue;

		else

		// ...otherwise defer until the page is fixed up

			{

			TUint64 iat64 = reinterpret_cast<TUint64>(iat);

			*info.iFixup64++ = (iat64 << 32) | writeValue;

			}

		}

	info.iIat = iat;

	return KErrNone;

	}

/**

Fix up the import addresses, used for 'elf derived' executables.

@param aPtr Pointer to function arguments (SFixupImportAddressesInfo structure).

*/

TInt svElfDerivedFixupImportAddresses(TAny* aPtr)

	{

	SFixupImportAddressesInfo& info = *(SFixupImportAddressesInfo*)aPtr;

	TUint32 maxOrdinal = (TUint32)info.iExporter->iExportDirCount;

	TUint32 absentOrdinal = (TUint32)info.iExporter->iFileEntryPoint;

	TUint32* exp_dir = info.iExportDir - KOrdinalBase; // address of 0th ordinal

	TUint32 exp_delta = info.iExportDirEntryDelta;

	TUint32 code = info.iCodeLoadAddress;

	TUint32* iol = info.iImportOffsetList;

	TUint32* iolE = iol+info.iNumImports;

	for(; iol<iolE; ++iol)

		{

		TUint32* impPtr = (TUint32*)(code+*iol);

		TUint32 impd = *impPtr;

		TUint32 imp = impd & 0xffff;

		TUint32 offset = impd >> 16;

		if(imp>maxOrdinal)

			return KErrNotSupported;

		TUint32 writeValue;

		if(imp==0 && !(info.iExporter->iAttr&ECodeSegAttNmdExpData))

			{

			// attempt to import ordinal zero (symbol name data) from an executable

			// which doesn't export this information, use NULL for imported value in this case...

			writeValue = NULL;

			}

		else

			{

			// get imported value from exporter...

			TUint32 exp_addr = exp_dir[imp];

			if(exp_addr==0 || exp_addr==absentOrdinal)

				return KErrNotSupported;

			writeValue = exp_addr + exp_delta + offset;

			}

		// if not code paging then directly fix up the import...

		if (info.iFixup64 == 0)

			*impPtr = writeValue;

		// ...otherwise defer until the page is fixed up

		else

			{

			TUint64 impPtr64 = reinterpret_cast<TUint64>(impPtr);

			*info.iFixup64++ = (impPtr64 << 32) | writeValue;

			}

		}

	return KErrNone;

	}

/**

Wrapper for memory copy arguments.

*/

struct SCopyDataInfo

	{

	TAny* iDest;

	const TAny* iSource;

	TInt iNumberOfBytes;

	};

/**

Copies word aligned memory.

@param aPtr Pointer to function arguments (SCopyDataInfo structure).

*/

TInt svWordCopy(TAny* aPtr)

	{

	SCopyDataInfo& info=*(SCopyDataInfo*)aPtr;

	return (TInt) Mem::Move(info.iDest, info.iSource, info.iNumberOfBytes);

	}

/**

Copies memory.

@param aPtr Pointer to function arguments (SCopyDataInfo structure).

*/

TInt svMemCopy(TAny* aPtr)

	{

	SCopyDataInfo& info=*(SCopyDataInfo*)aPtr;

	return (TInt) Mem::Copy(info.iDest, info.iSource, info.iNumberOfBytes);

	}

/**

Argument for svElfDerivedGetImportInfo.

*/

struct SGetImportDataInfo

	{

	TInt iCount;					// number to extract

	TUint32* iDest;					// destination address for data

	TUint32 iCodeLoadAddress;		// address where code has been loaded

	TUint32* iImportOffsetList;		// pointer to list of import offsets in E32ImportBlock