// 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\moving\mcodeseg.cpp

// 

//

#include "memmodel.h"

#include "cache_maintenance.h"

#include <demand_paging.h>

_LIT(KLitUserCode,"USER$CODE");

_LIT(KLitKernCode,"KERN$CODE");

TInt MM::CreateCodeChunk(TBool aKernel)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("MM::CreateCodeChunk %d",aKernel));

	Mmu& m = Mmu::Get();

	SChunkCreateInfo c;

	c.iGlobal = ETrue;

	c.iAtt = TChunkCreate::EDisconnected;

	c.iForceFixed = EFalse;

	c.iOperations = 0;

	c.iPreallocated = 0;

	c.iOwner = NULL;

	if (aKernel)

		{

		c.iRunAddress = m.iKernelCodeBase;

		c.iType = EKernelCode;

		c.iMaxSize = m.iMaxKernelCodeSize;

		c.iName.Set(KLitKernCode);

		}

	else

		{

		c.iRunAddress = m.iUserCodeBase;

		c.iType = EDll;

		c.iMaxSize = m.iMaxUserCodeSize;

		c.iName.Set(KLitUserCode);

		}

	TLinAddr runAddr;

	DMemModelChunk* pC = NULL;

	TInt r=K::TheKernelProcess->NewChunk((DChunk*&)pC, c, runAddr);

	if (r==KErrNone)

		{

		pC->SetFixedAddress(c.iRunAddress, 0);

		if (aKernel)

			MM::KernelCodeChunk = pC;

		else

			MM::UserCodeChunk = pC;

		}

	return r;

	}

DCodeSeg* M::NewCodeSeg(TCodeSegCreateInfo&)

//

// Create a new instance of this class.

//

	{

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

	return new DMemModelCodeSeg;

	}

DEpocCodeSegMemory* DEpocCodeSegMemory::New(DEpocCodeSeg* aCodeSeg)

	{

	return new DMemModelCodeSegMemory(aCodeSeg);

	}

DMemModelCodeSegMemory::DMemModelCodeSegMemory(DEpocCodeSeg* aCodeSeg)

	: DMmuCodeSegMemory(aCodeSeg)

	{

	}

TInt DMemModelCodeSegMemory::Create(TCodeSegCreateInfo& aInfo)

	{

	TInt r = DMmuCodeSegMemory::Create(aInfo);

	if(r!=KErrNone)

		return r;

	Mmu& m=Mmu::Get();

	TInt codeSize = iPageCount<<m.iPageShift;

	TInt dataSize = iDataPageCount<<m.iPageShift;

	TInt totalSize = codeSize+dataSize;

	DCodeSeg::Wait();

	DChunk::TCommitType commitType = iIsDemandPaged ? DChunk::ECommitVirtual : DChunk::ECommitDiscontiguous;

	r=MM::UserCodeChunk->FindFree(totalSize, 0, 0);

	if (r<0)

		{

		r = KErrNoMemory;

		goto exit;

		}

	iCodeAllocBase = r;

	r = KErrNone;

	r=MM::UserCodeChunk->Commit(iCodeAllocBase, codeSize, commitType);

	if (r<0)

		{

		r = KErrNoMemory;

		goto exit;

		}

	iRamInfo.iCodeRunAddr = ((TLinAddr)MM::UserCodeChunk->Base())+iCodeAllocBase;

	iRamInfo.iCodeLoadAddr = iRamInfo.iCodeRunAddr;

	if (iRamInfo.iDataSize)

		{

		if(iDataPageCount)

			iRamInfo.iDataLoadAddr = iRamInfo.iCodeLoadAddr+codeSize;

		else

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

		}

	if (!iIsDemandPaged)

		{

		TInt loadedSize = iRamInfo.iCodeSize+iRamInfo.iDataSize;

		memset((TAny*)(iRamInfo.iCodeLoadAddr+loadedSize), 0x03, totalSize-loadedSize);

		}

	else

		{

		if(dataSize)

			{

			r=MM::UserCodeChunk->Commit(iCodeAllocBase+codeSize, dataSize, DChunk::ECommitDiscontiguous);

			if (r<0)

				goto exit;

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

			}

		}

exit:

	DCodeSeg::Signal();

	return r;

	}

