// 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));
	
	iFlash->EndTransaction();
	return KErrAbort;
	}

/**
 * This erases each block in the flash partition
 * @return One of the system wide codes
 */
TInt SCMonitor::EraseEntireFlashPartition()
	{
	if(iMultiCrashInfo)
		{
		iMultiCrashInfo->Reset();
		
		SCMCrashBlockEntry* block = iMultiCrashInfo->GetNextBlock();
		while(block)
			{
			TInt err = EraseFlashBlock(*block);
			if(KErrNone != err)
				{
				return err;
				}
			
			block = iMultiCrashInfo->GetNextBlock();
			}
		
		return KErrNone;
		}
	
	CLTRACE("SCMonitor::EraseEntireFlashPartition() -- No Flash MAP available, trying to use the raw driver to delete.");
	TheSCMonitor.iFlash->EraseLogArea();
	
	return KErrNone;
	}

//eof scmonitor.cpp