// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Buffer Manager for Protocols

// 

//

#include <comms-infras/cfperfmetrics.h>

#include "mbufmanager.h"

#include "es_prot.h"	// for ESocketTimerPriority

#include <e32hal.h>

#include <comms-infras/cfmacro.h>

#include "MBufPoolChain.h"

#include "MBufTimer.h"

#include "MBufPool.h"

#include "MBufSizeAllocator.h"

#include "MBufPoolManager.h"

#include "MBufMemoryAllocator.h"

#include <cflog.h>

#include <comms-infras/commsbufpond.h>

#include <comms-infras/commsbufpondop.h>

#include <comms-infras/mbufasyncrequest.h>

#ifdef __CFLOG_ACTIVE

__CFLOG_STMT(_LIT8(KComponent, "Manager");)

__CFLOG_STMT(_LIT8(KSubsysMBufMgr, "MBufMgr");) // subsystem name

#endif

/**

MBuf Private Heap Limits

@internalTechnology

*/

static const TInt KMBufFreePriority = 20;

// The asynchronous allocations have to be requested by the thread that created the MBufMgr

// This we do by having a requester object in that thread which gets completed by the other

// threads to trigger the request

NONSHARABLE_CLASS(CRequestAsyncAlloc) : public CActive

	{

public:

	static CRequestAsyncAlloc* NewL();

	virtual ~CRequestAsyncAlloc();

	void StartWaitForRequest();

	void MakeRequest();

private:

	CRequestAsyncAlloc();

	void ConstructL();

	virtual void DoCancel();

	virtual void RunL();

	RCriticalSection iCritSec;

	RThread iMBufMgrOwnerThread;

	TBool iSignalled;

	};

CRequestAsyncAlloc::CRequestAsyncAlloc()

: CActive(0)

	{

	}

CRequestAsyncAlloc* CRequestAsyncAlloc::NewL()

	{

	CRequestAsyncAlloc* This = new(ELeave) CRequestAsyncAlloc;

	CleanupStack::PushL(This);

	This->ConstructL();

	CleanupStack::Pop(This);

	return This;

	}

void CRequestAsyncAlloc::ConstructL()

	{

	User::LeaveIfError(iCritSec.CreateLocal());

	iMBufMgrOwnerThread.Duplicate(RThread());

	CActiveScheduler::Add(this);

	}

CRequestAsyncAlloc::~CRequestAsyncAlloc()

	{

	Deque();

	iCritSec.Close();

	iMBufMgrOwnerThread.Close();

	}

void CRequestAsyncAlloc::StartWaitForRequest()

	{

	__ASSERT_DEBUG(!IsActive(), CMBufManager::Panic(EMBuf_AlreadyActive));

	iStatus = KRequestPending;

	SetActive();

	}

void CRequestAsyncAlloc::MakeRequest()

	{

	NETWORKING_ATOMIC(;) // Codepattern below may have SMP implications

	// This is being most likely being called from the context of some thread other than the

	// MBufMgr owner, and there's a distinct risk of more than one thread being OOB at the same

	// time since it's a common pool. So here we have to guard against being completed multiple

	// times, using a critical section because there's a tiny but real risk of a completion from

	// another thread in between a test upon IsActive() and our completion of it, which could give

	// a stray event panic

	if(!iSignalled)

		{

		// We're almost certainly the only thread doing this; now check again inside the critsec to be sure

		iCritSec.Wait();

		if(!iSignalled)

			{

			iSignalled = ETrue;

			TRequestStatus* pStatus = &iStatus;

			iMBufMgrOwnerThread.RequestComplete(pStatus, KErrNone);

			}

		iCritSec.Signal();

		}

	}

void CRequestAsyncAlloc::DoCancel()

	{

	NETWORKING_ATOMIC(;) // Codepattern below may have SMP implications

	if(!iSignalled)

		{

		// We're almost certainly the only thread doing this; now check again inside the critsec to be sure

		iCritSec.Wait();

		if(!iSignalled)

			{

			iSignalled = ETrue;

			TRequestStatus* pStatus = &iStatus;

			User::RequestComplete(pStatus, KErrCancel);

			}

		iCritSec.Signal();

		}

	}

