// Copyright (c) 2008-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\debug\crashMonitor\src\scmonitor.cpp

// Core dump server - Kernel side crash monitor

// 

//

/**

 @file

 @internalTechnology

*/

#include <scmonitor.h>

#include <kernel/monitor.h>

#include <assp.h>

#include <drivers/crashflash.h>

#include <kernel/klib.h>

#include <crashlogwalker.h>

#include <scmconfigitem.h>

#include "scmdatasave.h"

GLDEF_D SCMonitor TheSCMonitor; //global definition of SCMonitor

//keep things 4 byte aligned

const TInt KRestartType = SCMonitor::ESoftRestart;

/**

SCMonitor constructor

*/

SCMonitor::SCMonitor()

	: iMultiCrashInfo(NULL)

	{

	}

SCMonitor::~SCMonitor()

	{

	delete iMultiCrashInfo;

	}

/**

 Print data to the corresponding output channel. Derived from monitor

 @param aDes the buffer containing the data

 */

void SCMonitor::Print (const TDesC8& aDes )

	{

	//intended to do nothing

	}

/**

 * Allocates resources for SCMonitor

 * cant fully construct in constructor as we are a kernel extension and resources are limited when we are created

 */

void SCMonitor::StableConstruction()

	{

	LOG_CONTEXT

	iDataSave = new SCMDataSave(this, TheSCMonitor.iFlash);	

	//Configuration object for use upon crash

	iScmConfig = new SCMConfiguration();

	TInt err = iScmConfig->SetDefaultConfig();	

	if(KErrNone != err)

		{

		CLTRACE1("SCMonitor::StableConstruction - Unable to set default config err = %d", err);

		}

#ifdef NO_MULTICRASHINFO	

	iMultiCrashInfo = NULL;

#else	

	//We need to take a look at the flash map from variant_norflash_layout.h

	iMultiCrashInfo = new SCMMultiCrashInfo();

	TUint numberBlocks = KCrashLogSize / KCrashLogBlockSize;

	for(TUint32 cnt = 0; cnt < numberBlocks; cnt++)

		{

		iMultiCrashInfo->AddBlock(new SCMCrashBlockEntry(cnt, cnt * KCrashLogBlockSize, KCrashLogBlockSize));

		}

#endif

	}

/**

 * Start a secondary DFC queue for the Flash and Init the flash in the variant(h4)

 * @param aAny

 */

void StartSecondary (TAny* )

	{

	LOG_CONTEXT

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

	//specific derived CrashFlash

	TheSCMonitor.InitFlash ( );

	TheSCMonitor.StableConstruction();

	}

/**

 * Global method to create a dfc queue

 * @param Method to intialise the flash.

 * @param Null

 * @param Gets the address of the supervisor thread DFC queue

 * @param TDfcQ priority number

 * @return a DFC object

 */

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

/**

 * Kernel Main module entry - Own implementation( similar to crash logger)

 * @param aReason reason to enter to the method

 * @return One of the system wide codes

 */

GLDEF_C TInt KernelModuleEntry(TInt aReason)

	{	

	if(aReason==KModuleEntryReasonVariantInit0)

		{

		new(&TheSCMonitor) SCMonitor;

		// We are going to register the system Crash monitor here so that the order

		// the monitor modules are placed in rom is preserved.  

		// The monitor is not fully intialised here.

		//the variant target is missing as we still have to finalise on the crash flash 

		//implementation. H2 & H4 doesnt support currently.

		LOG_CONTEXT		

		CLTRACE("Installing System Crash Monitor");

		Monitor::RegisterMonitorImpl (&TheSCMonitor );

		return KErrNone;

		}

	else if (aReason==KModuleEntryReasonExtensionInit0 )

		{

		return KErrNone;

		}

	else if (aReason==KModuleEntryReasonExtensionInit1 )

		{

		LOG_CONTEXT

		CLTRACE("Enqueing dfc to init crash flash for System Crash Monitor after all modules loaded");

		StartSecondaryDfc.Enque ( );

		return KErrNone;

		}

	return KErrArgument;

	}

