diff -r 185201be11b0 -r 516af714ebb4 perfsrv/memspy/memspy_plat/memspy_api/include/MemSpyEngineClientInterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/perfsrv/memspy/memspy_plat/memspy_api/include/MemSpyEngineClientInterface.h	Fri Sep 17 08:38:31 2010 +0300
@@ -0,0 +1,742 @@
+/*
+* 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:
+*
+*/
+
+
+#ifndef MEMSPYENGINECLIENTINTERFACE_H
+#define MEMSPYENGINECLIENTINTERFACE_H
+
+
+// System includes
+#include <e32base.h>
+#include <u32std.h>
+
+// Constants
+const TInt KMemSpyClientServerVersion           = 2;
+const TInt KMemSpyListInfoForAllThreads         = -1;
+
+/**
+ * Special constant to be used to indicate kernel thread id
+ * when performing kernel-specific thread agnostic operations.
+ *
+ * Note that the kernel thread is not supported for all thread-specific
+ * operation types. 
+ *
+ * Use this value to indicate that the kernel thread is the target
+ * thread when calling the thread-specific overload of PerformOperation().
+ */
+const TUint32 KMemSpyClientServerThreadIdKernel = KMaxTUint32;
+
+// Internal constants
+const TInt KMemSpyOpFlagsTypeMask               = 0x0000FFFF;
+const TInt KMemSpyOpFlagsInclusionMask          = 0xFFFF0000;
+const TInt KMemSpyOpFlagsIncludesThreadId       = 0x00010000;
+const TInt KMemSpyOpFlagsIncludesThreadName     = 0x00020000;
+const TInt KMemSpyOpFlagsAsyncOperation         = 0x00040000;
+// Literal constants
+_LIT( KMemSpyServerName, "MemSpyServer" );
+_LIT( KMemSpyProcessName0, "MemSpyServer.exe" );
+_LIT( KMemSpyProcessName1, "MemSpyUI.exe" );
+//_LIT( KMemSpyProcessName2, "MemSpyConsole.exe" );
+
+//
+// Supported MemSpy operation types
+//
+// Operations which can only be applied to a specific thread are
+// prefixed by [TS] - i.e. it is permitted to use the thread-specific 
+// overload of PerformOperation() for this operation type.
+//
+// Operations that can be applied only to the entire device are
+// prefixed by [ED] - i.e. it is permitted to use the 
+// thread-agnostic overload of PerformOperation() for this operation type.
+//
+// Operations that support kernel-thread-specific requests
+// are prefixed by [KS] - i.e. it is permitted to use the 
+// thread-specific overload of PerformOperation() and the thread
+// identification parameter should correspond to KMemSpyClientServerThreadIdKernel.
+// NB: The overload of PerformOperation() which supports a descriptor cannot
+// be used.
+//
+// Operations that are not relevant to a thread are prefixed
+// by [NT] - i.e. use the thread-agnostic overload of
+// PerformOperation()
+//
+// All other op codes are deemed internal and are not to be
+// used except via provided APIs.
+//
+enum TMemSpyClientServerOp
+    {
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpMarkerFirst = 0,
+
+    /**
+     * [TS][ED]
+     * Show basic summary information about a thread/process
+     */
+    EMemSpyClientServerOpSummaryInfo = EMemSpyClientServerOpMarkerFirst,
+
+    /**
+     * [TS][ED]
+     * Show detailed summary information about a thread/process
+     */
+    EMemSpyClientServerOpSummaryInfoDetailed,
+
+    /**
+     * [TS][ED][KS]
+     * Show heap information & statistics for a user-side thread
+     */
+    EMemSpyClientServerOpHeapInfo,
+
+    /**
+     * [TS][ED]
+     * Prvide heap cell listings for a thread
+     */
+    EMemSpyClientServerOpHeapCellListing,
+
+    /**
+     * [TS][ED][KS]
+     * Dump a thread's heap
+     */
+    EMemSpyClientServerOpHeapData,
+
+    /**
+     * [TS][ED]
+     * Show summary information about a thread's stack
+     */
+    EMemSpyClientServerOpStackInfo,
+
+    /**
+     * [TS][ED]
+     * Dump a thread's user-side stack
+     */
+    EMemSpyClientServerOpStackDataUser,
+
+    /**
+     * [TS][ED]
+     * Dump a thread's kernel-side stack
+     */
+    EMemSpyClientServerOpStackDataKernel,
+
+    /**
+     * [TS][ED]
+     * List all open files in the OS or then the open files
+     * for a given thread.
+     */
+    EMemSpyClientServerOpOpenFiles,
+    
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpMarkerThreadAgnosticFirst,
+
+    /**
+     * [ED]
+     * Provide compact heap information for the entire device, which
+     * can be compared with other similar listings using Heap Analyser.
+     */
+    EMemSpyClientServerOpHeapInfoCompact = EMemSpyClientServerOpMarkerThreadAgnosticFirst,
+
+    /**
+     * [ED]
+     * Show compact stack information for the device
+     */
+    EMemSpyClientServerOpStackInfoCompact,
+
+    /**
+     * [NT]
+     * Start the system wide memory tracker (SWMT) running, so that when
+     * the timer expires, the system characteristics will be sampled
+     * and any changes notified. NB: Starting the SWMT running for the first time
+     * will cause an initial preparatory cycle to be established. Future updates
+     * will then follow when the timer tick period expires
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingTimerStart,
+
+    /** 
+     * [NT]
+     * Stop the system wide memory tracker. No futher automatic timer-based
+     * SWMT cycles will be performed unless "Force update" is utilised or the timer
+     * is started again.
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingTimerStop,
+
+    /** 
+     * [NT]
+     * Reset the SWMT so that all existing cycles are discarded (which can free
+     * quite a lot of memory). All operations are cancelled, the SWMT will be idle.
+     * 
+     * If performing manual "force updates" to the SWMT, then the SWMT should be reset
+     * before starting a new test run. For timer-based SWMT sampling, this operation
+     * is performed internally by MemSpy and therefore is redundant in that situation.
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingReset,
+
+    /**
+     * [NT]
+     * Force the system wide memory tracker (internal to memspy) to
+     * perform a refresh
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingForceUpdate,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSwitchOutputSinkFile,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSwitchOutputSinkTrace,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpEnumerateKernelContainer,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpEnumerateKernelContainerAll,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpBitmapsSave,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpDisableAknIconCache,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSendToBackground,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpBringToForeground,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpExit,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesSet,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterSet,
+
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpSet,
+        
+    /**
+     * [INTERNAL REQUEST]
+     */
+    EMemSpyClientServerOpSystemWideMemoryTrackingModeSet,        
+    
+    /**
+	 * [INTERNAL REQUEST]
+	 */
+	EMemSpyClientServerOpMarkerUiFirst,
+	
+	EMemSpyClientServerOpGetProcessCount = EMemSpyClientServerOpMarkerUiFirst,
+	
+	EMemSpyClientServerOpGetProcesses,
+	
+	EMemSpyClienServerOpGetProcessIdByName,
+	
+	EMemSpyClientServerOpGetThreadCount,
+	
+	EMemSpyClientServerOpGetThreads,
+	
+	EMemSpyClientServerOpSetThreadPriority,
+	
+	EMemSpyClientServerOpProcessSystemPermanentOrCritical,
+	
+	EMemSpyClientServerOpEndProcess,
+	
+	EMemSpyClientServerOpSwitchToProcess,
+	
+	//Threads operations
+	EMemSpyClientServerOpThreadSystemPermanentOrCritical,
+	
+	EMemSpyClientServerOpEndThread,
+	
+	EMemSpyClientServerOpSwitchToThread,
+	
+	EMemSpyClientServerOpGetInfoItemType,
+	
+	EMemSpyClientServerOpGetProcessIdByThreadId,
+	
+	EMemSpyClientServerOpGetThreadInfoItemsCount,
+	
+	EMemSpyClientServerOpGetThreadInfoItems,
+	
+	EMemSpyClientServerOpOutputInfoHandles,
+	
+	EMemSpyClientServerOpOutputAOList,
+		
+	
+	//Kernel Objects operations
+	EMemSpyClientServerOpGetKernelObjectCount,
+	
+	EMemSpyClientServerOpGetKernelObjects,
+	
+	EMemSpyClientServerOpGetKernelObjectItemCount,
+	
+	EMemSpyClientServerOpGetKernelObjectItems,
+	
+	EMemSpyClientServerOpGetHeap,
+	
+	EMemSpyClientServerOpGetMemoryTrackingCycleCount,
+	
+	EMemSpyClientServerOpGetMemoryTrackingCycles,
+	
+	EMemSpyClientServerOpGetMemoryTrackingMdcaCount,
+	/**
+	 * [INTERNAL REQUEST]
+	 * Register for notifications of device wide operation progress.
+	 */
+	EMemSpyClientServerOpNotifyDeviceWideOperationProgress,
+	
+	/**
+	 * [INTERNAL REQUEST]
+	 * Cancel current device wide operation
+	 */
+	EMemSpyClientServerOpCancelDeviceWideOperation,	
+	
+	EMemSpyClientServerOpOutputAllContainerContents,
+	    
+	EMemSpyClientServerOpDumpKernelHeap,
+	
+	EMemSpyClientServerOpSetSwmtAutoStartProcessList,
+		
+	EMemSpyClientServerOpGetOutputSink,
+	
+	/**
+	 * [INTERNAL REQUEST]
+	 * Check if system wide memory tracking timer is running.
+	 */
+	EMemSpyClientServerOpIsSwmtRunning,
+	
+	EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodGet,
+
+	EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterGet,
+    
+    EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesGet,
+    
+    EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpGet,
+
+    EMemSpyClientServerOpSystemWideMemoryTrackingModeGet,   
+	
+    //Servers methods
+	EMemSpyClientServerOpGetServerCount,
+	
+	EMemSpyClientServerOpGetServers,
+	
+	EMemSpyClientServerOpGetSortedServers,
+	
+	EMemSpyClientServerOpServerListOutputGeneric,
+	
+	EMemSpyClientServerOpGetEComCategoryCount,
+	    
+	EMemSpyClientServerOpGetEComCategories,
+	
+	EMemSpyClientServerOpGetEComInterfaceCount,
+	        
+	EMemSpyClientServerOpGetEComInterfaces,
+	
+	EMemSpyClientServerOpGetEComImplementationCount,
+	            
+	EMemSpyClientServerOpGetEComImplementations,
+	
+	EMemSpyClientServerOpMarkerUiLast,		
+	
+	/**
+	 * [INTERNAL REQUEST]
+	 */
+    EMemSpyClientServerOpMarkerLast,
+    };
+
+
+enum TMemSpyEndType
+	{
+	ETerminate,
+	EKill,
+	EPanic
+	};
+
+
+
+
+
+NONSHARABLE_CLASS( RMemSpyEngineClientInterface ) : public RSessionBase
+    {
+public:
+    inline RMemSpyEngineClientInterface();
+    inline TInt Connect();
+    inline void Close();
+
+public: // API
+
+    /**
+     * Thread-agnostic request function. Performs the operation in the context of
+     * the entire device.
+     *
+     * I.e. can only be used for [NT] or [ED] requests.
+     */
+    inline TInt PerformOperation( TMemSpyClientServerOp aOperation );
+
+    /**
+     * Thread-specific request functions. Perform the requested operation in the context
+     * of the specified thread id, or (possibly partial) thread name.
+     *
+     * To perform the operation in the context of the current thread, invoke the
+     * function as follows:
+     *
+     *      PerformOperation( <...>, RThread().Id() );
+     *
+     * I.e. can only be used for [TS] requests.
+     */
+    inline TInt PerformOperation( TMemSpyClientServerOp aOperation, TThreadId aId );
+    inline TInt PerformOperation( TMemSpyClientServerOp aOperation, const TDesC& aThreadName );
+
+    /**
+     * General functions to switch MemSpy's output mode.
+     */
+    inline TInt SwitchOutputModeFile();
+    inline TInt SwitchOutputModeTrace();
+
+    /**
+     * Configure the system wide memory tracker timer interval (for automatic timer-based polling).
+     * Change will take effect next time SWMT is started.
+     */
+    inline TInt SystemWideMemoryTrackerTimerIntervalSet( TInt aInterval );
+
+    /**
+     * Configure the system wide memory tracker categories.
+     * Change will take effect next time SWMT is started.
+     */
+    inline TInt SystemWideMemoryTrackerCategoriesSet( TInt aCategories );
+
+    /**
+     * Configure the system wide memory tracker for filtering user heaps by thread name.
+     * Change will take effect next time SWMT is started.
+     */
+    inline TInt SystemWideMemoryTrackerThreadFilterSet( const TDesC& aFilter );
+    
+    /**
+     * Configure the system wide memory tracker for enabling/disabling Heap dumps during SWMT.
+     * Change will take effect next time SWMT is started.
+     */
+    inline TInt SystemWideMemoryTrackerHeapDumpSet( TBool aDumpEnabled );
+    
+    /**
+     * List the contents of a specific kernel container. See TObjectType for types.
+     */
+    inline TInt EnumerateKernelContainer( TObjectType aType );
+
+    /**
+     * List the contents of all kernel containers
+     */
+    inline TInt EnumerateKernelContainerAll();
+
+    /**
+     * Save bitmaps to memory card
+     */
+    inline TInt SaveAllBitmaps();
+
+    /**
+     * Disable AknIcon caching
+     */
+    inline TInt DisableAknIconCache();
+
+    /**
+     * Send MemSpy to the background/bring to foreground
+     */
+    inline TInt SendToBackground();
+    inline TInt BringToForeground();
+
+    /**
+     * Exit MemSpy
+     */
+    inline TInt Exit();
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+inline RMemSpyEngineClientInterface::RMemSpyEngineClientInterface()
+    {
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::Connect()
+    {
+    TVersion version( KMemSpyClientServerVersion, 0, 0 );
+    return CreateSession( KMemSpyServerName, version );
+    }
+
+
+inline void RMemSpyEngineClientInterface::Close()
+    {
+    RSessionBase::Close();
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::PerformOperation( TMemSpyClientServerOp aOperation )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = aOperation;
+        const TIpcArgs args( KMemSpyListInfoForAllThreads );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::PerformOperation( TMemSpyClientServerOp aOperation, TThreadId aId )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = aOperation | KMemSpyOpFlagsIncludesThreadId;
+        const TIpcArgs args( aId );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::PerformOperation( TMemSpyClientServerOp aOperation, const TDesC& aThreadName )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = aOperation | KMemSpyOpFlagsIncludesThreadName;
+        const TIpcArgs args( &aThreadName );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+
+
+
+
+inline TInt RMemSpyEngineClientInterface::SwitchOutputModeFile()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSwitchOutputSinkFile;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SwitchOutputModeTrace()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSwitchOutputSinkTrace;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+
+
+
+
+
+
+inline TInt RMemSpyEngineClientInterface::SystemWideMemoryTrackerTimerIntervalSet( TInt aInterval )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSystemWideMemoryTrackingTimerPeriodSet;
+        const TIpcArgs args( aInterval );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SystemWideMemoryTrackerCategoriesSet( TInt aCategories )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSystemWideMemoryTrackingCategoriesSet;
+        const TIpcArgs args( aCategories );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SystemWideMemoryTrackerThreadFilterSet( const TDesC& aFilter )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSystemWideMemoryTrackingThreadNameFilterSet;
+        TIpcArgs args( &aFilter );
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SystemWideMemoryTrackerHeapDumpSet( TBool aDumpEnabled  )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSystemWideMemoryTrackingHeapDumpSet;
+        const TIpcArgs args( aDumpEnabled );
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::EnumerateKernelContainer( TObjectType aType )
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpEnumerateKernelContainer;
+        const TIpcArgs args( aType );
+        //
+        error = SendReceive( opCode, args );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::EnumerateKernelContainerAll()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpEnumerateKernelContainerAll;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SaveAllBitmaps()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpBitmapsSave;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::DisableAknIconCache()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpDisableAknIconCache;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::SendToBackground()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpSendToBackground;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::BringToForeground()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpBringToForeground;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+inline TInt RMemSpyEngineClientInterface::Exit()
+    {
+    TInt error = KErrNotReady;
+    if  ( Handle() != KNullHandle )
+        {
+        const TInt opCode = EMemSpyClientServerOpExit;
+        error = SendReceive( opCode );
+        }
+    return error;
+    }
+
+
+#endif