// btrace_reader.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

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

// Accenture - Initial contribution

//

#include "btrace_parser.h"

class TBtraceHeader

	{

public:

	TUint8 iSize;

	TUint8 iFlags;

	TUint8 iCategory;

	TUint8 iSubCategory;

	};

NONSHARABLE_CLASS(CMultipartFragment) : public CBase

	{

public:

	static CMultipartFragment* NewLC(const TBtraceFrame& aFirstFrame, TUint32 aExtra);

	~CMultipartFragment();

	static TInt Compare(const CMultipartFragment& aFirst, const CMultipartFragment& aSecond);

	void AddDataL(const TDesC8& aData);

	TUint8 Category() const { return iFirstFrame.iCategory; }

	TUint8 SubCategory() const { return iFirstFrame.iSubCategory; }

	const TBtraceFrame& Frame() const { return iFirstFrame; }

	TInt TotalSize() const { return iTotalSize; }

	CMultipartFragment(TUint32 aExtra); // Only used for search key

private:

	CMultipartFragment(const TBtraceFrame& aFirstFrame, TUint32 aExtra);

	void ConstructL();

private:

	TInt iTotalSize;

	TBtraceFrame iFirstFrame;

	TUint32 iUniqueId;

	RBuf8 iData;

	};

NONSHARABLE_CLASS(CFlusher) : public CTimer

	{

public:

	static CFlusher* NewL(CBtraceReader& aReader);

	~CFlusher();

	void Start(TTimeIntervalMicroSeconds32 aPeriod);

	void Stop();

private:

	CFlusher(CBtraceReader& aReader);

	void Queue();

private: // From CTimer.

	virtual void RunL();

private:

	TTimeIntervalMicroSeconds32 iPeriod;

	CBtraceReader& iReader;

	};

