// 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\kernel\sbtrace.cpp

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#include <e32panic.h>

#include "memmodel.h"

//SBTraceData BTraceData = { {0},0,0 };

TBool DummyBTraceHandler(TUint32,TUint32,const TUint32,const TUint32,const TUint32,const TUint32,const TUint32,const TUint32)

	{

	return EFalse;

	}

void BTrace::Init0()

	{

	BTrace::SetHandler(DummyBTraceHandler);

	TUint32* src = Kern::SuperPage().iInitialBTraceFilter;

	TUint32* srcEnd = src+256/32;

	// always have EMetaTrace enabled if any trace category is enabled...

	TUint32 anySet = 0;

	TUint32* scan = src;

	do anySet |= *scan++;

	while(scan<srcEnd);

	if(anySet)

		SetFilter(BTrace::EMetaTrace,1);

	TInt category = 0;

	do

		{

		TUint32 bits = *src++;

		do

			{

			if(category!=BTrace::EMetaTrace)

				SetFilter(category,(bits&1));

			++category;

			bits >>= 1;

			}

		while(category&31);

		}

	while(src<srcEnd);

	}

EXPORT_C TInt BTrace::Control(BTrace::TControl aFunction, TAny* aArg1, TAny* aArg2)

	{

	return (*BTraceData.iControl)(aFunction, aArg1, aArg2);

	}

EXPORT_C BTrace::THandler BTrace::SetHandler(BTrace::THandler aHandler)

	{

	BTrace::TControlFunction oldControl;

	BTrace::THandler oldHandler;

	SetHandlers(aHandler,0,oldHandler,oldControl);

	return oldHandler;

	}

void TraceFastMutexName(NFastMutex* aMutex, const char* aName)

	{

	TPtrC8 name((const TUint8*)aName);

	BTraceN(BTrace::EFastMutex, BTrace::EFastMutexName, aMutex, 0, name.Ptr(), name.Length());

	}

void TraceDObject(DObject* aObj, TUint aCat, TUint aSub, const char* aName)

	{

	if (!aObj)

		return;

	DObject* owner = aObj->iOwner;

	if (!aObj->iName && aName)

		{

		TPtrC8 name((const TUint8*)aName);

		BTraceN(aCat, aSub, aObj, owner, name.Ptr(), name.Size());

		}

	else

		{

		TKName nameBuf;

		aObj->Name(nameBuf);

		BTraceN(aCat, aSub, aObj, owner, nameBuf.Ptr(), nameBuf.Size());

		}

	}

// IMPORTANT, this function must not be used for objects which have overridden Close()

// because the use of AsyncClose() by this function would then be unsafe

void TraceContainerContents(DObjectCon* aCon, TUint aCat, TUint aSub)

	{

	if (!aCon)

		return;

	NKern::ThreadEnterCS();

	aCon->Wait();

	TInt num = aCon->Count();

	for (TInt i=0; i<num; i++)

		{

		DObject* obj = (DObject*)(*aCon)[i];

		if (obj->Open() == KErrNone)

			{

			TraceDObject(obj, aCat, aSub, 0);

			obj->AsyncClose();

			}

		}

	aCon->Signal();

	NKern::ThreadLeaveCS();

	}

