diff -r 0ff24a8f6ca2 -r 98307c651589 perfsrv/analyzetool/dynamicmemoryhook/src/analyzetoolfilelog.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/perfsrv/analyzetool/dynamicmemoryhook/src/analyzetoolfilelog.cpp	Mon Sep 06 15:00:47 2010 +0300
@@ -0,0 +1,603 @@
+/*
+* Copyright (c) 2010 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:  Declaration of the class TATDriveInfo.
+*
+*/
+
+#include "analyzetoolfilelog.h"
+#include "atdriveinfo.h"
+#include "atlog.h"
+#include <analyzetool/customuser.h>
+#include <analyzetool/analyzetooltraceconstants.h>
+#include <f32file.h> //RFs
+#include <utf.h>
+
+// New file name start and end index.
+const TInt KNameIndexStart = 1;
+const TInt KNameIndexEnd = 100;
+
+RATFileLog::RATFileLog()
+	{
+
+    // Initialize iMicroSecondsAt1970
+    TTime time( KJanuaryFirst1970 );
+    iMicroSecondsAt1970 = time.Int64();
+    iError = KErrNone;
+	}
+
+RATFileLog::~RATFileLog()
+	{
+	// Auto-generated destructor stub
+	}
+
+
+// Local time function.
+TInt64 RATFileLog::CurrentTime()
+    {
+    LOGSTR1( "ATFL void CATStorageServerSession::GetTime()" );
+    
+    // Get the current universal time
+    TTime time;
+    time.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 ( time.Int64() - iMicroSecondsAt1970 );        
+    }
+
+TInt RATFileLog::ATFileLogVersion()
+{
+    LOGSTR1( "ATFL CATFileLog::ATFileLogVersion()" );
+    
+    iFile << KDataFileVersion;
+
+    iFile.CommitL();   
+    return KErrNone;
+}
+
+TInt RATFileLog::ATFileLogProcessStarted( const TDesC8& aProcessName,
+                                          TUint aProcessId,
+                                          TUint32 aIsDebug,
+                                          const TDesC8& aAtoolVersion,
+                                          const TDesC8& aApiVersion )
+{
+    LOGSTR1( "ATFL CATFileLog::ATFileLogProcessStarted()" );
+ 
+    // log the current time
+    iFile << this->CurrentTime();
+    
+    // <Time stamp> PCS <Process name> <Process ID> <Udeb> <Version>
+    iFile << (TUint8)EProcessStart;
+    iFile << aProcessName;
+    iFile << (TUint32)aProcessId;
+    iFile << aIsDebug;
+    iFile << aAtoolVersion;
+    iFile << aApiVersion;
+    
+    // ensure that any buffered data is written to the stream
+    iFile.CommitL();
+    
+    return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogProcessEnded
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogProcessEnded( TUint aHandleLeakCount )
+{
+	LOGSTR1( "ATFL CATFileLog::ATFileLogProcessEnded()" );
+	   
+	if ( aHandleLeakCount > 0 )
+	{
+		// HDL <Handle count>
+		iFile << this->CurrentTime();
+        iFile << (TUint8)EHandleLeak;
+        iFile << (TUint32)aHandleLeakCount;	
+	}
+
+	// log the current time
+    iFile << this->CurrentTime();
+	
+	// PCE
+	iFile << (TUint8)EProcessEnd;
+	
+    // ensure that any buffered data is written to the stream
+    iFile.CommitL();
+	
+	return KErrNone;	
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogDllLoaded
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogDllLoaded( const TDesC8& aDllName, TUint32 aStartAddress,
+                                TUint32 aEndAddress )
+{
+	LOGSTR1( "ATFL CATFileLog::ATFileLogDllLoaded()" );
+	    
+	// log the current time
+	iFile << this->CurrentTime();
+	
+	// DLL <DLL name> <Memory start address> <Memory end address>
+
+	// DLL
+	iFile << (TUint8)EDllLoad;
+	// dll name
+	iFile << aDllName;
+	// start adress
+	iFile << aStartAddress;
+	//end adress
+	iFile << aEndAddress;
+	
+	// ensure that any buffered data is written to the stream
+	iFile.CommitL();
+	
+	return KErrNone;
+}
+
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogDllUnloaded
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogDllUnloaded( const TDesC8& aDllName, TUint32 aStartAddress,
+                                       TUint32 aEndAddress )
+{
+    LOGSTR1( "ATFL CATFileLog::ATFileLogDllUnloaded()" );
+
+    // log the current time
+    iFile << this->CurrentTime();
+    
+    // DLU <DLL name> <Memory start address> <Memory end address>
+    
+    // DLU
+    iFile << (TUint8)EDllUnload;
+    // dll name
+    iFile << aDllName;
+    // start adress
+    iFile << aStartAddress;
+    //end adress
+    iFile << aEndAddress;
+    
+    // ensure that any buffered data is written to the stream
+    iFile.CommitL();
+	
+	return KErrNone;
+		
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogMemoryAllocated
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogMemoryAllocated( TUint32 aMemAddress,
+                                  TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,
+                                  TInt aSize,  TUint aThreadId  )
+{
+	LOGSTR1( "ATFL CATFileLog::ATFileLogMemoryAllocated()" );
+	
+	// ALH <Memory address> <Allocation size> <Thread ID> 
+	// <Call stack address count> <Call stack address> <Call stack address> ...
+	
+	// log the current time
+	iFile << this->CurrentTime();
+
+	// ALH
+	iFile << (TUint8)EAllocH;
+	// memory adress
+	iFile << aMemAddress;
+	// allocation size
+	iFile << (TUint32)aSize;
+	// thread ID
+	iFile << (TUint32)aThreadId;
+
+	// Search call stack for address count.
+	TInt addrCount(0);
+	for ( TInt j = 0; j < aCallstack.Count() ; j++ )
+		{
+		if ( aCallstack.At(j) == 0 )
+			break;
+		addrCount++;
+		}
+	
+	// address count
+    iFile << (TUint32)addrCount;
+		
+	// Go through all call stack's memory addresses associated with
+	// this memory allocation 
+	for ( TInt addrPos = 0; addrPos < addrCount; addrPos++ )
+		{
+	    iFile <<  aCallstack.At( addrPos );
+		}
+
+	// ensure that any buffered data is written to the stream
+	iFile.CommitL();
+
+	return KErrNone;	
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogMemoryFreed
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogMemoryFreed( TUint32 aMemAddress, 
+		                                  TFixedArray<TUint32, KATMaxFreeCallstackLength>& aFreeCallstack, 
+		                                  TUint aThreadId )
+{
+    LOGSTR1( "ATFL CATFileLog::ATFileLogMemoryFreed()" );
+	
+	// FRH <Memory address> <Thread ID> <Call stack address count> 
+	// <Call stack address> <Call stack address> ...
+
+	// log the current time
+	iFile << this->CurrentTime();
+
+	// FRH
+	iFile << (TUint8)EFreeH;
+	
+	// Append the start address of this allocation in the 32-bit (max 8 characters)
+	// hexadecimal text format.
+	iFile << aMemAddress;
+
+	// thread ID
+	iFile << (TUint32)aThreadId;
+	
+	// Search call stack for address count.
+	TInt addrCount(0);
+	for ( TInt j = 0; j < aFreeCallstack.Count() ; j++ )
+		{
+		if ( aFreeCallstack.At(j) == 0 )
+			break;
+		addrCount++;
+		}
+	
+	// address count.
+	iFile << (TUint32)addrCount;
+
+	// Go through all call stack's memory addresses associated with
+	// this memory allocation 
+	for ( TInt addrPos = 0; addrPos < addrCount; addrPos++ )
+		{
+		iFile << aFreeCallstack.At( addrPos );
+		}
+
+	// ensure that any buffered data is written to the stream
+	iFile.CommitL();
+
+	return KErrNone;		
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogMemoryReallocated
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogMemoryReallocated( TUint32 aMemAddressFree,  TUint32 aMemAddressAlloc,
+                                  TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,
+                                  TInt aSize,  TUint aThreadId  )
+{
+	LOGSTR1( "ATFL CATFileLog::ATFileLogMemoryReallocated()" );    
+	    
+	// RAH <Freed memory address> <Allocated memory address> <Allocation size> <Thread ID>
+	// <Call stack address count> <Call stack address> <Call stack address> ...
+	        
+    // log the current time
+    iFile << this->CurrentTime();
+	
+	// RAH
+    iFile <<  (TUint8)EReallocH;
+	// memory adress freed
+    iFile << aMemAddressFree;
+	// memory adress allocated
+    iFile << aMemAddressAlloc;
+	// allocation size
+    iFile << (TUint32)aSize;
+	// thread ID
+    iFile << (TUint32)aThreadId;
+
+	// Search call stack for address count.
+	TInt addrCount(0);
+	for ( TInt j = 0; j < aCallstack.Count() ; j++ )
+		{
+		if ( aCallstack.At(j) == 0 )
+			break;
+		addrCount++;
+		}
+	
+	// address count
+	iFile << (TUint32)addrCount;
+		
+	// Go through all call stack's memory addresses associated with
+	// this memory allocation 
+	for ( TInt addrPos = 0; addrPos < addrCount; addrPos++ )
+		{	  
+		// Append call stack address.
+		iFile << aCallstack.At( addrPos );
+		}
+
+	// ensure that any buffered data is written to the stream
+	iFile.CommitL();
+
+	return KErrNone;	
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogThreadStarted
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogThreadStarted( TUint aThreadId )
+{
+	LOGSTR1( "ATFL CATFileLog::ATFileLogThreadStarted()" );
+
+	// log the current time
+	iFile << this->CurrentTime();
+	
+	// TDS <Thread ID>
+
+	// TDS
+	iFile << (TUint8)EThreadStart;
+	// thread ID
+	iFile << (TUint32)aThreadId;
+    
+    // ensure that any buffered data is written to the stream
+    iFile.CommitL();
+
+	return KErrNone;
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogThreadEnded
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogThreadEnded( TUint64 aThreadId )
+{
+	  LOGSTR1( "ATFL CATFileLog::ATFileLogThreadEnded()" );
+
+		// log the current time
+		iFile << this->CurrentTime();
+		
+		// TDE <Thread ID>
+
+		// TDE
+		iFile << (TUint8)EThreadEnd;
+		// thread ID
+		iFile << (TUint32)aThreadId;
+	    
+	    // ensure that any buffered data is written to the stream
+	    iFile.CommitL();
+
+		return KErrNone;
+}
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ATFileLogDeviceInfo
+// 
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::ATFileLogDeviceInfo( const TDesC8& aS60Version, const TDesC8& aChecksum)
+
+{
+    LOGSTR1( "ATFL CATFileLog::ATFileLogVersionsInfo()" );
+
+    // log the current time
+    iFile << this->CurrentTime();
+
+    // VER
+    iFile << (TUint8)EDeviceInfo;
+    // sw version
+    iFile << aS60Version;
+    // rom checksum
+    iFile << aChecksum;
+
+    // ensure that any buffered data is written to the stream
+    iFile.CommitL();
+
+	return KErrNone;	
+}
+
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::OpenFsAndFile
+// Internally used for opening a handle to the file server and a file
+// -----------------------------------------------------------------------------
+// 
+TInt RATFileLog::OpenFsAndFile( const TDesC& aFileName, const TDesC& aFilePath, 
+    const TDesC8& aProcessName )
+    {
+    LOGSTR1( "ATFL TInt CATFileLog::OpenFsAndFile()" );
+    
+    // Connect file server, return if error occured
+    iError = iFileServer.Connect();
+    if ( iError )
+        {
+        iFileServer.Close();
+        return iError;
+        }
+    
+    iError = iFileServer.ShareAuto();
+    if( iError )
+    	{
+		iFileServer.Close();
+		return iError;
+    	}
+
+    // Open a file
+    TBuf<KMaxFileName> fileNameBuf;  
+    
+    iError = TATDriveInfo::CreatePath( fileNameBuf, aFileName, aFilePath, iFileServer );
+                        
+    // Return, if an error occured, and it
+    // is not KErrAlreadyExists
+    if ( iError && iError != KErrAlreadyExists )
+        {
+        iFileServer.Close();
+        return iError;
+        }
+
+    // if file already exist, generat new filename with index
+    GenerateNewFileName( fileNameBuf, aProcessName );
+    
+    // Save the file name for this session
+    CnvUtfConverter::ConvertFromUnicodeToUtf8( iLogFile, fileNameBuf );
+    
+    LOGSTR2( "ATFL > 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 | EFileShareAny );
+        if ( !iError )
+            {
+        	// todo
+            }
+        }
+       
+    if ( iError )
+        {
+        iFile.Close();
+        iFileServer.Close();
+        return iError;
+        }
+
+    return iError;
+    }
+
+// -----------------------------------------------------------------------------
+// RATFileLog::GenerateNewFileName
+// Called internally when need generate new file name.
+// -----------------------------------------------------------------------------
+//                     
+void RATFileLog::GenerateNewFileName( TDes& aFileName,
+    const TDesC8& aProcessName )
+    {    
+    LOGSTR1( "ATFL void CATFileLog::GenerateNewFileName()" );
+        
+    // Extension
+    TBuf<KExtensionLength> extension;
+        
+	// Check if file already exist
+	CheckIfFileAlreadyExist( aFileName );
+	if ( iError == KErrNotFound )
+		{
+	    // If not we can use filename without indexing
+		return;
+		}
+	
+	// File with aFileName already exist, let's add index
+	
+	// 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, &KLeftBracket, i, &KRightBracket, &extension );
+		LOGSTR2( "ATFL > tempName(%S)", &tempName );
+		// Try to open file
+		CheckIfFileAlreadyExist( tempName );
+		// File does not exist, this index can be used
+		if ( iError == KErrNotFound )
+			{
+			aFileName.Copy( tempName );
+			break;
+			}
+		}
+    }
+
+// -----------------------------------------------------------------------------
+// RATFileLog::ParseExtension
+// Method is used to parse file name extension.
+// -----------------------------------------------------------------------------
+//                     
+void RATFileLog::ParseExtension( 
+    TDes& aFileName, TDes& aExtension )
+    {    
+    LOGSTR2( "ATFL void CATFileLog::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( "ATFL > aFileName(%S), aExtension(%S)", 
+                &aFileName, &aExtension );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// RATFileLog::CheckIfFileAlreadyExist
+// Method is used to check that file exists and is valid.
+// -----------------------------------------------------------------------------
+//                     
+void RATFileLog::CheckIfFileAlreadyExist( 
+    const TDes& aFileName )
+    {    
+    LOGSTR2( "ATFL void CATFileLog::CheckIfFileAlreadyExist(%S)", 
+            &aFileName );
+    
+    iError = iFile.Open( iFileServer, aFileName, EFileWrite );
+    LOGSTR2( "ATFL > iError(%i)", iError );
+    }
+
+
+// -----------------------------------------------------------------------------
+// RATFileLog::CloseFsAndFile
+// Internally used for closing a handle to the file server and a file
+// -----------------------------------------------------------------------------
+// 
+void RATFileLog::CloseFsAndFile()
+    {
+    LOGSTR1( "ATFL void CATFileLog::CloseFsAndFile()" );
+    
+    // Close the file    
+    iFile.Close();
+                 
+    // Close the server session and return the error code   
+    iFileServer.Close();
+    }
+