TInt DMemModelCodeSegMemory::Loaded(TCodeSegCreateInfo& aInfo)

	{

	TInt r = DMmuCodeSegMemory::Loaded(aInfo);

	if(r!=KErrNone)

		return r;

	Mmu& m=Mmu::Get();

	TInt pageShift = m.iPageShift;

	if(iIsDemandPaged)

		{

		// apply code fixups to pages which have already been loaded...

		TLinAddr loadAddr = iRamInfo.iCodeLoadAddr;

		TLinAddr loadAddrEnd = loadAddr+iRamInfo.iCodeSize;

		TLinAddr runAddr = iRamInfo.iCodeLoadAddr;

		TInt pageSize = 1<<pageShift;

		for(; loadAddr<loadAddrEnd; loadAddr+=pageSize,runAddr+=pageSize)

			{

			if(m.LinearToPhysical(loadAddr)!=KPhysAddrInvalid)

				{

				r = ApplyCodeFixupsOnLoad((TUint32*)loadAddr,runAddr);

				if(r!=KErrNone)

					return r;

				}

			}

		}

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

	// discard any temporary pages used to store loaded data section...

	if(iDataPageCount)

		{

		TInt codeSize = iPageCount<<pageShift;

		MM::UserCodeChunk->Decommit(iCodeAllocBase+codeSize, iDataPageCount<<pageShift);

		iDataPageCount = 0;

		//Reduce the size of the DCodeSeg now the data section has been moved

		iCodeSeg->iSize = codeSize;

		}

	return KErrNone;

	}

void DMemModelCodeSegMemory::Destroy()

	{

	if(iCodeAllocBase!=KMinTInt && iDataPageCount)

		{

		Mmu& m=Mmu::Get();

		TInt dataSize = iDataPageCount<<m.iPageShift;

		TInt codeSize = iPageCount<<m.iPageShift;

		if(dataSize)

			MM::UserCodeChunk->Decommit(iCodeAllocBase+codeSize, dataSize);

		}

	}

DMemModelCodeSegMemory::~DMemModelCodeSegMemory()

	{

	if(iCodeAllocBase!=KMinTInt)

		{

		Mmu& m=Mmu::Get();

		TInt codeSize = iPageCount<<m.iPageShift;

		DMemModelChunk::TDecommitType decommitType = iIsDemandPaged ? DChunk::EDecommitVirtual : DChunk::EDecommitNormal;

		MM::UserCodeChunk->Decommit(iCodeAllocBase, codeSize, decommitType);

		}

	}

DMemModelCodeSeg::DMemModelCodeSeg()

//

// Constructor

//

	:	iCodeAllocBase(KMinTInt),

		iDataAllocBase(KMinTInt)

	{

	}

DMemModelCodeSeg::~DMemModelCodeSeg()

//

// Destructor

