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

// 

//

#include "memmodel.h"

#include "cache_maintenance.h"

#include <mmubase.inl>

#include <ramalloc.h>

DMemModelChunk::DMemModelChunk()

	{

	}

TLinearSection* DMemModelChunk::LinearSection()

	{

	Mmu& m=Mmu::Get();

	TInt ar=(iAttributes&EAddressRangeMask);

	switch (ar)

		{

		case EAddressLocal:			return ((DMemModelProcess*)iOwningProcess)->iLocalSection;

		case EAddressFixed:			return NULL;

		case EAddressShared:		return m.iSharedSection;

		case EAddressUserGlobal:	return m.iUserGlobalSection;

		case EAddressKernel:		return m.iKernelSection;

		}

	MM::Panic(MM::EChunkBadAddressRange);

	return NULL;

	}

void DMemModelChunk::Destruct()

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("DMemModelChunk destruct %O",this));

	if (iPageTables)

		{

#ifdef _DEBUG

		TInt r;

#define SET_R_IF_DEBUG(x)	r = (x)

#else

#define SET_R_IF_DEBUG(x)	(void)(x)

#endif

		if (iAttributes & EDisconnected)

			SET_R_IF_DEBUG(Decommit(0,iMaxSize));

		else if (iAttributes & EDoubleEnded)

			SET_R_IF_DEBUG(AdjustDoubleEnded(0,0));

		else

			SET_R_IF_DEBUG(Adjust(0));

		__ASSERT_DEBUG(r==KErrNone, MM::Panic(MM::EDecommitFailed));

#ifdef _DEBUG

		// check all page tables have been freed...

		Mmu& m=Mmu::Get();

		TInt nPdes=(iMaxSize+m.iChunkMask)>>m.iChunkShift;

		for(TInt i=0; i<nPdes; i++)

			{

			__NK_ASSERT_DEBUG(iPageTables[i]==0xffff);

			}

#endif

		}

	if (iBase)

		{

		TLinearSection* s=LinearSection();

		if(s)

			{

			Mmu::Wait();

			__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::~DMemModelChunk remove region"));

			Mmu& m=Mmu::Get();

			s->iAllocator.Free( (TLinAddr(iBase)-s->iBase)>>m.iChunkShift, iMaxSize>>m.iChunkShift);

			Mmu::Signal();

			}

		}

	delete iOsAsids;

	Kern::Free(iPageTables);

	delete iPageBitMap;

	delete iPermanentPageBitMap;

	if(iKernelMirror)

		iKernelMirror->Close(NULL);

	TDfc* dfc = iDestroyedDfc;

	if (dfc)

		dfc->QueueOnIdle();

	__KTRACE_OPT(KMEMTRACE, {Mmu::Wait(); Kern::Printf("MT:D %d %x %O",NTickCount(),this,this);Mmu::Signal();});

#ifdef BTRACE_CHUNKS

	BTraceContext4(BTrace::EChunks,BTrace::EChunkDestroyed,this);

#endif

	}

TInt DMemModelChunk::Close(TAny* aPtr)

	{

	if (aPtr)

		{

		DMemModelProcess* pP=(DMemModelProcess*)aPtr;

		if ((iAttributes&EMapTypeMask)==EMapTypeLocal)

			pP=(DMemModelProcess*)iOwningProcess;

		pP->RemoveChunk(this);

		}

	TInt r=Dec();

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Close %d %O",r,this));

	__NK_ASSERT_DEBUG(r > 0); // Should never be negative.

	if (r==1)

		{

		K::ObjDelete(this);

		return EObjectDeleted;

		}

	return 0;

	}

TUint8* DMemModelChunk::Base(DProcess* aProcess)

	{

	return iBase;

	}

