--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dbgsrv/coredumpserver/plugins/formatters/test/testcrashdatasource.cpp Tue Mar 02 10:33:16 2010 +0530
@@ -0,0 +1,462 @@
+// Copyright (c) 2007-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 <rm_debug_api.h>
+#include "testcrashdatasource.h"
+#include <debuglogging.h>
+
+CTestCrashDataSource::CTestCrashDataSource( )
+ {
+ RDebug::Printf( "test_crashdatasource.cpp::CTestCrashDataSource::CTestCrashDataSource()\n" );
+ }
+
+
+// second-phase constructor
+void CTestCrashDataSource::ConstructL()
+ {
+ RDebug::Printf( "test_crashdatasource.cpp::CTestCrashDataSource::ConstructL()\n" );
+ }
+
+
+// destructor
+CTestCrashDataSource::~CTestCrashDataSource()
+ {
+ RDebug::Printf( "test_crashdatasource.cpp::CTestCrashDataSource::~CTestCrashDataSource()\n" );
+ }
+
+
+
+TInt CTestCrashDataSource::SetSimRegValues( const TUint32 aThreadId,
+ RRegisterList & aRegisterList )
+ {
+
+ RDebug::Print( _L("CTestCrashDataSource::SetSimRegValues()\n") );
+
+ if( aRegisterList.Count() > 0 )
+ {
+
+ TUint8 val8 = (TUint8)(KRegValue8 + aThreadId);
+ TUint16 val16 = (TUint16)(KRegValue16 + aThreadId);
+ TUint32 val32 = (TUint32)(KRegValue32 + aThreadId);
+ TUint64 val64 = (TUint64)(MAKE_TUINT64(0xFEDCBA98u,0x76543210u) + aThreadId);
+
+ for( TInt i = 0; i < aRegisterList.Count(); i ++ )
+ {
+
+ TRegisterData & reg = aRegisterList[i];
+
+ switch ( reg.iSize )
+ {
+ case 0:
+ reg.iValue8 = val8 + i;
+ RDebug::Printf( " Setting reg[%d] iValue8=0x%X\n", i, reg.iValue8 );
+ break;
+ case 1:
+ reg.iValue16 = val16+ i;
+ RDebug::Printf( " Setting reg[%d] iValue16=0x%X\n", i, reg.iValue16 );
+ break;
+ case 2:
+ reg.iValue32 = val32+ i;
+ RDebug::Printf( " Setting reg[%d] iValue32=0x%X\n", i, reg.iValue32 );
+ break;
+ case 3:
+ reg.iValue64 = val64+ i;
+ RDebug::Printf( " Setting reg[%d]=0x%X%X\n", i,
+ I64HIGH(reg.iValue64), I64LOW(reg.iValue64) );
+ break;
+ }
+
+ //reg.iAvailable = i%8 ? ETrue : EFalse;
+ /*
+ if ( 0 == ((i+1) % 8) )
+ {
+ RDebug::Printf( " setting reg[%d] as not available\n", i );
+ reg.iAvailable = EFalse;
+ }
+ */
+ }
+
+ return KErrNone;
+
+ }
+
+ return KErrBadHandle;
+
+ }
+
+
+void CTestCrashDataSource::PrintRegs( RRegisterList & aRegisterList )
+ {
+ RDebug::Printf( "CTestCrashDataSource::PrintRegs()\n" );
+
+ if( aRegisterList.Count() > 0 )
+ {
+ for( TInt i = 0; i < aRegisterList.Count(); i ++ )
+ {
+ TRegisterData & reg = aRegisterList[i];
+
+ RDebug::Printf( " reg[%d] iRegClass=%d, iId=%d, iSubId=%d, iSize=%d, iAvailable=",
+ i, reg.iRegClass, reg.iId, reg.iSubId, reg.iSize );
+ if(reg.iAvailable)
+ RDebug::Printf( "ETrue\n" );
+ else
+ RDebug::Printf( "EFalse\n" );
+
+ switch ( reg.iSize )
+ {
+ case 0:
+ RDebug::Printf( " iValue8=0x%X\n", reg.iValue8 ); break;
+ case 1:
+ RDebug::Printf( " iValue16=0x%X\n", reg.iValue16 ); break;
+ case 2:
+ RDebug::Printf( " iValue32=0x%X\n", reg.iValue32 ); break;
+ case 3:
+ RDebug::Printf( " iValue64=0x%X%X\n",
+ I64HIGH(reg.iValue64), I64LOW(reg.iValue64) );
+ break;
+ }
+ }
+ }
+ else
+ {
+ RDebug::Printf( " No registers to print\n" );
+ }
+ }
+
+
+void CTestCrashDataSource::GetRegisterListL( RRegisterList & aRegisterList )
+{
+
+ LOG_MSG("CTestCrashDataSource::GetRegisterListL()\n");
+
+ TFunctionalityRegister ids[] = {ERegisterR0,
+ ERegisterR1,
+ ERegisterR2,
+ ERegisterR3,
+ ERegisterR4,
+ ERegisterR5,
+ ERegisterR6,
+ ERegisterR7,
+ ERegisterR8,
+ ERegisterR9,
+ ERegisterR10,
+ ERegisterR11,
+ ERegisterR12,
+ ERegisterR13,
+ ERegisterR14,
+ ERegisterR15,
+ ERegisterCpsr,
+ ERegisterR13Svc,
+ ERegisterR14Svc,
+ ERegisterSpsrSvc,
+ ERegisterR13Abt,
+ ERegisterR14Abt,
+ ERegisterSpsrAbt,
+ ERegisterR13Und,
+ ERegisterR14Und,
+ ERegisterSpsrUnd,
+ ERegisterR13Irq,
+ ERegisterR14Irq,
+ ERegisterSpsrIrq,
+ ERegisterR8Fiq,
+ ERegisterR9Fiq,
+ ERegisterR10Fiq,
+ ERegisterR11Fiq,
+ ERegisterR12Fiq,
+ ERegisterR13Fiq,
+ ERegisterR14Fiq,
+ ERegisterSpsrFiq,
+ ERegisterLast
+ };
+
+ aRegisterList.Reset();
+
+ TRegisterData reg;
+ //core regs
+ const TFunctionalityRegister* r;
+ for(r = ids; *r != ERegisterLast; ++r)
+ {
+ reg.iRegClass = 0; //Core
+ reg.iId = *r; // R0, ...
+ reg.iSubId = 0; // not used for Core Regs
+ reg.iSize = 2;
+ reg.iAvailable = ETrue;
+ aRegisterList.AppendL( reg );
+
+ }
+
+ //copro regs
+ for(TInt i = 0; i < KCoProRegsCount; ++i)
+ {
+ reg.iRegClass = 1; //CoPro
+ reg.iId = i; // R0, ...
+ reg.iSubId = KRegSubId + i;
+ reg.iSize = i%4;
+ reg.iAvailable = i < KCoProRegsCount/2 ? ETrue : EFalse; //half not available
+ aRegisterList.AppendL( reg );
+ }
+}
+
+void CTestCrashDataSource::ReadRegistersL( const TUint64 aThreadId, RRegisterList &aRegisterList )
+ {
+
+ //RDebug::Print( _L("CTestCrashDataSource::ReadRegisters( threadId=0x%X)\n"), I64LOW(aThreadId) );
+
+ if( aRegisterList.Count() )
+ {
+ RDebug::Printf( "Register list already supplied\n" );
+ User::LeaveIfError(SetSimRegValues( aThreadId, aRegisterList ));
+ }
+ else
+ {
+ RDebug::Printf( "Creating register list\n" );
+ GetRegisterListL( aRegisterList );
+ User::LeaveIfError(SetSimRegValues( aThreadId, aRegisterList ));
+ }
+
+ PrintRegs( aRegisterList );
+
+ }
+
+
+
+void CTestCrashDataSource::ReadMemoryL(
+ const TUint64 aThreadId,
+ const TUint32 aAddress,
+ const TUint32 aLength,
+ TDes8 & aData )
+ {
+
+ RDebug::Print( _L("CCrashDataSource::ReadMemory( tId=0x%X, addr=0x%X, len=0x%X)\n"),
+ aThreadId, aAddress, aLength );
+
+ for( TUint32 i = 0; i < aLength; i++ )
+ {
+ aData.Append((TUint8*)&i, 1);
+ RDebug::Printf( " Memory[%d]=0x%X\n", i, aData[i] );
+ }
+ }
+
+
+
+
+void CTestCrashDataSource::GetProcessListL( RProcessPointerList & aProcList,
+ TUint & aTotalProcessListDescSize )
+ {
+
+ RDebug::Print( _L("CTestCrashDataSource::GetProcessList( )\n") );
+
+ CProcessInfo *processInfo = CProcessInfo::NewL(KCrashPid, KCrashFileName );
+
+ TInt err = aProcList.Append( processInfo );
+ if(err != KErrNone)
+ {
+ delete processInfo;
+ User::Leave(err);
+ }
+ }
+
+void CTestCrashDataSource::GetExecutableListL( RExecutablePointerList & aExecutableList,
+ TUint & aTotalExecutableListDescSize )
+ {
+
+ RDebug::Print( _L("CTestCrashDataSource::GetExecutableList( )\n") );
+
+ CExecutableInfo *executableInfo = CExecutableInfo::NewL(KCrashFileName, EFalse, EFalse );
+
+ TInt err = aExecutableList.Append( executableInfo );
+ if(err != KErrNone)
+ {
+ delete executableInfo;
+ User::Leave(err);
+ }
+ }
+
+void CTestCrashDataSource::GetThreadListL( const TUint64 aProcessId,
+ RThreadPointerList & aThreadList,
+ TUint & aTotalThreadListDescSize )
+ {
+ GetThreadListL( I64LOW( aProcessId ), aThreadList, aTotalThreadListDescSize );
+ }
+
+
+void CTestCrashDataSource::GetThreadListL( const TUint32 aProcessId,
+ RThreadPointerList & aThreadList,
+ TUint & aTotalThreadListDescSize )
+ {
+
+ RDebug::Print( _L("CTestCrashDataSource::GetThreadList( pId=0x%X)\n"), aProcessId );
+
+
+
+ LOG_MSG2( "CTestCrashDataSource::GetThreadListL( pId=0x%X)\n", aProcessId );
+
+ aThreadList.ResetAndDestroy();
+ aTotalThreadListDescSize = 0;
+
+ for(TInt i =0; i < KCrashThreadsCount; ++i)
+ {
+ CThreadInfo *thread = CThreadInfo::NewL( KCrashTid + i,
+ KCrashThreadName,
+ KCrashPid,
+ KCrashThreadPriority + i,
+ KCrashSvcStackPtr + i,
+ KCrashSvcStackAddr + i,
+ KCrashSvcStackSize + i,
+ KCrashUsrStackAddr + i,
+ KCrashUsrStackSize + i);
+ aThreadList.Append(thread);
+ //delete thread;
+ }
+
+ }
+
+void CTestCrashDataSource::GetCodeSegmentsL( const TUint64 aTid, RCodeSegPointerList &aCodeSegs, TUint &aTotalCodeSegListDescSize )
+ {
+
+ RDebug::Printf( "CTestCrashDataSource::GetExecutableInfo(pId=0x%X)\n", aTid );
+ TInt err;
+
+ TCodeSegInfo *segInfo;
+
+ if(KCrashXIP)
+ RDebug::Printf( " Exec info XIP == ETrue\n" );
+ else
+ RDebug::Printf( " Exec info XIP == EFalse\n" );
+
+
+ segInfo = new(ELeave) TCodeSegInfo;
+ segInfo->iName = KCrashFileName;
+ segInfo->iXIP = ETrue;
+ segInfo->iCodeSize = KCrashCodeSize + aTid;
+ segInfo->iCodeRunAddr = KCrashCodeRunAddr + aTid;
+ segInfo->iCodeLoadAddr = KCrashCodeLoadAddr + aTid;
+ segInfo->iRoDataSize = KCrashRODataSize + aTid;
+ segInfo->iRoDataRunAddr = KCrashRODataRunAddr + aTid;
+ segInfo->iRoDataLoadAddr = KCrashRODataLoadAddr + aTid;
+ segInfo->iDataSize = KCrashDataSize + aTid;
+ segInfo->iDataRunAddr = KCrashDataRunAddr + aTid;
+ segInfo->iDataLoadAddr = KCrashDataLoadAddr + aTid;
+ segInfo->iType = EExeCodeSegType;
+ err = aCodeSegs.Append(segInfo);
+ if(err != KErrNone)
+ {
+ delete segInfo;
+ User::Leave(err);
+ }
+ aTotalCodeSegListDescSize += sizeof(TCodeSegInfo);
+
+ segInfo = new(ELeave) TCodeSegInfo;
+ segInfo->iName = KLibName1;
+ segInfo->iXIP = ETrue;
+ segInfo->iCodeSize = KCrashCodeSize + aTid + 1;
+ segInfo->iCodeRunAddr = KCrashCodeRunAddr + aTid + 1;
+ segInfo->iCodeLoadAddr = KCrashCodeLoadAddr + aTid + 1;
+ segInfo->iRoDataSize = KCrashRODataSize + aTid + 1;
+ segInfo->iRoDataRunAddr = KCrashRODataRunAddr + aTid + 1;
+ segInfo->iRoDataLoadAddr = KCrashRODataLoadAddr + aTid + 1;
+ segInfo->iDataSize = KCrashDataSize + aTid + 1;
+ segInfo->iDataRunAddr = KCrashDataRunAddr + aTid + 1;
+ segInfo->iDataLoadAddr = KCrashDataLoadAddr + aTid + 1;
+ segInfo->iType = EDllCodeSegType;
+ err = aCodeSegs.Append(segInfo);
+ if(err != KErrNone)
+ {
+ delete segInfo;
+ User::Leave(err);
+ }
+ aTotalCodeSegListDescSize += sizeof(TCodeSegInfo);
+
+ segInfo = new(ELeave) TCodeSegInfo;
+ segInfo->iName = KLibName2;
+ segInfo->iXIP = EFalse;
+ segInfo->iCodeSize = KCrashCodeSize + aTid + 2;
+ segInfo->iCodeRunAddr = KCrashCodeRunAddr + aTid + 2;
+ segInfo->iCodeLoadAddr = KCrashCodeLoadAddr + aTid + 2;
+ segInfo->iRoDataSize = KCrashRODataSize + aTid + 2;
+ segInfo->iRoDataRunAddr = KCrashRODataRunAddr + aTid + 2;
+ segInfo->iRoDataLoadAddr = KCrashRODataLoadAddr + aTid + 2;
+ segInfo->iDataSize = KCrashDataSize + aTid + 2;
+ segInfo->iDataRunAddr = KCrashDataRunAddr + aTid + 2;
+ segInfo->iDataLoadAddr = KCrashDataLoadAddr + aTid + 2;
+ segInfo->iType = EDllCodeSegType;
+ err = aCodeSegs.Append(segInfo);
+ if(err != KErrNone)
+ {
+ delete segInfo;
+ User::Leave(err);
+ }
+ aTotalCodeSegListDescSize += sizeof(TCodeSegInfo);
+
+ }
+
+void CTestCrashDataSource::ReadTraceBufferL(TDes8 &aTraceData )
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCrashDataSource::GetLocksL(TSCMLockData& aLockData)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCrashDataSource::GetROMBuildInfoL(TRomHeaderData& aRomHeader)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+TUint CTestCrashDataSource::GetExceptionStackSizeL(const Debug::TArmProcessorModes aMode)
+ {
+ User::Leave(KErrNotSupported);
+ return 0;
+ }
+
+void CTestCrashDataSource::GetExceptionStackL(const Debug::TArmProcessorModes aMode, TDes8& aStack, TUint aStartReadPoint)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+TInt CTestCrashDataSource::GetDataSourceFunctionality(TDes8& aFuncBuffer)
+ {
+ return KErrNotSupported;
+ }
+
+TInt CTestCrashDataSource::GetDataSourceFunctionalityBufSize(TUint& aBufSize)
+ {
+ return KErrNotSupported;
+ }
+
+TVersion CTestCrashDataSource::GetVersion() const
+ {
+ TVersion ver(2,0,0);
+ return ver;
+ }
+
+TInt CTestCrashDataSource::GetVariantSpecificDataSize(TUint& aDataSize)
+ {
+ aDataSize = 0;
+ return KErrNotSupported;
+ }
+
+TInt CTestCrashDataSource::GetVariantSpecificData(TDes8& aVarSpecData)
+ {
+ (void)aVarSpecData;
+ return KErrNotSupported;
+ }
+
+//eof
+