// Copyright (c) 2002-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:

// f32\sfile\sf_thread.cpp

// 

//

#include "sf_std.h"

#include <u32exec.h>

#include "sf_file_cache.h"

#define __CHECK_DRVNUM(d) {__ASSERT_DEBUG(d>=EDriveA && d<=EDriveZ,Fault(EFsThreadBadDrvNum));}

#ifdef __X86__

const TInt KRequestThreadStackSize = 0x4000;

#else

const TInt KRequestThreadStackSize = 0x3000;

#endif

const TInt KFinaliseTimerPeriod = 10 * 1000 * 1000;	// default 10S finalisation timeout

TFsDriveThread FsThreadManager::iFsThreads[KMaxDrives];

TUint FsThreadManager::iMainId=0;

CDisconnectThread* FsThreadManager::iDisconnectThread=NULL;

TUint FsThreadManager::iDisconnectThreadId=0;

TFsDriveThread::TFsDriveThread()

//

//

//

:iIsAvailable(EFalse),iIsSync(EFalse),iThread(NULL),iId(0),iIsHung(EFalse),iMediaChangePending(EFalse)

	{

	TInt r=iFSLock.CreateLocal();

	__ASSERT_ALWAYS(r==KErrNone,Fault(EFsThreadConstructor));

	}

TFsPluginThread::TFsPluginThread()

//

//

//

:iIsAvailable(ETrue),iThread(NULL),iId(0)

	{

	TInt r=iPluginLock.CreateLocal();

	iDriveNumber= KMaxDrives+1;

	__ASSERT_ALWAYS(r==KErrNone,Fault(EFsThreadConstructor));

	}

TInt FsThreadManager::CreateDisconnectThread()

//

// Called just once at startup

//

	{

	__PRINT(_L("Create disconnect thread"));

	TRAPD(r,iDisconnectThread=CDisconnectThread::NewL());

	if(r!=KErrNone)

		return(r);

	TRAP(r,iDisconnectThreadId=iDisconnectThread->StartL());

	if(r!=KErrNone)

		{

		delete(iDisconnectThread);

		iDisconnectThread=NULL;

		iDisconnectThreadId=0;

		}

	__THRD_PRINT2(_L("iDisconnectThread=0x%x id=0x%x"),iDisconnectThread,iDisconnectThreadId);

	return(r);

	}

TBool FsThreadManager::IsDisconnectThread()

//

// Return ETrue if the calling thread is the disconnect thread

//

	{

	return(iDisconnectThreadId==RThread().Id());

	}

TInt FsThreadManager::InitDrive(TInt aDrvNumber,TBool aIsSync)

//

// Create a drive thread

// Should only by called from main file server thread with drive thread unavailable

// 

