Function report

Linux Kernel

v5.5.9

Brick Technologies Co., Ltd

Source Code:mm\filemap.c Create Date:2022-07-28 14:01:37
Last Modify:2020-03-12 14:18:49 Copyright©Brick
home page Tree
Annotation kernel can get tool activityDownload SCCTChinese

Name:lock_page - unlock a locked page*@page: the page* Unlocks the page and wakes up sleepers in ___wait_on_page_locked().* Also wakes sleepers in wait_on_page_writeback() because the wakeup* mechanism between PageLocked pages and PageWriteback pages is shared.

Proto:void unlock_page(struct page *page)

Type:void

Parameter:

TypeParameterName
struct page *page
1313  BUILD_BUG_ON - break compile if a condition is true(PG_waiters != 7)
1314  page = compound_head(page)
1315  VM_BUG_ON_PAGE(!PageLocked(page), page)
1316  If lear_bit_unlock_is_negative_byte - Clear a bit in memory and test if bottom* byte is negative, for unlock Then wake_up_page_bit(page, PG_locked)
Caller
NameDescribe
__replace_page__replace_page - replace page in vma by new page
page_endioAfter completing I/O on a page, call this routine to update the page* flags appropriately
find_lock_entryd_lock_entry - locate, pin and lock a page cache entry*@mapping: the address_space to search*@offset: the page cache index* Looks up the page cache slot at @mapping & @offset. If there is a* page cache page, it is returned locked and with an increased
pagecache_get_pagepagecache_get_page - find and get a page reference*@mapping: the address_space to search*@offset: the page index*@fgp_flags: PCG flags*@gfp_mask: gfp mask to use for the page cache data page allocation* Looks up the page cache slot at @mapping & @offset.
generic_file_buffered_readgeneric_file_buffered_read - generic file read routine*@iocb: the iocb to read*@iter: data destination*@written: already copied* This is a generic file read routine, and uses the* mapping->a_ops->readpage() function for the actual low-level stuff.
filemap_faultlemap_fault - read in file data for page fault handling*@vmf: struct vm_fault containing details of the fault* filemap_fault() is invoked via the vma operations vector for a* mapped memory region to read in file data during a page fault
filemap_map_pages
filemap_page_mkwrite
do_read_cache_page
write_cache_pageswrite_cache_pages - walk the list of dirty pages of the given address space and write all of them
write_one_pagewrite_one_page - write out a single page and wait on I/O*@page: the page to write* The page must be locked by the caller and will be unlocked upon return
set_page_dirty_lockset_page_dirty() is racy if the caller has no reference against* CPU could truncate the page off the mapping and then free the mapping.* Usually, the page _is_ locked, or the caller is a user-space process which
read_cache_pages_invalidate_pagesee if a page needs releasing upon read_cache_pages() failure* - the caller of read_cache_pages() may have set PG_private or PG_fscache* before calling, such as the NFS fs marking pages that are cached locally* on disk, thus we need to give the fs a
truncate_inode_pages_rangeruncate_inode_pages_range - truncate range of pages specified by start & end byte offsets*@mapping: mapping to truncate*@lstart: offset from which to truncate*@lend: offset to which to truncate (inclusive)* Truncate the page cache, removing the pages that
invalidate_mapping_pagesvalidate_mapping_pages - Invalidate all the unlocked pages of one inode*@mapping: the address_space which holds the pages to invalidate*@start: the offset 'from' which to invalidate*@end: the offset 'to' which to invalidate (inclusive)* This function only
invalidate_inode_pages2_rangevalidate_inode_pages2_range - remove range of pages from an address_space*@mapping: the address_space*@start: the page offset 'from' which to invalidate*@end: the page offset 'to' which to invalidate (inclusive)* Any pages which are found to be mapped
pagecache_isize_extendedpagecache_isize_extended - update pagecache after extension of i_size*@inode: inode for which i_size was extended*@from: original inode size*@to: new inode size* Handle extension of inode size either caused by extending truncate or by
handle_write_errorWe detected a synchronous write error writing a page out. Probably* -ENOSPC. We need to propagate that into the address_space for a subsequent* fsync(), msync() or close().* The tricky part is that after writepage we cannot touch the mapping: nothing
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.
shrink_active_list
follow_page_pte
follow_pmd_mask
do_page_mkwriteNotify the address space that the page is about to become writable so that* it can prohibit this or wait for the page to get into an appropriate state.* We do this without the lock held, so that it can sleep if it needs to.
fault_dirty_shared_pageHandle 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_copyHandle 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.
wp_page_shared
do_wp_pageThis 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
do_swap_pageWe enter with non-exclusive mmap_sem (to exclude vma changes,* but allow concurrent faults), and pte mapped but not yet locked.* We return with pte unmapped and unlocked.* We return with the mmap_sem locked or unlocked in the same cases
__do_faultThe mmap_sem must have been held on entry, and may have been* released depending on flags and vma->vm_ops->fault() return value.* See filemap_fault() and __lock_page_retry().
do_read_fault
do_cow_fault
do_shared_fault
__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.
__munlock_pagevecMunlock a batch of pages from the same zone* The work is split to two main phases
munlock_vma_pages_rangemunlock_vma_pages_range() - munlock all pages in the vma range.'*@vma - vma containing range to be munlock()ed.*@start - start address in @vma of the range*@end - end of range in @vma.* For mremap(), munmap() and exit().* Called with @vma VM_LOCKED.
page_referencedpage_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
madvise_cold_or_pageout_pte_range
madvise_free_pte_range
end_swap_bio_read
swap_writepageWe may have stale swap cache pages in memory: notice* them here and get rid of the unnecessary final write.
__swap_writepage
swap_readpage
free_swap_cacheIf we are the only user, then try to free up the swap cache. * Its ok to check for PageSwapCache without the page lock* here because we are going to recheck again inside* try_to_free_swap() _with_ the lock.* - Marcelo
__try_to_reclaim_swaprns 1 if swap entry is freed
unuse_pteNo need to decide whether this PTE shares the swap entry with others,* just let do_wp_page work it out if a write is requested later - to* force COW, vm_page_prot omits write permission from any private vma.
unuse_pte_range
try_to_unuseIf the boolean frontswap is true, only unuse pages_to_unuse pages;* pages_to_unuse==0 means all pages; ignored if frontswap is false
hugetlb_no_page
hugetlb_fault
hugetlb_mcopy_atomic_pteUsed by userfaultfd UFFDIO_COPY. Based on mcopy_atomic_pte with* modifications for huge pages.
get_ksm_pageget_ksm_page: checks if the page indicated by the stable node* is still its ksm page, despite having held no reference to it.* In which case we can trust the content of the page, and it* returns the gotten page; but if the page has now been zapped,
remove_rmap_item_from_treeRemoving rmap_item from stable or unstable tree.* This function will clean the information from the stable/unstable tree.
try_to_merge_one_pagery_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,
stable_tree_searchstable_tree_search - search for page inside the stable tree* This function checks if there is a page inside the stable tree* with identical content to the page that we are scanning right now
cmp_and_merge_pagemp_and_merge_page - first see if page can be merged into the stable tree;* if not, compare checksum to previous and if it's the same, see if page can* be inserted into the unstable tree, or merged with a page already there and
isolate_movable_page
putback_movable_pagesPut previously isolated pages back onto the appropriate lists* from where they were once taken off for compaction/migration.* This function shall be used whenever the isolated pageset has been* built from lru, balloon, hugetlbfs page
__unmap_and_move
unmap_and_moveObtain the lock on page, remove all ptes and migrate the page* to the newly allocated page in newpage.
unmap_and_move_huge_pageCounterpart of unmap_and_move_page() for hugepage migration
migrate_pagesmigrate_pages - migrate the pages specified in a list, to the free pages* supplied as the target for the page migration*@from: The list of pages to be migrated.*@get_new_page: The function used to allocate free pages to be used
do_huge_pmd_wp_page
follow_trans_huge_pmd
do_huge_pmd_numa_pageNUMA hinting page fault entry point for trans huge pmds
madvise_free_huge_pmdReturn true if we do MADV_FREE successfully on entire pmd page.* Otherwise, return false.
__split_huge_page
deferred_split_scan
release_pte_page
__collapse_huge_page_isolate
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.
me_huge_pageHuge 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.
memory_failure_hugetlb
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
unpoison_memorypoison_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_huge_page
__soft_offline_page
soft_offline_in_use_page
trylock_zspage
__free_zspage
free_z3fold_pageResets the struct page fields and frees the page
z3fold_allocz3fold_alloc() - allocates a region of a given size*@pool: z3fold pool from which to allocate*@size: size in bytes of the desired allocation*@gfp: gfp flags used if the pool needs to grow*@handle: handle of the new allocation* This function will attempt
balloon_page_enqueue_one
balloon_page_list_dequeuealloon_page_list_dequeue() - removes pages from balloon's page list and* returns a list of the pages.*@b_dev_info: balloon device decriptor where we will grab a page from.*@pages: pointer to the list of pages that would be returned to the caller.
page_idle_clear_pte_refs
vfs_unlock_two_pagesUnlock two pages, being careful not to unlock the same page twice.
simple_readpage
simple_write_endsimple_write_end - .write_end helper for non-block-device FSes*@file: See .write_end of address_space_operations*@mapping: "*@pos: "*@len: "*@copied: "*@page: "*@fsdata: "* simple_write_end does the minimum needed for updating a page after writing is
page_cache_pipe_buf_stealAttempt to steal a page from a pipe buffer. This should perhaps go into* a vm helper function, it's already simplified quite a bit by the* addition of remove_mapping(). If success is returned, the caller may
page_cache_pipe_buf_confirmCheck whether the contents of buf is OK to access. Since the content* is a page cache page, IO may be in flight.
end_buffer_async_read
grow_dev_pageCreate the page-cache page that contains the requested block.* This is used purely for blockdev mappings.
clean_bdev_aliaseslean_bdev_aliases: clean a range of buffers in block device*@bdev: Block device to clean buffers in*@block: Start of a range of blocks to clean*@len: Number of blocks to clean* We are taking a range of blocks for data and we don't want writeback of any*
__block_write_full_pageWhile block_write_full_page is writing back the dirty buffers under* the page lock, whoever dirtied the buffers may decide to clean them* again at any time
block_write_beginlock_write_begin takes care of the basic task of block allocation and* bringing partial write blocks uptodate first.* The filesystem needs to handle block truncation upon failure.
generic_write_end
block_read_full_pageGeneric "read page" function for block devices that have the normal* get_block functionality
block_page_mkwritelock_page_mkwrite() is not allowed to change the file size as it gets* called from a page fault handler when a page is first dirtied
nobh_write_beginOn entry, the page is fully not uptodate.* On exit the page is fully uptodate in the areas outside (from,to)* The filesystem needs to handle block truncation upon failure.
nobh_write_end
nobh_writepagebh_writepage() - based on block_full_write_page() except* that it tries to operate without attaching bufferheads to* the page.
nobh_truncate_page
block_truncate_page
block_write_full_pageThe generic ->writepage function for buffer-backed address_spaces
blkdev_write_end
bdev_write_pagedev_write_page() - Start writing a page to a block device*@bdev: The device to write the page to*@sector: The offset on the device to write the page to (need not be aligned)*@page: The page to write*@wbc: The writeback_control for the write
do_mpage_readpageThis is the worker routine which does all the work of mapping the disk* blocks and constructs largest possible bios, submits them for IO if the* blocks are not contiguous on the disk
__mpage_writepage
aio_setup_ring
iomap_read_finish
iomap_readpage
iomap_readpages_actor
iomap_readpages
iomap_write_begin
iomap_write_end
iomap_page_mkwrite
iomap_writepage_mapWe implement an immediate ioend submission policy here to avoid needing to* chain multiple ioends and hence nest mempool allocations which can violate* forward progress guarantees we need to provide
iomap_do_writepageWrite out a dirty page.* For delalloc space on the page we need to allocate space and flush it.* For unwritten space on the page we need to start the conversion to* regular allocated space.
page_seek_hole_dataSeek for SEEK_DATA / SEEK_HOLE within @page, starting at @lastoff.* Returns true if found and updates @lastoff to the offset in file.
ramfs_nommu_expand_for_mappingadd a contiguous set of pages into a ramfs inode when it's truncated from* size 0 on the assumption that it's going to be used for an mmap of shared* memory