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

//

#include <e32debug.h>

#include <d32btrace.h>

#include <crashlogwalker.h>

#include <optionconfig.h>

#include "flashdatasource.h"

// Required for interface to Debug Security Server via RSecuritySvrSession

#include "coredumpsession.h"

using namespace Debug;

CFlashDataSource::CFlashDataSource(RSecuritySvrSession &aSource) :

	iSecSess(aSource),

	iLockData(NULL),

	iRomBuildInfo(NULL),

	iTraceDump(NULL),

	iVarSpecData(NULL),

    iWalker(iFlashBuf),

	iScmConfig(NULL),

	iCrashFound(EFalse)

	{

	//no implementation

	}

/**

 * This looks at the crash logs header and keeps note of where all the different types of data reside

 * @return one of the OS wide system codes

 */

TInt CFlashDataSource::ProcessCrashHeaderL(TInt aCrashStart)

	{

	LOG_MSG("CFlashDataSource::ProcessCrashHeader()");

	//record where the crash started

	TInt iCrashStart = aCrashStart;

	User::LeaveIfError(ReadCrashLog(iCrashStart, Debug::KMaxCoreHeaderSize));

	User::LeaveIfError(iWalker.ReadLogHeader(0));

	iHdr = iWalker.GetCrashHeader();

	iOffsetsHdr = iWalker.GetOffsetsHeader();

	if(iOffsetsHdr.iId == ESCMOffsetsHeader)

		{

		iOffsetsPresent = ETrue;

		}

	return KErrNone;

	}

/**

 * attempts to read the scm config block from start of flash to see if its there

 * @return The configuration block if found. Check for NULL and ownership is passed to caller

 */

SCMConfiguration* CFlashDataSource::GetSCMConfigFromFlashL()

	{

	LOG_MSG("CFlashDataSource::GetSCMConfigFromFlashL()");

	//Always at start of flash

	TInt scmLocation = 0;

	Debug::SCMConfiguration* config = new Debug::SCMConfiguration();

	CleanupStack::PushL(config);

	User::LeaveIfError(ReadCrashLog(scmLocation, SCMConfiguration::KScmConfigMaxSize));

	CleanupStack::Pop();	

	//Put a reader on the buffer

	TByteStreamReader rdr(const_cast<TUint8*>(iFlashBuf.Ptr()));

	if(config->Deserialize(rdr) == KErrNone)

		{

		LOG_MSG3("CFlashDataSource::GetSCMConfigFromFlashL()  Config found. It is [%d] [0x%X] bytes in size",

					config->GetSize(), config->GetSize());

		LOG_MSG("CFlashDataSource::GetSCMConfigFromFlashL() #2");

		return config;

		}

	else

		{

		LOG_MSG("CFlashDataSource::GetSCMConfigFromFlashL() No config found");

		delete config;

		return NULL;

		}

	}

/**

 * This looks at the entire log partition looking for where the crash of this ID

 * begins

 * @param aCrashId ID we are looking for

 * @return TInt where crash starts

 * @leave One of the OS wide codes

 */

TInt CFlashDataSource::GetCrashStartFromCrashIDL(TInt aCrashId)

	{

	LOG_MSG2("CFlashDataSource::GetCrashStartFromCrashIDL(TInt aCrashId)	 ID = %d", aCrashId);

	TInt crashStart = 0;

	TInt readStatus = KErrNone;

	//Start looking where the config ends if it exists

	Debug::SCMConfiguration* config = GetSCMConfigFromFlashL();

	if(config)

		{

		crashStart = config->GetSize();

		}

	delete config;

	while(readStatus == KErrNone)

		{

		User::LeaveIfError(ReadCrashLog(crashStart, Debug::KMaxCoreHeaderSize));

		readStatus = iWalker.ReadLogHeader(0); //Look at header from start of buffer

		if(readStatus != KErrNone)

			{

			CLTRACE("CFlashDataSource::GetCrashStartFromCrashIDL ReadCrashLogL leaving with KErrNotFound #1");

			User::Leave(KErrNotFound);

			}

		else if(iWalker.GetCrashHeader().iCrashId == aCrashId)

			{

			return crashStart;

			}

		const TCrashInfoHeader currentHdr = iWalker.GetCrashHeader();

		TUint32 flashPadding = currentHdr.iFlashBlockSize - (crashStart + currentHdr.iLogSize)%currentHdr.iFlashBlockSize;

		crashStart += (currentHdr.iLogSize + flashPadding);

		}

	CLTRACE("CFlashDataSource::GetCrashStartFromCrashIDL ReadCrashLogL leaving with KErrNotFound #2");

	User::Leave(KErrNotFound);

	return 0;  //avoid comp warnings

	}

/**

 * This walks the crash log verifying it is not corrupt and builds up a map of the log so that we can get the

 * data required faster later on when the appropriate call is made.

 * @param Crash ID to look at

 * @leave One of the system wide error codes

 */

