// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\sfile\sf_file_cache.cpp

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32std.h>

#include <e32std_private.h>

#include "sf_std.h"

#include <e32uid.h>

#include <e32wins.h>

#include <f32file.h>

#include <hal.h>

#include "sf_file_cache.h"

#include "sf_cache_man.h"

#include "sf_cache_client.h"

#include "sf_file_cache_defs.h"

// disables flushing of stale cachelines before each write

#define LAZY_WRITE

enum TFileCacheFault

	{

	ECacheSettingsInitFailed,

	ECacheSettingsNotFound,

	ECacheSettingGetFailed,

	ECacheCodeFault,

	ECacheBadOperationIndex,

	ENoFileCache,

	EFileAlreadyClosed,

	EClosingDirtyFile,

	ECompletingWriteWithDataRemaining,

	EPosBeyondSize,

	EMsgAlreadyCompleted,

	EBadRetCode,

	EInternalError,

	ERequestUncancelled,

	ELockAlreadyOpen,

	EBadSegmentCount,

	EReNewingOpenCache,

	EClosingUnNamedFile,

	EFileNameAlreadyOwned,

	EClosedFileHasNoName,

	EReOpeningUnNamedFile,

	EStartingDirtyAWrongStage,

	EUnexpectedReNewLFailure,

	EDirtyDataOwnerNull,

	EFlushingWithSessionNull,

	};

LOCAL_C void Fault(TFileCacheFault aFault)

//

// Report a fault in the file cache

//

	{

	User::Panic(_L("FSFILECACHE"), aFault);

	}

const TInt KMinSequentialReadsBeforeReadAhead = 3;

//************************************

// CFileCache

//************************************

inline TBool ReadCachingEnabled(CFileShare& aShare)

	{

	TUint mode = aShare.iMode;

	TInt fileCacheFlags = TFileCacheSettings::Flags(aShare.File().Drive().DriveNumber());

	if (((mode & EFileReadBuffered) && (fileCacheFlags & (EFileCacheReadEnabled | EFileCacheReadOn))) ||

		(((mode & EFileReadDirectIO) == 0) && (fileCacheFlags & EFileCacheReadOn)))

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

inline TBool WriteCachingEnabled(CFileShare& aShare)

	{

	TUint mode = aShare.iMode;

	TInt fileCacheFlags = TFileCacheSettings::Flags(aShare.File().Drive().DriveNumber());

	if ((mode & EFileWrite) == 0)

		{

		return EFalse;

		}

	else if (((mode & EFileWriteBuffered) && (fileCacheFlags & (EFileCacheWriteEnabled | EFileCacheWriteOn))) ||

		(((mode & EFileWriteDirectIO) == 0) && (fileCacheFlags & EFileCacheWriteOn)))

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

void CFileCache::SetFileCacheFlags(CFileShare& aShare)

	{

	TInt fileCacheFlags = TFileCacheSettings::Flags(iDriveNum);

	TUint& mode = aShare.iMode;

	// enable/disable read ahead

	if (((mode & EFileReadAheadOn) && (fileCacheFlags & (EFileCacheReadAheadEnabled | EFileCacheReadAheadOn))) ||

		 (((mode & EFileReadAheadOff) == 0) && (fileCacheFlags & EFileCacheReadAheadOn)))

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheReadAhead ENABLED"));

		mode|= EFileReadAheadOn;

		}

	else

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheReadAhead disabled"));

		mode&= ~EFileReadAheadOn;

		}

	// enable/disable read caching 

	if (ReadCachingEnabled(aShare))

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheRead ENABLED"));

		mode|= EFileReadBuffered;

		}

	else

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheRead disabled"));

		// if read caching is off, turn off read-ahead too

		mode&= ~(EFileReadBuffered | EFileReadAheadOn);

		}

	// enable/disable write caching 

	if (WriteCachingEnabled(aShare))

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheWrite ENABLED"));

		mode|= EFileWriteBuffered;

		}

	else

		{

		__CACHE_PRINT(_L("CACHEFILE: EFileCacheWrite disabled"));

		mode&= ~EFileWriteBuffered;

		}

	}

