// 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:

// f32\inc\f32fsys.inl

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without noticed. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

#define __IS_DRIVETHREAD() {__ASSERT_DEBUG(IsDriveThread(),DriveFault(ETrue));}

#define __IS_MAINTHREAD() {__ASSERT_DEBUG(IsMainThread(),DriveFault(EFalse));}

//---------------------------------------------------------------------------------------------------------------------------------

// Class TDrive

/**

Gets last error reason.

@return	TInt	Returns last error reason.

*/

inline TInt TDrive::GetReason() const

	{

	__IS_DRIVETHREAD(); 

	return(iReason);

	}

/**

Sets a flag to state that the drive contents has changed.

@param	aValue	True if contents has changed; False if unchanged.

*/

inline void TDrive::SetChanged(TBool aValue)

	{

	iChanged=aValue;

	}

/**

Determines whether the drive content has changed.

@return	True if contents changed , False if unchanged.

*/

inline TBool TDrive::IsChanged() const

	{

	return(iChanged);

	}

/**

Returns the drive number.

@return The drive number. 

@see TDriveNumber

*/

inline TInt TDrive::DriveNumber() const

	{return(iDriveNumber);}

/**

Determines whether the drive is mounted.

@return True if drive is mounted, False if drive is not mounted.

*/

inline TBool TDrive::IsMounted() const

	{

	__IS_DRIVETHREAD();

	return(iCurrentMount!=NULL);

	}

/**

Determines whether attribute is set to local.

@return True if attribute is set to KDriveAttLocal, False for all other attributes.

*/

inline TBool TDrive::IsLocal()  const

	{return(iAtt & KDriveAttLocal);}

/**

Determines whether the drive is ROM drive.

@return True if drive attribute is set as ROM drive  , False if not set as ROM drive.

*/

inline TBool TDrive::IsRom()  const

	{return( iAtt & KDriveAttRom);}

/**

Determines whether the drive is removable.

@return True if drive attribute is set to removable , False for all other attributes.

*/

inline TBool TDrive::IsRemovable() const

	{return( iAtt & KDriveAttRemovable);}

/**

Determines whether the drive is substed.

@return True if drive attribute is set to substed (KDriveAttSubsted), False for all other attributes.

*/

inline TBool TDrive::IsSubsted() const

	{return( iAtt & KDriveAttSubsted);}//	KDriveAttSubsted = 0x08

/**

Gets a reference to the object representing the current mount.

@return The file's mount.

*/

inline CMountCB& TDrive::CurrentMount() const

	{

	__IS_DRIVETHREAD();

	return(*iCurrentMount);

	}

inline  TBool TDrive::IsCurrentMount(CMountCB& aMount) const

	{return(iCurrentMount == &aMount);}

/**

Gets the substed drive.

@return		A pointer to the drive which is substed.

*/

inline TDrive& TDrive::SubstedDrive()const

	{

	__IS_MAINTHREAD();

	return(*iSubstedDrive);

	}

/**

Sets the drive as substed to the path set by an earlier call to SetSubst().

@param	aDrive	A pointer to the drive on which the volume is mounted.

*/

inline void TDrive::SetSubstedDrive(TDrive* aDrive)

	{

	__IS_MAINTHREAD();

	iSubstedDrive=aDrive;

	}

/**

Gets the substed path set by an earlier call to SetSubst().

@return	A reference to a heap descriptor containing the substed path.

*/

inline HBufC& TDrive::Subst() const

	{

	__IS_MAINTHREAD();

	return(*iSubst);

	}

/**

Assigns a path to a drive.

@param	aSubst	Path will be assigned to a drive.

*/

inline void TDrive::SetSubst(HBufC* aSubst)

	{

	__IS_MAINTHREAD();

	iSubst=aSubst;

	}

/**

Gets a reference to the object representing the mount on which the file resides.

@return The Drives's mount.

*/

inline CFsObjectCon& TDrive::Mount() const

	{return(*iMount);}

/**

Gets a reference to the object representing the file system

@return The reference to file system.

*/

inline CFileSystem& TDrive::FSys()

	{return(*iFSys);}

/**

Gets the object representing the file system

@return The file system.

*/

inline CFileSystem*& TDrive::GetFSys()

	{return(iFSys);}

