// 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_cache_man.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_cache_man.h"

#include "sf_cache_client.h"

#include "sf_file_cache.h"

#include "sf_file_cache_defs.h"

//#undef __SIMULATE_LOCK_FAILURES__

//#define __RAMDOM_LOCK_FAILURES__

//#define __PSEUDO_RANDOM_FAILURES__		

//#define __LOCK_ENTIRE_CACHELINE__

#ifdef __RAMDOM_LOCK_FAILURES__	

#include <e32math.h>

#endif

#define CACHE_NUM_TO_ADDR(n) (iBase + (n << iCacheLineSizeLog2))

#define ADDR_TO_CACHELINE_ADDR(a) ((((a - iBase) >> iCacheLineSizeLog2) << iCacheLineSizeLog2) + iBase)

#define ADDR_TO_INDEX(a) ((a - iBase) >> iCacheLineSizeLog2)

#if defined(_DEBUG)

	#define __CACHELINE_INVARIANT(aCacheLine)						\

	__ASSERT_DEBUG(												\

		aCacheLine.iDirtySegments <= aCacheLine.iFilledSegments &&	\

		aCacheLine.iFilledSegments <= aCacheLine.iAllocatedSegments,	\

		Fault(EInvalidCacheLine));

#else

	#define __CACHELINE_INVARIANT(aCacheLine)

#endif

const TInt KSegmentSize = 4096;

const TInt KSegmentSizeLog2 = 12;

const TInt64 KSegmentSizeMask = MAKE_TINT64(0x7FFFFFFF,0xFFFFF000);

const TInt KCacheLineSizeLog2 = 17;	// 128K

const TInt KCacheLineSize = (1 << KCacheLineSizeLog2 );

const TInt KCacheLineSizeInSegments = (KCacheLineSize >> KSegmentSizeLog2);

CCacheManager* CCacheManagerFactory::iCacheManager = NULL;

LOCAL_C void Fault(TCacheManagerFault aFault)

//

// Report a fault in the cache manager

//

	{

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

	}

/*

Indicates if a number passed in is a power of two

@param aNum number to be tested

@return Flag to indicate the result of the test

*/

LOCAL_C TBool IsPowerOfTwo(TInt aNum)

	{

	return (aNum != 0 && (aNum & -aNum) == aNum);

	}

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

// CCacheManagerFactory

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

void CCacheManagerFactory::CreateL()

	{

	__ASSERT_ALWAYS(iCacheManager == NULL, Fault(ECacheAlreadyCreated));

	if (TGlobalFileCacheSettings::Enabled())

		{

		iCacheManager = CCacheManager::NewCacheL(TGlobalFileCacheSettings::CacheSize());

		}

	else

		{

		Destroy(); 

		}

	}

CCacheManager* CCacheManagerFactory::CacheManager()

	{

	return iCacheManager;

	}

TInt CCacheManagerFactory::Destroy()

	{

	delete iCacheManager;

	iCacheManager = NULL;

	return KErrNone;

	}

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

// CCacheManager

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

CCacheManager* CCacheManager::NewCacheL(TInt aCacheSize)

	{

	CCacheManager* cacheManager = new (ELeave) CCacheManager(aCacheSize);

	CleanupStack::PushL(cacheManager);

	cacheManager->ConstructL();

	CleanupStack::Pop(1, cacheManager);

	return cacheManager;

	}

CCacheManager::~CCacheManager()

	{

	CacheLock();

	iFreeQueue.Close();

	iUsedQueue.Close();

	delete [] iCacheLines;

	CacheUnlock();

	iLock.Close();

	iChunk.Close();

	}

CCacheManager::CCacheManager(TUint aCacheSize)

	{

	// Get the page size

	TInt pageSize;

	TInt r = HAL::Get(HAL::EMemoryPageSize, pageSize);

	if (r != KErrNone)

		pageSize = KSegmentSize;

	__ASSERT_ALWAYS(IsPowerOfTwo(pageSize), Fault(EIllegalPageSize));

	// For the time being we only a support page size of 4K and we assume

	// that page size = segment size, since the extra overhead of supporting 

	// variable page sizes now is non-trivial.

	//

	// If a processor with a different page size needs to be supported 

	// in the future, then we need to either rework this code to be able to

	// devide up pages into smaller segments or analyze the impact of having 

	// a different page size on performance.

	__ASSERT_ALWAYS(pageSize == KSegmentSize, Fault(EIllegalPageSize));

	iCacheLineSize = KCacheLineSize;

	iCacheLineSizeLog2 = KCacheLineSizeLog2;

	iCacheSize = aCacheSize;

	iSegmentsPerCacheLine = 1 << (iCacheLineSizeLog2 - KSegmentSizeLog2);

	iMaxLockedSegments = TGlobalFileCacheSettings::MaxLockedSize() >> KSegmentSizeLog2;

#ifdef __SIMULATE_LOCK_FAILURES__

	iSimulateLockFailureMode = EFalse;	// off by default unless switched on by KControlIoSimulateLockFailureMode

#endif

	}

