--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/sfile/sf_std.inl Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,337 @@
+// Copyright (c) 1998-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_std.inl
+//
+//
+
+#ifndef SF_STD_INL
+#define SF_STD_INL
+
+//Class CFsRequest
+
+void CFsRequest::Kill(TInt aReason)
+ {
+ if(!ErrorPlugin(aReason))
+ Message().Kill(aReason);
+ }
+
+void CFsRequest::Terminate(TInt aReason)
+ {
+ if(!ErrorPlugin(aReason))
+ Message().Terminate(aReason);
+ }
+
+void CFsRequest::Panic(const TDesC &aCategory,TInt aReason)
+ {
+ __IF_DEBUG(Print(_L("CFsRequest::Panic %S %d"),&aCategory,aReason));
+ if(!ErrorPlugin(aReason))
+ Message().Panic(aCategory,aReason);
+ }
+
+TBool CFsRequest::ErrorPlugin(TInt aError)
+ {
+ CFsMessageRequest& self = *(CFsMessageRequest*)this;
+ CFsPlugin* plugin = self.iOwnerPlugin;
+ if(plugin)
+ {
+ plugin->iLastError = aError;
+ plugin->iThreadP->OperationLockSignal();
+ self.iOwnerPlugin = NULL;
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// class CFsObjectIx
+TInt CFsObjectIx::Count() const
+ {return(iHighWaterMark);}
+TInt CFsObjectIx::ActiveCount() const
+ {return(iNumEntries);}
+void CFsObjectIx::Lock()
+ {iLock.Wait();}
+void CFsObjectIx::Unlock()
+ {iLock.Signal();}
+
+// class CFsObjectCon
+void CFsObjectCon::Lock()
+ {iLock.Wait();}
+void CFsObjectCon::Unlock()
+ {iLock.Signal();}
+TInt CFsObjectCon::UniqueID() const
+ {return(iUniqueID);}
+TInt CFsObjectCon::Count() const
+ {return(iCount);}
+
+// class CDisconnectThread
+CFsInternalRequest* CDisconnectThread::GetRequest()
+ {return(iRequest);}
+
+
+
+
+
+
+
+
+// class CServerFs
+void CServerFs::SessionQueueLockWait()
+ {iSessionQueueLock.Wait();}
+
+void CServerFs::SessionQueueLockSignal()
+ {iSessionQueueLock.Signal();}
+
+// class CSessionFs
+void CSessionFs::IncResourceCount()
+ { __e32_atomic_add_ord32(&iResourceCount, 1); }
+void CSessionFs::DecResourceCount()
+ { __e32_atomic_add_ord32(&iResourceCount, (TUint32)(-1)); }
+CFsObjectIx& CSessionFs::Handles()
+ {return(*iHandles);}
+
+
+HBufC& CSessionFs::Path()
+ {/*__CHECK_MAINTHREAD();*/ return(*iPath);}
+void CSessionFs::SetPath(HBufC* aPath)
+ {__CHECK_MAINTHREAD(); iPath=aPath;}
+
+TThreadId& CSessionFs::ThreadId()
+ { return iId; }
+void CSessionFs::SetThreadId(const TThreadId& aId)
+ {
+ iId = aId;
+ }
+
+
+// class TReservedDriveAccess
+TReservedDriveAccess::TReservedDriveAccess(TInt aDriveNumber)
+ : iDriveNumber(aDriveNumber),
+ iReservedSpace(0),
+ iReservedAccess(EFalse)
+ { }
+
+TReservedDriveAccess::TReservedDriveAccess(TInt aDriveNumber, TInt aReservedSpace)
+ : iDriveNumber(aDriveNumber),
+ iReservedSpace(aReservedSpace),
+ iReservedAccess(EFalse)
+ { }
+
+
+// class TOperation
+TBool TOperation::IsSync() const
+ {return(iFlags & ESync)?(TBool)ETrue:(TBool)EFalse;}
+TInt TOperation::Function()
+ {return(iFunction);}
+TInt TOperation::Initialise(CFsRequest* aRequest)
+ {return((*iInitialise)(aRequest));}
+TInt TOperation::PostInitialise(CFsRequest* aRequest)
+ {return((*iPostInitialise)(aRequest));}
+TInt TOperation::DoRequestL(CFsRequest* aRequest)
+ {return((*iDoRequestL)(aRequest));}
+TFsPluginRequest::TF32ArgType TOperation::Arg(TUint aIndex)
+ {return((TFsPluginRequest::TF32ArgType)((TUint8*)&iArgs)[aIndex]);}
+
+
+inline void TMsgOperation::Set(TInt64 aPos, TInt aLength, TUint8* aData, TInt aOffset, TInt aNextState)
+ {
+ iReadWriteArgs.iPos = aPos;
+ iReadWriteArgs.iTotalLength = iReadWriteArgs.iLength = aLength;
+ iReadWriteArgs.iData = aData;
+ iReadWriteArgs.iOffset = aOffset;
+ iClientRequest = EFalse;
+ iState = aNextState;
+ }
+
+//Operations pushed from the client use this version of Set
+inline void TMsgOperation::Set(TInt64 aPos, TInt aLength, TDesC8* aData, TInt aOffset, TInt aNextState)
+ {
+ iReadWriteArgs.iPos = aPos;
+ iReadWriteArgs.iTotalLength = iReadWriteArgs.iLength = aLength;
+ iReadWriteArgs.iData = aData;
+ iReadWriteArgs.iOffset = aOffset;
+ iClientRequest = ETrue;
+ iState = aNextState;
+ }
+
+// class CFsRequest
+TOperation* CFsRequest::Operation()
+ {return(iOperation);}
+CSessionFs* CFsRequest::Session()
+ {return(iSession);}
+void CFsRequest::SetSession(CSessionFs* aSession)
+ {iSession=aSession;}
+TInt CFsRequest::DriveNumber()
+ {return(iDriveNumber);}
+void CFsRequest::SetDriveNumber(TInt aDriveNumber)
+ {iDriveNumber=aDriveNumber;}
+TBool CFsRequest::IsCompleted()
+ {return(iIsCompleted);}
+void CFsRequest::SetCompleted(TBool aIsCompleted)
+ {iIsCompleted=aIsCompleted;}
+TUint CFsRequest::ScratchValue()
+ {return I64LOW(iScratchValue);}
+void CFsRequest::SetScratchValue(const TUint aValue)
+ {SetAndOpenScratchValue(aValue);}
+TInt64 CFsRequest::ScratchValue64()
+ {return(iScratchValue);}
+void CFsRequest::SetScratchValue64(const TInt64& aValue)
+ {SetAndOpenScratchValue(aValue);}
+TBool CFsRequest::IsSeparateThread()
+ {return(!iOperation->IsSync());}
+TBool CFsRequest::IsPostOperation() const
+ {return iFlags & EPostOperation;}
+void CFsRequest::SetPostOperation(TBool aSet)
+ {aSet? iFlags |= EPostOperation : iFlags &= ~EPostOperation;}
+TBool CFsRequest::IsPluginSpecific() const
+ {return(iOperation->iFunction == EFsPluginOpen ||
+ iOperation->iFunction == EFsPluginDoRequest ||
+ iOperation->iFunction == EFsPluginDoControl ||
+ iOperation->iFunction == EFsPluginDoCancel);}
+
+TBool CFsRequest::IsExpectedResult(TInt aError) const
+ {return ((aError == KErrNone) ||
+ (iOperation->iFunction == EFsDirReadPacked && aError == KErrEof));}
+
+void CFsRequest::SetError(TInt aError)
+ {iError = aError;}
+
+TInt CFsRequest::GetError() const
+ {return iError;}
+
+TBool CFsRequest::IsChangeNotify() const
+ { return ( iSession && iSession->IsChangeNotify() && iOperation->IsChangeNotify()); }
+
+void CFsRequest::SetState(TReqStates aReqState)
+ { iReqState = aReqState; }
+
+TBool CFsRequest::DirectToDrive()
+ { return(iDirectToDrive); }
+
+TBool CFsRequest::IsFsObjectOpen()
+ { return iFlags & EFsObjectOpen;}
+void CFsRequest::SetFsObjectOpen(TBool aSet)
+ {aSet? iFlags |= EFsObjectOpen : iFlags &= ~EFsObjectOpen;}
+
+/**
+Returns ETrue if the IPC Message Argument slot is packed with descriptor data for
+EFsFileRead, EFsFileWrite, EFsFileSeek, EFsFileLock, EFsFileUnLock, EFsFileSize,
+EFsFileSetSize and EFsReadFileSection requests.
+
+@panic if the aMsgNum is greater than the number of IPC message arguments, KMaxMessageArguments.
+
+@param IPC message argument index
+*/
+TBool CFsRequest::IsDescData(TInt aMsgNum)
+ {
+ __ASSERT_DEBUG(aMsgNum < KMaxMessageArguments, Fault(EBadMessageSlotIndex));
+ return ((1 << (aMsgNum + KIpcFlagOffset)) & Message().Function())?(TBool)ETrue:(TBool)EFalse;
+ }
+
+/**
+Least 16 bits (0 to 15) are used for file server operation index.
+Remaining bits (16 to 31) are reserved for other purposes.
+Should be called in place of CFsRequest::Message().Function()
+if the file server operation index is required.
+
+@return Returns the file server operation index by masking the upper 16 bits.
+*/
+TInt CFsRequest::FsFunction()
+ {return (Message().Function() & KIpcFunctionMask);}
+
+// class CFsMessageRequest
+void CFsMessageRequest::SetMessage(RMessage2& aMessage)
+ {iMessage=aMessage;}
+
+TMsgOperation* CFsMessageRequest::CurrentOperationPtr()
+ {return iCurrentOperation;}
+
+// class CFsInternalRequest
+void CFsInternalRequest::SetThreadHandle(TInt aThreadHandle)
+ {iThreadHandle=aThreadHandle;}
+TInt CFsInternalRequest::ThreadHandle()
+ {return(iThreadHandle);}
+TRequestStatus& CFsInternalRequest::Status()
+ {return(iStatus);}
+TBool CFsInternalRequest::IsAllocated()
+ {return(iIsAllocated);}
+void CFsInternalRequest::SetAllocated()
+ {iIsAllocated=ETrue;}
+
+// class CFsMessageRequest
+TBool CFsMessageRequest::IsFreeChanged()
+ {return(iFlags & EFreeChanged);}
+void CFsMessageRequest::SetFreeChanged(TBool aChanged)
+ { if (aChanged) iFlags |= EFreeChanged; else iFlags &= ~EFreeChanged;};
+TBool CFsMessageRequest::IsAllocated()
+ {return(iFlags & EIsAllocated);}
+void CFsMessageRequest::SetAllocated()
+ {iFlags |= EIsAllocated;}
+CFsMessageRequest::CFsMessageRequest()
+ {iFlags &= ~EIsAllocated;}
+
+TBool CFsMessageRequest::PostInterceptEnabled()
+ {return iFlags & EPostInterceptEnabled;}
+void CFsMessageRequest::EnablePostIntercept(TBool aEnable)
+ {if (aEnable) iFlags |= EPostInterceptEnabled; else iFlags &= ~EPostInterceptEnabled;}
+
+
+
+inline TInt& CFsMessageRequest::LastError()
+ {
+ return iLastError;
+ }
+inline void CFsMessageRequest::SetLastError(TInt aLastError)
+ {
+ iLastError = aLastError;
+ }
+
+inline void CFsMessageRequest::Init()
+ {
+ SetLastError(KErrNone);
+ iCurrentOperation = NULL;
+ }
+
+
+// class CNotifyInfo
+CSessionFs* CNotifyInfo::Session()
+ {return(iSession);}
+TRequestStatus* CNotifyInfo::Status()
+ {return(iStatus);}
+
+#if defined(_USE_CONTROLIO) || defined(_DEBUG) || defined(_DEBUG_RELEASE)
+// Class RequestAllocator
+/** returns number of dynamically allocated requests */
+TInt RequestAllocator::AllocatedCount()
+{ return iAllocated;}
+/** returns number of permanently & dynamically allocated requests */
+TInt RequestAllocator::TotalCount()
+{ return iAllocated + iAllocNum;}
+#endif
+
+//---------------------------------------------------------------------------------------------------------------------
+
+inline CFileSystem* CMountBody::GetFileSystem() const
+ {
+ return iFSys;
+ }
+
+inline void CMountBody::SetFileSystem(CFileSystem* aFsys)
+ {
+ iFSys = aFsys;
+ }
+
+
+
+#endif //SF_STD_INL
+
+