// btrace.cpp

// 

// Copyright (c) 2007 - 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.h"

#if defined(FSHELL_MEMORY_ACCESS_SUPPORT)

#define TEXT_TRACE_MODE_SUPPORTED

#endif

const TInt KMaxCategories = 256;

const TUint KPrimingStopped = 0x102864BC;

CCommandBase* CCmdBtrace::NewLC()

	{

	CCmdBtrace* self = new(ELeave) CCmdBtrace();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCmdBtrace::~CCmdBtrace()

	{

	iPrimaryFilters.Close();

	iSecondaryFilters.Close();

	iBtrace.Close();

	}

CCmdBtrace::CCmdBtrace()

	: iThreshold(50)

	{

	}

void CCmdBtrace::ConstructL()

	{

	BaseConstructL();

	}

const TDesC& CCmdBtrace::Name() const

	{

#ifdef BUILDING_ATRACE

	_LIT(KName, "atrace");

#else

	_LIT(KName, "btrace");

#endif

	return KName;

	}

#define CASE_LIT(x) case BTrace:: x : { _LIT(KName, #x); return &KName; }

#define CASE_REALLY_LIT(x) case x : { _LIT(KName, #x); return &KName; }

const TDesC* BtraceCategoryName(TInt aCategory)

	{

	switch (aCategory)

		{

		CASE_LIT(ERDebugPrintf)

		CASE_LIT(EKernPrintf)

		CASE_LIT(EPlatsecPrintf)

		CASE_LIT(EThreadIdentification)

		CASE_LIT(ECpuUsage)

		CASE_LIT(EKernPerfLog)

		CASE_LIT(EClientServer)

		CASE_LIT(ERequests)

		CASE_LIT(EChunks)

		CASE_LIT(ECodeSegs)

		CASE_LIT(EPaging)

		CASE_LIT(EThreadPriority)

		CASE_LIT(EPagingMedia)

		CASE_LIT(EKernelMemory)

		CASE_LIT(EHeap)

		CASE_LIT(EMetaTrace)

		CASE_LIT(ERamAllocator)

		CASE_LIT(EFastMutex)

		CASE_LIT(EProfiling)

		CASE_REALLY_LIT(ExtraBTrace::EPubSub)

		CASE_REALLY_LIT(ExtraBTrace::EFfsTrace)

		CASE_LIT(EPlatformSpecificFirst)

		CASE_LIT(EPlatformSpecificLast)

		CASE_LIT(ESymbianExtentionsFirst)

		CASE_LIT(ESymbianExtentionsLast)

		CASE_LIT(ETest1)

		CASE_LIT(ETest2)

		default:

			{

			_LIT(KUnknown, "?");

			return &KUnknown;

			}

		}

	}

void CCmdBtrace::DoRunL()

	{

#ifdef TEXT_TRACE_MODE_SUPPORTED

	if (iOptions.IsPresent(&iTextTraceMode))

		{

		LoadMemoryAccessL();

		const TInt ESerialOutMask = 3; // As per kernel.h

		TInt err = iMemAccess.SetTextTraceMode(iTextTraceMode, ESerialOutMask);

		LeaveIfErr(err, _L("Couldn't set text trace mode"));

		}

#endif

	TInt i;

	LeaveIfErr(iBtrace.Open(), _L("Couldn't open RBTrace"));

	if (iOptions.IsPresent(&iReset))

		{

		ResetL();

		}

	if (iOptions.IsPresent(&iBufferSize))

		{

		iBtrace.ResizeBuffer(iBufferSize * 1024);

		}

	if (iOptions.IsPresent(&iMode))

		{

		SetMode(iMode);

		}

	iBtrace.SetTimestamp2Enabled(iEnableTimestamp2);

	const TInt numPrimaryFilters = iPrimaryFilters.Count();

	if (numPrimaryFilters > 0)

		{

		RemovePrimaryFilters();

		EmptyBuffer();

		// Enable the specified categories.

		for (i = 0; i < numPrimaryFilters; ++i)

			{

			iBtrace.SetFilter(iPrimaryFilters[i], 1);

			}

		}

	if (iTest)

		{

		TestL();

		return;

		}

	const TInt numSecondaryFilters = iSecondaryFilters.Count();

	if (numSecondaryFilters > 0)

		{

		TUint32* filterArray = new(ELeave) TUint32[iSecondaryFilters.Count()];

		for (i = 0; i < numSecondaryFilters; ++i)

			{

			filterArray[i] = iSecondaryFilters[i];

			}

		TInt err = iBtrace.SetFilter2(filterArray, numSecondaryFilters);

		if (err)

			{

			PrintError(err, _L("Couldn't set secondary filter"));

			}

		else

			{

			// Discard old data.

			EmptyBuffer();

			}

		delete[] filterArray;

		}

	if (numPrimaryFilters > 0 || numSecondaryFilters > 0) 

		{

		BTrace8(BTrace::EMetaTrace, BTrace::EMetaTraceMeasurementEnd, KPrimingStopped, KPrimingStopped);

		}

	if (iFileName.Length())

		{

		RFile file;

		User::LeaveIfError(file.Replace(FsL(), iFileName, EFileWrite));

		file.Close();

		}

	if (iFileName.Length() || iDumpToRdebug)

		{

		if (iFollow)

			{

			if (iThreshold > 100)

				{

				PrintError(KErrArgument, _L("Invalid threshold percentage"));

				User::Leave(KErrArgument);

				}

			Printf(_L("Hit any key to abort waiting and flush buffer...\r\n"));

			TInt bytesRequired = (iBtrace.BufferSize() * iThreshold) / 100;

			TBool finished(EFalse);

			while (!finished)

				{

				TRequestStatus btraceStatus;

				iBtrace.RequestData(btraceStatus, bytesRequired);

				TRequestStatus keyStatus;

				Stdin().WaitForKey(keyStatus);

				if (iVerbose)

					{

					Printf(_L("Waiting for %d bytes in buffer\r\n"), bytesRequired);

					}

				User::WaitForRequest(btraceStatus, keyStatus);

				if (keyStatus == KRequestPending)

					{

					Stdin().WaitForKeyCancel();

					User::WaitForRequest(keyStatus);

					User::LeaveIfError(btraceStatus.Int());

					}

				else

					{

					iBtrace.CancelRequestData();

					User::WaitForRequest(btraceStatus);

					finished = ETrue;

					}

				DumpL();

				}

			}

		else

			{

			DumpL();

			}

		}

	if (iVerbose || (iFileName.Length() == 0))

		{

		Printf(_L("Buffer size: %d\r\n"), iBtrace.BufferSize());

		Printf(_L("Mode: %S (%u)\r\n"), ModeText(iBtrace.Mode()), iBtrace.Mode());

#ifdef TEXT_TRACE_MODE_SUPPORTED

		LoadMemoryAccessL();

		TUint traceMode = 0;

		TInt err = iMemAccess.SetTextTraceMode(traceMode, 0);

		if (err)

			{

			PrintWarning(_L("Couldn't read text trace mode: err=%d"), err);

			}

		else

			{

			_LIT(KHuh, "<?>");

			const TDesC* name = &KHuh;

#define CASE_LIT2(x, y) case x: { _LIT(KName, #y); name = &KName; break; }

			switch (traceMode)

				{

				CASE_LIT2(0, ESerialOutDefault)

				CASE_LIT2(1, ESerialOutNever)

				CASE_LIT2(2, ESerialOutAlways)

				default:

					break;

				}

			Printf(_L("Text trace mode: %S (%d)\r\n"), name, traceMode);

			}

#endif

		Printf(_L("Primary filters:\r\n"));

		TBool foundOne(EFalse);

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

			{

			if (iBtrace.Filter(i) == 1)

				{

				Printf(_L("\t%d (%S)\r\n"), i, BtraceCategoryName(i));

				foundOne = ETrue;

				}

			}

		if (!foundOne)

			{

			Write(_L("\tnone\r\n"));

			}

		Printf(_L("Secondary filters: "));

		TInt globalFilter;

		TUint32* uids;

		TInt ret = iBtrace.Filter2(uids, globalFilter);

		if (ret >= 0)

			{

			if (globalFilter)

				{

				Printf(_L("[Secondary filters accept]\r\n"));

				}

			else

				{

				Printf(_L("[Secondary filters reject]\r\n"));

				}

			if (ret > 0)

				{

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

					{

					Printf(_L("\t0x%08x\r\n"), uids[i]);

					}

				}

			else

				{

				Write(_L("\tnone\r\n"));

				}

			delete uids;

			}

		else

			{

			PrintError(ret, _L("Unable to read secondary filters"));

			}

		}

	}

void CCmdBtrace::DumpL()

	{

	RFile file;

	if (iFileName.Length())

		{

		if (iVerbose)

			{

			Printf(_L("Opening \"%S\"\r\n"), &iFileName);

			}

		User::LeaveIfError(file.Open(FsL(), iFileName, EFileWrite));

		CleanupClosePushL(file);

		TInt pos = 0;

		User::LeaveIfError(file.Seek(ESeekEnd, pos));

		}

	TUint8* data;

	TInt size;

	TInt err = KErrNone;

	while ((size = iBtrace.GetData(data)) != 0)

		{

		if (file.SubSessionHandle() && (err == KErrNone))

			{

			if (iVerbose)

				{

				Printf(_L("Writing %d bytes to \"%S\"\r\n"), size, &iFileName);

				}

			err = file.Write(TPtrC8(data,size));

			if (err)

				{

				PrintError(err, _L("Couldn't write to file"));

				}

			}

		if (iDumpToRdebug)

			{

			if (iVerbose)

				{

				Printf(_L("Writing %d bytes to LtkUtils::HexDumpToRDebug\r\n"), size);

				}

			LtkUtils::HexDumpToRDebug(TPtrC8(data, size));

			}

		iBtrace.DataUsed();

		}

	User::LeaveIfError(err);

	if (iFileName.Length())

		{

		CleanupStack::PopAndDestroy(&file);

		}

	}

void CCmdBtrace::ArgumentsL(RCommandArgumentList& aArguments)

	{

	_LIT(KArgFiles, "file_name");

	aArguments.AppendFileNameL(iFileName, KArgFiles);

	}

void CCmdBtrace::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptPrimaryFilter, "filter");

	aOptions.AppendUintL(iPrimaryFilters, KOptPrimaryFilter);

	_LIT(KOptSecondaryFilter, "secondary");

	aOptions.AppendUintL(iSecondaryFilters, KOptSecondaryFilter);

	_LIT(KOptMode, "mode");

	aOptions.AppendUintL(iMode, KOptMode);

	_LIT(KOptBufferSize, "buffer");

	aOptions.AppendUintL(iBufferSize, KOptBufferSize);

	_LIT(KOptDump, "dump");

	aOptions.AppendBoolL(iDumpToRdebug, KOptDump);

	_LIT(KOptFollow, "follow");

	aOptions.AppendBoolL(iFollow, KOptFollow);

	_LIT(KOptThreshold, "threshold");

	aOptions.AppendUintL(iThreshold, KOptThreshold);

	_LIT(KOptTimestamp2, "timestamp2");

	aOptions.AppendBoolL(iEnableTimestamp2, KOptTimestamp2);

	_LIT(KOptVerbose, "verbose");

	aOptions.AppendBoolL(iVerbose, KOptVerbose);

	_LIT(KOptTest, "test");

	aOptions.AppendBoolL(iTest, KOptTest);

	_LIT(KOptReset, "reset");

	aOptions.AppendBoolL(iReset, KOptReset);

