kernel/vm/vm_page.cpp

853 		VMPageQueue::Iterator it = pageQueueInfos[i].queue->GetIterator();
854 		while (vm_page* p = it.Next()) {
1168 	for (PageReservationWaiterList::Iterator it
1170 		PageReservationWaiter* waiter = it.Next();) {
1792 	Given enough time, it will clear out all pages from the free queue - we
1793 	could probably slow it down after having reached a certain threshold.
2029 	// We have a modified page -- however, while we're writing it back,
2031 	// page, we mark it clean before actually writing it back; if
2032 	// writing the page fails for some reason, we'll just keep it in the
2036 	// had the chance to write it back, then we'll write it again later -- that
2062 		// put it into the active/inactive queue
2074 			// it now.
2081 			// Writing the page failed -- mark the page modified and move it to
2083 			// keep trying to write it over and over again. We keep
2380 		// depending on how urgent it becomes to get pages to disk, we adjust
2420 			// locking the cache, just ignore it.
2441 				// We can't/don't want to do anything with this page, so move it
2452 			// We need our own reference to the store, as it might currently be
2539 			// We need to mark the page modified, since otherwise it could be
2616 		// vm_page_allocate_page_run() can pick it up), since they would be
2671 		// atomic. Beyond that it doesn't really matter. We have to unlock the
2749 	// it is relatively expensive to page out pages, we do that on a grander
2795 		// unmap the page, if it hasn't been accessed.
2861 	// wake up the page writer, if we tossed it some pages
3089 		for (PageReservationWaiterList::Iterator it
3091 			(otherWaiter = it.Next()) != NULL;) {
3160 	VMCachePagesTree::Iterator it
3164 		vm_page* page = it.Next();
3245 	Note, however, that it might not do this immediately, and it can well
3266 	for (VMCachePagesTree::Iterator it
3268 			vm_page *page = it.Next();) {
3426 		"thread's address space and for the page it is mapped to (if any)\n"
3644 	// clear the page, if we had to take it from the free queue and a clear
3688 	will unlock regardless of whether it succeeds or fails.
3690 	If the function fails, it cleans up after itself, i.e. it will free all
3691 	pages it managed to allocate.
3741 				// Probably a page was cached when our caller checked. Now it's
3786 			// free the page, if it is still cached
3822 		for (VMPageQueue::PageList::Iterator it = freePages.GetIterator();
3823 				vm_page* page = it.Next();) {
3861 		acceptable physical address where the page run may end (i.e. it must
3974 			// apparently a cached page couldn't be allocated -- skip it and
4065 		// when it requeues busy pages. The reason is that vm_soft_fault()
4114 	use by being reclaimed as well (IOW it factors in things like cache pages
4146 	// only, it is not really worth introducing such locking. Therefore we just