// Copyright (c) 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 <ramalloc.h>

#include "mm.h"

#include "mmu.h"

#include "mmanager.h"

#include "mobject.h"

#include "mpager.h"

#include "mmapping.h"

TInt M::RamDefragFault(TAny* /*aExceptionInfo*/)

	{// Defag faults are handled by Mmu::HandlePageFault() on the flexible memory model.

	return KErrAbort;

	} 

EXPORT_C TInt Epoc::MovePhysicalPage(TPhysAddr aOld, TPhysAddr& aNew, TRamDefragPageToMove aPageToMove)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::MovePhysicalPage");

	__KTRACE_OPT(KMMU,Kern::Printf("Epoc::MovePhysicalPage() old=%08x pageToMove=%d",aOld,aPageToMove));

	// Mark aNew as invalid if a page is moved then this will be updated.

	// However, if the page couldn't be moved or is discarded then it must be invalid.

	aNew = KPhysAddrInvalid;

	TInt r = KErrNotFound;

	switch (aPageToMove)

		{

		case ERamDefragPage_Physical :

			break;

		case ERamDefragPage_PageTable :

			{

			// Assume aOld is a linear address in current thread and get the physical

			// address of the page table that maps it and move that.

			TLinAddr linAddr = (TLinAddr) aOld;

			DMemModelThread* thread = (DMemModelThread*)TheCurrentThread;

			// Get the os asid of current thread's process so no need to open reference on it.

			TUint osAsid = ((DMemModelProcess*)thread->iOwningProcess)->OsAsid();

			TUint offsetInMapping;

			TUint mapInstanceCount;

			DMemoryMapping* mapping = MM::FindMappingInAddressSpace(osAsid,linAddr,1,offsetInMapping,mapInstanceCount);

			if (!mapping)

				return r;

			MmuLock::Lock();

			TUint memoryIndex = (offsetInMapping >> KPageShift)+ mapping->iStartIndex;

			TPte* pte = mapping->FindPageTable(linAddr, memoryIndex);

			if (mapInstanceCount != mapping->MapInstanceCount() || !pte)

				{

				MmuLock::Unlock();

				mapping->Close();

				return r;

				}

			TPhysAddr physAddr = TheMmu.LinearToPhysical((TLinAddr)pte, KKernelOsAsid);

			__NK_ASSERT_DEBUG(physAddr != KPhysAddrInvalid);

			aOld = physAddr;	// Have physical address of page table page so move it.

			MmuLock::Unlock();

			mapping->Close();

			break;

			}

		case ERamDefragPage_PageTableInfo :

			{

			// Assume aOld is a linear address in current thread and get physical 

			// address of the page table info of the page table that maps it 

			// and move that.

			TLinAddr linAddr = (TLinAddr) aOld;

			DMemModelThread* thread = (DMemModelThread*)TheCurrentThread;

			// Get the os asid of current thread's process so no need to open reference on it.

			TUint osAsid = ((DMemModelProcess*)thread->iOwningProcess)->OsAsid();

			TUint offsetInMapping;

			TUint mapInstanceCount;

			DMemoryMapping* mapping = MM::FindMappingInAddressSpace(osAsid,linAddr,1,offsetInMapping,mapInstanceCount);

			if (!mapping)

				return r;

			MmuLock::Lock();

			TUint memoryIndex = (offsetInMapping >> KPageShift)+ mapping->iStartIndex;

			TPte* pte = mapping->FindPageTable(linAddr, memoryIndex);

			if (mapInstanceCount != mapping->MapInstanceCount() || !pte)

				{

				MmuLock::Unlock();

				mapping->Close();

				return r;

				}

			SPageTableInfo* pti = SPageTableInfo::FromPtPtr(pte);

			TPhysAddr physAddr = TheMmu.LinearToPhysical((TLinAddr)pti, KKernelOsAsid);

			__NK_ASSERT_DEBUG(physAddr != KPhysAddrInvalid);

			aOld = physAddr;	// Have physical address of page table info page so move it.

			MmuLock::Unlock();

			mapping->Close();

			break;

			}

		default :

			r = KErrNotSupported;

			return r;

		}

	RamAllocLock::Lock();

	// Move the page to any RAM zone.

	r = M::MovePage(aOld, aNew, KRamZoneInvalidId, EFalse);

	RamAllocLock::Unlock();

	return r;

	}

TInt M::MovePage(TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest)

	{

	TInt r;

	// get memory object corresponding to the page...

	DMemoryObject* memory = 0;

	MmuLock::Lock();

	SPageInfo* pi = SPageInfo::SafeFromPhysAddr(aOld&~KPageMask);

	if(pi)

		{

		if (pi->PagedState() != SPageInfo::EUnpaged)

			{// The page is paged so let the pager handle it.

			return ThePager.DiscardPage(pi, aBlockZoneId, aBlockRest);

			}

		if (pi->Type()==SPageInfo::EManaged)

			memory = pi->Owner();

		}

	MmuLock::Unlock();

	// Note, whilst we hold the RamAllocLock the page can't change it's use

	// and we can safely assume that it still belongs to the memory object

	// at a fixed page index.

	// Also, as memory objects can't be destroyed whilst they still own pages

	// we can safely access this object without taking an explicit referernce,

	// i.e. we don't need to Open() the memory object.

	if (!pi)

		{// page info for aOld not found so aOld is not a RAM page...

		r = KErrArgument;

		}

	else if(!memory)

		{

		// page does not have a memory manager, so we can't move it...

		r = KErrNotSupported;

		}

	else

		{

		// move page...

		r = memory->iManager->MovePage(memory, pi, aNew, aBlockZoneId, aBlockRest);

		}

	return r;

	}