FCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfile/sf_plugin

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 #include "sf_std.h"
 #include "sf_plugin_priv.h"
 CFsObjectCon* FsPluginManager::iPluginFactories = NULL;
 CFsObjectCon* FsPluginManager::iPluginConns     = NULL;
-RReadWriteLock FsPluginManager::iChainLock;
+RFastLock FsPluginManager::iChainLock;
 RPointerArray<CFsPlugin> FsPluginManager::iPluginChain;
 CFsSyncMessageScheduler* FsPluginManager::iScheduler = NULL;
 TBool IsPagableDrive(TInt aDrive)
 	{
 		{
 		pP->Close();
 		return err;
 		}
-	WriteLockChain();
+	LockChain();
 	err = InsertInPluginStack(pP,aPos);
 	UnlockChain();
 	if(err != KErrNone)
 		{
 		pP->Close();
 		return err;
 		}
-	err = InitPlugin(*pP, aPluginFactory.Library());
+	err = InitPlugin(*pP);
 	if(err != KErrNone)
 		{
 		return err;
 		}
 	aPluginFactory.IncrementMounted();
 /**
 Transfer any outstanding requests to next/previous plugin depending on
 if it is post filter or not
-Must be called with the plugin chain write-locked.
+Must be called with the plugin chain locked.
 Attains plugin-thread's listlock.
 */
 void FsPluginManager::TransferRequests(CPluginThread* aPluginThread)
 	{
 	aPluginThread->iListLock.Wait();
 	            }
 	        if(pR->IsPostOperation())
 	            {
 	            //[set the plugin to] pass the request backwards in the chain
-	            PrevPlugin(pR->iCurrentPlugin, &mR);
+	            PrevPlugin(pR->iCurrentPlugin, &mR, EFalse);
 	            }
 	        else //IsPreOperations
 	            {
 	            //[set the plugin to] pass the request forwards in the chain
-	            NextPlugin(pR->iCurrentPlugin, &mR);
+	            NextPlugin(pR->iCurrentPlugin, &mR, EFalse);
 	            }
 	        if(pR->iCurrentPlugin)
 	            {
 	            pR->iCurrentPlugin->iThreadP->DeliverBack(pR);
 	}
 /**
 Find the next plugin that supports the operation
-Must be called with the plugin chain (at least read-) locked.
 @param aPlugin - On calling the function this may contain either NULL or the current plugin.
 If it is called with NULL, then we start to look for plugins from the beginning of the chain.
 If is is called with a plugin then we start to look after that plugin for the next one.
 On return, aPlugin shall contain either a plugin or NULL.
+@param aLock - If this is set to ETRUE, then the function shall lock the plugin chain.
+If this is set to EFALSE, then the caller of the function MUST already hold the lock.
 @param aCheckCurrentOperation - Optional, if false, will return the next plugin,
 								whether the plugin is currently registered
 								for the current function or not. (so long as mounted on the current drive)
 */
-TInt FsPluginManager::NextPlugin(CFsPlugin*& aPlugin, CFsMessageRequest* aMsgRequest, TBool aCheckCurrentOperation)
+TInt FsPluginManager::NextPlugin(CFsPlugin*& aPlugin, CFsMessageRequest* aMsgRequest,TBool aLock, TBool aCheckCurrentOperation)
 	{
 	if(aMsgRequest->DirectToDrive())
 		{
 		aPlugin = NULL;
 		return KErrNotFound;
 	TInt start;
 	TInt function = aMsgRequest->Operation()->Function();
 	TInt drive = aMsgRequest->DriveNumber();
+	if(aLock)
+	    LockChain();
 	//the plugin chain lock must be held by this point.
 	TInt count = iPluginChain.Count();
 	if(aPlugin == NULL)
 		start=0;
 				{
 				if((function == EFsDismountPlugin) || (iPluginChain[i]->IsMounted(drive)))
 					{
 					aPlugin = iPluginChain[i];
+					if(aLock)
+					    UnlockChain();
 					return KErrNone;
 					}
 				}
 			}
 		}
 	aPlugin = NULL;
+	if(aLock)
+	    UnlockChain();
 	return KErrNotFound;
 	}
 /**
 Find the next plugin that supports the operation
-Must be called with the plugin chain (at least read-) locked.
 @see FsPluginManager::NextPlugin
 */
