// 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\multiple\mprocess.cpp

// 

//

#include "memmodel.h"

#include "mmboot.h"

#include "cache_maintenance.h"

#include <demand_paging.h>

#define iMState		iWaitLink.iSpare1

// just for convenience...

#define KAmSelfMod	(DMemModelChunk::ECode | DMemModelChunk::EAddressLocal)

_LIT(KDollarDat,"$DAT");

_LIT(KLitDollarCode,"$CODE");

_LIT(KLitDllDollarData,"DLL$DATA");

#ifdef __CPU_HAS_BTB

extern void __FlushBtb();

#endif

const TInt KChunkGranularity=4;

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

 * Process

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

void DMemModelProcess::Destruct()

	{

	__ASSERT_ALWAYS(!iChunkCount && !iCodeChunk && !iDllDataChunk, MM::Panic(MM::EProcessDestructChunksRemaining));

	Kern::Free(iChunks);

	Kern::Free(iLocalSection);

	if (iOsAsid)

		{

		Mmu& m=Mmu::Get();

		MmuBase::Wait();

		m.FreeOsAsid(iOsAsid);

		iOsAsid=0;

		MmuBase::Signal();

#ifndef __SMP__

		LastUserSelfMod=0;  // must force a BTB flush when next selfmod chunk switched in

#endif

		}

#ifdef __CPU_HAS_BTB

	__FlushBtb();

#endif

	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;

		}

	TInt mapType=pC->iAttributes & DMemModelChunk::EMapTypeMask;

	pC->iOwningProcess=(mapType==DMemModelChunk::EMapTypeLocal)?this:NULL;

#ifdef __CPU_HAS_BTB

	if ((pC->iAttributes & KAmSelfMod) == KAmSelfMod)  // it's a potentially overlapping self-mod

		{

		iSelfModChunks++;

#ifndef __SMP__

		LastUserSelfMod = this;  // we become the last selfmodding process

#endif

		__FlushBtb();		// we need to do this, as there may be bad branches already in the btb

		}

#endif

	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 && aInfo.iInitialTop!=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 && (aInfo.iOperations & SChunkCreateInfo::EAdd))

		{

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

//				MM::TheMmu->SyncCodeMappings();

		if (mapType!=DMemModelChunk::EMapTypeGlobal)

			{

			r=WaitProcessLock();

			if (r==KErrNone)

				{

				r=AddChunk(pC,aRunAddr,EFalse);

				SignalProcessLock();

				}

			}

		else

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

		}

	if (r==KErrNone)

		{

		if(r==KErrNone)

			if(pC->iKernelMirror)

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

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

	Mmu& m=Mmu::Get();

	TInt r=KErrNone;

	iSelfModChunks=0;  // we don't have any yet.

	if (aKernelProcess)

		{

		iAttributes |= ESupervisor;

		//iOsAsid=0;

//		Leave these till Mmu::Init2

//		if (m.iLocalPdSize)

//			iLocalPageDir=m.LinearToPhysical(TLinAddr(m.LocalPageDir(0)));

//		iGlobalPageDir=m.LinearToPhysical(TLinAddr(m.GlobalPageDir(0)));

		m.iAsidInfo[0]=((TUint32)this)|1;

		iAddressCheckMaskR=0xffffffff;

		iAddressCheckMaskW=0xffffffff;

		}

	else

		{

		MmuBase::Wait();

		r=m.NewOsAsid(EFalse);

		if (r>=0)

			{

			iOsAsid=r;

			if (m.iLocalPdSize)

				iLocalPageDir=m.LinearToPhysical(TLinAddr(m.LocalPageDir(r)));

			else

				iGlobalPageDir=m.LinearToPhysical(TLinAddr(m.GlobalPageDir(r)));

			m.iAsidInfo[r] |= (TUint32)this;

			r=KErrNone;

			}

		MmuBase::Signal();

		if (r==KErrNone && 0==(iLocalSection=TLinearSection::New(m.iUserLocalBase, m.iUserLocalEnd)) )

			r=KErrNoMemory;

		}

	__KTRACE_OPT(KPROC,Kern::Printf("OS ASID=%d, LPD=%08x, GPD=%08x, ASID info=%08x",iOsAsid,iLocalPageDir,

											iGlobalPageDir,m.iAsidInfo[iOsAsid]));

	__KTRACE_OPT(KPROC,Kern::Printf("<DMemModelProcess::DoCreate %d",r));

	return r;

	}

