// 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:

 // e32utils\trace\btrace.cpp

 // 

 //

 #include <e32cons.h>

 #include <f32file.h>

 #include <d32btrace.h>

 CConsoleBase* Console;

 extern RBTrace Trace;

 #undef ASSERT

 #define ASSERT(c) (void)((c)||(AssertFailed(__LINE__)))

 TInt AssertFailed(TInt aLine)

 	{

 	_LIT(KPanicCategory,"ASSERT");

 	User::Panic(KPanicCategory,aLine);

 	return 0;

 	}

 int strlen(const char* string)

 	{

 	int len=0;

 	while(string[len]) ++len;

 	return len;

 	}

 class TDesTruncate : public TDes8Overflow { void Overflow(TDes8&) {}; } IgnoreOverflow;

 void printf(const char* aFormat,...)

 	{

 	TPtrC8 formatDes((TUint8*)aFormat,strlen(aFormat));

 	VA_LIST list;

 	VA_START(list, aFormat);

 	TBuf16<0x100> buffer;

 	// coverity[uninit_use_in_call]

 	((TDes8&)buffer).AppendFormatList(formatDes, list, &IgnoreOverflow);

 	Console->Write(((TDes8&)buffer).Expand());

 	}

 TInt getch()

 	{

 	TRequestStatus keyStat;

 	Console->Read(keyStat);

 	User::WaitForRequest(keyStat);

 	return Console->KeyCode();

 	}

 TInt getch(TInt aTimeout)

 	{

 	TRequestStatus keyStat;

 	Console->Read(keyStat);

 	RTimer timer;

 	TInt r=timer.CreateLocal();

 	ASSERT(r==KErrNone);

 	TRequestStatus timerStat;

 	timer.After(timerStat,aTimeout*1000000);

 	User::WaitForRequest(timerStat,keyStat);

 	TInt key = -1;

 	if(keyStat!=KRequestPending)

 		key = Console->KeyCode();

 	timer.Cancel();

 	Console->ReadCancel();

 	User::WaitForAnyRequest();

 	return key;

 	}

 int Main(int argc, char** argv);

 void exit_btrace(int result)

 	{

 	User::Exit(result);

 	}

 TInt E32Main()

 	{

 	// create console...

 	TFileName exeFile = RProcess().FileName();

 	TRAPD(r, Console = Console::NewL(exeFile,TSize(KConsFullScreen,KConsFullScreen)));

 	ASSERT(r==KErrNone);

 	// get command-line...

 	RBuf clDes;

 	ASSERT(clDes.Create(User::CommandLineLength()+1)==KErrNone);

 	User::CommandLine(clDes);

 	char* cl = (char*)clDes.Collapse().PtrZ(); // convert to null terminated C string

 	// split up args...

 	RPointerArray<TAny> argArray;

 	ASSERT(KErrNone==argArray.Append(exeFile.Collapse().Ptr())); // first arg is program name

 	for(;;)

 		{

 		while((unsigned)(*cl-1)<(unsigned)' ') ++cl; // skip whitespace

 		if(!*cl) break;

 		ASSERT(KErrNone==argArray.Append(cl));

 		while(*++cl>' ') {}; // skip non-whitespace

 		if(!*cl) break;

 		*cl++ = 0; // add null terminator to arg

 		}

 	// call main...

 	return Main(argArray.Count(),(char**)&argArray[0]);

 	}

 int Error()

 	{

 	getch(5); // pause for a while

 	exit_btrace(-1);

 	return 0;

 	}

 char* FileName = 0;

 char* PrimaryFilterArg = NULL;

 bool SetFilter2 = false;

 RArray<TUint32> Filter2;

 bool SetMode = false;

 unsigned Mode = 0;

 bool SetBufferSize = false;

 unsigned BufferSize = 0;

 bool DumpToDebugPort = false;

 TInt AnalysisLevel = 0;

 bool Analyse = false;

 bool DiscardOldData = true;

 RFs Fs;

 RFile File;

 void RePrime();

 void Dump()

 	{

 	TUint oldMode = Trace.Mode();

 	Trace.SetMode(0); // turn off trace capture while we dump

 	TUint8* data;

 	TInt size;

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

 		{

 		if(FileName)

 			{

 			TInt r=File.Write(TPtrC8(data,size));

 			if(r!=KErrNone)

 				{

 				printf("Error writing to file (1). (Code %d)",r);

 				Error();

 				}

 			}

 		if(DumpToDebugPort)

 			{

 			do

 				{

 				int s = size;

 				if(s>256) s=256;

 				RDebug::RawPrint(TPtrC8(data,s));

 				data += s;

 				size -= s;

 				}

 			while(size);

 			}

 		Trace.DataUsed();

 		}

 	// Flush the file here so we can be sure to detect whether the btrace data 

 	// has been written successfully to the file.

 	if (FileName)

 		{

 		// Flush the file here so we can be sure to detect whether the btrace data 

 		// has been written successfully to the file.

 		TInt r = File.Flush();

 		if (r != KErrNone)

 			{

 			printf("Error writing to file (2). (Code %d)",r);

 			Error();

 			}

 		File.Close();

 		}

 	Trace.SetMode(oldMode);

 	RePrime();

 	}

 bool SetFilter(char* args);

 void DoAnalyse(TInt aAnalysisLevel);

 int DoCommand()

 	{

 	if(SetBufferSize)

 		Trace.ResizeBuffer(BufferSize*1024);

 	if(SetMode)

 		Trace.SetMode(Mode);

 	if (PrimaryFilterArg)

 		SetFilter(PrimaryFilterArg);

 	if(SetFilter2)

 		{

 		TInt r = Trace.SetFilter2(&Filter2[0], Filter2.Count());

 		if(r<0)

 			{

 			printf("Error setting secondary filter. (%d)",r);

 			Error();

 			}

 		if (DiscardOldData)

 			Trace.Empty(); // discard old data

 		}

 	if(FileName || DumpToDebugPort)

 		Dump();

 	if(Analyse)

 		DoAnalyse(AnalysisLevel);

 	return 0;

 	}

 unsigned int ParseDecimal(char*& args)

 	{

 	unsigned int i=0;

 	unsigned int d;

 	while((d=*args-'0')<10u)

 		{

 		++args;

 		i = i*10+d;

 		}

 	return i;

 	}

 bool SetFilter(char* args)

 	{

 	unsigned i;

 	// Turn everything off and discard old data

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

 		{			

 		Trace.SetFilter(i,0); 

 		}

 	if (DiscardOldData)

 		Trace.Empty();

 	// Iterate over comma-seperated filter numbers

 	bool set_metatrace = false;

 	while((unsigned)(*args-'0')<10u)

 		{

 		unsigned int i = ParseDecimal(args);

 		if(i>=256)

 			{

 			printf("Primary filter value out of range");

 			Error();

 			}

 		if (!set_metatrace) 

 			{

 			set_metatrace = true;

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

 			}

 		Trace.SetFilter(i,1);

 		if(*args==',')

 			++args;

 		}

 	return (*args==0);

 	}

 bool ParseFilter2(char* args)

 	{

 	while((unsigned)(*args-'0') < 10u)

 		{

 		unsigned int i = ParseDecimal(args);

 		TInt r = Filter2.Append(i);

 		if(r<0)

 			{

 			printf("Error parsing secondary filter. (%d)",r);

 			Error();

 			}

 		if(*args==',')

 			{

 			++args;

 			}

 		}

 	return SetFilter2=(*args==0);

 	}

 bool ParseMode(char* args)

 	{

 	Mode = ParseDecimal(args);

 	return SetMode=(*args==0);

 	}

 bool ParseBufferSize(char* args)

 	{

 	BufferSize = ParseDecimal(args);

 	return SetBufferSize=(*args==0);

 	}

 bool ParseAnalyse(char* args)

 	{

 	AnalysisLevel = ParseDecimal(args);

 	return Analyse=(*args==0);

 	}

 int CreateFile(char* name)

 	{

 	if(FileName)

 		{

 		printf("Too many arguments");

 		return Error();

 		}

 	FileName = name;

 	unsigned nameLen = strlen(name);

 	if(nameLen>(unsigned)KMaxFileName)

 		{

 		printf("File name too long.\n");

 		return Error();

 		}

 	TInt r;

 	if(!Fs.Handle())

 		{

 		r = Fs.Connect();

 		if(r!=KErrNone)

 			{

 			printf("Couldn't connect to file server. (%d)\n",r);

 			return Error();

 			}

 		}

 	TBuf8<KMaxFileName*2> fn = TPtrC8((TUint8*)name,nameLen);

 	r = File.Replace(Fs,fn.Expand(),EFileWrite);

 	if(r!=KErrNone)

 		{

 		printf("Couldn't create file: %s. (%d)\n",name,r);

 		return Error();

 		}

 	return 0;

 	}

 int Help()

 	{

 	printf("Usage: BTRACE [options] [filename]\n");

 	printf("\n");

 	printf("Options:\n");

 	printf("-fLIST   Set primary filter to a LIST of comma separated category numbers.\n");

 	printf("         This argument may be used more than once e.g. -f1,22,3 -f44 \n");

 	printf("-sLIST   Set secondary filter to a LIST of comma separated UID values.\n");

 	printf("         This argument may be used more than once e.g. -s1221,22,343243 -s3242344 \n");

 	printf("-mN      Set capture mode to value N (See RBTrace::TMode)\n");

 	printf("-bN      Set capture buffer size to N kBytes\n");

 	printf("-d       Dump contents of trace buffer to debug port\n");

 	printf("-tsNAME  Output a test measurement start trace with text NAME. This text\n");

 	printf("         may be between 0 and 80 non-whitespace characters.\n");

 	printf("-te      Output a test measurement end trace\n");

 	printf("-aLEVEL  Analyse trace buffer and produce a report. UNSUPPORTED!\n");

 	printf("-k       Keep old contents of trace buffer when enabling a new filter\n");

 	printf("filename File to dump contents of trace buffer to.\n");

 	getch();

 	return 0;

 	}

 int Main(int argc, char** argv)

 	{

 	if(argc<=1)

 		return Help();

 	TInt r = Trace.Open();

 	if(r!=KErrNone)

 		{

 		printf("Couldn't open BTrace driver. (Code %d)",r);

 		Error();

 		return r;

 		}

 	char* a;

 	while(--argc)

 		{

 		a = *++argv;

 		if(a[0]!='-')

 			{

 			CreateFile(a);

 			continue;

 			}

 		int r=0;

 		switch(a[1])

 			{

 		case 'f': PrimaryFilterArg = a+2; r = true; break;

 		case 's': r=ParseFilter2(a+2); break;

 		case 'm': r=ParseMode(a+2); break;

 		case 'b': r=ParseBufferSize(a+2); break;

 		case 'd': r=a[2]==0; DumpToDebugPort = true; break;

 		case 't': 

 			{

 			if (a[2]=='s') 

 				{

 				TUint cch=strlen(a);

 				if (cch > KMaxBTraceDataArray)

 					cch = KMaxBTraceDataArray;

 				int buff[KMaxBTraceDataArray/sizeof(int)];

 				a+=3;

 				memcpy(buff, a, cch);

 				BTraceContextN(BTrace::EMetaTrace, BTrace::EMetaTraceMeasurementStart, 0,0, buff, cch);

 				r=1;

 				}

 			else if (a[2]=='e')

 				{

 				BTraceContext8(BTrace::EMetaTrace, BTrace::EMetaTraceMeasurementEnd, 0,0);

 				r=1;

 				}

 			}

 			break;

 		case 'a': r=ParseAnalyse(a+2); break;

 		case 'k': DiscardOldData = false; r = true; break;

 		default: break;

 			}

 		if(!r)

 			{

 			printf("Bad command line argument: %s",a);

 			Error();

 			}

 		}

 	return DoCommand();

 	}