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/memspyenginehelperkernelcontainers.h>

    19 

    20 // User includes

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

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

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

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

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

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

    27 

    28 // Driver includes

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

    30 #include <memspy/driver/memspydriverconstants.h>

    31 #include <memspy/driver/memspydriverenumerationsshared.h>

    32 

    33 // Constants

    34 const TInt KMaxGenericHandleCount = 1024 * 2;

    35 _LIT( KMemSpyMarkerKernelContainer, "<%SMEMSPY_KERNEL_CONTAINER_%02d>" );

    36 _LIT( KMemSpyMarkerKernelContainersAll, "<%SMEMSPY_KERNEL_CONTAINERS>" );

    37 

    38 

    39 

    40 CMemSpyEngineHelperKernelContainers::CMemSpyEngineHelperKernelContainers( CMemSpyEngine& aEngine )

    41 :   iEngine( aEngine )

    42     {

    43     }

    44 

    45     

    46 CMemSpyEngineHelperKernelContainers::~CMemSpyEngineHelperKernelContainers()

    47     {

    48     }

    49 

    50 

    51 void CMemSpyEngineHelperKernelContainers::ConstructL()

    52     {

    53     }

    54 

    55 

    56 CMemSpyEngineHelperKernelContainers* CMemSpyEngineHelperKernelContainers::NewL( CMemSpyEngine& aEngine )

    57     {

    58     CMemSpyEngineHelperKernelContainers* self = new(ELeave) CMemSpyEngineHelperKernelContainers( aEngine );

    59     CleanupStack::PushL( self );

    60     self->ConstructL();

    61     CleanupStack::Pop( self );

    62     return self;

    63     }

    64 

    65 

    66 EXPORT_C CMemSpyEngineGenericKernelObjectList* CMemSpyEngineHelperKernelContainers::ObjectsForSpecificContainerL( TMemSpyDriverContainerType aForContainer )

    67     {

    68     CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( aForContainer, iEngine );

    69     AddObjectsFromContainerL( *list, aForContainer );

    70     CleanupStack::Pop( list );

    71     return list;

    72     }

    73 

    74 

    75 EXPORT_C CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineHelperKernelContainers::ObjectsAllL()

    76     {

    77     CMemSpyEngineGenericKernelObjectContainer* container = CMemSpyEngineGenericKernelObjectContainer::NewLC();

    78     //

    79     for( TInt i=EMemSpyDriverContainerTypeFirst; i<=EMemSpyDriverContainerTypeLast; i++ )

    80         {

    81         const TMemSpyDriverContainerType type = static_cast< TMemSpyDriverContainerType >( i );

    82         //

    83         CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( type, iEngine );

    84         AddObjectsFromContainerL( *list, type );

    85         container->AddListL( list );

    86         CleanupStack::Pop( list );

    87         }

    88     //

    89     CleanupStack::Pop( container );

    90     return container;

    91     }

    92 

    93 

    94 CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineHelperKernelContainers::ObjectsAllLightweightL()

    95     {

    96     CMemSpyEngineGenericKernelObjectContainer* container = CMemSpyEngineGenericKernelObjectContainer::NewLC();

    97     //

    98     for( TInt i=EMemSpyDriverContainerTypeFirst; i<=EMemSpyDriverContainerTypeLast; i++ )

    99         {

   100         const TMemSpyDriverContainerType type = static_cast< TMemSpyDriverContainerType >( i );

   101         //

   102         CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( type, iEngine );

   103         AddObjectsFromContainerL( *list, type, EFalse );

   104         container->AddListL( list );

   105         CleanupStack::Pop( list );

   106         }

   107     //

   108     CleanupStack::Pop( container );

   109     return container;

   110     }

   111 

   112 

   113 TMemSpyDriverContainerType CMemSpyEngineHelperKernelContainers::MapToType( TObjectType aType )

   114     {

   115     TMemSpyDriverContainerType ret = EMemSpyDriverContainerTypeUnknown;

   116     //

   117     if ( aType >= EMemSpyDriverContainerTypeFirst && aType <= EMemSpyDriverContainerTypeLast )

   118         {

   119         ret = (TMemSpyDriverContainerType) aType;

   120         }

   121     //

   122     return ret;

   123     }

   124 

   125 

   126 EXPORT_C void CMemSpyEngineHelperKernelContainers::OutputL( const CMemSpyEngineGenericKernelObjectContainer& aContainer ) const

   127     {

   128     aContainer.OutputL( iEngine.Sink() );

   129     }

   130 

   131 

   132 CMemSpyEngine& CMemSpyEngineHelperKernelContainers::Engine() const

   133     {

   134     return iEngine;

   135     }

   136 

   137 

   138 void CMemSpyEngineHelperKernelContainers::AddObjectsFromContainerL( CMemSpyEngineGenericKernelObjectList& aList, TMemSpyDriverContainerType aContainer, TBool aGetInfo )

   139     {

   140 	TAny* handles[KMaxGenericHandleCount];

   141 	TInt c = KMaxGenericHandleCount;

   142 

   143 	TInt r = iEngine.Driver().GetContainerHandles( aContainer, handles, c );

   144 	if  ( r == KErrNone )

   145     	{

   146         if  ( c > 0 )

   147             {

   148         	if (c > KMaxGenericHandleCount)

   149         		{

   150         		c = KMaxGenericHandleCount;

   151         		}

   152 

   153         	TMemSpyDriverHandleInfoGeneric info;

   154         	for (TInt i=0; i<c && r == KErrNone; i++)

   155         		{

   156                 if  ( aGetInfo )

   157                     {

   158         		    r = iEngine.Driver().GetGenericHandleInfo( KMemSpyDriverEnumerateContainerHandles, aContainer, handles[i], info );

   159         		    if  ( r == KErrNone )

   160         			    {

   161         			    aList.AddItemL( info );

   162         			    }

   163                     }

   164                 else

   165                     {

   166                     aList.AddItemL( handles[ i ] );

   167                     }

   168         		}

   169             }

   170         }

   171     }

   172 

   173 

   174 

   175 

   176 

   177 

   178 

   179 

   180 

   181 

   182 

   183 

   184 

   185 

   186 

   187 

   188 

   189 

   190 

   191 

   192 

   193 

   194 

   195 

   196 

   197 

   198 

   199 

   200 

   201 

   202 

   203 CMemSpyEngineGenericKernelObjectList::CMemSpyEngineGenericKernelObjectList( TMemSpyDriverContainerType aType )

   204 :   iType( aType ), iItems( 25 ), iHandles( 25 )

   205     {

   206     }

   207 

   208 

   209 EXPORT_C CMemSpyEngineGenericKernelObjectList::~CMemSpyEngineGenericKernelObjectList()

   210     {

   211     delete iName;

   212     iHandles.Close();

   213     iItems.Close();

   214     }

   215 

   216 

   217 void CMemSpyEngineGenericKernelObjectList::ConstructL( CMemSpyEngine& aEngine )

   218     {

   219     iName = HBufC::NewL( KMaxFullName );

   220     iSize = aEngine.Driver().GetApproximateKernelObjectSize( iType );

   221     UpdateNameL();

   222     }

   223 

   224 

   225 CMemSpyEngineGenericKernelObjectList* CMemSpyEngineGenericKernelObjectList::NewLC( TMemSpyDriverContainerType aType, CMemSpyEngine& aEngine )

   226     {

   227     CMemSpyEngineGenericKernelObjectList* self = new(ELeave) CMemSpyEngineGenericKernelObjectList( aType );

   228     CleanupStack::PushL( self );

   229     self->ConstructL( aEngine );

   230     return self;

   231     }

   232 

   233 

   234 EXPORT_C TInt CMemSpyEngineGenericKernelObjectList::Count() const

   235     {

   236     return iHandles.Count();

   237     }

   238 

   239 

   240 EXPORT_C const TMemSpyDriverHandleInfoGeneric& CMemSpyEngineGenericKernelObjectList::At( TInt aIndex ) const

   241     {

   242     return iItems[ aIndex ];

   243     }

   244 

   245 

   246 EXPORT_C TMemSpyDriverContainerType CMemSpyEngineGenericKernelObjectList::Type() const

   247     {

   248     return iType;

   249     }

   250     

   251 

   252 EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::TypeAsString( TMemSpyDriverContainerType aType )

   253     {

   254     _LIT( KTypeUnknown, "Unknown Type" );

   255     _LIT( KTypeThread, "Thread" );

   256     _LIT( KTypeProcess, "Process" );

   257     _LIT( KTypeChunk, "Chunk" );

   258     _LIT( KTypeLibrary, "Library" );

   259     _LIT( KTypeSemaphore, "Semaphore" );

   260     _LIT( KTypeMutex, "Mutex" );

   261     _LIT( KTypeTimer, "Timer" );

   262     _LIT( KTypeServer, "Server" );

   263     _LIT( KTypeSession, "Session" );

   264     _LIT( KTypeLogicalDevice, "Logical Device" );

   265     _LIT( KTypePhysicalDevice, "Physical Device" );

   266     _LIT( KTypeLogicalChannel, "Logical Channel" );

   267     _LIT( KTypeChangeNotifier, "Change Notifier" );

   268     _LIT( KTypeUndertaker, "Undertaker" );

   269     _LIT( KTypeMsgQueue, "Msg. Queue" );

   270     _LIT( KTypePropertyRef, "Property Ref." );

   271     _LIT( KTypeCondVar, "Conditional Var." );

   272      //

   273     TPtrC pType( KTypeUnknown );

   274     //

   275     switch( aType )

   276         {

   277     case EMemSpyDriverContainerTypeThread:

   278         pType.Set( KTypeThread );

   279         break;

   280     case EMemSpyDriverContainerTypeProcess:

   281         pType.Set( KTypeProcess );

   282         break;

   283     case EMemSpyDriverContainerTypeChunk:

   284         pType.Set( KTypeChunk );

   285         break;

   286     case EMemSpyDriverContainerTypeLibrary:

   287         pType.Set( KTypeLibrary );

   288         break;

   289     case EMemSpyDriverContainerTypeSemaphore:

   290         pType.Set( KTypeSemaphore );

   291         break;

   292     case EMemSpyDriverContainerTypeMutex:

   293         pType.Set( KTypeMutex );

   294         break;

   295     case EMemSpyDriverContainerTypeTimer:

   296         pType.Set( KTypeTimer );

   297         break;

   298     case EMemSpyDriverContainerTypeServer:

   299         pType.Set( KTypeServer );

   300         break;

   301     case EMemSpyDriverContainerTypeSession:

   302         pType.Set( KTypeSession );

   303         break;

   304     case EMemSpyDriverContainerTypeLogicalDevice:

   305         pType.Set( KTypeLogicalDevice );

   306         break;

   307     case EMemSpyDriverContainerTypePhysicalDevice:

   308         pType.Set( KTypePhysicalDevice );

   309         break;

   310     case EMemSpyDriverContainerTypeLogicalChannel:

   311         pType.Set( KTypeLogicalChannel );

   312         break;

   313     case EMemSpyDriverContainerTypeChangeNotifier:

   314         pType.Set( KTypeChangeNotifier );

   315         break;

   316     case EMemSpyDriverContainerTypeUndertaker:

   317         pType.Set( KTypeUndertaker );

   318         break;

   319     case EMemSpyDriverContainerTypeMsgQueue:

   320         pType.Set( KTypeMsgQueue );

   321         break;

   322     case EMemSpyDriverContainerTypePropertyRef:

   323         pType.Set( KTypePropertyRef );

   324         break;

   325     case EMemSpyDriverContainerTypeCondVar:

   326         pType.Set( KTypeCondVar );

   327         break;

   328         

   329     default:

   330         break;

   331         }

   332     //

   333     return pType;

   334     }

   335 

   336 

   337 EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::Name() const

   338     {

   339     return TPtrC( *iName );

   340     }

   341 

   342 

   343 EXPORT_C void CMemSpyEngineGenericKernelObjectList::OutputL( CMemSpyEngineOutputSink& aSink ) const

   344     {

   345     // Start marker

   346     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainer, &KNullDesC, iType );

   347 

   348     TBuf<70> itemPrefix;

   349     TBuf<KMaxFullName + 128> buf;

   350     const TInt entryCount = Count();

   351     const TInt64 size( iSize * entryCount );

   352     const TMemSpySizeText sizeText( MemSpyEngineUtils::FormatSizeText( size, 0 ) );

   353     //    

   354     _LIT(KContainerTitle, "CONTAINER \'%S\' => %d item(s), %S");

   355     const TPtrC pType( TypeAsString( iType ) );

   356     buf.Format(KContainerTitle, &pType, entryCount, &sizeText);

   357     aSink.OutputSectionHeadingL( buf, '=' );

   358     //

   359     for( TInt entryIndex=0; entryIndex<entryCount; entryIndex++ )

   360         {

   361         const TMemSpyDriverHandleInfoGeneric& entry = At( entryIndex );

   362         //

   363         _LIT( KItemPrefixFormat, "[KernCont] {%04d} 0x%08x" );

   364         itemPrefix.Format( KItemPrefixFormat, entryIndex, entry.iHandle );

   365 

   366         buf.Copy( entry.iName );

   367 

   368         aSink.OutputItemAndValueL( itemPrefix, buf );

   369         }

   370 

   371     // End marker

   372     aSink.OutputBlankLineL();

   373     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainer, &KMemSpySinkTagClose, iType );

   374     aSink.OutputBlankLineL();

   375     }

   376 

   377 

   378 TAny* CMemSpyEngineGenericKernelObjectList::HandleAt( TInt aIndex ) const

   379     {

   380     return iHandles[ aIndex ];

   381     }

   382 

   383 

   384 void CMemSpyEngineGenericKernelObjectList::AddItemL( TAny* aHandle )

   385     {

   386     iHandles.InsertInAddressOrderL( aHandle );

   387     }

   388 

   389 

   390 void CMemSpyEngineGenericKernelObjectList::AddItemL( const TMemSpyDriverHandleInfoGeneric& aItem )

   391     {

   392     AddItemL( aItem.iHandle );

   393     iItems.AppendL( aItem );

   394     //

   395     UpdateNameL();

   396     }

   397 

   398 

   399 void CMemSpyEngineGenericKernelObjectList::UpdateNameL()

   400     {

   401     const TInt count = iItems.Count();

   402     const TInt64 size( iSize * count );

   403     const TMemSpySizeText sizeText( MemSpyEngineUtils::FormatSizeText( size, 0 ) );

   404     //

   405     _LIT(KNameFormat, "\t%S\t\t%d item");

   406     TPtr pName( iName->Des() );

   407     //

   408     const TPtrC pType( TypeAsString( iType ) );

   409     //

   410     pName.Format( KNameFormat, &pType, count );

   411     //

   412     if  ( count == 0 || count > 1 )

   413         {

   414         pName.Append( _L("s") );

   415         }

   416 

   417     pName.AppendFormat( _L(", %S"), &sizeText );

   418     }

   419 

   420 

   421 

   422 

   423 

   424 

   425 

   426 

   427 

   428 

   429 

   430 

   431 

   432 

   433 

   434 

   435 

   436 

   437 

   438 

   439 

   440 

   441 

   442 

   443 

   444 CMemSpyEngineGenericKernelObjectContainer::CMemSpyEngineGenericKernelObjectContainer()

   445 :   iItems( 25 )

   446     {

   447     }

   448 

   449 

   450 EXPORT_C CMemSpyEngineGenericKernelObjectContainer::~CMemSpyEngineGenericKernelObjectContainer()

   451     {

   452     iItems.ResetAndDestroy();

   453     iItems.Close();

   454     }

   455 

   456 

   457 void CMemSpyEngineGenericKernelObjectContainer::ConstructL()

   458     {

   459     }

   460 

   461 

   462 CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineGenericKernelObjectContainer::NewLC()

   463     {

   464     CMemSpyEngineGenericKernelObjectContainer* self = new(ELeave) CMemSpyEngineGenericKernelObjectContainer();

   465     CleanupStack::PushL( self );

   466     self->ConstructL();

   467     return self;

   468     }

   469 

   470 

   471 EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::Count() const

   472     {

   473     return iItems.Count();

   474     }

   475 

   476 

   477 EXPORT_C const CMemSpyEngineGenericKernelObjectList& CMemSpyEngineGenericKernelObjectContainer::At( TInt aIndex ) const

   478     {

   479     return *iItems[ aIndex ];

   480     }

   481 

   482 

   483 EXPORT_C void CMemSpyEngineGenericKernelObjectContainer::OutputL( CMemSpyEngineOutputSink& aSink ) const

   484     {

   485     // Start marker

   486     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KNullDesC );

   487 

   488     const TInt listCount= Count();

   489     for( TInt listIndex=0; listIndex<listCount; listIndex++ )

   490         {

   491         const CMemSpyEngineGenericKernelObjectList& list = At( listIndex );

   492         list.OutputL( aSink );

   493         }

   494 

   495     // End marker

   496     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KMemSpySinkTagClose );

   497     }

   498 

   499 

   500 void CMemSpyEngineGenericKernelObjectContainer::AddListL( CMemSpyEngineGenericKernelObjectList* aList )

   501     {

   502     iItems.AppendL( aList );

   503     }

   504 

   505 

   506 EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::MdcaCount() const

   507     {

   508     return Count();

   509     }

   510 

   511 

   512 EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectContainer::MdcaPoint( TInt aIndex ) const

   513     {

   514     const CMemSpyEngineGenericKernelObjectList& item = At( aIndex );

   515     return item.Name();

   516     }

   517 

   518 

   519 

   520 

   521 

   522 

   523 

   524 

   525 

   526 

   527 

   528 

   529 

   530 

   531 

   532