--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/sfile/sf_mnt.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,466 @@
+// Copyright (c) 1995-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:
+//
+
+#include "sf_std.h"
+
+
+
+
+/**
+Default constructor.
+*/
+EXPORT_C CMountCB::CMountCB()
+ :iMountQ(_FOFF(CFileCB,iMountLink))
+ {
+ __PRINT1(_L("CMountCB::CMountCB()[0x%x]"),this);
+ }
+
+
+
+
+EXPORT_C CMountCB::~CMountCB()
+ {
+ __PRINT1(_L("CMountCB::~CMountCB()[0x%x]"),this);
+ delete iBody;
+ delete iVolumeName;
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ Compares the specified mount control block with this one for inequality.
+
+ Two mount control blocks are different if either the addresses of
+ the mount control blocks ar different, or their iMountNumber values
+ are different.
+
+ @param aMount The mount control block to be compared.
+
+ @return True, if the mount control blocks are different, false otherwise.
+*/
+EXPORT_C TBool CMountCB::operator!=(const CMountCB& aMount) const
+ {
+
+ if (this==(&aMount) && MountNumber()==aMount.MountNumber())
+ return(FALSE);
+ return(TRUE);
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ Tests whether the given attribute mask matches given criteria (specified
+ in another mask).
+
+ This function is used when filtering entries. aMatt specifies the criteria
+ to be matched by anAtt.
+
+ Volumes are ignored, so if anAtt has the volume attribute set then
+ the function returns false.
+
+ If aMatt does not have a hidden (KEntryAttHidden), system (KEntryAttSystem),
+ or directory (KEntryAttDir) attribute set and anAtt does have
+ the corresponding attribute set, then the function returns false.
+ Alternatively, if aMatt has KEntryAttMustBeFile set and anAtt has
+ the directory attribute set, then the function also returns EFalse.
+
+ Further matching behaviour can be implemented using
+ KEntryAttMatchExclusive and KEntryAttMatchExclude.
+
+ @param anAtt Attribute mask to be tested.
+ @param aMatt The attribute match mask.
+
+ @return True, if the anAtt entry attributes match, false otherwise.
+
+ @see KEntryAttHidden
+ @see KEntryAttSystem
+ @see KEntryAttDir
+ @see KEntryAttMustBeFile
+ @see KEntryAttMatchExclusive
+ @see KEntryAttMatchExclude
+*/
+EXPORT_C TBool CMountCB::MatchEntryAtt(TUint anAtt,TUint aMatt) const
+ {
+ if (aMatt&KEntryAttMatchExclude)
+ { // Include any except
+ if ((anAtt&aMatt)==0)
+ return(ETrue);
+ return(EFalse);
+ }
+
+ anAtt&=KEntryAttMaskSupported;
+ if ((aMatt&KEntryAttMustBeFile) && (anAtt&KEntryAttIllegal))
+ return(EFalse); // Not a file
+
+ if ((aMatt&KEntryAttHidden)==0 && (anAtt&KEntryAttHidden))
+ return(EFalse); // Ignore hidden unless requested
+ if ((aMatt&KEntryAttSystem)==0 && (anAtt&KEntryAttSystem))
+ return(EFalse); // Ignore system unless requested
+ if ((aMatt&KEntryAttDir)==0 && (anAtt&KEntryAttDir))
+ return(EFalse); // Ignore directory unless requested
+ if (anAtt&KEntryAttVolume)
+ return(EFalse); // Ignore volumes
+
+ anAtt&=(~(KEntryAttHidden|KEntryAttSystem)); // remove hidden and system
+
+ if (aMatt&KEntryAttMatchExclusive)
+ { // Exclude all except
+ if ((anAtt&aMatt)!=0)
+ return(ETrue);
+ return(EFalse);
+ }
+ return(ETrue);
+ }
+
+
+
+//-----------------------------------------------------------------------------
+/**
+ Gets the address of the specified file if it is found in ROM.
+
+ The default implementation sets aFileStart to NULL, and this should only
+ be overridden by ROM file systems.
+
+ @param aFileName A reference to a descriptor containing the full file name.
+ @param aFileStart On return, the address of the file, aFileName.
+ The default implementation returns NULL.
+*/
+EXPORT_C void CMountCB::IsFileInRom(const TDesC& /*aFileName*/,TUint8*& aFileStart)
+ {
+
+ aFileStart=NULL;
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ Notifies the file server that the free disk space of the mounted volume
+ has changed outside of the standard file system operations.
+
+ For example, the background thread of the log flash file system will call
+ this function after a background roll-forward.
+
+ @param aFreeSpace New free disk space value.
+*/
+EXPORT_C void CMountCB::SetDiskSpaceChange(TInt64 aFreeSpace)
+ {
+ const TInt drv=Drive().DriveNumber();
+ __ASSERT_ALWAYS(aFreeSpace>=0,Fault(ESvrFreeDiskSpace));
+ __PRINT3(_L("CMountCB::SetDiskSpaceChange(%LU) drv:%d, %dKB"), aFreeSpace, drv, (TUint32)(aFreeSpace>>10));
+
+ // Notifying involves memory de-allocation on the file server's heap -
+ // check if we need to switch heaps.
+ RAllocator* current_alloc = &User::Heap();
+ RAllocator* svr_alloc = ServerThreadAllocator;
+ if (current_alloc != svr_alloc)
+ User::SwitchHeap(svr_alloc);
+
+ FsNotify::HandleDiskSpace(drv, aFreeSpace);
+
+ if (current_alloc != svr_alloc)
+ User::SwitchHeap(current_alloc);
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Initialize the MountCB object.
+
+ @param aDrive TDrive object that will be used by the mount for drive access
+ @param apFileSystem pointer to the File System object that has produced this CMountCB
+*/
+EXPORT_C void CMountCB::InitL(TDrive& aDrive, CFileSystem* apFileSystem)
+ {
+ __PRINT3(_L("CMountCB::InitL()[0x%x] drv:%d, FS:0x%x"), this, aDrive.DriveNumber(), apFileSystem);
+ ASSERT(apFileSystem);
+
+
+ SetDrive(&aDrive);
+ DoInitL(aDrive.DriveNumber());
+
+ // see whether the file system supports the CFileCB extended API
+ MFileAccessor* fileAccessor = NULL;
+
+ GetInterfaceTraced(CMountCB::EFileAccessor, (void*&) fileAccessor, NULL);
+
+ MFileExtendedInterface* fileExtInterface = NULL;
+ GetInterface(CMountCB::EFileExtendedInterface, (void*&) fileExtInterface, NULL);
+
+ if(!iBody)
+ {
+ iBody = new(ELeave)CMountBody(this, fileAccessor, fileExtInterface);
+ }
+ else
+ {
+ //-- some file systems can call this method several times for the same mount.
+ //-- composite FS, for example.
+ __PRINT1(_L("CMountCB::InitL !!re-initialisation!! iBody:0x%x"), iBody);
+ }
+
+ SetFileSystem(apFileSystem); //-- associate MountCB object with the file system it belongs to; this relies on iBody
+ }
+
+/**
+Reports whether the specified interface is supported - if it is,
+the a supplied interface object is modified to it
+
+@param aInterfaceId The interface of interest
+@param aInterface The interface object
+@return KErrNone if the interface is supported, otherwise KErrNotFound
+*/
+EXPORT_C TInt CMountCB::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)
+ {
+ return(KErrNotSupported);
+ }
+
+/**
+Creates a clamp for the named file, and provides clamp handle data to the caller.
+
+@param aDriveNo The number of the drive on which the file can be found
+@param aName Name of the file to clamp
+@param aHandle Pointer to the clamp handle data
+@return KErrNone if successful, otherwise one of the systme-wide eror codes.
+*/
+TInt CMountCB::ClampFile(const TInt aDriveNo, const TDesC& aName, TAny* aHandle)
+ {
+ return(iBody?iBody->ClampFile(aDriveNo,aName,aHandle):KErrNotSupported);
+ };
+
+/**
+Reports whether the named file is clamped.
+
+@param aName Name of the file to clamp
+@return 0 if the file is not clamped, 1 if it is, or a system-wide error code.
+*/
+EXPORT_C TInt CMountCB::IsFileClamped(/*const TDesC& aName,*/ const TInt64 aUniqueId)
+ {
+ return(iBody?iBody->IsFileClamped(aUniqueId):KErrNotSupported);
+ };
+
+/**
+Removes the clamp indicated by the specified handle.
+If this was the last clamp for the drive, any pending dismount is performed.
+
+@param aHandle Pointer to the clamp handle data
+@return KErrNone if successful, a system-wide error code otherwise
+*/
+TInt CMountCB::UnclampFile(RFileClamp* aHandle)
+ {
+ return(iBody?iBody->UnclampFile(aHandle):KErrNotSupported);
+ };
+
+/**
+Returns the current number of clamps
+
+@return the number of clamps
+*/
+TInt CMountCB::NoOfClamps()
+ {
+ return(iBody?iBody->NoOfClamps():KErrNotSupported);
+ }
+
+
+
+
+/**
+Gets the sub type name of mounted file system (e.g. FAT12, FAT16 or FAT32 of Fat file system).
+Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
+The real implementations is done by classes multiple inherited from both CMountCB and
+MFileSystemSubType that have implemented MFileSystemSubType::SubType() virtual function.
+File system that do not support sub types will have KErrNotSupported returned.
+
+@param aSubTypeName A descriptor contains return of the sub type name.
+@return KErrNone if successful; otherwise another of the system wide error codes;
+ KErrNotSupported if sub type is not supported by mounted file system;
+
+@see MFileSystemSubType::SubType()
+*/
+TInt CMountCB::FileSystemSubType(TDes& aName)
+ {
+ MFileSystemSubType* interface = NULL;
+ TAny* dummy = NULL;
+ TInt rel = GetInterfaceTraced(EGetFileSystemSubType, (TAny*&)(interface), dummy);
+ if((interface != NULL) && (rel == KErrNone))
+ {
+ rel = interface->SubType(aName);
+ }
+
+ return rel;
+ }
+
+/**
+Gets the cluster size of mounted file system.
+Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
+The real implementation is done by classes multiple inherited from both CMountCB and
+MFileSystemClusterSize that have implemented MFileSystemClusterSize::ClusterSize() function.
+File system that do not support concept of 'clusters' will have the default KErrNotSupported returned.
+
+@return Cluster size value if successful; otherwise another of the system wide error codes;
+ KErrNotSupported if cluster is not supported by mounted file system;
+
+@see MFileSystemClusterSize::ClusterSize()
+*/
+TInt CMountCB::FileSystemClusterSize()
+ {
+ MFileSystemClusterSize* interface = NULL;
+ TAny* dummy = NULL;
+ TInt rel = GetInterfaceTraced(EGetClusterSize, (TAny*&)(interface), dummy);
+ if((interface != NULL) && (rel == KErrNone))
+ {
+ rel = interface->ClusterSize();
+ }
+
+ return rel;
+ }
+
+
+/**
+@prototype
+
+Reads a specified section of the file, regardless of the file's lock state.
+
+Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
+The real implementation is done by classes multiple inherited from both CMountCB and
+MFileSystemExtendedInterface that have implemented MFileSystemExtendedInterface::ExtendedReadSectionL() function.
+File system that do not support large file will implement the default CMountCB::ReadSectionL() function.
+
+@see CMountCB::ReadSectionL()
+
+@see MFileSystemExtendedInterface::ExtendedReadSectionL()
+*/
+void CMountCB::ReadSection64L(const TDesC& aName,TInt64 aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)
+ {
+ iBody->iFileExtendedInterface->ReadSection64L(aName, aPos, aTrg, aLength, aMessage);
+ }
+
+TInt CMountCB::GetFileUniqueId(const TDesC& aName, TInt64& aUniqueId)
+ {
+ return (iBody->iFileAccessor->GetFileUniqueId(aName, aUniqueId));
+ }
+
+TInt CMountCB::Spare3(TInt aVal, TAny* aPtr1, TAny* aPtr2)
+ {
+ return (iBody->iFileAccessor->Spare3(aVal, aPtr1, aPtr2));
+ }
+
+TInt CMountCB::Spare2(TInt aVal, TAny* aPtr1, TAny* aPtr2)
+ {
+ return (iBody->iFileAccessor->Spare2(aVal, aPtr1, aPtr2));
+ }
+
+TInt CMountCB::Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2)
+ {
+ return (iBody->iFileAccessor->Spare1(aVal, aPtr1, aPtr2));
+ }
+
+TInt CMountCB::GetInterfaceTraced(TInt aInterfaceId, TAny*& aInterface, TAny* aInput)
+ {
+ TRACE3(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetInterface, EF32TraceUidFileSys,
+ DriveNumber(), aInterfaceId, aInput);
+
+ TInt r = GetInterface(aInterfaceId, aInterface, aInput);
+
+ TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetInterfaceRet, EF32TraceUidFileSys, r, aInterface);
+
+ return r;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Get the file system name. I.e. The name of the file system that produced this object of CMountCB
+ @param aName buffer for the name
+*/
+void CMountCB::FileSystemName(TDes& aName)
+{
+ aName = FileSystem()->Name();
+}
+
+
+
+//-----------------------------------------------------------------------------
+/**
+ Associate CFileSystem object (the factory) and the produced CMountCB object.
+ @param aFS pointer to the file system that produced this mount.
+*/
+void CMountCB::SetFileSystem(CFileSystem* aFS)
+ {
+ ASSERT(iBody);
+ iBody->SetFileSystem(aFS);
+ }
+
+/**
+ Get reference to the filesystem, associated with this mount.
+*/
+EXPORT_C CFileSystem* CMountCB::FileSystem() const
+ {
+ ASSERT(iBody);
+ CFileSystem* pFSys = iBody->GetFileSystem();
+ ASSERT(pFSys);
+ return pFSys;
+ }
+
+void CMountCB::SetProxyDriveDismounted()
+ {
+ iBody->SetProxyDriveDismounted();
+ }
+
+TBool CMountCB::ProxyDriveDismounted()
+ {
+ return iBody->ProxyDriveDismounted();
+ }
+
+
+/**
+ Factory method. Produces CFileCB object.
+*/
+CFileCB* CMountCB::NewFileL() const
+ {
+ return FileSystem()->NewFileL();
+ }
+
+/**
+ Factory method. Produces CDirCB object.
+*/
+CDirCB* CMountCB::NewDirL() const
+ {
+ return FileSystem()->NewDirL();
+ }
+
+
+/**
+ Factory method. Produces CFormatCB object.
+*/
+CFormatCB* CMountCB::NewFormatL() const
+ {
+ return FileSystem()->NewFormatL();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+