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

 //

 #include <memmodel.h>

 #include "mmu/mm.h"

 #include "mmboot.h"

 #include "mmu/mcodepaging.h"

 #include "cache_maintenance.h"

 DCodeSeg* M::NewCodeSeg(TCodeSegCreateInfo&)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("M::NewCodeSeg"));

 	return new DMemModelCodeSeg;

 	}

 //

 // DMemModelCodeSegMemory

 //

 DEpocCodeSegMemory* DEpocCodeSegMemory::New(DEpocCodeSeg* aCodeSeg)

 	{

 	return new DMemModelCodeSegMemory(aCodeSeg);

 	}

 DMemModelCodeSegMemory::DMemModelCodeSegMemory(DEpocCodeSeg* aCodeSeg)

 	: DEpocCodeSegMemory(aCodeSeg)

 	{

 	}

 TInt DMemModelCodeSegMemory::Create(TCodeSegCreateInfo& aInfo, DMemModelProcess* aProcess)

 	{

 	TInt r;

 	TUint codePageCount;

 	TUint dataPageCount;

 	TBool isDemandPaged;

 	if(!aInfo.iUseCodePaging)

 		{

 		isDemandPaged = 0;

 		codePageCount = MM::RoundToPageCount(iRamInfo.iCodeSize+iRamInfo.iDataSize);

 		dataPageCount = 0;

 		}

 	else

 		{

 		isDemandPaged = 1;

 		codePageCount = MM::RoundToPageCount(iRamInfo.iCodeSize);

 		dataPageCount = MM::RoundToPageCount(iRamInfo.iDataSize);

 		iDataSectionMemory = Kern::Alloc(iRamInfo.iDataSize);

 		if(!iDataSectionMemory)

 			return KErrNoMemory;

 		}

 	iCodeSeg->iSize = codePageCount<<KPageShift;

 	// allocate virtual address for code to run at...

 	const TUint codeSize = codePageCount<<KPageShift;

 	if(iCodeSeg->IsExe())

 		{// Get the os asid without opening a reference on it as aProcess isn't fully 

 		// created yet so won't free its os asid.

 		r = MM::VirtualAlloc(aProcess->OsAsid(),iRamInfo.iCodeRunAddr,codeSize,isDemandPaged);

 		if(r!=KErrNone)

 			return r;

 		aProcess->iCodeVirtualAllocSize = codeSize;

 		aProcess->iCodeVirtualAllocAddress = iRamInfo.iCodeRunAddr;

 		iCodeSeg->iAttr |= ECodeSegAttAddrNotUnique;

 		}

 	else

 		{

 		r = MM::VirtualAllocCommon(iRamInfo.iCodeRunAddr,codeSize,isDemandPaged);

 		if(r!=KErrNone)

 			return r;

 		iVirtualAllocCommonSize = codeSize;

 		}

 	// create memory object for codeseg...

 	if(isDemandPaged)

 		{

 		// create memory object...

 		r = MM::PagedCodeNew(iCodeMemoryObject, codePageCount, iPagedCodeInfo);

 		if(r!=KErrNone)

 			return r;

 		// get file blockmap for codeseg contents...

 		r = iPagedCodeInfo->ReadBlockMap(aInfo);

 		if (r != KErrNone)

 			return r;

 		}

 	else

 		{

 		// create memory object...

 		TMemoryCreateFlags flags = (TMemoryCreateFlags)(EMemoryCreateNoWipe | EMemoryCreateAllowExecution);

 		r = MM::MemoryNew(iCodeMemoryObject, EMemoryObjectMovable, codePageCount, flags);

 		if(r!=KErrNone)

 			return r;

 		// commit memory...

 		r = MM::MemoryAlloc(iCodeMemoryObject,0,codePageCount);

 		if(r!=KErrNone)

 			return r;

 		}

 	// create a mapping of the memory for the loader...

 	// No need to open reference on os asid it is the current thread/process's.

 	DMemModelProcess* pP = (DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	r = MM::MappingNew(iCodeLoadMapping,iCodeMemoryObject,EUserReadWrite,pP->OsAsid());

 	if(r!=KErrNone)

 		return r;

 	iRamInfo.iCodeLoadAddr = MM::MappingBase(iCodeLoadMapping);

 	// work out where the loader is to put the loaded data section...

 	TInt loadSize = iRamInfo.iCodeSize; // size of memory filled by loader

 	if(iRamInfo.iDataSize)

 		{

 		if(!dataPageCount)

 			{

 			// data loaded immediately after code...

 			iRamInfo.iDataLoadAddr = iRamInfo.iCodeLoadAddr+iRamInfo.iCodeSize;

 			loadSize += iRamInfo.iDataSize;

 			}

 		else

 			{

 			// create memory object for data...

 			DMemoryObject* dataMemory;

 			r = MM::MemoryNew(dataMemory, EMemoryObjectMovable, dataPageCount, EMemoryCreateNoWipe);

 			if(r!=KErrNone)

 				return r;

 			// commit memory...

 			r = MM::MemoryAlloc(dataMemory,0,dataPageCount);

 			if(r==KErrNone)

 				{

 				// create a mapping of the memory for the loader...

 				// No need to open reference on os asid it is the current thread/process's.

 				r = MM::MappingNew(iDataLoadMapping,dataMemory,EUserReadWrite,pP->OsAsid());

 				}

 			if(r!=KErrNone)

 				{

 				MM::MemoryDestroy(dataMemory);

 				return r;

 				}

 			iRamInfo.iDataLoadAddr = MM::MappingBase(iDataLoadMapping);

 			}

 		}

 	if(!isDemandPaged)

 		{

 		// wipe memory that the loader wont fill...

 		UNLOCK_USER_MEMORY();

 		memset((TAny*)(iRamInfo.iCodeLoadAddr+loadSize), 0x03, codeSize-loadSize);

 		LOCK_USER_MEMORY();

 		}

 	// done...

 	iCreator = pP;

 	return KErrNone;

 	}

 TInt DMemModelCodeSegMemory::Loaded(TCodeSegCreateInfo& aInfo)

 	{

 	if(iPagedCodeInfo)

 		{

 		// get information needed to fixup code for it's run address...

 		TInt r = iPagedCodeInfo->ReadFixupTables(aInfo);

 		if(r!=KErrNone)

 			return r;

 		MM::PagedCodeLoaded(iCodeMemoryObject, iRamInfo.iCodeLoadAddr);

 		}

 	else

 		{

 		// make code visible to instruction cache...

 		UNLOCK_USER_MEMORY();

 		CacheMaintenance::CodeChanged(iRamInfo.iCodeLoadAddr, iRamInfo.iCodeSize);

 		LOCK_USER_MEMORY();

 		}

 	// adjust iDataLoadAddr to point to address contents for initial data section

 	// in running process...

 	if(iRamInfo.iDataLoadAddr)

 		{

 		TAny* dataSection = iDataSectionMemory;

 		if(dataSection)

 			{

 			// contents for initial data section to be stored in iDataSectionMemory...

 			UNLOCK_USER_MEMORY();

 			memcpy(dataSection,(TAny*)iRamInfo.iDataLoadAddr,iRamInfo.iDataSize);

 			LOCK_USER_MEMORY();

 			iRamInfo.iDataLoadAddr = (TLinAddr)dataSection;

 			}

 		else

 			{

 			// contents for initial data section stored after code...

 			__NK_ASSERT_DEBUG(iRamInfo.iDataLoadAddr==iRamInfo.iCodeLoadAddr+iRamInfo.iCodeSize); // check data loaded at end of code

 			iRamInfo.iDataLoadAddr = iRamInfo.iCodeRunAddr+iRamInfo.iCodeSize;

 			}

 		}

 	// copy export directory (this will now have fixups applied)...

 	TInt exportDirSize = iRamInfo.iExportDirCount * sizeof(TLinAddr);

 	if(exportDirSize > 0 || (exportDirSize==0 && (iCodeSeg->iAttr&ECodeSegAttNmdExpData)) )

 		{

 		exportDirSize += sizeof(TLinAddr);

 		TLinAddr* expDir = (TLinAddr*)Kern::Alloc(exportDirSize);

 		if(!expDir)

 			return KErrNoMemory;

 		iCopyOfExportDir = expDir;

 		TLinAddr expDirLoad = iRamInfo.iExportDir-iRamInfo.iCodeRunAddr+iRamInfo.iCodeLoadAddr;

 		UNLOCK_USER_MEMORY();

 		memcpy(expDir,(TAny*)(expDirLoad-sizeof(TLinAddr)),exportDirSize);

 		LOCK_USER_MEMORY();

 		}

 	// unmap code from loading process...

 	DMemModelProcess* pP=(DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	__ASSERT_ALWAYS(iCreator==pP, MM::Panic(MM::ECodeSegLoadedNotCreator));

 	MM::MappingDestroy(iCodeLoadMapping);

 	MM::MappingAndMemoryDestroy(iDataLoadMapping);

 	iCreator=NULL;

 	// Mark the code memory object read only to prevent malicious code modifying it.

 	TInt r = MM::MemorySetReadOnly(iCodeMemoryObject);

 	__ASSERT_ALWAYS(r == KErrNone, MM::Panic(MM::ECodeSegSetReadOnlyFailure));

 	return KErrNone;

 	}

 void DMemModelCodeSegMemory::Destroy()

 	{

 	MM::MappingDestroy(iCodeLoadMapping);

 	MM::MappingAndMemoryDestroy(iDataLoadMapping);

 	}

 DMemModelCodeSegMemory::~DMemModelCodeSegMemory()

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelCodeSegMemory::~DMemModelCodeSegMemory %x", this));

 	__NK_ASSERT_DEBUG(iAccessCount==0);

 	MM::MappingDestroy(iCodeLoadMapping);

 	MM::MappingAndMemoryDestroy(iDataLoadMapping);

 	MM::MemoryDestroy(iCodeMemoryObject);

 	if(iVirtualAllocCommonSize)

 		MM::VirtualFreeCommon(iRamInfo.iCodeRunAddr, iVirtualAllocCommonSize);

 	Kern::Free(iCopyOfExportDir);

 	Kern::Free(iDataSectionMemory);

 	}

 //

 // DMemModelCodeSeg

 //

 DMemModelCodeSeg::DMemModelCodeSeg()

 	{

 	}

 DMemModelCodeSeg::~DMemModelCodeSeg()

 	{

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

 	DCodeSeg::Wait();

 	MM::MappingDestroy(iCodeLoadMapping);

 	MM::MappingDestroy(iCodeGlobalMapping);

 	MM::MemoryDestroy(iCodeMemoryObject);

 	if(Memory())

 		Memory()->Destroy();

 	if(iDataAllocSize)

 		MM::VirtualFreeCommon(iDataAllocBase,iDataAllocSize);

 	DCodeSeg::Signal();

 	Kern::Free(iKernelData);

 	DEpocCodeSeg::Destruct();

 	}

 TInt DMemModelCodeSeg::DoCreateRam(TCodeSegCreateInfo& aInfo, DProcess* aProcess)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelCodeSeg::DoCreateRam %C", this));

 	SRamCodeInfo& ri = RamInfo();

 	iSize = MM::RoundToPageSize(ri.iCodeSize+ri.iDataSize);

 	if (iSize==0)

 		return KErrCorrupt;

 	TBool kernel = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );

 //	TBool user_global = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttGlobal );

 	TBool user_local = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == 0 );

 	TUint total_data_size = ri.iDataSize+ri.iBssSize;

 	if(user_local)

 		{

 		// setup paging attribute for code...

 		if(aInfo.iUseCodePaging)

 			iAttr |= ECodeSegAttCodePaged;

 		if(total_data_size && !IsExe())

 			{

 			// setup paging attribute for data section...

 			if(aInfo.iUseCodePaging)

 				if(K::MemModelAttributes & EMemModelAttrDataPaging)

 					iAttr |= ECodeSegAttDataPaged;

 			// allocate virtual address for data section...

 			TInt r = MM::VirtualAllocCommon(iDataAllocBase,total_data_size,iAttr&ECodeSegAttDataPaged);

 			if(r!=KErrNone)

 				return r;

 			iDataAllocSize = total_data_size;

 			ri.iDataRunAddr = iDataAllocBase;

 			}

 		// create DCodeSegMemory for RAM loaded user local code...

 		TInt r = Memory()->Create(aInfo,(DMemModelProcess*)aProcess);

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 		if (r == KErrNone)

 			{

 			BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsCodeSeg,Memory()->iCodeMemoryObject,this);

 			}

 #endif

 		return r;

 		}

 	// kernel or user-global code...

 	// create memory object for codeseg...

 	TMemoryCreateFlags flags = EMemoryCreateAllowExecution;

 	if(kernel)

 		{

 		flags = (TMemoryCreateFlags)(flags|EMemoryCreateNoWipe);

 		}

 	TInt r = MM::MemoryNew(iCodeMemoryObject, EMemoryObjectMovable, MM::BytesToPages(iSize), flags);

 	if(r!=KErrNone)

 		return r;

 	// commit memory...

 	r = MM::MemoryAlloc(iCodeMemoryObject,0,MM::BytesToPages(iSize));

 	if(r!=KErrNone)

 		return r;

 	// create a mapping of the memory for the loader...

 	// No need to open reference on os asid it is the current thread/process's.

 	DMemModelProcess* pP = (DMemModelProcess*)TheCurrentThread->iOwningProcess;

 	r = MM::MappingNew(iCodeLoadMapping,iCodeMemoryObject,EUserReadWrite,pP->OsAsid());

 	if(r!=KErrNone)

 		return r;

 	ri.iCodeLoadAddr = MM::MappingBase(iCodeLoadMapping);

 	// create a global mapping of the memory for the codeseg to run at...

 	r = MM::MappingNew(iCodeGlobalMapping,iCodeMemoryObject,kernel?ESupervisorExecute:EUserExecute,KKernelOsAsid);

 	if(r!=KErrNone)

 		return r;

 	ri.iCodeRunAddr = MM::MappingBase(iCodeGlobalMapping);

 	if(kernel)

 		{

 		// setup data section memory...

 		if (ri.iDataSize)

 			ri.iDataLoadAddr = ri.iCodeLoadAddr+ri.iCodeSize;

 		if (total_data_size)

 			{

 			iKernelData = Kern::Alloc(total_data_size);

 			if (!iKernelData)

 				return KErrNoMemory;

 			ri.iDataRunAddr = (TLinAddr)iKernelData;

 			}

 		}

 	else

 		{

 		// we don't allow static data in global code...

 		ri.iDataLoadAddr = 0;

 		ri.iDataRunAddr = 0;

 		}

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 	BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsCodeSeg,iCodeMemoryObject,this);

 #endif

 	// done...

 	return KErrNone;

 	}

 TInt DMemModelCodeSeg::DoCreateXIP(DProcess* aProcess)

 	{

 //	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelCodeSeg::DoCreateXIP %C proc %O", this, aProcess));

 	return KErrNone;

 	}

 TInt DMemModelCodeSeg::Loaded(TCodeSegCreateInfo& aInfo)

 	{

 	if(iXIP)

 		return DEpocCodeSeg::Loaded(aInfo);

 	TBool kernel = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );

 	TBool user_global = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttGlobal );

 	TBool user_local = ( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == 0 );

 	if(user_local)

 		{

 		TInt r = Memory()->Loaded(aInfo);

 		if(r!=KErrNone)

 			return r;

 		}

 	else if((kernel && iExeCodeSeg!=this) || user_global)

 		{

 		// user-global or kernel code...

 		SRamCodeInfo& ri = RamInfo();

 		UNLOCK_USER_MEMORY();

 		CacheMaintenance::CodeChanged(ri.iCodeLoadAddr, ri.iCodeSize);

 		LOCK_USER_MEMORY();

 		MM::MappingDestroy(iCodeLoadMapping);

 		// adjust iDataLoadAddr to point to address contents for initial data section

 		// in running process...

 		if(ri.iDataLoadAddr)

 			ri.iDataLoadAddr = ri.iCodeRunAddr+ri.iCodeSize;

 		// Mark the code memory object read only to prevent malicious code modifying it.

 		TInt r = MM::MemorySetReadOnly(iCodeMemoryObject);

 		__ASSERT_ALWAYS(r == KErrNone, MM::Panic(MM::ECodeSegSetReadOnlyFailure));

 		}

 	return DEpocCodeSeg::Loaded(aInfo);

 	}

 void DMemModelCodeSeg::ReadExportDir(TUint32* aDest)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelCodeSeg::ReadExportDir %C %08x",this, aDest));

 	if(!iXIP)

 		{

 		// This is not XIP code so the loader can't access the export directory. 

 		if (Memory()->iCopyOfExportDir)

 			{// This must be local user side code.

 			__NK_ASSERT_DEBUG((iAttr & (ECodeSegAttKernel|ECodeSegAttGlobal)) == 0);

 			// Copy the kernel's copy of the export directory for this code seg to the loader's buffer.

 			SRamCodeInfo& ri = RamInfo();

 			TInt size = (ri.iExportDirCount + 1) * sizeof(TLinAddr);

 			kumemput(aDest, Memory()->iCopyOfExportDir, size);

 			}

 		else

 			{// This must be kernel side code.

 			__NK_ASSERT_DEBUG((iAttr & (ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel);

 			// Copy the export directory for this code seg to the loader's buffer.

 			SRamCodeInfo& ri = RamInfo();

 			TInt size = (ri.iExportDirCount + 1) * sizeof(TLinAddr);

 			TAny* expDirLoad = (TAny*)(ri.iExportDir - sizeof(TLinAddr));

 			kumemput(aDest, expDirLoad, size);

 			}

 		}

 	}

 TBool DMemModelCodeSeg::OpenCheck(DProcess* aProcess)

 	{

 	return FindCheck(aProcess);

 	}

 TBool DMemModelCodeSeg::FindCheck(DProcess* aProcess)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("CSEG:%08x Compat? proc=%O",this,aProcess));

 	if (aProcess)

 		{

 		DMemModelProcess& p=*(DMemModelProcess*)aProcess;

 		DCodeSeg* pPSeg=p.CodeSeg();

 		if (iAttachProcess && iAttachProcess!=aProcess)

 			return EFalse;

 		if (iExeCodeSeg && iExeCodeSeg!=pPSeg)

 			return EFalse;

 		}

 	return ETrue;

 	}

 void DMemModelCodeSeg::BTracePrime(TInt aCategory)

 	{

 	DCodeSeg::BTracePrime(aCategory);

 #ifdef BTRACE_FLEXIBLE_MEM_MODEL

 	if (aCategory == BTrace::EFlexibleMemModel || aCategory == -1)

 		{

 		// code seg mutex is held here, so memory objects cannot be destroyed

 		DMemModelCodeSegMemory* codeSegMemory = Memory();

 		if (codeSegMemory)

 			{

 			if (codeSegMemory->iCodeMemoryObject)

 				{

 				BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsCodeSeg,Memory()->iCodeMemoryObject,this);

 				}

 			}

 		else

 			{

 			if (iCodeMemoryObject)

 				{

 				BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsCodeSeg,iCodeMemoryObject,this);

 				}

 			}

 		}

 #endif	

 	}

 //

 // TPagedCodeInfo

 //

 TPagedCodeInfo::~TPagedCodeInfo()

 	{

 	Kern::Free(iCodeRelocTable);

 	Kern::Free(iCodePageOffsets);

 	}

 TInt TPagedCodeInfo::ReadBlockMap(const TCodeSegCreateInfo& aInfo)

 	{

 	if(aInfo.iCodeBlockMapEntriesSize <= 0)

 		return KErrArgument;  // no block map provided

 	// get compression data...

 	iCompressionType = aInfo.iCompressionType;

 	switch(iCompressionType)

 		{

 	case KFormatNotCompressed:

 		__ASSERT_COMPILE(KFormatNotCompressed==0); // Decompress() assumes this

 		break;

 	case KUidCompressionBytePair:

 		{

 		if(!aInfo.iCodePageOffsets)

 			return KErrArgument;

 		TInt pageCount = MM::RoundToPageCount(aInfo.iCodeSize);

 		TInt size = sizeof(TInt32) * (pageCount + 1);

 		iCodePageOffsets = (TInt32*)Kern::Alloc(size);

 		if(!iCodePageOffsets)

 			return KErrNoMemory;

 		kumemget32(iCodePageOffsets, aInfo.iCodePageOffsets, size);

 #ifdef __DUMP_BLOCKMAP_INFO

 		Kern::Printf("CodePageOffsets:");

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

 			Kern::Printf("  %08x", iCodePageOffsets[i]);

 #endif

 		TInt last = 0;

 		for(TInt j=0; j<pageCount+1; ++j)

 			{

 			if(iCodePageOffsets[j] < last ||

 				iCodePageOffsets[j] > (aInfo.iCodeLengthInFile + aInfo.iCodeStartInFile))

 				{

 				__NK_ASSERT_DEBUG(0);

 				return KErrCorrupt;

 				}

 			last = iCodePageOffsets[j];

 			}

 		}

 		break;

 	default:

 		return KErrNotSupported;

 		}

 	// Copy block map data itself...

 #ifdef __DUMP_BLOCKMAP_INFO

 	Kern::Printf("Original block map");

 	Kern::Printf("  block granularity: %d", aInfo.iCodeBlockMapCommon.iBlockGranularity);

 	Kern::Printf("  block start offset: %x", aInfo.iCodeBlockMapCommon.iBlockStartOffset);

 	Kern::Printf("  start block address: %016lx", aInfo.iCodeBlockMapCommon.iStartBlockAddress);

 	Kern::Printf("  local drive number: %d", aInfo.iCodeBlockMapCommon.iLocalDriveNumber);

 	Kern::Printf("  entry size: %d", aInfo.iCodeBlockMapEntriesSize);

 #endif

 	// Find relevant paging device

 	iCodeLocalDrive = aInfo.iCodeBlockMapCommon.iLocalDriveNumber;

 	if(TUint(iCodeLocalDrive) >= (TUint)KMaxLocalDrives)

 		{

 		__KTRACE_OPT(KPAGING,Kern::Printf("Bad local drive number"));

 		return KErrArgument;

 		}

 	DPagingDevice* device = CodePagingDevice(iCodeLocalDrive);

 	if(!device)

 		{

 		__KTRACE_OPT(KPAGING,Kern::Printf("No paging device installed for drive"));

 		return KErrNotSupported;

 		}

 	// Set code start offset

 	iCodeStartInFile = aInfo.iCodeStartInFile;

 	if(iCodeStartInFile < 0)

 		{

 		__KTRACE_OPT(KPAGING,Kern::Printf("Bad code start offset"));

 		return KErrArgument;

 		}

 	// Allocate buffer for block map and copy from user-side

 	TBlockMapEntryBase* buffer = (TBlockMapEntryBase*)Kern::Alloc(aInfo.iCodeBlockMapEntriesSize);

 	if(!buffer)

 		return KErrNoMemory;

 	kumemget32(buffer, aInfo.iCodeBlockMapEntries, aInfo.iCodeBlockMapEntriesSize);

 #ifdef __DUMP_BLOCKMAP_INFO

 	Kern::Printf("  entries:");

 	for (TInt k = 0 ; k < aInfo.iCodeBlockMapEntriesSize / sizeof(TBlockMapEntryBase) ; ++k)

 		Kern::Printf("    %d: %d blocks at %08x", k, buffer[k].iNumberOfBlocks, buffer[k].iStartBlock);

 #endif

 	// Initialise block map

 	TInt r = iBlockMap.Initialise(aInfo.iCodeBlockMapCommon,

 								  buffer,

 								  aInfo.iCodeBlockMapEntriesSize,

 								  device->iReadUnitShift,

 								  iCodeStartInFile + aInfo.iCodeLengthInFile);

 	if(r!=KErrNone)

 		{

 		Kern::Free(buffer);

 		return r;

 		}

 #if defined(__DUMP_BLOCKMAP_INFO) && defined(_DEBUG)

 	iBlockMap.Dump();

 #endif

 	iCodeSize = aInfo.iCodeSize;

 	return KErrNone;

 	}

 /**

 Read code relocation table and import fixup table from user side.

 */

 TInt TPagedCodeInfo::ReadFixupTables(const TCodeSegCreateInfo& aInfo)

 	{

 	iCodeRelocTableSize = aInfo.iCodeRelocTableSize;

 	iImportFixupTableSize = aInfo.iImportFixupTableSize;

 	iCodeDelta = aInfo.iCodeDelta;

 	iDataDelta = aInfo.iDataDelta;

 	// round sizes up to four-byte boundaries...

 	TUint relocSize = (iCodeRelocTableSize + 3) & ~3;

 	TUint fixupSize = (iImportFixupTableSize + 3) & ~3;

 	// copy relocs and fixups...

 	iCodeRelocTable = (TUint8*)Kern::Alloc(relocSize+fixupSize);

 	if (!iCodeRelocTable)

 		return KErrNoMemory;

 	iImportFixupTable = iCodeRelocTable + relocSize;

 	kumemget32(iCodeRelocTable, aInfo.iCodeRelocTable, relocSize);

 	kumemget32(iImportFixupTable, aInfo.iImportFixupTable, fixupSize);

 	return KErrNone;

 	}

 void TPagedCodeInfo::ApplyFixups(TLinAddr aBuffer, TUint iIndex)

 	{

 //	START_PAGING_BENCHMARK;

 	// relocate code...

 	if(iCodeRelocTableSize)

 		{

 		TUint8* codeRelocTable = iCodeRelocTable;

 		TUint startOffset = ((TUint32*)codeRelocTable)[iIndex];

 		TUint endOffset = ((TUint32*)codeRelocTable)[iIndex+1];

 		__KTRACE_OPT(KPAGING, Kern::Printf("Performing code relocation: start == %x, end == %x", startOffset, endOffset));

 		__ASSERT_ALWAYS(startOffset<=endOffset && endOffset<=iCodeRelocTableSize, K::Fault(K::ECodeSegBadFixupTables));

 		const TUint32 codeDelta = iCodeDelta;

 		const TUint32 dataDelta = iDataDelta;

 		const TUint16* ptr = (const TUint16*)(codeRelocTable + startOffset);

 		const TUint16* end = (const TUint16*)(codeRelocTable + endOffset);

 		while(ptr<end)

 			{

 			TUint16 entry = *ptr++;

 			TUint32* addr = (TUint32*)(aBuffer+(entry&0x0fff));

 			TUint32 word = *addr;

 #ifdef _DEBUG

 			TInt type = entry&0xf000;

 			__NK_ASSERT_DEBUG(type==KTextRelocType || type==KDataRelocType);

 #endif

 			if(entry<KDataRelocType)

 				word += codeDelta;

 			else

 				word += dataDelta;

 			*addr = word;

 			}

 		}

 	// fixup imports...

 	if(iImportFixupTableSize)

 		{

 		TUint8* importFixupTable = iImportFixupTable;

 		TUint startOffset = ((TUint32*)importFixupTable)[iIndex];

 		TUint endOffset = ((TUint32*)importFixupTable)[iIndex+1];

 		__KTRACE_OPT(KPAGING, Kern::Printf("Performing import fixup: start == %x, end == %x", startOffset, endOffset));

 		__ASSERT_ALWAYS(startOffset<=endOffset && endOffset<=iImportFixupTableSize, K::Fault(K::ECodeSegBadFixupTables));

 		const TUint16* ptr = (const TUint16*)(importFixupTable + startOffset);

 		const TUint16* end = (const TUint16*)(importFixupTable + endOffset);

 		while(ptr<end)

 			{

 			TUint16 offset = *ptr++;

 			TUint32 wordLow = *ptr++;

 			TUint32 wordHigh = *ptr++;

 			TUint32 word = (wordHigh << 16) | wordLow;

 //			__KTRACE_OPT(KPAGING, Kern::Printf("DP: Fixup %08x=%08x", iRamInfo.iCodeRunAddr+(page<<KPageShift)+offset, word));

 			*(TUint32*)(aBuffer+offset) = word;

 			}

 		}

 //	END_PAGING_BENCHMARK(DemandPaging::ThePager, EPagingBmFixupCodePage);

 	}