// 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 <plat_priv.h>

#include "mm.h"

#include "mmu.h"

#include "maddressspace.h"

#include "mpdalloc.h"

#include "mmapping.h"

/**

Allocator for OS Address Space IDs (OS ASIDs).

This is a simple bitmap allocator for KNumOsAsids integers with an

associated mutex to guard against concurrency when allocating and

freeing.

*/

class OsAsidAllocator

	{

public:

	void Init2()

		{

		iAllocator = TBitMapAllocator::New(KNumOsAsids,ETrue);

		__NK_ASSERT_ALWAYS(iAllocator);

		iAllocator->Alloc(KKernelOsAsid,1); // make kernel OS ASID already allocated

		}

	TInt Alloc()

		{

		NKern::FMWait(&iLock);

		TInt osAsid = iAllocator->Alloc();

		NKern::FMSignal(&iLock);

		if(osAsid<0)

			return KErrNoMemory;

		return osAsid;

		}

	void Free(TInt aOsAsid)

		{

		NKern::FMWait(&iLock);

		iAllocator->Free(aOsAsid);

		NKern::FMSignal(&iLock);

		}

private:

	TBitMapAllocator* iAllocator;

	NFastMutex iLock;

	}

OsAsidAllocator;

//

// DAddressSpace

//

DAddressSpace KernelAddressSpace;	///< The kernel's address space object.

__ASSERT_COMPILE(KKernelOsAsid==0);

DAddressSpace* AddressSpace[KNumOsAsids] = { &KernelAddressSpace };

RVirtualAllocator DAddressSpace::UserGlobalVirtualAllocator;

RBackwardsVirtualAllocator DAddressSpace::UserCommonVirtualAllocator;

/**

The read lock used for protecting the mappings container in address spaces (DAddressSpace::iMappings).

A single global lock is used for all processes - this isn't required but it is the simplest

implementation if we want to avoid the memory overhead of allocating a mutex per address space.

*/

NFastMutex TheAddressSpaceMappingLock;

/**

A pool of mutexes which are used to protect an address space's virtual address allocation

and acts as a write lock for the mappings container (DAddressSpace::iMappings).

*/

DMutexPool AddressSpaceMutexPool;

void DAddressSpace::Init2()

	{

	// create allocator for ASIDs...

	OsAsidAllocator.Init2();

	// construct the kernel's address space...

	TInt r = KernelAddressSpace.Construct(0, KKernelSectionBase, KKernelSectionEnd);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	// mark primary i/o region as already allocated...

	__ASSERT_COMPILE(((KPrimaryIOBase|KPrimaryIOEnd)&KChunkMask)==0); // region must be chunk aligned to avoid PDE type conflicts with any new allocations

	TLinAddr addr;

	TUint size;

	r = KernelAddressSpace.AllocateVirtualMemory(addr,size,KPrimaryIOBase,KPrimaryIOEnd-KPrimaryIOBase,0);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	// construct user global memory allocator...

	r = UserGlobalVirtualAllocator.Construct(KGlobalMemoryBase,KUserMemoryLimit,ENumVirtualAllocTypes,AddressSpace[KKernelOsAsid]->iLock);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	// construct user common memory allocator (two slab types, one each for paged and unpaged memory)...

	r = UserCommonVirtualAllocator.Construct(KUserLocalDataBase,KUserLocalDataEnd,ENumVirtualAllocTypes,AddressSpace[KKernelOsAsid]->iLock);

	__NK_ASSERT_ALWAYS(r==KErrNone);

	// reserve virtual memory for XIP user code...

	TUint romDataSize = TheRomHeader().iTotalUserDataSize;

	TLinAddr romDataBase = TheRomHeader().iUserDataAddress-romDataSize;

	__NK_ASSERT_DEBUG(TheRomHeader().iUserDataAddress==KUserLocalDataEnd);

	if(romDataSize)

		{

		r = UserCommonVirtualAllocator.Alloc(addr,size,romDataBase,romDataSize,0);

		__NK_ASSERT_ALWAYS(r==KErrNone);

		}

	}

DAddressSpace::DAddressSpace()

	: iMappings(&TheAddressSpaceMappingLock,iLock)

	{

	}

TInt DAddressSpace::New(TPhysAddr& aPageDirectory)

	{

	TRACE(("DAddressSpace::New(?)"));

	TInt r;

	TInt osAsid = OsAsidAllocator.Alloc();

	if(osAsid<0)

		r = KErrNoMemory;

	else

		{

		r = PageDirectories.Alloc(osAsid,aPageDirectory);

		if(r!=KErrNone)

			OsAsidAllocator.Free(osAsid);

		else

			{

			DAddressSpace*& info = AddressSpace[osAsid];

			__NK_ASSERT_DEBUG(!info);

			info = new DAddressSpace();

			if(!info)

				{

				PageDirectories.Free(osAsid);

				OsAsidAllocator.Free(osAsid);

				r = KErrNoMemory;

				}

			else

				{

				r = info->Construct(osAsid,KUserLocalDataBase,KUserLocalDataEnd);

				if(r!=KErrNone)

					{

					info->Close();

					info = 0;

					}

				}

			}

		}

	if(r==KErrNone)

		r = osAsid;

	else

		aPageDirectory = KPhysAddrInvalid;

	TRACE(("DAddressSpace::New returns %d",r));

	return r;

	}

