// Copyright (c) 1994-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\mprocess.cpp

// 

//

#include "memmodel.h"

#include "cache_maintenance.h"

#include "mmboot.h"

#define iMState		iWaitLink.iSpare1

_LIT(KDollarDat,"$DAT");

_LIT(KLitDllDollarData,"DLL$DATA");

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

 * Process

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

void DMemModelProcess::Destruct()

	{

	NKern::LockSystem();

	if (this==TheCurrentAddressSpace)

		TheCurrentAddressSpace=NULL;

	if (this==TheCurrentVMProcess)

		TheCurrentVMProcess=NULL;

	if (this==TheCurrentDataSectionProcess)

		TheCurrentDataSectionProcess=NULL;

	if (this==TheCompleteDataSectionProcess)

		TheCompleteDataSectionProcess=NULL;

	NKern::UnlockSystem();

	DProcess::Destruct();

	}

TInt DMemModelProcess::NewChunk(DChunk*& aChunk, SChunkCreateInfo& aInfo, TLinAddr& aRunAddr)

	{

	aChunk=NULL;

	DMemModelChunk* pC=NULL;

	TInt r=GetNewChunk(pC,aInfo);

	if (r!=KErrNone)

		{

		if (pC)

			pC->Close(NULL);

		return r;

		}

	if (aInfo.iForceFixed || iAttributes & DMemModelProcess::EFixedAddress)

		pC->iAttributes |= DMemModelChunk::EFixedAddress;

	if (!aInfo.iGlobal && (iAttributes & DMemModelProcess::EPrivate)!=0)

		pC->iAttributes |= DMemModelChunk::EPrivate;

	if (pC->iChunkType==EDll || pC->iChunkType==EUserCode || pC->iChunkType==EUserSelfModCode || pC->iChunkType==EKernelCode)

		pC->iAttributes |= (DMemModelChunk::EFixedAddress|DMemModelChunk::ECode);

	pC->iOwningProcess=(aInfo.iGlobal)?NULL:this;

	r=pC->Create(aInfo);

	if (r==KErrNone && (aInfo.iOperations & SChunkCreateInfo::EAdjust))

		{

		if (aInfo.iRunAddress!=0)

			pC->SetFixedAddress(aInfo.iRunAddress,aInfo.iPreallocated);

		if (aInfo.iPreallocated==0)

			{

			if (pC->iAttributes & DChunk::EDisconnected)

				{

				r=pC->Commit(aInfo.iInitialBottom,aInfo.iInitialTop-aInfo.iInitialBottom);

				}

			else if (pC->iAttributes & DChunk::EDoubleEnded)

				{

				r=pC->AdjustDoubleEnded(aInfo.iInitialBottom,aInfo.iInitialTop);

				}

			else

				{

				r=pC->Adjust(aInfo.iInitialTop);

				}

			}

		if (r==KErrNone && pC->iHomeRegionBase==0 && (pC->iAttributes&DMemModelChunk::EFixedAddress)!=0)

			{

			r=pC->Reserve(0);

			aRunAddr=(TLinAddr)pC->Base();

			}

		}

	if (r==KErrNone && (aInfo.iOperations & SChunkCreateInfo::EAdd))

		{

		if (pC->iAttributes & DMemModelChunk::ECode)

			Mmu::Get().SyncCodeMappings();

		if (pC->iChunkType!=EUserCode)

			{

			r=WaitProcessLock();

			if (r==KErrNone)

				{

				r=AddChunk(pC,aRunAddr,EFalse);

				SignalProcessLock();

				}

			}

		else

			aRunAddr=(TLinAddr)pC->Base();	// code chunks always fixed address

		}

	if (r==KErrNone)

		{

		pC->iDestroyedDfc = aInfo.iDestroyedDfc;

		aChunk=(DChunk*)pC;

		}

	else

		pC->Close(NULL);	// NULL since chunk can't have been added to process

	return r;

	}

