FCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfat32/sl

equal deleted inserted replaced

-:56f325a607ea
+:0173bcd7697c
 CFatMountCB::CFatMountCB()
 {
 __PRINT2(_L("CFatMountCB::CFatMountCB() 0x%x, %S"), this, &KThisFsyName);
-iFatType = EInvalid;
+SetFatType(EInvalid);
 iState   = ENotMounted;
 DBG_STATEMENT(iCBRecFlag = 0); //-- debug flag only
 }
 CFatMountCB::~CFatMountCB()
 {
 //-------------------------------------------------------------------------------------------------------------------
 /**
 Try remount this Fat volume. Checks if the volume parameters remained the same as on original MountL() call, and
 if they are, re-initialises the mount. This includes resetting all caches.
-! Do not call this method from TFatDriveInterface methods, like citical and non-critical notifiers ! This can lead to the
+! Do not call this method from TDriveInterface methods, like citical and non-critical notifiers ! This can lead to the
 recursive loops and undefined behaviour.
 @return KErrNone if the remount was OK
 system-wide error code otherwise
 */
 //-------------------------------------------------------------------------------------------------------------------
 /**
 Open CFatMountCB for write. I.e. perform some actions on the first write attempt.
-This is a callback from TFatDriveInterface.
+This is a callback from TDriveInterface.
 @return System wide error code.
 */
 TInt CFatMountCB::OpenMountForWrite()
 {
 if(State() == EInit_W)
 __PRINT1(_L("#- CFatMountCB::OpenMountForWrite() drv:%d\n"),DriveNumber());
 ASSERT(State() == EInit_R || State() == EFinalised);
 //-- Check possible recursion. This method must not be called recursively. SetVolumeCleanL() works through direct disc access and
-//-- can not call TFatDriveInterface methods that call this method etc.
+//-- can not call TDriveInterface methods that call this method etc.
 ASSERT(iCBRecFlag == 0);
 DBG_STATEMENT(iCBRecFlag = 1); //-- set recursion check flag
 //-- do here some "opening" work, like marking volme as dirty
-//-- be careful here, as soon as this is a callback from TFatDriveInterface, writing via TFatDriveInterface may cause some unwanted recursion.
+//-- be careful here, as soon as this is a callback from TDriveInterface, writing via TDriveInterface may cause some unwanted recursion.
 //-- mark the volume as dirty
 TInt nRes=KErrNone;
 TRAP(nRes, SetVolumeCleanL(EFalse));
 if(nRes == KErrNone)
 const TInt64  mruPos = MakeLinAddrL(aDosEntryPos);
 pDirCache->MakePageMRU(mruPos);
-	// only update the leaf dir cache when the original cache index is provided
+	//-- if the corresponding leaf directory name is cached, associate the last search positionin this directory.
+//-- the next search in this dir. will start from this position (and will wrap around over the dir. beginning).
+//-- the "last search position" will is the position of current VFAT entryset start.
 	if (aLeafDir.iClusterNum)
 		{
 iLeafDirCache->UpdateMRUPos(TLeafDirData(aLeafDir.iClusterNum, aStartEntryPos));
 		}
 }
 return;
 TInt count = 1;
 iTargetName.Set(aTargetName);
 isLegalDosName = IsLegalDosName(aTargetName, ETrue, EFalse, EFalse, ETrue, EFalse);
 if(isLegalDosName)
 {//-- iShortName will contain generated short DOS name by long filename
 iShortName = DoGenerateShortNameL(aTargetName, count, ETrue);
 }
 //---------------------------------------------------
 //-- if we have fully specified name and directory cache is present, try to
 //-- locate the name in the cache first to avoid reading from media
 //-- if the entry belongs to the root directory (for FAT12,16) skip the lookup, because root directory isn't aligned by cluster size boundary,
 //-- while directory cache pages are. For FAT32 it doesn't matter, because root dir is a usual file.
+//-- the "rummage dir. cache" can be swithed off. This is not affecting the functionality, only the performance.
+#if 1
 if(iRawDisk->DirCacheInterface() && trgNameFullySpecified && !IsRootDir(aDosEntryPos) && !aFileCreationHelper)
 {//-- aName is fully specified, i.e doesn't contain wildcards
 findHelper.InitialiseL(trgtNameNoDot);
 if(bMatchFound)
 {
 return(aStartEntry.IsVFatEntry());
 }
 }
+#endif
 //---------------------------------------------------
 // we need to scan ahead from the mru pos then come back to beginning, if startcluster is provided
 TBool scanAhead = EFalse;
 // if we have a starting cluster number (and it's not root directory in FAT16/12 case)&&
 	                     if(findHelper.MatchDosEntryName(aDosEntry.Name().Ptr()))
 	                    	 {
 							 found = ETrue;
 	                    	 break; //-- DOS entries match, success.
 	                    	 }
 	                	 }
 	                 else if (!trgNameFullySpecified)
 	                	 {//-- target name contains wildcards, we need to use MatchF with dos name
-	                     TBuf8<0x20> dosName8(DosNameFromStdFormat(aDosEntry.Name()));
+TBuf8<0x20> dosName8(DosNameFromStdFormat(aDosEntry.Name()));
 	                     TBuf<0x20>  dosName;
 	                     LocaleUtils::ConvertToUnicodeL(dosName, dosName8); //-- convert DOS name to unicode (implies locale settings)
 	                     if (dosName.MatchF(trgtNameNoDot)!=KErrNotFound)
 	                    	 {
 							 found = ETrue;
 							 break;
 	                    	 }
-	                	 }
+}
 	                }
 	            else //if (aStartEntry.IsVFatEntry())
 	                {//-- we've read a legacy FAT entry, so compare DOS entries
 if (iRawDisk->DirCacheInterface() && aDosEntryPos.Cluster())
 	{
 	TInt64 mruPos = MakeLinAddrL(aDosEntryPos);
 iRawDisk->DirCacheInterface()->MakePageMRU(mruPos);
-	// only update the leaf dir cache when the original cache index is provided
+	//-- if the corresponding leaf directory name is cached, associate the last search positionin this directory.
-	if (aLeafDirData.iClusterNum)
+//-- the next search in this dir. will start from this position (and will wrap around over the dir. beginning).
+//-- the "last search position" will is the position of current VFAT entryset start.
+	if(aLeafDirData.iClusterNum)
 		{
-iLeafDirCache->UpdateMRUPos(TLeafDirData(aLeafDirData.iClusterNum, aDosEntryPos));
+iLeafDirCache->UpdateMRUPos(TLeafDirData(aLeafDirData.iClusterNum, aStartEntryPos));
 }
 	}
 return (aStartEntry.IsVFatEntry());
 }
 // cluster count may be zero if boot sector failed to be read (e.g. if the media is locked)
 // or if TDrive::MountMedia(ETrue) has been called (in which case the boot sector may
 if (MaxClusters == 0)
 return KErrCorrupt;
