i_size_read

Type	Parameter	Name
const struct inode *	inode

**Caller**
Name	Describe
copy_insn
__uprobe_register	__uprobe_register - register a probe*@inode: the file in which the probe has to be placed
generic_file_buffered_read	generic_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_iter	generic_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_fault	lemap_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_checks	Performs 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_checks	Performs 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_checks	Performs 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_pte	Used by userfaultfd UFFDIO_COPY. Based on mcopy_atomic_pte with* modifications for huge pages.
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.
mcopy_atomic_pte
mfill_zeropage_pte
shm_destroy
do_shmat	Fix 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_shmdt	detach and kill segment if marked destroyed.* The work is done in shm_close.
blk_ioctl_discard
blk_ioctl_zeroout
blkdev_ioctl	always keep this in sync with compat_blkdev_ioctl()
ibm_partition	This is the main function, called by check.c
find_valid_gpt	d_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_ioctl	Most 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_hash	ma_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_open	Called 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_llseek	generic_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_len	Ensure 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_prep	Check 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_fillattr	generic_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_preallocate	This 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_preallocate	just account for different alignment
file_ioctl
fsstack_copy_inode_size	does _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_page	While 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_page	Generic "read page" function for block devices that have the normal* get_block functionality
block_page_mkwrite	lock_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_writepage	bh_writepage() - based on block_full_write_page() except* that it tries to operate without attaching bufferheads to* the page.
block_write_full_page	The generic ->writepage function for buffer-backed address_spaces
set_init_blocksize
block_llseek	private 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_change	heck_disk_size_change - checks for disk size change and adjusts bdev size
blkdev_write_iter	Write 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_blocks	Call 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_IO	Walk 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_IO	This is a library function for use by filesystem drivers
do_mpage_readpage	This 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_binary	These 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_truncate	Ensures 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_range	Calculate 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_writepage	Write 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_rw	map_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_activate	Iterate 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

Function report