/**

 Method to intialize the system crash monitor

 @param aCategory the fault category type

 @param aReason the reason for crash

 @return restart type

 */

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

	{

	LOG_CONTEXT

	__KTRACE_OPT(KALWAYS, Kern::Printf("\n\nSystem Crash Monitor Launched: To Analyse Crash Produced Use Core Dump Server\n"));

	//Start logging the data:	

	//Need to lock kernel to access object containers (it technically is anyway, but flag isnt set)

	NKern::Lock();

	DoCrash(aCategory, aReason);	

	NKern::Unlock();		

	__KTRACE_OPT(KALWAYS, Kern::Printf("System Crash Monitor Finished: Log Size = [%d]\n", iDataSave->iCrashInf.iLogSize));

	return KRestartType;

	}

/**

 * This is responsible for setting up any structures required for processing of the crash

 * @param aCategory the fault category type

 * @param aReason 

 */

void SCMonitor::DoCrash(TAny* aCategory, TInt aReason )

	{

	// get debug mask

	TInt dbgMask = Kern::SuperPage().iDebugMask[0];

	// if we are writing to the comm port then we need to turn off other debug messages

	if( iDataSave->GetWriteSelect() == SCMDataSave::EWriteComm)

		{

		Kern::SuperPage().iDebugMask[0] = 0;

		}

	if(!aCategory)

		{

		CLTRACE("\tNULL category retrieved and returning");

		TheSCMonitor.iFlash->EndTransaction();

		return;

		}

	iFrame = NULL;

	CLTRACE("\tAbout to set category -- note: can occasionaly crash board");	

	iFaultCategory = *(const TDesC8*)aCategory;  // this crashes the board sometimes		

	iFaultReason = aReason;

	Epoc::SetMonitorExceptionHandler ((TLinAddr)HandleException );

	// get the first start block

	// will retieve start of flash by default

	SCMCrashBlockEntry block;

	TInt err = GetNextCrashStartPoint(block);  // will also attempt to read iScmConfig

	if(KErrNone == err)

		{

		CLTRACE2("SCMonitor::DoCrash next crash will be written at blocknumber = %d offset  %d"

				, block.iBlockNumber, block.iBlockOffset);

		}

	else

		{

		CLTRACE1("SCMonitor::DoCrash Failed to find a valid block to write to, can not continue. err = [%d]", err);

		return;

		}

	TUint crashId = block.iBlockNumber;	

	iDataSave->iWriter->ResetBytesWritten();		

	//Write the crash (1st pass is to gather header data)

	TInt spaceRequired = ProcessCrash(block, crashId, EFalse);					

	// now do the real write	

	// prepare flash for data	

	TheSCMonitor.iFlash->StartTransaction();	

	TheSCMonitor.iFlash->SetWritePos(block.iBlockOffset);

	//write the crash this time

	ProcessCrash(block, crashId, ETrue);

	TheSCMonitor.iFlash->EndTransaction();	

	// restore debug mask

	Kern::SuperPage().iDebugMask[0] = dbgMask;

	}

/**

 * This walks the existing crash log and finds out where current crashes finish

 * @param aBlockEntry Block to use. Only valid if KErrNone is returned.

 * @return One of the OS wide codes

 */