TInt DMemModelProcess::CreateDataBssStackArea(TProcessCreateInfo& aInfo)

	{

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

	Mmu& m=Mmu::Get();

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

	TInt maxSize=dataBssSize+PP::MaxStackSpacePerProcess;

	TLinAddr dataRunAddress=m.iUserLocalBase;

	iDataBssRunAddress=dataRunAddress;

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

	cinfo.iRunAddress=0;

	TLinAddr cb;

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

	return r;

	}

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

	{

	DMemModelChunk* pC=(DMemModelChunk*)aChunk;

	if ((pC->iAttributes & DMemModelChunk::EPrivate) && this!=pC->iOwningProcess)

		return KErrAccessDenied;

	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 M::FsRegisterThread()

	{

	DMemModelChunk* pC=(DMemModelChunk*)PP::TheRamDriveChunk;

	TInt mapType=pC->iAttributes & DMemModelChunk::EMapTypeMask;

	if (mapType!=DMemModelChunk::EMapTypeLocal)

		{

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

		TLinAddr dataSectionBase;

		TInt r=pP->WaitProcessLock();

		if (r==KErrNone)

			r=pP->AddChunk(pC,dataSectionBase,EFalse);

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

		pP->SignalProcessLock();

		}

	}

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 %O to %O",aChunk,this));

	SChunkInfo *pC=iChunks;

	SChunkInfo *pE=pC+iChunkCount-1;

	TLinAddr base=TLinAddr(aChunk->iBase);

	TInt i=0;

#ifdef __CPU_HAS_BTB

	if ((aChunk->iAttributes & KAmSelfMod)==KAmSelfMod)  // it's a potentially overlapping self-mod

		{

		iSelfModChunks++;

#ifndef __SMP__

		LastUserSelfMod = this;  // we become the last selfmodding process

#endif

		__FlushBtb();		// we need to do this, as there may be bad branches already in the btb

		}

#endif

	if (iChunkCount)

		{

		for (; pE>=pC && TLinAddr(pE->iChunk->iBase)>base; --pE);

		if (pE>=pC && TLinAddr(pE->iChunk->iBase)+pE->iChunk->iMaxSize>base)

			return KErrInUse;

		pC=pE+1;

		if (pC<iChunks+iChunkCount && base+aChunk->iMaxSize>TLinAddr(pC->iChunk->iBase))

			return KErrInUse;

		i=pC-iChunks;

		}

	if (iChunkCount==iChunkAlloc)

		{

		TInt newAlloc=iChunkAlloc+KChunkGranularity;

		TInt r=Kern::SafeReAlloc((TAny*&)iChunks,iChunkAlloc*sizeof(SChunkInfo),newAlloc*sizeof(SChunkInfo));

		if (r!=KErrNone)

			return r;

		pC=iChunks+i;

		iChunkAlloc=newAlloc;

		}

	memmove(pC+1,pC,(iChunkCount-i)*sizeof(SChunkInfo));

	++iChunkCount;

	pC->isReadOnly=isReadOnly;

	pC->iAccessCount=1;

	pC->iChunk=aChunk;

	aDataSectionBase=base;

	Mmu& m=Mmu::Get();

	if (aChunk->iOsAsids)

		{

		// only need to do address space manipulation for shared chunks

		MmuBase::Wait();

		aChunk->iOsAsids->Alloc(iOsAsid,1);

		TLinAddr a;

		TInt i=0;

		for (a=TLinAddr(aChunk->iBase); a<TLinAddr(aChunk->iBase)+aChunk->iMaxSize; a+=m.iChunkSize, ++i)

			{

			TInt ptid=aChunk->iPageTables[i];

			if (ptid!=0xffff)

				m.DoAssignPageTable(ptid,a,aChunk->iPdePermissions,(const TAny*)iOsAsid);

			}

		MmuBase::Signal();

		}

	if (aChunk->iChunkType==ERamDrive)

		{

		NKern::LockSystem();

		iAddressCheckMaskR |= m.iRamDriveMask;

		iAddressCheckMaskW |= m.iRamDriveMask;

		NKern::UnlockSystem();

		}

	__DEBUG_EVENT(EEventUpdateProcess, this);

	return KErrNone;

	}