-TInt FsPluginManager::PrevPlugin(CFsPlugin*& aPlugin, CFsMessageRequest* aMsgRequest)
+TInt FsPluginManager::PrevPlugin(CFsPlugin*& aPlugin, CFsMessageRequest* aMsgRequest, TBool aLock)
 	{
 	if(aMsgRequest->DirectToDrive() && (aMsgRequest->CurrentOperationPtr() != NULL))
 		{
 		aPlugin = NULL;
 		return KErrNotFound;
 		}
 	TInt start;
 	TInt function = aMsgRequest->Operation()->Function();
 	TInt drive = aMsgRequest->DriveNumber();
+	if(aLock)
+	    LockChain();
 	//the plugin chain lock must be held by this point.
 	TInt count= iPluginChain.Count();
 	if(aPlugin == NULL)
 				{
 				if((function == EFsDismountPlugin) || (iPluginChain[i]->IsMounted(drive)))
 					{
 					aPlugin = iPluginChain[i];
+					if(aLock)
+					    UnlockChain();
 					return KErrNone;
 					}
 				}
 			}
 		}
 	aPlugin = NULL;
+	if(aLock)
+	    UnlockChain();
 	return KErrNotFound;
 	}
 /**
 Inserts the plugin in the stack (chain)
 /**
 Finds a plugin by unique position
 */
 CFsPlugin* FsPluginManager::FindByUniquePosition(TInt aUniquePosition)
 	{
-	ReadLockChain();
+	LockChain();
 	CFsPlugin* plugin = NULL;
 	TInt count= iPluginChain.Count();
 	for(TInt i=0;i<count;i++)
 		{
 		if(aUniquePosition == iPluginChain[i]->iUniquePos)
 /**
 Create a plugin thread
 Should only by called from main file server thread with plugin thread unavailable
 */
-TInt FsPluginManager::InitPlugin(CFsPlugin& aPlugin, RLibrary aLibrary)
+TInt FsPluginManager::InitPlugin(CFsPlugin& aPlugin)
 	{
 	TInt err = KErrNone;
 	if(!aPlugin.iThreadP)
 		{
-		TRAP(err,aPlugin.iThreadP=CPluginThread::NewL(aPlugin, aLibrary));
+		TRAP(err,aPlugin.iThreadP=CPluginThread::NewL(aPlugin));
 		if(err!=KErrNone)
 			return err;
 		}
 	aPlugin.iThreadId = aPlugin.iThreadP->StartL();
 	aPlugin = iPluginChain[aPos];
 	return KErrNone;
 	}
 /**
-Locks the chain for reading
+Locks the chain
 */
-void FsPluginManager::ReadLockChain()
+void FsPluginManager::LockChain()
 	{
-iChainLock.ReadLock();
+	iChainLock.Wait();
 	}
-/**
-Locks the chain for writing
-*/
-void FsPluginManager::WriteLockChain()
-{
-iChainLock.WriteLock();
-}
 /**
 Unlocks the chain
 */
 void FsPluginManager::UnlockChain()
 	{
-iChainLock.Unlock();
+	iChainLock.Signal();
 	}
 /**
 Gets plugin conn from handle
 */
 	__PRINT2(_L("FsPluginManager::CompleteSessionRequests(%08x, %d)"), aSession, aValue);
 	// Iterate through all plugins, cancelling outstanding session requests
 	aRequest->Set(CancelPluginOp, aSession);
-	FsPluginManager::ReadLockChain();
+	FsPluginManager::LockChain();
 	TInt count = FsPluginManager::ChainCount();
 	TInt oldCount = count;
 	TInt i;
 	for(i=0; i<count; i++)
 	    {
 	    aRequest->Dispatch();
 	    //Cancel is delivered to the front of the request queue
 	    //so hopefully this wont take too long.
 	    FsPluginManager::UnlockChain();
 	    User::WaitForRequest(aRequest->Status());
-	    FsPluginManager::ReadLockChain();
+	    FsPluginManager::LockChain();
 	    __ASSERT_ALWAYS(aRequest->Status().Int()==KErrNone||aRequest->Status().Int()==KErrCancel,Fault(ESessionDisconnectThread2));
 	    count = FsPluginManager::ChainCount();
 	    //If a plugin was removed whilst the chain was unlocked we need to make sure we don't skip any plugins
 	    if(count != oldCount)
 	        {

branch	RCL_3
changeset 257	3e88ff8f41d5
parent 256	c1f20ce4abcf