void CRequestAsyncAlloc::RunL()

	{

	// Now that we're in the thread that owns the timer we can reset it

	CMBufManager::Context()->WatchDogReset();

	// Ready for the next cry of OOB distress

	iStatus = KRequestPending;

	iSignalled = EFalse;

	SetActive();

	}

//

// MBUF MANAGER

//

CMBufManager::CMBufManager()

/**

MBUF MANAGER

*/

	{

#ifdef __CFLOG_ACTIVE

	__CFLOG_1(KSubsysMBufMgr, KComponent, _L8("CMBufManager %x:\tCMBufManager()"), this);

#endif

	iAllocsPending.SetOffset(_FOFF(CCommsBufAsyncRequest,iLink));

#ifdef SYMBIAN_NETWORKING_PERFMETRICS

	CommsFW::CPerfMetricStore::AddClient(this, AddToPerfLog);

#endif

	}

void CMBufManager::Panic(TMBufPanic aPanic)

/**

For use by mbuf related classes

*/

	{

	_LIT(mbuf,"MBuf");

	User::Panic(mbuf, aPanic);

	}

CMBufManager::~CMBufManager()

//

//

//

	{

#ifdef SYMBIAN_NETWORKING_PERFMETRICS

	CommsFW::CPerfMetricStore::RemoveClient(this);

#endif

	if (iRequestAsyncAlloc)

		{

		iRequestAsyncAlloc->Cancel();

		delete iRequestAsyncAlloc;

		iRequestAsyncAlloc = NULL;

		}

	while (!iAllocsPending.IsEmpty())

		{

        CancelRequest(*iAllocsPending.First());

        }

	if (iFreeCB!=NULL)

		{

        delete iFreeCB;

        }

	iAsynAllocLock.Close();

	delete iTimer;

	if (iMBufPoolManager)

		{

		delete iMBufPoolManager;

		}

	Dll::SetTls(NULL);

	}

EXPORT_C MCommsBufPondIntf* CMBufManager::New(RArray <TCommsBufPoolCreateInfo>& aPoolInfo, RLibrary& aLibrary, TInt aMaxHeapSize)

	{   	

	CMBufManager* self = new CMBufManager(aLibrary);

	if (self)	

		{

		Dll::SetTls(self);

		TRAPD( err, self->ConstructL(aPoolInfo, aMaxHeapSize));

		if( err != KErrNone)

			{

			Dll::SetTls(NULL);

			delete self;

			return NULL;				

			}

		}

	return self;

	}

void CMBufManager::ConstructL(RArray <TCommsBufPoolCreateInfo>& aPoolInfo, TInt aMaxHeapSize)

	{	

	// Calculate the total heapsize

	TInt totalHeapSize = aMaxHeapSize;

	if(aMaxHeapSize == 0)

		{

		for (TInt i = 0; i < aPoolInfo.Count(); ++i)		

			{

			totalHeapSize += (aPoolInfo[i].iCeiling * (ALIGN_UP(sizeof(RMBuf)) + ALIGN_UP(aPoolInfo[i].iBufSize)));

			}			

		}

	ConstructL(totalHeapSize);

	for (TInt i = 0; i < aPoolInfo.Count(); ++i)		

		{

		iMBufPoolManager->AddL(aPoolInfo[i].iBufSize, aPoolInfo[i].iInitialBufs, aPoolInfo[i].iGrowByBufs, aPoolInfo[i].iMinFreeBufs, aPoolInfo[i].iCeiling * aPoolInfo[i].iBufSize);

		}

	}

CMBufManager::CMBufManager(RLibrary& aLibrary)

: iLibrary(aLibrary)

	{

#ifdef __CFLOG_ACTIVE

	__CFLOG_1(KSubsysMBufMgr, KComponent, _L8("CMBufManager %x:\tCMBufManager()"), this);

#endif

	iAllocsPending.SetOffset(_FOFF(CCommsBufAsyncRequest,iLink));

#ifdef SYMBIAN_NETWORKING_PERFMETRICS

	CommsFW::CPerfMetricStore::AddClient(this, AddToPerfLog);

#endif		

	}

void CMBufManager::ConstructL(TInt aMaxHeapSize)

//

//

