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

equal deleted inserted replaced

-:56f325a607ea
+:0173bcd7697c
 iStartRamAddr(aStartRamAddr),
 iOwnerCache(aOwnerCache),
 iValid(EFalse),
 iLocked(EFalse)
 	{
-//	__PRINT3(_L("TDynamicDirCachePage::TDynamicDirCachePage(aStartMedPos=%lx, aStartRamAddr=0x%X, aPageSize=%u)"), aStartMedPos, aStartRamAddr, PageSizeInBytes());
+	//__PRINT3(_L("TDynamicDirCachePage::TDynamicDirCachePage(aStartMedPos=%lx, aStartRamAddr=0x%X, aPageSize=%u)"), aStartMedPos, aStartRamAddr, PageSizeInBytes());
 	iType = EUnknown;
 	}
 /////////////////////////////// class CDynamicDirCache::TLookupEntry ///////////////////////////
 /**
 	}
 /////////////////////////////// class CDynamicDirCache ///////////////////////////
 CDynamicDirCache::~CDynamicDirCache()
 	{
-//	__PRINT(_L("CDynamicDirCache::~CDynamicDirCache()"));
+	__PRINT(_L("CDynamicDirCache::~CDynamicDirCache()"));
 	// we should never decommit locked pages
 while (!iLockedQ.IsEmpty())
 		{
 		TDynamicDirCachePage* page = iLockedQ.Last();
 		DecommitPage(page);	// inform cache client to decommit page memory
 		delete page;
 		}
 	ASSERT(iUnlockedQCount == 0);
-	delete iActivePage;
 	ASSERT(iLookupTable.Count() == 0);
 	iLookupTable.Close();
 if (iCacheMemoryClient)
 	iCacheMemoryClient->Reset();
 	}
 @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
 */
-CDynamicDirCache::CDynamicDirCache(TFatDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeInBytesLog2)
+CDynamicDirCache::CDynamicDirCache(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeInBytesLog2)
 :iPageSizeLog2(aPageSizeInBytesLog2),
 iMinSizeInPages(aMinPageNum),
 iMaxSizeInPages(aMaxPageNum),
 iDrive(aDrive),
 iLockedQ(_FOFF(TDynamicDirCachePage, iLink)),
 	if (!iCacheMemoryClient)
 		{
 		User::Leave(KErrNoMemory);
 		}
-	// reserve active page
-	iActivePage = AllocateAndLockNewPageL(0);
+	// allocate as many permanently locked pages as there are threads - plus one
-	ASSERT(iActivePage);
+	// otherwise DoMakePageMRU() won't work properly with only one thread
-	if (!iActivePage)
+//-- At present moment the size of TDrive thread pool is 1 (1 drive thread in a pool)
-		{
+	iPermanentlyAllocatedPageCount = 1;
-		User::Leave(KErrNoMemory);
-		}
+	if (iPermanentlyAllocatedPageCount > iMinSizeInPages)
-	iActivePage->SetPageType(TDynamicDirCachePage::EActivePage);
+		iMinSizeInPages = iPermanentlyAllocatedPageCount;
+	for (TUint n=0; n<iPermanentlyAllocatedPageCount; n++)
+		{
+		TDynamicDirCachePage* pPage = AllocateAndLockNewPageL(0);
+		AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);
+		LookupTblAdd(pPage);
+		}
 	}
 /**
 Static factory function of CDynamicDirCache
 */
