// 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\include\kernel\scmdatasave.h

// Kernel System crash data save header file

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without notice. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

#ifndef SCMDATASAVE_H

#define SCMDATASAVE_H

/**

 @file

 @internalComponent

 */

#include <plat_priv.h>

#include <kernel/monitor.h>

#include <e32des8.h>	

#include <arm.h>

#include <crashflash.h>

#include <scmdatatypes.h>

#include <scmbytestreamutil.h>

#include <scmconfig.h>

using namespace Debug;

IMPORT_C TInt64 CrashTime();

_LIT8(KKernelHeapChunkName, "ekern.exe::SvHeap");

/**

 * This class handles gathering of the kernel data and writing it to flash

 * 

 */

class SCMDataSave : MPhysicalWriterImpl

	{	

	public:	

	    enum TRegisterSetType

	        {

	        EUserRegisters = 0,

	        ESupervisorRegisters = 1,

	        EFullCPURegisters = 2,

	        ERegSetNone = 3,

	        ERegLast

	        }; 

	    enum TStackType

	    	{

	    	EUsrStack = 0,

	    	ESvrStack = 1,

	    	EStackTypeNone = 2,

	    	EStackLast

	    	};

	    enum TDumpScope

	    	{

	    	EThreadSpecific = 0,

	    	EProcessSpecific = 1,

	    	ESystemWide = 2,

	    	EDumpLast

	    	};

	    /**

	     * This structure defines the type of data we wish to dump for a given kernel object

	     */

	    struct TDataToDump

	    	{

	    	TBool iMetaData;   		/**< Dump meta data about object */

	    	TBool iCodeSegs;   		/**< Dump DProcess code segs (ignored for other objects) */

	    	TStackType iStk;   		/**< Dump this stack type */

	    	TRegisterSetType iReg;  /**< Dump this register set */

	    	TDataToDump()

	    		{

	    		//upon construction, nothing is set to be dumped

	    		iMetaData = EFalse;

	    		iCodeSegs = EFalse;

	    		iStk = EStackTypeNone;

	    		iReg = ERegSetNone;

	    		}

	    	};

		enum TWriteSelect

			{ 

			EWriteFlash = 0, /**< write data to flash */

			EWriteComm =1,   /**< write data to comm port */

			ELast

			};

	public:

		IMPORT_C SCMDataSave(Monitor* aMonitor, CrashFlash* aFlash);

		virtual ~SCMDataSave();

		TInt LogCrashHeader(const TDesC8& aCategory, TInt aReason, TInt aCrashId, TUint& aSizeDumped);

		TInt LogThreadData(DThread* aThread, TUint& aSizeDumped);

		TInt LogProcessData(DProcess* aProcess, TUint& aSizeDumped);

		TInt LogCodeSegments(DProcess* aProcess, TUint& aSizeDumped);

		TInt LogThreadUserStack(DThread* aThread, TBool aFullStack, TUint& aSizeDumped);

		TInt LogThreadSupervisorStack(DThread* aThread, TBool aFullStack, TUint& aSizeDumped);		

		TInt LogRegisters(DThread* aThread, const TRegisterSetType& aRegType, TUint& aSizeDumped);	

		TInt LogCPURegisters(TUint& aSizeDumped);

		TInt ReadUserRegisters(DThread* aThread, TArmRegSet& aRegs, TUint32& aAvailableRegs);

		TInt ReadSystemRegisters(DThread* aThread, TArmRegSet& aRegs, TUint32& aAvailableRegs);

		void ReadCPURegisters(SFullArmRegSet& aRegs);

		TInt LogMemory(const TUint8* aStartAddress, TInt aLength, const DThread* aThread, TUint& aSizeDumped);	

		TInt LogExceptionStacks(TUint& aSizeDumped);	

		TInt LogTraceBuffer(TInt aSizeToDump, TUint& aSizeDumped);

		TInt LogLocks(TUint& aSizeDumped);		

		TInt LogRawData(const TDesC8& aData, TUint& aSizeDumped);

		TInt LogVariantSpecificData(TUint& aSizeDumped);

		TInt LogRomInfo(TUint& aSizeDumped);

		TInt LogKernelHeap(TUint& aSizeDumped);		

		TInt FindKernelHeap(TInt32& aHeapLocation, TInt32& aHeapSize);

		TInt LogConfig(SCMConfiguration& aConfig);

		TInt ReadConfig(SCMConfiguration& aScmConfig);

		void Write(const TAny* aSomething, TInt aSize);

		static void WriteUart(const TUint8* aData, TInt aSize);			

		static void WriteUart(const TDesC8& aDes);

		virtual void DoPhysicalWrite(TAny* aData, TInt aPos, TInt aLen);

		void WriteCrashFlash(TInt aPos, TInt& aSize, const TDesC8& aBuffer);

		TInt GetRegisterType(const TRegisterSetType& aSetType, TInt32& aRegNumber, TUint32& aRegisterType);

		TInt GetByteCount();

		void SetByteCount(TInt aByte);

		TWriteSelect GetWriteSelect();

		void SetWriteSelect(TWriteSelect aWriteSelect);

		TUint SpaceRemaining();

		TUint MaxLogSize();

		void SetCrashStartingPoint(TUint32 aStart);

		TUint32 GetCrashStartingPoint() {return iStartingPointForCrash;}

	public:

		/** Offsets header to assist parsing */		

		TCrashOffsetsHeader 	iHdr;		  	

		/** Basic crash info */

		TCrashInfoHeader		iCrashInf;   	

		/** Writer for physical writing */

		TCachedByteStreamWriter* iWriter;		

	private:				

		Monitor* iMonitor; //need to use this to map memory and things like that

		CrashFlash* iFlash;

		TTraceDump iTrace;

		TInt iByteCount;

		//This is a pointer to memory on the heap we can use that is the same size as iFlash.GetFlashBlockSize()

		HBuf8* iFlashCache;

		TWriteSelect iWriteSelect;

		TBool iPerformChecksum;

		TScmChecksum iChecksum;	

		TUint32 iStartingPointForCrash;	

	};

#endif /*SCMDATASAVE_H*/