Function report

Linux Kernel

v5.5.9

Brick Technologies Co., Ltd

Source Code:include\linux\page-flags.h Create Date:2022-07-28 05:36:14
Last Modify:2020-03-12 14:18:49 Copyright©Brick
home page Tree
Annotation kernel can get tool activityDownload SCCTChinese

Name:PageLRU

Proto:static inline __attribute__((__always_inline__)) int PageLRU(struct page *page)

Type:int

Parameter:

TypeParameterName
struct page *page
320  Return st_bit - Determine whether a bit is set*@nr: bit number to test*@addr: Address to start counting from
Caller
NameDescribe
__page_cache_releaseThis 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_pageWriteback 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_accessedMark 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_addlru_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_unevictablelru_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_fnIf 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_pagedeactivate_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_lazyfreemark_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_pageslease_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_tailsed by __split_huge_page_refcount()
__pagevec_lru_add_fn
shrink_page_listshrink_page_list() returns the number of reclaimed pages
__isolate_lru_pageAttempt 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_pagespgdat->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_pagesolate_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_lruThis 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_pagesheck_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_blocksolate_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_evictionworkingset_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_pageIsolate a page from LRU with optional get_page() pin.* Assumes lru_lock already held and page already pinned.
__putback_lru_fast_preparePrepare 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_munlockry_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_freepagesMove 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_pagesThis 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_accountmem_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_chargemem_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_swapoutmem_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_pageWhen 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_mappingsDo all that is necessary to remove user space mappings. Unmap* the pages and send SIGBUS to the processes if the data was dirty.
memory_failurememory_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_pageIdle 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