TInt DMemModelProcess::DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo)

	{

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DoCreate %O",this));

	if (aKernelProcess)

		iAttributes=ESupervisor|EFixedAddress|EPrivate;

	else if (aInfo.iAttr & ECodeSegAttFixed)

		iAttributes=EFixedAddress|EPrivate;

	else

		iAttributes=0;

	if ((iAttributes & ESupervisor)==0 && (iAttributes & EFixedAddress)!=0)

		{

		CheckForFixedAccess();

		}

	return KErrNone;

	}

TInt DMemModelProcess::CreateDataBssStackArea(TProcessCreateInfo& aInfo)

	{

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::CreateDataBssStackArea %O",this));

	TInt dataBssSize=Mmu::RoundToPageSize(aInfo.iTotalDataSize);

	TInt maxSize=dataBssSize+PP::MaxStackSpacePerProcess;

	TBool fixed=(iAttributes & EFixedAddress);

	__KTRACE_OPT(KPROC,Kern::Printf("DataBssSize=%x, chunk max size %x",dataBssSize,maxSize));

	SChunkCreateInfo cinfo;

	cinfo.iGlobal=EFalse;

	cinfo.iAtt=TChunkCreate::EDisconnected;

	cinfo.iForceFixed=EFalse;

	cinfo.iOperations=SChunkCreateInfo::EAdjust|SChunkCreateInfo::EAdd;

	cinfo.iType=EUserData;

	cinfo.iMaxSize=maxSize;

	cinfo.iInitialBottom=0;

	cinfo.iInitialTop=dataBssSize;

	cinfo.iPreallocated=0;

	cinfo.iName.Set(KDollarDat);

	cinfo.iOwner=this;

	if (fixed && dataBssSize!=0 && aInfo.iCodeLoadAddress)

		{

		const TRomImageHeader& rih=*(const TRomImageHeader*)aInfo.iCodeLoadAddress;

		cinfo.iRunAddress=rih.iDataBssLinearBase;

		}

	else

		cinfo.iRunAddress=0;

	TInt r=NewChunk((DChunk*&)iDataBssStackChunk,cinfo,iDataBssRunAddress);

	return r;

	}

TInt DMemModelProcess::AddChunk(DChunk* aChunk,TBool isReadOnly)

	{

	DMemModelChunk* pC=(DMemModelChunk*)aChunk;

	TInt r=WaitProcessLock();

	if (r==KErrNone)

		{

		TInt pos=0;

		r=ChunkIndex(pC,pos);

		TLinAddr dataSectionBase=0;

		if (r==0) // Found the chunk in this process, just up its count

			{

			iChunks[pos].iAccessCount++;

			__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk %08x to %08x (Access count incremented to %d)",aChunk,this,iChunks[pos].iAccessCount));

			SignalProcessLock();

			return KErrNone;

			}

		r=AddChunk(pC,dataSectionBase,isReadOnly);

		SignalProcessLock();

		}

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk returns %d",r));

	return r;

	}

void FlushBeforeChunkMove(DMemModelChunk* aChunk)

	{

	Mmu& m = Mmu::Get();

	TUint32 ff=Mmu::EFlushDMove|Mmu::EFlushDPermChg;

	if (aChunk->iAttributes & DMemModelChunk::ECode)		// assumption here that code chunks don't move

		ff |= Mmu::EFlushIPermChg;

	m.GenericFlush(ff);

	}

