// 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++;

		}

	if (pC==pE)

		return KErrNotFound;

	aPos=i;

	return KErrNone;

	}

void DMemModelProcess::RemoveDllData()

//

// Call with CodeSegLock held

//

	{

	Kern::SafeClose((DObject*&)iDllDataChunk, this);

	}

TInt DMemModelProcess::CreateDllDataChunk()

//

// Call with CodeSegLock held

//

	{

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

	Mmu& m = Mmu::Get();

	SChunkCreateInfo c;

	c.iGlobal=EFalse;

	c.iAtt=TChunkCreate::EDisconnected;

	c.iForceFixed=EFalse;

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

	c.iRunAddress=0;

	c.iPreallocated=0;

	c.iType=EDllData;

	c.iMaxSize=(iAttributes&EFixedAddress) ? 1 : m.iMaxDllDataSize;	// minimal size for fixed processes

	c.iName.Set(KLitDllDollarData);

	c.iOwner=this;

	c.iInitialBottom=0;

	c.iInitialTop=0;

	TLinAddr runAddr;

	return NewChunk((DChunk*&)iDllDataChunk,c,runAddr);

	}

void DMemModelProcess::FreeDllDataChunk()

	{

	iDllDataChunk->Close(this);

	iDllDataChunk=NULL;

	}

TInt DMemModelProcess::CommitDllData(TLinAddr aBase, TInt aSize)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O CommitDllData %08x+%x",this,aBase,aSize));

	TInt r=KErrNone;

	if (!iDllDataChunk)

		r=CreateDllDataChunk();

	if (r==KErrNone)

		{

		Mmu& m = Mmu::Get();

		TLinAddr dll_data_base=(iAttributes & EFixedAddress) ? (TLinAddr)iDllDataChunk->Base()

														: TLinAddr(m.iDllDataBase);

		TInt offset=aBase-dll_data_base;

		__ASSERT_ALWAYS(TUint32(offset)<TUint32(iDllDataChunk->iMaxSize),MM::Panic(MM::ECommitInvalidDllDataAddress));

		r=iDllDataChunk->Commit(offset, aSize);

		if (r!=KErrNone && iDllDataChunk->iSize==0)

			FreeDllDataChunk();

		}

	__KTRACE_OPT(KDLL,Kern::Printf("CommitDllData returns %d",r));

	return r;

	}

void DMemModelProcess::DecommitDllData(TLinAddr aBase, TInt aSize)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelProcess %O DecommitDllData %08x+%x",this,aBase,aSize));

	Mmu& m = Mmu::Get();

	TLinAddr dll_data_base=(iAttributes & EFixedAddress) ? (TLinAddr)iDllDataChunk->Base()

													: TLinAddr(m.iDllDataBase);

	TInt offset=aBase-dll_data_base;

	TInt r=iDllDataChunk->Decommit(offset, aSize);

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

	if (iDllDataChunk->iSize==0)

		FreeDllDataChunk();

	}

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 || seg.iDataAllocBase==-1)

		return KErrNone;	// no extra mappings needed for kernel code or code with fixed data address

	TInt r=KErrNone;

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

			}

		}

	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 || seg.iDataAllocBase==-1)

		return;	// no extra mappings needed for kernel code or code with fixed data address

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

		}

	}

TInt DMemModelProcess::NewShPool(DShPool*& /* aPool */, TShPoolCreateInfo& /* aInfo */)

	{

	return KErrNotSupported;

	}

TInt DThread::RawRead(const TAny* aSrc, TAny* aDest, TInt aLength, TInt aFlags, TIpcExcTrap* aExcTrap)

//

// Read from the thread's process.

// aSrc is run address of memory to read. The memory is in aThread's address space.

// aDest is the address of destination. The memory is in the current process's address space.

// aExcTrap, exception trap object to be updated if the actual memory access is performed on another memory area. It happens 

//           when  reading is performed in chunks or if home adress is read instead of the provided run address.

