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

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 /**
 Notify the media drive about media areas that shall be treated as "deleted" if this feature is supported.
 @param aFreedClusters array with FAT numbers of clusters that shall be marked as "deleted"
 */
-void CFatTable::DoFreedClustersNotify(RClusterArray &aFreedClusters)
+void CFatTable::DoFreedClustersNotifyL(RClusterArray &aFreedClusters)
 {
 ASSERT(iMediaAtt & KMediaAttDeleteNotify);
 const TUint clusterCount = aFreedClusters.Count();
 	for (TUint i=0; i<clusterCount; ++i)
 	{
 const TUint currCluster = aFreedClusters[i];
 if (deleteLen == 0)
-		    byteAddress = DataPositionInBytes(currCluster); //-- start of the media range
+		    byteAddress = DataPositionInBytesL(currCluster); //-- start of the media range
 deleteLen += bytesPerCluster;
 //-- if this is the last entry in the array or the net cluster number is not consecutive, notify the driver
 		if ((i+1) == clusterCount || aFreedClusters[i+1] != (currCluster+1))
 const TInt r = iOwner->LocalDrive()->DeleteNotify(byteAddress, deleteLen);
 			if(r != KErrNone)
 {//-- if DeleteNotify() failed, it means that something terribly wrong happened to the NAND media;
 //-- in normal circumstances it can not happen. One of the reasons: totally worn out media.
 const TBool platSecEnabled = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement);
-__PRINT3(_L("CFatTable::DoFreedClustersNotify() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);
+__PRINT3(_L("CFatTable::DoFreedClustersNotifyL() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);
 if(platSecEnabled)
 {
 //-- if PlatSec is enabled, we can't afford jeopardize the security; without DeleteNotify()
 //-- it's possible to pick up data from deleted files, so, panic the file server.
 {//-- reached a limit of the entries in the array. Flush FAT cache, notify the driver and empty the array.
 IncrementFreeClusterCount(cntFreedClusters);
 cntFreedClusters = 0;
 SetFreeClusterHint(lastKnownFreeCluster);
-DoFreedClustersNotify(deletedClusters);
+DoFreedClustersNotifyL(deletedClusters);
 }
 }
 //-- increase the number of free clusters and notify the driver if required.
 IncrementFreeClusterCount(cntFreedClusters);
 SetFreeClusterHint(lastKnownFreeCluster);
 if(bFreeClustersNotify)
-DoFreedClustersNotify(deletedClusters);
+DoFreedClustersNotifyL(deletedClusters);
 	CleanupStack::PopAndDestroy(&deletedClusters);
 	}
 //-----------------------------------------------------------------------------
 //__PRINT1(_L("#- CFatTable::RequestFreeClusters(%d)"),aClustersRequired);
 ASSERT(aClustersRequired >0);
 return (NumberOfFreeClusters() >= aClustersRequired);
 }
-//-----------------------------------------------------------------------------
-/**
-@return ETrue if the cluster number aClusterNo is valid, i.e. belongs to the FAT table
-*/
-TBool CFatTable::ClusterNumberValid(TUint32 aClusterNo) const
-{
-return (aClusterNo >= KFatFirstSearchCluster) && (aClusterNo < iMaxEntries);
-}
 //#######################################################################################################################################
 //#     CAtaFatTable class implementation
 Constructor
 */
 CAtaFatTable::CAtaFatTable(CFatMountCB& aOwner)
 :CFatTable(aOwner), iDriveInteface(aOwner.DriveInterface())
 {
 iState = ENotInitialised;
 }
 CAtaFatTable::~CAtaFatTable()
 {
 if(pFatBitCache)
 {//-- bit cache is present, we need to populate (or repopulate it)
 //-- create helper thread object and start the thread
 ipHelperThread = CFat32BitCachePopulator::NewL(*this);
-if(ipHelperThread->Launch() != KErrNone)
+ipHelperThread->Launch();
-{//-- failed for some reason
+//-- background FAT bit cache populating thread is running now.
-DestroyHelperThread();
+//-- the result of thread start up and completion isn't very interesting: If it fails to
-}
+//-- properly populate the cache, nothing fatal will happen.
-else
-{
-//-- background FAT bit cache populating thread is running now.
-//-- the result of thread start up and completion isn't very interesting: If it fails to
-//-- properly populate the cache, nothing fatal will happen.
-}
 }
 //-- CFat32BitCachePopulator doesn't affect FAT table state.
 SetState(EMounted);
 return;
 TInt nMntDebugFlags;
 if(bFat32BkGndScan && RProperty::Get(KSID_Test1, iOwner->DriveNumber(), nMntDebugFlags) == KErrNone)
 {//-- test property for this drive is defined
 if(nMntDebugFlags & KMntDisable_FatBkGndScan)
 {
-__PRINT(_L("#- FAT32 BkGnd scan is disabled by debug interface."));
+__PRINT(_L("#- FAT32 BkGnd scan is disabled is disabled by debug interface."));
 bFat32BkGndScan = EFalse;
 }
 }
 #endif
 //-- 2. create helper thread object and start the thread
 ipHelperThread = CFat32FreeSpaceScanner::NewL(*this);
 SetState(EFreeClustersScan);
-User::LeaveIfError(ipHelperThread->Launch());
+ipHelperThread->Launch();
 //-- background FAT scanning thread is running now
 }
 //-----------------------------------------------------------------------------
 /**
 FlushL();
 	}
 /**
-Return the location of a Cluster in the data section of the media
+Return media position in bytes of the cluster start
 @param aCluster to find location of
 @return Byte offset of the cluster data
 */
-TInt64 CAtaFatTable::DataPositionInBytes(TUint32 aCluster) const
+TInt64 CAtaFatTable::DataPositionInBytesL(TUint32 aCluster) const
 	{
+if(!ClusterNumberValid(aCluster))
-__ASSERT_DEBUG(ClusterNumberValid(aCluster), Fault(EFatTable_InvalidIndex));
+{
+__ASSERT_DEBUG(0, Fault(EFatTable_InvalidIndex));
-const TInt clusterBasePosition=iOwner->ClusterBasePosition();
+User::Leave(KErrCorrupt);
+}
+const TUint32 clusterBasePosition=iOwner->ClusterBasePosition();
 	return(((TInt64(aCluster)-KFatFirstSearchCluster) << iOwner->ClusterSizeLog2()) + clusterBasePosition);
 	}
 ForceStop();
 ASSERT(0);
 return nRes;
 }
 //-- Helper FAT thread is running now
 return KErrNone;
 }
 //#######################################################################################################################################
 //#     CFat32ScanThread implementation
 //-----------------------------------------------------------------------------
 /**
 Launches the FAT32_ScanThread scaner thread.
-@return  KErrNone if the thread launched OK
+@return  standard error code
-standard error code otherwise
 */
 TInt CFat32ScanThread::Launch()
 {
 return DoLaunchThread(FAT32_ScanThread, this);
 }

branch	RCL_3
changeset 257	3e88ff8f41d5
parent 256	c1f20ce4abcf
child 268	345b1ca54e88