// fdb.cpp

// 

// Copyright (c) 2009 - 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 <fshell/ioutils.h>

#include <fshell/memoryaccesscmd.h>

#include <fshell/ltkutils.h>

#include <fshell/bsym.h>

#include <fshell/descriptorutils.h>

#include <fshell/iocons_writer.h>

#include <fshell/line_editor.h>

#include <fshell/qr3dll.h>

#include <u32std.h> // Is this available in all environments? If not, need to define TDesType ourselves

#include <babitflags.h>

#include <badesca.h>

_LIT(KCrLf, "\r\n");

_LIT(KPrompt, "fdb>");

using namespace IoUtils;

using namespace LtkUtils;

const TInt KMaxRegisters = 32;

class CCmdFdb : public CMemoryAccessCommandBase, public MLineEditorObserver, public MLineCompleter

	{

public:

	static CCommandBase* NewLC();

	~CCmdFdb();

private:

	struct SThreadContext;

	CCmdFdb();

	void InstallL();

	void AttachL(TUint aThreadId);

	void Detach(SThreadContext* aContext);

	void PrintThreadInfo(SThreadContext& aContext);

	void PrintRegistersL(SThreadContext& aThread);

	void PrintRegistersL(SThreadContext& aThread, TBool aUserMode);

	void PrintRegistersLRPC(SThreadContext& aThread, TBool aUserMode);

	void RefreshL(SThreadContext& aContext);

	void RefreshIfRunningL(SThreadContext& aContext);

	TPtrC LookupSymbol(TUint32 aAddress);

	void StartCommandParsingL();

	void ProcessLineL(const TDesC& aLine);

	void FocusL(TUint aThreadId);

	SThreadContext* ContextForThread(TUint aThreadId) const;

	SThreadContext& CurrentL();

	SThreadContext& CurrentNoRefreshL();

	enum TPrintMode { EJustSymbols, EAllData, EHexDump };

	void PrintMemL(TUint aThreadId, TUint32 aStart, TUint32 aEnd, TPrintMode aMode);

	void BrrrrrainsL();

	void ShowHelpTextL();

	TBool IsSymbol(TUint aAddress) const;

	void StartInteractiveViewL(TLinAddr aAddress);

	void DrawMemViewL(TBool aUpdate);

	void UpdateMemForMemViewL();

	static TInt IsDescriptorHeader(TUint8 const* aHeaderPtr, TInt aMaxLen);

	void ShowBreakpointsL();

	static TInt BreakTest(TAny* aPtr);

	static TInt BreakTestLtk(TAny* aPtr);

	static TInt BreakTestCond(TAny* aPtr);

	void ClearAllBreakpointsL();

	void BreakpointHit(const RMemoryAccess::TBreakpointNotification& aNotif);

	void CompleteLineWithSymbolL(TConsoleLine& aLine, TLex& aLex);

	void CheckForConditionL(TLex& aLex, RMemoryAccess::TPredicate& aCondition);

private: // From MLineCompleter

	void LcCompleteLineL(TConsoleLine& aLine, const TChar& aEscapeChar);

private: // From MLineEditorObserver

	void LeoHandleLine(const TDesC& aLine);

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual void DoRunL();

	virtual void ArgumentsL(RCommandArgumentList& aArguments);

	virtual void OptionsL(RCommandOptionList& aOptions);

	void RunL();

	void DoCancel();

private:

	// Command line stuff

	TBool iAllThreads;

	TUint iThreadId;

	TFileName2 iBsymFile;

	TFileName2 iMapFileDir;

	// Thread context

	struct SThreadContext

		{

		SThreadContext() : iUserValidRegisters(0), iSupervisorValidRegisters(0), iFlags(0) {}

		RThread iThread;

		TUint32 iUserRegisters[KMaxRegisters];

		TUint32 iUserValidRegisters;

		TUint32 iSupervisorRegisters[KMaxRegisters];

		TUint32 iSupervisorValidRegisters;

		TThreadKernelInfo iKernelInfo;

		enum TFlags { ERunning = 1, };

		TBitFlags32 iFlags;

		};

	SThreadContext* iCurrent;

	RPointerArray<SThreadContext> iThreads;

	// Other stuff

	CSymbolics* iSymbols;

	TBuf<256> iTempNameBuf;

	// Line editor support

	TIoConsWriterAdaptor iConsoleAdapter;

	CLineEditor* iLineEditor;

	TBuf<256> iCommandLineBuf;

	TBool iFinishedCommand;

	TBool iShouldExit;

	// Interactive wossname support

	enum TViewType

		{

		EUnspecified,

		EStack,

		EHeap,

		};

	TViewType iMemoryViewType;

	TLinAddr iMemStart;

	RBuf8 iMemBuf;

	/*

	class TCrumb

		{

		enum TType { EAddress, EHeapCell, };

		TType iType;

		TLinAddr iAddress;

		TInt iIndex;

		}

	RArray<TCrumb> iBreadcrumbs;

	RArray<TLinAddr> iMarks;

	RArray<TLinAddr> iLinks;

	*/

	// Breakpoint support

	RMemoryAccess::TBreakpointNotification iBreakpointNotification;

	TPckg<RMemoryAccess::TBreakpointNotification> iBreakpointNotificationPkg;

	class CBreakpointNotifier : public CActive

		{

	public:

		CBreakpointNotifier(CCmdFdb& aCmd);

		~CBreakpointNotifier();

	private:

		void Request();

		void RunL();

		void DoCancel();

	private:

		CCmdFdb& iCmd;

		};

	friend class CBreakpointNotifier; // Declaration needed for gcc 2.9

	CBreakpointNotifier* iBreakpointNotifier;

	};