DAddressSpace::~DAddressSpace()

	{

	TRACE(("DAddressSpace[0x%08x]::~DAddressSpace() osAsid = %d",this,iOsAsid));

#ifdef _DEBUG

	if(iMappings.Count())

		Dump();

#endif

	__NK_ASSERT_DEBUG(iMappings.Count()==0);

	TInt osAsid = iOsAsid;

	AddressSpace[osAsid] = 0;

	PageDirectories.Free(osAsid);

	InvalidateTLBForAsid(osAsid);

	OsAsidAllocator.Free(osAsid);

	}

TInt DAddressSpace::Construct(TInt aOsAsid, TLinAddr aStart, TLinAddr aEnd)

	{

	TRACE(("DAddressSpace::Construct(%d,0x%08x,0x%08x)",aOsAsid,aStart,aEnd));

	iOsAsid = aOsAsid;

	return iVirtualAllocator.Construct(aStart,aEnd,ENumVirtualAllocTypes,iLock);

	}

void DAddressSpace::Lock()

	{

	AddressSpaceMutexPool.Wait(iLock);

	}

void DAddressSpace::Unlock()

	{

	AddressSpaceMutexPool.Signal(iLock);

	}

TInt DAddressSpace::AllocateVirtualMemory(TLinAddr& aAddr, TUint& aSize, TLinAddr aRequestedAddr, TUint aRequestedSize, TUint aPdeType)

	{

	TRACE(("DAddressSpace::AllocateVirtualMemory(?,?,0x%08x,0x%08x,%d) osAsid=%d",aRequestedAddr,aRequestedSize,aPdeType,iOsAsid));

	__NK_ASSERT_DEBUG(aPdeType<ENumVirtualAllocTypes);

	Lock();

	TInt r = iVirtualAllocator.Alloc(aAddr,aSize,aRequestedAddr,aRequestedSize,aPdeType);

	if(r==KErrNone)

		Open();

	Unlock();

	TRACE(("DAddressSpace::AllocateVirtualMemory returns %d region=0x%08x+0x%08x",r,aAddr,aSize));

	return r;

	}

TInt DAddressSpace::AllocateUserGlobalVirtualMemory(TLinAddr& aAddr, TUint& aSize, TLinAddr aRequestedAddr, TUint aRequestedSize, TUint aPdeType)

	{

	TRACE(("DAddressSpace::AllocateUserGlobalVirtualMemory(?,?,0x%08x,0x%08x,%d)",aRequestedAddr,aRequestedSize,aPdeType));

	__NK_ASSERT_DEBUG(aPdeType<ENumVirtualAllocTypes);

	KernelAddressSpace.Lock();

	TInt r = UserGlobalVirtualAllocator.Alloc(aAddr,aSize,aRequestedAddr,aRequestedSize,aPdeType);

	KernelAddressSpace.Unlock();

	TRACE(("DAddressSpace::AllocateUserGlobalVirtualMemory returns %d region=0x%08x+0x%08x",r,aAddr,aSize));

	return r;

	}

void DAddressSpace::FreeVirtualMemory(TLinAddr aAddr, TUint aSize)

	{

	TRACE(("DAddressSpace::FreeVirtualMemory(0x%08x,0x%08x) osAsid=%d",aAddr, aSize, iOsAsid));

	Lock();

	if(iOsAsid==(TInt)KKernelOsAsid && UserGlobalVirtualAllocator.InRange(aAddr,aSize))

		UserGlobalVirtualAllocator.Free(aAddr,aSize);

	else

		{

		iVirtualAllocator.Free(aAddr,aSize);

		AsyncClose();

		}

	Unlock();

	}

TInt DAddressSpace::AllocateUserCommonVirtualMemory(TLinAddr& aAddr, TUint& aSize, TLinAddr aRequestedAddr, TUint aRequestedSize, TUint aPdeType)

	{

	TRACE(("DAddressSpace::AllocateUserCommonVirtualMemory(?,?,0x%08x,0x%08x,%d)",aRequestedAddr,aRequestedSize,aPdeType));

	__NK_ASSERT_DEBUG(aPdeType<ENumVirtualAllocTypes);

	KernelAddressSpace.Lock();

	TInt r = UserCommonVirtualAllocator.Alloc(aAddr,aSize,aRequestedAddr,aRequestedSize,aPdeType);

	KernelAddressSpace.Unlock();

	TRACE(("DAddressSpace::AllocateUserCommonVirtualMemory returns %d region=0x%08x+0x%08x",r,aAddr,aSize));

	return r;

	}

