Symaptic: os/kernelhwsrv/kerneltest/e32test/debug/d

     1 // Copyright (c) 2005-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 the License "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 // e32\drivers\trace\btrace.cpp

    15 //

    16 //

    18 #include <kernel/kern_priv.h>

    19 #include "platform.h"

    20 #include "d_btrace.h"

    23 class DBTraceTestFactory : public DLogicalDevice

    24 	{

    25 public:

    26 	virtual TInt Install();

    27 	virtual void GetCaps(TDes8& aDes) const;

    28 	virtual TInt Create(DLogicalChannelBase*& aChannel);

    29 	};

    32 class DBTraceTestChannel : public DLogicalChannelBase

    33 	{

    34 public:

    35 	DBTraceTestChannel();

    36 	virtual ~DBTraceTestChannel();

    37 	//	Inherited from DObject

    38 	virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);

    39 	// Inherited from DLogicalChannelBase

    40 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

    41 	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

    42 private:

    43 	DThread* iClient;

    44 public:

    45 	static void TestTrace(DBTraceTestChannel* aSelf);

    46 	static void TestUTrace(DBTraceTestChannel* aSelf);

    47 private:

    48 	TUint32 iTestType;

    49 	TInt iTestDataSize;

    50 	TUint32 iTestData[KMaxBTraceRecordSize*2/4];

    51 	volatile TBool iTimerExpired;

    52 	NTimer iTraceTimer;

    53 	TDfc iTraceIDFC;

    54 	};

    57 //

    58 // DBTraceTestFactory

    59 //

    61 TInt DBTraceTestFactory::Install()

    62 	{

    63 	return SetName(&RBTraceTest::Name());

    64 	}

    66 void DBTraceTestFactory::GetCaps(TDes8& aDes) const

    67 	{

    68 	Kern::InfoCopy(aDes,0,0);

    69 	}

    71 TInt DBTraceTestFactory::Create(DLogicalChannelBase*& aChannel)

    72 	{

    73 	aChannel=new DBTraceTestChannel();

    74 	if(!aChannel)

    75 		return KErrNoMemory;

    76 	return KErrNone;

    77 	}

    80 //

    81 // DBTraceTestChannel

    82 //

    84 DBTraceTestChannel::DBTraceTestChannel()

    85 	: iTraceTimer((NTimerFn)TestTrace,this),

    86 	iTraceIDFC((NTimerFn)TestTrace,this)

    87 	{

    88 	}

    90 DBTraceTestChannel::~DBTraceTestChannel()

    91 	{

    92 	iTraceTimer.Cancel();

    93 	}

    95 TInt DBTraceTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

    96 	{

    97 	iClient = &Kern::CurrentThread();

    98 	return KErrNone;

    99 	}

   102 TInt DBTraceTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)

   103 	{

   104 	if (aType!=EOwnerThread || aThread!=iClient)

   105 		return KErrAccessDenied;

   106 	return KErrNone;

   107 	}

   109 TInt DBTraceTestChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

   110 	{

   111 	switch(aReqNo)

   112 		{

   113 	// test functions

   114 	case RBTraceTest::ETestSpecialTrace:

   115 	case RBTraceTest::ETestTrace:

   116 		{

   117 		TPtr8 data((TUint8*)&iTestData,sizeof(iTestData));

   118 		Kern::KUDesGet(data,*(TDesC8*)a2);

   119 		iTestDataSize = data.Size()-4;

   120 		if(aReqNo==RBTraceTest::ETestSpecialTrace)

   121 			{

   122 			iTestType = (TUint)a1;

   123 			iTimerExpired = EFalse;

   124 			if(iTestType&RBTraceTest::EContextIsr)

   125 				iTraceTimer.OneShot(1);

   126 			else if(iTestType&RBTraceTest::EContextIDFC)

   127 				{

   128 				NKern::Lock();

   129 				iTraceIDFC.Add();

   130 				NKern::Unlock();

   131 				}

   132 			else if(iTestType&RBTraceTest::EContextIntsOff)

   133 				{

   134 				TInt irq = NKern::DisableAllInterrupts();

   135 				TestTrace(this);

   136 				NKern::RestoreInterrupts(irq);

   137 				}

   138 			else

   139 				TestTrace(this);

   140 			while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

   141 			return (TInt)NKern::CurrentThread();

   142 			}

   143 		else

   144 			{

   145 			TInt delay = (TInt)a1/NKern::TickPeriod();

   146 			iTestType = 0;

   147 			if(!delay)

   148 				TestTrace(this);

   149 			else

   150 				{

   151 				iTraceTimer.Cancel();

   152 				iTraceTimer.OneShot(delay+1);

   153 				}

   154 			}

   155 		}

   156 		return KErrNone;

   158 	case RBTraceTest::ETestBenchmark:

   159 		{

   160 		TInt delay = (TInt)a2/NKern::TickPeriod();

   161 		TInt size = (TInt)a1;

   162 		iTestDataSize = -1;

   164 		// wait for next tick...

   165 		iTraceTimer.Cancel();

   166 		iTimerExpired = EFalse;

   167 		iTraceTimer.OneShot(1);

   168 		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

   170 		// do benchmark...

   171 		iTimerExpired = EFalse;

   172 		iTraceTimer.OneShot(delay+1);

   173 		TInt count = 0;

   174 		if(size)

   175 			for(;;)

   176 				{

   177 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   178 				BTraceContextN(BTrace::ETest1,0,0,0,&iTestData,size);

   179 				++count;

   180 				if(!finished)

   181 					continue;

   182 				break;

   183 				}

   184 		else

   185 			for(;;)

   186 				{

   187 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   188 				BTrace0(BTrace::ETest1,0);

   189 				++count;

   190 				if(!finished)

   191 					continue;

   192 				break;

   193 				}

   194 		return count;

   195 		}

   197 	case RBTraceTest::ETestBenchmark2:

   198 		{

   199 		TInt delay = (TInt)a2/NKern::TickPeriod();

   200 		TInt size = (TInt)a1;

   201 		iTestDataSize = -1;

   203 		// wait for next tick...

   204 		iTraceTimer.Cancel();

   205 		iTimerExpired = EFalse;

   206 		iTraceTimer.OneShot(1);

   207 		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

   209 		// do benchmark...

   210 		iTimerExpired = EFalse;

   211 		iTraceTimer.OneShot(delay+1);

   212 		TInt count = 0;

   213 		if(size)

   214 			for(;;)

   215 				{

   216 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   217 				BTraceFilteredContextN(BTrace::ETest1,0,KBTraceFilterTestUid1,0,&iTestData,size);

   218 				++count;

   219 				if(!finished)

   220 					continue;

   221 				break;

   222 				}

   223 		else

   224 			for(;;)

   225 				{

   226 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   227 				BTraceFiltered4(BTrace::ETest1,0,KBTraceFilterTestUid1);

   228 				++count;

   229 				if(!finished)

   230 					continue;

   231 				break;

   232 				}

   233 		return count;

   234 		}

   236 	case RBTraceTest::ETestBenchmarkCheckFilter:

   237 		{

   238 		TInt delay = (TInt)a2/NKern::TickPeriod();

   240 		// wait for next tick...

   241 		iTraceTimer.Cancel();

   242 		iTimerExpired = EFalse;

   243 		iTraceTimer.OneShot(1);

   244 		while(!__e32_atomic_load_acq32(&iTimerExpired)) {};

   246 		// do benchmark...

   247 		iTimerExpired = EFalse;

   248 		iTraceTimer.OneShot(delay+1);

   249 		TInt count = 0;

   250 		if(a1)

   251 			for(;;)

   252 				{

   253 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   254 				BTrace::CheckFilter2(BTrace::ETest1,KBTraceFilterTestUid1);

   255 				++count;

   256 				if(!finished)

   257 					continue;

   258 				break;

   259 				}

   260 		else

   261 			for(;;)

   262 				{

   263 				TBool finished = __e32_atomic_load_acq32(&iTimerExpired);

   264 				BTrace::CheckFilter(BTrace::ETest1);

   265 				++count;

   266 				if(!finished)

   267 					continue;

   268 				break;

   269 				}

   270 		return count;

   271 		}

   272 	case RBTraceTest::ETestUTrace:

   273 		{

   274 		TPtr8 data((TUint8*)&iTestData,sizeof(iTestData));

   275 		Kern::KUDesGet(data,*(TDesC8*)a2);

   276 		iTestDataSize = data.Size()-4;

   277 		TInt delay = (TInt)a1/NKern::TickPeriod();

   278 		iTestType = 0;

   279 		if(!delay)

   280 			TestUTrace(this);

   281 		else

   282 			{

   283 			iTraceTimer.Cancel();

   284 			iTraceTimer.OneShot(delay+1);

   285 			}

   286 		return KErrNone;

   287 		}

   289 	default:

   290 		break;

   291 		}

   292 	return KErrNotSupported;

   293 	}

   296 void DBTraceTestChannel::TestTrace(DBTraceTestChannel* aSelf)

   297 	{

   298 	TInt size = aSelf->iTestDataSize;

   299 	if(size<0)

   300 		{

   301 		__e32_atomic_store_rel32(&aSelf->iTimerExpired, 1);

   302 		return;

   303 		}

   304 	TUint32* data = aSelf->iTestData;

   305 	BTrace::TCategory category = (BTrace::TCategory)((TUint8*)data)[0];

   306 	TUint subCategory = (BTrace::TCategory)((TUint8*)data)[1];

   307 	TUint type = aSelf->iTestType&0xff;

   308 	TBool bigTrace = aSelf->iTestType&RBTraceTest::EBigTrace;

   309 	TBool filter2Trace = aSelf->iTestType&RBTraceTest::EFilter2Trace;

   311 	if(!filter2Trace)

   312 		{

   313 		if(type==BTrace::EPcPresent)

   314 			{

   315 			if(bigTrace)

   316 				{

   317 				BTracePcBig(category,subCategory,data[1],data+2,size-4);

   318 				BTracePcBig(category,subCategory,data[1],data+2,size-4);

   319 				}

   320 			else if(size==0)

   321 				{

   322 				BTracePc0(category,subCategory);

   323 				BTracePc0(category,subCategory);

   324 				}

   325 			else if(size<=4)

   326 				{

   327 				BTracePc4(category,subCategory,data[1]);

   328 				BTracePc4(category,subCategory,data[1]);

   329 				}

   330 			else if(size<=8)

   331 				{

   332 				BTracePc8(category,subCategory,data[1],data[2]);

   333 				BTracePc8(category,subCategory,data[1],data[2]);

   334 				}

   335 			else

   336 				{

   337 				BTracePcN(category,subCategory,data[1],data[2],data+3,size-8);

   338 				BTracePcN(category,subCategory,data[1],data[2],data+3,size-8);

   339 				}

   340 			}

   341 		else if(type==BTrace::EContextIdPresent)

   342 			{

   343 			if(bigTrace)

   344 				{

   345 				BTraceContextBig(category,subCategory,data[1],data+2,size-4);

   346 				BTraceContextBig(category,subCategory,data[1],data+2,size-4);

   347 				}

   348 			else if(size==0)

   349 				{

   350 				BTraceContext0(category,subCategory);

   351 				BTraceContext0(category,subCategory);

   352 				}

   353 			else if(size<=4)

   354 				{

   355 				BTraceContext4(category,subCategory,data[1]);

   356 				BTraceContext4(category,subCategory,data[1]);

   357 				}

   358 			else if(size<=8)

   359 				{

   360 				BTraceContext8(category,subCategory,data[1],data[2]);

   361 				BTraceContext8(category,subCategory,data[1],data[2]);

   362 				}

   363 			else

   364 				{

   365 				BTraceContextN(category,subCategory,data[1],data[2],data+3,size-8);

   366 				BTraceContextN(category,subCategory,data[1],data[2],data+3,size-8);

   367 				}

   368 			}

   369 		else if(type==BTrace::EContextIdPresent+BTrace::EPcPresent)

   370 			{

   371 			if(bigTrace)

   372 				{

   373 				BTraceContextPcBig(category,subCategory,data[1],data+2,size-4);

   374 				BTraceContextPcBig(category,subCategory,data[1],data+2,size-4);

   375 				}

   376 			else if(size==0)

   377 				{

   378 				BTraceContextPc0(category,subCategory);

   379 				BTraceContextPc0(category,subCategory);

   380 				}

   381 			else if(size<=4)

   382 				{

   383 				BTraceContextPc4(category,subCategory,data[1]);

   384 				BTraceContextPc4(category,subCategory,data[1]);

   385 				}

   386 			else if(size<=8)

   387 				{

   388 				BTraceContextPc8(category,subCategory,data[1],data[2]);

   389 				BTraceContextPc8(category,subCategory,data[1],data[2]);

   390 				}

   391 			else

   392 				{

   393 				BTraceContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

   394 				BTraceContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

   395 				}

   396 			}

   397 		else

   398 			{

   399 			if(bigTrace)

   400 				BTraceBig(category,subCategory,data[1],data+2,size-4);

   401 			else if(size==0)

   402 				BTrace0(category,subCategory);

   403 			else if(size<=4)

   404 				BTrace4(category,subCategory,data[1]);

   405 			else if(size<8)

   406 				BTrace8(category,subCategory,data[1],data[2]);

   407 			else

   408 				BTraceN(category,subCategory,data[1],data[2],data+3,size-8);

   409 			}

   410 		}

   411 	else

   412 		{

   413 		if(type==BTrace::EPcPresent)

   414 			{

   415 			if(bigTrace)

   416 				{

   417 				BTraceFilteredPcBig(category,subCategory,data[1],data+2,size-4);

   418 				BTraceFilteredPcBig(category,subCategory,data[1],data+2,size-4);

   419 				}

   420 			else if(size<4)

   421 				{

   422 				// invalid

   423 				}

   424 			else if(size==4)

   425 				{

   426 				BTraceFilteredPc4(category,subCategory,data[1]);

   427 				BTraceFilteredPc4(category,subCategory,data[1]);

   428 				}

   429 			else if(size<=8)

   430 				{

   431 				BTraceFilteredPc8(category,subCategory,data[1],data[2]);

   432 				BTraceFilteredPc8(category,subCategory,data[1],data[2]);

   433 				}

   434 			else

   435 				{

   436 				BTraceFilteredPcN(category,subCategory,data[1],data[2],data+3,size-8);

   437 				BTraceFilteredPcN(category,subCategory,data[1],data[2],data+3,size-8);

   438 				}

   439 			}

   440 		else if(type==BTrace::EContextIdPresent)

   441 			{

   442 			if(bigTrace)

   443 				{

   444 				BTraceFilteredContextBig(category,subCategory,data[1],data+2,size-4);

   445 				BTraceFilteredContextBig(category,subCategory,data[1],data+2,size-4);

   446 				}

   447 			else if(size<4)

   448 				{

   449 				// invalid

   450 				}

   451 			else if(size==4)

   452 				{

   453 				BTraceFilteredContext4(category,subCategory,data[1]);

   454 				BTraceFilteredContext4(category,subCategory,data[1]);

   455 				}

   456 			else if(size<=8)

   457 				{

   458 				BTraceFilteredContext8(category,subCategory,data[1],data[2]);

   459 				BTraceFilteredContext8(category,subCategory,data[1],data[2]);

   460 				}

   461 			else

   462 				{

   463 				BTraceFilteredContextN(category,subCategory,data[1],data[2],data+3,size-8);

   464 				BTraceFilteredContextN(category,subCategory,data[1],data[2],data+3,size-8);

   465 				}

   466 			}

   467 		else if(type==BTrace::EContextIdPresent+BTrace::EPcPresent)

   468 			{

   469 			if(bigTrace)

   470 				{

   471 				BTraceFilteredContextPcBig(category,subCategory,data[1],data+2,size-4);

   472 				BTraceFilteredContextPcBig(category,subCategory,data[1],data+2,size-4);

   473 				}

   474 			else if(size<4)

   475 				{

   476 				// invalid

   477 				}

   478 			else if(size==4)

   479 				{

   480 				BTraceFilteredContextPc4(category,subCategory,data[1]);

   481 				BTraceFilteredContextPc4(category,subCategory,data[1]);

   482 				}

   483 			else if(size<=8)

   484 				{

   485 				BTraceFilteredContextPc8(category,subCategory,data[1],data[2]);

   486 				BTraceFilteredContextPc8(category,subCategory,data[1],data[2]);

   487 				}

   488 			else

   489 				{

   490 				BTraceFilteredContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

   491 				BTraceFilteredContextPcN(category,subCategory,data[1],data[2],data+3,size-8);

   492 				}

   493 			}

   494 		else

   495 			{

   496 			if(bigTrace)

   497 				BTraceFilteredBig(category,subCategory,data[1],data+2,size-4);

   498 			else if(size<4)

   499 				{

   500 				// invalid

   501 				}

   502 			else if(size==4)

   503 				BTraceFiltered4(category,subCategory,data[1]);

   504 			else if(size<8)

   505 				BTraceFiltered8(category,subCategory,data[1],data[2]);

   506 			else

   507 				BTraceFilteredN(category,subCategory,data[1],data[2],data+3,size-8);

   508 			}

   509 		}

   510 	__e32_atomic_store_rel32(&aSelf->iTimerExpired, 1);

   511 	}

   513 void DBTraceTestChannel::TestUTrace(DBTraceTestChannel* aSelf)

   514 	{

   515 	aSelf->iTimerExpired = ETrue;

   516 	TInt size = aSelf->iTestDataSize;

   517 	if(size<0)

   518 		return;

   519 	TUint32* data = aSelf->iTestData;

   520 	BTrace::TCategory category = (BTrace::TCategory)((TUint8*)data)[0];

   521 	TUint subCategory = (BTrace::TCategory)((TUint8*)data)[1];

   523 	#define T_UTRACE_HEADER(aSize,aClassification,aContext,aPc)																\

   524 		((((aSize) + (aContext?4:0) + (aPc?4:0)) << BTrace::ESizeIndex*8)										\

   525 		+(((aContext?BTrace::EContextIdPresent:0) | (aPc?BTrace::EPcPresent:0)) << BTrace::EFlagsIndex*8)			\

   526 		+((aClassification) << BTrace::ECategoryIndex*8)																				\

   527 		+((subCategory) << BTrace::ESubCategoryIndex*8))

   529 	#define UTRACE_SECONDARY(aClassification,aModuleUid,aThreadIdPresent,aPcPresent,aPc,aFormatId)	\

   530 		BTrace::OutFilteredPcFormatBig(T_UTRACE_HEADER(8,aClassification,aThreadIdPresent,aPcPresent),(TUint32)(aModuleUid),aPc,aFormatId,0,0)

   532 	#define UTRACE_SECONDARY_4(aClassification,aModuleUid,aThreadIdPresent,aPcPresent,aPc,aFormatId, aData1) \

   533 		BTrace::OutFilteredPcFormatBig(T_UTRACE_HEADER(8,aClassification,aThreadIdPresent,aPcPresent),(TUint32)(aModuleUid),aPc,aFormatId,&aData1,4)

   535 	#define UTRACE_SECONDARY_ANY(aClassification, aModuleUid, aThreadIdPresent, aPcPresent, aPc, aFormatId, aData, aDataSize) \

   536 		BTrace::OutFilteredPcFormatBig(T_UTRACE_HEADER(8,aClassification,aThreadIdPresent,aPcPresent),(TUint32)(aModuleUid),aPc,aFormatId,aData,(TInt)(aDataSize))

   539 	TUint32 KUtracePcValues[3]={0, 0x123456, 0x987654};

   540 	TUint16 formatId = (TUint16)data[2];

   541 	TUint type = aSelf->iTestType&0xff;

   542 	if(type == BTrace::EPcPresent)

   543 		{

   544 		if(size <= 0)

   545 			{

   546 			UTRACE_SECONDARY(category, data[1], EFalse, ETrue, KUtracePcValues[1], formatId);

   547 			UTRACE_SECONDARY(category, data[1], EFalse, ETrue, KUtracePcValues[2], formatId);

   548 			}

   549 		else if(size <= 4)

   550 			{

   551 			UTRACE_SECONDARY_4(category, data[1], EFalse, ETrue, KUtracePcValues[1], formatId, data[3]);

   552 			UTRACE_SECONDARY_4(category, data[1], EFalse, ETrue, KUtracePcValues[2], formatId, data[3]);

   553 			}

   554 		else //size > 8

   555 			{

   556 			UTRACE_SECONDARY_ANY(category, data[1], EFalse, ETrue, KUtracePcValues[1], formatId, data+3, size);

   557 			UTRACE_SECONDARY_ANY(category, data[1], EFalse, ETrue, KUtracePcValues[2], formatId, data+3, size);

   558 			}

   559 		}

   560 	else if(type==BTrace::EContextIdPresent)

   561 		{

   562 		if(size <= 0)

   563 			{

   564 			UTRACE_SECONDARY(category, data[1], ETrue, EFalse, KUtracePcValues[1], formatId);

   565 			UTRACE_SECONDARY(category, data[1], ETrue, EFalse, KUtracePcValues[2], formatId);

   566 			}

   567 		else if(size <= 4)

   568 			{

   569 			UTRACE_SECONDARY_4(category, data[1], ETrue, EFalse, KUtracePcValues[1], formatId, data[3]);

   570 			UTRACE_SECONDARY_4(category, data[1], ETrue, EFalse, KUtracePcValues[2], formatId, data[3]);

   571 			}

   572 		else //size > 8

   573 			{

   574 			UTRACE_SECONDARY_ANY(category, data[1], ETrue, EFalse, KUtracePcValues[1], formatId, data+3, size);

   575 			UTRACE_SECONDARY_ANY(category, data[1], ETrue, EFalse, KUtracePcValues[2], formatId, data+3, size);

   576 			}

   577 		}

   578 	else if(type==BTrace::EContextIdPresent+BTrace::EPcPresent)

   579 		{

   580 		if(size <= 0)

   581 			{

   582 			UTRACE_SECONDARY(category, data[1], ETrue, ETrue, KUtracePcValues[1], formatId);

   583 			UTRACE_SECONDARY(category, data[1], ETrue, ETrue, KUtracePcValues[2], formatId);

   584 			}

   585 		else if(size <= 4)

   586 			{

   587 			UTRACE_SECONDARY_4(category, data[1], ETrue, ETrue, KUtracePcValues[1], formatId, data[3]);

   588 			UTRACE_SECONDARY_4(category, data[1], ETrue, ETrue, KUtracePcValues[2], formatId, data[3]);

   589 			}

   590 		else //size > 8

   591 			{

   592 			UTRACE_SECONDARY_ANY(category, data[1], ETrue, ETrue, KUtracePcValues[1], formatId, data+3, size);

   593 			UTRACE_SECONDARY_ANY(category, data[1], ETrue, ETrue, KUtracePcValues[2], formatId, data+3, size);

   594 			}

   595 		}

   596 	else

   597 		{

   598 		if(size <= 0)

   599 			{

   600 			UTRACE_SECONDARY(category, data[1], EFalse, EFalse, KUtracePcValues[1], formatId);

   601 			UTRACE_SECONDARY(category, data[1], EFalse, EFalse, KUtracePcValues[2], formatId);

   602 			}

   603 		else if(size <= 4)

   604 			{

   605 			UTRACE_SECONDARY_4(category, data[1], EFalse, EFalse, KUtracePcValues[1], formatId, data[3]);

   606 			UTRACE_SECONDARY_4(category, data[1], EFalse, EFalse, KUtracePcValues[2], formatId, data[3]);

   607 			}

   608 		else //size > 8

   609 			{

   610 			UTRACE_SECONDARY_ANY(category, data[1], EFalse, EFalse, KUtracePcValues[1], formatId, data+3, size);

   611 			UTRACE_SECONDARY_ANY(category, data[1], EFalse, EFalse, KUtracePcValues[2], formatId, data+3, size);

   612 			}

   613 		}

   615 	}

   617 DECLARE_STANDARD_LDD()

   618 	{

   619 	return new DBTraceTestFactory;

   620 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--