1#ifndef BLOCK_H
2#define BLOCK_H
3
4#include "block/aio.h"
5#include "qapi/qapi-types-block-core.h"
6#include "block/aio-wait.h"
7#include "qemu/iov.h"
8#include "qemu/coroutine.h"
9#include "block/accounting.h"
10#include "block/dirty-bitmap.h"
11#include "block/blockjob.h"
12#include "qemu/hbitmap.h"
13
14
15typedef struct BlockDriver BlockDriver;
16typedef struct BdrvChild BdrvChild;
17typedef struct BdrvChildRole BdrvChildRole;
18
19typedef struct BlockDriverInfo {
20
21 int cluster_size;
22
23 int64_t vm_state_offset;
24 bool is_dirty;
25
26
27
28
29 bool unallocated_blocks_are_zero;
30
31
32
33 bool needs_compressed_writes;
34} BlockDriverInfo;
35
36typedef struct BlockFragInfo {
37 uint64_t allocated_clusters;
38 uint64_t total_clusters;
39 uint64_t fragmented_clusters;
40 uint64_t compressed_clusters;
41} BlockFragInfo;
42
43typedef enum {
44 BDRV_REQ_COPY_ON_READ = 0x1,
45 BDRV_REQ_ZERO_WRITE = 0x2,
46
47
48
49
50
51
52
53 BDRV_REQ_MAY_UNMAP = 0x4,
54
55
56
57
58
59
60
61
62
63
64
65
66 BDRV_REQ_NO_SERIALISING = 0x8,
67 BDRV_REQ_FUA = 0x10,
68 BDRV_REQ_WRITE_COMPRESSED = 0x20,
69
70
71
72 BDRV_REQ_WRITE_UNCHANGED = 0x40,
73
74
75
76
77
78
79
80
81
82
83
84 BDRV_REQ_SERIALISING = 0x80,
85
86
87 BDRV_REQ_MASK = 0xff,
88} BdrvRequestFlags;
89
90typedef struct BlockSizes {
91 uint32_t phys;
92 uint32_t log;
93} BlockSizes;
94
95typedef struct HDGeometry {
96 uint32_t heads;
97 uint32_t sectors;
98 uint32_t cylinders;
99} HDGeometry;
100
101#define BDRV_O_RDWR 0x0002
102#define BDRV_O_RESIZE 0x0004
103#define BDRV_O_SNAPSHOT 0x0008
104#define BDRV_O_TEMPORARY 0x0010
105#define BDRV_O_NOCACHE 0x0020
106#define BDRV_O_NATIVE_AIO 0x0080
107#define BDRV_O_NO_BACKING 0x0100
108#define BDRV_O_NO_FLUSH 0x0200
109#define BDRV_O_COPY_ON_READ 0x0400
110#define BDRV_O_INACTIVE 0x0800
111#define BDRV_O_CHECK 0x1000
112#define BDRV_O_ALLOW_RDWR 0x2000
113#define BDRV_O_UNMAP 0x4000
114#define BDRV_O_PROTOCOL 0x8000
115
116
117#define BDRV_O_NO_IO 0x10000
118#define BDRV_O_AUTO_RDONLY 0x20000
119
120#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
121
122
123
124
125#define BDRV_OPT_CACHE_WB "cache.writeback"
126#define BDRV_OPT_CACHE_DIRECT "cache.direct"
127#define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush"
128#define BDRV_OPT_READ_ONLY "read-only"
129#define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
130#define BDRV_OPT_DISCARD "discard"
131#define BDRV_OPT_FORCE_SHARE "force-share"
132
133
134#define BDRV_SECTOR_BITS 9
135#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
136#define BDRV_SECTOR_MASK ~(BDRV_SECTOR_SIZE - 1)
137
138#define BDRV_REQUEST_MAX_SECTORS MIN(SIZE_MAX >> BDRV_SECTOR_BITS, \
139 INT_MAX >> BDRV_SECTOR_BITS)
140#define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176#define BDRV_BLOCK_DATA 0x01
177#define BDRV_BLOCK_ZERO 0x02
178#define BDRV_BLOCK_OFFSET_VALID 0x04
179#define BDRV_BLOCK_RAW 0x08
180#define BDRV_BLOCK_ALLOCATED 0x10
181#define BDRV_BLOCK_EOF 0x20
182#define BDRV_BLOCK_OFFSET_MASK BDRV_SECTOR_MASK
183
184typedef QSIMPLEQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue;
185
186typedef struct BDRVReopenState {
187 BlockDriverState *bs;
188 int flags;
189 BlockdevDetectZeroesOptions detect_zeroes;
190 uint64_t perm, shared_perm;
191 QDict *options;
192 QDict *explicit_options;
193 void *opaque;
194} BDRVReopenState;
195
196
197
198
199typedef enum BlockOpType {
200 BLOCK_OP_TYPE_BACKUP_SOURCE,
201 BLOCK_OP_TYPE_BACKUP_TARGET,
202 BLOCK_OP_TYPE_CHANGE,
203 BLOCK_OP_TYPE_COMMIT_SOURCE,
204 BLOCK_OP_TYPE_COMMIT_TARGET,
205 BLOCK_OP_TYPE_DATAPLANE,
206 BLOCK_OP_TYPE_DRIVE_DEL,
207 BLOCK_OP_TYPE_EJECT,
208 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
209 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT,
210 BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE,
211 BLOCK_OP_TYPE_MIRROR_SOURCE,
212 BLOCK_OP_TYPE_MIRROR_TARGET,
213 BLOCK_OP_TYPE_RESIZE,
214 BLOCK_OP_TYPE_STREAM,
215 BLOCK_OP_TYPE_REPLACE,
216 BLOCK_OP_TYPE_MAX,
217} BlockOpType;
218
219
220enum {
221
222
223
224
225
226
227
228
229
230
231 BLK_PERM_CONSISTENT_READ = 0x01,
232
233
234 BLK_PERM_WRITE = 0x02,
235
236
237
238
239
240
241
242
243
244 BLK_PERM_WRITE_UNCHANGED = 0x04,
245
246
247 BLK_PERM_RESIZE = 0x08,
248
249
250
251
252
253 BLK_PERM_GRAPH_MOD = 0x10,
254
255 BLK_PERM_ALL = 0x1f,
256
257 DEFAULT_PERM_PASSTHROUGH = BLK_PERM_CONSISTENT_READ
258 | BLK_PERM_WRITE
259 | BLK_PERM_WRITE_UNCHANGED
260 | BLK_PERM_RESIZE,
261
262 DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH,
263};
264
265char *bdrv_perm_names(uint64_t perm);
266
267
268void bdrv_init(void);
269void bdrv_init_with_whitelist(void);
270bool bdrv_uses_whitelist(void);
271int bdrv_is_whitelisted(BlockDriver *drv, bool read_only);
272BlockDriver *bdrv_find_protocol(const char *filename,
273 bool allow_protocol_prefix,
274 Error **errp);
275BlockDriver *bdrv_find_format(const char *format_name);
276int bdrv_create(BlockDriver *drv, const char* filename,
277 QemuOpts *opts, Error **errp);
278int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp);
279BlockDriverState *bdrv_new(void);
280void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
281 Error **errp);
282void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
283 Error **errp);
284
285int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
286int bdrv_parse_discard_flags(const char *mode, int *flags);
287BdrvChild *bdrv_open_child(const char *filename,
288 QDict *options, const char *bdref_key,
289 BlockDriverState* parent,
290 const BdrvChildRole *child_role,
291 bool allow_none, Error **errp);
292BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp);
293void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
294 Error **errp);
295int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
296 const char *bdref_key, Error **errp);
297BlockDriverState *bdrv_open(const char *filename, const char *reference,
298 QDict *options, int flags, Error **errp);
299BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
300 int flags, Error **errp);
301BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
302 BlockDriverState *bs,
303 QDict *options, int flags);
304int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp);
305int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp);
306int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
307 BlockReopenQueue *queue, Error **errp);
308void bdrv_reopen_commit(BDRVReopenState *reopen_state);
309void bdrv_reopen_abort(BDRVReopenState *reopen_state);
310int bdrv_read(BdrvChild *child, int64_t sector_num,
311 uint8_t *buf, int nb_sectors);
312int bdrv_write(BdrvChild *child, int64_t sector_num,
313 const uint8_t *buf, int nb_sectors);
314int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
315 int bytes, BdrvRequestFlags flags);
316int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
317int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes);
318int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
319int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes);
320int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov);
321int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
322 const void *buf, int count);
323
324
325
326
327
328
329int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
330 int bytes, BdrvRequestFlags flags);
331BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
332 const char *backing_file);
333void bdrv_refresh_filename(BlockDriverState *bs);
334
335int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset,
336 PreallocMode prealloc, Error **errp);
337int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
338 Error **errp);
339
340int64_t bdrv_nb_sectors(BlockDriverState *bs);
341int64_t bdrv_getlength(BlockDriverState *bs);
342int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
343BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
344 BlockDriverState *in_bs, Error **errp);
345void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);
346void bdrv_refresh_limits(BlockDriverState *bs, Error **errp);
347int bdrv_commit(BlockDriverState *bs);
348int bdrv_change_backing_file(BlockDriverState *bs,
349 const char *backing_file, const char *backing_fmt);
350void bdrv_register(BlockDriver *bdrv);
351int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
352 const char *backing_file_str);
353BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
354 BlockDriverState *bs);
355BlockDriverState *bdrv_find_base(BlockDriverState *bs);
356
357
358typedef struct BdrvCheckResult {
359 int corruptions;
360 int leaks;
361 int check_errors;
362 int corruptions_fixed;
363 int leaks_fixed;
364 int64_t image_end_offset;
365 BlockFragInfo bfi;
366} BdrvCheckResult;
367
368typedef enum {
369 BDRV_FIX_LEAKS = 1,
370 BDRV_FIX_ERRORS = 2,
371} BdrvCheckMode;
372
373int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
374
375
376
377
378typedef void BlockDriverAmendStatusCB(BlockDriverState *bs, int64_t offset,
379 int64_t total_work_size, void *opaque);
380int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *opts,
381 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
382 Error **errp);
383
384
385bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
386 BlockDriverState *candidate);
387bool bdrv_is_first_non_filter(BlockDriverState *candidate);
388
389
390BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
391 const char *node_name, Error **errp);
392
393
394void bdrv_aio_cancel(BlockAIOCB *acb);
395void bdrv_aio_cancel_async(BlockAIOCB *acb);
396
397
398int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
399
400
401void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp);
402void bdrv_invalidate_cache_all(Error **errp);
403int bdrv_inactivate_all(void);
404
405
406int bdrv_flush(BlockDriverState *bs);
407int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
408int bdrv_flush_all(void);
409void bdrv_close_all(void);
410void bdrv_drain(BlockDriverState *bs);
411void coroutine_fn bdrv_co_drain(BlockDriverState *bs);
412void bdrv_drain_all_begin(void);
413void bdrv_drain_all_end(void);
414void bdrv_drain_all(void);
415
416#define BDRV_POLL_WHILE(bs, cond) ({ \
417 BlockDriverState *bs_ = (bs); \
418 AIO_WAIT_WHILE(bdrv_get_aio_context(bs_), \
419 cond); })
420
421int bdrv_pdiscard(BdrvChild *child, int64_t offset, int bytes);
422int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int bytes);
423int bdrv_has_zero_init_1(BlockDriverState *bs);
424int bdrv_has_zero_init(BlockDriverState *bs);
425bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
426bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
427int bdrv_block_status(BlockDriverState *bs, int64_t offset,
428 int64_t bytes, int64_t *pnum, int64_t *map,
429 BlockDriverState **file);
430int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
431 int64_t offset, int64_t bytes, int64_t *pnum,
432 int64_t *map, BlockDriverState **file);
433int bdrv_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
434 int64_t *pnum);
435int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
436 int64_t offset, int64_t bytes, int64_t *pnum);
437
438bool bdrv_is_read_only(BlockDriverState *bs);
439int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
440 bool ignore_allow_rdw, Error **errp);
441int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
442 Error **errp);
443bool bdrv_is_writable(BlockDriverState *bs);
444bool bdrv_is_sg(BlockDriverState *bs);
445bool bdrv_is_inserted(BlockDriverState *bs);
446void bdrv_lock_medium(BlockDriverState *bs, bool locked);
447void bdrv_eject(BlockDriverState *bs, bool eject_flag);
448const char *bdrv_get_format_name(BlockDriverState *bs);
449BlockDriverState *bdrv_find_node(const char *node_name);
450BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
451BlockDriverState *bdrv_lookup_bs(const char *device,
452 const char *node_name,
453 Error **errp);
454bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);
455BlockDriverState *bdrv_next_node(BlockDriverState *bs);
456BlockDriverState *bdrv_next_all_states(BlockDriverState *bs);
457
458typedef struct BdrvNextIterator {
459 enum {
460 BDRV_NEXT_BACKEND_ROOTS,
461 BDRV_NEXT_MONITOR_OWNED,
462 } phase;
463 BlockBackend *blk;
464 BlockDriverState *bs;
465} BdrvNextIterator;
466
467BlockDriverState *bdrv_first(BdrvNextIterator *it);
468BlockDriverState *bdrv_next(BdrvNextIterator *it);
469void bdrv_next_cleanup(BdrvNextIterator *it);
470
471BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
472bool bdrv_is_encrypted(BlockDriverState *bs);
473void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
474 void *opaque);
475const char *bdrv_get_node_name(const BlockDriverState *bs);
476const char *bdrv_get_device_name(const BlockDriverState *bs);
477const char *bdrv_get_device_or_node_name(const BlockDriverState *bs);
478int bdrv_get_flags(BlockDriverState *bs);
479int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
480ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs);
481void bdrv_round_to_clusters(BlockDriverState *bs,
482 int64_t offset, int64_t bytes,
483 int64_t *cluster_offset,
484 int64_t *cluster_bytes);
485
486const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
487void bdrv_get_backing_filename(BlockDriverState *bs,
488 char *filename, int filename_size);
489void bdrv_get_full_backing_filename(BlockDriverState *bs,
490 char *dest, size_t sz, Error **errp);
491void bdrv_get_full_backing_filename_from_filename(const char *backed,
492 const char *backing,
493 char *dest, size_t sz,
494 Error **errp);
495
496int path_has_protocol(const char *path);
497int path_is_absolute(const char *path);
498void path_combine(char *dest, int dest_size,
499 const char *base_path,
500 const char *filename);
501
502int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
503int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);
504int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
505 int64_t pos, int size);
506
507int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
508 int64_t pos, int size);
509
510void bdrv_img_create(const char *filename, const char *fmt,
511 const char *base_filename, const char *base_fmt,
512 char *options, uint64_t img_size, int flags,
513 bool quiet, Error **errp);
514
515
516
517size_t bdrv_min_mem_align(BlockDriverState *bs);
518
519size_t bdrv_opt_mem_align(BlockDriverState *bs);
520void *qemu_blockalign(BlockDriverState *bs, size_t size);
521void *qemu_blockalign0(BlockDriverState *bs, size_t size);
522void *qemu_try_blockalign(BlockDriverState *bs, size_t size);
523void *qemu_try_blockalign0(BlockDriverState *bs, size_t size);
524bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov);
525
526void bdrv_enable_copy_on_read(BlockDriverState *bs);
527void bdrv_disable_copy_on_read(BlockDriverState *bs);
528
529void bdrv_ref(BlockDriverState *bs);
530void bdrv_unref(BlockDriverState *bs);
531void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child);
532BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
533 BlockDriverState *child_bs,
534 const char *child_name,
535 const BdrvChildRole *child_role,
536 Error **errp);
537
538bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp);
539void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason);
540void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason);
541void bdrv_op_block_all(BlockDriverState *bs, Error *reason);
542void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason);
543bool bdrv_op_blocker_is_empty(BlockDriverState *bs);
544
545#define BLKDBG_EVENT(child, evt) \
546 do { \
547 if (child) { \
548 bdrv_debug_event(child->bs, evt); \
549 } \
550 } while (0)
551
552void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
553
554int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
555 const char *tag);
556int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag);
557int bdrv_debug_resume(BlockDriverState *bs, const char *tag);
558bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag);
559
560
561
562
563
564
565AioContext *bdrv_get_aio_context(BlockDriverState *bs);
566
567
568
569
570void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co);
571
572
573
574
575
576
577
578
579
580void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context);
581int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz);
582int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo);
583
584void bdrv_io_plug(BlockDriverState *bs);
585void bdrv_io_unplug(BlockDriverState *bs);
586
587
588
589
590
591
592
593void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore,
594 bool ignore_bds_parents);
595
596
597
598
599
600
601
602void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll);
603
604
605
606
607
608
609
610void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,
611 bool ignore_bds_parents);
612
613
614
615
616
617
618
619
620
621
622
623
624
625bool bdrv_drain_poll(BlockDriverState *bs, bool recursive,
626 BdrvChild *ignore_parent, bool ignore_bds_parents);
627
628
629
630
631
632
633
634
635
636
637
638void bdrv_drained_begin(BlockDriverState *bs);
639
640
641
642
643
644
645
646void bdrv_do_drained_begin_quiesce(BlockDriverState *bs,
647 BdrvChild *parent, bool ignore_bds_parents);
648
649
650
651
652
653void bdrv_subtree_drained_begin(BlockDriverState *bs);
654
655
656
657
658
659
660void bdrv_drained_end(BlockDriverState *bs);
661
662
663
664
665void bdrv_subtree_drained_end(BlockDriverState *bs);
666
667void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
668 Error **errp);
669void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
670
671bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
672 uint32_t granularity, Error **errp);
673
674
675
676
677
678
679
680
681void bdrv_register_buf(BlockDriverState *bs, void *host, size_t size);
682void bdrv_unregister_buf(BlockDriverState *bs, void *host);
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset,
714 BdrvChild *dst, uint64_t dst_offset,
715 uint64_t bytes, BdrvRequestFlags read_flags,
716 BdrvRequestFlags write_flags);
717#endif
718