/**

Gets the object representing the TDriveExtInfo.

@return The Drive extension information object.

@see	TDriveExtInfo

*/

inline TDriveExtInfo& TDrive::ExtInfo()

	{

	__IS_DRIVETHREAD();

	return(iExtInfo);

	}

/**

Sets the notification flag ON. The client will receive notifications on Read or Write 

failures from the file system.

*/

inline void TDrive::SetNotifyOn()

	{

	__IS_DRIVETHREAD();

	iDriveFlags &= ~ENotifyOff;

	}

/**

Sets the notification flag OFF. The client will not receive notifications on Read or Write 

failures from the file system.

*/

inline void TDrive::SetNotifyOff()

	{

	__IS_DRIVETHREAD();

	iDriveFlags |= ENotifyOff;

	}

/**

Locks the drive.This function acquires iLock mutex.

*/

inline void TDrive::Lock()

	{iLock.Wait();}

/**

UnLocks the drive.This function signals the iLock mutex.

*/

inline void TDrive::UnLock()

	{iLock.Signal();}

/**

Gets the reserved space of a drive

@return	Amount of space reserved in bytes.

*/

inline TInt TDrive::ReservedSpace() const

	{return iReservedSpace;}

/**

Reserves a space of a drive.

@param	aReservedSpace	Amount of space to reserve in bytes.

*/

inline void TDrive::SetReservedSpace(const TInt aReservedSpace)

	{iReservedSpace=aReservedSpace; }

/**

Sets the rugged flag in the drive object.

@param Flag to set or clear the rugged flag.

@see	IsRugged()

*/

inline void TDrive::SetRugged(TBool aIsRugged)

	{

	if (!aIsRugged)

		iDriveFlags |= ENotRugged;

	else

		iDriveFlags &= ~ENotRugged;

	}

/**

Returns whether the current drive is running as rugged Fat

or not.If IsRugged flag is set then in the event of power 

failure fat/metadata will be in a valid state if the scandrive 

utility is run immediately after.

@return Is rugged fat flag.

*/

inline TBool TDrive::IsRugged() const

	{return !(iDriveFlags & ENotRugged); }

/**

    @return ETrue if the drive is synchronous, i.e. runs in the main file server thread.

*/

inline TBool TDrive::IsSynchronous() const

{

    return iDriveFlags & EDriveIsSynch;

}

/**

    Set or reset internal EDriveIsSynch flag for the TDrive.

*/

inline void TDrive::SetSynchronous(TBool aIsSynch)

{

    if(aIsSynch)

        iDriveFlags |= EDriveIsSynch;

    else

        iDriveFlags &= ~EDriveIsSynch;

}

inline TBool TDrive::DismountDeferred() const

	{ return(iDriveFlags & EDismountDeferred); }

// Class CMountCB

/**

Gets a reference to the object representing the drive on which

the volume is mounted.

@return The drive on which the volume is mounted.

*/

inline TDrive& CMountCB::Drive() const

	{return(*iDrive);}

/**

Sets a pointer to the object representing the drive on which

the volume is mounted.

@param aDrive A pointer to the drive on which the volume is mounted.

*/

inline void CMountCB::SetDrive(TDrive* aDrive)

	{iDrive=aDrive;}

/**

Gets a reference to a heap descriptor containing the name of

the mounted volume.

@return A reference to a heap descriptor containing the volume name.

*/

inline HBufC& CMountCB::VolumeName() const

	{return(*iVolumeName);}

/**

Sets a pointer to a heap descriptor containing the name of the mounted volume.

@param aName A pointer to a heap descriptor containing the name of

             the mounted volume to be set.

*/

inline void CMountCB::SetVolumeName(HBufC* aName)

	{iVolumeName=aName;}

/**

Tests whether the client is notified of any read or write failures.

The notification status is a property of the current session with

the file server, the value of which is stored in CSessionFs::iNotifyUser.

If set to true, the client will receive notifications from the file system.

Typically, this function might be used to save the current notification

state prior to temporarily disabling notifiers. This allows the original

notification state to be restored. 

Note that GetNotifyUser() is only available once the drive has been set for

the mount control block (using SetDrive()), since the notification status

is held by the session and accessed via the drive.

@return True if the client receives notifications from the file system,

        false otherwise.

*/