TInt DMemModelChunk::DoCreate(SChunkCreateInfo& aInfo)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O DoCreate att=%08x",this,iAttributes));

	__ASSERT_COMPILE(!(EMMChunkAttributesMask & EChunkAttributesMask));

	if (aInfo.iMaxSize<=0)

		return KErrArgument;

	if (iKernelMirror)

		{

		iKernelMirror->iAttributes |= iAttributes|EMemoryNotOwned;

		TInt r=iKernelMirror->DoCreate(aInfo);

		if(r!=KErrNone)

			return r;

		}

	Mmu& m=Mmu::Get();

	TInt nPdes=(aInfo.iMaxSize+m.iChunkMask)>>m.iChunkShift;

	iMaxSize=nPdes<<m.iChunkShift;

	iMapAttr = aInfo.iMapAttr;

	SetupPermissions();

	TInt mapType=iAttributes & EMapTypeMask;

	if (mapType==EMapTypeShared)

		{

		iOsAsids=TBitMapAllocator::New(m.iNumOsAsids,ETrue);

		if (!iOsAsids)

			return KErrNoMemory;

		}

	TInt maxpages=iMaxSize>>m.iPageShift;

	if (iAttributes & EDisconnected)

		{

		TBitMapAllocator* pM=TBitMapAllocator::New(maxpages,ETrue);

		if (!pM)

			return KErrNoMemory;

		iPageBitMap=pM;

		__KTRACE_OPT(KMMU,Kern::Printf("PageBitMap at %08x, MaxPages %d",pM,maxpages));

		}

	if(iChunkType==ESharedKernelSingle || iChunkType==ESharedKernelMultiple)

		{

		TBitMapAllocator* pM=TBitMapAllocator::New(maxpages,ETrue);

		if (!pM)

			return KErrNoMemory;

		iPermanentPageBitMap = pM;

		}

	iPageTables=(TUint16*)Kern::Alloc(nPdes*sizeof(TUint16));

	if (!iPageTables)

		return KErrNoMemory;

	memset(iPageTables,0xff,nPdes*sizeof(TUint16));

	MmuBase::Wait();

	TInt r=AllocateAddress();

	__KTRACE_OPT(KMEMTRACE,Kern::Printf("MT:C %d %x %O",NTickCount(),this,this));

	MmuBase::Signal();

#ifdef BTRACE_CHUNKS

	TKName nameBuf;

	Name(nameBuf);

	BTraceContextN(BTrace::EChunks,BTrace::EChunkCreated,this,iMaxSize,nameBuf.Ptr(),nameBuf.Size());

	if(iOwningProcess)

		BTrace8(BTrace::EChunks,BTrace::EChunkOwner,this,iOwningProcess);

	BTraceContext12(BTrace::EChunks,BTrace::EChunkInfo,this,iChunkType,iAttributes);

#endif

	return r;

	}

void DMemModelChunk::ClaimInitialPages()

	{

	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O ClaimInitialPages()",this));

	Mmu& m=Mmu::Get();

	TInt offset=0;

	TUint32 ccp=K::CompressKHeapPtr(this);

	NKern::LockSystem();

	while(offset<iSize)

		{

		TInt ptid=m.PageTableId(TLinAddr(iBase)+offset);

		__ASSERT_ALWAYS(ptid>=0,MM::Panic(MM::EClaimInitialPagesBadPageTable));

		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x PTID=%d",offset,ptid));

		iPageTables[offset>>m.iChunkShift]=ptid;

		SPageTableInfo& ptinfo = m.PtInfo(ptid);

		ptinfo.SetChunk(ccp,offset>>m.iChunkShift);

		TPte* pPte=(TPte*)m.PageTableLinAddr(ptid);

		TInt i;

		TInt np = 0;

		TInt flashCount = MM::MaxPagesInOneGo;

		for (i=0; i<m.iChunkSize>>m.iPageShift; ++i, offset+=m.iPageSize)

			{

			if(--flashCount<=0)

				{

				flashCount = MM::MaxPagesInOneGo;

				NKern::FlashSystem();

				}

			TPte pte=pPte[i];

			if (m.PteIsPresent(pte))

				{

				++np;

				TPhysAddr phys=m.PtePhysAddr(pte, i);

				__KTRACE_OPT(KMMU,Kern::Printf("Offset %x phys %08x",offset,phys));

				SPageInfo* info = SPageInfo::SafeFromPhysAddr(phys);

				if(info)

					{

					info->SetChunk(this,offset>>m.iPageShift);

#ifdef BTRACE_KERNEL_MEMORY

					--Epoc::KernelMiscPages; // page now owned by chunk, and is not 'miscelaneous'

#endif

					}

				}

			}

		ptinfo.iCount = np;

		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x PTID %d NP %d", offset, ptid, np));

		}

	NKern::UnlockSystem();

	}

void DMemModelChunk::SetFixedAddress(TLinAddr aAddr, TInt aInitialSize)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O SetFixedAddress %08x size %08x",this,aAddr,aInitialSize));

	iBase=(TUint8*)aAddr;

	iSize=Mmu::RoundToPageSize(aInitialSize);

	ClaimInitialPages();

	}

TInt DMemModelChunk::Reserve(TInt aInitialSize)

//

// Reserve home section address space for a chunk

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O Reserve() size %08x",this,aInitialSize));

	iSize=Mmu::RoundToPageSize(aInitialSize);

	ClaimInitialPages();

	return KErrNone;

	}

TInt DMemModelChunk::Adjust(TInt aNewSize)

//

