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

//

#include <memmodel.h>

#include "mmu/mm.h"

#include "mmu/maddrcont.h"

#include "mmboot.h"

#include <kernel/cache.h>

#include "execs.h"

#define iMState		iWaitLink.iSpare1

NFastMutex TheSharedChunkLock;

#ifndef _DEBUG

const TInt KChunkGranularity = 4; // amount to grow SChunkInfo list by

const TInt KMaxChunkInfosInOneGo = 100; // max number of SChunkInfo objects to copy with System Lock held

#else // if debug...

const TInt KChunkGranularity = 1;

const TInt KMaxChunkInfosInOneGo = 1;

#endif

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

 * Process

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

DMemModelProcess::~DMemModelProcess()

	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelProcess destruct"));

	Destruct();

	}

void DMemModelProcess::Destruct()

	{

	__ASSERT_ALWAYS(!iOsAsidRefCount, MM::Panic(MM::EProcessDestructOsAsidRemaining));

	__ASSERT_ALWAYS(!iChunkCount, MM::Panic(MM::EProcessDestructChunksRemaining));

	Kern::Free(iChunks);

	__ASSERT_ALWAYS(!iSharedChunks || iSharedChunks->Count()==0, MM::Panic(MM::EProcessDestructChunksRemaining));

	delete iSharedChunks;

	DProcess::Destruct();

	}

TInt DMemModelProcess::TryOpenOsAsid()

	{

	if (__e32_atomic_tas_ord32(&iOsAsidRefCount, 1, 1, 0))

		{

		return iOsAsid;

		}

	return KErrDied;

	}

void DMemModelProcess::CloseOsAsid()

	{

	if (__e32_atomic_tas_ord32(&iOsAsidRefCount, 1, -1, 0) == 1)

		{// Last reference has been closed so free the asid.

		MM::AddressSpaceFree(iOsAsid);

		}

	}

void DMemModelProcess::AsyncCloseOsAsid()

	{

	if (__e32_atomic_tas_ord32(&iOsAsidRefCount, 1, -1, 0) == 1)

		{// Last reference has been closed so free the asid asynchronusly.

		MM::AsyncAddressSpaceFree(iOsAsid);

		}

	}

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

	{

	aChunk=NULL;

	DMemModelChunk* pC=new DMemModelChunk;

	if (!pC)

		return KErrNoMemory;

	TChunkType type = aInfo.iType;

	pC->iChunkType=type;

	TInt r=pC->SetAttributes(aInfo);

	if (r!=KErrNone)

		{

		pC->Close(NULL);

		return r;

		}

	pC->iOwningProcess=(pC->iAttributes&DMemModelChunk::EPublic)?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 && 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))

		{

		r = AddChunk(pC, EFalse);

		}

	if (r==KErrNone)

		{

		if(pC->iKernelMapping)

			aRunAddr = (TLinAddr)MM::MappingBase(pC->iKernelMapping);

		pC->iDestroyedDfc = aInfo.iDestroyedDfc;

		aChunk=(DChunk*)pC;

		}

	else

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

	return r;

	}

/**

Determine whether this process should be data paged.

@param aInfo	A reference to the create info for this process.

 */

