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 "MemSpyEngineHelperSysMemTrackerEntryChunk.h"

    19 

    20 // System includes

    21 #include <e32base.h>

    22 #include <badesca.h>

    23 

    24 // Driver includes

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

    26 

    27 // User includes

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

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

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

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

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

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

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

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

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

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

    38 #include "MemSpyEngineHelperSysMemTrackerImp.h"

    39 #include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

    40 #include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

    41 

    42 

    43 

    44 

    45 CMemSpyEngineHelperSysMemTrackerEntryChunk::CMemSpyEngineHelperSysMemTrackerEntryChunk( CMemSpyEngineHelperSysMemTrackerImp& aTracker )

    46 :   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeChunk )

    47     {

    48     }

    49 

    50 

    51 CMemSpyEngineHelperSysMemTrackerEntryChunk::~CMemSpyEngineHelperSysMemTrackerEntryChunk()

    52     {

    53     delete iChunkName;

    54     }

    55 

    56 

    57 void CMemSpyEngineHelperSysMemTrackerEntryChunk::ConstructL( const TMemSpyDriverChunkInfo& aInfo, const TDesC& aFullChunkName )

    58     {

    59     iCurrent = aInfo;

    60     iLast = aInfo;

    61     //

    62     iChunkName = aFullChunkName.AllocL();

    63     SetHandle( aInfo.iHandle );

    64     }

    65 

    66 

    67 void CMemSpyEngineHelperSysMemTrackerEntryChunk::ConstructL( const TMemSpyDriverChunkInfo& aInfo, CMemSpyProcess& aProcess )

    68     {

    69     ConstructL( aInfo, aInfo.iName );

    70     //

    71     SetProcess( aProcess.Id() );

    72     }

    73 

    74 

    75 CMemSpyEngineHelperSysMemTrackerEntryChunk* CMemSpyEngineHelperSysMemTrackerEntryChunk::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, const TMemSpyDriverChunkInfo& aInfo )

    76     {

    77     CMemSpyEngineHelperSysMemTrackerEntryChunk* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryChunk( aTracker );

    78     CleanupStack::PushL( self );

    79     self->ConstructL( aInfo, aInfo.iName );

    80     return self;

    81     }

    82 

    83 

    84 CMemSpyEngineHelperSysMemTrackerEntryChunk* CMemSpyEngineHelperSysMemTrackerEntryChunk::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, const TMemSpyDriverChunkInfo& aInfo, CMemSpyProcess& aProcess )

    85     {

    86     CMemSpyEngineHelperSysMemTrackerEntryChunk* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryChunk( aTracker );

    87     CleanupStack::PushL( self );

    88     self->ConstructL( aInfo, aProcess );

    89     return self;

    90     }

    91 

    92 

    93 void CMemSpyEngineHelperSysMemTrackerEntryChunk::UpdateFromL( const CMemSpyEngineHelperSysMemTrackerEntry& aEntry )

    94     {

    95     const CMemSpyEngineHelperSysMemTrackerEntryChunk& entry = static_cast< const CMemSpyEngineHelperSysMemTrackerEntryChunk& >( aEntry );

    96     

    97     // Update state

    98     iLast = iCurrent;

    99     iCurrent = entry.iCurrent;

   100     }

   101 

   102 

   103 TBool CMemSpyEngineHelperSysMemTrackerEntryChunk::HasChangedL( const TMemSpyEngineHelperSysMemTrackerConfig& /*aConfig*/ ) const

   104     {

   105     const TBool hasChanged = ( iCurrent.iSize != iLast.iSize );

   106     return hasChanged;

   107     }

   108 

   109 

   110 void CMemSpyEngineHelperSysMemTrackerEntryChunk::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   111     {

   112     CMemSpyEngineHelperSysMemTrackerCycleChangeChunk* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::NewLC( Attributes(), *iChunkName, iCurrent, IsNew() ? NULL : &iLast );

   113     aCycle.AddAndPopL( changeDescriptor );

   114     }

   115 

   116 

   117 void CMemSpyEngineHelperSysMemTrackerEntryChunk::UpdateCycleStatistics( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   118     {

   119     aCycle.AddToMemoryUsed( iCurrent.iSize );

   120     }

   121 

   122 

   123 

   124 

   125 

   126 

   127 

   128 

   129 

   130 

   131 

   132 

   133 

   134 

   135 

   136 

   137 

   138 

   139 

   140 

   141 

   142 

   143 

   144 

   145 

   146 

   147 

   148 

   149 

   150 

   151 

   152 

   153 

   154 

   155 

   156 

   157 

   158 

   159 

   160 

   161 

   162 

   163 

   164 

   165 CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::CMemSpyEngineHelperSysMemTrackerCycleChangeChunk( TUint8 aAttribs, const TMemSpyDriverChunkInfo& aCurrent )

   166 :   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs ), iCurrent( aCurrent )

   167     {

   168     }

   169 

   170 

   171 CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::~CMemSpyEngineHelperSysMemTrackerCycleChangeChunk()

   172     {

   173     delete iLast;

   174     delete iChunkName;

   175     }

   176 

   177 

   178 void CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::ConstructL( const TDesC& aChunkName, const TMemSpyDriverChunkInfo* aLast )

   179     {

   180     BaseConstructL();

   181 

   182     // Save the thread name

   183     iChunkName = aChunkName.AllocL();

   184 

   185     // Save last heap data (if available)

   186     if ( aLast )

   187         {

   188         iLast = new (ELeave) TMemSpyDriverChunkInfo();

   189         *iLast = *aLast;

   190         }

   191     }

   192 

   193 

   194 CMemSpyEngineHelperSysMemTrackerCycleChangeChunk* CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::NewLC( TUint8 aAttribs, const TDesC& aChunkName, const TMemSpyDriverChunkInfo& aCurrent, const TMemSpyDriverChunkInfo* aLast )

   195     {

   196     CMemSpyEngineHelperSysMemTrackerCycleChangeChunk* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeChunk( aAttribs, aCurrent );

   197     CleanupStack::PushL( self );

   198     self->ConstructL( aChunkName, aLast );

   199     return self;

   200     }

   201 

   202 

   203 TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::Type() const

   204     {

   205     return EMemSpyEngineSysMemTrackerTypeChunk;

   206     }

   207    

   208 

   209 void CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   210     {

   211     _LIT( KHeaderChunk, "Type, Process, Chunk, Handle, Base Addr, Size, Max Size, Attribs");

   212     aSink.OutputLineL( KHeaderChunk );

   213     }

   214  

   215 

   216 void CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   217     {

   218     _LIT( KFormat, "%S,%S,%S,0x%08x,0x%08x,%d,%d,%S" );

   219     //

   220     TMemSpySWMTTypeName type;;

   221     FormatType( type );

   222     //

   223     TBuf<20> attribs;

   224     FormatAttributes( attribs );

   225     //

   226     HBufC* buf = HBufC::NewLC( 1024 );

   227     TPtr pBuf(buf->Des());

   228 

   229     // Try to get associated process name

   230     TFullName processName( KNullDesC );

   231     CMemSpyEngine& engine = aSink.Engine();

   232     const TInt procIndex = engine.Container().ProcessIndexById( iCurrent.iOwnerId );

   233     if  ( procIndex >= 0 )

   234         {

   235         CMemSpyProcess& process = engine.Container().At( procIndex );

   236         process.FullName( processName );

   237         }

   238 

   239     // Now output line

   240     pBuf.Format( KFormat, 

   241                  &type,

   242                  &processName, 

   243                  iChunkName,

   244                  iCurrent.iHandle,

   245                  iCurrent.iBaseAddress,

   246                  iCurrent.iSize,

   247                  iCurrent.iMaxSize,

   248                  &attribs

   249                  );

   250 

   251     aSink.OutputLineL( pBuf );

   252     CleanupStack::PopAndDestroy( buf );

   253     }

   254 

   255 

   256 void CMemSpyEngineHelperSysMemTrackerCycleChangeChunk::OutputDataL( CMemSpyEngineOutputSink& /*aSink*/, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   257     {

   258     }

   259