// Copyright (c) 2004-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\smonlog.cpp

// Automatic (non-iteractive) crash logger.

// 

//

#include <kernel/monitor.h>

#include <crashflash.h>

#include <assp.h>

#ifdef _CRASHLOG_COMPR

#include "crashlog_gzip.h"

#endif

const TInt KRestartType = CrashLogger::ESoftRestart;

/** Number of seconds elapsed between 01/01/0000 AD and 01/01/2000 AD.

    Value is the number of days multiplied by the number of seconds per day:

    730497 * 86400

 */

const TInt64 KYear2000ADInSeconds = I64LIT(63114940800);

IMPORT_C TInt64 CrashTime();

#ifdef _CRASHLOG_COMPR

LOCAL_D TCrashLogGzip gDebugGzip;

#endif

GLDEF_D CrashLogger TheCrashLogger;

CrashLogger::CrashLogger() 

#ifdef _CRASHLOG_COMPR	

: iEncoder(&gDebugGzip)

#endif

{}

void CrashLogger::Print(const TDesC8& aDes)

	{	

#ifdef _CRASHLOG_COMPR	

	if (!iTruncated)

		{

		iTruncated = iEncoder->Write(aDes);

		}		

#else

	TheCrashLogger.iFlash->Write(aDes);

#endif

	}

TInt CrashLogger::Init2(TAny* aCategory, TInt aReason)

	{

	__KTRACE_OPT(KALWAYS,Kern::Printf("Starting Crash Logger..."));

	if(KDebugNum(KCRASHLOGGERDISABLE))

		{

		__KTRACE_OPT(KALWAYS,Kern::Printf("Crash Logger Disabled; Closing."));

		return KErrNone;

		}

	if(!iFlash)

		{

		__KTRACE_OPT(KALWAYS,Kern::Printf("Crash logger has not been fully initialised, exiting..."));

		return KRestartType;

		}

	iFrame=NULL;

	iFaultCategory=*(const TDesC8*)aCategory;

	iFaultReason=aReason;

	Epoc::SetMonitorExceptionHandler((TLinAddr)HandleException);

	CpuInit();

	__KTRACE_OPT(KALWAYS,Kern::Printf("Crash Logger initialised"));

	iFlash->StartTransaction();

	__KTRACE_OPT(KALWAYS,Kern::Printf("Started transaction..."));

	if(SignatureExists())

		{

		__KTRACE_OPT(KALWAYS,Kern::Printf("Refusing to overwrite existing crash log, exiting..."));

		return KRestartType;

		}

	__KTRACE_OPT(KALWAYS,Kern::Printf("No existing crash log found. Proceeding with crash log dump..."));

	__KTRACE_OPT(KALWAYS,Kern::Printf("Erasing log area..."));

	iFlash->EraseLogArea();

	__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping crashinfo..."));

	DumpCrashInfo();

	__KTRACE_OPT(KALWAYS,Kern::Printf("Writing signature..."));

	WriteSignature();

	iFlash->EndTransaction();

	__KTRACE_OPT(KALWAYS,Kern::Printf("Transaction completed."));

	return KRestartType;

	}

TBool CrashLogger::SignatureExists()

	{

	__KTRACE_OPT(KDEBUGGER,Kern::Printf(">CrashLogger::SignatureExists()."));

	iFlash->SetReadPos(KCrashLogSizeFieldBytes);

	TBuf8<KCrashLogSignatureBytes> buf(0);

	buf.Copy(KCrashLogSignature);

	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Expected signature: %S", &KCrashLogSignature));

	buf.SetLength(KCrashLogSignatureBytes);

	iFlash->Read(buf);

	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Found signature: %S", &buf));

	if(buf.Compare(KCrashLogSignature) != 0)

		{

		__KTRACE_OPT(KDEBUGGER,Kern::Printf("<CrashLogger::SignatureExists():EFalse."));

		return EFalse;

		}

	__KTRACE_OPT(KDEBUGGER,Kern::Printf("<CrashLogger::SignatureExists():ETrue."));

	return ETrue;

	}