// Adjust a standard chunk.

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust %08x",aNewSize));

	if (iAttributes & (EDoubleEnded|EDisconnected))

		return KErrGeneral;

	if (aNewSize<0 || aNewSize>iMaxSize)

		return KErrArgument;

	TInt r=KErrNone;

	TInt newSize=Mmu::RoundToPageSize(aNewSize);

	if (newSize!=iSize)

		{

		Mmu::Wait();

		if (newSize>iSize)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust growing"));

			r=DoCommit(iSize,newSize-iSize);

			}

		else if (newSize<iSize)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust shrinking"));

			DoDecommit(newSize,iSize-newSize);

			}

		Mmu::Signal();

		}

	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O adjusted to %x base %08x",this,iSize,iBase));

	return r;

	}

TInt DMemModelChunk::Address(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress)

	{

	if(!iPermanentPageBitMap)

		return KErrAccessDenied;

	if(TUint(aOffset)>=TUint(iMaxSize))

		return KErrArgument;

	if(TUint(aOffset+aSize)>TUint(iMaxSize))

		return KErrArgument;

	if(aSize<=0)

		return KErrArgument;

	TInt pageShift = Mmu::Get().iPageShift;

	TInt start = aOffset>>pageShift;

	TInt size = ((aOffset+aSize-1)>>pageShift)-start+1;

	if(iPermanentPageBitMap->NotAllocated(start,size))

		return KErrNotFound;

	aKernelAddress = (TLinAddr)iKernelMirror->iBase+aOffset;

	return KErrNone;

	}

TInt DMemModelChunk::PhysicalAddress(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress, TUint32& aPhysicalAddress, TUint32* aPhysicalPageList)

	{

	TInt r=Address(aOffset,aSize,aKernelAddress);

	if(r!=KErrNone)

		return r;

	return Mmu::Get().LinearToPhysical(aKernelAddress,aSize,aPhysicalAddress,aPhysicalPageList);

	}

void DMemModelChunk::Substitute(TInt aOffset, TPhysAddr aOldAddr, TPhysAddr aNewAddr)

	{

	// Substitute the page mapping at aOffset with aNewAddr.

	// Enter and leave with system locked.

	// This is sometimes called with interrupts disabled and should leave them alone.

	Mmu& m = Mmu::Get();

	__ASSERT_ALWAYS(iKernelMirror==NULL,MM::Panic(MM::EChunkRemapUnsupported));

	TInt ptid=iPageTables[aOffset>>m.iChunkShift];

	if(ptid==0xffff)

		MM::Panic(MM::EChunkRemapNoPageTable);

	// Permissions for global code will have been overwritten with ApplyPermissions

	// so we can't trust iPtePermissions for those chunk types

	TPte perms;

   	if(iChunkType==EKernelCode)

		perms = m.iKernelCodePtePerm;

	else if(iChunkType==EDll)

		perms = m.iGlobalCodePtePerm;

	else

		perms = iPtePermissions;

	m.RemapPage(ptid, (TLinAddr)iBase+aOffset, aOldAddr, aNewAddr, perms, iOwningProcess);

	}

/**

Get the movability type of the chunk's pages

@return How movable the chunk's pages are

*/

TZonePageType DMemModelChunk::GetPageType()

	{

	// Shared chunks have their physical addresses available

	if (iChunkType == ESharedKernelSingle ||

		iChunkType == ESharedKernelMultiple || 

		iChunkType == ESharedIo ||

		iChunkType == ESharedKernelMirror ||

		iChunkType == EKernelMessage ||

		iChunkType == EKernelData)	// Don't move kernel heap pages as DMA may be accessing them.

		{

		return EPageFixed;

		}

	// All other types of chunk are movable

	return EPageMovable;

	}