TInt DMemModelProcess::AddChunk(DMemModelChunk* aChunk, TLinAddr& aDataSectionBase, TBool isReadOnly)

	{

	//

	// Must hold the process $LOCK mutex before calling this

	//

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AddChunk %08x to %08x (for first time)",aChunk,this));

	TInt r=AllocateDataSectionBase(*((DMemModelChunk*)aChunk),(TUint&)aDataSectionBase);

	if(r!=KErrNone)

		return r;

	if (iNumChunks==KMaxChunksInProcess)

		return KErrOverflow;		// too many chunks in the process

	SChunkInfo *pC=iChunks;

	SChunkInfo *pE=pC+iNumChunks-1;

	NKern::LockSystem();

	while(pE>=pC && TUint(pE->iDataSectionBase)>TUint(aDataSectionBase))

		{

		pE[1]=pE[0];

		pE--;

		}

	pC=pE+1;

	pC->iDataSectionBase=aDataSectionBase;

	pC->isReadOnly=isReadOnly;

	pC->iAccessCount=1;

	pC->iChunk=aChunk;

	iNumChunks++;

	if(!(iAttributes&ESupervisor))

		{

		TInt attribs=aChunk->iAttributes;

		if (!(attribs&DMemModelChunk::EFixedAddress))

			{

			iNumMovingChunks++;

			iAttributes |= EMoving;

			}

		if (attribs&DMemModelChunk::EFixedAccess)

			{

			NKern::UnlockSystem();

			AddFixedAccessChunk(aChunk);

			goto done;	// FINISHED

			}

		iAttributes |= EVariableAccess;

		if (attribs & DMemModelChunk::ECode)

			{

			iNumNonFixedAccessCodeChunks++;

			iAttributes |= EVariableCode;

			}

		if (++iNumNonFixedAccessChunks==1)

			{

			NKern::UnlockSystem();

			DoAttributeChange();	// change process from fixed to variable access

			NKern::LockSystem();

			}

		if (this!=TheCurrentThread->iOwningProcess)

			{

			// Adding chunk to another process

			if (this==TheCurrentDataSectionProcess && !(attribs&DMemModelChunk::EFixedAddress))

				TheCompleteDataSectionProcess=NULL;	// just set partial state change flag and leave chunk alone

			if (this==TheCurrentAddressSpace)

				TheCurrentAddressSpace=NULL;

			NKern::UnlockSystem();

			goto done;	// FINISHED

			}

		// Adding chunk to currently active user process

		{

		TheCurrentAddressSpace=NULL;

		Mmu& m = Mmu::Get();

		TUint32 ff=0;	// flush flags

		DMemModelChunk::TChunkState state=isReadOnly?DMemModelChunk::ERunningRO:DMemModelChunk::ERunningRW;

		if (attribs&DMemModelChunk::EFixedAddress)

			{

			// Fixed address chunk, just change permissions

			ff|=aChunk->ApplyTopLevelPermissions(state);

			}

		else if (this==TheCurrentDataSectionProcess)

			{

			// Moving chunk.

			// This process is already in the data section, so just move the chunk down.

			// Must do flushing first

			TheCompleteDataSectionProcess=NULL;

			FlushBeforeChunkMove(aChunk);

			aChunk->MoveToRunAddress(aDataSectionBase,state);	// idempotent

			TheCompleteDataSectionProcess=this;

			}

		else if (iNumMovingChunks==1)

			{

			// The first moving chunk being added to a process with the data section occupied by another process.

			// This is the problematic case - we must displace the other process from the data section.

			// However we must allow preemption after each chunk is moved. Note that if a reschedule does

			// occur the necessary chunk moves will have been done by the scheduler, so we can finish

			// immediately.

			// Must do cache flushing first

			m.GenericFlush(Mmu::EFlushDMove);

			if (TheCurrentDataSectionProcess)

				{

				if (TheCurrentDataSectionProcess->iAttributes & EVariableCode)

					ff |= Mmu::EFlushIPermChg;

				SChunkInfo* pOtherProcChunks=TheCurrentDataSectionProcess->iChunks;

				SChunkInfo* pEndOtherProcChunks=pOtherProcChunks+TheCurrentDataSectionProcess->iNumChunks;

				NKern::FlashSystem();

				// if a reschedule occurs, TheCompleteDataSectionProcess will become equal to this

				while (TheCompleteDataSectionProcess!=this && pOtherProcChunks<pEndOtherProcChunks)

					{

					DMemModelChunk *pChunk=pOtherProcChunks->iChunk;

					pChunk->MoveToHomeSection();

					++pOtherProcChunks;

					TheCompleteDataSectionProcess=NULL;

					NKern::FlashSystem();

					}

				}

			if (TheCompleteDataSectionProcess!=this)

				{

				if (attribs & DMemModelChunk::ECode)

					ff |= Mmu::EFlushIPermChg;

				aChunk->MoveToRunAddress(aDataSectionBase,state);

				TheCurrentDataSectionProcess=this;

				TheCompleteDataSectionProcess=this;

				}

			}

		TheCurrentAddressSpace=this;

		TheCurrentVMProcess=this;

		if (ff)

			m.GenericFlush(ff);

		}

	}

	NKern::UnlockSystem();

done:

	__KTRACE_OPT(KPROC,Kern::Printf("Added array entry for %x",aDataSectionBase));

	__KTRACE_OPT(KPROC,Kern::Printf("Chunks maxsize %x",pC->iChunk->MaxSize()));

	__DEBUG_EVENT(EEventUpdateProcess, this);

	return KErrNone;

	}

