@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
h 200 lines 7.28 KB
Raw
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, unsigned int mode, int64_t offset,
42 int64_t bytes, 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 * GRAPH_RDLOCK 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 * GRAPH_RDLOCK bdrv_cow_child(BlockDriverState *bs);
134 BdrvChild * GRAPH_RDLOCK bdrv_filter_child(BlockDriverState *bs);
135 BdrvChild * GRAPH_RDLOCK bdrv_filter_or_cow_child(BlockDriverState *bs);
136 BdrvChild * GRAPH_RDLOCK bdrv_primary_child(BlockDriverState *bs);
137 BlockDriverState * GRAPH_RDLOCK bdrv_skip_filters(BlockDriverState *bs);
138 BlockDriverState * GRAPH_RDLOCK bdrv_backing_chain_next(BlockDriverState *bs);
139
140 static inline BlockDriverState * GRAPH_RDLOCK
141 bdrv_cow_bs(BlockDriverState *bs)
142 {
143 IO_CODE();
144 return child_bs(bdrv_cow_child(bs));
145 }
146
147 static inline BlockDriverState * GRAPH_RDLOCK
148 bdrv_filter_bs(BlockDriverState *bs)
149 {
150 IO_CODE();
151 return child_bs(bdrv_filter_child(bs));
152 }
153
154 static inline BlockDriverState * GRAPH_RDLOCK
155 bdrv_filter_or_cow_bs(BlockDriverState *bs)
156 {
157 IO_CODE();
158 return child_bs(bdrv_filter_or_cow_child(bs));
159 }
160
161 static inline BlockDriverState * GRAPH_RDLOCK
162 bdrv_primary_bs(BlockDriverState *bs)
163 {
164 IO_CODE();
165 return child_bs(bdrv_primary_child(bs));
166 }
167
168 /**
169 * Check whether the given offset is in the cached block-status data
170 * region.
171 *
172 * If it is, and @pnum is not NULL, *pnum is set to
173 * `bsc.data_end - offset`, i.e. how many bytes, starting from
174 * @offset, are data (according to the cache).
175 * Otherwise, *pnum is not touched.
176 */
177 bool bdrv_bsc_is_data(BlockDriverState *bs, int64_t offset, int64_t *pnum);
178
179 /**
180 * If [offset, offset + bytes) overlaps with the currently cached
181 * block-status region, invalidate the cache.
182 *
183 * (To be used by I/O paths that cause data regions to be zero or
184 * holes.)
185 */
186 void bdrv_bsc_invalidate_range(BlockDriverState *bs,
187 int64_t offset, int64_t bytes);
188
189 /**
190 * Mark the range [offset, offset + bytes) as a data region.
191 */
192 void bdrv_bsc_fill(BlockDriverState *bs, int64_t offset, int64_t bytes);
193
194 /*
195 * Notify all parents that the size of the child changed.
196 */
197 void coroutine_fn GRAPH_RDLOCK
198 bdrv_co_parent_cb_resize(BlockDriverState *bs);
199
200 #endif /* BLOCK_INT_IO_H */