CFlusher* CFlusher::NewL(CBtraceReader& aReader)

	{

	CFlusher* self = new(ELeave) CFlusher(aReader);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFlusher::~CFlusher()

	{

	}

void CFlusher::Start(TTimeIntervalMicroSeconds32 aPeriod)

	{

	ASSERT(!IsActive());

	iPeriod = aPeriod;

	Queue();

	}

void CFlusher::Stop()

	{

	Cancel();

	}

CFlusher::CFlusher(CBtraceReader& aReader)

	: CTimer(CActive::EPriorityStandard), iReader(aReader)

	{

	CActiveScheduler::Add(this);

	}

void CFlusher::Queue()

	{

	if (iPeriod.Int() > 0)

		{

		After(iPeriod);

		}

	}

void CFlusher::RunL()

	{

	Queue();

	iReader.FlushL();	

	}

const TInt KMaxCategories = 256;

const TInt KBlockSize = 512;

const TInt KArrayGranularity = 4;

const TUint KObserveAllCategories = 0xFFFFFFFFu;

TBtraceFrame::TBtraceFrame(const TBtraceHeader& aHeader)

	: iSize(aHeader.iSize), iFlags(aHeader.iFlags), iCategory(aHeader.iCategory), iSubCategory(aHeader.iSubCategory)

	{

	}

EXPORT_C CBtraceReader* CBtraceReader::NewL(TMode aMode, TInt aBufferSize, TInt aThreshold, MBtraceLog* aLog)

	{

	CBtraceReader* self = new(ELeave) CBtraceReader(aMode, aThreshold, aLog);

	CleanupStack::PushL(self);

	self->ConstructL(aBufferSize);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CBtraceReader* CBtraceReader::NewL(const TDesC& aReplayFileName, MBtraceLog* aLog)

	{

	CBtraceReader* self = new(ELeave) CBtraceReader(EAllowBtraceToOverflow, 0, aLog);

	CleanupStack::PushL(self);

	self->ConstructL(aReplayFileName);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CBtraceReader::~CBtraceReader()

	{

	delete iFlusher;

	Cancel();

	DisableBtrace();

	iBtrace.Close();

#ifdef FSHELL_ATRACE_SUPPORT

	iAtraceConfig.Close();

#endif

	iObservers.Close();

	iReplayFile.Close();

	iRecordFile.Close();

	iFs.Close();

	delete iReplayData;

	iMultipartFragments.ResetAndDestroy();

	}

EXPORT_C void CBtraceReader::Reset()

	{

	iReplayFile.Close();

	iRecordFile.Close();

	delete iReplayData;

	ResetAndReprimeL();

	}

EXPORT_C void CBtraceReader::SynchronizeL()

	{

	Log(_L("Synchronizing clock time with btrace time...\r\n"));

	__ASSERT_ALWAYS(!iSynchronizing, Panic(EBtpPanicNestedSynchronizeCalls));

	iSynchronizing = ETrue;

	FlushL(); // FlushL now takes care of putting a sync frame in

	Log(_L("Synchronize complete\r\n"));

	}

EXPORT_C void CBtraceReader::Start(const TBtraceTickCount& aInitialTickCount)

	{

	iInitialTickCount = aInitialTickCount;

	QueueRead();

	}

EXPORT_C void CBtraceReader::Start(const TBtraceTickCount& aInitialTickCount, TTimeIntervalMicroSeconds32 aAutoFlushPeriod)

	{

	if (iFlusher)

		{

		iFlusher->Stop();

		}

	else

		{

		iFlusher = CFlusher::NewL(*this);

		}

	iFlusher->Start(aAutoFlushPeriod);

	Start(aInitialTickCount);

	}

EXPORT_C void CBtraceReader::DisableBtrace()

	{

	if (iBtrace.Handle())

		{

		// Turn everything off.

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

			{

			iBtrace.SetFilter(i, 0);

			}

		iBtrace.SetMode(0);

		}

	}

EXPORT_C void CBtraceReader::EnableCategoryL(TUint aCategory)

	{

#ifdef FSHELL_ATRACE_SUPPORT

	if (iAtraceConfig.Handle() && aCategory == BTrace::EProfiling)

		{

		User::LeaveIfError(iAtraceConfig.EnableProfiling(1));

		}

	else

#endif

	if (iBtrace.Handle())

		{

		User::LeaveIfError(iBtrace.SetFilter(aCategory, 1));

		}

	}

EXPORT_C void CBtraceReader::DisableCategoryL(TUint aCategory)

	{

	// Check no-one's using it

	TInt found = iObservers.SpecificFindInUnsignedKeyOrder(TObserver::ArrayKey(aCategory), EArrayFindMode_Any);

	if (found != KErrNotFound) User::Leave(KErrInUse);

	if (aCategory == BTrace::EMetaTrace) User::Leave(KErrInUse);

#ifdef FSHELL_ATRACE_SUPPORT

	if (iAtraceConfig.Handle() && aCategory == BTrace::EProfiling)

		{

		User::LeaveIfError(iAtraceConfig.EnableProfiling(EFalse));

		}

	else

#endif

		if (iBtrace.Handle())

		{

		User::LeaveIfError(iBtrace.SetFilter(aCategory, 0));

		}

	}

EXPORT_C void CBtraceReader::AddObserverL(MBtraceObserver& aObserver)

	{

	AddObserverL(aObserver, ENormal);

	}

EXPORT_C void CBtraceReader::AddObserverL(MBtraceObserver& aObserver, TObserverType aType)

	{

	__ASSERT_ALWAYS(!iIteratingObservers, Panic(EBtpPanicAddObserverCalledWhileIterating));

	TObserver observer(aObserver, aType, KObserveAllCategories);

	User::LeaveIfError(iObservers.InsertInUnsignedKeyOrderAllowRepeats(observer));

	}

EXPORT_C void CBtraceReader::AddObserverL(TUint aCategory, MBtraceObserver& aObserver)

	{

	AddObserverL(aCategory, aObserver, ENormal);

	}

EXPORT_C void CBtraceReader::AddObserverL(TUint aCategory, MBtraceObserver& aObserver, TObserverType aType)

	{

	__ASSERT_ALWAYS(!iIteratingObservers, Panic(EBtpPanicAddObserverCalledWhileIterating));

	EnableCategoryL(aCategory);

	TObserver observer(aObserver, aType, aCategory);

	User::LeaveIfError(iObservers.InsertInUnsignedKeyOrderAllowRepeats(observer));

	}

TBool CBtraceReader::ObserversEqual(const TObserver& aA, const TObserver& aB)

	{

	return (aA.iObserver == aB.iObserver && aA.iCategory == aB.iCategory);

	}

EXPORT_C void CBtraceReader::RemoveObserver(MBtraceObserver& aObserver)

	{

	__ASSERT_ALWAYS(!iIteratingObservers, Panic(EBtpPanicRemoveObserverCalledWhileIterating));

	TObserver observer(aObserver, ENormal, KObserveAllCategories);

	TInt pos = iObservers.Find(observer, TIdentityRelation<TObserver>(&ObserversEqual));

	if (pos >= 0)

		{

		iObservers.Remove(pos);

		}

	}

EXPORT_C void CBtraceReader::RemoveObserver(TUint aCategory, MBtraceObserver& aObserver)

	{

	__ASSERT_ALWAYS(!iIteratingObservers, Panic(EBtpPanicRemoveObserverCalledWhileIterating));

	// There could be multiple observers for each category, so find the last one...

	TObserver observer(aObserver, ENormal, aCategory);

	TInt pos = iObservers.SpecificFindInUnsignedKeyOrder(observer, EArrayFindMode_Last);

	if (pos >= 0)

		{

		// ...now do a linear search for this specific one (backwards because the observer can then be removed without messing up the loop index).

		TBool specificObserverFound(EFalse);

		TInt numCatObservers = 0;

		for (TInt i = (pos - 1); i >= 0; --i)

			{

			const TObserver& theObserver = iObservers[i];

			if (theObserver.iCategory == aCategory)

				{

				if (theObserver.iObserver == &aObserver)

					{

					iObservers.Remove(i);

					specificObserverFound = ETrue;

					}

				else

					{

					++numCatObservers;

					}

				}

			else

				{

				break;

				}

			}

		//__ASSERT_DEBUG(specificObserverFound, Panic(EBtpPanicObserverNotFound));

		if (specificObserverFound && (numCatObservers == 0) && (iBtrace.Handle()))

			{

			// This was the last observer of this category, so turn it off.

			DisableCategoryL(aCategory);

			}

		}

	}

EXPORT_C void CBtraceReader::AddFrameObseverL(MBtraceFrameObserver& aObserver)

	{

	if (iFrameObserver) Panic(EBtpPanicFrameObserverAlreadyExists);

	iFrameObserver = &aObserver;

	}

EXPORT_C void CBtraceReader::RemoveFrameObserver(MBtraceFrameObserver& aObserver)

	{

	if (iFrameObserver == &aObserver)

		{

		iFrameObserver = NULL;

		}

	}

EXPORT_C void CBtraceReader::GetReplayStartTickCountL(TBtraceTickCount& aTickCount)

	{

	__ASSERT_ALWAYS(iReplayData != NULL, Panic(EBtpPanicReaderNotReplaying));

	aTickCount.iNano = 0;

	aTickCount.iFast = 0;

	// Read the first btrace frame to find its tick count.

	TUint8* data;

	TInt size = GetData(data);

	__ASSERT_ALWAYS(size > 0, Panic(EBtpPanicNoReplayData));

	TUint8* c = data;

	TBtraceHeader* header = (TBtraceHeader*)c;

	TUint8* d = c + sizeof(TBtraceHeader);

	if ((header->iFlags & BTrace::EMissingRecord) && (c != data))

		{

		Log(_L("Warning: btrace buffer overflowed\r\n"));

		User::Leave(KErrOverflow);

		}

	if (header->iFlags & BTrace::EHeader2Present)

		{

		d += 4;

		}

	if (header->iFlags & BTrace::ETimestampPresent)

		{

		aTickCount.iFast = *((TUint32*)d);

		d += 4;

		}

	if (header->iFlags & BTrace::ETimestamp2Present)

		{

		aTickCount.iNano = *((TUint32*)d);

		d += 4;

		}

	// Rewind the file to ensure the first btrace frame is read again when the buffer

	// is properly parsed.

	TInt pos = 0;

	User::LeaveIfError(iReplayFile.Seek(ESeekStart, pos));

	}

EXPORT_C void CBtraceReader::SetBufferSizeL(TInt aBufferSize)

	{

	if (iBtrace.Handle() == 0)

		{

		User::Leave(KErrNotReady);

		}

	User::LeaveIfError(iBtrace.ResizeBuffer(aBufferSize));

	ResetAndReprimeL(); // This is needed to a) reprime, and b) switch btrace back on. Calling ResizeBuffer actually sets the mode to zero. Who knew?

	}

EXPORT_C void CBtraceReader::SetReplayFileNameL(const TDesC& aReplayFileName)

	{

	__ASSERT_ALWAYS(aReplayFileName.Length() || iBtrace.Handle(), Panic(EBtpPanicTriedToDisableReplayWhenBtraceNotRunning)); // Can't transition from replay to live btrace if btrace was never opened (ie if the NewL overload taking a replay file name was used)

	if (iReplayFile.SubSessionHandle() > 0)

		{

		iReplayFile.Close();

		}

	if (aReplayFileName.Length())

		{

		User::LeaveIfError(iReplayFile.Open(iFs, aReplayFileName, EFileRead));

		if (iReplayData == NULL)

			{

			iReplayData = HBufC8::NewL(KBlockSize);

			}

		}

	else

		{

		delete iReplayData;

		iReplayData = NULL;

		}

	}

EXPORT_C const TBtraceTickCount& CBtraceReader::CurrentTickCount() const

	{

	Log(_L("Tick count: %u (%u)\r\n"), iCurrentTickCount.iNano, iCurrentTickCount.iFast);

	return iCurrentTickCount;

	}

void CBtraceReader::RunL()

	{

	switch (iMode)

		{

		case EAllowBtraceToOverflow:

			{

			__ASSERT_ALWAYS(EFalse, Panic(EBtpPanicUnexpectedReaderRun));

			}

		case EFlushOnBtraceThreshold:

			{

			Log(_L("Btrace buffer crossed threshold - flushing...\r\n"));

			QueueRead();

			FlushL();

			break;

			}

		case ELeaveOnBtraceThreshold:

			{

			Log(_L("Btrace buffer crossed threshold - leaving with KErrTooBig\r\n"));

			User::Leave(KErrTooBig);

			}

		default:

			{

			__ASSERT_ALWAYS(EFalse, Panic(EBtpPanicInvalidReaderMode));

			}

		}

	}

void CBtraceReader::DoCancel()

	{

	if (iBtrace.Handle())

		{

		iBtrace.CancelRequestData();

		}

	}

CBtraceReader::CBtraceReader(TMode aMode, TInt aThreshold, MBtraceLog* aLog)

	: CActive(CActive::EPriorityStandard), iMode(aMode), iLog(aLog), iThreshold(aThreshold), iObservers(KArrayGranularity, _FOFF(TObserver, iCategory))

	{

	CActiveScheduler::Add(this);

	}

void CBtraceReader::ConstructL(TInt aBufferSize)

	{

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iBtrace.Open());

#ifdef FSHELL_ATRACE_SUPPORT

	User::LeaveIfError(iAtraceConfig.Connect());

#endif

	iBtrace.Empty();

	if (iBtrace.BufferSize() < aBufferSize)

		{

		// If the buffer is bigger, don't shrink it

		SetBufferSizeL(aBufferSize);

		}

	iBtrace.SetTimestamp2Enabled(ETrue);

	// Turn everything off.

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

		{

		iBtrace.SetFilter(i, 0);

		}

	// And turn metatrace on (we always keep this on)

	iBtrace.SetFilter(BTrace::EMetaTrace, 1);

	iBtrace.SetMode(RBTrace::EEnable);

	}

void CBtraceReader::ConstructL(const TDesC& aReplayFileName)

	{

	User::LeaveIfError(iFs.Connect());

	SetReplayFileNameL(aReplayFileName);

	}

void CBtraceReader::QueueRead()

	{

	if ((iMode > EAllowBtraceToOverflow) && (iThreshold > 0))

		{

		iBtrace.RequestData(iStatus, iThreshold);

		SetActive();

		}

	}

void CBtraceReader::DoReadL(TBool& aFinished)

	{

	TUint8* data;

	TInt size = GetData(data);

	if (size <= 0)

		{

		aFinished = ETrue;

		iBtraceBuffer.Set(NULL, 0);

		}

	else

		{

		aFinished = EFalse;

		iBtraceBuffer.Set(data, size);

		iNumBytesRead += size;

		TUint8* c = data;

		TUint8* end = c + size;

		do

			{

			TBtraceHeader* header = (TBtraceHeader*)c;

			TBtraceFrame frame(*header);

			TUint8* d = c + sizeof(TBtraceHeader);

			TUint32 extra = 0;

			TUint32 header2 = 0;

			if ((header->iFlags & BTrace::EMissingRecord)) // && (c != data))

				{