// Copyright (c) 2007-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 "mm.h"

#include "mmu.h"

#include "mobject.h"

#include "mmapping.h"

#include "mmanager.h"

#include "mpdalloc.h"

#include "mptalloc.h"

#include "mpager.h"

#include "maddressspace.h"

//

// DMutexPool

//

DMutexPool::~DMutexPool()

	{

	TUint i;

	for(i=0; i<iCount; ++i)

		{

		DMutex* mutex = iMembers[i].iMutex;

		if(mutex)

			mutex->Close(0);

		}

	Kern::Free(iMembers);

	}

TInt DMutexPool::Create(TUint aCount, const TDesC* aName, TUint aOrder)

	{

	if(aCount>EMaxPoolSize)

		return KErrTooBig;

	iMembers = (SMember*)Kern::AllocZ(aCount*sizeof(SMember));

	if(!iMembers)

		return KErrNoMemory;

	iCount = aCount;

	TInt r = KErrNone;

	TUint i;

	for(i=0; i<aCount; ++i)

		{

		TKName name;

		if(aName)

			{

			name = *aName;

			name.AppendNum(i);

			}

		K::MutexCreate(iMembers[i].iMutex, name, NULL, EFalse, aOrder);

		if(r!=KErrNone)

			break;

		}

	return r;

	}

/**

@class DMutexPool

@details

The cookie used for dynamically assigned mutexes is broken into three bit fields:

- Bit 0, always set. (To distinguish the cookie from a proper DMutex*).

- Bits 1 through #KMutexPoolIndexBits, these contain the index of the assigned

  mutex within DMutexPool::iMembers.

- Bits (#KMutexPoolIndexBits+1) through 31, the count of the number of threads waiting

  for this particular mutex assignment. When this reaches zero, the mutex can

  be unassigned.

*/

/**

Number of bits used to contain the index value of a dynamically assigned pool mutex.

*/

const TUint KMutexPoolIndexBits = 7;

const TUint KMutexPoolIndexMask = ((1<<KMutexPoolIndexBits)-1)<<1;

const TUint KMutexPoolWaitCountIncrement = 1<<(KMutexPoolIndexBits+1);

__ASSERT_COMPILE(DMutexPool::EMaxPoolSize<=TUint(KMutexPoolIndexMask/2+1)); // required for algorithm correctness

__ASSERT_COMPILE(DMutexPool::EMaxPoolSize<=64); // required to avoid excessive system lock hold time

void DMutexPool::Wait(DMutex*& aMutexRef)

	{

	NKern::LockSystem();

	TUintPtr poolMutex = (TUintPtr)aMutexRef;

	if(!poolMutex)

		{

		// try and find a free mutex, else use the next one...

		TUint next = iNext;

		do

			{

			if(iMembers[next].iUseCount==0)

				break;

			if(++next>=iCount)

				next = 0;

			}

		while(next!=iNext);

		// use found mutex...

		++iMembers[next].iUseCount;

		poolMutex = (next*2)+1; // mutex index*2 | 1

		// update next...

		if(++next>=iCount)

			next = 0;

		iNext = next;

		}

	DMutex* mutex = (DMutex*)poolMutex;

	if(poolMutex&1)

		{

		// mutex is a pool mutex, get pointer, and update wait count...

		SMember* member = &iMembers[(poolMutex&KMutexPoolIndexMask)>>1];

		mutex = member->iMutex;

		poolMutex += KMutexPoolWaitCountIncrement;

		__NK_ASSERT_ALWAYS(poolMutex>=KMutexPoolWaitCountIncrement);

		aMutexRef = (DMutex*)poolMutex;

		}

	mutex->Wait();

	NKern::UnlockSystem();

	}