TInt DMemModelProcess::SetPaging(const TProcessCreateInfo& aInfo)

	{

	TUint pagedFlags = aInfo.iFlags & TProcessCreateInfo::EDataPagingMask;

	// If KImageDataPaged and KImageDataUnpaged flags present then corrupt

	// Check this first to ensure that it is always verified.

	if (pagedFlags == TProcessCreateInfo::EDataPagingMask)

		{

		return KErrCorrupt;

		}

	if (aInfo.iAttr & ECodeSegAttKernel ||

		!(K::MemModelAttributes & EMemModelAttrDataPaging))

		{// Kernel process shouldn't be data paged or no data paging device installed.

		return KErrNone;

		}

	TUint dataPolicy = TheSuperPage().KernelConfigFlags() & EKernelConfigDataPagingPolicyMask;

	if (dataPolicy == EKernelConfigDataPagingPolicyAlwaysPage)

		{

		iAttributes |= EDataPaged;

		return KErrNone;

		}

	if (dataPolicy == EKernelConfigDataPagingPolicyNoPaging)

		{// No paging allowed so just return.

		return KErrNone;

		}

	if (pagedFlags == TProcessCreateInfo::EDataPaged)

		{

		iAttributes |= EDataPaged;

		return KErrNone;

		}

	if (pagedFlags == TProcessCreateInfo::EDataUnpaged)

		{// No paging set so just return.

		return KErrNone;

		}

	// Neither paged nor unpaged set so use default paging policy.

	// dataPolicy must be EKernelConfigDataPagingPolicyDefaultUnpaged or 

	// EKernelConfigDataPagingPolicyDefaultPaged.

	__NK_ASSERT_DEBUG(pagedFlags == TProcessCreateInfo::EDataPagingUnspecified);

	__NK_ASSERT_DEBUG(	dataPolicy == EKernelConfigDataPagingPolicyDefaultPaged ||

						dataPolicy == EKernelConfigDataPagingPolicyDefaultUnpaged);

	if (dataPolicy == EKernelConfigDataPagingPolicyDefaultPaged)

		{

		iAttributes |= EDataPaged;

		}

	return KErrNone;

	}

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

	{

	// Required so we can detect whether a process has been created and added 

	// to its object container by checking for iContainerID!=EProcess.

	__ASSERT_COMPILE(EProcess != 0);

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

	TInt r=KErrNone;

	if (aKernelProcess)

		{

		iAttributes |= ESupervisor;

		iOsAsid = KKernelOsAsid;

		}

	else

		{

		r = MM::AddressSpaceAlloc(iPageDir);

		if (r>=0)

			{

			iOsAsid = r;

			r = KErrNone;

			}

		}

	if (r == KErrNone)

		{// Add this process's own reference to its os asid.

		__e32_atomic_store_ord32(&iOsAsidRefCount, 1);

		}

#ifdef BTRACE_FLEXIBLE_MEM_MODEL

	BTrace8(BTrace::EFlexibleMemModel,BTrace::EAddressSpaceId,this,iOsAsid);

#endif

	__KTRACE_OPT(KPROC,Kern::Printf("OS ASID=%d, PD=%08x",iOsAsid,iPageDir));

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

	TInt r = KErrNone;

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

	if(dataBssSize)

		{

		DMemoryObject* memory;

		TMemoryObjectType memoryType = iAttributes&EDataPaged ? EMemoryObjectPaged : EMemoryObjectMovable;

		r = MM::MemoryNew(memory,memoryType,MM::BytesToPages(dataBssSize));

		if(r==KErrNone)

			{

			r = MM::MemoryAlloc(memory,0,MM::BytesToPages(dataBssSize));

			if(r==KErrNone)

				{

				r = MM::MappingNew(iDataBssMapping,memory,EUserReadWrite,OsAsid());

				}

			if(r!=KErrNone)

				MM::MemoryDestroy(memory);

			else

				{

				iDataBssRunAddress = MM::MappingBase(iDataBssMapping);

#ifdef BTRACE_FLEXIBLE_MEM_MODEL

				BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsProcessStaticData,memory,this);

#endif

				}

			}

		}

	__KTRACE_OPT(KPROC,Kern::Printf("DataBssSize=%x, ",dataBssSize));

	return r;

	}

TInt DMemModelProcess::AttachExistingCodeSeg(TProcessCreateInfo& aInfo)

	{

	TInt r = DEpocProcess::AttachExistingCodeSeg(aInfo);

	if(r==KErrNone)

		{

		// allocate virtual memory for the EXEs codeseg...

		DMemModelCodeSeg* seg = (DMemModelCodeSeg*)iTempCodeSeg;

		if(seg->iAttr&ECodeSegAttAddrNotUnique)

			{

			TUint codeSize = seg->iSize;

			TLinAddr codeAddr = seg->RamInfo().iCodeRunAddr;

			TBool isDemandPaged = seg->iAttr&ECodeSegAttCodePaged;

			// Allocate virtual memory for the code seg using the os asid.

			// No need to open a reference on os asid as process not fully 

			// created yet so it can't die and free the os asid.

			r = MM::VirtualAlloc(OsAsid(),codeAddr,codeSize,isDemandPaged);

			if(r==KErrNone)

				{

				iCodeVirtualAllocSize = codeSize;

				iCodeVirtualAllocAddress = codeAddr;

				}

			}

		}

	return r;

	}

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

	{

	DMemModelChunk* pC=(DMemModelChunk*)aChunk;

	if(pC->iOwningProcess && this!=pC->iOwningProcess)

		return KErrAccessDenied;

	TInt r = WaitProcessLock();

	if(r==KErrNone)

		{

		TInt i = ChunkIndex(pC);

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

			{

			iChunks[i].iAccessCount++;

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

			SignalProcessLock();

			return KErrNone;

			}

		r = DoAddChunk(pC,aIsReadOnly);

		SignalProcessLock();

		}

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

	return r;

	}

void M::FsRegisterThread()

	{

	TInternalRamDrive::Unlock();

	}

void ExecHandler::UnlockRamDrive()

	{

	}

EXPORT_C TLinAddr TInternalRamDrive::Base()

	{

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

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

	NKern::LockSystem();

	TLinAddr addr = (TLinAddr)pC->Base(pP);

	NKern::UnlockSystem();

	if(!addr)

		{

		Unlock();

		NKern::LockSystem();

		addr = (TLinAddr)pC->Base(pP);

		NKern::UnlockSystem();

		}

	return addr;

	}

EXPORT_C void TInternalRamDrive::Unlock()

	{

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

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

	TInt r = pP->WaitProcessLock();

	if(r==KErrNone)

		if(pP->ChunkIndex(pC)==KErrNotFound)

			r = pP->DoAddChunk(pC,EFalse);

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

	pP->SignalProcessLock();

	}

EXPORT_C void TInternalRamDrive::Lock()

	{

	}