// Enter and return with system locked.

	{

	const TUint8* pS=(const TUint8*)aSrc;

	TUint8* pD=(TUint8*)aDest;

	const TUint8* pC=NULL;

	TBool check=ETrue;

	TBool suspect=EFalse;

	DThread* pT=TheCurrentThread;

	while (aLength)

		{

		if (check)

			{

			suspect=((aFlags & KCheckLocalAddress) && !MM::CurrentAddress(pT,pD,aLength,ETrue));

			if (iMState==EDead)

				return KErrDied;

			pC=(const TUint8*)MM::CurrentAddress(this,pS,aLength,EFalse);

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead %08x<-[%08x::%08x]%08x+%x",pD,this,pS,pC,aLength));

			if (!pC)

				return KErrBadDescriptor;

			}

		TInt len=Min(aLength,K::MaxMemCopyInOneGo);

		if (aExcTrap)

			{

			aExcTrap->iSize = (len + 2*(sizeof(TInt32)-1));//+6 is for the worst case. We do not have to be precise here.

			aExcTrap->iRemoteBase = (TLinAddr)pC & ~(sizeof(TInt32)-1);		

			if (aExcTrap->iLocalBase)

				aExcTrap->iLocalBase = (TLinAddr)pD & ~(sizeof(TInt32)-1);

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead exc. update: %08x %08x %08x",aExcTrap->iLocalBase,aExcTrap->iRemoteBase,aExcTrap->iSize));

			}

#ifdef __DEMAND_PAGING__

		XTRAP_PAGING_START(check);

		CHECK_PAGING_SAFE;

#endif

		suspect?(void)umemput(pD,pC,len):(void)memcpy(pD,pC,len);

#ifdef __DEMAND_PAGING__

		XTRAP_PAGING_END;

		if(check<0)

			return check; // paging error caused by bad client (I.e. 'this' thread was bad)

		if(check)

			{

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead paging trap, suspect %d, dest %08x, source %08x, length %d\n", suspect, pD, pC, len));

			continue;

			}

#endif

		pD+=len;

		pS+=len;

		pC+=len;

		aLength-=len;

		if (aLength)

			check=NKern::FlashSystem();

		}

	return KErrNone;

	}

TInt DThread::RawWrite(const TAny* aDest, const TAny* aSrc, TInt aLength, TInt aFlags, DThread* aOriginatingThread, TIpcExcTrap* aExcTrap)

//

// Write to the thread's process.

// aDest is run address of memory to write. It resides in this thread's address space.

// aSrc is address of the source buffer. It resides in the current process's address space.

// aOriginatingThread is the thread on behalf of which this operation is performed (eg client of device driver).

// Enter and return with system locked

// aExcTrap, exception trap object to be updated if the actual memory access is performed on another memory area. It happens 

//           when  reading is performed in chunks or if home adress is read instead of the provided run address.

//

	{

	TUint8* pD=(TUint8*)aDest;

	const TUint8* pS=(const TUint8*)aSrc;

	TUint8* pC=NULL;

	TBool check=ETrue;

	TBool suspect=EFalse;

	DThread* pT=TheCurrentThread;

	DThread* pO=aOriginatingThread;

	if (!pO)

		pO=pT;

	DProcess* pF=K::TheFileServerProcess;

	TBool special=(iOwningProcess==pF && pO->iOwningProcess==pF);

	while (aLength)

		{

		if (check)

			{

			suspect=((aFlags & KCheckLocalAddress) && !MM::CurrentAddress(pT,pS,aLength,EFalse));

			if (iMState==EDead)

				return KErrDied;

			pC=(TUint8*)MM::CurrentAddress(this,pD,aLength,ETrue);

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawRead [%08x::%08x]%08x<-%08x+%x",this,pD,pC,pS,aLength));

			if (!pC)

				{

				if (special)

					pC=pD;

				else

					return KErrBadDescriptor;

				}

			}

		TInt len=Min(aLength,K::MaxMemCopyInOneGo);

		if (aExcTrap)

			{

			aExcTrap->iSize = (len + 2*(sizeof(TInt32)-1));//+6 is for the worst case. We do not have to be precise here.

			aExcTrap->iRemoteBase = (TLinAddr)pC & ~(sizeof(TInt32)-1);	

			if (aExcTrap->iLocalBase)

				aExcTrap->iLocalBase = (TLinAddr)pS & ~(sizeof(TInt32)-1);

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawWrite exc. update %08x %08x %08x",aExcTrap->iLocalBase,aExcTrap->iRemoteBase,aExcTrap->iSize));

			}

#ifdef __DEMAND_PAGING__

		XTRAP_PAGING_START(check);

		// Must check that it is safe to page, unless we are reading from unpaged ROM in which case

		// we allow it.  umemget does this anyway, so we just need to check if suspect is not set.

		if (!suspect)

			{

			CHECK_PAGING_SAFE_RANGE((TLinAddr)aSrc, aLength);

			CHECK_DATA_PAGING_SAFE_RANGE((TLinAddr)aDest, aLength);

			}

#endif

		suspect?(void)umemget(pC,pS,len):(void)memcpy(pC,pS,len);

#ifdef __DEMAND_PAGING__

		XTRAP_PAGING_END

		if(check<0)

			return check; // paging error caused by bad client (I.e. 'this' thread was bad)

		if(check)

			{

			__KTRACE_OPT(KTHREAD2,Kern::Printf("DThread::RawWrite paging trap, suspect %d, dest %08x, src %08x, length %d\n", suspect, pC, pD, len));

			continue;

			}

#endif

		pD+=len;

		pS+=len;

		pC+=len;

		aLength-=len;

		if (aLength)

			check=NKern::FlashSystem();

		}

	return KErrNone;

	}