void CCacheManager::ConstructL()

	{

	// calculate the low-memory threshold below which we fail any attempt to allocate memory

	TMemoryInfoV1Buf meminfo;

	TInt r = UserHal::MemoryInfo(meminfo);

	__ASSERT_ALWAYS(r==KErrNone,Fault(EMemoryInfoFailed));

	iLowMemoryThreshold = (meminfo().iTotalRamInBytes * TGlobalFileCacheSettings::LowMemoryThreshold()) / 100;

	__CACHE_PRINT4(_L("CACHEMAN: totalRAM %d freeRAM %d KDefaultLowMemoryThresholdPercent %d iLowMemoryThreshold %d"), 

		meminfo().iTotalRamInBytes, meminfo().iFreeRamInBytes, KDefaultLowMemoryThreshold, iLowMemoryThreshold);

	__CACHE_PRINT1(_L("CACHEMAN: iCacheSize %d"), iCacheSize);

	TChunkCreateInfo createInfo;

	createInfo.SetCache(iCacheSize);

	createInfo.SetOwner(EOwnerProcess);

	r = iChunk.Create(createInfo);

	User::LeaveIfError(r);

	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;

	if (mm < EMemModelTypeFlexible)

		{

		// On memory models before flexible, File System has to register chunks that will be DMA-ed.

		// On flexible memory model, local media is using new physical pinning Kernel interface that

		// doesn't require registration of the chunk.

		UserSvr::RegisterTrustedChunk(iChunk.Handle());

		}

	__ASSERT_ALWAYS(iCacheSize > KSegmentSize, Fault(EIllegalCacheSize));

	r = iLock.CreateLocal();

	User::LeaveIfError(r);

	iNumOfCacheLines = iCacheSize >> iCacheLineSizeLog2;

	iBase = Base();

	iCacheLines = new (ELeave) TCacheLine[iNumOfCacheLines];

	for (TInt n=0; n<iNumOfCacheLines; n++)

		{

		// coverity[var_decl]

		TCacheLine cacheLine;

		cacheLine.iAddr = CACHE_NUM_TO_ADDR(n);

		cacheLine.iAllocatedSegments = 0;

		cacheLine.iFilledSegments = 0;

		cacheLine.iDirtySegments = 0;

		cacheLine.iLockCount = 0;

		cacheLine.iLockedSegmentStart = 0;

		cacheLine.iLockedSegmentCount = 0;

		cacheLine.iClient = NULL;

		// coverity[uninit_use]

		iCacheLines[n] = cacheLine;

		r = iFreeQueue.Append(&iCacheLines[n]);

		User::LeaveIfError(r);

		}

	}

CCacheClient* CCacheManager::CreateClientL()

	{

	CCacheClient* client = CCacheClient::NewL(*this);

	return client;

	}

void CCacheManager::RegisterClient(CCacheClient& /*aClient*/)

	{

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	iStats.iFileCount++;

#endif

	}

void CCacheManager::DeregisterClient(CCacheClient& /*aClient*/)

	{

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	iStats.iFileCount--;

#endif

	}

void CCacheManager::FreeMemoryChanged(TBool aMemoryLow)

	{

	iMemoryLow = aMemoryLow;

	}

TBool CCacheManager::TooManyLockedSegments()

	{

	return (iLockedSegmentCount >= iMaxLockedSegments)?(TBool)ETrue:(TBool)EFalse;

	}

TInt CCacheManager::SegmentSize()

	{

	return KSegmentSize;

	}

TInt CCacheManager::SegmentSizeLog2()

	{

	return KSegmentSizeLog2;

	}

TInt64 CCacheManager::SegmentSizeMask()

	{

	return KSegmentSizeMask;

	}

TInt CCacheManager::CacheLineSize()

	{

	return KCacheLineSize;

	}

TInt CCacheManager::CacheLineSizeInSegments()

	{

	return KCacheLineSizeInSegments;

	}

TInt CCacheManager::CacheLineSizeLog2()

	{

	return KCacheLineSizeLog2;

	}

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

