1 // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Trace Core

    15 //

    16 

    17 #include "TraceCoreBTraceHandler.h"

    18 #include "TraceCoreWriter.h"

    19 #include "TraceCoreDebug.h"

    20 #include "TraceCoreConstants.h"

    21 #include "BTraceOstCategoryHandler.h"

    22 #include "BTraceKernelCategoryHandler.h"

    23 #include "OstTraceDefinitions.h"

    24 #ifdef OST_TRACE_COMPILER_IN_USE

    25 #include "TraceCoreBTraceHandlerTraces.h"

    26 #endif

    27 

    28 

    29 /**

    30  * Static instance is needed when calling traces from handler function

    31  */

    32 DTraceCoreBTraceHandler* DTraceCoreBTraceHandler::iInstance = NULL;

    33 

    34 

    35 /**

    36  * Constructor

    37  */

    38 DTraceCoreBTraceHandler::DTraceCoreBTraceHandler()

    39 : iCategoryHandlers( NULL )

    40 , iOstHandler( NULL )

    41 , iKernelHandler( NULL )

    42 	{

    43 	}

    44 

    45 

    46 /**

    47  * Destructor

    48  */

    49 DTraceCoreBTraceHandler::~DTraceCoreBTraceHandler()

    50 	{

    51     // Handlers are deleted first -> They call UnregisterCategoryHandler

    52 	delete iOstHandler;

    53 	delete iKernelHandler;

    54     delete[] iCategoryHandlers;

    55     DTraceCoreBTraceHandler::iInstance = NULL;

    56 	}

    57 	

    58 

    59 /**

    60  * Initializes BTrace handler

    61  */

    62 TInt DTraceCoreBTraceHandler::Init()

    63 	{

    64     iCategoryHandlers = new DBTraceCategoryHandler*[ KBTraceCategoryCount ];

    65     TInt ret;

    66     if ( iCategoryHandlers != NULL )

    67         {

    68         memset( iCategoryHandlers, 0, sizeof ( DBTraceCategoryHandler* ) * KBTraceCategoryCount );

    69         // Registers this handler to TraceCore

    70         ret = Register();

    71         if ( ret == KErrNone )

    72             {

    73             // Registers the callback function to BTrace

    74             BTrace::SetHandler( BTraceHandlerFunc );

    75             DTraceCoreBTraceHandler::iInstance = this;

    76             }

    77         }

    78     else

    79         {

    80         ret = KErrNoMemory;

    81         }

    82 

    83     // Autogen, OST and Symbian kernel category handlers are integrated to TraceCore

    84     if ( ret == KErrNone )

    85         {

    86 

    87         ret = StartOstHandler();

    88 

    89         if ( ret == KErrNone )

    90             {

    91             ret = StartKernelHandler();

    92             }

    93         }

    94     

    95     TC_TRACE( ETraceLevelFlow, Kern::Printf( "<DTraceCoreBTraceHandler::Init - return %d", ret ) );

    96     return ret;

    97     }

    98 

    99 

   100     

   101 /**

   102  * Starts the OST category handler

   103  */

   104 TInt DTraceCoreBTraceHandler::StartOstHandler()

   105     {

   106     TInt ret = KErrNoMemory;

   107     iOstHandler = new DBTraceOstCategoryHandler();

   108     if ( iOstHandler != NULL )

   109         {

   110         // Init calls RegisterCategoryHandler

   111         ret = iOstHandler->Init();

   112         }

   113     TC_TRACE( ETraceLevelError,Kern::Printf( "DTraceCoreBTraceHandler::StartOstHandler - %d", ret ) );

   114     return ret;

   115     }

   116 

   117 

   118 /**

   119  * Starts the kernel category handler

   120  */

   121 TInt DTraceCoreBTraceHandler::StartKernelHandler()

   122     {

   123     TInt ret = KErrGeneral;

   124     if ( iOstHandler != NULL )

   125         {

   126         iKernelHandler = new DBTraceKernelCategoryHandler();

   127         if ( iKernelHandler != NULL )

   128             {

   129             // Init calls RegisterCategoryHandler

   130             ret = iKernelHandler->Init();

   131             }

   132         // Memory allocation failed

   133         else

   134             {

   135             ret = KErrNoMemory;

   136             }

   137         }

   138     // noelse

   139 

   140     TC_TRACE( ETraceLevelError, Kern::Printf("DTraceCoreBTraceHandler::StartKernelHandler - %d", ret ) );

   141     return ret;

   142     }

   143 

   144 

   145 /**

   146  * Called before SetWriter with interrupts enabled

   147  * 

   148  * @param aWriter Pointer to writer

   149  */       

   150 void DTraceCoreBTraceHandler::PrepareSetWriter( DTraceCoreWriter* aWriter )

   151     {

   152     if ( iCategoryHandlers != NULL )

   153         {

   154         DTraceCoreHandler::PrepareSetWriter( aWriter );

   155         // Delegates the writer to category handlers

   156         DBTraceCategoryHandler* previousHandler = NULL;

   157         for ( TInt i = 0; i < KBTraceCategoryCount; i++ )

   158             {

   159             DBTraceCategoryHandler* handler = iCategoryHandlers[ i ];

   160             if ( handler != NULL && handler != previousHandler )

   161                 {

   162                 handler->PrepareSetWriter( aWriter );

   163                 previousHandler = handler;

   164                 }

   165             }

   166         }

   167     }

   168 

   169 

   170 /**

   171  * Sets the writer to be used for trace output

   172  * 

   173  * @param aWriter Pointer to writer

   174  */       

   175 void DTraceCoreBTraceHandler::SetWriter( DTraceCoreWriter* aWriter )

   176     {

   177     OstTrace1( TRACE_FLOW, DTRACECOREBTRACEHANDLER_SETWRITER_ENTRY, "> DTraceCoreBTraceHandler::SetWriter 0x%x", ( TUint )&( aWriter ) );

   178     if (aWriter)

   179     	{

   180 		OstTrace1( TRACE_INTERNALS, DTRACECOREBTRACEHANDLER_SETWRITER_WRITERTYPE, "Writer type: %d", aWriter->GetWriterType() );

   181 		}

   182     

   183     if ( iCategoryHandlers != NULL )

   184         {

   185         DTraceCoreHandler::SetWriter( aWriter );

   186         // Delegates the writer to category handlers

   187         DBTraceCategoryHandler* previousHandler = NULL;

   188         for ( TInt i = 0; i < KBTraceCategoryCount; i++ )

   189             {

   190             DBTraceCategoryHandler* handler = iCategoryHandlers[ i ];

   191             if ( handler != NULL && handler != previousHandler )

   192                 {

   193                 handler->SetWriter( aWriter );

   194                 previousHandler = handler;

   195                 }

   196             }

   197         }

   198     }

   199 

   200 

   201 /**

   202  * Sets settings

   203  * 

   204  * @param aSettings Pointer to settings

   205  */       

   206 void DTraceCoreBTraceHandler::SetSettings( DTraceCoreSettings* aSettings )

   207     {

   208     OstTrace1( TRACE_FLOW, DTRACECOREBTRACEHANDLER_SETSETTINGS_ENTRY, "> DTraceCoreBTraceHandler::SetSettings 0x%x", ( TUint )&( aSettings ) );

   209     if ( iCategoryHandlers != NULL )

   210         {

   211         DTraceCoreHandler::SetSettings( aSettings );

   212         // Delegates the settings saver to category handlers

   213         DBTraceCategoryHandler* previousHandler = NULL;

   214         for ( TInt i = 0; i < KBTraceCategoryCount; i++ )

   215             {

   216             DBTraceCategoryHandler* handler = iCategoryHandlers[ i ];

   217             if ( handler != NULL && handler != previousHandler )

   218                 {

   219                 handler->SetSettings( aSettings );

   220                 previousHandler = handler;

   221                 }

   222             }

   223         }

   224     }

   225 

   226 

   227 

   228 /**

   229  * Registers a category handler

   230  *

   231  * @param aCategory The category to be processed with the category handler

   232  * @param aHandler The handler which processes the category

   233  */

   234 void DTraceCoreBTraceHandler::RegisterCategoryHandler( TUint8 aCategory, DBTraceCategoryHandler& aHandler )

   235     {

   236     OstTraceExt2( TRACE_FLOW, DTRACECOREBTRACEHANDLER_REGISTERCATEGORYHANDLER_ENTRY, "> DTraceCoreBTraceHandler::RegisterCategoryHandler. ID:0x%x Addr:0x%x", aCategory, ( TUint )&( aHandler ) );

   237     if ( iCategoryHandlers != NULL )

   238         {

   239         iCategoryHandlers[ aCategory ] = &aHandler;

   240 

   241         // BTrace kernel categories are not enabled by default

   242         // MF added - commented out this code

   243 

   244         if ( iWriter != NULL )

   245             {

   246             aHandler.SetWriter( iWriter );

   247             }

   248         if ( iSettings != NULL )

   249             {

   250             aHandler.SetSettings( iSettings );

   251             }

   252         OstTraceExt2( TRACE_NORMAL, DTRACECOREBTRACEHANDLER_REGISTERCATEGORYHANDLER_HANDLER_REGISTERED, "DTraceCoreBTraceHandler::RegisterCategoryHandler - Handler registered. ID:0x%x Addr:0x%x", aCategory, ( TUint )&( aHandler ) );

   253         }

   254     }

   255 

   256 

   257 /**

   258  * Unregisters a category handler

   259  *

   260  * @param aCategory The category to be unregistered

   261  */

   262 void DTraceCoreBTraceHandler::UnregisterCategoryHandler( TUint8 aCategory )

   263     {

   264     OstTrace1( TRACE_FLOW, DTRACECOREBTRACEHANDLER_UNREGISTERCATEGORYHANDLER_ENTRY, "> DTraceCoreBTraceHandler::UnregisterCategoryHandler. ID:0x%x", aCategory );

   265     

   266     // Unregister category handler

   267     if ( iCategoryHandlers != NULL )

   268         {

   269         iCategoryHandlers[ aCategory ] = NULL;

   270         BTrace::SetFilter( aCategory, 0 );

   271         OstTrace1( TRACE_NORMAL, DTRACECOREBTRACEHANDLER_UNREGISTERCATEGORYHANDLER_UNREGISTERED, "DTraceCoreBTraceHandler::UnregisterCategoryHandler - Handler unregistered. ID:0x%x", aCategory );

   272         }

   273     }

   274 

   275 

   276 /**

   277  * Callback function that is registered to BTrace.

   278  * 

   279  * Tracing is not allowed from this method.

   280  *

   281  * @param aHeader BTrace header

   282  * @param aHeader2 Extra header data

   283  * @param aContext The thread context in which this function was called

   284  * @param a1 The first trace parameter

   285  * @param a2 The second trace parameter

   286  * @param a3 The third trace parameter

   287  * @param aExtra Extra trace data

   288  * @param aPc The program counter value

   289  * @return ETrue if trace was processed, EFalse if not

   290  */

   291 TBool DTraceCoreBTraceHandler::BTraceHandlerFunc( TUint32 aHeader, TUint32 aHeader2, const TUint32 aContext, 

   292                                                   const TUint32 a1, const TUint32 a2, const TUint32 a3, 

   293                                                   const TUint32 aExtra, const TUint32 aPc )

   294     {

   295     TBool retval;

   296     DTraceCoreBTraceHandler* handler = DTraceCoreBTraceHandler::iInstance;

   297     if ( handler != NULL && handler->iWriter != NULL )

   298         {

   299         DBTraceCategoryHandler* categoryHandler = handler->GetCategoryHandler( aHeader );

   300         if ( categoryHandler != NULL )

   301             {

   302             retval = categoryHandler->HandleFrame( aHeader, aHeader2, aContext, a1, a2, a3, aExtra, aPc );

   303             }

   304         else

   305             {

   306             retval = EFalse;

   307             }

   308         }

   309     else

   310         {

   311         retval = EFalse;

   312         }

   313     return retval;

   314     }

   315 

   316 

   317 /**

   318  * Gets the category handler for given BTrace header

   319  *

   320  * @param aHeader BTrace header

   321  */

   322 inline DBTraceCategoryHandler* DTraceCoreBTraceHandler::GetCategoryHandler( TUint32 aHeader )

   323     {

   324     __ASSERT_DEBUG( iCategoryHandlers != NULL, Kern::Fault( "DTraceCoreBTraceHandler::GetCategoryHandler - NULL", KErrGeneral ) );

   325     return iCategoryHandlers[ ( aHeader >> ( BTrace::ECategoryIndex * KByteSize ) ) & KByteMask ];

   326     }

   327 

   328 // End of File