// 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 processed reloc table if loader tracing enabled. The dump is in

	// two parts; first, the page indexes (1 word per page), then the entries

	// describing the items to be relocated on each of these pages, formatted

	// with up to 8 entries per line but starting a new line for each page.

	// Each of these entries has the relocation type in the first nibble, and

	// the offset within the page in the remaining 3 nibbles.

	const TUint32* table32 = (const TUint32*)table;

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

		__IF_DEBUG(Printf("%04x: %08x", i*4, table32[i]));

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

		{

		TUint start = table32[i];

		TInt nbytes = table32[i+1] - start;

		while (nbytes)

			{

			TBuf8<0x100> buf;

			buf.Format(_L8("%04x:"), start);

			const TUint16* p = (const TUint16*)(table+start);

			TInt n = nbytes <= 16 ? nbytes : 16;

			for (nbytes -= n, start += n; n > 0; n -= 2)

				buf.AppendFormat(_L8(" %04x"), *p++);

			buf.AppendFormat(_L8("\r\n"));

			__IF_DEBUG(RawPrint(buf));

			}

		}

#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;

		}

	}

	{

	VA_LIST list;

	VA_START(list, aFmt);

	TPtrC8 fmt((const TText8*)aFmt);

	TBuf8<0x100> buf;

	buf.AppendFormatList(fmt, list);

	buf.AppendFormat(_L8("\r\n"));

	RDebug::RawPrint(buf);

	VA_END(list);

	}

/**

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 along with the text section

*/

TInt svRelocateExports(TAny* aPtr)

	{

	E32Image& exporter = *(E32Image*)aPtr;

	// Dump everything potentially useful that we know about the exporter ...

						exporter.iUseCodePaging, exporter.iRomImageHeader, exporter.iHeader));

						exporter.iCodeLoadAddress, exporter.iCodeRunAddress,

						exporter.iCodeSize, exporter.iTextSize))

						exporter.iDataLoadAddress, exporter.iDataRunAddress,

						exporter.iDataSize, exporter.iBssSize, exporter.iTotalDataSize));

						exporter.iCodeDelta, exporter.iDataDelta, exporter.iExportDirEntryDelta));

	// It turns out that very little of the exporter info is useful! For

	// example, the required code and data deltas are NOT those provided

	// by the exporter, nor are the load addresses relevant ... :(

	//

	// In the case of a PE-derived image, the entries in the export table

	// are expressed in terms of offsets into the image file, rather than

	// locations in memory. Each therefore needs to be relocated by the

	// difference between its file offset and its run address.

	//

	// It is assumed that the code segment appears before the data segment

	// in the file; therefore, export table entries with values between 0

	// and (exporter.iCodeSize) refer to the text segment, while higher

	// values represent references to data addresses. Since the run addresses

	// of code and data segments may be different, each type of export must

	// be relocated with respect to the correct section.

	//

	// The following express the start and finish of each section in terms of

	// file offsets and then derive the required adjustments to the entries

	// in the export table ...

	TUint32 codeStart = 0;							// compiler whinges if this is 'const' :(

	const TUint32 codeFinish = codeStart + exporter.iCodeSize;

	const TUint32 dataStart = codeFinish;

	const TUint32 dataFinish = dataStart + exporter.iTotalDataSize;

	const TUint32 codeDelta = exporter.iCodeRunAddress - codeStart;

	const TUint32 dataDelta = exporter.iDataRunAddress - dataStart;

	TUint32* destExport = (TUint32*)exporter.iExportDirLoad;

	for (TInt i = exporter.iExportDirCount; --i >= 0; )

		{

		TUint32 relocAddr = *destExport;

		TUint32 newValue;

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

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

		else if (relocAddr >= dataStart && relocAddr < dataFinish)

			newValue = relocAddr + dataDelta;		// points to data/bss section

		else

			newValue = relocAddr;					// unknown - just leave it alone

		*destExport++ = newValue;

							exporter.iExportDirCount-i, relocAddr, newValue,

							(relocAddr >= codeStart && relocAddr < codeFinish) ? 'C' :

							(relocAddr >= dataStart && relocAddr < dataFinish) ? 'D' : 'X'));

		}

	return 0;

	}

struct SFixupImportAddressesInfo

	{

	TUint32* iIat;					// Next part of IAT to be fixed up

	E32Image* iExporter;			// Module from which we're importing

	TInt iNumImports;				// Number of imports from this exporter

	/**

	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.

For a given importer, this function will be called once for each image from which

objects are imported, and each time it will update the relevant portion of the

importer's IAT, until all imports from all exporters have been processed.

*/

TInt svFixupImportAddresses(TAny* aPtr)

	{

	SFixupImportAddressesInfo& info = *(SFixupImportAddressesInfo*)aPtr;

	E32Image& exporter = *info.iExporter;

#ifdef _DEBUG

						info.iNumImports, info.iCodeLoadAddress, info.iFixup64, info.iExporter));

	// Dump everything potentially useful that we know about the exporter ...

						&exporter.iFileName, exporter.iUseCodePaging,

						exporter.iRomImageHeader, exporter.iHeader));

						exporter.iCodeLoadAddress, exporter.iCodeRunAddress,

						exporter.iCodeSize, exporter.iTextSize))

						exporter.iDataLoadAddress, exporter.iDataRunAddress,

						exporter.iDataSize, exporter.iBssSize, exporter.iTotalDataSize));

						exporter.iCodeDelta, exporter.iDataDelta, exporter.iExportDirEntryDelta));

	if (exporter.iRomImageHeader)

		{

		const TRomImageHeader& rh = *exporter.iRomImageHeader;

							rh.iCodeAddress, rh.iCodeSize, rh.iTextSize));

							rh.iDataAddress, rh.iDataSize, rh.iBssSize));

							rh.iDataBssLinearBase, rh.iTotalDataSize));

		}

	if (exporter.iHeader)

		{