-CDynamicDirCache* CDynamicDirCache::NewL(TFatDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, const TDesC& aClientName)
+CDynamicDirCache* CDynamicDirCache::NewL(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, const TDesC& aClientName)
 {
-//    __PRINT3(_L("CDynamicDirCache::NewL(MinPageNum=%u, MaxPageNum=%u, page=%u)"), aMinPageNum, aMaxPageNum, 1<<aPageSizeLog2);
+__PRINT3(_L("CDynamicDirCache::NewL(MinPageNum=%u, MaxPageNum=%u, page=%u)"), aMinPageNum, aMaxPageNum, 1<<aPageSizeLog2);
 CDynamicDirCache* pSelf = new (ELeave) CDynamicDirCache(aDrive, aMinPageNum, aMaxPageNum, aPageSizeLog2);
 CleanupStack::PushL(pSelf);
 pSelf->ConstructL(aClientName);
 CleanupStack::Pop();
 return pSelf;
 		iLockedQCount++;
 		}
 	}
 /**
-Read data from a single page. If the page is not found or not valid anymore, read media onto iActive page
+Read data from a single page. If the page is not found or not valid anymore, read media onto iActive page first.
-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.
+@param	aPos	the starting position of the media address to be read.
-@param	aDes	the descriptor to contain the content.
+@param	aLength	the length of the content to be read.
-@pre	aLength should be no more than page size.
+@param	aDes	the descriptor to contain the content.
+@pre	aLength should be no more than page size.
 */
 void CDynamicDirCache::ReadDataFromSinglePageL(TInt64 aPos, TInt aLength, TDes8& aDes)
 	{
 //-- the data section is in the cache page entirely, take data directly from the cache
 	TDynamicDirCachePage* pPage = FindPageByPos(aPos);
 if (pPage)
 	{
 		// lock page before reading,
 	if (LockPage(pPage) != NULL)
 		{
-		// read data
+		// read data and append them to the descriptor
-aDes.Copy(pPage->PtrInPage(aPos), aLength);
+aDes.Append(pPage->PtrInPage(aPos), aLength);
 // if page is from unlocked queue, insert it onto the last page of the locked
 //  queue. this is to avoid excessive locking and unlocking operations that is
 //  highly likely to happen for following reads.
 if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)
 	if (!pPage)
 		{
 // if page not found or page data not valid anymore, use active page to read data in
 pPage = UpdateActivePageL(aPos);
-// read data
+// read data and append them to the descriptor
-aDes.Copy(pPage->PtrInPage(aPos), aLength);
+aDes.Append(pPage->PtrInPage(aPos), aLength);
 	}
 	}
 //====================================================================
 //-- 1. read data that are already in the current page
 ReadDataFromSinglePageL(currMediaPos, bytesToPageEnd, aDes);
 dataLen -= bytesToPageEnd;
 currMediaPos += bytesToPageEnd;
-TPtr8 dataNext = aDes.MidTPtr(aDes.Length());
 //-- 2. read whole pages of data
 while (dataLen >= PageSz)
 	{
 	//-- find out if currMediaPos is in cache. If not, find a spare page and read data there
-	ReadDataFromSinglePageL(currMediaPos, PageSz, dataNext);
+ReadDataFromSinglePageL(currMediaPos, PageSz, aDes);
 currMediaPos += PageSz;
 dataLen -= PageSz;
-dataNext = dataNext.MidTPtr(dataNext.Length());
 	}
 //-- 3. read the rest of the data
 if(dataLen > 0)
 {
-	ReadDataFromSinglePageL(currMediaPos, dataLen, dataNext);
+ReadDataFromSinglePageL(currMediaPos, dataLen, aDes);
 }
 } //else((TUint32)aLength <= bytesToPageEnd)
 	}
 /**
 		{
 		UnlockPage(pPage);
 		}
 	// always make writting events MRU
-	MakePageMRU(aPos);
+	DoMakePageMRU(aPos);
 return;
 	}
 /**
 Implementation of pure virtual function.
 User::Leave(nErr);
 }
 	}
 /**
-Implementation of pure virtual function.
+Invalidate the cache
 @see	MWTCacheInterface::InvalidateCache()
 */