#ifdef __DEBUGGER_SUPPORT__

TInt CodeModifier::SafeWriteCode(DProcess* aProcess, TLinAddr aAddress, TInt aSize, TUint aValue, void* aOldValue)

	{

	//Set exception handler. Make sure the boundaries cover the worst case (aSize = 4)

	TIpcExcTrap xt;

	xt.iLocalBase=0;

	xt.iRemoteBase=(TLinAddr)aAddress&~3; //word aligned.

	xt.iSize=sizeof(TInt);

	xt.iDir=1;

	NKern::LockSystem();

	TInt r=xt.Trap(NULL);

	if (r==0)

		{

		r = WriteCode(aAddress, aSize, aValue, aOldValue);

		xt.UnTrap();

		}

	NKern::UnlockSystem();

	return r;	

	}

TInt CodeModifier::WriteCode(TLinAddr aAddress, TInt aSize, TUint aValue, void* aOldValue)

	{

	TUint userChunkBase = (TUint)MM::UserCodeChunk->Base();

	TRomHeader romHeader = Epoc::RomHeader();

	if (!((aAddress >= romHeader.iRomBase ) && (aAddress < (romHeader.iRomBase + romHeader.iUncompressedSize))))  //if not in ROM

		if ( (aAddress<userChunkBase) || (aAddress) > (userChunkBase+MM::UserCodeChunk->MaxSize()) ) //and not in non-XIP code

			return KErrBadDescriptor;

	// if page was moved by defrag there may be a cache line with the

	// wrong, old physical address, so we must invalidate this first.

	InternalCache::Invalidate(KCacheSelectD, (TLinAddr)aAddress, 4);

	//Copy data and clean/invalidate caches with interrupts disabled.

	TInt irq=NKern::DisableAllInterrupts();

	switch(aSize)

		{

		case 1:

			*(TUint8*) aOldValue = *(TUint8*)aAddress;

			*(TUint8*) aAddress  = (TUint8)aValue;

			 break;

		case 2:

			*(TUint16*) aOldValue = *(TUint16*)aAddress;

			*(TUint16*) aAddress  = (TUint16)aValue;

			 break;

		default://It is 4 otherwise

			*(TUint32*) aOldValue = *(TUint32*)aAddress;

			*(TUint32*) aAddress  = (TUint32)aValue;

			 break;

		};

	CacheMaintenance::CodeChanged(aAddress, aSize, CacheMaintenance::ECodeModifier);

	NKern::RestoreInterrupts(irq);

	return KErrNone;

	}

#endif //__DEBUGGER_SUPPORT__

TInt DThread::ReadAndParseDesHeader(const TAny* aSrc, TDesHeader& aDest)

//

// Read the header of a remote descriptor.

// Enter and return with system locked

