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

equal deleted inserted replaced

-:e7d2d738d3c2
+:2f92ad2dc5db
 }
 //----------------------------------------------------------------------------------------------------
 /**
 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.
+For FAT12/16 it's OK, because the FAT12/16 is fully cached.
 */
 void CScanDrive::DoParseFatL()
 {
 const TInt KMaxClusters = MaxClusters();
 }
 //----------------------------------------------------------------------------------------------------
 /**
-Start the scanner. The this calss description about what it actually does.
+Starts the scanner.
-@param  aMode specifies the operational mode.
+@param	aMode	Specifies the operational mode.
 */
 void CScanDrive::StartL(TScanDriveMode aMode)
 	{
 	__PRINT2(_L("CScanDrive::StartL(%d), drive:%d"), aMode, iMount->DriveNumber());
 iScanDriveMode = aMode;
 //elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
 //__PRINT1(_L("#@@@ CScanDrive #1:%d ms "), elapsedTime);
 	CheckDirStructureL();
-//-- uncomments a line below if you need to compare real and restored FAT tables and print out all differences
+//-- uncomment a line below if you need to compare real and restored FAT tables and print out all differences
 //CompareFatsL(EFalse);
 //timeEnd.UniversalTime(); //-- take end time
 //elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
 //__PRINT1(_L("#@@@ CScanDrive #2:%d ms "), elapsedTime);
 			if(err==KErrNone)
 				return;
 			}
 		}
-	__ASSERT_ALWAYS(err==KErrNone,User::Leave(KErrNotFound));
+if(err != KErrNone)
+{
+__PRINT1(_L("CScanDrive::FindSameStartClusterL() #1 %d"), err);
+User::Leave(KErrNotFound);
+}
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 Scan through directory structure looking for start cluster found in iMatching
 @param aDirCluster Start cluster for scan to start
 @return System wide error value
 @leave
 */
