Function report

Linux Kernel

v5.5.9

Brick Technologies Co., Ltd

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

Name:NOTE: in a 32bit arch with a preemptable kernel and* an UP compile the i_size_read/write must be atomic* with respect to the local cpu (unlike with preempt disabled),* but they don't need to be atomic with respect to other cpus like in* true SMP (so they

Proto:static inline loff_t i_size_read(const struct inode *inode)

Type:loff_t

Parameter:

TypeParameterName
const struct inode *inode
866  Return i_size
Caller
NameDescribe
copy_insn
__uprobe_register__uprobe_register - register a probe*@inode: the file in which the probe has to be placed
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.
generic_file_read_itergeneric_file_read_iter - generic filesystem read routine*@iocb: kernel I/O control block*@iter: destination for the data read* This is the "read_iter()" routine for all filesystems* that can use the page cache directly
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
generic_write_checksPerforms necessary checks before doing a write* Can adjust writing position or amount of bytes to write.* Returns appropriate error code that caller should return or* zero in case that write should be allowed.
generic_remap_checksPerforms necessary checks before doing a clone.* Can adjust amount of bytes to clone via @req_count argument.* Returns appropriate error code that caller should return or* zero in case the clone should be allowed.
generic_copy_file_checksPerforms necessary checks before doing a file copy* Can adjust amount of bytes to copy via @req_count argument.* Returns appropriate error code that caller should return or* zero in case the copy should be allowed.
generic_file_direct_write
__do_page_cache_readahead__do_page_cache_readahead() actually reads a chunk of disk. It allocates* the pages first, then submits them for I/O. This avoids the very bad* behaviour which would occur if page allocations are causing VM writeback.
generic_swapfile_activate
read_swap_header
hugetlb_no_page
hugetlb_mcopy_atomic_pteUsed by userfaultfd UFFDIO_COPY. Based on mcopy_atomic_pte with* modifications for huge pages.
split_huge_page_to_listThis 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.
mcopy_atomic_pte
mfill_zeropage_pte
shm_destroy
do_shmatFix shmaddr, allocate descriptor, map shm, add attach descriptor to lists.* NOTE! Despite the name, this is NOT a direct system call entrypoint. The* "raddr" thing points to kernel space, and there has to be a wrapper around* this.
ksys_shmdtdetach and kill segment if marked destroyed.* The work is done in shm_close.
blk_ioctl_discard
blk_ioctl_zeroout
blkdev_ioctlalways keep this in sync with compat_blkdev_ioctl()
ibm_partitionThis is the main function, called by check.c
find_valid_gptd_valid_gpt() - Search disk for valid GPT headers and PTEs*@state: disk parsed partitions*@gpt: GPT header ptr, filled on return.*@ptes: PTEs ptr, filled on return.* Description: Returns 1 if valid, 0 on error.
compat_blkdev_ioctlMost of the generic ioctls are handled in the normal fallback path.This assumes the blkdev's low level compat_ioctl always returnsENOIOCTLCMD for unknown ioctls.
sel_open_policy
ima_calc_file_hash_atfm
ima_calc_file_hash_tfm
ima_calc_file_hashma_calc_file_hash - calculate file hash* Asynchronous hash (ahash) allows using HW acceleration for calculating* a hash. ahash performance varies for different data sizes on different* crypto accelerators
generic_file_openCalled when an inode is about to be open.* We use this to disallow opening large files on 32bit systems if* the caller didn't specify O_LARGEFILE. On 64bit systems we force* on this flag in sys_open.
generic_file_llseekgeneric_file_llseek - generic llseek implementation for regular files*@file: file structure to seek on*@offset: file offset to seek to*@whence: type of seek* This is a generic implemenation of ->llseek useable for all normal local* filesystems
default_llseek
generic_remap_check_lenEnsure that we don't remap a partial EOF block in the middle of something* else. Assume that the offsets have already been checked for block* alignment.* For clone we only link a partial EOF block above or at the destination file's* EOF
generic_remap_file_range_prepCheck that the two inodes are eligible for cloning, the ranges make* sense, and then flush all dirty data. Caller must ensure that the* inodes have been locked against any other modifications.
vfs_dedupe_file_range
generic_fillattrgeneric_fillattr - Fill in the basic attributes from the inode struct*@inode: Inode to use as the source*@stat: Where to fill in the attributes* Fill in the basic attributes in the kstat structure from data that's to be* found on the VFS inode structure
kernel_read_file
__generic_block_fiemap__generic_block_fiemap - FIEMAP for block based inodes (no locking)*@inode: the inode to map*@fieinfo: the fiemap info struct that will be passed back to userspace*@start: where to start mapping in the inode*@len: how much space to map*@get_block: the
ioctl_preallocateThis provides compatibility with legacy XFS pre-allocation ioctls* which predate the fallocate syscall.* Only the l_start, l_len and l_whence fields of the 'struct space_resv'* are used here, rest are ignored.
compat_ioctl_preallocatejust account for different alignment
file_ioctl
fsstack_copy_inode_sizedoes _NOT_ require i_mutex to be held.* This function cannot be inlined since i_size_{read,write} is rather* heavy-weight on 32-bit systems
blkdev_max_block
__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
iomap_to_bh
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_writepagebh_writepage() - based on block_full_write_page() except* that it tries to operate without attaching bufferheads to* the page.
block_write_full_pageThe generic ->writepage function for buffer-backed address_spaces
set_init_blocksize
block_llseekprivate llseek:* for a block special file file_inode(file)->i_size is zero* so we compute the size by hand (just as in block_read/write above)
check_disk_size_changeheck_disk_size_change - checks for disk size change and adjusts bdev size
blkdev_write_iterWrite data to the block device. Only intended for the block device itself* and the raw driver which basically is a fake block device.* Does not take i_mutex for the write and thus is not for general purpose* use.
blkdev_read_iter
blkdev_fallocate
get_more_blocksCall into the fs to map some more disk blocks. We record the current number* of available blocks at sdio->blocks_available. These are in units of the* fs blocksize, i_blocksize(inode).* The fs is allowed to map lots of blocks at once
do_direct_IOWalk the user pages, and the file, mapping blocks to disk and generating* a sequence of (page,offset,len,block) mappings. These mappings are injected* into submit_page_section(), which takes care of the next stage of submission
do_blockdev_direct_IOThis is a library function for use by filesystem drivers
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
dax_iomap_actor
dax_iomap_pte_fault
flock64_to_posix_lock
load_aout_binaryThese are the functions used to load a.out style executables and shared* libraries. There is no binary dependent code anywhere else.
load_aout_library
dump_truncateEnsures that file size is big enough to contain the current file* postion. This prevents gdb from complaining about a truncated file* if the last "write" to the file was dump_skip.
iomap_adjust_read_rangeCalculate the range inside the page that we actually need to read.
iomap_read_inline_data
iomap_block_needs_zeroing
iomap_write_failed
iomap_page_mkwrite
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.
iomap_dio_bio_actor
iomap_dio_rwmap_dio_rw() always completes O_[D]SYNC writes regardless of whether the IO* is being issued as AIO or not. This allows us to optimise pure data writes* to use REQ_FUA rather than requiring generic_write_sync() to issue a* REQ_FLUSH post write
iomap_seek_hole
iomap_seek_data
iomap_swapfile_activateIterate a swap file's iomaps to construct physical extents that can be* passed to the swapfile subsystem.
v1_check_quota_file
ramfs_nommu_get_unmapped_area