Symaptic: os/kernelhwsrv/userlibandfileserver/fileserver/sfat/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\sfat\inc\sl_std.inl

    15 //

    16 //

    18 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    19 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    20 //!!

    21 //!! WARNING!! DO NOT edit this file !! '\sfat' component is obsolete and is not being used. '\sfat32'replaces it

    22 //!!

    23 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    24 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    26 #ifndef SL_STD_INL

    27 #define SL_STD_INL

    31 TBool IsPowerOf2(TUint32 aVal)

    32     {

    33     if (aVal==0)

    34         return EFalse;

    36     return !(aVal & (aVal-1));

    37     }

    39 TUint32 Pow2(TUint32 aVal)

    40     {

    41         //ASSERT(aVal<32);

    42         return 1 << aVal;

    43     }

    46 //---------------------------------------------------------------------------------------------------------------------------------

    47 // class TEntryPos

    48 TUint32 TEntryPos::Cluster() const

    49     {

    50     return (TUint32) iCluster;

    51     }

    53 TUint32 TEntryPos::Pos() const

    54     {

    55     return (TUint32) iPos;

    56     }

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

    59     {

    60     ASSERT(this != &aRhs);

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

    62     }

    65 //---------------------------------------------------------------------------------------------------------------------------------

    66 // class CFatMountCB

    68 inline TInt CFatMountCB::RootDirectorySector() const

    69     {return iVolParam.RootDirectorySector();}

    71 inline TUint CFatMountCB::RootDirEnd() const

    72     {return iVolParam.RootDirEnd();}

    74 inline TUint32 CFatMountCB::RootClusterNum() const

    75     {return iVolParam.RootClusterNum(); }

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

    79     {return anEntry.StartCluster();}

    83 /**

    84 returns true for root dir on Fat12/16 (fixed root dir versions of Fat).

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

    87 @param aEntry position on volume being queried

    88 @return Whether Root dir position or not

    89 */

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

    91     {return((aEntry.iCluster==0) ? (TBool)ETrue : (TBool)EFalse);}

    93 /**

    94 Indicates the root directory cluster, For Fat12/16 root is always indicated by cluster number zero

    95 @return The root cluster indicator

    96 */

    97 TInt CFatMountCB::RootIndicator() const

    98     {return 0;}

   101 TBool CFatMountCB::Is16BitFat() const

   102     {return(iFatType == EFat16);}

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

   105 TInt CFatMountCB::ClusterSizeLog2() const

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

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

   109 TInt CFatMountCB::SectorSizeLog2() const

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

   112 /** @return sector per cluster */

   113 TInt CFatMountCB::SectorsPerCluster() const

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

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

   117 TInt CFatMountCB::ClusterBasePosition() const

   118     {return(iFirstFreeByte);}

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

   121 TInt CFatMountCB::ClusterRelativePos(TInt aPos) const

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

   124 /**

   125 Calculates the maximum number of clusters

   126 @return  maximum number of clusters

   127 */

   128 TUint32 CFatMountCB::MaxClusterNumber() const

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

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

   132 TInt CFatMountCB::TotalSectors() const

   133     {return iVolParam.TotalSectors();}

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

   136 TInt CFatMountCB::FatSizeInBytes() const

   137     {return iVolParam.FatSizeInBytes();}

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

   140 TUint32 CFatMountCB::FirstFatSector() const

   141     {return iVolParam.FirstFatSector();}

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

   144 TInt CFatMountCB::StartOfFatInBytes() const

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

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

   148 TInt CFatMountCB::NumberOfFats() const

   149     {return iVolParam.NumberOfFats();}

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

   153 CFatTable& CFatMountCB::FAT() const

   154     {return(*iFatTable);}

   155 /**

   156 Returns a refrence to the file system object owned by the coresponding TDrive for a drive used for creating subsession objects

   157 @return refrence to file system object

   158 */

   159 CFatFileSystem& CFatMountCB::FatFileSystem() const

   160     {return((CFatFileSystem&)Drive().FSys());}

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

   164 CRawDisk& CFatMountCB::RawDisk() const

   165     {return(*iRawDisk);}

   167 /**

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

   169 */

   170 TBool CFatMountCB::IsBadCluster(TInt aCluster) const

   171     {return Is16BitFat() ? aCluster==0xFFF7 : aCluster==0xFF7;}

   173 /**

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

   175 @return Is rugged fat flag

   176 */

   177 TBool CFatMountCB::IsRuggedFSys() const

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

   180 /**

   181 Sets the rugged flag in the file system object

   182 @param Flag to set or clear the rugged flag

   183 */

   184 void CFatMountCB::SetRuggedFSys(TBool aVal)

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

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

   188 TUint32 CFatMountCB::UsableClusters() const

   189     {return(iUsableClusters);}

   192 TUint CFatMountCB::StartOfRootDirInBytes() const

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

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

   197 TFatType CFatMountCB::FatType() const

   198 {

   199     return iFatType;

   200 }

   202 CAsyncNotifier* CFatMountCB::Notifier() const

   203     {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 TFatDriveInterface& CFatMountCB::DriveInterface() const

   242     {

   243     return (TFatDriveInterface&)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     }

   314 //-------  debug methods

   315 #ifdef  _DEBUG

   316 /**

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

   318 @return ETrue if write fails on or not

   319 */

   320 TBool CFatMountCB::IsWriteFail()const

   321     {return(iIsWriteFail);}

   322 /**

   323 Switches write fails on or off, for test

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

   325 */

   326 void CFatMountCB::SetWriteFail(TBool aIsWriteFail)

   327     {iIsWriteFail=aIsWriteFail;}

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

   330 TInt CFatMountCB::WriteFailCount()const

   331     {return(iWriteFailCount);}

   333 /**

   334 Set the number of Write fails

   335 @param aFailCount number of write fails, for test

   336 */

   337 void CFatMountCB::SetWriteFailCount(TInt aFailCount)

   338     {iWriteFailCount=aFailCount;}

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

   341 void CFatMountCB::DecWriteFailCount()

   342     {--iWriteFailCount;}

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

   345 TInt CFatMountCB::WriteFailError()const

   346     {return iWriteFailError;}

   348 /**

   349 Set the write fail error code, for test

   350 @param aErrorValue The Error for a write fails

   351 */

   352 void CFatMountCB::SetWriteFailError(TInt aErrorValue)

   353     {iWriteFailError=aErrorValue;}

   355 #endif

   358 //---------------------------------------------------------------------------------------------------------------------------------

   359 // class CFatFormatCB

   361 TBool CFatFormatCB::Is16BitFat() const

   362     {return(iFileSystemName==KFileSystemName16);}

   364 CFatMountCB& CFatFormatCB::FatMount()

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

   367 /**

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

   369 @return Pointer to the local drive

   370 */

   371 CProxyDrive* CFatFormatCB::LocalDrive()

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

   375 //---------------------------------------------------------------------------------------------------------------------------------

   376 // class CFatFileCB

   378 /**

   379 Returns the owning mount from file object

   381 @return pointer to the owning mount object

   382 */

   383 CFatMountCB& CFatFileCB::FatMount() const

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

   386 /**

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

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

   390 */

   391 CFatTable& CFatFileCB::FAT()

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

   394 /**

   395 Position with in a cluster for a given address

   397 @param aPos Byte position

   398 */

   399 TInt CFatFileCB::ClusterRelativePos(TInt aPos)

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

   401 /**

   402 Returns Log2 of cluster size from mount

   404 @return cluster size

   405 */

   406 TInt CFatFileCB::ClusterSizeLog2()

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

   409 /*

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

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

   412 */

   413 inline TBool CFatFileCB::IsSeekIndex() const

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

   417 //---------------------------------------------------------------------------------------------------------------------------------

   418 // class CFatDirCB

   420 /**

   421 Returns the owning mount from directory object

   423 @return pointer to the owning mount object

   424 */

   425 CFatMountCB& CFatDirCB::FatMount()

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

   430 //---------------------------------------------------------------------------------------------------------------------------------

   431 // class CFatTable

   433 TUint32 CFatTable::FreeClusters() const

   434     {

   435     return iFreeClusters;

   436     }

   439 TBool CFatTable::IsEof16Bit(TInt aCluster) const

   440     {return(aCluster>=0xFFF8 && aCluster<=0xFFFF);}

   442 TBool CFatTable::IsEof12Bit(TInt aCluster) const

   443     {return(aCluster>=0xFF8 && aCluster<=0xFFF);}

   445 TInt CFatTable::SectorSizeLog2() const

   446     {return(iOwner->SectorSizeLog2());}

   448 //---------------------------------------------------------------------------------------------------------------------------------

   450 inline TBool CFatTable::IsFat12() const

   451     {

   452     return iFatType == EFat12;

   453     }

   455 inline TBool CFatTable::IsFat16() const

   456     {

   457     return iFatType == EFat16;

   458     }

   460 inline TFatType CFatTable::FatType() const

   461     {

   462     return iFatType;

   463     }

   464 /**

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

   466 */

   467 inline TUint32 CFatTable::MaxEntries() const

   468     {

   469         ASSERT(iMaxEntries > 0);

   470         return iMaxEntries;

   471     }

   474 // class TFatDriveInterface

   475 TBool TFatDriveInterface::NotifyUser() const

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

   480 //----------------------------------------------------------------------------------------------------

   481 // class CRawDisk

   483 /**

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

   485     MUST do it via this interface.

   486     Default implementation returns NULL

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

   489 */

   490 MWTCacheInterface* CRawDisk::DirCacheInterface()

   491     {

   492     return NULL;

   493     }

   495 //---------------------------------------------------------------------------------------------------------------------------------

   496 //-- class RBitVector

   498 /** @return size of the vector (number of bits) */

   499 inline TUint32 RBitVector::Size() const

   500     {

   501     return iNumBits;

   502     }

   504 /**

   505     Get a bit by index

   507     @param aIndex  index in a bit vector

   508     @return 0 if the bit at pos aIndex is 0, not zero otherwise

   509     @panic EIndexOutOfRange if aIndex is out of range

   510 */

   511 inline TBool RBitVector::operator[](TUint32 aIndex) const

   512     {

   513     __ASSERT_ALWAYS(aIndex < iNumBits, Panic(EIndexOutOfRange));

   514     return (ipData[WordNum(aIndex)] & (1<<BitInWord(aIndex)));

   515     }

   517 /**

   518     Set a bit at pos aIndex to '1'

   519     @param aIndex  index in a bit vector

   520     @panic EIndexOutOfRange if aIndex is out of range

   521 */

   522 inline void RBitVector::SetBit(TUint32 aIndex)

   523     {

   524     __ASSERT_ALWAYS(aIndex < iNumBits, Panic(EIndexOutOfRange));

   525     ipData[WordNum(aIndex)] |= (1<<BitInWord(aIndex));

   526     }

   528 /**

   529     Set a bit at pos aIndex to '0'

   530     @param aIndex  index in a bit vector

   531     @panic EIndexOutOfRange if aIndex is out of range

   532 */

   533 inline void RBitVector::ResetBit(TUint32 aIndex)

   534     {

   535     __ASSERT_ALWAYS(aIndex < iNumBits, Panic(EIndexOutOfRange));

   536     ipData[WordNum(aIndex)] &= ~(1<<BitInWord(aIndex));

   537     }

   539 /**

   540     Invert a bit at pos aIndex

   541     @param aIndex  index in a bit vector

   542     @panic EIndexOutOfRange if aIndex is out of range

   543 */

   544 inline void RBitVector::InvertBit(TUint32 aIndex)

   545     {

   546     __ASSERT_ALWAYS(aIndex < iNumBits, Panic(EIndexOutOfRange));

   547     ipData[WordNum(aIndex)] ^= (1<<BitInWord(aIndex));

   548     }

   550 /**

   551     Set bit value at position aIndex

   552     @param aIndex  index in a bit vector

   553     @panic EIndexOutOfRange if aIndex is out of range

   554 */

   555 inline void RBitVector::SetBitVal(TUint32 aIndex, TBool aVal)

   556     {

   557     if(aVal)

   558         SetBit(aIndex);

   559     else

   560         ResetBit(aIndex);

   561     }

   564 inline TUint32 RBitVector::MaskLastWord(TUint32 aVal) const

   565     {

   566     const TUint32 shift = (32-(iNumBits & 0x1F)) & 0x1F;

   567     return (aVal << shift) >> shift; //-- mask unused high bits

   568     }

   572 inline TUint32 RBitVector::WordNum(TUint32 aBitPos)  const

   573     {

   574     return aBitPos >> 5;

   575     }

   577 inline TUint32 RBitVector::BitInWord(TUint32 aBitPos) const

   578     {

   579     return aBitPos & 0x1F;

   580     }

   582 /**

   583     Calculate offset of the page starting position in the cluster

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

   585     @param aPageSzLog2  page size in log2

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

   587 */

   588 inline TUint32 CalculatePageOffsetInCluster(TUint32 aPos, TUint aPageSzLog2)

   589     {

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

   591     }

   593 #endif //SL_STD_INL

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