// Copyright (c) 1994-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\kernel\smonitor.cpp

// Kernel crash debugger - machine independent portion common between the crash

// debugger and crash logger.

// 

//

#include <kernel/monitor.h>

#include "msgqueue.h"

#define iMState		iWaitLink.iSpare1

GLDEF_D Monitor* TheMonitorPtr = 0;

LOCAL_D Monitor* TheAltMonitorPtrs[MONITOR_MAXCOUNT] = { 0 };

_LIT8(KLitThread, "THREAD");

_LIT8(KLitProcess, "PROCESS");

_LIT8(KLitChunk, "CHUNK");

_LIT8(KLitLibrary, "LIBRARY");

_LIT8(KLitSemaphore, "SEMAPHORE");

_LIT8(KLitMutex, "MUTEX");

_LIT8(KLitTimer, "TIMER");

_LIT8(KLitServer, "SERVER");

_LIT8(KLitSession, "SESSION");

_LIT8(KLitLogicalDevice, "LOGICAL DEVICE");

_LIT8(KLitPhysicalDevice, "PHYSICAL DEVICE");

_LIT8(KLitLogicalChannel, "LOGICAL CHANNEL");

_LIT8(KLitChangeNotifier, "CHANGE NOTIFIER");

_LIT8(KLitUndertaker, "UNDERTAKER");

_LIT8(KLitUnknown, "UNKNOWN");

_LIT8(KLitLibraries, "LIBRARIES");

_LIT8(KLitS, "S");

_LIT8(KLitES, "ES");

_LIT8(KLitMsgQueue, "MESSAGE QUEUE");

_LIT8(KLitPropertyRef, "PROPERTY REF");

_LIT8(KLitCondVar, "CONDITION VARIABLE");

const TDesC8* const ContainerName[ENumObjectTypes]=

	{

	&KLitThread,

	&KLitProcess,

	&KLitChunk,

	&KLitLibrary,

	&KLitSemaphore,

	&KLitMutex,

	&KLitTimer,

	&KLitServer,

	&KLitSession,

	&KLitLogicalDevice,

	&KLitPhysicalDevice,

	&KLitLogicalChannel,

	&KLitChangeNotifier,

	&KLitUndertaker,

	&KLitMsgQueue,

	&KLitPropertyRef,

	&KLitCondVar

	};

void mstrcat(TDes8& aDes, const char* s)

	{

	aDes+=TPtrC8((const TUint8*)s);

	}

void Monitor::GetObjectTypeName(TDes8& aDes, TInt aType, TBool aPlural)

	{

	if (aType<0 || aType>=ENumObjectTypes)

		aDes=KLitUnknown;

	else

		{

		aDes=*ContainerName[aType];

		if (aPlural)

			{

			switch (aType)

				{

				case EProcess:

				case EMutex:

					aDes+=KLitES;

					break;

				case ELibrary:

					aDes=KLitLibraries;

					break;

				default:

					aDes+=KLitS;

					break;

				}

			}

		}

	}

EXPORT_C void Monitor::PrintLine(const TDesC8& aDes)

	{

	Print(aDes);

	NewLine();

	}

EXPORT_C void Monitor::Printf(const char* aFmt, ...)

	{

	TBuf8<256> printBuf;

	VA_LIST list;

	VA_START(list,aFmt);

	Kern::AppendFormat(printBuf,aFmt,list);

	Print(printBuf);

	}

EXPORT_C void Monitor::Print(const char* s)

	{

	Print(TPtrC8((const TUint8*)s));

	}

EXPORT_C void Monitor::PrintLine(const char* s)

	{

	Print(s);

	NewLine();

	}

EXPORT_C void Monitor::NewLine()

	{

	TBuf<2> buf(0);

	buf.Append(0x0d);

	buf.Append(0x0a);

	Print(buf);

	}

DMonObject* DMonObject::Owner()

	{

	if (iOwner)

		return iOwner;

	return NULL;

	}

TInt DMonObject::Type()

	{

	return iContainerID-1;  // KErrNotFound (-1) returned for objects not in a container

	}

