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

// 

//

#include "memmodel.h"

#include "cache_maintenance.h"

#include <mmubase.inl>

#include <ramalloc.h>

DMemModelChunk::DMemModelChunk()

	{

	}

void DMemModelChunk::Destruct()

	{

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

	Mmu& m = Mmu::Get();

	TInt nPdes=iMaxSize>>m.iChunkShift;

	if (nPdes<=32 || iPdeBitMap!=NULL)

		{

		if ((iAttributes & EDisconnected) && iPageBitMap!=NULL)

			Decommit(0,iMaxSize);

		else if (iAttributes & EDoubleEnded)

			AdjustDoubleEnded(0,0);

		else

			Adjust(0);

		}

	if ((iAttributes&EFixedAddress) && iHomeRegionBase>=m.iKernelSection->iBase)

		{

		Mmu::Wait();

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

		if (TLinAddr(iBase)==iHomeBase)

			iBase=NULL;

		DeallocateHomeAddress();	// unlink from home section queue

		iHomeRegionBase=0;

		iHomeBase=0;

		Mmu::Signal();

		}

	if ((iMaxSize>>m.iChunkShift) > 32)

		{

		TAny* pM = __e32_atomic_swp_ord_ptr(&iPdeBitMap, 0);

		Kern::Free(pM);

		}

	TBitMapAllocator* pM = (TBitMapAllocator*)__e32_atomic_swp_ord_ptr(&iPageBitMap, 0);

	delete pM;

	pM = (TBitMapAllocator*)__e32_atomic_swp_ord_ptr(&iPermanentPageBitMap, 0);

	delete pM;

	TDfc* dfc = (TDfc*)__e32_atomic_swp_ord_ptr(&iDestroyedDfc, 0);

	if(dfc)

		dfc->Enque();

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

		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)

	{

	__ASSERT_COMPILE(!(EMMChunkAttributesMask & EChunkAttributesMask));

	if (aInfo.iMaxSize<=0)

		return KErrArgument;

	Mmu& m=Mmu::Get();

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

	iMaxSize=nPdes<<m.iChunkShift;

	iMapAttr = aInfo.iMapAttr;

	SetupPermissions();

	if (nPdes>32)

		{

		TInt words=(nPdes+31)>>5;

		iPdeBitMap=(TUint32*)Kern::Alloc(words*sizeof(TUint32));

		if (!iPdeBitMap)

			return KErrNoMemory;

		memclr(iPdeBitMap, words*sizeof(TUint32));

		}

	else

		iPdeBitMap=NULL;

	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;

		}

	__KTRACE_OPT(KMEMTRACE, {Mmu::Wait();Kern::Printf("MT:C %d %x %O",NTickCount(),this,this);Mmu::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 KErrNone;

	}

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.GetPageTableId(TLinAddr(iBase)+offset);

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

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

		AddPde(offset);

		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* pi = SPageInfo::SafeFromPhysAddr(phys);

				if (pi)

					{

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

	__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));

	}

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

	{

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

	iHomeRegionOffset=0;

	iHomeRegionBase=aAddr;

	iHomeBase=aAddr;

	iBase=(TUint8*)aAddr;

	iHomeRegionSize=iMaxSize;

	iAttributes|=EFixedAddress;

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

	iHomeRegionOffset=0;

	if (!K::Initialising)

		Mmu::Wait();

	iHomeRegionBase=AllocateHomeAddress(iMaxSize);

	if (!K::Initialising)

		Mmu::Signal();

	iHomeBase=iHomeRegionBase;

	iBase=(TUint8*)iHomeRegionBase;

	if (iHomeRegionBase==0)

		return KErrNoMemory;

	iSize=Mmu::RoundToPageSize(aInitialSize);

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O address %08x",this,iHomeRegionBase));

	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 home %08x",this,iSize,iBase,iHomeRegionBase));

	return r;

	}

