Symaptic: os/kernelhwsrv/userlibandfileserver/fileserver/sfat32/inc/sl

     1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // f32\sfat32\inc\sl_std.inl

    15 //

    16 //

    18 #ifndef SL_STD_INL

    19 #define SL_STD_INL

    23 //---------------------------------------------------------------------------------------------------------------------------------

    24 // class TEntryPos

    25 TUint32 TEntryPos::Cluster() const

    26     {

    27     return (TUint32) iCluster;

    28     }

    30 TUint32 TEntryPos::Pos() const

    31     {

    32     return (TUint32) iPos;

    33     }

    35 TBool TEntryPos::operator==(const TEntryPos& aRhs) const

    36     {

    37     ASSERT(this != &aRhs);

    38     return (iCluster == aRhs.iCluster && iPos == aRhs.iPos);

    39     }

    42 //---------------------------------------------------------------------------------------------------------------------------------

    43 // class CFatMountCB

    45 inline TInt CFatMountCB::RootDirectorySector() const

    46     {return iVolParam.RootDirectorySector();}

    48 inline TUint CFatMountCB::RootDirEnd() const

    49     {return iVolParam.RootDirEnd();}

    51 inline TUint32 CFatMountCB::RootClusterNum() const

    52     {return iVolParam.RootClusterNum(); }

    55 inline TInt CFatMountCB::StartCluster(const TFatDirEntry & anEntry) const

    56 	{

    57 	if(Is32BitFat())

    58 		return anEntry.StartCluster();

    59 	else

    60 		return 0xFFFF&anEntry.StartCluster();

    61 	}

    63 /**

    64 returns true for root dir on Fat12/16 (fixed root dir versions of Fat) false on fat32

    65 this function is used to handle special cases for reading/writing the root directory on FAT via the use of cluster zero.

    67 @param aEntry position on volume being queried

    68 @return Whether Root dir position or not

    69 */

    70 TBool CFatMountCB::IsRootDir(const TEntryPos &aEntry) const

    71 	{

    72 	if(Is32BitFat())

    73 		return EFalse;

    74 	else

    75 		return((aEntry.iCluster==0) ? (TBool)ETrue : (TBool)EFalse);

    76 	}

    77 /**

    78 Indicates the root directory cluster, For Fat12/16 root is always indicated by cluster number zero, on Fat32 the is a root cluster number

    79 @return The root cluster indicator

    80 */

    81 TInt CFatMountCB::RootIndicator() const

    82 	{

    83 	if(Is32BitFat())

    84         return iVolParam.RootClusterNum();

    85 	else

    86 		return 0;

    87 	}

    90 /** @return Log2 of cluster size on volume */

    91 TInt CFatMountCB::ClusterSizeLog2() const

    92     {return(iVolParam.ClusterSizeLog2());}

    94 /** @return Log2 of media sector size  */

    95 TInt CFatMountCB::SectorSizeLog2() const

    96     {return(iVolParam.SectorSizeLog2());}

    98 /** @return sector per cluster */

    99 TInt CFatMountCB::SectorsPerCluster() const

   100     {return(1<<(iVolParam.ClusterSizeLog2()-iVolParam.SectorSizeLog2()));}

   102 /** @return the base position of a cluster */

   103 TInt CFatMountCB::ClusterBasePosition() const

   104 	{return(iFirstFreeByte);}

   106 /** @return the offset into a cluster of a byte address */

   107 TInt CFatMountCB::ClusterRelativePos(TInt aPos) const

   108 	{return(aPos&((1<<ClusterSizeLog2())-1));}

   110 /**

   111 Calculates the maximum number of clusters

   112 @return  maximum number of clusters

   113 */

   114 TUint32 CFatMountCB::MaxClusterNumber() const

   115     {return(TotalSectors()>>(ClusterSizeLog2()-SectorSizeLog2()));}

   117 /** @return the the total sectors on volume */

   118 TInt CFatMountCB::TotalSectors() const

   119     {return iVolParam.TotalSectors();}

   121 /** @return total size of a Fat in bytes */

   122 TInt CFatMountCB::FatSizeInBytes() const

   123     {return iVolParam.FatSizeInBytes();}

   125 /** @return first sector of the Fat */

   126 TUint32 CFatMountCB::FirstFatSector() const

   127     {return iVolParam.FirstFatSector();}

   129 /** @return the byte offset of the Fat */

   130 TInt CFatMountCB::StartOfFatInBytes() const

   131 	{return(FirstFatSector()<<SectorSizeLog2());}

   133 /** @return Number of Fats used by the volume */

   134 TInt CFatMountCB::NumberOfFats() const

   135     {return iVolParam.NumberOfFats();}

   138 /** @return refrence to the fat table owned by the mount */

   139 CFatTable& CFatMountCB::FAT() const

   140 	{return(*iFatTable);}

   141 /**

   142     @return refrence to the file system object that has produced this CFatMountCB

   143 */

   144 CFatFileSystem& CFatMountCB::FatFileSystem() const

   145 	{

   146     return (CFatFileSystem&)(*FileSystem()); //-- CMountCB::FileSystem() provides correct answer

   147     }

   150 /** @return  refrence to a raw disk object owned by the mount */

   151 CRawDisk& CFatMountCB::RawDisk() const

   152 	{return(*iRawDisk);}

   154 /**

   155 @return ETrue if aCluster value is bad cluster marker defined in FAT specification

   156 */

   157 TBool CFatMountCB::IsBadCluster(TInt aCluster) const

   158 	{return Is32BitFat() ? aCluster==0xFFFFFF7 : Is16BitFat() ? aCluster==0xFFF7 : aCluster==0xFF7;}

   160 /**

   161 Returns whether the current mount is running as rugged Fat or not, this is held in the file system object

   162 @return Is rugged fat flag

   163 */

   164 TBool CFatMountCB::IsRuggedFSys() const

   165 	{return Drive().IsRugged();}

   167 /**

   168 Sets the rugged flag in the file system object

   169 @param Flag to set or clear the rugged flag

   170 */

   171 void CFatMountCB::SetRuggedFSys(TBool aVal)

   172 	{Drive().SetRugged(aVal);}

   174 /** @return the usable clusters count for a volume */

   175 TUint32 CFatMountCB::UsableClusters() const

   176 	{return(iUsableClusters);}

   179 TUint CFatMountCB::StartOfRootDirInBytes() const

   180     {return iVolParam.RootDirectorySector()<<SectorSizeLog2();}

   183 /** @return FAT type for this mount */

   184 TFatType CFatMountCB::FatType() const

   185 {

   186     return iFatType;

   187 }

   189 /** @return ETrue if the mount has 16bit FAT */

   190 TBool CFatMountCB::Is16BitFat() const

   191 {

   192     return FatType() == EFat16;

   193 }

   195 /** @return ETrue if the mount has 32bit FAT */

   196 TBool CFatMountCB::Is32BitFat() const

   197 {

   198     return FatType() == EFat32;

   199 }

   201 CAsyncNotifier* CFatMountCB::Notifier() const

   202 	{return iNotifier;}

   206 /**

   207     Set or reset Read Only mode for the mount.

   208     @param    aReadOnlyMode if ETrue, the mount will be set RO.

   209 */

   210 void  CFatMountCB::SetReadOnly(TBool aReadOnlyMode)

   211     {

   212     iReadOnly = aReadOnlyMode;

   213     }

   216 /**

   217     @return ETrue if the volume is in Read-Only state

   218 */

   219 TBool CFatMountCB::ReadOnly(void) const

   220     {

   221     return iReadOnly;

   222     }

   224 /** @return state of the CFatMountCB*/

   225 CFatMountCB::TFatMntState CFatMountCB::State() const

   226     {

   227     return iState;

   228     }

   230 /**

   231     Set state of the CFatMountCB

   232     @param  aState state to set

   233 */

   234 void CFatMountCB::SetState(TFatMntState aState)

   235     {

   236     __PRINT3(_L("#- CFatMountCB::SetState() drv:%d, %d->%d\n"),DriveNumber(),iState,aState);

   237     iState = aState;

   238     }

   241 TDriveInterface& CFatMountCB::DriveInterface() const

   242     {

   243     return (TDriveInterface&)iDriverInterface;

   244     }

   246 const TFatConfig& CFatMountCB::FatConfig() const

   247     {

   248     return iFatConfig;

   249     }

   251 //---------------------------------------------------------------------------------------------------------------------------------

   252 /**

   253 Check if the XFileCreationHelper object is initialised.

   254 */

   255 TBool CFatMountCB::XFileCreationHelper::IsInitialised() const

   256 	{

   257 	return isInitialised;

   258 	}

   260 /**

   261 Get number of new entries for file creation.

   262 */

   263 TUint16	CFatMountCB::XFileCreationHelper::NumOfAddingEntries() const

   264 	{

   265 	ASSERT(isInitialised);

   266 	return iNumOfAddingEntries;

   267 	}

   269 /**

   270 Get position of new entries for file creation.

   271 */

   272 TEntryPos CFatMountCB::XFileCreationHelper::EntryAddingPos() const

   273 	{

   274 	ASSERT(isInitialised);

   275 	return iEntryAddingPos;

   276 	}

   278 /**

   279 Check if position of new entries has been found.

   280 */

   281 TBool CFatMountCB::XFileCreationHelper::IsNewEntryPosFound() const

   282 	{

   283 	ASSERT(isInitialised);

   284 	return isNewEntryPosFound;

   285 	}

   287 /**

   288 Check if file name of the new file is a legal dos name.

   289 */

   290 TBool CFatMountCB::XFileCreationHelper::IsTrgNameLegalDosName() const

   291 	{

   292 	ASSERT(isInitialised);

   293 	return isTrgNameLegalDosName;

   294 	}

   296 /**

   297 Set entry position for new entries to be added.

   298 */

   299 void CFatMountCB::XFileCreationHelper::SetEntryAddingPos(const TEntryPos& aEntryPos)

   300 	{

   301 	iEntryAddingPos = aEntryPos;

   302 	}

   304 /**

   305 Set condition if position of new entries has been found.

   306 */

   307 void CFatMountCB::XFileCreationHelper::SetIsNewEntryPosFound(TBool aFound)

   308 	{

   309 	isNewEntryPosFound = aFound;

   310 	}

   313 /**

   314     Checks for "EOC" for all Fat types

   315     @param  aCluster FAT table entry (cluster number) to check

   316     @return ETrue    if aCluster is a EOC for the FAT type being used by CFatMountCB

   317 */

   318 TBool CFatMountCB::IsEndOfClusterCh(TInt aCluster) const

   319 	{

   320     ASSERT(iFatEocCode);

   322     if((TUint32)aCluster >= iFatEocCode)

   323         return ETrue;

   325     ASSERT((TUint32)aCluster <= iFatEocCode+7);

   327 	return EFalse;

   328     }

   330 /**

   331     Sets "End of Cluster Chain" value in aCluster depending on the FAT type.

   332     @param aCluster cluster to set to end of chain marker

   333 */

   334 void CFatMountCB::SetEndOfClusterCh(TInt &aCluster) const

   335 	{

   336     ASSERT(iFatEocCode);

   337     aCluster = iFatEocCode+7;

   338 	}

   341 //-------  debug methods

   342 #ifdef  _DEBUG

   343 /**

   344 Debug function indicates whether write fails are active or not, for test

   345 @return ETrue if write fails on or not

   346 */

   347 TBool CFatMountCB::IsWriteFail()const

   348 	{return(iIsWriteFail);}

   349 /**

   350 Switches write fails on or off, for test

   351 @param aIsWriteFail set true or false to set write fails on or off

   352 */

   353 void CFatMountCB::SetWriteFail(TBool aIsWriteFail)

   354 	{iIsWriteFail=aIsWriteFail;}

   356 /** @return number of write fails to occur, for test */

   357 TInt CFatMountCB::WriteFailCount()const

   358 	{return(iWriteFailCount);}

   360 /**

   361 Set the number of Write fails

   362 @param aFailCount number of write fails, for test

   363 */

   364 void CFatMountCB::SetWriteFailCount(TInt aFailCount)

   365 	{iWriteFailCount=aFailCount;}

   367 /** Decrement the number of write fails, for test */

   368 void CFatMountCB::DecWriteFailCount()

   369 	{--iWriteFailCount;}

   371 /** @return Error for a write failure, for test */

   372 TInt CFatMountCB::WriteFailError()const

   373 	{return iWriteFailError;}

   375 /**

   376 Set the write fail error code, for test

   377 @param aErrorValue The Error for a write fails

   378 */

   379 void CFatMountCB::SetWriteFailError(TInt aErrorValue)

   380 	{iWriteFailError=aErrorValue;}

   382 #endif

   388 //---------------------------------------------------------------------------------------------------------------------------------

   389 // class CFatFormatCB

   391 /** @return pointer to the owning mount object */

   392 CFatMountCB& CFatFormatCB::FatMount()

   393 	{return *(CFatMountCB*)&Mount();}

   395 /**

   396 Returns the local drive used by the file systems from the owning mount

   397 @return Pointer to the local drive

   398 */

   399 CProxyDrive* CFatFormatCB::LocalDrive()

   400 	{return(FatMount().LocalDrive());}

   403 //---------------------------------------------------------------------------------------------------------------------------------

   404 // class CFatFileCB

   406 /**

   407 Returns the owning mount from file object

   409 @return pointer to the owning mount object

   410 */

   411 CFatMountCB& CFatFileCB::FatMount() const

   412 	{return((CFatMountCB&)Mount());}

   414 /**

   415 Returns the fat table used by the file system for this mount

   417 @return Refrence to the Fat table owned by the mount

   418 */

   419 CFatTable& CFatFileCB::FAT()

   420 	{return(FatMount().FAT());}

   422 /**

   423 Position with in a cluster for a given address

   425 @param aPos Byte position

   426 */

   427 TInt CFatFileCB::ClusterRelativePos(TInt aPos)

   428 	{return(FatMount().ClusterRelativePos(aPos));}

   429 /**

   430 Returns Log2 of cluster size from mount

   432 @return cluster size

   433 */

   434 TInt CFatFileCB::ClusterSizeLog2()

   435 	{return(FatMount().ClusterSizeLog2());}

   437 /*

   438  Note: this replaces SeekIndex() which was only used in sl_mnt

   439  to verify whether the seek index had been created/initialised

   440 */

   441 inline TBool CFatFileCB::IsSeekIndex() const

   442 {return (iSeekIndex==NULL?(TBool)EFalse:(TBool)ETrue); }

   445 //---------------------------------------------------------------------------------------------------------------------------------

   446 // class CFatDirCB

   448 /**

   449 Returns the owning mount from directory object

   451 @return pointer to the owning mount object

   452 */

   453 CFatMountCB& CFatDirCB::FatMount()

   454 	{return((CFatMountCB&)Mount());}

   458 //---------------------------------------------------------------------------------------------------------------------------------

   459 // class CFatTable

   461 TUint32 CFatTable::FreeClusters() const

   462     {

   463     return iFreeClusters;

   464     }

   467 //---------------------------------------------------------------------------------------------------------------------------------

   469 inline TFatType CFatTable::FatType() const

   470     {

   471     return iFatType;

   472     }

   474 inline TBool CFatTable::IsFat12() const

   475     {

   476     return iFatType == EFat12;

   477     }

   479 inline TBool CFatTable::IsFat16() const

   480     {

   481     return iFatType == EFat16;

   482     }

   484 inline TBool CFatTable::IsFat32() const

   485     {

   486     return iFatType == EFat32;

   487     }

   490 /**

   491     Checks for "EOC" for all Fat types

   492     @param  aCluster FAT table entry (cluster number) to check

   493     @return ETrue    if aCluster is a EOC for the FAT type being used by CFatMountCB that owns the CFatTable

   494 */

   495 inline TBool CFatTable::IsEndOfClusterCh(TUint32 aCluster) const

   496     {

   497     ASSERT(iFatEocCode);

   499     if(aCluster >= iFatEocCode)

   500         return ETrue;

   502     ASSERT((TUint32)aCluster <= iFatEocCode+7);

   503 	return EFalse;

   504     }

   507 /**

   508 @return Maximal number of addresable FAT entries. This value is taken from the owning mount

   509 */

   510 inline TUint32 CFatTable::MaxEntries() const

   511     {

   512         ASSERT(iMaxEntries > 0);

   513         return iMaxEntries;

   514     }

   517 // class TDriveInterface

   518 TBool TDriveInterface::NotifyUser() const

   519 	{return(iMount->GetNotifyUser());}

   522 //----------------------------------------------------------------------------------------------------

   523 // class CRawDisk

   525 /**

   526     Get pointer to the directory cache interface. Any client that reads/writes directory entries

   527     MUST do it via this interface.

   528     Default implementation returns NULL

   530     @return     pointer to the MWTCacheInterface interface, or NULL if it is not present.

   531 */

   532 MWTCacheInterface* CRawDisk::DirCacheInterface()

   533     {

   534     return NULL;

   535     }

   537 //---------------------------------------------------------------------------------------------------------------------------------

   539 /**

   540     Calculate offset of the page starting position in the cluster

   541     @param aPos  the current entry position in bytes in the cluster

   542     @param aPageSzLog2	page size in log2

   543     @return		the starting position of the page that contains aPos

   544 */

   545 inline TUint32 CalculatePageOffsetInCluster(TUint32 aPos, TUint aPageSzLog2)

   546 	{

   547 	return (aPos >> aPageSzLog2) << aPageSzLog2;

   548 	}

   550 #endif //SL_STD_INL

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--