EXE_BOILER_PLATE(CCmdFdb)

CCommandBase* CCmdFdb::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdFdb::~CCmdFdb()

	{

	Cancel();

	delete iLineEditor;

	for (TInt i = 0; i < iThreads.Count(); i++)

		{

		SThreadContext* thread = iThreads[i];

		thread->iThread.Close();

		delete thread;

		}

	iThreads.Close();

	delete iSymbols;

	iMemBuf.Close();

	delete iBreakpointNotifier;

	/*

	iLinks.Close();

	iBreadcrumbs.Close();

	iMarks.Close();

	*/

	}

CCmdFdb::CCmdFdb()

	: CMemoryAccessCommandBase(EManualComplete), iConsoleAdapter(Stdout()), iBreakpointNotificationPkg(iBreakpointNotification)

	{

	}

const TDesC& CCmdFdb::Name() const

	{

	_LIT(KName, "fdb");	

	return KName;

	}

void CCmdFdb::ArgumentsL(RCommandArgumentList& aArguments)

	{

	aArguments.AppendUintL(iThreadId, _L("threadid"));

	}

void CCmdFdb::OptionsL(RCommandOptionList& aOptions)

	{

	aOptions.AppendBoolL(iAllThreads, _L("all"));

	aOptions.AppendFileNameL(iBsymFile, _L("symbols"));

	aOptions.AppendFileNameL(iMapFileDir, _L("mapfiles"));

	}

struct STestData

	{

	STestData() : iPtr8(NULL, 0) {}

	char iPad1[12];

	TBuf8<6> iBuf8;

	TInt iPad2;

	TBufC8<9> iBufC8;

	char iPad3;

	TPtrC8 iPtrC8;

	TUint64 iPad4;

	TPtr8 iPtr8;

	char iPad5[3];

	};

