kernel/vm/vm_page.cpp

93 // queue.
131 // lock, otherwise, a read lock suffices (each queue still has a spinlock to
830 		VMPageQueue*	queue;
853 		VMPageQueue::Iterator it = pageQueueInfos[i].queue->GetIterator();
856 				kprintf("found page %p in queue %p (%s)\n", page,
857 					pageQueueInfos[i].queue, pageQueueInfos[i].name);
863 	kprintf("page %p isn't in any queue\n", page);
974 		kprintf("queue:           %p\n", page->queue);
1028 	struct VMPageQueue *queue;
1036 		queue = (VMPageQueue*)strtoul(argv[1], NULL, 16);
1038 		queue = &sFreePageQueue;
1040 		queue = &sClearPageQueue;
1042 		queue = &sModifiedPageQueue;
1044 		queue = &sActivePageQueue;
1046 		queue = &sInactivePageQueue;
1048 		queue = &sCachedPageQueue;
1050 		kprintf("page_queue: unknown queue \"%s\".\n", argv[1]);
1054 	kprintf("queue = %p, queue->head = %p, queue->tail = %p, queue->count = %"
1055 		B_PRIuPHYSADDR "\n", queue, queue->Head(), queue->Tail(),
1056 		queue->Count());
1059 		struct vm_page *page = queue->Head();
1062 		for (page_num_t i = 0; page; i++, page = queue->Next(page)) {
1173 	kprintf("\nfree queue: %p, count = %" B_PRIuPHYSADDR "\n", &sFreePageQueue,
1175 	kprintf("clear queue: %p, count = %" B_PRIuPHYSADDR "\n", &sClearPageQueue,
1177 	kprintf("modified queue: %p, count = %" B_PRIuPHYSADDR " (%" B_PRId32
1181 	kprintf("active queue: %p, count = %" B_PRIuPHYSADDR "\n",
1183 	kprintf("inactive queue: %p, count = %" B_PRIuPHYSADDR "\n",
1185 	kprintf("cached queue: %p, count = %" B_PRIuPHYSADDR "\n",
1670 		// state, even if we don't change the queue. We actually don't have to
1671 		// do this, though, since only for the active queue there are different
1690 /*! Moves a previously modified page into a now appropriate queue.
1758 				VMPageQueue& queue = page->State() == PAGE_STATE_FREE
1760 				queue.Remove(page);
1788 	and moves some pages from the free queue over to the clear queue.
1789 	Given enough time, it will clear out all pages from the free queue - we
1818 		// get some pages from the free queue, mostly sorted
1850 		// and put them into the clear queue
1880 	marker.queue = NULL;
2059 		// put it into the active/inactive queue
2079 			// an appropriate queue other than the modified queue, so we don't
2081 			// non-temporary pages in the modified queue, though, so they don't
2082 			// get lost in the inactive queue.
2329 	queue, writes them back, and moves them back to the active queue.
2365 			// We ran through the whole queue without being able to write a
2560 		// Get the first free pages of the (in)active queue
2563 		// Get the next page of the current queue
2658 	VMPageQueue& queue = sActivePageQueue;
2660 	// We want to scan the whole queue in roughly kIdleRunsForFullQueue runs.
2661 	uint32 maxToScan = queue.Count() / kIdleRunsForFullQueue + 1;
2669 		// queue anyway to lock the page's cache, and we'll recheck afterwards.
2670 		vm_page* page = queue.Head();
2680 			// page is no longer in the cache or in this queue
2745 	// Determine how many pages at maximum to send to the modified queue. Since
2753 	VMPageQueue& queue = sInactivePageQueue;
2754 	InterruptsSpinLocker queueLocker(queue.GetLock());
2755 	uint32 maxToScan = queue.Count();
2757 	vm_page* nextPage = queue.Head();
2766 		nextPage = queue.Next(page);
2772 		queue.InsertAfter(page, &marker);
2782 			nextPage = queue.Next(&marker);
2783 			queue.Remove(&marker);
2812 		// Move to fitting queue or requeue:
2813 		// * Active mapped pages go to the active queue.
2816 		//   the cached queue, otherwise to the modified queue (up to a limit).
2846 		nextPage = queue.Next(&marker);
2847 		queue.Remove(&marker);
2870 	VMPageQueue& queue = sActivePageQueue;
2871 	InterruptsSpinLocker queueLocker(queue.GetLock());
2872 	uint32 maxToScan = queue.Count();
2886 	vm_page* nextPage = queue.Head();
2895 		nextPage = queue.Next(page);
2901 		queue.InsertAfter(page, &marker);
2910 			nextPage = queue.Next(&marker);
2911 			queue.Remove(&marker);
2945 		nextPage = queue.Next(&marker);
2946 		queue.Remove(&marker);
2971 	// Walk the active list and move pages to the inactive queue.
3000 	// Walk the active list and move pages to the inactive queue.
3324 	sModifiedPageQueue.Init("modified pages queue");
3325 	sInactivePageQueue.Init("inactive pages queue");
3326 	sActivePageQueue.Init("active pages queue");
3327 	sCachedPageQueue.Init("cached pages queue");
3328 	sFreePageQueue.Init("free pages queue");
3329 	sClearPageQueue.Init("clear pages queue");
3424 	add_debugger_command("page_queue", &dump_page_queue, "Dump page queue");
3426 		"Find out which queue a page is actually in");
3581 	VMPageQueue* queue;
3585 		queue = &sClearPageQueue;
3588 		queue = &sFreePageQueue;
3594 	vm_page* page = queue->RemoveHeadUnlocked();
3596 		// if the primary queue was empty, grab the page from the
3597 		// secondary queue
3602 			// between the queues after we checked the first queue. Grab the
3607 			page = queue->RemoveHead();
3638 	// clear the page, if we had to take it from the free queue and a clear
3658 	// Page lists are sorted, so remove tails before prepending to the respective queue.
3822 	// add pages to target queue
4048 /*!	Moves a page to either the tail of the head of its current queue,
4065 	VMPageQueue *queue = NULL;
4069 			queue = &sActivePageQueue;
4072 			queue = &sInactivePageQueue;
4075 			queue = &sModifiedPageQueue;
4078 			queue = &sCachedPageQueue;
4093 	queue->RequeueUnlocked(page, tail);
4153 	// modified queue count is therefore split into temporary and non-temporary