void CFileCache::ConstructL(CFileShare& aShare)

	{

	iDrive = &aShare.File().Drive();

	iDriveNum = iDrive->DriveNumber();

	iMount=&iDrive->CurrentMount();

	DoInitL(iDriveNum);	

	CCacheManager* manager = CCacheManagerFactory::CacheManager();

	iCacheClient = manager->CreateClientL();

	manager->RegisterClient(*iCacheClient);

	TInt segmentSize = SegmentSize();

	TInt segmentSizeMask = I64LOW(SegmentSizeMask());

	// Get file cache size

	iCacheSize			= TFileCacheSettings::CacheSize(iDriveNum);

	// must be at least one segment

	iCacheSize			= Max(iCacheSize, segmentSize);

	// round up to nearest whole segment

	iCacheSize			= (iCacheSize + segmentSize - 1) & segmentSizeMask;

	// Get max read-ahead length

	iMaxReadAheadLen	= TFileCacheSettings::MaxReadAheadLen(iDriveNum);

	// must be at least one segment

	iMaxReadAheadLen	= Max(iMaxReadAheadLen, segmentSize);

	// round up to nearest whole segment

	iMaxReadAheadLen	= (iMaxReadAheadLen + segmentSize - 1) & segmentSizeMask;

	// read-ahead should not be greater than the cache size minus one segment

	iMaxReadAheadLen	= Min(iMaxReadAheadLen, iCacheSize - segmentSize);

	// ... or greater than one cacheline (128K should be enough !)

	iMaxReadAheadLen	= Min(iMaxReadAheadLen, iCacheClient->CacheLineSize());

	iFileCacheReadAsync = TFileCacheSettings::FileCacheReadAsync(iDriveNum);

	iClosedFileKeepAliveTime	= TFileCacheSettings::ClosedFileKeepAliveTime(iDriveNum);

	iDirtyDataFlushTime			= TFileCacheSettings::DirtyDataFlushTime(iDriveNum);

	// Calculate max number of segments to cache

	TInt maxSegmentsToCache = iCacheSize >> SegmentSizeLog2();

	__CACHE_PRINT1(_L("CACHEFILE: maxSegmentsToCache %d"), maxSegmentsToCache);

	iCacheClient->SetMaxSegments(maxSegmentsToCache);

	CFileCache* fileCache = ReNewL(aShare);

	__ASSERT_ALWAYS(fileCache != NULL, Fault(EUnexpectedReNewLFailure));

	}

CFileCache* CFileCache::NewL(CFileShare& aShare)

	{

	__CACHE_PRINT(_L("CACHEFILE: CFileCache::NewL()"));

	CFileCB* file = &aShare.File();

	if ((CCacheManagerFactory::CacheManager() == NULL) ||

		(!ReadCachingEnabled(aShare) && !WriteCachingEnabled(aShare)) ||

		(FsThreadManager::IsDriveSync(file->Drive().DriveNumber(),EFalse)))

		return NULL;

	CFileCache* fileCache = new(ELeave) CFileCache();

	CleanupClosePushL(*fileCache);

	fileCache->ConstructL(aShare);

	CleanupStack::Pop(1, fileCache);

	return fileCache;

	}

CFileCache* CFileCache::ReNewL(CFileShare& aShare)

	{

	__CACHE_PRINT(_L("CACHEFILE: CFileCache::ReNewL()"));

	// check not already open i.e. attached to a CFileCB

	__ASSERT_DEBUG(iFileCB == NULL, Fault(EReNewingOpenCache));

	// make sure the drive thread exists (the mount may have been mounted

	// synchronously since the drive was last open)

	const TInt r = FsThreadManager::GetDriveThread(iDriveNum, &iDriveThread);

	if ((r!= KErrNone) || !iDriveThread)

		return NULL;

	// if re-opening in DirectIo mode, destroy the file cache 

	if (!ReadCachingEnabled(aShare) && !WriteCachingEnabled(aShare))

		{

		Close();

		return NULL;

		}

	SetFileCacheFlags(aShare);

	// assign ownership of this object to aFileCB before any leaves occur

	iFileCB = &aShare.File();

	iFileCB->iBody->iFileCache = this;

	__ASSERT_DEBUG(iLock.Handle() == KNullHandle, Fault(ELockAlreadyOpen));

	User::LeaveIfError(iLock.CreateLocal());

	// delete the file name to save heap space (it's only needed 

	// while the file is on the closed queue so that it can be matched)

	delete iFileNameF;

	iFileNameF = NULL;

	return this;

	}