void CCmdFdb::DoRunL()

	{

	LoadMemoryAccessL();

	TInt mode = iMemAccess.GetZombieDebugMode();

	LeaveIfErr(mode, _L("Couldn't get zombie mode from driver"));

	iSymbols = new(ELeave) CSymbolics(FsL());

	if (iBsymFile.Length())

		{

		//Printf(_L("Loading symbolics... ")); // It can take a while...

		iSymbols->AddBsymFileL(iBsymFile);

		//Printf(_L("done.\r\n"));

		}

	if (iMapFileDir.Length())

		{

		iSymbols->SetFallbackMapFileDirL(iMapFileDir);

		}

	// Testing

	//CMapFile* map = CMapFile::NewL(FsL(), _L("C:\\symbols\\QResources3.exe.map"));

	//iSymbols->AddMapFileL(map);

	//const TDesC& symName = iSymbols->LookupL(_L("QResources3.exe"), 0x10abc);

	//Printf(_L("Found symbol = %S\r\n"), &symName);

	if (Env().IsDefined(_L("FDB_TEST")))

		{

		STestData test;

		test.iBuf8 = _L8("12345");

		test.iBufC8 = _L8("abcdefg");

		test.iPtrC8.Set(test.iBufC8);

		TPckg<STestData> pkg(test);

		iMemBuf.Assign(pkg.AllocL());

		DrawMemViewL(EFalse);

		return;

		}

	TBool install = ETrue;

	// Figure out something sensible to do

	if (mode != 0 || iThreadId != 0) install = EFalse;

	if (iAllThreads) Printf(_L("Note that because --all-threads was specified, this and all future commands will hang rather than exiting!\r\n"));

	InstallL(); // Always do this, in case user has changed the --all-threads setting

	if (install)

		{

		// This will really mess up evalid, but the toolkit doesn't really use it so I don't feel *too* guilty

		Printf(_L8("Welcome to fdb (build " __DATE__ " " __TIME__ ").\r\nDebugger hook installed and will stay running until you type 'uninstall'.\r\nYou can exit fdb if required and it will stay running in the background.\r\nType 'help' for command info.\r\n"));

		}

	else

		{

		AttachL(iThreadId);

		}

	iBreakpointNotifier = new(ELeave) CBreakpointNotifier(*this);

	TInt err = iMemAccess.RegisterPersistantBreakpoint(LtkUtils::BreakpointAddr());

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

		{

		LeaveIfErr(err, _L("Couldn't install the LtkUtils::Breakpoint() breakpoint"));

		}

	StartCommandParsingL();

	}

void CCmdFdb::InstallL()

	{

	LeaveIfErr(iMemAccess.SetZombieDebugMode(iAllThreads ? 2 : 1), _L("Couldn't install thread monitor"));

	const TUint32 KAllThreadsSystem = 1; // Word 2, bit 0

	TUint32 dbgmask = UserSvr::DebugMask(2);

	if (dbgmask & KAllThreadsSystem)

		{

		Printf(_L("(Clearing KAllThreadsSystem attribute)\r\n"));

		User::SetDebugMask(dbgmask & ~KAllThreadsSystem, 2);

		}

	}