-TInt CScanDrive::FindStartClusterL(TInt aDirCluster)
+TInt CScanDrive::FindStartClusterL(TUint32 aDirCluster)
 	{
 	__PRINT1(_L("CScanDrive::FindStartCluster dirCluster=%d"),aDirCluster);
-	__ASSERT_ALWAYS(aDirCluster>=iMount->RootIndicator(),User::Leave(KErrCorrupt));
+	if(aDirCluster < (TUint)iMount->RootIndicator() || aDirCluster >= MaxClusters())
+{
+__PRINT(_L("CScanDrive::FindStartCluster() #!\n"));
+IndicateErrorsFound(EBadClusterNumber);
+User::Leave(KErrCorrupt);
+}
 	if(++iRecursiveDepth==KMaxScanDepth)
 		{
 		--iRecursiveDepth;
 		return(KErrNotFound);
 		}
 	TEntryPos entryPos(aDirCluster,0);
 	TInt dirEntries=0;
-	FOREVER
+	for(;;)
 		{
 		TFatDirEntry entry;
 		ReadDirEntryL(entryPos,entry);
 		if(entry.IsParentDirectory()||entry.IsCurrentDirectory()||entry.IsErased())
 			{
 			if(IsEndOfRootDir(entryPos))
 				break;
 			MoveToNextEntryL(entryPos);
 			continue;
 			}
 		if(entry.IsEndOfDirectory())
 			break;
-		TBool isComplete;
 		TEntryPos vfatPos=entryPos;
-		isComplete=MoveToVFatEndL(entryPos,entry,dirEntries);
+		const TBool isComplete = MoveToVFatEndL(entryPos,entry,dirEntries);
-		__ASSERT_ALWAYS(isComplete,User::Leave(KErrBadName));
+if(!isComplete)
+{
+__PRINT(_L("CScanDrive::FindStartCluster() #2\n"));
+IndicateErrorsFound(EEntrySetIncomplete);
+User::Leave(KErrBadName);
+}
 		TInt err=CheckEntryClusterL(entry,vfatPos);
 		if(err==KErrNone)
 			{
 			--iRecursiveDepth;
 			return(KErrNone);
 		}
 	else if(aEntry.Attributes()&KEntryAttDir)
 		return(FindStartClusterL(iMount->StartCluster(aEntry)));
-	return(KErrNotFound);
+	return KErrNotFound;
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 Checks directory structure for errors, can be considered the start point of the scan.
 		const TBool isComplete = MoveToVFatEndL(entryPos,entry,dirEntries);
 if(!isComplete && CheckDiskMode())
 {//-- broken VFAT entryset; in CheckDisk mode this is the FS error, abort further activity
+__PRINT(_L("CScanDrive::CheckDirL() #1"));
 IndicateErrorsFound(EInvalidEntrySize);
 User::Leave(KErrCorrupt);
 }
 // Only assume that this is a corrupted VFAT entry if the VFAT attributes are set;
 @leave System wide error code
 */
 void CScanDrive::ProcessEntryL(const TFatDirEntry& aEntry)
 	{
 	__PRINT(_L("CScanDrive::ProcessEntryL"));
-	TInt entryAtt=aEntry.Attributes();
+	const TUint entryAtt=aEntry.Attributes();
-	__ASSERT_ALWAYS(!(entryAtt&~KEntryAttMaskSupported)&&!aEntry.IsErased(),User::Leave(KErrCorrupt));
+if((entryAtt & ~KEntryAttMaskSupported) || aEntry.IsErased())
+{
+__PRINT1(_L("CScanDrive::ProcessEntryL() wrong entry att: 0x%x"), entryAtt);
+IndicateErrorsFound(EEntryBadAtt);
+User::Leave(KErrCorrupt);
+}
 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());
+RecordClusterChainL(iMount->StartCluster(aEntry), aEntry.Size());
 }
 	else if(entryAtt&KEntryAttDir)
 		{//-- this is the directory, walk into it
 CheckDirL(iMount->StartCluster(aEntry));
 }
 @param aCluster Cluster chain start point
 @param aSizeInBytes Size of the file or directory in bytes
 @leave System wide error values
 */
-void CScanDrive::RecordClusterChainL(TInt aCluster, TUint aSizeInBytes)
+void CScanDrive::RecordClusterChainL(TUint32 aCluster, TUint aSizeInBytes)
 	{
 	__PRINT2(_L("CScanDrive::RecordClusterChainL() cl:%d, sz:%d") ,aCluster, aSizeInBytes);
-	__ASSERT_ALWAYS(aCluster>0, User::Leave(KErrCorrupt));
+if(aCluster < KFatFirstSearchCluster || aCluster >= MaxClusters())
+	    {
+__PRINT(_L("CScanDrive::RecordClusterChainL() #0"));
+IndicateErrorsFound(EBadClusterNumber);
+User::Leave(KErrCorrupt);
+}
 TUint clusterCount;
 if(aSizeInBytes==0)
+		{
 		clusterCount=1;
+}
 	else
 		{
 const TUint64 tmp = aSizeInBytes + Pow2_64(iMount->ClusterSizeLog2()) - 1;
 clusterCount = (TUint) (tmp >> iMount->ClusterSizeLog2());
 }
-	TInt startCluster=aCluster;
+	TUint startCluster=aCluster;
 	while(clusterCount)
 		{
 if(IsClusterUsedL(aCluster))
 			{//-- this cluster already seems to belong to some other object; crosslinked cluster chain. Can't fix it.
-			if(CheckDiskMode())
+__PRINT1(_L("CScanDrive::RecordClusterChainL #1 %d"),aCluster);
+if(CheckDiskMode())
 {//-- in check disk mode this is a FS error; Indicate error and abort furter scanning
-__PRINT1(_L("CScanDrive::RecordClusterChainL #1 %d"),aCluster);
+__PRINT(_L("CScanDrive::RecordClusterChainL #1.1"));
 IndicateErrorsFound(EClusterAlreadyInUse);
 User::Leave(KErrCorrupt);
 }
-__ASSERT_ALWAYS(!IsDirError() && iMatching.iStartCluster==0 && aCluster==startCluster,User::Leave(KErrCorrupt));
+if(IsDirError() || iMatching.iStartCluster > 0 || aCluster != startCluster)
+{//-- secondary entry into this state
+__PRINT(_L("CScanDrive::RecordClusterChainL #1.2"));
+IndicateErrorsFound(EClusterAlreadyInUse);
+User::Leave(KErrCorrupt);
+}
 			iMatching.iStartCluster=aCluster;
 			iDirError=EScanMatchingEntry;		//ERROR POINT
 IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 			return;
 			}
 if(clusterCount==1)
-			{
+			{//-- we have reached the end of the cluster chain
 			if(!iMount->IsEndOfClusterCh(ReadFatL(aCluster)))
-				{//-- seems to be a rugged FAT artefact; File truncation had failed before and now file length is less than
+				{//-- seems to be a rugged FAT artefact; File truncation/extension had failed before and now file length is less than
-//-- the corresponding cluster chain shall be. It will be truncated.
+//-- the corresponding cluster chain shall be. It will be truncated to the size recorded in file DOS entry.
 				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);
 		else
 			{
 			const TUint clusterVal=ReadFatL(aCluster);
 //__PRINT2(_L("#--: %d -> %d"), aCluster, clusterVal);
+if(IsEofF(clusterVal) || clusterVal == KSpareCluster )
-__ASSERT_ALWAYS(!IsEofF(clusterVal) && clusterVal !=KSpareCluster, User::Leave(KErrCorrupt));
+{//-- unexpected end of the cluster chain (it is shorter than recorded in file dir. entry)
+__PRINT1(_L("CScanDrive::RecordClusterChainL #3 %d"),clusterVal);
+IndicateErrorsFound(EBadClusterValue);
+User::Leave(KErrCorrupt);
+}
 			MarkClusterUsedL(aCluster);
 			aCluster=clusterVal;
 			--clusterCount;
 			}
 	__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));
+if(toFollow <=0 || aEntry.IsErased())
-	FOREVER
+{
+__PRINT1(_L("CScanDrive::MoveToVFatEndL #1 %d"),toFollow);
+IndicateErrorsFound(EEntrySetIncomplete);
+User::Leave(KErrCorrupt);
+}
+	for(;;)
 		{
 		MoveToNextEntryL(aPos);
 		ReadDirEntryL(aPos,aEntry);
 		++aDirLength;
 		--toFollow;
 @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();
+	const TBool res = !(aEntry.Attributes()&~KEntryAttMaskSupported) && !aEntry.IsErased() && !aEntry.IsVFatEntry() && !aEntry.IsEndOfDirectory();
 	return res;
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 @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));
+if(IsDirError())
+{
+__PRINT(_L("CScanDrive::AddPartialVFatL #1"));
+User::Leave(KErrCorrupt);
+}
 	iPartEntry.iEntryPos=aStartPos;
 	iPartEntry.iEntry=aEntry;
 	iDirError=EScanPartEntry;
 	}
 @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));
