1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#ifndef BLOCK_IO_H
25#define BLOCK_IO_H
26
27#include "block/aio-wait.h"
28#include "block/block-common.h"
29#include "qemu/coroutine.h"
30#include "qemu/iov.h"
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45int co_wrapper_mixed_bdrv_rdlock
46bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset, int64_t bytes,
47 BdrvRequestFlags flags);
48
49int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
50
51int co_wrapper_mixed_bdrv_rdlock
52bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
53 BdrvRequestFlags flags);
54
55int co_wrapper_mixed_bdrv_rdlock
56bdrv_pwrite(BdrvChild *child, int64_t offset,int64_t bytes,
57 const void *buf, BdrvRequestFlags flags);
58
59int co_wrapper_mixed_bdrv_rdlock
60bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
61 const void *buf, BdrvRequestFlags flags);
62
63int coroutine_fn GRAPH_RDLOCK
64bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
65 const void *buf, BdrvRequestFlags flags);
66
67
68
69
70
71
72
73int coroutine_fn GRAPH_RDLOCK
74bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset, int64_t bytes,
75 BdrvRequestFlags flags);
76
77int coroutine_fn GRAPH_RDLOCK
78bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
79 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
80
81int64_t coroutine_fn GRAPH_RDLOCK bdrv_co_nb_sectors(BlockDriverState *bs);
82int64_t coroutine_mixed_fn bdrv_nb_sectors(BlockDriverState *bs);
83
84int64_t coroutine_fn GRAPH_RDLOCK bdrv_co_getlength(BlockDriverState *bs);
85int64_t co_wrapper_mixed_bdrv_rdlock bdrv_getlength(BlockDriverState *bs);
86
87int64_t coroutine_fn GRAPH_RDLOCK
88bdrv_co_get_allocated_file_size(BlockDriverState *bs);
89
90int64_t co_wrapper_bdrv_rdlock
91bdrv_get_allocated_file_size(BlockDriverState *bs);
92
93BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
94 BlockDriverState *in_bs, Error **errp);
95
96int coroutine_fn GRAPH_RDLOCK
97bdrv_co_delete_file(BlockDriverState *bs, Error **errp);
98
99void coroutine_fn GRAPH_RDLOCK
100bdrv_co_delete_file_noerr(BlockDriverState *bs);
101
102
103
104void bdrv_aio_cancel(BlockAIOCB *acb);
105void bdrv_aio_cancel_async(BlockAIOCB *acb);
106
107
108int coroutine_fn GRAPH_RDLOCK
109bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
110
111
112int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);
113
114int coroutine_fn GRAPH_RDLOCK bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
115 int64_t bytes);
116
117
118int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_report(BlockDriverState *bs,
119 int64_t offset,
120 unsigned int *nr_zones,
121 BlockZoneDescriptor *zones);
122int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_mgmt(BlockDriverState *bs,
123 BlockZoneOp op,
124 int64_t offset, int64_t len);
125int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(BlockDriverState *bs,
126 int64_t *offset,
127 QEMUIOVector *qiov,
128 BdrvRequestFlags flags);
129
130bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
131int bdrv_block_status(BlockDriverState *bs, int64_t offset,
132 int64_t bytes, int64_t *pnum, int64_t *map,
133 BlockDriverState **file);
134
135int coroutine_fn GRAPH_RDLOCK
136bdrv_co_block_status_above(BlockDriverState *bs, BlockDriverState *base,
137 int64_t offset, int64_t bytes, int64_t *pnum,
138 int64_t *map, BlockDriverState **file);
139int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
140 int64_t offset, int64_t bytes, int64_t *pnum,
141 int64_t *map, BlockDriverState **file);
142
143int coroutine_fn GRAPH_RDLOCK
144bdrv_co_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
145 int64_t *pnum);
146int bdrv_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
147 int64_t *pnum);
148
149int coroutine_fn GRAPH_RDLOCK
150bdrv_co_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
151 bool include_base, int64_t offset, int64_t bytes,
152 int64_t *pnum);
153int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
154 bool include_base, int64_t offset, int64_t bytes,
155 int64_t *pnum);
156
157int coroutine_fn GRAPH_RDLOCK
158bdrv_co_is_zero_fast(BlockDriverState *bs, int64_t offset, int64_t bytes);
159
160int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
161 Error **errp);
162bool bdrv_is_read_only(BlockDriverState *bs);
163bool bdrv_is_writable(BlockDriverState *bs);
164bool bdrv_is_sg(BlockDriverState *bs);
165int bdrv_get_flags(BlockDriverState *bs);
166
167bool coroutine_fn GRAPH_RDLOCK bdrv_co_is_inserted(BlockDriverState *bs);
168bool co_wrapper_bdrv_rdlock bdrv_is_inserted(BlockDriverState *bs);
169
170void coroutine_fn GRAPH_RDLOCK
171bdrv_co_lock_medium(BlockDriverState *bs, bool locked);
172
173void coroutine_fn GRAPH_RDLOCK
174bdrv_co_eject(BlockDriverState *bs, bool eject_flag);
175
176const char *bdrv_get_format_name(BlockDriverState *bs);
177
178bool bdrv_supports_compressed_writes(BlockDriverState *bs);
179const char *bdrv_get_node_name(const BlockDriverState *bs);
180const char *bdrv_get_device_name(const BlockDriverState *bs);
181const char *bdrv_get_device_or_node_name(const BlockDriverState *bs);
182
183int coroutine_fn GRAPH_RDLOCK
184bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
185
186int co_wrapper_mixed_bdrv_rdlock
187bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
188
189ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
190 Error **errp);
191BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs);
192void bdrv_round_to_clusters(BlockDriverState *bs,
193 int64_t offset, int64_t bytes,
194 int64_t *cluster_offset,
195 int64_t *cluster_bytes);
196
197void bdrv_get_backing_filename(BlockDriverState *bs,
198 char *filename, int filename_size);
199
200int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
201 int64_t pos, int size);
202
203int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
204 int64_t pos, int size);
205
206
207
208
209
210size_t bdrv_min_mem_align(BlockDriverState *bs);
211
212size_t bdrv_opt_mem_align(BlockDriverState *bs);
213void *qemu_blockalign(BlockDriverState *bs, size_t size);
214void *qemu_blockalign0(BlockDriverState *bs, size_t size);
215void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
216void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
217
218void bdrv_enable_copy_on_read(BlockDriverState *bs);
219void bdrv_disable_copy_on_read(BlockDriverState *bs);
220
221void coroutine_fn GRAPH_RDLOCK
222bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event);
223
224void co_wrapper_mixed_bdrv_rdlock
225bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
226
227#define BLKDBG_CO_EVENT(child, evt) \
228 do { \
229 if (child) { \
230 bdrv_co_debug_event(child->bs, evt); \
231 } \
232 } while (0)
233
234#define BLKDBG_EVENT(child, evt) \
235 do { \
236 if (child) { \
237 bdrv_debug_event(child->bs, evt); \
238 } \
239 } while (0)
240
241
242
243
244
245
246AioContext *bdrv_get_aio_context(BlockDriverState *bs);
247
248AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c);
249
250
251
252
253
254
255
256
257
258
259AioContext *coroutine_fn bdrv_co_enter(BlockDriverState *bs);
260
261
262
263
264
265void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx);
266
267AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c);
268
269bool coroutine_fn GRAPH_RDLOCK
270bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
271 uint32_t granularity, Error **errp);
272bool co_wrapper_bdrv_rdlock
273bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
274 uint32_t granularity, Error **errp);
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305int coroutine_fn GRAPH_RDLOCK
306bdrv_co_copy_range(BdrvChild *src, int64_t src_offset,
307 BdrvChild *dst, int64_t dst_offset,
308 int64_t bytes, BdrvRequestFlags read_flags,
309 BdrvRequestFlags write_flags);
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332#define BDRV_POLL_WHILE(bs, cond) ({ \
333 BlockDriverState *bs_ = (bs); \
334 IO_OR_GS_CODE(); \
335 AIO_WAIT_WHILE(bdrv_get_aio_context(bs_), \
336 cond); })
337
338void bdrv_drain(BlockDriverState *bs);
339
340int co_wrapper_mixed_bdrv_rdlock
341bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
342 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
343
344int co_wrapper_mixed_bdrv_rdlock
345bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
346
347
348int co_wrapper_mixed_bdrv_rdlock
349bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
350
351int co_wrapper_mixed_bdrv_rdlock bdrv_flush(BlockDriverState *bs);
352
353int co_wrapper_mixed_bdrv_rdlock
354bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
355
356int co_wrapper_mixed_bdrv_rdlock
357bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
358
359int co_wrapper_mixed_bdrv_rdlock
360bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
361
362
363
364
365
366
367void bdrv_parent_drained_begin_single(BdrvChild *c);
368
369
370
371
372
373
374
375bool bdrv_parent_drained_poll_single(BdrvChild *c);
376
377
378
379
380
381
382void bdrv_parent_drained_end_single(BdrvChild *c);
383
384
385
386
387
388
389
390
391
392
393
394
395bool bdrv_drain_poll(BlockDriverState *bs, BdrvChild *ignore_parent,
396 bool ignore_bds_parents);
397
398
399
400
401
402
403
404
405
406void bdrv_drained_begin(BlockDriverState *bs);
407
408
409
410
411
412
413
414void bdrv_do_drained_begin_quiesce(BlockDriverState *bs, BdrvChild *parent);
415
416
417
418
419
420
421void bdrv_drained_end(BlockDriverState *bs);
422
423#endif
424