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

equal deleted inserted replaced

-:5e441a173c63
+:d9f1e5bfe28c
 void CScanDrive::ConstructL(CFatMountCB* aMount)
 {
 ASSERT(aMount);
 //--- setting up
-iMount=aMount;
+	iMount			 = aMount;
-iGenericError = ENoErrors;
+	iGenericError	 = ENoErrors;
-iDirError     = ENoDirError;
+	iDirError		 = ENoDirError;
-iMaxClusters  = iMount->UsableClusters()+KFatFirstSearchCluster; //-- UsableClusters() doesn't count first 2 unused clusers
+	iHangingClusters = 0;
+	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. Each bit in the vector represents 1 FAT cluster.
 const TUint32 KClustersNum = MaxClusters();
 }
 //----------------------------------------------------------------------------------------------------
 /**
 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();
 for(TInt i=KFatFirstSearchCluster; i<KMaxClusters; ++i)
 	    {
 const TUint32 nFatEntry = ReadFatL(i);
 //-- each '1' bit represents a used cluster
 if(nFatEntry != KSpareCluster)
 iMediaFatBits.SetBit(i);
 	    }
 }
 //----------------------------------------------------------------------------------------------------
 void CScanDrive::DoParseFat32Buf(const TPtrC8& aBuf, TUint32& aCurrFatEntry)
 {
 ASSERT((aBuf.Size() & (sizeof(TFat32Entry)-1)) == 0);
 const TInt KNumEntries = aBuf.Size() >> KFat32EntrySzLog2;
 const TFat32Entry* const pFatEntry = (const TFat32Entry*)(aBuf.Ptr());
 for(TInt i=0; i<KNumEntries; ++i)
 {
 if(aCurrFatEntry >= KFatFirstSearchCluster)
 {
 const TUint32 KFatBufSz = 32*K1KiloByte; //-- buffer size for FAT reading. 32K seems to be optimal size
 iMediaFatBits.Fill(0);
-RBuf8 buf;
+RBuf8 fatParseBuf;
-CleanupClosePushL(buf);
+CleanupClosePushL(fatParseBuf);
 //-- allocate memory for FAT parse buffer
-buf.CreateMaxL(KFatBufSz);
+fatParseBuf.CreateMaxL(KFatBufSz);
 //-- read FAT directly from the media into the large buffer and parse it
 TUint32 rem = KFatSize;
 TUint32 mediaPos = KFat1StartPos;
 TUint32 currFatEntry = 0;
 while(rem)
 {
 const TUint32 bytesToRead=Min(rem, KFatBufSz);
-TPtrC8 ptrData(buf.Ptr(), bytesToRead);
+TPtrC8 ptrData(fatParseBuf.Ptr(), bytesToRead);
 //-- read portion of the FAT into buffer
-User::LeaveIfError(iMount->LocalDrive()->Read(mediaPos, bytesToRead, buf));
+User::LeaveIfError(iMount->LocalDrive()->Read(mediaPos, bytesToRead, fatParseBuf));
 //-- parse the buffer and populate bit vector
 DoParseFat32Buf(ptrData, currFatEntry);
 mediaPos += bytesToRead;
 rem -= bytesToRead;
 }
-buf.Close();
+fatParseBuf.Close();
-CleanupStack::PopAndDestroy(&buf);
+CleanupStack::PopAndDestroy(&fatParseBuf);
 }
 //----------------------------------------------------------------------------------------------------
 else
 return iGenericError;
 }
 /**
-Sets the flag indicating than there are errors in filesystem structure
+Sets the flag indicating that there are errors in filesystem structure
 See ProblemsDiscovered()
 @param  aError a code describing the error
 */
 void CScanDrive::IndicateErrorsFound(TGenericError aError)
 }
 //----------------------------------------------------------------------------------------------------
 /**
-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;
 	    CompareAndFixFatsL();
 }
 	PrintErrors();
 timeEnd.UniversalTime(); //-- take end time
 const TInt elapsedTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
 (void)elapsedTime;
 */
 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