void DAddressSpace::FreeUserCommonVirtualMemory(TLinAddr aAddr, TUint aSize)

	{

	TRACE(("DAddressSpace::FreeUserCommonVirtualMemory(0x%08x,0x%08x)",aAddr,aSize));

	KernelAddressSpace.Lock();

	UserCommonVirtualAllocator.Free(aAddr,aSize);

	KernelAddressSpace.Unlock();

	}

TInt DAddressSpace::AddMapping(TLinAddr aAddr, DMemoryMapping* aMapping)

	{

	Lock();

	TRACE(("DAddressSpace::AddMapping(0x%08x,0x%08x) osAsid=%d",aAddr, aMapping, iOsAsid));

	TInt r = iMappings.Add(aAddr,aMapping);

	TRACE(("DAddressSpace::AddMapping osAsid=%d returns %d",iOsAsid, r));

	Unlock();

	return r;

	}

DMemoryMapping* DAddressSpace::RemoveMapping(TLinAddr aAddr)

	{

	Lock();

	DMemoryMapping* removed = (DMemoryMapping*)iMappings.Remove(aAddr);

	TRACE(("DAddressSpace::RemoveMapping(0x%08x) osAsid=%d returns 0x%08x",aAddr, iOsAsid, removed));

	Unlock();

	return removed;

	}

DMemoryMapping* DAddressSpace::GetMapping(TLinAddr aAddr)

	{

	iMappings.ReadLock();

	DMemoryMapping* mapping = (DMemoryMapping*)iMappings.Find(aAddr);

	TRACE(("DAddressSpace::GetMapping(0x%08x) osAsid=%d returns 0x%08x",aAddr, iOsAsid, mapping));

	__NK_ASSERT_DEBUG(mapping); // caller must know there is a mapping

	iMappings.ReadUnlock();

	return mapping;

	}

DMemoryMapping* DAddressSpace::FindMapping(TLinAddr aAddr, TUint aSize, TUint& aOffsetInMapping, TUint& aInstanceCount)

	{

	__ASSERT_CRITICAL;

	DMemoryMapping* result = NULL;

	// find mapping...

	iMappings.ReadLock();

	TUint dummy;

	DMemoryMapping* mapping = (DMemoryMapping*)iMappings.Find(aAddr,dummy);

	if(mapping && mapping->IsAttached())

		{

		// found mapping, check addresses are in range...

		TUint offset = aAddr-mapping->Base();

		TUint end = offset+aSize;

		if(offset<end && end<=mapping->iSizeInPages<<KPageShift)

			{

			// addresses OK, get a reference on the mapping before releasing list lock...

			aOffsetInMapping = offset;

			aInstanceCount = mapping->MapInstanceCount();

			mapping->Open(); // can't fail because mapping IsAttached

			result = mapping;

			}

		}

	iMappings.ReadUnlock();

	return result;

	}

TBool DAddressSpace::CheckPdeType(TLinAddr aAddr, TUint aSize, TUint aPdeType)

	{

	TRACE(("DAddressSpace::CheckPdeType(0x%08x,0x%08x,%d) osAsid=%d",aAddr, aSize, aPdeType, iOsAsid));

	TBool r;

	Lock();

	if(iOsAsid==(TInt)KKernelOsAsid && UserGlobalVirtualAllocator.InRange(aAddr,aSize))

		r = UserGlobalVirtualAllocator.CheckSlabType(aAddr,aSize,aPdeType);

	else

		r = iVirtualAllocator.CheckSlabType(aAddr,aSize,aPdeType);

	TRACE(("DAddressSpace::CheckPdeType returns %d",r));

	Unlock();

	return r;

	}

//

// Debug

//

#ifdef _DEBUG

void DAddressSpace::Dump()

	{

	Kern::Printf("DAddressSpace[0x%08x]::Dump() osAsid = %d",this,iOsAsid);

	TLinAddr virt = 0;

	do

		{

		--virt;

		iMappings.ReadLock();

		TUint offsetInMapping = 0;

		DMemoryMapping* mapping = (DMemoryMapping*)iMappings.Find(virt,offsetInMapping);

		if(mapping)

			{

			if(!mapping->TryOpen())

				mapping = NULL;

			virt -= offsetInMapping;

			}

		iMappings.ReadUnlock();

		if(!mapping)

			break;

		mapping->Dump();

		mapping->Close();

		}

	while(virt);

	}

#endif // _DEBUG