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

// e32/memmodel/epoc/flexible/mshbuf.cpp

// Shareable Data Buffers

#include <memmodel.h>

#include "mmu/mm.h"

#include "mmboot.h"

#include <kernel/smap.h>

_LIT(KLitDMemModelAlignedShPool,"DMMAlignedShPool");	// Must be no more than 16 characters!

struct TWait

	{

	void Link(TWait*& aList)

		{

		iSem.SetOwner(NULL);

		iNext = aList;

		aList = this;

		};

	void Wait()

		{

		NKern::FSWait(&iSem);

		}

	NFastSemaphore iSem;

	TWait* iNext;

	static void SignalAll(TWait* aList)

		{

		while (aList)

			{

			TWait* next = aList->iNext;

			NKern::FSSignal(&aList->iSem);

			aList = next;

			}

		}

	};

class DShBufMapping : public DBase

	{

public:

	SDblQueLink iObjLink;

	DMemoryMapping* iMapping;

	TInt iOsAsid;

	TWait* iTransitions; // Mapping and Unmapping operations

	TBool iTransitioning;

	};

DMemModelShPool::DMemModelShPool() : DShPool()

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelShPool::DMemModelShPool"));

	}

DMemModelShPool::~DMemModelShPool()

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelShPool::~DMemModelShPool"));

	}

void DMemModelShPool::DestroyClientResources(DProcess* aProcess)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelShPool::DestroyClientResources"));

	TInt r = DestroyAllMappingsAndReservedHandles(aProcess);

	__NK_ASSERT_DEBUG((r == KErrNone) || (r == KErrDied));

	(void)r;		// Silence warnings

	}

DMemModelAlignedShBuf::DMemModelAlignedShBuf(DShPool* aPool) : DShBuf(aPool)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::DMemModelAlignedShBuf()"));

	}

TInt DMemModelAlignedShBuf::Construct()

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::Construct()"));

	TInt r = KErrNone;

	r = DShBuf::Construct();

	if (r == KErrNone)

		r = Create();

	return r;

	}

TInt DMemModelAlignedShBuf::Close(TAny* aPtr)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::Close(0x%08x)", aPtr));

	if (aPtr)

		{

		DProcess* pP = reinterpret_cast<DProcess*>(aPtr);

		UnMap(pP);

		iPool->CloseClient(pP);

		}

	return DShBuf::Close(aPtr);

	}

TInt DMemModelAlignedShBuf::AddToProcess(DProcess* aProcess, TUint aAttr)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("Adding DMemModelShBuf %O to process %O",this,aProcess));

	TInt r;

	TLinAddr base;

	TUint flags;

	r = iPool->OpenClient(aProcess, flags);

	if (r == KErrNone)

		{

		if ((flags & EShPoolAutoMapBuf) && ((aAttr & EShPoolNoMapBuf) == 0))

			{

			// note we use the client's pool flags and not the buffer attributes

			r = Map(flags, aProcess, base);

			if (aProcess == K::TheKernelProcess)

				iRelAddress = static_cast<TLinAddr>(base);

			}

		}

	return r;

	}

TInt DMemModelAlignedShBuf::Create()

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::Create()"));

	TInt r = KErrNone;

	// calculate memory type...

	TMemoryObjectType memoryType =  EMemoryObjectUnpaged;

	TMemoryAttributes attr = EMemoryAttributeStandard;

	// calculate memory flags...

	TMemoryCreateFlags flags = static_cast<TMemoryCreateFlags>((EMemoryCreateDefault|EMemoryCreateUseCustomWipeByte|(0xAA<<EMemoryCreateWipeByteShift)));

	// note that any guard pages will be included in iBufGap, however the amount of memory committed

	// will be iBufSize rounded up to a page

	r = MM::MemoryNew(iMemoryObject, memoryType, MM::RoundToPageCount(iPool->iBufGap), flags, attr);

	if(r!=KErrNone)

		return r;

	if (iPool->iPoolFlags & EShPoolContiguous)

		{

		TPhysAddr paddr;

		r = MM::MemoryAllocContiguous(iMemoryObject, 0, MM::RoundToPageCount(iPool->iBufSize), 0, paddr);

		}

	else

		{

		r = MM::MemoryAlloc(iMemoryObject, 0, MM::RoundToPageCount(iPool->iBufSize));

		}

	return r;

	}

DMemModelAlignedShBuf::~DMemModelAlignedShBuf()

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::~DMemModelAlignedShBuf()"));

	__NK_ASSERT_DEBUG(iMappings.IsEmpty());

	MM::MemoryDestroy(iMemoryObject);

	}

