// 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"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sf_file_cacheTraces.h"

#endif

// 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,

	ECacheSettingGetFailed,

	ECacheCodeFault,

	ECacheBadOperationIndex,

	ENoFileCache,

	EFileAlreadyClosed,

	EClosingDirtyFile,

	ECompletingWriteWithDataRemaining,

	EPosBeyondSize,

	EMsgAlreadyCompleted,

	EBadRetCode,

	EInternalError,

	ERequestUncancelled,

	ELockAlreadyOpen,

	EBadSegmentCount,

	EReNewingOpenCache,

	EClosingUnNamedFile,

	EFileNameAlreadyOwned,

	EClosedFileHasNoName,

	EReOpeningUnNamedFile,

	EStartingDirtyAWrongStage,

	EUnexpectedReNewLFailure,

	EDirtyDataOwnerNull,

	EFlushingWithSessionNull,

	EFlushingWithAllocatedRequest,

	};

LOCAL_C void Fault(TFileCacheFault aFault)

//

// Report a fault in the file cache

//

	{

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

	}

const TInt KMinSequentialReadsBeforeReadAhead = 3;

#ifdef DOUBLE_BUFFERED_WRITING

const TInt KMinSequentialAppendsBeforeFlush = 3;

#endif

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

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