1 /* 2 * QEMU System Emulator block driver 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #ifndef BLOCK_INT_IO_H 25 #define BLOCK_INT_IO_H 26 27 #include "block/block_int-common.h" 28 #include "qemu/hbitmap.h" 29 #include "qemu/main-loop.h" 30 31 /* 32 * I/O API functions. These functions are thread-safe. 33 * 34 * See include/block/block-io.h for more information about 35 * the I/O API. 36 */ 37 38 int coroutine_fn GRAPH_RDLOCK bdrv_co_preadv_snapshot(BdrvChild *child, 39 int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); 40 int coroutine_fn GRAPH_RDLOCK bdrv_co_snapshot_block_status( 41 BlockDriverState *bs, bool want_zero, int64_t offset, int64_t bytes, 42 int64_t *pnum, int64_t *map, BlockDriverState **file); 43 int coroutine_fn GRAPH_RDLOCK bdrv_co_pdiscard_snapshot(BlockDriverState *bs, 44 int64_t offset, int64_t bytes); 45 46 47 int coroutine_fn GRAPH_RDLOCK bdrv_co_preadv(BdrvChild *child, 48 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 49 BdrvRequestFlags flags); 50 int coroutine_fn GRAPH_RDLOCK bdrv_co_preadv_part(BdrvChild *child, 51 int64_t offset, int64_t bytes, 52 QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); 53 int coroutine_fn GRAPH_RDLOCK bdrv_co_pwritev(BdrvChild *child, 54 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 55 BdrvRequestFlags flags); 56 int coroutine_fn GRAPH_RDLOCK bdrv_co_pwritev_part(BdrvChild *child, 57 int64_t offset, int64_t bytes, 58 QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); 59 60 static inline int coroutine_fn GRAPH_RDLOCK bdrv_co_pread(BdrvChild *child, 61 int64_t offset, int64_t bytes, void *buf, BdrvRequestFlags flags) 62 { 63 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); 64 IO_CODE(); 65 assert_bdrv_graph_readable(); 66 67 return bdrv_co_preadv(child, offset, bytes, &qiov, flags); 68 } 69 70 static inline int coroutine_fn GRAPH_RDLOCK bdrv_co_pwrite(BdrvChild *child, 71 int64_t offset, int64_t bytes, const void *buf, BdrvRequestFlags flags) 72 { 73 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); 74 IO_CODE(); 75 assert_bdrv_graph_readable(); 76 77 return bdrv_co_pwritev(child, offset, bytes, &qiov, flags); 78 } 79 80 void coroutine_fn bdrv_make_request_serialising(BdrvTrackedRequest *req, 81 uint64_t align); 82 BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs); 83 84 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, 85 const char *filename); 86 87 /** 88 * bdrv_wakeup: 89 * @bs: The BlockDriverState for which an I/O operation has been completed. 90 * 91 * Wake up the main thread if it is waiting on BDRV_POLL_WHILE. During 92 * synchronous I/O on a BlockDriverState that is attached to another 93 * I/O thread, the main thread lets the I/O thread's event loop run, 94 * waiting for the I/O operation to complete. A bdrv_wakeup will wake 95 * up the main thread if necessary. 96 * 97 * Manual calls to bdrv_wakeup are rarely necessary, because 98 * bdrv_dec_in_flight already calls it. 99 */ 100 void bdrv_wakeup(BlockDriverState *bs); 101 102 const char *bdrv_get_parent_name(const BlockDriverState *bs); 103 bool blk_dev_has_tray(BlockBackend *blk); 104 bool blk_dev_is_tray_open(BlockBackend *blk); 105 106 void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes); 107 108 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out); 109 void bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest, 110 const BdrvDirtyBitmap *src, 111 HBitmap **backup, bool lock); 112 113 void bdrv_inc_in_flight(BlockDriverState *bs); 114 void bdrv_dec_in_flight(BlockDriverState *bs); 115 116 int coroutine_fn GRAPH_RDLOCK 117 bdrv_co_copy_range_from(BdrvChild *src, int64_t src_offset, 118 BdrvChild *dst, int64_t dst_offset, 119 int64_t bytes, BdrvRequestFlags read_flags, 120 BdrvRequestFlags write_flags); 121 int coroutine_fn GRAPH_RDLOCK 122 bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset, 123 BdrvChild *dst, int64_t dst_offset, 124 int64_t bytes, BdrvRequestFlags read_flags, 125 BdrvRequestFlags write_flags); 126 127 int coroutine_fn GRAPH_RDLOCK 128 bdrv_co_refresh_total_sectors(BlockDriverState *bs, int64_t hint); 129 130 int co_wrapper_mixed_bdrv_rdlock 131 bdrv_refresh_total_sectors(BlockDriverState *bs, int64_t hint); 132 133 BdrvChild *bdrv_cow_child(BlockDriverState *bs); 134 BdrvChild *bdrv_filter_child(BlockDriverState *bs); 135 BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs); 136 BdrvChild *bdrv_primary_child(BlockDriverState *bs); 137 BlockDriverState *bdrv_skip_filters(BlockDriverState *bs); 138 BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs); 139 140 static inline BlockDriverState *bdrv_cow_bs(BlockDriverState *bs) 141 { 142 IO_CODE(); 143 return child_bs(bdrv_cow_child(bs)); 144 } 145 146 static inline BlockDriverState *bdrv_filter_bs(BlockDriverState *bs) 147 { 148 IO_CODE(); 149 return child_bs(bdrv_filter_child(bs)); 150 } 151 152 static inline BlockDriverState *bdrv_filter_or_cow_bs(BlockDriverState *bs) 153 { 154 IO_CODE(); 155 return child_bs(bdrv_filter_or_cow_child(bs)); 156 } 157 158 static inline BlockDriverState *bdrv_primary_bs(BlockDriverState *bs) 159 { 160 IO_CODE(); 161 return child_bs(bdrv_primary_child(bs)); 162 } 163 164 /** 165 * Check whether the given offset is in the cached block-status data 166 * region. 167 * 168 * If it is, and @pnum is not NULL, *pnum is set to 169 * `bsc.data_end - offset`, i.e. how many bytes, starting from 170 * @offset, are data (according to the cache). 171 * Otherwise, *pnum is not touched. 172 */ 173 bool bdrv_bsc_is_data(BlockDriverState *bs, int64_t offset, int64_t *pnum); 174 175 /** 176 * If [offset, offset + bytes) overlaps with the currently cached 177 * block-status region, invalidate the cache. 178 * 179 * (To be used by I/O paths that cause data regions to be zero or 180 * holes.) 181 */ 182 void bdrv_bsc_invalidate_range(BlockDriverState *bs, 183 int64_t offset, int64_t bytes); 184 185 /** 186 * Mark the range [offset, offset + bytes) as a data region. 187 */ 188 void bdrv_bsc_fill(BlockDriverState *bs, int64_t offset, int64_t bytes); 189 190 #endif /* BLOCK_INT_IO_H */ 191