PageAnon

Type	Parameter	Name
struct page *	page

**Caller**
Name	Describe
get_futex_key	get_futex_key() - Get parameters which are the keys for a futex@uaddr: virtual address of the futex@fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED*@key: address where result is stored
__replace_page	__replace_page - replace page in vma by new page
uprobe_write_opcode	NOTE:* Expect the breakpoint instruction to be the smallest size instruction for* the architecture
lru_lazyfree_fn
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.
page_check_dirty_writeback	Check if a page is dirty or under writeback
shrink_page_list	shrink_page_list() returns the number of reclaimed pages
__page_mapcount	Slow path of page_mapcount() for compound pages
__dump_page
zap_pte_range
insert_page	This is the old fallback for page remapping.* For historical reasons, it only allows reserved pages. Only* old drivers should use this, and they needed to mark their* pages reserved for the old functions anyway.
fault_dirty_shared_page	Handle dirtying of a page in shared file mapping on a write fault.* The function expects the page to be locked and unlocks it.
wp_page_copy	Handle the case of a page which we actually need to copy to a new page.* Called with mmap_sem locked and the old page referenced, but* without the ptl held.* High level logic flow:* - Allocate a page, copy the content of the old page to the new one.
do_wp_page	This routine handles present pages, when users try to write* to a shared page. It is done by copying the page to a new address* and decrementing the shared-page counter for the old page.* Note that this routine assumes that the protection checks have been
page_address_in_vma	At what user virtual address is page expected in vma?* Caller should check the page is actually part of the vma.
page_referenced	page_referenced - test if the page was referenced@page: the page to test@is_locked: caller holds lock on the page@memcg: target memory cgroup@vm_flags: collect encountered vma->vm_flags who actually referenced the page* Quick test_and_clear_referenced
__page_set_anon_rmap	__page_set_anon_rmap - set up new anonymous rmap@page: Page or Hugepage to add to rmap@vma: VM area to add page to.@address: User virtual address of the mapping @exclusive: the page is exclusively owned by the current process
page_remove_rmap	page_remove_rmap - take down pte mapping from a page@page: page to remove mapping from@compound: uncharge the page as compound or small page* The caller needs to hold the pte lock.
try_to_unmap_one	@arg: enum ttu_flags will be passed to this argument
try_to_unmap	ry_to_unmap - try to remove all page table mappings to a page@page: the page to get unmapped@flags: action and flags* Tries to remove all the page table entries which are mapping this* page, used in the pageout path. Caller must hold the page lock.
rmap_walk
rmap_walk_locked	Like rmap_walk, but caller holds relevant rmap lock
hugetlb_cow	Hugetlb_cow() should be called with page lock of the original hugepage held.* Called with hugetlb_instantiation_mutex held and pte_page locked so we* cannot race with other handlers or page migration.
get_mergeable_page
try_to_merge_one_page	ry_to_merge_one_page - take two pages and merge them into one@vma: the vma that holds the pte pointing to page@page: the PageAnon page that we want to replace with kpage*@kpage: the PageKsm page that we want to map instead of page,
scan_get_next_rmap_item
remove_migration_pte	Restore a potential migration pte to a working pte entry
__unmap_and_move
unmap_and_move_huge_page	Counterpart of unmap_and_move_page() for hugepage migration
follow_trans_huge_pmd
zap_huge_pmd
unmap_page
__split_huge_page_tail
__split_huge_page
total_mapcount
can_split_huge_page	Racy check whether the huge page can be split
split_huge_page_to_list	This function splits huge page into normal pages. @page can point to any* subpage of huge page to split. Split doesn't change the position of @page.* Only caller must hold pin on the @page, otherwise split fails with -EBUSY.* The huge page must be locked.
__collapse_huge_page_isolate
khugepaged_scan_pmd
mem_cgroup_charge_statistics
mc_handle_present_pte
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.
uncharge_page
mem_cgroup_migrate	mem_cgroup_migrate - charge a page's replacement@oldpage: currently circulating page@newpage: replacement page* Charge @newpage as a replacement page for @oldpage. @oldpage will* be uncharged upon free.
collect_procs	Collect the processes who have the corrupted page mapped to kill.
me_pagecache_clean	Clean (or cleaned) page cache page.
me_huge_page	Huge pages. Needs work.* Issues:* - Error on hugepage is contained in hugepage unit (not in raw page unit.)* To narrow down kill region to one page, we need to break up pmd.
get_hwpoison_page	get_hwpoison_page() - Get refcount for memory error handling:@page: raw error page (hit by memory error) Return: return 0 if failed to grab the refcount, otherwise true (some* non-zero value.)
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
soft_offline_in_use_page
page_idle_clear_pte_refs

Function report