// Copyright (c) 1996-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\notifier.cpp
// DChangeNotifier & DUndertaker code
// Note that both change notifier and undertaker handles can be thread or process relative
// 
//

#include <kernel/kern_priv.h>
#include "execs.h"

#define iMState		iWaitLink.iSpare1

DChangeNotifier::DChangeNotifier()
//
// Constructor
//
	{

	/**************************************************************************
	**   CHANGE THE NEXT LINE IF YOU ADD A NEW ECHANGES... TO THE NOTIFIER   **
	**   But not for EChangesLowMemory!										 **
	**************************************************************************/
	iChanges=EChangesLocale|EChangesMidnightCrossover|EChangesThreadDeath|EChangesPowerStatus|EChangesSystemTime|EChangesFreeMemory|EChangesOutOfMemory|EChangesThrashLevel;
	//iRequest=NULL;
	//iThread=NULL;
	}

TInt DChangeNotifier::Create()
	{
	return Kern::CreateClientRequest(iRequest);
	}

DChangeNotifier::~DChangeNotifier()
//
// Destructor
// Enter and leave with system unlocked.
//
	{
	NKern::LockSystem();
	if (iThread)
		Complete(KErrGeneral);
	else
		NKern::UnlockSystem();
	Kern::DestroyClientRequest(iRequest);
	}


void DChangeNotifier::Complete(TInt aResult)
//
// Complete the client the result code specified
// Enter with system locked, leave with system unlocked.
//
	{
	DThread* t = iThread;
	iChanges = 0;
	iThread = NULL;
	NKern::ThreadEnterCS();
	Kern::QueueRequestComplete(t, iRequest,aResult);
	NKern::UnlockSystem();
	t->Close(NULL);
	NKern::ThreadLeaveCS();
	}


void DChangeNotifier::Notify(TUint aChanges)
//
// Complete logged on status, or save up change.
// Enter with system locked, leave with system unlocked.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("DChangeNotifier::Notify %08x %x",this,aChanges));
	iChanges|=aChanges;
	if (iRequest->IsReady())
		Complete(iChanges);
	else
		NKern::UnlockSystem();
	}


TInt DChangeNotifier::Logon(TRequestStatus& aStatus, DThread* aThread)
//
// Logon to notifier.
// Enter with system locked, return with system unlocked.
//
	{
	if (iRequest->SetStatus(&aStatus) != KErrNone)
		return KErrInUse;
	iThread=aThread;
	iThread->CheckedOpen();
	if (iChanges!=0)
		Complete(iChanges);
	else
		NKern::UnlockSystem();
	return KErrNone;
	}

TInt DChangeNotifier::LogonCancel(DThread* aThread)
//
// Logoff from notifier.
// Enter with system locked, return with system unlocked.
//
	{
	if (iRequest->IsReady() && iThread==aThread)
		{
		Complete(KErrCancel);
		return KErrNone;
		}
	NKern::UnlockSystem();
	return KErrGeneral;
	}

TInt ExecHandler::ChangeNotifierCreate(TOwnerType aType)
//
// Create a change notifier
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChangeNotifierCreate"));
	NKern::ThreadEnterCS();
	DChangeNotifier* pN=new DChangeNotifier;
	TInt r=KErrNoMemory;
	if (pN)
		{
		r=pN->Create();
		if (r==KErrNone)
			r=K::AddObject(pN,EChangeNotifier);
		if (r==KErrNone)
			r=K::MakeHandle(aType,pN);
		if (r<KErrNone)
			pN->Close(NULL);
		}
	NKern::ThreadLeaveCS();
	return r;
	}

TInt ExecHandler::ChangeNotifierLogon(DChangeNotifier* aChangeNotifier, TRequestStatus& aStatus)
//
// Enter with system locked, return with system unlocked.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChangeNotifierLogon"));
	return aChangeNotifier->Logon(aStatus, TheCurrentThread);
	}

TInt ExecHandler::ChangeNotifierLogoff(DChangeNotifier* aChangeNotifier)
//
// Enter with system locked, return with system unlocked.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChangeNotifierLogoff"));
	return aChangeNotifier->LogonCancel(TheCurrentThread);
	}


/** Synchronously notifies all change notifiers of a set of events.

	This call causes all DChangeNotifier objects to record the events indicated
	and to signal their owning thread if it is currently logged on.

	@param	aChanges	The mask of events to be notified (TChanges enumeration)

	@pre    No fast mutex can be held
	@pre    Calling thread must be in a critical section
	@pre	Call in a thread context
	@pre	Kernel must be unlocked
	@pre	interrupts enabled
	
	@see Kern::AsyncNotifyChanges()
	@see TChanges
 */
EXPORT_C void Kern::NotifyChanges(TUint aChanges)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::NotifyChanges");		
	__KTRACE_OPT(KTHREAD,Kern::Printf("Kern::NotifyChanges %x",aChanges));
	DObjectCon& chnot=*K::Containers[EChangeNotifier];
	chnot.Wait();
	TInt c=chnot.Count();
	TInt i;
	for(i=0; i<c; i++)
		{
		DChangeNotifier* pN=(DChangeNotifier*)chnot[i];
		if (pN->Open() == KErrNone)
			{
			NKern::LockSystem();
			pN->Notify(aChanges);
			pN->AsyncClose();
			}
		}
	chnot.Signal();
	}

