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