void CrashLogger::DumpCrashInfo()

	{

	volatile TInt state = ERomInfo;

#ifdef _CRASHLOG_COMPR

	iTruncated = EFalse;

	iEncoder->SetOutput(TheCrashLogger.iFlash);

#endif //_CRASHLOG_COMPR

	for(state=0; state <= EFinished; )

		{

		MTRAPD(r, DoDumpCrashInfo(state))

		if(r!=KErrNone)

			{

			ProcessError(r);

			}

		}

#ifdef _CRASHLOG_COMPR

	iEncoder->FlushEnd();

#endif //_CRASHLOG_COMPR

	}

void CrashLogger::DoDumpCrashInfo(volatile TInt& aState)

	{

	volatile TInt j = 0;

	switch(aState)

		{

		case ERomInfo:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping rom information..."));

			PrintLine("===Dumping rom information...===");

			DumpRomInfo();

			break;

		case ECrashTime:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping crash time..."));

			PrintLine("===Dumping crash time...===");

			DumpCrashTime();

			break;	

		case EFaultInfo:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping fault information..."));

			PrintLine("===Dumping fault information...===");

			DisplayFaultInfo();

			break;

		case EGeneralInfo:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping general crash info..."));

			PrintLine("===Dumping general crash info...===");

			TInt i;

			ProcessInfoCommand(KNullDesC8, i);

			break;

		case EObjectContainers:

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping object containers..."));

			PrintLine("===Dumping object containers...===");

			for(; j < ENumObjectTypes; j++)

				{

				MTRAPD(r,DumpObjectContainer(j,EFalse));

				if(r!=KErrNone)

					{

					ProcessError(r);

					}

				}

			//Once we are done all the various containers advance the aState

			++aState;

			break;

		case ERegisters:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping cpu registers..."));

			PrintLine("===Dumping cpu registers...===");

			DumpCpuRegisters();

			break;

		case ECurrentThreadStack:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping the current thread's stack..."));

			PrintLine("===Dumping the current thread's stack...===");

			DumpThreadStack(&Kern::CurrentThread());

			break; 

		case EExceptionStacks:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping the exception stacks..."));

			PrintLine("===Dumping Exception stacks...");

			DumpExceptionStacks();

			break;

		case EVariantSpecific:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping variant specifc debug information..."));

			PrintLine("===Dumping variant specifc debug information...===");

			DumpVariantSpecific();

			break;

		case ECodeSegs:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping code segments..."));

			PrintLine("===Dumping code segments...===");

			DisplayCodeSeg(EFalse);

			break;

		case EOtherThreadStacks:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Dumping other thread stacks..."));

			PrintLine("===Dumping other thread stacks...===");

			DumpThreadStacks(EFalse);

			break;

		case EFinished:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Finished automatic debug dump."));

			PrintLine("===Finished automatic debug dump.===");

			break;	

		default:

			++aState;

			__KTRACE_OPT(KALWAYS,Kern::Printf("Unknown Auto Print State.  Restarting..."));

			PrintLine("===Unknown Auto Print State===");

			Kern::Restart(0);

			break;

		} 

	}

void CrashLogger::WriteSignature()

	{

#ifndef _CRASHLOG_COMPR

	TBuf8<KCrashLogHeaderSize> sig(0);

	*(TUint32*)(sig.Ptr()) = iFlash->BytesWritten() + KCrashLogHeaderSize;

	sig.SetLength(KCrashLogSizeFieldBytes);

	// Add the signature string

	sig.Append(KCrashLogSignature);

	iFlash->WriteSignature(sig);

#else

	TBuf8<KCrashLogHeaderSize> sig(0);

	TUint32* ptr = (TUint32*)sig.Ptr();

	// The crashlog size in bytes including the header

	*ptr = iFlash->BytesWritten() + KCrashLogHeaderSize;

	__KTRACE_OPT(KALWAYS,Kern::Printf("WriteSignature: Size=%d",iFlash->BytesWritten() + KCrashLogHeaderSize));		

	// Add the signature string

	sig.SetLength(KCrashLogSizeFieldBytes);

	sig.Append(KCrashLogSignature);

	ptr += (sig.Length()>>2); 	// seek to end of sig so far

	// The crashlog uncompressed size	

	*ptr = iEncoder->GetDataCompressed();

	ptr++;

	__KTRACE_OPT(KALWAYS,Kern::Printf("WriteSignature: Uncompr Size=%d",iEncoder->GetDataCompressed()));

	// The log flags 

	TUint32 flags = KCrashLogFlagGzip;

	flags |= (iTruncated)?KCrashLogFlagTruncated : 0;

	flags |= iFlash->GetLogOffset()<<KCrashLogFlagOffShift;

	*ptr = flags;

	__KTRACE_OPT(KALWAYS,Kern::Printf("WriteSignature: Flags=%08x",flags));

	sig.SetLength(KCrashLogHeaderSize);

	iFlash->WriteSignature(sig);

#endif //_CRASHLOG_COMPR

	}

