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

equal deleted inserted replaced

-:741dcdf88ba9
+:c4d65d91ad0c
 @param	aOwnerCache	pointer of the cache that owns this page
 @param	aStartMedPos	the start address on the media that this page caches
 @param	aStartRamAddr	the start address in the ram that this page content lives
 */
 TDynamicDirCachePage::TDynamicDirCachePage(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr)
 :iStartMedPos(aStartMedPos),
 iStartRamAddr(aStartRamAddr),
 iOwnerCache(aOwnerCache),
 iValid(EFalse),
 iLocked(EFalse)
 	{
 	//__PRINT3(_L("TDynamicDirCachePage::TDynamicDirCachePage(aStartMedPos=%lx, aStartRamAddr=0x%X, aPageSize=%u)"), aStartMedPos, aStartRamAddr, PageSizeInBytes());
 	iType = EUnknown;
 	}
 /**
 Constructor of CDynamicDirCache.
 @param	aDrive	local drive interface to read/write media
 @param	aMinPageNum	the minimum page number for the cache, includes iActive page and locked pages.
 @param	aMaxPageNum	the maximum page number for the cache, includes iActive page, locked pages and unlocked pages.
-@param	aPageSizeInBytesLog2	the log2 value of page size in bytes, assumes page size is always a power of two
+@param	aPageSizeInBytesLog2	Log2 of the page size in bytes, this is the cache read granularity
-*/
+@param  aWrGranularityLog2      Log2(cache write granularity)
-CDynamicDirCache::CDynamicDirCache(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeInBytesLog2)
+*/
-:iPageSizeLog2(aPageSizeInBytesLog2),
+CDynamicDirCache::CDynamicDirCache(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeInBytesLog2, TUint32 aWrGranularityLog2)
-iMinSizeInPages(aMinPageNum),
+:iPageSizeLog2(aPageSizeInBytesLog2),
-iMaxSizeInPages(aMaxPageNum),
+iWrGranularityLog2(aWrGranularityLog2),
-iDrive(aDrive),
+iMinSizeInPages(aMinPageNum),
-iLockedQ(_FOFF(TDynamicDirCachePage, iLink)),
+iMaxSizeInPages(aMaxPageNum),
-iUnlockedQ(_FOFF(TDynamicDirCachePage, iLink)),
+iDrive(aDrive),
-iLockedQCount(0),
+iLockedQ(_FOFF(TDynamicDirCachePage, iLink)),
-iUnlockedQCount(0),
+iUnlockedQ(_FOFF(TDynamicDirCachePage, iLink)),
-iHashFunction(HashFunction),
+iLockedQCount(0),
-iIdentityFunction(IdentityFunction),
+iUnlockedQCount(0),
-iLookupTable(iHashFunction, iIdentityFunction)
+iHashFunction(HashFunction),
+iIdentityFunction(IdentityFunction),
+iLookupTable(iHashFunction, iIdentityFunction)
 	{
 	iPageSizeInBytes = 1 << aPageSizeInBytesLog2;
 	iCacheDisabled = EFalse;
 iMinCacheSizeInBytes = aMinPageNum << aPageSizeInBytesLog2;
 iMaxCacheSizeInBytes = aMaxPageNum << aPageSizeInBytesLog2;
 	}
 /**
 Static factory function of CDynamicDirCache
 */
-CDynamicDirCache* CDynamicDirCache::NewL(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, const TDesC& aClientName)
+CDynamicDirCache* CDynamicDirCache::NewL(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, TUint32 aWrGranularityLog2, const TDesC& aClientName)
 {
 __PRINT3(_L("CDynamicDirCache::NewL(MinPageNum=%u, MaxPageNum=%u, page=%u)"), aMinPageNum, aMaxPageNum, 1<<aPageSizeLog2);
-CDynamicDirCache* pSelf = new (ELeave) CDynamicDirCache(aDrive, aMinPageNum, aMaxPageNum, aPageSizeLog2);
+CDynamicDirCache* pSelf = new (ELeave) CDynamicDirCache(aDrive, aMinPageNum, aMaxPageNum, aPageSizeLog2, aWrGranularityLog2);
 CleanupStack::PushL(pSelf);
 pSelf->ConstructL(aClientName);
 CleanupStack::Pop();
 return pSelf;
 }
 @param	aPos	the starting position of the media address to be write.
 @param	aData	the starting address that the writing content lives in the ram.
 @param	aDataLen	the length of the content to be written.
 @pre	aDataLen	should be no more than page size.
 */
