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 EXPORT_C TInt CMemSpyEngineGenericKernelObjectList::Size() const

   252     {

   253     return iSize;

   254     }

   255 

   256 EXPORT_C TInt CMemSpyEngineGenericKernelObjectList::ItemsCount() const

   257 	{

   258 	return iItems.Count();

   259 	}

   260     

   261 

   262 EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::TypeAsString( TMemSpyDriverContainerType aType )

   263     {

   264     _LIT( KTypeUnknown, "Unknown Type" );

   265     _LIT( KTypeThread, "Thread" );

   266     _LIT( KTypeProcess, "Process" );

   267     _LIT( KTypeChunk, "Chunk" );

   268     _LIT( KTypeLibrary, "Library" );

   269     _LIT( KTypeSemaphore, "Semaphore" );

   270     _LIT( KTypeMutex, "Mutex" );

   271     _LIT( KTypeTimer, "Timer" );

   272     _LIT( KTypeServer, "Server" );

   273     _LIT( KTypeSession, "Session" );

   274     _LIT( KTypeLogicalDevice, "Logical Device" );

   275     _LIT( KTypePhysicalDevice, "Physical Device" );

   276     _LIT( KTypeLogicalChannel, "Logical Channel" );

   277     _LIT( KTypeChangeNotifier, "Change Notifier" );

   278     _LIT( KTypeUndertaker, "Undertaker" );

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

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

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

   282      //

   283     TPtrC pType( KTypeUnknown );

   284     //

   285     switch( aType )

   286         {

   287     case EMemSpyDriverContainerTypeThread:

   288         pType.Set( KTypeThread );

   289         break;

   290     case EMemSpyDriverContainerTypeProcess:

   291         pType.Set( KTypeProcess );

   292         break;

   293     case EMemSpyDriverContainerTypeChunk:

   294         pType.Set( KTypeChunk );

   295         break;

   296     case EMemSpyDriverContainerTypeLibrary:

   297         pType.Set( KTypeLibrary );

   298         break;

   299     case EMemSpyDriverContainerTypeSemaphore:

   300         pType.Set( KTypeSemaphore );

   301         break;

   302     case EMemSpyDriverContainerTypeMutex:

   303         pType.Set( KTypeMutex );

   304         break;

   305     case EMemSpyDriverContainerTypeTimer:

   306         pType.Set( KTypeTimer );

   307         break;

   308     case EMemSpyDriverContainerTypeServer:

   309         pType.Set( KTypeServer );

   310         break;

   311     case EMemSpyDriverContainerTypeSession:

   312         pType.Set( KTypeSession );

   313         break;

   314     case EMemSpyDriverContainerTypeLogicalDevice:

   315         pType.Set( KTypeLogicalDevice );

   316         break;

   317     case EMemSpyDriverContainerTypePhysicalDevice:

   318         pType.Set( KTypePhysicalDevice );

   319         break;

   320     case EMemSpyDriverContainerTypeLogicalChannel:

   321         pType.Set( KTypeLogicalChannel );

   322         break;

   323     case EMemSpyDriverContainerTypeChangeNotifier:

   324         pType.Set( KTypeChangeNotifier );

   325         break;

   326     case EMemSpyDriverContainerTypeUndertaker:

   327         pType.Set( KTypeUndertaker );

   328         break;

   329     case EMemSpyDriverContainerTypeMsgQueue:

   330         pType.Set( KTypeMsgQueue );

   331         break;

   332     case EMemSpyDriverContainerTypePropertyRef:

   333         pType.Set( KTypePropertyRef );

   334         break;

   335     case EMemSpyDriverContainerTypeCondVar:

   336         pType.Set( KTypeCondVar );

   337         break;

   338         

   339     default:

   340         break;

   341         }

   342     //

   343     return pType;

   344     }

   345 

   346 

   347 EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::Name() const

   348     {

   349     return TPtrC( *iName );

   350     }

   351 

   352 

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

   354     {

   355     // Start marker

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

   357 

   358     TBuf<70> itemPrefix;

   359     TBuf<KMaxFullName + 128> buf;

   360     const TInt entryCount = Count();

   361     const TInt64 size( iSize * entryCount );

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

   363     //    

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

   365     const TPtrC pType( TypeAsString( iType ) );

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

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

   368     //

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

   370         {

   371         const TMemSpyDriverHandleInfoGeneric& entry = At( entryIndex );

   372         //

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

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

   375 

   376         buf.Copy( entry.iName );

   377 

   378         aSink.OutputItemAndValueL( itemPrefix, buf );

   379         }

   380 

   381     // End marker

   382     aSink.OutputBlankLineL();

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

   384     aSink.OutputBlankLineL();

   385     }

   386 

   387 

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

   389     {

   390     return iHandles[ aIndex ];

   391     }

   392 

   393 

   394 void CMemSpyEngineGenericKernelObjectList::AddItemL( TAny* aHandle )

   395     {

   396     iHandles.InsertInAddressOrderL( aHandle );

   397     }

   398 

   399 

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

   401     {

   402     AddItemL( aItem.iHandle );

   403     iItems.AppendL( aItem );

   404     //

   405     //UpdateNameL();

   406     }

   407 

   408 

   409 void CMemSpyEngineGenericKernelObjectList::UpdateNameL()

   410     {

   411     const TInt count = iItems.Count();

   412     const TInt64 size( iSize * count );

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

   414     //

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

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

   417     //

   418     const TPtrC pType( TypeAsString( iType ) );

   419     //

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

   421     //

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

   423         {

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

   425         }

   426 

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

   428     }

   429 

   430 

   431 

   432 

   433 

   434 

   435 

   436 

   437 

   438 

   439 

   440 

   441 

   442 

   443 

   444 

   445 

   446 

   447 

   448 

   449 

   450 

   451 

   452 

   453 

   454 CMemSpyEngineGenericKernelObjectContainer::CMemSpyEngineGenericKernelObjectContainer()

   455 :   iItems( 25 )

   456     {

   457     }

   458 

   459 

   460 EXPORT_C CMemSpyEngineGenericKernelObjectContainer::~CMemSpyEngineGenericKernelObjectContainer()

   461     {

   462     iItems.ResetAndDestroy();

   463     iItems.Close();

   464     }

   465 

   466 

   467 void CMemSpyEngineGenericKernelObjectContainer::ConstructL()

   468     {

   469     }

   470 

   471 

   472 CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineGenericKernelObjectContainer::NewLC()

   473     {

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

   475     CleanupStack::PushL( self );

   476     self->ConstructL();

   477     return self;

   478     }

   479 

   480 

   481 EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::Count() const

   482     {

   483     return iItems.Count();

   484     }

   485 

   486 

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

   488     {

   489     return *iItems[ aIndex ];

   490     }

   491 

   492 

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

   494     {

   495     // Start marker

   496     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KNullDesC );

   497 

   498     const TInt listCount= Count();

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

   500         {

   501         const CMemSpyEngineGenericKernelObjectList& list = At( listIndex );

   502         list.OutputL( aSink );

   503         }

   504 

   505     // End marker

   506     aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KMemSpySinkTagClose );

   507     }

   508 

   509 

   510 void CMemSpyEngineGenericKernelObjectContainer::AddListL( CMemSpyEngineGenericKernelObjectList* aList )

   511     {

   512     iItems.AppendL( aList );

   513     }

   514 

   515 

   516 EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::MdcaCount() const

   517     {

   518     return Count();

   519     }

   520 

   521 

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

   523     {

   524     const CMemSpyEngineGenericKernelObjectList& item = At( aIndex );

   525     return item.Name();

   526     }

   527 

   528 

   529 

   530 

   531 

   532 

   533 

   534 

   535 

   536 

   537 

   538 

   539 

   540 

   541 

   542