// 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\crashlogwalker.cpp

 // Class to allow us to traverse the crash log generated by System Crash Monitor

 // 

 //

 /**

  @file

  @internalTechnology

 */

 #ifndef __KERNEL_MODE__

 #include <e32std.h>

 #include <e32std_private.h> 

 #include <e32base.h>

 #include <e32base_private.h> 

 #endif

 #include "scmtrace.h"

 #include "crashlogwalker.h"

 namespace Debug

 	{	

 	/**

 	 * Constructor for log walker

 	 * @param aBuffer The buffer containing the crash data

 	 */

 	TCrashLogWalker::TCrashLogWalker(TDesC8& aBuffer) : 

 		iBuffer(aBuffer),

 		iReader(const_cast<TUint8*>(iBuffer.Ptr()))

 		{

 		}

 	/**

 	 * This reads in the crash header from the buffer from the given start point

 	 * @param aStartPoint Point to begin reading in buffer

 	 * @return One of the OS wide codes

 	 */

 	TInt TCrashLogWalker::ReadLogHeader(const TInt aStartPoint)

 		{		

 		iReader.SetPosition(aStartPoint);

 		TInt err = iCrashHeader.Deserialize(iReader);

 		if(err != KErrNone)

 			{

 			CLTRACE("(TCrashLogWalker::ReadLogHeader) - failed to read crash header");

 			return KErrCorrupt;

 			}

 		err = iOffsets.Deserialize(iReader);

 		if(err != KErrNone)

 			{

 			CLTRACE("(TCrashLogWalker::ReadLogHeader) - failed to read offsets");

 			return KErrCorrupt;

 			}

 		TRegisterSet set;

 		err = set.Deserialize(iReader);

 		if(err != KErrNone)

 			{

 			CLTRACE("(TCrashLogWalker::ReadLogHeader) - failed to read register set");

 			return KErrCorrupt;

 			}

 		for(TInt cnt = 0; cnt < set.iNumRegisters; cnt++)

 			{

 			TRegisterValue val;

 			err = val.Deserialize(iReader);

 			if(err != KErrNone)

 				{

 				CLTRACE1("(TCrashLogWalker::ReadLogHeader) - failed to read TRegisterValue cnt = %d", cnt);

 				return KErrCorrupt;

 				}

 			HelpAssignRegisterToContext(val);

 			}

 		return VerifyHeader();

 		}

 	/**

 	 * Getter for the crash context - This is the CPU register set at the time of crash

 	 * @return Crash Context

 	 */

 	const TRmdArmExcInfo& TCrashLogWalker::GetCrashContext() const

 		{

 		return iContext;

 		}

 	/**

 	 * Returns the crash size for the crash that has just been read, provided the

 	 * reading of the header was succesful. 

 	 * @see ReadLogHeader

 	 * @return Crash Log size

 	 */

 	TInt TCrashLogWalker::GetCrashSize() const

 		{

 		return iCrashHeader.iLogSize;

 		}

 	/**

 	 * Returns the crash ID for the crash that has just been read, provided the

 	 * reading of the header was succesful. 

 	 * @see ReadLogHeader

 	 * @return Crash Log ID

 	 */

 	TInt TCrashLogWalker::GetCrashId() const

 		{

 		return iCrashHeader.iCrashId;

 		}

 	/**

 	 * Looks at the member crash log header and checks that it is valid.

 	 * @see ReadLogHeader 

 	 * @return one of the OS wide codes

 	 */

 	TInt TCrashLogWalker::VerifyHeader()

 		{

 		if(iCrashHeader.iId == ESCMTCrashInfo)

 			{			

 			CLTRACE("TCrashLogWalker::VerifyHeader() OK");

 			return KErrNone;

 			}

 		else

 			{

 			CLTRACE("TCrashLogWalker::VerifyHeader() FAILED");

 			return KErrCorrupt;

 			}

 		}

 	/**

 	 * Updates the buffer being used by the crash walker and resets reader to use 

 	 * the beginning of this

 	 * @param aBuffer New buffer

 	 */

 	void TCrashLogWalker::UpdateBuffer(TDesC8& aBuffer)

 		{

 		iBuffer = aBuffer;		

 		//Read from start of this buffer		

 		iReader = TByteStreamReader(const_cast<TUint8*>(aBuffer.Ptr()));

 		}

 #ifndef __KERNEL_MODE__

 	/**

 	 * Gets the next data type from the buffer. If this is NULL it means the buffer was too small.

 	 * Call again with a larger buffer. It assumes the buffer contains valid data and leaves with KErrCorrupt 

 	 * if it isnt. Note for raw data types, the data will be empty. This should be read with GetRawDataTypeL after reseting the reader to the 

 	 * correct position. If you just want to skip a raw data type, move the buffer along the size of (contained in the returned struct)

 	 * 

 	 * @see GetRawDataTypeL

 	 * @see UpdateBuffer

 	 * @param aPos Next position that will be read. If we return NULL, this is the position the next buffer should

 	 * 			begin from

 	 * @param aId ID of the MByteStreamSerializable returned	 

 	 * @param buffer size to be used the next time. Unchanged if the current buffer is ok

 	 * @return MByteStreamSerializable pointer. Ownership is passed to caller. NULL if failed

 	 * @leave KErrCorrupt if the buffer cant be read

 	 */

 	MByteStreamSerializable* TCrashLogWalker::GetNextDataTypeL(TInt& aPos, SCMStructId& aId, TInt& aBufferSize)

 		{

 		MByteStreamSerializable* data = NULL;

 		TInt roomInBuffer = iBuffer.Length() - iReader.CurrentPosition();

 		//make sure we have at LEAST 4 bytes in the buffer

 		if(roomInBuffer < (TInt)(sizeof(TInt)))

 			{

 			aBufferSize = sizeof(TInt);

 			return NULL;

 			}

 		//this stores the required size in which to deserialize a structure - to make sure 

 		//there is room in the buffer

 		TInt maxSize = 0;

 		aPos = iReader.CurrentPosition();

 		aBufferSize = iBuffer.Length();		

 		//all these data types are defined by their first byte

 		aId = (SCMStructId)iBuffer.Ptr()[iReader.CurrentPosition()];		

 		//ensure we have a valid structure found

 		if(aId <= 0 || aId >= ESCMLast)

 			{

 			//oddness is afoot and the mist of corruption reigns thick

 			User::Leave(KErrCorrupt);

 			}					

 		switch(aId)

 			{

 			case ESCMOffsetsHeader:

 				{

 				data = new TCrashOffsetsHeader();	

 				maxSize = TCrashOffsetsHeader::KSCMCrashOffsetsMaxSize;

 				break;

 				}

 			case ESCMTCrashInfo:

 				{

 				data = new TCrashInfoHeader();

 				maxSize = TCrashInfoHeader::KSCMCrashInfoMaxSize;

 				break;

 				}

 			case ESCMProcessData:

 				{

 				data = new TProcessData();

 				maxSize = TProcessData::KSCMProcessDataMaxSize;

 				break;

 				}

 			case ESCMThreadData:

 				{

 				data = new TThreadData();

 				maxSize = TThreadData::KSCMThreadDataMaxSize;

 				break;

 				}

 			case ESCMThreadStack:

 				{

 				data = new TThreadStack();

 				maxSize = TThreadStack::KSCMThreadStackMaxSize;

 				break;

 				}

 			case ESCMRegisterValue:

 				{

 				data = new TRegisterValue();

 				maxSize = TRegisterValue::KSCMRegisterValueMaxSize;

 				break;

 				}

 			case ESCMRegisterSet:

 				{

 				data = new TRegisterSet();

 				maxSize = TRegisterSet::KSCMRegisterSetMaxSize;

 				break;

 				}

 			case ESCMMemory:

 				{

 				data = new TMemoryDump();

 				maxSize = TMemoryDump::KSCMMemDumpMaxSize;

 				break;

 				}

 			case ESCMCodeSegSet:

 				{

 				data = new TCodeSegmentSet();

 				maxSize = TCodeSegmentSet::KSCMCodeSegSetMaxSize;

 				break;

 				}

 			case ESCMCodeSeg:

 				{

 				data = new TCodeSegment();

 				maxSize = TCodeSegment::KMaxSegmentNameSize;

 				break;

 				}	

 			case ESCMLocks:

 				{

 				data = new TSCMLockData();

 				maxSize = TSCMLockData::KSCMLockDataMaxSize;	

 				break;

 				}

 			case ESCMVariantData:

 				{

 				data = new TVariantSpecificData();

 				maxSize = TVariantSpecificData::KSCMVarSpecMaxSize;	

 				break;

 				}				

 			case ESCMRomHeader:

 				{

 				data = new TRomHeaderData();

 				maxSize = TRomHeaderData::KSCMRomHdrMaxSize;	

 				break;

 				}				

 			case ESCMRawData:

 				{

 				data = new TRawData();

 				//This is a special case. The data in here can be any length, so we need to deserialise it

 				//to find this length out. The MAX_SIZE of this class is the max size minus data

 				//which is fine if we dont assign the TPtr8.				

 				if(TRawData::KSCMRawDataMaxSize > roomInBuffer )

 					{					

 					aBufferSize = (maxSize > aBufferSize) ? maxSize : aBufferSize;

 					if(data)

 						delete data;

 					return NULL;

 					}

 				else

 					{

 					data->Deserialize(iReader);

 					maxSize = data->GetSize();

 					aPos = iReader.CurrentPosition();

 					return data;

 					}

 				}

 			case ESCMTraceData:

 				{

 				data = new TTraceDump();

 				maxSize = TTraceDump::KSCMTraceDumpMaxSize;

 				break;

 				}

 			default :

 				{

 				User::Panic(_L("Unexpected Null. Unrecognised Data type from crash log."), KErrGeneral); //Programming error				

 				}							

 			}

 		__ASSERT_ALWAYS((data != NULL), User::Panic(_L("Unexpected Null"), KErrGeneral));

 		if(maxSize > roomInBuffer )

 			{

 			//Not enough room in buffer to read this. Tell caller where in the current buffer

 			//we were via aPos, and what minimum size buffer should be used next time to allow reading

 			aBufferSize = maxSize;

 			if(data)

 				{

 				delete data;

 				}

 			return NULL;

 			}

 		if(!data)

 			{

 			CLTRACE("Unable to create data structure");

 			User::Leave(KErrAbort);

 			}

 		data->Deserialize(iReader);			

 		aPos = iReader.CurrentPosition();

 		return data;

 		}

 	/**

 	 * Assuming the next type in the buffer is a TRawData type, this will return the TRawData

 	 * types data pointer pointing to the buffer passed via aRawBuf.

 	 *  

 	 * The difference between this call and GetNextDataTypeL is that GetNextDataTypeL only lets you move along the buffer

 	 * it doesnt allow you to specify a buffer in which to store the raw data.

 	 * 

 	 * @see GetNextDataTypeL

 	 * @return TRawData* This is the TRawData object that holds the data via the buffer passed in. Ownership is passed to the caller

 	 * @param aPos position in buffer its been found. If we return NULL, this is the position the next buffer should

 	 * 			begin from

 	 * @param aBufferSize Should we return NULL, that means the descriptor passed in was not big enough and should be of at least aBufferSize bytes

 	 * @param aRawBuf The buffer to store the data refered to by the TRawData returned

 	 * @param aStartRawPosition The point in the raw data at which we will start to put it into the buffer

 	 * @leave One of the OS wide codes

 	 */

 	TRawData* TCrashLogWalker::GetRawDataTypeL(TInt& aPos, TInt& aBufferSize, TDes8& aRawBuf, TInt aStartRawPosition)

 		{								

 		//make sure we have at LEAST the size of the struct in the buffer

 		if(iBuffer.Length() < TRawData::KSCMRawDataMaxSize)

 			{

 			aBufferSize = TRawData::KSCMRawDataMaxSize;

 			return NULL;

 			}

 		//this stores the required size in which to deserialize a structure - to make sure 

 		//there is room in the buffer

 		aPos = iReader.CurrentPosition();

 		aBufferSize = iBuffer.Length();

 		//all these data types are defined by their first byte

 		TInt id = (SCMStructId)iBuffer.Ptr()[iReader.CurrentPosition()];

 		if(id != ESCMRawData)

 			{

 			User::Leave(KErrCorrupt);

 			}		

 		//Deserialise once to get the length (this will ignore the data in the absence of a Tptr)

 		TRawData* data = new TRawData();

 		data->Deserialize(iReader);

 		//reset reader to where the raw data starts again

 		iReader.SetPosition(aPos);

 		//now we know we have room, deserialize into this descriptor	

 		aRawBuf.SetMax();	

 		data->iData.Set(aRawBuf.MidTPtr(0));

 		User::LeaveIfError(data->Deserialize(aStartRawPosition, iReader));

 		return data;

 		}

 #endif

 	/**

 	 * This is a helper function to convert between the two formats of register

 	 * @param aRegVal Resulting register values

 	 */

 	void TCrashLogWalker::HelpAssignRegisterToContext(const TRegisterValue& aRegVal)

 		{

 		//only interested in core registers at the moment

 		if(aRegVal.iClass != 0 || aRegVal.iSize != 2)

 			{

 			return;

 			}

 		//Is there a cleverer way to do this with bitmasks and FOFF ?

 		switch(aRegVal.iType)

 			{

 			case 0x0 :

 				{

 				iContext.iR0 = aRegVal.iValue32;

 				break;

 				}

 			case 0x100 :

 				{

 				iContext.iR1 = aRegVal.iValue32;

 				break;

 				}

 			case 0x200 :

 				{

 				iContext.iR2 = aRegVal.iValue32;

 				break;

 				}

 			case 0x300 :

 				{

 				iContext.iR3 = aRegVal.iValue32;

 				break;

 				}

 			case 0x400 :

 				{

 				iContext.iR4 = aRegVal.iValue32;

 				break;

 				}

 			case 0x500 :

 				{

 				iContext.iR5 = aRegVal.iValue32;

 				break;

 				}

 			case 0x600 :

 				{

 				iContext.iR6 = aRegVal.iValue32;

 				break;

 				}

 			case 0x700 :

 				{

 				iContext.iR7 = aRegVal.iValue32;

 				break;

 				}

 			case 0x800 :

 				{

 				iContext.iR8 = aRegVal.iValue32;

 				break;

 				}

 			case 0x900 :

 				{

 				iContext.iR9 = aRegVal.iValue32;

 				break;

 				}

 			case 0xa00 :

 				{

 				iContext.iR10 = aRegVal.iValue32;

 				break;

 				}

 			case 0xb00 :

 				{

 				iContext.iR11 = aRegVal.iValue32;

 				break;

 				}

 			case 0xc00 :

 				{

 				iContext.iR12 = aRegVal.iValue32;

 				break;

 				}

 			case 0xd00 :

 				{

 				iContext.iR13 = aRegVal.iValue32;				

 				break;

 				}

 			case 0xe00 :

 				{

 				iContext.iR14 = aRegVal.iValue32;

 				break;

 				}

 			case 0xf00 :

 				{

 				iContext.iR15 = aRegVal.iValue32;

 				break;

 				}

 			case 0x1000 :

 				{

 				iContext.iCpsr = aRegVal.iValue32;

 				break;

 				}

 			case 0x1100 :

 				{

 				iContext.iR13Svc = aRegVal.iValue32;

 				break;

 				}

 			case 0x1200 :

 				{

 				iContext.iR14Svc = aRegVal.iValue32;

 				break;

 				}

 			default :

 				{

 				return;

 				}				

 			}

 		}

 	/**

 	 * Getter for crash header

 	 * @return header

 	 */

 	const TCrashInfoHeader& TCrashLogWalker::GetCrashHeader() const

 		{

 		return iCrashHeader;

 		}

 	/**

 	 * Getter for crash offsets header

 	 * @return header

 	 */

 	const TCrashOffsetsHeader& TCrashLogWalker::GetOffsetsHeader() const

 		{

 		return iOffsets;

 		}			

 	}

 //eof