TFileCacheStats& CCacheManager::Stats()

	{

	iStats.iFreeCount = iFreeQueue.Count();

	iStats.iUsedCount = iUsedQueue.Count();

	iStats.iLockedSegmentCount = iLockedSegmentCount;

	iStats.iFilesOnClosedQueue = TClosedFileUtils::Count();

	__ASSERT_DEBUG(iStats.iFreeCount >= 0, Fault(EInvalidStats));

	__ASSERT_DEBUG(iStats.iUsedCount >= 0, Fault(EInvalidStats));

	__ASSERT_DEBUG(iStats.iLockedSegmentCount >= 0, Fault(EInvalidStats));

	__ASSERT_DEBUG(iStats.iFilesOnClosedQueue >= 0, Fault(EInvalidStats));

	return iStats;

	}

#endif	// #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

void CCacheManager::CacheLock()

	{

	iLock.Wait();

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	iManagerLocked = ETrue;

#endif

	}

void CCacheManager::CacheUnlock()

	{

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	iManagerLocked = EFalse;

#endif

	iLock.Signal();

	}

TInt CCacheManager::AllocateAndLockCacheLine(CCacheClient* aClient, TInt64 aPos, const TCacheLine*& aCacheLine, TInt aSegmentCount)

	{

	__ASSERT_DEBUG(aSegmentCount <= iSegmentsPerCacheLine, Fault(EInvalidAllocCount));

	// check for low system memory

	TMemoryInfoV1Buf meminfo;

	TInt r = UserHal::MemoryInfo(meminfo);

	__ASSERT_ALWAYS(r==KErrNone,Fault(EMemoryInfoFailed));

	if (iMemoryLow || (meminfo().iFreeRamInBytes < iLowMemoryThreshold))

		{

		__CACHE_PRINT(_L("CACHEMAN: free RAM below threshold !!!"));

		return KErrNoMemory;

		}

	CacheLock();

	__CACHE_PRINT1(_L("CACHEMAN: Allocate %d segments, Lock %d"), aSegmentCount);

	__CACHE_PRINT2(_L("CACHEMAN: iFreeQueue %d iUsedQueue %d"), iFreeQueue.Count(), iUsedQueue.Count());

#ifdef  __SIMULATE_LOCK_FAILURES__

	if (SimulatedFailure(iAllocFailureCount))

		{

		__CACHE_PRINT(_L("CACHEMAN: simulating allocation failure"));

		CacheUnlock();

		return KErrNoMemory;

		}

#endif

	// any cachelines free ?

	TInt freeCacheLines = iFreeQueue.Count();

	TCacheLine* cacheLine = NULL;

	if (freeCacheLines == 0 && !StealCacheLine(aClient))

		{

		CacheUnlock();

		return KErrNotFound;

		}

	cacheLine = iFreeQueue[0];

	__CACHELINE_INVARIANT((*cacheLine));

	__ASSERT_DEBUG( cacheLine->iAllocatedSegments == 0, Fault(EInvalidAllocCount));

	__ASSERT_DEBUG( cacheLine->iFilledSegments == 0, Fault(EInvalidFillCount));

	__ASSERT_DEBUG( cacheLine->iDirtySegments == 0, Fault(EInvalidFillCount));

	__ASSERT_DEBUG( cacheLine->iLockCount == 0, Fault(EInvalidLockCount));

	__ASSERT_DEBUG( cacheLine->iLockedSegmentStart == 0, Fault(EInvalidLockedPageStart));

	__ASSERT_DEBUG( cacheLine->iLockedSegmentCount == 0, Fault(EInvalidLockedPageCount));

	__ASSERT_DEBUG( cacheLine->iClient == NULL, Fault(EInvalidClient));

	TUint8* addr = cacheLine->iAddr;

	// Commit it

	r = Commit(addr, aSegmentCount);

	if (r != KErrNone)

		{

		CacheUnlock();

		return r;

		}

	cacheLine->iAllocatedSegments = (TUint8) (aSegmentCount);

	cacheLine->iLockedSegmentStart = 0;

	cacheLine->iLockedSegmentCount = (TUint8) aSegmentCount;

	// Add to used queue

	r = iUsedQueue.InsertInAddressOrder(cacheLine);

	if (r != KErrNone)

		{

		Decommit(addr, aSegmentCount);

		CacheUnlock();

		return r;

		}

	cacheLine->iClient = aClient;

	cacheLine->iPos = aPos;

	// Remove from free queue

	iFreeQueue.Remove(0);

	// RChunk will lock segments initially unless explicitly unlocked

	cacheLine->iLockCount++;

	__CACHE_PRINT2(_L("CACHEMAN: LockCount for %08X is %d"), cacheLine->iAddr, cacheLine->iLockCount);

	CacheUnlock();

	aCacheLine = cacheLine;

	return r;

	}

