--- a/memana/analyzetoolclient/storageserver/server/src/atstorageserversession.cpp Thu Feb 11 15:52:57 2010 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3397 +0,0 @@
-/*
-* 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: Definitions and constants for the class CATStorageServerSession
-*
-*/
-
-
-
-// INCLUDE FILES
-#include <utf.h>
-#include <analyzetool/analyzetooltraceconstants.h>
-#include "atstorageServerSession.h"
-#include "atstorageServer.h"
-#include "atstorageservercommon.h"
-#include "atmemoryentry.h"
-#include "atlog.h"
-#include "atdynprocessinfo.h"
-#include "atdriveinfo.h"
-
-// CONSTANTS
-
-// New file name start and end index.
-const TInt KNameIndexStart = 1;
-const TInt KNameIndexEnd = 100;
-
-// ==================== MEMBER FUNCTIONS for TAllocInfo ========================
-
-// -----------------------------------------------------------------------------
-// TAllocInfo::TAllocInfo
-// Implementation for the constructor of the class TAllocInfo
-// -----------------------------------------------------------------------------
-//
-TAllocInfo::TAllocInfo( TUint32 aMemAddress, TInt aAllocSize ) :
- iMemAddress( aMemAddress ),
- iAllocSize( aAllocSize )
- {
- }
-
-
-// ============== MEMBER FUNCTIONS for CATStorageServerSession =================
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CATStorageServerSession
-// C++ default constructor. It Does not contain any code that
-// might leave.
-// -----------------------------------------------------------------------------
-//
-CATStorageServerSession::CATStorageServerSession( CATStorageServer& aStorageServer ) :
- iStorageServer( aStorageServer ),
- iError( 0 ),
- iLeakArray( KLeakArrayGranularity ),
- iProcessId( KNullProcessId ),
- iLoggingOngoing( EFalse ),
- iLogOption( KDefaultLoggingMode ),
- iCurAllocSize( 0 ),
- iMaxAllocs( 0 ),
- iMaxAllocSize( 0 ),
- iLogFile( KEmpty() ),
- iIsUdeb( 1 )
- {
- LOGSTR1( "STSE CATStorageServerSession::CATStorageServerSession()" );
-
- // Initialize iMicroSecondsAt1970
- TTime time( KJanuaryFirst1970 );
- iMicroSecondsAt1970 = time.Int64();
-
- // Increment the server's session count by one (1)
- iStorageServer.IncSessionCount();
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::ConstructL
-// Symbian 2nd phase constructor can leave.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::ConstructL()
- {
- // Intentionally left empty
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::NewL
-// Two-phased constructor.
-// -----------------------------------------------------------------------------
-//
-CATStorageServerSession* CATStorageServerSession::NewL( CATStorageServer& aStorageServer )
- {
- CATStorageServerSession* self = NewLC( aStorageServer );
- CleanupStack::Pop( self );
-
- return self;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::NewLC
-// Two-phased constructor.
-// -----------------------------------------------------------------------------
-//
-CATStorageServerSession* CATStorageServerSession::NewLC( CATStorageServer& aStorageServer )
- {
- CATStorageServerSession* self = new ( ELeave ) CATStorageServerSession( aStorageServer );
-
- CleanupStack::PushL( self );
- self->ConstructL();
- return self;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::~CATStorageServerSession
-// Destructor
-// -----------------------------------------------------------------------------
-CATStorageServerSession::~CATStorageServerSession()
- {
- LOGSTR1( "STSE CATStorageServerSession::~CATStorageServerSession()" );
-
- // Empty the array and delete the referenced objects
- iLeakArray.ResetAndDestroy();
-
- // Close the leak array
- iLeakArray.Close();
-
- // Close the allocation info array
- iAllocInfoArray.Close();
-
- // Check if process closed abnormal
- if ( iProcessId != KNullProcessId &&
- iLoggingOngoing && iLogOption != EATLoggingOff &&
- iError != KErrNoMemory )
- {
- LogAbnormalEnd();
- }
-
- // Close the file and the handle to the file server
- CloseFsAndFile();
-
- // Remove the process with the current PID from the server's array of processes
- TRAP_IGNORE( iStorageServer.RemoveProcessL( iProcessId ) );
-
- // Decrement the server's session count by one (1)
- iStorageServer.DecSessionCount();
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::ServiceL
-// This function is called by the client/server framework
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::ServiceL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE void CATStorageServerSession::ServiceL()" );
-
- // If logging has been cancelled for this session, return immediately
- if( iLogOption == EATLoggingOff )
- {
- aMessage.Complete( KErrCancel );
- return;
- }
-
- switch ( aMessage.Function() )
- {
- case CATStorageServer::EProcessStarted:
- {
- // If logging is not ongoing, set the log option
- if( !iLoggingOngoing )
- {
- // Set the operation mode
- SetLogOption( aMessage );
- }
-
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogProcessStartXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogProcessStartedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EDllLoaded:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogDllLoadXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogDllLoadedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EDllUnloaded:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogDllUnloadXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogDllUnloadedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EMemoryAllocated:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogMemoryAllocXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogMemoryAllocatedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EMemoryFreed:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogMemoryFreedXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogMemoryFreedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EProcessEnded:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = LogProcessEndXtiL( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = LogProcessEndedL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EMemoryCheck:
- {
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- iError = CheckMemoryAddressXti( aMessage );
- }
- break;
-
- case EATLogToFile:
- {
- iError = CheckMemoryAddressL( aMessage );
- }
- break;
-
- default:
- {
- // Panic the client and set iError KErrCancel, because being
- // here implies that an illegal log option has been given.
- PanicClient( EAToolIllegalLogOption, aMessage );
- iError = KErrCancel;
- }
- break;
- }
- }
- break;
-
-
- case CATStorageServer::EGetProcesses:
- {
- iError = GetProcessesL( aMessage );
- }
- break;
-
-
- case CATStorageServer::EGetDlls:
- {
- iError = GetDllsL( aMessage );
- }
- break;
-
- case CATStorageServer::EGetLoggingMode:
- {
- iError = GetLoggingModeL( aMessage );
- }
- break;
-
- case CATStorageServer::ESubtestStart:
- {
- iError = StartSubtestL( aMessage );
- }
- break;
-
- case CATStorageServer::ESubtestStop:
- {
- iError = StopSubtestL( aMessage );
- }
- break;
-
- case CATStorageServer::ESubtestStart2:
- {
- iError = StartSubtest2L( aMessage );
- }
- break;
-
- case CATStorageServer::ESubtestStop2:
- {
- iError = StopSubtest2( aMessage );
- }
- break;
-
- case CATStorageServer::EGetCurrentAllocs:
- {
- iError = GetCurrentAllocsL( aMessage );
- }
- break;
-
- case CATStorageServer::EGetMaxAllocs:
- {
- iError = GetMaxAllocsL( aMessage );
- }
- break;
-
- case CATStorageServer::ECancelLogging:
- {
- iError = CancelLoggingL( aMessage );
- }
- break;
-
- case CATStorageServer::EGetUdeb:
- {
- iError = GetUdebL( aMessage );
- }
- break;
-
- case CATStorageServer::EGetLoggingFile:
- {
- iError = GetLoggingFileL( aMessage );
- }
- break;
-
- case CATStorageServer::EProcessUdeb:
- {
- SetUdeb( aMessage );
- }
- break;
-
- case CATStorageServer::EIsMemoryAdded:
- {
- iError = IsMemoryAdded( aMessage );
- LOGSTR2( "STSE > IsMemoryAdded err = %i", iError );
- }
- break;
-
- default:
- {
- // Panic both the client and server, because being here implies
- // that there is an internal error in the client/server.
- PanicClient( EAToolBadRequest, aMessage );
- StorageServerPanic( KCategoryServer, EAToolBadRequest );
- }
- break;
-
- }
-
- // Complete the message, if it has not been already cancelled.
- if ( iError != KErrCancel )
- {
- // Log the error code. Only KErrNoMemory errors are logged.
- if ( iLogOption == EATLogToFile && iError == KErrNoMemory )
- {
- HandleError( iError );
- }
- else if ( iLogOption == EATLogToXti && iError == KErrNoMemory )
- {
- HandleErrorXti( iError );
- }
-
- // Complete serving the message
- aMessage.Complete( iError );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogProcessStartedL()
-// Opens a logging file with the requested name and then writes information
-// on process start into the file.
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogProcessStartedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessStartedL()" );
-
- // Panic the client and return, if this method has already been called for this
- // session object (and a logging file has been opened)
- if ( iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- LOGMEM;
-
- // READ THE FIRST ARGUMENT (descriptor)
-
- // Length of the first argument (index 0)
- TInt length = aMessage.GetDesLength( 0 );
-
- LOGSTR2( "STSE length of the fileName: %i", length );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- // Construct a buffer for file name, and leave the pointer on Cleanup Stack
- HBufC* fileName = HBufC::NewLC( length );
- TPtr fileNamePtr( fileName->Des() );
-
- // Read the client side's descriptor at index 0
- iError = aMessage.Read( 0, fileNamePtr );
-
- if ( iError != KErrNone )
- {
- CleanupStack::PopAndDestroy( fileName );
- return iError;
- }
-
- // READ THE SECOND ARGUMENT (descriptor)
-
- // Length of the second argument (index 1)
- length = aMessage.GetDesLength( 1 );
-
- LOGSTR2( "STSE length of the processName: %i", length );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- CleanupStack::PopAndDestroy( fileName );
- return length;
- }
-
- HBufC8* processName = HBufC8::NewL( length );
- TPtr8 bufPtr( processName->Des() );
-
- // Read the client side's descriptor at index 1
- iError = aMessage.Read( 1, bufPtr );
-
- if ( iError != KErrNone )
- {
- delete processName;
- CleanupStack::PopAndDestroy( fileName );
- return iError;
- }
-
- // READ THE THIRD ARGUMENT (integer, a process ID)
- TInt processId = aMessage.Int2();
-
- // Open a file server session and a file. The file
- // will be opened with the name received from the client
- iError = OpenFsAndFile( *fileName, *processName );
- CleanupStack::PopAndDestroy( fileName );
- // Return without logging, if an error occured
- if ( iError != KErrNone )
- {
- // Delete the local objects
- delete processName;
- return iError;
- }
-
- // Get the home time for the configuration UI
- iTime.HomeTime();
-
- // Add the process into the server's array of processes
- iError = iStorageServer.AddProcessL( *processName,
- processId,
- this,
- iTime.Int64() );
-
- // Return without logging, if an error occured
- if ( iError )
- {
- // Remove, if something was added regardless of the error
- // However, we must not remove an existing process
- if ( iError != KErrAlreadyExists )
- {
- iStorageServer.RemoveProcessL( processId );
- }
- return iError;
- }
-
- // Make a buffer that will be logged into the opened logging file
- TBuf8<KProcessStartBufLength> loggingBuf;
- loggingBuf.Format( KProcessStart, processName, processId );
-
- delete processName;
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append udeb/urel information to the process start
- loggingBuf.Append( KSpace );
- loggingBuf.AppendNum( iIsUdeb, EHex );
-
- // Append trace version information
- loggingBuf.Append( KSpace );
- loggingBuf.AppendNum( KATTraceVersion, EHex );
-
- // Append a new line
- loggingBuf.Append( KNewLine );
-
- // Write the buffer into the file
- iError = iFile.Write( loggingBuf );
-
- // Return, if an error occured
- if ( iError )
- {
- iStorageServer.RemoveProcessL( processId );
- return iError;
- }
-
- LOGMEM;
-
- // Set the process ID value for this logging session
- iProcessId = processId;
- // Set logging session started
- iLoggingOngoing = ETrue;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogProcessStartXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogProcessStartXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessStartXtiL()" );
-
- // Panic the client and return, if this method has already been called for this
- // session object
- if ( iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- LOGMEM;
-
- // READ THE SECOND ARGUMENT (descriptor)
- // The first argument, file name, is ignored when logging thru XTI
-
- // Length of the second argument (index 1)
- TInt length = aMessage.GetDesLength( 1 );
-
- LOGSTR2( "STSE length of the processName: %i", length );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- HBufC8* processName = HBufC8::NewL( length );
- TPtr8 bufPtr( processName->Des() );
-
- // Read the client side's descriptor at index 1
- iError = aMessage.Read( 1, bufPtr );
-
- if ( iError != KErrNone )
- {
- // Delete local objects and return
- delete processName;
- return iError;
- }
-
- // READ THE THIRD ARGUMENT (integer, a process ID)
- TInt processId = aMessage.Int2();
-
- // Get the home time for the configuration UI
- iTime.HomeTime();
-
- // Add the process into the server's array of processes
- iError = iStorageServer.AddProcessL( *processName, processId, this,
- iTime.Int64() );
-
- // Return without logging, if an error occured
- if ( iError )
- {
- // Remove, if something was added regardless of the error
- // However, we must not remove an existing process
- if ( iError != KErrAlreadyExists )
- {
- iStorageServer.RemoveProcessL( processId );
- }
- return iError;
- }
-
- // Make a buffer that will be logged
- TBuf8<KProcessStartBufLength> loggingBuf;
-
- loggingBuf.Format( KProcessStart, processName, processId );
-
- delete processName;
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append udeb/urel information to the process start
- loggingBuf.Append( KSpace );
- loggingBuf.AppendNum( iIsUdeb, EHex );
-
- // Append version number
- loggingBuf.Append( KSpace );
- loggingBuf.AppendNum( KATTraceVersion, EHex );
-
- // Append a new line
- loggingBuf.Append( KNewLine );
-
- // Log to XTI
- TBuf<KProcessStartBufLength> xtiBuf;
- xtiBuf.Copy( loggingBuf );
- RDebug::Print( KXtiMessage, processId ,&xtiBuf );
-
- LOGMEM;
-
- // Set the process ID value for this logging session
- iProcessId = processId;
- // Set logging session started
- iLoggingOngoing = ETrue;
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogDllLoadedL()
-// Logs to the file opened by the function LogProcessStartedL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogDllLoadedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogDllLoadedL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the length of the first argument (index 0)
- TInt length = aMessage.GetDesLength( 0 );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- HBufC8* dllName = HBufC8::NewL( length );
- TPtr8 bufPtr( dllName->Des() );
-
- // Read the client side's descriptor (the argument 0)
- iError = aMessage.Read( 0, bufPtr );
-
- if ( iError != KErrNone )
- {
- delete dllName;
- return iError;
- }
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Add this dll into the server's array
- TUint32 startAddress( aMessage.Int1() );
- TUint32 endAddress( aMessage.Int2() );
- iError = iStorageServer.AddDllL( iProcessId,
- TATDllInfo( startAddress, endAddress, timeFrom1970, *dllName ) );
-
- // Return without logging, if an error occured
- if ( iError )
- {
- delete dllName;
- return iError;
- }
-
- // Make a buffer that will be logged into the opened logging file
- TBuf8<KDllLoadBufLength> loggingBuf;
- loggingBuf.Format( KDllLoad, dllName, timeFrom1970, startAddress, endAddress );
-
- delete dllName;
-
- // Write the buffer into a file and return the error code
- return iFile.Write( loggingBuf );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogDllLoadXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogDllLoadXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogDllLoadXtiL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the length of the first argument (index 0)
- TInt length = aMessage.GetDesLength( 0 );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- HBufC8* dllName = HBufC8::NewL( length );
- TPtr8 bufPtr( dllName->Des() );
-
- // Read the client side's descriptor (the argument 0)
- iError = aMessage.Read( 0, bufPtr );
-
- if ( iError != KErrNone )
- {
- delete dllName;
- return iError;
- }
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- TUint32 startAddress( aMessage.Int1() );
- TUint32 endAddress( aMessage.Int2() );
-
- // Add this dll into the server's array
- iError = iStorageServer.AddDllL( iProcessId,
- TATDllInfo( startAddress, endAddress, timeFrom1970, *dllName ) );
-
- // Return without logging, if an error occured
- if ( iError )
- {
- delete dllName;
- return iError;
- }
-
- // Make a buffer that will be logged
- TBuf8<KDllLoadBufLength> loggingBuf;
- loggingBuf.Format( KDllLoad, dllName, timeFrom1970, startAddress, endAddress );
-
- delete dllName;
-
- TBuf<KDllLoadBufLength> xtiBuf;
- xtiBuf.Copy( loggingBuf );
- RDebug::Print( KXtiMessage, iProcessId ,&xtiBuf );
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogDllUnloadedL()
-// Logs to the file opened by the function LogProcessStartedL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogDllUnloadedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogDllUnloadedL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the length of the first argument (index 0)
- TInt length = aMessage.GetDesLength( 0 );
-
- LOGSTR2( "STSE length %i", length );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- HBufC8* dllName = HBufC8::NewL( length );
- TPtr8 bufPtr( dllName->Des() );
-
- // Read the client side's descriptor (the argument 0)
- iError = aMessage.Read( 0, bufPtr );
-
- if ( iError != KErrNone )
- {
- delete dllName;
- return iError;
- }
-
- TUint32 startAddress = aMessage.Int1();
- TUint32 endAddress = aMessage.Int2();
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Make a buffer that will be logged into the opened logging file
- TBuf8<KDllUnloadBufLength> loggingBuf;
- loggingBuf.Format( KDllUnload, dllName, timeFrom1970, startAddress, endAddress );
-
- // Remove this dll from the server's array
- iError = iStorageServer.RemoveDllL( iProcessId, bufPtr );
-
- delete dllName;
-
- // Return without logging, if an error occured
- if ( iError )
- {
- return iError;
- }
-
- // Write the buffer into a file and return the error code
- return iFile.Write( loggingBuf );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogDllUnloadXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogDllUnloadXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogDllUnloadXtiL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the length of the first argument (index 0)
- TInt length = aMessage.GetDesLength( 0 );
-
- LOGSTR2( "STSE length %i", length );
-
- // Return if errors
- if ( length == KErrArgument || length == KErrBadDescriptor )
- {
- return length;
- }
-
- HBufC8* dllName = HBufC8::NewL( length );
- TPtr8 bufPtr( dllName->Des() );
-
- // Read the client side's descriptor (the argument 0)
- iError = aMessage.Read( 0, bufPtr );
-
- if ( iError != KErrNone )
- {
- delete dllName;
- return iError;
- }
-
- TUint32 startAddress = aMessage.Int1();
- TUint32 endAddress = aMessage.Int2();
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Make a buffer that will be logged
- TBuf8<KDllUnloadBufLength> loggingBuf;
- loggingBuf.Format( KDllUnload, dllName, timeFrom1970, startAddress, endAddress );
-
- // Remove this dll from the server's array
- iError = iStorageServer.RemoveDllL( iProcessId, bufPtr );
-
- delete dllName;
-
- // Return without logging, if an error occured
- if ( iError )
- {
- return iError;
- }
-
- TBuf<KDllLoadBufLength> xtiBuf;
- xtiBuf.Copy( loggingBuf );
- RDebug::Print( KXtiMessage, iProcessId ,&xtiBuf );
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogMemoryAllocatedL()
-// Constructs a CATMemoryEntry object and appends it into iLeakArray.
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogMemoryAllocatedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogMemoryAllocatedL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // A pointer to a buffer of call stack's memory addresses
- CBufFlat* stackBuf = NULL;
-
- iError = KErrNone;
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Read the first argument (index 0)
- TUint32 memAddress = aMessage.Int0();
- if ( memAddress == 0 )
- {
- return KErrNotSupported;
- }
-
- // Read the length of the descriptor argument (index 1) that should include
- // call stack memory addresses associated with this memory allocation
- TInt bufferLength = aMessage.GetDesLength( 1 );
-
- // Construct a buffer for aCallstack
- stackBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( stackBuf );
-
- // Buffer position
- TInt pos = 0;
-
- stackBuf->ExpandL( pos, bufferLength );
-
- TPtr8 bufPtr = stackBuf->Ptr( pos );
-
- // Read the descriptor argument into the buffer
- aMessage.ReadL( 1, bufPtr );
-
- // Read the third argument (index 2) that tells the size of this allocation
- TInt size = aMessage.Int2();
-
- // Construct a new CATMemoryEntry object.
- // The ownership of the current stackBuf object is given to the "entry" object.
- CATMemoryEntry* entry =
- new (ELeave) CATMemoryEntry( memAddress, stackBuf, timeFrom1970, size );
-
- // Pop stackBuf from CleanupStack and set it to NULL, because it is not used anymore.
- CleanupStack::Pop( stackBuf );
- stackBuf = NULL;
-
- // Make sure that the same memory area is not tryed to be allocated a second time
- TIdentityRelation<CATMemoryEntry> matcher( CATMemoryEntry::Match );
-
- TInt index = iLeakArray.Find( entry, matcher );
-
- if ( index == KErrNotFound )
- {
- TLinearOrder<CATMemoryEntry> order( CATMemoryEntry::Compare );
-
- // Insert the "entry" object into "iLeakArray". The ownership of
- // the "entry" object is given to the array.
- iError = iLeakArray.InsertInOrderAllowRepeats( entry, order );
-
- // If an insertion to the array was not successful, delete the created
- // entry manually and return.
- if ( iError )
- {
- delete entry;
- return iError;
- }
-
- // Make a TAllocInfo object, and give values for its members.
- TAllocInfo allocInfo( memAddress, size );
-
- // Insert the allocInfo object into iAllocInfoArray
- iError = iAllocInfoArray.InsertInUnsignedKeyOrder( allocInfo );
-
- // If an insertion to the array was not successful, delete the created entry
- // and remove its pointer from iLeakArray.
- if ( iError )
- {
- index = iLeakArray.Find( entry, matcher );
- // Delete the entry object and remove remove the pointer from the array
- delete entry;
- // The index should be in a legal range, because the earlier insertion of
- // the entry was successful
- iLeakArray.Remove( index );
- }
-
- // Otherwise update the iCurAllocSize, iMaxAllocs and iMaxAllocSize variables
-
- iCurAllocSize += size;
-
- // The count can never be negative => associate it to an unsigned int
- TUint allocCount = iAllocInfoArray.Count();
- if ( allocCount > iMaxAllocs )
- {
- iMaxAllocs = allocCount;
- }
-
- if ( iCurAllocSize > iMaxAllocSize )
- {
- iMaxAllocSize = iCurAllocSize;
- }
-
- return iError;
- }
-
- // This shouldn't happen, because the same memory area shouldn't be allocated
- // more than once (without deallocating it first)
- else
- {
- delete entry;
- return KErrAlreadyExists;
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogMemoryAllocXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogMemoryAllocXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogMemoryAllocXtiL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // Read the first argument (index 0)
- TUint32 memAddress = aMessage.Int0();
- if ( memAddress == 0 )
- {
- return KErrNotSupported;
- }
-
- // Read the third argument (index 2) that tells the size of this allocation
- TInt size = aMessage.Int2();
-
- // Append this allocation into the iAllocInfoArray array. This array is for
- // providing the configuration UI with information on allocations
-
- // Make a TAllocInfo object, and give values for its members.
- TAllocInfo allocInfo( memAddress, size );
-
- // Insert the allocInfo object into iAllocInfoArray
- iError = iAllocInfoArray.InsertInUnsignedKeyOrder( allocInfo );
-
- // Log debug message if duplicated allocation.
- if ( iError == KErrAlreadyExists )
- {
- LOGSTR2( "STSE TInt CATStorageServerSession::LogMemoryAllocXtiL() Error, duplicate allocation :%i", memAddress );
- }
-
- // A pointer to a buffer of call stack's memory addresses
- CBufFlat* stackBuf = NULL;
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Read the length of the descriptor argument (index 1) that should include
- // call stack memory addresses associated with this memory allocation
- TInt bufferLength = aMessage.GetDesLength( 1 );
-
- // Construct a buffer for aCallstack
- stackBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( stackBuf );
-
- // Buffer position
- TInt pos( 0 );
- stackBuf->ExpandL( pos, bufferLength );
-
- TPtr8 bufPtr = stackBuf->Ptr( pos );
-
- // Read the descriptor argument (index 1) into the buffer
- aMessage.ReadL( 1, bufPtr );
-
- // Variable for the number of memory addresses in the call stack
- TInt addrCount( 0 );
- TUint32 callStackAddr;
-
- // Read the first word of the buffer. This includes the number of
- // memory addresses stored in the current stackBuf
- stackBuf->Read( pos, &addrCount, KWordSize );
-
- // Move the position one word onwards.
- pos += KWordSize;
-
- // Create a 16-bit buffer, and a pointer descriptor for it
- // ALLOCH <Memory address> <Time stamp> <Allocation size> <Call stack address count>
- // <Call stack address> <Call stack address> ...
- HBufC* xtiBuf = HBufC::NewL( KMemAllocBufLength );
- TPtr xtiPtr( xtiBuf->Des() );
-
- // Pop stackBuf from CleanupStack, since no leavable operations will be done
- // anymore
- CleanupStack::Pop( stackBuf );
-
- // Append the tag implying a memory allocation line in the data file
- xtiPtr.Append( KMemoryAllocHeader );
-
- // Append the start address of this allocation in the 32-bit (max 8 characters)
- // hexadecimal text format.
- xtiPtr.AppendNum( memAddress, EHex );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( timeFrom1970, EHex );
-
- // Append the size of the allocation in the 32-bit (max 8 characters) hexadecimal
- // text format.
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( size, EHex );
-
- // Append call stack address count
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( addrCount, EHex );
-
- // Calculate last item length
- TInt lastItemLength( KXtiMessage().Length() + KHexa32Length +
- KSpaceLength + KNewlineLength );
-
- TUint packetNumber( 1 );
-
- // Go through all call stack's memory addresses associated with
- // this memory allocation
- for ( TInt j = 0; j < addrCount; j++ )
- {
- // ALLOCF <Memory address> <Time stamp> <Packet number>
- // <Call stack address> <Call stack address> ...
- if ( xtiPtr.Length() <= 0 )
- {
- // Create alloc fragment message header
- xtiPtr.Append( KMemoryAllocFragment );
- xtiPtr.AppendNum( memAddress, EHex );
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( timeFrom1970, EHex );
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( packetNumber, EHex );
- // Increase packet number
- packetNumber++;
- }
-
- // Read the next call stack's memory address stored in the buffer.
- stackBuf->Read( pos, &callStackAddr, KWordSize );
-
- // Append the read memory address as a hexadecimal number
- xtiPtr.AppendFormat( KHexaNumberXti, callStackAddr );
-
- // Move the pos variable one word onwards.
- pos += KWordSize;
-
- // Check if buffer max length exceed
- if ( lastItemLength + xtiPtr.Length() >= KMemAllocBufLength )
- {
- xtiPtr.Append( KNewLineXti );
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId, xtiBuf );
- // Empty XTI buffer
- xtiPtr.Delete( 0, xtiPtr.MaxLength() );
- }
- }
-
- // Send the last message if exists
- if ( xtiPtr.Length() > 0 )
- {
- xtiPtr.Append( KNewLineXti );
-
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId, xtiBuf );
- }
-
- delete xtiBuf;
- delete stackBuf;
-
- // Update the iCurAllocSize, iMaxAllocs and iMaxAllocSize variables
- iCurAllocSize += size;
-
- // The count can never be negative => associate it to an unsigned int
- TUint allocCount = iAllocInfoArray.Count();
- if ( allocCount > iMaxAllocs )
- {
- iMaxAllocs = allocCount;
- }
-
- if ( iCurAllocSize > iMaxAllocSize )
- {
- iMaxAllocSize = iCurAllocSize;
- }
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogMemoryFreedL()
-// Removes a TATMemoryEntry object with the specified memory address from
-// iLeakArray, if found.
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogMemoryFreedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogMemoryFreedL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // Get the memory address
- TUint32 memAddress = aMessage.Int0();
-
- // Remove this memory allocation from the leak array
- TIdentityRelation<CATMemoryEntry> matcher( CATMemoryEntry::Match );
- CATMemoryEntry* entry = new (ELeave) CATMemoryEntry( memAddress, NULL, 0, 0 );
- TInt index = iLeakArray.Find( entry, matcher );
- delete entry;
-
- // Return, if the requested memory address was not found
- // (had not been allocated)
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Delete the CATMemoryEntry object at "index" and remove from the array
- delete iLeakArray[index];
- iLeakArray.Remove( index );
-
- // Remove this memory allocation also from the allocation info array
- // Make a TAllocInfo object for a "find" operation
- TAllocInfo allocInfo( memAddress, 0 );
- index = iAllocInfoArray.FindInUnsignedKeyOrder( allocInfo );
-
- // The index should not be KErrNotFound, because an object with this memory address
- // was found in the iLeakArray array. If the index is out of range, something is
- // badly wrong, so it would be alright to panic in that case.
- if ( index == KErrNotFound )
- {
- PanicClient( EAToolInternalError, aMessage );
- return KErrCancel;
- }
-
- // Decrease the current alloc size and remove the requested allocation
- // from iAllocInfoArray
- iCurAllocSize -= iAllocInfoArray[index].iAllocSize;
- iAllocInfoArray.Remove( index );
-
- // If we are here, everything has gone alright
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::IsMemoryAdded()
-// Check a memory allocation (memory address) from an internal array.
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::IsMemoryAdded( const RMessage2& aMessage,
- const TBool aRemoveAlloc )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::IsMemoryAdded()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // Read the first argument (index 0)
- TUint32 memAddress = aMessage.Int0();
-
- // Try to find this memory allocation from the allocation info array
-
- // Make a TAllocInfo object for a "find" operation
- TAllocInfo allocInfo( memAddress, 0 );
- TInt index( iAllocInfoArray.FindInUnsignedKeyOrder( allocInfo ) );
-
- if ( index == KErrNotFound )
- {
- return index;
- }
- else if ( aRemoveAlloc )
- {
- // Otherwise decrease the current alloc size and remove the requested allocation
- // from iAllocInfoArray
- iCurAllocSize -= iAllocInfoArray[index].iAllocSize;
- iAllocInfoArray.Remove( index );
- }
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogMemoryFreedXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogMemoryFreedXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogMemoryFreedXtiL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // A pointer to a buffer of call stack's memory addresses
- CBufFlat* stackBuf = NULL;
- iError = KErrNone;
-
- // Read the first argument (index 0)
- TUint32 memAddress = aMessage.Int0();
-
- // Remove address from allocation table and its size from alloc size,
- // if found from table.
- TAllocInfo allocInfo( memAddress, 0 ); // Dummy info for search.
- TInt index( iAllocInfoArray.FindInUnsignedKeyOrder( allocInfo ) );
- if ( index != KErrNotFound )
- {
- // Decrease the current alloc size and remove the requested allocation
- // from table.
- iCurAllocSize -= iAllocInfoArray[index].iAllocSize;
- iAllocInfoArray.Remove( index );
- }
- else
- {
- LOGSTR2( "STSE TInt CATStorageServerSession::LogMemoryFreedXti() Error, cannot find alloc for free: %i", memAddress );
- }
-
- // Read the length of the descriptor argument (index 1) that should include
- // call stack memory addresses associated with this memory allocation
- TInt bufferLength = aMessage.GetDesLength( 1 );
-
- // Construct a buffer for aCallstack
- stackBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( stackBuf );
-
- // Buffer position
- TInt pos = 0;
-
- stackBuf->ExpandL( pos, bufferLength );
-
- TPtr8 bufPtr = stackBuf->Ptr( pos );
-
- // Read the descriptor argument (index 1) into the buffer
- aMessage.ReadL( 1, bufPtr );
-
- // Variable for the number of memory addresses in the call stack
- TInt addrCount( 0 );
- TUint32 callStackAddr( 0 );
-
- // Read the first word of the buffer. This includes the number of
- // memory addresses stored in the current stackBuf
- stackBuf->Read( pos, &addrCount, KWordSize );
-
- // Move the position one word onwards.
- pos += KWordSize;
-
- // Create a 16-bit buffer, and a pointer descriptor for it
- HBufC* xtiBuf = HBufC::NewL( KMemFreedBufLength );
- TPtr xtiPtr( xtiBuf->Des() );
-
- // Pop stackBuf from CleanupStack, since no leavable operations will be done
- // anymore
- CleanupStack::Pop( stackBuf );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Memory deallocation header message.
- // FREEH <Memory address> <Time stamp> <Call stack address count> <Call stack address>
- // <Call stack address> ...
-
- // Append the tag implying a memory free line in the data file
- xtiPtr.Append( KMemoryFreedHeader );
-
- // Append the start address of this allocation in the 32-bit (max 8 characters)
- // hexadecimal text format.
- xtiPtr.AppendNum( memAddress, EHex );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( timeFrom1970, EHex );
-
- // Append call stack address count
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( addrCount, EHex );
-
- // Packet number
- TUint packetNumber( 1 );
-
- // Calculate last item length
- TInt lastItemLength( KXtiMessage().Length() + KHexa32Length +
- KSpaceLength + KNewlineLength );
-
- // Go through all call stack's memory addresses associated with
- // this memory allocation
- for ( TInt j = 0; j < addrCount; j++ )
- {
- if ( xtiPtr.Length() <= 0 )
- {
- // Memory deallocation fragment message.
- // FREEF <Memory address> <Time stamp> <Packet number> <Call stack address count>
- // <Call stack address>...
- // Create free fragment message header
- xtiPtr.Append( KMemoryFreedFragment );
- xtiPtr.AppendNum( memAddress, EHex );
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( timeFrom1970, EHex );
- xtiPtr.Append( KSpaceXti );
- xtiPtr.AppendNum( packetNumber, EHex );
- // Increase packet number
- packetNumber++;
- }
-
- // Read the next call stack's memory address stored in the buffer.
- stackBuf->Read( pos, &callStackAddr, KWordSize );
-
- // Append the read memory address as a hexadecimal number
- xtiPtr.AppendFormat( KHexaNumberXti, callStackAddr );
-
- // Move the pos variable one word onwards.
- pos += KWordSize;
-
- // Check if buffer max length exceed
- if ( lastItemLength + xtiPtr.Length() >= KMemFreedBufLength )
- {
- xtiPtr.Append( KNewLineXti );
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId, xtiBuf );
- // Empty XTI buffer
- xtiPtr.Delete( 0, xtiPtr.MaxLength() );
- }
- }
-
- // Send the last message if exists
- if ( xtiPtr.Length() > 0 )
- {
- xtiPtr.Append( KNewLineXti );
-
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId, xtiBuf );
- }
-
- delete xtiBuf;
- delete stackBuf;
- // If we are here, everything has gone alright
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogProcessEndedL()
-// Prints memory leaks and information on process end into a file opened by the
-// function LogProcessStartedL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogProcessEndedL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessEndedL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the sent process ID
- TUint processId = aMessage.Int0();
-
- // The process ID got from the client should equal iProcessId.
- // If it does not, return KErrNotSupported
- if ( processId != iProcessId )
- {
- return KErrNotSupported;
- }
-
- //////////////////////////////////////////////
- // Log memory leaks
- //////////////////////////////////////////////
-
- // Print the information on the memory allocations that were never freed
- iError = PrintLeaksL( aMessage );
-
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- //////////////////////////////////////////////
- // Log handle leaks
- //////////////////////////////////////////////
-
- TUint handleLeakCount = aMessage.Int1();
-
- if( handleLeakCount == 0 )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessEndedL() No handle leaks to report" );
- }
- else
- {
- // Make a buffer that will be logged
- TBuf8<KHandleLeakBufLength> loggingBuf;
-
- // Set handle leak module name to unknown since it can not be defined.
- // Write the handle leak count from aMessage.
- loggingBuf.Format( KHandleLeak, &KUnknownModule, handleLeakCount );
-
- // Write the constructed string into the data file and return if error
- iError = iFile.Write( loggingBuf );
-
- if ( iError != KErrNone )
- {
- return iError;
- }
- }
-
- //////////////////////////////////////////////
- // Log process end
- //////////////////////////////////////////////
-
- // Make a buffer that will be logged into the opened logging file
- TBufC8<KProcessEndBufLength> processEndBuf;
-
- TPtr8 bufPtr = processEndBuf.Des();
-
- bufPtr.AppendFormat( KProcessEnd, iProcessId );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- bufPtr.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- bufPtr.Append( KNewLine );
-
- // Write the buffer into a file and return the error code
- iError = iFile.Write( processEndBuf );
-
- // Close the file and the handle to the file server
- CloseFsAndFile();
-
- // Remove the process from the server's array of processes
- iError = iStorageServer.RemoveProcessL( processId );
-
- // Reset iProcesssId and set the logging flag false
- iProcessId = KNullProcessId;
- iLoggingOngoing = EFalse;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogProcessEndXtiL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogProcessEndXtiL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessEndXtiL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Read the sent process ID
- TUint processId = aMessage.Int0();
-
- // The process ID got from the client should equal iProcessId.
- // If it does not, return KErrNotSupported
- if ( processId != iProcessId )
- {
- return KErrNotSupported;
- }
-
- //////////////////////////////////////////////
- // Log handle leaks
- //////////////////////////////////////////////
-
- TUint handleLeakCount = aMessage.Int1();
-
- if( handleLeakCount == 0 )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessEndXtiL() No handle leaks to report" );
- }
- else
- {
- // Make a buffer that will be logged
- TBuf8<KHandleLeakBufLength> loggingBuf;
-
- // Make a 16-bit buffer that can be logged using RDebug
- TBuf<KHandleLeakBufLength> xtiBuf;
-
- // Set handle leak module name to unknown since it can not be defined.
- // Write the handle leak count from aMessage.
- loggingBuf.Format( KHandleLeak, &KUnknownModule, handleLeakCount );
-
- xtiBuf.Copy( loggingBuf );
-
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId , &xtiBuf );
- }
-
- //////////////////////////////////////////////
- // Log process end
- //////////////////////////////////////////////
-
- // Make a buffer that will be logged
- TBuf<KProcessEndBufLength> processEndBuf;
- processEndBuf.AppendFormat( KProcessEndXti, iProcessId );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- processEndBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- processEndBuf.Append( KNewLineXti );
-
- // Log through XTI channel
- RDebug::Print( KXtiMessage, iProcessId, &processEndBuf );
-
- // Remove the process from the server's array of processes
- iError = iStorageServer.RemoveProcessL( iProcessId );
-
- // Reset iProcesssId and set the logging flag false
- iProcessId = KNullProcessId;
- iLoggingOngoing = EFalse;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CheckMemoryAddressL()
-// Checks if given memory address can be found
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::CheckMemoryAddressL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::CheckMemoryAddressL()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- iError = KErrNone;
-
- // Check if memory address can be found in iLeakArray
- TUint32 memAddress = aMessage.Int0();
- TIdentityRelation<CATMemoryEntry> matcher( CATMemoryEntry::Match );
- CATMemoryEntry* entry = new (ELeave) CATMemoryEntry( memAddress, NULL, 0, 0 );
-
- // Get the index or an error code
- iError = iLeakArray.Find( entry, matcher );
- delete entry;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CheckMemoryAddressXti()
-// Checks if some memory address can be found
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::CheckMemoryAddressXti( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::CheckMemoryAddressXti()" );
-
- // Panic the client and return, if a logging session is not ongoing
- // ( can be started by calling the client's LogProcessStarted() )
- if ( !iLoggingOngoing )
- {
- PanicClient( EAToolNotAllowed, aMessage );
- return KErrCancel;
- }
-
- // Always return KErrNone in this mode
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetProcessesL()
-// Checks if some memory address can be found
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetProcessesL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetProcessesL()" );
-
- iError = KErrNone;
-
- TInt processInfoSize = sizeof( TATProcessInfo );
-
- CBufFlat* processInfoBuf;
-
- // Buffer position
- TInt pos( 0 );
-
- // Calculate the length of the buffer to be constructed for processes
- // One word will be reserved for the length of the array.
- TInt bufferLength = KWordSize + KATMaxProcesses * processInfoSize;
-
- // Construct processInfoBuf and expand it before the beginning (index 0)
- processInfoBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( processInfoBuf );
- processInfoBuf->ExpandL( pos, bufferLength );
-
- RArray<TATProcessInfo> processArray = iStorageServer.ProcessInfoArray();
-
- // Variable for the number of TATProcessInfo objects in processArray
- TInt count = processArray.Count();
-
- // The count cannot be greater than KATMaxProcesses, because the client
- // has reserved a buffer of this size to be filled by the server
- if ( count > KATMaxProcesses )
- {
- count = KATMaxProcesses;
- }
-
- // Write the count (4 bytes) into the beginning of processInfoBuf
- processInfoBuf->Write( pos, &count, KWordSize );
-
- // Move the position one word onwards.
- pos += KWordSize;
-
- // Write all the process info objects into the buffer
- for ( TInt i = 0; i < count; i++ )
- {
- TATProcessInfo& processInfo = processArray[i];
-
- // Write the current process info into the buffer
- processInfoBuf->Write( pos, &processInfo, processInfoSize );
-
- // Move the pos variable onwards.
- pos += processInfoSize;
- }
-
- // Make a pointer descriptor pointing to the start of processInfoBuf
- TPtr8 bufPtr( processInfoBuf->Ptr(0) );
-
- // Write the buffer into aMessage at index 0 for the client
- aMessage.WriteL( 0, bufPtr );
-
- CleanupStack::PopAndDestroy( processInfoBuf );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetDllsL()
-// Checks if some memory address can be found
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetDllsL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetDllsL()" );
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Size of a DLL descriptor
- TInt sizeOfDllDesc = sizeof( TBuf8<KMaxLibraryName> );
-
- // Buffer position
- TInt pos( 0 );
-
- // Calculate the length of the buffer to be constructed for DLL names.
- // One word will be reserved for the length of the array.
- TInt bufferLength = KWordSize + KATMaxDlls * sizeOfDllDesc;
-
- CBufFlat* dllBuf;
- // Construct dllBuf and expand it before the beginning (index 0)
- dllBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( dllBuf );
- dllBuf->ExpandL( pos, bufferLength );
-
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- CleanupStack::PopAndDestroy( dllBuf );
- return index;
- }
-
- // Get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Fetch a reference to the desired DLL array
- RArray<TATDllInfo>& dllArray = dynProcessInfo->iDlls;
-
- // Take the count of names in the array
- TInt count = dllArray.Count();
-
- // The count cannot be greater than KATMaxDlls, because the client
- // has reserved a buffer of this size to be filled by the server
- if ( count > KATMaxDlls )
- {
- count = KATMaxDlls;
- }
-
- // Write the count (4 bytes) into the beginning of dllBuf
- dllBuf->Write( pos, &count, KWordSize );
-
- // Move the position one word onwards.
- pos += KWordSize;
-
- // Go through all DLL names objects sent to the server
- for ( TInt i = 0; i < count; i++ )
- {
- TBuf8<KMaxLibraryName>& dllName = dllArray[i].iName;
-
- // Write the current DLL name into the buffer
- dllBuf->Write( pos, &dllName, sizeOfDllDesc );
-
- // Move the pos variable onwards.
- pos += sizeOfDllDesc;
- }
-
- // Make a pointer descriptor pointing to the start of dllBuf
- TPtr8 bufPtr( dllBuf->Ptr(0) );
-
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, bufPtr );
-
- CleanupStack::PopAndDestroy( dllBuf );
-
- // The dynProcessInfo object will not be deleted, because it is still owned by the
- // server object's dynamic process info array.
- dynProcessInfo = NULL;
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetLoggingModeL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetLoggingModeL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetLoggingModeL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Buffer position
- TInt pos( 0 );
-
- // The length of the buffer to be constructed for logging mode
- TInt bufferLength = KWordSize;
-
- // Get the dynamic process info array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
- CBufFlat* loggingModeBuf;
- // Construct allocInfoBuf and expand it before the beginning (index 0)
- loggingModeBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( loggingModeBuf );
- loggingModeBuf->ExpandL( 0, bufferLength );
-
- // Write the current logging mode of the requested process into the buffer.
- loggingModeBuf->Write( pos, &sessionObject->iLogOption, KWordSize );
-
- // Make a pointer descriptor that points to the data of allocInfoBuf
- TPtr8 bufPtr( loggingModeBuf->Ptr(0) );
-
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, bufPtr );
-
- CleanupStack::PopAndDestroy( loggingModeBuf );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::StartSubtestL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::StartSubtestL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::StartSubtestL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Read the sub test ID at index 1
- TBuf8<KATMaxSubtestIdLength> subTestName;
- iError = aMessage.Read( 1, subTestName );
-
- // Return if reading was not successful
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- // Create another (non-8-bit) descriptor for logging to XTI
- // and copy the contents
- TBuf<KATMaxSubtestIdLength> subTestNameXTI;
- subTestNameXTI.Copy( subTestName );
-
- // Read the handle count at index 2
- TInt handleCount = aMessage.Int2();
-
- // FIND THE REQUESTED PROCESS
-
- // Get the dynamic process array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- const CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Make a buffer for logging thru XTI
- TBuf<KTestStartBufLength> loggingBuf;
-
- // Copy the line tag into the buffer
- loggingBuf.Copy( KSubtestStart );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append the sub test ID
- loggingBuf.Append( subTestNameXTI );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append current handle leak count
- loggingBuf.AppendNum( handleCount );
-
- // Append a new line
- loggingBuf.Append( KNewLineXti );
-
- // Log the string through XTI
- iError = sessionObject->LogThroughXti( loggingBuf );
-
- // *******************
- // Send loaded DLL's
- // *******************
-
- // Fetch a reference to the desired DLL array
- RArray<TATDllInfo>& dllArray = dynProcessInfo->iDlls;
-
- // Take the count of dll info items
- TInt count( dllArray.Count() );
- LOGSTR2( "STSE > dllArray.Count( %i )", count );
-
- // Create buffers
- TBuf<KDllLoadBufLength> xtiBuf;
- TBuf8<KDllLoadBufLength> dllBuf;
-
- for ( TInt x = 0; x < count; x++ )
- {
- dllBuf.Format( KDllLoad, &dllArray[x].iName, dllArray[x].iLoadTime,
- dllArray[x].iStartAddress, dllArray[x].iEndAddress );
- xtiBuf.Copy( dllBuf );
-
- // Log the string through XTI
- iError = sessionObject->LogThroughXti( xtiBuf );
- if ( iError != KErrNone )
- {
- LOGSTR2( "STSE > LogThroughXti() err( %i )", iError );
- }
- }
- sessionObject = NULL;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::StopSubtestL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::StopSubtestL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::StopSubtestL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Read the sub test ID at index 1
- TBuf8<KATMaxSubtestIdLength> subTestName;
- iError = aMessage.Read( 1, subTestName );
-
- // Return if reading was not successful
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- // Create another (non-8-bit) descriptor for logging to XTI,
- // and copy the contents
- TBuf<KATMaxSubtestIdLength> subTestNameXTI;
- subTestNameXTI.Copy( subTestName );
-
- // Read the handle count at index 2
- TInt handleCount = aMessage.Int2();
-
- // FIND THE REQUESTED PROCESS
-
- // Get the dynamic process array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- const CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Make a buffer for logging thru XTI
- TBuf<KTestEndBufLength> loggingBuf;
-
- // Copy the line tag into the buffer
- loggingBuf.Copy( KSubtestEnd );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append the sub test ID
- loggingBuf.Append( subTestNameXTI );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append current handle leak count
- loggingBuf.AppendNum( handleCount );
-
- // Append a new line
- loggingBuf.Append( KNewLineXti );
-
- // Log the string through XTI
- iError = sessionObject->LogThroughXti( loggingBuf );
-
- sessionObject = NULL;
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::StartSubtest2L()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::StartSubtest2L( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::StartSubtest2L()" );
-
- iError = KErrNone;
-
- // Read the sub test ID at index 0
- TBuf8<KATMaxSubtestIdLength> subTestName;
- iError = aMessage.Read( 0, subTestName );
-
- // Return if reading was not successful
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- // Create another (non-8-bit) descriptor for logging to XTI
- // and copy the contents
- TBuf<KATMaxSubtestIdLength> subTestNameXTI;
- subTestNameXTI.Copy( subTestName );
-
- // Make a buffer for logging thru XTI
- TBuf<KTestStartBufLength> loggingBuf;
-
- // Copy the line tag into the buffer
- loggingBuf.Copy( KSubtestStart );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append the sub test ID
- loggingBuf.Append( subTestNameXTI );
-
- // Append a new line
- loggingBuf.Append( KNewLineXti );
-
- // Log the string through XTI
- iError = LogThroughXti( loggingBuf );
-
- // *******************
- // Send loaded DLL's
- // *******************
-
- // Get the dynamic process array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( iProcessId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Fetch a reference to the desired DLL array
- RArray<TATDllInfo>& dllArray = dynProcessInfo->iDlls;
-
- // Take the count of dll info items
- TInt count( dllArray.Count() );
- LOGSTR2( "STSE > dllArray.Count( %i )", count );
-
- // Create buffers
- TBuf<KDllLoadBufLength> xtiBuf;
- TBuf8<KDllLoadBufLength> dllBuf;
-
- for ( TInt x = 0; x < count; x++ )
- {
- dllBuf.Format( KDllLoad, &dllArray[x].iName, dllArray[x].iLoadTime,
- dllArray[x].iStartAddress, dllArray[x].iEndAddress );
- xtiBuf.Copy( dllBuf );
-
- // Log the string through XTI
- iError = LogThroughXti( xtiBuf );
- if ( iError != KErrNone )
- {
- LOGSTR2( "STSE > LogThroughXti() err( %i )", iError );
- }
- }
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::StopSubtest2()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::StopSubtest2( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::StopSubtest2()" );
-
- iError = KErrNone;
-
- // Read the sub test ID at index 0
- TBuf8<KATMaxSubtestIdLength> subTestName;
- iError = aMessage.Read( 0, subTestName );
-
- // Return if reading was not successful
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- // Create another (non-8-bit) descriptor for logging to XTI,
- // and copy the contents
- TBuf<KATMaxSubtestIdLength> subTestNameXTI;
- subTestNameXTI.Copy( subTestName );
-
- // Make a buffer for logging thru XTI
- TBuf<KTestEndBufLength> loggingBuf;
-
- // Copy the line tag into the buffer
- loggingBuf.Copy( KSubtestEnd );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a space
- loggingBuf.Append( KSpaceXti );
-
- // Append the sub test ID
- loggingBuf.Append( subTestNameXTI );
-
- // Append a new line
- loggingBuf.Append( KNewLineXti );
-
- // Log the string through XTI
- iError = LogThroughXti( loggingBuf );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetCurrentAllocsL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetCurrentAllocsL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetCurrentAllocsL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
- TUint32 allocNumber( 0 );
- TUint32 allocSize( 0 );
-
- // Buffer position
- TInt pos( 0 );
-
- // The length of the buffer to be constructed for allocation number and size
- TInt bufferLength = KWordSize + KWordSize;
-
- // Get the dynamic process info array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Get the alloc info array of that session object
- RArray<TAllocInfo> allocInfo = sessionObject->AllocInfoArray();
-
- // Get the values for current allocations number and size
- allocNumber = allocInfo.Count();
-
- // Calculate the total size of the current allocations
- for ( TUint32 i = 0; i < allocNumber; i++ )
- {
- allocSize += allocInfo[i].iAllocSize;
- }
-
- LOGSTR2( "STSE allocSize: %u", allocSize );
- LOGSTR2( "STSE iCurAllocSize: %u", iCurAllocSize );
-
- CBufFlat* allocInfoBuf;
- // Construct allocInfoBuf and expand it before the beginning (index 0)
- allocInfoBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( allocInfoBuf );
- allocInfoBuf->ExpandL( 0, bufferLength );
-
- // Write the current number of allocations of the requested process into the buffer.
- allocInfoBuf->Write( pos, &allocNumber, KWordSize );
-
- // Move the position one word onwards
- pos += KWordSize;
-
- // Write the current total size of the allocations of the requested process into the
- // buffer.
- allocInfoBuf->Write( pos, &allocSize, KWordSize );
-
- // Make a pointer descriptor that points to the data of allocInfoBuf
- TPtr8 bufPtr( allocInfoBuf->Ptr(0) );
-
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, bufPtr );
-
- CleanupStack::PopAndDestroy( allocInfoBuf );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetMaxAllocsL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetMaxAllocsL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetMaxAllocsL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
- TUint32 allocNumber( 0 );
- TUint32 allocSize( 0 );
-
- // Buffer position
- TInt pos( 0 );
-
- // The length of the buffer to be constructed for allocation number and size
- TInt bufferLength = KWordSize + KWordSize;
-
- // Get the dynamic process info array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Get values for the maximum allocations number and size
- allocNumber = sessionObject->iMaxAllocs;
- allocSize = sessionObject->iMaxAllocSize;
-
- CBufFlat* allocInfoBuf;
- // Construct allocInfoBuf and expand it before the beginning (index 0)
- allocInfoBuf = CBufFlat::NewL( bufferLength );
- CleanupStack::PushL( allocInfoBuf );
- allocInfoBuf->ExpandL( 0, bufferLength );
-
- // Write the maximum number of allocations of the requested process into the buffer.
- allocInfoBuf->Write( pos, &allocNumber, KWordSize );
-
- // Move the position one word onwards
- pos += KWordSize;
-
- // Write the maximum total size of the allocations of the requested process into the
- // buffer.
- allocInfoBuf->Write( pos, &allocSize, KWordSize );
-
- // Make a pointer descriptor that points to the data of allocInfoBuf
- TPtr8 bufPtr( allocInfoBuf->Ptr(0) );
-
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, bufPtr );
-
- CleanupStack::PopAndDestroy( allocInfoBuf );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CancelLoggingL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::CancelLoggingL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::CancelLoggingL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // FIND THE REQUESTED PROCESS
-
- // Get the dynamic process array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the session object of the requested process
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Make a buffer for logging "logging cancelled"
- TBuf8<KCancelBufLength> loggingBuf;
-
- // Copy the "logging cancelled" tag into the buffer with the current time
- loggingBuf.AppendFormat( KLoggingCancelled, timeFrom1970 );
-
- // Log the buffer eather to a file or to XTI channel depending on the current
- // logging mode
-
- if ( sessionObject->iLoggingOngoing &&
- sessionObject->iLogOption == EATLogToFile )
- {
- // Write the buffer into the file
- sessionObject->iFile.Write( loggingBuf );
- }
-
- else if ( sessionObject->iLoggingOngoing &&
- sessionObject->iLogOption == EATLogToXti )
- {
- // Make a buffer for logging to XTI
- TBuf<KCancelBufLength> xtiBuf;
- xtiBuf.Copy( loggingBuf );
-
- // Write the buffer into the XTI channel
- RDebug::Print( KXtiMessage, processId ,&xtiBuf );
- }
-
- // Switch off logging of the requested process
- sessionObject->iLogOption = EATLoggingOff;
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::HandleError
-// Internally used for handling error situations.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::HandleError( TInt aError )
- {
- LOGSTR1( "STSE void CATStorageServerSession::HandleError()" );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Make a buffer that will be logged into the opened logging file
- TBufC8<KErrOccuredBufLength> loggingBuf;
-
- TPtr8 bufPtr( loggingBuf.Des() );
-
- // Write the error code to the buffer
- bufPtr.Format( KErrorOccured, aError );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- bufPtr.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- bufPtr.Append( KNewLine );
-
- // Write the buffer into a file (if possible in the current condition)
- iFile.Write( loggingBuf );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::HandleErrorXti()
-// Internally used for handling error situations.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::HandleErrorXti( TInt aError )
- {
- LOGSTR1( "STSE void CATStorageServerSession::HandleErrorXti()" );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- // Make a buffer that will be logged
- TBuf<KErrOccuredBufLength> xtiBuf;
-
- // Write the error code to the buffer
- xtiBuf.Format( KErrorOccuredXti, aError );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- xtiBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- xtiBuf.Append( KNewLineXti );
-
- RDebug::Print( KXtiMessage, iProcessId , &xtiBuf );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::OpenFsAndFile
-// Internally used for opening a handle to the file server and a file
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::OpenFsAndFile( const TDesC& aFileName,
- const TDesC8& aProcessName )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::OpenFsAndFile()" );
-
- // Connect file server, return if error occured
- iError = iFileServer.Connect();
- if ( iError )
- {
- iFileServer.Close();
- return iError;
- }
-
- // Open a file
- TBuf<KMaxFileName> fileNameBuf;
- iError = TATDriveInfo::CreatePath( fileNameBuf, aFileName, iFileServer );
-
- // Return, if an error occured, and it
- // is not KErrAlreadyExists
- if ( iError && iError != KErrAlreadyExists )
- {
- iFileServer.Close();
- return iError;
- }
-
- // Save the file name for this session
- CnvUtfConverter::ConvertFromUnicodeToUtf8( iLogFile, fileNameBuf );
-
- // Try to open file
- CheckIfFileAlreadyExist( fileNameBuf );
-
- // If a data file with the requested name already existed, and was opened
- // successfully, check the version of the file. If the line telling the version of
- // the file is not the expected, replace the file
- // If cannot open the file(error is KErrInUse), generate new filename and
- // then try to create new file.
- if ( iError == KErrNone )
- {
- CheckFileVersion( fileNameBuf );
- }
- else if ( iError == KErrInUse )
- {
- GenerateNewFileName( fileNameBuf, aProcessName );
-
- // Save the file name for this session
- CnvUtfConverter::ConvertFromUnicodeToUtf8( iLogFile, fileNameBuf );
- }
- LOGSTR2( "STSE > iError(%i)", iError );
-
- // If the file does not exist, create it. Write also the version number of
- // the file at the beginning of the new file
- if ( iError == KErrNotFound )
- {
- iError = iFile.Create( iFileServer, fileNameBuf, EFileWrite );
-
- if ( !iError )
- {
- iError = iFile.Write( KDataFileVersion );
- }
- }
-
- if ( iError )
- {
- iFile.Close();
- iFileServer.Close();
- return iError;
- }
-
- // Seek the end of the file and set the current file position there
- TInt offset = 0;
- iError = iFile.Seek( ESeekEnd, offset );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GenerateNewFileName
-// Called internally when need generate new file name.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::GenerateNewFileName( TDes& aFileName,
- const TDesC8& aProcessName )
- {
- LOGSTR1( "STSE void CATStorageServerSession::GenerateNewFileName()" );
-
- // Extension
- TBuf<KExtensionLength> extension;
-
- // Parse file extension
- ParseExtension( aFileName, extension );
-
- // Try to find UID3 from current process name
- TInt uidErr( KErrBadName );
- TBuf<KMaxFileName> unicodeFile;
-
- // Converts text encoded using the Unicode transformation format UTF-8
- // into the Unicode UCS-2 character set.
- CnvUtfConverter::ConvertToUnicodeFromUtf8( unicodeFile, aProcessName );
- LOGSTR2( "STSE > unicodeFile(%S)", &unicodeFile );
-
- // Find square brackets
- TInt sPos( unicodeFile.Find( KOpenSquareBracket ) );
- TInt ePos( unicodeFile.Find( KCloseSquareBracket ) );
- LOGSTR3( "STSE > sPos(%i), ePos(%i)", sPos, ePos );
-
- if ( sPos != KErrNotFound && ePos != KErrNotFound )
- {
- TBuf<KProcessUidLength> processUid;
- TInt pEnd( ePos - sPos - KOpenSquareBracket().Length() );
- LOGSTR2( "STSE > pEnd(%i)", pEnd );
-
- // Copy UID value
- if ( pEnd > 0 )
- {
- processUid.Copy( unicodeFile.Mid(
- sPos + KOpenSquareBracket().Length(), pEnd ) );
- LOGSTR2( "STSE > processUid(%S)", &processUid );
- }
-
- if ( aFileName.Find( processUid ) == KErrNotFound )
- {
- // UID not exist, create new filename
- // Append uid to filename (<file name>_<uid>.<extension>)
- aFileName.Append( KUnderLine );
- aFileName.Append( processUid );
- aFileName.Append( extension );
- // Try to open file
- CheckIfFileAlreadyExist( aFileName );
-
- if ( iError == KErrNone )
- {
- uidErr = KErrNone;
- CheckFileVersion( aFileName );
- }
- }
- }
-
- if ( uidErr == KErrBadName && iError != KErrNotFound )
- {
- // Need re-create file name, add end off file _xx (xx=01, 02...)
- LOGSTR2( "STSE > Re-create file name, aFileName(%S)", &aFileName );
-
- // Parse file extension if exists.
- ParseExtension( aFileName, extension );
-
- // Temp file name
- TBuf<KMaxFileName> tempName;
-
- for ( TInt i = KNameIndexStart; i < KNameIndexEnd; i++ )
- {
- tempName.Delete( 0, tempName.MaxLength() );
- tempName.Format( KFormat, &aFileName, &KUnderLine, i, &extension );
- LOGSTR2( "STSE > tempName(%S)", &tempName );
- // Try to open file
- CheckIfFileAlreadyExist( tempName );
-
- if ( iError == KErrNone || iError == KErrNotFound )
- {
- aFileName.Copy( tempName );
- break;
- }
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::ParseExtension
-// Method is used to parse file name extension.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::ParseExtension(
- TDes& aFileName, TDes& aExtension )
- {
- LOGSTR2( "STSE void CATStorageServerSession::ParseExtension(%S)",
- &aFileName );
-
- // Parse current file name
- TParse parse;
- // Set up the TParse object
- parse.Set( aFileName, NULL, NULL );
-
- // Tests whether an extension is present.
- if ( parse.ExtPresent() )
- {
- // Gets the extension
- aExtension.Copy( parse.Ext() );
- // Remove extension from file name
- TInt pos( aFileName.Find( aExtension ) );
- aFileName.Delete( pos, aFileName.Length() );
- LOGSTR3( "STSE > aFileName(%S), aExtension(%S)",
- &aFileName, &aExtension );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CheckIfFileAlreadyExist
-// Method is used to check that file exists and is valid.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::CheckIfFileAlreadyExist(
- const TDes& aFileName )
- {
- LOGSTR2( "STSE void CATStorageServerSession::CheckIfFileAlreadyExist(%S)",
- &aFileName );
-
- iError = iFile.Open( iFileServer, aFileName, EFileWrite );
- LOGSTR2( "STSE > iError(%i)", iError );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CheckFileVersion
-// Method is used to check file version.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::CheckFileVersion(
- const TDes& aFileName )
- {
- LOGSTR2( "STSE void CATStorageServerSession::CheckFileVersion(%S)",
- &aFileName );
-
- TBuf8<KVersionStringLength> versionString;
-
- // Read version information from the beginning of the file (offset 0)
- iFile.Read( 0, versionString, KVersionStringLength );
-
- // Delete the existing file, if the version string read from the file does not
- // match with KDataFileVersion.
- if ( versionString.Compare( KDataFileVersion ) != 0 )
- {
- // Close the existing, opened file, and delete it
- iFile.Close();
- iError = iFileServer.Delete( aFileName );
-
- // If the deletion was successful, set iError = KErrNotFound, so a new
- // file will be created in the next few lines
- if ( iError == KErrNone )
- {
- iError = KErrNotFound;
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::CloseFsAndFile
-// Internally used for closing a handle to the file server and a file
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::CloseFsAndFile()
- {
- LOGSTR1( "STSE void CATStorageServerSession::CloseFsAndFile()" );
-
- // Close the file
- iFile.Close();
-
- // Close the server session and return the error code
- iFileServer.Close();
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::PrintLeaksL()
-// Called internally when a process is closed. Prints possible memory leaks
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::PrintLeaksL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::PrintLeaksL()" );
-
- // Panic both the client and the server, if this method is called in a wrong
- // state (logging should be ongoing, and the system should be logging into a file,
- // not into XTI channel)
- if ( !iLoggingOngoing || iLogOption != EATLogToFile )
- {
- PanicClient( EAToolInternalError, aMessage );
- StorageServerPanic( KCategoryServer, EAToolInternalError );
- }
-
- LOGMEM;
-
- // A pointer to a buffer of call stack's memory addresses
- CBufFlat* stackBuf = NULL;
-
- iError = KErrNone;
-
- TUint32 callStackAddr;
-
- // Number of leaks
- TInt leakCount = iLeakArray.Count();
-
- // Variable for the number of memory addresses in the call stack
- TInt addrCount( 0 );
-
- // Buffer position
- TInt pos( 0 );
-
- // Go through all the leaks
- for ( TInt i = 0; i < leakCount; i++ )
- {
- pos = 0;
-
- // Get the call stack buffer of the the leak i.
- stackBuf = const_cast<CBufFlat*>( iLeakArray[i]->iCallstackBuf );
-
- // Read the first word of the buffer. This includes the number of
- // memory addresses stored in the current stackBuf
- stackBuf->Read( pos, &addrCount, KWordSize );
-
- // Move the position one word onwards.
- pos += KWordSize;
-
- // Construct a buffer for the string to be written into the logging file
- // because of this memory leak. MEM_LEAK: <Memory address> <Time stamp>
- // <Allocation size> <Call stack address> <Call stack address> ...
- HBufC8* leakString =
- HBufC8::NewL( KMemleakLength +
- KHexa32Length +
- KSpaceLength + KHexa64Length +
- KSpaceLength + KHexa32Length +
- ( addrCount * (KSpaceLength + KHexa32Length) ) +
- KNewlineLength
- );
-
- // Make a pointer descriptor that points to leakString
- TPtr8 leakStringPtr( leakString->Des() );
-
- // Append the tag implying a memory leak line in the data file
- leakStringPtr.Append( KMemoryLeak );
-
- // Append the address of the memory leak
- TUint32 memAddress = iLeakArray[i]->iMemAddress;
- leakStringPtr.AppendNum( memAddress, EHex );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- leakStringPtr.Append( KSpace );
- TInt64 allocTime = iLeakArray[i]->iAllocTime;
- leakStringPtr.AppendNum( allocTime, EHex );
-
- // Append the size of the allocation in the 32-bit (max 8 characters) hexadecimal
- // text format.
- leakStringPtr.Append( KSpace );
- TInt allocSize = iLeakArray[i]->iAllocSize;
- leakStringPtr.AppendNum( allocSize, EHex );
-
- // Go through all call stack's memory addresses associated with
- // the current memory leak
- for ( TInt j = 0; j < addrCount; j++ )
- {
- // Read the next call stack's memory address stored in the buffer.
- stackBuf->Read( pos, &callStackAddr, KWordSize );
-
- // Append the read memory address as a hexadecimal number
- leakStringPtr.AppendFormat( KHexaNumber, callStackAddr );
-
- // Move the pos variable one word onwards.
- pos += KWordSize;
- }
-
- leakStringPtr.Append( KNewLine );
-
- // Set stackBuf to NULL, because it is not used anymore.
- stackBuf = NULL;
-
- // Write the constructed string into the data file and return if error
- iError = iFile.Write( *leakString );
-
- delete leakString;
-
- if ( iError != KErrNone )
- {
- return iError;
- }
-
- } // The outer for
-
- LOGSTR1( "STSE End of CATStorageServerSession::PrintLeaks()" );
- LOGMEM;
-
- // Empty the leak array and delete the referenced objects
- iLeakArray.ResetAndDestroy();
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::SetLogOption()
-// For setting the logging mode.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::SetLogOption( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE void CATStorageServerSession::SetLogOption()" );
-
- // Panic both the client and the server, if this method is called in a wrong
- // state (logging must not be ongoing when changing the mode of operation).
- // So, the mode cannot be changed "on the fly".
- if ( iLoggingOngoing )
- {
- PanicClient( EAToolInternalError, aMessage );
- StorageServerPanic( KCategoryServer, EAToolInternalError );
- }
-
- iLogOption = static_cast<TATLogOption>( aMessage.Int3() );
-
- // The default is EATLogToFile
- if ( iLogOption == EATUseDefault )
- {
- iLogOption = KDefaultLoggingMode;
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogThroughXti()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::LogThroughXti( const TDesC& aLogString ) const
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::LogThroughXti()" );
-
- // Return KErrNotSupported, if a logging session is not currently ongoing, or
- // the logging mode is not EATLogToXti
- if ( !iLoggingOngoing || iLogOption != EATLogToXti)
- {
- return KErrNotSupported;
- }
-
- RDebug::Print( KXtiMessage, iProcessId, &aLogString );
-
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::AllocInfoArray
-// -----------------------------------------------------------------------------
-//
-RArray<TAllocInfo>& CATStorageServerSession::AllocInfoArray()
- {
- LOGSTR1( "STSE RArray<TAllocInfo>& CATStorageServerSession::AllocInfoArray()" );
-
- return iAllocInfoArray;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::PanicClient
-// Creates a panic in the associated client's code.
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::PanicClient( TInt aPanic, const RMessage2& aMessage )
- {
- LOGSTR1( "STSE void CATStorageServerSession::PanicClient()" );
-
- aMessage.Panic( KCategoryClient, aPanic );
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetLoggingFileL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetLoggingFileL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetLoggingFileL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Get the dynamic process info array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, sessionObject->iLogFile );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetUdebL()
-// -----------------------------------------------------------------------------
-//
-TInt CATStorageServerSession::GetUdebL( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE TInt CATStorageServerSession::GetUdebL()" );
-
- iError = KErrNone;
-
- // Read the process ID at index 0
- TUint processId = aMessage.Int0();
-
- // Get the dynamic process info array
- RPointerArray<CATDynProcessInfo> dynProcessArray =
- iStorageServer.DynProcessInfoArray();
-
- // Construct a CATDynProcessInfo object with the given process ID for searching
- CATDynProcessInfo* dynProcessInfo = new (ELeave) CATDynProcessInfo( processId );
-
- // Find the index of a CATDynProcessInfo object with the given process ID
- TLinearOrder<CATDynProcessInfo> order( CATDynProcessInfo::Compare );
- TInt index = dynProcessArray.FindInOrder( dynProcessInfo, order );
- delete dynProcessInfo;
- dynProcessInfo = NULL;
-
- // Return, if a process with the requested process ID was not found
- if ( index == KErrNotFound )
- {
- return index;
- }
-
- // Otherwise get the wanted dynamic process info
- dynProcessInfo = dynProcessArray[index];
-
- // Get the desired process's associated session object
- CATStorageServerSession* sessionObject = dynProcessInfo->iSessionObject;
-
- TBuf8<KMaxVersionName> isUdeb;
- if ( sessionObject->iIsUdeb == 1 )
- {
- isUdeb.Copy( KUdeb() );
- }
- else if ( sessionObject->iIsUdeb == 0 )
- {
- isUdeb.Copy( KUrel() );
- }
- else
- {
- return KErrNotFound;
- }
- // Write the whole buffer into aMessage at index 1 for the client
- aMessage.WriteL( 1, isUdeb );
-
- return iError;
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::SetUdeb()
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::SetUdeb( const RMessage2& aMessage )
- {
- LOGSTR1( "STSE void CATStorageServerSession::SetUdeb()" );
-
- iIsUdeb = aMessage.Int0();
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::LogAbnormalEnd()
-// -----------------------------------------------------------------------------
-//
-void CATStorageServerSession::LogAbnormalEnd()
- {
- LOGSTR1( "STSE void CATStorageServerSession::LogAbnormalEnd()" );
-
- // Get the current universal time
- TInt64 timeFrom1970( GetTime() );
-
- switch ( iLogOption )
- {
- case EATLogToXti:
- {
- // Make a buffer that will be logged
- TBuf<KEndAbnormalBufLength> xtiBuf;
-
- // Write the process id to the buffer
- xtiBuf.Format( KProcessEndAbnormalXti, iProcessId );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- xtiBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- xtiBuf.Append( KNewLineXti );
-
- // Write the buffer into the XTI channel
- RDebug::Print( KXtiMessage, iProcessId, &xtiBuf );
- }
- break;
-
- case EATLogToFile:
- {
- // Make a buffer that will be logged
- TBuf8<KEndAbnormalBufLength> loggingBuf;
-
- // Write the process id to the buffer
- loggingBuf.Format( KProcessEndAbnormal, iProcessId );
-
- // Append the current time in the 64-bit (max 16 characters) hexadecimal text
- // format
- loggingBuf.AppendNum( timeFrom1970, EHex );
-
- // Append a new line
- loggingBuf.Append( KNewLine );
-
- // Write the buffer into a file (if possible in the current condition)
- iFile.Write( loggingBuf );
- }
- break;
-
- default:
- break;
- }
- }
-
-// -----------------------------------------------------------------------------
-// CATStorageServerSession::GetTime()
-// Get the current universal time
-// -----------------------------------------------------------------------------
-//
-TInt64 CATStorageServerSession::GetTime()
- {
- LOGSTR1( "STSE void CATStorageServerSession::GetTime()" );
-
- // Get the current universal time
- iTime.UniversalTime();
-
- // Change the time format that tells the number of microseconds from January First,
- // 0 AD nominal Gregorian, into a format that tells the number of microseconds from
- // January First, 1970 AD nominal Gregorian. This is a more generic format and
- // can be directly exploited by the PC code parsing the data file that this
- // server generates.
- return ( iTime.Int64() - iMicroSecondsAt1970 );
- }
-
-// End of File