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

			{

			MM::MappingDestroy(mapping);

			r = KErrNoMemory;

			}

		}

	// Close the reference on the os asid as while aMapping is valid then the 

	// os asid must be also.

	aProcess->CloseOsAsid();

	aMapping = m;

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

	return r;

	}

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

	{

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

	TInt r = KErrNone;

	Kern::MutexWait(*iProcessLock);

	LockPool();

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

	UnlockPool();

	if (!client)

		{

		client = new DMemModelAlignedShPoolClient;

		if (client)

			{

			client->iFlags = aAttr;

			r = iClientMap->Add(reinterpret_cast<TUint>(aProcess), client);

			if (r == KErrNone)

				{

				if (aProcess != K::TheKernelProcess)

					{

					r = aProcess->iHandles.Reserve(iTotalBuffers);

					if (r != KErrNone)

						{

						iClientMap->Remove(reinterpret_cast<TUint>(aProcess));

						}

					}

				}

			if (r != KErrNone)

				{

				delete client;

				r = KErrNoMemory;

				}

			}

		else

			{

			r = KErrNoMemory;

			}

		}

	else

		{

		LockPool();

		client->iAccessCount++;

		UnlockPool();

		}

	Kern::MutexSignal(*iProcessLock);

	return r;

	}

DMemModelAlignedShPool::DMemModelAlignedShPool() :	DMemModelShPool()

	{

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

	}

void DMemModelAlignedShPool::Free(DShBuf* aBuf)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShPool::Free (aBuf = 0x%08x)", aBuf));

	LockPool();

#ifdef _DEBUG

	// Remove from allocated list

	aBuf->iObjLink.Deque();

#endif

	DMemModelAlignedShBuf* buf = reinterpret_cast<DMemModelAlignedShBuf*>(aBuf);

	if (MM::MemoryIsNotMapped(buf->iMemoryObject))

		{

		UnlockPool(); // have to release fast mutex

		MM::MemoryWipe(buf->iMemoryObject);

		LockPool();

		// we want to put the initial buffers at the head of the free list

		// and the grown buffers at the tail as this makes shrinking more efficient

		if (aBuf >= iInitialBuffersArray && aBuf < (iInitialBuffersArray + iInitialBuffers))

			{

			iFreeList.AddHead(&aBuf->iObjLink);

			}

		else

			{

			iFreeList.Add(&aBuf->iObjLink);

			}

		++iFreeBuffers;

#ifdef _DEBUG

		--iAllocatedBuffers;

#endif

		}

	else

		{

		iPendingList.Add(&aBuf->iObjLink);

		}

	iPoolFlags &= ~EShPoolSuppressShrink;		// Allow shrinking again, if it was blocked

	UnlockPool();

	// queue ManagementDfc which completes notifications as appropriate

	if (HaveWorkToDo())

		KickManagementDfc();

	DShPool::Close(NULL); // decrement pool reference count

	}

TInt DMemModelAlignedShPool::UpdateFreeList()

	{

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

	LockPool();

	SDblQueLink* pLink = iPendingList.First();

	UnlockPool();

	SDblQueLink* anchor = &iPendingList.iA;

	while (pLink != anchor)

		{

		DMemModelAlignedShBuf* buf = _LOFF(pLink, DMemModelAlignedShBuf, iObjLink);

		LockPool();

		pLink = pLink->iNext;

		UnlockPool();

		if (MM::MemoryIsNotMapped(buf->iMemoryObject))

			{

			LockPool();

			buf->iObjLink.Deque();

			UnlockPool();

			MM::MemoryWipe(buf->iMemoryObject);

			LockPool();

			if (buf >= iInitialBuffersArray && buf < (iInitialBuffersArray + iInitialBuffers))

				{

				iFreeList.AddHead(&buf->iObjLink);

				}

			else

				{

				iFreeList.Add(&buf->iObjLink);

				}

			++iFreeBuffers;

#ifdef _DEBUG

			--iAllocatedBuffers;

#endif

			UnlockPool();

			}

		}

	__KTRACE_OPT(KMMU, Kern::Printf("<DMemModelAlignedShPool::UpdateFreeList"));

	return KErrNone;

	}

DMemModelAlignedShPool::~DMemModelAlignedShPool()

	{

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

	}

