diff -r 185201be11b0 -r 516af714ebb4 perfsrv/memspy/Engine/Source/ClientServer/MemSpyEngineServer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/perfsrv/memspy/Engine/Source/ClientServer/MemSpyEngineServer.cpp	Fri Sep 17 08:38:31 2010 +0300
@@ -0,0 +1,1788 @@
+/*
+* 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 "MemSpyEngineServer.h"
+
+// System includes
+#include <e32svr.h>
+#include <w32std.h>
+#include <APGTASK.H>
+#include <APGWGNAM.H>  
+
+// User includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyenginelogger.h>
+#include <memspyengineclientinterface.h>
+#include <memspy/engine/memspyengineobjectthread.h>
+#include <memspy/engine/memspyengineobjectprocess.h>
+#include <memspy/engine/memspyengineobjectcontainer.h>
+#include <memspy/engine/memspyenginehelperchunk.h>
+#include <memspy/engine/memspyenginehelpercodesegment.h>
+#include <memspy/engine/memspyenginehelperheap.h>
+#include <memspy/engine/memspyenginehelperstack.h>
+#include <memspy/engine/memspyenginehelperthread.h>
+#include <memspy/engine/memspyenginehelperprocess.h>
+#include <memspy/engine/memspyenginehelperfilesystem.h>
+#include <memspy/engine/memspyenginehelperram.h>
+#include <memspy/engine/memspyenginehelpersysmemtracker.h>
+#include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>
+#include <memspy/engine/memspyenginehelperkernelcontainers.h>
+#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>
+#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>
+#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>
+#include <memspy/engine/memspyenginehelperserver.h>
+#include <memspy/engine/memspyenginehelperecom.h>
+
+#include <memspy/engine/memspyprocessdata.h>
+#include <memspy/engine/memspythreaddata.h>
+#include <memspy/engine/memspykernelobjectdata.h>
+#include <memspy/engine/memspythreadinfoitemdata.h>
+#include <memspy/engine/memspymemorytrackingcycledata.h>
+#include <memspy/engine/memspyengineoutputsink.h>
+#include <memspy/engine/memspyenginehelperactiveobject.h>
+#include <memspy/engine/memspyserverdata.h>
+#include <memspysession.h>
+#include <memspy/engine/memspyecomdata.h>
+
+inline CShutdown::CShutdown() :CTimer(-1)
+    {
+    CActiveScheduler::Add(this);
+    }
+
+inline void CShutdown::ConstructL()
+    {
+    CTimer::ConstructL();
+    }
+
+inline void CShutdown::Start()
+    {
+    After(KMyShutdownDelay);
+    }
+
+void CShutdown::RunL()
+    //
+    // Initiate server exit when the timer expires
+    //
+    {
+    CActiveScheduler::Stop();
+    }
+
+CMemSpyEngineServer::CMemSpyEngineServer( CMemSpyEngine& aEngine )
+:   CServer2( EPriorityNormal ), iEngine( aEngine )
+    {
+    }
+
+
+CMemSpyEngineServer::~CMemSpyEngineServer()
+    {
+    }
+
+
+void CMemSpyEngineServer::ConstructL()
+    {
+    StartL( KMemSpyServerName );
+        
+    iShutdown.ConstructL();
+    // ensure that the server still exits even if the 1st client fails to connect
+    iShutdown.Start();
+    }
+
+
+CMemSpyEngineServer* CMemSpyEngineServer::NewL( CMemSpyEngine& aEngine )
+    {
+    CMemSpyEngineServer* self = new(ELeave) CMemSpyEngineServer( aEngine );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+
+CSession2* CMemSpyEngineServer::NewSessionL( const TVersion& aVersion, const RMessage2& aMessage ) const
+    {
+    if  ( aVersion.iMajor != KMemSpyClientServerVersion )
+        {
+        RDebug::Printf( "[MemSpy] CMemSpyEngineSession::NewSessionL() - BAD VERSION" );
+        User::Leave( KErrNotSupported );
+        }
+    //
+    CMemSpyEngineSession* session = CMemSpyEngineSession::NewL( iEngine, aMessage );
+	return session;
+    }
+
+void CMemSpyEngineServer::AddSession(TBool aCliRequest)
+    {
+    if (aCliRequest)
+        {
+        iCliConnected = ETrue;
+        }
+    else
+        {
+        ++iSessionCount;
+        }
+    iShutdown.Cancel();
+    }
+
+void CMemSpyEngineServer::DropSession(TBool aCliRequest)
+    {
+    if (!aCliRequest)
+        {
+        --iSessionCount;
+        }
+    
+    if (iSessionCount == 0 && !iCliConnected)
+        {
+        iShutdown.Start();
+        }
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineSession::CMemSpyEngineSession( CMemSpyEngine& aEngine )
+:   iEngine( aEngine )
+    {
+    }
+
+
+CMemSpyEngineSession::~CMemSpyEngineSession()
+    {
+#ifdef _DEBUG
+    TPtrC pThreadName( KNullDesC );
+    if  ( iClientThreadName )
+        {
+        pThreadName.Set( *iClientThreadName );
+        }
+
+    RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::~CMemSpyEngineSession() - DEAD SESSION - this: 0x%08x, id: %4d, name: %S"), this, iClientThreadId, iClientThreadName );
+#endif
+
+    delete iClientThreadName;
+        
+    Server().DropSession(iIsCliRequest);
+    }
+
+
+void CMemSpyEngineSession::ConstructL( const RMessage2& aMessage )
+    {
+	RThread thread;
+    const TInt error = aMessage.Client( thread );
+    CleanupClosePushL( thread );
+
+    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::ConstructL() - this: 0x%08x - opening client thread - err: %d", this, error ) );
+
+    User::LeaveIfError( error );
+
+    const TFullName threadName( thread.FullName() );
+    iClientThreadName = threadName.AllocL();
+    iClientThreadId = thread.Id();
+
+    CleanupStack::PopAndDestroy( &thread );
+    
+    const TUid KCliUid3 = { 0x2002129D };
+    iIsCliRequest = aMessage.SecureId() == TSecureId(KCliUid3);
+    
+    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::ConstructL() - NEW SESSION - this: 0x%08x, id: %4d, client: %S"), this, iClientThreadId, iClientThreadName ) );
+    }
+
+void CMemSpyEngineSession::CreateL()
+    {   
+    Server().AddSession(iIsCliRequest);
+    }
+
+CMemSpyEngineSession* CMemSpyEngineSession::NewL( CMemSpyEngine& aEngine, const RMessage2& aMessage )
+    {
+    CMemSpyEngineSession* self = new(ELeave) CMemSpyEngineSession( aEngine );
+    CleanupStack::PushL( self );
+    self->ConstructL( aMessage );
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+
+void CMemSpyEngineSession::ServiceL( const RMessage2& aMessage )
+    {
+    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::ServiceL() - START - this: 0x%08x, fn: 0x%08x, id: %4d, client: %S"), this, aMessage.Function(), iClientThreadId, iClientThreadName ) );
+
+    TRAPD( error, DoServiceL( aMessage ) );
+    if  ( error != KErrNone )
+        {
+        RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::ServiceL() - SERVICE ERROR - this: 0x%08x, fn: %d, err: %d, client: %S"), this, aMessage.Function(), error, iClientThreadName );
+        }
+    
+    if ((aMessage.Function() & KMemSpyOpFlagsAsyncOperation) == 0 || error != KErrNone)
+    	{
+		aMessage.Complete( error );
+    	}
+
+    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::ServiceL() - END - this: 0x%08x, fn: 0x%08x, id: %4d, client: %S"), this, aMessage.Function(), iClientThreadId, iClientThreadName ) );
+	}
+
+// ---------------------------------------------------------
+// DoServiceL( const RMessage2& aMessage )
+// ---------------------------------------------------------
+//
+void CMemSpyEngineSession::DoServiceL( const RMessage2& aMessage )
+	{
+	TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;
+	if (function >= EMemSpyClientServerOpMarkerUiFirst && 
+		function < EMemSpyClientServerOpMarkerUiLast)
+		
+		DoUiServiceL(aMessage);
+	else
+		DoCmdServiceL(aMessage);
+	}
+// ---------------------------------------------------------
+// DoUiServiceL( const RMessage2& aMessage )
+// ---------------------------------------------------------
+//
+void CMemSpyEngineSession::DoUiServiceL( const RMessage2& aMessage )
+    {
+	switch (aMessage.Function() & KMemSpyOpFlagsTypeMask)
+		{
+	    case EMemSpyClientServerOpGetOutputSink:
+	        {
+	        TMemSpySinkType sink = iEngine.SinkType();
+	        TPckgBuf<TMemSpySinkType> type( sink );
+	        
+	        aMessage.WriteL( 0, type );
+	        break;
+	        }
+		case EMemSpyClientServerOpGetProcessCount:
+			{
+			aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.Container().Count()));
+			break;
+			}
+		case EMemSpyClientServerOpGetProcesses:
+			{
+			CMemSpyEngineObjectContainer& list = iEngine.Container();
+			
+			TPckgBuf<TInt> a0;
+			aMessage.ReadL(0, a0);
+			TInt realCount = Min(a0(), list.Count());
+			
+			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyProcessData))
+				{
+				CMemSpyProcess& process = iEngine.Container().At(i);
+				TMemSpyProcessData data;
+				data.iIsDead = process.IsDead();
+				data.iId = process.Id();
+				data.iName.Copy(process.Name().Left(KMaxFullName));
+				data.iThreadCount = process.Count();
+				data.iPriority = process.Priority();
+				data.iExitType = process.ExitType();
+				data.iExitReason = process.ExitReason();
+				data.iExitCategory = process.ExitCategory();
+				data.iSID = process.SID();
+				
+				TPckgBuf<TMemSpyProcessData> buffer(data);
+				aMessage.WriteL(1, buffer, offset);
+				}
+			
+			a0 = list.Count();
+			aMessage.WriteL(0, a0);
+
+			break;
+			}
+		case EMemSpyClienServerOpGetProcessIdByName:
+			{
+			TFullName processName;
+			aMessage.ReadL(0, processName);
+			
+			TBool found(EFalse);
+			
+			for (TInt i=0; i<iEngine.Container().Count(); i++)
+				{
+				CMemSpyProcess& process = iEngine.Container().At(i);
+				if (process.Name().FindF(processName) >= 0)
+					{
+					found = ETrue;
+					TPckgBuf<TProcessId> procId(process.Id());
+					aMessage.WriteL(1, procId);
+					}
+				}
+			
+			if (!found)
+				{
+				User::Leave(KErrNotFound);
+				}
+			
+			break;
+			}
+		case EMemSpyClientServerOpProcessSystemPermanentOrCritical:
+			{
+			TBool ret = EFalse;
+			TPckgBuf<TProcessId> id;
+			aMessage.ReadL( 0, id );
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();
+			CMemSpyProcess& process = container.ProcessByIdL( id() );
+			
+			if  ( process.IsSystemPermanent() || process.IsSystemCritical() )
+				{
+				ret = ETrue;
+				}
+			TPckgBuf<TBool> retBuf( ret );
+			aMessage.WriteL( 1, retBuf );
+			
+			break;
+			}
+		case EMemSpyClientServerOpEndProcess:
+			{
+			TPckgBuf<TProcessId> id;
+			aMessage.ReadL( 0, id );
+			TPckgBuf<TMemSpyEndType> type;
+			aMessage.ReadL( 1, type );
+					
+			CMemSpyEngineObjectContainer& container = iEngine.Container();			
+			CMemSpyProcess& process = container.ProcessByIdL( id() );
+									
+			switch ( type() )
+				{
+				case ETerminate:
+					{
+					process.TerminateL();
+					break;
+					}
+				case EPanic:
+					{
+					process.PanicL();
+					break;
+					}
+				case EKill:
+					{
+					process.KillL();
+					break;
+					}
+				}																
+			break;
+			}
+		case EMemSpyClientServerOpSwitchToProcess:
+			{/*
+			TInt wgCount;
+			RWsSession wsSession;
+			User::LeaveIfError( wsSession.Connect() );
+			CleanupClosePushL( wsSession );
+			User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );
+			RArray<RWsSession::TWindowGroupChainInfo> wgArray;
+			CleanupClosePushL( wgArray );
+			User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );
+			TApaTask task( wsSession );
+			TBool brought( EFalse );
+			TInt wgId( KErrNotFound );
+			TThreadId threadId;
+			
+			TPckgBuf<TProcessId> id;
+			aMessage.ReadL( 0, id );
+			CMemSpyEngineObjectContainer& container = iEngine.Container();
+			CMemSpyProcess& process = container.ProcessByIdL( id() );
+			
+			// loop trough threads in a process
+			for ( TInt i = 0; i < process.MdcaCount(); i++ )
+				{
+				TInt wgCountLocal = wgCount;
+							
+				// loop trough all window groups and see if a thread id matches
+				while( !brought && wgCountLocal-- )
+					{
+					wgId = wgArray[wgCountLocal].iId;
+					User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );
+					if ( threadId == process.At( i ).Id() )
+						{
+						CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );
+						task.SetWgId( wgId );
+						if ( !wgName->Hidden() && task.Exists() )
+							{
+							task.BringToForeground();
+							brought = ETrue;                        
+							}
+						CleanupStack::PopAndDestroy( wgName );
+						}
+					}
+				}
+			
+			TPckgBuf<TBool> ret( brought );
+			aMessage.WriteL( 1, ret );
+			
+			break;*/
+			}
+		case EMemSpyClientServerOpGetThreadCount:
+			{
+			TPckgBuf<TProcessId> pid;
+			aMessage.ReadL(1, pid);
+			CMemSpyProcess& process = iEngine.Container().ProcessByIdL(pid());
+			aMessage.WriteL(0, TPckgBuf<TInt>(process.Count()));
+			break;
+			}
+		case EMemSpyClientServerOpGetThreads:
+			{
+			TPckgBuf<TProcessId> pid;
+			aMessage.ReadL(2, pid);
+			
+			CMemSpyProcess& list = iEngine.Container().ProcessByIdL(pid());
+			
+			TPckgBuf<TInt> a0;
+			aMessage.ReadL(0, a0);
+			TInt realCount = Min(a0(), list.Count());
+						
+			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyThreadData))
+				{
+				CMemSpyThread& thread = list.At(i);
+				
+				TMemSpyThreadData data;
+				data.iId = thread.Id();
+				data.iName.Copy(thread.Name().Left(KMaxFullName));
+				data.iThreadPriority = thread.Priority();
+				
+				TPckgBuf<TMemSpyThreadData> buffer(data);
+				aMessage.WriteL(1, buffer, offset);
+				}
+			
+			a0 = list.Count();
+			aMessage.WriteL(0, a0);
+
+			break;
+			}
+		case EMemSpyClientServerOpSetThreadPriority:
+			{
+			TPckgBuf<TThreadId> tid;
+			TPckgBuf<TInt> priority;
+			aMessage.ReadL(0, tid);
+			aMessage.ReadL(1, priority);
+			
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError(iEngine.Container().ProcessAndThreadByThreadId(tid(), process, thread));
+			
+			if (thread)
+				{				
+				thread->SetPriorityL(static_cast<TThreadPriority>(priority()));
+				}					
+			break;
+			}
+		case EMemSpyClientServerOpThreadSystemPermanentOrCritical:
+			{
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 0, id );
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );
+			
+			TBool ret = thread && ( thread->IsSystemPermanent() || thread->IsSystemCritical() );
+			
+			TPckgBuf<TBool> retBuf( ret );
+			aMessage.WriteL( 1, retBuf );
+							
+			break;
+			}
+		case EMemSpyClientServerOpEndThread:
+			{
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 0, id );
+			TPckgBuf<TMemSpyEndType> type;
+			aMessage.ReadL( 1, type );
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );
+			
+			if( thread )
+				{
+				switch ( type() )
+					{
+					case ETerminate:
+						{
+						thread->TerminateL();
+						break;
+						}
+					case EPanic:
+						{
+						thread->PanicL();
+						break;
+						}
+					case EKill:
+						{
+						thread->KillL();
+						break;
+						}
+					}				
+				}			
+			break;
+			}
+		case EMemSpyClientServerOpSwitchToThread:
+			{
+			TInt wgCount;
+			RWsSession wsSession;
+			User::LeaveIfError( wsSession.Connect() );
+			CleanupClosePushL( wsSession );
+			User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );
+			RArray<RWsSession::TWindowGroupChainInfo> wgArray;
+			CleanupClosePushL( wgArray );
+			User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );
+			TApaTask task( wsSession );
+			TBool brought( EFalse );
+			TInt wgId( KErrNotFound );
+			TThreadId threadId;
+					
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 0, id );
+					
+			// loop trough all window groups and see if a thread id matches
+			while( !brought && wgCount-- )
+				{
+				wgId = wgArray[wgCount].iId;
+				User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );
+				if ( threadId == id() )
+					{
+					CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );
+					task.SetWgId( wgId );
+					if ( !wgName->Hidden() && task.Exists() )
+						{
+						task.BringToForeground();
+						brought = ETrue;                        
+						}
+					CleanupStack::PopAndDestroy( wgName );
+					}
+				}			
+			TPckgBuf<TBool> ret( brought );
+			aMessage.WriteL( 1, ret );															
+					
+			break;
+			}		
+		case EMemSpyClientServerOpGetInfoItemType:
+			{
+			
+			TPckgBuf<TInt> index;
+			aMessage.ReadL( 0, index );			
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 1, id);
+								
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL; //not needed
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );
+		            
+			CMemSpyThreadInfoContainer& threadInfoContainer = thread->InfoContainerForceSyncronousConstructionL();                        
+			TMemSpyThreadInfoItemType retType = threadInfoContainer.Item( index() ).Type();
+			
+			TPckgBuf<TMemSpyThreadInfoItemType> ret( retType );
+			aMessage.WriteL( 2, ret );			
+			
+			break;
+			}
+		case EMemSpyClientServerOpGetThreadInfoItemsCount:
+			{
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 0, id );
+			TPckgBuf<TMemSpyThreadInfoItemType> type;
+			aMessage.ReadL( 1, type );					 
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			
+			container.ProcessAndThreadByThreadId( id(), process, thread );
+			
+			CMemSpyThreadInfoContainer& threadInfoContainer = thread->InfoContainerForceSyncronousConstructionL();                 
+								
+			CMemSpyThreadInfoItemBase& threadInfoItemBase = threadInfoContainer.Item( type() );
+				    
+			TInt count = threadInfoItemBase.MdcaCount();		    
+			TPckgBuf<TInt> tempret( count );
+			aMessage.WriteL( 2, tempret );
+		
+			break;
+			}		
+		case EMemSpyClientServerOpGetThreadInfoItems:
+			{
+			TPckgBuf<TInt> count;
+			aMessage.ReadL( 0, count );						
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL( 1, id );
+			TPckgBuf<TMemSpyThreadInfoItemType> type;
+			aMessage.ReadL( 2, type );			
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id() , process, thread ) );
+							  
+			CMemSpyThreadInfoContainer& threadInfoContainer = thread->InfoContainerForceSyncronousConstructionL();      
+
+			CMemSpyThreadInfoItemBase& threadInfoItemBase = threadInfoContainer.Item( type() ); //get ThreadInfoItemBaseByType
+			
+			TInt itemCount = Min(count(), threadInfoItemBase.MdcaCount());
+								
+			for( TInt i=0, offset = 0; i<itemCount; i++, offset += sizeof( TMemSpyThreadInfoItemData ) )
+				{
+				TMemSpyThreadInfoItemData data;
+				
+				TPtrC caption(threadInfoItemBase.MdcaPoint(i).Mid(1));
+				TInt tabPos = caption.Locate('\t');
+				if (tabPos != KErrNotFound)
+					caption.Set(caption.Left(tabPos));
+				
+				TPtrC value(threadInfoItemBase.MdcaPoint(i));
+				tabPos = value.LocateReverse('\t');
+				if (tabPos != KErrNotFound)
+					value.Set(value.Mid(tabPos + 1));
+												
+				data.iCaption.Copy( caption.Left(64) );
+				data.iValue.Copy( value.Left(32) );
+							
+				TPckgBuf<TMemSpyThreadInfoItemData> buffer(data);
+				aMessage.WriteL(3, buffer, offset);				
+				}			
+			aMessage.WriteL(0, count);
+					
+			break;
+			}
+			
+		case EMemSpyClientServerOpGetProcessIdByThreadId:
+			{
+			TPckgBuf<TThreadId> tid;
+			aMessage.ReadL( 1, tid );					
+			
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL;
+			//
+			const TInt error = iEngine.Container().ProcessAndThreadByThreadId( tid(), process, thread );
+			
+			TProcessId pid = process->Id();
+			
+			TPckgBuf<TProcessId> ret(pid);
+			aMessage.WriteL( 0, ret );
+									
+			break;
+			}
+			
+		// --- KernelObjects related functions ---
+		case EMemSpyClientServerOpGetKernelObjectCount:
+			{
+			TInt iCount = EMemSpyDriverContainerTypeLast - EMemSpyDriverContainerTypeFirst + 1;
+			TPckgBuf<TInt> ret( iCount );
+			aMessage.WriteL(0, ret);			
+			break;
+			}
+		case EMemSpyClientServerOpGetKernelObjects:
+			{
+			TPckgBuf<TInt> count;
+			aMessage.ReadL(0, count);
+			
+			CMemSpyEngineGenericKernelObjectContainer* model = iEngine.HelperKernelContainers().ObjectsAllL(); //contains all the objects
+			CleanupStack::PushL( model );
+			
+			for( TInt i=0, offset = 0; i<count(); i++, offset += sizeof( TMemSpyKernelObjectData ) )
+				{
+				TMemSpyKernelObjectData data;
+				
+				TPtrC name(model->At(i).Name().Mid(1));
+				TInt tabPos = name.Locate('\t');
+				if (tabPos != KErrNotFound)
+					name.Set(name.Left(tabPos));
+												
+				data.iName.Copy(name);
+				data.iType = model->At(i).Type();
+				data.iCount = model->At(i).Count();											
+				data.iSize = model->At(i).Count() * model->At(i).Count();
+
+				TPckgBuf<TMemSpyKernelObjectData> buffer(data);
+				aMessage.WriteL(1, buffer, offset);
+				}			
+			aMessage.WriteL(0, count);
+			CleanupStack::PopAndDestroy( model );
+			break;
+			}
+		case EMemSpyClientServerOpGetKernelObjectItemCount:
+			{
+			TPckgBuf<TMemSpyDriverContainerType> tempType;
+			aMessage.ReadL(1, tempType); //get type of kernel object
+			TMemSpyDriverContainerType type = tempType();
+			
+			CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();
+			CMemSpyEngineGenericKernelObjectList* iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( type );			
+			
+			TInt count = iObjectList->Count();
+			TPckgBuf<TInt> ret( count );
+			aMessage.WriteL( 0, ret );
+						
+			break;
+			}
+		case EMemSpyClientServerOpGetKernelObjectItems:
+			{
+			TPckgBuf<TInt> count;
+			TPckgBuf<TMemSpyDriverContainerType> tempType;
+			aMessage.ReadL( 0, count ); //get count of items
+			aMessage.ReadL(1, tempType); //get type of kernel object
+			TInt c = count();
+						
+			CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();
+			CMemSpyEngineGenericKernelObjectList* iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( tempType() );			
+			
+			for( TInt i=0, offset = 0; i<c; i++, offset += sizeof( TMemSpyDriverHandleInfoGeneric ) )
+				{
+				TMemSpyDriverHandleInfoGeneric data;								
+															
+				data = iObjectList->At( i );
+				
+				TPckgBuf<TMemSpyDriverHandleInfoGeneric> buffer(data);
+				aMessage.WriteL(2, buffer, offset);
+				}			
+					
+			break;
+			}
+			
+		case EMemSpyClientServerOpOutputAllContainerContents:
+			{
+			CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();
+			CMemSpyEngineGenericKernelObjectContainer* model = kernelContainerManager.ObjectsAllL();
+			
+			model->OutputL( iEngine.Sink() );
+
+			break;
+			}
+			
+		case EMemSpyClientServerOpDumpKernelHeap:
+			{
+		    iEngine.HelperHeap().OutputHeapDataKernelL();
+			
+			break;
+			}
+			
+		case EMemSpyClientServerOpOutputInfoHandles:
+			{
+			TPckgBuf<TThreadId> id;
+			aMessage.ReadL(0, id);
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id() , process, thread ) );
+										  
+			CMemSpyThreadInfoContainer& threadInfoContainer = thread->InfoContainerForceSyncronousConstructionL();
+			
+			threadInfoContainer.PrintL();
+			
+			break;
+			}
+			
+		case EMemSpyClientServerOpOutputAOList:
+			{
+			TPckgBuf<TThreadId> id;
+			TPckgBuf<TMemSpyThreadInfoItemType> type;
+			aMessage.ReadL(0, id);
+			aMessage.ReadL(1, type);
+			
+			CMemSpyEngineObjectContainer& container = iEngine.Container();            
+			CMemSpyProcess* process = NULL;
+			CMemSpyThread* thread = NULL; 
+			User::LeaveIfError( container.ProcessAndThreadByThreadId( id() , process, thread ) );
+										  
+			CMemSpyThreadInfoContainer& threadInfoContainer = thread->InfoContainerForceSyncronousConstructionL();      
+
+			CMemSpyThreadInfoItemBase* threadInfoItem = &threadInfoContainer.Item( type() );
+						
+			CMemSpyThreadInfoActiveObjects* activeObjectArray = static_cast< CMemSpyThreadInfoActiveObjects* >( threadInfoItem );			
+						
+		    // Begin a new data stream
+		    _LIT( KMemSpyContext, "Active Object List - " );
+		    _LIT( KMemSpyFolder, "Active Objects" );
+		    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );
+		    		    
+		    // Set prefix for overall listing
+		    iEngine.Sink().OutputPrefixSetLC( KMemSpyContext );
+
+		    // Create header
+		    CMemSpyEngineActiveObjectArray::OutputDataColumnsL( iEngine );
+		    
+		    // List items
+		    const TInt count = activeObjectArray->Array().Count();
+		    for(TInt i=0; i<count; i++)
+		        {
+		        const CMemSpyEngineActiveObject& object = activeObjectArray->Array().At( i );
+		        //
+		        object.OutputDataL( iEngine );
+		        }
+
+		    // Tidy up
+		    CleanupStack::PopAndDestroy(); // prefix
+
+		    // End data stream		    		    
+		    iEngine.Sink().DataStreamEndL();		    
+			
+			break;
+			}
+			
+		// --- Kernel Heap related functions ---
+		case EMemSpyClientServerOpGetHeap:
+			{
+			TMemSpyHeapInfo heapInfo;			
+			iEngine.HelperHeap().GetHeapInfoKernelL( heapInfo );
+			TMemSpyHeapData data = iEngine.HelperHeap().NewHeapRawInfo( heapInfo );
+			
+			TPckgBuf<TMemSpyHeapData> buffer(data);
+			aMessage.WriteL(0, buffer);
+			
+			break;
+			}
+			
+		case EMemSpyClientServerOpGetServerCount:
+            {
+            CMemSpyEngineServerList* list = iEngine.HelperServer().ServerListL();
+            CleanupStack::PushL(list);
+            // TODO: cache it between calls
+            aMessage.WriteL(0, TPckgBuf<TInt>(list->MdcaCount()));
+            
+            CleanupStack::PopAndDestroy(list);
+            break;
+            }
+        // --- Servers related functions
+        case EMemSpyClientServerOpGetServers:
+            {
+            CMemSpyEngineServerList* list = iEngine.HelperServer().ServerListL();
+            CleanupStack::PushL(list);
+            
+            TPckgBuf<TInt> a0;
+            aMessage.ReadL(0, a0);
+            TInt realCount = Min(a0(), list->MdcaCount());
+            
+            for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyServerData))
+                {
+                const CMemSpyEngineServerEntry& server = list->At(i);
+                TMemSpyServerData data;
+                
+                CMemSpyProcess* process = NULL;
+                CMemSpyThread* thread = NULL;
+                TInt error = iEngine.Container().ProcessAndThreadByThreadId( server.Id(), process, thread );
+                if (error == KErrNone && thread)
+                    {
+                    data.iId = thread->Process().Id();
+                    }
+                data.iName.Copy(server.Name().Left(KMaxFullName));
+                data.iSessionCount = server.SessionCount();
+                
+                TPckgBuf<TMemSpyServerData> buffer(data);
+                aMessage.WriteL(1, buffer, offset);
+                }
+            
+            a0 = list->Count();
+            aMessage.WriteL(0, a0);
+            
+            CleanupStack::PopAndDestroy(list);
+
+            break;
+            }
+            
+        case EMemSpyClientServerOpGetSortedServers:
+        	{
+        	CMemSpyEngineServerList* list = iEngine.HelperServer().ServerListL();
+        	CleanupStack::PushL(list);
+        	
+        	TPckgBuf<TSortType> a2;
+        	aMessage.ReadL( 2, a2 );
+        	
+        	//sort the list of the servers
+        	if( a2() == ESortServByName )
+        		list->SortByNameL();
+        	else
+        		list->SortBySessionCountL();
+        	
+        	TPckgBuf<TInt> a0;        	
+        	aMessage.ReadL(0, a0);        	        	        
+        	
+        	TInt realCount = Min(a0(), list->MdcaCount());
+        	            
+        	for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyServerData))
+        		{
+				const CMemSpyEngineServerEntry& server = list->At(i);
+				TMemSpyServerData data;
+        	                
+				data.iId = server.Id();
+				data.iName.Copy(server.Name().Left(KMaxFullName));
+				data.iSessionCount = server.SessionCount();
+        	                
+				TPckgBuf<TMemSpyServerData> buffer(data);
+				aMessage.WriteL(1, buffer, offset);
+        		}        	           
+			a0 = list->Count();
+			aMessage.WriteL(0, a0);
+        	            
+			CleanupStack::PopAndDestroy(list);
+			break;
+        	}
+          
+        case EMemSpyClientServerOpServerListOutputGeneric:
+        	{
+            TPckgBuf<TBool> a0;
+            aMessage.ReadL(0, a0);
+        	
+            CMemSpyEngineServerList* list;            
+            list = iEngine.HelperServer().ServerListL();
+            CleanupStack::PushL(list);
+            
+            _LIT( KMemSpyContext, "Server List - " );
+            _LIT( KMemSpyFolder, "Servers" );
+            iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );
+
+            // Set prefix for overall listing
+            iEngine.Sink().OutputPrefixSetLC( KMemSpyContext );
+
+            // Create header
+            CMemSpyEngineServerList::OutputDataColumnsL( iEngine, a0() );
+               
+            // List items
+            const TInt count = list->Count();
+            for(TInt i=0; i<count; i++)
+            	{
+				const CMemSpyEngineServerEntry& server = list->At( i );
+				//
+				server.OutputDataL( iEngine.HelperServer(), a0() );
+            	}
+
+            // Tidy up
+            CleanupStack::PopAndDestroy(); // prefix
+            
+            // End data stream
+            iEngine.Sink().DataStreamEndL();
+            
+            CleanupStack::PopAndDestroy(list);        	
+        	break;
+        	}        	
+        	
+		case EMemSpyClientServerOpGetMemoryTrackingCycleCount:
+			{
+			TInt count = iEngine.HelperSysMemTracker().CompletedCycles().Count();
+			TPckgBuf<TInt> ret( count );
+			aMessage.WriteL( 0, ret );			
+			break;
+			}		
+			
+		case EMemSpyClientServerOpGetMemoryTrackingCycles:
+			{
+			const RPointerArray<CMemSpyEngineHelperSysMemTrackerCycle>& list = iEngine.HelperSysMemTracker().CompletedCycles();
+
+			TPckgBuf<TInt> a0;
+			aMessage.ReadL(0, a0);
+			TInt realCount = Min(a0(), list.Count());
+			
+			for (TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyMemoryTrackingCycleData))
+				{
+				CMemSpyProcess& process = iEngine.Container().At(i);
+				TMemSpyMemoryTrackingCycleData data;
+				data.iCycleNumber = list[i]->CycleNumber();
+				data.iCaption.Copy(list[i]->Caption().Left(KMaxFullName));
+				data.iTime = list[i]->Time();
+				data.iFreeMemory = list[i]->MemoryFree();
+				data.iMemoryDelta = list[i]->MemoryDelta();
+				data.iPreviousCycleDiff = list[i]->MemoryFreePreviousCycle();
+				data.iChangeCount = list[i]->ChangeCount();
+				
+				TPckgBuf<TMemSpyMemoryTrackingCycleData> buffer(data);
+				aMessage.WriteL(1, buffer, offset);
+				}
+			
+			a0 = list.Count();
+			aMessage.WriteL(0, a0);
+
+		break;
+		}
+
+	case EMemSpyClientServerOpIsSwmtRunning:
+		{
+		TPckgBuf<TBool> running(iEngine.HelperSysMemTracker().IsActive());
+		aMessage.WriteL(0, running);
+		break;
+		}
+		
+	case EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodGet:
+	    {	    			   
+	    // Get current config
+	    TMemSpyEngineHelperSysMemTrackerConfig config;
+	    iEngine.HelperSysMemTracker().GetConfig( config );
+	    TInt time = config.iTimerPeriod.Int();
+	    TPckgBuf<TInt> tim(time);			            
+	    aMessage.WriteL( 0, tim );
+	    break;
+	    }
+	    
+	case EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesGet:
+		{
+		// Get current config
+		TMemSpyEngineHelperSysMemTrackerConfig config;
+		iEngine.HelperSysMemTracker().GetConfig( config );		
+		TInt categories = config.iEnabledCategories;		
+		TPckgBuf<TInt> ret( categories );
+		aMessage.WriteL( 0, ret );						
+		break;
+		}
+		
+	case EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterGet:
+		{
+		TMemSpyEngineHelperSysMemTrackerConfig config;
+		iEngine.HelperSysMemTracker().GetConfig( config );                 
+		TName threadNameFilter = config.iThreadNameFilter;
+		TPckgBuf<TName> name(threadNameFilter);
+		aMessage.WriteL( 0, name );
+		
+		break;
+		}
+		
+	case EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpGet:
+		{
+		TMemSpyEngineHelperSysMemTrackerConfig config;
+		iEngine.HelperSysMemTracker().GetConfig( config );		           
+		TBool heapDump = config.iDumpData;
+		TPckgBuf<TBool> heap(heapDump);			            
+		aMessage.WriteL( 0, heap );
+		break;
+		}
+						
+	case EMemSpyClientServerOpSystemWideMemoryTrackingModeGet:
+		{
+		TMemSpyEngineHelperSysMemTrackerConfig config;
+		iEngine.HelperSysMemTracker().GetConfig( config );	 		 
+		TPckgBuf<TMemSpyEngineHelperSysMemTrackerConfig::TMemSpyEngineSysMemTrackerMode> mod(config.iMode);			             		            
+		aMessage.WriteL(0, mod);	 			 		    
+		break;
+		}			
+		
+	case EMemSpyClientServerOpNotifyDeviceWideOperationProgress:
+		{
+		if (!Server().CurrentOperationTracker())
+			{
+			User::Leave(KErrNotReady);
+			}
+		
+		Server().CurrentOperationTracker()->AddNotificationL(aMessage);
+		break;
+		}
+		
+	case EMemSpyClientServerOpCancelDeviceWideOperation:
+		if (!Server().CurrentOperationTracker())
+			{
+			User::Leave(KErrNotReady);
+			}
+		
+		Server().CurrentOperationTracker()->Cancel();
+		break;
+	
+		
+	case EMemSpyClientServerOpGetEComCategoryCount:
+	    aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.HelperECom().MdcaCount()));
+	    break;
+	    
+
+	case EMemSpyClientServerOpGetEComCategories:
+	    {
+	    TPckgBuf<TInt> a0;
+        aMessage.ReadL(0, a0);
+        TInt realCount = Min(a0(), iEngine.HelperECom().MdcaCount());
+        
+        for (TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyEComCategoryData))
+            {
+            TMemSpyEComCategoryData data;
+            data.iId.iUid = i;
+            data.iName.Copy(iEngine.HelperECom().At(i).Name());
+            data.iInterfaceCount = iEngine.HelperECom().At(i).MdcaCount();
+            
+            TPckgBuf<TMemSpyEComCategoryData> buffer(data);
+            aMessage.WriteL(1, buffer, offset);
+		}
+        
+        a0 = iEngine.HelperECom().MdcaCount();
+        aMessage.WriteL(0, a0);
+	    break;
+    }
+	    
+	case EMemSpyClientServerOpGetEComInterfaceCount:
+	    {
+	    TPckgBuf<TUid> a1;
+        aMessage.ReadL(1, a1);
+        TInt index = a1().iUid;
+        
+        if (index < 0 || index >= iEngine.HelperECom().MdcaCount())
+            {
+            User::Leave(KErrArgument);
+            }
+        
+        aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.HelperECom().At(index).MdcaCount()));
+	    break;
+	    }
+	            
+	case EMemSpyClientServerOpGetEComInterfaces:
+	    {
+	    TPckgBuf<TInt> a0;
+        aMessage.ReadL(0, a0);
+        TInt realCount = Min(a0(), iEngine.HelperECom().MdcaCount());
+        
+        TPckgBuf<TUid> a1;
+        aMessage.ReadL(1, a1);
+        TInt categoryIndex = a1().iUid;
+        
+        if (categoryIndex < 0 || categoryIndex >= iEngine.HelperECom().MdcaCount())
+            {
+            User::Leave(KErrArgument);
+            }
+        
+        CMemSpyEngineEComCategory &category = iEngine.HelperECom().At(categoryIndex);
+        
+        for (TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyEComInterfaceData))
+            {
+            TMemSpyEComInterfaceData data;
+            data.iId.iUid = (TInt32) &category.At(i);
+            data.iCategoryId.iUid = categoryIndex;
+            data.iName.Copy(category.At(i).Name());
+            data.iImplementationCount = category.At(i).MdcaCount();
+            
+            TPckgBuf<TMemSpyEComInterfaceData> buffer(data);
+            aMessage.WriteL(2, buffer, offset);
+            }
+        
+        a0 = realCount;
+        aMessage.WriteL(0, a0);
+        
+        break;
+	    }
+	    
+	case EMemSpyClientServerOpGetEComImplementationCount:
+	    {
+	    TPckgBuf<TUid> a1;
+        aMessage.ReadL(1, a1);
+        CMemSpyEngineEComInterface* interface = reinterpret_cast<CMemSpyEngineEComInterface*>(a1().iUid);
+        
+        // TODO: check if it really is valid interface 
+        
+        aMessage.WriteL(0, TPckgBuf<TInt>(interface->MdcaCount()));
+	    break;
+	    }
+	                
+	case EMemSpyClientServerOpGetEComImplementations:
+	    {
+        TPckgBuf<TUid> a1;
+        aMessage.ReadL(1, a1);
+        CMemSpyEngineEComInterface* interface = reinterpret_cast<CMemSpyEngineEComInterface*>(a1().iUid);
+        
+        TPckgBuf<TInt> a0;
+        aMessage.ReadL(0, a0);
+        TInt realCount = Min(a0(), interface->MdcaCount());
+        
+        
+        for (TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyEComImplementationData))
+            {
+            TMemSpyEComImplementationData data;
+            data.iName.Copy(interface->At(i).Info().DisplayName());
+            data.iImplementationUid = interface->At(i).Info().ImplementationUid();
+            data.iVersion = interface->At(i).Info().Version();
+            data.iDataType.Copy(interface->At(i).Info().DataType());
+            data.iOpaqueData.Copy(interface->At(i).Info().OpaqueData());
+            data.iDrive = interface->At(i).Info().Drive();
+            data.iRomOnly = interface->At(i).Info().RomOnly();
+            data.iRomBased = interface->At(i).Info().RomBased();
+            data.iVendorId = interface->At(i).Info().VendorId();
+            data.iDisabled = interface->At(i).Info().Disabled();
+            
+            TPckgBuf<TMemSpyEComImplementationData> buffer(data);
+            aMessage.WriteL(2, buffer, offset);
+            }
+        
+        a0 = realCount;
+        aMessage.WriteL(0, a0);
+        
+        break;
+	    }
+	    
+		}
+    }
+
+// ---------------------------------------------------------
+// DoCmdServiceL( const RMessage2& aMessage )
+// ---------------------------------------------------------
+//
+void CMemSpyEngineSession::DoCmdServiceL( const RMessage2& aMessage )
+    {
+    TInt error = KErrNone;
+
+    // Check function attributes
+    const TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;
+    const TInt argSpec = aMessage.Function() & KMemSpyOpFlagsInclusionMask;
+    const TBool byThreadId = ( argSpec == KMemSpyOpFlagsIncludesThreadId );
+    const TBool byThreadName = ( argSpec == KMemSpyOpFlagsIncludesThreadName );
+
+    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - START - unmodified function: 0x%08x, opCode: %d [TID: %d, TN: %d]", aMessage.Function(), function, byThreadId, byThreadName ) );
+
+    // Check function is supported and argument combination is valid
+    error = ValidateFunction( function, byThreadId, byThreadName );
+    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - validation result: %d", error ) );
+    
+    // Process function request
+    if  ( error == KErrNone )
+        {
+        if  ( byThreadId )
+            {
+            TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - [TID] thread-specific..." ) );
+            
+            const TThreadId threadId( aMessage.Int0() );
+            HandleThreadSpecificOpL( function, threadId );
+            }
+        else if ( byThreadName )
+            {
+            TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - [TN] thread-specific..." ) );
+
+            error = aMessage.GetDesLength( 0 /*slot 0*/ );
+        
+            if  ( error > 0 && error <= KMaxFullName )
+                {
+                TFullName* threadName = new(ELeave) TFullName();
+                CleanupStack::PushL( threadName );
+                aMessage.ReadL( 0, *threadName );
+                HandleThreadSpecificOpL( function, *threadName );
+                CleanupStack::PopAndDestroy( threadName );
+                }
+            else
+                {
+                error = KErrArgument;
+                }
+            }
+        else
+            {
+            TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - thread-agnostic..." ) );
+
+            HandleThreadAgnosticOpL( function, aMessage );
+            }
+        }
+
+    User::LeaveIfError( error );
+
+    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::DoServiceL() - END" ) );
+    }
+
+
+
+TInt CMemSpyEngineSession::ValidateFunction( TInt aFunction, TBool aIncludesThreadId, TBool aIncludesThreadName )
+    {
+    TInt err = KErrNotSupported;
+    
+    // Check the operation is within op-code range
+    if  ( aFunction >= EMemSpyClientServerOpMarkerFirst && aFunction < EMemSpyClientServerOpMarkerLast )
+        {
+        // Check the operation doesn't include unnecessary or not supported information
+        const TBool includesThreadIdentifier = ( aIncludesThreadId || aIncludesThreadName );
+        if  ( includesThreadIdentifier && aFunction >= EMemSpyClientServerOpMarkerThreadAgnosticFirst )
+            {
+            // Passing a thread identifier to a thread agnostic operation
+            err = KErrArgument;
+            }
+        else
+            {
+            err = KErrNone;
+            }
+        }
+    //
+    if  ( err != KErrNone )
+        {
+        RDebug::Printf( "[MemSpy] CMemSpyEngineSession::ValidateFunction() - function request did not validate - [withId: %d, withName: %d]", aIncludesThreadId, aIncludesThreadName );
+        }
+    //
+    return err;
+    }
+
+
+void CMemSpyEngineSession::HandleThreadSpecificOpL( TInt aFunction, const TThreadId& aThreadId )
+    {
+    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - START - aFunction: %d, aThreadId: %d", aFunction, (TUint) aThreadId ) );
+
+    ASSERT( (TUint) aThreadId != 0 );
+    TInt error = KErrNone;
+
+    // Check if its a kernel thread identifier
+    const TBool isKernel = ( static_cast<TUint32>( aThreadId ) == KMemSpyClientServerThreadIdKernel );
+
+    // Treat as thread specific operation
+    CMemSpyProcess* process = NULL;
+    CMemSpyThread* thread = NULL;
+    if  ( !isKernel )
+        {
+        error = iEngine.Container().ProcessAndThreadByThreadId( aThreadId, process, thread );
+        TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - search result: %d, proc: 0x%08x, thread: 0x%08x", error, process, thread ) );
+        }
+    else
+        {
+        // Kernel is only supported for a couple of operations
+        if  ( aFunction == EMemSpyClientServerOpHeapInfo || aFunction == EMemSpyClientServerOpHeapData )
+            {
+            }
+        else
+            {
+            TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - trying to call unsupported function for kernel thread!" ) );
+            error = KErrArgument;
+            }
+        }
+
+    // Must be no error so far and we must have a valid thread & process when performing a non-kernel op
+    // or then if we are performing a kernel op, we don't need the thread or process.
+    if  ( error == KErrNone && ( ( thread && process && !isKernel ) || ( isKernel ) ) )
+        {
+#ifdef _DEBUG
+        if  ( thread )
+            {
+            HBufC* threadName = thread->FullName().AllocLC();
+            _LIT( KTrace2, "[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - thread: %S" );
+            RDebug::Print( KTrace2, threadName );
+            CleanupStack::PopAndDestroy( threadName );
+            }
+        else if ( isKernel )
+            {
+            _LIT( KTrace2, "[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - thread: Kernel" );
+            RDebug::Print( KTrace2 );
+            }
+#endif
+
+        // Got a valid thread object - now work out which operation to perform...
+        switch( aFunction )
+            {
+        case EMemSpyClientServerOpSummaryInfo:
+            iEngine.HelperProcess().OutputProcessInfoL( *process );
+            break;
+        case EMemSpyClientServerOpSummaryInfoDetailed:
+            iEngine.HelperProcess().OutputProcessInfoDetailedL( *process );
+            break;
+        case EMemSpyClientServerOpHeapInfo:
+            if  ( isKernel )
+                {
+                iEngine.HelperHeap().OutputHeapInfoKernelL();
+                }
+            else
+                {
+                iEngine.HelperHeap().OutputHeapInfoUserL( *thread );
+                }
+            break;
+        case EMemSpyClientServerOpHeapCellListing:
+            iEngine.HelperHeap().OutputCellListingUserL( *thread );
+            break;
+        case EMemSpyClientServerOpHeapData:
+            if  ( isKernel )
+                {
+                iEngine.HelperHeap().OutputHeapDataKernelL();
+                }
+            else
+                {
+                iEngine.HelperHeap().OutputHeapDataUserL( *thread );
+                }
+            break;
+        case EMemSpyClientServerOpStackInfo:
+            iEngine.HelperStack().OutputStackInfoL( *thread );
+            break;
+        case EMemSpyClientServerOpStackDataUser:
+            iEngine.HelperStack().OutputStackDataL( *thread, EMemSpyDriverDomainUser, EFalse );
+            break;
+        case EMemSpyClientServerOpStackDataKernel:
+            iEngine.HelperStack().OutputStackDataL( *thread, EMemSpyDriverDomainKernel, EFalse );
+            break;
+        case EMemSpyClientServerOpOpenFiles:
+            iEngine.HelperFileSystem().ListOpenFilesL( aThreadId );
+            break;
+
+        default:
+            error = KErrNotSupported;
+            break;
+            }
+        }
+
+    TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - END - aFunction: %d, aThreadId: %d, error: %d", aFunction, (TUint) aThreadId, error ) );
+    User::LeaveIfError( error );
+    }
+
+
+void CMemSpyEngineSession::HandleThreadSpecificOpL( TInt aFunction, const TDesC& aThreadName )
+    {
+    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - START - aFunction: %d, aThreadName: %S"), aFunction, &aThreadName ) );
+    //
+    CMemSpyProcess* process = NULL;
+    CMemSpyThread* thread = NULL;
+    TInt error = iEngine.Container().ProcessAndThreadByPartialName( aThreadName, process, thread );
+    User::LeaveIfError( error );
+    //
+    const TThreadId threadId( thread->Id() );
+    HandleThreadSpecificOpL( aFunction, threadId );
+    //
+    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::HandleThreadSpecificOpL() - END - aFunction: %d, aThreadName: %S"), aFunction, &aThreadName ) );
+    }
+
+
+void CMemSpyEngineSession::HandleThreadAgnosticOpL( TInt aFunction, const RMessage2& aMessage )
+    {
+    TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - START" ) );
+    
+    //
+    if  ( aFunction ==  EMemSpyClientServerOpHeapInfoCompact )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpHeapInfoCompact") );
+        if (aMessage.Function() & KMemSpyOpFlagsAsyncOperation)
+        	{
+			StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EEntireDeviceHeapInfoCompact, aMessage);
+        	}
+        else
+        	{
+			iEngine.HelperHeap().OutputHeapInfoForDeviceL();
+        	}
+        }
+    else if ( aFunction ==  EMemSpyClientServerOpStackInfoCompact )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpStackInfoCompact") );
+        if (aMessage.Function() & KMemSpyOpFlagsAsyncOperation)
+			{
+			StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EEntireDeviceStackInfoCompact, aMessage);
+			}
+		else
+			{
+			iEngine.HelperStack().OutputStackInfoForDeviceL();
+			}
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart") );
+        iEngine.HelperSysMemTracker().StartL();
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop") );
+        iEngine.HelperSysMemTracker().StopL();
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingReset )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingReset") );
+        iEngine.HelperSysMemTracker().Reset();
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate") );
+        iEngine.HelperSysMemTracker().CheckForChangesNowL();
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet") );
+        
+        // Get current config
+        TMemSpyEngineHelperSysMemTrackerConfig config;
+        iEngine.HelperSysMemTracker().GetConfig( config );
+
+        // Set new timer value
+        config.iTimerPeriod = aMessage.Int0();
+
+        // And update config... which will leave if the config is invalid
+        iEngine.HelperSysMemTracker().SetConfigL( config );
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesSet )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesSet") );
+        // Get current config
+        TMemSpyEngineHelperSysMemTrackerConfig config;
+        iEngine.HelperSysMemTracker().GetConfig( config );
+
+        // Set new categories
+        config.iEnabledCategories = aMessage.Int0();
+
+        // And update config... which will leave if the config is invalid
+        iEngine.HelperSysMemTracker().SetConfigL( config );
+        }
+    
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterSet )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterSet") );
+        // Get current config
+        TMemSpyEngineHelperSysMemTrackerConfig config;
+        iEngine.HelperSysMemTracker().GetConfig( config );
+
+        // Set new filter
+        RBuf buf;
+        buf.CleanupClosePushL();
+        TInt len = aMessage.GetDesLength( 0 );
+        if ( len > 0 )
+            {
+            buf.CreateL( len );
+            aMessage.ReadL( 0, buf, 0 );
+            config.iThreadNameFilter.Copy( buf );            
+            }
+        else
+            {
+            config.iThreadNameFilter.Zero();
+            }
+        CleanupStack::PopAndDestroy( &buf );
+
+        // And update config... which will leave if the config is invalid
+        iEngine.HelperSysMemTracker().SetConfigL( config );
+        }
+    else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpSet )
+        {
+        // Get current config
+        TMemSpyEngineHelperSysMemTrackerConfig config;
+        iEngine.HelperSysMemTracker().GetConfig( config );
+        
+        // Set new Heap Dump value
+        config.iDumpData = aMessage.Int0();
+        
+        // And update config... which will leave if the config is invalid
+        iEngine.HelperSysMemTracker().SetConfigL( config );
+        }
+    else if( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingModeSet)
+    	{
+		TMemSpyEngineHelperSysMemTrackerConfig config;
+		iEngine.HelperSysMemTracker().GetConfig( config );
+		
+		TPckgBuf<TMemSpyEngineHelperSysMemTrackerConfig::TMemSpyEngineSysMemTrackerMode> mode;
+		aMessage.ReadL( 0, mode );
+		
+		config.iMode = mode();
+			
+		// And update config... which will leave if the config is invalid
+		iEngine.HelperSysMemTracker().SetConfigL( config );
+    	}
+    
+    else if ( aFunction == EMemSpyClientServerOpSwitchOutputSinkTrace )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSwitchOutputSinkTrace") );
+        iEngine.InstallDebugSinkL();
+        }
+    else if ( aFunction == EMemSpyClientServerOpSwitchOutputSinkFile )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSwitchOutputSinkFile") );
+        // Read file name from message.
+        TFileName fileName;
+        RBuf buf;
+		buf.CleanupClosePushL();
+		
+		TInt len = aMessage.GetDesLength( 0 );
+		if ( len > 0 )
+			{
+			buf.CreateL( len );
+			aMessage.ReadL( 0, buf, 0 );
+			
+			iEngine.InstallFileSinkL( buf );           
+			}
+		else
+			{
+			iEngine.InstallFileSinkL( KNullDesC );
+			}
+		
+		CleanupStack::PopAndDestroy( &buf );
+        
+        }
+    else if ( aFunction == EMemSpyClientServerOpEnumerateKernelContainer )
+        {
+        const TMemSpyDriverContainerType type = CMemSpyEngineHelperKernelContainers::MapToType( static_cast< TObjectType >( aMessage.Int0() ) );
+
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpEnumerateKernelContainer - type: %d", type ) );
+
+        CMemSpyEngineGenericKernelObjectList* model = iEngine.HelperKernelContainers().ObjectsForSpecificContainerL( type );
+        CleanupStack::PushL( model );
+        model->OutputL( iEngine.Sink() );
+        CleanupStack::PopAndDestroy( model );
+        }
+    else if ( aFunction == EMemSpyClientServerOpEnumerateKernelContainerAll )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpEnumerateKernelContainerAll") );
+        CMemSpyEngineGenericKernelObjectContainer* model = iEngine.HelperKernelContainers().ObjectsAllL();
+        CleanupStack::PushL( model );
+        model->OutputL( iEngine.Sink() );
+        CleanupStack::PopAndDestroy( model );
+        }
+    else if ( aFunction == EMemSpyClientServerOpOpenFiles )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpOpenFiles") );
+        iEngine.ListOpenFilesL();
+        }
+    else if ( aFunction == EMemSpyClientServerOpDisableAknIconCache )
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpDisableAknIconCache") );
+        iEngine.HelperRAM().SetAknIconCacheStatusL( EFalse );
+        }
+    else if ( aFunction == EMemSpyClientServerOpSummaryInfo )
+    	{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSummaryInfo") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityGeneralSummary, aMessage);
+    	}
+    else if ( aFunction == EMemSpyClientServerOpSummaryInfoDetailed )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSummaryInfoDetailed") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityGeneralDetailed, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpHeapInfo )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpHeapInfo") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityHeapInfo, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpHeapCellListing )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpHeapCellListing") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityHeapCellListing, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpHeapData )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpHeapData") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityHeapData, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpStackInfo )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpStackInfo") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityStackInfo, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpStackDataUser )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpStackDataUser") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityStackDataUser, aMessage);
+		}
+    else if ( aFunction == EMemSpyClientServerOpStackDataKernel )
+		{
+		TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpStackDataKernel") );
+		StartDeviceWideOperationL(CMemSpyDeviceWideOperations::EPerEntityStackDataKernel, aMessage);
+		}
+    else
+        {
+        TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - [device-wide operation] => invoking UI") );
+        iEngine.NotifyClientServerOperationRequestL( aFunction );
+        }
+    //
+    TRACE( RDebug::Printf("[MemSpy] CMemSpyEngineSession::HandleThreadAgnosticOpL() - END" ) );
+    }
+
+void CMemSpyEngineSession::StartDeviceWideOperationL(CMemSpyDeviceWideOperations::TOperation aOperation, const RMessage2& aMessage)
+	{
+	if (Server().CurrentOperationTracker())
+		{
+		User::Leave(KErrInUse);
+		}
+	
+	Server().SetCurrentOperationTracker(CMemSpyDwOperationTracker::NewL(aOperation, aMessage, Server()));
+	}
+
+
+
+
+
+
+
+
+
+CMemSpyDwOperationTracker* CMemSpyDwOperationTracker::NewL(CMemSpyDeviceWideOperations::TOperation aOperation, 
+		const RMessage2& aOperationMessage, CMemSpyEngineServer& aServer)
+	{
+	CMemSpyDwOperationTracker* self = new (ELeave) CMemSpyDwOperationTracker(aOperationMessage, aServer);
+	CleanupStack::PushL( self );
+	self->ConstructL(aOperation);
+	CleanupStack::Pop( self );
+	return self;
+	}
+	
+CMemSpyDwOperationTracker::~CMemSpyDwOperationTracker()
+	{
+	delete iOperation;
+	delete iPendingNotifications;
+	}
+
+CMemSpyDwOperationTracker::CMemSpyDwOperationTracker(const RMessage2& aOperationMessage, CMemSpyEngineServer& aServer) : 
+		iOperationMessage(aOperationMessage),
+		iServer(aServer),
+		iPendingNotifications(0),
+		iOperation(0),
+		iProgress(0)
+	{
+	}
+
+
+void CMemSpyDwOperationTracker::ConstructL(CMemSpyDeviceWideOperations::TOperation aOperation)
+	{
+	iPendingNotifications = new (ELeave) CArrayFixFlat<RMessage2>(3);
+	iOperation = CMemSpyDeviceWideOperations::NewL(iServer.Engine(), *this, aOperation);
+	}
+
+void CMemSpyDwOperationTracker::AddNotificationL(const RMessage2& aMessage)
+	{
+	iPendingNotifications->AppendL(aMessage);
+	}
+
+void CMemSpyDwOperationTracker::Cancel()
+	{
+	iOperation->Cancel();
+	}
+
+void CMemSpyDwOperationTracker::HandleDeviceWideOperationEvent(TEvent aEvent, TInt aParam1, const TDesC& aParam2)
+	{
+	switch( aEvent )
+		{
+	case MMemSpyDeviceWideOperationsObserver::EOperationCompleted:
+	case MMemSpyDeviceWideOperationsObserver::EOperationCancelled:
+		iServer.SetCurrentOperationTracker(0);
+		
+		for (TInt i=0; i<iPendingNotifications->Count(); i++)
+			{
+			iPendingNotifications->At(i).Complete(KErrCancel);
+			}
+		
+		if (iOperationMessage.Function() & KMemSpyOpFlagsAsyncOperation)
+			{
+			iOperationMessage.Complete(
+				aEvent == MMemSpyDeviceWideOperationsObserver::EOperationCompleted ? KErrNone : KErrCancel);
+			}
+		
+		iPendingNotifications->Reset();
+		
+		delete this;
+		break;
+		
+	case MMemSpyDeviceWideOperationsObserver::EOperationProgressEnd:
+		{
+		iProgress += aParam1;
+		for (TInt i=0; i<iPendingNotifications->Count(); i++)
+			{
+			TInt err;
+			TRAP(err, iPendingNotifications->At(i).WriteL(0, TPckgBuf<TInt>( iProgress * 100 / iOperation->TotalOperationSize() )));
+			TRAP(err, iPendingNotifications->At(i).WriteL(1, aParam2));
+			if (err != KErrNone)
+				{
+				// TODO: iPendingProgressNotifications->At(i).Panic()
+				}
+			iPendingNotifications->At(i).Complete(KErrNone);
+			}
+		iPendingNotifications->Reset();
+		break;
+		}
+		
+		}
+	
+	}