void CFileCache::Init(CFileShare& aShare)

	{

	SetFileCacheFlags(aShare);

	}

CFileCache::CFileCache() : 

	iClosedTimer(ClosedTimerEvent, this),

	iDirtyTimer(DirtyTimerEvent, this)

	{

	}

CFileCache::~CFileCache()

	{

	iLock.Close();

	// stop the owning CFileCB from pointing to an about-to-be deleted object

	if (iFileCB && iFileCB->iBody)

		iFileCB->iBody->iFileCache = NULL;

	CCacheManagerFactory::CacheManager()->DeregisterClient(*iCacheClient);

	delete iCacheClient;

	delete iFileNameF;

	}

TInt CFileCache::ClosedTimerEvent(TAny* aFileCache)

	{

	TClosedFileUtils::Remove((CFileCache*) aFileCache);

	return KErrNone;

	}

TInt CFileCache::DirtyTimerEvent(TAny* aFileCache)

	{

	// Cannot report errors here

	// coverity [unchecked_value]

	(void)((CFileCache*) aFileCache)->FlushDirty();

	return KErrNone;

	}

void CFileCache::Close()

	{

	__CACHE_PRINT1(_L("CFileCache::Close() 0x%x"),this);

	TInt r = KErrNone;

#ifdef _DEBUG

	if (iCacheClient)	// NB Object may not have been fully constructed

		{

		TInt64  pos;

		TUint8* addr;

		__ASSERT_DEBUG(((iCacheClient->FindFirstDirtySegment(pos, addr)) == 0), Fault(EClosingDirtyFile));

		__ASSERT_DEBUG(!iDirtyDataOwner, Fault(EClosingDirtyFile));

		}

#endif

	__CACHE_PRINT2(_L("CFileCache::Close() iFileCB %08X IsClosed %d"), 

		iFileCB, TClosedFileUtils::IsClosed(this));

	// if not already closed move to closed file queue

	if (iFileCB != NULL && 

		!iFileCB->DeleteOnClose() &&

		!TClosedFileUtils::IsClosed(this) && 

		IsDriveThread())

		{

		// add to ClosedFiles container

		__CACHE_PRINT1(_L("CLOSEDFILES: Adding %S\n"), &iFileCB->FileNameF() );

		TRAP(r, TClosedFileUtils::AddL(this, ETrue));

		// Acquire ownership of the CFileCB's file name

		__ASSERT_DEBUG(iFileCB->iFileNameF, Fault(EClosingUnNamedFile));

		__ASSERT_DEBUG(iFileNameF == NULL, Fault(EFileNameAlreadyOwned));

		iFileNameF = iFileCB->iFileNameF;

		iNameHash = iFileCB->iNameHash;

		iFileCB->iFileNameF = NULL;

		// remove pointer to owning CFileCB as this is called from CFileCB's destructor

		iFileCB = NULL;

		// Successfully moved file !

		if (r == KErrNone)

			{

			// close the RFastLock object here to prevent OOM kernel tests from failing

			iLock.Close();

			return;

			}

		}

	iClosedTimer.Stop();

	// if already closed, close for good. N.B. CFsObject::DoClose() will 

	// cause it to be removed from the ClosedFiles container

	CFsDispatchObject::Close();

	}

CMountCB& CFileCache::Mount() const

	{

	return *iMount;

	}

CFileCB* CFileCache::FileCB()

	{

	return iFileCB;

	}

TInt CFileCache::SegmentSize() const

	{

	return iCacheClient->SegmentSize();

	}