-void CDynamicDirCache::InvalidateCache(void)
+void CDynamicDirCache::DoInvalidateCache(void)
 	{
 	__PRINT2(_L("CDynamicDirCache::InvalidateCache(locked=%d, unlocked=%d)"), iLockedQCount, iUnlockedQCount);
 	// we should never decommit locked pages as they needs to be reserved anyway
 	// the overhead of unnecessary page committing operations
-	while(!iLockedQ.IsEmpty())
+	TInt pagesToRemoveFromLockedQueue = iLockedQCount - iPermanentlyAllocatedPageCount;
+	TInt n;
+	for (n=0; n<pagesToRemoveFromLockedQueue; n++)
 		{
 		TDynamicDirCachePage* page = iLockedQ.Last();
 		DeQueue(page);						// remove from queue
 		LookupTblRemove(page->StartPos());	// remove from lookuptable
+		DecommitPage(page);					// inform cache client to decommit page memory
 		delete page;
 		}
-	ASSERT(iLockedQCount == 0);
+	ASSERT(iLockedQCount == iPermanentlyAllocatedPageCount);
+	TDblQueIter<TDynamicDirCachePage> q(iLockedQ);
+	q.SetToFirst();
+	while((TDynamicDirCachePage*) q)
+		{
+		TDynamicDirCachePage* page = q++;
+		LookupTblRemove(page->StartPos());// remove from lookuptable
+		ResetPagePos(page);				// reset start media position (0), invalidate page content
+		}
 	// however we should decommit unlocked pages here
 	while (!iUnlockedQ.IsEmpty())
 		{
 		TDynamicDirCachePage* page = iUnlockedQ.Last();
 		DecommitPage(page);					// inform cache client to decommit page memory
 		delete page;
 		}
 	ASSERT(iUnlockedQCount == 0);
-ASSERT(iLookupTable.Count() == 0);
+	ASSERT(iLockedQCount == iPermanentlyAllocatedPageCount);
-	iLookupTable.Close();
 	ASSERT(iCacheMemoryClient);
+	}
-	// initialize cache state.
-	// Note that once the client is reset, all pages lose connection with the client
+/**
-	//	including the active page. So we will need to reset and re-allocate active page
+Implementation of pure virtual function.
-	//	properly.
+@see	MWTCacheInterface::InvalidateCache()
-	if (iCacheMemoryClient)
+*/
-	iCacheMemoryClient->Reset();
+void CDynamicDirCache::InvalidateCache(void)
+	{
-	// reset and re-allocate active page
+	DoInvalidateCache();
-	ResetPagePos(iActivePage);				// reset start media position (0), invalidate page content
+	}
-	TUint8* startRamAddr = iCacheMemoryClient->AllocateAndLockSegments(PageSizeInSegs());
-	// this should always succeed as the client has just been reset and there are always reserved pages
-	ASSERT(startRamAddr);
-	iActivePage->SetStartPtr(startRamAddr);	// set RAM address
-	}
 /** this method isn't implemented*/
 void CDynamicDirCache::InvalidateCachePage(TUint64 /*aPos*/)
 {
 ASSERT(0);
 TUint32 CDynamicDirCache::PageSizeInBytesLog2() const
 	{
 	return iPageSizeLog2;
 	}
-/**
-Implementation of pure virtual function.
+void CDynamicDirCache::DoMakePageMRU(TInt64 aPos)
-@see	MWTCacheInterface::MakePageMRU()
+	{
-*/
+//	__PRINT1(_L("MakePageMRU (%lx)"), aPos);
-void CDynamicDirCache::MakePageMRU(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 the MRU page first, if it is already the MRU page, we can return immediately
 	TInt64 pageStartMedPos = CalcPageStartPos(aPos);
 	if (!iLockedQ.IsEmpty())
 		{
 	}
 // by now, the page is either locked or active page
 	ASSERT(pPage && pPage->IsValid() && pPage->IsLocked());
+	TBool allocateNewPage = pPage == iLockedQ.Last() && !CacheIsFull();
 	switch (pPage->PageType())
 		{
-		// if the page is the active page, we will need to find a new active page for replacement
-		case TDynamicDirCachePage::EActivePage:
-			{
-			TDynamicDirCachePage* newAP = NULL;
-			// if there is more cache room available, try to create a new page first
-			if (!CacheIsFull())
-				{
-				// allocate and lock a new page
-				TRAPD(err, newAP = AllocateAndLockNewPageL(0));
-				// if any error ocurrs, return immediately
-				if (err != KErrNone)
-					{
-					// unlock the page that was originally unlocked before leave
-					if (pPage->PageType() == TDynamicDirCachePage::EUnlocked)
-						{
-						UnlockPage(pPage);
-						}
-					return;
-					}
-				if (newAP)
-					{
-					// replace the active page with the new page
-					newAP->SetPageType(TDynamicDirCachePage::EActivePage);
-					iActivePage = newAP;
-					}
-				}
-			// if cache has grown to its max size, or new page allocation failed
-			if (!newAP)
-				{
-				// try to lock the LRU page on the unlocked page queque first
-				if (!iUnlockedQ.IsEmpty())
-					{
-					newAP = iUnlockedQ.Last();
-					ASSERT(newAP->IsValid());
-					if (LockPage(newAP) != NULL)
-						{
-						// deque, reset pos, set new type
-						DeQueue(newAP);
-		        		LookupTblRemove(newAP->StartPos());
-						ResetPagePos(newAP);
-						newAP->SetPageType(TDynamicDirCachePage::EActivePage);
-						// replace active page
-						iActivePage = newAP;
-						}
-					// if falied locking the LRU page from unclocked queque,
-					// delete it
-					else
-						{
-						DeQueue(newAP);
-		        		LookupTblRemove(newAP->StartPos());
-		        		DecommitPage(newAP);
-		        		delete newAP;
-		        		newAP = NULL;
-						}
-					}
-				}
-			// if still have not found new active page
-			// grab the LRU page from Locked Page Queue for active page
-			if (!newAP)
-				{
-				ASSERT(!iLockedQ.IsEmpty());
-				newAP = iLockedQ.Last();
-				// deque, reset pos, set new type
-				DeQueue(newAP);
-		LookupTblRemove(newAP->StartPos());
-				ResetPagePos(newAP);
-				newAP->SetPageType(TDynamicDirCachePage::EActivePage);
-				// replace active page
-				iActivePage = newAP;
-				}
-			// we should always be able to find a locked page for active page
-			ASSERT(newAP != NULL);
-			// make original page (i.e. former active page) MRU
-			// add onto locked queue
-			AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);
-			// add onto lookuptbl, as active page is not on lookup tbl originally
-			LookupTblAdd(pPage);
-			// check cache limit
-			CheckThresholds();
-			return;
-			}
 		case TDynamicDirCachePage::EUnlocked:
 			{
 			// if page was originally on Unlocked Page Queque, remove it from Unlocked Page Queue, add it
 			// to the Locked Page Queue and make it MRU
 			DeQueue(pPage);
 			AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);
 			// check cache limit
 			CheckThresholds();
-			return;
 			}
 		case TDynamicDirCachePage::ELocked:
 			{
 			// otherwise the page was on Locked Page Queue, make it MRU
 			// no need to check cache limit
 			if (pPage != iLockedQ.First())
 				{
 				DeQueue(pPage);
 				AddFirstOntoQueue(pPage, TDynamicDirCachePage::ELocked);
-				return;
 				}
 			break;
 			}
 		default:
 			ASSERT(0);
 		}
