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

    19 

    20 // Shared includes

    21 #include "MemSpyDriverOpCodes.h"

    22 #include <memspy/driver/memspydriverobjectsshared.h>

    23 #include "MemSpyDriverObjectsInternal.h"

    24 

    25 // User includes

    26 #include "MemSpyDriverUtils.h"

    27 #include "MemSpyDriverDevice.h"

    28 #include "MemSpyDriverOSAdaption.h"

    29 

    30 

    31 DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase( DMemSpyDriverDevice& aDevice, DThread& aThread )

    32 :   DMemSpyDriverLogChanBase( aDevice, aThread )

    33     {

    34 	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase() - this: 0x%08x", this ));

    35     }

    36 

    37 

    38 DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase()

    39 	{

    40 	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - START - this: 0x%08x", this ));

    41 

    42     ResetTempHandles();

    43 

    44 	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - END - this: 0x%08x", this ));

    45 	}

    46 

    47 

    48 

    49 

    50 

    51 

    52 

    53 

    54 

    55 DObject* DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer( TMemSpyDriverContainerType aContainerType, DObject* aSearchFor, TBool aQuick )

    56     {

    57 	__ASSERT_DEBUG( aSearchFor != NULL, MemSpyDriverUtils::Fault( __LINE__ ) );

    58     const TObjectType expectedType = ObjectTypeFromMemSpyContainerType( aContainerType );

    59     TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - START - aSearchFor: 0x%08x, expectedType: %d", aSearchFor, expectedType ));

    60 

    61     DObject* ret = NULL;

    62     

    63     // Quick mode means we just check container ids and we trust that the object

    64     // will exist.

    65     if ( aQuick )

    66         {

    67         const TObjectType objectType = OSAdaption().DThread().GetObjectType( *aSearchFor );

    68         TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - aSearchFor.iContainerID: %d", objectType ) );

    69         if  ( objectType == expectedType )

    70             {

    71             ret = aSearchFor;

    72             }

    73         }

    74     else

    75         {

    76         // Full check to see if the specified object is part of the container

    77         DObjectCon* container = Kern::Containers()[ expectedType ];

    78         container->Wait();

    79         NKern::LockSystem();

    80 

    81         const TInt count = container->Count();

    82         for(TInt i=0; i<count; i++)

    83             {

    84             DObject* object = (*container)[ i ];

    85 

    86             // Do the two match?

    87             if  ( object == aSearchFor )

    88                 {

    89                 TRACE( Kern::Printf("    found match: %O", object));

    90 

    91                 ret = object;

    92                 break;

    93                 }

    94             }

    95 

    96         NKern::UnlockSystem();

    97         container->Signal();

    98         }

    99 

   100     TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - END - ret: 0x%08x", ret ));

   101     TRACE( Kern::Printf(" ") );

   102     return ret;

   103     }

   104 

   105 

   106 

   107 TObjectType DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType( TMemSpyDriverContainerType aType )

   108     {

   109     // Map type

   110     TObjectType type = EObjectTypeAny;

   111     switch( aType )

   112         {

   113     case EMemSpyDriverContainerTypeThread:

   114  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeThread" ));

   115         type = EThread;

   116         break;

   117     case EMemSpyDriverContainerTypeProcess:

   118  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeProcess" ));

   119         type = EProcess;

   120         break;

   121     case EMemSpyDriverContainerTypeChunk:

   122  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChunk" ));

   123         type = EChunk;

   124         break;

   125     case EMemSpyDriverContainerTypeLibrary:

   126  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLibrary" ));

   127         type = ELibrary;

   128         break;

   129     case EMemSpyDriverContainerTypeSemaphore:

   130  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSemaphore" ));

   131         type = ESemaphore;

   132         break;

   133     case EMemSpyDriverContainerTypeMutex:

   134  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMutex" ));

   135         type = EMutex;

   136         break;

   137     case EMemSpyDriverContainerTypeTimer:

   138  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeTimer" ));

   139         type = ETimer;

   140         break;

   141     case EMemSpyDriverContainerTypeServer:

   142  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeServer" ));

   143         type = EServer;

   144         break;

   145     case EMemSpyDriverContainerTypeSession:

   146  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSession" ));

   147         type = ESession;

   148         break;

   149     case EMemSpyDriverContainerTypeLogicalDevice:

   150  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalDevice" ));

   151         type = ELogicalDevice;

   152         break;

   153     case EMemSpyDriverContainerTypePhysicalDevice:

   154  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePhysicalDevice" ));

   155         type = EPhysicalDevice;

   156         break;

   157     case EMemSpyDriverContainerTypeLogicalChannel:

   158  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalChannel" ));

   159         type = ELogicalChannel;

   160         break;

   161     case EMemSpyDriverContainerTypeChangeNotifier:

   162  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChangeNotifier" ));

   163         type = EChangeNotifier;

   164         break;

   165     case EMemSpyDriverContainerTypeUndertaker:

   166  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeUndertaker" ));

   167         type = EUndertaker;

   168         break;

   169     case EMemSpyDriverContainerTypeMsgQueue:

   170  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMsgQueue" ));

   171         type = EMsgQueue;

   172         break;

   173     case EMemSpyDriverContainerTypePropertyRef:

   174  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePropertyRef" ));

   175         type = EPropertyRef;

   176         break;

   177     case EMemSpyDriverContainerTypeCondVar:

   178  	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeCondVar" ));

   179         type = ECondVar;

   180         break;

   181     default:

   182         Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType - unsupported container type: %d", aType);

   183         break;

   184         }

   185     //

   186     return type;

   187     }

   188 

   189 

   190 

   191 

   192 

   193 

   194 

   195 

   196 

   197 

   198 

   199 

   200 

   201 

   202 

   203 

   204 

   205 

   206 

   207 

   208 

   209 

   210 

   211 

   212 

   213 

   214 

   215 

   216     

   217 

   218 void DMemSpyDriverLogChanContainerBase::ResetTempHandles()

   219     {

   220     iTempHandleCount = 0;

   221     }

   222 

   223 

   224 void DMemSpyDriverLogChanContainerBase::AddTempHandle( TAny* aHandle )

   225     {

   226     __ASSERT_ALWAYS( iTempHandleCount >= 0, MemSpyDriverUtils::Fault( __LINE__) );

   227     if  ( iTempHandleCount < KMemSpyDriverMaxHandles )

   228         {

   229         iTempHandles[ iTempHandleCount++ ] = aHandle;

   230         }

   231     }

   232 

   233 

   234 TAny* DMemSpyDriverLogChanContainerBase::TempHandleAt( TInt aIndex ) const

   235     {

   236     __ASSERT_ALWAYS( aIndex >= 0 && aIndex < KMemSpyDriverMaxHandles, MemSpyDriverUtils::Fault(__LINE__) );

   237     __ASSERT_ALWAYS( aIndex < iTempHandleCount, MemSpyDriverUtils::Fault(__LINE__) );

   238     return iTempHandles[ aIndex ];

   239     }

   240 

   241 

   242 TInt DMemSpyDriverLogChanContainerBase::TempHandleCount() const

   243     {

   244     TRACE( Kern::Printf( "DMemSpyDriverLogChanContainerBase::TempHandleCount() - END - count is: %d", iTempHandleCount ));

   245     return iTempHandleCount;

   246     }

   247 

   248 

   249 TInt DMemSpyDriverLogChanContainerBase::WriteToClient( TAny** aHandlePtr, TInt* aCountPtr, TInt aMaxCount )

   250     {

   251 	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::WriteToClient() - START - iTempHandleCount: %d", iTempHandleCount ));

   252 

   253     TInt r = KErrNone;

   254 

   255     // This variable holds the number of handles that we have already

   256 	// written to the client-side.

   257 	TInt currentWriteIndex = 0;

   258 

   259     // If the client passed a bad descriptor then we panic it. Otherwise, we always update the amount

   260     // of handles we have found (even if there was an error - i.e. we set the value to zero) or else

   261     // the client will attempt to index through its huge stack-based handle array.

   262 	NKern::ThreadEnterCS();

   263     TInt tempHandleCount = TempHandleCount();

   264     TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles - trying to write %d handles to client...", tempHandleCount ));

   265 

   266     for( ; currentWriteIndex<tempHandleCount && r == KErrNone && currentWriteIndex < aMaxCount; )

   267         {

   268         TAny* handle = TempHandleAt( currentWriteIndex );

   269         r = Kern::ThreadRawWrite( &ClientThread(), aHandlePtr + currentWriteIndex, &handle, sizeof(TAny*) );

   270         if  (r == KErrNone)

   271             {

   272             ++currentWriteIndex;

   273             }

   274         }

   275 

   276 	if  ( r == KErrBadDescriptor )

   277         {

   278         MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );

   279         }

   280     else

   281         {

   282         const TInt finalWrite = Kern::ThreadRawWrite( &ClientThread(), aCountPtr, &currentWriteIndex, sizeof(TInt) );

   283         if  ( r == KErrNone )

   284             {

   285             r = finalWrite;

   286             }

   287         }

   288 	NKern::ThreadLeaveCS();

   289 

   290 	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles() - END - r: %d", r));

   291 	return r;

   292     }