46 /*

    46 /**

    47 Limit the maximum number of oldest pages to bound the time taken by SelectPagesToClean(), which is

    47 Default limit for the maximum number of oldest pages.

    48 called with the MmuLock held.

    48 

    49 If the data paging device sets iPreferredWriteShift, then this is increased if necessary to allow

    50 that many pages to be present.

    51 

    52 This limit exists to make our live list implementation a closer approximation to LRU, and to bound

    53 the time taken by SelectSequentialPagesToClean(), which is called with the MmuLock held.

    50 const TUint KMaxOldestPages = 32;

    55 const TUint KDefaultMaxOldestPages = 32;

    57 DPager::DPager()

    62 DPager::DPager() :

    58 	: iMinimumPageCount(0), iMaximumPageCount(0), iYoungOldRatio(0),

    63 	iMinimumPageCount(0),

    59 	  iYoungCount(0), iOldCount(0), iOldestCleanCount(0),

    64 	iMaximumPageCount(0),

    60 	  iNumberOfFreePages(0), iReservePageCount(0), iMinimumPageLimit(0)

    65 	iYoungOldRatio(0),

    66 	iYoungCount(0),

    67 	iOldCount(0),

    68 	iOldestCleanCount(0),

    69 	iMaxOldestPages(KDefaultMaxOldestPages),

    70 	iNumberOfFreePages(0),

    71 	iReservePageCount(0),

    72 	iMinimumPageLimit(0),

    73 	iPagesToClean(1)

   448 			{// Update the list links point to the new page.

   461 			{// Update the list links to point to the new page.

   449 			__NK_ASSERT_DEBUG(iYoungCount);

   488 TInt DPager::TryStealOldestPage(SPageInfo*& aPageInfoOut)

   500 SPageInfo* DPager::StealOrAllocPage(TBool aAllowAlloc, Mmu::TRamAllocFlags aAllocFlags)

   493 	// find oldest page in list...

   505 	// The PageCleaningLock may or may not be held to start with

   506 	TBool pageCleaningLockAcquired = EFalse;

   507 

   499 		}

   518 		pageInfo = SPageInfo::FromLink(link);

   500 	else if (iOldestDirtyCount)

   519 		if(pageInfo->Type()==SPageInfo::EUnused)

   520 			goto try_steal_from_page_info;

   521 		}

   522 	

   523 	// maybe try getting a free page from the system pool...

   524 	if (aAllowAlloc && !HaveMaximumPages())

   525 		{

   526 		MmuLock::Unlock();

   527 		pageInfo = GetPageFromSystem(aAllocFlags);

   528 		MmuLock::Lock();

   529 		if (pageInfo)

   530 			goto exit;

   531 		}

   532 	

   533 	// try stealing the oldest clean page on the  live list if there is one...

   534 	if (iOldestCleanCount)

   535 		{

   536 		__NK_ASSERT_DEBUG(!iOldestCleanList.IsEmpty());

   537 		link = iOldestCleanList.Last();

   538 		goto try_steal_from_link;

   539 		}

   540 

   541 	// no clean oldest pages, see if we can clean multiple dirty pages in one go...

   542 	if (iOldestDirtyCount > 1 && iPagesToClean > 1)

   543 		{

   544 		__NK_ASSERT_DEBUG(!iOldestDirtyList.IsEmpty());

   545 

   546 		// check if we hold page cleaning lock

   547 		TBool needPageCleaningLock = !PageCleaningLock::IsHeld();

   548 		if (needPageCleaningLock)

   549 			{

   550 			// temporarily release ram alloc mutex and acquire page cleaning mutex

   551 			MmuLock::Unlock();

   552 			RamAllocLock::Unlock();

   553 			PageCleaningLock::Lock();

   554 			MmuLock::Lock();

   555 			}

   556 

   557 		// there may be clean pages now if we've waited on the page cleaning mutex, if so don't

   558 		// bother cleaning but just restart

   559 		if (iOldestCleanCount == 0 && iOldestDirtyCount >= 1)

   560 			CleanSomePages(EFalse);

   561 

   562 		if (needPageCleaningLock)

   563 			{

   564 			// release page cleaning mutex and re-aquire ram alloc mutex

   565 			MmuLock::Unlock();

   566 			PageCleaningLock::Unlock();			

   567 			RamAllocLock::Lock();

   568 			MmuLock::Lock();

   569 			}

   570 

   571 		// if there are now some clean pages we restart so as to take one of them

   572 		if (iOldestCleanCount > 0)

   573 			goto restart;

   574 		}

   575 

   576 	// otherwise just try to steal the oldest page...

   577 	if (iOldestDirtyCount)

   516 	SPageInfo* pageInfo = SPageInfo::FromLink(link);

   593 

   517 

   594 try_steal_from_link:

   595 

   596 	// lookup page info

   597 	__NK_ASSERT_DEBUG(link);

   598 	pageInfo = SPageInfo::FromLink(link);

   599 	

   600 try_steal_from_page_info:

   601 	

   602 	// if the page is dirty and we don't hold the page cleaning mutex then we have to wait on it,

   603 	// and restart - we clean with the ram alloc mutex held in this case

   519 		return 1;

   605 		{		

   520 

   606 		MmuLock::Unlock();

   607 		PageCleaningLock::Lock();

   608 		MmuLock::Lock();

   609 		pageCleaningLockAcquired = ETrue;

   610 		goto restart;

   611 		}

   612 	

   522 	TInt r = StealPage(pageInfo);	

   614 	if (StealPage(pageInfo) != KErrNone)

   523 	if (r == KErrNone)

   615 		goto restart;

   524 		{

   525 		BalanceAges();

   526 		aPageInfoOut = pageInfo;

   527 		}

   529 	return r;

   617 	BalanceAges();

   530 	}

   618 	

   531 

   619 exit:

   532 

   620 	if (pageCleaningLockAcquired)

   533 SPageInfo* DPager::StealOldestPage()

   621 		{		

   534 	{

   622 		MmuLock::Unlock();

   623 		PageCleaningLock::Unlock();

   624 		MmuLock::Lock();

   625 		}

   626 

   627 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

   536 	TBool pageCleaningLockHeld = EFalse;

   629 	

   537 	for(;;)

   630 	return pageInfo;

   538 		{

   631 	}

   539 		SPageInfo* pageInfo = NULL;

   632 

   540 		TInt r = TryStealOldestPage(pageInfo);

   633 

   541 		

   634 template <class T, TUint maxObjects> class TSequentialColourSelector

   542 		if (r == KErrNone)

   543 			{

   544 			if (pageCleaningLockHeld)

   545 				{

   546 				MmuLock::Unlock();

   547 				PageCleaningLock::Unlock();

   548 				MmuLock::Lock();

   549 				}

   550 			return pageInfo;

   551 			}

   552 		else if (r == 1)

   553 			{

   554 			__NK_ASSERT_ALWAYS(!pageCleaningLockHeld);

   555 			MmuLock::Unlock();

   556 			PageCleaningLock::Lock();

   557 			MmuLock::Lock();

   558 			pageCleaningLockHeld = ETrue;

   559 			}

   560 		// else retry...

   561 		}

   562 	}

   563 

   564 #ifdef __CPU_CACHE_HAS_COLOUR

   565 

   566 template <class T, TInt maxObjects> class TSequentialColourSelector

   569 	static const TInt KMaxLength = maxObjects;

   637 	enum

   570 	static const TInt KArrayLength = _ALIGN_UP(KMaxLength, KPageColourCount);

   638 		{

   639 		KMaxSearchLength = _ALIGN_UP(maxObjects, KPageColourCount)

   640 		};

   572 	FORCE_INLINE TSequentialColourSelector()

   642 	FORCE_INLINE TSequentialColourSelector(TUint aTargetLength)

   579 		return iLongestLength >= KMaxLength;

   652 		return iLongestLength >= iTargetLength;

   580 		}

   653 		}

   581 

   654 

   582 	FORCE_INLINE void AddCandidate(T* aObject, TInt aColour)

   655 	FORCE_INLINE void AddCandidate(T* aObject, TUint aColour)

   585 		for (TInt i = aColour ; i < KArrayLength ; i += KPageColourCount)

   658 		for (TUint i = aColour ; i < iSearchLength ; i += KPageColourCount)

   591 				TInt j = i + 1;

   664 				TUint j = i + 1;

   592 				while(j < KArrayLength && iSeqLength[j])

   665 				while(j < iSearchLength && iSeqLength[j])

   594 				TInt currentLength = iSeqLength[j - 1];

   667 				TUint currentLength = iSeqLength[j - 1];

   605 	FORCE_INLINE TInt FindLongestRun(T** aObjectsOut)

   678 	FORCE_INLINE TUint FindLongestRun(T** aObjectsOut)

   610 		if (iLongestLength < KMaxLength && iSlot[0] && iSlot[KArrayLength - 1])

   683 		if (iLongestLength < iTargetLength && iSlot[0] && iSlot[iSearchLength - 1])

   616 			TInt wrappedLength = iSeqLength[KArrayLength - 1] + iSeqLength[i - 1];

   689 			TUint wrappedLength = iSeqLength[iSearchLength - 1] + iSeqLength[i - 1];

   620 				iLongestStart = KArrayLength - iSeqLength[KArrayLength - 1];

   693 				iLongestStart = iSearchLength - iSeqLength[iSearchLength - 1];

   624 		iLongestLength = Min(iLongestLength, KMaxLength);

   697 		iLongestLength = MinU(iLongestLength, iTargetLength);

   625 

   698 

   626 		__NK_ASSERT_DEBUG(iLongestStart >= 0 && iLongestStart < KArrayLength);

   699 		__NK_ASSERT_DEBUG(iLongestStart < iSearchLength);

   627 		__NK_ASSERT_DEBUG(iLongestStart + iLongestLength < 2 * KArrayLength);

   700 		__NK_ASSERT_DEBUG(iLongestStart + iLongestLength < 2 * iSearchLength);

   628 

   701 

   629 		TInt len = Min(iLongestLength, KArrayLength - iLongestStart);

   702 		TUint len = MinU(iLongestLength, iSearchLength - iLongestStart);

   637 	T* iSlot[KArrayLength];

   710 	TUint iTargetLength;

   638 	TInt8 iSeqLength[KArrayLength];

   711 	TUint iSearchLength;

   639 	TInt iLongestStart;

   712 	TUint iLongestStart;

   640 	TInt iLongestLength;

   713 	TUint iLongestLength;

   714 	T* iSlot[KMaxSearchLength];

   715 	TUint8 iSeqLength[KMaxSearchLength];

   643 TInt DPager::SelectPagesToClean(SPageInfo** aPageInfosOut)

   718 

   644 	{

   719 TInt DPager::SelectSequentialPagesToClean(SPageInfo** aPageInfosOut)

   645 	// select up to KMaxPagesToClean oldest dirty pages with sequential page colours

   720 	{

   721 	// select up to iPagesToClean oldest dirty pages with sequential page colours

   649 	TSequentialColourSelector<SPageInfo, KMaxPagesToClean> selector;

   725 	TSequentialColourSelector<SPageInfo, KMaxPagesToClean> selector(iPagesToClean);

   671 #else

   747 

   672 

   748 TInt DPager::SelectOldestPagesToClean(SPageInfo** aPageInfosOut)

   673 TInt DPager::SelectPagesToClean(SPageInfo** aPageInfosOut)

   749 	{

   674 	{

   750 	// select up to iPagesToClean oldest dirty pages

   675 	// no page colouring restrictions, so just take up to KMaxPagesToClean oldest dirty pages

   677 	TInt pageCount = 0;

   752 	TUint pageCount = 0;

   679 	while (link != &iOldestDirtyList.iA && pageCount < KMaxPagesToClean)

   754 	while (link != &iOldestDirtyList.iA && pageCount < iPagesToClean)

   704 	TInt pageCount = SelectPagesToClean(&pageInfos[0]);

   779 	TInt pageCount;

   780 	if (iCleanInSequence)

   781 		pageCount = SelectSequentialPagesToClean(&pageInfos[0]);

   782 	else

   783 		pageCount = SelectOldestPagesToClean(&pageInfos[0]);

   817 	TInt r = DiscardPage(aPageInfo, KRamZoneInvalidId, EFalse);

   901 	TInt r = DiscardPage(aPageInfo, KRamZoneInvalidId, M::EMoveDisMoveDirty);

   829 static TBool DiscardCanStealPage(SPageInfo* aOldPageInfo, TBool aBlockRest)

   910 static TBool DiscardCanStealPage(SPageInfo* aOldPageInfo, TBool aMoveDirty)

   834 		(aOldPageInfo->PagedState() != SPageInfo::EPagedPinned && (!aBlockRest || !aOldPageInfo->IsDirty()));	

   915 		(aOldPageInfo->PagedState() != SPageInfo::EPagedPinned && (!aMoveDirty || !aOldPageInfo->IsDirty()));	

   835 	}

   916 	}

   836 

   917 

   837 

   918 

   838 TInt DPager::DiscardPage(SPageInfo* aOldPageInfo, TUint aBlockZoneId, TBool aBlockRest)

   919 TInt DPager::DiscardPage(SPageInfo* aOldPageInfo, TUint aBlockZoneId, TUint aMoveDisFlags)

   846 

   927 	TBool moveDirty = (aMoveDisFlags & M::EMoveDisMoveDirty) != 0;

   847 	if (!DiscardCanStealPage(aOldPageInfo, aBlockRest))

   928 	TBool blockRest = (aMoveDisFlags & M::EMoveDisBlockRest) != 0;

   848 		{

   929 

   930 	if (!DiscardCanStealPage(aOldPageInfo, moveDirty))

   931 		{

   932 		// Page must be managed if it is pinned or dirty.

   933 		__NK_ASSERT_DEBUG(aOldPageInfo->Type()==SPageInfo::EManaged);

   851 		// Page must be managed if it is pinned or dirty.

   936 		memory->Open();

   852 		__NK_ASSERT_DEBUG(aOldPageInfo->Type()==SPageInfo::EManaged);

   853 		__NK_ASSERT_DEBUG(memory);

   854 		MmuLock::Unlock();

   857 		TInt r = memory->iManager->MovePage(memory, aOldPageInfo, newAddr, aBlockZoneId, aBlockRest);

   939 		TInt r = memory->iManager->MovePage(memory, aOldPageInfo, newAddr, aBlockZoneId, blockRest);

   878 			newPageInfo = GetPageFromSystem((Mmu::TRamAllocFlags)flags, aBlockZoneId, aBlockRest);

   961 			newPageInfo = GetPageFromSystem((Mmu::TRamAllocFlags)flags, aBlockZoneId, blockRest);

   897 		if (!DiscardCanStealPage(aOldPageInfo, aBlockRest))

   980 		if (!DiscardCanStealPage(aOldPageInfo, moveDirty))

   955 		}

  1038 		}	

  1039 	MmuLock::Unlock();

   962 		MmuLock::Lock();

  1045 		}

   963 		}	

  1046 

   964 	

   965 	MmuLock::Unlock();

  1008 void DPager::ReturnPageToSystem()

  1089 TBool DPager::TryReturnOldestPageToSystem()

  1012 

  1093 	__NK_ASSERT_DEBUG(iNumberOfFreePages>0);

  1013 	ReturnPageToSystem(*StealOldestPage());

  1094 

  1095 	SPageInfo* pageInfo = StealOrAllocPage(EFalse, (Mmu::TRamAllocFlags)0);

  1096 	

  1097 	// StealOrAllocPage may have released the MmuLock, so check there are still enough pages

  1098 	// to remove one from the live list

  1099 	if (iNumberOfFreePages>0)

  1100 		{

  1101 		ReturnPageToSystem(*pageInfo);

  1102 		return ETrue;

  1103 		}

  1104 	else

  1105 		{

  1106 		AddAsFreePage(pageInfo);

  1107 		return EFalse;

  1108 		}

  1109 	}

  1110 

  1111 

  1112 TUint DPager::AllowAddFreePages(SPageInfo*& aPageInfo, TUint aNumPages)

  1113 	{

  1114 	if (iMinimumPageCount + iNumberOfFreePages == iMaximumPageCount)

  1115 		{// The paging cache is already at the maximum size so steal a page

  1116 		// so it can be returned to the system if required.

  1117 		aPageInfo = StealOrAllocPage(EFalse, (Mmu::TRamAllocFlags)0);

  1118 		__NK_ASSERT_DEBUG(aPageInfo->PagedState() == SPageInfo::EUnpaged);

  1119 		return 1;

  1120 		}

  1121 	// The paging cache is not at its maximum so determine how many can be added to

  1122 	// the paging cache without it growing past its maximum.

  1123 	aPageInfo = NULL;

  1124 	__NK_ASSERT_DEBUG(iMinimumPageCount + iNumberOfFreePages < iMaximumPageCount);

  1125 	if (iMinimumPageCount + iNumberOfFreePages + aNumPages > iMaximumPageCount)

  1126 		{

  1127 		return iMaximumPageCount - (iMinimumPageCount + iNumberOfFreePages);

  1128 		}

  1129 	else

  1130 		return aNumPages;

  1131 	}

  1132 

  1133 

  1134 void DPager::AllowAddFreePage(SPageInfo*& aPageInfo)

  1135 	{

  1136 	if (iMinimumPageCount + iNumberOfFreePages == iMaximumPageCount)

  1137 		{// The paging cache is already at the maximum size so steal a page

  1138 		// so it can be returned to the system if required.

  1139 		aPageInfo = StealOrAllocPage(EFalse, (Mmu::TRamAllocFlags)0);

  1140 		__NK_ASSERT_DEBUG(aPageInfo->PagedState() == SPageInfo::EUnpaged);

  1141 		return;

  1142 		}

  1143 	aPageInfo = NULL;

  1042 	TBool pageCleaningLockHeld = EFalse;

  1172 	// ram alloc mutex may or may not be held

  1043 	SPageInfo* pageInfo;

  1173 	__NK_ASSERT_DEBUG(!MmuLock::IsHeld());

  1044 	TPhysAddr pagePhys;

  1045 	TInt r = KErrGeneral;

  1105 try_steal_oldest_page:

  1177 	MmuLock::Lock();	

  1106 	__NK_ASSERT_ALWAYS(iOldestCleanCount|iOldestDirtyCount|iOldCount|iYoungCount);

  1178 	SPageInfo* pageInfo = StealOrAllocPage(ETrue, aAllocFlags);

  1107 	r = TryStealOldestPage(pageInfo);

  1179 	TBool wasAllocated = pageInfo->Type() == SPageInfo::EUnknown;

  1108 	// if this fails we restart whole process

  1109 	if (r < KErrNone)

  1110 		goto find_a_page;

  1111 

  1112 	// if we need to clean, acquire page cleaning mutex for life of this function

  1113 	if (r == 1)

  1114 		{

  1115 		__NK_ASSERT_ALWAYS(!pageCleaningLockHeld);

  1116 		MmuLock::Unlock();

  1117 		PageCleaningLock::Lock();

  1118 		MmuLock::Lock();

  1119 		pageCleaningLockHeld = ETrue;

  1120 		goto find_a_page;		

  1121 		}

  1122 

  1123 	// otherwise we're done!

  1124 	__NK_ASSERT_DEBUG(r == KErrNone);

  1127 	// make page state same as a freshly allocated page...

  1182 	if (!wasAllocated)

  1128 	pagePhys = pageInfo->PhysAddr();

  1183 		{

  1129 	TheMmu.PagesAllocated(&pagePhys,1,aAllocFlags);

  1184 		// make page state same as a freshly allocated page...

  1130 

  1185 		TPhysAddr pagePhys = pageInfo->PhysAddr();

  1131 done:

  1186 		TheMmu.PagesAllocated(&pagePhys,1,aAllocFlags);

  1132 	if (pageCleaningLockHeld)

  1187 		}

  1133 		PageCleaningLock::Unlock();

  1188 

  1149 		ReturnPageToSystem();

  1204 		if (TryReturnOldestPageToSystem())

  1150 		--aNumPages;

  1205 			--aNumPages;

  1203 		// put page on live list...

  1271 		// put page on live list and free the stolen page...

  1206 

  1274 		if (pageInfo)

  1275 			ReturnPageToSystem(*pageInfo);

  1265 		if(iNumberOfFreePages<1)

  1334 		if(!iNumberOfFreePages)

  1336 	TBool restrictPage = EFalse;

  1412 	TBool retry;

  1337 	SPageInfo* pageInfo = NULL;

  1413 	do

  1338 	TUint oldestCount = iOldestCleanCount + iOldestDirtyCount;

  1414 		{

  1339 	if((iOldCount + oldestCount) * iYoungOldRatio < iYoungCount)

  1415 		retry = EFalse;

  1340 		{

  1416 		TBool restrictPage = EFalse;

  1341 		// Need more old pages so make one young page into an old page...

  1417 		SPageInfo* pageInfo = NULL;

  1342 		__NK_ASSERT_DEBUG(!iYoungList.IsEmpty());

  1418 		TUint oldestCount = iOldestCleanCount + iOldestDirtyCount;

  1343 		__NK_ASSERT_DEBUG(iYoungCount);

  1419 		if((iOldCount + oldestCount) * iYoungOldRatio < iYoungCount)

  1344 		SDblQueLink* link = iYoungList.Last()->Deque();

  1420 			{

  1345 		--iYoungCount;

  1421 			// Need more old pages so make one young page into an old page...

  1346 

  1422 			__NK_ASSERT_DEBUG(!iYoungList.IsEmpty());

  1347 		pageInfo = SPageInfo::FromLink(link);

  1423 			__NK_ASSERT_DEBUG(iYoungCount);

  1348 		pageInfo->SetPagedState(SPageInfo::EPagedOld);

  1424 			SDblQueLink* link = iYoungList.Last()->Deque();

  1349 

  1425 			--iYoungCount;

  1350 		iOldList.AddHead(link);

  1426 

  1351 		++iOldCount;

  1427 			pageInfo = SPageInfo::FromLink(link);

  1352 

  1428 			pageInfo->SetPagedState(SPageInfo::EPagedOld);

  1353 		Event(EEventPageAged,pageInfo);

  1429 

  1354 		// Delay restricting the page until it is safe to release the MmuLock.

  1430 			iOldList.AddHead(link);

  1355 		restrictPage = ETrue;

  1431 			++iOldCount;

  1356 		}

  1432 

  1357 

  1433 			Event(EEventPageAged,pageInfo);

  1358 	// Check we have enough oldest pages.

  1434 			// Delay restricting the page until it is safe to release the MmuLock.

  1359 	if (oldestCount < KMaxOldestPages &&

  1435 			restrictPage = ETrue;

  1360 		oldestCount * iOldOldestRatio < iOldCount)

  1436 			}

  1361 		{

  1437 

  1362 		__NK_ASSERT_DEBUG(!iOldList.IsEmpty());

  1438 		// Check we have enough oldest pages.

  1363 		__NK_ASSERT_DEBUG(iOldCount);

  1439 		if (oldestCount < iMaxOldestPages &&

  1364 		SDblQueLink* link = iOldList.Last()->Deque();

  1440 			oldestCount * iOldOldestRatio < iOldCount)

  1365 		--iOldCount;

  1441 			{

  1366 

  1442 			__NK_ASSERT_DEBUG(!iOldList.IsEmpty());

  1367 		SPageInfo* oldestPageInfo = SPageInfo::FromLink(link);

  1443 			__NK_ASSERT_DEBUG(iOldCount);

  1368 		if (oldestPageInfo->IsDirty())

  1444 			SDblQueLink* link = iOldList.Last()->Deque();

  1369 			{

  1445 			--iOldCount;

  1370 			oldestPageInfo->SetPagedState(SPageInfo::EPagedOldestDirty);

  1446 

  1371 			iOldestDirtyList.AddHead(link);

  1447 			SPageInfo* oldestPageInfo = SPageInfo::FromLink(link);

  1372 			++iOldestDirtyCount;

  1448 			if (oldestPageInfo->IsDirty())

  1373 			PageCleaner::NotifyPagesToClean();

  1449 				{

  1374 			Event(EEventPageAgedDirty,oldestPageInfo);

  1450 				oldestPageInfo->SetOldestPage(SPageInfo::EPagedOldestDirty);

  1375 			}

  1451 				iOldestDirtyList.AddHead(link);

  1376 		else

  1452 				++iOldestDirtyCount;

  1377 			{

  1453 				PageCleaner::NotifyPagesToClean();

  1378 			oldestPageInfo->SetPagedState(SPageInfo::EPagedOldestClean);

  1454 				Event(EEventPageAgedDirty,oldestPageInfo);

  1379 			iOldestCleanList.AddHead(link);

  1455 				}

  1380 			++iOldestCleanCount;

  1456 			else

  1381 			Event(EEventPageAgedClean,oldestPageInfo);

  1457 				{

  1382 			}

  1458 				oldestPageInfo->SetOldestPage(SPageInfo::EPagedOldestClean);

  1383 		}

  1459 				iOldestCleanList.AddHead(link);

  1384 

  1460 				++iOldestCleanCount;

  1385 	if (restrictPage)

  1461 				Event(EEventPageAgedClean,oldestPageInfo);

  1386 		{

  1462 				}

  1387 		// Make the recently aged old page inaccessible.  This is done last as it 

  1463 			}

  1388 		// will release the MmuLock and therefore the page counts may otherwise change.

  1464 

  1389 		RestrictPage(pageInfo,ERestrictPagesNoAccessForOldPage);

  1465 		if (restrictPage)

  1390 		}

  1466 			{

  1467 			// Make the recently aged old page inaccessible.  This is done last as it will release

  1468 			// the MmuLock and therefore the page counts may otherwise change.

  1469 			TInt r = RestrictPage(pageInfo,ERestrictPagesNoAccessForOldPage);

  1470 

  1471 			if (r == KErrInUse)

  1472 				{

  1473 				SPageInfo::TPagedState state = pageInfo->PagedState();

  1474 				if (state == SPageInfo::EPagedOld ||

  1475 					state == SPageInfo::EPagedOldestClean ||

  1476 					state == SPageInfo::EPagedOldestDirty)

  1477 					{

  1478 					// The restrict operation failed, but the page was left in an old state.  This

  1479 					// can happen when:

  1480 					//  

  1481 					//  - pages are in the process of being pinned - the mapping will veto the

  1482 					//    restriction

  1483 					//  - pages are rejuvenated and then become quickly become old again

  1484 					//  

  1485 					// In the second instance the page will be needlessly rejuvenated because we

  1486 					// can't tell that it has actually been restricted by another thread

  1487 					RemovePage(pageInfo);

  1488 					AddAsYoungestPage(pageInfo);

  1489 					retry = ETrue;

  1490 					}

  1491 				}

  1492 			}

  1493 		}

  1494 	while (retry);

  1399 		ReturnPageToSystem();

  1503 		TryReturnOldestPageToSystem();

  1854 	iNumberOfFreePages += aNumPages;

  1971 	while (aNumPages)

  1855 	RemoveExcessPages();

  1972 		{

  1856 

  1973 		SPageInfo* pageInfo;

  1974 		// This may release the ram alloc lock but it will flash the mmulock

  1975 		// if not all pages could be added in one go, i.e. freePages != aNumPages.

  1976 		TUint freePages = AllowAddFreePages(pageInfo, aNumPages);

  1977 		iNumberOfFreePages += freePages;

  1978 		aNumPages -= freePages;

  1979 		if (pageInfo)

  1980 			ReturnPageToSystem(*pageInfo);

  1981 		}

  1982 

  1983 	__NK_ASSERT_DEBUG((iMinimumPageCount + iNumberOfFreePages) <= iMaximumPageCount);

  1996 	TRACE(("DPager::ResizeLiveList(%d,%d) current young=%d old=%d min=%d free=%d max=%d",aMinimumPageCount,aMaximumPageCount,iYoungCount,iOldCount,iMinimumPageCount,iNumberOfFreePages,iMaximumPageCount));

  2123 	TRACE(("DPager::ResizeLiveList(%d,%d) current: %d %d %d %d, %d %d %d",

  2124 		   aMinimumPageCount,aMaximumPageCount,

  2125 		   iYoungCount,iOldCount,iOldestCleanCount,iOldestDirtyCount,

  2126 		   iMinimumPageCount,iNumberOfFreePages,iMaximumPageCount));

  2008 	if(aMinimumPageCount>aMaximumPageCount)

  2138 	if(aMinimumPageCount > aMaximumPageCount)

  2010 

  2140 	

  2021 	if(iMinimumPageLimit<iAbsoluteMinPageCount)

  2156 	if(iMinimumPageLimit < iAbsoluteMinPageCount)

  2023 	if(aMinimumPageCount<iMinimumPageLimit+iReservePageCount)

  2158 	if(aMinimumPageCount < iMinimumPageLimit + iReservePageCount)

  2024 		aMinimumPageCount = iMinimumPageLimit+iReservePageCount;

  2159 		aMinimumPageCount = iMinimumPageLimit + iReservePageCount;

  2025 	if(aMaximumPageCount<aMinimumPageCount)

  2160 	if(aMaximumPageCount < aMinimumPageCount)

  2026 		aMaximumPageCount=aMinimumPageCount;

  2161 		aMaximumPageCount = aMinimumPageCount;

  2033 	TInt spare = iMinimumPageCount-aMinimumPageCount;

  2168 	if(aMinimumPageCount < iMinimumPageCount)

  2034 	if(spare>0)

  2169 		{

  2035 		{

  2170 		iNumberOfFreePages += iMinimumPageCount - aMinimumPageCount;

  2036 		iMinimumPageCount -= spare;

  2171 		iMinimumPageCount = aMinimumPageCount;

  2037 		iNumberOfFreePages += spare;

  2041 	TInt r=KErrNone;

  2175 	TInt r = KErrNone;

  2042 	while(iMinimumPageCount<aMinimumPageCount)

  2176 	while(aMinimumPageCount > iMinimumPageCount)

  2043 		{

  2177 		{

  2044 		TUint newMin = aMinimumPageCount;

  2178 		TUint newMin = MinU(aMinimumPageCount, iMinimumPageCount + iNumberOfFreePages);

  2045 		TUint maxMin = iMinimumPageCount+iNumberOfFreePages;

  2179 		

  2046 		if(newMin>maxMin)

  2180 		if (newMin == iMinimumPageCount)

  2047 			newMin = maxMin;

  2181 			{

  2048 

  2182 			// have to add pages before we can increase minimum page count

  2049 		TUint delta = newMin-iMinimumPageCount;

  2183 			if(!TryGrowLiveList())

  2050 		if(delta)

  2184 				{

  2051 			{

  2185 				r = KErrNoMemory;

  2186 				break;

  2187 				}

  2188 			}

  2189 		else

  2190 			{

  2191 			iNumberOfFreePages -= newMin - iMinimumPageCount;

  2065 	while(iMaximumPageCount>aMaximumPageCount)

  2197 	while(aMaximumPageCount < iMaximumPageCount)

  2066 		{

  2198 		{

  2067 		TUint newMax = aMaximumPageCount;

  2199 		TUint newMax = MaxU(aMaximumPageCount, iMinimumPageCount + iNumberOfFreePages);

  2068 		TUint minMax = iMinimumPageCount+iNumberOfFreePages;

  2200 

  2069 		if(newMax<minMax)

  2201 		if (newMax == iMaximumPageCount)

  2070 			newMax = minMax;

  2202 			{

  2071 

  2203 			// have to remove pages before we can reduce maximum page count

  2072 		TUint delta = iMaximumPageCount-newMax;

  2204 			TryReturnOldestPageToSystem();

  2073 		if(delta)

  2205 			}

  2206 		else

  2076 			continue;

  2209 			}

  2077 			}

  2210 		}

  2078 

  2211 	

  2079 		ReturnPageToSystem();

  2212 	TRACE(("DPager::ResizeLiveList end: %d %d %d %d, %d %d %d",

  2080 		}

  2213 		   iYoungCount,iOldCount,iOldestCleanCount,iOldestDirtyCount,

  2081 

  2214 		   iMinimumPageCount,iNumberOfFreePages,iMaximumPageCount));

  2082 	TRACE(("DPager::ResizeLiveList end with young=%d old=%d min=%d free=%d max=%d",iYoungCount,iOldCount,iMinimumPageCount,iNumberOfFreePages,iMaximumPageCount));

  2215 	

  2216 	__NK_ASSERT_DEBUG((iMinimumPageCount + iNumberOfFreePages) <= iMaximumPageCount);