//

	{

	__PRINT1(_L("FsThreadManager::InitDrive() drive=%d"),aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	__ASSERT_ALWAYS(!t.iIsAvailable,Fault(EThreadManagerInitDrive));

	t.iIsSync=ETrue;

	return ChangeSync(aDrvNumber, aIsSync);

	}

TInt FsThreadManager::ChangeSync(TInt aDrvNumber,TBool aIsSync)

//

// Change if a drive is syncronouse after it has been inishalised.

// Should be called from the main thread.  

// Any pending oporations will be compleated.

//

	{

	__PRINT1(_L("FsThreadManager::ChangeSync() drive=%d"),aDrvNumber);

	__CHECK_DRVNUM(aDrvNumber);

	__CHECK_MAINTHREAD();

	LockDrive(aDrvNumber);

	TFsDriveThread& t=FsThreadManager::GetFsDriveThread(aDrvNumber);

	TInt r=KErrNone;

	if (aIsSync!=t.iIsSync)

		{

		if (!aIsSync)

			{

			if(!t.iThread)

				{

				TRAP(r,t.iThread=CDriveThread::NewL());

				if(r!=KErrNone)

					{

					UnlockDrive(aDrvNumber);

					return(r);

					}

				}

			TRAP(r,t.iId=t.iThread->StartL(aDrvNumber));

			__THRD_PRINT2(_L("Starting thread 0x%x returned %d"),&t,r);

			if(r!=KErrNone)

				aIsSync=ETrue;

			else

				{

				t.iIsSync=EFalse;

				__THRD_PRINT1(_L("drive thread id=0x%x"),t.iId);

				}

			}

		if (aIsSync)

			{

			if (t.iThread)

				{

				t.iThread->CompleteAllRequests(KErrNotReady);

				t.iThread->iExit=ETrue;

				t.iThread=NULL;

				}

			t.iIsSync=ETrue;

			}

		}

	if (r==KErrNone)

		t.iIsAvailable=ETrue;

	UnlockDrive(aDrvNumber);	

	return r;

	}

void FsThreadManager::CloseDrive(TInt aDrvNumber)

//

// Close a drive thread

// Assumes already locked or safe

// If file system in not synchronous then should be called from a drive thread request

//

	{

	__PRINT1(_L("FsThreadManager::CloseDrive() drive=%d"),aDrvNumber);

	__CHECK_DRVNUM(aDrvNumber);

	// no need to cancel requests if synchronous since queued

	if(!FsThreadManager::IsDriveSync(aDrvNumber,EFalse))

		{

		CDriveThread* pT=NULL;

		TInt r=FsThreadManager::GetDriveThread(aDrvNumber,&pT);

		__ASSERT_ALWAYS(r==KErrNone && pT,Fault(EDismountFsDriveThread));

		pT->CompleteAllRequests(KErrNotReady);

		}

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	__ASSERT_ALWAYS(t.iIsAvailable,Fault(EFsThreadDriveClose1));

	if(!t.iIsSync)

		{

		__ASSERT_ALWAYS(FsThreadManager::IsDriveThread(aDrvNumber,EFalse),Fault(EFsThreadDriveClose2));

		StopFinalisationTimer(aDrvNumber);

		// drive thread will exit when request completed

		t.iThread->iExit=ETrue;

		// Ensure that subsequent remounts use a new thread AND a new CDriveThread object - 

		// re-use of the CDriveThread object can lead to deadlock while both old & new threads are active.

		t.iThread = NULL;	

		// Empty the closed file queue for this drive before the thread ends and the CDriveThread object 

		// is deleted because the closed file queue contains a list of CFileCache objects which will 

		// call CRequestThread::RemoveTimer() when closed

		TClosedFileUtils::Remove(aDrvNumber);

		}

	else

		{

		__CHECK_MAINTHREAD();

		t.iIsSync=EFalse;

		}

	t.iIsAvailable=EFalse;

	t.iId=0;

	}

TBool FsThreadManager::IsDriveAvailable(TInt aDrvNumber,TBool aIsLock)

//

//

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	if(aIsLock)

		t.iFSLock.Wait();

	TBool b=t.iIsAvailable;

	if(aIsLock)

		t.iFSLock.Signal();

	__THRD_PRINT2(_L("drive thread %d iIsAvailable=%d"),aDrvNumber,b);

	return(b);

	}

TBool FsThreadManager::IsDriveSync(TInt aDrvNumber,TBool aLock)

//

// 

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	if(aLock)

		t.iFSLock.Wait();

	TBool b=(t.iIsAvailable&&t.iIsSync);

	if(aLock)

		t.iFSLock.Signal();

	__THRD_PRINT2(_L("drive thread %d iIsSync=%d"),aDrvNumber,b);

	return(b);

	}

TInt FsThreadManager::GetDriveThread(TInt aDrvNumber, CDriveThread** aDrvThread)

//

// Assumes locked or called from the drive thread

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	*aDrvThread=NULL;

	TInt r=KErrNone;

	if(!t.iIsAvailable)

		r=KErrNotReady;

	else if(t.iIsSync)

		r=KErrAccessDenied;

	else

		{

		*aDrvThread=t.iThread;

		__ASSERT_DEBUG(*aDrvThread,Fault(EFsThreadGetThread));

		}

	__THRD_PRINT4(_L("GetDriveThread(%d) r %d id=0x%x *aDrvThread=0x%x"),aDrvNumber, r, t.iId, *aDrvThread);

	return r;

	}