void DMutexPool::Signal(DMutex*& aMutexRef)

	{

	NKern::LockSystem();

	TUintPtr poolMutex = (TUintPtr)aMutexRef;

	__NK_ASSERT_ALWAYS(poolMutex);

	DMutex* mutex = (DMutex*)poolMutex;

	if(poolMutex&1)

		{

		// mutex is a pool mutex, get pointer, and update wait count...

		SMember* member = &iMembers[(poolMutex&KMutexPoolIndexMask)>>1];

		mutex = member->iMutex;

		__NK_ASSERT_ALWAYS(poolMutex>=KMutexPoolWaitCountIncrement);

		poolMutex -= KMutexPoolWaitCountIncrement;

		if(poolMutex<KMutexPoolWaitCountIncrement)

			{

			--member->iUseCount;

			poolMutex = 0;

			}

		aMutexRef = (DMutex*)poolMutex;

		}

	mutex->Signal();

	}

TBool DMutexPool::IsHeld(DMutex*& aMutexRef)

	{

	TBool held = false;

	NKern::LockSystem();

	TUintPtr poolMutex = (TUintPtr)aMutexRef;

	if(poolMutex)

		{

		DMutex* mutex = (DMutex*)poolMutex;

		if(poolMutex&1)

			{

			SMember* member = &iMembers[(poolMutex&KMutexPoolIndexMask)>>1];

			mutex = member->iMutex;

			}

		held = mutex->iCleanup.iThread==&Kern::CurrentThread();

		}

	NKern::UnlockSystem();

	return held;

	}

//

// DReferenceCountedObject

//

DReferenceCountedObject::~DReferenceCountedObject()

	{

	__NK_ASSERT_DEBUG(iReferenceCount==0);

	}

void DReferenceCountedObject::Open()

	{

	__ASSERT_CRITICAL

	TBool ok = __e32_atomic_tas_ord32(&iReferenceCount, 1, 1, 0);

	__NK_ASSERT_ALWAYS(ok);

	}

TBool DReferenceCountedObject::TryOpen()

	{

	__ASSERT_CRITICAL

	TBool ok = __e32_atomic_tas_ord32(&iReferenceCount, 1, 1, 0);

	return ok;

	}

TBool DReferenceCountedObject::CheckCloseIsSafe()

	{

	__ASSERT_CRITICAL

#ifdef _DEBUG

	NFastMutex* fm = NKern::HeldFastMutex();

	if(fm)

		{

		Kern::Printf("DReferenceCountedObject[0x%08x]::Close() fast mutex violation %M",this,fm);

		return false;

		}

	SDblQue& ml = TheCurrentThread->iMutexList;

	if(!ml.IsEmpty())

		{

		DMutex* m = _LOFF(ml.First(), DMutex, iOrderLink);

		if(m->iOrder<KMutexOrdKernelHeap)

			{

			Kern::Printf("DReferenceCountedObject[0x%08x]::Close() mutex order violation holding mutex %O",this,m);

			return false;

			}

		}

#endif

	return true;

	}

TBool DReferenceCountedObject::CheckAsyncCloseIsSafe()

	{

	__ASSERT_CRITICAL

#ifdef _DEBUG

	NFastMutex* fm = NKern::HeldFastMutex();

	if(fm)

		{

		Kern::Printf("DReferenceCountedObject[0x%08x]::AsyncClose() fast mutex violation %M",this,fm);

		return false;

		}

#endif

	return true;

	}

void DReferenceCountedObject::Close()

	{

	__ASSERT_CRITICAL

	__NK_ASSERT_DEBUG(CheckCloseIsSafe());

	__NK_ASSERT_DEBUG(iReferenceCount>0);

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

		delete this;

	}

void DReferenceCountedObject::AsyncClose()

	{

	__ASSERT_CRITICAL

	__NK_ASSERT_DEBUG(CheckAsyncCloseIsSafe());

	__NK_ASSERT_DEBUG(iReferenceCount>0);

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

		AsyncDelete();

	}

//

// Memory object functions

//

