// 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_request.cpp

// 

//

#include "sf_std.h"

#include "sf_file_cache.h"

#ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION	

#include "sf_notifier.h"

#endif //SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION	

TParse dummyP;

RMessage2 dummyM;

CFsClientMessageRequest* RequestAllocator::iFreeHead;				

CFsClientMessageRequest* RequestAllocator::iCloseHead;

TInt RequestAllocator::iRequestCount;

TInt RequestAllocator::iFreeCount;

TInt RequestAllocator::iRequestCountPeak;

RFastLock RequestAllocator::iCacheLock;

TMsgOperation* OperationAllocator::iFreeHead;				

TInt OperationAllocator::iRequestCount;

TInt OperationAllocator::iFreeCount;

TInt OperationAllocator::iRequestCountPeak;

RFastLock OperationAllocator::iCacheLock;

TInt RequestAllocator::Initialise()

	{	

	iFreeHead = NULL;  

	iCloseHead = NULL; 

	iRequestCount = 0; 

	iFreeCount = 0;

	iRequestCountPeak = 0;

	return iCacheLock.CreateLocal();

	}

void RequestAllocator::FreeRequest(CFsClientMessageRequest* aRequest)

//

//free request 

//

	{

	__CACHE_PRINT1(_L("RequestAllocator::FreeRequest for %x"), aRequest);

	ASSERT(aRequest != NULL);

	iCacheLock.Wait();

	if (iFreeCount >= KFreeCountMax)

		{

		delete aRequest;

		ASSERT(iRequestCount > 0);

		iRequestCount--;

		}

	else

		{

		aRequest->SetSubstedDrive(NULL);

		aRequest->iNext = iFreeHead;

		iFreeHead=aRequest;

		iFreeCount++;

		}

	iCacheLock.Signal();

	}

void RequestAllocator::OpenSubFailed(CSessionFs* aSession)

//

//	Move request from closed list to free list

//

	{

	__ASSERT_DEBUG(iCloseHead!=NULL,Fault(ERequestAllocatorOpenSubFailed)); // On arriving here Close Queue is supposed to be empty

	__ASSERT_ALWAYS(aSession!=NULL,Fault(ERequestAllocatorOpenSubFailed));

	if (iCloseHead==NULL)

		{

		return;

		}

	iCacheLock.Wait();

	CFsClientMessageRequest* rp = iCloseHead;

	iCloseHead = rp->iNext;

	iCacheLock.Signal();

	// dec the number of closed requests owned by this session

	aSession->CloseRequestCountDec();

	__CACHE_PRINT1(_L("RequestAllocator::OpenSubFailed() IsAllocated %d"), rp->IsAllocated());

	FreeRequest(rp);

	}

CFsClientMessageRequest* RequestAllocator::GetRequest()

//

// Get request from the free queue

//

	{

	CFsClientMessageRequest* request;

	if (iFreeHead == NULL)

		{

		request = new CFsClientMessageRequest;

		if (request)

			{

			iRequestCount++;

			iRequestCountPeak = Max(iRequestCountPeak, iRequestCount);

			}

		}

	else

		{

		request = iFreeHead;

		iFreeHead = iFreeHead->iNext;

		request->iNext = NULL;

		iFreeCount--;

		ASSERT(iFreeCount >= 0);

		}

	return request;

	}

TInt RequestAllocator::GetMessageRequest(const TOperation& aOperation,const RMessage2& aMessage,CFsClientMessageRequest* &aRequest)

//

//	tries to get a pre allocated message from the cache. Failing that allocates one indivisualy 

