// 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 (MBuf Chains)

// 

//

/**

 @file

 @internalComponent

*/

#include <es_mbman.h>

#include "MBufPoolChain.h"

#include "MBufPoolManager.h"

#include <cflog.h>

//

// MBUF CHAIN

//

#ifdef __CFLOG_ACTIVE

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

__CFLOG_STMT(_LIT8(KComponentPerformance, "performance");)	// component name - used for any sub-optimal performance behaviuor

#endif

__IMPLEMENT_CLEANUP(RMBufChain, Free)

EXPORT_C void RMBufChain::AllocL(TInt aLen)

/**

Allocate sufficient mbufs to hold specfied amount of data,

optionally zeroing the buffers.

- Overloaded min/max variants (eg. refer RMBufChain::Alloc) deliberately do not exist because;

  a. Intention is to ultimately deprecate (or at least discourage) the leaving variants since their usage is not typically (but not always

     the case) recommended because they the throw/catch mechanism can hinder performance if used in appopriately.

  b. Intention is to ultimately deprecate (or at least discourage) this class as it will likely be superceded by a generic system wide

     equivalent.

  c. If they shown to useful for this API, they can easily be added in the future... but the same can not be said for removing them in the future!

@param aLen A length of the cell

*/

	{

	RMBufAllocator allocator;

	return AllocL(aLen, allocator);

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen)

/**

Allocate sufficient mbufs to hold specfied amount of data,

optionally zeroing the buffers.

@param aLen A length of the cell

*/

	{

	RMBufAllocator allocator;

	return Alloc(aLen, allocator);

	}

TInt RMBufChain::Alloc(TInt aLen, const RMBufChain &aMBufChain)

	{

	RMBufAllocator allocator;

	return Alloc(aLen, aMBufChain, allocator);

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen, TInt aMinMBufSize)

	{

	RMBufAllocator allocator;

	return Alloc(aLen, aMinMBufSize, allocator);

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen, TInt aMinMBufSize, TInt aMaxMBufSize)

	{

	RMBufAllocator allocator;

	return Alloc(aLen, aMinMBufSize, aMaxMBufSize, allocator);

	}

// overloading for TLS

EXPORT_C void RMBufChain::AllocL(TInt aLen, RMBufAllocator& aRMBufAllocator)

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aRMBufAllocator.MBufManager().AllocL(aLen);

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen, RMBufAllocator& aRMBufAllocator)

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aRMBufAllocator.MBufManager().Alloc(aLen);

	return iNext? KErrNone: KErrNoMBufs;

	}

TInt RMBufChain::Alloc(TInt aLen, const RMBufChain& aMBufChain, RMBufAllocator& aRMBufAllocator)

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aRMBufAllocator.MBufManager().Alloc(aLen, aMBufChain);

	return iNext? KErrNone: KErrNoMBufs;

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen, TInt aMinMBufSize, RMBufAllocator& aRMBufAllocator)

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aRMBufAllocator.MBufManager().Alloc(aLen, aMinMBufSize);

	return iNext? KErrNone: KErrNoMBufs;

	}

EXPORT_C TInt RMBufChain::Alloc(TInt aLen, TInt aMinMBufSize, TInt aMaxMBufSize, RMBufAllocator& aRMBufAllocator)

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aRMBufAllocator.MBufManager().Alloc(aLen, aMinMBufSize, aMaxMBufSize);

	return iNext? KErrNone: KErrNoMBufs;

	}

EXPORT_C TInt RMBufChain::ReAlloc(TInt aLen)

/**

Adjust the size of a chain, allocates a new memory for the chain

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

@param aLen A new length

*/

	{

	__ASSERT_ALWAYS(aLen>=0, CMBufManager::Panic(EMBuf_NegativeLength));

	TInt currLen = Length();

	if(aLen < currLen)

		TrimEnd(aLen);

	else if(aLen > currLen)

		{

		TInt extraReq = aLen - currLen;

		if(currLen > 0)

			{

			// Extend the final buf to consume any idle space

			RMBuf* pLast = Last();

			TInt idleSpace = pLast->Size() - pLast->End();

			ASSERT(idleSpace >= 0);

			if(idleSpace)

				{

				TInt useSpace = Min(idleSpace, extraReq);

				pLast->AdjustEnd(useSpace);

				extraReq -= useSpace;

				// Did this yield enough?

				if(!extraReq)

					return KErrNone;

				}

			}

		// Need additional allocation

		RMBufChain extraChain;

		TInt err = extraChain.Alloc(extraReq, *this);

		if(err != KErrNone)

			{

			return err;

			}

		Append(extraChain);

		}

	return KErrNone;

	}

EXPORT_C void RMBufChain::ReAllocL(TInt aLen)

/**

Adjust the size of a chain, allocates a new memory for the chain

@param aLen A new length

*/

	{

	User::LeaveIfError(ReAlloc(aLen));

	}