TInt MM::MemoryNew(DMemoryObject*& aMemory, TMemoryObjectType aType, TUint aPageCount, TMemoryCreateFlags aCreateFlags, TMemoryAttributes aAttributes)

	{

	TRACE(("MM::MemoryNew(?,0x%08x,0x%08x,0x%08x,0x%08x)",aType,aPageCount,aCreateFlags,*(TUint32*)&aAttributes));

	DMemoryManager* manager;

	if(aCreateFlags&EMemoryCreateCustomManager)

		manager = (DMemoryManager*)aType;

	else

		{

		switch(aType)

			{

		case EMemoryObjectUnpaged:

			manager = TheUnpagedMemoryManager;

			break;

		case EMemoryObjectMovable:

			manager = TheMovableMemoryManager;

			break;

		case EMemoryObjectPaged:

			manager = TheDataPagedMemoryManager;

			break;

		case EMemoryObjectDiscardable:

			manager = TheDiscardableMemoryManager;

			break;

		case EMemoryObjectHardware:

			manager = TheHardwareMemoryManager;

			break;

		default:

			manager = 0;

			__NK_ASSERT_DEBUG(0);

			break;

			}

		}

	TMemoryCreateFlags flags = (TMemoryCreateFlags)(aCreateFlags&~(EMemoryCreateDemandPaged));

	TInt r = manager->New(aMemory,aPageCount,aAttributes,flags);

	TRACE(("MM::MemoryNew returns %d, aMemory=0x%08x",r,aMemory));

#ifdef BTRACE_FLEXIBLE_MEM_MODEL

	if (r == KErrNone)

		aMemory->BTraceCreate();

#endif

	return r;

	}

TInt MM::MemoryClaimInitialPages(DMemoryObject* aMemory, TLinAddr aBase, TUint aSize, TMappingPermissions aPermissions, TBool aAllowGaps, TBool aAllowNonRamPages)

	{

	TRACE(("MM::MemoryClaimInitialPages(0x%08x,0x%08x,0x%08x,0x%08x,%d,%d)",aMemory,aBase,aPermissions,aSize,aAllowGaps!=0,aAllowNonRamPages!=0));

	TInt r = aMemory->ClaimInitialPages(aBase,aSize,aPermissions,aAllowGaps,aAllowNonRamPages);

	TRACE(("MM::MemoryClaimInitialPages returns %d",r));

	__NK_ASSERT_DEBUG(r==KErrNone);

	return r;

	}

void MM::MemorySetLock(DMemoryObject* aMemory, DMutex* aLock)

	{

	aMemory->SetLock(aLock);

	}

void MM::MemoryLock(DMemoryObject* aMemory)

	{

	MemoryObjectLock::Lock(aMemory);

	}

void MM::MemoryUnlock(DMemoryObject* aMemory)

	{

	MemoryObjectLock::Unlock(aMemory);

	}

void MM::MemoryDestroy(DMemoryObject*& aMemory)

	{

	DMemoryObject* memory = (DMemoryObject*)__e32_atomic_swp_ord_ptr(&aMemory, 0);

	if (!memory)

		return;

	TRACE(("MM::MemoryDestroy(0x%08x)",memory));

#ifdef BTRACE_FLEXIBLE_MEM_MODEL

	BTraceContext4(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectDestroy,memory);

#endif

	memory->iManager->Destruct(memory);

	}

TInt MM::MemoryAlloc(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE(("MM::MemoryAlloc(0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->Alloc(aMemory,aIndex,aCount);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryAlloc returns %d",r));

	return r;

	}

TInt MM::MemoryAllocContiguous(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TUint aAlign, TPhysAddr& aPhysAddr)

	{

	TRACE(("MM::MemoryAllocContiguous(0x%08x,0x%08x,0x%08x,%d,?)",aMemory,aIndex,aCount,aAlign));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->AllocContiguous(aMemory,aIndex,aCount,MM::RoundToPageShift(aAlign),aPhysAddr);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryAlloc returns %d (aPhysAddr=0x%08x)",r,aPhysAddr));

	return r;

	}