TInt DMemModelChunk::ExpandHomeRegion(TInt aOffset, TInt aSize)

	{

	// Ensure that the chunk's home region is big enough to accommodate extra RAM being committed

	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O ExpandHomeRegion(%x,%x)",this,aOffset,aSize));

	Mmu& m = Mmu::Get();

	TBool lowerLimitOk=(aOffset>=iHomeRegionOffset && aOffset<=iHomeRegionOffset+iHomeRegionSize);

	TBool upperLimitOk=(aOffset+aSize>=iHomeRegionOffset && aOffset+aSize<=iHomeRegionOffset+iHomeRegionSize);

	if (lowerLimitOk && upperLimitOk)

		return KErrNone;	// no change required

	TInt newLowerLimit;

	TInt newUpperLimit;

	if (iHomeRegionSize)

		{

		newLowerLimit=Min(iHomeRegionOffset,aOffset);

		newUpperLimit=Max(iHomeRegionOffset+iHomeRegionSize,aOffset+aSize);

		}

	else

		{

		newLowerLimit=aOffset;

		newUpperLimit=aOffset+aSize;

		}

	newLowerLimit &= ~m.iChunkMask;

	newUpperLimit = (newUpperLimit+m.iChunkMask)&~m.iChunkMask;

	TInt newHomeRegionSize=newUpperLimit-newLowerLimit;

	__KTRACE_OPT(KMMU,Kern::Printf("newLowerLimit=%x, newUpperLimit=%x",newLowerLimit,newUpperLimit));

	if (newHomeRegionSize>iMaxSize)

		return KErrArgument;

	TLinAddr newHomeRegionBase;

	if (iHomeRegionSize==0)

		newHomeRegionBase=AllocateHomeAddress(newHomeRegionSize);

	else

		newHomeRegionBase=ReallocateHomeAddress(newHomeRegionSize);

	__KTRACE_OPT(KMMU,Kern::Printf("newHomeRegionBase=%08x",newHomeRegionBase));

	if (newHomeRegionBase==0)

		return KErrNoMemory;

	TInt deltaOffset=iHomeRegionOffset-newLowerLimit;

	TLinAddr newHomeBase=newHomeRegionBase-newLowerLimit;

	TLinAddr translatedHomeBase=newHomeRegionBase+deltaOffset;

	// lock the kernel while we change the chunk's home region

	// Note: The new home region always contains the original home region, so

	// if we reach here, it must be strictly larger.

	NKern::LockSystem();

	if (iNumPdes && iHomeRegionBase!=translatedHomeBase)

		{

		TLinAddr oldBase=TLinAddr(iBase);

		if (oldBase==iHomeBase)

			{

			// chunk is currently at home, so must move it

			// Note: this operation must cope with overlapping initial and final regions

			m.GenericFlush(Mmu::EFlushDMove);		// preemption could occur here...

			if (TLinAddr(iBase)==iHomeBase)	// ...so need to check chunk is still at home address

				{

				m.MoveChunk(iHomeRegionBase,translatedHomeBase,iNumPdes);

				iBase=(TUint8*)newHomeBase;

				MoveCurrentPdes(iHomeRegionBase,translatedHomeBase);

				MoveHomePdes(iHomeRegionBase,translatedHomeBase);

				}

			}

		else

			{

			MoveHomePdes(iHomeRegionBase,translatedHomeBase);

			}

		__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::ExpandHomeRegion moved home base from %08x to %08x",

							iHomeRegionBase,newHomeRegionBase));

		}

	if (!iBase)

		iBase=(TUint8*)newHomeBase;

	iHomeRegionBase=newHomeRegionBase;

	iHomeRegionOffset=newLowerLimit;

	iHomeBase=newHomeBase;

	__KTRACE_OPT(KMMU,Kern::Printf("Final iHomeRegionBase=%08x, iHomeRegionOffset=%08x",iHomeRegionBase,iHomeRegionOffset));

	__KTRACE_OPT(KMMU,Kern::Printf("Final iHomeRegionSize=%08x, iBase=%08x, iHomeBase=%08x",iHomeRegionSize,iBase,iHomeBase));

	__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));

	NKern::UnlockSystem();

	return KErrNone;

	}

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

	// Called with the system lock held.

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Substitute %x %08x %08x",aOffset,aOldAddr,aNewAddr));

	Mmu& m = Mmu::Get();

	TLinAddr addr=(TLinAddr)iBase+aOffset;

	TInt ptid=m.GetPageTableId(addr);

	if(ptid<0)

		MM::Panic(MM::EChunkRemapNoPageTable);

	m.RemapPage(ptid, addr, aOldAddr, aNewAddr, iPtePermissions, iOwningProcess);

	if(iChunkType==EKernelCode || iChunkType==EDll || iChunkType==EUserSelfModCode)

		m.SyncCodeMappings();

	}

/**

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

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

	TPhysAddr nextPage=0;

	TUint32 ccp=K::CompressKHeapPtr(this);

	SPageInfo::TType type = SPageInfo::EChunk;

	if (iHomeRegionSize==0 || (iAttributes&EFixedAddress)==0)

		{

		r=ExpandHomeRegion(aOffset,aSize);

		if (r!=KErrNone)

			return r;

		}

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

			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;

		r=m.AllocContiguousRam(numPages<<m.iPageShift, nextPage, GetPageType(), 0);

		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;

#ifdef __MARM__

	case DChunk::ECommitVirtual:

		break;

#endif

	default:

		return KErrNotSupported;

		}

	// Commit memory a bit at a time (so system lock is only needs to be held for limited time)

	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

		NKern::LockSystem();						// lock the system while we look at the page directory

		TLinAddr addr=(TLinAddr)iBase+offset;		// current address

		TInt ptid=m.GetPageTableId(addr);			// get page table ID if a page table is already assigned here

		NKern::UnlockSystem();						// we can now unlock the system

		newPtId=-1;

		if (ptid<0)

			{