void CCmdFdb::AttachL(TUint aThreadId)

	{

	if (aThreadId == 0)

		{

		// Need to figure out something to attach to

		TBuf8<64> buf; // TODO handle more than this many zombies

		TInt res = iMemAccess.GetZombies(buf);

		LeaveIfErr(res, _L("Couldn't get zombie info from driver"));

		//TInt leftOver = 0;

		//if (res > buf.MaxLength()) leftOver = (res - buf.MaxLength()) / sizeof(TUint);

		RMemoryAccess::TZombieInfo* ptr = (RMemoryAccess::TZombieInfo*)buf.Ptr();

		TInt zombiecount = buf.Length() / sizeof(RMemoryAccess::TZombieInfo);

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

			{

			TUint id = ptr[i].iThreadId;

			if (ContextForThread(id)) continue; // already attached to this thread, keep looking

			RThread thread;

			TInt err = iMemAccess.RThreadForceOpen(thread, id);

			if (err)

				{

				PrintWarning(_L("Couldn't open thread %u"), id);

				continue;

				}

			iTempNameBuf = thread.FullName();

			Printf(_L("(Found thread id %u %S)\r\n"), id, &iTempNameBuf);

			if (aThreadId == 0) aThreadId = id;

			thread.Close();

			}

		if (aThreadId == 0)

			{

			if (buf.Length())

				Printf(_L("No zombied threads found that aren't already attached.\r\n"));

			else

				PrintWarning(_L("No zombied threads found to attach to."));

			return;

			}

		else

			{

			Printf(_L("(Attaching to thread %u)\r\n"), aThreadId);

			}

		}

	SThreadContext* context = ContextForThread(aThreadId);

	if (context)

		{

		PrintWarning(_L("Already attached to thread %u, focussing it instead."), aThreadId);

		iCurrent = context;

		return;

		}

	context = new(ELeave) SThreadContext;

	CleanupStack::PushL(context);

	RThread& thread(context->iThread);

	CleanupClosePushL(thread);

	LeaveIfErr(iMemAccess.RThreadForceOpen(thread, aThreadId), _L("Couldn't open thread %u"), aThreadId);

	RefreshL(*context);

	iThreads.AppendL(context);

	CleanupStack::Pop(2, context); // context->iThread, context

	iCurrent = context;

	PrintThreadInfo(*context);

	// Don't print any more than this - it makes the output too wordy

	//PrintRegistersL(*context);

	}

void CCmdFdb::PrintThreadInfo(SThreadContext& aContext)

	{

	RThread& aThread = aContext.iThread;

	TFullName name = aThread.FullName();

	Write(_L("Name: "));

	Write(name);

	Printf(_L("\r\nThread Id: %d, exit type: "), (TUint)aThread.Id());

	TExitType exitType = aThread.ExitType();

	if (exitType == EExitPending)

		{

		Printf(_L("Still running\r\n"));

		}

	else if (exitType == EExitKill)

		{

		Printf(_L("Kill %d\r\n"), aThread.ExitReason());

		}

	else if (exitType == EExitTerminate)

		{

		Printf(_L("Terminate %d\r\n"), aThread.ExitReason());

		}

	else if (exitType == EExitPanic)

		{

		TExitCategoryName exitCategory = aThread.ExitCategory();

		Printf(_L("Panic %S %d\r\n"), &exitCategory, aThread.ExitReason());

		}

	Printf(_L("User stack: base=%08x limit=%08x\r\n"), aContext.iKernelInfo.UserStackBase(), aContext.iKernelInfo.iUserStackLimit);

	Printf(_L("Kern stack: base=%08x limit=%08x\r\n"), aContext.iKernelInfo.iSupervisorStack + aContext.iKernelInfo.iSupervisorStackSize, aContext.iKernelInfo.iSupervisorStack);

	}

void CCmdFdb::PrintRegistersL(SThreadContext& aThread)

	{

	PrintRegistersL(aThread, ETrue);

	PrintRegistersL(aThread, EFalse);

	}

void CCmdFdb::PrintRegistersL(SThreadContext& aThread, TBool aUserMode)

	{

	if (aUserMode)

		{

		Printf(_L("User mode registers:\r\n"));

		}

	else

		{

		Printf(_L("Supervisor mode registers:\r\n"));

		}

	TUint32 valid = aThread.iUserValidRegisters;

	TUint32* ptr = aThread.iUserRegisters;

	if (!aUserMode)

		{

		valid = aThread.iSupervisorValidRegisters;

		ptr = aThread.iSupervisorRegisters;

		}

	if (valid == 0) Printf(_L("(No valid registers)\r\n"));

	// From here down is ARM specific, but since no other platforms implement this API there's no pressing need to ifdef it

	// See TArmRegSet for the ordering

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

		{

		if (valid & (1<<i))

			{

			if (i < 10) Write(_L(" ")); // extra space for padding

			Printf(_L("  R%d: "), i);

			Printf(_L("%08x "), ptr[i]);

			Write(LookupSymbol(ptr[i]));

			Write(KCrLf);

			}

		}

	if (valid & (1<<16))

		{

		Printf(_L("Flags (%cPSR): %08x\r\n"), aUserMode ? 'C' : 'S', ptr[16]); // CPSR or SPSR

		}

	if (valid & (1<<17))

		{

		// Domain Access Control Register

		Printf(_L(" DACR: %08x\r\n"), ptr[16]);

		}

	}