void DMemModelProcess::DoRemoveChunk(TInt aIndex)

	{

	__DEBUG_EVENT(EEventUpdateProcess, this);

	DMemModelChunk* chunk = iChunks[aIndex].iChunk;

	memmove(iChunks+aIndex, iChunks+aIndex+1, (iChunkCount-aIndex-1)*sizeof(SChunkInfo));

	--iChunkCount;

	Mmu& m=Mmu::Get();

	if (chunk->iOsAsids)

		{

		// only need to do address space manipulation for shared chunks

		MmuBase::Wait();

		chunk->iOsAsids->Free(iOsAsid);

		TLinAddr a;

		for (a=TLinAddr(chunk->iBase); a<TLinAddr(chunk->iBase)+chunk->iMaxSize; a+=m.iChunkSize)

			m.DoUnassignPageTable(a,(const TAny*)iOsAsid);

		TUint32 mask=(chunk->iAttributes&DMemModelChunk::ECode)?Mmu::EFlushITLB:0;

		m.GenericFlush(mask|Mmu::EFlushDTLB);

		MmuBase::Signal();

		}

	if (chunk->iChunkType==ERamDrive)

		{

		NKern::LockSystem();

		iAddressCheckMaskR &= ~m.iRamDriveMask;

		iAddressCheckMaskW &= ~m.iRamDriveMask;

		NKern::UnlockSystem();

		}

	}

