--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Driver/Kernel/Source/MemSpyDriverLogicalChannel.cpp	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,325 @@
+/*
+* 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 "MemSpyDriverLogicalChannel.h"
+
+// System includes
+#include <u32hal.h>
+#include <e32rom.h>
+
+// User includes
+#include "MemSpyDriverUtils.h"
+#include "MemSpyDriverDevice.h"
+#include <memspy/driver/memspydriverconstants.h>
+#include "MemSpyDriverLogChanChunks.h"
+#include "MemSpyDriverLogChanClientServer.h"
+#include "MemSpyDriverLogChanCodeSegs.h"
+#include "MemSpyDriverLogChanContainers.h"
+#include "MemSpyDriverLogChanHeapData.h"
+#include "MemSpyDriverLogChanHeapWalk.h"
+#include "MemSpyDriverLogChanHeapInfo.h"
+#include "MemSpyDriverLogChanMisc.h"
+#include "MemSpyDriverLogChanProcessInspection.h"
+#include "MemSpyDriverLogChanStack.h"
+#include "MemSpyDriverLogChanRawMemory.h"
+#include "MemSpyDriverLogChanUserEventMonitor.h"
+#include "MemSpyDriverLogChanThreadAndProcess.h"
+
+
+DMemSpyDriverLogicalChannel::DMemSpyDriverLogicalChannel()
+    {
+    }
+
+
+DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel()
+	{
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - START"));
+
+    NKern::ThreadEnterCS();
+    SubChannelsDestroy();
+    NKern::ThreadLeaveCS();
+
+    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - closing client thread..."));
+    Kern::SafeClose( (DObject*&) iClientThread, NULL );
+
+    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - calling device to cleanup..."));
+    MemSpyDevice().Cleanup();
+
+    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - END"));
+	}
+
+
+TInt DMemSpyDriverLogicalChannel::DoCreate( TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer )
+	{
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate() - START - heldFM: %d, device: 0x%08x", Kern::CurrentThread().iNThread.iHeldFastMutex != NULL, &MemSpyDevice() ) );
+
+    TInt error = KErrNone;
+    //
+    if  ( !Kern::QueryVersionSupported( KMemSpyDriverVersion(), aVer ) )
+        {
+        error = KErrNotSupported;
+        }
+    else
+        {
+        // Try to get the memory model type
+        
+    	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - opening client thread..."));
+
+        iClientThread = &Kern::CurrentThread();
+	    error = iClientThread->Open();
+        TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - client thread open error: %d", error ));
+
+        if  ( error == KErrNone )
+            {
+            TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - creating sub channels error: %d", error ));
+            error = SubChannelsRegister();
+            }
+        }
+    //
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate() - END - heldFM: %d", Kern::CurrentThread().iNThread.iHeldFastMutex != NULL ) );
+    return error;
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+TInt DMemSpyDriverLogicalChannel::Request( TInt aFunction, TAny* a1, TAny* a2 )
+	{
+	TRACE( Kern::Printf(" " ) );
+	TRACE( Kern::Printf(" " ) );
+	TRACE( Kern::Printf("--------------------------------------------------------------------------------------------------------------------- " ) );
+	TRACE_OP( Kern::Printf("DMemSpyDriverLogicalChannel::Request() - START - fn: %3d, a1: 0x%08x, a2: 0x%08x, heldFM: %d", aFunction, a1, a2, iClientThread->iNThread.iHeldFastMutex != NULL ) );
+	TRACE( Kern::Printf("--------------------------------------------------------------------------------------------------------------------- " ) );
+	//
+    TInt r = KErrNotSupported;
+    //
+    DMemSpyDriverLogChanBase* handler = SubChannelForFunction( aFunction );
+    if  ( handler )
+        {
+        r = handler->Request( aFunction, a1, a2 );
+        }
+    //
+#ifdef _DEBUG
+    if  ( r < 0 && r != KErrEof )
+        {
+	    Kern::Printf( "DMemSpyDriverLogicalChannel::Request() - END - fn: %3d, a1: 0x%08x, a2: 0x%08x, heldFM: %d, r: %d", aFunction, a1, a2, iClientThread->iNThread.iHeldFastMutex != NULL, r );
+        }
+#endif
+	TRACE( Kern::Printf(" " ) );
+	TRACE( Kern::Printf(" " ) );
+    //
+    return r;
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+
+TInt DMemSpyDriverLogicalChannel::SubChannelsRegister()
+    {
+    TInt r = KErrNone;
+    DMemSpyDriverDevice& device = MemSpyDevice();
+    DMemSpyDriverLogChanBase* subChan = NULL;
+    //
+    subChan = new DMemSpyDriverLogChanChunks( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanClientServer( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanCodeSegs( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanContainers( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanHeapData( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanHeapInfo( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanHeapWalk( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanMisc( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanProcessInspection( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanRawMemory( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanStack( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanThreadAndProcess( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    subChan = new DMemSpyDriverLogChanUserEventMonitor( device, *iClientThread );
+    r = SubChannelConstructAndSave( subChan );
+    if ( r != KErrNone )
+        {
+        return r;
+        }
+    //
+    return r;
+    }
+
+
+TInt DMemSpyDriverLogicalChannel::SubChannelConstructAndSave( DMemSpyDriverLogChanBase*& aSubChannel )
+    {
+    TInt r = KErrNoMemory;
+    //
+    if ( aSubChannel )
+        {
+        NKern::ThreadEnterCS();
+        r = aSubChannel->Construct();
+        //
+        if  ( r == KErrNone )
+            {
+            r = iSubChannels.Append( aSubChannel );
+            if  ( r != KErrNone )
+                {
+                delete aSubChannel;
+                }
+            }
+        else
+            {
+            delete aSubChannel;
+            }
+        //
+        NKern::ThreadLeaveCS();
+        }
+    //
+    aSubChannel = NULL;
+    return r;
+    }
+
+
+void DMemSpyDriverLogicalChannel::SubChannelsDestroy()
+    {
+    const TInt count = iSubChannels.Count();
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - START - count: %d", count ) );
+    //
+    NKern::ThreadEnterCS();
+    for( TInt i=0; i<count; i++ )
+        {
+        DMemSpyDriverLogChanBase* subChan = iSubChannels[ i ];
+	    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - deleting subChannel: 0x%08x", subChan ) );
+        delete subChan;
+        }
+    //
+    iSubChannels.Reset();
+    NKern::ThreadLeaveCS();
+    //
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - END" ) );
+    }
+
+
+DMemSpyDriverLogChanBase* DMemSpyDriverLogicalChannel::SubChannelForFunction( TInt aFunction )
+    {
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelForFunction() - START - aFunction: %d", aFunction ) );
+    //
+    DMemSpyDriverLogChanBase* ret = NULL;
+    const TInt count = iSubChannels.Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        DMemSpyDriverLogChanBase* subChan = iSubChannels[ i ];
+        if  ( subChan->IsHandler( aFunction ) )
+            {
+            ret = subChan;
+            break;
+            }
+        }
+    //
+	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelForFunction() - END - aFunction: %d, subChannel: 0x%08x", aFunction, ret ) );
+    return ret;
+    }
+
+
+DMemSpyDriverDevice& DMemSpyDriverLogicalChannel::MemSpyDevice()
+    {
+    DMemSpyDriverDevice& device = *((DMemSpyDriverDevice*) iDevice);
+    return device;
+    }
+