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