TInt CFileCache::SegmentSizeLog2() const

	{

	return iCacheClient->SegmentSizeLog2();

	}

TInt64 CFileCache::SegmentSizeMask() const

	{

	return iCacheClient->SegmentSizeMask();

	}

/**

Sets the cached file size  

@param aSize The size of the file.

*/  

void CFileCache::SetSize64(TInt64 aSize)

	{

	__e32_atomic_store_ord64(&iSize64, aSize);

	}

TDrive& CFileCache::Drive() const

	{

	return *iDrive;

	}

TUint32 CFileCache::NameHash() const

	{

	return(iNameHash);

	}

HBufC& CFileCache::FileNameF() const

	{

	__ASSERT_DEBUG(iFileNameF, Fault(EClosedFileHasNoName));

	return(*iFileNameF);

	}

TBool CFileCache::IsDriveThread()

	{

	return FsThreadManager::IsDriveThread(iDriveNum, EFalse);

	}

void CFileCache::ResetReadAhead()

	{

//	iSequentialReads = 0;

	iReadAheadLen = 0;

	iReadAheadPos = 0;

	}

/**

ReadAhead() - 

dispatches a new message to fill the read cache if 

(ReadAheadPos - ShareReadPos) <= (ReadAheadLen)

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

		^				^

		|----- ReadAheadLen ----------------->

		|				| 

  ShareReadPos		ReadAheadPos	

Every successful read-ahead doubles ReadAheadLen until it reaches the maximum 

(KDefaultFileCacheMaxReadAheadLen). 

*/

void CFileCache::ReadAhead(CFsMessageRequest& aMsgRequest, TUint aMode)

	{

	if (!(aMode & EFileReadAheadOn) ||

		(iSequentialReads < KMinSequentialReadsBeforeReadAhead) ||

		iMaxReadAheadLen == 0)

		return;

	TInt segmentSize = SegmentSize();

	TInt64 segmentSizeMask = SegmentSizeMask();

	// if the read-ahead pos has been reset to zero, then the read-ahead 

	// position and length must be re-calculated

	TBool resetting = (iReadAheadPos == 0)?(TBool)ETrue:(TBool)EFalse;

	if (resetting)

		{

		iReadAheadPos = (iLastReadPos + segmentSize - 1) & segmentSizeMask;	

		// ensure read ahead len at least as big as last read

		iReadAheadLen = Max(iReadAheadLen, iLastReadLen);	

		// round up to a segment size

		iReadAheadLen = (iReadAheadLen + segmentSize - 1) & (TInt) segmentSizeMask;

		// ensure read ahead len at least as big as 1 segments 

		iReadAheadLen = Max(iReadAheadLen, segmentSize);	

		// ensure read ahead len not greater than the maximum read ahead len

		iReadAheadLen = Min(iReadAheadLen, iMaxReadAheadLen);

		iReadAheadRequest = NULL;

		}

	TInt bytesBuffered = (TInt) (iReadAheadPos - iLastReadPos);

	TInt bytesNotBuffered = iMaxReadAheadLen - bytesBuffered;

	// if read-ahead buffer len > current read-ahead len OR

	// read-ahead buffer is more than half full, do nothing

	if ((iReadAheadRequest) ||

		(bytesBuffered > iReadAheadLen) || 

		(bytesBuffered > (iMaxReadAheadLen>>1)) ||

		(iReadAheadPos >= iSize64))

		{

		return;

		}

	// double the read-ahead length - unless this is the first

	if (!resetting)

		iReadAheadLen<<= 1;

	// ensure read ahead len not greater than the free space available in buffer

	iReadAheadLen = Min(iReadAheadLen, bytesNotBuffered);

	// round up to a segment size

	iReadAheadLen = (iReadAheadLen + segmentSize - 1) & (TInt) segmentSizeMask;

#if defined (_DEBUG_READ_AHEAD)

	TInt64 oldReadAheadPos = iReadAheadPos;

#endif

	DoReadAhead(aMsgRequest, aMode);

//	RDebug::Print(_L("Buffered: old %d new %d"), bytesBuffered, (iReadAheadPos == 0)?bytesBuffered:iReadAheadPos - iLastReadPos);

#if defined (_DEBUG_READ_AHEAD)

RDebug::Print(_L("Buffered: old %d new %d iLastReadPos %d ReadAheadPos old %d new %d iReadAheadLen %d"), 

	bytesBuffered, 

	(TInt) ((iReadAheadPos == 0)?bytesBuffered:iReadAheadPos - iLastReadPos),

	I64LOW(iLastReadPos),

	I64LOW(oldReadAheadPos),

	I64LOW(iReadAheadPos),

	iReadAheadLen);

#endif	// (_DEBUG_READ_AHEAD)

	return;

	}