TInt SCMonitor::GetNextCrashStartPoint(SCMCrashBlockEntry& aBlockEntry)

	{

	LOG_CONTEXT	

	//First thing is to try and read the config

	TBool configFound = (iDataSave->ReadConfig(*iScmConfig) == KErrNone);

	if( iMultiCrashInfo)	

		{				

		/**

		 * data save has been configured to use multicrash info to find the next block we are on we need to scan each

		 * block to see if it contains a valid header. if we find an empty block in our block list then that is the

		 * one we will use if we find no empty blocks then we have no room left	

		 */

		iMultiCrashInfo->Reset();

		SCMCrashBlockEntry* block = iMultiCrashInfo->GetNextBlock();

		TBool blockFound = EFalse;				

		//For any crashes in flash, we need to record where they end, so that we can then go to the next

		//block after the one in which it ends

		TInt crashEndPoint = 0;		

		while(block)

			{	

			CLTRACE1("SCMonitor::GetNextCrashStartPoint Processing block number %d", block->iBlockNumber );			

			//If we have already found our block, we should erase subsequent ones for use

			if(blockFound)

				{

				TInt err = EraseFlashBlock(*block);

				if(err != KErrNone)

					{					

					return err;

					}

				block = iMultiCrashInfo->GetNextBlock(); 

				continue;

				}	

			//is this block before a crash end? if it is, we cant use it as a crash can span multiple blocks

			if(block->iBlockOffset >= crashEndPoint)

				{

				//special condition if we have a config

				TUint startPos = block->iBlockOffset;

				TUint skipBytes = 0;

				if(configFound && block->iBlockOffset == 0)

					{

					startPos+=iScmConfig->GetSize();

					//must align to flash for read

					skipBytes = startPos % KFlashAlignment;	

					startPos -= skipBytes;

					}

				// try and read an info header at these flash coords

				TBuf8<TCrashInfoHeader::KSCMCrashInfoMaxSize + KFlashAlignment> buf;

				buf.SetLength(TCrashInfoHeader::KSCMCrashInfoMaxSize + KFlashAlignment);

				CLTRACE1("(SCMonitor::GetNextCrashStartPoint) reading at offset %d", block->iBlockOffset);

				TheSCMonitor.iFlash->SetReadPos(startPos);

				TheSCMonitor.iFlash->Read(buf);

				// create the buffer applying the offset of bytes skipped

				TByteStreamReader reader(const_cast<TUint8*> (buf.Ptr() + skipBytes));

				TCrashInfoHeader header;								

				TInt err = header.Deserialize(reader);

				if(err == KErrCorrupt)

					{

					CLTRACE2("(SCMonitor::GetNextCrashStartPoint) Found empty block blocknumber %d blockoffset = %d"

							, block->iBlockNumber, block->iBlockOffset);

					blockFound = ETrue;

					aBlockEntry = *block;

					continue; //Dont get next block, as next run will erase this current block for use

					}

				else

					{					

					crashEndPoint = header.iLogSize + startPos;

					CLTRACE3("(SCMonitor::GetNextCrashStartPoint) In block [%d] we found a valid crash header. This crash finishes at [%d] [0x%X]", block->iBlockNumber, crashEndPoint, crashEndPoint);

					}

				}

			block = iMultiCrashInfo->GetNextBlock();

			}									

		if(blockFound)

			{

			return KErrNone;

			}

		else

			{

			//CLTRACE("(SCMonitor::GetNextCrashStartPoint) No available blocks TREATING as NO MULTICRASH INFO will write to default block");

			//In this case should we just overwrite old crashes and return the first block as the comment above suggests

			//return blockFound;

			}

		}

	// no multi crash info supplied - use default first block settings

	TInt err = EraseEntireFlashPartition();

	if(err != KErrNone)

		{

		CLTRACE1("Unable to delete area required to log to flash. Aborting. Error - [%d]", err);

		return err;

		}

	aBlockEntry = SCMCrashBlockEntry(0,0,0);

	return KErrNone;

	}

/**

 * Handles the processing of the crash

 * @return The size of the crash log (including header) that has been/will be written

 */

