1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

    19 

    20 // System includes

    21 #include <f32file.h>

    22 #include <hal.h>

    23 #include <kernel/arm/arm_types.h>

    24 #include <memspy/driver/memspydriverclient.h>

    25 #include <memspy/engine/memspyengine.h>

    26 #include <memspy/engine/memspyengineutils.h>

    27 #include <memspy/engine/memspyengineoutputlist.h>

    28 #include <memspy/engine/memspyenginehelpercodesegment.h>

    29 #include <memspy/engine/memspyenginehelperactiveobject.h>

    30 #include <memspy/engine/memspyenginehelperchunk.h>

    31 #include <memspy/engine/memspyenginehelperheap.h>

    32 #include <memspy/engine/memspyenginehelperprocess.h>

    33 #include <memspy/engine/memspyengineobjectprocess.h>

    34 #include <memspy/engine/memspyengineobjectthread.h>

    35 #include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

    36 #include <memspy/engine/memspyengineoutputsink.h>

    37 

    38 // User includes

    39 #include "MemSpyEngineOutputListItem.h"

    40 

    41 // Constants

    42 const TInt KMemSpyNumericFormatBufferSize = 20;

    43 

    44 // Literal constants

    45 _LIT( KMemSpyNumericHexFormat, "0x%08x" );

    46 _LIT( KMemSpyNumericDecFormat, "%d" );

    47 _LIT( KMemSpyNumericLongFormat, "%Ld" );

    48 _LIT( KMemSpyCaptionYes, "Yes" );

    49 _LIT( KMemSpyCaptionNo, "No" );

    50 _LIT( KMemSpyCaptionOn, "On" );

    51 _LIT( KMemSpyCaptionOff, "Off" );

    52 _LIT( KMemSpyUnavailable, "Unavailable" );

    53 _LIT( KMemSpyDead, "Dead" );

    54 _LIT( KMemSpyNoItems, "(No items)" );

    55 

    56 

    57 

    58 CMemSpyThreadInfoItemBase::CMemSpyThreadInfoItemBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aType, TBool aAsyncConstruction )

    59 :   CMemSpyEngineObject( aContainer ), iContainer( aContainer ), iCallBack( CActive::EPriorityLow ), iType( aType )

    60     {

    61     if  ( aAsyncConstruction )

    62         {

    63         TCallBack callBackMethod( CallConstructL, this );

    64         iCallBack.Set( callBackMethod );

    65         iCallBack.CallBack();

    66         }

    67     }

    68 

    69 

    70 CMemSpyThreadInfoItemBase::~CMemSpyThreadInfoItemBase()

    71     {

    72     TRAP_IGNORE( iContainer.NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemDestroyed, iType ) );

    73     //

    74     iItems.ResetAndDestroy();

    75     iItems.Close();

    76     }

    77 

    78 

    79 TInt CMemSpyThreadInfoItemBase::CallConstructL( TAny* aSelf )

    80     {

    81     CMemSpyThreadInfoItemBase* self = reinterpret_cast< CMemSpyThreadInfoItemBase* >( aSelf );

    82     self->iReady = EFalse;

    83     

    84     // Don't try to refresh dead thread

    85     TInt err = KErrNone;

    86     if ( !self->Container().Thread().IsDead() )

    87         {

    88         TRAP(err, self->ConstructL());

    89         if  ( err != KErrNone )

    90             {

    91     #ifdef _DEBUG

    92             RDebug::Printf( "CMemSpyThreadInfoItemBase::CallConstructL() - construction err: %d, iType: %d", err, self->iType );

    93     #endif

    94             self->AddItemL( KMemSpyUnavailable, KNullDesC );

    95             self->iIsEmpty = ETrue;

    96             }

    97         else if ( self->MdcaCount() == 0 )

    98             {

    99             self->AddItemL( KMemSpyNoItems, KNullDesC );

   100             self->iIsEmpty = ETrue;

   101             }        

   102         }

   103     else

   104         {

   105         self->AddItemL( KMemSpyDead, KNullDesC );

   106         self->iIsEmpty = ETrue;

   107         }

   108     //

   109     self->iReady = ETrue;

   110     return KErrNone;

   111     }

   112 

   113 

   114 EXPORT_C TInt CMemSpyThreadInfoItemBase::MdcaCount() const

   115     {

   116     return iItems.Count();

   117     }

   118 

   119 

   120 EXPORT_C TPtrC CMemSpyThreadInfoItemBase::MdcaPoint( TInt aIndex ) const

   121     {

   122     CItem* item = iItems[ aIndex ];

   123     return TPtrC( item->Combined() );

   124     }

   125 

   126 EXPORT_C TPtrC CMemSpyThreadInfoItemBase::Caption(TInt aIndex ) const

   127 	{

   128 	CItem* item = iItems[ aIndex ];

   129 	return TPtrC( item->Caption() );

   130 	}

   131 

   132 EXPORT_C TPtrC CMemSpyThreadInfoItemBase::Value(TInt aIndex ) const

   133 	{

   134 	CItem* item = iItems[ aIndex ];

   135 	return TPtrC( item->Value() );

   136 	}

   137 

   138 EXPORT_C CMemSpyEngine& CMemSpyThreadInfoItemBase::Engine() const

   139     {

   140     return iContainer.Engine();

   141     }

   142 

   143 

   144 EXPORT_C void CMemSpyThreadInfoItemBase::PrintL()

   145     {

   146     const TInt count = iItems.Count();

   147     if  ( count > 0 && !iIsEmpty )

   148         {

   149         CMemSpyEngine& engine = Engine();

   150         CMemSpyEngineOutputSink& sink = engine.Sink();

   151 

   152         HBufC* name = MemSpyEngineUtils::CleanupTextLC( Name() );

   153         sink.OutputSectionHeadingL( *name, TChar('-') );

   154         CleanupStack::PopAndDestroy( name );

   155         sink.OutputPrefixSetLC( _L("  ") ); // Slight insertion

   156 

   157         // First pass to get max lengths

   158         TInt maxLengthCaption = 0;

   159         TInt maxLengthValue = 0;

   160 

   161         for( TInt j=0; j<count; j++ )

   162             {

   163             const CItem* item = iItems[ j ];

   164             maxLengthCaption = Max( maxLengthCaption, item->Caption().Length() );

   165             maxLengthValue = Max( maxLengthValue, item->Value().Length() );

   166             }

   167 

   168         // Second pass - real this time - to print the values

   169         HBufC* line = HBufC::NewLC( ( maxLengthCaption + maxLengthValue ) + 20 );

   170         TPtr pLine( line->Des() );

   171         //

   172         for( TInt i=0; i<count; i++ )

   173             {

   174             const CItem* item = iItems[ i ];

   175 

   176             // Remove initial tabs in caption

   177             HBufC* caption = MemSpyEngineUtils::CleanupTextLC( item->Caption() );

   178         

   179             // Create value item & replace any further tabs

   180             HBufC* value = MemSpyEngineUtils::CleanupTextLC( item->Value() );

   181 

   182             // Now format the final line, with padding.

   183             pLine.Justify( *caption, maxLengthCaption + 3, ELeft, TChar(' ') );

   184             pLine.Append( *value );

   185             CleanupStack::PopAndDestroy( 2, caption );

   186 

   187             // Sink output

   188             sink.OutputLineL( pLine );

   189             }

   190         //

   191         CleanupStack::PopAndDestroy( line );

   192         sink.OutputBlankLineL();

   193         CleanupStack::PopAndDestroy(); // clear prefix

   194         }

   195     }

   196 

   197 

   198 

   199 void CMemSpyThreadInfoItemBase::AddItemL( const TDesC& aCaption, const TDesC& aValue )

   200     {

   201     CItem* item = CItem::NewLC( aCaption, aValue );

   202     iItems.AppendL( item );

   203     CleanupStack::Pop( item );

   204     }

   205 

   206 

   207 void CMemSpyThreadInfoItemBase::AddItemHexL( const TDesC& aCaption, TUint aValue )

   208     {

   209     TBuf<KMemSpyNumericFormatBufferSize> val;

   210     val.Format( KMemSpyNumericHexFormat, aValue );

   211     AddItemL( aCaption, val );

   212     }

   213 

   214 

   215 void CMemSpyThreadInfoItemBase::AddItemDecimalL( const TDesC& aCaption, TInt aValue )

   216     {

   217     TBuf<KMemSpyNumericFormatBufferSize> val;

   218     val.Format( KMemSpyNumericDecFormat, aValue );

   219     AddItemL( aCaption, val );

   220     }

   221 

   222 

   223 void CMemSpyThreadInfoItemBase::AddItemLongL( const TDesC& aCaption, const TInt64& aValue )

   224     {

   225     TBuf<KMemSpyNumericFormatBufferSize> val;

   226     val.Format( KMemSpyNumericLongFormat, aValue );

   227     AddItemL( aCaption, val );

   228     }

   229 

   230 

   231 void CMemSpyThreadInfoItemBase::AddItemYesNoL( const TDesC& aCaption, TBool aYes )

   232     {

   233     CItem* item = CItem::NewYesNoLC( aCaption, aYes );

   234     iItems.AppendL( item );

   235     CleanupStack::Pop( item );

   236     }

   237 

   238 

   239 void CMemSpyThreadInfoItemBase::AddItemOnOffL( const TDesC& aCaption, TBool aOn )

   240     {

   241     CItem* item = CItem::NewOnOffLC( aCaption, aOn );

   242     iItems.AppendL( item );

   243     CleanupStack::Pop( item );

   244     }

   245 

   246 

   247 void CMemSpyThreadInfoItemBase::AddItemPercentageL( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue )

   248     {

   249     const TMemSpyPercentText val( MemSpyEngineUtils::FormatPercentage( TReal( aOneHundredPercentValue ), TReal( aValue ) ) );

   250     AddItemL( aCaption, val );

   251     }

   252 

   253 

   254 EXPORT_C void CMemSpyThreadInfoItemBase::RebuildL()

   255     {

   256     Reset();

   257     CallConstructL( this );

   258     }

   259 

   260 

   261 EXPORT_C TBool CMemSpyThreadInfoItemBase::IsReady() const

   262     {

   263     return iReady;

   264     }

   265 

   266 

   267 EXPORT_C TMemSpyThreadInfoItemType CMemSpyThreadInfoItemBase::Type() const

   268     {

   269     return iType;

   270     }

   271 

   272 

   273 void CMemSpyThreadInfoItemBase::Reset()

   274     {

   275     iItems.ResetAndDestroy();

   276     }

   277 

   278 

   279 void CMemSpyThreadInfoItemBase::StripProcessAndThreadNames( TDes& aText )

   280     {

   281     StripProcessName( aText );

   282     StripThreadName( aText );

   283     }

   284 

   285 

   286 void CMemSpyThreadInfoItemBase::StripProcessName( TDes& aText )

   287     {

   288     CMemSpyProcess& process = Container().Thread().Process();

   289     const TPtrC processName( process.Name() );

   290     TFullName temp;

   291     //

   292     _LIT( KProcessNameUidFormat1, "%S.exe[%08x]" );

   293     temp.Format( KProcessNameUidFormat1, &processName, process.SID() );

   294     const TBool stripped = MemSpyEngineUtils::StripText( aText, temp );

   295     //

   296     if  ( stripped == EFalse )

   297         {

   298         _LIT( KProcessNameUidFormat2, "%S[%08x]" );

   299         temp.Format( KProcessNameUidFormat2, &processName, process.SID() );

   300         MemSpyEngineUtils::StripText( aText, temp );

   301         }

   302     }

   303 

   304 

   305 void CMemSpyThreadInfoItemBase::StripThreadName( TDes& aText )

   306     {

   307     CMemSpyThread& thread = Container().Thread();

   308     const TPtrC threadName( thread.Name() );

   309     const TBool stripped = MemSpyEngineUtils::StripText( aText, threadName );

   310     (void) stripped;

   311     }

   312 

   313 

   314 CMemSpyThreadInfoItemBase::CItem& CMemSpyThreadInfoItemBase::Item( TInt aIndex )

   315     {

   316     CItem* item = iItems[ aIndex ];

   317     return *item;

   318     }

   319 

   320 

   321 const CMemSpyThreadInfoItemBase::CItem& CMemSpyThreadInfoItemBase::Item( TInt aIndex ) const

   322     {

   323     const CItem* item = iItems[ aIndex ];

   324     return *item;

   325     }

   326 

   327 

   328 

   329 

   330 

   331 

   332 

   333 

   334 

   335 

   336 

   337 

   338 

   339 

   340 

   341 

   342 

   343 

   344 

   345 

   346 CMemSpyThreadInfoItemBase::CItem::CItem()

   347     {

   348     }

   349 

   350 

   351 CMemSpyThreadInfoItemBase::CItem::~CItem()

   352     {

   353     delete iCaption;

   354     delete iValue;

   355     delete iCombined;

   356     }

   357 

   358 

   359 void CMemSpyThreadInfoItemBase::CItem::ConstructL( const TDesC& aCaption, const TDesC& aValue )

   360     {

   361     iCaption = aCaption.AllocL();

   362     iValue = aValue.AllocL();

   363     //

   364     UpdateCombinedL();

   365     }

   366 

   367 

   368 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const CItem& aCopyMe )

   369     {

   370     CItem* self = new(ELeave) CItem();

   371     CleanupStack::PushL( self );

   372     self->ConstructL( aCopyMe.Caption(), aCopyMe.Value() );

   373     return self;

   374     }

   375 

   376 

   377 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const TDesC& aCaption )

   378     {

   379     CItem* self = new(ELeave) CItem();

   380     CleanupStack::PushL( self );

   381     self->ConstructL( aCaption, KNullDesC );

   382     return self;

   383     }

   384 

   385 

   386 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const TDesC& aCaption, const TDesC& aValue )

   387     {

   388     CItem* self = new(ELeave) CItem();

   389     CleanupStack::PushL( self );

   390     self->ConstructL( aCaption, aValue );

   391     return self;

   392     }

   393 

   394 

   395 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewHexLC( const TDesC& aCaption, TUint aValue )

   396     {

   397     CItem* ret = CItem::NewLC( aCaption );

   398     ret->SetHexL( aValue );

   399     return ret;

   400     }

   401 

   402 

   403 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewDecimalLC( const TDesC& aCaption, TInt aValue )

   404     {

   405     CItem* ret = CItem::NewLC( aCaption );

   406     ret->SetDecimalL( aValue );

   407     return ret;

   408     }

   409 

   410 

   411 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLongLC( const TDesC& aCaption, const TInt64& aValue )

   412     {

   413     CItem* ret = CItem::NewLC( aCaption );

   414     ret->SetLongL( aValue );

   415     return ret;

   416     }

   417 

   418 

   419 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewYesNoLC( const TDesC& aCaption, TBool aYes )

   420     {

   421     CItem* ret = CItem::NewLC( aCaption );

   422     ret->SetYesNoL( aYes );

   423     return ret;

   424     }

   425 

   426 

   427 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewOnOffLC( const TDesC& aCaption, TBool aOn )

   428     {

   429     CItem* ret = CItem::NewLC( aCaption );

   430     ret->SetOnOffL( aOn );

   431     return ret;

   432     }

   433 

   434 

   435 CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewPercentageLC( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue )

   436     {

   437     CItem* ret = CItem::NewLC( aCaption );

   438     ret->SetPercentageL( aOneHundredPercentValue, aValue );

   439     return ret;

   440     }

   441 

   442 

   443 void CMemSpyThreadInfoItemBase::CItem::SetValueL( const TDesC& aValue )

   444     {

   445     if  ( iValue == NULL )

   446         {

   447         iValue = aValue.AllocL();

   448         }

   449     else

   450         {

   451         if  ( iValue->Des().MaxLength() < aValue.Length() )

   452             {

   453             iValue = iValue->ReAllocL( aValue.Length() );

   454             }

   455             

   456         // Now its safe to assign new content

   457         *iValue = aValue;

   458         }

   459         

   460     UpdateCombinedL();

   461     }

   462 

   463 

   464 void CMemSpyThreadInfoItemBase::CItem::SetHexL( TUint aValue )

   465     {

   466     TBuf<KMemSpyNumericFormatBufferSize> val;

   467     val.Format( KMemSpyNumericHexFormat, aValue );

   468     SetValueL( val );

   469     }

   470 

   471 

   472 void CMemSpyThreadInfoItemBase::CItem::SetDecimalL( TInt aValue )

   473     {

   474     TBuf<KMemSpyNumericFormatBufferSize> val;

   475     val.Format( KMemSpyNumericDecFormat, aValue );

   476     SetValueL( val );

   477     }

   478 

   479 

   480 void CMemSpyThreadInfoItemBase::CItem::SetLongL( const TInt64& aValue )

   481     {

   482     TBuf<KMemSpyNumericFormatBufferSize> val;

   483     val.Format( KMemSpyNumericLongFormat, aValue );

   484     SetValueL( val );

   485     }

   486 

   487 

   488 void CMemSpyThreadInfoItemBase::CItem::SetYesNoL( TBool aYes )

   489     {

   490     if  ( aYes )

   491         {

   492         SetValueL( KMemSpyCaptionYes );

   493         }

   494     else

   495         {

   496         SetValueL( KMemSpyCaptionNo );

   497         }

   498     }

   499 

   500 

   501 void CMemSpyThreadInfoItemBase::CItem::SetOnOffL( TBool aOn )

   502     {

   503     if  ( aOn )

   504         {

   505         SetValueL( KMemSpyCaptionOn );

   506         }

   507     else

   508         {

   509         SetValueL( KMemSpyCaptionOff );

   510         }

   511     }

   512 

   513 

   514 void CMemSpyThreadInfoItemBase::CItem::SetPercentageL( TInt aOneHundredPercentValue, TInt aValue )

   515     {

   516     const TMemSpyPercentText val( MemSpyEngineUtils::FormatPercentage( TReal( aOneHundredPercentValue ), TReal( aValue ) ) );

   517     SetValueL( val );

   518     }

   519 

   520 

   521 void CMemSpyThreadInfoItemBase::CItem::UpdateCombinedL()

   522     {

   523     const TInt requiredLength = Caption().Length() + Value().Length() + 10;

   524     //

   525     if  ( iCombined == NULL )

   526         {

   527         iCombined = HBufC::NewL( requiredLength );

   528         }

   529     else if ( iCombined->Des().MaxLength() < requiredLength )

   530         {

   531         iCombined = iCombined->ReAllocL( requiredLength );

   532         }

   533         

   534     TPtr pCombined( iCombined->Des() );

   535     pCombined.Zero();

   536     pCombined.Append( _L("\t") );

   537     pCombined.Append( Caption() );

   538     pCombined.Append( _L("\t\t") );

   539     pCombined.Append( Value() );

   540     }

   541 

   542 

   543 

   544 

   545 

   546 

   547 

   548 

   549 

   550 

   551 

   552 

   553 

   554 

   555 

   556 

   557 

   558 

   559 

   560 

   561 

   562 

   563 

   564 

   565 

   566 

   567 

   568 

   569 

   570 

   571 

   572 

   573 

   574 

   575 

   576 

   577 

   578 

   579 

   580 CMemSpyThreadInfoGeneral::CMemSpyThreadInfoGeneral( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   581 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeGeneralInfo, aAsyncConstruction )

   582     {

   583     }

   584 

   585 

   586 void CMemSpyThreadInfoGeneral::ConstructL()

   587     {

   588     TBuf<50> temp;

   589     RThread thread;

   590     Container().Thread().OpenLC( thread );

   591     const CMemSpyProcess& process = Container().Thread().Process();

   592 

   593     _LIT( KItem1, "Thread Id" );

   594     AddItemLongL( KItem1, thread.Id() );

   595 

   596     _LIT( KItem1a, "Process Id" );

   597     AddItemLongL( KItem1a, (TUint) process.Id() );

   598   

   599     _LIT( KItem1b, "SID" );

   600     AddItemHexL( KItem1b, process.SID() );

   601   

   602     _LIT( KItem1c, "VID" );

   603     AddItemHexL( KItem1c, process.VID() );

   604 

   605     _LIT( KItem2, "Thread Priority" );

   606     CMemSpyThread::AppendPriority( temp, thread.Priority() );

   607     AddItemL( KItem2, temp );

   608     temp.Zero();

   609    

   610     _LIT( KItem3, "Process Priority" );

   611     CMemSpyProcess::AppendPriority( temp, thread.ProcessPriority() );

   612     AddItemL( KItem3, temp );

   613     temp.Zero();

   614    

   615     _LIT( KItem4, "Request Count" );

   616     AddItemDecimalL( KItem4, thread.RequestCount() );

   617    

   618     TInt processHandleCount = 0;

   619     TInt threadHandleCount = 0;

   620     thread.HandleCount( processHandleCount, threadHandleCount );

   621 

   622     _LIT( KItem5a, "Process Handles" );

   623     AddItemDecimalL( KItem5a, processHandleCount );

   624 

   625     _LIT( KItem5b, "Thread Handles" );

   626     AddItemDecimalL( KItem5b, threadHandleCount );

   627 

   628     // Thread handle info

   629     THandleInfo handleInfo;

   630     thread.HandleInfo( &handleInfo );

   631 

   632     _LIT( KItem5c, "Num. Proc. (Using)" );

   633     AddItemDecimalL( KItem5c, handleInfo.iNumProcesses );

   634 

   635     _LIT( KItem5d, "Num. Thread (Using)" );

   636     AddItemDecimalL( KItem5d, handleInfo.iNumThreads );

   637 

   638     _LIT( KItem5e, "Attributes" );

   639     AddItemDecimalL( KItem5e, thread.Attributes() );

   640     

   641     // CPU time (request special kernel build)

   642     TTimeIntervalMicroSeconds cpuTime;

   643     if  ( thread.GetCpuTime( cpuTime ) == KErrNone )

   644         {

   645         _LIT( KItem5f, "CPU Time (us)" );

   646         const TInt64 time = cpuTime.Int64();

   647         AddItemLongL( KItem5f, time );

   648         }

   649 

   650     // Exit info

   651     _LIT( KItem6, "Exit Type" );

   652     CMemSpyThread::AppendExitType( temp, thread.ExitType() );

   653     AddItemL( KItem6, temp );

   654     temp.Zero();

   655 

   656     if  ( thread.ExitType() != EExitPending )

   657         {

   658         _LIT( KItem7, "Exit Reason" );

   659         AddItemDecimalL( KItem7, thread.ExitReason() );

   660 

   661         _LIT( KItem8, "Exit Category" );

   662         const TExitCategoryName cat( thread.ExitCategory() );

   663         AddItemL( KItem8, cat );

   664         }

   665 

   666     // Registers

   667     MakeRegisterListingL( thread );

   668     

   669     CleanupStack::PopAndDestroy( &thread );

   670 

   671     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

   672     }

   673 

   674 

   675 CMemSpyThreadInfoGeneral* CMemSpyThreadInfoGeneral::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   676     {

   677     CMemSpyThreadInfoGeneral* self = new(ELeave) CMemSpyThreadInfoGeneral( aContainer, aAsyncConstruction );

   678     CleanupStack::PushL( self );

   679     if  ( !aAsyncConstruction )

   680         {

   681         self->ConstructL();

   682         }

   683     return self;

   684     }

   685 

   686 

   687 EXPORT_C TPtrC CMemSpyThreadInfoGeneral::Name() const

   688     {

   689     _LIT(KName, "\tGeneral");

   690     return TPtrC( KName );

   691     }

   692 

   693 

   694 void CMemSpyThreadInfoGeneral::MakeRegisterListingL( RThread& aThread )

   695     {

   696 #ifndef __WINS__

   697     _LIT(KRegFormatGeneral, "R%02d");

   698     _LIT(KRegFormatSP, "SP");

   699     _LIT(KRegFormatLR, "LR");

   700     _LIT(KRegFormatPC, "PC");

   701     _LIT(KRegFormatFlags, "Flags");

   702     _LIT(KRegFormatDACR, "DACR"); // Data access control register

   703     //

   704     TArmRegSet regList;

   705     TPckg<TArmRegSet> pRegList( regList );

   706     //

   707     aThread.Context( pRegList );

   708 	TArmReg* pReg = reinterpret_cast<TArmReg*>( &regList );

   709     //

   710     for( TInt i=0; i<KArmRegisterCount; i++ )

   711         {

   712         const TArmReg regValue = pReg[ i ];

   713         //

   714         if  ( i <= EArmR12 )

   715             {

   716             TBuf<128> buf;

   717             buf.Format( KRegFormatGeneral, i );

   718             AddItemHexL( buf, regValue );

   719             }

   720         else

   721             {

   722             TPtrC pCaption( KRegFormatGeneral );

   723             //

   724             if  ( i == EArmSp )

   725                 {

   726                 pCaption.Set( KRegFormatSP );

   727                 }

   728             else if ( i == EArmLr )

   729                 {

   730                 pCaption.Set( KRegFormatLR );

   731                 }

   732             else if ( i == EArmPc )

   733                 {

   734                 pCaption.Set( KRegFormatPC );

   735                 }

   736             else if ( i == EArmFlags )

   737                 {

   738                 pCaption.Set( KRegFormatFlags );

   739                 }

   740             else if ( i == EArmDacr )

   741                 {

   742                 pCaption.Set( KRegFormatDACR );

   743                 }

   744             //

   745             AddItemHexL( pCaption, regValue );

   746             }

   747         }

   748 #else

   749     (void) aThread;

   750 #endif

   751     }

   752 

   753 

   754 

   755 

   756 

   757 

   758 

   759 

   760 

   761 

   762 

   763 

   764 

   765 

   766 CMemSpyThreadInfoHeap::CMemSpyThreadInfoHeap( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   767 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeHeap, aAsyncConstruction )

   768     {

   769     }

   770 

   771 

   772 void CMemSpyThreadInfoHeap::ConstructL()

   773     {

   774     CMemSpyEngineHelperHeap& heapHelper = Engine().HelperHeap();

   775 

   776     // Get heap info first of all

   777     TMemSpyHeapInfo info;

   778     heapHelper.GetHeapInfoUserL( Container().Thread().Process().Id(), Container().Thread().Id(), info );

   779     CMemSpyEngineOutputList* list = heapHelper.NewHeapSummaryShortLC( info );

   780 

   781     // Now add each item to our view

   782     const TInt count = list->Count();

   783     for( TInt i=0; i<count; i++ )

   784         {

   785         const CMemSpyEngineOutputListItem& item = list->Item( i );

   786         //

   787         AddItemL( item.Caption(), item.Value() );

   788         }

   789 

   790     // Tidy up

   791     CleanupStack::PopAndDestroy( list );

   792     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

   793     }

   794 

   795 

   796 CMemSpyThreadInfoHeap* CMemSpyThreadInfoHeap::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   797     {

   798     CMemSpyThreadInfoHeap* self = new(ELeave) CMemSpyThreadInfoHeap( aContainer, aAsyncConstruction );

   799     CleanupStack::PushL( self );

   800     if  ( !aAsyncConstruction )

   801         {

   802         self->ConstructL();

   803         }

   804     return self;

   805     }

   806 

   807 

   808 EXPORT_C TPtrC CMemSpyThreadInfoHeap::Name() const

   809     {

   810     _LIT(KName, "\tHeap");

   811     return TPtrC( KName );

   812     }

   813 

   814 

   815 

   816 

   817 

   818 

   819 

   820 

   821 

   822 

   823 

   824 

   825 

   826 

   827 

   828 

   829 CMemSpyThreadInfoActiveObjects::CMemSpyThreadInfoActiveObjects( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   830 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeActiveObject, aAsyncConstruction )

   831     {

   832     }

   833 

   834 

   835 CMemSpyThreadInfoActiveObjects::~CMemSpyThreadInfoActiveObjects()

   836     {

   837     delete iItems;

   838     }

   839 

   840 

   841 void CMemSpyThreadInfoActiveObjects::ConstructL()

   842     {

   843     CMemSpyEngine& engine = Container().Thread().Process().Engine();

   844     engine.ProcessSuspendLC( Container().Thread().Process().Id() );

   845     //

   846     CMemSpyEngineActiveObjectArray* activeObjects = engine.HelperActiveObject().ActiveObjectListL( Container().Thread() );

   847     delete iItems;

   848     iItems = activeObjects;

   849     //

   850     CleanupStack::PopAndDestroy(); // ProcessSuspendLC

   851 

   852     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

   853     }

   854 

   855 

   856 CMemSpyThreadInfoActiveObjects* CMemSpyThreadInfoActiveObjects::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   857     {

   858     CMemSpyThreadInfoActiveObjects* self = new(ELeave) CMemSpyThreadInfoActiveObjects( aContainer, aAsyncConstruction );

   859     CleanupStack::PushL( self );

   860     if  ( !aAsyncConstruction )

   861         {

   862         self->ConstructL();

   863         }

   864     return self;

   865     }

   866 

   867 

   868 EXPORT_C TPtrC CMemSpyThreadInfoActiveObjects::Name() const

   869     {

   870     _LIT(KName, "\tActive Objects");

   871     return TPtrC( KName );

   872     }

   873 

   874 

   875 EXPORT_C TInt CMemSpyThreadInfoActiveObjects::MdcaCount() const

   876     {

   877     TInt count = 0;

   878     //

   879     if  ( iItems )

   880         {

   881         count = iItems->MdcaCount();

   882         }

   883     //

   884     return count;

   885     }

   886 

   887 

   888 EXPORT_C TPtrC CMemSpyThreadInfoActiveObjects::MdcaPoint(TInt aIndex) const

   889     {

   890     TPtrC ret( KNullDesC );

   891     //

   892     if  ( iItems )

   893         {

   894         ret.Set( iItems->MdcaPoint( aIndex ) );

   895         }

   896     //

   897     return ret;

   898     }

   899 

   900 

   901 

   902 

   903 

   904 

   905 

   906 

   907 

   908 

   909 

   910 

   911 CMemSpyThreadInfoOpenFiles::CMemSpyThreadInfoOpenFiles( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   912 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeOpenFiles, aAsyncConstruction )

   913     {

   914     }

   915 

   916 

   917 void CMemSpyThreadInfoOpenFiles::ConstructL()

   918     {

   919     _LIT(KSpace, " ");

   920     //

   921     const TThreadId myThreadId = Container().Thread().Id();

   922     CMemSpyEngine& engine = Container().Thread().Process().Engine();

   923     RFs& fsSession = engine.FsSession();

   924     //

   925     TMemSpySizeText valueBuf;

   926     TBuf<128> timeBuf;

   927     TOpenFileScan scanner( fsSession );

   928     //

   929     CFileList* list = NULL;

   930     scanner.NextL( list );

   931 

   932     while( list != NULL )

   933         {

   934         if  ( scanner.ThreadId() == myThreadId )

   935             {

   936             CleanupStack::PushL( list );

   937     

   938             const TInt entryCount = list->Count();

   939             for(TInt i=0; i<entryCount; i++)

   940                 {

   941                 const TEntry& entry = (*list)[ i ];

   942 

   943                 // Get time and size format strings

   944                 valueBuf = MemSpyEngineUtils::FormatSizeText( entry.iSize );

   945                 MemSpyEngineUtils::FormatTimeL( timeBuf, entry.iModified );

   946                 timeBuf.Insert( 0, KSpace );

   947                 timeBuf.Insert( 0, valueBuf );

   948 

   949                 // Get just file name

   950                 TParsePtrC parser( entry.iName );

   951                 const TPtrC pJustName( parser.NameAndExt() );

   952 

   953                 // Create item 

   954                 AddItemL( pJustName, timeBuf );

   955                 }

   956 

   957             CleanupStack::Pop( list );

   958             }

   959 

   960         delete list;

   961         list = NULL;

   962         scanner.NextL( list );

   963         }

   964 

   965     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

   966     }

   967 

   968 

   969 CMemSpyThreadInfoOpenFiles* CMemSpyThreadInfoOpenFiles::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

   970     {

   971     CMemSpyThreadInfoOpenFiles* self = new(ELeave) CMemSpyThreadInfoOpenFiles( aContainer, aAsyncConstruction );

   972     CleanupStack::PushL( self );

   973     if  ( !aAsyncConstruction )

   974         {

   975         self->ConstructL();

   976         }

   977     return self;

   978     }

   979 

   980 

   981 EXPORT_C TPtrC CMemSpyThreadInfoOpenFiles::Name() const

   982     {

   983     _LIT(KName, "\tOpen Files");

   984     return TPtrC( KName );

   985     }

   986 

   987 

   988 

   989 

   990 

   991 

   992 

   993 

   994 

   995 

   996 

   997 

   998 

   999 

  1000 

  1001 

  1002 CMemSpyThreadInfoStack::CMemSpyThreadInfoStack( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

  1003 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeStack, aAsyncConstruction )

  1004     {

  1005     }

  1006 

  1007 

  1008 void CMemSpyThreadInfoStack::ConstructL()

  1009     {

  1010     CMemSpyEngine& engine = Container().Thread().Process().Engine();

  1011     engine.ProcessSuspendLC( Container().Thread().Process().Id() );

  1012     //

  1013     TMemSpyDriverStackInfo info;

  1014     const TInt error = engine.Driver().GetStackInfo( Container().Thread().Id(), info );

  1015     User::LeaveIfError( error );

  1016     

  1017     _LIT( KItem1, "Size" );

  1018     AddItemDecimalL( KItem1, info.iUserStackSize );

  1019 

  1020 #ifndef __WINS__

  1021     const TInt userStackUsage = (TInt) ( info.iUserStackBase + info.iUserStackSize ) - info.iUserStackPointer;

  1022     const TInt userStackHighWaterMarkUsage = (TInt) ( info.iUserStackBase + info.iUserStackSize ) - info.iUserStackHighWatermark;

  1023 

  1024     _LIT( KItem2, "Stack used" );

  1025     AddItemDecimalL( KItem2, userStackUsage );

  1026     

  1027     _LIT( KItem3, "(percentage)" );

  1028     AddItemPercentageL( KItem3, info.iUserStackSize, userStackUsage );

  1029 

  1030     _LIT( KItem4, "High watermark" );

  1031     AddItemDecimalL( KItem4, userStackHighWaterMarkUsage );

  1032     

  1033     _LIT( KItem5, "(percentage)" );

  1034     AddItemPercentageL( KItem5, info.iUserStackSize, userStackHighWaterMarkUsage );

  1035 #endif

  1036 

  1037     _LIT( KItem6, "Base address" );

  1038     AddItemHexL( KItem6, info.iUserStackBase );

  1039 

  1040 #ifndef __WINS__

  1041     _LIT( KItem7, "Current pointer" );

  1042     AddItemHexL( KItem7, info.iUserStackPointer );

  1043 #endif

  1044     //

  1045     CleanupStack::PopAndDestroy(); // ProcessSuspendLC

  1046 

  1047     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

  1048     }

  1049 

  1050 

  1051 CMemSpyThreadInfoStack* CMemSpyThreadInfoStack::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

  1052     {

  1053     CMemSpyThreadInfoStack* self = new(ELeave) CMemSpyThreadInfoStack( aContainer, aAsyncConstruction );

  1054     CleanupStack::PushL( self );

  1055     if  ( !aAsyncConstruction )

  1056         {

  1057         self->ConstructL();

  1058         }

  1059     return self;

  1060     }

  1061 

  1062 

  1063 EXPORT_C TPtrC CMemSpyThreadInfoStack::Name() const

  1064     {

  1065     _LIT(KName, "\tStack");

  1066     return TPtrC( KName );

  1067     }

  1068 

  1069 

  1070 

  1071 

  1072 

  1073 

  1074 

  1075 

  1076 

  1077 

  1078 

  1079 

  1080 

  1081 

  1082 

  1083 

  1084 

  1085 

  1086 

  1087 

  1088 

  1089 

  1090 

  1091 

  1092 

  1093 

  1094 

  1095 

  1096 

  1097 

  1098 CMemSpyThreadInfoChunk::CMemSpyThreadInfoChunk( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

  1099 :   CMemSpyThreadInfoItemBase( aContainer, EMemSpyThreadInfoItemTypeChunk, aAsyncConstruction )

  1100     {

  1101     }

  1102 

  1103 

  1104 CMemSpyThreadInfoChunk::~CMemSpyThreadInfoChunk()

  1105     {

  1106     delete iList;

  1107     }

  1108 

  1109 

  1110 void CMemSpyThreadInfoChunk::ConstructL()

  1111     {

  1112     CMemSpyEngine& engine = Container().Thread().Process().Engine();

  1113     engine.ProcessSuspendLC( Container().Thread().Process().Id() );

  1114     //

  1115     CMemSpyEngineChunkList* list = engine.HelperChunk().ListForThreadL( Container().Thread().Id() );

  1116     delete iList;

  1117     iList = list;

  1118     //

  1119     CleanupStack::PopAndDestroy(); // ProcessSuspendLC

  1120 

  1121     Container().NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemChanged, Type() );

  1122     }

  1123 

  1124 

  1125 CMemSpyThreadInfoChunk* CMemSpyThreadInfoChunk::NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction )

  1126     {

  1127     CMemSpyThreadInfoChunk* self = new(ELeave) CMemSpyThreadInfoChunk( aContainer, aAsyncConstruction );

  1128     CleanupStack::PushL( self );

  1129     if  ( !aAsyncConstruction )

  1130         {

  1131         self->ConstructL();

  1132         }

  1133     return self;

  1134     }