TInt DMemModelProcess::AllocateDataSectionBase(DMemModelChunk& aChunk, TUint& aBase)

	{

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::AllocateDataSectionBase"));

	aBase=0;

	if ((aChunk.iAttributes & DMemModelChunk::EPrivate) && this!=aChunk.iOwningProcess)

		return KErrAccessDenied;

	if (aChunk.iAttributes & DMemModelChunk::EFixedAddress)

		{

		aBase=aChunk.iHomeRegionBase;

		return KErrNone;

		}

	Mmu& m = Mmu::Get();

	TLinAddr base=0;

	TLinAddr maxBase=0;

	switch (aChunk.iChunkType)

		{

	case EUserData:

		base=m.iDataSectionBase;

		maxBase=m.iDllDataBase;

		break;

	case EUserCode:

	case EUserSelfModCode:

		MM::Panic(MM::EUserCodeNotFixed);

		break;

	case EDllData:

		aBase=m.iDllDataBase;

		return KErrNone;

	default:

		__KTRACE_OPT(KPANIC,Kern::Printf("DMemModelProcess::AllocateDataSectionBase BadChunkType %d",aChunk.iChunkType));

		return KErrAccessDenied;

		}

	TLinAddr lastBase=base;

	SChunkInfo *pS=iChunks;

	SChunkInfo *pE=pS+iNumChunks;

	while (pS<pE)

		{

		TLinAddr thisBase=pS->iDataSectionBase;

		__KTRACE_OPT(KPROC,Kern::Printf("Chunk already at %x",thisBase));

		if (thisBase>=maxBase)

			break;

		if (thisBase>=base) // Within the range we are allocating

			{

			TInt gap=thisBase-lastBase;

			if (gap>=aChunk.MaxSize())

				break;

			lastBase=thisBase+pS->iChunk->MaxSize();

			}

		pS++;

		}

	if (lastBase+aChunk.MaxSize()>maxBase)

		{

		__KTRACE_OPT(KPROC,Kern::Printf("ERROR - none allocated, out of memory"));

		return KErrNoMemory;

		}

	aBase=lastBase;

	__KTRACE_OPT(KPROC,Kern::Printf("User allocated %x",aBase));

	return KErrNone;

	}

TUint8* DMemModelProcess::DataSectionBase(DMemModelChunk* aChunk)

	{

	// this can't be called after $LOCK is deleted

	Kern::MutexWait(*iProcessLock);

	TInt pos=0;

	TInt r=ChunkIndex(aChunk,pos);

	if (r==0) // Found the chunk

		{

		TUint8* answer=((TUint8*)iChunks[pos].iDataSectionBase);

		__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DataSectionBase %x",answer));

		Kern::MutexSignal(*iProcessLock);

		return answer;

		}

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DataSectionBase chunk %08x not present in %08x",aChunk,this));

	Kern::MutexSignal(*iProcessLock);

	return(NULL);

	}