TInt SCMonitor::ProcessCrash(const SCMCrashBlockEntry& aBlock, TUint aCrashId, TBool aCommit)

	{	

	LOG_CONTEXT

	CLTRACE5("aBlock.iBlockOffset = [%d]  [0x%X] aBlock.iBlockNumber = %d aBlock.iBlockSize = [%d]  [0x%X]",

			aBlock.iBlockOffset, aBlock.iBlockOffset, aBlock.iBlockNumber, aBlock.iBlockSize, aBlock.iBlockSize);		

	// reset writer for start of each crash

	iDataSave->iWriter->ResetBytesWritten();

	TInt logLevel = 0;

	if(aCommit)

		{

		logLevel = KALWAYS;

		iDataSave->iWriter->EnablePhysicalWriting();	

		}

	else

		{

#if defined(_DEBUG)

		logLevel = KDEBUGGER;

#else

		logLevel = KALWAYS; //Doesnt matter, KTRACE OPT is empty for rel builds 

		if(logLevel != KALWAYS)

			{

			//This is to avoid warning

			}

#endif

		iDataSave->iWriter->DisablePhysicalWriting();	

		}

	iDataSave->SetByteCount(aBlock.iBlockOffset);	

	if(aBlock.iBlockOffset == 0 && aBlock.iBlockNumber == 0)

		{	

		// this is the first crash - we need to save the config here first

		CLTRACE("(SCMonitor::ProcessCrash) - this is block 0 - WRITING CONFIG");

		iDataSave->LogConfig(*iScmConfig);	

		//Config is not part of crash so reset bytes written			

		iDataSave->SetCrashStartingPoint(iDataSave->iWriter->GetBytesWritten());		

		}	

	else

		{

		iDataSave->SetCrashStartingPoint(aBlock.iBlockOffset);

		}	

	iDataSave->iWriter->ResetBytesWritten();

	TUint32 logSize = 0;

	TUint sizeOfObjectDumped = 0;

	TInt err = iDataSave->LogCrashHeader(iFaultCategory, iFaultReason, aCrashId, sizeOfObjectDumped);		

	if(KErrNone != err)

		{

		CLTRACE("System Crash Monitor: Failed to create crash info header - (TCrashInfo)"); 

		return KRestartType;

		}	

	logSize += sizeOfObjectDumped;

	//Now we must read the configuration to use. This is held at the start of our flash partition

	//and managed by the iConfig object

	iScmConfig->ResetToHighestPriority();	

	//Always want the crash context

	iDataSave->iHdr.iCTFullRegOffset = logSize + iDataSave->GetCrashStartingPoint();

	err = iDataSave->LogCPURegisters(sizeOfObjectDumped);

	if(KErrNone != err)

		{

		CLTRACE1("\tError logging full registers = %d", err);

		}	

	logSize += sizeOfObjectDumped;

	CLTRACE("\tAbout to enter processing loop");		

	SCMDataSave::TDataToDump dump;

	for(;;)		

		{		

		//now we get each item by priority from the configuration

		TConfigItem* configItem = iScmConfig->GetNextItem();

		if(!configItem)

			{

			// end of list

			break;

			}

		CLTRACE1("\nLooking at item type [%d]", configItem->GetDataType());

		if(configItem->GetSpaceRequired() > iDataSave->SpaceRemaining())

			{

			__KTRACE_OPT(logLevel, Kern::Printf("\t\tFor Item Type [%d]: Unable to log [0x%X] [%d] bytes because we only have [0x%X] [%d] bytes left", configItem->GetDataType(), configItem->GetSpaceRequired(), configItem->GetSpaceRequired(), iDataSave->SpaceRemaining(), iDataSave->SpaceRemaining()));

			continue;

			}

		else

			{

			CLTRACE1("Will require [%d] bytes for this item", configItem->GetSpaceRequired());

			}

		// only interested in logging items with priority > 0

		if( configItem->GetPriority() <= 0)

			{

			CLTRACE1("\tIgnored config item type %d priority 0", configItem->GetDataType());

			continue;

			}

		//there are a lot of TUints in the hdr to record where we wrote this item. 

		//This will point to the one of interest for this configItem

		TUint32* offsetPointer = NULL;				

		//now we check the type of data we wish to dump

		switch(configItem->GetDataType())

			{

			case TConfigItem::ECrashedThreadMetaData:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ECrashedThreadMetaData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = LogThreadMetaData(SCMDataSave::EThreadSpecific, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iCTMetaOffset);

				break;

				}

			case TConfigItem::EThreadsMetaData:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EThreadsMetaData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//record location we are writing to in the header

				iDataSave->iHdr.iTLstOffset = iDataSave->iWriter->GetBytesWritten();

				err = LogThreadMetaData(SCMDataSave::ESystemWide, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iTLstOffset);

				break;

				}

			case TConfigItem::ECrashedProcessMetaData:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ECrashedProcessMetaData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = LogProcessMetaData(SCMDataSave::EProcessSpecific, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iCPMetaOffset);

				break;

				}

			case TConfigItem::EProcessMetaData:		

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EProcessMetaData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = LogProcessMetaData(SCMDataSave::ESystemWide, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iPLstOffset);

				break;

				}

			case TConfigItem::ECrashedProcessUsrStacks:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ECrashedProcessUsrStacks at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::EUsrStack;

				dump.iReg = SCMDataSave::ERegSetNone;	

				err = LogObjectContainers(EThread, SCMDataSave::EProcessSpecific, dump, sizeOfObjectDumped);	

				offsetPointer = &(iDataSave->iHdr.iCTUsrStkOffset);

				break;

				}

			case TConfigItem::EThreadsUsrStack:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EThreadsUsrStack at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::EUsrStack;

				dump.iReg = SCMDataSave::ERegSetNone;

				err = LogObjectContainers(EThread, SCMDataSave::ESystemWide, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iSysSvrStkOffset);

				break;

				}

			case TConfigItem::ECrashedProcessSvrStacks:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ECrashedProcessSvrStacks at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::ESvrStack;

				dump.iReg = SCMDataSave::ERegSetNone;

				err = LogObjectContainers(EThread, SCMDataSave::EProcessSpecific, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iCTSvrStkOffset);

				break;

				}

			case TConfigItem::EThreadsSvrStack:			

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EThreadsSvrStack at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::ESvrStack;

				dump.iReg = SCMDataSave::ERegSetNone;

				err = LogObjectContainers(EThread, SCMDataSave::ESystemWide, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iSysSvrStkOffset);

				break;

				}

			case TConfigItem::EThreadsUsrRegisters:		

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EThreadsUsrRegisters at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::EStackTypeNone;

				dump.iReg = SCMDataSave::EUserRegisters;

				err = LogObjectContainers(EThread, SCMDataSave::ESystemWide, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iSysUsrRegOffset);

				break;

				}

			case TConfigItem::EThreadsSvrRegisters:		

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EThreadsSvrRegisters at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = EFalse;

				dump.iStk = SCMDataSave::EStackTypeNone;

				dump.iReg = SCMDataSave::ESupervisorRegisters;

				err = LogObjectContainers(EThread, SCMDataSave::ESystemWide, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iSysSvrRegOffset);

				break;

				}

			case TConfigItem::EExceptionStacks:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EExceptionStacks at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = iDataSave->LogExceptionStacks(sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iExcStkOffset);

				break;

				}

			case TConfigItem::ECrashedProcessCodeSegs:

				{	

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ECrashedProcessCodeSegs at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = ETrue;

				dump.iStk = SCMDataSave::EStackTypeNone;

				dump.iReg = SCMDataSave::ERegSetNone;				

				err = LogObjectContainers(EProcess, SCMDataSave::EProcessSpecific, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iCPCodeSegOffset);

				break;

				}

			case TConfigItem::EProcessCodeSegs:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EProcessCodeSegs at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				//define what we wish to dump

				dump.iMetaData = EFalse;

				dump.iCodeSegs = ETrue;

				dump.iStk = SCMDataSave::EStackTypeNone;

				dump.iReg = SCMDataSave::ERegSetNone;

				err = LogObjectContainers(EProcess, SCMDataSave::ESystemWide, dump, sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iSysCodeSegOffset);

				break;

				}

			case TConfigItem::ETraceData:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ETraceData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = iDataSave->LogTraceBuffer(configItem->GetSizeToDump(), sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iTraceOffset);

				break;

				}		

			case TConfigItem::ELocks:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ELocks at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));	

				err = iDataSave->LogLocks(sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iScmLocksOffset);

				break;

				}

			case TConfigItem::EKernelHeap:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EKernelHeap at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = iDataSave->LogKernelHeap(sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iKernelHeapOffset);

				break;

				}

			case TConfigItem::EVariantSpecificData:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: EVariantSpecificData at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = iDataSave->LogVariantSpecificData(sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iVarSpecInfOffset);

				break;

				}

			case TConfigItem::ERomInfo:

				{

				__KTRACE_OPT(logLevel, Kern::Printf("\tDoing: ERomInfo at [%d] offset from [%d]", iDataSave->iWriter->GetBytesWritten(), iDataSave->GetCrashStartingPoint()));

				err = iDataSave->LogRomInfo(sizeOfObjectDumped);

				offsetPointer = &(iDataSave->iHdr.iRomInfoOffset);

				break;

				}

			//unknown configuration type - something bad is going on

			default: return 0;			

			}				

		if(KErrNone != err)

			{

			__KTRACE_OPT(logLevel, Kern::Printf("\tError logging data: [%d]   Type = [%d]", err, aBlock.iBlockOffset));

			continue;

			}

		//Set the space required so next time around we will know in advance how much space we need

		configItem->SetSpaceRequired(sizeOfObjectDumped);		

		//Note: the following steps are only required for the first time we call process crash. The second time,

		//when physical writing is enabled, these will have been written already and so they dont matter

		//update the offset and logsize if we are going to dump this item

		TUint32 absoluteLogPos = logSize + iDataSave->GetCrashStartingPoint();

		if(absoluteLogPos+sizeOfObjectDumped < iDataSave->MaxLogSize())

			{

			//now, we must record where in the crash log this item will be dumped

			*offsetPointer = absoluteLogPos;

			logSize += sizeOfObjectDumped;

			}

		}

	iDataSave->iCrashInf.iLogSize = logSize;	

	iDataSave->iWriter->FlushCache();		

	return iDataSave->iCrashInf.iLogSize;

	}