TInt DMemModelAlignedShPool::DoCreate(TShPoolCreateInfo& aInfo)

	{

	TUint64 maxSize64 = static_cast<TUint64>(aInfo.iInfo.iMaxBufs) * static_cast<TUint64>(iBufGap);

	if (maxSize64 > static_cast<TUint64>(KMaxTInt) || maxSize64 <= static_cast<TUint64>(0))

		return KErrArgument;

	iMaxPages = MM::RoundToPageCount(static_cast<TInt>(maxSize64));

	return KErrNone;

	}

TInt DMemModelAlignedShPool::DestroyAllMappingsAndReservedHandles(DProcess* aProcess)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShPool::DestroyAllMappingsAndReservedHandles(0x%08x)", aProcess));

	TInt r = KErrNone;

	Kern::MutexWait(*iProcessLock);

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

	__NK_ASSERT_DEBUG(client);

	__NK_ASSERT_DEBUG(client->iAccessCount == 0);

	DestroyMappings(client, KMaxTInt);

	delete client;

	if (aProcess != K::TheKernelProcess)

		{

		// Remove reserved handles

		r = aProcess->iHandles.Reserve(-iTotalBuffers);

		}

	Kern::MutexSignal(*iProcessLock);

	__KTRACE_OPT(KMMU, Kern::Printf("<DMemModelAlignedShPool::DestroyAllMappingsAndReservedHandles(0x%08x)", aProcess));

	return r;

	}

TInt DMemModelAlignedShPool::DestroyMappings(DMemModelAlignedShPoolClient* aClient, TInt aNoOfMappings)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DMemModelAlignedShPool::DestroyMappings(0x%08x)", aClient));

	TInt r = KErrNone;

	TInt i = 0;

	DShBufMapping* m = NULL;

	SDblQueLink* pLink = NULL;

	while (i < aNoOfMappings && !aClient->iMappingFreeList.IsEmpty())

		{

		LockPool();

		pLink = aClient->iMappingFreeList.GetFirst();

		UnlockPool();

		if (pLink == NULL)

			break;

		m = _LOFF(pLink, DShBufMapping, iObjLink);

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

		MM::MappingClose(m->iMapping);

		delete m;

		++i;

		}

	__KTRACE_OPT(KMMU, Kern::Printf("<DMemModelAlignedShPool::DestroyMappings"));

	return r;

	}

TInt DMemModelAlignedShPool::CreateMappings(DMemModelAlignedShPoolClient* aClient, TInt aNoOfMappings, DMemModelProcess* aProcess)

	{

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

	__ASSERT_MUTEX(iProcessLock);

	TInt r = KErrNone;

	for (TInt i = 0; i < aNoOfMappings; ++i)

		{

		DShBufMapping* mapping;

		r = MappingNew(mapping, aProcess);

		if (r == KErrNone)

			{

			LockPool();

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

			UnlockPool();

			}

		else

			{

			r = KErrNoMemory;

			break;

			}

		}

	return r;

	}

TInt DMemModelAlignedShPool::UpdateMappingsAndReservedHandles(TInt aNoOfBuffers)

	{

	__KTRACE_OPT(KMMU2, Kern::Printf(">DMemModelAlignedShPool::UpdateMappingsAndReservedHandles(0x%08x)", aNoOfBuffers));

	SMap::TIterator iter(*iClientMap);

	SMap::TEntry* entry;

	SMap::TEntry* lastEntry = NULL;

	DMemModelProcess* pP;

	DMemModelAlignedShPoolClient* client;

	TInt result = KErrNone;

	Kern::MutexWait(*iProcessLock);

	// First handle the case of increasing allocation

	if (aNoOfBuffers > 0)

		while ((entry = iter.Next()) != lastEntry)

			{

			// Try to update handle reservation; skip if process is null or has gone away

			client = (DMemModelAlignedShPoolClient*)(entry->iObj);

			pP = (DMemModelProcess*)(entry->iKey);

			if (!pP)

				continue;

			TInt r = pP->iHandles.Reserve(aNoOfBuffers);

			if (r)

				__KTRACE_OPT(KMMU2, Kern::Printf("?DMemModelAlignedShPool::UpdateMappingsAndReservedHandles(0x%08x) Reserve failed %d", aNoOfBuffers, r));

			if (r == KErrDied)

				continue;

			if (r == KErrNone && client->iWindowSize <= 0)

				{

				// A positive window size means the number of mappings is fixed, so we don't need to reserve more.

				// But here zero or negative means a variable number, so we need to create extra mappings now.

				r = CreateMappings(client, aNoOfBuffers, pP);

				if (r != KErrNone)

					{

					__KTRACE_OPT(KMMU2, Kern::Printf("?DMemModelAlignedShPool::UpdateMappingsAndReservedHandles(0x%08x) CreateMappings failed %d", aNoOfBuffers, r));

					pP->iHandles.Reserve(-aNoOfBuffers); // Creation failed, so release the handles reserved above

					}

				}

			if (r != KErrNone)

				{

				// Some problem; cleanup as best we can by falling into the loop below to undo what we've done

				result = r;

				iter.Reset();

				lastEntry = entry;

				aNoOfBuffers = -aNoOfBuffers;

				break;

				}

			}

	// Now handle the case of decreasing allocation; also used for recovery from errors, in which case

	// this loop iterates only over the elements that were *successfully* processed by the loop above

	if (aNoOfBuffers < 0)

		while ((entry = iter.Next()) != lastEntry)

			{

			// Try to update handle reservation; skip if process is null or has gone away

			client = (DMemModelAlignedShPoolClient*)(entry->iObj);

			pP = (DMemModelProcess*)(entry->iKey);

			if (!pP)

				continue;

			TInt r = pP->iHandles.Reserve(aNoOfBuffers);

			if (r == KErrDied)

				continue;

			if (r == KErrNone && client->iWindowSize <= 0)

				r = DestroyMappings(client, -aNoOfBuffers);

			// De-allocation by Reserve(-n) and/or DestroyMappings() should never fail

			if (r != KErrNone)

				Kern::PanicCurrentThread(KLitDMemModelAlignedShPool, r);

			}

	Kern::MutexSignal(*iProcessLock);

	__KTRACE_OPT(KMMU2, Kern::Printf("<DMemModelAlignedShPool::UpdateMappingsAndReservedHandles(0x%08x) returning %d", aNoOfBuffers, result));

	return result;

	}