void CFileCache::DoReadAhead(CFsMessageRequest& aMsgRequest, TUint aMode)

	{

	if (iCacheClient->FindSegment(iReadAheadPos) != NULL)

		{

		// if read ahead pos is already cached, then synchronous reads have caught up,

		// so reset read ahead pos.

#if defined (_DEBUG_READ_AHEAD)

		RDebug::Print(_L("ReadAhead: pos %d already cached"), I64LOW(iReadAheadPos));

#endif

		iReadAheadPos = 0;

		return;

		}

	CFsClientMessageRequest* newRequest = NULL;

	TInt r = AllocateRequest(newRequest, EFalse, aMsgRequest.Session());

	if (r != KErrNone)

		return;

	r = newRequest->PushOperation(

		iReadAheadPos, 

		iReadAheadLen,

		(TUint8*) NULL, 

		0,						// aOffset 

		NULL);					// aCallback

	if (r != KErrNone)

		{

		newRequest->Free();

		newRequest = NULL;

		return;

		}

	__CACHE_PRINT2(_L("TFsFileRead: ReadAhead pos %ld len %d"), newRequest->CurrentOperation().iReadWriteArgs.iPos, newRequest->CurrentOperation().iReadWriteArgs.iTotalLength);

//	RDebug::Print(_L("ReadH:\tpos %d\tlen %d"), I64LOW(newRequest->CurrentOperation().iReadWriteArgs.iPos), newRequest->CurrentOperation().iReadWriteArgs.iTotalLength);

	r = ReadBuffered(*newRequest, aMode);

	if (r != CFsRequest::EReqActionContinue)

		{

		// if read ahead pos is already cached, then synchronous reads have caught up,

		// so reset read ahead pos.

		if (r == CFsRequest::EReqActionComplete)

			{

#if defined (_DEBUG_READ_AHEAD)

			RDebug::Print(_L("ReadAhead pos %d ALREADY DONE !!!"), I64LOW(iReadAheadPos));

#endif

			iReadAheadPos = 0;

			}

		newRequest->PopOperation();

		newRequest->Free();

		newRequest = NULL;

		return;

		}

	iReadAheadPos = iReadAheadPos + iReadAheadLen;

	iReadAheadRequest = newRequest;

#if defined (_DEBUG_READ_AHEAD)

	RDebug::Print(_L("Dispatching ReadAhead with %s priority"), iFileCacheReadAsync?_S16("HIGH"):_S16("LOW"));

#endif

	// If if media driver reads are synchronous (i.e. not interrupt driven) dispatch read-ahead 

	// with low priority  so that it doesn't prevent client thread from running

	newRequest->Dispatch(

		EFalse,					// don't init

		iFileCacheReadAsync?(TBool)EFalse:(TBool)ETrue, 

		EFalse);				// dispatch to back

	}

