// 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()

	{

	return KErrNone;

	}

TInt CRequestThread::DoStart(RThread& aThread)

//

// create thread and return handle

// necessary for client to close thread handle if successful

//

	{

	TInt r=aThread.Create(KNullDesC,::ThreadFunction,KRequestThreadStackSize,NULL,(TAny*)this);

	__PRINT1(_L("CRequestThread::DoStart() r=%d"),r);

	if(r!=KErrNone)

		return(r);

	TRequestStatus status;

	aThread.Rendezvous(status);

	if(status==KRequestPending)

		{

		aThread.SetPriority(EPriorityLess);

		aThread.Resume();

		}

	else

		{

		aThread.Kill(0);

		}

	User::WaitForRequest(status);

	r = status.Int();

	if(r!=KErrNone)

		aThread.Close();

	else

		iThread = aThread;

	return(r);

	}

void CRequestThread::Receive()

//

// Receive and process requests

//

	{

	FOREVER

		{

		iListLock.Wait();

		if(!iList.IsEmpty())

			{

			iRequest=iList.First();

			iRequest->iLink.Deque();

			__THRD_PRINT(_L("CRequestThread::Receive() dequeing"));

			iListLock.Signal();

			}

		else

			{

			iIsWaiting=ETrue;

			iRequest = NULL;	// set to NULL so we can distinguish between a timer and a request signal

			iListLock.Signal();

			__THRD_PRINT(_L("CRequestThread::Receive() waiting"));

			User::WaitForAnyRequest();

			iIsWaiting=EFalse;	// force main thread to post new requests on queue to avoid suspending this thread unnecessarily

			}

		__THRD_PRINT2(_L("received req 0x%x, func 0x%x"),iRequest, iRequest ? iRequest->Operation()->iFunction : -1);

		iTimer->RunL();

		if (iRequest)

			iRequest->Process();

		if(iExit)

		    {

		    //Any requests that sneaked on to

		    //the queue are cancelled in 

		    //CRequestThread::ThreadFunction()

		    break;

		    }

		}

	}

void CRequestThread::Deliver(CFsRequest* aRequest,TBool aIsFront, TBool aLowPriority)

//

// Deliver a request to the list from calling thread

// Write request directly to current request if thread is waiting

//

	{

	__THRD_PRINT4(_L("Deliver req %08x to threadId %lx aIsFront=%d iIsWaiting=%d"), aRequest, iThread.Id().Id(), aIsFront, iIsWaiting);

	iListLock.Wait();

	if (iList.IsEmpty())

		{

		// if this is a low priority request (and this is the only request in the queue),

		// reduce the thread's priority to EPriorityAbsoluteBackground

		if (iLowPriority != aLowPriority)

			{

			__THRD_PRINT(_L("LOWERING THREAD PRIORITY"));

			iThread.SetPriority(aLowPriority?EPriorityAbsoluteBackground:EPriorityLess);

			iLowPriority = aLowPriority;

			}

		}

	else

		{

		// there's more than one request in the queue, so rather than go throught the entire queue

		// to determine what the thread's priority should be, assume that it should be "high"

		if (iLowPriority)

			{

			iThread.SetPriority(EPriorityLess);

			iLowPriority = EFalse;

			}

		}

	if(iIsWaiting)

		{

		// the request thread must be waiting on the iWaitLock

		iIsWaiting=EFalse;

		iListLock.Signal();

		iRequest=aRequest;

		iThread.RequestSignal();

		}

	else

		{

		if(aIsFront)

			iList.AddFirst(*aRequest);

		else

			iList.AddLast(*aRequest);

		iListLock.Signal();

		}

	}

void CRequestThread::DeliverFront(CFsRequest* aRequest)

//

//

//

	{

	Deliver(aRequest,ETrue);

	}

void CRequestThread::DeliverBack(CFsRequest* aRequest, TBool aLowPriority)

//

//

//

	{

	Deliver(aRequest,EFalse,aLowPriority);

	}

CFsDeltaTimer* CRequestThread::Timer()

	{

	__ASSERT_ALWAYS(iTimer,Fault(ERequestThreadNotInitialised));

	return iTimer;

	}

CDriveThread::CDriveThread()

	: iFinaliseTimer(FinaliseTimerEvent, this)

	{

	}

CDriveThread* CDriveThread::NewL()

//

//