void CrashLogger::DumpExceptionStacks()

	{

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

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

	PrintLine("   Dumping IRQ stack...");

	MTRAPD(r1,DoMemoryDumpL((TLinAddr)stackInfo.iIrqStackBase, stackInfo.iIrqStackSize));

	if(r1!=KErrNone)

		ProcessError(r1);	

	PrintLine("   Dumping FIQ stack...");

	MTRAPD(r2,DoMemoryDumpL((TLinAddr)stackInfo.iFiqStackBase, stackInfo.iFiqStackSize));

	if(r2!=KErrNone)

		ProcessError(r2);	

#else

	PrintLine("Not Supported");

#endif

	}

void CrashLogger::DumpRomInfo()

	{               

	TVersion romVersion = Epoc::RomHeader().iVersion;

	TVersionName v = romVersion.Name(); 

	Printf("Rom Version: %S",&v);

	TInt64 time = Epoc::RomHeader().iTime;

	Printf("Rom built %x%xh seconds after 0 AD.",I64HIGH(time),I64LOW(time));

	NewLine();

	}

void CrashLogger::DumpCrashTime()

	{                   

	// We want time from 2000AD when SystemTime starts from 0AD hence the adjustment.

	TTimeK secsSince0AD = CrashTime();

    if(!secsSince0AD)

        {

        Printf("Data corruption prevented determining timestamp");

        }

    else

        {

		TTimeK secsSince2000AD = secsSince0AD - KYear2000ADInSeconds;

	    Printf("Crashed %xh seconds after 01/01/00 00:00:00.", secsSince2000AD);

	    }

	NewLine();

	}

void StartSecondary(TAny*)

	{

	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Initialising flash for crash logger"));

	//InitFlash is implemented in the variant as it creates a variant

	//specific derived CrashFlash

	TheCrashLogger.InitFlash();

	}

GLDEF_C TDfc StartSecondaryDfc(&StartSecondary, NULL, Kern::SvMsgQue(), KMaxDfcPriority-1);

GLDEF_C TInt KernelModuleEntry(TInt aReason)

	{

	if(aReason==KModuleEntryReasonVariantInit0)

		{

#ifdef _CRASHLOG_COMPR

		new(&gDebugGzip) TCrashLogGzip;

#endif

		new(&TheCrashLogger) CrashLogger;

		TheCrashLogger.iFlash = 0;

		// We are going to register the crash logger here so that the order

		// the monitor modules are placed in rom is preserved.  However, since

		// we haven't been entirely initialised, this monitor will have to be

		// skipped if we crash prior to its full initialisation (in

		// ExtensionInit1)

		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Installing crash logger extension"));

		Monitor::RegisterMonitorImpl(&TheCrashLogger);

		return KErrNone;

		}

	else if(aReason==KModuleEntryReasonExtensionInit0)

		{

		// Returning KErrNone here ensures we are called later with aReason ==

		// KModuleEntryReasonExtensionInit1.

		return KErrNone;

		}

	else if(aReason==KModuleEntryReasonExtensionInit1)

		{

		// We have to be called at ExtensionInit1 as we require the kernel heap

		// to allocate a DPlatChunkHw in CrashLogger::InitFlash().  The kernel

		// heap doesn't exist until after ExtensionInit0

		// Added later...  In addition to requiring a kernel heap, we also need

		// all nand flash drivers to have been loaded such that they initialise

		// the hardware correctly for us.  To do this, rather than initialising

		// here, we enque a dfc to be handled after all modules have been

		// loaded (exstart.cpp employs a similar scheme).  We've given the dfc

		// a highish priority to ensure that the crash logger is ready before

		// the file system and most of the rest of the system boots.  This

		// should ensure that one can capture crashes that occur here.

		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Enqueing dfc to init crash flash after all modules loaded"));

		StartSecondaryDfc.Enque();

		return KErrNone;

		}

	return KErrArgument;

	}