TInt DMemModelChunk::DoCommit(TInt aOffset, TInt aSize, TCommitType aCommitType, TUint32* aExtraArg)

	{

	// Commit more RAM to a chunk at a specified offset

	// enter and leave with system unlocked

	// must hold RamAlloc mutex before calling this function

	__ASSERT_MUTEX(MmuBase::RamAllocatorMutex);

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoCommit %x+%x type=%d extra=%08x",aOffset,aSize,aCommitType,aExtraArg));

	TInt offset=aOffset;

	TInt endOffset=offset+aSize;

	TInt newPtId=-1;

	Mmu& m = Mmu::Get();

	DRamAllocator& a = *m.iRamPageAllocator;

	TInt r=KErrNone;

	TPhysAddr pageList[KMaxPages];

	TPhysAddr* pPageList=0; 	// In case of discontiguous commit it points to the list of physical pages.

	TPhysAddr nextPage=0; 		// In case of contiguous commit, it points to the physical address to commit

	SPageInfo::TType type = SPageInfo::EChunk;

	// Set flag to indicate if RAM should be cleared before being committed.

	// Note, EDll, EUserCode are covered in the code segment, in order not to clear

	// the region overwritten by the loader

	TBool clearRam =	iChunkType==EUserData

					 || iChunkType==EDllData

					 || iChunkType==EUserSelfModCode

					 || iChunkType==ESharedKernelSingle

					 || iChunkType==ESharedKernelMultiple

					 || iChunkType==ESharedIo

					 || iChunkType==ERamDrive;

	TBool ownsMemory = !(iAttributes&EMemoryNotOwned);

	TBool physicalCommit = aCommitType&DChunk::ECommitPhysicalMask;

	if(ownsMemory)

		{

		if(physicalCommit)

			return KErrNotSupported;

		}

	else

		{

		if(!physicalCommit && aCommitType != DChunk::ECommitVirtual)

			return KErrNotSupported;

		type = SPageInfo::EInvalid;	// to indicate page info not to be updated

		}

	switch(aCommitType)

		{

	case DChunk::ECommitDiscontiguous:

		// No setup to do

		break;

	case DChunk::ECommitContiguous:

		{

		// Allocate a block of contiguous RAM from the free pool

		TInt numPages=(endOffset-offset)>>m.iPageShift;

		if (r!=KErrNone)

			return r;

		if(clearRam)

			m.ClearPages(numPages, (TPhysAddr*)(nextPage|1), iClearByte);  // clear RAM if required

		*aExtraArg = nextPage;	// store physical address of RAM as return argument

		}

		break;

	case DChunk::ECommitDiscontiguousPhysical:

		{

		pPageList = aExtraArg;				// use pages given given to us

		// Check address of pages are multiples of page size...

		TInt numPages=(endOffset-offset)>>m.iPageShift;

		TUint32* ptr = aExtraArg;

		TUint32* endPtr = aExtraArg+numPages;

		if(ptr>=endPtr)

			return KErrNone;				// Zero size commit is OK

		TPhysAddr pageBits = 0;

		do

			pageBits |= *ptr++;

		while(ptr<endPtr);

		if(pageBits&(m.iPageSize-1))

			return KErrArgument;			// all addresses must be multiple of page size

		}

		break;

	case DChunk::ECommitContiguousPhysical:

		nextPage = (TPhysAddr)aExtraArg;	// we have been given the physical address to use

		if(nextPage&(m.iPageSize-1))

			return KErrArgument;			// address must be multiple of page size

		break;

	case DChunk::ECommitVirtual:

#ifndef __MARM__

		return KErrNotSupported;

#endif

		break;

	default:

		return KErrNotSupported;

		}

	while(offset<endOffset)

		{

		TInt np=(endOffset-offset)>>m.iPageShift;	// pages remaining to satisfy request

		TInt npEnd=(m.iChunkSize-(offset&m.iChunkMask))>>m.iPageShift;// number of pages to end of page table

		if (np>npEnd)

			np=npEnd;								// limit to single page table

		if (np>MM::MaxPagesInOneGo)

			np=MM::MaxPagesInOneGo;					// limit

		TInt ptid=iPageTables[offset>>m.iChunkShift];

		newPtId=-1;

		if (ptid==0xffff)

			{

			// need to allocate a new page table

			newPtId=m.AllocPageTable();

			if (newPtId<0)

				{

				r=KErrNoMemory;

				break;	// Exit the loop. Below, we'll free all ram

						// that is allocated in the previous loop passes.

				}

			ptid=newPtId;

			}

		if(aCommitType==DChunk::ECommitDiscontiguous)

			{

			pPageList = pageList;

			r=m.AllocRamPages(pPageList,np, GetPageType());	// try to allocate pages

			if (r!=KErrNone)  //If fail, clean up what was allocated in this loop.

				{

				if (newPtId>=0)

					m.FreePageTable(newPtId);

					break;	// Exit the loop. Below, we'll free all ram

							// that is allocated in the previous loop passes.

				}

			if(clearRam)

				m.ClearPages(np, pPageList, iClearByte);	// clear RAM if required

			}

		TInt commitSize = np<<m.iPageShift;

		// In shared chunks (visible to both user and kernel side), it is always kernel side

		// to be mapped the first. Decommiting will go in reverse order.

		if(iKernelMirror)

			{

			// Map the same memory into the kernel mirror chunk

			if(pPageList)

				r = iKernelMirror->DoCommit(offset,commitSize,ECommitDiscontiguousPhysical,pPageList);

			else

				r = iKernelMirror->DoCommit(offset,commitSize,ECommitContiguousPhysical,(TUint32*)nextPage);

			__KTRACE_OPT(KMMU,Kern::Printf("iKernelMirror->DoCommit returns %d",r));

			if(r!=KErrNone) //If fail, clean up what was allocated in this loop.

				{

				if(aCommitType==DChunk::ECommitDiscontiguous)

					m.FreePages(pPageList,np,EPageFixed);

				if (newPtId>=0)

					m.FreePageTable(newPtId);

				break;	// Exit the loop. Below, we'll free all ram

						// that is allocated in the previous loop passes.

				}

			}

		// Commit the memory.