diff -r 000000000000 -r 96e5fb8b040d userlibandfileserver/fileserver/sfile/sf_mnt.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/userlibandfileserver/fileserver/sfile/sf_mnt.cpp Thu Dec 17 09:24:54 2009 +0200 @@ -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(); + } + + + + + + + + + + + + + + + +