// 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/emul/win32/mshbuf.cpp

// Shareable Data Buffers

#include "memmodel.h"

#include <kernel/smap.h>

_LIT(KLitDWin32ShPool,"DWin32ShPool");

_LIT(KLitDWin32AlignedShPool,"DWin32AlignedShPool");

_LIT(KLitDWin32NonAlignedShPool,"DWin32NonAlignedShPool");

DWin32ShBuf::DWin32ShBuf(DShPool* aPool, TLinAddr aRelAddr) : DShBuf(aPool, aRelAddr)

	{

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

	}

DWin32ShBuf::~DWin32ShBuf()

	{

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

	}

TUint8* DWin32ShBuf::Base(DProcess* aProcess)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DWin32ShBuf::Base(0x%x)", aProcess));

	TUint8* base = reinterpret_cast<DWin32ShPool*>(iPool)->Base(aProcess) + (TUint)iRelAddress;

	return base;

	}

TUint8* DWin32ShBuf::Base()

	{

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

	TUint8* base = reinterpret_cast<DWin32ShPool*>(iPool)->Base() + (TUint)iRelAddress;

	return base;

	}

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

	{

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

	TInt r = KErrNotSupported;

	if (iPool->iPoolFlags & EShPoolPageAlignedBuffer)

		{

		if(iMapped)

			{

			r = KErrAlreadyExists;

			}

		else

			{

			aBase = reinterpret_cast<TUint>(reinterpret_cast<DWin32ShPool*>(iPool)->Base() + (TUint)iRelAddress);

			iMapped = ETrue;

			r = KErrNone;

			}

		}

	return r;

	}

TInt DWin32ShBuf::UnMap(DProcess* /* aProcess */)

	{

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

	TInt r = KErrNotSupported;

	if (iPool->iPoolFlags & EShPoolPageAlignedBuffer)

		{

		if(iMapped)

			{

			iMapped = EFalse;

			r = KErrNone;

			}

		else

			{

			r = KErrNotFound;

			}

		}

	return r;

	}

TInt DWin32ShBuf::AddToProcess(DProcess* aProcess, TUint /* aAttr */)

	{

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

	TUint flags;

	TInt r = KErrNone;

	if (aProcess != K::TheKernelProcess)

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

	return r;

	}

TInt DWin32ShBuf::Close(TAny* aPtr)

	{

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

	if (aPtr)

		{

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

		if (pP != K::TheKernelProcess)

		    iPool->CloseClient(pP);

		}

	return DShBuf::Close(aPtr);

	}

DWin32ShPool::DWin32ShPool()

  : DShPool()

	{

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

	}

DWin32ShPool::~DWin32ShPool()

	{

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

	if (iWin32MemoryBase)

		{

		TUint64 maxSize = static_cast<TUint64>(iMaxBuffers) * static_cast<TUint64>(iBufGap);

		// We know that maxSize is less than KMaxTInt as we tested for this in DoCreate().

		VirtualFree(LPVOID(iWin32MemoryBase), (SIZE_T)maxSize, MEM_DECOMMIT);

		VirtualFree(LPVOID(iWin32MemoryBase), 0, MEM_RELEASE);

		MM::Wait();

		MM::FreeMemory += iWin32MemorySize;

		MM::Signal();

		}

	delete iBufMap;

	}

void DWin32ShPool::DestroyClientResources(DProcess* aProcess)

	{

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

	TInt r = DestroyHandles(aProcess);

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

	(void)r;		// Silence warnings

	}

TInt DWin32ShPool::DeleteInitialBuffers()

	{

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

	if (iInitialBuffersArray != NULL)

		{

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

			{

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

			iInitialBuffersArray[i].Dec();

			iInitialBuffersArray[i].~DWin32ShBuf();

			}

		Kern::Free(iInitialBuffersArray);

		iInitialBuffersArray = NULL;

		}

	return KErrNone;

	}