TInt DMemModelAlignedShPool::DeleteInitialBuffers()

	{

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

	if (iInitialBuffersArray != NULL)

		{

		for (TUint i = 0; i < iInitialBuffers; i++)

			{

			iInitialBuffersArray[i].iObjLink.Deque(); // remove from free list

			iInitialBuffersArray[i].Dec();

			iInitialBuffersArray[i].~DMemModelAlignedShBuf();

			}

		}

	Kern::Free(iInitialBuffersArray);

	iInitialBuffersArray = NULL;

	return KErrNone;

	}

TInt DMemModelAlignedShPool::Close(TAny* aPtr)

	{

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

	if (aPtr)

		{

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

		CloseClient(pP);

		}

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

	return DShPool::Close(aPtr);

	}

TInt DMemModelAlignedShPool::CreateInitialBuffers()

	{

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

	iInitialBuffersArray = reinterpret_cast<DMemModelAlignedShBuf*>(Kern::Alloc(iInitialBuffers * sizeof(DMemModelAlignedShBuf)));

	if (iInitialBuffersArray == NULL)

		return KErrNoMemory;

	for (TUint i = 0; i < iInitialBuffers; i++)

		{

		// always use kernel linear address in DShBuf

		DMemModelAlignedShBuf *buf = new (&iInitialBuffersArray[i]) DMemModelAlignedShBuf(this);

		TInt r = buf->Construct();

		if (r == KErrNone)

			{

			iFreeList.Add(&buf->iObjLink);

			}

		else

			{

			iInitialBuffers = i;

			return KErrNoMemory;

			}

		}

	iFreeBuffers  = iInitialBuffers;

	iTotalBuffers = iInitialBuffers;

	return KErrNone;

	}

TInt DMemModelAlignedShPool::GrowPool()

	{

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

	TInt r = KErrNone;

	SDblQue temp;

	Kern::MutexWait(*iProcessLock);

	TUint32 headroom = iMaxBuffers - iTotalBuffers;

	// How many buffers to grow by?

	TUint32 grow = mult_fx248(iTotalBuffers, iGrowByRatio);

	if (grow == 0)			// Handle round-to-zero

		grow = 1;

	if (grow > headroom)

		grow = headroom;

	TUint i;

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

		{

		DMemModelAlignedShBuf *buf = new DMemModelAlignedShBuf(this);

		if (buf == NULL)

			{

			r = KErrNoMemory;

			break;

			}

		TInt r = buf->Construct();

		if (r != KErrNone)

			{

			buf->DObject::Close(NULL);

			break;

			}

		temp.Add(&buf->iObjLink);

		}

	r = UpdateMappingsAndReservedHandles(i);

	if (r == KErrNone)

		{

		LockPool();

		iFreeList.MoveFrom(&temp);

		iFreeBuffers += i;

		iTotalBuffers += i;

		UnlockPool();