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

equal deleted inserted replaced

-:36bfc973b146
+:329ab0095843
 /**
 @file
 @internalTechnology
 */
-//#define DEBUG_SCANDRIVE
 #include "sl_std.h"
 #include "sl_scandrv.h"
+const TInt KMaxScanDepth			= 20;   ///< Maximum scan depth of to avoid stack over flow
+const TInt KClusterListGranularity	= 8;    ///< Granularity of cluster list used for storage of clusters when KMaxScanDepth is reached
-const TInt KEndOfDirectory			= 0xFFFF;   ///< End of directory marker
-const TInt KMaxScanDepth			= 20;       ///< Maximum scan depth of to avoid stack over flow
-const TInt KClusterListGranularity	= 8;        ///< Granularity of cluster list used for storage of clusters when KMaxScanDepth is reached
+/**
+CScanDrive factory method
-/**
+@param  aMount the owning mount
-Creates a CScanDrive
+*/
-@param aMount The owning mount
+CScanDrive* CScanDrive::NewL(CFatMountCB* aMount)
-*/
+	{
-CScanDrive* CScanDrive::NewL(CFatMountCB* aMount)
+	if(!aMount)
-	{
+		{
-	if(aMount==NULL)
+ASSERT(0);
-		User::Leave(KErrArgument);
+User::Leave(KErrArgument);
+}
 	CScanDrive* self=new (ELeave) CScanDrive();
 	CleanupStack::PushL(self);
 	self->ConstructL(aMount);
 	CleanupStack::Pop();
-	return self;
+return self;
 	}
 CScanDrive::~CScanDrive()
 	{
-	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
+	for(TUint i=0; i<KMaxArrayDepth && iClusterListArray[i]!=NULL; ++i)
 		{
 		iClusterListArray[i]->Close();
 		delete iClusterListArray[i];
 		}
 iScanFatBits.Close();
 	}
 /**
-Allocates the Cluster array, the bit packed Fats and if run in a seperate
+Creates the structure of this class.
-thread the extra CFatTable and cluster buffer
+@param aMount The owning mount
-@param aMount The owning mount
 */
 void CScanDrive::ConstructL(CFatMountCB* aMount)
 {
-	iMount=aMount;
+ASSERT(aMount);
+//--- setting up
+iMount=aMount;
+iGenericError = ENoErrors;
+iDirError     = ENoDirError;
+iMaxClusters  = iMount->UsableClusters()+KFatFirstSearchCluster; //-- UsableClusters() doesn't count first 2 unused clusers
+//------------------------------
-//-- create bit vectors that will represent FAT on media and reconstructed by ScanDrive
+//-- create bit vectors that will represent FAT on media and reconstructed by ScanDrive. Each bit in the vector represents 1 FAT cluster.
-//-- each bit in the vector represents 1 FAT cluster.
+const TUint32 KClustersNum = MaxClusters();
-const TUint32 KClustersNum = iMount->UsableClusters()+KFatFirstSearchCluster; //-- UsableClusters() doesn't count first 2 unused clusers
 CleanupClosePushL(iMediaFatBits);
 CleanupClosePushL(iScanFatBits);
 iMediaFatBits.CreateL(KClustersNum);
-iScanFatBits.CreateL(KClustersNum);;
+iScanFatBits.CreateL(KClustersNum);
 CleanupStack::Pop(&iScanFatBits);
 CleanupStack::Pop(&iMediaFatBits);
 }
 //----------------------------------------------------------------------------------------------------
 /**
-FAT type-agnnostic parser. Reads whole FAT and sets up a bit vector.
+FAT type-agnostic parser. Reads whole FAT and sets up a bit vector.
 for FAT12/16 it's OK, because the FAT12/16 is fully cached.
 */
 void CScanDrive::DoParseFatL()
 {
-const TInt MaxClusters = iMount->UsableClusters()+KFatFirstSearchCluster;
+const TInt KMaxClusters = MaxClusters();
 iMediaFatBits.Fill(0);
-for(TInt i=KFatFirstSearchCluster; i<MaxClusters; ++i)
+__PRINT1(_L("CScanDrive::DoParseFatL(), clusters:%d"), KMaxClusters);
+for(TInt i=KFatFirstSearchCluster; i<KMaxClusters; ++i)
 	    {
 const TUint32 nFatEntry = ReadFatL(i);
 //-- each '1' bit represents a used cluster
 if(nFatEntry != KSpareCluster)
 1. Larger buffer gives better read performance
 2. using dedicated buffer doesn't trash FAT32 LRU cache.
 */
 void CScanDrive::DoParseFat32L()
 {
+const TInt    KNumClusters = MaxClusters();
+__PRINT1(_L("CScanDrive::DoParseFat32L(), clusters:%d"), KNumClusters);
 ASSERT(iMount->FatType() == EFat32);
-const TUint32 KNumClusters  = iMount->UsableClusters()+KFatFirstSearchCluster;
 const TUint32 KFat1StartPos = iMount->StartOfFatInBytes();
 const TUint32 KFatSize      = KNumClusters * sizeof(TFat32Entry); //-- usable size of one FAT.
 const TUint32 KFatBufSz = 32*K1KiloByte; //-- buffer size for FAT reading. 32K seems to be optimal size
 buf.Close();
 CleanupStack::PopAndDestroy(&buf);
 }
 //----------------------------------------------------------------------------------------------------
 /**
 Sets up a bit list representation of the media fat
 Reads whole FAT and sets '1' bits in the bit vector corresponding to the occupied clusters.
 */
 void CScanDrive::ReadMediaFatL()
 {
 ASSERT(iMount->ConsistentState());
+TInt nRes;
 if(iMount->FatType() == EFat32)
 {//-- for FAT32 try to use specialised method of parsing
-TInt nRes;
 TRAP(nRes, DoParseFat32L())
 if(nRes == KErrNone)
 return;
 }
 //-- use old FAT-agnostic parsing
 DoParseFatL();
 }
-/**
-Set a cluster as visited in the bit packed scan Fat
+/**
+@return True if a directory error has been found
-@param aCluster Cluster number
-*/
-void CScanDrive::SetUsedL(TUint aCluster)
-	{
-	__ASSERT_ALWAYS(aCluster >= KFatFirstSearchCluster && aCluster < (KFatFirstSearchCluster+iMount->UsableClusters()),User::Leave(KErrCorrupt));
-iScanFatBits.SetBit(aCluster);
-	}
-/**
-Query whether a cluster is already set as used
-@param aCluster Cluster to query
-*/
-TBool CScanDrive::AlreadyUsedL(TUint aCluster) const
-	{
-	__ASSERT_ALWAYS(aCluster >= KFatFirstSearchCluster && aCluster < (KFatFirstSearchCluster+iMount->UsableClusters()),User::Leave(KErrCorrupt));
-return iScanFatBits[aCluster];
-	}
-/**
-@param aPos Position in a directory cluster
-@return  ETrue if aPos is the last entry in the root directory
-*/
-TBool CScanDrive::IsEndOfRootDir(const TEntryPos& aPos)const
-	{
-	return(iMount->IsRootDir(aPos)&&(iMount->StartOfRootDirInBytes()+aPos.iPos==(iMount->RootDirEnd()-KSizeOfFatDirEntry)));
-	}
-/**
-@param aVal Value of the cluster to be tested
-@return ETrue if aVal is the end of cluster marker
-*/
-TBool CScanDrive::IsEofF(TInt aVal) const
-	{
-return iMount->IsEndOfClusterCh(aVal);
-	}
-/**
-@return True if a directory error has been found
 */
 TBool CScanDrive::IsDirError() const
 	{
 	return(iDirError!=0);
 	}
 /**
-After StartL() and finishing allows us to know if there were any problems at all.
+After StartL() and finishing allows us to know if there were any problems discovered at all.
 The client may wish to remount the filesystem if there were errors.
-@return EFalse if there were no problems in FS.
+@return The code describing the problem.
 */
-TBool CScanDrive::ProblemsDiscovered() const
+CScanDrive::TGenericError CScanDrive::ProblemsDiscovered() const
 {
-return IsDirError() || iFoundProblems;
+if(IsDirError())
+return EScanDriveDirError;
+else
+return iGenericError;
 }
 /**
 Sets the flag indicating than there are errors in filesystem structure
 See ProblemsDiscovered()
-*/
-void CScanDrive::IndicateErrorsFound()
+@param  aError a code describing the error
+*/
+void CScanDrive::IndicateErrorsFound(TGenericError aError)
 {
-iFoundProblems = ETrue;
+ASSERT(aError != ENoErrors);
+iGenericError = aError;
 }
+//----------------------------------------------------------------------------------------------------
 /**
-Start point for scan drive also fixes up errors
+Start the scanner. The this calss description about what it actually does.
+@param  aMode specifies the operational mode.
-@return The result of the scan
+*/
-@leave
+void CScanDrive::StartL(TScanDriveMode aMode)
-*/
+	{
-TInt CScanDrive::StartL()
+	__PRINT2(_L("CScanDrive::StartL(%d), drive:%d"), aMode, iMount->DriveNumber());
-	{
+iScanDriveMode = aMode;
-	__PRINT1(_L("CScanDrive::StartL(), drive:%d"), iMount->DriveNumber());
 //-- used for measuring time
 TTime   timeStart;
 TTime   timeEnd;
 timeStart.UniversalTime(); //-- take start time
 	ReadMediaFatL();
+//timeEnd.UniversalTime(); //-- take end time
+//elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
+//__PRINT1(_L("#@@@ CScanDrive #1:%d ms "), elapsedTime);
 	CheckDirStructureL();
-#if defined(DEBUG_SCANDRIVE)
-	CompareFatsL();
+//-- uncomments a line below if you need to compare real and restored FAT tables and print out all differences
-#endif
+//CompareFatsL(EFalse);
-	if(IsDirError())
-		FixupDirErrorL();
+//timeEnd.UniversalTime(); //-- take end time
+//elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
-	WriteNewFatsL();
+//__PRINT1(_L("#@@@ CScanDrive #2:%d ms "), elapsedTime);
-#if defined(DEBUG_SCANDRIVE)
+if(CheckDiskMode())
+{//-- in check disk mode it is nesessarily just to detech FS errors
+CompareFatsL(ETrue); //-- will stop on the first error found
+}
+else
+{//-- In ScanDrive mode we need to find and fix Rugged FAT artefacts.
+if(IsDirError())
+		    FixupDirErrorL();
+	    CompareAndFixFatsL();
+}
 	PrintErrors();
-#endif
 timeEnd.UniversalTime(); //-- take end time
-const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
+const TInt elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
-(void)msScanTime;
+(void)elapsedTime;
 __PRINT1(_L("CScanDrive: Directories visisted = %d\n"),iDirsChecked);
-__PRINT1(_L("#@@@ CScanDrive time taken:%d ms "), msScanTime);
+__PRINT1(_L("#@@@ CScanDrive time taken:%d ms "), elapsedTime);
-	return KErrNone;
-	}
+	return;
-/**
+	}
-Fix errors detected by the drive scan
+//----------------------------------------------------------------------------------------------------
+/**
+Fix errors detected by the drive scan
 @leave System wide error code
 */
 void CScanDrive::FixupDirErrorL()
 	{
-	if(!IsDirError())
+	ASSERT(!CheckDiskMode());
+if(!IsDirError())
 		return;
 if(iDirError==EScanMatchingEntry)
 		{
 		FindSameStartClusterL();
 	else
 		{
 FixPartEntryL();
 }
-IndicateErrorsFound(); //-- indicate that we have found errors
+IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Find positions of entries with same start cluster for error correction, searches
+/**
-the whole volume. Starts at the root directory.
+Find positions of entries with same start cluster for error correction, searches
+the whole volume. Starts at the root directory.
-@leave System wide error code
+@leave System wide error code
 */
 void CScanDrive::FindSameStartClusterL()
 	{
 	TInt err=FindStartClusterL(iMount->RootIndicator());
 	if(err==KErrNone)
 		return;
-	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
+for(TUint i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
 		{
 		RArray<TInt>* clusterList=iClusterListArray[i];
 		for(TInt j=0;j<clusterList->Count();++j)
 			{
 			iRecursiveDepth=0;
 			err=FindStartClusterL((*clusterList)[j]);
 			if(err==KErrNone)
 				return;
 			}
 		}
 	__ASSERT_ALWAYS(err==KErrNone,User::Leave(KErrNotFound));
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Scan through directory structure looking for start cluster found in iMatching
+/**
+Scan through directory structure looking for start cluster found in iMatching
-@param aDirCluster Start cluster for scan to start
-@return System wide error value
+@param aDirCluster Start cluster for scan to start
-@leave
+@return System wide error value
+@leave
 */
 TInt CScanDrive::FindStartClusterL(TInt aDirCluster)
 	{
 	__PRINT1(_L("CScanDrive::FindStartCluster dirCluster=%d"),aDirCluster);
 	__ASSERT_ALWAYS(aDirCluster>=iMount->RootIndicator(),User::Leave(KErrCorrupt));
 			break;
 		TBool isComplete;
 		TEntryPos vfatPos=entryPos;
 		isComplete=MoveToVFatEndL(entryPos,entry,dirEntries);
 		__ASSERT_ALWAYS(isComplete,User::Leave(KErrBadName));
 		TInt err=CheckEntryClusterL(entry,vfatPos);
 		if(err==KErrNone)
 			{
 			--iRecursiveDepth;
 			return(err);
 			}
 		if(IsEndOfRootDir(entryPos))
 			break;
 		MoveToNextEntryL(entryPos);
 		}
 	--iRecursiveDepth;
 	return(KErrNotFound);
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Procces aEntry to find matching start cluster
+/**
+Procces aEntry to find matching start cluster
-@param aEntry Directory entry to check
-@param aEntryPos Position of directory to check
+@param aEntry Directory entry to check
-@return System wide error value
+@param aEntryPos Position of directory to check
-@leave
+@return System wide error value
+@leave
 */
 TInt CScanDrive::CheckEntryClusterL(const TFatDirEntry& aEntry, const TEntryPos& aEntryPos)
 	{
 	__PRINT(_L("CScanDrive::CheckEntryClusterL"));
-	if(iMount->StartCluster(aEntry)==iMatching.iStartCluster)
+	if((TUint)iMount->StartCluster(aEntry)==iMatching.iStartCluster)
 		{
 		TBool complete=AddMatchingEntryL(aEntryPos);
 		if(complete)
 			return(KErrNone);
 		}
 	else if(aEntry.Attributes()&KEntryAttDir)
 		return(FindStartClusterL(iMount->StartCluster(aEntry)));
 	return(KErrNotFound);
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Checks directory strucutre for errors, can be considered the start point of the scan.
+/**
-Handles recursion depth to avoid stack overflow.
+Checks directory structure for errors, can be considered the start point of the scan.
+Handles recursion depth to avoid stack overflow.
-@leave System wide error code
+@leave System wide error code
 */
 void CScanDrive::CheckDirStructureL()
 	{
 	CheckDirL(iMount->RootIndicator());
 	// Due to recursive nature of CheckDirL when a depth of
 	// KMaxScanDepth is reached clusters are stored in a list
 	// and passed into CheckDirL afresh
-	for(TInt i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
+	for(TUint i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
 		{
 		RArray<TInt>* clusterList=iClusterListArray[i];
 		++iListArrayIndex;
 		for(TInt j=0;j<clusterList->Count();++j)
 			{
 			}
 		}
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Function is called recursively with Process entry untill the whole volume has been scanned.
+/**
-Each directory entry is scanned for errors, these are recorded for later fixing.
+This function is called recursively with Process entry untill the whole volume has been scanned.
+Each directory entry is scanned for errors, these are recorded for later fixing.
-@param aCluster Directory cluster to start checking
-@leave System wide error codes
+@param aCluster Directory cluster to start checking
-*/
+@leave System wide error codes
-void CScanDrive::CheckDirL(TInt aCluster)
+*/
+void CScanDrive::CheckDirL(TUint32 aCluster)
 	{
 	__PRINT1(_L("CScanDrive::CheckDirL aCluster=%d"),aCluster);
-	__ASSERT_ALWAYS(aCluster>=0,User::Leave(KErrCorrupt));
 	// check depth of recursion
 	if(++iRecursiveDepth==KMaxScanDepth)
 		{
 		AddToClusterListL(aCluster);
 		--iRecursiveDepth;
 		return;
 		}
-#if defined(DEBUG_SCANDRIVE)
 	++iDirsChecked;
-#endif
 	TEntryPos entryPos(aCluster,0);
 	TInt dirEntries=0;
 	FOREVER
 		{
 		TFatDirEntry entry;
 		ReadDirEntryL(entryPos,entry);
 		if(!iMount->IsEndOfClusterCh(entryPos.iCluster))
 			++dirEntries;
-		if(entry.IsParentDirectory()||entry.IsCurrentDirectory()||entry.IsErased())
+		if(entry.IsParentDirectory() || entry.IsCurrentDirectory() || entry.IsErased())
 			{
 			if(IsEndOfRootDir(entryPos))
 				break;
 			MoveToNextEntryL(entryPos);
 			continue;
 			}
 		if(entry.IsEndOfDirectory())
 			{
 			if(aCluster)
-				WriteClusterChainL(aCluster,dirEntries<<KSizeOfFatDirEntryLog2);
+				RecordClusterChainL(aCluster,dirEntries<<KSizeOfFatDirEntryLog2);
 			break;
 			}
 		TEntryPos origPos=entryPos;
 		TFatDirEntry origEntry=entry;
 		TInt origDirEntries=dirEntries;
-		TBool isComplete;
-		isComplete=MoveToVFatEndL(entryPos,entry,dirEntries);
+		const TBool isComplete = MoveToVFatEndL(entryPos,entry,dirEntries);
-		// Only assume that this is a corrupted VFAT entry if the VFAT attributes are set;
+if(!isComplete && CheckDiskMode())
+{//-- broken VFAT entryset; in CheckDisk mode this is the FS error, abort further activity
+IndicateErrorsFound(EInvalidEntrySize);
+User::Leave(KErrCorrupt);
+}
+// Only assume that this is a corrupted VFAT entry if the VFAT attributes are set;
 		// assuming a non-VFAT corrupted entry is a VFAT entry is dangerous as we then assume that the
 		// first byte is a count of entries to skip, thus completely invalidating the next <n> directories.
-		if (!isComplete && origEntry.IsVFatEntry())
+//-- this code seems to deal with one of the Rugged FAT artefacts: partially deleted VFAT entryset, when DOS entry is deleted first
+//-- and delettion of VFAT ones had failed
+if(!isComplete && origEntry.IsVFatEntry())
 			{
 			AddPartialVFatL(origPos,origEntry);
-			if(entryPos.iCluster!=KEndOfDirectory)
+			if(!IsEofF(entryPos.iCluster))
 				{
 				TInt toMove=origEntry.NumFollowing()-(dirEntries-origDirEntries);
 				if(toMove)
 					MovePastEntriesL(entryPos,entry,toMove,dirEntries);
 				}
 				// incomplete long file name entry
 				dirEntries = origDirEntries;
 				}
 			}
 		else
-			ProcessEntryL(entry);
+			{
+ProcessEntryL(entry);
+}
 		if(IsEndOfRootDir(entryPos))
 			break;
 		MoveToNextEntryL(entryPos);
 		}
 	--iRecursiveDepth;
 	}
+//----------------------------------------------------------------------------------------------------
 /**
 Process non trivial entries, such as files, if they are correct by filling out their
 cluster allocation in the bit packed Fat table. If it comes accross a directory
 CheckDirL will be called.
 @param aEntry Directory entry to check
 @leave System wide error code
 */
 void CScanDrive::ProcessEntryL(const TFatDirEntry& aEntry)
 	{
 	__PRINT(_L("CScanDrive::ProcessEntryL"));
 	TInt entryAtt=aEntry.Attributes();
 	__ASSERT_ALWAYS(!(entryAtt&~KEntryAttMaskSupported)&&!aEntry.IsErased(),User::Leave(KErrCorrupt));
-	if(!(entryAtt&(KEntryAttDir|KEntryAttVolume)) && iMount->StartCluster(aEntry)>0)
-		WriteClusterChainL(iMount->StartCluster(aEntry),(TUint) aEntry.Size());
+if(!(entryAtt&(KEntryAttDir|KEntryAttVolume)) && iMount->StartCluster(aEntry)>0)
+		{//-- this is a file with length >0. Check that its cluster chain corresponds to its size
+RecordClusterChainL(iMount->StartCluster(aEntry),(TUint) aEntry.Size());
+}
 	else if(entryAtt&KEntryAttDir)
-		CheckDirL(iMount->StartCluster(aEntry));
+		{//-- this is the directory, walk into it
-	}
+CheckDirL(iMount->StartCluster(aEntry));
+}
-/**
+	}
-Writes out the cluster chain for a correct file or directory, checks that the cluster
-has not already been used and that the correct number of clusters are allocated for the
+//----------------------------------------------------------------------------------------------------
-size of file. Registers cluster as used if correct
+/**
+Walks the cluster chain for a correct file or directory, checks that the cluster
-@param aCluster Cluster chain start point
+has not already been used and that the correct number of clusters are allocated for the
-@param aSizeInBytes Size of the file or directory in bytes
+size of file. Registers cluster as used, if correct.
-@leave System wide error values
-*/
+@param aCluster Cluster chain start point
-void CScanDrive::WriteClusterChainL(TInt aCluster,TUint aSizeInBytes)
+@param aSizeInBytes Size of the file or directory in bytes
-//
+@leave System wide error values
-// Mark off in the new fat the clusters used by entry with start cluster of aCluster
+*/
-//
+void CScanDrive::RecordClusterChainL(TInt aCluster, TUint aSizeInBytes)
 	{
-	__PRINT1(_L("CScanDrive::WriteClusterChainL starting at %d"),aCluster);
+	__PRINT2(_L("CScanDrive::RecordClusterChainL() cl:%d, sz:%d") ,aCluster, aSizeInBytes);
-	__ASSERT_ALWAYS(aCluster>0,User::Leave(KErrCorrupt));
+	__ASSERT_ALWAYS(aCluster>0, User::Leave(KErrCorrupt));
-	TInt clusterCount;
-	if(aSizeInBytes==0)
+TUint clusterCount;
+if(aSizeInBytes==0)
 		clusterCount=1;
 	else
-		clusterCount = (TInt) (( TInt64(aSizeInBytes) + TInt64((1<<iMount->ClusterSizeLog2())-1) ) >> iMount->ClusterSizeLog2());
+		{
+const TUint64 tmp = aSizeInBytes + Pow2_64(iMount->ClusterSizeLog2()) - 1;
+clusterCount = (TUint) (tmp >> iMount->ClusterSizeLog2());
+}
 	TInt startCluster=aCluster;
 	while(clusterCount)
 		{
-		if(AlreadyUsedL(aCluster))
+if(IsClusterUsedL(aCluster))
-			{
+			{//-- this cluster already seems to belong to some other object; crosslinked cluster chain. Can't fix it.
-			__ASSERT_ALWAYS(!IsDirError()&&iMatching.iStartCluster==0&&aCluster==startCluster,User::Leave(KErrCorrupt));
+			if(CheckDiskMode())
+{//-- in check disk mode this is a FS error; Indicate error and abort furter scanning
+__PRINT1(_L("CScanDrive::RecordClusterChainL #1 %d"),aCluster);
+IndicateErrorsFound(EClusterAlreadyInUse);
+User::Leave(KErrCorrupt);
+}
+__ASSERT_ALWAYS(!IsDirError() && iMatching.iStartCluster==0 && aCluster==startCluster,User::Leave(KErrCorrupt));
 			iMatching.iStartCluster=aCluster;
 			iDirError=EScanMatchingEntry;		//ERROR POINT
-IndicateErrorsFound(); //-- indicate that we have found errors
+IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 			return;
 			}
-		if(clusterCount==1)
+if(clusterCount==1)
 			{
 			if(!iMount->IsEndOfClusterCh(ReadFatL(aCluster)))
-				{
+				{//-- seems to be a rugged FAT artefact; File truncation had failed before and now file length is less than
-				//This is a genuine truncation
+//-- the corresponding cluster chain shall be. It will be truncated.
 				iTruncationCluster = aCluster;
+if(CheckDiskMode())
+{//-- in check disk mode this is a FS error; Indicate error and abort furter scanning
+__PRINT1(_L("CScanDrive::RecordClusterChainL #2 %d"),aCluster);
+IndicateErrorsFound(EInvalidEntrySize);
+User::Leave(KErrCorrupt);
+}
 }
-			SetUsedL(aCluster);
+//__PRINT1(_L("#--: %d -> EOC"), aCluster);
+MarkClusterUsedL(aCluster);
 			return;
 			}
 		else
 			{
-			TInt clusterVal=ReadFatL(aCluster);
+			const TUint clusterVal=ReadFatL(aCluster);
-			__ASSERT_ALWAYS(!IsEofF(clusterVal) && clusterVal!=0,User::Leave(KErrCorrupt));
-			SetUsedL(aCluster);
+//__PRINT2(_L("#--: %d -> %d"), aCluster, clusterVal);
+__ASSERT_ALWAYS(!IsEofF(clusterVal) && clusterVal !=KSpareCluster, User::Leave(KErrCorrupt));
+			MarkClusterUsedL(aCluster);
 			aCluster=clusterVal;
 			--clusterCount;
 			}
-		}
-	}
+}//while(clusterCount)
+	}
-/**
-Move to dos entry, checking all vfat entry ID numbers are in sequence.
+//----------------------------------------------------------------------------------------------------
-Assumes aEntry is not erased
+/**
+Move to dos entry, checking all vfat entry ID numbers are in sequence.
-@param aPos Position of the entry to move from, returns with new position
+Assumes aEntry is not erased
-@param aEntry The Dos entry after the Vfat entries on return
-@param aDirLength Running total of the length of the directory in entries
+@param aPos Position of the entry to move from, returns with new position
-@leave System wide error codes
+@param aEntry The Dos entry after the Vfat entries on return
-@return EFalse if not valid vfat entries or dos entry, else returns ETrue
+@param aDirLength Running total of the length of the directory in entries
+@leave System wide error codes
+@return EFalse if not valid vfat entries or dos entry, else returns ETrue
 */
 TBool CScanDrive::MoveToVFatEndL(TEntryPos& aPos,TFatDirEntry& aEntry,TInt& aDirLength)
 	{
 	__PRINT2(_L("CScanDrive::MoveToVFatEndL cluster=%d,pos=%d"),aPos.iCluster,aPos.iPos);
 	if(!aEntry.IsVFatEntry())
 		return IsDosEntry(aEntry);
 	TInt toFollow=aEntry.NumFollowing();
-	__ASSERT_ALWAYS(toFollow>0&&!aEntry.IsErased(),User::Leave(KErrCorrupt));
+	__ASSERT_ALWAYS(toFollow>0 && !aEntry.IsErased(), User::Leave(KErrCorrupt));
 	FOREVER
 		{
 		MoveToNextEntryL(aPos);
 		ReadDirEntryL(aPos,aEntry);
 		++aDirLength;
 		--toFollow;
 		if(!toFollow)
 			break;
-		if(!IsValidVFatEntry(aEntry,toFollow))
+if(!IsValidVFatEntry(aEntry,toFollow))
 			return(EFalse);
 		}
-	return(IsDosEntry(aEntry));
-	}
+return(IsDosEntry(aEntry));
+	}
-/**
-Check if an entry is valid VFat
+//----------------------------------------------------------------------------------------------------
+/**
-@param aEntry Entry to check
+Check if an entry is valid VFat
-@param aPrevNum Number into VFat entries for a dos entry to ensure in correct position
-@return ETrue if aEntry is a valid vfat entry
+@param aEntry Entry to check
+@param aPrevNum Number into VFat entries for a dos entry to ensure in correct position
+@return ETrue if aEntry is a valid vfat entry
 */
 TBool CScanDrive::IsValidVFatEntry(const TFatDirEntry& aEntry,TInt aPrevNum)const
 	{
 	if(aEntry.IsErased()||!aEntry.IsVFatEntry())
-		return(EFalse);
+		return EFalse;
 	return(aEntry.NumFollowing()==aPrevNum);
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Check if an entry is a Dos entry
+/**
+Check if an entry is a Dos entry
-@param aEntry Entry to check
-@return ETrue if aEntry is a dos entry
+@param aEntry Entry to check
+@return ETrue if aEntry is a dos entry
 */
 TBool CScanDrive::IsDosEntry(const TFatDirEntry& aEntry)const
 	{
 	TBool res = !(aEntry.Attributes()&~KEntryAttMaskSupported) && !aEntry.IsErased() && !aEntry.IsVFatEntry() && !aEntry.IsEndOfDirectory();
 	return res;
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Add partial entry to iPartEntry under the error condition of not all Vfat entries
+/**
-being present
+Add partial entry to iPartEntry under the error condition of not all Vfat entries being present
 @param aStartPos Position of the Dos entry associated with the VFat entries
 @param aEntry Directory Entry of the Dos entry associated with the VFat entries
 @leave KErrCorrupt Occurs if the entry is not valid
 */
 void CScanDrive::AddPartialVFatL(const TEntryPos& aStartPos, const TFatDirEntry& aEntry)
 	{
 	__PRINT2(_L("CScanDrive::AddPartialVFatL cluster=%d pos=%d"),aStartPos.iCluster,aStartPos.iPos);
 	__ASSERT_ALWAYS(!IsDirError(),User::Leave(KErrCorrupt));
 	iPartEntry.iEntryPos=aStartPos;
 	iPartEntry.iEntry=aEntry;
 	iDirError=EScanPartEntry;
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Add entry position to iMatching
+/**
+Add entry position to iMatching
-@param aEntryPos Position of the entry with the matching entry
-@leave KErrCorrupt if the start cluster is 0 or more that two matching entries occurs
+@param aEntryPos Position of the entry with the matching entry
-@return
+@leave KErrCorrupt if the start cluster is 0 or more that two matching entries occurs
+@return
 */
 TBool CScanDrive::AddMatchingEntryL(const TEntryPos& aEntryPos)
 	{
 	__PRINT2(_L("CScanDrive::AddMatchingEntryL cluster=%d pos=%d"),aEntryPos.iCluster,aEntryPos.iPos);
 	__ASSERT_ALWAYS(iMatching.iStartCluster>0 && iMatching.iCount<KMaxMatchingEntries,User::Leave(KErrCorrupt));
 	iMatching.iEntries[iMatching.iCount++]=aEntryPos;
 	return iMatching.iCount==KMaxMatchingEntries;
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Scan for differnces in the new and old FAT table writing them to media if discovered
+/**
+Scan for differnces in the new and old FAT table writing them to media if discovered
-@leave System wide error codes
+It is supposed to be called in 'ScanDrive' mode only
-*/
-void CScanDrive::WriteNewFatsL()
+@leave System wide error codes
+*/
+void CScanDrive::CompareAndFixFatsL()
 {
+__PRINT1(_L("CScanDrive::CompareAndFixFatsL() drv:%d"),iMount->DriveNumber());
-__PRINT1(_L("CScanDrive::WriteNewFatsL() drv:%d"),iMount->DriveNumber());
+ASSERT(!CheckDiskMode());
 TUint32 nClustersFixed = 0; //-- fixed clusters count
 TUint32 nBadClusters   = 0; //-- bad cluster count
 TUint32 dirtyFatSector = 0; //-- FAT table media sector with not-flushed data
 	        {
 if(BoolXOR(iMediaFatBits[i], iScanFatBits[i]))
 {//-- difference in the cluster "i" between a real FAT and what ScanDrive restored.
 //-- indicate that there are some problems in FAT. and we probably wrote something there.
-IndicateErrorsFound();
+IndicateErrorsFound(EScanDriveDirError);
 //-- skip BAD cluster, can't mark it as unused.
 if(iMount->IsBadCluster(ReadFatL(i)))
 {
 ++nBadClusters;
 {
 	    iMount->FAT().WriteFatEntryEofL(iTruncationCluster);
 		iMount->FAT().FlushL();
 //-- indicate that there are some problems in FAT. and we probably wrote something there.
-IndicateErrorsFound(); //-- indicate that we have found errors
+IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 ++nClustersFixed;
 }
 __PRINT2(_L("CScanDrive::WriteNewFatsL() fixed:%d, bad:%d"), nClustersFixed, nBadClusters);
 }
-/**
+//----------------------------------------------------------------------------------------------------
-Read the ID stored in reserved2 in the Dos entry or associated with the Dos entry of the
+/**
-Entry at the position passed in. This is used to find which version of two matching entries
+Read the "Rugged FAT" ID, stored in reserved2 in the Dos entry or associated with the Dos entry of the
-should be kept.
+Entry at the position passed in. This is used to find which version of two matching entries should be kept.
-@param aVFatPos Position of an entry to read ID from
-@leave System wide error codes
+@param aVFatPos Position of an entry to read ID from
-@return The ID found in reserved2 field of dos entry
+@leave System wide error codes
+@return The ID found in reserved2 field of dos entry
 */
 TInt CScanDrive::GetReservedidL(TEntryPos aVFatPos)
 	{
 	__PRINT(_L("CScanDrive::GetReservedidL"));
 	TFatDirEntry entry;
 		ReadDirEntryL(aVFatPos,entry);
 		}
 	return(entry.RuggedFatEntryId());
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Erase part entry found in iPartEntry
+/**
+Erase part entry found in iPartEntry
 @leave System wide error code
 */
 void CScanDrive::FixPartEntryL()
 	{
 	__PRINT2(_L("CScanDrive::FixPartEntryL cluster=%d,pos=%d"),iPartEntry.iEntryPos.iCluster,iPartEntry.iEntryPos.iPos);
-	iMount->EraseDirEntryL(iPartEntry.iEntryPos,iPartEntry.iEntry);
+	ASSERT(!CheckDiskMode());
-IndicateErrorsFound(); //-- indicate that we have found errors
+iMount->EraseDirEntryL(iPartEntry.iEntryPos,iPartEntry.iEntry);
+IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Delete entry with largest value in the reserved2 section(bytes 20 and 21) of dos entry
+/**
+Delete entry with largest value in the reserved2 section(bytes 20 and 21) of dos entry
-@leave System wide error code
+@leave System wide error code
 */
 void CScanDrive::FixMatchingEntryL()
 	{
-	__PRINT1(_L("CScanDrive::FixMatchingEntryL() start cluster=%d"),iMatching.iStartCluster);
+__PRINT1(_L("CScanDrive::FixMatchingEntryL() start cluster=%d"),iMatching.iStartCluster);
 	__ASSERT_ALWAYS(iMatching.iCount==KMaxMatchingEntries,User::Leave(KErrCorrupt));
-	TInt idOne=GetReservedidL(iMatching.iEntries[0]);
+	ASSERT(!CheckDiskMode());
+TInt idOne=GetReservedidL(iMatching.iEntries[0]);
 	TInt idTwo=GetReservedidL(iMatching.iEntries[1]);
 	TFatDirEntry entry;
 	TInt num=idOne>idTwo?0:1;
 	ReadDirEntryL(iMatching.iEntries[num],entry);
 	iMount->EraseDirEntryL(iMatching.iEntries[num],entry);
-IndicateErrorsFound(); //-- indicate that we have found errors
+IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 	}
-/**
-Move past specified number of entries
+//----------------------------------------------------------------------------------------------------
+/**
-@param aEntryPos Start position to move from, updated as move takes place
+Move past specified number of entries
-@param aEntry Directory entry moved to
-@param aToMove Number of entries to move through
+@param aEntryPos Start position to move from, updated as move takes place
-@param aDirEntries Number of entries moved, updated as move takes place
+@param aEntry Directory entry moved to
-@leave System wide error code
+@param aToMove Number of entries to move through
+@param aDirEntries Number of entries moved, updated as move takes place
+@leave System wide error code
 */
 void CScanDrive::MovePastEntriesL(TEntryPos& aEntryPos,TFatDirEntry& aEntry,TInt aToMove,TInt& aDirEntries)
 	{
-	while(aToMove-- && aEntryPos.iCluster!=KEndOfDirectory)
+	while(aToMove-- && !IsEofF(aEntryPos.iCluster))
 		{
 		MoveToNextEntryL(aEntryPos);
 		++aDirEntries;
 		}
 	ReadDirEntryL(aEntryPos,aEntry);
 	}
-/**
+//----------------------------------------------------------------------------------------------------
-Adds aCluster to cluster list array so that it may be revisited later, avoids stack
+/**
-over flow
+Adds aCluster to cluster list array so that it may be revisited later, avoids stack
+over flow
-@param aCluster Directory cluster number to add to the list
-@leave KErrNoMemory If allocation fails
+@param aCluster Directory cluster number to add to the list
+@leave KErrNoMemory If allocation fails
 */
 void CScanDrive::AddToClusterListL(TInt aCluster)
 	{
 	if(iListArrayIndex>=KMaxArrayDepth)
 		return;
 	if(iClusterListArray[iListArrayIndex]==NULL)
 		iClusterListArray[iListArrayIndex]=new(ELeave) RArray<TInt>(KClusterListGranularity);
 	iClusterListArray[iListArrayIndex]->Append(aCluster);
 	}
-#if defined(DEBUG_SCANDRIVE)
+//----------------------------------------------------------------------------------------------------
 /**
-Used for debug purposes only, compares new Fat and first Fat table, displays any differences
+Used in "CheckDisk" mode mostly. Compares first FAT table on the media with the FAT bitmap restored by walking the directory structure.
-and there meaning
+Displays any differences and records an error if found.
-@leave System wide error codes
+@param  aStopOnFirstErrorFound if ETrue will stop after discovering first error (FATs discrepancy)
-*/
-void CScanDrive::CompareFatsL() const
+@leave  System wide error codes
+*/
+void CScanDrive::CompareFatsL(TBool aStopOnFirstErrorFound)
 {
-	__PRINT(_L("CScanDrive::CompareFatsL()"));
+	__PRINT1(_L("CScanDrive::CompareFatsL(%d)"), aStopOnFirstErrorFound);
 TUint32 diffPos;
 if(!iMediaFatBits.Diff(iScanFatBits, diffPos))
 return; //-- FATs are identical
 //-- there is a difference between the real FAT and reconstructed one. Find the mismaching bit and fix FAT.
-const TInt clusters = iMount->UsableClusters();
+const TUint clusters = iMount->UsableClusters();
 ASSERT(diffPos < (TUint32)clusters);
-TInt scanusedcnt=0;
+TUint scanusedcnt=0;
-	TInt mediausedcnt=0;
+	TUint mediausedcnt=0;
-for(TInt i=diffPos; i<clusters; ++i)
+for(TUint i=diffPos; i<clusters; ++i)
 	    {
 const TBool bRealFatEntry = iMediaFatBits[i];
 const TBool bNewFatEntry  = iScanFatBits[i];
 		if(BoolXOR(bRealFatEntry, bNewFatEntry))
-		    {
+		    {//-- mismatch between FAT on the media and the FAT bitmap restored by walking directory structure
-			if(bRealFatEntry && !bNewFatEntry)
-			    {
+			    if(bRealFatEntry)
-__PRINT1(_L("Lost cluster=%d\n"),i);
+{//-- FAT[i] on the media is marked as occupied, but retored FAT bitmap shows that it is free
+if(iMount->IsBadCluster(ReadFatL(i)))
+continue; //-- this is a BAD cluster it can't be occupied by the FS object, OK.
+__PRINT2(_L("FAT[%d] = %d\n"), i, ReadFatL(i));
+__PRINT1(_L("iTruncationCluster = %d\n"), iTruncationCluster);
+//-- this is a lost cluster
+if(!IsEofF(ReadFatL(i)) && (i==iTruncationCluster))
+{//-- seems to be a Rugged FAT ertefact
+__PRINT1(_L("Hanging cluster = %d\n"),i);
+}
+else
+{
+__PRINT1(_L("Lost cluster=%d\n"),i);
+}
+IndicateErrorsFound(EBadClusterValue);
 }
-			else if((bRealFatEntry && !IsEofF(ReadFatL(i))) && (i==iTruncationCluster))
+else
-			    {
+{//-- FAT[i] on the media is marked as free, but retored FAT bitmap shows that it is occupied by some object
-	__PRINT1(_L("Hanging cluster = %d\n"),i);
+IndicateErrorsFound(EClusterAlreadyInUse);
+__PRINT1(_L("Unflushed cluster = %d\n"),i);
 }
-			else if(!bRealFatEntry && bNewFatEntry)
-{
+if(aStopOnFirstErrorFound)
-				__PRINT1(_L("Unflushed cluster = %d\n"),i);
+break; //-- not asked to check for errors further
-}
-			else
+}
-				User::Leave(KErrCorrupt);
-		    }
 if(bRealFatEntry)
 			mediausedcnt++;
 		if(bNewFatEntry)
 }
 __PRINT2(_L("Scan Fat Used=%d, Media Fat Used=%d \n"),scanusedcnt,mediausedcnt);
 }
-/**
+//----------------------------------------------------------------------------------------------------
-For debug purposes, print errors found as debug output
+/**
+For debug purposes, print errors found as debug output
 */
 void CScanDrive::PrintErrors()
 {
+#if defined(_DEBUG)
 	__PRINT1(_L("Directories visisted = %d\n"),iDirsChecked);
 	if(iDirError==EScanPartEntry)
 	    {
 	__PRINT2(_L("Part entry-dir cluster=%d,dir pos=%d,\n"),iPartEntry.iEntryPos.iCluster,iPartEntry.iEntryPos.iPos);
 	    {
 		__PRINT1(_L("Matching cluster - cluster no=%d\n"),iMatching.iStartCluster);
 		__PRINT2(_L("\tcluster 1 - dir cluster=%d,dir pos=%d\n"),iMatching.iEntries[0].iCluster,iMatching.iEntries[0].iPos);
 		__PRINT2(_L("\tcluster 2 - dir cluster=%d,dir pos=%d\n"),iMatching.iEntries[1].iCluster,iMatching.iEntries[1].iPos);
 	    }
+#endif
 }
-#endif
 /**
 Read a FAT directory entry from disk, either reads directly from the main cache or
 from the cluster buffer if scan drive is running in a seperate thread.
 @param aDirEntry Contents of directory entry read
 @leave System wide error code
 */
 void CScanDrive::ReadDirEntryL(const TEntryPos& aPos,TFatDirEntry& aDirEntry)
 {
-	__PRINT(_L("CScanDrive::ReadDirEntryL"));
+	//__PRINT(_L("CScanDrive::ReadDirEntryL"));
 	if (iMount->IsEndOfClusterCh(aPos.iCluster))
 		{
 		Mem::FillZ(&aDirEntry,sizeof(TFatDirEntry));
 		return;
 		}
 	iMount->ReadDirEntryL(aPos, aDirEntry);
 }
 /**
 Move to next directory entry, if anEntry is at the end of the cluster, and we are not
 the root dir, move it to the next cluster in the chain.
 @param aPos Current directory position up dated to position of next entry.
-@leave System wide error codes
 */
 void CScanDrive::MoveToNextEntryL(TEntryPos& aPos)
 	{
 	//__PRINT(_L("CScanDrive::MoveToNextEntryL"));
 	iMount->MoveToNextEntryL(aPos);
 	}
 /**
 Read a cluster from the Media Fat if scan run in a seperate thread read from scan fat table
 otherwise read from mount owned Fat table
 @param aClusterNum Cluster to read
-@leave System wide error code
+@return Value of cluster read from Fat
-@return Value of cluster read from Fat
+*/
-*/
+TUint32 CScanDrive::ReadFatL(TUint aClusterNum)
-TUint32 CScanDrive::ReadFatL(TInt aClusterNum) const
+	{
-	{
+	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
-	return iMount->FAT().ReadL(aClusterNum);
+{
+IndicateErrorsFound(EBadClusterNumber);
+User::Leave(KErrCorrupt);
+}
+//-- actually, ReadL() can leave with some error code, that won't be reflected in IndicateErrorsFound().
+//-- it's possible to improve but is it worth it?
+return iMount->FAT().ReadL(aClusterNum);
 }
+/**
+Set a cluster as visited in the bit packed scan Fat
+@param aCluster Cluster number
+*/
+void CScanDrive::MarkClusterUsedL(TUint aClusterNum)
+	{
+	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
+{
+IndicateErrorsFound(EBadClusterNumber);
+User::Leave(KErrCorrupt);
+}
+iScanFatBits.SetBit(aClusterNum);
+	}
+/**
+Query whether a cluster is already set as used
+@param aCluster Cluster to query
+*/
+TBool CScanDrive::IsClusterUsedL(TUint aClusterNum)
+	{
+	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
+{
+IndicateErrorsFound(EBadClusterNumber);
+User::Leave(KErrCorrupt);
+}
+return iScanFatBits[aClusterNum];
+	}
+/**
+@param aPos Position in a directory cluster
+@return  ETrue if aPos is the last entry in the root directory
+*/
+TBool CScanDrive::IsEndOfRootDir(const TEntryPos& aPos)const
+	{
+	return(iMount->IsRootDir(aPos)&&(iMount->StartOfRootDirInBytes()+aPos.iPos==(iMount->RootDirEnd()-KSizeOfFatDirEntry)));
+	}
+/**
+@param aVal Value of the cluster to be tested
+@return ETrue if aVal is the end of cluster marker
+*/
+TBool CScanDrive::IsEofF(TInt aVal) const
+	{
+return iMount->IsEndOfClusterCh(aVal);
+	}
+/** @return max. number of clusters on the volume being scanned */
+TUint32 CScanDrive::MaxClusters() const
+{
+ASSERT(iMaxClusters);
+return iMaxClusters;
+}
+/** @return ETrue in we are operating in "CheckDisk" mode*/
+TBool CScanDrive::CheckDiskMode() const
+{
+return iScanDriveMode == ECheckDisk;
+}

changeset 45	329ab0095843
parent 44	36bfc973b146
child 87	2f92ad2dc5db
child 90	947f0dc9f7a8