page_count

Type	Parameter	Name
struct page *	page

**Caller**
Name	Describe
unaccount_page_cache_page
page_cache_free_page
is_page_cache_freeable
shrink_page_list	shrink_page_list() returns the number of reclaimed pages
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.
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
vm_insert_page	vm_insert_page - insert single page into user vma@vma: user vma to map to@addr: target user address of this page@page: source kernel page This allows drivers to insert individual pages they've allocated* into a user vma.
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_is_buddy	This function checks whether a page is free && is the buddy* we can coalesce a page and its buddy if* (a) the buddy is not in a hole (check before calling!) &&* (b) the buddy is in the buddy system &&* (c) a page and its buddy have the same order &&
split_page	split_page takes a non-compound higher-order page, and splits it into* n (1<
free_contig_range
__free_huge_page
dissolve_free_huge_page	Dissolve a given free hugepage into free buddy pages. This function does* nothing for in-use hugepages and non-hugepages.* This function returns values like below:* -EBUSY: failed to dissolved free hugepages or the hugepage is in-use
gather_surplus_pages	Increase the hugetlb pool such that it can accommodate a reservation* of size 'delta'.
gather_bootmem_prealloc	Put bootmem huge pages into the standard lists after mem_map is up
follow_hugetlb_page
write_protect_page
migrate_page_move_mapping	Replace the page in the mapping.* The number of remaining references must be:* 1 for anonymous pages without a mapping* 2 for pages with a mapping* 3 for pages with a mapping and PagePrivate/PagePrivate2 set.
migrate_huge_page_move_mapping	The expected number of remaining references is the same as that* of migrate_page_move_mapping().
__buffer_migrate_page
unmap_and_move	Obtain the lock on page, remove all ptes and migrate the page* to the newly allocated page in newpage.
__split_huge_pmd_locked
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
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.
page_action
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
unpoison_memory	poison_memory - Unpoison a previously poisoned page@pfn: Page number of the to be unpoisoned page Software-unpoison a page that has been poisoned by* memory_failure() earlier
__soft_offline_page
kmemleak_scan	Scan data sections and all the referenced memory blocks allocated via the* kernel's standard allocators. This function must be called with the* scan_mutex held.
memfd_tag_pins
memfd_wait_for_pins	Setting SEAL_WRITE requires us to verify there's no pending writer. However,* via get_user_pages(), drivers might have some pending I/O without any active* user-space mappings (eg., direct-IO, AIO). Therefore, we look at all pages
anon_pipe_buf_release
anon_pipe_buf_steal
generic_pipe_buf_steal	generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer@pipe: the pipe that the buffer belongs to@buf: the buffer to attempt to steal* Description:* This function attempts to steal the &struct page attached to*@buf
aio_free_ring
aio_setup_ring

Function report