void DMemModelProcess::DoRemoveChunk(TInt aIndex)

	{

	// Must be called with process $LOCK mutex held

	__DEBUG_EVENT(EEventUpdateProcess, this);

	DMemModelChunk* chunk = iChunks[aIndex].iChunk;

	Mmu& m = Mmu::Get();

	NKern::LockSystem();

	TInt attribs=chunk->iAttributes;

	__KTRACE_OPT(KPROC,Kern::Printf("Removing Chunk attribs=%08x, Process attribs=%08x",attribs,iAttributes));

	if (!(attribs&DMemModelChunk::EFixedAccess))

		{

		// Must leave chunk in process chunk list until we have flushed the cache if necessary

		if (this==TheCurrentVMProcess && (attribs&DMemModelChunk::EFixedAddress))

			{

			TUint32 ff=chunk->ApplyTopLevelPermissions(DMemModelChunk::ENotRunning);

			m.GenericFlush(ff);

			// the system must now remain locked until the chunk is removed from the process chunk list

			}

		if (this==TheCurrentDataSectionProcess && !(attribs&DMemModelChunk::EFixedAddress))

			{

			// must do cache flush first

			FlushBeforeChunkMove(chunk);	// preemptible, but on return cache is free of chunk data

			chunk->MoveToHomeSection();

			// the system must now remain locked until the chunk is removed from the process chunk list

			}

		}

	// Remove the chunk from the process chunk list

	SChunkInfo *pD=iChunks+aIndex;

	SChunkInfo *pS=iChunks+aIndex+1;

	SChunkInfo *pE=iChunks+iNumChunks;

	while(pS<pE)

		*pD++=*pS++;

	iNumChunks--;

	// Update the process attribute flags

	if (!(attribs&DMemModelChunk::EFixedAddress))

		{

		if (--iNumMovingChunks==0)

			iAttributes &= ~EMoving;

		}

	if (!(attribs&DMemModelChunk::EFixedAccess))

		{

		if ((attribs&DMemModelChunk::ECode) && --iNumNonFixedAccessCodeChunks==0)

				iAttributes &= ~EVariableCode;

		if (this==TheCurrentDataSectionProcess && !(iAttributes&EMoving))

			{

			TheCurrentDataSectionProcess=NULL;

			TheCompleteDataSectionProcess=NULL;

			}

		if (--iNumNonFixedAccessChunks==0)

			{

			iAttributes &= ~EVariableAccess;

			if (this==TheCurrentVMProcess)

				{

				TheCurrentVMProcess=NULL;

				TheCurrentAddressSpace=NULL;

				}

			NKern::UnlockSystem();

			DoAttributeChange();	// change process from variable to fixed access

			}

		else

			NKern::UnlockSystem();

		}

	else

		{

		NKern::UnlockSystem();

		RemoveFixedAccessChunk(chunk);

		}

	}

/**

Final chance for process to release resources during its death.

Called with process $LOCK mutex held (if it exists).

This mutex will not be released before it is deleted.

I.e. no other thread will ever hold the mutex again.

*/

void DMemModelProcess::FinalRelease()

	{

	// Clean up any left over chunks (such as SharedIo buffers)

	while(iNumChunks)

		DoRemoveChunk(0);

	}

void DMemModelProcess::RemoveChunk(DMemModelChunk *aChunk)

	{

	// note that this can't be called after the process $LOCK mutex has been deleted

	// since it can only be called by a thread in this process doing a handle close or

	// dying, or by the process handles array being deleted due to the process dying,

	// all of which happen before $LOCK is deleted.

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::RemoveChunk %08x from %08x",aChunk,this));

	Kern::MutexWait(*iProcessLock);

	TInt pos=0;

	TInt r=ChunkIndex(aChunk,pos);

	__KTRACE_OPT(KPROC,if(r) Kern::Printf("Chunk lookup failed with %d",r));

	if (r==0) // Found the chunk

		{

		__KTRACE_OPT(KPROC,Kern::Printf("Chunk access count %d",iChunks[pos].iAccessCount));

		if (--iChunks[pos].iAccessCount==0)

			DoRemoveChunk(pos);

		}

	Kern::MutexSignal(*iProcessLock);

	}

TInt DMemModelProcess::ChunkIndex(DMemModelChunk* aChunk,TInt& aPos)

	{

	if (aChunk==NULL)

		return(KErrNotFound);

	TInt i=0;

	SChunkInfo *pC=iChunks;

	SChunkInfo *pE=pC+iNumChunks;

	while(pC<pE && (pC->iChunk!=aChunk))

		{

		pC++;

		i++;

		}