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

//

#include <kernel/emi.h>

#include <kernel/kern_priv.h>

#ifdef __EMI_SUPPORT__

#ifdef __SMP__

#error EMI incompatible with SMP

#endif

// For use with DThread::iEmiFlags

// const TUint8 KThdCreated   = 0; 

const TUint8 KThdStarting     = 1;

const TUint8 KThdRunning      = 2;

const TUint8 KThdExiting      = 3;

const TUint8 KThdEMIStateMask = 3;

const TUint8 KThdUseOldExit   = 4;

const TUint8 KThdReStart      = 8;

// Static inishalization

TThreadExitMonitor   EMI::ExitMonitor    = NULL;

TThreadExitMonitor   EMI::OldExitMonitor = NULL;

TThreadStartMonitor  EMI::StartMonitor   = NULL;

TInt                 EMI::Generation     = 0;

NFastSemaphore*      EMI::ExitSemaphore  = NULL;

NTimer*              EMI::AfterIdleTimer = NULL;

EMI::TAfterIdleState EMI::AfterIdleState = ENone;

TInt                 EMI::AfterIdleDelay = 0;

/** 

@internalComponent

*/

TInt EMI::Init()

	{

	K::TheNullThread->iEmiFlags= KThdRunning;

	ExitSemaphore = new NFastSemaphore();

	if (!ExitSemaphore)

		return KErrNoMemory;

	TheScheduler.iSigma = new NThread();

	return (TheScheduler.iSigma == NULL) ? KErrNoMemory : KErrNone;

	}

//EXPORT_C TInt EMI::TaskEventLogging(TBool aLogging, TInt aLogSize, TThreadStartMonitor aStartMonitor, TThreadExitMonitor aExitMonitor)

/**

Starts or stops the scheduling event logging system.

The function can be called repeatedly to change the configuration of the scheduling event

logging system at any time.

It take pointers to two functions, known as the 'start monitor' and

the 'exit monitor'. 

The 'start monitor' is called when a Symbian OS thread, (a DThread), starts

executing, i.e. after the thread is initially resumed. It should be used

to initialise any data associated with the thread, and to set the thread

as loggable, through a call to SetThreadLoggable(), if scheduling event logging is required.

The 'exit monitor' is called when, and if, a Symbian OS thread, (a DThread) exits.

It should be used to free any resources associated with	the thread.

The initial state of the 'start monitor' and the 'exit monitor' is NULL.

Changing from this joint initial state, by setting one or both, causes all threads

to be initialised to a non-loggable state.

TaskEventLogging() should be protected from possible parallel

invocation, as it does not act atomically.

@param aLogging

	If true, scheduling event logging is enabled.  If false, scheduling event logging is disabled,

	but non-scheduling events can still be logged. The initial state is false.

@param aLogSize

	The number of entries in the internal event log.  If the event buffer is

	filled up, oldest events are deleted to make way for new events and the

	"event lost" flag is set on the event following the deleted event.  A

	value of 0 indicates no event log and no event logging is possible in this

	state.  If an event log already exists, and this value is a different

	size, then all events in the old log will be lost. 

	Changing the event size may result in a memory allocation.  On failure,

	this function returns KErrNoMemory, with logging turned off, and no event

	buffer. Monitors are left as they where before the call.

@param aStartMonitor

	A pointer to the function to be called when a new DThread is started. A value of 

	NULL means that no 'start monitor' function will be called.

	Once this function has been set, it is called for each DThread that

	already exists.  This includes the Idle thread, the Supervisor thread,

	and	DFC threads.  The function is also called for the Sigma thread, which

	accounts for time spent in non-loggable scheduled entities.  Such entities

	would include DThreads that are not fully initialised, or are being

	deleted.

	On return, the 'start monitor' function should return 0 for success or

	a negative value to indicate failure. Note that a failure here may result

	in the creation of the thread failing. Threads that are already running remain running.

@param aExitMonitor

	A pointer to the function to be called when (and if) a DThread

	exits. A value of NULL means that no 'exit monitor' function will be called.

	Before the exit monitor is called, the monitoring of the thread is 

	disabled, i.e. it is set to non-loggable, and all events for the thread are deleted

	from the event log. In reality, the deleted event records are altered so that

	they no longer make any reference to the deleted thread, 

	but instead refer to the Sigma thread. (This gives rise to the possibility of 

	seeing the Sigma thread switching to the Sigma thread) Note that a 

	non-visible thread will still trigger this routine. 

@pre Calling thread must be in a critical section. 

@pre Interrupts must be enabled. 

@pre Kernel must be unlocked. 

@pre No fast mutex can be held. 

@pre Call in a thread context. 

@pre Can be used in a device driver. 

@return KErrNone on success; KErrNoMemory on allocation failure; 

        KErrNotSupported if EMI is not compiled into the kernel.

*/

