block: throttle-groups: Use BlockBackend pointers internally
[qemu.git] / include / block / block_int.h
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_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_LAZY_REFCOUNTS 8
42
43 #define BLOCK_OPT_SIZE "size"
44 #define BLOCK_OPT_ENCRYPT "encryption"
45 #define BLOCK_OPT_COMPAT6 "compat6"
46 #define BLOCK_OPT_HWVERSION "hwversion"
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
63 enum BdrvTrackedRequestType {
64 BDRV_TRACKED_READ,
65 BDRV_TRACKED_WRITE,
66 BDRV_TRACKED_FLUSH,
67 BDRV_TRACKED_IOCTL,
68 BDRV_TRACKED_DISCARD,
69 };
70
71 typedef 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; /* owner, used for deadlock detection */
83 CoQueue wait_queue; /* coroutines blocked on this request */
84
85 struct BdrvTrackedRequest *waiting_for;
86 } BdrvTrackedRequest;
87
88 struct BlockDriver {
89 const char *format_name;
90 int instance_size;
91
92 /* set to true if the BlockDriver is a block filter */
93 bool is_filter;
94 /* for snapshots block filter like Quorum can implement the
95 * following recursive callback.
96 * It's purpose is to recurse on the filter children while calling
97 * bdrv_recurse_is_first_non_filter on them.
98 * For a sample implementation look in the future Quorum block filter.
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 /* Any driver implementing this callback is expected to be able to handle
107 * NULL file names in its .bdrv_open() implementation */
108 void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp);
109 /* Drivers not implementing bdrv_parse_filename nor bdrv_open should have
110 * this field set to true, except ones that are defined only by their
111 * child's bs.
112 * An example of the last type will be the quorum block driver.
113 */
114 bool bdrv_needs_filename;
115
116 /* Set if a driver can support backing files */
117 bool supports_backing;
118
119 /* For handling image reopen for split or non-split files */
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 void (*bdrv_close)(BlockDriverState *bs);
131 int (*bdrv_create)(const char *filename, QemuOpts *opts, Error **errp);
132 int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
133 int (*bdrv_make_empty)(BlockDriverState *bs);
134
135 void (*bdrv_refresh_filename)(BlockDriverState *bs, QDict *options);
136
137 /* aio */
138 BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs,
139 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
140 BlockCompletionFunc *cb, void *opaque);
141 BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs,
142 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
143 BlockCompletionFunc *cb, void *opaque);
144 BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs,
145 BlockCompletionFunc *cb, void *opaque);
146 BlockAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs,
147 int64_t sector_num, int nb_sectors,
148 BlockCompletionFunc *cb, void *opaque);
149
150 int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs,
151 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
152 int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs,
153 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
154 int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
155 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov);
156 int coroutine_fn (*bdrv_co_writev_flags)(BlockDriverState *bs,
157 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags);
158 int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs,
159 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
160
161 /*
162 * Efficiently zero a region of the disk image. Typically an image format
163 * would use a compact metadata representation to implement this. This
164 * function pointer may be NULL or return -ENOSUP and .bdrv_co_writev()
165 * will be called instead.
166 */
167 int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs,
168 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
169 int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,
170 int64_t sector_num, int nb_sectors);
171 int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs,
172 int64_t sector_num, int nb_sectors, int *pnum,
173 BlockDriverState **file);
174
175 /*
176 * Invalidate any cached meta-data.
177 */
178 void (*bdrv_invalidate_cache)(BlockDriverState *bs, Error **errp);
179 int (*bdrv_inactivate)(BlockDriverState *bs);
180
181 /*
182 * Flushes all data for all layers by calling bdrv_co_flush for underlying
183 * layers, if needed. This function is needed for deterministic
184 * synchronization of the flush finishing callback.
185 */
186 int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs);
187
188 /*
189 * Flushes all data that was already written to the OS all the way down to
190 * the disk (for example raw-posix calls fsync()).
191 */
192 int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs);
193
194 /*
195 * Flushes all internal caches to the OS. The data may still sit in a
196 * writeback cache of the host OS, but it will survive a crash of the qemu
197 * process.
198 */
199 int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs);
200
201 const char *protocol_name;
202 int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset);
203
204 int64_t (*bdrv_getlength)(BlockDriverState *bs);
205 bool has_variable_length;
206 int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs);
207
208 int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num,
209 const uint8_t *buf, int nb_sectors);
210
211 int (*bdrv_snapshot_create)(BlockDriverState *bs,
212 QEMUSnapshotInfo *sn_info);
213 int (*bdrv_snapshot_goto)(BlockDriverState *bs,
214 const char *snapshot_id);
215 int (*bdrv_snapshot_delete)(BlockDriverState *bs,
216 const char *snapshot_id,
217 const char *name,
218 Error **errp);
219 int (*bdrv_snapshot_list)(BlockDriverState *bs,
220 QEMUSnapshotInfo **psn_info);
221 int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs,
222 const char *snapshot_id,
223 const char *name,
224 Error **errp);
225 int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi);
226 ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs);
227
228 int (*bdrv_save_vmstate)(BlockDriverState *bs, QEMUIOVector *qiov,
229 int64_t pos);
230 int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf,
231 int64_t pos, int size);
232
233 int (*bdrv_change_backing_file)(BlockDriverState *bs,
234 const char *backing_file, const char *backing_fmt);
235
236 /* removable device specific */
237 bool (*bdrv_is_inserted)(BlockDriverState *bs);
238 int (*bdrv_media_changed)(BlockDriverState *bs);
239 void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag);
240 void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked);
241
242 /* to control generic scsi devices */
243 BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
244 unsigned long int req, void *buf,
245 BlockCompletionFunc *cb, void *opaque);
246
247 /* List of options for creating images, terminated by name == NULL */
248 QemuOptsList *create_opts;
249
250 /*
251 * Returns 0 for completed check, -errno for internal errors.
252 * The check results are stored in result.
253 */
254 int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result,
255 BdrvCheckMode fix);
256
257 int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts,
258 BlockDriverAmendStatusCB *status_cb,
259 void *cb_opaque);
260
261 void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event);
262
263 /* TODO Better pass a option string/QDict/QemuOpts to add any rule? */
264 int (*bdrv_debug_breakpoint)(BlockDriverState *bs, const char *event,
265 const char *tag);
266 int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs,
267 const char *tag);
268 int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag);
269 bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag);
270
271 void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp);
272
273 /*
274 * Returns 1 if newly created images are guaranteed to contain only
275 * zeros, 0 otherwise.
276 */
277 int (*bdrv_has_zero_init)(BlockDriverState *bs);
278
279 /* Remove fd handlers, timers, and other event loop callbacks so the event
280 * loop is no longer in use. Called with no in-flight requests and in
281 * depth-first traversal order with parents before child nodes.
282 */
283 void (*bdrv_detach_aio_context)(BlockDriverState *bs);
284
285 /* Add fd handlers, timers, and other event loop callbacks so I/O requests
286 * can be processed again. Called with no in-flight requests and in
287 * depth-first traversal order with child nodes before parent nodes.
288 */
289 void (*bdrv_attach_aio_context)(BlockDriverState *bs,
290 AioContext *new_context);
291
292 /* io queue for linux-aio */
293 void (*bdrv_io_plug)(BlockDriverState *bs);
294 void (*bdrv_io_unplug)(BlockDriverState *bs);
295
296 /**
297 * Try to get @bs's logical and physical block size.
298 * On success, store them in @bsz and return zero.
299 * On failure, return negative errno.
300 */
301 int (*bdrv_probe_blocksizes)(BlockDriverState *bs, BlockSizes *bsz);
302 /**
303 * Try to get @bs's geometry (cyls, heads, sectors)
304 * On success, store them in @geo and return 0.
305 * On failure return -errno.
306 * Only drivers that want to override guest geometry implement this
307 * callback; see hd_geometry_guess().
308 */
309 int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo);
310
311 /**
312 * Drain and stop any internal sources of requests in the driver, and
313 * remain so until next I/O callback (e.g. bdrv_co_writev) is called.
314 */
315 void (*bdrv_drain)(BlockDriverState *bs);
316
317 void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child,
318 Error **errp);
319 void (*bdrv_del_child)(BlockDriverState *parent, BdrvChild *child,
320 Error **errp);
321
322 QLIST_ENTRY(BlockDriver) list;
323 };
324
325 typedef struct BlockLimits {
326 /* maximum number of sectors that can be discarded at once */
327 int max_discard;
328
329 /* optimal alignment for discard requests in sectors */
330 int64_t discard_alignment;
331
332 /* maximum number of sectors that can zeroized at once */
333 int max_write_zeroes;
334
335 /* optimal alignment for write zeroes requests in sectors */
336 int64_t write_zeroes_alignment;
337
338 /* optimal transfer length in sectors */
339 int opt_transfer_length;
340
341 /* maximal transfer length in sectors */
342 int max_transfer_length;
343
344 /* memory alignment so that no bounce buffer is needed */
345 size_t min_mem_alignment;
346
347 /* memory alignment for bounce buffer */
348 size_t opt_mem_alignment;
349
350 /* maximum number of iovec elements */
351 int max_iov;
352 } BlockLimits;
353
354 typedef struct BdrvOpBlocker BdrvOpBlocker;
355
356 typedef struct BdrvAioNotifier {
357 void (*attached_aio_context)(AioContext *new_context, void *opaque);
358 void (*detach_aio_context)(void *opaque);
359
360 void *opaque;
361
362 QLIST_ENTRY(BdrvAioNotifier) list;
363 } BdrvAioNotifier;
364
365 struct BdrvChildRole {
366 void (*inherit_options)(int *child_flags, QDict *child_options,
367 int parent_flags, QDict *parent_options);
368 };
369
370 extern const BdrvChildRole child_file;
371 extern const BdrvChildRole child_format;
372
373 struct BdrvChild {
374 BlockDriverState *bs;
375 char *name;
376 const BdrvChildRole *role;
377 QLIST_ENTRY(BdrvChild) next;
378 QLIST_ENTRY(BdrvChild) next_parent;
379 };
380
381 /*
382 * Note: the function bdrv_append() copies and swaps contents of
383 * BlockDriverStates, so if you add new fields to this struct, please
384 * inspect bdrv_append() to determine if the new fields need to be
385 * copied as well.
386 */
387 struct BlockDriverState {
388 int64_t total_sectors; /* if we are reading a disk image, give its
389 size in sectors */
390 int read_only; /* if true, the media is read only */
391 int open_flags; /* flags used to open the file, re-used for re-open */
392 int encrypted; /* if true, the media is encrypted */
393 int valid_key; /* if true, a valid encryption key has been set */
394 int sg; /* if true, the device is a /dev/sg* */
395 int copy_on_read; /* if true, copy read backing sectors into image
396 note this is a reference count */
397 bool probed;
398
399 BlockDriver *drv; /* NULL means no media */
400 void *opaque;
401
402 BlockBackend *blk; /* owning backend, if any */
403
404 AioContext *aio_context; /* event loop used for fd handlers, timers, etc */
405 /* long-running tasks intended to always use the same AioContext as this
406 * BDS may register themselves in this list to be notified of changes
407 * regarding this BDS's context */
408 QLIST_HEAD(, BdrvAioNotifier) aio_notifiers;
409
410 char filename[PATH_MAX];
411 char backing_file[PATH_MAX]; /* if non zero, the image is a diff of
412 this file image */
413 char backing_format[16]; /* if non-zero and backing_file exists */
414
415 QDict *full_open_options;
416 char exact_filename[PATH_MAX];
417
418 BdrvChild *backing;
419 BdrvChild *file;
420
421 /* Callback before write request is processed */
422 NotifierWithReturnList before_write_notifiers;
423
424 /* number of in-flight serialising requests */
425 unsigned int serialising_in_flight;
426
427 /* I/O throttling.
428 * throttle_state tells us if this BDS has I/O limits configured.
429 * io_limits_disabled tells us if they are currently being enforced */
430 CoQueue throttled_reqs[2];
431 unsigned int io_limits_disabled;
432
433 /* The following fields are protected by the ThrottleGroup lock.
434 * See the ThrottleGroup documentation for details. */
435 ThrottleState *throttle_state;
436 ThrottleTimers throttle_timers;
437 unsigned pending_reqs[2];
438
439 /* Offset after the highest byte written to */
440 uint64_t wr_highest_offset;
441
442 /* I/O Limits */
443 BlockLimits bl;
444
445 /* Whether produces zeros when read beyond eof */
446 bool zero_beyond_eof;
447
448 /* Alignment requirement for offset/length of I/O requests */
449 unsigned int request_alignment;
450 /* Flags honored during pwrite (so far: BDRV_REQ_FUA) */
451 unsigned int supported_write_flags;
452 /* Flags honored during write_zeroes (so far: BDRV_REQ_FUA,
453 * BDRV_REQ_MAY_UNMAP) */
454 unsigned int supported_zero_flags;
455
456 /* the following member gives a name to every node on the bs graph. */
457 char node_name[32];
458 /* element of the list of named nodes building the graph */
459 QTAILQ_ENTRY(BlockDriverState) node_list;
460 /* element of the list of all BlockDriverStates (all_bdrv_states) */
461 QTAILQ_ENTRY(BlockDriverState) bs_list;
462 /* element of the list of monitor-owned BDS */
463 QTAILQ_ENTRY(BlockDriverState) monitor_list;
464 QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
465 int refcnt;
466
467 QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
468
469 /* operation blockers */
470 QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX];
471
472 /* long-running background operation */
473 BlockJob *job;
474
475 /* The node that this node inherited default options from (and a reopen on
476 * which can affect this node by changing these defaults). This is always a
477 * parent node of this node. */
478 BlockDriverState *inherits_from;
479 QLIST_HEAD(, BdrvChild) children;
480 QLIST_HEAD(, BdrvChild) parents;
481
482 QDict *options;
483 QDict *explicit_options;
484 BlockdevDetectZeroesOptions detect_zeroes;
485
486 /* The error object in use for blocking operations on backing_hd */
487 Error *backing_blocker;
488
489 /* threshold limit for writes, in bytes. "High water mark". */
490 uint64_t write_threshold_offset;
491 NotifierWithReturn write_threshold_notifier;
492
493 /* counters for nested bdrv_io_plug and bdrv_io_unplugged_begin */
494 unsigned io_plugged;
495 unsigned io_plug_disabled;
496
497 int quiesce_counter;
498 };
499
500 struct BlockBackendRootState {
501 int open_flags;
502 bool read_only;
503 BlockdevDetectZeroesOptions detect_zeroes;
504
505 char *throttle_group;
506 ThrottleState *throttle_state;
507 };
508
509 static inline BlockDriverState *backing_bs(BlockDriverState *bs)
510 {
511 return bs->backing ? bs->backing->bs : NULL;
512 }
513
514
515 /* Essential block drivers which must always be statically linked into qemu, and
516 * which therefore can be accessed without using bdrv_find_format() */
517 extern BlockDriver bdrv_file;
518 extern BlockDriver bdrv_raw;
519 extern BlockDriver bdrv_qcow2;
520
521 /**
522 * bdrv_setup_io_funcs:
523 *
524 * Prepare a #BlockDriver for I/O request processing by populating
525 * unimplemented coroutine and AIO interfaces with generic wrapper functions
526 * that fall back to implemented interfaces.
527 */
528 void bdrv_setup_io_funcs(BlockDriver *bdrv);
529
530 int coroutine_fn bdrv_co_preadv(BlockDriverState *bs,
531 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
532 BdrvRequestFlags flags);
533 int coroutine_fn bdrv_co_pwritev(BlockDriverState *bs,
534 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
535 BdrvRequestFlags flags);
536
537 int get_tmp_filename(char *filename, int size);
538 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
539 const char *filename);
540
541 void bdrv_set_io_limits(BlockDriverState *bs,
542 ThrottleConfig *cfg);
543
544
545 /**
546 * bdrv_add_before_write_notifier:
547 *
548 * Register a callback that is invoked before write requests are processed but
549 * after any throttling or waiting for overlapping requests.
550 */
551 void bdrv_add_before_write_notifier(BlockDriverState *bs,
552 NotifierWithReturn *notifier);
553
554 /**
555 * bdrv_detach_aio_context:
556 *
557 * May be called from .bdrv_detach_aio_context() to detach children from the
558 * current #AioContext. This is only needed by block drivers that manage their
559 * own children. Both ->file and ->backing are automatically handled and
560 * block drivers should not call this function on them explicitly.
561 */
562 void bdrv_detach_aio_context(BlockDriverState *bs);
563
564 /**
565 * bdrv_attach_aio_context:
566 *
567 * May be called from .bdrv_attach_aio_context() to attach children to the new
568 * #AioContext. This is only needed by block drivers that manage their own
569 * children. Both ->file and ->backing are automatically handled and block
570 * drivers should not call this function on them explicitly.
571 */
572 void bdrv_attach_aio_context(BlockDriverState *bs,
573 AioContext *new_context);
574
575 /**
576 * bdrv_add_aio_context_notifier:
577 *
578 * If a long-running job intends to be always run in the same AioContext as a
579 * certain BDS, it may use this function to be notified of changes regarding the
580 * association of the BDS to an AioContext.
581 *
582 * attached_aio_context() is called after the target BDS has been attached to a
583 * new AioContext; detach_aio_context() is called before the target BDS is being
584 * detached from its old AioContext.
585 */
586 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
587 void (*attached_aio_context)(AioContext *new_context, void *opaque),
588 void (*detach_aio_context)(void *opaque), void *opaque);
589
590 /**
591 * bdrv_remove_aio_context_notifier:
592 *
593 * Unsubscribe of change notifications regarding the BDS's AioContext. The
594 * parameters given here have to be the same as those given to
595 * bdrv_add_aio_context_notifier().
596 */
597 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
598 void (*aio_context_attached)(AioContext *,
599 void *),
600 void (*aio_context_detached)(void *),
601 void *opaque);
602
603 #ifdef _WIN32
604 int is_windows_drive(const char *filename);
605 #endif
606
607 /**
608 * stream_start:
609 * @bs: Block device to operate on.
610 * @base: Block device that will become the new base, or %NULL to
611 * flatten the whole backing file chain onto @bs.
612 * @base_id: The file name that will be written to @bs as the new
613 * backing file if the job completes. Ignored if @base is %NULL.
614 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
615 * @on_error: The action to take upon error.
616 * @cb: Completion function for the job.
617 * @opaque: Opaque pointer value passed to @cb.
618 * @errp: Error object.
619 *
620 * Start a streaming operation on @bs. Clusters that are unallocated
621 * in @bs, but allocated in any image between @base and @bs (both
622 * exclusive) will be written to @bs. At the end of a successful
623 * streaming job, the backing file of @bs will be changed to
624 * @base_id in the written image and to @base in the live BlockDriverState.
625 */
626 void stream_start(BlockDriverState *bs, BlockDriverState *base,
627 const char *base_id, int64_t speed, BlockdevOnError on_error,
628 BlockCompletionFunc *cb,
629 void *opaque, Error **errp);
630
631 /**
632 * commit_start:
633 * @bs: Active block device.
634 * @top: Top block device to be committed.
635 * @base: Block device that will be written into, and become the new top.
636 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
637 * @on_error: The action to take upon error.
638 * @cb: Completion function for the job.
639 * @opaque: Opaque pointer value passed to @cb.
640 * @backing_file_str: String to use as the backing file in @top's overlay
641 * @errp: Error object.
642 *
643 */
644 void commit_start(BlockDriverState *bs, BlockDriverState *base,
645 BlockDriverState *top, int64_t speed,
646 BlockdevOnError on_error, BlockCompletionFunc *cb,
647 void *opaque, const char *backing_file_str, Error **errp);
648 /**
649 * commit_active_start:
650 * @bs: Active block device to be committed.
651 * @base: Block device that will be written into, and become the new top.
652 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
653 * @on_error: The action to take upon error.
654 * @cb: Completion function for the job.
655 * @opaque: Opaque pointer value passed to @cb.
656 * @errp: Error object.
657 *
658 */
659 void commit_active_start(BlockDriverState *bs, BlockDriverState *base,
660 int64_t speed,
661 BlockdevOnError on_error,
662 BlockCompletionFunc *cb,
663 void *opaque, Error **errp);
664 /*
665 * mirror_start:
666 * @bs: Block device to operate on.
667 * @target: Block device to write to.
668 * @replaces: Block graph node name to replace once the mirror is done. Can
669 * only be used when full mirroring is selected.
670 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
671 * @granularity: The chosen granularity for the dirty bitmap.
672 * @buf_size: The amount of data that can be in flight at one time.
673 * @mode: Whether to collapse all images in the chain to the target.
674 * @on_source_error: The action to take upon error reading from the source.
675 * @on_target_error: The action to take upon error writing to the target.
676 * @unmap: Whether to unmap target where source sectors only contain zeroes.
677 * @cb: Completion function for the job.
678 * @opaque: Opaque pointer value passed to @cb.
679 * @errp: Error object.
680 *
681 * Start a mirroring operation on @bs. Clusters that are allocated
682 * in @bs will be written to @bs until the job is cancelled or
683 * manually completed. At the end of a successful mirroring job,
684 * @bs will be switched to read from @target.
685 */
686 void mirror_start(BlockDriverState *bs, BlockDriverState *target,
687 const char *replaces,
688 int64_t speed, uint32_t granularity, int64_t buf_size,
689 MirrorSyncMode mode, BlockdevOnError on_source_error,
690 BlockdevOnError on_target_error,
691 bool unmap,
692 BlockCompletionFunc *cb,
693 void *opaque, Error **errp);
694
695 /*
696 * backup_start:
697 * @bs: Block device to operate on.
698 * @target: Block device to write to.
699 * @speed: The maximum speed, in bytes per second, or 0 for unlimited.
700 * @sync_mode: What parts of the disk image should be copied to the destination.
701 * @sync_bitmap: The dirty bitmap if sync_mode is MIRROR_SYNC_MODE_INCREMENTAL.
702 * @on_source_error: The action to take upon error reading from the source.
703 * @on_target_error: The action to take upon error writing to the target.
704 * @cb: Completion function for the job.
705 * @opaque: Opaque pointer value passed to @cb.
706 * @txn: Transaction that this job is part of (may be NULL).
707 *
708 * Start a backup operation on @bs. Clusters in @bs are written to @target
709 * until the job is cancelled or manually completed.
710 */
711 void backup_start(BlockDriverState *bs, BlockDriverState *target,
712 int64_t speed, MirrorSyncMode sync_mode,
713 BdrvDirtyBitmap *sync_bitmap,
714 BlockdevOnError on_source_error,
715 BlockdevOnError on_target_error,
716 BlockCompletionFunc *cb, void *opaque,
717 BlockJobTxn *txn, Error **errp);
718
719 void hmp_drive_add_node(Monitor *mon, const char *optstr);
720
721 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
722 const char *child_name,
723 const BdrvChildRole *child_role);
724 void bdrv_root_unref_child(BdrvChild *child);
725
726 void bdrv_no_throttling_begin(BlockDriverState *bs);
727 void bdrv_no_throttling_end(BlockDriverState *bs);
728
729 void blk_dev_change_media_cb(BlockBackend *blk, bool load);
730 bool blk_dev_has_removable_media(BlockBackend *blk);
731 bool blk_dev_has_tray(BlockBackend *blk);
732 void blk_dev_eject_request(BlockBackend *blk, bool force);
733 bool blk_dev_is_tray_open(BlockBackend *blk);
734 bool blk_dev_is_medium_locked(BlockBackend *blk);
735 void blk_dev_resize_cb(BlockBackend *blk);
736
737 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors);
738 bool bdrv_requests_pending(BlockDriverState *bs);
739
740 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out);
741 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in);
742
743 void blockdev_close_all_bdrv_states(void);
744
745 #endif /* BLOCK_INT_H */