void CFlashDataSource::AnalyseCrashL(TInt aCrashId)

	{

	LOG_MSG2("CFlashDataSource::AnalyseCrashL(TInt aCrashId = [%d])", aCrashId);

	//Reset the state

	iOffsetsPresent = EFalse;

	iCrashMemoryMap.Reset();

	iCodeSegMap.Reset();

	iHdrProcd = EFalse;

    if(iCurrentCodeSegSet)

    	{

		delete iCurrentCodeSegSet;

		iCurrentCodeSegSet = NULL;

    	}

    if(iLockData)

    	{

    	delete iLockData;

    	iLockData = NULL;

    	}

    if(iRomBuildInfo)

    	{

    	delete iRomBuildInfo;

    	iRomBuildInfo = NULL;

    	}

	TInt crashStart = GetCrashStartFromCrashIDL(aCrashId);

	ProcessCrashHeaderL(crashStart);

	TInt dataSizeRead = 0;

	TInt flashPos = crashStart;

	//either read the defined amt or the log size, whichever is less

	TInt rdSize = READ_SIZE;

	/**

	 *	Our conditions to keep reading  or decide log is corrupt are:

	 *	1. Have we read logSize bytes?

	 *			No - Keep Going

	 *			Yes - Finished

	 *			More - Corrupt

	 *  2. There is no more data of interest to be read. Is the number of bytes read = log size?

	 */

	TInt recommendedReadSize = 0;

	while(dataSizeRead != iHdr.iLogSize)

		{

		//We need to decide how much to read here. It is possible that we need to read greater than the log size

		//as the reader can't know in advance the exact size of a struct, so it has to assume the worst case scenario

		//of the largest size it could be

		rdSize = (rdSize < READ_SIZE) ? READ_SIZE : rdSize;	//resize this to be large

		TInt bytesRemaining = iHdr.iLogSize - dataSizeRead;

		if(rdSize > bytesRemaining)

			{

			rdSize = bytesRemaining;

			}

		//always be at least the rec read size

		rdSize = (rdSize < recommendedReadSize) ? recommendedReadSize : rdSize;

		User::LeaveIfError(ReadCrashLog(flashPos, rdSize));

		//Get what we can out of this buffer read

		SCMStructId id = ESCMFirst;

		TInt bufferPos = 0;

		MByteStreamSerializable* data = NULL;

		do

			{

			//Have we got to end of crash?

			if(dataSizeRead == iHdr.iLogSize)

				{

				break;

				}

			data = iWalker.GetNextDataTypeL(bufferPos, id, recommendedReadSize);

			//Analyse what we got

			if(data)

				{

				CleanupStack::PushL(data);

				dataSizeRead += data->GetSize();

				//check we are within range

				if(dataSizeRead > iHdr.iLogSize)

					{

					LOG_MSG4("CFlashDataSource::AnalyseCrashL: Corrupt -->    dataSizeRead [%d] > iHdr.iLogSize [%d] at line [%d]", dataSizeRead, iHdr.iLogSize, __LINE__);

					User::Leave(KErrCorrupt);

					}

				HelpAnalyseCrashL(data, id, flashPos + bufferPos - data->GetSize());

				CleanupStack::PopAndDestroy(data);

				}

			else

				{

				//if data was NULL, that means there wasnt enough room in the buffer to read the next one

				flashPos += bufferPos;

				}

			}

		while(data);

		}

	}

/**

 * Helper for crash analysis. Takes a pointer to a data type, an ID to tell us what type it is, and where

 * in the flash it has been found. If it is a type of interest, we record its position

 * @param aData Data Type of interest

 * @param aStructId ID to describe data type

 * @param aPosFound Where it was found in the flash

 * @leave

 */

void CFlashDataSource::HelpAnalyseCrashL(const MByteStreamSerializable* aData, TInt aStructId, TInt aPosFound)

	{

	switch(aStructId)

		{

		case ESCMMemory :

			{

			//we want to keep track of this objects

			TObjectLocation map;

			map.iOffset = aPosFound;

			map.iObjectId = static_cast<const TMemoryDump*>(aData)->iPid;

			iCrashMemoryMap.AppendL(map);

			break;

			}

		case ESCMCodeSegSet :

			{

			//The set contains the PID for the code segs to follow - copy to our cached version

			if(iCurrentCodeSegSet)

				{

				delete iCurrentCodeSegSet;

				iCurrentCodeSegSet = NULL;

				}

			iCurrentCodeSegSet = new TCodeSegmentSet();

			*iCurrentCodeSegSet = *(static_cast<const TCodeSegmentSet*>(aData));

			break;

			}

		case ESCMCodeSeg :

			{

			//ensure we have a code segment set for this

			__ASSERT_ALWAYS(iCurrentCodeSegSet, User::Leave(KErrCorrupt));

			//we want to keep track of these objects

			TObjectLocation map;

			map.iOffset = aPosFound;

			map.iObjectId = iCurrentCodeSegSet->iPid;

			iCodeSegMap.AppendL(map);

			break;

			}

		case ESCMRomHeader :

			{

			if(iRomBuildInfo)

				{

				delete iRomBuildInfo;

				iRomBuildInfo = NULL;

				}

			iRomBuildInfo = new TRomHeaderData();

			*iRomBuildInfo = *(static_cast<const TRomHeaderData*>(aData));

			break;

			}

		case ESCMLocks:

			{

			if(iLockData)

				{

				delete iLockData;

				iLockData = NULL;

				}

			iLockData = new TSCMLockData();

			*iLockData = *(static_cast<const TSCMLockData*>(aData));

			break;

			}

		case ESCMTCrashInfo :

			{

			iHeaderStart = aPosFound;

			break;

			}

		case ESCMTraceData :

			{

			if(iTraceDump)

				{

				delete iTraceDump;

				iTraceDump = NULL;

				}

			iTraceDump = new TTraceDump();

			*iTraceDump = *(static_cast<const TTraceDump*>(aData));

			break;

			}

		case ESCMVariantData:

			{

			if(iVarSpecData)

				{

				delete iVarSpecData;

				iVarSpecData = NULL;

				}

			iVarSpecData = new TVariantSpecificData();

			*iVarSpecData = *(static_cast<const TVariantSpecificData*>(aData));

			break;

			}

		case ESCMOffsetsHeader :

		case ESCMProcessData :

		case ESCMThreadData :

		case ESCMThreadStack :

		case ESCMRegisterValue :

		case ESCMRegisterSet :

		case ESCMRawData :

			{

			//No problem if we arent interested in the object, carry on, nothing to see here

			break;

			}

		default :

			{

			LOG_MSG2("CFlashDataSource::HelpAnalyseCrashL --> Dont recognise struct ID = [%d] therefore corrupt", aStructId);

			//if we dont recognise the object, then oddness is afoot and the mist of corruption reigns thick

			User::Leave(KErrCorrupt);

			}

		}

	}