+if(iMatching.iStartCluster <= 0 || iMatching.iCount >= KMaxMatchingEntries)
+{
+__PRINT(_L("CScanDrive::AddMatchingEntryL #1"));
+User::Leave(KErrCorrupt);
+}
 	iMatching.iEntries[iMatching.iCount++]=aEntryPos;
 	return iMatching.iCount==KMaxMatchingEntries;
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 Read the "Rugged FAT" 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 should be kept.
 @param aVFatPos Position of an entry to read ID from
 @leave System wide error codes
 @return The ID found in reserved2 field of dos entry
 */
 TInt CScanDrive::GetReservedidL(TEntryPos aVFatPos)
 	TFatDirEntry entry;
 	ReadDirEntryL(aVFatPos,entry);
 	if(!IsDosEntry(entry))
 		{
 		TInt toMove=entry.NumFollowing();
 		while(toMove--)
 			MoveToNextEntryL(aVFatPos);
 		ReadDirEntryL(aVFatPos,entry);
 		}
 	return(entry.RuggedFatEntryId());
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 */
 void CScanDrive::FixMatchingEntryL()
 	{
 __PRINT1(_L("CScanDrive::FixMatchingEntryL() start cluster=%d"),iMatching.iStartCluster);
-	__ASSERT_ALWAYS(iMatching.iCount==KMaxMatchingEntries,User::Leave(KErrCorrupt));
+if(iMatching.iCount != KMaxMatchingEntries)
+{
+__PRINT1(_L("CScanDrive::FixMatchingEntryL() #1 %d"), iMatching.iCount);
+User::Leave(KErrCorrupt);
+}
 	ASSERT(!CheckDiskMode());
-TInt idOne=GetReservedidL(iMatching.iEntries[0]);
+const TInt idOne=GetReservedidL(iMatching.iEntries[0]);
-	TInt idTwo=GetReservedidL(iMatching.iEntries[1]);
+	const TInt idTwo=GetReservedidL(iMatching.iEntries[1]);
 	TFatDirEntry entry;
-	TInt num=idOne>idTwo?0:1;
+const TInt num = idOne>idTwo ? 0:1;
 	ReadDirEntryL(iMatching.iEntries[num],entry);
 	iMount->EraseDirEntryL(iMatching.iEntries[num],entry);
 IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 	if(iListArrayIndex>=KMaxArrayDepth)
 		return;
 	if(iClusterListArray[iListArrayIndex]==NULL)
 		iClusterListArray[iListArrayIndex]=new(ELeave) RArray<TInt>(KClusterListGranularity);
 	iClusterListArray[iListArrayIndex]->Append(aCluster);
 	}
 //----------------------------------------------------------------------------------------------------
 */
 TUint32 CScanDrive::ReadFatL(TUint aClusterNum)
 	{
 	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
 {
+__PRINT1(_L("CScanDrive::ReadFatL() bad cluster:%d\n"),aClusterNum);
 IndicateErrorsFound(EBadClusterNumber);
 User::Leave(KErrCorrupt);
 }
 //-- actually, ReadL() can leave with some error code, that won't be reflected in IndicateErrorsFound().
 */
 void CScanDrive::MarkClusterUsedL(TUint aClusterNum)
 	{
 	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
 {
+__PRINT1(_L("CScanDrive::MarkClusterUsedL() bad cluster:%d\n"),aClusterNum);
 IndicateErrorsFound(EBadClusterNumber);
 User::Leave(KErrCorrupt);
 }
 iScanFatBits.SetBit(aClusterNum);
 */
 TBool CScanDrive::IsClusterUsedL(TUint aClusterNum)
 	{
 	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
 {
+__PRINT1(_L("CScanDrive::IsClusterUsedL() bad cluster:%d\n"),aClusterNum);
 IndicateErrorsFound(EBadClusterNumber);
 User::Leave(KErrCorrupt);
 }
 return iScanFatBits[aClusterNum];

branch	RCL_3
changeset 87	2f92ad2dc5db
parent 36	538db54a451d
child 256	c1f20ce4abcf