inline TBool CMountCB::GetNotifyUser() const

	{return(Drive().GetNotifyUser());}

/**

*/

inline void CMountCB::SetNotifyOn()

	{Drive().SetNotifyOn();}

/**

*/

inline void CMountCB::SetNotifyOff()

	{Drive().SetNotifyOff();}

/**

Locks the mount by incrementing the internal lock counter.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

*/

inline void CMountCB::IncLock()

	{iLockMount++;}

/**

Unlocks the mount by decrementing the internal lock counter.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

*/

inline void CMountCB::DecLock()

	{iLockMount--;}

/**

Gets the current lock status.

It delivers the current lock status by returning the internal lock counter.

@return The current lock status.

*/

inline TInt CMountCB::LockStatus() const

	{return(iLockMount);}

/**

Tests whether the mount is currently locked. 

A mount is locked when the internal lock counter is greater than zero.

On creation, the lock counter is set to zero.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

@return True if the mount is locked, false, otherwise.

*/

inline TBool CMountCB::Locked() const

	{return iLockMount>0; }

/**

Tests whether the mount control block represents the current mount on

the associated drive.

A drive has only one mount which is accessible: the current mount.

Any mount other than the current mount relates to a partition (i.e. volume)

that was present on a removable media which has since been removed.

The reason the mount has persisted is because resources (i.e. files/directories)

are still open on it.

This function is only available when the drive has been set for the mount

control block (using SetDrive()), since the current mount is held by the drive.

@return True if the mount is the current mount on the drive, false otherwise.

*/

inline TBool CMountCB::IsCurrentMount() const

	{return(this==&iDrive->CurrentMount());}

/**

*/

inline TInt64 CMountCB::Size() const

	{return(iSize);}

/**

Set the unique mount number

@param aMountNumber - The unique mount number

*/

const TInt KMountDismounted = 0x80000000;

inline void CMountCB::SetMountNumber(TInt aMountNumber)

	{ iMountNumber = (aMountNumber &~ KMountDismounted); }

/**

Set the mount to be dismounted

*/

inline void CMountCB::SetDismounted(TBool aDismounted)

	{

	if(aDismounted)

		iMountNumber |= KMountDismounted;

	else

		iMountNumber &= ~KMountDismounted;

	}

/**

Returns the unique mount number

@return The unique mount number

*/

inline TInt CMountCB::MountNumber() const

	{ return(iMountNumber &~ KMountDismounted); }

/**

Returns ETrue if the mount is flagged as dismounted.

@return ETrue if the mount is flagged as dismounted

*/

inline TBool CMountCB::IsDismounted() const

	{ return(iMountNumber & KMountDismounted); }

/**

Retrieves TBusLocalDrive object associated with the mount

*/

inline TInt CMountCB::LocalDrive(TBusLocalDrive*& aLocalDrive)

	{

	aLocalDrive = NULL;

	return GetInterface(EGetLocalDrive, (TAny*&) aLocalDrive, NULL);

	}

/**

Retrieves CProxyDrive object associated with the mount

*/

inline TInt CMountCB::ProxyDrive(CProxyDrive*& aProxyDrive)

	{

	aProxyDrive = NULL;

	return GetInterface(EGetProxyDrive, (TAny*&) aProxyDrive, NULL);

	}

inline TInt CMountCB::AddToCompositeMount(TInt aMountIndex)

	{ 

		TAny *mountInterface = NULL; 

		return(GetInterface(EAddToCompositeMount, mountInterface, (TAny*)aMountIndex)); 

	}

/**

Returns whether the mount (and any extensions) support file caching

*/

inline TInt CMountCB::LocalBufferSupport(CFileCB* aFile)

	{

	TAny* dummyInterface;

	return GetInterface(ELocalBufferSupport, dummyInterface, aFile);

	}

inline TInt CMountCB::MountControl(TInt /*aLevel*/, TInt /*aOption*/, TAny* /*aParam*/)

    {

    return KErrNotSupported;

    }

inline void CMountCB::FinaliseMountL(TInt aOperation, TAny* /*aParam1=NULL*/, TAny* /*aParam2=NULL*/) 

    {

    if(aOperation == RFs::EFinal_RW)

        {//-- call the legacy method

        FinaliseMountL();

        return;

        }

    User::Leave(KErrNotSupported);

    }

