1 // Copyright (c) 2005-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 Data parser

    15 //

    16 

    17 #include <e32svr.h>

    18 #include <e32def.h>

    19 #include <e32def_private.h>

    20 #include <e32btrace.h>

    21 

    22 #include "tracedataparser.h"

    23 #include "testdatawriternotifier.h"

    24 #include "tracecoreconstants.h"

    25 #include "d32tracebuffer.h"

    26 

    27 

    28 EXPORT_C TUint32 TTraceDataParser::Swap(TUint32 x)

    29     {

    30     return  (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24);

    31     }

    32 

    33 EXPORT_C TUint32 TTraceDataParser::ReadUint32FromBuf(TUint8*& aBuf, TBool aFromTestWriter)

    34     {

    35 #ifdef __WINS__

    36     aFromTestWriter = EFalse;

    37 #endif

    38     // reads a 4 byte integer of expected endianess

    39     TUint32 n;

    40     if (!aFromTestWriter)

    41         {

    42         n = *(aBuf+3) + (*(aBuf+2) << 8) + (*(aBuf+1) << 16) + (*aBuf << 24);

    43         }

    44     else

    45         {

    46         // endianess order is reversed for TestWriter on hw

    47         n = (*aBuf) + (*(aBuf+1) << 8) + (*(aBuf+2) << 16) + (*(aBuf+3) << 24);    

    48         }

    49     aBuf += sizeof(TUint32);

    50     return n;

    51     }

    52 

    53 EXPORT_C TUint16 TTraceDataParser::ReadUint16FromBuf(TUint8*& aBuf)

    54     {

    55     // reads a 2 byte integer of expected endianess

    56     TUint16 n = (*aBuf << 8)+ (*(aBuf+1));

    57     aBuf += sizeof(TUint16);

    58     return n;

    59     }

    60 

    61 TPtr8 TTraceDataParser::ReadTracePrintf(TUint8* aData, TInt aSize)

    62     {

    63     TPtr8 printfString(aData, aSize, aSize);

    64     TInt endPosition = printfString.Locate(TChar(0));

    65     if (endPosition >= 0)

    66         {

    67         printfString = printfString.Left(endPosition);

    68         }

    69     else

    70         {

    71         printfString.Trim();

    72         }

    73     return printfString;

    74     }

    75 

    76 TBool TTraceDataParser::StringsMatch(const TDesC8& aString1, const TDesC8& aString2)

    77     {

    78     TInt compareLength = (aString1.Length() > aString2.Length()) ? aString2.Length() : aString1.Length();

    79     if ( (aString2.Left(compareLength).Compare(aString1) == 0) ||

    80          (aString1.Left(compareLength).Compare(aString2) == 0) )

    81         {

    82         return ETrue;

    83         }

    84     return EFalse;

    85     }

    86 

    87 /**

    88  * Function to string for a number

    89  * @param aBuffer Trace data descriptor

    90  * @param aFindStringPattern Pattern that indicates where in the string the number will be, using an asterisk

    91  * @param aNumberFound If found, the number in the string

    92  * @return Symbian error code

    93  */

    94 TInt TTraceDataParser::ParseStringForNumber(const TDesC8& aBuffer, const TDesC8& aFindStringPattern, TInt& aNumberFound)

    95     {

    96     TInt err = KErrNotFound;

    97     TInt posOfNum = aFindStringPattern.Locate('*');

    98     TInt lengthOfNum = 1 + aBuffer.Length() - aFindStringPattern.Length();

    99     if (posOfNum >= 0 && lengthOfNum >= 1)

   100         {

   101         TBuf<KMaxNumberBufferLength> numberBuffer;

   102         numberBuffer.Copy(aBuffer.Mid(posOfNum, lengthOfNum));

   103         TLex lex(numberBuffer);

   104         err = lex.Val(aNumberFound);

   105         }

   106     return err;

   107     }

   108 

   109 /*

   110  * Validate the trace data in buffer

   111  *

   112  * @param aBuffer the buffer containing the trace data

   113  * @param aExpectedNum expected number of traces

   114  * @param aComponentID component ID of traces

   115  * @param aGroupID group ID of traces

   116  * @param aData first expected trace data

   117  * @param aTraceWord trace word of traces

   118  * @param aIdentical indicates that the payload of each trace packet should be identical

   119  * @param aBufferMode The mode of the trace buffer.. 0=straight, 1=circular.

   120  * @param aOrdinalData indicates whether the payload data reflects its position in the stream of trace packets

   121  * @param aNumTraces number of traces written to circular buffer

   122  * @param aMaxTraces maximum number of traces circular buffer can hold

   123  * @return Standard Symbian error code

   124  */

   125 EXPORT_C TInt TTraceDataParser::ValidatePayload(TDesC8&         aBuffer,

   126                                                 TInt            aExpectedNum,

   127                                                 TComponentId    aComponentID, 

   128                                                 TGroupId        aGroupID, 

   129                                                 TUint32         aData, 

   130                                                 TUint32         aTraceWord,

   131                                                 TBool           aIdentical, 

   132                                                 TInt            aBufferMode, 

   133                                                 TBool           aOrdinalData, 

   134                                                 TInt            aNumTraces, 

   135                                                 TInt            aMaxTraces)

   136     {

   137     if ((aBuffer.Length() == 0) && (aExpectedNum <= 0))    // size is zero and there should be no traces

   138         {

   139         return KErrNone;

   140         }

   141     if ((aBuffer.Length() == 0) && (aExpectedNum > 0))     // size is zero and there should be traces

   142         {

   143         return KErrCorrupt;

   144         }

   145     if (aBuffer.Length() != 0 && (aExpectedNum <= 0))      // size is non-zero and there should be no traces

   146         {

   147         return KErrCorrupt;

   148         }

   149 

   150     TUint32 lastData = aData;

   151     TBool firstInStream = ETrue;

   152 

   153     // get the current position on the stream of traces so we can determine what the payload value should be.

   154     TInt overwrites = 0;

   155     if (aBufferMode == RTraceBuffer::EFreeRunning)

   156         {

   157         TInt overwrittenTraces = aNumTraces; // initialise to number of traces we wrote to the buffer for circular test

   158         while (overwrittenTraces > aMaxTraces)

   159             {

   160             overwrittenTraces = overwrittenTraces - aMaxTraces; // aMaxTraces is the max the buffer can hold 

   161             overwrites++;

   162             }

   163         lastData = (aMaxTraces * (overwrites - 1)) + overwrittenTraces + 1; // get where we are in the buffer

   164         }

   165 

   166     TInt            numberOSTtraces = 0;

   167     TUint8*         data            = (TUint8*) aBuffer.Ptr();

   168     TUint8*         endOfData       = data + aBuffer.Size();    

   169     TUint8          testGID         = aGroupID;

   170     TUint32         testCID         = aComponentID;

   171     TUint32         testTraceWord   = 0;

   172 

   173     TTraceHeaderSettings  traceHeaderSettings;

   174 

   175     // Loop through all traces

   176     while (data < endOfData)

   177         {

   178         // Get trace info from header

   179         TInt err = ParseHeader(data, endOfData-data, traceHeaderSettings);

   180         

   181         if (err != KErrNone)

   182             {

   183             return err;

   184             }

   185 

   186         //check the missing flag if we expect it

   187         if ((firstInStream&&(overwrites>0)))

   188             {

   189             if(!(traceHeaderSettings.iHeaderFlags & BTrace::EMissingRecord))

   190                 {

   191                 return KErrCorrupt;

   192                 }

   193             }

   194 

   195         if (!traceHeaderSettings.iPrintfTrace)

   196             {

   197             testTraceWord = ((TUint32) (testGID << GROUPIDSHIFT)) + 1;

   198             

   199             // check group ID

   200             if (traceHeaderSettings.iCategory != testGID)

   201                 {

   202                 return KErrCorrupt;

   203                 }

   204             // check component ID

   205             if (traceHeaderSettings.iComponentID != testCID)

   206                 {

   207                 return KErrCorrupt;

   208                 }

   209             // check trace word

   210             if (traceHeaderSettings.iTraceWord != testTraceWord)

   211                 {

   212                 return KErrCorrupt;

   213                 }

   214             

   215             TBool lastTrace = EFalse;

   216             if ( (traceHeaderSettings.iMultiPartType == BTrace::EMultipartLast) || (!traceHeaderSettings.iMultiPartType) )

   217                 {

   218                 lastTrace = ETrue;

   219                 }

   220 

   221             // check trace payload

   222             for (TInt i=0; traceHeaderSettings.iLengthOfPayload>0; i++)

   223                 {

   224                 TUint32 param = Swap(ReadUint32FromBuf(data, traceHeaderSettings.iFromTestWriter));

   225                 // For circular case, we try to estimate to within +/- 2 where we are in payload

   226                 // for straight case we should get it exactly correct.

   227                 if ( ((param != lastData) && (aBufferMode == 0)) || 

   228                       ( ((param > lastData + 2) || (param < lastData - 2)) && (aBufferMode == RTraceBuffer::EFreeRunning) ) )

   229                     {

   230                     return KErrCorrupt;

   231                     }

   232                 lastData = param; // in case we weren't accurate in circular case.

   233                 traceHeaderSettings.iLengthOfPayload -= 4;

   234                 lastData++;

   235                 }

   236             lastData = (!aOrdinalData)? aData : lastData;

   237             if (!aOrdinalData)

   238                 {

   239                 lastData = (lastTrace || aIdentical) ? aData : lastData;

   240                 }

   241 

   242             if (traceHeaderSettings.iMultiPartType || aIdentical || aOrdinalData)

   243                 {

   244                 testGID = aGroupID;

   245                 testCID = aComponentID;

   246                 testTraceWord = aTraceWord;

   247                 }

   248             else

   249                 {

   250                 testGID++;

   251                 testCID++;

   252                 testTraceWord += (1 << GROUPIDSHIFT);

   253                 }

   254             numberOSTtraces++;

   255             }

   256         else

   257             {

   258             // Go to the next trace

   259             data += traceHeaderSettings.iLengthOfPayload;

   260             }

   261         firstInStream = EFalse; //after this, it's defnitely not the first trace in the stream.

   262         }

   263 

   264     // Check that we're getting the correct number of traces

   265     //or approximate ammount (+/-1) for circular buffer because

   266     //the arithmetic to overwrite traces sometimes also skips one

   267     //extra trace

   268 

   269     if (numberOSTtraces != aExpectedNum)

   270         {

   271         if ((aBufferMode==RTraceBuffer::EFreeRunning)

   272                 &&((numberOSTtraces>=aExpectedNum-1)||(numberOSTtraces<=aExpectedNum+1)))

   273             {

   274             return KErrNone;

   275             }

   276         return KErrCorrupt;

   277         }

   278 

   279     return KErrNone;

   280     }

   281 

   282 /*

   283  * Validate the single trace data in buffer

   284  * 

   285  * @param aBuffer the buffer containing the trace data

   286  * @param aTracePresent determines if trace data should be present or not

   287  * @param aGroupID expected GID

   288  * @param aComponentID expected CID

   289  * @param aData expected trace data

   290  * @param aPrintfTrace determines if trace data should be printf data or not

   291  * @param aMissingTrace determines if trace data should indicate missing data or not

   292  * @param aExpectedPrintfTrace expected printf trace data

   293  * @return Standard Symbian error code

   294  */

   295 EXPORT_C TInt TTraceDataParser::ValidatePayload(TDesC8&        aBuffer, 

   296                                                 TBool          aTracePresent, 

   297                                                 TGroupId       aGroupID, 

   298                                                 TComponentId   aComponentID, 

   299                                                 TUint32        aData,

   300                                                 TBool          aPrintfTrace,

   301                                                 TBool          aMissingTrace,

   302                                                 TDesC8*        aExpectedPrintfTrace)

   303     {

   304     if ((aBuffer.Length() == 0) && (!aTracePresent))    // size is zero and there should be no traces

   305         {

   306         return KErrNone;

   307         }

   308     if ((aBuffer.Length() == 0) && (aTracePresent))     // size is zero and there should be traces

   309         {

   310         return KErrCorrupt;

   311         }

   312     if (aBuffer.Length() != 0 && (!aTracePresent))      // size is non-zero and there should be no traces

   313         {

   314         return KErrCorrupt;

   315         }

   316 

   317     TUint8*         data            = (TUint8*) aBuffer.Ptr();

   318     TUint8*         endOfData       = data + aBuffer.Size();    

   319 

   320     TTraceHeaderSettings  traceHeaderSettings;

   321 

   322     // Get trace info from header

   323     TInt err = ParseHeader(data, endOfData-data, traceHeaderSettings);

   324     

   325     if (err != KErrNone)

   326         {

   327         return err;

   328         }

   329 

   330     // check trace type

   331     if (traceHeaderSettings.iPrintfTrace != aPrintfTrace)

   332         {

   333         return KErrCorrupt;

   334         }

   335 

   336     if (!traceHeaderSettings.iPrintfTrace)

   337         {

   338         TUint32 testTraceWord = ((TUint32) (aGroupID << GROUPIDSHIFT)) + 1;

   339         

   340         // check group ID

   341         if (traceHeaderSettings.iCategory != aGroupID)

   342             {

   343             return KErrCorrupt;

   344             }

   345         // check component ID

   346         if (traceHeaderSettings.iComponentID != aComponentID)

   347             {

   348             return KErrCorrupt;

   349             }

   350         // check trace word

   351         if (traceHeaderSettings.iTraceWord != testTraceWord)

   352             {

   353             return KErrCorrupt;

   354             }

   355         

   356         if (aMissingTrace)

   357             {

   358             // check missing flag

   359             if (!(traceHeaderSettings.iHeaderFlags & BTrace::EMissingRecord))

   360                 {

   361                 return KErrCorrupt;

   362                 }

   363             }

   364         

   365         TInt i = 0;

   366         while (data < endOfData)

   367             {

   368             TUint32 param = Swap(ReadUint32FromBuf(data, traceHeaderSettings.iFromTestWriter));

   369             if (param != aData + i)

   370                 {

   371                 return KErrCorrupt;

   372                 }

   373             i++;

   374             }

   375         }

   376     else if (!aExpectedPrintfTrace)

   377         {

   378         return KErrArgument;

   379         }

   380     else

   381         {

   382         TBuf8<KExpectedPrintfMaxLength> expectedPrintf;

   383         

   384         // In the case of an expected dropped trace, we only check for "* Dropped Trace" because

   385         // the test writer has completed the request for data when it writes that bit first (right 

   386         // before the next trace), and when it goes to write the actual trace, it doesn't.

   387         // If we change this, the "* Dropped Trace" will be overwritten by the actual trace before

   388         // the test can check it, since the test writer doesn't buffer trace data.

   389         if (aMissingTrace)

   390             {

   391             // check that "* Dropped Trace" is in the buffer

   392             expectedPrintf = KDroppedTrace;

   393             }

   394         else

   395             {

   396             // check that "Test Printf Trace" is in the buffer"

   397             expectedPrintf = *aExpectedPrintfTrace;

   398             }

   399         

   400         expectedPrintf.Append(TChar(0)); // printf handler appends null at the end.

   401 

   402         TPtrC8 actualprintf(data, traceHeaderSettings.iLengthOfPayload);

   403 

   404         // Need to fix endianess for hw

   405 #ifndef __WINS__

   406         TInt bufpos = 0;

   407         while (bufpos < (actualprintf.Length()-4))

   408             {

   409             // reads a 4 byte integer of expected endianess

   410             TUint32 n = actualprintf[bufpos] + (actualprintf[bufpos+1] << 8) + (actualprintf[bufpos+2] << 16) + (actualprintf[bufpos+3] << 24);

   411             bufpos += sizeof(TUint32);

   412             TUint32 tempData = Swap(n);

   413             memcpy((TAny*)(actualprintf.Ptr()+bufpos-4),(TAny*)&tempData, sizeof(TUint32));

   414             }        

   415 #endif //__WINS__

   416         

   417         if (expectedPrintf.Compare(actualprintf) != 0)

   418             {

   419             return KErrCorrupt;

   420             }

   421 

   422         // Check if there is another trace to follow

   423         data += traceHeaderSettings.iLengthOfPayload;

   424         if (data != endOfData)

   425             {

   426             TPtrC8 buffer(data, endOfData - data);

   427             

   428             return ValidatePayload(buffer, 

   429                                    aTracePresent, 

   430                                    aGroupID, 

   431                                    aComponentID, 

   432                                    aData,

   433                                    aPrintfTrace,

   434                                    EFalse,

   435                                    aExpectedPrintfTrace);

   436             }

   437         }    

   438     return KErrNone;

   439     }

   440 

   441 /*

   442  * Verify the priming data contains all the expected values

   443  *

   444  * @param aBuffer Buffer containing the trace data

   445  * @param aSize Size of the trace buffer

   446  * @param aCategory BTrace category of the trace data

   447  * @param aSubCategory BTrace subcategory of the trace data

   448  * @param aElementsFound Parameter to hold current state of expected data found so far

   449  * @param aVerificationData1 Optional input value - used differently for different categories

   450  * @param aVerificationData2 Optional input value - used differently for different categories

   451  * @return Standard Symbian error code

   452  */

   453 TInt TTraceDataParser::VerifyPrimingData(TUint8* aBuffer, 

   454                                          TInt    aSize, 

   455                                          TUint8  aCategory, 

   456                                          TUint8  aSubCategory, 

   457                                          TInt&   aElementsFound,

   458                                          TBool   aFromTestWriter, 

   459                                          TUint32 aVerificationData1, 

   460                                          TUint32 aVerificationData2)

   461     {

   462     TInt err = KErrNotSupported;

   463     switch(aCategory)

   464         {

   465         case BTrace::EThreadIdentification:

   466             err = VerifyThreadPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter, aVerificationData1, aVerificationData2);

   467             break;

   468         case BTrace::EFastMutex:

   469             err = VerifyFastMutexPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter);

   470             break;

   471         case BTrace::ECodeSegs:

   472             err = VerifyCodeSegsPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter, aVerificationData1, aVerificationData2);

   473             break;

   474         default:

   475             break;

   476         }

   477     return err;    

   478     }

   479 

   480 /*

   481  * Verify the EThreadIdentification priming data contains all the expected values

   482  *

   483  * @param aBuffer Buffer containing the trace data

   484  * @param aSize Size of the trace buffer

   485  * @param aSubCategory BTrace subcategory of the trace data

   486  * @param aElementsFound Parameter to hold current state of expected data found so far

   487  * @param aThreadAddr The address of the thread to search for

   488  * @param aProcessAddr The address of the process to search for

   489  * @return Standard Symbian error code

   490  */

   491 TInt TTraceDataParser::VerifyThreadPrimingData(TUint8* aBuffer, 

   492                                                TInt    aSize, 

   493                                                TUint8  aSubCategory, 

   494                                                TInt&   aElementsFound,

   495                                                TBool   aFromTestWriter, 

   496                                                TUint32 aThreadAddr, 

   497                                                TUint32 aProcessAddr)

   498     {

   499     RThread currentThread;    

   500     RProcess currentProcess;

   501 

   502     TUint32 tempThreadAddr;

   503     TUint32 tempProcessAddr;

   504     

   505     switch(aSubCategory)

   506         {

   507         case BTrace::EProcessCreate:

   508             {

   509             tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   510             if (tempProcessAddr == aProcessAddr)

   511                 {

   512                 aElementsFound |= 0x000000ff;

   513                 }

   514             }

   515             break;

   516             

   517         case BTrace::EProcessName:

   518             {

   519             tempThreadAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   520             tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   521             if ( (tempThreadAddr == aThreadAddr) && (tempProcessAddr == aProcessAddr) )

   522                 {

   523                 TBuf8<KMaxName> currentProcessName;

   524                 currentProcessName.Copy(currentProcess.Name());

   525                 TPtr8 processName(aBuffer,(aSize-8),(aSize-8)); //should be name of the process

   526                 processName.Trim();

   527                 if (StringsMatch(currentProcessName, processName))

   528                     {

   529                     aElementsFound |= 0x0000ff00;

   530                     }

   531                 }

   532             }

   533             break;

   534         

   535         case BTrace::EThreadName:

   536             {

   537             tempThreadAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   538             tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   539             if ( (tempThreadAddr == aThreadAddr) && (tempProcessAddr == aProcessAddr) )

   540                 {

   541                 TBuf8<KMaxName> currentThreadName;

   542                 currentThreadName.Copy(currentThread.Name());

   543                 TPtr8 threadName(aBuffer,(aSize-8),(aSize-8)); //should be name of the thread

   544                 threadName.Trim();

   545                 if (StringsMatch(currentThreadName, threadName))

   546                     {

   547                     aElementsFound |= 0x00ff0000;

   548                     }

   549                 }

   550             }

   551             break;

   552             

   553         case BTrace::EThreadId:

   554             {

   555             tempThreadAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   556             tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   557             if ( (tempThreadAddr == aThreadAddr) && (tempProcessAddr == aProcessAddr) )

   558                 {

   559                 TThreadId threadId = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   560                 if (currentThread.Id() == threadId)

   561                     {

   562                     aElementsFound |= 0xff000000;

   563                     }

   564                 }

   565             }

   566             break; 

   567             

   568         default:

   569             break;

   570         }

   571     

   572     TInt err = KErrNotFound;

   573     if (aElementsFound == 0xffffffff)

   574         {

   575         err = KErrNone;

   576         }

   577     return err;

   578     }

   579 

   580 /*

   581  * Verify the EFastMutex priming data contains all the expected values

   582  *

   583  * @param aBuffer Buffer containing the trace data

   584  * @param aSize Size of the trace buffer

   585  * @param aSubCategory BTrace subcategory of the trace data

   586  * @param aElementsFound Parameter to hold current state of expected data found so far

   587  * @return Standard Symbian error code

   588  */

   589 TInt TTraceDataParser::VerifyFastMutexPrimingData(TUint8* aBuffer, 

   590                                                   TInt    aSize, 

   591                                                   TUint8  aSubCategory, 

   592                                                   TInt&   aElementsFound,

   593                                                   TBool   aFromTestWriter)

   594     {

   595     if (aSubCategory == BTrace::EFastMutexName)

   596         {

   597         TUint32 fastMutexId = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   598         TUint32 unspecified = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   599         if (fastMutexId && !unspecified)

   600             {

   601             TPtr8 fastMutexName(aBuffer,(aSize-8),(aSize-8)); //should be name of the fast mutex

   602             fastMutexName.Trim();

   603             if (StringsMatch(KFastMutexNameSystemLock(), fastMutexName))

   604                 {

   605                 aElementsFound |= 0x000000ff;

   606                 }

   607             else if (StringsMatch(KFastMutexNameMsgLock(), fastMutexName))

   608                 {

   609                 aElementsFound |= 0x0000ff00;

   610                 }

   611             else if (StringsMatch(KFastMutexNameObjLock(), fastMutexName))

   612                 {

   613                 aElementsFound |= 0x00ff0000;

   614                 }

   615             else if (StringsMatch(KFastMutexNameLogonLock(), fastMutexName))

   616                 {

   617                 aElementsFound |= 0xff000000;

   618                 }

   619             }

   620         }

   621     

   622     TInt err = KErrNotFound;

   623     if (aElementsFound == 0xffffffff)

   624         {

   625         err = KErrNone;

   626         }

   627     return err;

   628     }

   629 

   630 /*

   631  * Verify the ECodeSegs priming data contains all the expected values

   632  *

   633  * @param aBuffer Buffer containing the trace data

   634  * @param aSize Size of the trace buffer

   635  * @param aSubCategory BTrace subcategory of the trace data

   636  * @param aElementsFound Parameter to hold current state of expected data found so far

   637  * @param aSegAddr1 The address of the first code seg to search for

   638  * @param aSegAddr2 The address of the second code seg to search for

   639  * @return Standard Symbian error code

   640  */

   641 TInt TTraceDataParser::VerifyCodeSegsPrimingData(TUint8* aBuffer, 

   642                                                  TInt    aSize, 

   643                                                  TUint8  aSubCategory, 

   644                                                  TInt&   aElementsFound,

   645                                                  TBool   aFromTestWriter, 

   646                                                  TUint32 aSegAddr1, 

   647                                                  TUint32 aSegAddr2)

   648     {

   649     TUint32 codeSegAddr;

   650     if (aSubCategory == BTrace::ECodeSegCreated)

   651         {

   652         codeSegAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   653         if (codeSegAddr == aSegAddr1 || codeSegAddr == aSegAddr2)

   654             {

   655             TPtr8 codeSegName(aBuffer,(aSize-4),(aSize-4)); //should be name of the code seg

   656             codeSegName.Trim();

   657             if (codeSegAddr == aSegAddr1 && StringsMatch(KCodeSegsName1(), codeSegName))

   658                 {

   659                 aElementsFound |= 0x000000ff;

   660                 }

   661             else if (codeSegAddr == aSegAddr2 && StringsMatch(KCodeSegsName2(), codeSegName))

   662                 {

   663                 aElementsFound |= 0x0000ff00;

   664                 }

   665             }

   666         }

   667     else if (aSubCategory == BTrace::ECodeSegInfo)

   668         {

   669         codeSegAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

   670         if (codeSegAddr == aSegAddr1)

   671             {

   672             aElementsFound |= 0x00ff0000;

   673             }

   674         else if (codeSegAddr == aSegAddr2)

   675             {

   676             aElementsFound |= 0xff000000;

   677             }

   678         }

   679     

   680     TInt err = KErrNotFound;

   681     if (aElementsFound == 0xffffffff)

   682         {

   683         err = KErrNone;

   684         }

   685     return err;

   686     }

   687 

   688 /*

   689  * Work out if a trace point is potentially kernel priming data based on category and subcategory

   690  *

   691  * @param aCategory BTrace category of the trace data

   692  * @param aSubCategory BTrace subcategory of the trace data

   693  * @param aIsPotentialPrimingTrace Output value set if there is no error

   694  * @return Standard Symbian error code

   695  */

   696 TBool TTraceDataParser::IsPotentialPrimingTrace(TUint8 aCategory, TUint8 aSubCategory, TBool& aIsPotentialPrimingTrace)

   697     {

   698     TInt err = KErrNone;

   699     

   700     switch(aCategory)

   701         {

   702         case BTrace::EThreadIdentification:

   703             {

   704             switch(aSubCategory)

   705                 {

   706                 case BTrace::EProcessCreate:

   707                 case BTrace::EProcessName:

   708                 case BTrace::EThreadName:

   709                 case BTrace::EThreadId:

   710                     aIsPotentialPrimingTrace = ETrue;

   711                     break;

   712                 default:

   713                     aIsPotentialPrimingTrace = EFalse;

   714                     break;

   715                 }

   716             }

   717             break;

   718         case BTrace::ECpuUsage:

   719             {

   720             switch(aSubCategory)

   721                 {

   722                 case BTrace::ENewThreadContext:

   723                     aIsPotentialPrimingTrace = ETrue;

   724                     break;

   725                 default:

   726                     aIsPotentialPrimingTrace = EFalse;

   727                     break;

   728                 }

   729             }

   730             break;

   731         case BTrace::EChunks:

   732             {

   733             switch(aSubCategory)

   734                 {

   735                 case BTrace::EChunkCreated:

   736                 case BTrace::EChunkOwner:

   737                 case BTrace::EChunkInfo:

   738                     aIsPotentialPrimingTrace = ETrue;

   739                     break;

   740                 default:

   741                     aIsPotentialPrimingTrace = EFalse;

   742                     break;

   743                 }

   744             }

   745             break;

   746         case BTrace::ECodeSegs:

   747             {

   748             switch(aSubCategory)

   749                 {

   750                 case BTrace::ECodeSegCreated:

   751                 case BTrace::ECodeSegInfo:

   752                     aIsPotentialPrimingTrace = ETrue;

   753                     break;

   754                 default:

   755                     aIsPotentialPrimingTrace = EFalse;

   756                     break;

   757                 }

   758             }

   759             break;

   760         case BTrace::EPaging:

   761             {

   762             switch(aSubCategory)

   763                 {

   764                 case BTrace::EPagingMemoryModel:

   765                     aIsPotentialPrimingTrace = ETrue;

   766                     break;

   767                 default:

   768                     aIsPotentialPrimingTrace = EFalse;

   769                     break;

   770                 }

   771             }

   772             break;

   773         case BTrace::EThreadPriority:

   774             {

   775             switch(aSubCategory)

   776                 {

   777                 case BTrace::EProcessPriority:

   778                 case BTrace::EDThreadPriority:

   779                 case BTrace::ENThreadPriority:

   780                     aIsPotentialPrimingTrace = ETrue;

   781                     break;

   782                 default:

   783                     aIsPotentialPrimingTrace = EFalse;

   784                     break;

   785                 }

   786             }

   787             break;

   788         case BTrace::EFastMutex:

   789             {

   790             switch(aSubCategory)

   791                 {

   792                 case BTrace::EFastMutexName:

   793                     aIsPotentialPrimingTrace = ETrue;

   794                     break;

   795                 default:

   796                     aIsPotentialPrimingTrace = EFalse;

   797                     break;

   798                 }

   799             }

   800             break;

   801         case BTrace::ESymbianKernelSync:

   802             {

   803             switch(aSubCategory)

   804                 {

   805                 case BTrace::EMutexCreate:

   806                 case BTrace::ESemaphoreCreate:

   807                 case BTrace::ECondVarCreate:

   808                     aIsPotentialPrimingTrace = ETrue;

   809                     break;

   810                 default:

   811                     aIsPotentialPrimingTrace = EFalse;

   812                     break;

   813                 }

   814             }

   815             break;

   816         case BTrace::EClientServer:

   817             {

   818             switch(aSubCategory)

   819                 {

   820                 case BTrace::EServerCreate:

   821                 case BTrace::ESessionAttach:

   822                     aIsPotentialPrimingTrace = ETrue;

   823                     break;

   824                 default:

   825                     aIsPotentialPrimingTrace = EFalse;

   826                     break;

   827                 }

   828             }

   829             break;

   830         default:

   831             err = KErrNotSupported;

   832             break;

   833         }

   834     

   835     return err;

   836     }

   837 

   838 /*

   839  * If the next trace is a meta trace true is returned if it is the start of priming data for a given group ID

   840  *

   841  * @param aBuffer Buffer containing the trace data

   842  * @param aGroupId Group ID of kernel priming data

   843  * @param aCategory BTrace category of the current trace

   844  * @param aSubCategory BTrace subcategory of the current trace

   845  * @return True if start of priming data for given group ID, false otherwise

   846  */

   847 TBool TTraceDataParser::IsStartOfKernelPrimingBatch(TUint8* aBuffer, TGroupId aGroupId, TUint8 aCategory, TUint8 aSubCategory)

   848     {

   849     TBool startOfBatch = EFalse;

   850     if (aCategory == BTrace::EMetaTrace)

   851         {

   852         if (aSubCategory == BTrace::EMetaTraceFilterChange)

   853             {

   854             TUint8 metaCategory = aBuffer[0];

   855             TUint8 isActive = aBuffer[1];

   856             if (metaCategory == aGroupId && isActive)

   857                 {

   858                 startOfBatch = ETrue;

   859                 }

   860             }        

   861         }

   862     return startOfBatch;

   863     }

   864 

   865 /*

   866  * Use heuristics to work out if current trace is part of kernel priming data

   867  *

   868  * @param aCategory BTrace category of the trace data

   869  * @param aSubCategory BTrace subcategory of the trace data

   870  * @param aTimeDifference Time difference (in microseconds) since last trace for given category

   871  * @param aIsInPrimingBatch Output parameter set to true if in priming data

   872  * @param aFirstTrace Boolean used to indicate if this is first trace (so there is no valid time difference)

   873  * @param aStartOfBatch Output parameter set to true if start of batch of kernel priming data

   874  * @return Standard Symbian error code

   875  */

   876 TInt TTraceDataParser::IsInPrimingBatch(TUint8  aCategory, 

   877                                         TUint8  aSubCategory, 

   878                                         TUint32 aTimeDifference, 

   879                                         TBool&  aIsInPrimingBatch, 

   880                                         TBool&  aFirstTrace, 

   881                                         TBool&  aStartOfBatch)

   882     {

   883     TBool isPotentialPrimingTrace = EFalse;

   884     TInt err = IsPotentialPrimingTrace(aCategory, aSubCategory, isPotentialPrimingTrace);

   885     

   886     // Look at timestamp to see if this is a new batch of traces

   887     if (aFirstTrace)

   888         {

   889         aFirstTrace = EFalse;

   890         }

   891     else if (aTimeDifference > KMinMilliSecondsBatchGap * 1000)

   892         {

   893         aStartOfBatch = ETrue;

   894         aIsInPrimingBatch = EFalse;

   895         }

   896     else

   897         {

   898         aStartOfBatch = EFalse;

   899         }

   900     

   901     if (isPotentialPrimingTrace && aStartOfBatch)

   902         {

   903         aIsInPrimingBatch = ETrue;

   904         aStartOfBatch = EFalse;

   905         }

   906     else if (!isPotentialPrimingTrace)

   907         {

   908         aIsInPrimingBatch = EFalse;

   909         }

   910     

   911     return err;

   912     }

   913 

   914 /*

   915  * Parse the trace data header

   916  * 

   917  * The following trace types are supported:

   918  *     OST traces (ascii and binary)

   919  *     XTIv3 traces (ascii and binary)

   920  *     Traces from the Test Writer (ascii and binary)

   921  *

   922  * @param aData Buffer containing the trace data

   923  * @param aSize Size of trace data buffer

   924  * @param aTraceHeaderSettings Output parameters set to header settings of the trace data

   925  * @return Standard Symbian error code

   926  */

   927 TInt TTraceDataParser::ParseHeader(TUint8*&                 aData, 

   928                                    TInt                     aSize, 

   929                                    TTraceHeaderSettings&    aTraceHeaderSettings)

   930     {

   931     // Check buffer is large enough to contain header

   932     aSize--;

   933     if (aSize < 0)

   934         {

   935         return KErrOverflow;

   936         }

   937     

   938     TInt err = KErrNone;    

   939     TUint8* startOfData = aData;

   940     aTraceHeaderSettings.iMultiPartType = 0;

   941     aTraceHeaderSettings.iMultiPartTraceID = 0;

   942     aTraceHeaderSettings.iPrintfTrace = EFalse;

   943     aTraceHeaderSettings.iHeaderFlags = EFalse;

   944     aTraceHeaderSettings.iFromTestWriter = EFalse;

   945     TBool xtiTrace = EFalse;

   946     TUint8 version = aData[0];                        // Version (1 byte)

   947     aData++;

   948     

   949     if (version == KXtiHeaderVersion)

   950         {

   951         // Check buffer is large enough to contain header

   952         aSize -= KMinSizeXtiHeader;

   953         if (aSize < 0)

   954             {

   955             aData = startOfData;

   956             return KErrOverflow;

   957             }

   958         xtiTrace = ETrue;

   959         TUint8 xtiTraceType = aData[KXtiTraceTypeIndex-1];

   960         if (xtiTraceType != KXtiProtocolIdSimpleTrace)

   961             {

   962             aTraceHeaderSettings.iPrintfTrace = ETrue;

   963             aTraceHeaderSettings.iLengthOfPayload = aData[KXtiLengthIndex-1] - 15;

   964             aData += KMinSizeXtiHeader;

   965             }

   966         else

   967             {

   968             // Check buffer is large enough to contain header

   969             aSize -= 1;

   970             if (aSize < 0)

   971                 {

   972                 aData = startOfData;

   973                 return KErrOverflow;

   974                 }

   975             // Jump to start of OST buffer

   976             aData += KMinSizeXtiHeader + 1;

   977             version = aData[0];

   978             aData++;

   979             }

   980         }

   981     

   982     if (version == KHeaderVersion) // Ost header version byte is correct

   983         {

   984         // Check buffer is large enough to contain header

   985         aSize -= KMinSizeOstHeader;

   986         if (aSize < 0)

   987             {

   988             aData = startOfData;

   989             return KErrOverflow;

   990             }

   991         const TUint8 protocolId = aData[0];                 // Protocol ID (1 byte)

   992         aData++;

   993         if (xtiTrace)

   994             {

   995             aTraceHeaderSettings.iLengthOfPayload = aData[0];

   996             aData++;

   997             aSize++;

   998             }

   999         else

  1000             {

  1001             aTraceHeaderSettings.iLengthOfPayload = ReadUint16FromBuf(aData);        // Size (2 bytes)

  1002             }

  1003     

  1004         if (protocolId == KProtocolIdSimpleTrace) // Normal binary data

  1005             {

  1006             // Check buffer is large enough to contain header

  1007             aSize -= KMinSizeOstBinaryHeader;

  1008             if (aSize < 0)

  1009                 {

  1010                 aData = startOfData;

  1011                 return KErrOverflow;

  1012                 }

  1013             ReadUint32FromBuf(aData);                       // Timestamp 1 (4 bytes)

  1014             aTraceHeaderSettings.iTimestamp = ReadUint32FromBuf(aData);          // Timestamp 2 (4 bytes)

  1015             }

  1016         else if (protocolId == KProtocolIdAscii) // Ascii Printf data

  1017             {

  1018             aTraceHeaderSettings.iPrintfTrace = ETrue;

  1019             // Check buffer is large enough to contain header

  1020             aSize -= KMinSizeOstAsciiHeader;

  1021             if (aSize < 0)

  1022                 {

  1023                 aData = startOfData;

  1024                 return KErrOverflow;

  1025                 }

  1026             aData += 8;

  1027             aTraceHeaderSettings.iLengthOfPayload -= 8;

  1028             }

  1029         else // Protocol ID is incorrect

  1030             {

  1031             err = KErrCorrupt;

  1032             }

  1033         }

  1034     else if (version == SYMBIAN_TRACE) // Trace data is binary data from Test Writer

  1035         {

  1036         aTraceHeaderSettings.iFromTestWriter = ETrue;

  1037         }

  1038     else if (version == PRINTF_TRACE) // Trace data is ascii data from Test Writer

  1039         {

  1040         aTraceHeaderSettings.iFromTestWriter = ETrue;

  1041         aTraceHeaderSettings.iPrintfTrace = ETrue;

  1042         // The end of the printf trace data will have null char, so use that to find end of payload

  1043         TPtr8 printfString(aData, aSize, aSize);

  1044         aTraceHeaderSettings.iLengthOfPayload = printfString.Locate(TChar(0));

  1045         if (aTraceHeaderSettings.iLengthOfPayload >= 0)

  1046             {

  1047             aTraceHeaderSettings.iLengthOfPayload++;

  1048             }

  1049         else

  1050             {

  1051             err = KErrCorrupt;

  1052             }

  1053         }

  1054     else if (version != KXtiHeaderVersion)

  1055         {

  1056         err = KErrCorrupt;

  1057         

  1058         if(aTraceHeaderSettings.iLengthOfPayload < 0 )

  1059             {

  1060             err = KErrOverflow;

  1061             }

  1062         }

  1063               

  1064     if (aTraceHeaderSettings.iPrintfTrace)

  1065         {

  1066         aTraceHeaderSettings.iTimestamp = 0;

  1067         aTraceHeaderSettings.iComponentID = 0;

  1068         aTraceHeaderSettings.iCategory = 0;

  1069         aTraceHeaderSettings.iSubCategory = 0;

  1070         aTraceHeaderSettings.iTraceWord = 0;

  1071         }

  1072     else if (err == KErrNone)

  1073         {

  1074         // Check buffer is large enough to contain header

  1075         aSize -= KMinSizeBinaryHeader;

  1076         if (aSize < 0)

  1077             {

  1078             aData = startOfData;

  1079             return KErrOverflow;

  1080             }

  1081         aTraceHeaderSettings.iComponentID = ReadUint32FromBuf(aData, aTraceHeaderSettings.iFromTestWriter);    // ComponentId (4 bytes)

  1082         aTraceHeaderSettings.iTraceWord = ReadUint32FromBuf(aData, aTraceHeaderSettings.iFromTestWriter);      // GroupId (2 bytes). TraceId (2 bytes)

  1083         

  1084         TUint8* startOfPayload = aData;

  1085         TUint8 size;

  1086         

  1087         TBool testWriterHwData = EFalse;

  1088 #ifndef __WINS__

  1089         testWriterHwData = aTraceHeaderSettings.iFromTestWriter;

  1090 #endif

  1091 

  1092         // now look at BTrace header and payload.

  1093         if (!testWriterHwData)

  1094             {

  1095             size = aData[BTrace::ESizeIndex];

  1096             aTraceHeaderSettings.iHeaderFlags = aData[BTrace::EFlagsIndex];

  1097             aTraceHeaderSettings.iCategory = aData[BTrace::ECategoryIndex];

  1098             aTraceHeaderSettings.iSubCategory = aData[BTrace::ESubCategoryIndex];

  1099             }

  1100         else

  1101             {

  1102             // endianess order is reversed for TestWriter on hw

  1103             aTraceHeaderSettings.iSubCategory = aData[BTrace::ESizeIndex];

  1104             aTraceHeaderSettings.iCategory = aData[BTrace::EFlagsIndex];

  1105             aTraceHeaderSettings.iHeaderFlags = aData[BTrace::ECategoryIndex];

  1106             size = aData[BTrace::ESubCategoryIndex];

  1107             }

  1108         

  1109         aData+=4;

  1110 

  1111         //read header extensions

  1112         if(aTraceHeaderSettings.iHeaderFlags & BTrace::EHeader2Present)

  1113             {

  1114             // Check buffer is large enough to contain header

  1115             aSize -= 4;

  1116             if (aSize < 0)

  1117                 {

  1118                 aData = startOfData;

  1119                 return KErrOverflow;

  1120                 }

  1121             TUint32 header2 = Swap(ReadUint32FromBuf(aData, aTraceHeaderSettings.iFromTestWriter));

  1122             aTraceHeaderSettings.iMultiPartType = header2 & BTrace::EMultipartFlagMask;

  1123             }

  1124         if(aTraceHeaderSettings.iHeaderFlags & BTrace::ETimestampPresent)

  1125             {

  1126             // Check buffer is large enough to contain header

  1127             aSize -= 4;

  1128             if (aSize < 0)

  1129                 {

  1130                 aData = startOfData;

  1131                 return KErrOverflow;

  1132                 }

  1133             ReadUint32FromBuf(aData, aTraceHeaderSettings.iFromTestWriter);

  1134             }

  1135         if(aTraceHeaderSettings.iHeaderFlags & BTrace::ETimestamp2Present)