void DMonObject::AppendName(TDes8& aDes)

	{

	((DObject*)this)->TraceAppendName(aDes,EFalse);

	}

void DMonObject::FullName(TDes8& aDes)

	{

	((DObject*)this)->TraceAppendFullName(aDes,EFalse);

	}

EXPORT_C void Monitor::ObjectDump(TUint aAddr)

	{

	DMonObject* pO=(DMonObject*)aAddr;

	pO->DumpData();

	}

EXPORT_C void Monitor::ObjectFullDump(TUint aAddr)

	{

	DMonObject* pO=(DMonObject*)aAddr;

	TInt index=pO->Type();

	DumpObjectData(pO,index);

	}

EXPORT_C void Monitor::DoMemoryDumpL(TUint aStart, TInt aLength)

	{

	TUint readSize=0x1;

	DoMemoryDumpL(aStart,aLength,readSize);		

	}

 EXPORT_C void Monitor::DoMemoryDumpL(TUint aStart, TInt aLength, TUint aReadSize)

 	{

    TBuf8<80> out;

	TBuf8<20> ascii;

	TUint a=aStart;

	do

		{

		out.Zero();

		ascii.Zero();

		out.AppendNumFixedWidth(a,EHex,8);

		out.Append(_L(": "));

		TUint b;

		if(aReadSize == 0x4)

	   		{

			for (b=0; b<16; b=b+4)

				{

				TUint c=*(TUint*)(a+b);

				out.AppendNumFixedWidth(c,EHex,8);

				out.Append(' ');

				if (c<0x20 || c>=0x7f)

					{

					c=0x2e;

					}

				ascii.Append(TChar(c));

				}

			}	

		else if(aReadSize == 0x2)

			{

			for (b=0; b<16; b+=2)

				{

				TUint16 c=*(TUint16*)(a+b);

				out.AppendNumFixedWidth(c,EHex,4);

				out.Append(' ');

				if (c<0x20 || c>=0x7f)

					{

					c=0x2e;	

					}

				ascii.Append(TChar(c));

				}	

			}

		else if(aReadSize == 0x1)

			{

			for (b=0; b<16; b++)

				{

				TUint8 c=*(TUint8*)(a+b);

				out.AppendNumFixedWidth(c,EHex,2);

				out.Append(' ');

				if (c<0x20 || c>=0x7f)

					{

					c=0x2e;	

					}

				ascii.Append(TChar(c));

				}

			}

		out.Append(ascii);

		PrintLine(out);

		a+=16;

		aLength-=16;

		}while(aLength>0); 

 	}

LOCAL_C TUint32 Read32L(TUint32 anAddr)

	{

	return *((TUint32*)anAddr);

	}

EXPORT_C void Monitor::DoDiscontiguousMemoryDumpL(TUint aStart, TInt aLength)

	{

	TUint readSize=0x1;

	DoDiscontiguousMemoryDumpL(aStart, aLength, readSize);

	}

EXPORT_C void Monitor::DoDiscontiguousMemoryDumpL(TUint aStart, TInt aLength, TUint aReadSize)

	{

	const TUint KPageMask = iPageSize - 1;

	TUint start = aStart & ~0xf; // start and finish on 16-byte boundary

	TUint limit = (aStart + aLength + 0xf) & ~0xf;

	while(start!=limit)

		{

		MTRAPD(r,DoMemoryDumpL(start,limit-start,aReadSize));

		if (r==KErrNone)

			return;

		if (r!=KErrAbort)

			Leave(r);

		// Got page fault so keep attempting to read from the next page until a valid 

		// page is found or the limit is reached.

		start = iExceptionInfo[1];	// faulted address

		TUint exceptionStart = start;

		do

			{

			ProcessError(r); // Output the fault information.

			start = (start + iPageSize) & ~KPageMask; // move on to next page

			if (TUint(start-limit) <= TUint(iPageSize))

				{ // reached limit

				start = limit;

				break;

				}

			MTRAP(r,Read32L(start));

			}

		while (r!=KErrNone);

		Printf("Skipped %x bytes due to exception(s)\r\n", start - exceptionStart);

		NewLine();

		}

	}