void CCmdFdb::PrintRegistersLRPC(SThreadContext& aThread, TBool aUserMode)

	{

	// Print these in the format of the stack trace

	TUint32 valid = aThread.iUserValidRegisters;

	TUint32* ptr = aThread.iUserRegisters;

	if (!aUserMode)

		{

		valid = aThread.iSupervisorValidRegisters;

		ptr = aThread.iSupervisorRegisters;

		}

	if (valid & 1<<15)

		{

		Printf(_L("     R15: %08x "), ptr[15]);

		Write(LookupSymbol(ptr[15]));

		Write(KCrLf);

		}

	if (valid & 1<<14)

		{

		Printf(_L("     R14: %08x "), ptr[14]);

		Write(LookupSymbol(ptr[14]));

		Write(KCrLf);

		}

	}

void CCmdFdb::RefreshIfRunningL(SThreadContext& aContext)

	{

	if (iCurrent->iFlags.IsSet(SThreadContext::ERunning))

		{

		// Thread is still running, we should refresh our info

		RefreshL(aContext);

		}

	}

void CCmdFdb::RefreshL(SThreadContext& aContext)

	{

	aContext.iFlags.Assign(SThreadContext::ERunning, aContext.iThread.ExitType() == EExitPending);

	TUint tid = aContext.iThread.Id();

	// Get registers

	TPtr8 userreg((TUint8*)&aContext.iUserRegisters[0], KMaxRegisters*sizeof(TUint32), KMaxRegisters*sizeof(TUint32));

	userreg.FillZ();

	aContext.iUserValidRegisters = 0;

	TInt err = iMemAccess.GetRegisters(aContext.iThread, ETrue, userreg, aContext.iUserValidRegisters);

	if (err) PrintError(err, _L("Couldn't read user registers for thread %u"), tid);

	TPtr8 supreg((TUint8*)&aContext.iSupervisorRegisters[0], KMaxRegisters*sizeof(TUint32), KMaxRegisters*sizeof(TUint32));

	supreg.FillZ();

	aContext.iSupervisorValidRegisters = 0;

	err = iMemAccess.GetRegisters(aContext.iThread, EFalse, supreg, aContext.iSupervisorValidRegisters);

	if (err) PrintError(err, _L("Couldn't read supervisor registers for thread %u\r\n"), tid);

	// And memaccess info

	TPckg<TThreadKernelInfo> kerninfo(aContext.iKernelInfo);

	err = iMemAccess.GetObjectInfoByHandle(EThread, RThread().Id(), aContext.iThread.Handle(), kerninfo);

	if (err) PrintError(err, _L("Couldn't read thread info from memoryaccess for thread %u\r\n"), tid);

	//aContext.iFlags.Assign(SThreadContext::ESuspended, aContext.iKernelInfo.iNThreadSuspendCount != 0);

	}

TPtrC CCmdFdb::LookupSymbol(TUint32 aAddress)

	{

	TPtrC name;

	if (iSymbols)

		{

		// Try straight ROM address lookup

		TRAPD(err, name.Set(iSymbols->LookupL(aAddress)));

		if (err) PrintError(err, _L("Failed to lookup symbol"));

		if (name.Length()) return name;

		}

	// Try getting a codeseg from memaccess

	TFullName8 codesegname;

	TInt res = iMemAccess.FindAddressInCodeSegments(codesegname, (TAny*)aAddress);