//

	{

	TInt r=KErrBadDescriptor;

	DThread* thread = TheCurrentThread;

	TRawDesHeader& header = (TRawDesHeader&)aDest;

#ifdef __DEMAND_PAGING__

retry:

	TInt pagingFault;

	XTRAP_PAGING_START(pagingFault);

	CHECK_PAGING_SAFE;

	thread->iIpcClient = this;

#endif

	const TUint32* pS=(const TUint32*)MM::CurrentAddress(this,aSrc,sizeof(TDesC8),EFalse);

	if (pS && KErrNone==Kern::SafeRead(pS,&header[0],sizeof(TUint32)))

		{

		TInt type=header[0]>>KShiftDesType8;

		static const TUint8 LengthLookup[16]={4,8,12,8,12,0,0,0,0,0,0,0,0,0,0,0};

		TInt len=LengthLookup[type];

		if(len>(TInt)sizeof(TUint32))

			{

			if(KErrNone==Kern::SafeRead(pS+1,&header[1],len-sizeof(TUint32)))

				r = type;

			// else, bad descriptor

			}

		else if(len)

			r = type;

		// else, bad descriptor

		}

#ifdef __DEMAND_PAGING__

	thread->iIpcClient = NULL;

	XTRAP_PAGING_END;

	if(pagingFault<0)

		return pagingFault; // paging error caused by bad client (I.e. 'this' thread was bad)

	if(pagingFault)

		goto retry;

#endif

	return K::ParseDesHeader(aSrc, header, aDest);

	}

DMemModelChunk* ChunkFromAddress(DThread* aThread, const TAny* aAddress)

	{

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

	DMemModelProcess::SChunkInfo* pS=pP->iChunks;

	DMemModelProcess::SChunkInfo* pC=pS+pP->iNumChunks;

	while(--pC>=pS && TUint(pC->iDataSectionBase)>TUint(aAddress)) {};

	if(pC<pS)

		return 0;

	return pC->iChunk;

	}

/**

	Open a shared chunk in which a remote address range is located.

*/

DChunk* DThread::OpenSharedChunk(const TAny* aAddress, TBool aWrite, TInt& aOffset)

	{

	NKern::LockSystem();

	DMemModelProcess* pP = (DMemModelProcess*)iOwningProcess;

	DMemModelProcess::SChunkInfo* pS=pP->iChunks;

	DMemModelProcess::SChunkInfo* pC=pS+pP->iNumChunks;

	while(--pC>=pS && TUint(pC->iDataSectionBase)>TUint(aAddress)) {};

	if(pC>=pS)

		{

		DMemModelChunk* chunk = pC->iChunk;

		if(chunk->iChunkType==ESharedKernelSingle || chunk->iChunkType==ESharedKernelMultiple)

			{

			TInt offset = (TInt)aAddress-(TInt)chunk->Base();

			if(TUint(offset)<TUint(chunk->iMaxSize) && chunk->Open()==KErrNone)

				{

				aOffset = offset;

				NKern::UnlockSystem();

				return chunk;

				}

			}

		}

	NKern::UnlockSystem();

	return 0;

	}

TInt DThread::PrepareMemoryForDMA(const TAny* aLinAddr, TInt aSize, TPhysAddr* aPhysicalPageList)

	{

	if ((iOwningProcess->iAttributes & DMemModelProcess::EFixedAddress )==0)

		return KErrNotSupported;

	Mmu& m=(Mmu&)*MmuBase::TheMmu;

	return m.PreparePagesForDMA((TLinAddr)aLinAddr, aSize, aPhysicalPageList);

	}

TInt DThread::ReleaseMemoryFromDMA(const TAny* aLinAddr, TInt aSize, TPhysAddr* aPhysicalPageList)

	{

	if ((iOwningProcess->iAttributes & DMemModelProcess::EFixedAddress )==0)

		return KErrNotSupported;

	TInt pageCount = (((TInt)aLinAddr & KPageMask) + aSize + KPageMask) >> KPageShift;

	Mmu& m=(Mmu&)*MmuBase::TheMmu;

	return m.ReleasePagesFromDMA(aPhysicalPageList, pageCount);

	}