TInt CFileCache::CompleteRead(CFsRequest* aRequest)

	{

	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

	__ASSERT_DEBUG(msgRequest.CurrentOperationPtr() != NULL, Fault(ECacheBadOperationIndex));

	CFileShare* share;

	CFileCB* file;

	GetFileFromScratch(aRequest, share, file);

	CFileCache* fileCache = file->FileCache();

	__ASSERT_DEBUG(fileCache != NULL, Fault(ENoFileCache));

#ifdef _DEBUG

	TInt cancelling = (msgRequest.LastError() == KErrCancel)?(TBool)ETrue:(TBool)EFalse;

#endif

	TUint mode = share?share->iMode : EFileReadBuffered;

	TInt r = fileCache->ReadBuffered(msgRequest, mode);

	// if this request has been cancelled we mustn't dispatch it again - 

	// we still need to call state machine however so that any locked segments can be unlocked

	TInt lastError = msgRequest.LastError();

#ifdef _DEBUG

	__ASSERT_DEBUG(!cancelling || msgRequest.LastError() == KErrCancel, Fault(ERequestUncancelled));

#endif

	if (lastError == KErrCancel)

		r = CFsRequest::EReqActionComplete;

	return r;

	}

/**

ReadBuffered - attempts to read from cache. 

Called from TFsFileRead::Initialise() and CFileCache::CompleteRead()

@return CFsRequest::EReqActionComplete if request entirely satisfied

		CFsRequest::EReqActionContinue if request not yet complete. 

			Results in transition from :

				TFsFileRead::PostInitialise() to TFsFileRead::DoRequestL() or

				CFileCache::CompleteRead() to TFsFileRead::DoRequestL()

		CFsRequest::EReqActionBusy if filecache is "busy"

*/

TInt CFileCache::ReadBuffered(CFsMessageRequest& aMsgRequest, TUint aMode)

	{

	iLock.Wait();

	CFsClientMessageRequest* newRequest = NULL;

	__CACHE_PRINT2(_L("CFileCache::ReadBuffered()  pos %d, len %d"), I64LOW(aMsgRequest.CurrentOperation().iReadWriteArgs.iPos), aMsgRequest.CurrentOperation().iReadWriteArgs.iTotalLength);

	TInt r = DoReadBuffered(aMsgRequest, aMode, newRequest);

	iLock.Signal();

	if (newRequest)

		newRequest->Dispatch();

	return r;

	}

void CFileCache::UpdateSharePosition(CFsMessageRequest& aMsgRequest, TMsgOperation& aCurrentOperation)

	{

	// update the file share's position if this request came from client

	if (aCurrentOperation.iClientRequest)

		{

		CFileShare* share = (CFileShare*)aMsgRequest.ScratchValue();

		if (aMsgRequest.LastError() == KErrNone)

			{

			__e32_atomic_store_ord64(&share->iPos, aCurrentOperation.iReadWriteArgs.iPos);

			}

		}

	}

