| /* |
| * QEMU System Emulator block driver |
| * |
| * Copyright (c) 2003 Fabrice Bellard |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| #ifndef BLOCK_INT_IO_H |
| #define BLOCK_INT_IO_H |
| |
| #include "block_int-common.h" |
| |
| /* |
| * I/O API functions. These functions are thread-safe. |
| * |
| * See include/block/block-io.h for more information about |
| * the I/O API. |
| */ |
| |
| int coroutine_fn bdrv_co_preadv_snapshot(BdrvChild *child, |
| int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); |
| int coroutine_fn bdrv_co_snapshot_block_status(BlockDriverState *bs, |
| bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, |
| int64_t *map, BlockDriverState **file); |
| int coroutine_fn bdrv_co_pdiscard_snapshot(BlockDriverState *bs, |
| int64_t offset, int64_t bytes); |
| |
| |
| int coroutine_fn bdrv_co_preadv(BdrvChild *child, |
| int64_t offset, int64_t bytes, QEMUIOVector *qiov, |
| BdrvRequestFlags flags); |
| int coroutine_fn bdrv_co_preadv_part(BdrvChild *child, |
| int64_t offset, int64_t bytes, |
| QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); |
| int coroutine_fn bdrv_co_pwritev(BdrvChild *child, |
| int64_t offset, int64_t bytes, QEMUIOVector *qiov, |
| BdrvRequestFlags flags); |
| int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child, |
| int64_t offset, int64_t bytes, |
| QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); |
| |
| static inline int coroutine_fn bdrv_co_pread(BdrvChild *child, |
| int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags) |
| { |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); |
| IO_CODE(); |
| |
| return bdrv_co_preadv(child, offset, bytes, &qiov, flags); |
| } |
| |
| static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child, |
| int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags) |
| { |
| QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); |
| IO_CODE(); |
| |
| return bdrv_co_pwritev(child, offset, bytes, &qiov, flags); |
| } |
| |
| bool coroutine_fn bdrv_make_request_serialising(BdrvTrackedRequest *req, |
| uint64_t align); |
| BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs); |
| |
| BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, |
| const char *filename); |
| |
| /** |
| * bdrv_wakeup: |
| * @bs: The BlockDriverState for which an I/O operation has been completed. |
| * |
| * Wake up the main thread if it is waiting on BDRV_POLL_WHILE. During |
| * synchronous I/O on a BlockDriverState that is attached to another |
| * I/O thread, the main thread lets the I/O thread's event loop run, |
| * waiting for the I/O operation to complete. A bdrv_wakeup will wake |
| * up the main thread if necessary. |
| * |
| * Manual calls to bdrv_wakeup are rarely necessary, because |
| * bdrv_dec_in_flight already calls it. |
| */ |
| void bdrv_wakeup(BlockDriverState *bs); |
| |
| const char *bdrv_get_parent_name(const BlockDriverState *bs); |
| bool blk_dev_has_tray(BlockBackend *blk); |
| bool blk_dev_is_tray_open(BlockBackend *blk); |
| |
| void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes); |
| |
| void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out); |
| bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest, |
| const BdrvDirtyBitmap *src, |
| HBitmap **backup, bool lock); |
| |
| void bdrv_inc_in_flight(BlockDriverState *bs); |
| void bdrv_dec_in_flight(BlockDriverState *bs); |
| |
| int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, int64_t src_offset, |
| BdrvChild *dst, int64_t dst_offset, |
| int64_t bytes, |
| BdrvRequestFlags read_flags, |
| BdrvRequestFlags write_flags); |
| int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset, |
| BdrvChild *dst, int64_t dst_offset, |
| int64_t bytes, |
| BdrvRequestFlags read_flags, |
| BdrvRequestFlags write_flags); |
| |
| int refresh_total_sectors(BlockDriverState *bs, int64_t hint); |
| |
| BdrvChild *bdrv_cow_child(BlockDriverState *bs); |
| BdrvChild *bdrv_filter_child(BlockDriverState *bs); |
| BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs); |
| BdrvChild *bdrv_primary_child(BlockDriverState *bs); |
| BlockDriverState *bdrv_skip_filters(BlockDriverState *bs); |
| BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs); |
| |
| static inline BlockDriverState *bdrv_cow_bs(BlockDriverState *bs) |
| { |
| IO_CODE(); |
| return child_bs(bdrv_cow_child(bs)); |
| } |
| |
| static inline BlockDriverState *bdrv_filter_bs(BlockDriverState *bs) |
| { |
| IO_CODE(); |
| return child_bs(bdrv_filter_child(bs)); |
| } |
| |
| static inline BlockDriverState *bdrv_filter_or_cow_bs(BlockDriverState *bs) |
| { |
| IO_CODE(); |
| return child_bs(bdrv_filter_or_cow_child(bs)); |
| } |
| |
| static inline BlockDriverState *bdrv_primary_bs(BlockDriverState *bs) |
| { |
| IO_CODE(); |
| return child_bs(bdrv_primary_child(bs)); |
| } |
| |
| /** |
| * Check whether the given offset is in the cached block-status data |
| * region. |
| * |
| * If it is, and @pnum is not NULL, *pnum is set to |
| * `bsc.data_end - offset`, i.e. how many bytes, starting from |
| * @offset, are data (according to the cache). |
| * Otherwise, *pnum is not touched. |
| */ |
| bool bdrv_bsc_is_data(BlockDriverState *bs, int64_t offset, int64_t *pnum); |
| |
| /** |
| * If [offset, offset + bytes) overlaps with the currently cached |
| * block-status region, invalidate the cache. |
| * |
| * (To be used by I/O paths that cause data regions to be zero or |
| * holes.) |
| */ |
| void bdrv_bsc_invalidate_range(BlockDriverState *bs, |
| int64_t offset, int64_t bytes); |
| |
| /** |
| * Mark the range [offset, offset + bytes) as a data region. |
| */ |
| void bdrv_bsc_fill(BlockDriverState *bs, int64_t offset, int64_t bytes); |
| |
| |
| /* |
| * "I/O or GS" API functions. These functions can run without |
| * the BQL, but only in one specific iothread/main loop. |
| * |
| * See include/block/block-io.h for more information about |
| * the "I/O or GS" API. |
| */ |
| |
| void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent); |
| void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent); |
| |
| #endif /* BLOCK_INT_IO_H */ |