TInt DWin32ShPool::DestroyHandles(DProcess* aProcess)

	{

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

	TInt r = KErrNone;

	Kern::MutexWait(*iProcessLock);

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

	__NK_ASSERT_DEBUG(client);

	__NK_ASSERT_DEBUG(client->iAccessCount == 0);

	delete client;

	if (aProcess != K::TheKernelProcess)

		{

		// Remove reserved handles

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

		}

	Kern::MutexSignal(*iProcessLock);

	return r;

	}

TInt DWin32ShPool::Close(TAny* aPtr)

	{

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

	if (aPtr) // not NULL must be user side

		{

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

		CloseClient(pP);

		}

	return DShPool::Close(aPtr);

	}

TInt DWin32ShPool::CreateInitialBuffers()

	{

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

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

	if (iInitialBuffersArray == NULL)

		return KErrNoMemory;

	TLinAddr offset = 0;

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

		{

		DWin32ShBuf *buf = new (&iInitialBuffersArray[i]) DWin32ShBuf(this, offset);

		TInt r = buf->Construct();

		if (r == KErrNone)

			{

			iFreeList.Add(&buf->iObjLink);

			}

		else

			{

			iInitialBuffers = i;

			return KErrNoMemory;

			}

		offset += iBufGap;

		}

	iFreeBuffers = iInitialBuffers;

	iTotalBuffers = iInitialBuffers;

	iBufMap->Alloc(0, iInitialBuffers);

	return KErrNone;

	}

TUint8* DWin32ShPool::Base()

	{

	return iWin32MemoryBase;

	}

TUint8* DWin32ShPool::Base(DProcess* /*aProcess*/)

	{

	return iWin32MemoryBase;

	}

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

	{

	__KTRACE_OPT(KEXEC, Kern::Printf("Adding DWin32ShPool %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 DShPoolClient;

		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;

				}

			}

		else

			{

			r = KErrNoMemory;

			}

		}

	else

		{

		LockPool();

		client->iAccessCount++;

		UnlockPool();

		}

	Kern::MutexSignal(*iProcessLock);

	return r;

	}

TInt DWin32ShPool::DoCreate(TShPoolCreateInfo& aInfo)

	{

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

	if (maxSize > static_cast<TUint64>(KMaxTInt))

		{

		return KErrArgument;

		}

	__KTRACE_OPT(KMMU,Kern::Printf("DWin32ShPool::DoCreate (maxSize = 0x%08x, iBufGap = 0x%08x)",

		static_cast<TInt>(maxSize), iBufGap));

	iWin32MemoryBase = (TUint8*) VirtualAlloc(NULL, (SIZE_T)maxSize, MEM_RESERVE, PAGE_READWRITE);

	if (iWin32MemoryBase == NULL)

		{

		return KErrNoMemory;

		}

	__KTRACE_OPT(KMMU,Kern::Printf("DWin32ShPool::DoCreate (iWin32MemoryBase = 0x%08x)", iWin32MemoryBase));

	iBufMap = TBitMapAllocator::New(aInfo.iInfo.iMaxBufs, (TBool)ETrue);

	if (iBufMap == NULL)

		{

		return KErrNoMemory;

		}

	return KErrNone;

	}

TBool DWin32ShPool::IsOpen(DProcess* /*aProcess*/)

	{

	// could do we some kind of check here?

	return (TBool)ETrue;

	}