TInt DMemModelProcess::DoAddChunk(DMemModelChunk* aChunk, TBool aIsReadOnly)

	{

	//

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

	// As the process lock is held it is safe to access iOsAsid without a reference.

	//

	__NK_ASSERT_DEBUG(ChunkIndex(aChunk)==KErrNotFound); // shouldn't be adding a chunk which is already added

	__KTRACE_OPT(KPROC,Kern::Printf("DMemModelProcess::DoAddChunk %O to %O",aChunk,this));

	// create mapping for chunk...

	DMemoryMapping* mapping;

	TMappingPermissions perm = MM::MappingPermissions

		(

		iOsAsid!=(TInt)KKernelOsAsid,	// user?

		aIsReadOnly==false, // write?

		aChunk->iAttributes&DMemModelChunk::ECode // execute?

		);

	TInt r;

	if(aChunk->iFixedBase) // HACK, kernel chunk has a fixed iBase

		r = MM::MappingNew(mapping,aChunk->iMemoryObject,perm,iOsAsid,EMappingCreateExactVirtual,(TLinAddr)aChunk->iFixedBase);

	else

		r = MM::MappingNew(mapping,aChunk->iMemoryObject,perm,iOsAsid);

	if(r!=KErrNone)

		return r;

	if(iOsAsid==0)

		aChunk->iKernelMapping = mapping;

	TLinAddr base = MM::MappingBase(mapping);

	// expand chunk info memory if required...

	if(iChunkCount==iChunkAlloc)

		{

		TInt newAlloc = iChunkAlloc+KChunkGranularity;

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

		if(r!=KErrNone)

			{

			MM::MappingDestroy(mapping);

			return r;

			}

		iChunkAlloc = newAlloc;

		}

	// insert new chunk info...

	TUint i = ChunkInsertIndex(aChunk);

	SChunkInfo* info = iChunks+i;

	SChunkInfo* infoEnd = iChunks+iChunkCount;

	NKern::LockSystem();

	++iChunkCount;

	for(;;)

		{

		// make space for new chunk info by shuffling along

		// existing infos KMaxChunkInfosInOneGo at a time...

		SChunkInfo* infoPtr = infoEnd-KMaxChunkInfosInOneGo;

		if(infoPtr<info)

			infoPtr = info;

		memmove(infoPtr+1,infoPtr,(TLinAddr)infoEnd-(TLinAddr)infoPtr);

		infoEnd = infoPtr;

		if(infoEnd<=info)

			break;

		NKern::FlashSystem();

		}

	info->iChunk = aChunk;

	info->iMapping = mapping;

	info->iAccessCount = 1;

	info->iIsReadOnly = aIsReadOnly;

	NKern::UnlockSystem();

	// add chunk to list of Shared Chunks...

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

		{

		if(!iSharedChunks)

			iSharedChunks = new RAddressedContainer(&TheSharedChunkLock,iProcessLock);

		if(!iSharedChunks)

			r = KErrNoMemory;

		else

			r = iSharedChunks->Add(base,aChunk);

		if(r!=KErrNone)

			{

			DoRemoveChunk(i);

			return r;

			}

		}

	// done OK...

	__DEBUG_EVENT(EEventUpdateProcess, this);

	return KErrNone;

	}

void DMemModelProcess::DoRemoveChunk(TInt aIndex)

	{

	__DEBUG_EVENT(EEventUpdateProcess, this);

	DMemModelChunk* chunk = iChunks[aIndex].iChunk;

	DMemoryMapping* mapping = iChunks[aIndex].iMapping;

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

		{

		// remove chunk from list of Shared Chunks...

		if(iSharedChunks)

			{

			iSharedChunks->Remove(MM::MappingBase(mapping));

#ifdef _DEBUG

			// delete iSharedChunks if it's empty, so memory leak test code passes...

			if(iSharedChunks->Count()==0)

				{

				NKern::FMWait(&TheSharedChunkLock);

				RAddressedContainer* s = iSharedChunks;

				iSharedChunks = 0;

				NKern::FMSignal(&TheSharedChunkLock);

				delete s;

				}

#endif

			}

		}

	// remove chunk from array...

	SChunkInfo* infoStart = iChunks+aIndex+1;

	SChunkInfo* infoEnd = iChunks+iChunkCount;

	NKern::LockSystem();

	for(;;)

		{

		// shuffle existing infos down KMaxChunkInfosInOneGo at a time...

		SChunkInfo* infoPtr = infoStart+KMaxChunkInfosInOneGo;

		if(infoPtr>infoEnd)

			infoPtr = infoEnd;

		memmove(infoStart-1,infoStart,(TLinAddr)infoPtr-(TLinAddr)infoStart);

		infoStart = infoPtr;

		if(infoStart>=infoEnd)

			break;

		NKern::FlashSystem();

		}

	--iChunkCount;

	NKern::UnlockSystem();

	if(mapping==chunk->iKernelMapping)

		chunk->iKernelMapping = 0;

	MM::MappingDestroy(mapping);

	}

/**

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

	// Destroy the remaining mappings and memory objects owned by this process

	MM::MappingAndMemoryDestroy(iDataBssMapping);

	if(iCodeVirtualAllocSize)