TInt CFileCache::DoReadBuffered(CFsMessageRequest& aMsgRequest, TUint aMode, CFsClientMessageRequest*& aNewRequest)

	{

	enum states

		{

		EStBegin=0,

		EStReadFromCache,

		EStReadFromDiskComplete,

		EStCopyToClient,

		EStReStart,

		EStEnd

		};

	TInt retCode = CFsRequest::EReqActionComplete;

	TInt& lastError = aMsgRequest.LastError();

	TBool driveThread = IsDriveThread();

	// temp storage for transition between EStReadFromCache / EStReadFromDiskComplete and EStCopyToClient

	TInt readLen = 0;

	TUint8* addr = NULL;

	TInt64 segmentStartPos = 0;

	TInt segmentSize = SegmentSize();

	TInt segmentSizeLog2 = SegmentSizeLog2();

	TInt64 segmentSizeMask = SegmentSizeMask();

	for(;;)

		{

		TMsgOperation* currentOperation = &aMsgRequest.CurrentOperation();

		TInt64& currentPos = currentOperation->iReadWriteArgs.iPos;

		TInt& totalLen = currentOperation->iReadWriteArgs.iTotalLength;

		TInt& currentOffset = currentOperation->iReadWriteArgs.iOffset;

		TBool readAhead = (currentOperation->iReadWriteArgs.iData == NULL)?(TBool)ETrue:(TBool)EFalse;

		switch(currentOperation->iState)

			{

			case EStBegin:

				// if EFileReadDirectIO, flush write cache and read direct from  disk

				if (!(aMode & EFileReadBuffered))

					{

					iLock.Signal();

					TInt r = FlushDirty(&aMsgRequest);

					iLock.Wait();

					if (r == CFsRequest::EReqActionBusy)

						return CFsRequest::EReqActionBusy;

					return CFsRequest::EReqActionContinue;	// read uncached

					}

				if (currentPos > iSize64)

					currentPos = iSize64;

				currentOperation->iState = EStReadFromCache;

				// count the number of sequential reads for read-ahead

				if (currentOperation->iClientRequest)

					{

					if (currentPos == iLastReadPos)

						{

						iSequentialReads++;

						}

					else

						{

						iSequentialReads = 0;

						ResetReadAhead();

						}

					iLastReadPos = currentPos + totalLen;

					iLastReadLen = totalLen;

					}

				// fall into...

			case EStReadFromCache:

				{

				// reading past end of file ?

				if (currentPos + totalLen > iSize64)

					totalLen = (TInt) (iSize64 - currentPos);

				if (totalLen == 0 || lastError != KErrNone)

					{

					currentOperation->iState = EStEnd;

					break;

					}

				segmentStartPos = currentPos & segmentSizeMask;

				TInt64 endPos = currentPos + totalLen;

				TUint maxLenToRead = (TUint)Min((TInt64)(iCacheClient->CacheLineSize()), (endPos - segmentStartPos));

				TInt maxSegments = (maxLenToRead + segmentSize - 1) >> segmentSizeLog2;

				TInt segmentCount = maxSegments;

				TInt filledSegmentCount;

				TInt lockError;

				addr = iCacheClient->FindAndLockSegments(segmentStartPos, segmentCount, filledSegmentCount, lockError, EFalse);

#if defined (_DEBUG_READ_AHEAD)

				if (addr && readAhead)

					RDebug::Print(_L("READAHEAD CACHELINE ALREADY EXISTS POS %d"), I64LOW(segmentStartPos));

#endif

				// if cacheline contains filled and empty segments, deal with these seperately

				// to simplify the code.....

				if (filledSegmentCount > 0 && segmentCount > filledSegmentCount)

					{

					segmentCount = Min(segmentCount, filledSegmentCount);

					}

				if (lockError == KErrInUse)

					{

					// cacheline in use (by other thread):

					// if this is a read-ahead, abandon it

					// otherwise re-post the request

					if (readAhead)

						{

						totalLen = 0;

						retCode = CFsRequest::EReqActionComplete;

						currentOperation->iState = EStEnd;

						}

					else

						{

#if defined (_DEBUG_READ_AHEAD)

						RDebug::Print(_L("READC CACHELINE BUSY POS %d"), I64LOW(segmentStartPos));

#endif

						return CFsRequest::EReqActionBusy;

						}

					break;

					}

				// if not found, try to allocate as many contiguous segments 

				// as possible so that the number of reads issued to the media 

				// driver is kept to a minumum

				if (addr == NULL)	// not found ?

					{

					// if read len > size of the cache, don't read excess 

					// through the cache as this is wasteful

					if (totalLen > iCacheSize)

						{

						TInt len = totalLen - iCacheSize;

						TInt r = aMsgRequest.PushOperation(

							currentPos, len, 

							(TDesC8*) currentOperation->iReadWriteArgs.iData, currentOffset,

							CompleteRead, 

							EStReadFromCache);

						if (r != KErrNone)

							{

							currentOperation->iState = EStReStart;

							break;

							}

						currentOffset+= len;

						currentPos+= len;

						totalLen-= len;

						return CFsRequest::EReqActionContinue;

						}

					// if position not cached postpone Initialise() to drive thread

					// as there may be a read ahead already in the queue

					if (!driveThread && !readAhead)

						{

#if defined (_DEBUG_READ_AHEAD)

						RDebug::Print(_L("*** POSTING READ TO DRIVE THREAD POS %d ***"), I64LOW(segmentStartPos));

#endif

						return CFsRequest::EReqActionBusy;

						}

					segmentCount = maxSegments;

					addr = iCacheClient->AllocateAndLockSegments(segmentStartPos, segmentCount, EFalse, !readAhead);

					if (addr == NULL)

						{

						__CACHE_PRINT(_L("AllocateSegment failed"));

						currentOperation->iState = EStReStart;

						break;

						}

					}

				readLen = segmentCount << segmentSizeLog2;

				__ASSERT_DEBUG(iSize64 > segmentStartPos, Fault(EPosBeyondSize));

				readLen = (TInt)Min((TInt64)readLen, (iSize64 - segmentStartPos));

				if (iCacheClient->SegmentEmpty(segmentStartPos))

					{

					// store readLen & addr in scratch area

					currentOperation->iScratchValue0 = addr;						

					currentOperation->iScratchValue1 = (TAny*) readLen;						

					// read into cache segment(s)

					__CACHE_PRINT2(_L("CACHEFILE: read pos %ld, readLen %d"), segmentStartPos, readLen);

					TInt r = aMsgRequest.PushOperation(

						segmentStartPos, readLen, addr, 0,

						CompleteRead, 

						EStReadFromDiskComplete);

					if (r != KErrNone)

						{

						iCacheClient->UnlockSegments(segmentStartPos);

						currentOperation->iState = EStReStart;

						break;

						}

					return CFsRequest::EReqActionContinue;

					}

				else

					{

					currentOperation->iState = EStCopyToClient;

					}

				}

				// fall into ...

			case EStCopyToClient:

				{

				TInt segmentsLocked = (readLen + segmentSize - 1) >> segmentSizeLog2;

				if (lastError == KErrNone)

					{

					// copy to user buffer

					TInt offset = iCacheClient->CacheOffset(currentPos);	// offset into segment

					TInt len = Min(readLen - offset, totalLen);

					// if addr is NULL then this is a read ahead request

					if (currentOperation->iReadWriteArgs.iData != NULL)

						{

						if (currentOperation->iClientRequest)

							{

							__ASSERT_DEBUG (aMsgRequest.Message().Handle() != NULL, Fault(EMsgAlreadyCompleted));

							TPtrC8 ptr(addr+offset, len);

							lastError = aMsgRequest.Write(0, ptr, currentOffset);

							}

						else

							{

							memcpy(((TUint8*) currentOperation->iReadWriteArgs.iData) + currentOffset, addr+offset, len);

							}

						}

					else

						{

						iReadAheadRequest = NULL;

						}

					currentOffset+= len;

					currentPos+= len;

					totalLen-= len;

					}

				if (lastError == KErrNone)

					iCacheClient->MarkSegmentsAsFilled(segmentStartPos, segmentsLocked);

				iCacheClient->UnlockSegments(segmentStartPos);

				if (lastError != KErrNone)

					{

					retCode = CFsRequest::EReqActionComplete;

					currentOperation->iState = EStEnd;

					break;

					}

				if (totalLen > 0 && lastError == KErrNone)

					{

					currentOperation->iState = EStReadFromCache;

					break;

					}

				currentOperation->iState = EStEnd;

				}

			// fall into ...

			case EStEnd:

				// update the file share's position if this request came from client

				UpdateSharePosition(aMsgRequest, *currentOperation);

				return retCode;

			case EStReadFromDiskComplete:

				{

				// restore readLen etc from scratch area

				segmentStartPos = currentPos & segmentSizeMask;

				addr = (TUint8*) currentOperation->iScratchValue0;

				readLen = (TInt) currentOperation->iScratchValue1;

				aMsgRequest.CurrentOperation().iState = EStCopyToClient;

				}

				break;

			case EStReStart:

				// ignore the failure if this is a read-ahead

				if (readAhead)

					{

					totalLen = 0;

					retCode = CFsRequest::EReqActionComplete;

					currentOperation->iState = EStEnd;

					break;

					}

				// 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);

					if (r == CFsRequest::EReqActionBusy || r != CFsRequest::EReqActionComplete)

						return r;

					}

				retCode = CFsRequest::EReqActionContinue;	// read uncached

				currentOperation->iState = EStEnd;