// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

//

#include <e32std.h>

#include <e32svr.h>

#include <f32file.h>

_LIT(KBlankLine, "\r");

class TDll

	{

public:

	TDll(const TDesC& aName, TUint8* aBase, TInt aSize)

		: iName(aName), iBase((TUint)aBase), iSize((TUint)aSize)

		{}

	TFullName iName;

	TUint iBase;

	TUint iSize;

	};

class TDllList

	{

public:

	static void FindDlls();

	static void ResetAndDestroy();

	static void ListDlls(TFileText& aTextFile);

	static TInt Match(TUint anAddr, const TDll*& aDll);

private:

	static RPointerArray<TDll> iList;

	};

RPointerArray<TDll> TDllList::iList(10);

void TDllList::ResetAndDestroy()

	{

	iList.ResetAndDestroy();

	}

void TDllList::ListDlls(TFileText& aTextFile)

	{

	TBuf<0x100> line;

	_LIT(KDllFormat, "%08x-%08x %S\r");

	aTextFile.Write(KBlankLine);

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

		{

		const TDll& dll=*(iList[i]);

		line.Format(KDllFormat, dll.iBase, dll.iBase+dll.iSize-1, &dll.iName);

		aTextFile.Write(line);

		}

	}

TInt TDllList::Match(TUint anAddr, const TDll*& aDll)

	{

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

		{

		aDll=iList[i];

		if (aDll->iBase<=anAddr && aDll->iBase+aDll->iSize > anAddr)

			return KErrNone;

		}

	return KErrNotFound;

	}

void TDllList::FindDlls()

//

// For each library known to the system, look for a chunk of the same name

//

	{

	TFindLibrary findLib;

	TFullName libName;

	while (findLib.Next(libName)==KErrNone)

		{

		TFindChunk findChunk(libName);

		TFullName chunkName;

		if (findChunk.Next(chunkName)!=KErrNone)

			continue;

		RChunk chunk;

		if (chunk.Open(findChunk)!=KErrNone)

			continue;

		TUint8* base=chunk.Base();

		TInt size=chunk.Size();

		chunk.Close();

		TDll* dllptr=new TDll(libName,base,size);

		if (dllptr!=0)

			iList.Append(dllptr);

		}

	}

_LIT(KFormatStackInfo,"Stack %08x-%08x (? %d?), sp=%08x\r");

HBufC8* GrabStack(const TDesC& /*aLine1*/, TThreadId aId, TUint aSp, TInt& aStackBase, TInt& aStackSize)

	{

	TInt err=KErrNone;

#if 0

	// Defect in E32 162 which means that RThread::GetRamSizes will always reset the machine!

	RThread thread;

	if (thread.Open(aId)!=KErrNone)

		return 0;

	TInt heapsize=0;

	err=thread.GetRamSizes(heapsize,aStackSize);

	thread.Close();

	if (err!=KErrNone)

		return 0;

	// Sanity check

	aStackBase = aSp & ~((1024*1024)-1);

	if (aStackSize<0 || aStackSize>=1024*1024 || aSp>(TUint)(aStackBase+aStackSize))

		{

		aStackBase=0;	// indicates a daft stack pointer

		return 0;

		}

#else

	// Sanity check & guess at stack size

	aStackBase = aSp & ~((1024*1024)-1);

	aStackSize = (aSp - aStackBase + 4096) & ~4095;		// round up to a multiple of the page size

	if (aStackBase+aStackSize-aSp < 200)

			aStackSize += 4096;		// seems too small - risk another page!

	if (aStackSize<0 || aStackSize>=1024*1024)

		{

		aStackBase=0;	// indicates a daft stack pointer

		return 0;

		}

	aStackSize-=4;	// a clue to the wise that this is a guess...

#endif

	// Ask the user if we want to risk grabbing the stack...

	TBuf<0x100> line2;

	line2.Format(KFormatStackInfo, aStackBase, aStackBase+aStackSize-1, aStackSize, aSp);

	// OK - let stack grabbing commence

	HBufC8* stackbuf = HBufC8::New(aStackSize);

	if (stackbuf==0)

		return 0;

	TPtr8 stackdes(stackbuf->Des());

	err=RDebug::ReadMemory(aId,aStackBase,stackdes,aStackSize);

	if (err!=KErrNone)

		{

		delete stackbuf;

		stackbuf=0;

		}

	return stackbuf;

	}

GLDEF_C TInt E32Main()

//

// Reporting more detail of KERN-EXEC 3 errors

//

// Warning: This code uses fragile assumptions which may not be true

// in future releases of EPOC

//

// 1) EXEs are located at 0x20000000

// 2) the map file for an EXE puts the start of text at 400010

// 3) the map file for a DLL puts the start of text at 10000010

// 4) the EPOC ROM lives at address 0x50000000

// 5) EPOC stacks start at a megabyte boundary

