userlibandfileserver/fileserver/sfile/sf_thread.cpp
changeset 273 6a75fa55495f
parent 271 dc268b18d709
equal deleted inserted replaced
271:dc268b18d709 273:6a75fa55495f
    29 
    29 
    30 const TInt KFinaliseTimerPeriod = 10 * 1000 * 1000;	// default 10S finalisation timeout
    30 const TInt KFinaliseTimerPeriod = 10 * 1000 * 1000;	// default 10S finalisation timeout
    31 
    31 
    32 TFsDriveThread FsThreadManager::iFsThreads[KMaxDrives];
    32 TFsDriveThread FsThreadManager::iFsThreads[KMaxDrives];
    33 TUint FsThreadManager::iMainId=0;
    33 TUint FsThreadManager::iMainId=0;
    34 CDisconnectThread* FsThreadManager::iDisconnectThread=NULL;
       
    35 TUint FsThreadManager::iDisconnectThreadId=0;
       
    36 
    34 
    37 TFsDriveThread::TFsDriveThread()
    35 TFsDriveThread::TFsDriveThread()
    38 //
    36 //
    39 //
    37 //
    40 //
    38 //
    51 :iIsAvailable(ETrue),iThread(NULL),iId(0)
    49 :iIsAvailable(ETrue),iThread(NULL),iId(0)
    52 	{
    50 	{
    53 	TInt r=iPluginLock.CreateLocal();
    51 	TInt r=iPluginLock.CreateLocal();
    54 	iDriveNumber= KMaxDrives+1;
    52 	iDriveNumber= KMaxDrives+1;
    55 	__ASSERT_ALWAYS(r==KErrNone,Fault(EFsThreadConstructor));
    53 	__ASSERT_ALWAYS(r==KErrNone,Fault(EFsThreadConstructor));
    56 	}
       
    57 
       
    58 TInt FsThreadManager::CreateDisconnectThread()
       
    59 //
       
    60 // Called just once at startup
       
    61 //
       
    62 	{
       
    63 	__PRINT(_L("Create disconnect thread"));
       
    64 	TRAPD(r,iDisconnectThread=CDisconnectThread::NewL());
       
    65 	if(r!=KErrNone)
       
    66 		return(r);
       
    67 	TRAP(r,iDisconnectThreadId=iDisconnectThread->StartL());
       
    68 	if(r!=KErrNone)
       
    69 		{
       
    70 		delete(iDisconnectThread);
       
    71 		iDisconnectThread=NULL;
       
    72 		iDisconnectThreadId=0;
       
    73 		}
       
    74 	__THRD_PRINT2(_L("iDisconnectThread=0x%x id=0x%x"),iDisconnectThread,iDisconnectThreadId);
       
    75 	return(r);
       
    76 	}
       
    77 
       
    78 TBool FsThreadManager::IsDisconnectThread()
       
    79 //
       
    80 // Return ETrue if the calling thread is the disconnect thread
       
    81 //
       
    82 	{
       
    83 	return(iDisconnectThreadId==RThread().Id());
       
    84 	}
    54 	}
    85 
    55 
    86 
    56 
    87 TInt FsThreadManager::InitDrive(TInt aDrvNumber,TBool aIsSync)
    57 TInt FsThreadManager::InitDrive(TInt aDrvNumber,TBool aIsSync)
    88 //
    58 //
   724 	TBuf<16> name;
   694 	TBuf<16> name;
   725 	name.Format(_L("DriveThread_%02d"), iDriveNumber);
   695 	name.Format(_L("DriveThread_%02d"), iDriveNumber);
   726 	return(RThread::RenameMe(name));
   696 	return(RThread::RenameMe(name));
   727 	}
   697 	}
   728 
   698 
   729 void CDriveThread::CompleteSessionRequests(CSessionFs* aSession, TInt aValue)
       
   730 //
       
   731 //
       
   732 //
       
   733 	{
       
   734 	__THRD_PRINT1(_L("CDriveThread::CompleteSessionReqeusts() drive=%d"),iDriveNumber);
       
   735 	iListLock.Wait();
       
   736 	TDblQueIter<CFsRequest> q(iList);
       
   737 	CFsRequest* pR;
       
   738 	while((pR=q++)!=NULL)
       
   739 		{
       
   740 		if(pR->Session()==aSession)
       
   741 			{
       
   742 			pR->iLink.Deque();
       
   743 			iListLock.Signal();
       
   744 			pR->Complete(aValue);
       
   745 			iListLock.Wait();
       
   746 			// set iterator back to head of queue in case Complete() has itself removed requests from the queue
       
   747 			q.SetToFirst();
       
   748 			}
       
   749 		}
       
   750 	iListLock.Signal();
       
   751 	__THRD_PRINT(_L("session requests completed"));
       
   752 	}
       
   753 
       
   754 
   699 
   755 void CDriveThread::CompleteReadWriteRequests()
   700 void CDriveThread::CompleteReadWriteRequests()
   756 	{
   701 	{
   757 	__THRD_PRINT1(_L("CDriveThread::CompleteReadWriteRequests() drive=%d"),iDriveNumber);
   702 	__THRD_PRINT1(_L("CDriveThread::CompleteReadWriteRequests() drive=%d"),iDriveNumber);
   758 
   703 
   863 
   808 
   864 	return KErrNone;
   809 	return KErrNone;
   865 	}
   810 	}
   866 
   811 
   867 
   812 
   868 CDisconnectThread::~CDisconnectThread()
       
   869 //
       
   870 //
       
   871 //
       
   872 	{
       
   873 	if(iRequest)
       
   874 		delete(iRequest);
       
   875 	}
       
   876 
       
   877 
       
   878 CDisconnectThread* CDisconnectThread::NewL()
       
   879 //
       
   880 //
       
   881 //
       
   882 	{
       
   883 	__THRD_PRINT(_L("CDisconnectThread::NewL()"));
       
   884 	CDisconnectThread* pT=new(ELeave) CDisconnectThread;
       
   885 	TInt r=pT->Initialise();
       
   886 	if(r!=KErrNone)
       
   887 		{
       
   888 		delete(pT);
       
   889 		User::Leave(r);
       
   890 		}
       
   891 	return(pT);
       
   892 	}
       
   893 
       
   894 TUint CDisconnectThread::StartL()
       
   895 //
       
   896 //
       
   897 //
       
   898 	{
       
   899 	__PRINT(_L("CDisconnectThread::StartL()"));
       
   900 	iRequest = new(ELeave) CFsInternalRequest;
       
   901 	__THRD_PRINT1(_L("internal request = 0x%x"),iRequest);
       
   902 	iRequest->Set(CancelSessionOp,NULL);	
       
   903 	
       
   904 	RThread t;
       
   905 	TInt r=DoStart(t);
       
   906 	if(r!=KErrNone)
       
   907 		{
       
   908 		delete(iRequest);
       
   909 		iRequest=NULL;
       
   910 		User::Leave(r);
       
   911 		}
       
   912 	iRequest->SetThreadHandle(t.Handle());
       
   913 	__THRD_PRINT1(_L("CDisconnect::StartL() handle=%d"),t.Handle());
       
   914 	iRequest->SetAllocated();
       
   915 	TUint id=t.Id();
       
   916 	return(id);
       
   917 	}
       
   918 
       
   919 
   813 
   920 CPluginThread::CPluginThread(CFsPlugin& aPlugin, RLibrary aLibrary)
   814 CPluginThread::CPluginThread(CFsPlugin& aPlugin, RLibrary aLibrary)
   921   : iPlugin(aPlugin), iLib(aLibrary)
   815   : iPlugin(aPlugin), iLib(aLibrary)
   922 	{
   816 	{
   923 	iPlugin.Open();
   817 	iPlugin.Open();
   964 	User::LeaveIfError(DoStart(t));
   858 	User::LeaveIfError(DoStart(t));
   965 	TUint id=t.Id();
   859 	TUint id=t.Id();
   966 	return(id);
   860 	return(id);
   967 	}
   861 	}
   968 
   862 
   969 void CPluginThread::CompleteSessionRequests(CSessionFs* aSession, TInt aValue)
       
   970 	{
       
   971 	__THRD_PRINT(_L("CPluginThread::CompleteSessionRequests()"));
       
   972 	iListLock.Wait();
       
   973 	TDblQueIter<CFsRequest> q(iList);
       
   974 	CFsRequest* pR;
       
   975 	while((pR=q++)!=NULL)
       
   976 		{
       
   977 		if(pR->Session()==aSession)
       
   978 			{
       
   979 			pR->iLink.Deque();
       
   980 			pR->Complete(aValue);
       
   981 			}
       
   982 		}
       
   983 	iListLock.Signal();
       
   984 	__THRD_PRINT(_L("session requests completed"));
       
   985 	}
       
   986 
   863 
   987 TInt CPluginThread::DoThreadInitialise()
   864 TInt CPluginThread::DoThreadInitialise()
   988 	{
   865 	{
   989 	__PRINT(_L("CPluginThread::DoThreadInitialise()"));
   866 	__PRINT(_L("CPluginThread::DoThreadInitialise()"));
   990  	TRAPD(err, iPlugin.InitialiseL());
   867  	TRAPD(err, iPlugin.InitialiseL());