1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Definitions and constants for the class CATStorageServerSession

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include    <utf.h>

    22 #include    <analyzetool/analyzetooltraceconstants.h>

    23 #include    "atstorageserversession.h"

    24 #include    "atstorageserver.h"

    25 #include    "atstorageservercommon.h"

    26 #include    "atmemoryentry.h"

    27 #include    "atlog.h"

    28 #include    "atdynprocessinfo.h"

    29 #include    "atdriveinfo.h"

    30 

    31 // CONSTANTS

    32 

    33 // New file name start and end index.

    34 const TInt KNameIndexStart = 1;

    35 const TInt KNameIndexEnd = 100;

    36 

    37 // ==================== MEMBER FUNCTIONS for TAllocInfo ========================

    38 

    39 // -----------------------------------------------------------------------------

    40 // TAllocInfo::TAllocInfo

    41 // Implementation for the constructor of the class TAllocInfo

    42 // -----------------------------------------------------------------------------

    43 //

    44 TAllocInfo::TAllocInfo( TUint32 aMemAddress, TInt aAllocSize ) :

    45     iMemAddress( aMemAddress ),

    46     iAllocSize( aAllocSize )

    47     {

    48     }

    49 

    50 

    51 // ============== MEMBER FUNCTIONS for CATStorageServerSession =================

    52 

    53 // -----------------------------------------------------------------------------

    54 // CATStorageServerSession::CATStorageServerSession

    55 // C++ default constructor. It Does not contain any code that

    56 // might leave.

    57 // -----------------------------------------------------------------------------

    58 //

    59 CATStorageServerSession::CATStorageServerSession( CATStorageServer& aStorageServer ) :

    60     iStorageServer( aStorageServer ),

    61     iError( 0 ),

    62     iLeakArray( KLeakArrayGranularity ),

    63     iProcessId( KNullProcessId ),

    64     iLoggingOngoing( EFalse ),

    65     iLogOption( KDefaultLoggingMode ),

    66     iCurAllocSize( 0 ),

    67     iMaxAllocs( 0 ),

    68     iMaxAllocSize( 0 ),

    69     iLogFile( KEmpty() ),

    70     iIsUdeb( 1 )

    71     {

    72     LOGSTR1( "STSE CATStorageServerSession::CATStorageServerSession()" );

    73     

    74     // Initialize iMicroSecondsAt1970

    75     TTime time( KJanuaryFirst1970 );

    76     iMicroSecondsAt1970 = time.Int64();

    77     

    78     // Increment the server's session count by one (1)

    79     iStorageServer.IncSessionCount();

    80     }

    81 

    82 // -----------------------------------------------------------------------------

    83 // CATStorageServerSession::ConstructL

    84 // Symbian 2nd phase constructor can leave.

    85 // -----------------------------------------------------------------------------

    86 //

    87 void CATStorageServerSession::ConstructL()

    88     {

    89     // Intentionally left empty

    90     }

    91 

    92 // -----------------------------------------------------------------------------

    93 // CATStorageServerSession::NewL

    94 // Two-phased constructor.

    95 // -----------------------------------------------------------------------------

    96 //

    97 CATStorageServerSession* CATStorageServerSession::NewL( CATStorageServer& aStorageServer )

    98     { 

    99     CATStorageServerSession* self = NewLC( aStorageServer );

   100     CleanupStack::Pop( self );

   101     

   102     return self;

   103     }

   104 

   105 // -----------------------------------------------------------------------------

   106 // CATStorageServerSession::NewLC

   107 // Two-phased constructor.

   108 // -----------------------------------------------------------------------------

   109 //

   110 CATStorageServerSession* CATStorageServerSession::NewLC( CATStorageServer& aStorageServer )

   111     { 

   112     CATStorageServerSession* self = new ( ELeave ) CATStorageServerSession( aStorageServer );

   113     

   114     CleanupStack::PushL( self );

   115     self->ConstructL();

   116     return self;

   117     }

   118 

   119 // -----------------------------------------------------------------------------

   120 // CATStorageServerSession::~CATStorageServerSession

   121 // Destructor

   122 // -----------------------------------------------------------------------------

   123 CATStorageServerSession::~CATStorageServerSession()

   124     {

   125     LOGSTR1( "STSE CATStorageServerSession::~CATStorageServerSession()" );

   126       

   127     // Empty the array and delete the referenced objects

   128     iLeakArray.ResetAndDestroy();

   129   

   130     // Close the leak array

   131     iLeakArray.Close();

   132     

   133     // Close the allocation info array

   134     iAllocInfoArray.Close();

   135     

   136     // Check if process closed abnormal

   137     if ( iProcessId != KNullProcessId && 

   138          iLoggingOngoing && iLogOption != EATLoggingOff && 

   139          iError != KErrNoMemory )

   140         {

   141         LogAbnormalEnd();

   142         }

   143     

   144     // Close the file and the handle to the file server

   145     CloseFsAndFile();

   146     

   147     // Remove the process with the current PID from the server's array of processes

   148     TRAP_IGNORE( iStorageServer.RemoveProcessL( iProcessId ) );

   149     

   150     // Decrement the server's session count by one (1)

   151     iStorageServer.DecSessionCount();

   152     }

   153     

   154 // -----------------------------------------------------------------------------

   155 // CATStorageServerSession::ServiceL

   156 // This function is called by the client/server framework

   157 // -----------------------------------------------------------------------------

   158 //

   159 void CATStorageServerSession::ServiceL( const RMessage2& aMessage )

   160     {

   161     LOGSTR1( "STSE void CATStorageServerSession::ServiceL()" );

   162     

   163     // If logging has been cancelled for this session, return immediately

   164     if( iLogOption == EATLoggingOff )

   165         {

   166         aMessage.Complete( KErrCancel );

   167         return;

   168         }

   169     

   170     switch ( aMessage.Function() )

   171         {

   172         case CATStorageServer::EProcessStarted:

   173             {

   174             // If logging is not ongoing, set the log option

   175             if( !iLoggingOngoing )

   176                 {

   177                 // Set the operation mode

   178                 SetLogOption( aMessage );

   179                 }

   180 

   181             switch ( iLogOption )

   182                 {

   183                 case EATLogToTrace:

   184                     {

   185                     iError = LogProcessStartTraceL( aMessage );

   186                     }

   187                 break;

   188                 

   189                 case EATLogToFile:

   190                     {

   191                     iError = LogProcessStartedL( aMessage );

   192                     }

   193                 break;

   194                 

   195                 default:

   196                     {

   197                     // Panic the client and set iError KErrCancel, because being

   198                     // here implies that an illegal log option has been given.

   199                     PanicClient( EAToolIllegalLogOption, aMessage );

   200                     iError = KErrCancel;

   201                     }

   202                 break;

   203                 }

   204             } 

   205         break;

   206         

   207         

   208         case CATStorageServer::EDllLoaded:

   209             {

   210             switch ( iLogOption )

   211                 {

   212                 case EATLogToTrace:

   213                     {

   214                     iError = LogDllLoadTraceL( aMessage );

   215                     }

   216                 break;

   217                 

   218                 case EATLogToFile:

   219                     {

   220                     iError = LogDllLoadedL( aMessage );

   221                     }

   222                 break;

   223                 

   224                 default:

   225                     {

   226                     // Panic the client and set iError KErrCancel, because being

   227                     // here implies that an illegal log option has been given.

   228                     PanicClient( EAToolIllegalLogOption, aMessage );

   229                     iError = KErrCancel;

   230                     }

   231                 break;

   232                 }

   233             }

   234         break;

   235         

   236         

   237         case CATStorageServer::EDllUnloaded:

   238             {

   239             switch ( iLogOption )

   240                 {

   241                 case EATLogToTrace:

   242                     {

   243                     iError = LogDllUnloadTraceL( aMessage );

   244                     }

   245                 break;

   246                 

   247                 case EATLogToFile:

   248                     {

   249                     iError = LogDllUnloadedL( aMessage );

   250                     }

   251                 break;

   252                 

   253                 default:

   254                     {

   255                     // Panic the client and set iError KErrCancel, because being

   256                     // here implies that an illegal log option has been given.

   257                     PanicClient( EAToolIllegalLogOption, aMessage );

   258                     iError = KErrCancel;

   259                     }

   260                 break;

   261                 }

   262             }

   263         break;

   264         

   265         

   266         case CATStorageServer::EMemoryAllocated:

   267             {

   268             switch ( iLogOption )

   269                 {

   270                 case EATLogToTrace:

   271                     {

   272                     iError = LogMemoryAllocTraceL( aMessage );

   273                     }

   274                 break;

   275                 

   276                 case EATLogToFile:

   277                     {

   278                     iError = LogMemoryAllocatedL( aMessage );

   279                     }

   280                 break;

   281                 

   282                 default:

   283                     {

   284                     // Panic the client and set iError KErrCancel, because being

   285                     // here implies that an illegal log option has been given.

   286                     PanicClient( EAToolIllegalLogOption, aMessage );

   287                     iError = KErrCancel;

   288                     }

   289                 break;

   290                 }

   291             }

   292         break;

   293         

   294         

   295         case CATStorageServer::EMemoryFreed:

   296             {

   297             switch ( iLogOption )

   298                 {

   299                 case EATLogToTrace:

   300                     {

   301                     iError = LogMemoryFreedTraceL( aMessage );

   302                     }

   303                 break;

   304                 

   305                 case EATLogToFile:

   306                     {

   307                     iError = LogMemoryFreedL( aMessage );

   308                     }

   309                 break;

   310                 

   311                 default:

   312                     {

   313                     // Panic the client and set iError KErrCancel, because being

   314                     // here implies that an illegal log option has been given.

   315                     PanicClient( EAToolIllegalLogOption, aMessage );

   316                     iError = KErrCancel;

   317                     }

   318                 break;

   319                 }

   320             }

   321         break;

   322         

   323         

   324         case CATStorageServer::EProcessEnded:

   325             {

   326             switch ( iLogOption )

   327                 {

   328                 case EATLogToTrace:

   329                     {

   330                     iError = LogProcessEndTraceL( aMessage );

   331                     }

   332                 break;

   333                 

   334                 case EATLogToFile:

   335                     {

   336                     iError = LogProcessEndedL( aMessage );

   337                     }

   338                 break;

   339                 

   340                 default:

   341                     {

   342                     // Panic the client and set iError KErrCancel, because being

   343                     // here implies that an illegal log option has been given.

   344                     PanicClient( EAToolIllegalLogOption, aMessage );

   345                     iError = KErrCancel;

   346                     }

   347                 break;

   348                 }

   349             }

   350         break;

   351         

   352         

   353         case CATStorageServer::EMemoryCheck:

   354             {

   355             switch ( iLogOption )

   356                 {

   357                 case EATLogToTrace:

   358                     {

   359                     iError = CheckMemoryAddressTrace( aMessage );

   360                     }

   361                 break;

   362                 

   363                 case EATLogToFile:

   364                     {

   365                     iError = CheckMemoryAddressL( aMessage );

   366                     }

   367                 break;

   368                 

   369                 default:

   370                     {

   371                     // Panic the client and set iError KErrCancel, because being

   372                     // here implies that an illegal log option has been given.

   373                     PanicClient( EAToolIllegalLogOption, aMessage );

   374                     iError = KErrCancel;

   375                     }

   376                 break;

   377                 }

   378             }

   379         break;

   380         

   381         

   382         case CATStorageServer::EGetProcesses:

   383             {

   384             iError = GetProcessesL( aMessage );

   385             }

   386         break;

   387         

   388         

   389         case CATStorageServer::EGetDlls:

   390             {

   391             iError = GetDllsL( aMessage );

   392             }

   393         break;

   394         

   395         case CATStorageServer::EGetLoggingMode:

   396             {

   397             iError = GetLoggingModeL( aMessage );

   398             }

   399         break;

   400         

   401         case CATStorageServer::ESubtestStart:

   402             {

   403             iError = StartSubtestL( aMessage );

   404             }

   405         break;

   406         

   407         case CATStorageServer::ESubtestStop:

   408             {

   409             iError = StopSubtestL( aMessage );

   410             }

   411         break;

   412         

   413         case CATStorageServer::ESubtestStart2:

   414             {

   415             iError = StartSubtest2L( aMessage );

   416             }

   417         break;

   418                

   419         case CATStorageServer::ESubtestStop2:

   420             {

   421             iError = StopSubtest2( aMessage );

   422             }

   423         break;

   424         

   425         case CATStorageServer::EGetCurrentAllocs:

   426             {

   427             iError = GetCurrentAllocsL( aMessage );

   428             }

   429         break;

   430         

   431         case CATStorageServer::EGetMaxAllocs:

   432             {

   433             iError = GetMaxAllocsL( aMessage );

   434             }

   435         break;

   436         

   437         case CATStorageServer::ECancelLogging:

   438             {

   439             iError = CancelLoggingL( aMessage );

   440             }

   441         break;

   442 

   443         case CATStorageServer::EGetUdeb:

   444             {

   445             iError = GetUdebL( aMessage );

   446             }

   447         break;

   448         

   449         case CATStorageServer::EGetLoggingFile:

   450             {

   451             iError = GetLoggingFileL( aMessage );

   452             }

   453         break;

   454 

   455         case CATStorageServer::EProcessUdeb:

   456             {

   457             SetUdeb( aMessage );

   458             }

   459         break;

   460         

   461         case CATStorageServer::EIsMemoryAdded:

   462             {

   463             iError = IsMemoryAdded( aMessage );

   464             LOGSTR2( "STSE > IsMemoryAdded err = %i", iError );

   465             }

   466         break;       

   467         

   468         default:

   469             {

   470             // Panic both the client and server, because being here implies

   471             // that there is an internal error in the client/server.

   472             PanicClient( EAToolBadRequest, aMessage );

   473             StorageServerPanic( KCategoryServer, EAToolBadRequest );

   474             }

   475         break;

   476             

   477         }

   478     

   479     // Complete the message, if it has not been already cancelled.

   480     if ( iError != KErrCancel )

   481         {

   482         // Log the error code. Only KErrNoMemory errors are logged.

   483         if ( iLogOption == EATLogToFile && iError == KErrNoMemory  )

   484             {

   485             HandleError( iError );

   486             }

   487         else if ( iLogOption == EATLogToTrace && iError == KErrNoMemory )

   488             {

   489             HandleErrorTrace( iError );

   490             }

   491                

   492         // Complete serving the message 

   493         aMessage.Complete( iError );

   494         }

   495     }

   496 

   497 // -----------------------------------------------------------------------------

   498 // CATStorageServerSession::LogProcessStartedL()

   499 // Opens a logging file with the requested name and then writes information

   500 // on process start into the file.

   501 // -----------------------------------------------------------------------------

   502 //

   503 TInt CATStorageServerSession::LogProcessStartedL( const RMessage2& aMessage )

   504     {

   505     LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessStartedL()" );

   506     

   507     // Panic the client and return, if this method has already been called for this

   508     // session object (and a logging file has been opened)

   509     if ( iLoggingOngoing )

   510         {

   511         PanicClient( EAToolNotAllowed, aMessage );

   512         return KErrCancel;

   513         }

   514     

   515     iError = KErrNone;

   516     

   517     LOGMEM;

   518     

   519     // READ THE FIRST ARGUMENT (descriptor)  

   520     

   521     // Length of the first argument (index 0)

   522     TInt length = aMessage.GetDesLength( 0 );

   523     

   524     LOGSTR2( "STSE length of the fileName: %i", length );

   525     

   526     // Return if errors

   527     if ( length == KErrArgument || length == KErrBadDescriptor )

   528         {

   529         return length;

   530         }

   531     

   532     // Construct a buffer for file name, and leave the pointer on Cleanup Stack

   533     HBufC* fileName = HBufC::NewLC( length );

   534     TPtr fileNamePtr( fileName->Des() );

   535      

   536     // Read the client side's descriptor at index 0

   537     iError = aMessage.Read( 0, fileNamePtr );

   538     

   539     if ( iError != KErrNone )

   540         {

   541         CleanupStack::PopAndDestroy( fileName );

   542         return iError;

   543         }

   544     

   545     // READ THE SECOND ARGUMENT (descriptor)  

   546     

   547     // Length of the second argument (index 1)   

   548     length = aMessage.GetDesLength( 1 );

   549     

   550     LOGSTR2( "STSE length of the processName: %i", length );

   551     

   552     // Return if errors

   553     if ( length == KErrArgument || length == KErrBadDescriptor )

   554         {

   555         CleanupStack::PopAndDestroy( fileName );

   556         return length;

   557         }

   558     

   559     HBufC8* processName = HBufC8::NewL( length );

   560     TPtr8 bufPtr( processName->Des() );

   561 

   562     // Read the client side's descriptor at index 1 

   563     iError = aMessage.Read( 1, bufPtr );

   564   

   565     if ( iError != KErrNone )

   566         {

   567         delete processName;

   568         CleanupStack::PopAndDestroy( fileName );

   569         return iError;

   570         }

   571     

   572     // READ THE THIRD ARGUMENT (integer, a process ID)    

   573     TInt processId = aMessage.Int2();

   574     

   575     // Open a file server session and a file. The file

   576     // will be opened with the name received from the client

   577     iError = OpenFsAndFile( *fileName, *processName );

   578     CleanupStack::PopAndDestroy( fileName );

   579     // Return without logging, if an error occured

   580     if ( iError != KErrNone )

   581         {

   582         // Delete the local objects

   583         delete processName;

   584         return iError;

   585         }

   586     

   587     // Get the home time for the configuration UI

   588     iTime.HomeTime();

   589     

   590     // Add the process into the server's array of processes

   591     iError = iStorageServer.AddProcessL( *processName,

   592                                         processId,

   593                                         this,

   594                                         iTime.Int64() );

   595 

   596     // Return without logging, if an error occured

   597     if ( iError )

   598         {

   599         // Remove, if something was added regardless of the error

   600         // However, we must not remove an existing process

   601         if ( iError != KErrAlreadyExists )

   602             {

   603             iStorageServer.RemoveProcessL( processId );

   604             }

   605         return iError;

   606         }

   607       

   608     // Make a buffer that will be logged into the opened logging file

   609     TBuf8<KProcessStartBufLength> loggingBuf;

   610     loggingBuf.Format( KProcessStart, processName, processId );

   611     

   612     delete processName;

   613     

   614     // Get the current universal time       

   615     TInt64 timeFrom1970( GetTime() );

   616     

   617     // Append the current time in the 64-bit (max 16 characters) hexadecimal text

   618     // format

   619     loggingBuf.AppendNum( timeFrom1970, EHex );

   620     

   621     // Append udeb/urel information to the process start

   622     loggingBuf.Append( KSpace );  

   623     loggingBuf.AppendNum( iIsUdeb, EHex );

   624     

   625     // Append trace version information

   626     loggingBuf.Append( KSpace );

   627     loggingBuf.AppendNum( KATTraceVersion, EHex );

   628     

   629     // Append a new line

   630     loggingBuf.Append( KNewLine );

   631     

   632     // Write the buffer into the file  

   633     iError = iFile.Write( loggingBuf );

   634     

   635     // Return, if an error occured

   636     if ( iError )

   637         {

   638         iStorageServer.RemoveProcessL( processId );

   639         return iError;

   640         }

   641     

   642     LOGMEM;

   643     

   644     // Set the process ID value for this logging session

   645     iProcessId = processId;

   646     // Set logging session started

   647     iLoggingOngoing = ETrue;

   648     

   649     return iError;

   650     }

   651     

   652 // -----------------------------------------------------------------------------

   653 // CATStorageServerSession::LogProcessStartTraceL()

   654 // -----------------------------------------------------------------------------

   655 //    

   656 TInt CATStorageServerSession::LogProcessStartTraceL( const RMessage2& aMessage )

   657     {

   658     LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessStartTraceL()" );

   659     

   660     // Panic the client and return, if this method has already been called for this

   661     // session object

   662     if ( iLoggingOngoing )

   663         {

   664         PanicClient( EAToolNotAllowed, aMessage );

   665         return KErrCancel;

   666         }

   667     

   668     iError = KErrNone;

   669     

   670     LOGMEM;

   671     

   672     // READ THE SECOND ARGUMENT (descriptor)

   673     // The first argument, file name, is ignored when logging thru trace  

   674     

   675     // Length of the second argument (index 1)

   676     TInt length = aMessage.GetDesLength( 1 );

   677     

   678     LOGSTR2( "STSE length of the processName: %i", length );

   679 

   680     // Return if errors

   681     if ( length == KErrArgument || length == KErrBadDescriptor )

   682         {

   683         return length;

   684         }

   685 

   686     HBufC8* processName = HBufC8::NewL( length );

   687     TPtr8 bufPtr( processName->Des() );

   688 

   689     // Read the client side's descriptor at index 1 

   690     iError = aMessage.Read( 1, bufPtr );

   691   

   692     if ( iError != KErrNone )

   693         {

   694         // Delete local objects and return

   695         delete processName;

   696         return iError;

   697         }

   698     

   699     // READ THE THIRD ARGUMENT (integer, a process ID)    

   700     TInt processId = aMessage.Int2();

   701 

   702     // Get the home time for the configuration UI

   703     iTime.HomeTime();

   704     

   705     // Add the process into the server's array of processes

   706     iError = iStorageServer.AddProcessL( *processName, processId, this,

   707                                              iTime.Int64() );

   708     

   709     // Return without logging, if an error occured

   710     if ( iError )

   711         {

   712         // Remove, if something was added regardless of the error

   713         // However, we must not remove an existing process

   714         if ( iError != KErrAlreadyExists )

   715             {

   716             iStorageServer.RemoveProcessL( processId );

   717             }

   718         return iError;

   719         }

   720 

   721     // Make a buffer that will be logged

   722     TBuf8<KProcessStartBufLength> loggingBuf;

   723     

   724     loggingBuf.Format( KProcessStart, processName, processId );

   725     

   726     delete processName;

   727     

   728     // Get the current universal time      

   729     TInt64 timeFrom1970( GetTime() );

   730     

   731     // Append the current time in the 64-bit (max 16 characters) hexadecimal text

   732     // format

   733     loggingBuf.AppendNum( timeFrom1970, EHex );

   734     

   735     // Append udeb/urel information to the process start

   736     loggingBuf.Append( KSpace );

   737     loggingBuf.AppendNum( iIsUdeb, EHex );

   738     

   739     // Append version number

   740     loggingBuf.Append( KSpace );  

   741     loggingBuf.AppendNum( KATTraceVersion, EHex );

   742     

   743     // Append a new line

   744     loggingBuf.Append( KNewLine );

   745     

   746     // Log to trace

   747     TBuf<KProcessStartBufLength> traceBuf;

   748     traceBuf.Copy( loggingBuf );

   749     RDebug::Print( KTraceMessage, processId ,&traceBuf );

   750     

   751     LOGMEM;

   752     

   753     // Set the process ID value for this logging session

   754     iProcessId = processId;

   755     // Set logging session started

   756     iLoggingOngoing = ETrue;

   757     

   758     return KErrNone;

   759     }

   760 

   761 // -----------------------------------------------------------------------------

   762 // CATStorageServerSession::LogDllLoadedL()

   763 // Logs to the file opened by the function LogProcessStartedL()

   764 // -----------------------------------------------------------------------------

   765 //

   766 TInt CATStorageServerSession::LogDllLoadedL( const RMessage2& aMessage )

   767     {

   768     LOGSTR1( "STSE TInt CATStorageServerSession::LogDllLoadedL()" );

   769     

   770     // Panic the client and return, if a logging session is not ongoing

   771     // ( can be started by calling the client's LogProcessStarted() )

   772     if ( !iLoggingOngoing )

   773         {

   774         PanicClient( EAToolNotAllowed, aMessage );

   775         return KErrCancel;

   776         }

   777     

   778     iError = KErrNone;

   779     

   780     // Read the length of the first argument (index 0)   

   781     TInt length = aMessage.GetDesLength( 0 );

   782     

   783     // Return if errors

   784     if ( length == KErrArgument || length == KErrBadDescriptor )

   785         {

   786         return length;

   787         }

   788     

   789     HBufC8* dllName = HBufC8::NewL( length );

   790     TPtr8 bufPtr( dllName->Des() );

   791 

   792     // Read the client side's descriptor (the argument 0) 

   793     iError = aMessage.Read( 0, bufPtr );

   794   

   795     if ( iError != KErrNone )

   796         {

   797         delete dllName;

   798         return iError;

   799         }

   800     

   801     // Get the current universal time

   802 	TInt64 timeFrom1970( GetTime() );

   803         

   804     // Add this dll into the server's array

   805     TUint32 startAddress( aMessage.Int1() );        

   806     TUint32 endAddress( aMessage.Int2() );

   807     iError = iStorageServer.AddDllL( iProcessId, 

   808     		TATDllInfo( startAddress, endAddress, timeFrom1970, *dllName ) );

   809     

   810     // Return without logging, if an error occured

   811     if ( iError )

   812         {

   813         delete dllName;

   814         return iError;

   815         }

   816     

   817     // Make a buffer that will be logged into the opened logging file

   818     TBuf8<KDllLoadBufLength> loggingBuf;

   819     loggingBuf.Format( KDllLoad, dllName, timeFrom1970, startAddress, endAddress );

   820     

   821     delete dllName;

   822     

   823     // Write the buffer into a file and return the error code   

   824     return iFile.Write( loggingBuf );

   825     }

   826     

   827 // -----------------------------------------------------------------------------

   828 // CATStorageServerSession::LogDllLoadTraceL()

   829 // -----------------------------------------------------------------------------

   830 //    

   831 TInt CATStorageServerSession::LogDllLoadTraceL( const RMessage2& aMessage )

   832     {

   833     LOGSTR1( "STSE TInt CATStorageServerSession::LogDllLoadTraceL()" );

   834     

   835     // Panic the client and return, if a logging session is not ongoing

   836     // ( can be started by calling the client's LogProcessStarted() )

   837     if ( !iLoggingOngoing )

   838         {

   839         PanicClient( EAToolNotAllowed, aMessage );

   840         return KErrCancel;

   841         }

   842     

   843     iError = KErrNone;

   844     

   845     // Read the length of the first argument (index 0)

   846     TInt length = aMessage.GetDesLength( 0 );

   847     

   848     // Return if errors

   849     if ( length == KErrArgument || length == KErrBadDescriptor )

   850         {

   851         return length;

   852         }

   853     

   854     HBufC8* dllName = HBufC8::NewL( length );

   855     TPtr8 bufPtr( dllName->Des() );

   856 

   857     // Read the client side's descriptor (the argument 0) 

   858     iError = aMessage.Read( 0, bufPtr );

   859   

   860     if ( iError != KErrNone )

   861         {

   862         delete dllName;

   863         return iError;

   864         }

   865     // Get the current universal time

   866 	TInt64 timeFrom1970( GetTime() );

   867     	

   868     TUint32 startAddress( aMessage.Int1() );

   869     TUint32 endAddress( aMessage.Int2() );

   870         

   871     // Add this dll into the server's array 

   872     iError = iStorageServer.AddDllL( iProcessId, 

   873     		TATDllInfo( startAddress, endAddress, timeFrom1970, *dllName ) );

   874     

   875     // Return without logging, if an error occured

   876     if ( iError )

   877         {

   878         delete dllName;

   879         return iError;

   880         }

   881     

   882     // Make a buffer that will be logged

   883     TBuf8<KDllLoadBufLength> loggingBuf;

   884     loggingBuf.Format( KDllLoad, dllName, timeFrom1970, startAddress, endAddress );

   885     

   886     delete dllName;

   887     

   888     TBuf<KDllLoadBufLength> traceBuf;

   889     traceBuf.Copy( loggingBuf );

   890     RDebug::Print( KTraceMessage, iProcessId ,&traceBuf );

   891     return iError;

   892     }

   893     

   894 // -----------------------------------------------------------------------------

   895 // CATStorageServerSession::LogDllUnloadedL()

   896 // Logs to the file opened by the function LogProcessStartedL()

   897 // -----------------------------------------------------------------------------

   898 //

   899 TInt CATStorageServerSession::LogDllUnloadedL( const RMessage2& aMessage )

   900     {

   901     LOGSTR1( "STSE TInt CATStorageServerSession::LogDllUnloadedL()" );

   902     

   903     // Panic the client and return, if a logging session is not ongoing

   904     // ( can be started by calling the client's LogProcessStarted() )

   905     if ( !iLoggingOngoing )

   906         {

   907         PanicClient( EAToolNotAllowed, aMessage );

   908         return KErrCancel;

   909         }

   910     

   911     iError = KErrNone;

   912     

   913     // Read the length of the first argument (index 0)   

   914     TInt length = aMessage.GetDesLength( 0 );

   915     

   916     LOGSTR2( "STSE length %i", length );

   917     

   918     // Return if errors

   919     if ( length == KErrArgument || length == KErrBadDescriptor )

   920         {

   921         return length;

   922         }

   923     

   924     HBufC8* dllName = HBufC8::NewL( length );

   925     TPtr8 bufPtr( dllName->Des() );

   926 

   927     // Read the client side's descriptor (the argument 0) 

   928     iError = aMessage.Read( 0, bufPtr );

   929   

   930     if ( iError != KErrNone )

   931         {

   932         delete dllName;

   933         return iError;

   934         }

   935        

   936     TUint32 startAddress = aMessage.Int1();

   937     TUint32 endAddress = aMessage.Int2();

   938     

   939     // Get the current universal time

   940     TInt64 timeFrom1970( GetTime() );

   941         

   942     // Make a buffer that will be logged into the opened logging file

   943     TBuf8<KDllUnloadBufLength> loggingBuf;

   944     loggingBuf.Format( KDllUnload, dllName, timeFrom1970, startAddress, endAddress );

   945     

   946     // Remove this dll from the server's array

   947     iError = iStorageServer.RemoveDllL( iProcessId, bufPtr );

   948     

   949     delete dllName;

   950     

   951     // Return without logging, if an error occured

   952     if ( iError )

   953         {

   954         return iError;

   955         }

   956      

   957     // Write the buffer into a file and return the error code   

   958     return iFile.Write( loggingBuf );

   959     }

   960  

   961 // -----------------------------------------------------------------------------

   962 // CATStorageServerSession::LogDllUnloadTraceL()

   963 // -----------------------------------------------------------------------------

   964 //    

   965 TInt CATStorageServerSession::LogDllUnloadTraceL( const RMessage2& aMessage )

   966     {

   967     LOGSTR1( "STSE TInt CATStorageServerSession::LogDllUnloadTraceL()" );

   968     

   969     // Panic the client and return, if a logging session is not ongoing

   970     // ( can be started by calling the client's LogProcessStarted() )

   971     if ( !iLoggingOngoing )

   972         {

   973         PanicClient( EAToolNotAllowed, aMessage );

   974         return KErrCancel;

   975         }

   976         

   977     iError = KErrNone;

   978     

   979     // Read the length of the first argument (index 0)   

   980     TInt length = aMessage.GetDesLength( 0 );

   981     

   982     LOGSTR2( "STSE length %i", length );

   983     

   984     // Return if errors

   985     if ( length == KErrArgument || length == KErrBadDescriptor )

   986         {

   987         return length;

   988         }

   989     

   990     HBufC8* dllName = HBufC8::NewL( length );

   991     TPtr8 bufPtr( dllName->Des() );

   992 

   993     // Read the client side's descriptor (the argument 0) 

   994     iError = aMessage.Read( 0, bufPtr );

   995   

   996     if ( iError != KErrNone )

   997         {

   998         delete dllName;

   999         return iError;

  1000         }

  1001     

  1002     TUint32 startAddress = aMessage.Int1();

  1003     TUint32 endAddress = aMessage.Int2();

  1004     

  1005     // Get the current universal time

  1006     TInt64 timeFrom1970( GetTime() );

  1007         

  1008     // Make a buffer that will be logged

  1009     TBuf8<KDllUnloadBufLength> loggingBuf;

  1010     loggingBuf.Format( KDllUnload, dllName, timeFrom1970, startAddress, endAddress );

  1011     

  1012     // Remove this dll from the server's array

  1013     iError = iStorageServer.RemoveDllL( iProcessId, bufPtr );

  1014     

  1015     delete dllName;

  1016     

  1017     // Return without logging, if an error occured

  1018     if ( iError )

  1019         {

  1020         return iError;

  1021         }

  1022     

  1023     TBuf<KDllLoadBufLength> traceBuf;

  1024     traceBuf.Copy( loggingBuf );

  1025     RDebug::Print( KTraceMessage, iProcessId ,&traceBuf );

  1026     return iError;

  1027     }

  1028     

  1029 // -----------------------------------------------------------------------------

  1030 // CATStorageServerSession::LogMemoryAllocatedL()

  1031 // Constructs a CATMemoryEntry object and appends it into iLeakArray.

  1032 // -----------------------------------------------------------------------------

  1033 //

  1034 TInt CATStorageServerSession::LogMemoryAllocatedL( const RMessage2& aMessage )

  1035     {

  1036     LOGSTR1( "STSE TInt CATStorageServerSession::LogMemoryAllocatedL()" );

  1037     

  1038     // Panic the client and return, if a logging session is not ongoing

  1039     // ( can be started by calling the client's LogProcessStarted() )

  1040     if ( !iLoggingOngoing )

  1041         {

  1042         PanicClient( EAToolNotAllowed, aMessage );

  1043         return KErrCancel;

  1044         }     

  1045     

  1046     // A pointer to a buffer of call stack's memory addresses

  1047     CBufFlat* stackBuf = NULL;

  1048     

  1049     iError = KErrNone;

  1050     

  1051     // Get the current universal time

  1052     TInt64 timeFrom1970( GetTime() );

  1053     

  1054     // Read the first argument (index 0)

  1055     TUint32 memAddress = aMessage.Int0();

  1056     if ( memAddress == 0 )

  1057         {

  1058         return KErrNotSupported;

  1059         }

  1060     

  1061     // Read the length of the descriptor argument (index 1) that should include

  1062     // call stack memory addresses associated with this memory allocation

  1063     TInt bufferLength = aMessage.GetDesLength( 1 );

  1064     

  1065     // Construct a buffer for aCallstack

  1066     stackBuf = CBufFlat::NewL( bufferLength );

  1067     CleanupStack::PushL( stackBuf );

  1068     

  1069     // Buffer position

  1070     TInt pos = 0;

  1071     

  1072     stackBuf->ExpandL( pos, bufferLength );

  1073 

  1074     TPtr8 bufPtr = stackBuf->Ptr( pos );

  1075 

  1076     // Read the descriptor argument into the buffer

  1077     aMessage.ReadL( 1, bufPtr );

  1078 

  1079     // Read the third argument (index 2) that tells the size of this allocation

  1080     TInt size = aMessage.Int2();

  1081     

  1082     // Construct a new CATMemoryEntry object.   

  1083     // The ownership of the current stackBuf object is given to the "entry" object.

  1084     CATMemoryEntry* entry = 

  1085         new (ELeave) CATMemoryEntry( memAddress, stackBuf, timeFrom1970, size );

  1086     

  1087     // Pop stackBuf from CleanupStack and set it to NULL, because it is not used anymore.

  1088     CleanupStack::Pop( stackBuf );

  1089     stackBuf = NULL;

  1090     

  1091     // Make sure that the same memory area is not tryed to be allocated a second time

  1092     TIdentityRelation<CATMemoryEntry> matcher( CATMemoryEntry::Match );

  1093 

  1094     TInt index = iLeakArray.Find( entry, matcher );

  1095     

  1096     if ( index == KErrNotFound )

  1097         {

  1098         TLinearOrder<CATMemoryEntry> order( CATMemoryEntry::Compare );

  1099         

  1100         // Insert the "entry" object into "iLeakArray". The ownership of

  1101         // the "entry" object is given to the array.

  1102         iError = iLeakArray.InsertInOrderAllowRepeats( entry, order );

  1103                

  1104         // If an insertion to the array was not successful, delete the created

  1105         // entry manually and return.

  1106         if ( iError )

  1107             {

  1108             delete entry;

  1109             return iError;

  1110             }

  1111         

  1112         // Make a TAllocInfo object, and give values for its members.

  1113         TAllocInfo allocInfo( memAddress, size );

  1114 

  1115         // Insert the allocInfo object into iAllocInfoArray

  1116         iError = iAllocInfoArray.InsertInUnsignedKeyOrder( allocInfo );

  1117     

  1118         // If an insertion to the array was not successful, delete the created entry

  1119         // and remove its pointer from iLeakArray.

  1120         if ( iError )

  1121             {

  1122             index = iLeakArray.Find( entry, matcher );

  1123             // Delete the entry object and remove remove the pointer from the array

  1124             delete entry;

  1125             // The index should be in a legal range, because the earlier insertion of

  1126             // the entry was successful

  1127             iLeakArray.Remove( index );

  1128             }

  1129         

  1130         // Otherwise update the iCurAllocSize, iMaxAllocs and iMaxAllocSize variables

  1131         

  1132         iCurAllocSize += size;

  1133         

  1134         // The count can never be negative => associate it to an unsigned int