//

	{

	TBuf<0x100> line1;

	TBuf<0x100> line2;

	SDebugInfo info;

	struct SRegisterInfo reginfo;

	TUint pc = 0;

	TUint regs[16];

	const TDll* faultDll = NULL;

	_LIT(KInfo1, "D_EXC started");

	User::InfoPrint(KInfo1);

	TRequestStatus stat(0);

//	FOREVER

	for (TInt rep=0; rep<2; rep++)	// die after two exceptions

		{

		TInt err = KErrNone;

		// wait for any thread to panic...

		err=RDebug::GetException(info,stat);

		if (err!=KErrNone)

			{

			_LIT(KInfo2, "RDebug failure");

			User::Panic(KInfo2, err);

			}

		User::WaitForRequest(stat);

		_LIT(KFormatPanic, "%S panic %S %d\r");

		_LIT(KFormatException, "%S exception type %d\r");

		_LIT(KFormatBreakpoint, "%S has breakpoint %d\r");

		switch (info.iDebugType)

			{

		case EPanic:

			line1.Format(KFormatPanic,&info.iName,&info.iCategory, info.iPanicType);

			break;

		case EException:

			line1.Format(KFormatException,&info.iName,info.iPanicType);

			break;

		case EBreakPoint:

			line1.Format(KFormatBreakpoint,&info.iName,info.iPanicType);

			break;

		default:

			continue;

			}

		// assume that it's KERN-EXEC 3 and try to use the 

		// full RDebug support to locate the faulting instruction

		HBufC8* stack = NULL;

		TInt stackbase=0;

		TInt stacksize=0;

		const TInt KStackPointerReg = 13;

		pc = 0x00000001;	// illegal value

		err = RDebug::Open();

		if (err==KErrNone)

			{

			err = RDebug::RegisterInfo(reginfo);

			if (!err)

				{

				RDebug::GetRegister(info.iId,reginfo.iNumberOfPcRegister, pc);

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

				    {

					RDebug::GetRegister(info.iId, i, regs[i]);

				    }

				}

			TDllList::FindDlls();

			stack=GrabStack(line1, info.iId, regs[KStackPointerReg], stackbase, stacksize);

			RDebug::Close();

			}

		_LIT(KFormatEXE,	"pc=%08x, .map equivalent %08x\r");

		_LIT(KFormatROM,	"pc=%08x, in ROM\r");

		_LIT(KFormatDll,	"pc=%08x, in DLL %S, .map equivalent %08x\r");

		_LIT(KFormatOther,	"pc=%08x, iCodeAddr=%08x\r");

		_LIT(KFormatError,	"(Unable to determine pc)\r");

		if ((pc&3) == 0)

			{

			if (pc >= 0x20000000 && pc < 0x30000000)

			    {

				line2.Format(KFormatEXE, pc, pc-0x20000000+0x400010);

			    }

			else if (pc >= 0x50000000 && pc < 0x60000000)

				{

                line2.Format(KFormatROM, pc);

				}

			else if (TDllList::Match(pc, faultDll)==KErrNone)

			    {

				line2.Format(KFormatDll, pc, &faultDll->iName, pc-(faultDll->iBase)+0x10000010);

			    }

			else

			    {

				line2.Format(KFormatOther, pc, info.iCodeAddr);

			    }

			}

		else

		    {

			line2.Copy(KFormatError);

		    }

		RFs fs;

		err = fs.Connect();

		if (err!=KErrNone)

		    {

			break;

		    }

		_LIT(KFormatFilename,"d:\\d_exc_%d.txt");

		_LIT(KFormatStackname,"d:\\d_exc_%d.stk");

		// Report the basic information about registers, DLLs etc

		TFileName name;

		name.Format(KFormatFilename, *(TUint*)&info.iId);

		RFile file;

		err=file.Replace(fs, name, EFileWrite+EFileShareAny+EFileStreamText);

		if (err!=KErrNone)

		    {

            fs.Close();

            break;

		    }

		TFileText textfile;

		textfile.Set(file);

		textfile.Write(line1);

		textfile.Write(line2);

		textfile.Write(KBlankLine);

		_LIT(KFormatRegisters,"r%02d=%08x %08x %08x %08x\r");

		line2.Format(KFormatRegisters, 0, regs[0], regs[1], regs[2], regs[3]);

		textfile.Write(line2);

		line2.Format(KFormatRegisters, 4, regs[4], regs[5], regs[6], regs[7]);

		textfile.Write(line2);

		line2.Format(KFormatRegisters, 8, regs[8], regs[9], regs[10], regs[11]);

		textfile.Write(line2);

		line2.Format(KFormatRegisters, 12,regs[12], regs[13], regs[14], regs[15]);

		textfile.Write(line2);

		if (stackbase!=0)

			{

			line2.Format(KFormatStackInfo, stackbase, stackbase+stacksize-1, stacksize, regs[KStackPointerReg]);

			textfile.Write(line2);

			}

		TDllList::ListDlls(textfile);

		TDllList::ResetAndDestroy();

		file.Close();

		// Dump the stack as binary data

		if (stack)

			{

			name.Format(KFormatStackname, *(TUint*)&info.iId);

			err=file.Replace(fs, name, EFileWrite+EFileShareAny+EFileStreamText);

			if (err==KErrNone)

				{

				file.Write(*stack);

				file.Close();

				}

			}

		delete stack;

		fs.Close();

		}

	return stat.Int();

	}