/**

 * Logs the meta data for processes

 * @param aCurrentProcess - scope to dump

 * @return one of the OS wide codes

 */

TInt SCMonitor::LogProcessMetaData(SCMDataSave::TDumpScope aScope, TUint& aSizeDumped) const

	{

	LOG_CONTEXT

	SCMDataSave::TDataToDump dump;

	dump.iMetaData = ETrue;

	return LogObjectContainers(EProcess, aScope, dump, aSizeDumped);

	}

/**

 * 

 * @param aCurrentThread -  to only do the current (crashed thread) or to do all the others

 * @return one of the OS wide codes

 */

TInt SCMonitor::LogThreadMetaData(SCMDataSave::TDumpScope aScope, TUint& aSizeDumped) const

	{

	LOG_CONTEXT

	SCMDataSave::TDataToDump dump; 

	dump.iMetaData = ETrue;

	return LogObjectContainers(EThread, aScope, dump, aSizeDumped);

	}

/**

 * Generic method that looks at all kernel objects of aObjectType

 * @param aObjectType

 * @param aDumpScope - if you wish to dump for the the current process, current thread or entire system

 * @param aDataToDump - data you wish to dump

 * @param aSizeDumped - records how much was dumped

 * @return

 */

TInt SCMonitor::LogObjectContainers(TObjectType aObjectType, SCMDataSave::TDumpScope aDumpScope, const SCMDataSave::TDataToDump& aDataToDump, TUint& aSizeDumped) const

	{

	aSizeDumped = 0;

	if(aObjectType >= ENumObjectTypes)

		{

		return KErrArgument;

		}

	//Get the object container for the given object type

	DObjectCon* objectContainer = Kern::Containers()[aObjectType];

	if(objectContainer == NULL)

		{		

		CLTRACE("tFailed to get object container");

		return KErrNotFound;

		}

	//Must check the mutex on this is ok otherwise the data will be in an inconsistent state

	if(objectContainer->iMutex->iHoldCount)

		{

		CLTRACE("\tObject Container is in an inconsistant state");

		return KErrCorrupt;

		}

	TInt numObjects = objectContainer->Count();

	TInt err = KErrNone;	

	for(TInt cnt = 0; cnt< numObjects; cnt ++)

		{	

		DObject* object = (*objectContainer)[cnt];

		//Are we interested in the object? scope only relevant for thread and process objects, for others, the scope is implicit

		if(aObjectType == EThread)			

			{

			switch(aDumpScope)

				{

				case SCMDataSave::EThreadSpecific :

					{

					//if we are interested in the current thread and this is not it, continue

					if(((DThread*)object) != &Kern::CurrentThread())

						continue;

					break;

					}

				case SCMDataSave::EProcessSpecific :

					{

					//if we are interested in the current proc and this is not it, continue

					if(((DThread*)object)->iOwningProcess != &Kern::CurrentProcess())

						continue;					

					break;

					}

				case SCMDataSave::ESystemWide :

				default: 

					break;

				}

			}

		else if(aObjectType == EProcess)

			{

			switch(aDumpScope)

				{

				case SCMDataSave::EProcessSpecific :

					{

					if((DProcess*)object != &Kern::CurrentProcess())

						continue;

					break;

					}

				case SCMDataSave::EThreadSpecific :  //thread specific process doesnt make sense

					return KErrArgument;				

				case SCMDataSave::ESystemWide :

				default:

					break;

				}

			}

		//Now we look at the data we have been asked to dump

		if(aDataToDump.iMetaData)

			{

			TUint dumped = 0;

			err = HelpDumpMetaData(object, aObjectType, dumped);

			if(KErrNone != err)

				{

				CLTRACE1("Failed to meta data: [%d]", err);

				return err;

				}

			aSizeDumped += dumped;

			}

		if(aDataToDump.iCodeSegs)

			{

			if(aObjectType != EProcess)

				{

				return KErrArgument;

				}

			TUint dumped = 0;

			err = iDataSave->LogCodeSegments((DProcess*)object, dumped);

			if(KErrNone != err)

				{

				CLTRACE1("Failed to log code segments: [%d]", err);

				return err;

				}

			aSizeDumped += dumped;

			}

		if(aDataToDump.iStk != SCMDataSave::EStackTypeNone)

			{

			TUint dumped = 0;

			err = HelpDumpStacks(object, aObjectType, dumped, aDataToDump.iStk);

			if(KErrNone != err)

				{

				CLTRACE1("Failed to log stacks: [%d]", err);

				return err;

				}

			aSizeDumped += dumped;

			}

		if(aDataToDump.iReg != SCMDataSave::ERegSetNone)

			{			

			if(aObjectType != EThread)

				{

				return KErrArgument;

				}

			TUint dumped = 0;

			err = iDataSave->LogRegisters((DThread*)object, aDataToDump.iReg, dumped);	

			if(KErrNone != err && KErrNotSupported !=err)  //we expect to send down a KErrNotSupported when we ask for Full CPU set for the non crashed thread - thats fine

				{

				CLTRACE1("Failed to log registers: [%d]", err);

				return err;

				}

			aSizeDumped += dumped;

			}

		}

	return KErrNone;

	}