//
// Thread Watchers
//

TInt DUndertaker::Create()
	{
	return Kern::CreateClientDataRequest(iRequest);
	}

DUndertaker::~DUndertaker()
//
// Destructor
// Enter and return with system unlocked
//
	{
	if (iRequest)
		{
		NKern::LockSystem();
		Complete(KErrGeneral,NULL);
		Kern::DestroyClientRequest(iRequest);
		}
	}

void DUndertaker::Complete(TInt aValue, DThread* aDeadThread)
//
// Complete and delete from queue
// Enter with system locked and, if aDeadThread!=NULL, calling thread in critical section
// Return with system unlocked.
// Must be careful to ensure only one completion can occur
//
	{
	if (!iRequest->IsReady())
		{
		NKern::UnlockSystem();
		return;
		}	
	if (iOwningThread->iMState==DThread::EDead)
		{
		iOwningThread=NULL;
		iRequest->Reset();
		NKern::UnlockSystem();
		return;
		}
	iRequest->Data()=0;
	if (aDeadThread)
		{
		NKern::UnlockSystem();
		// At this point, the undertaker could be logged on again here by another thread in the same
		// process, but this will result in KErrInUse, as that thread can't know that the undertaker
		// has been completed
		iOwningThread->MakeHandleAndOpen(EOwnerThread,aDeadThread,iRequest->Data());
		NKern::LockSystem();
		}
	DThread* t = iOwningThread;
	iOwningThread = NULL;
	Kern::QueueRequestComplete(t, iRequest,aValue);
	NKern::UnlockSystem();
	}

void DUndertaker::Notify(DThread* aDeadThread)
//
// Complete the watcher if someone's logged on to it
// Enter and return with system unlocked
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("DUndertaker::Notify %08x",this));
	NKern::LockSystem();
	Complete(KErrDied,aDeadThread);
	}

TInt DUndertaker::Logon(TRequestStatus* aStatus, TInt* aDeadThreadHandle)
//
// Logon to thread watcher
// Enter and return with system locked
//
	{
	if (iRequest->SetStatus(aStatus) != KErrNone)
		return KErrInUse;
	iRequest->SetDestPtr(aDeadThreadHandle);
	iOwningThread=TheCurrentThread;
	return KErrNone;
	}

TInt DUndertaker::LogonCancel()
//
// Logoff from thread watcher
// Enter with system locked, return with system unlocked.
//
	{
	if (iOwningThread==TheCurrentThread)
		{
		Complete(KErrCancel,NULL);
		return KErrNone;
		}
	NKern::UnlockSystem();
	return KErrGeneral;
	}

TInt ExecHandler::UndertakerCreate(TOwnerType aType)
//
// Create a thread watcher
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::UndertakerCreate"));
	NKern::ThreadEnterCS();
	DUndertaker* pU=new DUndertaker;
	TInt r=KErrNoMemory;
	if (pU)
		{
		r=pU->Create();
		if (r==KErrNone)
			r=K::AddObject(pU,EUndertaker);
		if (r==KErrNone)
			r=K::MakeHandle(aType,pU);
		if (r<KErrNone)
			pU->Close(NULL);
		}
	NKern::ThreadLeaveCS();
	return r;
	}

TInt ExecHandler::UndertakerLogon(DUndertaker *anUndertaker, TRequestStatus& aStatus, TInt* aDeadThreadHandle)
//
// Enter and return with system locked.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::UndertakerLogon"));
	return anUndertaker->Logon(&aStatus,aDeadThreadHandle);
	}

TInt ExecHandler::UndertakerLogonCancel(DUndertaker* anUndertaker)
//
// Enter with system locked, return with system unlocked.
//
	{
	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::UndertakerLogonCancel"));
	return anUndertaker->LogonCancel();
	}


/** Notifies all undertakers of a thread death.

	This call causes all DUndertaker objects to signal their owning thread
	if it is currently logged on. A handle to the dead thread will be created
	for each owning thread signalled.

	@param	aDeadThread Pointer to the deceased thread.
	
	@pre    No fast mutex can be held.
    @pre    Calling thread must be in a critical section.
	@pre	Call in a thread context.
	@pre	Kernel must be unlocked
	@pre	interrupts enabled

	@internalTechnology
 */
EXPORT_C void Kern::NotifyThreadDeath(DThread* aDeadThread)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::NotifyThreadDeath");		
	__KTRACE_OPT(KTHREAD,Kern::Printf("Kern::NotifyThreadDeath %O",aDeadThread));
	DObjectCon& und=*K::Containers[EUndertaker];
	RObjectIx::Wait();
	und.Wait();
	TInt c=und.Count();
	TInt i;
	for (i=0; i<c; i++)
		{
		DUndertaker* pU=(DUndertaker*)und[i];
		if (pU->Open() == KErrNone)
			{
			pU->Notify(aDeadThread);
			pU->AsyncClose();
			}
		}
	und.Signal();
	RObjectIx::Signal();
	}