EXPORT_C TInt EMI::TaskEventLogging(TBool aLogging, TInt aLogSize, TThreadStartMonitor aStartMonitor, TThreadExitMonitor aExitMonitor)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"EMI::TaskEventLogging");	

	TInt error = TaskEventLogging(aLogging, aLogSize);

	if (error == KErrNone)

		ThreadMonitors(aStartMonitor, aExitMonitor);

	return error;

	}

/**

This is equivalent to calling the 4 parameter version of TaskEventLogging(), 

but with the last two parameters remaining unchanged.

@param aLogging If true, scheduling event logging is enabled.  If false,

                scheduling event logging is disabled, but non-scheduling events

                can still be logged. The initial state is false.

@param aLogSize The number of entries in the internal event log.  If the event buffer is

	            filled up, oldest events are deleted to make way for new events and the

	            "event lost" flag is set on the event following the deleted event.  A

	            value of 0 indicates no event log and no event logging is possible in this

	            state.  If an event log already exists, and this value is a different

	            size, then all events in the old log will be lost. 

	            Changing the event size may result in a memory allocation.  On failure,

	            this function returns KErrNoMemory, with logging turned off, and no event

	            buffer. Monitors are left as they where before the call.

@return KErrNone on success; KErrNoMemory on allocation failure; 

        KErrNotSupported if EMI is not compiled into the kernel.

@see TaskEventLogging()

*/

EXPORT_C TInt EMI::TaskEventLogging(TBool aLogging, TInt aLogSize)

	{

	// Alloc/DeAlloc event log.

	// ------------------------  

	// The event log is a ring buffer where iBufferStart is the first valid

	// record, and iBufferEnd is the last.  There is a floating empty slot.

	// To allow for this, one more record the aLogSize is allocated.

	// iBufferTail = next record to be read from.

	// iBufferHead = next record to be written to.

	TInt oldSize;

	TAny* eventBuffer;

	if (TheScheduler.iBufferStart)

		oldSize =(((TInt) TheScheduler.iBufferEnd -

			  (TInt) TheScheduler.iBufferStart) / sizeof(TTaskEventRecord));

	else

		oldSize = 0;

	if (aLogSize != oldSize)

		{

		// Disable logging

		TheScheduler.iLogging = EFalse;

		// Disable buffer use

		eventBuffer = TheScheduler.iBufferStart;

		NKern::Lock();

		TheScheduler.iBufferStart = NULL;

		Generation++;

		NKern::Unlock();

		if (oldSize > 0)

			Kern::Free(eventBuffer);

		if (aLogSize == 0)

			{

			aLogging = EFalse;

			TheScheduler.iBufferEnd = NULL;

			eventBuffer = NULL;

			}

		else if (aLogSize > 0)

			{

			aLogSize *= sizeof(TTaskEventRecord);

			eventBuffer = Kern::Alloc(aLogSize + sizeof(TTaskEventRecord));	// +1 empty slot

			if (eventBuffer != NULL)

				TheScheduler.iBufferEnd = (TAny*) ((TInt) eventBuffer + aLogSize);

			else

				{

				TheScheduler.iBufferEnd = NULL;

				TheScheduler.iLogging = EFalse;

				return KErrNoMemory;

				}

			TheScheduler.iBufferTail = eventBuffer;

			TheScheduler.iBufferHead = eventBuffer;

			}

		else

			{

			K::Fault(K::EBadLogSize);

			}

		//Re-enable buffer use;

		TheScheduler.iBufferStart = eventBuffer;

		}

	// Set Logging 

	// -----------

	TheScheduler.iLogging = aLogging;

	return KErrNone;

	}

