iov_iter_count

Type	Parameter	Name
const struct iov_iter *	i

**Caller**
Name	Describe
generic_load_microcode
devkmsg_write
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
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_file_direct_write
generic_perform_write
__generic_file_write_iter	__generic_file_write_iter - write data to a file@iocb: IO state structure (file, offset, etc.)@from: iov_iter with data to write* This function does all the work needed for actually writing data to a* file
process_vm_rw_pages	process_vm_rw_pages - read/write pages from task specified@pages: array of pointers to pages we want to copy@offset: offset in page to start copying from/to@len: number of bytes to copy@iter: where to copy to/from locally*@vm_write: 0 means copy from,
process_vm_rw_single_vec	process_vm_rw_single_vec - read/write pages from task specified@addr: start memory address of target process@len: size of area to copy to/from@iter: where to copy to/from locally@process_pages: struct pages area that can store at least*
process_vm_rw_core	process_vm_rw_core - core of reading/writing pages from task specified@pid: PID of process to read/write from/to@iter: where to copy to/from locally@rvec: iovec array specifying where to copy to/from in the other process@riovcnt: size of rvec
process_vm_rw	process_vm_rw - check iovecs before calling core routine@pid: PID of process to read/write from/to@lvec: iovec array specifying where to copy to/from locally@liovcnt: size of lvec array@rvec: iovec array specifying where to copy to/from in the other
compat_process_vm_rw
bio_iov_iter_get_pages	_iov_iter_get_pages - add user or kernel pages to a bio@bio: bio to add pages to@iter: iov iterator describing the region to be added* This takes either an iterator pointing to user memory, or one pointing to* kernel pages (BVEC iterator)
bio_copy_from_iter	_copy_from_iter - copy all pages from iov_iter to bio@bio: The &struct bio which describes the I/O as destination@iter: iov_iter as source* Copy all pages from iov_iter to bio.* Returns 0 on success, or error on failure.
bio_copy_to_iter	_copy_to_iter - copy all pages from bio to iov_iter@bio: The &struct bio which describes the I/O as source@iter: iov_iter as destination* Copy all pages from bio to iov_iter.* Returns 0 on success, or error on failure.
bio_map_user_iov	_map_user_iov - map user iovec into bio@q: the struct request_queue for the bio@iter: iovec iterator@gfp_mask: memory allocation flags Map the user space address into a bio suitable for io to a block* device. Returns an error pointer in case of error.
blk_rq_map_user_iov	lk_rq_map_user_iov - map user data to a request, for passthrough requests@q: request queue where request should be inserted@rq: request to map data to@map_data: pointer to the rq_map_data holding pages (if necessary)@iter: iovec iterator*@gfp_mask:
keyctl_instantiate_key_common	Instantiate a key with the specified payload and link the key into the* destination keyring if one is given.* The caller must have the appropriate instantiation permit set for this to* work (see keyctl_assume_authority). No other permissions are required.
do_loop_readv_writev	Do it by hand, with file-ops
do_iter_read
do_iter_write
pipe_read
pipe_write
iter_to_pipe
vmsplice_to_user	For lack of a better implementation, implement vmsplice() to userspace* as a simple copy of the pipes pages to the user iov.
do_vmsplice	Note that vmsplice only really supports true splicing _from_ user memory* to a pipe, not the other way around. Splicing from user memory is a simple* operation that can be supported without any funky alignment restrictions* or nasty vm tricks
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.
do_blockdev_direct_IO	This is a library function for use by filesystem drivers
aio_read
aio_write
loop_rw_iter	For files that don't have ->read_iter() and ->write_iter(), handle them* by looping over ->read() or ->write() manually.
io_read
io_write
dax_iomap_rw	dax_iomap_rw - Perform I/O to a DAX file@iocb: The control block for this I/O@iter: The addresses to do I/O from or to@ops: iomap ops passed from the file system This function performs read and write operations to directly mapped* persistent memory
iomap_write_actor
iomap_file_buffered_write
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

Function report