#ifdef TEXT_TRACE_MODE_SUPPORTED

	_LIT(KOptTextTraceMode, "text-trace-mode");

	aOptions.AppendUintL(iTextTraceMode, KOptTextTraceMode);

#endif

	}

#ifdef EXE_BUILD

EXE_BOILER_PLATE(CCmdBtrace)

#endif

void CCmdBtrace::TestL()

	{

	SetMode(RBTrace::EEnable);

	EmptyBuffer();

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

	_LIT8(KHello, "Hello world of btrace!!!");

	TInt res = BTraceBig(BTrace::ESymbianExtentionsFirst, 0, 0, KHello().Ptr(), KHello().Size());

	Printf(_L8("Writing text '%S' to btrace returned %d...\r\n"), &KHello, res);

	TUint8* data;

	TInt size;

	TInt err = KErrNotFound;

	while ((size = iBtrace.GetData(data)) != 0 && err == KErrNotFound)

		{

		Printf(_L("Read a buffer of size %d\r\n"), size);

		TPtrC8 ptr(data, size);

		if (ptr.Find(KHello) >= 0)

			{

			Printf(_L("Found text ok.\r\n"));

			err = KErrNone;

			}

		}

	if (err == KErrNotFound)

		{

		Printf(_L("Failed to find the test data\r\n"));

		}

	}