+	// KMaxScanDepth is reached, clusters are stored in a list
 	// and passed into CheckDirL afresh
 	for(TUint i=0;i<KMaxArrayDepth && iClusterListArray[i]!=NULL;++i)
 		{
 		RArray<TInt>* clusterList=iClusterListArray[i];
 	++iDirsChecked;
 	TEntryPos entryPos(aCluster,0);
 	TInt dirEntries=0;
-	FOREVER
+	for(;;)
 		{
 		TFatDirEntry entry;
 		ReadDirEntryL(entryPos,entry);
 		if(!iMount->IsEndOfClusterCh(entryPos.iCluster))
 			++dirEntries;
 	while(clusterCount)
 		{
 if(IsClusterUsedL(aCluster))
 			{//-- this cluster already seems to belong to some other object; crosslinked cluster chain. Can't fix it.
 __PRINT1(_L("CScanDrive::RecordClusterChainL #1 %d"),aCluster);
 if(CheckDiskMode())
-{//-- in check disk mode this is a FS error; Indicate error and abort furter scanning
+{//-- in check disk mode this is an FS error; Indicate error and abort further scanning
 __PRINT(_L("CScanDrive::RecordClusterChainL #1.1"));
 IndicateErrorsFound(EClusterAlreadyInUse);
 User::Leave(KErrCorrupt);
 }
 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/extension had failed before and now file length is less than
+				{
-//-- the corresponding cluster chain shall be. It will be truncated to the size recorded in file DOS entry.
+				// According to the directory entry, we have reached the end of the cluster chain,
-				iTruncationCluster = aCluster;
+				// whereas in the media FAT, it is not.
+				// This is a rugged FAT artefact; hanging cluster chain:
+				// 	A cluster chain which is longer in the FAT table than is recorded in the corresponding directory entry
+				// 	or not terminated by an EOC entry in FAT.
+				// This is caused by:
+				//  - File truncation failing.
+				//	- OR file expanding failing during flushing to the media FAT.
 if(CheckDiskMode())
-{//-- in check disk mode this is a FS error; Indicate error and abort furter scanning
+{//-- in check disk mode this is an FS error; Indicate error and abort further scanning
-__PRINT1(_L("CScanDrive::RecordClusterChainL #2 %d"),aCluster);
+__PRINT1(_L("CScanDrive::RecordClusterChainL #2 Hanging cluster=%d"),aCluster);
 IndicateErrorsFound(EInvalidEntrySize);
 User::Leave(KErrCorrupt);
 }
+				// The chain will be truncated to the size recorded in the file's DOS entry and
+				// the remaining lost cluster chain will be fixed later in CompareAndFixFatsL().
+				FixHangingClusterChainL(aCluster);
 }
 //__PRINT1(_L("#--: %d -> EOC"), aCluster);
 MarkClusterUsedL(aCluster);
 			return;
 			break;
 if(!IsValidVFatEntry(aEntry,toFollow))
 			return(EFalse);
 		}
+	// A sequence of VFat entries must end with a Dos entry to be valid.
-return(IsDosEntry(aEntry));
+	return(IsDosEntry(aEntry));
 	}
 //----------------------------------------------------------------------------------------------------
 /**
 Check if an entry is valid VFat
 	}
 //----------------------------------------------------------------------------------------------------
 /**
-Scan for differnces in the new and old FAT table writing them to media if discovered
+Scan for differences in the new and old FAT table writing them to media if discovered
 It is supposed to be called in 'ScanDrive' mode only
 @leave System wide error codes
 */
 void CScanDrive::CompareAndFixFatsL()
 {
 ++nBadClusters;
 continue;
 }
-//-- here we found a lost cluster. Its FAT entry will be replaced with KSpareCluster. In the case of multiple lost clusters FAT table will
+//-- Here we found a lost cluster. Its FAT entry will be replaced with KSpareCluster.
-//-- be flushed on media sector basis. It is much faster than flushing FAT after every write and will
+//-- In the case of multiple lost clusters FAT table will be flushed on media sector basis.
-//-- guarantee that FAT won't be corrupted if the media driver provides atomic sector write.
+//-- It is much faster than flushing FAT after every write and will guarantee
+//-- that FAT won't be corrupted if the media driver provides atomic sector write.
 if(nClustersFixed == 0)
 {//-- this is the first lost cluster entry we found
 //-- relative FAT media sector for the 'i' entry. The real value doesn't matter,
 //-- we will just be flushing FAT before writing to the different FAT media sector.
 else
 {
 const TUint32 fatSec = iMount->FAT().PosInBytes(i) >> KSectorSzLog2;
 if(fatSec != dirtyFatSector)
-{//-- we are going to write to a differrent media sector
+{//-- we are going to write to a different media sector
 iMount->FAT().FlushL();
 iMount->FAT().WriteL(i, KSpareCluster); //-- fix lost cluster
 dirtyFatSector = fatSec;
 }
 else
 if(nClustersFixed)
 iMount->FAT().FlushL();
 //------
-if(iTruncationCluster != 0)
-{
+	// Add the number of hanging clusters fixed by ScanDrive
-	    iMount->FAT().WriteFatEntryEofL(iTruncationCluster);
+	nClustersFixed += iHangingClusters;
-		iMount->FAT().FlushL();
+__PRINT3(_L("CScanDrive::WriteNewFatsL() fixed clusters=%d,hanging clusters=%d,bad clusters=%d"),nClustersFixed,iHangingClusters,nBadClusters);
-//-- indicate that there are some problems in FAT. and we probably wrote something there.
-IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
-++nClustersFixed;
-}
-__PRINT2(_L("CScanDrive::WriteNewFatsL() fixed:%d, bad:%d"), nClustersFixed, nBadClusters);
 }
 //----------------------------------------------------------------------------------------------------
 /**
 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
 */
 	iMount->EraseDirEntryL(iMatching.iEntries[num],entry);
 IndicateErrorsFound(EScanDriveDirError); //-- indicate that we have found errors
 	}
+//----------------------------------------------------------------------------------------------------
+/**
+	Fix a hanging cluster chain.
+	Writes EOF to the corresponding FAT entry, making this cluster chain length correspond to the
+	real file size recorded in the directory entry.
+	The remainder of the chain will be cleaned up later in CompareAndFixFatsL().
+	@leave	System wide error code
+*/
+void CScanDrive::FixHangingClusterChainL(TUint32 aFatEofIndex)
+	{
+	__PRINT1(_L("CScanDrive::FixHangingClusterL() Hanging cluster=%d"), aFatEofIndex);
+	iMount->FAT().WriteFatEntryEofL(aFatEofIndex);
+	iMount->FAT().FlushL();
+	iHangingClusters++;
+	// Indicate that we have found an error
+	IndicateErrorsFound(EScanDriveDirError);
+	}
 //----------------------------------------------------------------------------------------------------
 /**
 Move past specified number of entries
 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)
+			if(bRealFatEntry)
-{//-- FAT[i] on the media is marked as occupied, but retored FAT bitmap shows that it is free
+				{//-- FAT[i] on the media is marked as occupied, but restored FAT bitmap shows that it is free
-if(iMount->IsBadCluster(ReadFatL(i)))
+				if(iMount->IsBadCluster(ReadFatL(i)))
-continue; //-- this is a BAD cluster it can't be occupied by the FS object, OK.
+					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));
+				__PRINT2(_L("FAT[%d] = %d\n"), i, ReadFatL(i));
-__PRINT1(_L("iTruncationCluster = %d\n"), iTruncationCluster);
+				//-- this is a Rugged FAT artefact; a lost cluster
-//-- this is a lost cluster
+				__PRINT1(_L("Lost cluster=%d\n"),i);
-if(!IsEofF(ReadFatL(i)) && (i==iTruncationCluster))
-{//-- seems to be a Rugged FAT ertefact
+				IndicateErrorsFound(EBadClusterValue);
-__PRINT1(_L("Hanging cluster = %d\n"),i);
+				}
-}
+			else
-else
+				{//-- FAT[i] on the media is marked as free, but restored FAT bitmap shows that it is occupied by some object
-{
+				IndicateErrorsFound(EClusterAlreadyInUse);
-__PRINT1(_L("Lost cluster=%d\n"),i);
+				__PRINT1(_L("Unflushed cluster = %d\n"),i);
-}
+				}
+		 if(aStopOnFirstErrorFound)
-IndicateErrorsFound(EBadClusterValue);
+			 break; //-- not asked to check for errors further
-}
-else
-{//-- FAT[i] on the media is marked as free, but retored FAT bitmap shows that it is occupied by some object
-IndicateErrorsFound(EClusterAlreadyInUse);
-__PRINT1(_L("Unflushed cluster = %d\n"),i);
-}
-if(aStopOnFirstErrorFound)
-break; //-- not asked to check for errors further
 }
 if(bRealFatEntry)
 			mediausedcnt++;
 	//__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
+Read a cluster from the Media Fat if scan run in a separate thread read from scan Fat table
 otherwise read from mount owned Fat table
 @param aClusterNum Cluster to read
 @return Value of cluster read from Fat
 */
 TUint32 CScanDrive::ReadFatL(TUint aClusterNum)
 	{
 	if(aClusterNum < KFatFirstSearchCluster || aClusterNum >= MaxClusters())
 {
 __PRINT1(_L("CScanDrive::ReadFatL() bad cluster:%d\n"),aClusterNum);
 IndicateErrorsFound(EBadClusterNumber);

changeset 149	d9f1e5bfe28c
parent 90	947f0dc9f7a8
child 291	206a6eaaeb71