void FsThreadManager::LockDrive(TInt aDrvNumber)

//

// Lock the TFsDriveThread object for the aDrvNumber drive

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	__THRD_PRINT1(_L("FsThreadManager::LockDrive(%d)"),aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	t.iFSLock.Wait();

	}

void FsThreadManager::UnlockDrive(TInt aDrvNumber)

//

// Unlock the TFsDriveThread object for the aDrvNumber drive

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	__THRD_PRINT1(_L("FsThreadManager::UnlockDrive(%d)"),aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	t.iFSLock.Signal();

	}

void FsThreadManager::SetDriveHung(TInt aDrvNumber, TBool aIsHung)

	{

	if (aDrvNumber < EDriveA || aDrvNumber > EDriveZ)

		return;

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	// quick exit if hung state not changing or drive thread not available

	if ((!t.iIsAvailable) || (t.iIsHung == aIsHung))

		return;

	t.iFSLock.Wait();

	// Don't clear the hung state if this is a synchronous request

	// and the drive is asynchronous - we need to wait for whatever 

	// asynchronous request caused the hang to complete first.

	TUint id=RThread().Id();

	TBool isDriveThread = t.iIsSync || (!t.iIsSync && t.iId == id);

	__THRD_PRINT3(_L("Set %d Hung %d. Is Drive thread %d"), aDrvNumber, aIsHung, isDriveThread);

	if (!aIsHung && !isDriveThread)

		{

		t.iFSLock.Signal();

		return;

		}

	t.iIsHung = aIsHung;

	// if we're no longer hung, see if there's a media change pending

	// and if so issue one now

	TBool mediaChangePending = EFalse;

	if(!aIsHung)

		{

		mediaChangePending = t.iMediaChangePending;

		t.iMediaChangePending = EFalse;

		}

	t.iFSLock.Signal();

	// If the drive is now hung we must complete all requests in the drive thread's

	// queue - and all subsequent requests - with KErrNotReady to prevent deadlock.

	// For example, the notifier server may try to access the loader but one of the

	// requests in the queue may already belong to the loader.

	if (aIsHung && t.iThread)

		t.iThread->CompleteClientRequests(KErrNotReady);

	if(mediaChangePending)

		FsNotify::DiskChange(aDrvNumber);

	}

TBool FsThreadManager::IsDriveHung(TInt aDrvNumber)

	{

	if (aDrvNumber < EDriveA || aDrvNumber > EDriveZ)

		return EFalse;

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

//	__THRD_PRINT3(_L("Is %d Hung = %d"), aDrvNumber, t.iIsHung);

	return t.iIsHung;

	}

// If the drive is hung, then don't complete any disk change 

// notifications until the request causing the hang completes.

void FsThreadManager::SetMediaChangePending(TInt aDrvNumber)

	{

	if (aDrvNumber < EDriveA || aDrvNumber > EDriveZ)

		return;

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	if (!t.iIsAvailable)

		return;

	t.iFSLock.Wait();

	t.iMediaChangePending = ETrue;

	t.iFSLock.Signal();

	}

void FsThreadManager::SetMainThreadId()

//

// called at file server startup, assumes called from main file server thread

//

	{

	iMainId=RThread().Id();

	__THRD_PRINT1(_L("Main thread id = 0x%x"),iMainId);

	}

TBool FsThreadManager::IsDriveThread(TInt aDrvNumber,TBool aIsLock)

//

// Return ETrue if the calling thread is the aDrvNumber drive thread

//

	{

	__CHECK_DRVNUM(aDrvNumber);

	TFsDriveThread& t=GetFsDriveThread(aDrvNumber);

	TUint id=RThread().Id();

	if(aIsLock)

		t.iFSLock.Wait();

	TBool b = t.iIsAvailable && (!t.iIsSync && t.iId==id || t.iIsSync);

	if(aIsLock)

		t.iFSLock.Signal();

	return(b);

	}