//	

	{

	if(aOperation.IsOpenSubSess())

		{

		__CACHE_PRINT(_L("++RequestAllocator::GetMessageRequest() Open sub-sess"));

		iCacheLock.Wait();

		aRequest = GetRequest();

		CFsClientMessageRequest* closeRequest = GetRequest();

		if (aRequest == NULL || closeRequest == NULL)

			{

			delete aRequest;

			delete closeRequest;

			iCacheLock.Signal();

			return KErrNoMemory;

			}

		closeRequest->iNext = iCloseHead;		//set second one as a reserved (tail) close request

		iCloseHead = closeRequest;

		((CSessionFs*) aMessage.Session())->CloseRequestCountInc();

		}

	else if(aOperation.IsCloseSubSess())

		{

		__CACHE_PRINT(_L("++RequestAllocator::GetMessageRequest() Close sub-sess"));

		CFsObject* pO = SessionObjectFromHandle(aMessage.Int3(),0,reinterpret_cast<CSessionFs*>(aMessage.Session()));

		if(!pO)

			return KErrBadHandle;

		CObjPromotion* pm = (CObjPromotion*)pO;

		TInt function = aMessage.Function();

		switch(function & KIpcFunctionMask)

			{

			case EFsFormatSubClose:

				{

				if(pm->UniqueID() != Formats->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

			case EFsDirSubClose:

				{

				if(pm->UniqueID() != Dirs->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

			case EFsFileSubClose:

				{

				if(pm->UniqueID() != FileShares->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

			case EFsRawSubClose:

				{

				if(pm->UniqueID() != RawDisks->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

			case EFsPluginSubClose:

				{

				if(pm->UniqueID() != FsPluginManager::iPluginConns->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

#ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION					

			case EFsNotificationSubClose:

				{

				if(pm->UniqueID() != FsNotificationManager::iNotifyRequests->UniqueID())

					{

					return KErrBadHandle;

					}

				break;

				}

#endif //SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION					

			default:

				Fault(ECloseSubBadMessage);

			}

		iCacheLock.Wait();

		ASSERT(iCloseHead);

		aRequest = iCloseHead;

		iCloseHead = aRequest->iNext;

		((CSessionFs*) aMessage.Session())->CloseRequestCountDec();

		aRequest->iNext = NULL;

		if((function & KIpcFunctionMask)!= EFsPluginSubClose &&

			(function & KIpcFunctionMask)!= EFsNotificationSubClose)

			{

			aRequest->SetDrive(&TheDrives[((CFsDispatchObject*)pO)->DriveNumber()]);

			}

		aRequest->SetScratchValue((TUint)pO);

		}

	else

		{

		__CACHE_PRINT(_L("++RequestAllocator::GetMessageRequest() "));

		iCacheLock.Wait();

		aRequest = GetRequest();

		if (aRequest == NULL)

			{

			iCacheLock.Signal();

			return KErrNoMemory; 

			}

		}

	aRequest->Init();

	iCacheLock.Signal();

	// pre-allocate any TParse objects needed by this request

	if (aRequest->AllocParseObjects(aOperation) != KErrNone)

		{

		aRequest->Free();

		return KErrNoMemory; 

		}

	__CACHE_PRINT1(_L("--RequestAllocator::GetMessageRequest() allocated %08x"), aRequest);

	return KErrNone;

	}	

#if defined(_USE_CONTROLIO) || defined(_DEBUG) || defined(_DEBUG_RELEASE)

TInt RequestAllocator::CloseCount()

	{TInt count=0;

	iCacheLock.Wait();

	CFsClientMessageRequest* list=iCloseHead;

	while(list!=NULL)

		{

		count++;

		list=list->iNext;

		}

	iCacheLock.Signal();

	return(count);

	} 

TInt RequestAllocator::FreeCount()

	{

	TInt count=0;

	iCacheLock.Wait();

	CFsClientMessageRequest* list=iFreeHead;

	while(list!=NULL)

		{

		count++;

		list=list->iNext;

		}

	ASSERT(count == iFreeCount);

	iCacheLock.Signal();

	return(count);

	}

#endif

TInt OperationAllocator::Initialise()

	{	

	iFreeHead = NULL;  

	iRequestCount = 0; 

	iFreeCount = 0;

	return iCacheLock.CreateLocal();

	}

void OperationAllocator::FreeOperation(TMsgOperation* aOperation)

//

// free Operation

//

	{

	__CACHE_PRINT1(_L("RequestAllocator::FreeOperation() returning %x to free list"), aOperation);

	ASSERT(aOperation != NULL);

	iCacheLock.Wait();

	if (iFreeCount >= KFreeCountMax)

		{

		delete aOperation;

		ASSERT(iRequestCount > 0);

		iRequestCount--;

		}

	else

		{

		aOperation->iNext = iFreeHead;

		iFreeHead = aOperation;

		iFreeCount++;

		}

	iCacheLock.Signal();

	}

TInt OperationAllocator::GetOperation(TMsgOperation* &aOperation)

//

//	tries to get a pre allocated subop from the cache. Failing that allocates one individualy 

//	

	{

	__CACHE_PRINT(_L("RequestAllocator::GetOperation() "));

	iCacheLock.Wait();

	TInt r = KErrNone;

	if (iFreeHead == NULL)

		{

		aOperation = new TMsgOperation;

		if (aOperation == NULL)

			r = KErrNoMemory; 

		else

			{

			iRequestCount++;

			iRequestCountPeak = Max(iRequestCountPeak, iRequestCount);

			}

		}

	else

		{

		aOperation = iFreeHead;

		iFreeHead = iFreeHead->iNext;

		iFreeCount--;

		ASSERT(iFreeCount >= 0);

		}

	if (aOperation)

		aOperation->iNext = aOperation->iPrev = NULL;

	iCacheLock.Signal();

	return r;

	}	

CFsRequest::CFsRequest()

//

//

//

	: iOperation(NULL),iDriveNumber(KDriveInvalid)

	{}

CFsRequest::~CFsRequest()

//

//

//

	{

	Close();

	}

void CFsRequest::Set(const TOperation& aOperation,CSessionFs* aSession)

//

//

//

	{

	SetState(EReqStateInitialise);

	iOperation     = const_cast<TOperation*>(&aOperation);

	Set(aSession);

	}

void CFsRequest::Set(CSessionFs* aSession)

//

//

//

	{

	__ASSERT_DEBUG(iOperation,Fault(EBaseRequestSet1));

	SetState(EReqStateInitialise);

	iIsCompleted   = iOperation->IsCompleted();

	iError         = KErrNone;

	iDriveNumber   = KDriveInvalid;

	iCurrentPlugin = NULL;

	iOwnerPlugin   = NULL;

	iDirectToDrive = EFalse;

	iClientThreadId= 0;

	iFlags &= ~(EFreeChanged | EPostInterceptEnabled | EPostOperation | EFsDspObjOpen);

	iScratchValue = 0;

	OpenSession(aSession);

	}

TParse& CFsRequest::Src()

//

//

//

	{

	Fault(EBaseRequestSrc);

	return(dummyP);

	}

TParse& CFsRequest::Dest()

//

//

//

	{

	Fault(EBaseRequestDest);

	return(dummyP);

	}

TDrive* CFsRequest::Drive()

//

//

//

	{

	Fault(EBaseRequestDrive);

	return(NULL);

	}

TDrive* CFsRequest::SubstedDrive()

//

//

//

	{

	Fault(EBaseRequestSubstedDrive);

	return(NULL);

	}

void CFsRequest::SetDrive(TDrive* /*aDrive*/)

//

//

//

	{

	Fault(EBaseRequestSetDrive);

	}

void CFsRequest::SetSubstedDrive(TDrive* /*aDrive*/)

//

//

//

	{

	Fault(EBaseRequestSetSubstedDrive);

	}

TInt CFsRequest::GetSlot(TFsPluginRequest::TF32ArgType aType)

	{

	if(iOperation->Arg(0) == aType) return 0;

	if(iOperation->Arg(1) == aType) return 1;

	if(iOperation->Arg(2) == aType) return 2;

	if(iOperation->Arg(3) == aType) return 3;

	return(-1);

	}

TBool CFsMessageRequest::IsNotifierSpecific() const

	{

#ifndef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION

	return EFalse;

#else

	TInt function = iOperation->iFunction;

	return(	function == EFsNotificationAdd      || 

			function == EFsNotificationBuffer ||

			function == EFsNotificationCancel ||

			function == EFsNotificationOpen ||

			function == EFsNotificationRemove ||

			function == EFsNotificationRequest ||

			function == EFsNotificationSubClose);

#endif //SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION

	}

TBool CFsMessageRequest::IsNotifierSupported() const

	{

#ifndef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION

	return EFalse;

#else

	TInt function = iOperation->iFunction;

	return(	function == EFsDelete || 

			function == EFsRmDir || 

			function == EFsMkDir ||