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

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
 /**
 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::DoFreedClustersNotifyL(RClusterArray &aFreedClusters)
+void CFatTable::DoFreedClustersNotify(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 = DataPositionInBytesL(currCluster); //-- start of the media range
+		    byteAddress = DataPositionInBytes(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::DoFreedClustersNotifyL() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);
+__PRINT3(_L("CFatTable::DoFreedClustersNotify() 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);
-DoFreedClustersNotifyL(deletedClusters);
+DoFreedClustersNotify(deletedClusters);
 }
 }
 //-- increase the number of free clusters and notify the driver if required.
 IncrementFreeClusterCount(cntFreedClusters);
 SetFreeClusterHint(lastKnownFreeCluster);
 if(bFreeClustersNotify)
-DoFreedClustersNotifyL(deletedClusters);
+DoFreedClustersNotify(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);
-ipHelperThread->Launch();
+if(ipHelperThread->Launch() != KErrNone)
-//-- background FAT bit cache populating thread is running now.
+{//-- failed for some reason
-//-- the result of thread start up and completion isn't very interesting: If it fails to
+DestroyHelperThread();
-//-- 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 is disabled by debug interface."));
+__PRINT(_L("#- FAT32 BkGnd scan is disabled by debug interface."));
 bFat32BkGndScan = EFalse;
 }
 }
 #endif
 //-- 2. create helper thread object and start the thread
 ipHelperThread = CFat32FreeSpaceScanner::NewL(*this);
 SetState(EFreeClustersScan);
-ipHelperThread->Launch();
+User::LeaveIfError(ipHelperThread->Launch());
 //-- background FAT scanning thread is running now
 }
 //-----------------------------------------------------------------------------
 /**
 FlushL();
 	}
 /**
-Return media position in bytes of the cluster start
+Return the location of a Cluster in the data section of the media
 @param aCluster to find location of
 @return Byte offset of the cluster data
 */
-TInt64 CAtaFatTable::DataPositionInBytesL(TUint32 aCluster) const
+TInt64 CAtaFatTable::DataPositionInBytes(TUint32 aCluster) const
 	{
-if(!ClusterNumberValid(aCluster))
-{
+__ASSERT_DEBUG(ClusterNumberValid(aCluster), Fault(EFatTable_InvalidIndex));
-__ASSERT_DEBUG(0, Fault(EFatTable_InvalidIndex));
-User::Leave(KErrCorrupt);
+const TInt clusterBasePosition=iOwner->ClusterBasePosition();
-}
-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  standard error code
+@return  KErrNone if the thread launched OK
+standard error code otherwise
 */
 TInt CFat32ScanThread::Launch()
 {
 return DoLaunchThread(FAT32_ScanThread, this);
 }

branch	RCL_3
changeset 43	c1f20ce4abcf
parent 42	a179b74831c9
child 44	3e88ff8f41d5