diff -r 000000000000 -r a03f92240627 memspy/Driver/Kernel/Source/SubChannels/MemSpyDriverLogChanContainerBase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Driver/Kernel/Source/SubChannels/MemSpyDriverLogChanContainerBase.cpp	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,292 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include "MemSpyDriverLogChanContainerBase.h"
+
+// Shared includes
+#include "MemSpyDriverOpCodes.h"
+#include <memspy/driver/memspydriverobjectsshared.h>
+#include "MemSpyDriverObjectsInternal.h"
+
+// User includes
+#include "MemSpyDriverUtils.h"
+#include "MemSpyDriverDevice.h"
+#include "MemSpyDriverOSAdaption.h"
+
+
+DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase( DMemSpyDriverDevice& aDevice, DThread& aThread )
+:   DMemSpyDriverLogChanBase( aDevice, aThread )
+    {
+	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase() - this: 0x%08x", this ));
+    }
+
+
+DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase()
+	{
+	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - START - this: 0x%08x", this ));
+
+    ResetTempHandles();
+
+	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - END - this: 0x%08x", this ));
+	}
+
+
+
+
+
+
+
+
+
+DObject* DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer( TMemSpyDriverContainerType aContainerType, DObject* aSearchFor, TBool aQuick )
+    {
+	__ASSERT_DEBUG( aSearchFor != NULL, MemSpyDriverUtils::Fault( __LINE__ ) );
+    const TObjectType expectedType = ObjectTypeFromMemSpyContainerType( aContainerType );
+    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - START - aSearchFor: 0x%08x, expectedType: %d", aSearchFor, expectedType ));
+
+    DObject* ret = NULL;
+    
+    // Quick mode means we just check container ids and we trust that the object
+    // will exist.
+    if ( aQuick )
+        {
+        const TObjectType objectType = OSAdaption().DThread().GetObjectType( *aSearchFor );
+        TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - aSearchFor.iContainerID: %d", objectType ) );
+        if  ( objectType == expectedType )
+            {
+            ret = aSearchFor;
+            }
+        }
+    else
+        {
+        // Full check to see if the specified object is part of the container
+        DObjectCon* container = Kern::Containers()[ expectedType ];
+        container->Wait();
+        NKern::LockSystem();
+
+        const TInt count = container->Count();
+        for(TInt i=0; i<count; i++)
+            {
+            DObject* object = (*container)[ i ];
+
+            // Do the two match?
+            if  ( object == aSearchFor )
+                {
+                TRACE( Kern::Printf("    found match: %O", object));
+
+                ret = object;
+                break;
+                }
+            }
+
+        NKern::UnlockSystem();
+        container->Signal();
+        }
+
+    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - END - ret: 0x%08x", ret ));
+    TRACE( Kern::Printf(" ") );
+    return ret;
+    }
+
+
+
+TObjectType DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType( TMemSpyDriverContainerType aType )
+    {
+    // Map type
+    TObjectType type = EObjectTypeAny;
+    switch( aType )
+        {
+    case EMemSpyDriverContainerTypeThread:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeThread" ));
+        type = EThread;
+        break;
+    case EMemSpyDriverContainerTypeProcess:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeProcess" ));
+        type = EProcess;
+        break;
+    case EMemSpyDriverContainerTypeChunk:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChunk" ));
+        type = EChunk;
+        break;
+    case EMemSpyDriverContainerTypeLibrary:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLibrary" ));
+        type = ELibrary;
+        break;
+    case EMemSpyDriverContainerTypeSemaphore:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSemaphore" ));
+        type = ESemaphore;
+        break;
+    case EMemSpyDriverContainerTypeMutex:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMutex" ));
+        type = EMutex;
+        break;
+    case EMemSpyDriverContainerTypeTimer:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeTimer" ));
+        type = ETimer;
+        break;
+    case EMemSpyDriverContainerTypeServer:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeServer" ));
+        type = EServer;
+        break;
+    case EMemSpyDriverContainerTypeSession:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSession" ));
+        type = ESession;
+        break;
+    case EMemSpyDriverContainerTypeLogicalDevice:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalDevice" ));
+        type = ELogicalDevice;
+        break;
+    case EMemSpyDriverContainerTypePhysicalDevice:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePhysicalDevice" ));
+        type = EPhysicalDevice;
+        break;
+    case EMemSpyDriverContainerTypeLogicalChannel:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalChannel" ));
+        type = ELogicalChannel;
+        break;
+    case EMemSpyDriverContainerTypeChangeNotifier:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChangeNotifier" ));
+        type = EChangeNotifier;
+        break;
+    case EMemSpyDriverContainerTypeUndertaker:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeUndertaker" ));
+        type = EUndertaker;
+        break;
+    case EMemSpyDriverContainerTypeMsgQueue:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMsgQueue" ));
+        type = EMsgQueue;
+        break;
+    case EMemSpyDriverContainerTypePropertyRef:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePropertyRef" ));
+        type = EPropertyRef;
+        break;
+    case EMemSpyDriverContainerTypeCondVar:
+ 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeCondVar" ));
+        type = ECondVar;
+        break;
+    default:
+        Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType - unsupported container type: %d", aType);
+        break;
+        }
+    //
+    return type;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    
+
+void DMemSpyDriverLogChanContainerBase::ResetTempHandles()
+    {
+    iTempHandleCount = 0;
+    }
+
+
+void DMemSpyDriverLogChanContainerBase::AddTempHandle( TAny* aHandle )
+    {
+    __ASSERT_ALWAYS( iTempHandleCount >= 0, MemSpyDriverUtils::Fault( __LINE__) );
+    if  ( iTempHandleCount < KMemSpyDriverMaxHandles )
+        {
+        iTempHandles[ iTempHandleCount++ ] = aHandle;
+        }
+    }
+
+
+TAny* DMemSpyDriverLogChanContainerBase::TempHandleAt( TInt aIndex ) const
+    {
+    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < KMemSpyDriverMaxHandles, MemSpyDriverUtils::Fault(__LINE__) );
+    __ASSERT_ALWAYS( aIndex < iTempHandleCount, MemSpyDriverUtils::Fault(__LINE__) );
+    return iTempHandles[ aIndex ];
+    }
+
+
+TInt DMemSpyDriverLogChanContainerBase::TempHandleCount() const
+    {
+    TRACE( Kern::Printf( "DMemSpyDriverLogChanContainerBase::TempHandleCount() - END - count is: %d", iTempHandleCount ));
+    return iTempHandleCount;
+    }
+
+
+TInt DMemSpyDriverLogChanContainerBase::WriteToClient( TAny** aHandlePtr, TInt* aCountPtr, TInt aMaxCount )
+    {
+	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::WriteToClient() - START - iTempHandleCount: %d", iTempHandleCount ));
+
+    TInt r = KErrNone;
+
+    // This variable holds the number of handles that we have already
+	// written to the client-side.
+	TInt currentWriteIndex = 0;
+
+    // If the client passed a bad descriptor then we panic it. Otherwise, we always update the amount
+    // of handles we have found (even if there was an error - i.e. we set the value to zero) or else
+    // the client will attempt to index through its huge stack-based handle array.
+	NKern::ThreadEnterCS();
+    TInt tempHandleCount = TempHandleCount();
+    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles - trying to write %d handles to client...", tempHandleCount ));
+
+    for( ; currentWriteIndex<tempHandleCount && r == KErrNone && currentWriteIndex < aMaxCount; )
+        {
+        TAny* handle = TempHandleAt( currentWriteIndex );
+        r = Kern::ThreadRawWrite( &ClientThread(), aHandlePtr + currentWriteIndex, &handle, sizeof(TAny*) );
+        if  (r == KErrNone)
+            {
+            ++currentWriteIndex;
+            }
+        }
+
+	if  ( r == KErrBadDescriptor )
+        {
+        MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );
+        }
+    else
+        {
+        const TInt finalWrite = Kern::ThreadRawWrite( &ClientThread(), aCountPtr, &currentWriteIndex, sizeof(TInt) );
+        if  ( r == KErrNone )
+            {
+            r = finalWrite;
+            }
+        }
+	NKern::ThreadLeaveCS();
+
+	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles() - END - r: %d", r));
+	return r;
+    }