EXPORT_C TInt RMBufChain::Create(const TDesC8& aDes, TInt aHdrLen)

/**

Create an Mbuf chain from a descriptor optionally allowing room at front for a protocol header.

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

@param aDes

@param aHdrLen A header length

*/

	{

	TInt err = Alloc(aDes.Length() + aHdrLen);

	if(err == KErrNone)

		{

		CopyIn(aDes, aHdrLen);	// NB! old version prepended explicit buf. wonder if that matters?

		}

	return err;

	}

EXPORT_C void RMBufChain::CreateL(const TDesC8& aDes, TInt aHdrLen)

/**

Create an Mbuf chain from a descriptor optionally allowing room at front for a protocol header.

@param aDes

@param aHdrLen A header length

*/

	{

	User::LeaveIfError(Create(aDes, aHdrLen));

	}

EXPORT_C void RMBufChain::Free()

/**

Free an MBuf chain, returning it to the free Pool

A pointer to the first mbuf of the next packet is returned.

*/

	{

	if (iNext!=NULL)

		iNext->Free();

	Init();

	}

EXPORT_C void RMBufChain::FillZ(TInt aLen)

/**

Zero fill the first aLen bytes of an mbuf chain

@param aLen the length (how many byte to be appended to the end)

*/

	{

	__ASSERT_ALWAYS(iNext!=NULL, CMBufManager::Panic(EMBuf_EmptyChain));

	TInt n;

	RMBuf* m = iNext;

	while (aLen>0 && m!=NULL)

		{

			n = aLen < m->Length() ? aLen : m->Length();

			Mem::FillZ(m->Ptr(), n);

			aLen -= n;

			m = m->Next();

		}

	}

EXPORT_C void RMBufChain::CopyL(RMBufChain& newChain, TInt anOffset, TInt aLen) const

/**

Copy data into a new chain starting at a given offset

into this chain.

Allocate sufficient mbufs to hold specfied amount of data,

optionally zeroing the buffers.

@param aLen A length of the cell

*/

	{

	User::LeaveIfError(Copy(newChain, anOffset, aLen));

	}

EXPORT_C TInt RMBufChain::Copy(RMBufChain &newChain, TInt anOffset, TInt aLen) const

/**

Copy data into a new chain starting at a given offset

into this chain.

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

@param newChain A new chain, where the data is copied to

@param anOffset A offset,

@param aLen the length of the data to be copied

*/

	{

	__ASSERT_ALWAYS(iNext!=NULL, CMBufManager::Panic(EMBuf_EmptyChain));

	__ASSERT_ALWAYS(aLen>=0, CMBufManager::Panic(EMBuf_NegativeLength));

	__ASSERT_ALWAYS(anOffset>=0, CMBufManager::Panic(EMBuf_NegativeOffset));

	TInt n, n1, n2;

	TUint8* p1, *p2;

	RMBuf* m1, *m2;

	TInt len = Length();

	if (anOffset>0)

		{

		__ASSERT_ALWAYS(anOffset<len, CMBufManager::Panic(EMBuf_BadOffset));

		n = len - anOffset;

		len = Min(aLen, n);

		}

	else

		len = Min(aLen, len);

	TInt err = newChain.Alloc(len, *this);

	if(err != KErrNone)

		{

		return err;

		}

	if (anOffset>0)

		{

		if (!Goto(anOffset, m1, n, n1))

			return KErrNone;

		p1 = m1->Buffer()+n;

		}

	else

		{

		m1 = iNext;

		p1 = m1->Ptr();

		n1 = m1->Length();

		}

	m2 = newChain.iNext;

	p2 = m2->Ptr();

	n2 = m2->Length();

	while (len>0)

		{

		__ASSERT_DEBUG(n1>0 && n2>0, CMBufManager::Panic(EMBuf_NegativeLength));

		n = n1 < n2 ? n1 : n2;

		Mem::Copy(p2, p1, n);

		if (n1 -= n, n1 == 0)

			{

			if (m1 = m1->Next(), m1==NULL)

				break;

			p1 = m1->Ptr();

			n1 = m1->Length();

			}

		else

			p1 += n;

		if (n2 -= n, n2 == 0)

			{

			if (m2 = m2->Next(), m2==NULL)

				break;

			p2 = m2->Ptr();

			n2 = m2->Length();

			}

		else

			p2 += n;

		len -= n;

		}

	return KErrNone;

	}

EXPORT_C void RMBufChain::CopyIn(const TDesC8& aDes, TInt aOffset)

