diff -r ccab7f1f8266 -r a71a3e32a2ae memspy/MemSpyServer/Source/MemSpyServerSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/memspy/MemSpyServer/Source/MemSpyServerSession.cpp Thu May 13 23:59:27 2010 +0300 @@ -0,0 +1,953 @@ +/* +* 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: +* Implementation of the new MemSpyServer +*/ + +// System includes +#include +#include +#include +#include +//#include +//#include + +//user includes +#include "MemSpyServerSession.h" + +// User includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//cigasto +#include +//#include + +// --------------------------------------------------------- +// CMemSpyServerSession( CMemSpyEngine& aEngine ) +// --------------------------------------------------------- +// +CMemSpyServerSession::CMemSpyServerSession( CMemSpyEngine& aEngine ) +: iEngine( aEngine ) + { + } + +// --------------------------------------------------------- +// ~CMemSpyServerSession() +// --------------------------------------------------------- +// +CMemSpyServerSession::~CMemSpyServerSession() + { +#ifdef _DEBUG + TPtrC pThreadName( KNullDesC ); + if ( iClientThreadName ) + { + pThreadName.Set( *iClientThreadName ); + } + + RDebug::Print( _L("[MemSpy] CMemSpyServerSession::~CMemSpyServerSession() - DEAD SESSION - this: 0x%08x, id: %4d, name: %S"), this, iClientThreadId, iClientThreadName ); +#endif + + delete iClientThreadName; + } + +// --------------------------------------------------------- +// ConstructL( const RMessage2& aMessage ) +// --------------------------------------------------------- +// +void CMemSpyServerSession::ConstructL( const RMessage2& aMessage ) + { + RThread thread; + const TInt error = aMessage.Client( thread ); + CleanupClosePushL( thread ); + + TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::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 ); + + TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ConstructL() - NEW SESSION - this: 0x%08x, id: %4d, client: %S"), this, iClientThreadId, iClientThreadName ) ); + } + +// --------------------------------------------------------- +// NewL( CMemSpyEngine& aEngine, const RMessage2& aMessage ) +// Two-phased constructor +// --------------------------------------------------------- +// +CMemSpyServerSession* CMemSpyServerSession::NewL( CMemSpyEngine& aEngine, const RMessage2& aMessage ) + { + CMemSpyServerSession* self = new(ELeave) CMemSpyServerSession( aEngine ); + CleanupStack::PushL( self ); + self->ConstructL( aMessage ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------- +// ServiceL( const RMessage2& aMessage ) +// Method from which the clients request arrives +// --------------------------------------------------------- +// +void CMemSpyServerSession::ServiceL( const RMessage2& aMessage ) + { + TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::ServiceL() - SERVICE ERROR - this: 0x%08x, fn: %d, err: %d, client: %S"), this, aMessage.Function(), error, iClientThreadName ); + } + aMessage.Complete( error ); + + TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ServiceL() - END - this: 0x%08x, fn: 0x%08x, id: %4d, client: %S"), this, aMessage.Function(), iClientThreadId, iClientThreadName ) ); + } + +// --------------------------------------------------------- +// DoCmdServiceL( const RMessage2& aMessage ) +// --------------------------------------------------------- +// +void CMemSpyServerSession::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] CMemSpyServerSession::DoServiceL() - START - unmodified function: 0x%08x, opCode: %d [TID: %d, TN: %d]", aMessage.Function(), function, byThreadId, byThreadName ) ); + + switch (function) + { + case EGetProcessCount: + { + aMessage.WriteL(0, TPckgBuf(iEngine.Container().Count())); + break; + } + case EGetProcesses: + { + CMemSpyEngineObjectContainer& list = iEngine.Container(); + + TPckgBuf a0; + aMessage.ReadL(0, a0); + TInt realCount = Min(a0(), list.Count()); + + for(TInt i=0, offset = 0; i buffer(data); + aMessage.WriteL(1, buffer, offset); + } + + a0 = list.Count(); + aMessage.WriteL(0, a0); + + break; + } + case EProcessSystemPermanentOrCritical: + { + TBool ret = EFalse; + TPckgBuf id; + aMessage.ReadL( 0, id ); + + CMemSpyEngineObjectContainer& container = iEngine.Container(); + CMemSpyProcess& process = container.ProcessByIdL( id() ); + + process.Open(); + + if ( process.IsSystemPermanent() || process.IsSystemCritical() ) + { + ret = ETrue; + } + TPckgBuf retBuf( ret ); + aMessage.WriteL( 1, retBuf ); + + break; + } + case EEndProcess: + { + TPckgBuf id; + aMessage.ReadL( 0, id ); + TPckgBuf 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 ESwitchToProcess: + {/* + TInt wgCount; + RWsSession wsSession; + User::LeaveIfError( wsSession.Connect() ); + CleanupClosePushL( wsSession ); + User::LeaveIfError( wgCount = wsSession.NumWindowGroups() ); + RArray wgArray; + CleanupClosePushL( wgArray ); + User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) ); + TApaTask task( wsSession ); + TBool brought( EFalse ); + TInt wgId( KErrNotFound ); + TThreadId threadId; + + TPckgBuf 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 ret( brought ); + aMessage.WriteL( 1, ret ); + + break;*/ + } + case EGetThreadCount: + { + TPckgBuf pid; + aMessage.ReadL(1, pid); + CMemSpyProcess& process = iEngine.Container().ProcessByIdL(pid()); + process.Open(); + aMessage.WriteL(0, TPckgBuf(process.Count())); + process.Close(); + break; + } + case EGetThreads: + { + TPckgBuf pid; + aMessage.ReadL(2, pid); + + CMemSpyProcess& list = iEngine.Container().ProcessByIdL(pid()); + list.Open(); + + TPckgBuf a0; + aMessage.ReadL(0, a0); + TInt realCount = Min(a0(), list.Count()); + + for(TInt i=0, offset = 0; i buffer(data); + aMessage.WriteL(1, buffer, offset); + + thread.Close(); + } + + a0 = list.Count(); + aMessage.WriteL(0, a0); + + list.Close(); + + break; + } + case ESetThreadPriority: + { + TPckgBuf tid; + TPckgBuf 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->Open(); + thread->SetPriorityL(static_cast(priority())); + thread->Close(); + } + break; + } + case EThreadSystemPermanentOrCritical: + { + TBool ret = EFalse; + TPckgBuf id; + aMessage.ReadL( 0, id ); + + CMemSpyEngineObjectContainer& container = iEngine.Container(); + CMemSpyProcess* process = NULL; + CMemSpyThread* thread = NULL; + User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) ); + + if ( thread ) + { + thread->Open(); + + if ( thread->IsSystemPermanent() || thread->IsSystemCritical() ) + { + ret = ETrue; + } + thread->Close(); + } + TPckgBuf retBuf( ret ); + aMessage.WriteL( 1, retBuf ); + + break; + } + case EEndThread: + { + TPckgBuf id; + aMessage.ReadL( 0, id ); + TPckgBuf 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; + } + // --- KernelObjects related functions --- + case EGetKernelObjectTypeCount: + { + TInt iCount = EMemSpyDriverContainerTypeLast - EMemSpyDriverContainerTypeFirst; + TPckgBuf ret( iCount ); + aMessage.WriteL(0, ret); + break; + } + case EGetKernelObjects: + { + TPckgBuf count; + aMessage.ReadL(0, count); + + CMemSpyEngineGenericKernelObjectContainer* model = iEngine.HelperKernelContainers().ObjectsAllL(); //contains all the objects + CleanupStack::PushL( model ); + + for( TInt i=0, offset = 0; iAt(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 buffer(data); + aMessage.WriteL(1, buffer, offset); + } + aMessage.WriteL(0, count); + CleanupStack::PopAndDestroy( model ); + break; + } + case EGetKernelObjectItemsCount: + { + TPckgBuf tempType; + aMessage.ReadL(1, tempType); //get type of kernel object + TMemSpyDriverContainerType type = tempType(); + + CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers(); + CMemSpyEngineGenericKernelObjectList* iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( type ); + CleanupStack::PushL( iObjectList ); + + TInt count = iObjectList->Count(); + TPckgBuf ret( count ); + aMessage.WriteL( 0, ret ); + + CleanupStack::PopAndDestroy( iObjectList ); + break; + } + case EGetKernelObjectItems: + { + TPckgBuf count; + TPckgBuf 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() ); + CleanupStack::PushL( iObjectList ); + + for( TInt i=0, offset = 0; iAt( i ); + + TPckgBuf buffer(data); + aMessage.WriteL(2, buffer, offset); + } + + CleanupStack::PopAndDestroy( iObjectList ); + break; + } + // --- Kernel Heap related functions --- + case EGetHeap: + { + TMemSpyHeapInfo heapInfo; + iEngine.HelperHeap().GetHeapInfoKernelL( heapInfo ); + TMemSpyHeapData data = iEngine.HelperHeap().NewHeapRawInfo( heapInfo ); + + TPckgBuf buffer(data); + aMessage.WriteL(0, buffer); + + break; + } + } +// else if( function == EProcessByIndex ) +// { +// TMemSpyProcess iProcess; +// TInt in; +// TPckgBuf index( in ); +// aMessage.ReadL( 0, index ); +// CMemSpyProcess& process = iEngine.Container().At( index() ); +// //fill the data structure +// iProcess.iId = process.Id(); //process ID +// iProcess.iName.Append( process.Name() ); //raw process name +// iProcess.iThreadCount = process.Count(); //thread count +// iProcess.iPriority = process.Priority(); +// // +// TPckgBuf buf( iProcess ); +// aMessage.WriteL( 1, buf ); +// aMessage.Complete( KErrNone ); +// } +// else if( function == EProcessIndexById ) +// { +// TProcessId iId; +// TPckgBuf buf( iId ); +// aMessage.ReadL( 0, buf ); +// TInt index = iEngine.Container().ProcessIndexById( buf() ); +// TPckgBuf out( index ); +// aMessage.WriteL( 1, out ); +// aMessage.Complete( KErrNone ); +// } +// else if( function == EOutputProcessInfo ) +// { +// TProcessId iId; +// TPckgBuf buf( iId ); +// aMessage.ReadL( 0, buf ); +// CMemSpyProcess& process = iEngine.Container().ProcessByIdL( buf() ); +// iEngine.HelperProcess().OutputProcessInfoL( process ); +// } +// else if( function == EProcessIsDead ) +// { +// TProcessId iId; +// TPckgBuf buf( iId ); +// aMessage.ReadL( 0, buf ); +// CMemSpyProcess& process = iEngine.Container().ProcessByIdL( buf() ); +// TBool dead = process.IsDead(); +// TPckgBuf out( dead ); +// aMessage.WriteL( 1, out ); +// aMessage.Complete( KErrNone ); +// } +// else if( function == ESortProcessesBy ) +// { +// TSortType type; +// TPckgBuf buf(type); +// aMessage.ReadL( 0, buf ); +// if( buf() == ESortProcById ) +// { +// iEngine.Container().SortById(); +// } +// else if( buf() == ESortProcByName ) +// { +// iEngine.Container().SortByName(); +// } +// else if( buf() == ESortProcByThreadCount ) +// { +// iEngine.Container().SortByThreadCount(); +// } +// else if( buf() == ESortProcByCodeSegs ) +// { +// iEngine.Container().SortByCodeSegs(); +// } +// else if( buf() == ESortProcByHeapUsage ) +// { +// iEngine.Container().SortByHeapUsage(); +// } +// else if( buf() == ESortProcByStackUsage ) +// { +// iEngine.Container().SortByStackUsage(); +// } +// } +// else if( function == EOpenCloseCurrentProcess ) +// { +// TProcessId id; +// TBool open; +// TPckgBuf buf(id); +// TPckgBuf buf2(open); +// aMessage.ReadL( 0, buf ); +// aMessage.ReadL( 1, buf2 ); +// if( buf2() == 1 ) +// { +// iEngine.Container().ProcessByIdL( buf() ).Open(); +// } +// else +// { +// iEngine.Container().ProcessByIdL( buf() ).Close(); +// } +// } + +// // Check function is supported and argument combination is valid +// error = ValidateFunction( function, byThreadId, byThreadName ); +// TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::DoServiceL() - validation result: %d", error ) ); +// +// // Process function request +// if ( error == KErrNone ) +// { +// if ( byThreadId ) +// { +// TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::DoServiceL() - [TID] thread-specific..." ) ); +// +// const TThreadId threadId( aMessage.Int0() ); +// HandleThreadSpecificOpL( function, threadId ); +// } +// else if ( byThreadName ) +// { +// TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::DoServiceL() - thread-agnostic..." ) ); +// +// HandleThreadAgnosticOpL( function, aMessage ); +// } +// } + + User::LeaveIfError( error ); + + TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::DoServiceL() - HELLOOOOOO" ) ); + TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::DoServiceL() - END" ) ); + } + +// --------------------------------------------------------- +// ValidateFunction( TInt aFunction, TBool aIncludesThreadId, TBool aIncludesThreadName ) +// Validates the MemSpy operation types +// --------------------------------------------------------- +// +TInt CMemSpyServerSession::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] CMemSpyServerSession::ValidateFunction() - function request did not validate - [withId: %d, withName: %d]", aIncludesThreadId, aIncludesThreadName ); + } + // + return err; + } + +// --------------------------------------------------------- +// HandleThreadSpecificOpL( TInt aFunction, const TThreadId& aThreadId ) +// --------------------------------------------------------- +// +void CMemSpyServerSession::HandleThreadSpecificOpL( TInt aFunction, const TThreadId& aThreadId ) + { +// TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::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( 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] CMemSpyServerSession::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] CMemSpyServerSession::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] CMemSpyServerSession::HandleThreadSpecificOpL() - thread: %S" ); +// RDebug::Print( KTrace2, threadName ); +// CleanupStack::PopAndDestroy( threadName ); +// } +// else if ( isKernel ) +// { +// _LIT( KTrace2, "[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::HandleThreadSpecificOpL() - END - aFunction: %d, aThreadId: %d, error: %d", aFunction, (TUint) aThreadId, error ) ); +// User::LeaveIfError( error ); + } + +// --------------------------------------------------------- +// HandleThreadSpecificOpL( TInt aFunction, const TDesC& aThreadName ) +// Gets thread ID from aThreadName +// and calls HandleThreadSpecificOpL( , const TThreadId& aThreadId ) +// --------------------------------------------------------- +// +void CMemSpyServerSession::HandleThreadSpecificOpL( TInt aFunction, const TDesC& aThreadName ) + { +// TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::HandleThreadSpecificOpL() - END - aFunction: %d, aThreadName: %S"), aFunction, &aThreadName ) ); + } + +// --------------------------------------------------------- +// HandleThreadAgnosticOpL( TInt aFunction, const RMessage2& aMessage ) +// --------------------------------------------------------- +// +void CMemSpyServerSession::HandleThreadAgnosticOpL( TInt aFunction, const RMessage2& aMessage ) + { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - START" ) ); +// // +// if ( aFunction == EMemSpyClientServerOpHeapInfoCompact ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpHeapInfoCompact") ); +// iEngine.HelperHeap().OutputHeapInfoForDeviceL(); +// } +// else if ( aFunction == EMemSpyClientServerOpStackInfoCompact ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpStackInfoCompact") ); +// iEngine.HelperStack().OutputStackInfoForDeviceL(); +// } +// else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart") ); +// iEngine.HelperSysMemTracker().StartL(); +// } +// else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop") ); +// iEngine.HelperSysMemTracker().StopL(); +// } +// else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingReset ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingReset") ); +// iEngine.HelperSysMemTracker().Reset(); +// } +// else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate") ); +// iEngine.HelperSysMemTracker().CheckForChangesNowL(); +// } +// else if ( aFunction == EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::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] CMemSpyServerSession::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 == EMemSpyClientServerOpSwitchOutputSinkTrace ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSwitchOutputSinkTrace") ); +// iEngine.InstallSinkL( ESinkTypeDebug ); +// } +// else if ( aFunction == EMemSpyClientServerOpSwitchOutputSinkFile ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpSwitchOutputSinkFile") ); +// iEngine.InstallSinkL( ESinkTypeFile ); +// } +// else if ( aFunction == EMemSpyClientServerOpEnumerateKernelContainer ) +// { +// const TMemSpyDriverContainerType type = CMemSpyEngineHelperKernelContainers::MapToType( static_cast< TObjectType >( aMessage.Int0() ) ); +// +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::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] CMemSpyServerSession::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] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpOpenFiles") ); +// iEngine.ListOpenFilesL(); +// } +// else if ( aFunction == EMemSpyClientServerOpDisableAknIconCache ) +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - EMemSpyClientServerOpDisableAknIconCache") ); +// iEngine.HelperRAM().SetAknIconCacheStatusL( EFalse ); +// } +// else +// { +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - [device-wide operation] => invoking UI") ); +// iEngine.NotifyClientServerOperationRequestL( aFunction ); +// } +// // +// TRACE( RDebug::Printf("[MemSpy] CMemSpyServerSession::HandleThreadAgnosticOpL() - END" ) ); + }