TInt DMemModelAlignedShBuf::Map(TUint aMapAttr, DProcess* aProcess, TLinAddr& aBase)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::Map()"));

	TInt r = KErrNone;

	DShBufMapping* m = NULL;

	DMemoryMapping* mapping = NULL;

	DMemModelProcess* pP = reinterpret_cast<DMemModelProcess*>(aProcess);

	TBool write = (TBool)EFalse;

	// User = ETrue, ReadOnlyWrite = ETrue, Execute = EFalse

	if (aMapAttr & EShPoolWriteable)

		write = (TBool)ETrue;

	TMappingPermissions perm = MM::MappingPermissions(pP!=K::TheKernelProcess, write, (TBool)EFalse);

	TWait wait;

	for(;;)

		{

		iPool->LockPool();

		r = FindMapping(m, pP);

		if (r != KErrNone)

			break;

		if (m->iTransitioning)

			{

			wait.Link(m->iTransitions);

			iPool->UnlockPool();

			wait.Wait();

			}

		else

			{

			iPool->UnlockPool();

			return KErrAlreadyExists;

			}

		}

	DMemModelAlignedShPoolClient* client = reinterpret_cast<DMemModelAlignedShPoolClient*>(iPool->iClientMap->Find(reinterpret_cast<TUint>(aProcess)));

	__NK_ASSERT_DEBUG(client);

	DMemModelAlignedShPool* pool = reinterpret_cast<DMemModelAlignedShPool*>(iPool);

	__NK_ASSERT_DEBUG(m == NULL);

	r = pool->GetFreeMapping(m, client);

	if (r == KErrNone)

		{

		iMappings.AddHead(&m->iObjLink);

		m->iTransitioning = ETrue;

		mapping = m->iMapping;

		iPool->UnlockPool(); // have to release fast lock for MappingMap

		r = MM::MappingMap(mapping, perm, iMemoryObject, 0, MM::RoundToPageCount(pool->iBufSize));

		iPool->LockPool();

		TWait* list = m->iTransitions;

		m->iTransitions = NULL;

		if (r != KErrNone)

		    pool->ReleaseMapping(m, client);

		else

		    aBase = MM::MappingBase(mapping);

		m->iTransitioning = EFalse;

		iPool->UnlockPool();

		TWait::SignalAll(list);

		}

	else

		iPool->UnlockPool();

	return r;

	}

TInt DMemModelAlignedShBuf::FindMapping(DShBufMapping*& aMapping, DMemModelProcess* aProcess)

	{

	// Must be in critical section so we don't leak os asid references.

	__ASSERT_CRITICAL;

	__NK_ASSERT_DEBUG(iPool->iLock.HeldByCurrentThread());

	TInt r = KErrNotFound;

	aMapping = NULL;

	// Open a reference on aProcess's os asid so that it can't be freed and 

	// reused while searching.

	TInt osAsid = aProcess->TryOpenOsAsid();

	if (osAsid < 0)

		{// aProcess has died and freed its os asid.

		return KErrDied;

		}

	SDblQueLink* pLink = iMappings.First();

	SDblQueLink* end = reinterpret_cast<SDblQueLink*>(&iMappings);

	DShBufMapping* m = NULL;

	while (pLink != end)

		{

		m = _LOFF(pLink, DShBufMapping, iObjLink);

		if (m->iOsAsid == osAsid)

			{

			aMapping = m;

			r = KErrNone;

			break;

			}

		pLink = pLink->iNext;

		}

	// Close the reference on the os asid as if we have a mapping then its lifetime will 

	// determine whether the process still owns an os asid.

	aProcess->CloseOsAsid();	

	return r;

	}

TInt DMemModelAlignedShBuf::UnMap(DProcess* aProcess)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::UnMap()"));

	TInt r = KErrNone;

	DMemModelProcess* pP = reinterpret_cast<DMemModelProcess*>(aProcess);

	DShBufMapping* m = NULL;

	TWait wait;

	for(;;)

		{

		iPool->LockPool();

		r = FindMapping(m, pP);

		if (r != KErrNone)

			{

			iPool->UnlockPool();

			return KErrNotFound;

			}

		if (m->iTransitioning)

			{

			wait.Link(m->iTransitions);

			iPool->UnlockPool();

			wait.Wait();

			}

		else

			{

			break;

			}

		}

	m->iTransitioning = ETrue;

	iPool->UnlockPool();

	MM::MappingUnmap(m->iMapping);

	iPool->LockPool();

	DMemModelAlignedShPoolClient* client = reinterpret_cast<DMemModelAlignedShPoolClient*>(iPool->iClientMap->Find(reinterpret_cast<TUint>(aProcess)));

	__NK_ASSERT_DEBUG(client);

	TWait* list = m->iTransitions;

	m->iTransitions = NULL;

	m->iObjLink.Deque();

	m->iTransitioning = EFalse;

	DMemModelAlignedShPool* pool = reinterpret_cast<DMemModelAlignedShPool*>(iPool);

	pool->ReleaseMapping(m, client);

	if (aProcess == K::TheKernelProcess)

	    iRelAddress = NULL;

	iPool->UnlockPool();

	wait.SignalAll(list);

	return KErrNone;

	}

TUint8* DMemModelAlignedShBuf::Base(DProcess* aProcess)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShBuf::Base()"));

	DMemModelProcess* pP = reinterpret_cast<DMemModelProcess*>(aProcess);

	DShBufMapping* mapping = NULL;

	iPool->LockPool();

	TInt r = FindMapping(mapping, pP);

	TUint8* base = NULL;

	if (r == KErrNone)

		base = reinterpret_cast<TUint8*>(MM::MappingBase(mapping->iMapping));

	iPool->UnlockPool();

	return base;

	}