+//-- used for measuring time
+TTime   timeStart;
+TTime   timeEnd;
+timeStart.UniversalTime(); //-- take start time
 RBitVector bitVec; //-- each bit in this vector represents a FAT cluster
 TInt nRes = bitVec.Create(MaxClusters);
 if(nRes != KErrNone)
 {
 TRAP(r,CheckUnvisitedClustersL(bitVec));
 }
 bitVec.Close();
+timeEnd.UniversalTime(); //-- take end time
+const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
+(void)msScanTime;
+__PRINT1(_L("#@@@ CheckDisk() time taken:%d ms"), msScanTime);
 switch(r)
 {
 case KErrNone:
 DismountedLocalDrive();
 return nRes;
 }
+//-----------------------------------------------------------------------------------------
+/**
+Internal helper method.
+@param      aFatType FAT type
+@return     End Of Cluster Chain code that depend on FAT type, 0xff8 for FAT12, 0xfff8 for FAT16, and 0xffffff8 for FAT32
+*/
+TUint32 EocCodeByFatType(TFatType aFatType)
+{
+switch(aFatType)
+{
+case EFat32:
+return EOF_32Bit-7; //-- 0xffffff8
+case EFat16:
+return  EOF_16Bit-7; //-- 0xfff8
+case EFat12:
+return  EOF_12Bit-7; //-- 0xff8
+default:
+ASSERT(aFatType == EInvalid);
+return 0;
+}
+}
+//-----------------------------------------------------------------------------------------
+/**
+Set FAT type that this object of CFatMountCB will be dealing with.
+*/
+void CFatMountCB::SetFatType(TFatType aFatType)
+{
+ASSERT(State() == ENotMounted || State() == EDismounted || State() == EMounting) ;
+iFatType = aFatType;
+iFatEocCode = EocCodeByFatType(aFatType);
+}

changeset 33	0173bcd7697c
parent 15	4122176ea935
child 36	538db54a451d