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

equal deleted inserted replaced

-:345b1ca54e88
+:039a3e647356
 /**
 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
 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
-DestroyHelperThread();
-}
-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 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);
 	}
 //-----------------------------------------------------------------------------
 /**
 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);
 }
 //-- allow this thread to be preempted by another one that wants to access the media driver.
 //-- without this wait we will have priority inversion, because this (low priority) thread continiously reads data by big chunks
 //-- and doesn't allow others to access the driver.
-//-- On the other hand, if the thread's priority is boosted, there is no reason to be so polite.
+//-- On the other hand, if the thread's priority is boosted, there is no reason to be polite.
 if(!pSelf->IsPriorityBoosted())
-{//-- User::After() granularity can be much coarser than 1ms, e.g. 1/64 Sec. This will add up to the scanning time
+User::After(K1mSec); //-- User::After() granularity can be much coarser than 1ms
-User::After(K1mSec);
-}
-else
-{//-- use much less coarse granularity to allow this thread to be preempted even if its priority is boosted.
-User::AfterHighRes(128);
-}
 //-------------------------------------------
 mediaPos += bytesToRead;
 rem -= bytesToRead;

branch	RCL_3
changeset 294	039a3e647356
parent 268	345b1ca54e88