// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\drivers\trace\btrace.cpp

 // 

 //

 #include <kernel/kern_priv.h>

 #include "platform.h"

 #include "drivers/btrace.h"

 #if defined(__EPOC32__) && defined(__CPU_X86)

 #include <x86.h>

 #endif

 TBTraceBufferK Buffer;

 TBool ChannelOpen = EFalse;

 const TUint KCopyBufferMaxSize = 0x10000;

 TInt TBTraceBufferK::Create(TInt aSize)

 	{

 	if(aSize<=0)

 		return KErrArgument;

 	TUint pageSize = Kern::RoundToPageSize(1);

 	aSize = (aSize+pageSize-1)&-(TInt)pageSize;

 	TUint recordOffsets = aSize+pageSize;

 	TUint recordOffsetsSize = Kern::RoundToPageSize(aSize>>2);

 	TUint copyBuffer = recordOffsets+recordOffsetsSize+pageSize;

 	TUint copyBufferSize = Kern::RoundToPageSize(aSize>>2);

 	if(copyBufferSize>KCopyBufferMaxSize)

 		copyBufferSize = KCopyBufferMaxSize;

 	TUint chunkSize = copyBuffer+copyBufferSize+pageSize;

 	// Create chunk...

     TChunkCreateInfo info;

     info.iType         = TChunkCreateInfo::ESharedKernelSingle;

     info.iMaxSize      = chunkSize;

 #ifdef __EPOC32__

 	// we want full caching, no execute, default sharing

 	new (&info.iMapAttr) TMappingAttributes2(EMemAttNormalCached, EFalse, ETrue);

 #endif

     info.iOwnsMemory   = ETrue; // Use memory from system's free pool

     info.iDestroyedDfc = NULL;

 	TUint32 mapAttr;

 	TInt r = Kern::ChunkCreate(info, iBufferChunk, iAddress, mapAttr);

 	if(r==KErrNone)

 		r = Kern::ChunkCommit(iBufferChunk, 0, aSize);

 	if(r==KErrNone)

 		r = Kern::ChunkCommit(iBufferChunk, recordOffsets, recordOffsetsSize);

 	if(r==KErrNone)

 		r = Kern::ChunkCommit(iBufferChunk, copyBuffer, copyBufferSize);

 	// Check errors...

 	if(r!=KErrNone)

 		{

 		Close();

 		return r;

 		}

 	// Initialise state...

 	iStart = sizeof(TBTraceBuffer);

 	iEnd = aSize;

 	iRecordOffsets = (TUint8*)(iAddress+recordOffsets);

 	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

 	userBuffer->iRecordOffsets = recordOffsets;

 	userBuffer->iCopyBuffer = copyBuffer;

 	userBuffer->iCopyBufferSize = copyBufferSize;

 	Reset(0);

 #ifndef __SMP__

 	TInt irq = NKern::DisableAllInterrupts();

 #endif

 	iTimestamp2Enabled = EFalse;

 	BTrace::SetHandlers(TBTraceBufferK::Trace,TBTraceBufferK::ControlFunction,iOldBTraceHandler,iOldBTraceControl);

 #ifndef __SMP__

 	NKern::RestoreInterrupts(irq);

 #endif

 	return KErrNone;

 	}

 void TBTraceBufferK::Close()

 	{

 #ifdef __SMP__

 	if(iOldBTraceHandler)

 		{

 		BTrace::THandler handler;

 		BTrace::TControlFunction control;

 		BTrace::SetHandlers(iOldBTraceHandler,iOldBTraceControl,handler,control);

 		iOldBTraceHandler = NULL;

 		iOldBTraceControl = NULL;

 		}

 	TSpinLock* sl = BTrace::LockPtr();

 	TInt irq = sl->LockIrqSave();	// guarantees handler can't run at the same time

 	DChunk* chunk = iBufferChunk;

 	iBufferChunk = NULL;

 	iAddress = NULL;

 	sl->UnlockIrqRestore(irq);

 #else

 	TInt irq = NKern::DisableAllInterrupts();

 	if(iOldBTraceHandler)

 		{

 		BTrace::THandler handler;

 		BTrace::TControlFunction control;

 		BTrace::SetHandlers(iOldBTraceHandler,iOldBTraceControl,handler,control);

 		iOldBTraceHandler = NULL;

 		iOldBTraceControl = NULL;

 		}

 	DChunk* chunk = iBufferChunk;

 	iBufferChunk = NULL;

 	iAddress = NULL;

 	NKern::RestoreInterrupts(irq);

 #endif

 	if(chunk)

 		Kern::ChunkClose(chunk);

 	}

 /**

 Helper functions for encoding pseudo- floating point values recoverable by:

 	int exponent = (signed char)(encoded_val >> 24);

 	int mantissa = encoded_val & 0xFFFFFF;

 	double val = mantissa * pow(2, exponent);

 */

 TUint EncodeFloatesque(TUint64 val64, TInt exponent)

 	{

 	// Lose precision until it fits in 24 bits

 	TInt round_up = 0;

 	while (val64>=0x1000000) 

 		{

 		round_up = (TInt)(val64&1);

 		val64 >>= 1;

 		exponent++;

 		}

 	if (round_up) 

 		{

 		val64++;

 		if (val64>=0x1000000) 

 			{

 			val64 >>= 1;

 			exponent++;

 			}

 		}

 	// Return 8-bit exponent and 24-bit mantissa

 	return (TUint)(val64 | (((unsigned char)exponent)<<24));

 	}

 TUint EncodeReciprocal(TUint val)

 	{

 	if (val==0) return val;

 	// Get reciprocal * 2^64

 	TUint64 val64 = val;

 	TUint64 div = 0;

 	div--;

 	val64 = div / val64;

 	return EncodeFloatesque(val64, -64);

 	}

 TUint EncodePostDiv(TUint val, TUint divisor)

 	{

 	TUint64 val64 = val;

 	val64 <<= 32;

 	val64 = val64 / divisor;

 	return EncodeFloatesque(val64, -32);

 	}

 void BTracePrimeMetatrace()

 	{

 #ifdef __SMP__

 	TUint period1 = EncodeReciprocal(NKern::TimestampFrequency());

 	TUint period2 = period1 + (32u<<24);	// timestamp2 period is 2^32 * timestamp1 period

 	BTrace12(BTrace::EMetaTrace, BTrace::EMetaTraceTimestampsInfo, period1, period2, 1);

 #else

 	TUint period1 = EncodeReciprocal(NKern::FastCounterFrequency());

 	TUint period2 = EncodePostDiv(NKern::TickPeriod(), 1000000);

 	BTrace12(BTrace::EMetaTrace, BTrace::EMetaTraceTimestampsInfo, period1, period2, 0);

 #endif

 	}

 void TBTraceBufferK::Reset(TUint aMode)

 	{

 #ifdef __SMP__

 	TSpinLock* sl = BTrace::LockPtr();

 #endif

 	TInt irq = __SPIN_LOCK_IRQSAVE(*sl);	// guarantees handler can't run at the same time

 	iHead = iStart;

 	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

 	userBuffer->iStart = iStart;

 	userBuffer->iEnd = iEnd;

 	userBuffer->iHead = iHead;

 	userBuffer->iTail = iHead;

 	userBuffer->iGeneration = 0;

 	userBuffer->iMode = aMode;

 	__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

 	if(aMode)

 		{

 		if (BTrace::CheckFilter(BTrace::EMetaTrace))

 			BTracePrimeMetatrace();

 		BTrace::Prime();

 		}

 	}

 TInt TBTraceBufferK::RequestData(TInt aSize, TDfc* aDfc)

 	{

 	if(aSize<=0)

 		aSize = 1;

 #ifdef __SMP__

 	TSpinLock* sl = BTrace::LockPtr();

 #endif

 	TInt irq = __SPIN_LOCK_IRQSAVE(*sl);	// guarantees handler can't run

 	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

 	if(!userBuffer)

 		{

 		__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

 		return KErrNotReady;

 		}

 	TInt dif = userBuffer->iTail-iHead;

 	if(dif>0)

 		aSize = 0; // we need no more bytes because all bytes to end of buffer are available

 	else

 		aSize += dif; // number of bytes extra we need

 	if(aSize>0)

 		{

 		iRequestDataSize = aSize;

 		iWaitingDfc = aDfc;

 		}

 	__SPIN_UNLOCK_IRQRESTORE(*sl,irq);

 	if(aSize<=0)

 		return KErrCompletion;

 	return KErrNone;

 	}

 #ifndef BTRACE_DRIVER_MACHINE_CODED

 TBool TBTraceBufferK::Trace_Impl(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra, const TUint32 aPc, TBool aIncTimestamp2)

 	{

 #ifndef __SMP__

 	TInt irq = NKern::DisableAllInterrupts();

 #endif

 #ifdef __SMP__

 	// Header 2 always present and contains CPU number

 	// If Header2 not originally there, add 4 to size

 	if (!(aHeader&(BTrace::EHeader2Present<<BTrace::EFlagsIndex*8)))

 		aHeader += (4<<BTrace::ESizeIndex*8) + (BTrace::EHeader2Present<<BTrace::EFlagsIndex*8), aHeader2=0;

 	aHeader2 = (aHeader2 &~ BTrace::ECpuIdMask) | (NKern::CurrentCpu()<<20);

 #endif

 #ifdef BTRACE_INCLUDE_TIMESTAMPS

 	// Add timestamp to trace...

 #if defined(__SMP__)

 	aHeader += 8<<BTrace::ESizeIndex*8;

 	aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8 | BTrace::ETimestamp2Present<<BTrace::EFlagsIndex*8;

 	TUint64 timeStamp = NKern::Timestamp();

 #elif defined(__EPOC32__) && defined(__CPU_X86)

 	aHeader += 8<<BTrace::ESizeIndex*8;

 	aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8 | BTrace::ETimestamp2Present<<BTrace::EFlagsIndex*8;

 	TUint64 timeStamp = X86::Timestamp();

 #else

 	TUint32 timeStamp = NKern::FastCounter();

 	TUint32 timeStamp2 = 0;

 	if (aIncTimestamp2)

 		{

 		timeStamp2 = NKern::TickCount();

 		aHeader += 8<<BTrace::ESizeIndex*8;

 		aHeader |= (BTrace::ETimestampPresent | BTrace::ETimestamp2Present) << BTrace::EFlagsIndex*8;

 		}

 	else

 		{

 		aHeader += 4<<BTrace::ESizeIndex*8;

 		aHeader |= BTrace::ETimestampPresent<<BTrace::EFlagsIndex*8;

 		}

 #endif

 #endif

 	TUint size = (aHeader+3)&0xfc;

 	TBTraceBufferK& buffer = Buffer;

 	TLinAddr address = buffer.iAddress;

 	TBTraceBuffer& user_buffer = *(TBTraceBuffer*)address;

 	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

 #ifdef __SMP__

 	__e32_memory_barrier();

 #endif

 	TUint start = buffer.iStart;

 	TUint end = buffer.iEnd;

 	TUint orig_head = buffer.iHead;

 	TInt requestDataSize = buffer.iRequestDataSize;

 	TUint8* recordOffsets = buffer.iRecordOffsets;

 	TUint32 orig_tail = user_buffer.iTail;

 	TUint32 newHead, head, tail;

 	if(!(user_buffer.iMode&RBTrace::EEnable))

 		goto trace_off;

 retry:

 	head = orig_head;

 	tail = orig_tail &~ 1;

 	newHead = head+size;

 	if(newHead>end)

 		{

 		requestDataSize = 0; 

 		newHead = start+size;

 		if(head<tail || tail<newHead+1)

 			{

 			if(!(user_buffer.iMode&RBTrace::EFreeRunning))

 				goto trace_dropped;

 			user_buffer.iWrap = head;

 			head = start;

 			tail = newHead+(recordOffsets[newHead>>2]<<2);

 			goto overwrite;

 			}

 		user_buffer.iWrap = head;

 		head = start;

 		}

 	else if(head<tail && tail<=newHead)

 		{

 		{

 		requestDataSize = 0; 

 		TUint wrap = user_buffer.iWrap;

 		if(!(user_buffer.iMode&RBTrace::EFreeRunning))

 			goto trace_dropped;

 		if(newHead<end && newHead<wrap)

 			{

 			tail = newHead+(recordOffsets[newHead>>2]<<2);

 			if(tail>=end || tail>=wrap)

 				tail = start;

 			}

 		else

 			tail = start;

 		}

 overwrite:

 		*(TUint32*)(address+tail) |= BTrace::EMissingRecord<<(BTrace::EFlagsIndex*8);

 		if (!__e32_atomic_cas_ord32(&user_buffer.iTail, &orig_tail, tail|1))

 			goto retry;	// go round again if user side has already updated the tail pointer

 		}

 	buffer.iRequestDataSize = requestDataSize-size;

 	{

 	recordOffsets += head>>2;

 	TUint32* src;

 	TUint32* dst = (TUint32*)((TUint)address+head);

 	size >>= 2; // we are now counting words, not bytes

 	// store first word of trace...

 	TUint w = aHeader;

 	if(buffer.iDropped)

 		{

 		buffer.iDropped = 0;

 		w |= BTrace::EMissingRecord<<(BTrace::EFlagsIndex*8); 

 		}

 	*recordOffsets++ = (TUint8)size;

 	--size;

 	*dst++ = w;

 #ifndef __SMP__

 	if(aHeader&(BTrace::EHeader2Present<<(BTrace::EFlagsIndex*8)))

 #endif

 		{

 		w = aHeader2;

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = w;

 		}

 #ifdef BTRACE_INCLUDE_TIMESTAMPS

 	// store timestamp...

 #if defined(__SMP__) || (defined(__EPOC32__) && defined(__CPU_X86))

 	*recordOffsets++ = (TUint8)size;

 	--size;

 	*dst++ = TUint32(timeStamp);

 	*recordOffsets++ = (TUint8)size;

 	--size;

 	*dst++ = TUint32(timeStamp>>32);

 #else

 	*recordOffsets++ = (TUint8)size;

 	--size;

 	*dst++ = timeStamp;

 	if (aIncTimestamp2)

 		{

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = timeStamp2;

 		}

 #endif

 #endif

 	if(aHeader&(BTrace::EContextIdPresent<<(BTrace::EFlagsIndex*8)))

 		{

 		w = aContext;

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = w;

 		}

 	if(aHeader&(BTrace::EPcPresent<<(BTrace::EFlagsIndex*8)))

 		{

 		w = aPc;

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = w;

 		}

 	if(aHeader&(BTrace::EExtraPresent<<(BTrace::EFlagsIndex*8)))

 		{

 		w = aExtra;

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = w;

 		}

 	// store remainding words of trace...

 	if(size)

 		{

 		w = a1;

 		*recordOffsets++ = (TUint8)size;

 		--size;

 		*dst++ = w;

 		if(size)

 			{

 			w = a2;

 			*recordOffsets++ = (TUint8)size;

 			--size;

 			*dst++ = w;

 			if(size)

 				{

 				if(size==1)

 					{

 					w = a3;

 					*recordOffsets++ = (TUint8)size;

 					*dst++ = w;

 					}

 				else

 					{

 					src = (TUint32*)a3;

 					do

 						{

 						w = *src++;

 						*recordOffsets++ = (TUint8)size;

 						--size;

 						*dst++ = w;

 						}

 					while(size);

 					}

 				}

 			}

 		}

 	}

 	buffer.iHead = newHead;

 #ifdef __SMP__

 	__e32_memory_barrier();	// make sure written data is observed before head pointer update

 #endif

 	user_buffer.iHead = newHead;

 	{

 	TDfc* dfc = (TDfc*)buffer.iWaitingDfc;

 	if(dfc && buffer.iRequestDataSize<=0)

 		{

 		buffer.iWaitingDfc = NULL;

 		dfc->RawAdd();

 		}

 	}

 #ifdef __SMP__

 	__e32_memory_barrier();

 #endif

 	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

 #ifndef __SMP__

 	NKern::RestoreInterrupts(irq);

 #endif

 	return ETrue;

 trace_dropped:

 	buffer.iRequestDataSize = 0; 

 	buffer.iDropped = ETrue;

 #ifdef __SMP__

 	__e32_memory_barrier();

 #endif

 	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

 #ifndef __SMP__

 	NKern::RestoreInterrupts(irq);

 #endif

 	return ETrue;

 trace_off:

 #ifdef __SMP__

 	__e32_memory_barrier();

 #endif

 	++user_buffer.iGeneration;	// atomic not required since only driver modifies iGeneration

 #ifndef __SMP__

 	NKern::RestoreInterrupts(irq);

 #endif

 	return EFalse;

 	}

 TBool TBTraceBufferK::TraceWithTimestamp2(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra,const TUint32 aPc)

 	{

 	return Trace_Impl(aHeader, aHeader2, aContext, a1, a2, a3, aExtra, aPc, ETrue);

 	}

 TBool TBTraceBufferK::Trace(TUint32 aHeader,TUint32 aHeader2,const TUint32 aContext,const TUint32 a1,const TUint32 a2,const TUint32 a3,const TUint32 aExtra,const TUint32 aPc)

 	{

 	return Trace_Impl(aHeader, aHeader2, aContext, a1, a2, a3, aExtra, aPc, EFalse);

 	}

 #endif // BTRACE_DRIVER_MACHINE_CODED

 TInt TBTraceBufferK::ControlFunction(BTrace::TControl aFunction, TAny* aArg1, TAny* aArg2)

 	{

 	switch(aFunction)

 		{

 	case BTrace::ECtrlSystemCrashed:

 		if(Buffer.iAddress)

 			((TBTraceBuffer*)Buffer.iAddress)->iMode = 0; // turn off trace

 		return KErrNone;

 	case BTrace::ECtrlCrashReadFirst:

 		Buffer.iCrashReadPart = 0;

 		// fall through...

 	case BTrace::ECtrlCrashReadNext:

 		Buffer.CrashRead(*(TUint8**)aArg1,*(TUint*)aArg2);

 		++Buffer.iCrashReadPart;

 		return KErrNone;

 	default:

 		return KErrNotSupported;

 		}

 	}

 void TBTraceBufferK::CrashRead(TUint8*& aData, TUint& aSize)

 	{

 	// start by assuming no data...

 	aData = 0;

 	aSize = 0;

 	TBTraceBuffer* userBuffer = (TBTraceBuffer*)iAddress;

 	if(!userBuffer)

 		return; // no trace buffer, so end...

 	TUint head = iHead;

 	TUint tail = userBuffer->iTail;

 	TUint8* data = (TUint8*)userBuffer;

 	if(head>tail)

 		{

 		// data is in one part...

 		if(iCrashReadPart==0)

 			{

 			aData = data+tail;

 			aSize = head-tail;

 			}

 		// else no more parts

 		}

 	else if(head<tail)

 		{

 		// data is in two parts...

 		if(iCrashReadPart==0)

 			{

 			// first part...

 			aData = data+tail;

 			aSize = userBuffer->iWrap-tail;

 			}

 		else if(iCrashReadPart==1)

 			{

 			// second part...

 			aData = data+iStart;

 			aSize = head-iStart;

 			}

 		// else no more parts

 		}

 	}

 //

 // LDD

 //

 class DBTraceFactory : public DLogicalDevice

 	{

 public:

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DBTraceChannel : public DLogicalChannelBase

 	{

 public:

 	DBTraceChannel();

 	virtual ~DBTraceChannel();

 	//	Inherited from DObject

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

 	// Inherited from DLogicalChannelBase

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

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

 	//

 	static void WaitCallback(TAny* aSelf);

 private:

 	DThread* iClient;

 	TClientRequest*	iWaitRequest;

 	TDfc iWaitDfc;

 	TBool iOpened;

 	TInt iFilter2Count;

 	TUint32* iFilter2;

 	TUint32* iFilter2Set;

 	TBool iTimestamp2Enabled;

 	};

 //

 // DBTraceFactory

 //

 TInt DBTraceFactory::Install()

 	{

 	return SetName(&RBTrace::Name());

 	}

 void DBTraceFactory::GetCaps(TDes8& aDes) const

 	{

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

 	}

 TInt DBTraceFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 	aChannel=new DBTraceChannel();

 	if(!aChannel)

 		return KErrNoMemory;

 	return KErrNone;

 	}

 void syncDfcFn(TAny* aPtr)

 	{

 	NKern::FSSignal((NFastSemaphore*)aPtr);

 	}

 void Sync(TDfcQue* aDfcQ)

 	{

 	NFastSemaphore s(0);

 	TDfc dfc(&syncDfcFn, &s, aDfcQ, 0);

 	dfc.Enque();

 	NKern::FSWait(&s);

 	}

 //

 // DBTraceChannel

 //

 DBTraceChannel::DBTraceChannel()

 	: iWaitDfc(WaitCallback,this,Kern::DfcQue1(),7)

 	{

 	}

 DBTraceChannel::~DBTraceChannel()

 	{

 	delete iFilter2Set;

 	Buffer.iWaitingDfc = NULL;

 	iWaitDfc.Cancel();

 	Sync(Kern::DfcQue1());

 	if (iWaitRequest)

 		{

 		Kern::QueueRequestComplete(iClient, iWaitRequest, KErrCancel);	// does nothing if request not pending

 		Kern::DestroyClientRequest(iWaitRequest);

 		}

 	if (iOpened)

 		__e32_atomic_swp_ord32(&ChannelOpen, 0);

 	}

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

 	{

 //	_LIT_SECURITY_POLICY_C2(KSecurityPolicy,ECapabilityReadDeviceData,ECapabilityWriteDeviceData);

 //	if(!KSecurityPolicy().CheckPolicy(&Kern::CurrentThread(),__PLATSEC_DIAGNOSTIC_STRING("Checked by BTRACE")))

 //		return KErrPermissionDenied;

 	iClient = &Kern::CurrentThread();

 	TInt r = Kern::CreateClientRequest(iWaitRequest);

 	if (r!=KErrNone)

 		return r;

 	if (__e32_atomic_swp_ord32(&ChannelOpen, 1))

 		return KErrInUse;

 	iOpened = ETrue;

 	return KErrNone;

 	}

 TInt DBTraceChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)

 	{

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

 		return KErrAccessDenied;

 	return KErrNone;

 	}

 void DBTraceChannel::WaitCallback(TAny* aSelf)

 	{

 	DBTraceChannel& c = *(DBTraceChannel*)aSelf;

 	Kern::QueueRequestComplete(c.iClient, c.iWaitRequest, KErrNone);

 	}

 TInt DBTraceChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

 	{

 	TInt r;

 	TBTraceBufferK& buffer = Buffer;

 	switch(aReqNo)

 		{

 	case RBTrace::EOpenBuffer:

 		NKern::ThreadEnterCS();

 		if(!Buffer.iBufferChunk)

 			r = buffer.Create(0x100000);

 		else

 			r = KErrNone;

 		if(r==KErrNone)

 			r = Kern::MakeHandleAndOpen(NULL, buffer.iBufferChunk);

 		NKern::ThreadLeaveCS();

 		return r;

 	case RBTrace::EResizeBuffer:

 		NKern::ThreadEnterCS();

 		buffer.Close();

 		r = buffer.Create((TInt)a1);

 		NKern::ThreadLeaveCS();

 		return r;

 	case RBTrace::ESetFilter:

 		{

 		TInt old = BTrace::SetFilter((BTrace::TCategory)(TInt)a1,(TInt)a2);

 		if((TInt)a2==1 && old==0) // filter turned on?

 			{

 			if ((TInt)a1==BTrace::EMetaTrace) 

 				BTracePrimeMetatrace();

 			BTrace::Prime((TInt)a1); // prime this trace category

 			}

 		return old;

 		}

 	case RBTrace::ESetFilter2:

 		return BTrace::SetFilter2((TUint32)a1,(TBool)a2);

 	case RBTrace::ESetFilter2Array:

 		{

 		NKern::ThreadEnterCS();

 		delete iFilter2Set;

 		TInt size = (TInt)a2*sizeof(TUint32);

 		TUint32* buffer = (TUint32*)Kern::Alloc(size);

 		iFilter2Set = buffer;

 		NKern::ThreadLeaveCS();

 		if(!buffer)

 			return KErrNoMemory;

 		kumemget32(buffer,a1,size);

 		r = BTrace::SetFilter2(buffer,(TInt)a2);

 		NKern::ThreadEnterCS();

 		delete iFilter2Set;

 		iFilter2Set = 0;

 		NKern::ThreadLeaveCS();

 		return r;

 		}

 	case RBTrace::ESetFilter2Global:

 		BTrace::SetFilter2((TBool)a1);

 		return KErrNone;

 	case RBTrace::EGetFilter2Part1:

 		{

 		NKern::ThreadEnterCS();

 		delete iFilter2;

 		iFilter2 = 0;

 		iFilter2Count = 0;

 		TInt globalFilter = 0;

 		iFilter2Count = BTrace::Filter2(iFilter2,globalFilter);

 		NKern::ThreadLeaveCS();

 		kumemput32(a2,&globalFilter,sizeof(TBool));

 		return iFilter2Count;

 		}

 	case RBTrace::EGetFilter2Part2:

 		if((TInt)a2!=iFilter2Count)

 			return KErrArgument;

 		if(iFilter2Count>0)

 			kumemput32(a1,iFilter2,iFilter2Count*sizeof(TUint32));

 		NKern::ThreadEnterCS();

 		delete iFilter2;

 		iFilter2 = 0;

 		iFilter2Count = 0;

 		NKern::ThreadLeaveCS();

 		return KErrNone;

 	case RBTrace::ERequestData:

 		if (iWaitRequest->SetStatus((TRequestStatus*)a1) != KErrNone)

 			Kern::PanicCurrentThread(RBTrace::Name(),RBTrace::ERequestAlreadyPending);

 		r = buffer.RequestData((TInt)a2,&iWaitDfc);

 		if (r!=KErrNone)

 			{

 			iWaitRequest->Reset();

 			TRequestStatus* s = (TRequestStatus*)a1;

 			if (r==KErrCompletion)

 				r = KErrNone;

 			Kern::RequestComplete(s, r);

 			}

 		return r;

 	case RBTrace::ECancelRequestData:

 		buffer.iWaitingDfc = NULL;

 		iWaitDfc.Cancel();

 		Kern::QueueRequestComplete(iClient, iWaitRequest, KErrCancel);

 		return KErrNone;

 	case RBTrace::ESetSerialPortOutput:

 		{

 		TUint mode = Kern::ESerialOutNever+(TUint)a1;

 		mode = Kern::SetTextTraceMode(mode,Kern::ESerialOutMask);

 		mode &= Kern::ESerialOutMask;

 		return mode-Kern::ESerialOutNever;

 		}

 	case RBTrace::ESetTimestamp2Enabled:

 		{

 		TBool old = iTimestamp2Enabled;

 		iTimestamp2Enabled = (TBool)a1;

 		BTrace::TControlFunction oldControl;

 		BTrace::THandler oldHandler;

 		BTrace::THandler handler = iTimestamp2Enabled ? TBTraceBufferK::TraceWithTimestamp2 : TBTraceBufferK::Trace;

 		BTrace::SetHandlers(handler,TBTraceBufferK::ControlFunction,oldHandler,oldControl);

 		return old;

 		}

 	default:

 		break;

 		}

 	return KErrNotSupported;

 	}

 DECLARE_EXTENSION_LDD()

 	{

 	return new DBTraceFactory;

 	}

 #ifdef __WINS__

 DECLARE_STANDARD_EXTENSION()

 #else

 DECLARE_EXTENSION_WITH_PRIORITY(KExtensionMaximumPriority)

 #endif

 	{

 	TSuperPage& superPage = Kern::SuperPage();

 	TInt bufferSize = superPage.iInitialBTraceBuffer;

 	if(!bufferSize)

 		bufferSize = 0x10000;

 	TInt r=Buffer.Create(bufferSize);

 	if(r==KErrNone)

 		Buffer.Reset(superPage.iInitialBTraceMode);

 	return r;

 	}