/*
* Copyright (c) 2006-2007 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: Logging to chunk wrappe for Mul
*
*/
// CLASS HEADER
#include "mullogchunk.h"
// EXTERNAL INCLUDES
#include <e32svr.h>
// LOCAL DECLARATIONS
namespace
{
// size for the chunks
const TInt KLogChunkSize = 1000000; // 1 million bytes
// name for chunk 1
_LIT( KLogChunk1Name, "MUL_Logchunk1" );
// name for chunk 2
_LIT( KLogChunk2Name, "MUL_Logchunk2" );
// extension for log file
_LIT( KLogFileExtension, ".log" );
// carriage return / line feed
_LIT8( KLogCR, "\r" );
_LIT8( KLogLF, "\n" );
// constant for machine word alignment
const TInt KBytesInAWord = sizeof( TInt32 );
}
inline void Panic(TInt aReason)
{
_LIT(applicationName,"Mul Logging");
User::Panic(applicationName, aReason);
}
// -----------------------------------------------------------------------------
// RMulLogUtility::Open
// -----------------------------------------------------------------------------
TInt RMulLogUtility::Open( const TDesC& aName, TBool aReadOnly )
{
// open the chunk
return iChunk.OpenGlobal( aName, aReadOnly );
}
// -----------------------------------------------------------------------------
// RMulLogUtility::CreateL
// -----------------------------------------------------------------------------
void RMulLogUtility::CreateL( const TDesC& aName )
{
// create the chunk, leave if error
TInt error = iChunk.CreateGlobal( aName, KLogChunkSize, KLogChunkSize );
// dont treate already exists as an error
if( KErrAlreadyExists == error )
{
// open in read-write
User::LeaveIfError( iChunk.OpenGlobal( aName, EFalse ) );
}
else
{
User::LeaveIfError( error );
}
// initialise the iChunk to all zeros.
Mem::FillZ( iChunk.Base(), iChunk.Size() );
// initialise current address to base
SetCurrentAddress( BaseAddress() );
// initialise last logged address to base
SetLastLoggedAddress( BaseAddress() );
}
// -----------------------------------------------------------------------------
// RMulLogUtility::Close
// -----------------------------------------------------------------------------
void RMulLogUtility::Close()
{
iChunk.Close();
}
// -----------------------------------------------------------------------------
// RMulLogUtility::ChunkSize
// -----------------------------------------------------------------------------
TInt RMulLogUtility::ChunkSize()
{
return iChunk.Size();
}
// -----------------------------------------------------------------------------
// RMulLogUtility::Id
// -----------------------------------------------------------------------------
TObjectId RMulLogUtility::Id()
{
// take chunk base address
TUint8* ptr_in_chunk = iChunk.Base();
// cast that to TObjectId*
TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );
// return the id
return *ptr_as_tobjectid;
}
// -----------------------------------------------------------------------------
// RMulLogUtility::SetId
// -----------------------------------------------------------------------------
void RMulLogUtility::SetId( TObjectId aId )
{
// take chunk base address
TUint8* ptr_in_chunk = iChunk.Base();
// cast that to TObjectId*
TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );
// assign the id in place
*ptr_as_tobjectid = aId;
}
// -----------------------------------------------------------------------------
// RMulLogUtility::CurrentAddress
// -----------------------------------------------------------------------------
TUint8* RMulLogUtility::CurrentAddress()
{
// take chunk base address plus object id
TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );
// cast that to TInt*
TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
// dereference that pointer to read the 32 bits that are the address
TUint32 value_of_pointer = *ptr_as_tint;
// then return the value as TUint8*
return reinterpret_cast< TUint8* >( value_of_pointer );
}
// -----------------------------------------------------------------------------
// RMulLogUtility::SetCurrentAddress
// -----------------------------------------------------------------------------
void RMulLogUtility::SetCurrentAddress( TUint8* aValue )
{
// take chunk base address plus object id
TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );
// cast that to TInt*
TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
// assign the addres to TInt
TUint32 new_value = reinterpret_cast< TUint32 >( aValue );
// ensure we're byte aligned - ARM requires 32 bit alignment to machine word
// boundary!!
TInt remainder = new_value % KBytesInAWord;
if ( remainder > 0 )
{
new_value += ( KBytesInAWord - remainder );
}
// set the new value to the chunk
*ptr_as_tint = new_value;
}
// -----------------------------------------------------------------------------
// RMulLogUtility::LastLoggedAddress
// -----------------------------------------------------------------------------
TUint8* RMulLogUtility::LastLoggedAddress()
{
// take chunk base address plus object id plus one pointer
TUint8* ptr_in_chunk =
iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );
// cast that to TInt*
TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
// dereference that pointer to read the 32 bits that are the address
TUint32 value_of_pointer = *ptr_as_tint;
// then return the value as TUint8*
return reinterpret_cast< TUint8* >( value_of_pointer );
}
// -----------------------------------------------------------------------------
// RMulLogUtility::SetLastLoggedAddress
// -----------------------------------------------------------------------------
void RMulLogUtility::SetLastLoggedAddress( TUint8* aValue )
{
// take chunk base address plus object id plus one pointer
TUint8* ptr_in_chunk =
iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );
// cast that to TInt*
TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
// assign the addres to TInt
TUint32 new_value = reinterpret_cast< TUint32 >( aValue );
// ensure we're byte aligned - ARM requires 32 bit alignment to machine word
// boundary!!
TInt remainder = new_value % KBytesInAWord;
if ( remainder > 0 )
{
new_value += ( KBytesInAWord - remainder );
}
// set the new value to the chunk
*ptr_as_tint = new_value;
}
// -----------------------------------------------------------------------------
// RMulLogUtility::BaseAddress
// -----------------------------------------------------------------------------
TUint8* RMulLogUtility::BaseAddress()
{
// take chunks base address
TUint8* base = iChunk.Base();
// calculate the topmost write address, our header is
// TObjectId and two TUint8*
return base + sizeof( TObjectId ) + sizeof( TUint8* ) * 2;
}
// -----------------------------------------------------------------------------
// RMulLogUtility::LastAddress
// -----------------------------------------------------------------------------
TUint8* RMulLogUtility::LastAddress()
{
// return chunks base address plus its size
return iChunk.Base() + iChunk.Size();
}
// -----------------------------------------------------------------------------
// RMulLogClient::Open
// -----------------------------------------------------------------------------
EXPORT_C TInt RMulLogClient::Open( TObjectId aId )
{
// try to open first log chunk, in read-write mode
TInt err = iLogUtility.Open( KLogChunk1Name(), EFalse );
if ( err != KErrNone )
{
return err;
}
// check id
TObjectId id = iLogUtility.Id();
if ( id == TObjectId( 0 ) )
{
// no id set, so reserve this for us and use this chunk
iLogUtility.SetId( aId );
}
// check if our id was there?
else if( id != aId )
{
// not our chunk, try second chunk in read-write mode
err = iLogUtility.Open( KLogChunk2Name(), EFalse );
if ( err != KErrNone )
{
return err;
}
// check id
id = iLogUtility.Id();
if ( id == TObjectId( 0 ) )
{
// no id, reserve this for us and use this chunk
iLogUtility.SetId( aId );
}
else if ( id != aId )
{
// both chunks already reserved, return error
return KErrNotFound;
}
}
return KErrNone;
}
// -----------------------------------------------------------------------------
// RMulLogClient::Close
// -----------------------------------------------------------------------------
EXPORT_C void RMulLogClient::Close()
{
iLogUtility.Close();
}
// -----------------------------------------------------------------------------
// RMulLogClient::Write
// -----------------------------------------------------------------------------
EXPORT_C void RMulLogClient::Write( const TDesC8& aLogEntry )
{
// get the size of log entry (in bytes)
TInt num_bytes = aLogEntry.Size();
// take current address and chunk size to ensure log entry fits
TUint8* current_address = iLogUtility.CurrentAddress();
// calculate the new current address, we write the size and the data
TUint8* after_write = current_address + num_bytes + sizeof( TInt );
// chck that we fit
if( after_write >= iLogUtility.LastAddress() )
{
// we dont fit in the end
// need to mark the old current_address so that
// manager knows we jumped to the start
TInt* last_indicator_ptr =
reinterpret_cast< TInt* >( current_address );
// assign KErrNotFound there
*last_indicator_ptr = KErrNotFound;
// write this entry to the base address
current_address = iLogUtility.BaseAddress();
}
// we need to store the size in the chunk first so take a TInt*
TInt* size_ptr = reinterpret_cast< TInt* >( current_address );
// assign new value in place
*size_ptr = num_bytes;
// increase address
current_address += sizeof( TInt );
// copy the data, first target, then source and last number of bytes
Mem::Copy( current_address, aLogEntry.Ptr(), num_bytes );
// and set the new current address
iLogUtility.SetCurrentAddress( current_address + num_bytes );
}
// -----------------------------------------------------------------------------
// RMulLogManager::CreateL
// -----------------------------------------------------------------------------
EXPORT_C void RMulLogManager::CreateL()
{
// connect to the file server
User::LeaveIfError( iFs.Connect() );
// create two log chunks
iLogUtility1.CreateL( KLogChunk1Name );
iLogUtility2.CreateL( KLogChunk2Name );
}
// -----------------------------------------------------------------------------
// RMulLogManager::Release
// -----------------------------------------------------------------------------
EXPORT_C void RMulLogManager::Release()
{
// close file server handle
iFs.Close();
// release both log chunks
iLogUtility1.Close();
iLogUtility2.Close();
}
// -----------------------------------------------------------------------------
// RMulLogManager::CommitToFileL
// -----------------------------------------------------------------------------
EXPORT_C void RMulLogManager::CommitToFileL( const TDesC& aFolder )
{
// open the file
RFile file;
CleanupClosePushL( file );
// chunk1
// create the file name
TFileName fileName;
fileName = aFolder;
fileName.Append( KLogChunk1Name );
fileName.Append( KLogFileExtension );
// try to open the file
TInt err = file.Open( iFs, fileName, EFileWrite );
if ( err == KErrNotFound )
{
// file doesn't exist so create it
err = file.Create( iFs, fileName, EFileWrite );
}
User::LeaveIfError( err );
// write the first chunk to file
CommitToFileL( iLogUtility1, file );
// close the file
file.Close();
// chunk2
// reset the file name
fileName.Zero();
// create the file name
fileName = aFolder;
fileName.Append( KLogChunk2Name );
fileName.Append( KLogFileExtension );
// try to open the file
err = file.Open( iFs, fileName, EFileWrite );
if ( err == KErrNotFound )
{
// file doesn't exist so create it
err = file.Create( iFs, fileName, EFileWrite );
}
User::LeaveIfError( err );
// write the second chunk to file
CommitToFileL( iLogUtility2, file );
CleanupStack::PopAndDestroy( &file );
}
// -----------------------------------------------------------------------------
// RMulLogManager::CommitToFileL
// -----------------------------------------------------------------------------
void RMulLogManager::CommitToFileL( RMulLogUtility& aUtility, RFile& aFile )
{
// Need to explicitly move to the end of the file as it's not done
// automatically on call to Write
TInt pos = 0;
TInt err = aFile.Seek( ESeekEnd, pos );
User::LeaveIfError( err );
TPtr8 logEntryPtr( 0, 0 );
TInt logEntrySize = 0;
// what's previously been logged to the file?
TUint8* lastLoggedAddress = aUtility.LastLoggedAddress();
// how much more has been added to the chunk?
TUint8* currentAddress = aUtility.CurrentAddress();
// write each of the chunk's logged entries to the file
TInt32* sizePtr = NULL;
while ( currentAddress != lastLoggedAddress && err == KErrNone )
{
// get the logEntry's size
sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );
logEntrySize = *sizePtr;
if ( logEntrySize == KErrNotFound )
{
// logged entries have wrapped around the end of the chunk
// so start from the beginning
lastLoggedAddress = aUtility.BaseAddress();
sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );
logEntrySize = *sizePtr;
}
// set an error - this will be reset to KErrNone if we succeed
// with finding and writing a log entry
err = KErrNotFound;
if ( logEntrySize > 0 )
{
// move the current address to the data
lastLoggedAddress += sizeof( TInt32 );
// extract the log entry's data
logEntryPtr.Set( lastLoggedAddress, logEntrySize, logEntrySize );
// write the log entry to the file
err = aFile.Write( logEntryPtr );
// append carriage return and line feed to the entry
err = aFile.Write( KLogCR );
err = aFile.Write( KLogLF );
// ensure we align to a multiple of a 4-byte boundary
TInt remainder = logEntrySize % KBytesInAWord;
if ( remainder > 0 )
{
// not aligned so add some padding
logEntrySize += ( KBytesInAWord - remainder );
}
// update the last logged address
lastLoggedAddress += logEntrySize;
}
}
// update the last logged address
aUtility.SetLastLoggedAddress( lastLoggedAddress );
//
// commit the data
err = aFile.Flush();
User::LeaveIfError( err );
}