EXPORT_C void BTrace::Prime(TInt aCategory)

	{

	(void)aCategory;

#ifdef BTRACE_CPU_USAGE

	if(aCategory==BTrace::ECpuUsage || aCategory==-1)

		{

		BTraceContext0(BTrace::ECpuUsage,BTrace::ENewThreadContext);

		}

#endif

#if defined(BTRACE_THREAD_IDENTIFICATION) || defined(BTRACE_FLEXIBLE_MEM_MODEL)

	if(aCategory==BTrace::EThreadIdentification || aCategory==BTrace::EFlexibleMemModel || aCategory==-1)

		{

		DObjectCon* processes=Kern::Containers()[EProcess];

		if(processes)

			{

			NKern::ThreadEnterCS();

			DCodeSeg::Wait();	// FMM implementation needs to traverse code seg graph

			processes->Wait();

			TInt numProcesses = processes->Count();

			for(TInt i=0; i<numProcesses; i++)

				{

				DProcess* process = (DProcess*)(*processes)[i];

				if (process->Open() == KErrNone)

					{

					process->BTracePrime(aCategory);

					process->AsyncClose();

					}

				}

			processes->Signal();

			DCodeSeg::Signal();

			NKern::ThreadLeaveCS();

			}

		}

#endif

#if defined(BTRACE_THREAD_IDENTIFICATION) || defined(BTRACE_FLEXIBLE_MEM_MODEL)

	if(aCategory==BTrace::EThreadIdentification || aCategory==BTrace::EFlexibleMemModel || aCategory==-1)

		{

		DObjectCon* threads=Kern::Containers()[EThread];

		if(threads)

			{

			NKern::ThreadEnterCS();

			threads->Wait();

			TInt numThread = threads->Count();

			for(TInt i=0; i<numThread; i++)

				{

				DThread* thread = (DThread*)(*threads)[i];

				if (thread->Open() == KErrNone)

					{

					thread->BTracePrime(aCategory);

					thread->AsyncClose();

					}

				}

			threads->Signal();

			NKern::ThreadLeaveCS();

			}

		}

#endif

#if defined(BTRACE_CHUNKS) || defined(BTRACE_FLEXIBLE_MEM_MODEL)

	if(aCategory==BTrace::EChunks || aCategory==BTrace::EFlexibleMemModel || aCategory==-1)

		{

		DObjectCon* chunks=Kern::Containers()[EChunk];

		if(chunks)

			{

			NKern::ThreadEnterCS();

			chunks->Wait();

			TInt num = chunks->Count();

			for(TInt i=0; i<num; i++)

				{

				DChunk* chunk = (DChunk*)(*chunks)[i];

				if (chunk->Open() == KErrNone)

					{

					chunk->BTracePrime(aCategory);

					chunk->AsyncClose();

					}

				}

			chunks->Signal();

			NKern::ThreadLeaveCS();

			}

		}

#endif

#if defined(BTRACE_CODESEGS) || defined(BTRACE_FLEXIBLE_MEM_MODEL)

	if(aCategory==BTrace::ECodeSegs || aCategory==BTrace::EFlexibleMemModel || aCategory==-1)

		{

		NKern::ThreadEnterCS();

		DCodeSeg::Wait();

		SDblQueLink* anchor=&DCodeSeg::GlobalList.iA;

		SDblQueLink* pL=anchor->iNext;

		for (; pL!=anchor; pL=pL->iNext)

			{

			DCodeSeg* seg=_LOFF(pL,DCodeSeg,iLink);

			seg->CheckedOpen();

			seg->BTracePrime(aCategory);

			seg->CheckedClose();

			}

		DCodeSeg::Signal();

		NKern::ThreadLeaveCS();

		}

#endif

#ifdef BTRACE_PAGING

	if(aCategory==BTrace::EPaging || aCategory==-1)

		{

		BTrace4(BTrace::EPaging,BTrace::EPagingMemoryModel,K::MemModelAttributes & EMemModelTypeMask);

		}

#endif

#ifdef BTRACE_THREAD_PRIORITY

	if(aCategory==BTrace::EThreadPriority || aCategory==-1)

		{

		DObjectCon* threads=Kern::Containers()[EThread];

		if(threads)

			{

			NKern::ThreadEnterCS();

			threads->Wait();

			TInt numThread = threads->Count();

			for(TInt i=0; i<numThread; i++)

				{

				DThread* thread = (DThread*)(*threads)[i];

				DProcess* process = thread->iOwningProcess;

				NThread* nThread = &thread->iNThread;

				BTrace8(BTrace::EThreadPriority,BTrace::EProcessPriority,process,process->iPriority);

				BTrace12(BTrace::EThreadPriority,BTrace::EDThreadPriority,nThread,thread->iThreadPriority,thread->iDefaultPriority);

				BTrace8(BTrace::EThreadPriority,BTrace::ENThreadPriority,nThread,nThread->iPriority);

				}

			threads->Signal();

			NKern::ThreadLeaveCS();

			}

		}

#endif

#ifdef BTRACE_KERNEL_MEMORY

	if(aCategory==BTrace::EKernelMemory || aCategory==-1)

		M::BTracePrime(aCategory);

#endif

#ifdef BTRACE_RAM_ALLOCATOR

	if (aCategory == BTrace::ERamAllocator || aCategory == -1)

		M::BTracePrime(aCategory);

#endif

#ifdef BTRACE_FAST_MUTEX

	if (aCategory == BTrace::EFastMutex || aCategory == -1)

		{

		// Log the Name and Address of the system lock

		TraceFastMutexName(&TheScheduler.iLock, "System Lock");

		TraceFastMutexName(&TMessageQue::MsgLock, "MsgLock");

		TraceFastMutexName(&DObject::Lock, "ObjLock");

		TraceFastMutexName(&TLogon::LogonLock, "LogonLock");

		}

#endif

#ifdef BTRACE_SYMBIAN_KERNEL_SYNC

	if (aCategory == BTrace::ESymbianKernelSync || aCategory == -1)

		{

		TInt i;

		for (i=0; i<ENumObjectTypes; ++i)

			TraceDObject(K::Containers[i]->Lock(), BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceDObject(RObjectIx::HandleMutex, BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceDObject(DCodeSeg::CodeSegLock, BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceDObject(TTickQ::Mutex, BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceDObject(K::MachineConfigMutex, BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceDObject(((RHeapK*)K::Allocator)->Mutex(), BTrace::ESymbianKernelSync, BTrace::EMutexCreate, 0);

		TraceContainerContents(K::Containers[ESemaphore], BTrace::ESymbianKernelSync, BTrace::ESemaphoreCreate);

		TraceContainerContents(K::Containers[EMutex], BTrace::ESymbianKernelSync, BTrace::EMutexCreate);

		TraceContainerContents(K::Containers[ECondVar], BTrace::ESymbianKernelSync, BTrace::ECondVarCreate);

		}

#endif

	}

TBool BTrace::IsSupported(TUint aCategory)

	{

	if(aCategory>255)

		return EFalse;

	switch(aCategory)

		{

	// traces which are always supported...

	case ERDebugPrintf:

	case EKernPrintf:

	case EKernPerfLog:

	case EProfiling:

	case ETest1:

	case ETest2:

		return ETrue;

	// traces which are conditional...

#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

	case EPlatsecPrintf:

		if(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecDiagnostics)

			return ETrue;

		return EFalse;

#endif

#ifdef BTRACE_THREAD_IDENTIFICATION

	case EThreadIdentification:

		return ETrue;

#endif

#ifdef BTRACE_CPU_USAGE

	case ECpuUsage:

		return ETrue;

#endif

#ifdef BTRACE_CLIENT_SERVER

	case EClientServer:

		return ETrue;

#endif

#ifdef BTRACE_REQUESTS

	case ERequests:

		return ETrue;

#endif

#ifdef BTRACE_CHUNKS

	case EChunks:

		return ETrue;

#endif

#ifdef BTRACE_CODESEGS

	case ECodeSegs:

		return ETrue;

#endif

#ifdef BTRACE_PAGING

	case EPaging:

		return ETrue;

#endif

#ifdef BTRACE_THREAD_PRIORITY

	case EThreadPriority:

		return ETrue;

#endif

#ifdef BTRACE_PAGING_MEDIA

	case EPagingMedia:

		return ETrue;

#endif

#ifdef BTRACE_KERNEL_MEMORY

	case EKernelMemory:

		return ETrue;

#endif

	case EHeap:

	case EMetaTrace:

		return ETrue;

#ifdef BTRACE_RAM_ALLOCATOR

	case ERamAllocator:

		return ETrue;

#endif

#ifdef BTRACE_FAST_MUTEX

	case EFastMutex:

		return ETrue;

#endif

#ifdef BTRACE_RESOURCE_MANAGER

    case EResourceManager:

       return ETrue;

#endif

	   case EIic:

		   return ETrue;

#ifdef BTRACE_TRAWEVENT

	case ERawEvent:

		return ETrue;

#endif

#ifdef BTRACE_SYMBIAN_KERNEL_SYNC

	case ESymbianKernelSync:

		return ETrue;

#endif

#ifdef BTRACE_FLEXIBLE_MEM_MODEL

	case EFlexibleMemModel:

		return ETrue;

#endif

	default:

		return aCategory>=128; // all categories >=128 are 'supported'

		}

	}

//

// DBTraceFilter2

//

#ifdef __SMP__

TSpinLock BTraceFilter2Lock(TSpinLock::EOrderBTrace);

#endif

DBTraceFilter2* DBTraceFilter2::iCleanupHead = 0;

DBTraceFilter2* DBTraceFilter2::New(TInt aNumUids)

	{

	DBTraceFilter2* self = (DBTraceFilter2*)Kern::AllocZ(sizeof(DBTraceFilter2)+aNumUids*sizeof(TUint32));

	if (self!=NULL)

		self->iAccessCount = 1;

	return self;

	}

void DBTraceFilter2::Cleanup()

	{

	FOREVER

		{

		TInt irq = __SPIN_LOCK_IRQSAVE(BTraceFilter2Lock);

		DBTraceFilter2* p = iCleanupHead;

		if (p)

			iCleanupHead = p->iCleanupLink;

		__SPIN_UNLOCK_IRQRESTORE(BTraceFilter2Lock, irq);

		if (!p)

			break;

		delete p;

		}

	}

DBTraceFilter2* DBTraceFilter2::Open(DBTraceFilter2*volatile& aFilter2)

	{

	TInt irq = __SPIN_LOCK_IRQSAVE(BTraceFilter2Lock);

	DBTraceFilter2* filter2 = aFilter2;

	if ((TLinAddr)filter2>1u)

		++filter2->iAccessCount;

	__SPIN_UNLOCK_IRQRESTORE(BTraceFilter2Lock, irq);

	return filter2;

	}

void DBTraceFilter2::Close()

	{

	if ((TLinAddr)this<=1u)

		return;

	TInt irq = __SPIN_LOCK_IRQSAVE(BTraceFilter2Lock);

	TInt access = iAccessCount;

	__NK_ASSERT_DEBUG(access>0);

	iAccessCount = access-1;

	if (access==1)

		{

		iCleanupLink = iCleanupHead;

		iCleanupHead = this;

		}

	__SPIN_UNLOCK_IRQRESTORE(BTraceFilter2Lock, irq);

	}

#ifndef __MARM__

TBool DBTraceFilter2::Check(TUint32 aUid)

	{

	TInt l = 0;

	TInt r = iNumUids;

	while(r>l)

		{

		TUint m = (l+r)>>1;

		TUint32 x = iUids[m];

		if(aUid>x)

			l = m+1;

		else if(aUid<x)

			r = m;

		else

			return 1;

		}

	return 0;

	}

#endif

extern void HeapSortUnsigned(TUint* aEntries,TInt aCount);

/**

Sort UIDs and remove duplicates.

Return number of unique uids.

*/

static TInt Sort(TUint32* aUids, TInt aNumUids)

	{

	HeapSortUnsigned((TUint*)aUids,aNumUids);

	TUint32* end = aUids+aNumUids-1;

	// remove duplicates...

	TUint32* src = aUids;

	TUint32* dst = aUids;

	if(src<=end)

		{

		TUint32 a = *src++;

		TUint32 b = a;

		*dst++ = b;

		while(src<=end)

			{

			a = *src++;

			if(a!=b)

				{

				b = a;

				*dst++ = b;

				}

			}

		}

	return dst-aUids;

	}

/**

Remove aUid from list aSrc and store result at aDst.

*/