void MM::MemoryFree(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE(("MM::MemoryFree(0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	aMemory->ClipRegion(aIndex,aCount);

	aMemory->iManager->Free(aMemory,aIndex,aCount);

	MemoryObjectLock::Unlock(aMemory);

	}

TInt MM::MemoryAddPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages)

	{

	TRACE(("MM::MemoryAddPages(0x%08x,0x%08x,0x%08x,?)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->AddPages(aMemory,aIndex,aCount,aPages);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryAddPages returns %d",r));

	return r;

	}

TInt MM::MemoryAddContiguous(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr aPhysAddr)

	{

	TRACE(("MM::MemoryAddContiguous(0x%08x,0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount,aPhysAddr));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->AddContiguous(aMemory,aIndex,aCount,aPhysAddr);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryAddContiguous returns %d",r));

	return r;

	}

TUint MM::MemoryRemovePages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages)

	{

	TRACE(("MM::MemoryRemovePages(0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	aMemory->ClipRegion(aIndex,aCount);

	TInt r = aMemory->iManager->RemovePages(aMemory,aIndex,aCount,aPages);

	if(r<0)

		r = 0;

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryRemovePages returns %d",r));

	return r;

	}

TInt MM::MemoryAllowDiscard(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE(("MM::MemoryAllowDiscard(0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->AllowDiscard(aMemory,aIndex,aCount);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryAllowDiscard returns %d",r));

	return r;

	}

TInt MM::MemoryDisallowDiscard(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE(("MM::MemoryDisallowDiscard(0x%08x,0x%08x,0x%08x)",aMemory,aIndex,aCount));

	MemoryObjectLock::Lock(aMemory);

	TInt r;

	if(!aMemory->CheckRegion(aIndex,aCount))

		r = KErrArgument;

	else

		r = aMemory->iManager->DisallowDiscard(aMemory,aIndex,aCount);

	MemoryObjectLock::Unlock(aMemory);

	TRACE(("MM::MemoryDisallowDiscard returns %d",r));

	return r;

	}

TInt MM::MemoryPhysAddr(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr& aPhysicalAddress, TPhysAddr* aPhysicalPageList)

	{

	TRACE(("MM::MemoryPhysAddr(0x%08x,0x%08x,0x%08x,?,?)",aMemory,aIndex,aCount));

	TInt r = aMemory->PhysAddr(aIndex,aCount,aPhysicalAddress,aPhysicalPageList);

	TRACE(("MM::MemoryPhysAddr returns %d aPhysicalAddress=0x%08x",r,aPhysicalAddress));

	return r;

	}

void MM::MemoryBTracePrime(DMemoryObject* aMemory)

	{

	aMemory->BTraceCreate();

	aMemory->iMappings.Lock();

	TMappingListIter iter;

	DMemoryMapping* mapping = (DMemoryMapping*)iter.Start(aMemory->iMappings);

	while(mapping)

		{

		aMemory->iMappings.Unlock();	

		mapping->BTraceCreate();

		aMemory->iMappings.Lock();

		mapping = (DMemoryMapping*)iter.Next();

		}

	iter.Finish();

	aMemory->iMappings.Unlock();	

	}

void MM::MemoryClose(DMemoryObject* aMemory)

	{

	aMemory->Close();

	}

TBool MM::MemoryIsNotMapped(DMemoryObject* aMemory)

	{

	TBool r = aMemory->iMappings.IsEmpty();

	TRACE2(("MM::MemoryIsNotMapped(0x%08x) returns %d",aMemory,r));

	return r;

	}

//

// Physical pinning

//

TInt MM::PinPhysicalMemory(DMemoryObject* aMemory, DPhysicalPinMapping* aPinObject, TUint aIndex, TUint aCount, TBool aReadOnly, TPhysAddr& aAddress, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour)

	{