PageLRU

Type	Parameter	Name
struct page *	page

**Caller**
Name	Describe
__page_cache_release	This path almost never happens for VM activity - pages are normally* freed via pagevecs. But it gets used by networking.
pagevec_move_tail_fn
rotate_reclaimable_page	Writeback is about to end against a page which has been marked for immediate* reclaim. If it still appears to be reclaimable, move it to the tail of the* inactive list.
__activate_page
mark_page_accessed	Mark a page as having seen activity.* inactive,unreferenced -> inactive,referenced* inactive,referenced -> active,unreferenced* active,unreferenced -> active,referenced* When a newly allocated page is not yet visible, so safe for non-atomic ops,
lru_cache_add	lru_cache_add - add a page to a page list@page: the page to be added to the LRU. Queue the page for addition to the LRU via pagevec. The decision on whether* to add the page to the [in]active [file\|anon] list is deferred until the* pagevec is drained
lru_cache_add_active_or_unevictable	lru_cache_add_active_or_unevictable@page: the page to be added to LRU@vma: vma in which page is mapped for determining reclaimability* Place @page on the active or unevictable LRU list, depending on its* evictability
lru_deactivate_file_fn	If the page can not be invalidated, it is moved to the* inactive list to speed up its reclaim. It is moved to the* head of the list, rather than the tail, to give the flusher* threads some time to write it out, as this is much more
lru_deactivate_fn
lru_lazyfree_fn
deactivate_page	deactivate_page - deactivate a page@page: page to deactivate deactivate_page() moves @page to the inactive list if @page was on the active* list and was not an unevictable page. This is done to accelerate the reclaim* of @page.
mark_page_lazyfree	mark_page_lazyfree - make an anon page lazyfree@page: page to deactivate mark_page_lazyfree() moves @page to the inactive file list.* This is done to accelerate the reclaim of @page.
release_pages	lease_pages - batched put_page()@pages: array of pages to release@nr: number of pages* Decrement the reference count on all the pages in @pages. If it* fell to zero, remove the page from the LRU and free it.
lru_add_page_tail	sed by __split_huge_page_refcount()
__pagevec_lru_add_fn
shrink_page_list	shrink_page_list() returns the number of reclaimed pages
__isolate_lru_page	Attempt to remove the specified page from its LRU. Only take this page* if it is of the appropriate PageActive status. Pages which are being* freed elsewhere are also ignored.* returns 0 on success, -ve errno on failure.
isolate_lru_pages	pgdat->lru_lock is heavily contended. Some of the functions that* shrink the lists perform better by taking out a batch of pages* and working on them outside the LRU lock.* For pagecache intensive workloads, this function is the hottest
isolate_lru_page	solate_lru_page - tries to isolate a page from its LRU list@page: page to isolate from its LRU list Isolates a @page from an LRU list, clears PageLRU and adjusts the* vmstat statistic corresponding to whatever LRU list the page was on.
move_pages_to_lru	This moves pages from @list to corresponding LRU list.* We move them the other way if the page is referenced by one or more* processes, from rmap.* If the pages are mostly unmapped, the processing is fast and it is
check_move_unevictable_pages	heck_move_unevictable_pages - check pages for evictability and move to* appropriate zone lru list@pvec: pagevec with lru pages to check Checks pages for evictability, if an evictable page is in the unevictable
isolate_migratepages_block	solate_migratepages_block() - isolate all migrate-able pages within* a single pageblock@cc: Compaction control structure.@low_pfn: The first PFN to isolate*@end_pfn: The one-past-the-last PFN to isolate, within same pageblock
workingset_eviction	workingset_eviction - note the eviction of a page from memory@target_memcg: the cgroup that is causing the reclaim@page: the page being evicted* Returns a shadow entry to be stored in @page->mapping->i_pages in place
check_and_migrate_cma_pages
__munlock_isolate_lru_page	Isolate a page from LRU with optional get_page() pin.* Assumes lru_lock already held and page already pinned.
__putback_lru_fast_prepare	Prepare page for fast batched LRU putback via putback_lru_evictable_pagevec()* The fast path is available only for evictable pages with single mapping.* Then we can bypass the per-cpu pvec and get better performance.
try_to_munlock	ry_to_munlock - try to munlock a page@page: the page to be munlocked Called from munlock code. Checks all of the VMAs mapping the page* to make sure nobody else has this page mlocked. The page will be
move_freepages	Move the free pages in a range to the free lists of the requested type.* Note that start_page and end_pages are not aligned on a pageblock* boundary. If alignment is required, use move_freepages_block()
has_unmovable_pages	This function checks whether pageblock includes unmovable pages or not.* If @count is not zero, it is okay to include less @count unmovable pages* PageLRU check without isolation or lru_lock could race so that
__collapse_huge_page_isolate
khugepaged_scan_pmd
lock_page_lru
unlock_page_lru
mem_cgroup_move_account	mem_cgroup_move_account - move account of the page@page: the page@compound: charge the page as compound or small page@from: mem_cgroup which the page is moved from.@to: mem_cgroup which the page is moved to. @from != @to.
mem_cgroup_commit_charge	mem_cgroup_commit_charge - commit a page charge@page: page to charge@memcg: memcg to charge the page to@lrucare: page might be on LRU already@compound: charge the page as compound or small page* Finalize a charge transaction started by
uncharge_page
mem_cgroup_swapout	mem_cgroup_swapout - transfer a memsw charge to swap@page: page whose memsw charge to transfer@entry: swap entry to move the charge to* Transfer the memsw charge of @page to @entry.
shake_page	When a unknown page type is encountered drain as many buffers as possible* in the hope to turn the page into a LRU or free page, which we can handle.
hwpoison_user_mappings	Do all that is necessary to remove user space mappings. Unmap* the pages and send SIGBUS to the processes if the data was dirty.
memory_failure	memory_failure - Handle memory failure of a page.@pfn: Page Number of the corrupted page@flags: fine tune action taken* This function is called by the low level machine check code* of an architecture when it detects hardware memory corruption* of a page
get_any_page
__soft_offline_page
hwpoison_inject
page_idle_get_page	Idle page tracking only considers user memory pages, for other types of* pages the idle flag is always unset and an attempt to set it is silently* ignored

Function report