inline TInt CMountCB::CheckDisk(TInt /*aOperation*/, TAny* /*aParam1=NULL*/, TAny* /*aParam2=NULL*/) 

    {

    return(KErrNotSupported);

    }	

inline TInt CMountCB::ScanDrive(TInt /*aOperation*/, TAny* /*aParam1=NULL*/, TAny* /*aParam2=NULL*/) 

    {

    return(KErrNotSupported);

    }	

//---------------------------------------------------------------------------------------------------------------------------------

/**

    Check is this file system can be mounted on the drive at all. The file system implementation may, for example, 

    read and validate the boot region without real mounting overhead. 

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            this file system can be mounted on this drive

            KErrLocked          the media is locked on a physical level.

            other error codes depending on the implementation, indicating that this filesystem can't be mouned 

*/

inline TInt CMountCB::CheckFileSystemMountable() 

    {

    return MountControl(ECheckFsMountable, 0, NULL);

    }

//---------------------------------------------------------------------------------------------------------------------------------

/** 

    Query if the mount is finalised, corresponds to the EMountStateQuery control code only.

    @param  aFinalised  out: ETrue if the mount is finalised, EFalse otherwise. 

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            on success    

*/

inline TInt CMountCB::IsMountFinalised(TBool &aFinalised) 

    {

    return MountControl(EMountStateQuery, ESQ_IsMountFinalised, &aFinalised);

    }

//---------------------------------------------------------------------------------------------------------------------------------

/**

    Corresponds to EMountVolParamQuery. Request a certain amount of free space on the volume.

    If _current_ amount of free space is >= than required or it is not being updated in background by the mount, returns immediately;

    If mount is still counting free space and If _current_ amount of free space is < than required, the caller will be blocked

    until mount finds enough free space or reports that the _final_ amount of free space is less than required.

    @param   aFreeSpaceBytes in: number of free bytes on the volume required, out: resulted amount of free space. It can be less than 

                             required if there isn't enough free space on the volume at all.

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            on success    

*/

inline TInt CMountCB::RequestFreeSpace(TUint64 &aFreeSpaceBytes) 

    {

    return MountControl(EMountVolParamQuery, ESQ_RequestFreeSpace, &aFreeSpaceBytes);

    }

//---------------------------------------------------------------------------------------------------------------------------------

/**

    Corresponds to EMountVolParamQuery. A request to obtain the _current_ amount of free space on the volume asynchronously, without blocking.

    Some mounts implementations can count volume free space in the background. 

    @param  aFreeSpaceBytes  in: none; out: _current_ amount of free space on the volume.

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            on success    

*/

inline TInt CMountCB::GetCurrentFreeSpaceAvailable(TInt64 &aFreeSpaceBytes)

    {

    return MountControl(EMountVolParamQuery, ESQ_GetCurrentFreeSpace, &aFreeSpaceBytes);

    }

//---------------------------------------------------------------------------------------------------------------------------------

/**

    Corresponds to EMountVolParamQuery. A request to obtain size of the mounted volume without blocking (CMountCB::VolumeL() can block).

    @param  aVolSizeBytes  in: none; out: mounted volume size, same as TVolumeInfo::iSize

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            on success    

*/

inline TInt CMountCB::MountedVolumeSize(TUint64& aVolSizeBytes)  

    {

    return MountControl(EMountVolParamQuery, ESQ_MountedVolumeSize, &aVolSizeBytes);

    }

//---------------------------------------------------------------------------------------------------------------------------------

/** 

    Get Maximum file size, which is supported by the file system that has produced this mount. 

    @param  aVolSizeBytes  in: none; out: Theoretical max. supported by this file system file size.

    @return KErrNotSupported    this feature is not supported by the file system

            KErrNone            on success    

*/

inline TInt CMountCB::GetMaxSupportedFileSize(TUint64 &aSize) 

    {

    return MountControl(EMountFsParamQuery, ESQ_GetMaxSupportedFileSize, &aSize);

    }

//###############################################################################################

// Class CFileCB

/**

Sets the mount associated with the file.

@param aMount The mount.

*/

inline void CFileCB::SetMount(CMountCB * aMount)

	{iMount=aMount;}

/**

Gets a reference to the object representing the drive on which

the file resides.

@return A reference to the file's drive.

*/

