1 /*

     2 * Copyright (c) 2006-2007 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:  Logging to chunk wrappe for Mul

    15 *

    16 */

    17 

    18 

    19 // CLASS HEADER

    20 #include "mullogchunk.h"

    21 

    22 // EXTERNAL INCLUDES

    23 #include <e32svr.h>

    24 

    25 // LOCAL DECLARATIONS

    26 namespace

    27 	{

    28 	// size for the chunks

    29 	const TInt KLogChunkSize = 1000000; // 1 million bytes

    30 	// name for chunk 1

    31 	_LIT( KLogChunk1Name, "MUL_Logchunk1" );

    32 	// name for chunk 2

    33 	_LIT( KLogChunk2Name, "MUL_Logchunk2" );

    34 	// extension for log file

    35 	_LIT( KLogFileExtension, ".log" );

    36 	// carriage return / line feed

    37 	_LIT8( KLogCR, "\r" );

    38 	_LIT8( KLogLF, "\n" );

    39 	// constant for machine word alignment

    40 	const TInt KBytesInAWord = sizeof( TInt32 );

    41 	}

    42 	

    43 inline void Panic(TInt aReason)

    44     {

    45 	_LIT(applicationName,"Mul Logging");

    46     User::Panic(applicationName, aReason);

    47     }

    48 

    49 // -----------------------------------------------------------------------------

    50 // RMulLogUtility::Open

    51 // -----------------------------------------------------------------------------

    52 TInt RMulLogUtility::Open( const TDesC& aName, TBool aReadOnly )

    53 	{

    54 	// open the chunk

    55 	return iChunk.OpenGlobal( aName, aReadOnly );

    56 	}

    57 

    58 // -----------------------------------------------------------------------------

    59 // RMulLogUtility::CreateL

    60 // -----------------------------------------------------------------------------

    61 void RMulLogUtility::CreateL( const TDesC& aName )

    62     {

    63 	// create the chunk, leave if error

    64 	TInt error = iChunk.CreateGlobal( aName, KLogChunkSize, KLogChunkSize  );

    65 	// dont treate already exists as an error

    66 	if( KErrAlreadyExists == error )

    67 		{

    68 		// open in read-write

    69 		User::LeaveIfError( iChunk.OpenGlobal( aName, EFalse ) );

    70 		}

    71 	else

    72 		{

    73 		User::LeaveIfError( error );

    74 		}

    75 

    76     // initialise the iChunk to all zeros.

    77     Mem::FillZ( iChunk.Base(), iChunk.Size() );

    78     // initialise current address to base

    79     SetCurrentAddress( BaseAddress() );

    80     // initialise last logged address to base

    81     SetLastLoggedAddress( BaseAddress() );

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // RMulLogUtility::Close

    86 // -----------------------------------------------------------------------------

    87 void RMulLogUtility::Close()

    88 	{

    89 	iChunk.Close();

    90 	}

    91 

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

    93 // RMulLogUtility::ChunkSize

    94 // -----------------------------------------------------------------------------

    95 TInt RMulLogUtility::ChunkSize()

    96 	{

    97 	return iChunk.Size();

    98 	}

    99     

   100 // -----------------------------------------------------------------------------

   101 // RMulLogUtility::Id

   102 // -----------------------------------------------------------------------------

   103 TObjectId RMulLogUtility::Id()

   104 	{

   105 	// take chunk base address

   106 	TUint8* ptr_in_chunk = iChunk.Base();

   107 	// cast that to TObjectId*

   108 	TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );

   109 	// return the id

   110 	return *ptr_as_tobjectid;

   111 	}

   112 

   113 // -----------------------------------------------------------------------------

   114 // RMulLogUtility::SetId

   115 // -----------------------------------------------------------------------------

   116 void RMulLogUtility::SetId( TObjectId aId )

   117 	{

   118 	// take chunk base address

   119 	TUint8* ptr_in_chunk = iChunk.Base();

   120 	// cast that to TObjectId*

   121 	TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );

   122 	// assign the id in place

   123 	*ptr_as_tobjectid = aId;

   124 	}

   125 

   126 // -----------------------------------------------------------------------------

   127 // RMulLogUtility::CurrentAddress

   128 // -----------------------------------------------------------------------------

   129 TUint8* RMulLogUtility::CurrentAddress()

   130 	{

   131 	// take chunk base address plus object id

   132 	TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );

   133 	// cast that to TInt*

   134 	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );

   135 	// dereference that pointer to read the 32 bits that are the address

   136 	TUint32 value_of_pointer = *ptr_as_tint;

   137 	// then return the value as TUint8*

   138 	return reinterpret_cast< TUint8* >( value_of_pointer );

   139 	}

   140 

   141 // -----------------------------------------------------------------------------

   142 // RMulLogUtility::SetCurrentAddress

   143 // -----------------------------------------------------------------------------

   144 void RMulLogUtility::SetCurrentAddress( TUint8* aValue )

   145 	{

   146 	// take chunk base address plus object id

   147 	TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );

   148 	// cast that to TInt*

   149 	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );

   150 	// assign the addres to TInt

   151 	TUint32 new_value = reinterpret_cast< TUint32 >( aValue );

   152 	// ensure we're byte aligned - ARM requires 32 bit alignment to machine word

   153 	// boundary!!

   154 	TInt remainder = new_value % KBytesInAWord;

   155 	if ( remainder > 0 )

   156 	    {

   157 	    new_value += ( KBytesInAWord - remainder );

   158 	    }

   159 	// set the new value to the chunk

   160 	*ptr_as_tint = new_value;

   161 	}

   162 

   163 // -----------------------------------------------------------------------------

   164 // RMulLogUtility::LastLoggedAddress

   165 // -----------------------------------------------------------------------------

   166 TUint8* RMulLogUtility::LastLoggedAddress()

   167 	{

   168 	// take chunk base address plus object id plus one pointer

   169 	TUint8* ptr_in_chunk = 

   170 		iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );

   171 	// cast that to TInt*

   172 	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );

   173 	// dereference that pointer to read the 32 bits that are the address

   174 	TUint32 value_of_pointer = *ptr_as_tint;

   175 	// then return the value as TUint8*

   176 	return reinterpret_cast< TUint8* >( value_of_pointer );

   177 	}

   178 

   179 // -----------------------------------------------------------------------------

   180 // RMulLogUtility::SetLastLoggedAddress

   181 // -----------------------------------------------------------------------------

   182 void RMulLogUtility::SetLastLoggedAddress( TUint8* aValue )

   183 	{

   184 	// take chunk base address plus object id plus one pointer

   185 	TUint8* ptr_in_chunk = 

   186 		iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );

   187 	// cast that to TInt*

   188 	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );

   189 	// assign the addres to TInt

   190 	TUint32 new_value = reinterpret_cast< TUint32 >( aValue );

   191 	// ensure we're byte aligned - ARM requires 32 bit alignment to machine word

   192 	// boundary!!

   193     TInt remainder = new_value % KBytesInAWord;

   194 	if ( remainder > 0 )

   195 	    {

   196 	    new_value += ( KBytesInAWord - remainder );

   197 	    }	

   198 	// set the new value to the chunk

   199 	*ptr_as_tint = new_value;

   200 	}

   201 

   202 // -----------------------------------------------------------------------------

   203 // RMulLogUtility::BaseAddress

   204 // -----------------------------------------------------------------------------

   205 TUint8* RMulLogUtility::BaseAddress()

   206 	{

   207 	// take chunks base address

   208 	TUint8* base = iChunk.Base();

   209 	// calculate the topmost write address, our header is 

   210 	// TObjectId and two TUint8*

   211 	return base + sizeof( TObjectId ) + sizeof( TUint8* ) * 2;

   212 	}

   213 

   214 // -----------------------------------------------------------------------------

   215 // RMulLogUtility::LastAddress

   216 // -----------------------------------------------------------------------------

   217 TUint8* RMulLogUtility::LastAddress()

   218 	{

   219 	// return chunks base address plus its size

   220 	return iChunk.Base() + iChunk.Size();

   221 	}

   222 

   223 // -----------------------------------------------------------------------------

   224 // RMulLogClient::Open

   225 // -----------------------------------------------------------------------------

   226 EXPORT_C TInt RMulLogClient::Open( TObjectId aId )

   227     {

   228     // try to open first log chunk, in read-write mode

   229     TInt err = iLogUtility.Open( KLogChunk1Name(), EFalse );

   230     if ( err != KErrNone )

   231         {

   232         return err;

   233         }

   234     // check id

   235     TObjectId id = iLogUtility.Id();

   236     if ( id  == TObjectId( 0 ) )

   237         {

   238         // no id set, so reserve this for us and use this chunk

   239         iLogUtility.SetId( aId );

   240         }

   241     // check if our id was there?

   242     else if( id != aId )

   243         {

   244         // not our chunk, try second chunk in read-write mode

   245         err = iLogUtility.Open( KLogChunk2Name(), EFalse );

   246         if ( err != KErrNone )

   247             {

   248             return err;

   249             }

   250         // check id

   251         id = iLogUtility.Id();

   252         if ( id  == TObjectId( 0 ) )

   253             {

   254             // no id, reserve this for us and use this chunk

   255             iLogUtility.SetId( aId );

   256             }

   257         else if ( id != aId )

   258             {

   259             // both chunks already reserved, return error

   260             return KErrNotFound;

   261             }

   262        	}

   263     return KErrNone;

   264     }

   265 

   266 // -----------------------------------------------------------------------------

   267 // RMulLogClient::Close

   268 // -----------------------------------------------------------------------------

   269 EXPORT_C void RMulLogClient::Close()

   270 	{

   271     iLogUtility.Close();

   272 	}

   273 

   274 // -----------------------------------------------------------------------------

   275 // RMulLogClient::Write

   276 // -----------------------------------------------------------------------------

   277 EXPORT_C void RMulLogClient::Write( const TDesC8& aLogEntry )

   278     {

   279     // get the size of log entry (in bytes)

   280     TInt num_bytes = aLogEntry.Size();

   281     // take current address and chunk size to ensure log entry fits

   282     TUint8* current_address = iLogUtility.CurrentAddress();

   283     // calculate the new current address, we write the size and the data

   284     TUint8* after_write = current_address + num_bytes + sizeof( TInt );

   285     // chck that we fit

   286     if( after_write >= iLogUtility.LastAddress() )

   287     	{

   288     	// we dont fit in the end

   289     	// need to mark the old current_address so that

   290     	// manager knows we jumped to the start

   291 	    TInt* last_indicator_ptr = 

   292 	    	reinterpret_cast< TInt* >( current_address );

   293 	   	// assign KErrNotFound there

   294 		*last_indicator_ptr = KErrNotFound;

   295     	// write this entry to the base address

   296     	current_address = iLogUtility.BaseAddress();

   297     	}

   298     // we need to store the size in the chunk first so take a TInt*

   299     TInt* size_ptr = reinterpret_cast< TInt* >( current_address );

   300     // assign new value in place

   301     *size_ptr = num_bytes;

   302     // increase address

   303     current_address += sizeof( TInt );

   304     // copy the data, first target, then source and last number of bytes

   305     Mem::Copy( current_address, aLogEntry.Ptr(), num_bytes );

   306     // and set the new current address

   307     iLogUtility.SetCurrentAddress( current_address + num_bytes );

   308     }

   309 

   310 // -----------------------------------------------------------------------------

   311 // RMulLogManager::CreateL

   312 // -----------------------------------------------------------------------------

   313 EXPORT_C void RMulLogManager::CreateL()

   314     {

   315     // connect to the file server

   316     User::LeaveIfError( iFs.Connect() );

   317     

   318     // create two log chunks

   319     iLogUtility1.CreateL( KLogChunk1Name );

   320     iLogUtility2.CreateL( KLogChunk2Name );

   321     }

   322 

   323 // -----------------------------------------------------------------------------

   324 // RMulLogManager::Release

   325 // -----------------------------------------------------------------------------

   326 EXPORT_C void RMulLogManager::Release()

   327     {

   328     // close file server handle

   329     iFs.Close();

   330     

   331     // release both log chunks

   332     iLogUtility1.Close();

   333     iLogUtility2.Close();

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // RMulLogManager::CommitToFileL

   338 // -----------------------------------------------------------------------------

   339 EXPORT_C void RMulLogManager::CommitToFileL( const TDesC& aFolder )

   340 	{

   341 	// open the file

   342 	RFile file;

   343 	CleanupClosePushL( file );

   344 	

   345 	// chunk1

   346 	// create the file name

   347 	TFileName fileName;

   348 	fileName = aFolder;

   349 	fileName.Append( KLogChunk1Name );

   350 	fileName.Append( KLogFileExtension );

   351 	// try to open the file	

   352 	TInt err = file.Open( iFs, fileName, EFileWrite );

   353 	if ( err == KErrNotFound )

   354 	    {

   355 	    // file doesn't exist so create it

   356 	    err = file.Create( iFs, fileName, EFileWrite );

   357 	    }

   358 	User::LeaveIfError( err );

   359 	// write the first chunk to file

   360 	CommitToFileL( iLogUtility1, file );

   361 	// close the file

   362 	file.Close();

   363 	

   364 	// chunk2

   365 	// reset the file name

   366 	fileName.Zero();

   367 	// create the file name

   368 	fileName = aFolder;

   369 	fileName.Append( KLogChunk2Name );

   370 	fileName.Append( KLogFileExtension );

   371 	// try to open the file

   372 	err = file.Open( iFs, fileName, EFileWrite );

   373 	if ( err == KErrNotFound )

   374 	    {

   375 	    // file doesn't exist so create it

   376 	    err = file.Create( iFs, fileName, EFileWrite );

   377 	    }

   378 	User::LeaveIfError( err );

   379 	// write the second chunk to file

   380 	CommitToFileL( iLogUtility2, file );

   381 

   382 	CleanupStack::PopAndDestroy( &file );

   383 	}

   384 

   385 // -----------------------------------------------------------------------------

   386 // RMulLogManager::CommitToFileL

   387 // -----------------------------------------------------------------------------    

   388 void RMulLogManager::CommitToFileL( RMulLogUtility& aUtility, RFile& aFile )

   389     {

   390     // Need to explicitly move to the end of the file as it's not done

   391     // automatically on call to Write

   392     TInt pos = 0;

   393     TInt err = aFile.Seek( ESeekEnd, pos );

   394     User::LeaveIfError( err );

   395     TPtr8 logEntryPtr( 0, 0 );

   396     TInt logEntrySize = 0;

   397     

   398     // what's previously been logged to the file?

   399     TUint8* lastLoggedAddress = aUtility.LastLoggedAddress();

   400     

   401     // how much more has been added to the chunk?

   402     TUint8* currentAddress = aUtility.CurrentAddress();

   403     

   404     // write each of the chunk's logged entries to the file 

   405     TInt32* sizePtr = NULL;

   406     while ( currentAddress != lastLoggedAddress && err == KErrNone )

   407         {

   408         // get the logEntry's size

   409         sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );

   410         logEntrySize = *sizePtr;

   411         if ( logEntrySize == KErrNotFound )

   412             {

   413             // logged entries have wrapped around the end of the chunk

   414             // so start from the beginning

   415             lastLoggedAddress = aUtility.BaseAddress();

   416             sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );

   417             logEntrySize = *sizePtr;

   418             }

   419         // set an error - this will be reset to KErrNone if we succeed

   420         // with finding and writing a log entry

   421         err = KErrNotFound;

   422         if ( logEntrySize > 0 )

   423             {

   424             // move the current address to the data

   425             lastLoggedAddress += sizeof( TInt32 );

   426             // extract the log entry's data 

   427             logEntryPtr.Set( lastLoggedAddress, logEntrySize, logEntrySize );

   428             // write the log entry to the file

   429             err = aFile.Write( logEntryPtr );

   430             // append carriage return and line feed to the entry

   431             err = aFile.Write( KLogCR );

   432             err = aFile.Write( KLogLF );

   433             // ensure we align to a multiple of a 4-byte boundary

   434             TInt remainder = logEntrySize % KBytesInAWord;

   435             if ( remainder > 0 )

   436                 {

   437                 // not aligned so add some padding

   438                 logEntrySize += ( KBytesInAWord - remainder );

   439                 }

   440  

   441             // update the last logged address

   442             lastLoggedAddress += logEntrySize;

   443             }

   444         }

   445     // update the last logged address

   446     aUtility.SetLastLoggedAddress( lastLoggedAddress );

   447 	// 

   448 	// commit the data

   449 	err = aFile.Flush();

   450 	User::LeaveIfError( err );

   451     }