//

	{

	__PRINT(_L("CDriveThread::NewL()"));

	CDriveThread* pT=new(ELeave) CDriveThread;

	TInt r=pT->Initialise();

	if(r!=KErrNone)

		{

		delete(pT);

		User::Leave(r);

		}

	return(pT);

	}

TUint CDriveThread::StartL(TInt aDrvNumber)

//

//

//

	{

	__PRINT1(_L("CDriveThread::StartL() on drive %d"),aDrvNumber);

	iDriveNumber=aDrvNumber;

	RThread t;

	User::LeaveIfError(DoStart(t));

	TUint id=t.Id();

	return(id);

	}

TInt CDriveThread::DoThreadInitialise()

//

// Initialise function for the drive thread

//  - Renames the thread to contain the drive number.

//  - Note: Drive mappings are not available at this time, so we can't show the actual drive letter.

//

	{

	__PRINT1(_L("CDriveThread::DoThreadInitialise() on drive %d"), iDriveNumber);

	TBuf<16> name;

	name.Format(_L("DriveThread_%02d"), iDriveNumber);

	return(RThread::RenameMe(name));

	}

void CDriveThread::CompleteSessionRequests(CSessionFs* aSession, TInt aValue)

//

//

//

	{

	__THRD_PRINT1(_L("CDriveThread::CompleteSessionReqeusts() drive=%d"),iDriveNumber);

	iListLock.Wait();

	TDblQueIter<CFsRequest> q(iList);

	CFsRequest* pR;

	while((pR=q++)!=NULL)

		{

		if(pR->Session()==aSession)

			{

			pR->iLink.Deque();

			iListLock.Signal();

			pR->Complete(aValue);

			iListLock.Wait();

			// set iterator back to head of queue in case Complete() has itself removed requests from the queue

			q.SetToFirst();

			}

		}

	iListLock.Signal();

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

	}

void CDriveThread::CompleteReadWriteRequests()

	{

	__THRD_PRINT1(_L("CDriveThread::CompleteReadWriteRequests() drive=%d"),iDriveNumber);

	iListLock.Wait();

	TDblQueIter<CFsRequest> q(iList);

	CFsRequest* pR;

	while((pR=q++)!=NULL)

		{

		TInt func = pR->Operation()->Function();

		if (func == EFsFileRead || func == EFsFileWrite || func == EFsFileWriteDirty)

			{

			pR->iLink.Deque();

			pR->Complete(KErrNotReady);

			}

		}

	iListLock.Signal();

	__THRD_PRINT(_L("file read/write requests completed"));

	}

/*

This function is called by FsThreadManager::SetDriveHung() and attempts to purge the request queue 

of all requests which MIGHT belong to the critical notifier server (or to the loader) to avoid causing 

a deadlock when calling the server.

All requests are completed with KErrNotReady apart from :

- EFsFileWriteDirty requests, to avoid losing dirty data

- KDispatchObjectClose requests as they are raised by the file server only and therefore cannot belong to the critical notifier server

- EFsFileSubClose requests, to avoid closing files containing dirty data. These requests have their message completed

  so that clients are unblocked, but the request itself is not processed until later. (If the request WAS processed

  and completed, then this might result in the CFileCB and CMountCB object being deleted, leading to problems 

  dereferencing invalid pointers).

*/

void CDriveThread::CompleteClientRequests(TInt aValue)

	{

	__THRD_PRINT1(_L("CDriveThread::CompleteClientRequests() drive=%d"),iDriveNumber);

	iListLock.Wait();

	TDblQueIter<CFsRequest> q(iList);

	CFsRequest* pR;

	while((pR=q++)!=NULL)

		{

		TInt func = pR->Operation()->Function();

		if(func == EFsFileSubClose)

			{

			TInt msgHandle = pR->Message().Handle();

			if ((msgHandle != KLocalMessageHandle) && (msgHandle != 0))

				pR->Message().Complete(KErrNone);

			}

		else if (func != EFsFileWriteDirty && func != KDispatchObjectClose)

			{

			pR->iLink.Deque();

			iListLock.Signal();

			pR->Complete(aValue);

			iListLock.Wait();

			}

		}

	iListLock.Signal();

	__THRD_PRINT(_L("client read requests completed"));

	}

TBool CDriveThread::IsRequestWriteable()

//

// return if current request may cause write to disk

// must be called from drive thread

//

	{

	__ASSERT_ALWAYS(FsThreadManager::IsDriveThread(iDriveNumber,EFalse),Fault(EDriveThreadWriteable));

	return(iRequest->Operation()->IsWrite());

	}

