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 "MemSpyEngineHelperSysMemTrackerEntryOpenFile.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/memspyenginehelperfilesystem.h>

    38 #include "MemSpyEngineHelperSysMemTrackerImp.h"

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

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

    41 

    42 

    43 CMemSpyEngineHelperSysMemTrackerEntryOpenFile::CMemSpyEngineHelperSysMemTrackerEntryOpenFile( CMemSpyEngineHelperSysMemTrackerImp& aTracker )

    44 :   CMemSpyEngineHelperSysMemTrackerEntry( aTracker, EMemSpyEngineSysMemTrackerTypeOpenFile )

    45     {

    46     }

    47 

    48 

    49 CMemSpyEngineHelperSysMemTrackerEntryOpenFile::~CMemSpyEngineHelperSysMemTrackerEntryOpenFile()

    50     {

    51     delete iFileName;

    52     delete iThreadName;

    53     }

    54 

    55 

    56 void CMemSpyEngineHelperSysMemTrackerEntryOpenFile::ConstructL( const CMemSpyEngineOpenFileListForThread& aThreadInfo, const CMemSpyEngineOpenFileListEntry& aEntryInfo )

    57     {

    58     // Get basic details

    59     iThreadName = aThreadInfo.ThreadName().AllocL();

    60     SetThread( aThreadInfo.ThreadId() );

    61     SetProcess( aThreadInfo.ProcessId() );

    62 

    63     // Set file details

    64     iFileName = aEntryInfo.FileName().AllocL();

    65     iSize = aEntryInfo.Size();

    66     iUniqueFileId = aEntryInfo.UniqueFileId();

    67     }

    68 

    69 

    70 CMemSpyEngineHelperSysMemTrackerEntryOpenFile* CMemSpyEngineHelperSysMemTrackerEntryOpenFile::NewLC( CMemSpyEngineHelperSysMemTrackerImp& aTracker, const CMemSpyEngineOpenFileListForThread& aThreadInfo, const CMemSpyEngineOpenFileListEntry& aEntryInfo )

    71     {

    72     CMemSpyEngineHelperSysMemTrackerEntryOpenFile* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerEntryOpenFile( aTracker );

    73     CleanupStack::PushL( self );

    74     self->ConstructL( aThreadInfo, aEntryInfo );

    75     return self;

    76     }

    77 

    78 

    79 TUint64 CMemSpyEngineHelperSysMemTrackerEntryOpenFile::Key() const

    80     {

    81     const TUint32 val = ( Type() << 28 ) + ( iUniqueFileId < 24 ) + ThreadId(); 

    82     TUint64 ret = val;

    83     ret <<= 32;

    84     //

    85     const TUint32 fileNameHash = MemSpyEngineUtils::Hash( *iFileName );

    86     ret += fileNameHash;

    87     //

    88     return ret;

    89     }

    90 

    91 

    92 void CMemSpyEngineHelperSysMemTrackerEntryOpenFile::CreateChangeDescriptorL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    93     {

    94     CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile* changeDescriptor = CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::NewLC( Attributes(), *iThreadName, *iFileName, iSize, iUniqueFileId );

    95     aCycle.AddAndPopL( changeDescriptor );

    96     }

    97 

    98 

    99 void CMemSpyEngineHelperSysMemTrackerEntryOpenFile::UpdateCycleStatistics( CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   100     {

   101     // Doesn't participate in direct memory usage and indirect usage cannot really be measured.

   102     }

   103 

   104 

   105 

   106 

   107 

   108 

   109 

   110 

   111 

   112 

   113 

   114 

   115 

   116 

   117 

   118 

   119 

   120 

   121 

   122 

   123 

   124 

   125 

   126 CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile( TUint8 aAttribs, TInt aSize, TInt aUniqueFileId )

   127 :   CMemSpyEngineHelperSysMemTrackerCycleChange( aAttribs ), iSize( aSize ), iUniqueFileId( aUniqueFileId )

   128     {

   129     }

   130 

   131 

   132 CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::~CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile()

   133     {

   134     delete iFileName;

   135     delete iThreadName;

   136     }

   137 

   138 

   139 void CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::ConstructL( const TDesC& aThreadName, const TDesC& aFileName )

   140     {

   141     BaseConstructL();

   142 

   143     // Save the thread name

   144     iFileName = aFileName.AllocL();

   145     iThreadName = aThreadName.AllocL();

   146     }

   147 

   148 

   149 CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile* CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::NewLC( TUint8 aAttribs, const TDesC& aThreadName, const TDesC& aFileName, TInt aSize, TInt aUniqueFileId )

   150     {

   151     CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile( aAttribs, aSize, aUniqueFileId );

   152     CleanupStack::PushL( self );

   153     self->ConstructL( aThreadName, aFileName );

   154     return self;

   155     }

   156 

   157 

   158 TMemSpyEngineSysMemTrackerType CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::Type() const

   159     {

   160     return EMemSpyEngineSysMemTrackerTypeOpenFile;

   161     }

   162    

   163 

   164 void CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::OutputHeaderL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   165     {

   166     _LIT( KHeaderLine, "Type, File Name, Thread, File Size, Instance Id, Attribs");

   167     aSink.OutputLineL( KHeaderLine );

   168     }

   169  

   170 

   171 void CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::OutputContentL( CMemSpyEngineOutputSink& aSink, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   172     {

   173     _LIT( KFormat, "%S,%S,%S,%d,%d,%S" );

   174     //

   175     TMemSpySWMTTypeName type;;

   176     FormatType( type );

   177     //

   178     TBuf<20> attribs;

   179     FormatAttributes( attribs );

   180     //

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

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

   183 

   184     // Now output line

   185     pBuf.Format( KFormat,

   186                  &type,

   187                  iFileName,

   188                  iThreadName,

   189                  iSize,

   190                  iUniqueFileId,

   191                  &attribs

   192                  );

   193 

   194     aSink.OutputLineL( pBuf );

   195     CleanupStack::PopAndDestroy( buf );

   196     }

   197 

   198 

   199 void CMemSpyEngineHelperSysMemTrackerCycleChangeOpenFile::OutputDataL( CMemSpyEngineOutputSink& /*aSink*/, CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   200     {

   201     }