/**

 * Helper method for dumping stacks. Looks to see what type of stack we want and then calls

 * appropriate method

 * @param aObject The DThread object whose stack we want

 * @param aObjectType The object type of this aObject. Anything other than EThread will give KErrArgument

 * @param aSizeDumped Holds the size of the stack dumped after processing 

 * @param aStkType The type of stack to be dumped

 * @see TObjectType

 * @see SCMDataSave::TStackType

 * @return One of the system wide codes

 */

TInt SCMonitor::HelpDumpStacks(DObject* aObject, TObjectType aObjectType, TUint& aSizeDumped, SCMDataSave::TStackType aStkType) const

	{

	//verify args

	if(aObjectType != EThread)

		{

		return KErrArgument;

		}

	switch(aStkType)

		{

		case SCMDataSave::EUsrStack:

			{

			return iDataSave->LogThreadUserStack((DThread*)aObject, ETrue, aSizeDumped);

			}

		case SCMDataSave::ESvrStack:

			{

			return iDataSave->LogThreadSupervisorStack((DThread*)aObject, ETrue, aSizeDumped);

			}

		default: return KErrArgument;

		}

	}

/**

 * Helper method to dump meta data about a DThread or a DProcess object

 * @param aObject DObject to use

 * @param aObjectType Type of DObject. Must be EThread or EProcess

 * @param aSizeDumped Holds the size of the stack dumped after processing 

 * @return

 */

