MCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfile/sf_file

equal deleted inserted replaced

-:2bb754abd467
+:0ffb4e86fcc9
 #include "sf_file_cache_defs.h"
 // disables flushing of stale cachelines before each write
 #define LAZY_WRITE
+// call SetSizeL() to pre-allocate FAT clusters before flushing dirty data
+#define SETSIZE_BEFORE_WRITE
 enum TFileCacheFault
 	{
 	ECacheSettingsInitFailed,
 	ECacheSettingsNotFound,
 	EReOpeningUnNamedFile,
 	EStartingDirtyAWrongStage,
 	EUnexpectedReNewLFailure,
 	EDirtyDataOwnerNull,
 	EFlushingWithSessionNull,
+	EFlushingWithAllocatedRequest,
 	};
 LOCAL_C void Fault(TFileCacheFault aFault)
 //
 				// We need to flush all dirty data to disk in case this read overlaps
 				// with any dirty data already in the file cache
 				if (aMode & EFileWriteBuffered)
 					{
-					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, ETrue);
+					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFlushAll);
 					if (r == CFsRequest::EReqActionBusy || r != CFsRequest::EReqActionComplete)
 						return r;
 					}
 				retCode = CFsRequest::EReqActionContinue;	// read uncached
 				// (caching writes and requested write len > size of the cache),
 				// flush the write cache
 				if ((aMode & EFileWriteBuffered) == 0 ||
 					(cachingWrites && totalLen > iCacheSize))
 					{
-					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, ETrue);
+					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFlushAll);
 					if (r == CFsRequest::EReqActionBusy || r != CFsRequest::EReqActionComplete)
 						return r;
 					}
 				// if EFileWriteDirectIO then overwrite any non-dirty data and
 				// write direct to disk....
 					// Flush a single dirty cacheline (if there is one for this file)
 					// or all dirty data  on this drive (if there is any).
 					// If there's nothing to flush then the dirty (locked) data
 					// must belong to another drive, so there's not much we can do
 					// but write through
-					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFalse);
+					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFlushSingle);
 					if (r == CFsRequest::EReqActionBusy)
 						return CFsRequest::EReqActionBusy;
 					if (r != KErrInUse)
 						{
 						// Need to switch to drive thread to flush all data on this drive
 					{
 					// if no segment available, flush a single dirty cacheline
 					// or wait if already flushing
 					if (iFlushBusy)
 						return CFsRequest::EReqActionBusy;
-					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFalse);
+					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFlushSingle);
 					if (r != CFsRequest::EReqActionBusy && r != CFsRequest::EReqActionComplete)
 						lastError = r;
 					}
 #endif
 				// if no cacheline found & write caching is enabled, allocate a new cacheline
 				// we're going to issue an uncached write so clear any error
 				lastError = KErrNone;
 				if (cachingWrites)
 					{
-					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, ETrue);
+					TInt r = DoFlushDirty(aNewRequest, &aMsgRequest, EFlushAll);
 #ifdef _DEBUG
 					if (r == CFsRequest::EReqActionBusy)
 						CCacheManagerFactory::CacheManager()->Stats().iWriteThroughWithDirtyDataCount++;
 #endif
 					// Need to reset currentOperation.iReadWriteArgs.iTotalLength here to make sure
 	{
 	iLock.Wait();
 	CFsClientMessageRequest* newRequest = NULL;
-	TInt r = DoFlushDirty(newRequest, aOldRequest, ETrue);
+	TInt r = DoFlushDirty(newRequest, aOldRequest, EFlushAll);
 	iLock.Signal();
 	if (newRequest)
 	    {
 	}
 /**
 CFileCache::DoFlushDirty()
-@param aFlushAll. If EFalse then only a single cacheline will be flushed
+@param aFlushMode. The flush mode which indicates how many cache-lines to flush. @See TFlushMode
 returns	CFsRequest::EReqActionBusy if a flush is in progress OR cacheline already in use
 		CFsRequest::EReqActionComplete if nothing to flush / flush completed
 		KErrNoMemory if failed to allocate a request
 		or one of the system wide error codes
 */
-TInt CFileCache::DoFlushDirty(CFsClientMessageRequest*& aNewRequest, CFsRequest* aOldRequest, TBool aFlushAll)
+TInt CFileCache::DoFlushDirty(CFsClientMessageRequest*& aNewRequest, CFsRequest* aOldRequest, TFlushMode aFlushMode)
 	{
 	TInt64  pos;
 	TUint8* addr;
+	__ASSERT_ALWAYS(aNewRequest == NULL, Fault(EFlushingWithAllocatedRequest));
 	if (iFlushBusy)
 		return CFsRequest::EReqActionBusy;
 	TInt segmentCount = iCacheClient->FindFirstDirtySegment(pos, addr);
 		aNewRequest->Free();
 		aNewRequest = NULL;
 		return r;
 		}
-	// set the number of segments to flush - either all dirty data or the equivalent of one full cacheline
+	// set the flush mode
-	aNewRequest->CurrentOperation().iScratchValue0 =
+	aNewRequest->CurrentOperation().iScratchValue0 = (TAny*) aFlushMode;
-		(TAny*) (aFlushAll?KMaxTInt:iCacheClient->CacheLineSizeInSegments());
 	// issue flush request
 	r = FlushDirtySm(*aNewRequest);
 	// We should only get three possible return codes from FlushDirtySm() :
 		// requeue the caller's request (aOldRequest) if there is one
 		return CFsRequest::EReqActionBusy;
 		}
 	else	// CFsRequest::EReqActionComplete
 		{
+		// Return any allocation failures etc to client
+		TInt lastError = aNewRequest->LastError();
+		if (lastError != KErrNone)
+			r = lastError;
 		aNewRequest->PopOperation();
 		aNewRequest->Free();
 		aNewRequest = NULL;
 		return r;
 		}
 				currentOperation->iState = EStWriteToDisk;
 				TUint8* addr;
 				TInt segmentCount = iCacheClient->FindFirstDirtySegment(pos, addr);