/**

This is equivalent to calling the 4 parameter version of TaskEventLogging(), 

but with the first two parameters remaining unchanged.

@param aStartMonitor A pointer to the new 'start monitor' function.

@param aExitMonitor  A pointer to the new 'exit monitor' function.

@see TaskEventLogging()

@pre Calling thread must be in a critical section.

@pre No fast mutex can be held.

@pre ernel must be unlocked

@pre interrupts enabled

@pre Call in a thread context

*/

EXPORT_C void EMI::ThreadMonitors(TThreadStartMonitor aStartMonitor, TThreadExitMonitor aExitMonitor)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"EMI::ThreadMonitors");

	TInt threadNo;

	// Clear loggable

	// -------------- 

	DObjectCon & threadList = *(K::Containers[EThread]);

	// if monitors changed from initial state,

	// iterate thread list unsetting loggable flag.

	if ((StartMonitor == NULL) && (ExitMonitor == NULL)

			&& ((aStartMonitor != NULL) || (aExitMonitor != NULL)))

		{

		threadList.Wait();

		for (TInt i = threadList.Count()-1; i >=0; i--)

			((DThread*) threadList[i])->iNThread.ModifyAttributes(KThreadAttLoggable, 0);

		threadList.Signal();

		}

	// Set Monitors

	// ------------ 

	if ((StartMonitor == aStartMonitor) || (aStartMonitor == NULL))

		{

		StartMonitor = aStartMonitor;

		ExitMonitor = aExitMonitor;

		if ((aStartMonitor == NULL))

			{

			threadList.Wait();

			threadNo = threadList.Count();

			while (threadNo--)

				((DThread*) threadList[threadNo])->iEmiStartMonitor=NULL;

			threadList.Signal();

			}

		}

	else

		{

		TUint currentId = 0;

		TInt count;

		DThread* theThread;

		if (ExitMonitor == aExitMonitor)

			{

			StartMonitor = aStartMonitor;

			}

		else

			{

			// Newly created theads will use new monitors

			// but current threads can use old monitor until

			// new start monitor is called.

			threadList.Wait();

			NKern::Lock();

			OldExitMonitor = ExitMonitor;

			for (threadNo = threadList.Count()-1; threadNo >=0 ; threadNo--)

				{

				((DThread*) threadList[threadNo])->iEmiFlags |= KThdUseOldExit;

				NKern::PreemptionPoint();

				}

			StartMonitor = aStartMonitor;

			ExitMonitor = aExitMonitor;

			NKern::Unlock();

			// Unlocking and relocking acts as Premption point. 

			threadList.Signal();

			}

		// The Sigma thread;

		StartMonitor(TheScheduler.iSigma);

		threadList.Wait();

		// Iterate thead list, calling start monitor.

		theThread = (DThread *) threadList[0];

		currentId = theThread->iId;

		threadNo = -1;

		FOREVER

			{

			if (theThread->iId != currentId)

				{

				// from start find next thread with id>current

				count = threadList.Count();

				for (threadNo = 0; threadNo < count; threadNo++)

					{

					theThread = (DThread*) threadList[threadNo];

					if (theThread->iId > currentId)

						break;

					}

				if (theThread->iId > currentId)	// if found,				  

					currentId = theThread->iId;

				else

					break;

				}

			else

				{

				// move onto next thread

				threadNo++;

				if (threadNo >= threadList.Count())

					break;

				else

					{

					theThread = (DThread*) threadList[threadNo];

					currentId = theThread->iId;

					}

				}

			NKern::Lock();

			if (theThread->iEmiStartMonitor == (TAny*) StartMonitor)

				{

				theThread->iEmiFlags &= KThdEMIStateMask;	// Clear KThdUseOldExit

				NKern::Unlock();

				}

			else

				{

				if ((theThread->iEmiFlags & KThdEMIStateMask) != KThdRunning)

					{

					if ((theThread->iEmiFlags & KThdEMIStateMask) == KThdStarting)	// Old start running					  

						theThread->iEmiStartMonitor = (TAny*) StartMonitor;

					theThread->iEmiFlags &= KThdEMIStateMask;	// Clear KThdUseOldExit

					NKern::Unlock();

					}

				else

					{

					// Use new exit monitor, moniter running.					   

					theThread->iEmiFlags = KThdRunning 	| KThdReStart;	// & !KThdUseOldExit

					NKern::Unlock();

					threadList.Signal();

					StartMonitor(&(theThread->iNThread));

					theThread->iEmiStartMonitor = (TAny*) StartMonitor;

					NKern::Lock();

					if ((theThread->iEmiFlags & KThdEMIStateMask) == KThdExiting)

						{		// It must be waiting for us to finish.

						ExitSemaphore->Signal();

						theThread->iEmiFlags = KThdExiting;	// Clear flags

						}

					else

						theThread->iEmiFlags = KThdRunning;	// Clear flags					  

					NKern::Unlock();

					threadList.Wait();

					//Resync theadNo with theThread, after unlocked period

					if (threadNo >= threadList.Count())	//count could drop														

						threadNo = 0;

					theThread = (DThread*) threadList[threadNo];

					}

				}

			}		

		OldExitMonitor = NULL;	// Transfer compleated.	  

		threadList.Signal();

		}

	}

