// 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();
	}