inline TDrive& CFileCB::Drive() const

	{return(*iDrive);}

/**

Gets a reference to the object representing the drive on which the file was created.

The 'created drive' is only different from the 'drive', as returned by Drive(), if 

the 'drive' was a substitute for the 'created drive' in the file server session.

@return A reference to the drive on which the file was created.

*/

inline TDrive& CFileCB::CreatedDrive() const

	{return(*iCreatedDrive);}

/**

Gets a reference to the object representing the mount on which the file resides.

@return The file's mount.

*/

inline CMountCB& CFileCB::Mount() const

	{return(*iMount);}

/**

Gets a reference to a heap descriptor containing the full file name.

@return A heap descriptor containing the full file name.

*/

inline HBufC& CFileCB::FileName() const

	{return(*iFileName);}

/**

Gets a reference to a heap descriptor containing the folded full file name.

@return A heap descriptor containing the full file name.

*/

inline HBufC& CFileCB::FileNameF() const

	{return(*iFileNameF);}

/**

Gets the hash of the folded filename

@return hash of the folded file name

*/

inline TUint32 CFileCB::NameHash() const

	{return(iNameHash);}

/**

Gets a reference to the file share locks array being used by the file.

@return The file share lock.

*/

inline TFileLocksArray& CFileCB::FileLocks()

	{return(*iFileLocks);}

/**

Gets the file object's unique ID, as returned by CObject::UniqueID().

@return The object's unique ID.

@see CObject

*/

inline TInt CFileCB::UniqueID() const

	{return(CFsObject::UniqueID());}

/**

Gets the iShare value, which defines the level of access allowed to the file.

@return The value of iShare

@see CFileCB::iShare

*/

inline TShare CFileCB::Share() const

	{return(iShare);}

/**

Sets the iShare value, which defines the level of access allowed to the file.

@param aShare The new value.

@see CFileCB::iShare

*/

inline void CFileCB::SetShare(TShare aShare)

	{iShare=aShare;}

/**

Gets the size of the file.

@return The size of the file.

*/

inline TInt CFileCB::Size() const

	{return(iSize);}

/**

Sets the size of the file.

@param aSize The size of the file.

*/

inline void CFileCB::SetSize(TInt aSize)

	{iSize=aSize;}

/**

Gets the file's attributes.

@return An integer containing the file attribute bit mask.

*/

inline TInt CFileCB::Att() const

	{return(iAtt);}

/**

Sets the file's attributes.

@param aAtt The file attribute bit mask.

*/

inline void CFileCB::SetAtt(TInt aAtt)

	{iAtt=aAtt;}	

/**

Gets the universal time when the file was last modified.

@return The universal time when the file was last modiified.

*/

inline TTime CFileCB::Modified() const 

	{return(iModified);}

/**

Sets the universal time when the file was last modified.

@param aModified The universal time when the file was last modified.

*/

inline void CFileCB::SetModified(TTime aModified)

	{iModified=aModified;}

/**

Tests whether the file is corrupt.

@return ETrue if the file is corrupt; EFalse otherwise.

*/

inline TBool CFileCB::FileCorrupt() const

	{return iFileCorrupt;}

/**

Sets whether the file is corrupt.

@param aFileCorrupt ETrue, if the file is corrupt; EFalse, otherwise.

*/

inline void CFileCB::SetFileCorrupt(TBool aFileCorrupt)

	{iFileCorrupt=aFileCorrupt;}

/**

Gets the iBadPower value.

@return The value of iBadPower

@see CFileCB::iBadPower

*/

inline TBool CFileCB::BadPower() const

	{return (iBadPower);}

/**

Sets the iBadPower value.

@param aBadPower ETrue, if an operation on the file has failed due

                 to bad power;

				 EFalse if power has been found to be good.

@see CFileCB::iBadPower

*/

inline void CFileCB::SetBadPower(TBool aBadPower)

	{iBadPower=aBadPower;}

/**

Retrieves the BlockMap of a file.

@param aInfo

@param aStartPos

@param aEndPos

@return 

*/

inline TInt CFileCB::BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos)

	{

	TAny* pM;

	TInt r = GetInterface(EBlockMapInterface, pM, (TAny*) this);

	if (KErrNone!=r)

		return r;