/**

@internalComponent

*/

void EMI::CallStartHandler(DThread * aDThread)

	{

	TThreadStartMonitor startMonitor;

	TInt result;

	NKern::ThreadEnterCS();

	NKern::Lock();

	aDThread->iEmiStartMonitor = (TAny*) StartMonitor;

	if (OldExitMonitor == ExitMonitor)

		aDThread->iEmiFlags |= KThdStarting;

	else

		aDThread->iEmiFlags = KThdStarting;

	do

		{

		startMonitor = (TThreadStartMonitor) aDThread->iEmiStartMonitor;

		NKern::Unlock();

		if (startMonitor != NULL)

			{

			result = startMonitor (&(aDThread->iNThread));

			if (result < 0)

				{

				NKern::ThreadLeaveCS();

				Kern::Exit(result);

				}

			}

		NKern::Lock();

		}

	while ((TAny*) startMonitor != aDThread->iEmiStartMonitor);

	aDThread->iEmiFlags &= KThdUseOldExit;  // Flag must be preserved as could

	aDThread->iEmiFlags |= KThdRunning; // be about to run diffrent start monitor.

										// if loop above executed, flag is unset.

	NKern::Unlock();

	NKern::ThreadLeaveCS();

	}

/**

@internalComponent

*/

void EMI::CallExitHandler(DThread* aDThread)

	{

	TTaskEventRecord* rec;

	TInt currentGeneration;

	TAny* nThread = (TAny*) &(aDThread->iNThread);

	TThreadExitMonitor exitMonitor;

	// Set thread non-loggable

	((NThread*) nThread)->ModifyAttributes(KThreadAttLoggable, 0);

	// Clear event log

	NKern::Lock();

	if (TheScheduler.iBufferStart != NULL)

		{

		currentGeneration = Generation;

		rec = (TTaskEventRecord*) TheScheduler.iBufferHead;

		while ((rec != TheScheduler.iBufferTail) && (currentGeneration == Generation))

			{

			rec--;

			if (rec < TheScheduler.iBufferStart)

				rec = (TTaskEventRecord*) TheScheduler.iBufferEnd;

			if (rec->iPrevious == nThread)

				rec->iPrevious = TheScheduler.iSigma;

			if (rec->iNext == nThread)

				rec->iNext = TheScheduler.iSigma;

			NKern::PreemptionPoint();

			}

		}

	if ((aDThread->iEmiFlags & KThdEMIStateMask) != KThdRunning)

		{

		// Thread died before it started running - dont call VEMs function.

		aDThread->iEmiFlags	|= KThdExiting;	

		NKern::Unlock();

		}

	else

		{

		aDThread->iEmiFlags	|= KThdExiting;	// No further calls to Start monitor.