//

	{

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

	Mmu& m=Mmu::Get();

	if (!iXIP && iMemory)

		{

		SRamCodeInfo& ri=RamInfo();

		DCodeSeg::Wait();

		if (iCodeAllocBase!=KMinTInt)

			{

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

			if (kernel)

				MM::KernelCodeChunk->Decommit(iCodeAllocBase, iSize);

			}

		Memory()->Destroy();

		TInt data_alloc=(ri.iDataSize+ri.iBssSize+m.iPageMask)>>m.iPageShift;

		if (iDataAllocBase>=0)

			{

			MM::DllDataAllocator->Free(iDataAllocBase, data_alloc);

			}

		else if (iDataAllocBase==-1)

			{

			DMemModelProcess* p=(DMemModelProcess*)iAttachProcess;

			if (p->iExitType==EExitPending)

				{

				DMemModelChunk& c=*p->iDllDataChunk;

				TInt offset=ri.iDataRunAddr-TLinAddr(c.Base());

				c.Decommit(offset, data_alloc<<m.iPageShift);

				if (c.iSize==0)

					p->FreeDllDataChunk();

				}

			}

		DCodeSeg::Signal();

		}

	Kern::Free(iKernelData);

	DEpocCodeSeg::Destruct();

	}

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

	{

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

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

	DMemModelProcess* p=(DMemModelProcess*)aProcess;

	Mmu& m=Mmu::Get();

	SRamCodeInfo& ri=RamInfo();

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

	if (iSize==0)

		return KErrCorrupt;

	TInt total_data_size=ri.iDataSize+ri.iBssSize;

	TInt r=KErrNone;

	if (kernel)

		{

		r=MM::KernelCodeChunk->Allocate(iSize, 0, 0);

		if (r<0)

			return r;

		iCodeAllocBase=r;

		ri.iCodeRunAddr=(TUint32)MM::KernelCodeChunk->Base();

		ri.iCodeRunAddr+=r;

		ri.iCodeLoadAddr=ri.iCodeRunAddr;

		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;

			}

		return KErrNone;

		}

	r = Memory()->Create(aInfo);

	if(r!=KErrNone)

		return r;

	r=KErrNone;

	if (total_data_size && p && p->iAttributes&DMemModelProcess::EFixedAddress)

		{

		SetAttachProcess(p);

		}

	if (total_data_size && !IsExe())

		{

		TInt data_alloc_size=Mmu::RoundToPageSize(total_data_size);

		TInt data_alloc=data_alloc_size>>m.iPageShift;

		DCodeSeg::Wait();

		if (p)

			{

			if (p->iExitType!=EExitPending)

				return KErrDied;

			}

		if (iAttachProcess)

			{

			r=KErrNone;

			if (!p->iDllDataChunk)

				r=p->CreateDllDataChunk();

			if (r==KErrNone)

				{

				DMemModelChunk& c=*p->iDllDataChunk;

				r=c.Allocate(data_alloc_size, 0, 0);

				if (r>=0)

					{

					ri.iDataRunAddr=TLinAddr(c.Base())+r;

					iDataAllocBase=-1;

					r=KErrNone;

					}

				else

					{

					if (c.iSize==0)

						p->FreeDllDataChunk();

					r=KErrNoMemory;

					}

				}

			}

		else

			{

			r=MM::DllDataAllocator->AllocConsecutive(data_alloc, ETrue);

			if (r>=0)

				MM::DllDataAllocator->Alloc(r, data_alloc);

			if (r>=0)

				{

				iDataAllocBase=r;

				ri.iDataRunAddr=m.iDataSectionEnd-((r+data_alloc)<<m.iPageShift);

				r=KErrNone;

				}

			else

				r=KErrNoMemory;

			}

		DCodeSeg::Signal();

		}

	if(r!=KErrNone)

		return r;

	return r;

	}

TInt DMemModelCodeSeg::DoCreateXIP(DProcess* aProcess)

	{

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

	DMemModelProcess* p=(DMemModelProcess*)aProcess;

	TInt r=KErrNone;

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

	const TRomImageHeader& rih=RomInfo();

	TBool fixed=p && (p->iAttributes&DMemModelProcess::EFixedAddress);

	if (!kernel && fixed)

		{

		// XIP images with static data loaded into fixed processes are specific to a single process

		if (rih.iFlags&KRomImageFlagDataPresent)

			{

			if (rih.iTotalDataSize)

				{

				TLinAddr process_data_base=p->iDataBssRunAddress;

				TUint32 process_data_maxsize=p->iDataBssStackChunk->iMaxSize;

				if (rih.iDataBssLinearBase<process_data_base || 

					(rih.iDataBssLinearBase+rih.iTotalDataSize)>(process_data_base+process_data_maxsize))

					return KErrNotSupported;

				}

			SetAttachProcess(p);

			iDataAllocBase=-1;

			}

		}

	return r;

	}

TInt DMemModelCodeSeg::Loaded(TCodeSegCreateInfo& aInfo)

	{

	if (!iXIP)

		{

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

		if(kernel)

			{

			// Clean DCache for specified area, Invalidate ICache/BTB for specified area

			SRamCodeInfo& ri=RamInfo();

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

			}

		else

			{

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

			if(r!=KErrNone)

				return r;

			}

		}

	return DEpocCodeSeg::Loaded(aInfo);

	}

void DMemModelCodeSeg::ReadExportDir(TUint32* aDest)

	{

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

	if (!iXIP)

		{

		SRamCodeInfo& ri=RamInfo();

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

		kumemput32(aDest, (const TUint32*)(ri.iExportDir-sizeof(TUint32)), 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)

		return !iAttachProcess;	// can't reuse same code segment for a new instance of the process

	DMemModelProcess& p=*(DMemModelProcess*)aProcess;

	DCodeSeg* pPSeg=p.CodeSeg();

	if (iAttachProcess && iAttachProcess!=aProcess)

		return EFalse;

	if (iExeCodeSeg && iExeCodeSeg!=pPSeg)

		return EFalse;

	if (!iAttachProcess && (iMark & EMarkDataPresent))

		{

		// code seg used for moving processes, data present

		if (p.iAttributes & DMemModelProcess::EFixedAddress)

			return EFalse;

		}

	return ETrue;

	}