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

equal deleted inserted replaced

-:5af6c74cd793
+:af6ec97d9189
 /**
 The static cache page creation function.
 Cache page objects are not supposed to be created on the stack, so this factory function is required.
 */
-TDynamicDirCachePage* TDynamicDirCachePage::NewL(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr)
+TDynamicDirCachePage* TDynamicDirCachePage::CreateCachePage(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr)
 	{
-	return new(ELeave) TDynamicDirCachePage(aOwnerCache, aStartMedPos, aStartRamAddr);
+	return new TDynamicDirCachePage(aOwnerCache, aStartMedPos, aStartRamAddr);
 	}
 /**
 Cache page constructor.
 @param	aOwnerCache	pointer of the cache that owns this page
 :iPageSizeLog2(aPageSizeInBytesLog2),
 iWrGranularityLog2(aWrGranularityLog2),
 iMinSizeInPages(aMinPageNum),
 iMaxSizeInPages(aMaxPageNum),
 iDrive(aDrive),
+				  iLastVisitedPage(NULL),
 iLockedQ(_FOFF(TDynamicDirCachePage, iLink)),
 iUnlockedQ(_FOFF(TDynamicDirCachePage, iLink)),
 iLockedQCount(0),
 iUnlockedQCount(0),
 iHashFunction(HashFunction),
 	// allocate as many permanently locked pages as there are threads - plus one
 	// otherwise DoMakePageMRU() won't work properly with only one thread
 //-- At present moment the size of TDrive thread pool is 1 (1 drive thread in a pool)
-	const TUint KThreadCount = 1;
+const TUint KThreadCount = 1;
-	iPermanentlyAllocatedPageCount = KThreadCount + 1;
+iPermanentlyAllocatedPageCount = KThreadCount;
 	if (iPermanentlyAllocatedPageCount > iMinSizeInPages)
 		iMinSizeInPages = iPermanentlyAllocatedPageCount;
 	for (TUint n=0; n<iPermanentlyAllocatedPageCount; n++)
 		{
-		TDynamicDirCachePage* pPage = AllocateAndLockNewPageL(0);
+TDynamicDirCachePage* pPage = AllocateAndLockNewPage();
+ASSERT(pPage);
+if (!pPage)
+User::Leave(KErrNoMemory);
 		AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);
 		LookupTblAdd(pPage);
 		}
 	}
 CleanupStack::Pop();
 return pSelf;
 }
 /**
-Insert an unlocked page into the last position of the locked queue, may squeeze the original last page into
-the unlocked queue.
-This function is used on last visited but 'unlocked' pages to avoid excessive lock/unlock calls to cache memory
-manager as contiguous entry reading/writing often happens on the same page.
-@param	aPage	the page to be inserted.
-@pre	the page type of aPage should only be TDynamicDirCachePage::EUnknown
-*/
-void CDynamicDirCache::MakePageLastLocked(TDynamicDirCachePage* aPage)
-	{
-	// this function should not be called on active pages
-	ASSERT(aPage->iType == TDynamicDirCachePage::EUnknown);
-	if (iLockedQ.IsEmpty())
-		{
-		// if locked queue is empty, add it onto the locked queue directly
-		AddFirstOntoQueue(aPage, TDynamicDirCachePage::ELocked);
-		}
-	else
-		{
-		// otherwise, we squeeze for the last position on locked queue
-		while (iLockedQCount + 1 >= iMinSizeInPages)
-			{
-			TDynamicDirCachePage* last = iLockedQ.Last();
-			DeQueue(last);
-			UnlockPage(last);
-			AddFirstOntoQueue(last, TDynamicDirCachePage::EUnlocked);
-			}
-		// iLockedQCount + 1 < iMinSizeInPages
-		iLockedQ.AddLast(*aPage);
-		aPage->SetPageType(TDynamicDirCachePage::ELocked);
-		iLockedQCount++;
-		}
-	}
-/**
 Read data from a single page. If the page is not found or not valid anymore, read media onto iActive page first.
 The data will be _Appended_ the the descriptor aDes. The caller is responsible for maintaining this descriptor.
 @param	aPos	the starting position of the media address to be read.
 @param	aLength	the length of the content to be read.
 		{
 		// read data and append them to the descriptor
 aDes.Append(pPage->PtrInPage(aPos), aLength);
-// if page is from unlocked queue, insert it onto the last page of the locked
+// if page is from unlocked queue, try to keep it locked until we move to a
-//  queue. this is to avoid excessive locking and unlocking operations that is
+//  different page from the unlocked queue
-//  highly likely to happen for following reads.
+// this is to avoid excessive locking and unlocking operations that is
-if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)
+//  highly likely to happen when DoFindL() linearly scan through the directory
-	{
+if (pPage->PageType() == TDynamicDirCachePage::EUnlocked
-	DeQueue(pPage);
+&& iLastVisitedPage != pPage)
-	MakePageLastLocked(pPage);
+{
+// Note: iLastVisitedPage may have been moved from unlocked queue to locked queue
+if(iLastVisitedPage && iLastVisitedPage->PageType() == TDynamicDirCachePage::EUnlocked)
+{
+User::LeaveIfError(UnlockPage(iLastVisitedPage));
+}
+iLastVisitedPage = pPage;
 	}
 		}
 	else	// page locking failed
 		{
 		ASSERT(pPage->PageType() == TDynamicDirCachePage::EUnlocked);
 // dump cache, for debug
 case EDumpCache:
 	{
 	RFs fs;
-	fs.Connect();
+	r = fs.Connect();
+if(r != KErrNone)
+break;
 	const TUint32 debugRegister = DebugRegister();
 	fs.SetDebugRegister(debugRegister|KFSYS);
 	Dump();
 	fs.SetDebugRegister(debugRegister);
 	fs.Close();
+	r = KErrNone;
 	break;
 	}
 case ECacheInfo:
 	{
 	RFs fs;
-	fs.Connect();
+	r = fs.Connect();
+if(r != KErrNone)
+break;
 	const TUint32 debugRegister = DebugRegister();
 	fs.SetDebugRegister(debugRegister|KFSYS);
-	Info();
+TDirCacheInfo* aInfo = static_cast<TDirCacheInfo*>(aParam2);
+Info(aInfo);
 	fs.SetDebugRegister(debugRegister);
 	fs.Close();
+	r = KErrNone;
 	break;
 	}
 default:
 __PRINT1(_L("CDynamicDirCache::Control() invalid function: %d"), aFunction);
 void CDynamicDirCache::DoMakePageMRU(TInt64 aPos)
 	{
 //	__PRINT1(_L("MakePageMRU (%lx)"), aPos);
 //	__PRINT4(_L("Current Cache State: iLockedQCount=%d, iUnlockedQCount=%d, iLookupTbl=%d, iMaxSizeInPages=%d"), iLockedQCount, iUnlockedQCount, iLookupTable.Count(), iMaxSizeInPages);
-	// check there are at least two locked pages
+	// check there are at least one locked pages
-	ASSERT(iLockedQCount > 1);
+	ASSERT(iLockedQCount > 0);
 	// check the MRU page first, if it is already the MRU page, we can return immediately
 	TInt64 pageStartMedPos = CalcPageStartPos(aPos);
 	if (!iLockedQ.IsEmpty())
 		{
-		if (iLockedQ.First()->StartPos() == pageStartMedPos)
+if (iLockedQCount > 1 && iLockedQ.First()->StartPos() == pageStartMedPos)
 			{
 			return;
 			}
 		}
 	TDynamicDirCachePage* pPage = FindPageByPos(aPos);
-if (pPage)
+	if (pPage)
-	{
+		{
-	ASSERT(pPage->IsValid());
+		ASSERT(pPage->IsValid());
 		// lock page before make it MRU
-	if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)
+		if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)
-		{
+			{
-		ASSERT(!pPage->IsLocked());
+ASSERT(!pPage->IsLocked() || (pPage->IsLocked() && pPage == iLastVisitedPage));
-	if (LockPage(pPage) == NULL)
+			if (LockPage(pPage) == NULL)
-		{
+				{
-		DeQueue(pPage);
+				DeQueue(pPage);
-		LookupTblRemove(pPage->StartPos());
+				LookupTblRemove(pPage->StartPos());
-		DecommitPage(pPage);
+				DecommitPage(pPage);
-		delete pPage;
+				delete pPage;
-		pPage = NULL;
+				pPage = NULL;
-		}
+				}
-		}
+			}
-	else
+		else
-		{
+			{
-		// error checking: page should either be locked or active
+			// error checking: page should either be locked or active
-		ASSERT(LockPage(pPage) != NULL);
+			ASSERT(LockPage(pPage) != NULL);
-		}
+			}
-	}
+		}
-// if page not found or page data not valid anymore, use active page to read data
+	// if page not found or page data not valid anymore, use active page to read data
-if (!pPage)
+	if (!pPage)
-	{
+		{
-TRAPD(err, pPage = UpdateActivePageL(aPos));
+		TRAPD(err, pPage = UpdateActivePageL(aPos));
-if (err != KErrNone)
+		if (err != KErrNone)
-	{
+			{
-	// problem occurred reading active page, return immediately.
+			// problem occurred reading active page, return immediately.
-	return;
+			return;
-	}
+			}
-	}
+		}
-// by now, the page is either locked or active page
+	// by now, the page is either locked or active page
 	ASSERT(pPage && pPage->IsValid() && pPage->IsLocked());
-	TBool allocateNewPage = pPage == iLockedQ.Last() && !CacheIsFull();
+TBool makeNewPageMRU = pPage == iLockedQ.Last();
 	switch (pPage->PageType())
 		{
 		case TDynamicDirCachePage::EUnlocked:
 			}
 		default:
 			ASSERT(0);
 		}
-	if (allocateNewPage)
+if (!makeNewPageMRU)
-		{
+return;
-		TDynamicDirCachePage* nPage = NULL;
-		TRAPD(err, nPage = AllocateAndLockNewPageL(0));
+// when cache is full and a new MRU page is about to be added, we will need to evict the LRU page
-		if (err == KErrNone)
+//  accordingly
-			{
+if (CacheIsFull())
+{
-			// about to add a page to end of locked queue, so lie about iLockedQCount
+TUint32& queueCnt = iMaxSizeInPages - iMinSizeInPages > 0 ? iUnlockedQCount : iLockedQCount;
-			iLockedQCount++;
+queueCnt++;
-			CheckThresholds();
+CheckThresholds();
-			iLockedQCount--;
+queueCnt--;
+}
-			iLockedQ.AddLast(*nPage);
-			nPage->SetPageType(TDynamicDirCachePage::ELocked);
+// attempt to grow the cache by appending a clean, new page at the end of the locked page queue.
-			++iLockedQCount;
+// This can fail when out of memory; the LRU mechanism then makes sure the oldest page will be re-used.
-			LookupTblAdd(nPage);
+TDynamicDirCachePage* nPage = AllocateAndLockNewPage();
-			}
+if (!nPage)
-		}
+return;
+// about to add the new active page, force the locked queue to evict the existing last page to make room
+//  for the new active page
+	iLockedQCount++;
+	CheckThresholds();
+	iLockedQCount--;
+	iLockedQ.AddLast(*nPage);
+	nPage->SetPageType(TDynamicDirCachePage::ELocked);
+	++iLockedQCount;
 	}
 /**
 Implementation of pure virtual function.
 @see	MDiskSpecialAccessor::MakePageMRU()
 Check if the number of (locked pages + iActive page) and unlocked pages have exceeded minimum allowed page
 number and maximum allowed page number respectively.
 */
 void CDynamicDirCache::CheckThresholds()
 	{
-	while (iLockedQCount + 1 > iMinSizeInPages)
+while (iLockedQCount > iMinSizeInPages)
 		{
 		TDynamicDirCachePage* movePage = iLockedQ.Last();
 		UnlockPage(movePage);
 		DeQueue(movePage);
 		TInt err = LookupTblRemove(movePage->StartPos());
 /**
 Try to create a new page and lock the page content when it is created. This function should only be called
 when creating iActive page or making a page MRU (which might result in page evictions).
 @return	the pointer of the newly created page, or NULL if allocation failed.
-@param	aStartMedPos	the starting media address of the page to be created.
+*/
-@pre	aStartMedPos should not already be existing in the cache.
+TDynamicDirCachePage* CDynamicDirCache::AllocateAndLockNewPage(/*TInt64 aStartMedPos*/)
-*/
+{
-TDynamicDirCachePage* CDynamicDirCache::AllocateAndLockNewPageL(TInt64 aStartMedPos)
+__PRINT(_L("CDynamicDirCache::AllocateAndLockNewPage()"));
-	{
-	__PRINT1(_L("CDynamicDirCache::AllocateAndLockNewPageL(aStartMedPos=%lx)"), aStartMedPos);
+TUint8* startRamAddr = iCacheMemoryClient->AllocateAndLockSegments(PageSizeInSegs());
-	TUint8* startRamAddr = iCacheMemoryClient->AllocateAndLockSegments(PageSizeInSegs());
+if (!startRamAddr)
-	if (startRamAddr)
+return NULL;
-		{
-		// create new page and return
+TDynamicDirCachePage* pPage = TDynamicDirCachePage::CreateCachePage(this, 0, startRamAddr);
-		TDynamicDirCachePage* pPage = TDynamicDirCachePage::NewL(this, aStartMedPos, startRamAddr);
-		pPage->SetLocked(ETrue);
+// Failure would mean the cache chunk was able to grow but we've run out of heap.
-		pPage->SetValid(EFalse);
+// This seems extremely unlikely, but decommit the now-unmanageable cache segment just in case.
-		return pPage;
+if (!pPage)
-		}
+{
+iCacheMemoryClient->DecommitSegments(startRamAddr, PageSizeInSegs());
-	return NULL;
+return NULL;
-	}
+}
-#ifdef _DEBUG
+	pPage->SetLocked(ETrue);
+	pPage->SetValid(EFalse);
+	return pPage;
+	}
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 /**
 Dump cache information, only enabled in debug mode.
 @see CDynamicDirCache::Control()
 */
-void CDynamicDirCache::Info() const
+void CDynamicDirCache::Info(TDirCacheInfo* aInfo) const
-	{
+{
-	__PRINT(_L("======== CDynamicDirCache::Info ========="));
+__PRINT(_L("======== CDynamicDirCache::Info ========="));
-	const TUint32 SegmentSizeInBytesLog2 = CCacheMemoryManagerFactory::CacheMemoryManager()->SegmentSizeInBytesLog2();
+const TUint32 SegmentSizeInBytesLog2 = CCacheMemoryManagerFactory::CacheMemoryManager()->SegmentSizeInBytesLog2();
-	// page size
+const TUint32 pageMemSizeLog2 = iPageSizeLog2 > SegmentSizeInBytesLog2 ? iPageSizeLog2 : SegmentSizeInBytesLog2;
-	__PRINT1(_L("=== Pages size:               [%d Bytes]"), iPageSizeInBytes);
+// page size
-	__PRINT1(_L("=== Segment size:             [%d Bytes]"), 1 << SegmentSizeInBytesLog2);
+__PRINT1(_L("=== Segment size:             [%d Bytes]"), 1 << SegmentSizeInBytesLog2);
+__PRINT1(_L("=== Page data size:           [%d Bytes]"), iPageSizeInBytes);
-	// data size:
+__PRINT1(_L("=== Page mem size:            [%d Bytes]"), 1 << pageMemSizeLog2);
-	__PRINT1(_L("=== Min data size:            [%d Bytes]"), iMinSizeInPages << iPageSizeLog2);
-	__PRINT1(_L("=== Max data size:            [%d Bytes]"), iMaxSizeInPages << iPageSizeLog2);
+// cache size in pages
+__PRINT1(_L("=== Min cache size in pages:  [%d]"), iMinSizeInPages);
-	// memory size:
+__PRINT1(_L("=== Max cache size in pages:  [%d]"), iMaxSizeInPages);
-	const TUint32 pageMemSizeLog2 = iPageSizeLog2 > SegmentSizeInBytesLog2 ? iPageSizeLog2 : SegmentSizeInBytesLog2;
-	__PRINT1(_L("=== Min memory size:          [%d Bytes]"), iMinSizeInPages << pageMemSizeLog2);
+// locked page num
-	__PRINT1(_L("=== Max memory size:          [%d Bytes]"), iMaxSizeInPages << pageMemSizeLog2);
+__PRINT1(_L("=== Number of pages locked:   [%d]"), iLockedQCount);
+// unlocked page num
-	// reserved pages
+__PRINT1(_L("=== Number of pages unlocked: [%d]"), iUnlockedQCount);
-	__PRINT1(_L("=== Number of pages reserved: [%d]"), iMinSizeInPages);
+__PRINT(_L("=========================================\n"));
-	__PRINT1(_L("=== Reserved memory:          [%d Bytes]"), (iMinSizeInPages * PageSizeInSegs()) << SegmentSizeInBytesLog2);
-	// locked page num
+ASSERT(aInfo);
-	__PRINT1(_L("=== Number of pages locked:   [%d]"), iLockedQCount);
+aInfo->iMemorySegmentSize       = 1 << SegmentSizeInBytesLog2;
-	__PRINT1(_L("=== Locked memory:            [%d Bytes]"), (iLockedQCount * PageSizeInSegs()) << SegmentSizeInBytesLog2);
+aInfo->iPageSizeInMemory        = PageSizeInSegs() << SegmentSizeInBytesLog2;
-	// unlocked page num
+aInfo->iPageSizeInData          = iPageSizeInBytes;
-	__PRINT1(_L("=== Number of pages unlocked: [%d]"), iUnlockedQCount);
+aInfo->iMinCacheSizeInPages     = iMinSizeInPages;
-	__PRINT1(_L("=== Unlocked memory:          [%d Bytes]"), (iUnlockedQCount * PageSizeInSegs()) << SegmentSizeInBytesLog2);
+aInfo->iMaxCacheSizeInPages     = iMaxSizeInPages;
-	}
+aInfo->iMinCacheSizeInMemory    = iMinSizeInPages * aInfo->iPageSizeInMemory;
+aInfo->iMaxCacheSizeInMemory    = iMaxSizeInPages * aInfo->iPageSizeInMemory;
+aInfo->iLockedPageNumber        = iLockedQCount;
+aInfo->iUnlockedPageNumber      = iUnlockedQCount;
+}
 /**
 Dump cache content, only enabled in debug mode.
 @see CDynamicDirCache::Control()
 */
 pEntry = (TLookupEntry*) iter.Next();
 };
 }
 __PRINT(_L("===========================================\n"));
 }