/**

CCacheManager::ExtendCacheLine()

Attempts to extend the length of an existing cacheline by committing extra segments

The cacheline must be owned and locked already.

@param aCacheLine A reference to a locked, owned cacheline

@param aSegmentCount The new length of the cacheline (including the existing segments)

					 This must be greater then the existing length.

@return KErrNone if successful

		or other system wide error code.

*/

TInt CCacheManager::ExtendCacheLine(CCacheClient* aClient, const TCacheLine& aCacheLine, TInt aSegmentCount)

	{

	CacheLock();

	__ASSERT_DEBUG(aSegmentCount > 0, Fault(EInvalidSegmentCount));

	TCacheLine& cacheLine = const_cast<TCacheLine&>(aCacheLine);

	__CACHELINE_INVARIANT((cacheLine));

	__ASSERT_DEBUG(aSegmentCount <= iSegmentsPerCacheLine, Fault(EInvalidSegmentCount));

	__ASSERT_DEBUG(aSegmentCount > cacheLine.iAllocatedSegments, Fault(EInvalidSegmentCount));

	__ASSERT_DEBUG(cacheLine.iLockCount > 0, Fault(EInvalidLockCount));	// must be locked already

	__ASSERT_ALWAYS(cacheLine.iClient == aClient, Fault(EExtendingUnownedCacheline));

	// ensure all pages in cachline are locked

	__ASSERT_DEBUG(cacheLine.iLockedSegmentStart == 0, Fault(EInvalidLockRange));

	__ASSERT_DEBUG(cacheLine.iLockedSegmentCount == cacheLine.iAllocatedSegments, Fault(EInvalidLockRange));

	__CACHE_PRINT2(_L("CACHEMAN: ExtendCacheLine(%08X, %d)"), cacheLine.iAddr, aSegmentCount);

	// Commit the new segments

	TUint8* addrNewSegment = cacheLine.iAddr + (cacheLine.iAllocatedSegments << KSegmentSizeLog2);

	TInt segmentCountNew = aSegmentCount - cacheLine.iAllocatedSegments;

	TInt r = Commit(addrNewSegment, segmentCountNew);

	if (r == KErrNone)

		{

		cacheLine.iAllocatedSegments = cacheLine.iLockedSegmentCount = (TUint8) aSegmentCount;

		}

	CacheUnlock();

	return r;

	}

/**

CCacheManager::ReUseCacheLine()

Attempts to lock and then extend or shrink an already owned cacheline, ready for re-use.

If successful the cacheline is returned locked and all segments are marked as empty.

The cacheline must initially be unlocked.

@param aCacheLine A reference to an unlocked cacheline

@param aSegmentCount The new length of the cacheline;

					 this may be greater or less than the existing length.

@return KErrNone if successful

		or other system wide error code.

*/

TInt CCacheManager::ReAllocateAndLockCacheLine(CCacheClient* aClient, TInt64 aPos, const TCacheLine& aCacheLine, TInt aSegmentCount)

	{

	TCacheLine& cacheLine = const_cast<TCacheLine&>(aCacheLine);

	__CACHELINE_INVARIANT((cacheLine));

	__ASSERT_DEBUG(aSegmentCount > 0, Fault(EInvalidSegmentCount));

	__ASSERT_DEBUG(aSegmentCount <= iSegmentsPerCacheLine, Fault(EInvalidSegmentCount));

	__CACHE_PRINT2(_L("CACHEMAN: ReUseCacheLine(%08X, %d)"), cacheLine.iAddr, aSegmentCount);

	TInt r;

	// old cacheline same size or bigger ?

	if (cacheLine.iAllocatedSegments >= aSegmentCount)

		{

		r = LockCacheLine(aClient, aCacheLine, 0, aSegmentCount);

		if (r!= KErrNone)

			return r;

		if (cacheLine.iAllocatedSegments > aSegmentCount)

			{

			cacheLine.iFilledSegments = (TUint8) aSegmentCount;

			RemoveEmptySegments(aClient, aCacheLine);

			}

		}

	// old cacheline smaller

	else 

		{

		r = LockCacheLine(aClient, aCacheLine, 0, cacheLine.iAllocatedSegments);

		if (r != KErrNone)

			return r;

		r = ExtendCacheLine(aClient, aCacheLine, aSegmentCount);

		if (r != KErrNone)

			{

			UnlockCacheLine(aClient, aCacheLine);

			return r;

			}

		}

	cacheLine.iFilledSegments = 0;

	cacheLine.iPos = aPos;