//

	{

	User::LeaveIfError(iAsynAllocLock.CreateLocal());

	TCallBack c(FreeCallBack, this);

	// create an instance of the mbuf pool manager

	// - used to handle all pool allocation manipulation, also used as a concrete class for limited public interfaces exposed

	//   to the client

	iMBufPoolManager = CMBufPoolManager::NewL(aMaxHeapSize, *this);

	CleanupStack::PushL(iMBufPoolManager);

	iFreeCB = new(ELeave) CAsyncCallBack(c, KMBufFreePriority);

	CleanupStack::PushL(iFreeCB);

	iTimer=CDeltaTimer::NewL(EMBufMgrTimerPriority, KMbufManTimerGranularity);

	CleanupStack::PushL(iTimer);

	iTimerThreadId = RThread().Id();

	iRequestAsyncAlloc = CRequestAsyncAlloc::NewL();

	iRequestAsyncAlloc->StartWaitForRequest();

	CleanupStack::Pop(iTimer); 

	CleanupStack::Pop(iFreeCB); 

	CleanupStack::Pop(iMBufPoolManager); 

	}

CMBufManager* CMBufManager::Context()

	// There is a single system-wide MBuf manager.

	{

	CMBufManager* pMgr = STATIC_CAST(CMBufManager*, Dll::Tls());

	__ASSERT_ALWAYS(pMgr != NULL, Panic(EMBuf_NoManager));

	return pMgr;

	}

void CMBufManager::SetContext()

	// There is a single system-wide MBuf manager.

	{

	Dll::SetTls(this);

	}

void CMBufManager::Release(RLibrary& aLib)

	{

	aLib = iLibrary;

	delete this;		

	}

MCommsBufPondDbg& CMBufManager::CommsBufPondDbg()

	{

	return *this;		

	}

TInt CMBufManager::BytesAvailable() const

    {

	__ASSERT_DEBUG(iMBufPoolManager!=NULL, Panic(EMBuf_NoPoolManager));

	return iMBufPoolManager->BytesAvailable();

    }

TInt CMBufManager::BytesAvailable(TInt aSize) const

    {

    __ASSERT_DEBUG(iMBufPoolManager!=NULL, Panic(EMBuf_NoPoolManager));

	return iMBufPoolManager->BytesAvailable(aSize);

    }

#ifdef _MBUF_TEST

// misc. sanity checks - all pool chains

void CMBufManager::__DbgCheckChain(RMBuf* aMBuf, TMBufType aType, TInt aLength, TInt aSize)

//

// Check that an MBuf chain if of the required length and that all bufs are

// of the requred type.

//

	{

	CMBufManager* mgr = CMBufManager::Context();

	TInt siz=0, len=0;

	RMBuf* m;

	RMBuf* p = NULL;

	TMBufIter iter(aMBuf);

	while (m = iter++, m!=NULL)

		{

		mgr->__DbgCheckBuffer(m);

		len += m->Length();

		siz += m->Size();

		if (m->Type()!=aType)

			Panic(EMBuf_CheckFailType);

		p = m; // so we know what the previous one was when it panics under the debugger

		(void)p->Last();

		}

	if (aSize!=0 && siz!=aSize)

		Panic(EMBuf_CheckFailSize);

	if (aLength!=0 && len!=aLength)

		Panic(EMBuf_CheckFailLength);

	}

TInt CMBufManager::__DbgCheckBuffer(RMBuf* aBuf)

//

// For each pool within the corresponding chain, try to locate aBuf

//

	{

	return iMBufPoolManager->__DbgCheckBuffer(aBuf);

	}

#else	//#ifdef _MBUF_TEST

void CMBufManager::__DbgCheckChain(RMBuf* /*aMBuf*/, TMBufType /*aType*/, TInt /*aLength*/, TInt /*aSize*/)

{

   return;

}

TInt CMBufManager::__DbgCheckBuffer(RMBuf* /*aBuf*/)

{

   return KErrNone;

}

#endif

void CMBufManager::WatchDogReset()

	{

	if (iWatchDogIsPending)

		{

		iWatchDogIsPending=EFalse;

		MBufTimer::Remove(iWatchDog);

		}

	if(!iAllocsPending.IsEmpty())

		{

		TCallBack c(WatchDogExpire, this);

		iWatchDogIsPending=ETrue;

		iWatchDog.Set(c);

		MBufTimer::Queue(KMBufWatchDogTime,iWatchDog);

		}

	}

