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_INT_H
25#define BLOCK_INT_H
26
27#include "block/accounting.h"
28#include "block/block.h"
29#include "block/throttle-groups.h"
30#include "qemu/option.h"
31#include "qemu/queue.h"
32#include "qemu/coroutine.h"
33#include "qemu/timer.h"
34#include "qapi-types.h"
35#include "qemu/hbitmap.h"
36#include "block/snapshot.h"
37#include "qemu/main-loop.h"
38#include "qemu/throttle.h"
39
40#define BLOCK_FLAG_ENCRYPT 1
41#define BLOCK_FLAG_COMPAT6 4
42#define BLOCK_FLAG_LAZY_REFCOUNTS 8
43
44#define BLOCK_OPT_SIZE "size"
45#define BLOCK_OPT_ENCRYPT "encryption"
46#define BLOCK_OPT_COMPAT6 "compat6"
47#define BLOCK_OPT_BACKING_FILE "backing_file"
48#define BLOCK_OPT_BACKING_FMT "backing_fmt"
49#define BLOCK_OPT_CLUSTER_SIZE "cluster_size"
50#define BLOCK_OPT_TABLE_SIZE "table_size"
51#define BLOCK_OPT_PREALLOC "preallocation"
52#define BLOCK_OPT_SUBFMT "subformat"
53#define BLOCK_OPT_COMPAT_LEVEL "compat"
54#define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts"
55#define BLOCK_OPT_ADAPTER_TYPE "adapter_type"
56#define BLOCK_OPT_REDUNDANCY "redundancy"
57#define BLOCK_OPT_NOCOW "nocow"
58#define BLOCK_OPT_OBJECT_SIZE "object_size"
59#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits"
60
61#define BLOCK_PROBE_BUF_SIZE 512
62
63enum BdrvTrackedRequestType {
64 BDRV_TRACKED_READ,
65 BDRV_TRACKED_WRITE,
66 BDRV_TRACKED_FLUSH,
67 BDRV_TRACKED_IOCTL,
68 BDRV_TRACKED_DISCARD,
69};
70
71typedef struct BdrvTrackedRequest {
72 BlockDriverState *bs;
73 int64_t offset;
74 unsigned int bytes;
75 enum BdrvTrackedRequestType type;
76
77 bool serialising;
78 int64_t overlap_offset;
79 unsigned int overlap_bytes;
80
81 QLIST_ENTRY(BdrvTrackedRequest) list;
82 Coroutine *co;
83 CoQueue wait_queue;
84
85 struct BdrvTrackedRequest *waiting_for;
86} BdrvTrackedRequest;
87
88struct BlockDriver {
89 const char *format_name;
90 int instance_size;
91
92
93 bool is_filter;
94
95
96
97
98
99
100 bool (*bdrv_recurse_is_first_non_filter)(BlockDriverState *bs,
101 BlockDriverState *candidate);
102
103 int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename);
104 int (*bdrv_probe_device)(const char *filename);
105
106
107
108 void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp);
109
110
111
112
113
114 bool bdrv_needs_filename;
115
116
117 bool supports_backing;
118
119
120 int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state,
121 BlockReopenQueue *queue, Error **errp);
122 void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state);
123 void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state);
124 void (*bdrv_join_options)(QDict *options, QDict *old_options);
125
126 int (*bdrv_open)(BlockDriverState *bs, QDict *options, int flags,
127 Error **errp);
128 int (*bdrv_file_open)(BlockDriverState *bs, QDict *options, int flags,
129 Error **errp);
130 int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num,
131 uint8_t *buf, int nb_sectors);
132 int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num,
133 const uint8_t *buf, int nb_sectors);
134 void (*bdrv_close)(BlockDriverState *bs);
135 int (*bdrv_create)(const char *filename, QemuOpts *opts, Error **errp);
136 int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
137 int (*bdrv_make_empty)(BlockDriverState *bs);
138
139 void (*bdrv_refresh_filename)(BlockDriverState *bs, QDict *options);
140
141
142 BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
143 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
144 BlockCompletionFunc *cb, void *opaque);
145 BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
146 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
147 BlockCompletionFunc *cb, void *opaque);
148 BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
149 BlockCompletionFunc *cb, void *opaque);
150 BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs,
151 int64_t sector_num, int nb_sectors,
152 BlockCompletionFunc *cb, void *opaque);
153
154 int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs,
155 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
156 int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
157 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
158 int coroutine_fn (*bdrv_co_writev_flags)(BlockDriverState *bs,
159 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags);
160
161 int supported_write_flags;
162
163
164
165
166
167
168
169 int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs,
170 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
171 int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,
172 int64_t sector_num, int nb_sectors);
173 int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs,
174 int64_t sector_num, int nb_sectors, int *pnum,
175 BlockDriverState **file);
176
177
178
179
180 void (*bdrv_invalidate_cache)(BlockDriverState *bs, Error **errp);
181 int (*bdrv_inactivate)(BlockDriverState *bs);
182
183
184
185
186
187
188 int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs);
189
190
191
192
193
194 int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs);
195
196
197
198
199
200
201 int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs);
202
203 const char *protocol_name;
204 int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
205
206 int64_t (*bdrv_getlength)(BlockDriverState *bs);
207 bool has_variable_length;
208 int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
209
210 int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
211 const uint8_t *buf, int nb_sectors);
212
213 int (*bdrv_snapshot_create)(BlockDriverState *bs,
214 QEMUSnapshotInfo *sn_info);
215 int (*bdrv_snapshot_goto)(BlockDriverState *bs,
216 const char *snapshot_id);
217 int (*bdrv_snapshot_delete)(BlockDriverState *bs,
218 const char *snapshot_id,
219 const char *name,
220 Error **errp);
221 int (*bdrv_snapshot_list)(BlockDriverState *bs,
222 QEMUSnapshotInfo **psn_info);
223 int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs,
224 const char *snapshot_id,
225 const char *name,
226 Error **errp);
227 int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
228 ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs);
229
230 int (*bdrv_save_vmstate)(BlockDriverState *bs, QEMUIOVector *qiov,
231 int64_t pos);
232 int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf,
233 int64_t pos, int size);
234
235 int (*bdrv_change_backing_file)(BlockDriverState *bs,
236 const char *backing_file, const char *backing_fmt);
237
238
239 bool (*bdrv_is_inserted)(BlockDriverState *bs);
240 int (*bdrv_media_changed)(BlockDriverState *bs);
241 void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag);
242 void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);
243
244
245 BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
246 unsigned long int req, void *buf,
247 BlockCompletionFunc *cb, void *opaque);
248
249
250 QemuOptsList *create_opts;
251
252
253
254
255
256 int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result,
257 BdrvCheckMode fix);
258
259 int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts,
260 BlockDriverAmendStatusCB *status_cb,
261 void *cb_opaque);
262
263 void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event);
264
265
266 int (*bdrv_debug_breakpoint)(BlockDriverState *bs, const char *event,
267 const char *tag);
268 int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs,
269 const char *tag);
270 int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag);
271 bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag);
272
273 void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp);
274
275
276
277
278
279 int (*bdrv_has_zero_init)(BlockDriverState *bs);
280
281
282
283
284
285 void (*bdrv_detach_aio_context)(BlockDriverState *bs);
286
287
288
289
290
291 void (*bdrv_attach_aio_context)(BlockDriverState *bs,
292 AioContext *new_context);
293
294
295 void (*bdrv_io_plug)(BlockDriverState *bs);
296 void (*bdrv_io_unplug)(BlockDriverState *bs);
297 void (*bdrv_flush_io_queue)(BlockDriverState *bs);
298
299
300
301
302
303
304 int (*bdrv_probe_blocksizes)(BlockDriverState *bs, BlockSizes *bsz);
305
306
307
308
309
310
311
312 int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo);
313
314
315
316
317
318 void (*bdrv_drain)(BlockDriverState *bs);
319
320 QLIST_ENTRY(BlockDriver) list;
321};
322
323typedef struct BlockLimits {
324
325 int max_discard;
326
327
328 int64_t discard_alignment;
329
330
331 int max_write_zeroes;
332
333
334 int64_t write_zeroes_alignment;
335
336
337 int opt_transfer_length;
338
339
340 int max_transfer_length;
341
342
343 size_t min_mem_alignment;
344
345
346 size_t opt_mem_alignment;
347
348
349 int max_iov;
350} BlockLimits;
351
352typedef struct BdrvOpBlocker BdrvOpBlocker;
353
354typedef struct BdrvAioNotifier {
355 void (*attached_aio_context)(AioContext *new_context, void *opaque);
356 void (*detach_aio_context)(void *opaque);
357
358 void *opaque;
359
360 QLIST_ENTRY(BdrvAioNotifier) list;
361} BdrvAioNotifier;
362
363struct BdrvChildRole {
364 void (*inherit_options)(int *child_flags, QDict *child_options,
365 int parent_flags, QDict *parent_options);
366};
367
368extern const BdrvChildRole child_file;
369extern const BdrvChildRole child_format;
370
371struct BdrvChild {
372 BlockDriverState *bs;
373 char *name;
374 const BdrvChildRole *role;
375 QLIST_ENTRY(BdrvChild) next;
376 QLIST_ENTRY(BdrvChild) next_parent;
377};
378
379
380
381
382
383
384
385struct BlockDriverState {
386 int64_t total_sectors;
387
388 int read_only;
389 int open_flags;
390 int encrypted;
391 int valid_key;
392 int sg;
393 int copy_on_read;
394
395 bool probed;
396
397 BlockDriver *drv;
398 void *opaque;
399
400 BlockBackend *blk;
401
402 AioContext *aio_context;
403
404
405
406 QLIST_HEAD(, BdrvAioNotifier) aio_notifiers;
407
408 char filename[PATH_MAX];
409 char backing_file[PATH_MAX];
410
411 char backing_format[16];
412
413 QDict *full_open_options;
414 char exact_filename[PATH_MAX];
415
416 BdrvChild *backing;
417 BdrvChild *file;
418
419
420 NotifierWithReturnList before_write_notifiers;
421
422
423 unsigned int serialising_in_flight;
424
425
426
427
428
429 CoQueue throttled_reqs[2];
430 bool io_limits_enabled;
431
432
433 ThrottleState *throttle_state;
434 ThrottleTimers throttle_timers;
435 unsigned pending_reqs[2];
436 QLIST_ENTRY(BlockDriverState) round_robin;
437
438
439 uint64_t wr_highest_offset;
440
441
442 BlockLimits bl;
443
444
445 bool zero_beyond_eof;
446
447
448 unsigned int request_alignment;
449
450
451 char node_name[32];
452
453 QTAILQ_ENTRY(BlockDriverState) node_list;
454
455 QTAILQ_ENTRY(BlockDriverState) bs_list;
456
457 QTAILQ_ENTRY(BlockDriverState) monitor_list;
458 QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
459 int refcnt;
460
461 QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
462
463
464 QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX];
465
466
467 BlockJob *job;
468
469
470
471
472 BlockDriverState *inherits_from;
473 QLIST_HEAD(, BdrvChild) children;
474 QLIST_HEAD(, BdrvChild) parents;
475
476 QDict *options;
477 QDict *explicit_options;
478 BlockdevDetectZeroesOptions detect_zeroes;
479
480
481 Error *backing_blocker;
482
483
484 uint64_t write_threshold_offset;
485 NotifierWithReturn write_threshold_notifier;
486
487 int quiesce_counter;
488};
489
490struct BlockBackendRootState {
491 int open_flags;
492 bool read_only;
493 BlockdevDetectZeroesOptions detect_zeroes;
494
495 char *throttle_group;
496 ThrottleState *throttle_state;
497};
498
499static inline BlockDriverState *backing_bs(BlockDriverState *bs)
500{
501 return bs->backing ? bs->backing->bs : NULL;
502}
503
504
505
506
507extern BlockDriver bdrv_file;
508extern BlockDriver bdrv_raw;
509extern BlockDriver bdrv_qcow2;
510
511
512
513
514
515
516
517
518void bdrv_setup_io_funcs(BlockDriver *bdrv);
519
520int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
521 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
522 BdrvRequestFlags flags);
523int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
524 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
525 BdrvRequestFlags flags);
526
527int get_tmp_filename(char *filename, int size);
528BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
529 const char *filename);
530
531void bdrv_set_io_limits(BlockDriverState *bs,
532 ThrottleConfig *cfg);
533
534
535
536
537
538
539
540
541void bdrv_add_before_write_notifier(BlockDriverState *bs,
542 NotifierWithReturn *notifier);
543
544
545
546
547
548
549
550
551
552void bdrv_detach_aio_context(BlockDriverState *bs);
553
554
555
556
557
558
559
560
561
562void bdrv_attach_aio_context(BlockDriverState *bs,
563 AioContext *new_context);
564
565
566
567
568
569
570
571
572
573
574
575
576void bdrv_add_aio_context_notifier(BlockDriverState *bs,
577 void (*attached_aio_context)(AioContext *new_context, void *opaque),
578 void (*detach_aio_context)(void *opaque), void *opaque);
579
580
581
582
583
584
585
586
587void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
588 void (*aio_context_attached)(AioContext *,
589 void *),
590 void (*aio_context_detached)(void *),
591 void *opaque);
592
593#ifdef _WIN32
594int is_windows_drive(const char *filename);
595#endif
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616void stream_start(BlockDriverState *bs, BlockDriverState *base,
617 const char *base_id, int64_t speed, BlockdevOnError on_error,
618 BlockCompletionFunc *cb,
619 void *opaque, Error **errp);
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634void commit_start(BlockDriverState *bs, BlockDriverState *base,
635 BlockDriverState *top, int64_t speed,
636 BlockdevOnError on_error, BlockCompletionFunc *cb,
637 void *opaque, const char *backing_file_str, Error **errp);
638
639
640
641
642
643
644
645
646
647
648
649void commit_active_start(BlockDriverState *bs, BlockDriverState *base,
650 int64_t speed,
651 BlockdevOnError on_error,
652 BlockCompletionFunc *cb,
653 void *opaque, Error **errp);
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676void mirror_start(BlockDriverState *bs, BlockDriverState *target,
677 const char *replaces,
678 int64_t speed, uint32_t granularity, int64_t buf_size,
679 MirrorSyncMode mode, BlockdevOnError on_source_error,
680 BlockdevOnError on_target_error,
681 bool unmap,
682 BlockCompletionFunc *cb,
683 void *opaque, Error **errp);
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701void backup_start(BlockDriverState *bs, BlockDriverState *target,
702 int64_t speed, MirrorSyncMode sync_mode,
703 BdrvDirtyBitmap *sync_bitmap,
704 BlockdevOnError on_source_error,
705 BlockdevOnError on_target_error,
706 BlockCompletionFunc *cb, void *opaque,
707 BlockJobTxn *txn, Error **errp);
708
709void hmp_drive_add_node(Monitor *mon, const char *optstr);
710
711BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
712 const char *child_name,
713 const BdrvChildRole *child_role);
714void bdrv_root_unref_child(BdrvChild *child);
715
716void blk_dev_change_media_cb(BlockBackend *blk, bool load);
717bool blk_dev_has_removable_media(BlockBackend *blk);
718bool blk_dev_has_tray(BlockBackend *blk);
719void blk_dev_eject_request(BlockBackend *blk, bool force);
720bool blk_dev_is_tray_open(BlockBackend *blk);
721bool blk_dev_is_medium_locked(BlockBackend *blk);
722void blk_dev_resize_cb(BlockBackend *blk);
723
724void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
725bool bdrv_requests_pending(BlockDriverState *bs);
726
727void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out);
728void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in);
729
730void blockdev_close_all_bdrv_states(void);
731
732#endif
733