1 // Copyright (c) 2007-2009 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 // Ost Performance Tests Ost Call.

    15 //

    16 

    17 

    18 

    19 /**

    20  @file te_instrumentationpoints_enabled.cpp

    21  @internalTechnology

    22  @prototype

    23 */

    24 

    25 

    26 #include "te_instrumentationpoints.h"

    27 #include "te_instrumentationpoints_enabledTraces.h"

    28 #ifndef __KERNEL_MODE__

    29 #include <e32base.h> //for cleanupstack

    30 #endif

    31 

    32 #include "te_perfstackinfo.h"

    33 #include "te_dataparameters.h"

    34 #include "sanity/te_perfsanityhelpers.h"

    35 

    36 

    37 

    38 

    39 /*dummy function for Test function - used to calibrate and debug the timer class with the Lauterbach*/

    40 void tracefoo()

    41 	 {

    42 	 volatile int gt[100]; //expect 400 bytes stack use - i.e. 100 words of 4bytes each

    43 		for(int i=0; i<100;++i)

    44 			gt[i] = i;

    45 	 }

    46 

    47 

    48 TBool TUptTraceCalls::IsKernelTrace(TInt aApiId)

    49 	{

    50 	TBool isKernelTrace = EFalse;

    51 	switch(aApiId)

    52 	{

    53 		case EUptKernelPrintfchar:

    54 		case EUptKernelPrintfDesc8_big:

    55 		case EUptKernelPrintfDesc8_huge:

    56 		case EUptKernelTrace:

    57 		case EUptKernelTraceTUint32:

    58 		case EUptKernelTraceTUint32TUint32:

    59 		case EUptKernelTraceTAnySmallStruct:

    60 		case EUptKernelTraceTAnyBigStruct:

    61 		case EUptKernelTraceTAnyHugeStruct:

    62 		case EUptKernelTraceTemplatedSmallStruct:

    63 		case EUptKernelTraceTemplatedBigStruct:

    64 		case EUptKernelTraceTemplatedHugeStruct:

    65 		case EUptKernelIsTraceActive:

    66 		case UPTKernelTraceTest:

    67 		case UPTKernelNegativeFunctionalityTest:

    68 		case UPTKernelMultipleFunctionalityTest:

    69 		case UPTKernelBaseline:

    70 		isKernelTrace = ETrue;

    71 		break;

    72 		default:

    73 		break;

    74 		}

    75 	return isKernelTrace;

    76 	}

    77 

    78 

    79 TInt TUptTraceCalls::DoSendTraceL(const TApiRunConfig& aApiRunConfig, TApiRunResults& aApiRunResults)

    80 	{

    81 	TInt error = KErrGeneral;

    82 	TBool logged = EFalse;

    83 	TUint32 stackbase=0;

    84 	TUint32 before=0;

    85 	aApiRunResults.iApiStackUsage = 0;

    86 	

    87     switch(aApiRunConfig.iApiId)

    88 	{		

    89 		

    90 	case EUptPrintTDesC8_big:

    91 	case EUptKernelPrintfDesc8_big:

    92 		{

    93 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

    94 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

    95 		logged = OstPrint(attributes, KStringDesc8 );//TPtrC8((const TUint8*)KBigData8, KBigSize8)

    96 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

    97 		}

    98 	break;

    99 

   100 	case EUptPrintTDesC8_huge:

   101 	case EUptKernelPrintfDesc8_huge:

   102 		{

   103 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   104 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   105 		logged = OstPrint(attributes, KStringDescHuge8);//TPtrC8((const TUint8*)KHugeData8, KHugeSize8)

   106 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   107 		}

   108 	break;

   109 		

   110 	case EUptPrintTDesC16_big:

   111 #ifndef __KERNEL_MODE__

   112 		{

   113 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   114 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   115 		logged = OstPrint(attributes, KStringDesc16);//TPtrC16((const TUint16*)KBigData16, KBigSize16)

   116 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   117 		}

   118 #endif	

   119 	break;

   120 		

   121 	case EUptPrintTDesC16_huge:

   122 #ifndef __KERNEL_MODE__

   123 		{

   124 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   125 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   126 		logged = OstPrint(attributes, KStringDescHuge16);//TPtrC16((const TUint16*)KHugeData16, KHugeSize16)

   127 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   128 		}

   129 #endif	

   130 	break;

   131 	

   132 	

   133 	case EUptTraceTDesC8_big:

   134 	case EUptKernelTraceDesc8_big:

   135 		{

   136 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   137 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   138 		logged = OstTrace(attributes, KTraceId, KStringDesc8);

   139 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   140 		}

   141 	break;

   142 

   143 	case EUptTraceTDesC8_huge:

   144 	case EUptKernelTraceDesc8_huge:

   145 		{

   146 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   147 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   148 		logged = OstTrace(attributes, KTraceId, KStringDescHuge8);

   149 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   150 		}

   151 	break;

   152 	

   153 

   154 	

   155 	case EUptTraceTDesC16_big:

   156 #ifndef __KERNEL_MODE__

   157 		{

   158 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   159 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   160 		logged = OstTrace(attributes, KTraceId, KStringDesc16);

   161 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   162 		}

   163 #endif	

   164 	break;

   165 

   166 	case EUptTraceTDesC16_huge:

   167 #ifndef __KERNEL_MODE__

   168 		{

   169 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   170 		TTraceContext attributes(KComponentId, KGroupId,  aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   171 		logged = OstTrace(attributes, KTraceId, KStringDescHuge16);

   172 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   173 		}

   174 #endif	

   175 	break;

   176 	

   177 	

   178 	case EUptPrintfchar:

   179 	case EUptKernelPrintfchar:

   180 		{

   181 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   182 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   183 		logged = OstPrintf(attributes, KPrintfCStyleString);

   184 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   185 		}

   186 	break;

   187 

   188 	case EUptPrintfTRefByValueTDesC8:

   189 	case EUptKernelPrintfTRefByValueTDesC8:

   190 	    {

   191 	    __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   192 	    TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   193 	    logged = OstPrintf(attributes, KDesC8Formatted,2);

   194 	    __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   195 	    }

   196 

   197 	break;

   198 	case EUptPrintfTRefByValueTDesC16:

   199 #ifndef __KERNEL_MODE__

   200 		{

   201 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   202 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   203 		logged = OstPrintf(attributes,KDesCFormatted16,2);

   204 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   205 		}

   206 #endif

   207 	break;

   208 		

   209 	case EUptTrace:

   210 	case EUptKernelTrace:

   211 		{

   212 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   213 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   214 		logged = OstTrace(attributes, KTraceId);

   215 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   216 		}

   217 	break;

   218 		

   219 	case EUptTraceTUint32:

   220 	case EUptKernelTraceTUint32:

   221 		{

   222 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   223 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   224 		logged = OstTrace(attributes, KTraceId, KData1);

   225 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   226 		}

   227 	break;

   228 		

   229 	case EUptTraceTUint32TUint32:

   230 	case EUptKernelTraceTUint32TUint32:

   231 		{

   232 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   233 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   234 		logged = OstTrace(attributes, KTraceId, KData1, KData2);

   235 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);				

   236 		}

   237 	break;

   238 		

   239 	case EUptTraceTAnySmallStruct:

   240 	case EUptKernelTraceTAnySmallStruct:

   241 		{

   242 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   243 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   244 		logged = OstTrace(attributes, KTraceId, KSmallData, KSmallSize);

   245 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   246 		}

   247 	break;

   248 	case EUptTraceTAnyBigStruct:

   249 	case EUptKernelTraceTAnyBigStruct:

   250 		{

   251 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   252 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   253 		logged = OstTrace(attributes, KTraceId, KBigData8, KBigSize8);

   254 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   255 		}

   256 	break;

   257 

   258 	case EUptTraceTAnyHugeStruct:

   259 	case EUptKernelTraceTAnyHugeStruct:

   260 		{

   261 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   262 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   263 		logged = OstTrace(attributes, KTraceId, KHugeData8, KHugeSize8);

   264 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   265 		}

   266 	break;

   267 		

   268 	

   269 	case EUptTraceTemplatedSmallStruct:

   270 	case EUptKernelTraceTemplatedSmallStruct:

   271 		{

   272 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   273 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   274 		logged = OstTrace(attributes, KTraceId, KStructForTemplated);

   275 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   276 		}

   277 	break;

   278 	

   279 	case EUptTraceTemplatedBigStruct:

   280 	case EUptKernelTraceTemplatedBigStruct:

   281 		{

   282 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   283 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   284 		logged = OstTrace(attributes, KTraceId, KBigData8);

   285 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   286 		}

   287 	break;

   288 	

   289 	case EUptTraceTemplatedHugeStruct:

   290 	case EUptKernelTraceTemplatedHugeStruct:

   291 		{

   292 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   293 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   294 		logged = OstTrace(attributes, KTraceId, KHugeData8);

   295 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   296 		}

   297 	break;

   298 		

   299 	case EUptIsTraceActive:

   300 	case EUptKernelIsTraceActive:

   301 		{

   302 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   303 		TTraceContext attributes(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter);

   304 		logged = IsTraceActive(attributes);

   305 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   306 		}

   307 	break;

   308 		

   309 

   310 	case UPTTraceTest:

   311 	case UPTKernelTraceTest:

   312 		{

   313 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   314 		SanityFoo();

   315 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   316 		}

   317 	break;

   318 	

   319 	case UPTKernelNegativeFunctionalityTest:

   320 		{

   321 		logged = OstTrace(TTraceContext(KComponentId+1, KGroupId+1, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   322 		logged = OstTrace(TTraceContext(KComponentId+2, KGroupId+2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   323 		}

   324 	break;

   325 	

   326 	case UPTKernelMultipleFunctionalityTest:

   327 		{

   328 		logged = OstTrace(TTraceContext(KComponentId, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   329 		logged = OstTrace(TTraceContext(KComponentId + 1, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   330 		logged = OstTrace(TTraceContext(KComponentId + 2, KGroupId, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   331 		logged = OstTrace(TTraceContext(KComponentId, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   332 		logged = OstTrace(TTraceContext(KComponentId + 2, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   333 		logged = OstTrace(TTraceContext(KComponentId + 1, KGroupId + 2, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   334 		logged = OstTrace(TTraceContext(KComponentId, KGroupId + 1, aApiRunConfig.iHasContext, aApiRunConfig.iHasProgramCounter), KTraceId);

   335 		}

   336 		break;

   337 		

   338 	case BTraceFiltered4:

   339 		{

   340 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   341 		logged = BTraceFiltered4(KGroupId,0 ,KComponentId);

   342 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   343 		}

   344 	break;

   345 	case BTraceFiltered8:

   346 		{

   347 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   348 		logged = BTraceFiltered8(KGroupId,0 ,KComponentId,KData1);

   349 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   350 		}

   351 	break;

   352 	case BTraceFiltered12:

   353 		{

   354 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   355 		logged = BTraceFiltered12(KGroupId,0 ,KComponentId,KData1,KData2);

   356 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   357 		}

   358 	

   359 	break;

   360 	case BTraceFilteredBig:

   361 		{

   362 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   363 		logged = BTraceFilteredBig(KGroupId,0 ,KComponentId,KHugeData8,sizeof(KHugeData8));

   364 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   365 		}

   366 	break;

   367 	case BTrace0:

   368 		{

   369 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   370 		logged = BTrace0(KGroupId,0 );

   371 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   372 		}

   373 	break;

   374 	case BTrace4:

   375 		{

   376 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   377 		logged = BTrace4(KGroupId,0 ,KData1);

   378 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);						

   379 		}

   380 	break;

   381 	case BTrace8:

   382 		{

   383 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   384 		logged = BTrace8(KGroupId,0 ,KData1, KData2);

   385 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);		

   386 		}

   387 	break;

   388 	case BTrace12:

   389 		{

   390 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   391 		logged = BTrace12(KGroupId,0 ,KData1, KData2, KData3);

   392 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);		

   393 		}

   394 	break;		

   395 	case UPTKernelBaseline:

   396 	case UPTBaseline:

   397 		{

   398 		__MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   399 		__RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   400 		}

   401 	break;

   402 	

   403 	case EOstTraceDef0:

   404         {

   405         /**

   406         Preprocessor level for all traces on. 

   407         This should not be used from traces

   408         */

   409         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   410         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   411         OstTraceDef0( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDef0, "EOstTraceDef0" ) ;

   412         logged = ETrue;

   413         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   414         }

   415     break;

   416     

   417 	case EOstTraceDef1:

   418         {

   419         /**

   420         Preprocessor level for all traces on. 

   421         This should not be used from traces

   422         */

   423         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   424         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   425         OstTraceDef1( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDef1, "EOstTraceDef1 - %u" , KData1) ;

   426         logged = ETrue;

   427         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);  

   428             

   429         }

   430     break;

   431     

   432 	case EOstTraceDefData:

   433         {

   434         /**

   435         Preprocessor level for all traces on. 

   436         This should not be used from traces

   437         */

   438         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   439         const TAny* y = &KData1;

   440         

   441         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   442         OstTraceDefData( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefData, "EOstTraceDefData", y, sizeof(KData1) ) ;

   443         logged = ETrue;

   444         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   445 

   446         }

   447     break;

   448     

   449 	case EOstTraceDefExt1:

   450         {

   451         /**

   452         Preprocessor level for all traces on. 

   453         This should not be used from traces

   454         */

   455         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   456         

   457         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   458         OstTraceDefExt1( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt1, "OstTraceDefExt1 - %s", KDefault8 ) ;

   459         logged = ETrue;

   460         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   461 

   462         }

   463     break;

   464     

   465     case EOstTraceDefExt2:

   466         {

   467         /**

   468         Preprocessor level for all traces on. 

   469         This should not be used from traces

   470         */

   471         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   472         

   473         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   474         

   475         OstTraceDefExt2( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt2, "OstTraceDefExt2 - %u - %u", KData1 , KData1) ;

   476         logged = ETrue;

   477         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   478 

   479         }

   480     break;

   481     

   482     case EOstTraceDefExt3:

   483         {

   484         /**

   485         Preprocessor level for all traces on. 

   486         This should not be used from traces

   487         */

   488         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   489         

   490         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   491         

   492         OstTraceDefExt3( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt3, "OstTraceDefExt3 - %u - %u - %u", KData1 , KData1, KData1) ;

   493         logged = ETrue;

   494         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   495 

   496         }

   497     break;

   498     

   499     case EOstTraceDefExt4:

   500         {

   501         /**

   502         Preprocessor level for all traces on. 

   503         This should not be used from traces

   504         */

   505         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   506         

   507         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   508         

   509         OstTraceDefExt4( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt4, "OstTraceDefExt4 - %u - %u - %u - %u", KData1 , KData1, KData1, KData1) ;

   510         logged = ETrue;

   511         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   512 

   513         }

   514     break;

   515     

   516     case EOstTraceDefExt5:

   517         {

   518         /**

   519         Preprocessor level for all traces on. 

   520         This should not be used from traces

   521         */

   522         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   523         

   524         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   525         

   526         OstTraceDefExt5( OST_TRACE_CATEGORY_ALL, TRACE_FATAL, TEST_OstTraceDefExt5, "OstTraceDefExt5 - %u - %u - %u - %u - %u", KData1, KData1, KData1, KData1, KData1 ) ;

   527         logged = ETrue;

   528         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   529 

   530         }

   531     break;

   532     

   533     case EOstTrace0:

   534         {

   535         /**

   536         Preprocessor level for all traces on. 

   537         This should not be used from traces

   538         */

   539         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   540         

   541         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   542         OstTrace0( TRACE_FATAL, TEST_OSTTRACE0, "EOstTrace0" );

   543         logged = ETrue;

   544         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   545         }

   546     break;

   547     

   548     case EOstTrace1:

   549         {

   550         /**

   551         Preprocessor level for all traces on. 

   552         This should not be used from traces

   553         */

   554         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   555         

   556         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   557         OstTrace1( TRACE_FATAL, TEST_OSTTRACE1, "EOstTrace1  - %u" , KData1);

   558         logged = ETrue;

   559         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage);

   560 

   561         }

   562     break;

   563     

   564     case EOstTraceData:

   565         {

   566         /**

   567         Preprocessor level for all traces on. 

   568         This should not be used from traces

   569         */

   570         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   571         const TAny* y = &KData1;

   572         

   573         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   574         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA, "EOSTTraceData", y, sizeof(KData1) );

   575         logged = ETrue;

   576         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   577 

   578         }

   579     break;

   580     

   581     case EOstTraceExt1:

   582         {

   583         /**

   584         Preprocessor level for all traces on. 

   585         This should not be used from traces

   586         */

   587         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   588         

   589         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   590         OstTraceExt1( TRACE_FATAL, TEST_OSTTRACEEXT1, "OSTTraceExt1 - %hhd", KData8 ) ;

   591         logged = ETrue;

   592         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   593 

   594         }

   595     break;

   596     

   597     case EOstTraceExt2:

   598         {

   599         /**

   600         Preprocessor level for all traces on. 

   601         This should not be used from traces

   602         */

   603         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   604         

   605         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   606         OstTraceExt2( TRACE_FATAL, TEST_OSTTRACEEXT2, "OSTTraceExt2 - %u - %u", KData1 ,KData1) ;

   607         logged = ETrue;

   608         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   609 

   610         }

   611     break;

   612     

   613     case EOstTraceExt3:

   614         {

   615         /**

   616         Preprocessor level for all traces on. 

   617         This should not be used from traces

   618         */

   619         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF          

   620         

   621         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   622         OstTraceExt3( TRACE_FATAL, TEST_OSTTRACEEXT3, "OSTTraceExt3 - %u - %u - %u", KData1 ,KData1, KData1) ;

   623         logged = ETrue;

   624         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   625 

   626         }

   627     break;

   628     

   629     case EOstTraceExt4:

   630         {

   631         /**

   632         Preprocessor level for all traces on. 

   633         This should not be used from traces

   634         */

   635         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   636         

   637         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   638         OstTraceExt4( TRACE_FATAL, TEST_OSTTRACEEXT4, "OSTTraceExt4 - %u - %u - %u - %u", KData1 ,KData1, KData1, KData1) ;

   639         logged = ETrue;

   640         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   641 

   642         }

   643     break;

   644     

   645     case EOstTraceExt5:

   646         {

   647         /**

   648         Preprocessor level for all traces on. 

   649         This should not be used from traces

   650         */

   651         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   652         

   653         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   654         OstTraceExt5( TRACE_FATAL, TEST_OSTTRACEEXT5, "OSTTraceExt5 - %u - %u - %u - %u - %u", KData1 ,KData1, KData1, KData1, KData1) ;

   655         logged = ETrue;

   656         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   657 

   658         }

   659     break;

   660     

   661     case EOstTraceFunctionEntry0:

   662         {

   663         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   664         OstTraceFunctionEntry0( TEST_OSTTraceFunctionalityEntry0 );

   665         logged = ETrue;

   666         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   667         }

   668     break;

   669     

   670     case EOstTraceFunctionEntry1:

   671         {

   672         //const TAny* y = &KData1;

   673         

   674         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   675         OstTraceFunctionEntry1( TEST_OSTTraceFunctionalityEntry1, KData1 );

   676         logged = ETrue;

   677         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   678 

   679         }

   680     break;

   681     

   682     case EOstTraceFunctionEntryExt:

   683         {

   684         

   685         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   686         OstTraceFunctionEntryExt( TEST_OSTTraceFunctionalityExt, KData1 );

   687         logged = ETrue;

   688         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   689 

   690         }

   691     break;

   692     

   693     case EOstTraceFunctionExit0:

   694         {

   695         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   696         OstTraceFunctionExit0( TEST_OstTraceFunctionExit0 );

   697         logged = ETrue;

   698         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   699         }

   700     break;

   701     

   702     case EOstTraceFunctionExit1:

   703         {

   704         //const TAny* y = &KData1;

   705         

   706         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   707         OstTraceFunctionExit1( TEST_OSTTRACEFUNCTIONEXIT1, KData1 );

   708         logged = ETrue;

   709         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   710 

   711         }

   712     break;

   713     

   714     case EOstTraceFunctionExitExt:

   715         {

   716         TInt returnCode = 0;

   717         

   718         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   719         OstTraceFunctionExitExt( TEST_OSTTRACEFUNCTIONEXITEXT, KData1 , returnCode );

   720         logged = ETrue;

   721         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   722 

   723         }

   724     break;

   725     

   726     case EOstTraceEventStart0:

   727         {

   728         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   729         OstTraceEventStart0( TEST_OSTTRACEEVENTSTART0, "EOstTraceEventStart0" );

   730         logged = ETrue;

   731         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   732         }

   733     break;

   734     

   735     case EOstTraceEventStart1:

   736         {

   737         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   738         OstTraceEventStart1( TEST_OSTTRACEEVENTSTART1, "EOstTraceEventStart1 - %u", KData1 ) ;

   739         logged = ETrue;

   740         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   741 

   742         }

   743     break;

   744     

   745     case EOstTraceEventStop:

   746         {

   747         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   748         OstTraceEventStop( TEST_OSTTRACEEVENTSTOP, "EOstTraceEventStop", TEST_OSTTRACEEVENTSTART0 );

   749         logged = ETrue;

   750         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   751         }

   752     break;

   753     

   754     case EOstTraceState0:

   755         {

   756         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   757         OstTraceState0( TEST_OSTTRACESTATE0, "Test State Name", "Test State Value" );

   758         logged = ETrue;

   759         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   760         }

   761     break;

   762 	

   763     case EOstTraceState1:

   764         {

   765       //  const TAny* y = &KData1;

   766         

   767         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   768         OstTraceState1( TEST_OSTTRACESTATE1, "Test State Name", "Test State Value", KData1 );

   769         logged = ETrue;

   770         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   771 

   772         }

   773     break;

   774     

   775     case EOstTraceData96:

   776         {

   777         /**

   778         Preprocessor level for all traces on. 

   779         This should not be used from traces

   780         */

   781         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   782         

   783         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   784         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA96, "EOSTTraceData96", KBigData8, KBigSize8 );

   785         logged = ETrue;

   786         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   787 

   788         }

   789     break;

   790     

   791     case EOstTraceData1000:

   792         {

   793         /**

   794         Preprocessor level for all traces on. 

   795         This should not be used from traces

   796         */

   797         #define OST_TRACE_CATEGORY_ALL 0xFFFFFFFF

   798         

   799         __MARK_INITIAL_STACK(aApiRunConfig.iDoStack, stackbase, before);

   800         OstTraceData( TRACE_FATAL, TEST_OSTTRACEDATA1000, "EOSTTraceData1000", KHugeData8, KHugeSize8 );

   801         logged = ETrue;

   802         __RETURN_STACK_SIZE(aApiRunConfig.iDoStack, stackbase, before,  aApiRunResults.iApiStackUsage); 

   803 

   804         }

   805     break;

   806     

   807 	default:

   808 		error = KErrNotSupported;

   809 		break;

   810 	}

   811  	

   812 	//if the "trace" is in fact not an actual trace and trace not sent - this is a true result 

   813 	TBool realTrace = ETrue;

   814 	switch(aApiRunConfig.iApiId)

   815 	{

   816 	case UPTTraceTest:

   817 	case UPTKernelTraceTest:

   818 	case UPTKernelNegativeFunctionalityTest:

   819 	case UPTKernelMultipleFunctionalityTest:

   820 	case UPTBaseline:

   821 	case UPTKernelBaseline:

   822 	case UPTFooUserTime:

   823 	case UPTFooKernelTime:

   824 		realTrace = EFalse;

   825 	break;

   826 	default:

   827 	break;		

   828 	}		

   829 	

   830 	//ensure correct error values for the current test configurations are returned to the test framework

   831 	if(!logged)

   832 		{

   833 		if(error!=KErrNotSupported)

   834 			error = KErrGeneral;

   835 		}

   836 	else

   837 		error = KErrNone;

   838 		

   839 

   840 	//if trace has been disabled and trace not sent - this is a true result 

   841 	#ifdef TE_UPT_TRACE_DISABLED

   842 	if(error == KErrGeneral)

   843 			error = KErrNone;

   844 	#endif

   845 

   846 	if(error == KErrGeneral && realTrace == EFalse)

   847 		error = KErrNone;

   848 

   849 

   850 	//returns KErrNone if logged, KErrNotLogged if not logged, KErrGeneral if any other problem...

   851 	return error;

   852 	}

   853 

   854 

   855 

   856 //eof