+	if (allocateNewPage)
+		{
+		TDynamicDirCachePage* nPage = NULL;
+		TRAPD(err, nPage = AllocateAndLockNewPageL(0));
+		if (err == KErrNone)
+			{
+			// about to add a page to end of locked queue, so lie about iLockedQCount
+			iLockedQCount++;
+			CheckThresholds();
+			iLockedQCount--;
+			iLockedQ.AddLast(*nPage);
+			nPage->SetPageType(TDynamicDirCachePage::ELocked);
+			++iLockedQCount;
+			LookupTblAdd(nPage);
+			}
+		}
+	}
+/**
+Implementation of pure virtual function.
+@see	MDiskSpecialAccessor::MakePageMRU()
+*/
+void CDynamicDirCache::MakePageMRU(TInt64 aPos)
+	{
+	DoMakePageMRU(aPos);
 	}
 //====================================================================
 /**
 Internal query function, to check if aPos is cached or not. iActive page is included in searching.
 */
 TDynamicDirCachePage* CDynamicDirCache::FindPageByPos(TInt64 aPos)
 	{
-	__PRINT1(_L("CDynamicDirCache::FindPageByPos(aPos=%lx)"), aPos);
+//	__PRINT1(_L("CDynamicDirCache::FindPageByPos(aPos=%lx)"), aPos);
 // align the page position
 	TInt64 pageStartMedPos = CalcPageStartPos(aPos);
-	if ((iActivePage->StartPos() == pageStartMedPos))
-		{
-		ASSERT(iActivePage->IsValid());
-		return iActivePage;
-		}
 	// search in lookup table
 	return LookupTblFind(pageStartMedPos);
 	}
 /**
 TDynamicDirCachePage* CDynamicDirCache::UpdateActivePageL(TInt64 aPos)
 	{
 // align the page position
 	TInt64 pageStartMedPos = CalcPageStartPos(aPos);
-	if (iActivePage->StartPos() == pageStartMedPos && iActivePage->IsValid())
+	ASSERT(!iLockedQ.IsEmpty());
-		{
+	TDynamicDirCachePage* activePage = iLockedQ.Last();
-		return iActivePage;
-		}
+	if (activePage->StartPos() == pageStartMedPos && activePage->IsValid())
+		{
-	__PRINT2(_L("CDynamicDirCache::UpdateActivePageL(aPos=%lx, active=%lx)"), aPos, iActivePage->StartPos());
+		return activePage;
+		}
+	__PRINT2(_L("CDynamicDirCache::UpdateActivePageL(aPos=%lx, active=%lx)"), aPos, activePage->StartPos());
+	activePage->Deque();
+	LookupTblRemove(activePage->StartPos());
 	// set start med pos value, no other effects, only available to active page
-	iActivePage->SetPos(pageStartMedPos);
+	activePage->SetPos(pageStartMedPos);
 	// read data, make active page valid
-	TUint8* data = iActivePage->PtrInPage(iActivePage->iStartMedPos);
+	TUint8* data = activePage->PtrInPage(activePage->iStartMedPos);
 TPtr8 dataPtr(data, iPageSizeInBytes);
-const TInt nErr = iDrive.ReadNonCritical(iActivePage->iStartMedPos, iPageSizeInBytes, dataPtr);
+const TInt nErr = iDrive.ReadNonCritical(activePage->iStartMedPos, iPageSizeInBytes, dataPtr);
+	iLockedQ.AddLast(*activePage);
+	LookupTblAdd(activePage);
 if(nErr !=KErrNone)
 {
 // some serious problem occured during reading, invalidate cache.
-InvalidateCache();
+DoInvalidateCache();
 User::Leave(nErr);
 }
-iActivePage->SetValid(ETrue);
+activePage->SetValid(ETrue);
-return iActivePage;
+return activePage;
 	}
 /**
 Check if the number of (locked pages + iActive page) and unlocked pages have exceeded minimum allowed page
 number and maximum allowed page number respectively.
 		q.SetToFirst();
 		TInt i = 0;
 		while((TDynamicDirCachePage*)q)
 			{
 			TDynamicDirCachePage* pP = q++;
-			__PRINT3(_L("=== CDynamicDirCache::iLockedQ\t[%4d](pos=%lx, size=%d)"), i++, pP->StartPos(), pP->PageSizeInBytes());
+			__PRINT5(_L("=== CDynamicDirCache::iLockedQ\t[%4d](pos=%lx, locked=%d, valid=%d, size=%u)"), i++, pP->StartPos(), pP->IsLocked(), pP->IsValid(), pP->PageSizeInBytes());
 			}
 		}
 	if (!iUnlockedQ.IsEmpty())
 		{
 		TDblQueIter<TDynamicDirCachePage> q(iUnlockedQ);
 		q.SetToFirst();
 		TInt i = 0;
 		while((TDynamicDirCachePage*)q)
 			{
 			TDynamicDirCachePage* pP = q++;
-			__PRINT3(_L("=== CDynamicDirCache::iUnlockedQ\t[%4d](pos=%lx, size=%u)"), i++, pP->StartPos(), pP->PageSizeInBytes());
+			__PRINT5(_L("=== CDynamicDirCache::iUnlockedQ\t[%4d](pos=%lx, locked=%d, valid=%d, size=%u)"), i++, pP->StartPos(), pP->IsLocked(), pP->IsValid(), pP->PageSizeInBytes());
 			}
 		}
-	__PRINT2(_L("=== CDynamicDirCache::iActivePage\t[*](pos=%lx, size=%u)"), iActivePage->StartPos(), iActivePage->PageSizeInBytes());
 	if (iLookupTable.Count())
 		{
 		TInt i = 0;
 		THashSetIter<TLookupEntry> iter(iLookupTable);
 		TLookupEntry* pEntry;
 		pEntry = (TLookupEntry*) iter.Next();
 		while(pEntry)
 			{
 			TDynamicDirCachePage* pP = pEntry->iPage;
-			__PRINT3(_L("=== CDynamicDirCache::iLookupTable\t[%4d](pos=%lx, size=%u)"), i++, pP->StartPos(), pP->PageSizeInBytes());
+			__PRINT5(_L("=== CDynamicDirCache::iLookupTable\t[%4d](pos=%lx, locked=%d, valid=%d, size=%u)"), i++, pP->StartPos(), pP->IsLocked(), pP->IsValid(), pP->PageSizeInBytes());
 			pEntry = (TLookupEntry*) iter.Next();
 			};
 		}
 	__PRINT(_L("===========================================\n"));
 	}
 	{
 	ASSERT(aPage);
 	if (!aPage)
 		return KErrArgument;
-	// page must be dequed first or it is active page
-	if (aPage->iType != TDynamicDirCachePage::EActivePage && aPage->iType != TDynamicDirCachePage::EUnknown)
-		{
-		ASSERT(0);
-		return KErrArgument;
-		}
 	if (aType == TDynamicDirCachePage::ELocked)
 		{
 		iLockedQ.AddFirst(*aPage);
 		aPage->SetPageType(TDynamicDirCachePage::ELocked);
 		++iLockedQCount;
 		}
 	TLookupEntry* entry = iLookupTable.Find(TLookupEntry(aPos, 0, NULL));
 	if(entry)
 		{
-		ASSERT(entry->iPage->IsValid());
+		// last entry on used queue is used as the 'active' page & may not be valid
+		if (!entry->iPage->IsValid())
+			return NULL;
 		return entry->iPage;
 		}
 	return NULL;
 	}

changeset 33	0173bcd7697c
parent 15	4122176ea935
child 62	4a8fed1c0ef6
child 90	947f0dc9f7a8