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

TInt RequestAllocator::iAllocNumOperation;

TMsgOperation* RequestAllocator::iFreeHeadSupOp;

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

TInt RequestAllocator::iAllocated;

#endif

RFastLock RequestAllocator::iCacheLock;

void RequestAllocator::Initialise()

	{	

	iFreeHead=NULL;  

	iCloseHead=NULL; 

	iAllocNum=0; 

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

	iAllocated=0;

#endif

	iAllocNumOperation=0;

	iFreeHeadSupOp=NULL;

	}

TInt RequestAllocator::AllocRequest(TInt aNum)

//

//	Allocates a group of request objects

//

	{

    TInt i;

	if(iAllocNum < KMaxRequestAllocated)

		{

		__CACHE_PRINT(_L("RequestAllocator::AllocRequest() Not reached the limit"));

		CFsClientMessageRequest* list;

		CFsClientMessageRequest* start;

		list = new CFsClientMessageRequest[KAllocReqBlock];

		start = list;

		if(!list)

			return KErrNoMemory;

		// Make sure the constructors are called for every element in the array

		// - some compilers don't do this

		for(TInt j=0; j<KAllocReqBlock; j++)

			{

			CFsClientMessageRequest* request = &list[j];

			new(request) CFsClientMessageRequest();

			}

		iAllocNum += KAllocReqBlock;

		CFsClientMessageRequest* last;

		for(i=1;i<KAllocReqBlock;i++)

			{

			last = list;

			list++;

			last->iNext = list;

			}

		list->iNext = iFreeHead;

		iFreeHead = start;

		return KErrNone;

		}

	else

		{

		__CACHE_PRINT1(_L("RequestAllocator::AllocRequest() Limit exceeded Count = %d"),aNum);

		CFsClientMessageRequest* request;

		for(i=0;i<aNum;i++)

			{

			request=new CFsClientMessageRequest;

			if(!request)

				return KErrNoMemory;

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

			iAllocated++;

#endif

			request->SetAllocated();

			request->iNext=iFreeHead;

			iFreeHead=request;

			}

		return KErrNone;

		}

	}

void RequestAllocator::FreeRequest(CFsClientMessageRequest* aRequest)

//

//free request 

//

	{

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

	if(aRequest->IsAllocated())

		{

		__CACHE_PRINT(_L("RequestAllocator::FreeRequest() Allocated request"));

		delete(aRequest);

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

		iAllocated--;

#endif

		return;

		}

	__CACHE_PRINT(_L("RequestAllocator::FreeRequest() returning to free list"));

	iCacheLock.Wait();

	aRequest->iNext = iFreeHead;

	iFreeHead=aRequest;

	aRequest->SetSubstedDrive(NULL);

	iCacheLock.Signal();

	}

void RequestAllocator::OpenSubFailed(CSessionFs* aSession)

//

//	Move requst 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;

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

	aSession->CloseRequestCountDec();

	rp->iNext = NULL;

	if(rp->IsAllocated())

		{

		__CACHE_PRINT(_L("RequestAllocator::OpenSubFailed() Allocated request"));

		delete(rp);

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

		iAllocated--;

#endif

		}

	else

		{

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

		if(iFreeHead)

			{

			rp->iNext = iFreeHead;

			}

		else

			{

			rp->iNext = NULL;

			}

		iFreeHead = rp;		

		}

	iCacheLock.Signal();

	}

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

		if(iFreeHead == NULL || iFreeHead->iNext == NULL)

			{

			if(AllocRequest(2)!= KErrNone)

				{

				iCacheLock.Signal();

				return KErrNoMemory;

				}

			}

		aRequest= iFreeHead;						//get our request from free head

		iFreeHead = iFreeHead->iNext->iNext;	//set next but one as new free head read for next

		aRequest->iNext->iNext = NULL;				//seperate our request and close from free list

		CFsClientMessageRequest* CRp = aRequest->iNext;

		aRequest->iNext = NULL;

		if(iCloseHead)

			{

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

			iCloseHead = CRp;

			}

		else

			iCloseHead = CRp;

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

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

		if(!iFreeHead)

			{

			if(AllocRequest(1) != KErrNone)

				{

				iCacheLock.Signal();

				return KErrNoMemory; 

				}

			}

		aRequest = iFreeHead;						

		iFreeHead = aRequest->iNext;

		aRequest->iNext= NULL;

		}

	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;

	CFsClientMessageRequest* list=iCloseHead;

	while(list!=NULL)

		{

		count++;

		list=list->iNext;

		}

	return(count);

	} 