TBool CDriveThread::IsSessionNotifyUser()

//

// return if request's session has notify user set

// must be called from drive thread and request have a session set

//

	{

	__ASSERT_ALWAYS(FsThreadManager::IsDriveThread(iDriveNumber,EFalse),Fault(EDriveThreadNotifyUser1));

	// NB For read-ahead or a flush-dirty write request generated by the file cache, the session will be NULL: 

	// in this case assume that notify user is set (as it's the safest option)

	CSessionFs* session = iRequest->Session();

	return session ?  session->GetNotifyUser() : ETrue;

	}

void CDriveThread::StartFinalisationTimer()

	{

	if(IsProxyDrive(iDriveNumber))

		iFinaliseTimer.Start(this, KFinaliseTimerPeriod);

	}

void CDriveThread::StopFinalisationTimer()

	{

	iFinaliseTimer.Stop();

	}

TInt CDriveThread::FinaliseTimerEvent(TAny* aSelfP)

	{

	CDriveThread& self = *(CDriveThread*)aSelfP;

	TDrive& drive = TheDrives[self.iDriveNumber];

	if(drive.IsMounted())

        {

        if (drive.CurrentMount().LockStatus() == 0)

            {

            // Ignore the error here, as there's nothing we can do about it...

            (void)drive.FinaliseMount(RFs::EFinal_RW);

            }

        else

            {

            self.StartFinalisationTimer();

            }

        }

	return KErrNone;

	}

CDisconnectThread::~CDisconnectThread()

//

//

//

	{

	if(iRequest)

		delete(iRequest);

	}

CDisconnectThread* CDisconnectThread::NewL()

//

//

//

	{

	__THRD_PRINT(_L("CDisconnectThread::NewL()"));

	CDisconnectThread* pT=new(ELeave) CDisconnectThread;

	TInt r=pT->Initialise();

	if(r!=KErrNone)

		{

		delete(pT);

		User::Leave(r);

		}

	return(pT);

	}

TUint CDisconnectThread::StartL()

//

//

//

	{

	__PRINT(_L("CDisconnectThread::StartL()"));

	iRequest = new(ELeave) CFsInternalRequest;

	__THRD_PRINT1(_L("internal request = 0x%x"),iRequest);

	iRequest->Set(CancelSessionOp,NULL);	

	RThread t;

	TInt r=DoStart(t);

	if(r!=KErrNone)

		{

		delete(iRequest);

		iRequest=NULL;

		User::Leave(r);

		}

	iRequest->SetThreadHandle(t.Handle());

	__THRD_PRINT1(_L("CDisconnect::StartL() handle=%d"),t.Handle());

	iRequest->SetAllocated();

	TUint id=t.Id();

	return(id);

	}

CPluginThread::CPluginThread(CFsPlugin& aPlugin)

  : iPlugin(aPlugin)

	{

	/** @prototype */

	iOperationLock.Close();

	iPlugin.Open();

	}

CPluginThread::~CPluginThread()

    {

    iPlugin.Close();

    }

CPluginThread* CPluginThread::NewL(CFsPlugin& aPlugin)

	{

	__PRINT(_L("CPluginThread::NewL()"));

	CPluginThread* pT=new(ELeave) CPluginThread(aPlugin);

	TInt r=pT->Initialise();

	/** @prototype */

	if(r == KErrNone)

		r=pT->iOperationLock.CreateLocal(0);

	if(r!=KErrNone)

		{

		delete(pT);

		User::Leave(r);

		}

	return(pT);

	}

TUint CPluginThread::StartL()

	{

	__PRINT(_L("CPluginThread::StartL()"));

	RThread t;

	User::LeaveIfError(DoStart(t));

	TUint id=t.Id();

	return(id);

	}

void CPluginThread::CompleteSessionRequests(CSessionFs* aSession, TInt aValue)

	{

	__THRD_PRINT(_L("CPluginThread::CompleteSessionRequests()"));

	iListLock.Wait();

	TDblQueIter<CFsRequest> q(iList);

	CFsRequest* pR;

	while((pR=q++)!=NULL)

		{

		if(pR->Session()==aSession)

			{

			pR->iLink.Deque();

			pR->Complete(aValue);

			}

		}

	iListLock.Signal();

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

	}

TInt CPluginThread::DoThreadInitialise()

	{

	__PRINT(_L("CPluginThread::DoThreadInitialise()"));

 	TRAPD(err, iPlugin.InitialiseL());

	return err;

	}