-				// keep track of how many segments we've written
-				currentOperation->iScratchValue0 = (TAny*) ((TInt) currentOperation->iScratchValue0 - segmentCount);
 				// if no more dirty segments of if a genuine error then finish
 				// NB if the request has been cancelled then we still need to proceed and mark all the
 				// segments as clean, otherwise they will never get freed !
 				if (segmentCount == 0 || (lastError != KErrNone && lastError != KErrCancel))
 					{
 					{
 					currentOperation->iState = EStMarkAsClean;
 					break;
 					}
+#ifdef SETSIZE_BEFORE_WRITE
+				TInt64 physicalFileSize = iFileCB->Size64();
+				if ( (!iDrive->IsRugged()) && ((pos + (TInt64) len) > physicalFileSize))
+					{
+					// Need to switch to drive thread before calling CFileCB::SetSizeL()
+					if (!IsDriveThread())
+						{
+						aMsgRequest.SetState(CFsRequest::EReqStatePostInitialise);
+						return CFsRequest::EReqActionBusy;
+						}
+					__CACHE_PRINT2(_L("CACHEFILE: Increasing uncached size from %ld to %ld"), iFileCB->Size64(), iSize64);
+					TInt r;
+					r = CheckDiskSpace(iSize64 - physicalFileSize, &aMsgRequest);
+			        if(r == KErrNone)
+						TRAP(r, iFileCB->SetSizeL(iSize64))
+					if (r == KErrNone)
+						{
+						iFileCB->SetSize64(iSize64, ETrue);	// NB drive might be locked
+						}
+					}
+#endif
 				__CACHE_PRINT3(_L("CACHEFILE: FlushDirty first dirty pos %d, addr %08X count %d"), I64LOW(pos), addr, segmentCount);
 				TInt filledSegmentCount;
 				TInt lockError;
 				addr = iCacheClient->FindAndLockSegments(pos, segmentCount, filledSegmentCount, lockError, ETrue);
 					// Mark segment as clean
 					iCacheClient->MarkSegmentsAsClean(pos);
 					}
-				if (TInt(currentOperation->iScratchValue0) > 0)
+				switch((TFlushMode) (TInt) currentOperation->iScratchValue0)
-					currentOperation->iState = EStWriteToDisk;
+					{
-				else
+					case EFlushSingle:
-					currentOperation->iState = EStEnd;
+						currentOperation->iState = EStEnd;
+						break;
+					case EFlushAll:
+						currentOperation->iState = EStWriteToDisk;
+						break;
+					default:
+						ASSERT(0);
+						break;
+					}
 				}
 				break;
 			case EStEnd:
 				{

branch	RCL_3
changeset 41	0ffb4e86fcc9
parent 26	c734af59ce98
child 43	c1f20ce4abcf