void CCmdBtrace::ResetL()

	{

	SetMode(0);

	EmptyBuffer();

	RemovePrimaryFilters();

	RemoveSecondaryFiltersL();

	}

void CCmdBtrace::SetMode(TUint aMode)

	{

	if (iVerbose)

		{

		Printf(_L("Setting mode to \"%S\" (%u)\r\n"), ModeText(aMode), aMode);

		}

	iBtrace.SetMode(aMode);

	}

void CCmdBtrace::EmptyBuffer()

	{

	if (iVerbose)

		{

		Write(_L("Discarding contents of trace buffer...\r\n"));

		}

	iBtrace.Empty();

	}

void CCmdBtrace::RemovePrimaryFilters()

	{

	if (iVerbose)

		{

		Write(_L("Removing all primary filters...\r\n"));

		}

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

		{

		iBtrace.SetFilter(i, 0);

		}

	}

void CCmdBtrace::RemoveSecondaryFiltersL()

	{

	if (iVerbose)

		{

		Write(_L("Removing all secondary filters...\r\n"));

		}

	LeaveIfErr(iBtrace.SetFilter2((const TUint32*)NULL, 0), _L("Couldn't remove all secondary filters"));

	}

const TDesC* CCmdBtrace::ModeText(TUint aMode) const

	{

	_LIT(KDisabled, "disabled");

	_LIT(KEnabled, "enabled");

	_LIT(KFreeRunning, "enabled and free running");

	_LIT(KUnknown, "unknown");

	switch (aMode)

		{

		case 0:

			return &KDisabled;

		case RBTrace::EEnable:

			return &KEnabled;

		case RBTrace::EEnable | RBTrace::EFreeRunning:

			return &KFreeRunning;

		default:

			return &KUnknown;

		}

	}