/**

 * This Reads the portion of the crash log of interest into our buffer for processing later

 *

 * @param aPos Position of crash log to begin reading

 * @param aSize amount of data to read

 * @return KErrArgument if aSize exceeds the maximum read allowed or one of the other OS wide codes

 */

TInt CFlashDataSource::ReadCrashLog(const TInt aPos, const TUint aSize)

	{

	//ensure parameters are ok

	if(aPos < 0)

		{

		return KErrArgument;

		}

	TInt err = ReallocFlashBuf(aSize);

	if(err != KErrNone)

		{

		return err;

		}

	iWalker.UpdateBuffer(iFlashBuf);

	iFlashBuf.Zero();

	//Read the data from the flash buffer

	return iSecSess.ReadCrashLog(aPos, iFlashBuf, aSize);

	}

/**

 * Two Phase Constructor for CFlashDataSource

 * @param aSource Reference to Security Server session

 * @return Pointer to new CFlashDataSource object

 * @leave

 */

CFlashDataSource* CFlashDataSource::NewL(RSecuritySvrSession &aSource)

{

    CFlashDataSource *self = new(ELeave) CFlashDataSource(aSource);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

/**

 * second-phase constructor

 */

void CFlashDataSource::ConstructL()

    {

    //Create flash buffer. Will be resized as required

    iFlashBuf.CreateL(KInitialBufferSize);

    iFlashBuf.FillZ();

	iScmConfig = new (ELeave) Debug::SCMConfiguration();

	iScmConfig->SetDefaultConfig();

    }

/**

 * Destructor

 */

CFlashDataSource::~CFlashDataSource()

    {

	LOG_MSG( "server_crashdatasource.cpp::CFlashDataSource::~CFlashDataSource()\n" );

	iFlashBuf.Close();

	iFirstBlockBuf.Close();

	iCodeSegMap.Close();

	iCrashMemoryMap.Close();

	iThreadOwners.Close();

	if(iScmConfig)

		{

		delete iScmConfig;

		iScmConfig = NULL;

		}

	if(iCurrentCodeSegSet)

		{

		delete iCurrentCodeSegSet;

		iCurrentCodeSegSet = NULL;

		}

	if(iLockData)

		{

		delete iLockData;

		iLockData = NULL;

		}

	if(iRomBuildInfo)

		{

		delete iRomBuildInfo;

		iRomBuildInfo = NULL;

		}

	if(iTraceDump)

		{

		delete iTraceDump;

		iTraceDump = NULL;

		}

	if(iVarSpecData)

		{

		delete iVarSpecData;

		iVarSpecData = NULL;

		}

    }

void CFlashDataSource::GetRegisterListL( RRegisterList & aRegisterList )

	{

	//Not used

	User::Leave(KErrNotSupported);

	}

/**

 * Reads registers from flash for a given thread

 * @param aThreadId Thread of interest

 * @param aRegisterList Appends any registers found to this list

 * @leave OS wide code

 */

void CFlashDataSource::ReadRegistersL( const TUint64 aThreadId, RRegisterList  & aRegisterList )

	{

    LOG_MSG("CFlashDataSource::ReadRegistersL()");

	// Delete any objects in the array, since we will replace them.

	aRegisterList.Reset();

    /**

     * We keep 3 sets of registers in the flash at different points.

     * The first is the FullCPU register set for the thread that has crashed.

     * The second are the supervisor registers for a given thread (may not all be available)

     * The third are the user registers for a given thread (may not all be available)

     * These corrospond to 3 different configuration options

     */