// 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