TInt SCMonitor::HelpDumpMetaData(DObject* aObject, TObjectType aObjectType, TUint& aSizeDumped) const

	{

	aSizeDumped = 0;

	switch(aObjectType)

		{

		case EThread:

			{

			return iDataSave->LogThreadData((DThread*)aObject, aSizeDumped);	 

			}

		case EProcess:

			{

			return iDataSave->LogProcessData((DProcess*)aObject, aSizeDumped);

			}

		default: return KErrArgument;

		}

	}

/**

 * Wrapper method around the flash erase block fundtion to determine if the erase was succesful.

 * If the erase was not succesful we can't continue as we cannot write.

 * @param aBlockOffset Block to erase

 * @return One of the OS wide codes

 */

TInt SCMonitor::EraseFlashBlock(const SCMCrashBlockEntry& aBlock)

	{	

	iFlash->StartTransaction();

	TInt numAttempts = 0;

	while(numAttempts < KFlashEraseAttempts)

		{

		iFlash->SetWritePos(aBlock.iBlockOffset);

		iFlash->EraseFlashBlock(aBlock.iBlockOffset);

		//we will read the flash to make sure that it set the block to all 1's (well not all, just the start)

		TBuf8<sizeof(TUint32)> buf;

		buf.SetLength(sizeof(TUint32));

		iFlash->SetReadPos(aBlock.iBlockOffset);

		iFlash->Read(buf);

		volatile TUint32* result = (TUint32*)buf.Ptr();

		if(*result == 0xFFFFFFFF)

			{			

			__KTRACE_OPT(KALWAYS, Kern::Printf("Erase of block [0x%X] succesful after [%d] attempts", aBlock.iBlockOffset, numAttempts+1))			

			iFlash->EndTransaction();			

			return KErrNone;

			}

		numAttempts++;

		//Sometimes a write to the block helps the next erase

		TUint32 bytesWritten = 0;		

		while(bytesWritten < aBlock.iBlockSize)

			{

			TBuf8<sizeof(TUint8)> num;

			num.Append(0x0);

			iFlash->Write(num);

			bytesWritten++;

			}

		}		

	__KTRACE_OPT(KALWAYS, Kern::Printf("After %d attempts, we were unable to erase the flash block at [0x%X]. This could be because "

			"the driver is defective or because the flash has gone past its lifetime. Whatever it is though, "

			"we cannot continue.", KFlashEraseAttempts, aBlock.iBlockOffset));