// Copyright (c) 2005-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\drivers\trace\btracec.cpp

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include "d32btrace.h"

 #include <e32svr.h>

 #include <e32atomics.h>

 void Panic(TInt aPanicNum)

 	{

 	_LIT(KRBTracePanic,"RBTrace");

 	User::Panic(KRBTracePanic,aPanicNum);

 	}

 EXPORT_C TInt RBTrace::Open()

 	{

 	_LIT(KBTraceLddName,"btracex");

 	TInt r = User::LoadLogicalDevice(KBTraceLddName);

 	if(r!=KErrNone && r!=KErrAlreadyExists)

 		return r;

 	r = DoCreate( Name(), TVersion(), KNullUnit, NULL, NULL, EOwnerThread);

 	if(r==KErrNone)

 		{

 		r = OpenChunk();

 		if(r!=KErrNone)

 			Close();

 		}

 	return r;

 	};

 TInt RBTrace::OpenChunk()

 	{

 	TInt r = iDataChunk.SetReturnedHandle(DoControl(EOpenBuffer));

 	if(r==KErrNone)

 		iBuffer = (TBTraceBuffer*)iDataChunk.Base();

 	iLastGetDataSize = 0;

 	return r;

 	}

 void RBTrace::CloseChunk()

 	{

 	iLastGetDataSize = 0;

 	iBuffer = NULL;

 	iDataChunk.Close();

 	}

 EXPORT_C void RBTrace::Close()

 	{

 	CloseChunk();

 	RBusLogicalChannel::Close();

 	}

 EXPORT_C TInt RBTrace::BufferSize()

 	{

 	if(!iDataChunk.Handle())

 		return 0;

 	return iBuffer->iEnd;

 	}

 EXPORT_C TInt RBTrace::ResizeBuffer(TInt aSize)

 	{

 	CloseChunk();

 	TInt r = DoControl(EResizeBuffer,(TAny*)aSize);

 	if(r==KErrNone)

 		r = OpenChunk();

 	return r;

 	}

 EXPORT_C void RBTrace::Empty()

 	{

 	TBTraceBuffer* buffer = iBuffer;

 	TUint32 mode = __e32_atomic_swp_acq32(&buffer->iMode, 0);	/* read original mode and disable trace */

 	while(__e32_atomic_load_acq32(&buffer->iGeneration) & 1)	/* wait for trace handler to complete */

 		{ /* should really __chill() but not available user side */ }

 	buffer->iTail = buffer->iHead;

 	__e32_atomic_store_ord32(&buffer->iMode, mode);

 	}

 EXPORT_C TUint RBTrace::Mode()

 	{

 	return iBuffer->iMode;

 	}

 EXPORT_C void RBTrace::SetMode(TUint aMode)

 	{

 	iLastGetDataSize = 0;

 	__e32_atomic_store_ord32(&iBuffer->iMode, aMode);

 	}

 EXPORT_C TInt RBTrace::SetFilter(TUint aCategory, TInt aValue)

 	{

 	return (TInt)DoControl(ESetFilter,(TAny*)aCategory,(TAny*)aValue);

 	}

 EXPORT_C TInt RBTrace::SetFilter2(TUint32 aUid, TBool aValue)

 	{

 	return (TInt)DoControl(ESetFilter2,(TAny*)aUid,(TAny*)aValue);

 	}

 EXPORT_C TInt RBTrace::SetFilter2(const TUint32* aUids, TInt aNumUids)

 	{

 	return (TInt)DoControl(ESetFilter2Array,(TAny*)aUids,(TAny*)aNumUids);

 	}

 EXPORT_C TInt RBTrace::SetFilter2(TInt aGlobalFilter)

 	{

 	return DoControl(ESetFilter2Global,(TAny*)aGlobalFilter);

 	}

 EXPORT_C TInt RBTrace::Filter2(TUint32*& aUids, TInt& aGlobalFilter)

 	{

 	TInt count = (TInt)DoControl(EGetFilter2Part1,&aUids,&aGlobalFilter);

 	if(count<=0)

 		{

 		aUids = 0;

 		return count;

 		}

 	aUids = (TUint32*)User::Alloc(count*sizeof(TUint32));

 	if(!aUids)

 		return KErrNoMemory;

 	DoControl(EGetFilter2Part2,aUids,(TAny*)count);

 	return count;

 	}

 EXPORT_C TInt RBTrace::GetData(TUint8*& aData)

 	{

 	TInt size = iBuffer->GetData(aData);

 	iLastGetDataSize = size;

 	return size;

 	}

 EXPORT_C void RBTrace::DataUsed()

 	{

 	TBTraceBuffer* buffer = iBuffer;

 	if(!(buffer->iMode&RBTrace::EFreeRunning))

 		{

 		/* Make sure change to iTail is not observed before the trace data reads

 			which preceded the call to this function. */

 		__e32_memory_barrier();

 		buffer->iTail += iLastGetDataSize;

 		}

 	iLastGetDataSize = 0;

 	}

 EXPORT_C void RBTrace::RequestData(TRequestStatus& aStatus, TInt aSize)

 	{

 	if(aSize<0)

 		aSize = 0;

 	aStatus = KRequestPending;

 	if(aSize || iBuffer->iHead==iBuffer->iTail)

 		DoControl(ERequestData,&aStatus,(TAny*)aSize);

 	else

 		{

 		TRequestStatus* s = &aStatus;

 		User::RequestComplete(s,KErrNone);

 		}

 	}

 EXPORT_C void RBTrace::CancelRequestData()

 	{

 	DoControl(ECancelRequestData);

 	}

 EXPORT_C TBool RBTrace::SetTimestamp2Enabled(TBool aEnable)

 	{

 	return (TBool)DoControl(ESetTimestamp2Enabled, (TAny*)aEnable);

 	}

 /**

 Find out how much data is available.

 @param aData Set to the buffer offset where the available trace data is located.

 @param aTail Set to the the original value of the iTail pointer

 @return Number of bytes of trace data, or an error.

 */

 TInt TBTraceBuffer::Data(TUint& aData, TUint& aTail)

 	{

 	TUint head, tail, wrap;

 	TUint32 g0;

 	TInt retries=64;

 	do	{

 		if (--retries<0)

 			return KErrInUse;

 		// sleep every 8 tries to give the write a chance

 		if (retries&7==0)

 			User::AfterHighRes(1);

 		g0 = iGeneration;

 		__e32_memory_barrier();

 		head = iHead;

 		wrap = iWrap;

 		tail = __e32_atomic_and_rlx32(&iTail, ~TUint32(1));

 		__e32_memory_barrier();

 		} while(iGeneration!=g0 || (g0&1));	// repeat until we get a consistent set

 	tail &= ~1;

 	aTail = tail;

 	TUint end = head;

 	if (head<tail)

 		{

 		end = wrap;

 		if (tail>=end)

 			{

 			tail = iStart;

 			end = head;

 			}

 		}

 	aData = tail;

 	return end - tail;

 	}

 /**

 Adjust trace data size so it represents a whole number of trace records.

 @param aData The buffer offset where the available trace data is located.

 @param aSize The size of data at aTail. Must be >= KMaxBTraceRecordSize.

 @return An adjusted value for aSize.

 */

 TInt TBTraceBuffer::Adjust(TUint aData, TInt aSize)

 	{

 	TInt adjustedSize = (aSize&~3) - KMaxBTraceRecordSize;

 	if (adjustedSize<0)

 		Panic(0);

 	volatile TUint8* recordOffsets = (volatile TUint8*)this + iRecordOffsets;

 	adjustedSize += recordOffsets[(aData+adjustedSize)>>2]<<2;

 	if (adjustedSize>aSize)

 		Panic(1);

 	return adjustedSize;

 	}

 /**

 Update the stored tail offset.

 @param aOld The value which iTail is expected to have if no more overwrites have occurred

 @param aNew The new value for iTail

 @return aNew on success, 0 if the previous tail value had changed before we could update it.

 */

 TUint TBTraceBuffer::UpdateTail(TUint32 aOld, TUint32 aNew)

 	{

 	if (__e32_atomic_cas_rel32(&iTail, &aOld, aNew))

 		return aNew;	// if iTail==aOld, set iTail=aNew and return aNew

 	return 0;	// else return 0

 	}

 /**

 Copy data out of the main trace buffer into the 'copy buffer'.

 This may fail if the data is overwritten before it hase been successfully copied.

 @param aData The buffer offset where the available trace data is located.

 @param aTail The value which iTail is expected to have if no more overwrites have occurred

 @param aSize The size of data at aTail

 @return The number of bytes successfully copied.

 @post iBuffer.iTail has been updated to point to the trace record following those copied.

 */

 TInt TBTraceBuffer::CopyData(TUint aData, TUint aTail, TInt aSize)

 	{

 	// clip size to copy buffer

 	TInt maxSize = iCopyBufferSize;

 	if (aSize>maxSize)

 		aSize = Adjust(aData,maxSize);

 	if (iTail & 1)

 		return 0; // give up if data we're about to copy has been overwritten

 	memcpy((TUint8*)this+iCopyBuffer, (TUint8*)this+aData, aSize);

 	if (!UpdateTail(aTail, aData+aSize))

 		return 0;

 	return aSize;

 	}

 /**

 Get pointer to as much contiguous trace data as is available.

 @param aData Pointer to the first byte of trace data.

 @return The number of bytes of trace data available at aData.

 */

 TInt TBTraceBuffer::GetData(TUint8*& aData)

 	{

 	TInt retries = 4;

 	// get availabe data...

 	TUint data, tail;

 	TInt size = Data(data, tail);

 	if (!size)

 		return size; // no data available

 	if (!(iMode & RBTrace::EFreeRunning))

 		{

 		// if we got an error from Data but aren't in free-running mode, something has

 		// been interrupting the writing thread for some time while it has interrupts

 		// turned off. give up.

 		if (size<0)

 			return 0;

 		// were not in free-running mode, so we can leave the data where it is...

 		aData = (TUint8*)this + data;

 		iTail = data;	// OK since iTail never updated by kernel in this mode

 		return size;

 		}

 	// if we couldn't get a consistent snapshot of the pointers, we need to disable

 	// free running, otherwise we will stall for a very long time.

 	if (size==KErrInUse)

 		goto giveup;

 	// copy data to the copy buffer...

 	aData = (TUint8*)this + iCopyBuffer;

 	size = CopyData(data, tail, size);

 	if (size)

 		return size; // success

 	// data copy failed because new data was added during copy; this happens when the buffer

 	// is full, so now we'll attempt to discard data to give us some breathing space...

 	while(retries)

 		{

 		// see what data is available...

 		size = Data(data, tail);

 		if (!size)

 			return size; // no data in buffer (shouldn't happen because buffer was full to start with)

 		if (size==KErrInUse)

 			goto giveup;

 		// discard a proportion of the data...

 		TInt discard = iCopyBufferSize>>retries;

 		if (discard>=size)

 			discard = size;

 		else

 			discard = Adjust(data, discard); // make sure we only discard a whole number of trace records

 		size -= discard;

 		data = UpdateTail(tail, data+discard);

 		if (!data)

 			continue;	// tail was updated before we could discard, so try again

 		if (!size)

 			continue;	// we discarded everything - make sure and then exit

 		// try and copy remaining data...

 		size = CopyData(data, data, size);

 		if (size)

 			break; // success!

 		// loop around for another go, discard more this time

 		--retries;

 		}

 	if (!size)

 		{

 giveup:

 		// we haven't managed to copy data, so give up and do it with free-running mode off...

 		TUint32 mode = __e32_atomic_and_acq32(&iMode, ~(TUint32)RBTrace::EFreeRunning);	/* read original mode and disable free running */

 		size = Data(data, tail);

 		// as above: if we get an error here then something has been interrupting the writer

 		// for an unreasonable time, give up.

 		if (size<0)

 			return 0;

 		size = CopyData(data, tail, size);

 		__e32_atomic_store_ord32(&iMode, mode);	/* restore original mode */

 		}

 	// we discarded some data, so mark first trace record to indicate that some records are missing...

 	aData[BTrace::EFlagsIndex] |= BTrace::EMissingRecord;

 	return size;

 	}