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 "MemSpyEngineHelperSysMemTrackerEntryGlobalData.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/memspyenginehelperchunk.h>

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

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

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

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

    37 #include "MemSpyEngineHelperSysMemTrackerImp.h"

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

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

    40 

    41 

    42 

    43 

    44 CMemSpyEngineHelperSysMemTrackerGlobalData::CMemSpyEngineHelperSysMemTrackerGlobalData( CMemSpyEngineHelperSysMemTrackerImp& aTracker )

    45 :   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeGlobalData )

    46     {

    47     }

    48 

    49 

    50 CMemSpyEngineHelperSysMemTrackerGlobalData::~CMemSpyEngineHelperSysMemTrackerGlobalData()

    51     {

    52     delete iChunkName;

    53     delete iLast;

    54     }

    55 

    56 

    57 void CMemSpyEngineHelperSysMemTrackerGlobalData::ConstructL( CMemSpyProcess& aProcess, const TMemSpyDriverChunkInfo& aChunkInfo )

    58     {

    59     iCurrent = aChunkInfo;

    60     //

    61     SetProcess( aProcess.Id() );

    62     SetHandle( aChunkInfo.iHandle );

    63 

    64     if  ( aChunkInfo.iType == EMemSpyDriverChunkTypeGlobalData )

    65         {

    66         // Pure global data, unique chunk

    67         iLast = new(ELeave) TMemSpyDriverChunkInfo();

    68         *iLast = aChunkInfo;

    69         }

    70     else if ( aChunkInfo.iType == EMemSpyDriverChunkTypeStackAndProcessGlobalData )

    71         {

    72         // Mostly stack, possibly some global data too. Get the global data size from

    73         // the code seg associated with the process.

    74         CMemSpyEngineCodeSegList* codeSegs = Engine().HelperCodeSegment().CodeSegmentListL( aProcess.Id() );

    75         CleanupStack::PushL( codeSegs );

    76 

    77         // We're looking for the process codesegment...

    78         TFileName* fileName = new(ELeave) TFileName();

    79         CleanupStack::PushL( fileName );

    80         aProcess.GetFileName( *fileName );

    81         const TInt pos = codeSegs->IndexByName( *fileName );

    82         CleanupStack::PopAndDestroy( fileName );

    83 

    84         // Get total data size

    85         if  ( pos >= 0 )

    86             {

    87             const CMemSpyEngineCodeSegEntry& entry = codeSegs->At( pos );

    88             const TCodeSegCreateInfo& createInfo = entry.CreateInfo();

    89             iCurrent.iSize = Engine().Driver().RoundToPageSize( createInfo.iTotalDataSize );

    90             

    91             // If there is no data, then we don't want an entry in the list, so bail out.

    92             if  ( iCurrent.iSize == 0 )

    93                 {

    94                 User::Leave( KErrNotSupported );

    95                 }

    96             }

    97 

    98         CleanupStack::PopAndDestroy( codeSegs );

    99         }

   100 

   101     iChunkName = aChunkInfo.iName.AllocL();

   102     }

   103 

   104 

   105 CMemSpyEngineHelperSysMemTrackerGlobalData* CMemSpyEngineHelperSysMemTrackerGlobalData::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, CMemSpyProcess& aProcess, const TMemSpyDriverChunkInfo& aChunkInfo )

   106     {

   107     CMemSpyEngineHelperSysMemTrackerGlobalData* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerGlobalData( aTracker );

   108     CleanupStack::PushL( self );

   109     self->ConstructL( aProcess, aChunkInfo );

   110     return self;

   111     }

   112 

   113 

   114 void CMemSpyEngineHelperSysMemTrackerGlobalData::UpdateFromL( const CMemSpyEngineHelperSysMemTrackerEntry& aEntry )

   115     {

   116     const CMemSpyEngineHelperSysMemTrackerGlobalData& entry = static_cast< const CMemSpyEngineHelperSysMemTrackerGlobalData& >( aEntry );

   117     __ASSERT_ALWAYS( entry.IsProcessGlobalData() == IsProcessGlobalData(), User::Panic(_L("MemSpySysMemT"), __LINE__ ) );

   118    

   119     if  ( !IsProcessGlobalData() )

   120         {

   121         // Update state

   122         *iLast = iCurrent;

   123         iCurrent = entry.iCurrent;

   124         }

   125     }

   126 

   127 

   128 TBool CMemSpyEngineHelperSysMemTrackerGlobalData::HasChangedL( const TMemSpyEngineHelperSysMemTrackerConfig& /*aConfig*/ ) const

   129     {

   130     TBool hasChanged = EFalse;

   131     //

   132     if  ( !IsProcessGlobalData() )

   133         {

   134         hasChanged = ( iCurrent.iSize != iLast->iSize );

   135         }

   136     //

   137     return hasChanged;

   138     }

   139 

   140 

   141 void CMemSpyEngineHelperSysMemTrackerGlobalData::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   142     {

   143     CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::NewLC( Attributes(), *iChunkName, iCurrent, IsNew() ? NULL : iLast );

   144     aCycle.AddAndPopL( changeDescriptor );

   145     }

   146 

   147 

   148 void CMemSpyEngineHelperSysMemTrackerGlobalData::UpdateCycleStatistics( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   149     {

   150     const TInt size = CurrentGlobalDataSize();

   151     aCycle.AddToMemoryUsed( size );

   152     }

   153 

   154 

   155 TBool CMemSpyEngineHelperSysMemTrackerGlobalData::IsProcessGlobalData() const

   156     {

   157     return ( iLast == NULL );

   158     }

   159 

   160 

   161 TInt CMemSpyEngineHelperSysMemTrackerGlobalData::CurrentGlobalDataSize() const

   162     {

   163     const TInt size = iCurrent.iSize;

   164     return size;

   165     }

   166 

   167 

   168 

   169 

   170 

   171 

   172 

   173 

   174 

   175 

   176 

   177 

   178 

   179 

   180 

   181 

   182 

   183 

   184 

   185 

   186 

   187 

   188 

   189 

   190 CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData( TUint8 aAttribs, const TMemSpyDriverChunkInfoWithoutName& aCurrent )

   191 :   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs ), iCurrent( aCurrent )

   192     {

   193     }

   194 

   195 

   196 CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::~CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData()

   197     {

   198     delete iLast;

   199     delete iChunkName;

   200     }

   201 

   202 

   203 void CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::ConstructL( const TDesC& aChunkName, const TMemSpyDriverChunkInfoWithoutName* aLast )

   204     {

   205     BaseConstructL();

   206 

   207     // Save the thread name

   208     iChunkName = aChunkName.AllocL();

   209 

   210     // Save last heap data (if available)

   211     if  ( aLast )

   212         {

   213         iLast = new (ELeave) TMemSpyDriverChunkInfoWithoutName();

   214         *iLast = *aLast;

   215         }

   216     }

   217 

   218 

   219 CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData* CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::NewLC( TUint8 aAttribs, const TDesC& aChunkName, const TMemSpyDriverChunkInfoWithoutName& aCurrent, const TMemSpyDriverChunkInfoWithoutName* aLast )

   220     {

   221     CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData( aAttribs, aCurrent );

   222     CleanupStack::PushL( self );

   223     self->ConstructL( aChunkName, aLast );

   224     return self;

   225     }

   226 

   227 

   228 TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::Type() const

   229     {

   230     return EMemSpyEngineSysMemTrackerTypeGlobalData;

   231     }

   232    

   233 

   234 void CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   235     {

   236     _LIT( KHeaderGlobalData, "Type, Process, Chunk, Handle, Base Addr, Size, Max Size, Attribs");

   237     aSink.OutputLineL( KHeaderGlobalData );

   238     }

   239  

   240 

   241 void CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   242     {

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

   244     //

   245     TMemSpySWMTTypeName type;;

   246     FormatType( type );

   247     //

   248     TBuf<20> attribs;

   249     FormatAttributes( attribs );

   250     //

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

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

   253 

   254     // Try to get associated process name

   255     TPtrC pProcessName( KNullDesC );

   256     CMemSpyEngine& engine = aSink.Engine();

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

   258     if  ( procIndex >= 0 )

   259         {

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

   261         pProcessName.Set( process.Name() );

   262         }

   263 

   264     // Now output line

   265     pBuf.Format( KFormat, 

   266                  &type,

   267                  &pProcessName, 

   268                  iChunkName,

   269                  iCurrent.iHandle,

   270                  iCurrent.iBaseAddress,

   271                  iCurrent.iSize,

   272                  iCurrent.iMaxSize,

   273                  &attribs

   274                  );

   275 

   276     aSink.OutputLineL( pBuf );

   277     CleanupStack::PopAndDestroy( buf );

   278     }

   279 

   280 

   281 void CMemSpyEngineHelperSysMemTrackerCycleChangeGlobalData::OutputDataL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   282     {

   283     CMemSpyEngine& engine = aSink.Engine();

   284     }

   285