/**

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)

	if(iProcessLock)

		while(iChunkCount)

			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 %O RemoveChunk %O",this,aChunk));

	Kern::MutexWait(*iProcessLock);

	TInt pos=0;

	TInt r=ChunkIndex(aChunk,pos);

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

		{

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

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

			{

			DoRemoveChunk(pos);

#ifdef __CPU_HAS_BTB

			if ((aChunk->iAttributes & KAmSelfMod)==KAmSelfMod)  // was a self-mod code chunk

				if (iSelfModChunks)

					iSelfModChunks--;

#endif

			}

		}

	Kern::MutexSignal(*iProcessLock);

	}

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

	{

	if (!aChunk)

		return KErrNotFound;

	SChunkInfo *pC=iChunks;

	SChunkInfo *pE=pC+iChunkCount;

	for (; pC<pE && pC->iChunk!=aChunk; ++pC);

	if (pC==pE)

		return KErrNotFound;

	aPos=pC-iChunks;

	return KErrNone;

	}

TInt DMemModelProcess::MapCodeSeg(DCodeSeg* aSeg)

	{

	DMemModelCodeSeg& seg=*(DMemModelCodeSeg*)aSeg;

	__KTRACE_OPT(KDLL,Kern::Printf("Process %O MapCodeSeg %C", this, aSeg));

	TBool kernel_only=( (seg.iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );

	if (kernel_only && !(iAttributes&ESupervisor))

		return KErrNotSupported;

	if (seg.iAttr&ECodeSegAttKernel)

		return KErrNone;	// no extra mappings needed for kernel code

	TInt r=KErrNone;

	if (seg.Pages())

		r=MapUserRamCode(seg.Memory(),EFalse);

	if (seg.IsDll())

		{

		TInt total_data_size;

		TLinAddr data_base;

		seg.GetDataSizeAndBase(total_data_size, data_base);

		if (r==KErrNone && total_data_size)

			{

			TInt size=Mmu::RoundToPageSize(total_data_size);

			r=CommitDllData(data_base, size);

			if (r!=KErrNone && seg.Pages())

				UnmapUserRamCode(seg.Memory(), EFalse);

			}

		}

	return r;

	}

void DMemModelProcess::UnmapCodeSeg(DCodeSeg* aSeg)

	{

	DMemModelCodeSeg& seg=*(DMemModelCodeSeg*)aSeg;

	__KTRACE_OPT(KDLL,Kern::Printf("Process %O UnmapCodeSeg %C", this, aSeg));

	if (seg.iAttr&ECodeSegAttKernel)

		return;	// no extra mappings needed for kernel code

	if (seg.IsDll())

		{

		TInt total_data_size;

		TLinAddr data_base;

		seg.GetDataSizeAndBase(total_data_size, data_base);

		if (total_data_size)

			DecommitDllData(data_base, Mmu::RoundToPageSize(total_data_size));

		}

	if (seg.Pages())

		UnmapUserRamCode(seg.Memory(), EFalse);

	}

void DMemModelProcess::RemoveDllData()

//

// Call with CodeSegLock held

//

	{

	}

TInt DMemModelProcess::CreateCodeChunk()

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O CreateCodeChunk",this));

	TBool kernel=iAttributes&ESupervisor;

	Mmu& m=Mmu::Get();

	SChunkCreateInfo c;

	c.iGlobal=kernel;

	c.iAtt = TChunkCreate::EDisconnected | (kernel? 0 : TChunkCreate::EMemoryNotOwned);

	c.iForceFixed=EFalse;

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

	c.iRunAddress=kernel ? 0 : m.iUserCodeBase;

	c.iPreallocated=0;

	c.iType=kernel ? EKernelCode : EUserCode;

	c.iMaxSize=m.iMaxUserCodeSize;

	c.iName.Set(KLitDollarCode);

	c.iOwner=this;

	c.iInitialTop=0;

	TLinAddr runAddr;

	TInt r = NewChunk((DChunk*&)iCodeChunk,c,runAddr);

	return r;

	}

void DMemModelProcess::FreeCodeChunk()

	{

	iCodeChunk->Close(this);

	iCodeChunk=NULL;

	}

TInt DMemModelProcess::MapUserRamCode(DMemModelCodeSegMemory* aMemory, TBool aLoading)

	{

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess %O MapUserRamCode %C %d %d %d",

									this, aMemory->iCodeSeg, aLoading, iOsAsid, aMemory->iIsDemandPaged));

	__ASSERT_MUTEX(DCodeSeg::CodeSegLock);

	TInt r;

	if (!iCodeChunk)

		{

		r=CreateCodeChunk();

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

		if (r!=KErrNone)

			return r;

		}

	MmuBase::Wait();

	Mmu& m=Mmu::Get();

	TInt offset=aMemory->iRamInfo.iCodeRunAddr-TLinAddr(iCodeChunk->iBase);

	TInt codeSize = aMemory->iPageCount<<m.iPageShift;

	TBool paged = aMemory->iIsDemandPaged;

	DChunk::TCommitType commitType = paged ? DChunk::ECommitVirtual : DChunk::ECommitDiscontiguousPhysical;

	r=iCodeChunk->Commit(offset, codeSize, commitType, aMemory->iPages);

	__KTRACE_OPT(KPROC,Kern::Printf("Commit Pages returns %d", r));

	if(r==KErrNone)

		{

		if (aLoading && !paged)

			{

			iCodeChunk->ApplyPermissions(offset, codeSize, m.iUserCodeLoadPtePerm);

			UNLOCK_USER_MEMORY();

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

			LOCK_USER_MEMORY();

			}

		if(aLoading && aMemory->iDataPageCount)

			{

			TInt dataSize = aMemory->iDataPageCount<<m.iPageShift;

			r=iCodeChunk->Commit(offset+codeSize, dataSize, DChunk::ECommitDiscontiguousPhysical, aMemory->iPages+aMemory->iPageCount);

			if(r==KErrNone)

				{