-void CDynamicDirCache::WriteDataOntoSinglePageL(TInt64 aPos, const TUint8* aData, TUint32 aDataLen)
+TDynamicDirCachePage* CDynamicDirCache::WriteDataOntoSinglePageL(TInt64 aPos, const TUint8* aData, TUint32 aDataLen)
 	{
 	ASSERT(aDataLen <= iPageSizeInBytes);
 //-- the data section is in the cache page entirely, take data directly from the cache
 	TDynamicDirCachePage* pPage = FindPageByPos(aPos);
 if (pPage)
 		UnlockPage(pPage);
 		}
 	// always make writting events MRU
 	DoMakePageMRU(aPos);
-return;
+return pPage;
 	}
 /**
 Implementation of pure virtual function.
 @see	MWTCacheInterface::WriteL()
 TUint32 bytesToPageEnd = (TUint32)(pageStartMedPos + PageSz - aPos);
 //    __PRINT5(_L("CDynamicDirCache::WriteL: aPos=%lx, aLength=%x, page:%lx, pageSz:%x, bytesToPageEnd=%x"), aPos, dataLen, pageStartMedPos, PageSz, bytesToPageEnd);
 if(dataLen <= bytesToPageEnd)
-{
+{//-- make small write a multiple of a write granularity size (if it is used at all)
-WriteDataOntoSinglePageL(aPos, pData, dataLen);
+//-- this is not the best way to use write granularity, but we would need to refactor cache pages code to make it normal
+TDynamicDirCachePage* pPage = WriteDataOntoSinglePageL(aPos, pData, dataLen);
+TPtrC8 desBlock(aDes);
+if(iWrGranularityLog2)
+{//-- write granularity is used
+const TInt64  newPos = (aPos >> iWrGranularityLog2)  << iWrGranularityLog2; //-- round position down to the granularity unit size
+TUint32 newLen = (TUint32)(aPos - newPos)+dataLen;
+newLen = RoundUp(newLen, iWrGranularityLog2);
+const TUint8* pd = pPage->PtrInPage(newPos);
+desBlock.Set(pd, newLen);
+aPos = newPos;
+}
+//-- write data to the media
+const TInt nErr = iDrive.WriteCritical(aPos, desBlock);
+if(nErr != KErrNone)
+{//-- some serious problem occured during writing, invalidate cache.
+InvalidateCache();
+User::Leave(nErr);
+}
 }
 else
-{
+{//-- Data to be written cross cache page boundary or probably we have more than 1 page to write
+//-- this is a very rare case.
 __PRINT(_L("CDynamicDirCache::WriteL() CROSS PAGE!"));
 //-- Data to be written cross cache page boundary or probably we have more than 1 page to write
 TInt64  currMediaPos(aPos);
 //-- 3. write the rest of the data
 if(dataLen > 0)
 {
 WriteDataOntoSinglePageL(currMediaPos, pData, dataLen);
 }
-}// else(dataLen <= bytesToPageEnd)
 //-- write data to the media
 const TInt nErr = iDrive.WriteCritical(aPos,aDes);
 if(nErr != KErrNone)
 {//-- some serious problem occured during writing, invalidate cache.
 InvalidateCache();
 User::Leave(nErr);
 }
+}// else(dataLen <= bytesToPageEnd)
 	}
 /**
 Invalidate the cache
 @see	MWTCacheInterface::InvalidateCache()
 /**
 Implementation of pure virtual function.
 @see	MWTCacheInterface::PosCached()
 */
-TUint32 CDynamicDirCache::PosCached(const TInt64& aPos, TInt64& aCachedPosStart)
+TUint32 CDynamicDirCache::PosCached(TInt64 aPos)
 	{
 	const TInt64 pageStartMedPos = CalcPageStartPos(aPos);
 	// only search the page in lookup table
 	// NOTE: we don't count the active page into acount here,
 		if (LockPage(pPage) != NULL)
 			{
 //			__PRINT1(_L("CDynamicDirCache::PosCached: page(0x%lx) found on Unlocked Queue!"), aPos);
 			// have to unlock it before returning, otherwise there will be memory leak
 			UnlockPage(pPage);
-	    aCachedPosStart = pPage->StartPos();
 			return pPage->PageSizeInBytes();
 			}
 		else	// if the unlocked page is not valid anymore, remove it
 			{
 		DeQueue(pPage);
 		}
 	// otherwise if page is already locked or valid active page
 	else if (pPage)
 		{
 		__PRINT1(_L("CDynamicDirCache::PosCached: page(0x%lx) on Locked Queue!"), aPos);
-	    aCachedPosStart = pPage->StartPos();
 		return pPage->PageSizeInBytes();
 		}
 	// page is not found or not valid anymore
 	return 0;

branch	CompilerCompatibility
changeset 77	c4d65d91ad0c
parent 62	4a8fed1c0ef6
child 80	597aaf25e343