TBool FsThreadManager::IsMainThread()

//

// Returns ETrue if calling thread is same as main file server thread

//

	{

	return((TUint)(RThread().Id())==iMainId);

	}

void FsThreadManager::StartFinalisationTimer(TInt aDrvNumber)

	{

	if (aDrvNumber < EDriveA || aDrvNumber > EDriveZ)

		return;

	// If the message could cause disk modification, make sure that the finalisation

	// timer is queued so that we can mark the disk consistent at some point in the future

	CDriveThread* driveThread=NULL;

	TInt r = GetDriveThread(aDrvNumber, &driveThread);

	if(r == KErrNone && driveThread != NULL)

		driveThread->StartFinalisationTimer();

	}

void FsThreadManager::StopFinalisationTimer(TInt aDrvNumber)

	{

	if (aDrvNumber < EDriveA || aDrvNumber > EDriveZ)

		return;

	// If the message could cause disk modification, make sure that the finalisation

	// timer is queued so that we can mark the disk consistent at some point in the future

	CDriveThread* dT=NULL;

	TInt r = GetDriveThread(aDrvNumber, &dT);

	if(r == KErrNone && dT != NULL)

		{

		dT->StopFinalisationTimer();

		}

	}

CRequestThread::CRequestThread()

//

//

//

:iList(_FOFF(CFsRequest,iLink))

	{

	//iRequest=NULL;

	//iIsWaiting=EFalse;

	iExit=EFalse;

	}

TInt CRequestThread::Initialise()

//

// Initialise

//

	{

	TInt r=iListLock.CreateLocal();

	return(r);

	}

CRequestThread::~CRequestThread()

//

//

//

	{

	__ASSERT_ALWAYS(iList.IsEmpty(),Fault(ERequestThreadDestructor));

	iListLock.Close();

	if(iThread.Handle() != 0)

		{

		iThread.Close();

		}

	delete iTimer;

	}

LOCAL_C TInt ThreadFunction(TAny* aPtr)

//

//

//

	{

	__THRD_PRINT(_L("ThreadFunction()"));

	User::SetCritical(User::ESystemCritical);

	CRequestThread* pT=(CRequestThread*)aPtr;

	TInt r = pT->ThreadFunction();

	delete pT;

	return r;

	}

void CRequestThread::CompleteAllRequests(TInt aValue)

    {

    __THRD_PRINT(_L("CRequestThread::CompleteAllRequests()"));

    iListLock.Wait();

    while(!iList.IsEmpty())

        {

        CFsRequest* pR=iList.First();

        pR->iLink.Deque();

        iListLock.Signal();

        pR->Complete(aValue);

        iListLock.Wait();

        }

    iListLock.Signal();

    __THRD_PRINT(_L("all requests completed"));

    }

TInt CRequestThread::ThreadFunction()

//

// entry point for the thread

//

	{

	iTimer = CFsDeltaTimer::New(*this, EPriorityLess);

	if (iTimer == NULL)

		{

		RThread::Rendezvous(KErrNoMemory);

		return(KErrNone);

		}

	iTimer->iStatus = KErrNotReady;

	CTrapCleanup* trapHandler=CTrapCleanup::New();

	if (trapHandler==NULL)

		{

		RThread::Rendezvous(KErrNoMemory);

		delete iTimer;

		return(KErrNone);

		}

	RThread::Rendezvous(KErrNone);

	TInt err = DoThreadInitialise();

	if(err != KErrNone)

		{

		delete trapHandler;

		return(KErrNone);

		}

	iExit=EFalse;

	iIsWaiting=EFalse;

	// start receiving

	Receive();

	CompleteAllRequests(KErrNotReady);

	delete trapHandler;

	return(KErrNone);

	}

TInt CRequestThread::DoThreadInitialise()