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 DObject* DMemSpyDriverLogChanContainerBase::CheckedOpen(TMemSpyDriverContainerType aContainerType, DObject* aObject, TBool aQuick)

    53 	{

    54 	__ASSERT_CRITICAL;

    55 	__ASSERT_DEBUG(aObject != NULL, MemSpyDriverUtils::Fault( __LINE__ ));

    56     const TObjectType expectedType = ObjectTypeFromMemSpyContainerType(aContainerType);

    57 

    58     // Quick mode means we just check container ids and we trust that the object will exist.

    59 	// [TomS: not entirely convinced we can ever be certain of that]

    60     TInt err = KErrNotFound;

    61     if (aQuick)

    62         {

    63 		LOG("quick CheckedOpen of %08x", aObject);

    64         const TObjectType objectType = OSAdaption().DThread().GetObjectType(*aObject);

    65         if (objectType == expectedType)

    66             {

    67             err = aObject->Open();

    68             }

    69         }

    70 	else

    71 		{

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

    73         container->Wait();

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

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

    76             {

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

    78             if (object == aObject)

    79                 {

    80                 err = aObject->Open();

    81 				break;

    82 				}

    83 			}

    84 		container->Signal();

    85 		}

    86 

    87 	LOG("CheckedOpen(%d, 0x%08x, quick=%d) returned error %d", aContainerType, aObject, aQuick, err);

    88 	return (err == KErrNone) ? aObject : NULL;

    89 	}

    90 

    91 

    92 

    93 TObjectType DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType( TMemSpyDriverContainerType aType )

    94     {

    95     // Map type

    96     TObjectType type = EObjectTypeAny;

    97     switch( aType )

    98         {

    99     case EMemSpyDriverContainerTypeThread:

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

   101         type = EThread;

   102         break;

   103     case EMemSpyDriverContainerTypeProcess:

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

   105         type = EProcess;

   106         break;

   107     case EMemSpyDriverContainerTypeChunk:

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

   109         type = EChunk;

   110         break;

   111     case EMemSpyDriverContainerTypeLibrary:

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

   113         type = ELibrary;

   114         break;

   115     case EMemSpyDriverContainerTypeSemaphore:

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

   117         type = ESemaphore;

   118         break;

   119     case EMemSpyDriverContainerTypeMutex:

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

   121         type = EMutex;

   122         break;

   123     case EMemSpyDriverContainerTypeTimer:

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

   125         type = ETimer;

   126         break;

   127     case EMemSpyDriverContainerTypeServer:

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

   129         type = EServer;

   130         break;

   131     case EMemSpyDriverContainerTypeSession:

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

   133         type = ESession;

   134         break;

   135     case EMemSpyDriverContainerTypeLogicalDevice:

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

   137         type = ELogicalDevice;

   138         break;

   139     case EMemSpyDriverContainerTypePhysicalDevice:

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

   141         type = EPhysicalDevice;

   142         break;

   143     case EMemSpyDriverContainerTypeLogicalChannel:

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

   145         type = ELogicalChannel;

   146         break;

   147     case EMemSpyDriverContainerTypeChangeNotifier:

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

   149         type = EChangeNotifier;

   150         break;

   151     case EMemSpyDriverContainerTypeUndertaker:

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

   153         type = EUndertaker;

   154         break;

   155     case EMemSpyDriverContainerTypeMsgQueue:

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

   157         type = EMsgQueue;

   158         break;

   159     case EMemSpyDriverContainerTypePropertyRef:

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

   161         type = EPropertyRef;

   162         break;

   163     case EMemSpyDriverContainerTypeCondVar:

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

   165         type = ECondVar;

   166         break;

   167     default:

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

   169         break;

   170         }

   171     //

   172     return type;

   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 

   204 void DMemSpyDriverLogChanContainerBase::ResetTempHandles()

   205     {

   206     iTempHandleCount = 0;

   207     }

   208 

   209 

   210 void DMemSpyDriverLogChanContainerBase::AddTempHandle( TAny* aHandle )

   211     {

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

   213     if  ( iTempHandleCount < KMemSpyDriverMaxHandles )

   214         {

   215         iTempHandles[ iTempHandleCount++ ] = aHandle;

   216         }

   217     }

   218 

   219 

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

   221     {

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

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

   224     return iTempHandles[ aIndex ];

   225     }

   226 

   227 

   228 TInt DMemSpyDriverLogChanContainerBase::TempHandleCount() const

   229     {

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

   231     return iTempHandleCount;

   232     }

   233 

   234 

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

   236     {

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

   238 

   239     TInt r = KErrNone;

   240 

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

   242 	// written to the client-side.

   243 	TInt currentWriteIndex = 0;

   244 

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

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

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

   248 	NKern::ThreadEnterCS();

   249     TInt tempHandleCount = TempHandleCount();

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

   251 

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

   253         {

   254         TAny* handle = TempHandleAt( currentWriteIndex );

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

   256         if  (r == KErrNone)

   257             {

   258             ++currentWriteIndex;

   259             }

   260         }

   261 

   262 	if  ( r == KErrBadDescriptor )

   263         {

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

   265         }

   266     else

   267         {

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

   269         if  ( r == KErrNone )

   270             {

   271             r = finalWrite;

   272             }

   273         }

   274 	NKern::ThreadLeaveCS();

   275 

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

   277 	return r;

   278     }