void DMonObject::DumpData()

	{

	TBuf8<32> f;

	Monitor::GetObjectTypeName(f,Type(),EFalse);

	TheMonitorPtr->Printf("%S at %08x VPTR=%08x AccessCount=%d Owner=%08x\r\n",&f,this,iVptr,iAccessCount,iOwner);

	TBuf8<KMaxKernelName> object_name;

	FullName(object_name);

	TheMonitorPtr->Printf("Full name %S\r\n",&object_name);	

	}

EXPORT_C void Monitor::DisplayFaultInfo()

	{

	TSuperPage& sp=Kern::SuperPage();

	TExcInfo& x=sp.iKernelExcInfo;

	Printf("Fault Category: %S  Fault Reason: %08x\r\n",&iFaultCategory,iFaultReason);

	Printf("ExcId %08x CodeAddr %08x DataAddr %08x Extra %08x\r\n",sp.iKernelExcId,x.iCodeAddress,x.iDataAddress,x.iExtraData);

	DisplayCpuFaultInfo();

	}

void Monitor::DumpThreadData(DThread* pT)

	{

	TBuf8<80> buf=_L8("Thread MState ");

	switch(pT->iMState)

		{

		case DThread::ECreated: buf+=_L8("CREATED"); break;

		case DThread::EDead: buf+=_L8("DEAD"); break;

		case DThread::EReady: buf+=_L8("READY"); break;

		case DThread::EWaitSemaphore: buf+=_L8("WAITSEM "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EWaitSemaphoreSuspended: buf+=_L8("WAITSEMS "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EWaitMutex: buf+=_L8("WAITMUTEX "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EWaitMutexSuspended: buf+=_L8("WAITMUTXS "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EHoldMutexPending: buf+=_L8("HOLDMUTXP "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EWaitCondVar: buf+=_L8("WAITCONDVAR "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		case DThread::EWaitCondVarSuspended: buf+=_L8("WAITCONDVRS "); buf.AppendNumFixedWidth((TUint)pT->iWaitObj,EHex,8); break;

		default: buf+=_L8("??"); buf.AppendNumFixedWidth((TUint)pT->iMState,EHex,8); break;

		}

	PrintLine(buf);

	Printf("Default priority %d WaitLink Priority %d\r\n",pT->iDefaultPriority,pT->iWaitLink.iPriority);

	Printf("ExitInfo %d,%d,%lS\r\n",pT->iExitType,pT->iExitReason,&pT->iExitCategory);

	Printf("Flags %08x, Handles %08x\r\n",pT->iFlags,&pT->iHandles);

	Printf("Supervisor stack base %08x size %x\r\n", pT->iSupervisorStack, pT->iSupervisorStackSize);

	Printf("User stack base %08x size %x\r\n", pT->iUserStackRunAddress, pT->iUserStackSize);

	Printf("Id=%d, Alctr=%08x, Created alctr=%08x, Frame=%08x\r\n",pT->iId,pT->iAllocator,pT->iCreatedAllocator,pT->iFrame);

	Printf("Trap handler=%08x, ActiveScheduler=%08x, Exception handler=%08x\r\n",

								pT->iTrapHandler, pT->iScheduler, pT->iExceptionHandler);

	Printf("TempObj=%08x TempAlloc=%08x IpcCount=%08x\r\n",pT->iTempObj,pT->iTempAlloc,pT->iIpcCount);

	DisplayNThreadInfo(&pT->iNThread);

	DumpCpuThreadData(pT);

	}

void Monitor::DoStackDumpL(TUint aStart, TUint aEnd)

	{

	const TUint KPageMask = iPageSize - 1;

 	// Skip unused area of stack to minimise size of dump

	aStart &= 0xfffffff0;

	TUint* ptr = (TUint*)aStart;

  	TUint* limit = (TUint*)aEnd;

  	TUint pattern = 0;

	TUint* abortAddr = 0;

	while (ptr < limit)

		{

		MTRAPD(r, pattern = *ptr);

		if(r == KErrNone)

			break;

		// Current page not found so move onto the next one.

		ptr = (TUint*)(((TUint)ptr + iPageSize) & ~KPageMask);

		abortAddr = ptr;

		ProcessError(r);

		}

  	if (pattern == 0x29292929 ||	// User stack

		pattern == 0xeeeeeeee ||	// Supervisor stack

		pattern == 0xffffffff || 

		pattern == 0xaaaaaaaa ||	// IRQ stack

		pattern == 0xbbbbbbbb ||	// FIQ stack

		pattern == 0xdddddddd ||	// ABT and UND stack

		pattern == 0x03030303)		// Uninitialised memory

  		{

  		while ((ptr + 3) < limit)

			{

  			MTRAPD(r, if( ptr[0] == pattern && ptr[1] == pattern && ptr[2] == pattern && ptr[3] == pattern) ptr+=4; else break;);

			if (r != KErrNone)

				{// Current page not found so move onto the next one.

				ptr = (TUint*)(((TUint)ptr + iPageSize) & ~KPageMask);

				abortAddr = ptr;	// Due to alignment ptr[0]-ptr[3] will all be within the same page.

				ProcessError(r);

				}

			}

  		}

  	if (ptr != (TUint*)aStart)

		{

		if (abortAddr)

			{

			Printf("Skipped %x bytes due to exception(s)\r\n", (TUint)abortAddr - aStart);

			if (ptr != abortAddr)

				Printf("Skipped %x unused bytes of %02x\r\n", (TUint)ptr - (TUint)abortAddr, pattern & 0xff);

			}

		else

			{

			Printf("Skipped %x unused bytes of %02x\r\n", (TUint)ptr - aStart, pattern & 0xff);

			}

		}

	if (ptr < limit)

		DoDiscontiguousMemoryDumpL((TUint)ptr, (limit - ptr) << 2, (TBool)ETrue);

  	}

void Monitor::DoDumpThreadStack(DThread *aThread)

	{

	DMonObject* pO=(DMonObject*)aThread;

	if (!pO || pO->Type()!=EThread)

		{

		return;

		}

	pO->DumpData();

	TUint supSp, usrSp;

	GetStackPointers(&aThread->iNThread, supSp, usrSp);

	if (aThread->iUserStackRunAddress && aThread->iUserStackSize)

		{

		TInt usrSize = aThread->iUserStackSize;

		TUint usrRunStart = (TUint)aThread->iUserStackRunAddress;

		TUint usrRunEnd = usrRunStart+usrSize;

		Printf("User stack base at %08x, size == %x\r\n", usrRunStart, usrSize);

		Printf("Stack pointer == %08x\r\n", usrSp);

		TUint usrStart = MapAndLocateUserStack(aThread);

		if (usrStart)

			{

			Printf("Stack mapped at %08x\r\n", usrStart);

			TUint usrEnd = usrStart + usrSize;

			if (usrSp >= usrRunStart && usrSp < usrRunEnd)

				usrStart += usrSp - usrRunStart;

			DoStackDumpL(usrStart, usrEnd);

			NewLine();

			}

		else

			Printf("Couldn't locate user stack\r\n");

		}

	else

		Printf("No user-mode stack\r\n");

	TInt  supSize = aThread->iSupervisorStackSize;

	TUint supStart = (TUint)aThread->iSupervisorStack;

	TUint supEnd = supStart+supSize;

	Printf("Supervisor stack base at %08x, size == %x\r\n", supStart, supSize);

	Printf("Stack pointer == %08x\r\n", supSp);	

	if (supSp >= supStart && supSp < supEnd)

		supStart = supSp;

	DoStackDumpL(supStart, supEnd);

	}

EXPORT_C void Monitor::DumpThreadStack(DThread *aThread)

	{

	MTRAPD(r,DoDumpThreadStack(aThread));

	if (r!=KErrNone)

		ProcessError(r);

	}

EXPORT_C void Monitor::DumpThreadStacks(TBool aIncludeCurrent)

	{

	DObjectCon* pC=Container(EThread);

	for (TInt i=0 ; i<pC->Count() ; ++i)

		{

		DThread* pT=(DThread*)(*pC)[i];

		if (aIncludeCurrent || pT!=&Kern::CurrentThread())

			{

			DumpThreadStack(pT);

			NewLine();

			}

		}

	}

EXPORT_C void Monitor::DumpExceptionStacks()

	{

 	#if defined(__EPOC32__) && !defined(__CPU_X86)

 	TStackInfo& stackInfo = Kern::SuperPage().iStackInfo;

	Printf("IRQ stack base at %08x, size == %x\r\n", stackInfo.iIrqStackBase, stackInfo.iIrqStackSize);

 	MTRAPD(r1,DoStackDumpL((TLinAddr)stackInfo.iIrqStackBase,

						   (TLinAddr)stackInfo.iIrqStackBase + stackInfo.iIrqStackSize));

 	if(r1!=KErrNone)

 		ProcessError(r1);

	Printf("\r\nFIQ stack base at %08x, size == %x\r\n", stackInfo.iFiqStackBase, stackInfo.iFiqStackSize);

 	MTRAPD(r2,DoStackDumpL((TLinAddr)stackInfo.iFiqStackBase,

						   (TLinAddr)stackInfo.iFiqStackBase + stackInfo.iFiqStackSize));

 	if(r2!=KErrNone)

 		ProcessError(r2);	

 	#else

	PrintLine("Not Supported");

 	#endif

 	}

void Monitor::DumpProcessData(DProcess* pP)

	{

	Printf("ExitInfo %d,%d,%lS\r\n",pP->iExitType,pP->iExitReason,&pP->iExitCategory);

	Printf("Flags %08x, Handles %08x, Attributes %08x\r\n",pP->iFlags,&pP->iHandles,pP->iAttributes);

	Printf("DataBssChunk %08x, CodeSeg %08x\r\n",pP->iDataBssStackChunk,pP->iCodeSeg);

	Printf("DllLock %08x, Process Lock %08x SID %08x\r\n",pP->iDllLock,pP->iProcessLock,pP->iS.iSecureId);

	Printf("TempCodeSeg %08x CodeSeg %08x Capability %08x %08x\r\n",pP->iTempCodeSeg,pP->iCodeSeg,pP->iS.iCaps[1],pP->iS.iCaps[0]);

	TInt c=pP->iDynamicCode.Count();

	Printf("CodeSegs: Count=%d\r\n",c);

	if (c>0)

		{

		SCodeSegEntry* e = &pP->iDynamicCode[0];

		TInt i;

		for(i=0; i<c; ++i, ++e)

			Printf("%2d: seg=%08x lib=%08x\r\n", i, e->iSeg, e->iLib);

		}

	DumpMemModelProcessData(pP);

	DumpCpuProcessData(pP);

	}

void Monitor::DumpMessageQueueData(DMsgQueue* aQueue)

	{

	Printf("StartOfPool %08x, EndOfPool %08x\r\n", aQueue->iMsgPool, aQueue->iEndOfPool);

	Printf("FirstFullSlot %08x, FirstFreeSlot %08x\r\n", aQueue->iFirstFullSlot, aQueue->iFirstFreeSlot);

	Printf("MaxMsgLength %d\r\n", aQueue->iMaxMsgLength);

	TBuf8<80> buf=_L8("MessageQueue state ");

	switch (aQueue->iState)

		{

		case DMsgQueue::EEmpty: buf+=_L8("Empty"); break;

		case DMsgQueue::EPartial: buf+=_L8("Partial"); break;

		case DMsgQueue::EFull: buf+=_L8("Full"); break;

		default: buf+=_L8("????"); break;

		}

	PrintLine(buf);

	Printf("ThreadWaitingForData %08x, DataAvailStatPtr %08x\r\n",