TInt DWin32ShPool::UpdateFreeList()

	{

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

	SDblQue temp;

	SDblQueLink* anchor = reinterpret_cast<SDblQueLink*>(&iFreeList);

	LockPool();

	while(!iAltFreeList.IsEmpty())

		{

		// sort a temporary list of 'n' object with the lowest index first

		for (TInt n = 0; n < 8 && !iAltFreeList.IsEmpty(); ++n)

			{

			// bit of an assumption, lets assume that the lower indexes will be allocated and freed first

			// and therefore will be nearer the front of the list

			DShBuf* buf = _LOFF(iAltFreeList.GetFirst(), DShBuf, iObjLink);

			SDblQueLink* anchor = reinterpret_cast<SDblQueLink*>(&temp);

			SDblQueLink* pLink = temp.Last();

			for (;;)

				{

				// traverse the list starting at the back

				if ((pLink != anchor) && (_LOFF(pLink, DShBuf, iObjLink)->iRelAddress > buf->iRelAddress))

					{

					pLink = pLink->iPrev;

					}

				else

					{

					buf->iObjLink.InsertAfter(pLink);

					break;

					}

				}

			}

		// now merge with the free list

		while(!temp.IsEmpty())

			{

			if (iFreeList.IsEmpty())

				{

				iFreeList.MoveFrom(&temp);

				break;

				}

			// working backwards with the highest index

			DShBuf* buf = _LOFF(temp.Last(), DShBuf, iObjLink);

			SDblQueLink* pLink = iFreeList.Last();

			while (!NKern::FMFlash(&iLock))

				{

				if ((pLink != anchor) && (_LOFF(pLink, DShBuf, iObjLink)->iRelAddress > buf->iRelAddress))

					{

					pLink = pLink->iPrev;

					}

				else

					{

					buf->iObjLink.Deque();

					buf->iObjLink.InsertAfter(pLink);

					// next buffer

					if (temp.IsEmpty())

						break;

					buf = _LOFF(temp.Last(), DShBuf, iObjLink);

					}

				}

			}

		NKern::FMFlash(&iLock);

		}

	UnlockPool();

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

	return KErrNone;

	}

void DWin32ShPool::Free(DShBuf* aBuf)

	{

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

	TLinAddr newAddr = (TLinAddr)aBuf->Base();

#ifdef _DEBUG

	memset((TAny*)newAddr,0xde,aBuf->Size());

#else

	memclr((TAny*)newAddr,aBuf->Size());

#endif

	LockPool();

#ifdef _DEBUG

	// Remove from allocated list

	aBuf->iObjLink.Deque();

#endif

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

		{

		iAltFreeList.Add(&aBuf->iObjLink);

		}

	++iFreeBuffers;

#ifdef _DEBUG

	--iAllocatedBuffers;

#endif

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

	UnlockPool();

	// queue ManagementDfc which completes notifications as appropriate

	if (HaveWorkToDo())

		KickManagementDfc();

	Close(NULL); // decrement pool reference count

	}

// Kernel side API

TInt DWin32ShPool::Alloc(DShBuf*& aShBuf)

	{

	__KTRACE_OPT(KMMU, Kern::Printf(">DWin32ShPool::Alloc (DShBuf)"));

	TInt r = KErrNoMemory;

	aShBuf = NULL;

	LockPool();

	if (!iFreeList.IsEmpty())

		{

		aShBuf = _LOFF(iFreeList.GetFirst(), DShBuf, iObjLink);

#ifdef _DEBUG

		iAllocated.Add(&aShBuf->iObjLink);

		iAllocatedBuffers++;

#endif

		--iFreeBuffers;

		Open(); // increment pool reference count

		r = KErrNone;

		}

	else

		{

		// try alternative free list

		if (!iAltFreeList.IsEmpty())

			{

			aShBuf = _LOFF(iAltFreeList.GetFirst(), DShBuf, iObjLink);

#ifdef _DEBUG

			iAllocated.Add(&aShBuf->iObjLink);

			iAllocatedBuffers++;

#endif

			--iFreeBuffers;

			Open(); // increment pool reference count

			r = KErrNone;

			}

		}

	UnlockPool();

	if (HaveWorkToDo())

		KickManagementDfc();

	__KTRACE_OPT(KMMU, Kern::Printf("<DWin32ShPool::Alloc return buf = 0x%08x", aShBuf));

	return r;

	}

DWin32AlignedShPool::DWin32AlignedShPool()

  : DWin32ShPool()

	{

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

	}