TInt RequestAllocator::FreeCount()

	{

	TInt count=0;

	CFsClientMessageRequest* list=iFreeHead;

	while(list!=NULL)

		{

		count++;

		list=list->iNext;

		}

	return(count);}

#endif

TInt RequestAllocator::AllocOperation()

//

//	Allocates a group of TMsgOperation objects

//

// Must be called with iCacheLock held

	{

    TInt i;

	if(iAllocNumOperation < KMaxOperationAllocated)

		{

		__CACHE_PRINT(_L("RequestAllocator::AllocOperation() Not reached the limit"));

		TMsgOperation* list;

		TMsgOperation* start;

		list = new TMsgOperation[KAllocReqBlock];

		start = list;

		if(!list)

			return KErrNoMemory;

		for(TInt j=0; j<KAllocReqBlock; j++)

			{

			TMsgOperation* request = &list[j];

			request->iIsAllocated = EFalse;

			}

		iAllocNumOperation += KAllocReqBlock;

		TMsgOperation* last;

		for(i=1;i<KAllocReqBlock;i++)

			{

			last = list;

			list++;

			last->iNext = list;

			}

		list->iNext = iFreeHeadSupOp;

		iFreeHeadSupOp = start;

		return KErrNone;

		}

	else

		{

		__CACHE_PRINT(_L("RequestAllocator::AllocOperation() Limit exceeded"));

		TMsgOperation* request;

		request=new TMsgOperation;

		if(!request)

			return KErrNoMemory;

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

		iAllocated++;

#endif

		request->iIsAllocated = ETrue;

		request->iNext=iFreeHeadSupOp;

		iFreeHeadSupOp=request;

		return KErrNone;

		}

	}

TInt RequestAllocator::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();

	if(!iFreeHeadSupOp)

		{

		if(AllocOperation() != KErrNone)

			{

			iCacheLock.Signal();

			return KErrNoMemory; 

			}

		}

	aOperation = iFreeHeadSupOp;						

	iFreeHeadSupOp = aOperation->iNext;

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

	iCacheLock.Signal();

	return KErrNone;

	}	

void RequestAllocator::FreeOperation(TMsgOperation* aOperation)

//

// free Operation

//

	{

	if(aOperation->iIsAllocated)

		{

		__CACHE_PRINT(_L("RequestAllocator::FreeOperation() Allocated subop"));

		delete(aOperation);

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

		iAllocated--;

#endif

		return;

		}

	__CACHE_PRINT(_L("RequestAllocator::FreeOperation() returning to free list"));

	iCacheLock.Wait();

	aOperation->iNext = iFreeHeadSupOp;	// NB backward link only used when request in in use

	iFreeHeadSupOp = aOperation;

	iCacheLock.Signal();

	}

CFsRequest::CFsRequest()

//

//

//

	: iOperation(NULL),iDriveNumber(KDriveInvalid)

	{}

CFsRequest::~CFsRequest()

//

//

//

	{}

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

//

//

//

	{

	SetState(EReqStateInitialise);

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

	iSession       = aSession;

	iIsCompleted   = aOperation.IsCompleted();

	iError         = KErrNone;

	iDriveNumber   = KDriveInvalid;

	iCurrentPlugin = NULL;

	iOwnerPlugin   = NULL;

	iDirectToDrive = EFalse;

	iClientThreadId= 0;

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

	iScratchValue = 0;

	}

void CFsRequest::Set(CSessionFs* aSession)

//

//

//

	{

	__ASSERT_DEBUG(iOperation,Fault(EBaseRequestSet1));

	SetState(EReqStateInitialise);

	iSession       = aSession;

	iIsCompleted   = iOperation->IsCompleted();

	iError         = KErrNone;

	iDriveNumber   = KDriveInvalid;

	iCurrentPlugin = NULL;

	iOwnerPlugin   = NULL;

	iDirectToDrive = EFalse;

	iClientThreadId= 0;

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

	iScratchValue = 0;

	}

TParse& CFsRequest::Src()

//

//

//

	{

	Fault(EBaseRequestSrc);

	return(dummyP);

	}

TParse& CFsRequest::Dest()

//

//

//

	{

	Fault(EBaseRequestDest);

	return(dummyP);

	}

TDrive* CFsRequest::Drive()

//

//

//

	{

	Fault(EBaseRequestDrive);

	return(NULL);

	}

TDrive* CFsRequest::SubstedDrive()