TInt CMBufManager::WatchDogExpire(TAny* aPtr)

	{

	((CMBufManager*)aPtr)->iWatchDogIsPending=EFalse;

	((CMBufManager*)aPtr)->CompleteAsyncAllocs(EFalse);		// if required, do not allocate new pools

	((CMBufManager*)aPtr)->CompleteAsyncAllocs(ETrue);		// if required, do allocate new pools

	return 0;

	}

void CMBufManager::StartRequest(CCommsBufAsyncRequest& aRequest)

//

//

//

	{

	iAsynAllocLock.Wait();

	iAllocsPending.AddLast(aRequest);

	iAsynAllocLock.Signal();

	iRequestAsyncAlloc->MakeRequest();

	}

void CMBufManager::CancelRequest(CCommsBufAsyncRequest& aRequest)

//

//

//

	{

	aRequest.iLink.Deque();

	aRequest.Complete(KErrCancel);

	if (iRequestAsyncAlloc)

	   {

	   iRequestAsyncAlloc->MakeRequest();

	   }

	}

// attempt to complete outstanding asynchronous allocation requests

// - typically called after some mbufs have been freed

void CMBufManager::CompleteAsyncAllocs(TBool aIsAllocPool)

	{

	TBool reset = ETrue;

	CCommsBufAsyncRequest *req;

#ifdef __CFLOG_ACTIVE

	__CFLOG_1(KSubsysMBufMgr, KComponent, _L8("CMBufManager %x:\tCompleteAsyncAllocs() called"), this);

#endif

	// first lock the pending list

	iAsynAllocLock.Wait();

	TDblQueIter<CCommsBufAsyncRequest> iter(iAllocsPending);

	// attempt to allocate each outstanding asynchronous allocation request

	// - deliberately so, the request is attempted without extending the pool (as this is done from a watchdog timer as a last resort)

	while (req = iter++, req != NULL)

		{

		// if null size specified, then allocate a default sized mbuf

		// - to avoid a SC break, the default size is hard coded to K_MBufSmallSize for consumers that assume that this length will be returned

		TInt reqSize = req->iSize;

		if (reqSize == 0) 	// trs; does it make sense to request an allocation without specifying a length? kept as is to avoid a SC break

			reqSize = KMBufSmallSize;

		RMBuf* mBufs = Alloc(reqSize, req->iMinSize, req->iMaxSize, aIsAllocPool);

		if (mBufs)

			{

			RMBufQ& q = static_cast<RMBufQ&>(req->iBufQ);

			q = mBufs;

			req->Complete(KErrNone);

			if (aIsAllocPool)	// not done for pool allocation growth to ensure FC with the factored out implementation; CompleteLargeRequests()

				reset = EFalse;

			}

		}

	iAsynAllocLock.Signal();

	// only reset the watch dog if there are no pending requests left or a request was completed, otherwise big pending requests might

	// be stalled by a continual trickle of small allocs and frees.

	if (iAllocsPending.IsEmpty() || reset)

		WatchDogReset();

	}

// refer RMBufChain::AllocL notes regarding the deliberate decision not to provide an overloaded min/max mbuf size variant

RMBuf* CMBufManager::AllocL(TInt aSize)

//

// Allocate and initialise a chain of MBufs

// Total data length is set to exact size.

//

	{

	RMBuf* buf = Alloc(aSize);

	if(!buf)

		{

		User::Leave(KErrNoMBufs);

		}

	return buf;

	}

void CMBufManager::Free(RCommsBuf* aBuf)

	{

	iMBufPoolManager->Free(static_cast<RMBuf*>(aBuf), EFalse);

	}

TInt CMBufManager::LargestBufSize() const

    /** Returns the size of the largest MBuf that the manager can provide.

        @return the size of the largest MBuf that the manager can provide.

    */

	{

	// iLargestMBufSize is needed for legacy functionallity when the MBufSize is not specified

	// in RMBufChain::Align(TInt aSize).  It is updated in MBufPoolManager as new pools are created

	__ASSERT_DEBUG(iMBufPoolManager!=NULL, Panic(EMBuf_NoPoolManager));