-#endif //_DEBUG
+#endif //#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 /**
 Lock an unlocked page, or do nothing if the page is already locked.
 @return	TUint8*	pointer of the page to be locked, if locking is successful, otherwise return NULL.
 @param	aPage	the pointer of the page to be locked.
 */
 TInt CDynamicDirCache::UnlockPage(TDynamicDirCachePage* aPage)
 	{
 	ASSERT(aPage != NULL);
 	__PRINT1(_L("CDynamicDirCache::UnlockPage(%lx)"), aPage->StartPos());
-	TInt r = iCacheMemoryClient->UnlockSegments(aPage->StartPtr(), PageSizeInSegs());
+if (aPage)
-	if (r == KErrNone)
+{
-		{
+		TInt r = iCacheMemoryClient->UnlockSegments(aPage->StartPtr(), PageSizeInSegs());
-		aPage->SetLocked(EFalse);
+		if (r == KErrNone)
-		}
+			{
-	return r;
+			aPage->SetLocked(EFalse);
-	}
+			}
+		return r;
+		}
+return KErrArgument;
+}
 /**
 Decommit a locked or unlocked page.
 @return	TInt	KErrNone if decommition was successful, otherwise system-wide error code.
 @param	aPage	the pointer of the page to be decommitted.
 */

changeset 176	af6ec97d9189
parent 90	947f0dc9f7a8