Caller| Name | Describe |
|---|
| hib_submit_io | |
| end_swap_bio_read | |
| swap_readpage | |
| __bio_chain_endio | |
| bio_clone_fast | _clone_fast - clone a bio that shares the original bio's biovec*@bio: bio to clone*@gfp_mask: allocation priority*@bs: bio_set to allocate from* Like __bio_clone_fast, only also allocates the returned bio |
| bio_uncopy_user | _uncopy_user - finish previously mapped bio*@bio: bio being terminated* Free pages allocated from bio_copy_user_iov() and write back data* to user space in case of a read. |
| bio_copy_user_iov | _copy_user_iov - copy user data to bio*@q: destination block queue*@map_data: pointer to the rq_map_data holding pages (if necessary)*@iter: iovec iterator*@gfp_mask: memory allocation flags* Prepares and returns a bio for indirect user io, bouncing data |
| 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. |
| bio_unmap_user | _unmap_user - unmap a bio*@bio: the bio being unmapped* Unmap a bio previously mapped by bio_map_user_iov(). Must be called from* process context.* bio_unmap_user() may sleep. |
| bio_map_kern_endio | |
| bio_map_kern | _map_kern - map kernel address into bio*@q: the struct request_queue for the bio*@data: pointer to buffer to map*@len: length in bytes*@gfp_mask: allocation flags for bio allocation* Map the kernel address into a bio suitable for io to a block* device |
| bio_copy_kern_endio | |
| bio_copy_kern | _copy_kern - copy kernel address into bio*@q: the struct request_queue for the bio*@data: pointer to buffer to copy*@len: length in bytes*@gfp_mask: allocation flags for bio and page allocation*@reading: data direction is READ* copy the kernel address |
| bio_dirty_fn | _check_pages_dirty() will check that all the BIO's pages are still dirty.* If they are, then fine. If, however, some pages are clean then they must* have been written out during the direct-IO read. So we take another ref on |
| bio_check_pages_dirty | |
| blk_rq_unprep_clone | lk_rq_unprep_clone - Helper function to free all bios in a cloned request*@rq: the clone request to be cleaned up* Description:* Free all bios in @rq for a cloned request. |
| blk_rq_prep_clone | lk_rq_prep_clone - Helper function to setup clone request*@rq: the request to be setup*@rq_src: original request to be cloned*@bs: bio_set that bios for clone are allocated from*@gfp_mask: memory allocation mask for bio |
| blkdev_issue_flush | lkdev_issue_flush - queue a flush*@bdev: blockdev to issue flush for*@gfp_mask: memory allocation flags (for bio_alloc)*@error_sector: error sector* Description:* Issue a flush for the block device in question |
| blk_rq_append_bio | Append a bio to a passthrough request. Only works if the bio can be merged* into the request based on the driver constraints. |
| blk_rq_unmap_user | lk_rq_unmap_user - unmap a request with user data*@bio: start of bio list* Description:* Unmap a rq previously mapped by blk_rq_map_user(). The caller must* supply the original rq->bio from the blk_rq_map_user() return, since |
| blk_rq_map_kern | lk_rq_map_kern - map kernel data to a request, for passthrough requests*@q: request queue where request should be inserted*@rq: request to fill*@kbuf: the kernel buffer*@len: length of user data*@gfp_mask: memory allocation flags* Description: |
| blkdev_issue_discard | lkdev_issue_discard - queue a discard*@bdev: blockdev to issue discard for*@sector: start sector*@nr_sects: number of sectors to discard*@gfp_mask: memory allocation flags (for bio_alloc)*@flags: BLKDEV_DISCARD_* flags to control behaviour* Description: |
| blkdev_issue_write_same | lkdev_issue_write_same - queue a write same operation*@bdev: target blockdev*@sector: start sector*@nr_sects: number of sectors to write*@gfp_mask: memory allocation flags (for bio_alloc)*@page: page containing data* Description: |
| blkdev_issue_zeroout | lkdev_issue_zeroout - zero-fill a block range*@bdev: blockdev to write*@sector: start sector*@nr_sects: number of sectors to write*@gfp_mask: memory allocation flags (for bio_alloc)*@flags: controls detailed behavior* Description:* Zero-fill a block |
| bounce_end_io | |
| bounce_clone_bio | |
| blkdev_zone_mgmt | lkdev_zone_mgmt - Execute a zone management operation on a range of zones*@bdev: Target block device*@op: Operation to be performed on the zones*@sector: Start sector of the first zone to operate on*@nr_sectors: Number of sectors, should be at least the |
| blkdev_bio_end_io | |
| __blkdev_direct_IO | |
| dio_bio_complete | |
| mpage_end_io | I/O completion handler for multipage BIOs |
| fscrypt_zeroout_range | |
| iomap_read_end_io | |
| iomap_finish_ioend | We're now finished for good with this ioend structure. Update the page* state, release holds on bios, and finally free up memory. Do not use the* ioend after this. |
| iomap_dio_bio_end_io | |
| iomap_dio_bio_actor | |