// 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;

	}