/**

Copy data into an mbuf chain from a linear buffer

starting at specified offset.

@param aDes The buffer from where data is copied to the chain

@param aOffset The offset

*/

	{

	__ASSERT_ALWAYS(iNext!=NULL, CMBufManager::Panic(EMBuf_EmptyChain));

	__ASSERT_ALWAYS(aOffset>=0, CMBufManager::Panic(EMBuf_NegativeOffset));

	TUint8* ptr = (TUint8*)aDes.Ptr();

	TInt len = aDes.Length();

	TInt n;

	RMBuf* m;

	if (aOffset>0)

		{

		TInt o;

		if (!Goto(aOffset, m, o, n))

			return;

		if (n>len)

			n = len;

		Mem::Copy(m->Buffer()+o, ptr, n);

		ptr += n;

		len -= n;

		m = m->Next();

		}

	else

		m = iNext;

	while (len>0 && m!=NULL)

		{

		n = len > m->Length() ? m->Length() : len;

		Mem::Copy(m->Ptr(), ptr, n);

		ptr += n;

		len -= n;

		m = m->Next();

		}

	}

EXPORT_C void RMBufChain::CopyOut(TDes8& aDes, TInt aOffset) const

/**

Copy data from an mbuf chain into linear buffer

starting at specified offset.

@param aDes the buffer to copy in to

@param aOffset the offset

*/

	{

//removed after internal discussion; generally unhelpful as empty == zero length is ok concept

//	__ASSERT_ALWAYS(iNext!=NULL, CMBufManager::Panic(EMBuf_EmptyChain));

	__ASSERT_ALWAYS(aOffset>=0, CMBufManager::Panic(EMBuf_NegativeOffset));

	TUint8* ptr = (TUint8*)aDes.Ptr();

	TInt len = aDes.Length();

	TInt n;

	RMBuf* m;

	if (aOffset>0)

		{

		TInt o;

		if (!Goto(aOffset, m, o, n))

			{

			aDes.SetLength(0);

			return;

			}

		if (n>len)

			n = len;

		Mem::Copy(ptr, m->Buffer()+o, n);

		ptr += n;

		len -= n;

		m = m->Next();

		}

	else

		m = iNext;

	while (len>0 && m!=NULL)

		{

		n = len > m->Length() ? m->Length() : len;

		Mem::Copy(ptr, m->Ptr(), n);

		ptr += n;

		len -= n;

		m = m->Next();

		}

	aDes.SetLength(ptr-aDes.Ptr());

	}

EXPORT_C void RMBufChain::Assign(RMBufQ& aQueue)

/**

Take ownership of Mbuf from a queue

Previously allocated data (e.g. by a call to RMBufChain::AllocL) in the chain must be

emptied (e.g. by calling RMBufChain::Free) before the assignment

@param aQueue the queue

@see RMBufChain::IsEmpty()

@see RMBufChain::Free()

*/

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aQueue.First();

	aQueue.Init();

	}

EXPORT_C void RMBufChain::Assign(RMBufChain& aChain)

/**

Take ownership of Mbuf from another chain

Previously allocated data (e.g. by a call to RMBufChain::AllocL) in the chain must be

emptied (e.g. by calling RMBufChain::Free) before the assignment

@param aChain the chain

@see RMBufChain::IsEmpty()

@see RMBufChain::Free()

*/

	{

	__ASSERT_ALWAYS(iNext==NULL, CMBufManager::Panic(EMBuf_NotEmptyChain));

	iNext = aChain.iNext;

	aChain.Init();

	}

EXPORT_C void RMBufChain::Append(RMBufChain& aChain)

/**

Append an MBuf chain, taking ownership of the MBufs

@param aChain the chain to be appended

*/

	{

	__ASSERT_ALWAYS(iNext!=aChain.iNext, CMBufManager::Panic(EMBuf_CircularRef));

	if (iNext!=NULL)

		{

		RMBuf* last	= Last();

		last->Link(aChain.iNext);

		}

	else

		iNext = aChain.iNext;

	aChain.Init();

	}

EXPORT_C void RMBufChain::AppendL(TInt aLen)

/**

Append space to the end of a MBuf chain

@param aLen the length (how many byte to be appended to the end)

*/

	{

	User::LeaveIfError(Append(aLen));

	}

EXPORT_C TInt RMBufChain::Append(TInt aLen)

/**

Append space to the end of a MBuf chain

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

@param aLen the length (how many byte to be appended to the end)

*/

	{

	RMBufAllocator allocator;

	return Append(aLen, allocator);

	}

// overloading for TLS

EXPORT_C TInt RMBufChain::Append(TInt aLen, RMBufAllocator& aRMBufAllocator)

	{

	if (iNext==NULL)

		{

		return Alloc(aLen, *this, aRMBufAllocator);

		}

	RMBuf* last = Last();

	// Amount of space available on end of last Mbuf

	TInt n = Min(last->Size()-(last->Offset()+last->Length()), aLen);

	// Amount of space that needs to be Allocated in new buffers

	TInt m = aLen-n;

	if (m>0)

		{

		RMBufChain chn;

		TInt err = chn.Alloc(m, *this, aRMBufAllocator);

		if(err != KErrNone)

			{

			return err;

			}

		last->Link(chn.iNext);

		}

	// Left to last to avoid modifying the chain unless the extension suceeds

	last->AdjustEnd(n);

	return KErrNone;