TUint8* DMemModelAlignedShBuf::Base()

	{

	return reinterpret_cast<TUint8*>(iRelAddress);

	}

TInt DMemModelAlignedShBuf::Pin(TPhysicalPinObject* aPinObject, TBool aReadOnly, TPhysAddr& aAddress, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DMemModelAlignedShBuf::Pin");

	TInt r = MM::PinPhysicalMemory(iMemoryObject, (DPhysicalPinMapping*)aPinObject, 0,

								   MM::RoundToPageCount(Size()),

								   aReadOnly, aAddress, aPages, aMapAttr, aColour);

	return r;

	}

TInt DMemModelAlignedShPool::GetFreeMapping(DShBufMapping*& aMapping, DMemModelAlignedShPoolClient* aClient)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShPool::GetFreeMapping()"));

	__NK_ASSERT_DEBUG(iLock.HeldByCurrentThread());

	TInt r = KErrNotFound;

	aMapping = NULL;

	if (aClient)

		{

		if (!aClient->iMappingFreeList.IsEmpty())

			{

			aMapping = _LOFF(aClient->iMappingFreeList.GetFirst(), DShBufMapping, iObjLink);

			r = KErrNone;

			}

		else

			{

			r = KErrNoMemory;

			}

		}

	__KTRACE_OPT(KMMU2, Kern::Printf("DMemModelAlignedShPool::GetFreeMapping(0x%08x, 0x%08x) returns %d", aMapping, aClient, r));

	return r;

	}

TInt DMemModelAlignedShPool::ReleaseMapping(DShBufMapping*& aMapping, DMemModelAlignedShPoolClient* aClient)

	{

	__KTRACE_OPT(KMMU2, Kern::Printf("DMemModelAlignedShPool::ReleaseMapping(0x%08x,0x%08x)",aMapping,aClient));

	__NK_ASSERT_DEBUG(iLock.HeldByCurrentThread());

	TInt r = KErrNone;

	if (aClient)

		{

		aClient->iMappingFreeList.AddHead(&aMapping->iObjLink);

		aMapping = NULL;

		}

	else

		{

		// pool has probably been closed delete mapping

		r = KErrNotFound;

		__KTRACE_OPT(KMMU2, Kern::Printf("DMemModelAlignedShPool::ReleaseMapping delete 0x%08x",aMapping));

		UnlockPool(); // have to release fast lock for MappingDestroy

		MM::MappingDestroy(aMapping->iMapping);

		delete aMapping;

		aMapping = NULL;

		LockPool();

		}

	return r;

	}

TInt DMemModelAlignedShPool::SetBufferWindow(DProcess* aProcess, TInt aWindowSize)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShPool::SetBufferWindow()"));

	// Create and construct mappings but do not map

	// also allocate reserved handles

	TInt r = KErrNone;

	TUint noOfBuffers = aWindowSize;

	if (aWindowSize > static_cast<TInt>(iMaxBuffers))

		return KErrArgument;

	Kern::MutexWait(*iProcessLock);

	LockPool();

	DMemModelAlignedShPoolClient* client = reinterpret_cast<DMemModelAlignedShPoolClient*>(iClientMap->Find(reinterpret_cast<TUint>(aProcess)));

	UnlockPool();

	if (client)

		{

		if (client->iWindowSize != 0)

			{

			Kern::MutexSignal(*iProcessLock);

			return KErrAlreadyExists;

			}

		if (aWindowSize < 0)

			{

			noOfBuffers = iTotalBuffers;

			}

		DMemModelProcess* pP = reinterpret_cast<DMemModelProcess*>(aProcess);

		r = CreateMappings(client, noOfBuffers, pP);

		if (r == KErrNone)

			{

			client->iWindowSize = aWindowSize;

			}

		else

			{

			DestroyMappings(client, noOfBuffers);

			}

		}

	else

		{

		r = KErrNotFound;

		}

	Kern::MutexSignal(*iProcessLock);

	return r;

	}

TInt DMemModelAlignedShPool::MappingNew(DShBufMapping*& aMapping, DMemModelProcess* aProcess)

	{

	// Must be in critical section so we don't leak os asid references.

	__ASSERT_CRITICAL;

	TMappingCreateFlags flags=EMappingCreateDefault;

	FlagSet(flags, EMappingCreateReserveAllResources);

	// Open a reference to aProcess's os so it isn't freed and reused while

	// we're creating this mapping.

	TInt osAsid = aProcess->TryOpenOsAsid();

	if (osAsid < 0)

		{// The process has freed its os asid so can't create a new mapping.

		return KErrDied;

		}

	DMemoryMapping* mapping = NULL;

	DShBufMapping* m = NULL;

	TInt r = MM::MappingNew(mapping, MM::RoundToPageCount(iBufGap), osAsid, flags);

	if (r == KErrNone)

		{

		m = new DShBufMapping;

		if (m)

			{

			m->iMapping = mapping;

			m->iOsAsid = osAsid;

			}

		else