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_COMMON_H 25 #define BLOCK_INT_COMMON_H 26 27 #include "block/accounting.h" 28 #include "block/block.h" 29 #include "block/aio-wait.h" 30 #include "qemu/queue.h" 31 #include "qemu/coroutine.h" 32 #include "qemu/stats64.h" 33 #include "qemu/timer.h" 34 #include "qemu/hbitmap.h" 35 #include "block/snapshot.h" 36 #include "qemu/throttle.h" 37 #include "qemu/rcu.h" 38 39 #define BLOCK_FLAG_LAZY_REFCOUNTS 8 40 41 #define BLOCK_OPT_SIZE "size" 42 #define BLOCK_OPT_ENCRYPT "encryption" 43 #define BLOCK_OPT_ENCRYPT_FORMAT "encrypt.format" 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_EXTENT_SIZE_HINT "extent_size_hint" 58 #define BLOCK_OPT_OBJECT_SIZE "object_size" 59 #define BLOCK_OPT_REFCOUNT_BITS "refcount_bits" 60 #define BLOCK_OPT_DATA_FILE "data_file" 61 #define BLOCK_OPT_DATA_FILE_RAW "data_file_raw" 62 #define BLOCK_OPT_COMPRESSION_TYPE "compression_type" 63 #define BLOCK_OPT_EXTL2 "extended_l2" 64 65 #define BLOCK_PROBE_BUF_SIZE 512 66 67 enum BdrvTrackedRequestType { 68 BDRV_TRACKED_READ, 69 BDRV_TRACKED_WRITE, 70 BDRV_TRACKED_DISCARD, 71 BDRV_TRACKED_TRUNCATE, 72 }; 73 74 /* 75 * That is not quite good that BdrvTrackedRequest structure is public, 76 * as block/io.c is very careful about incoming offset/bytes being 77 * correct. Be sure to assert bdrv_check_request() succeeded after any 78 * modification of BdrvTrackedRequest object out of block/io.c 79 */ 80 typedef struct BdrvTrackedRequest { 81 BlockDriverState *bs; 82 int64_t offset; 83 int64_t bytes; 84 enum BdrvTrackedRequestType type; 85 86 bool serialising; 87 int64_t overlap_offset; 88 int64_t overlap_bytes; 89 90 QLIST_ENTRY(BdrvTrackedRequest) list; 91 Coroutine *co; /* owner, used for deadlock detection */ 92 CoQueue wait_queue; /* coroutines blocked on this request */ 93 94 struct BdrvTrackedRequest *waiting_for; 95 } BdrvTrackedRequest; 96 97 98 struct BlockDriver { 99 /* 100 * These fields are initialized when this object is created, 101 * and are never changed afterwards. 102 */ 103 104 const char *format_name; 105 int instance_size; 106 107 /* 108 * Set to true if the BlockDriver is a block filter. Block filters pass 109 * certain callbacks that refer to data (see block.c) to their bs->file 110 * or bs->backing (whichever one exists) if the driver doesn't implement 111 * them. Drivers that do not wish to forward must implement them and return 112 * -ENOTSUP. 113 * Note that filters are not allowed to modify data. 114 * 115 * Filters generally cannot have more than a single filtered child, 116 * because the data they present must at all times be the same as 117 * that on their filtered child. That would be impossible to 118 * achieve for multiple filtered children. 119 * (And this filtered child must then be bs->file or bs->backing.) 120 */ 121 bool is_filter; 122 /* 123 * Only make sense for filter drivers, for others must be false. 124 * If true, filtered child is bs->backing. Otherwise it's bs->file. 125 * Two internal filters use bs->backing as filtered child and has this 126 * field set to true: mirror_top and commit_top. There also two such test 127 * filters in tests/unit/test-bdrv-graph-mod.c. 128 * 129 * Never create any more such filters! 130 * 131 * TODO: imagine how to deprecate this behavior and make all filters work 132 * similarly using bs->file as filtered child. 133 */ 134 bool filtered_child_is_backing; 135 136 /* 137 * Set to true if the BlockDriver is a format driver. Format nodes 138 * generally do not expect their children to be other format nodes 139 * (except for backing files), and so format probing is disabled 140 * on those children. 141 */ 142 bool is_format; 143 144 /* 145 * Drivers not implementing bdrv_parse_filename nor bdrv_open should have 146 * this field set to true, except ones that are defined only by their 147 * child's bs. 148 * An example of the last type will be the quorum block driver. 149 */ 150 bool bdrv_needs_filename; 151 152 /* 153 * Set if a driver can support backing files. This also implies the 154 * following semantics: 155 * 156 * - Return status 0 of .bdrv_co_block_status means that corresponding 157 * blocks are not allocated in this layer of backing-chain 158 * - For such (unallocated) blocks, read will: 159 * - fill buffer with zeros if there is no backing file 160 * - read from the backing file otherwise, where the block layer 161 * takes care of reading zeros beyond EOF if backing file is short 162 */ 163 bool supports_backing; 164 165 bool has_variable_length; 166 167 /* 168 * Drivers setting this field must be able to work with just a plain 169 * filename with '<protocol_name>:' as a prefix, and no other options. 170 * Options may be extracted from the filename by implementing 171 * bdrv_parse_filename. 172 */ 173 const char *protocol_name; 174 175 /* List of options for creating images, terminated by name == NULL */ 176 QemuOptsList *create_opts; 177 178 /* List of options for image amend */ 179 QemuOptsList *amend_opts; 180 181 /* 182 * If this driver supports reopening images this contains a 183 * NULL-terminated list of the runtime options that can be 184 * modified. If an option in this list is unspecified during 185 * reopen then it _must_ be reset to its default value or return 186 * an error. 187 */ 188 const char *const *mutable_opts; 189 190 /* 191 * Pointer to a NULL-terminated array of names of strong options 192 * that can be specified for bdrv_open(). A strong option is one 193 * that changes the data of a BDS. 194 * If this pointer is NULL, the array is considered empty. 195 * "filename" and "driver" are always considered strong. 196 */ 197 const char *const *strong_runtime_opts; 198 199 200 /* 201 * Global state (GS) API. These functions run under the BQL. 202 * 203 * See include/block/block-global-state.h for more information about 204 * the GS API. 205 */ 206 207 /* 208 * This function is invoked under BQL before .bdrv_co_amend() 209 * (which in contrast does not necessarily run under the BQL) 210 * to allow driver-specific initialization code that requires 211 * the BQL, like setting up specific permission flags. 212 */ 213 int (*bdrv_amend_pre_run)(BlockDriverState *bs, Error **errp); 214 /* 215 * This function is invoked under BQL after .bdrv_co_amend() 216 * to allow cleaning up what was done in .bdrv_amend_pre_run(). 217 */ 218 void (*bdrv_amend_clean)(BlockDriverState *bs); 219 220 /* 221 * Return true if @to_replace can be replaced by a BDS with the 222 * same data as @bs without it affecting @bs's behavior (that is, 223 * without it being visible to @bs's parents). 224 */ 225 bool (*bdrv_recurse_can_replace)(BlockDriverState *bs, 226 BlockDriverState *to_replace); 227 228 int (*bdrv_probe_device)(const char *filename); 229 230 /* 231 * Any driver implementing this callback is expected to be able to handle 232 * NULL file names in its .bdrv_open() implementation. 233 */ 234 void (*bdrv_parse_filename)(const char *filename, QDict *options, 235 Error **errp); 236 237 /* For handling image reopen for split or non-split files. */ 238 int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, 239 BlockReopenQueue *queue, Error **errp); 240 void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state); 241 void (*bdrv_reopen_commit_post)(BDRVReopenState *reopen_state); 242 void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); 243 void (*bdrv_join_options)(QDict *options, QDict *old_options); 244 245 int (*bdrv_open)(BlockDriverState *bs, QDict *options, int flags, 246 Error **errp); 247 248 /* Protocol drivers should implement this instead of bdrv_open */ 249 int (*bdrv_file_open)(BlockDriverState *bs, QDict *options, int flags, 250 Error **errp); 251 void (*bdrv_close)(BlockDriverState *bs); 252 253 int coroutine_fn (*bdrv_co_create)(BlockdevCreateOptions *opts, 254 Error **errp); 255 int coroutine_fn (*bdrv_co_create_opts)(BlockDriver *drv, 256 const char *filename, 257 QemuOpts *opts, 258 Error **errp); 259 260 int (*bdrv_amend_options)(BlockDriverState *bs, 261 QemuOpts *opts, 262 BlockDriverAmendStatusCB *status_cb, 263 void *cb_opaque, 264 bool force, 265 Error **errp); 266 267 int (*bdrv_make_empty)(BlockDriverState *bs); 268 269 /* 270 * Refreshes the bs->exact_filename field. If that is impossible, 271 * bs->exact_filename has to be left empty. 272 */ 273 void (*bdrv_refresh_filename)(BlockDriverState *bs); 274 275 /* 276 * Gathers the open options for all children into @target. 277 * A simple format driver (without backing file support) might 278 * implement this function like this: 279 * 280 * QINCREF(bs->file->bs->full_open_options); 281 * qdict_put(target, "file", bs->file->bs->full_open_options); 282 * 283 * If not specified, the generic implementation will simply put 284 * all children's options under their respective name. 285 * 286 * @backing_overridden is true when bs->backing seems not to be 287 * the child that would result from opening bs->backing_file. 288 * Therefore, if it is true, the backing child's options should be 289 * gathered; otherwise, there is no need since the backing child 290 * is the one implied by the image header. 291 * 292 * Note that ideally this function would not be needed. Every 293 * block driver which implements it is probably doing something 294 * shady regarding its runtime option structure. 295 */ 296 void (*bdrv_gather_child_options)(BlockDriverState *bs, QDict *target, 297 bool backing_overridden); 298 299 /* 300 * Returns an allocated string which is the directory name of this BDS: It 301 * will be used to make relative filenames absolute by prepending this 302 * function's return value to them. 303 */ 304 char *(*bdrv_dirname)(BlockDriverState *bs, Error **errp); 305 306 /* 307 * This informs the driver that we are no longer interested in the result 308 * of in-flight requests, so don't waste the time if possible. 309 * 310 * One example usage is to avoid waiting for an nbd target node reconnect 311 * timeout during job-cancel with force=true. 312 */ 313 void (*bdrv_cancel_in_flight)(BlockDriverState *bs); 314 315 int (*bdrv_inactivate)(BlockDriverState *bs); 316 317 int (*bdrv_snapshot_create)(BlockDriverState *bs, 318 QEMUSnapshotInfo *sn_info); 319 int (*bdrv_snapshot_goto)(BlockDriverState *bs, 320 const char *snapshot_id); 321 int (*bdrv_snapshot_delete)(BlockDriverState *bs, 322 const char *snapshot_id, 323 const char *name, 324 Error **errp); 325 int (*bdrv_snapshot_list)(BlockDriverState *bs, 326 QEMUSnapshotInfo **psn_info); 327 int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, 328 const char *snapshot_id, 329 const char *name, 330 Error **errp); 331 332 int (*bdrv_change_backing_file)(BlockDriverState *bs, 333 const char *backing_file, const char *backing_fmt); 334 335 /* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ 336 int (*bdrv_debug_breakpoint)(BlockDriverState *bs, const char *event, 337 const char *tag); 338 int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, 339 const char *tag); 340 int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag); 341 bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag); 342 343 void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp); 344 345 /* 346 * Returns 1 if newly created images are guaranteed to contain only 347 * zeros, 0 otherwise. 348 */ 349 int (*bdrv_has_zero_init)(BlockDriverState *bs); 350 351 /* 352 * Remove fd handlers, timers, and other event loop callbacks so the event 353 * loop is no longer in use. Called with no in-flight requests and in 354 * depth-first traversal order with parents before child nodes. 355 */ 356 void (*bdrv_detach_aio_context)(BlockDriverState *bs); 357 358 /* 359 * Add fd handlers, timers, and other event loop callbacks so I/O requests 360 * can be processed again. Called with no in-flight requests and in 361 * depth-first traversal order with child nodes before parent nodes. 362 */ 363 void (*bdrv_attach_aio_context)(BlockDriverState *bs, 364 AioContext *new_context); 365 366 /** 367 * Try to get @bs's logical and physical block size. 368 * On success, store them in @bsz and return zero. 369 * On failure, return negative errno. 370 */ 371 int (*bdrv_probe_blocksizes)(BlockDriverState *bs, BlockSizes *bsz); 372 /** 373 * Try to get @bs's geometry (cyls, heads, sectors) 374 * On success, store them in @geo and return 0. 375 * On failure return -errno. 376 * Only drivers that want to override guest geometry implement this 377 * callback; see hd_geometry_guess(). 378 */ 379 int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo); 380 381 void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child, 382 Error **errp); 383 void (*bdrv_del_child)(BlockDriverState *parent, BdrvChild *child, 384 Error **errp); 385 386 /** 387 * Informs the block driver that a permission change is intended. The 388 * driver checks whether the change is permissible and may take other 389 * preparations for the change (e.g. get file system locks). This operation 390 * is always followed either by a call to either .bdrv_set_perm or 391 * .bdrv_abort_perm_update. 392 * 393 * Checks whether the requested set of cumulative permissions in @perm 394 * can be granted for accessing @bs and whether no other users are using 395 * permissions other than those given in @shared (both arguments take 396 * BLK_PERM_* bitmasks). 397 * 398 * If both conditions are met, 0 is returned. Otherwise, -errno is returned 399 * and errp is set to an error describing the conflict. 400 */ 401 int (*bdrv_check_perm)(BlockDriverState *bs, uint64_t perm, 402 uint64_t shared, Error **errp); 403 404 /** 405 * Called to inform the driver that the set of cumulative set of used 406 * permissions for @bs has changed to @perm, and the set of sharable 407 * permission to @shared. The driver can use this to propagate changes to 408 * its children (i.e. request permissions only if a parent actually needs 409 * them). 410 * 411 * This function is only invoked after bdrv_check_perm(), so block drivers 412 * may rely on preparations made in their .bdrv_check_perm implementation. 413 */ 414 void (*bdrv_set_perm)(BlockDriverState *bs, uint64_t perm, uint64_t shared); 415 416 /* 417 * Called to inform the driver that after a previous bdrv_check_perm() 418 * call, the permission update is not performed and any preparations made 419 * for it (e.g. taken file locks) need to be undone. 420 * 421 * This function can be called even for nodes that never saw a 422 * bdrv_check_perm() call. It is a no-op then. 423 */ 424 void (*bdrv_abort_perm_update)(BlockDriverState *bs); 425 426 /** 427 * Returns in @nperm and @nshared the permissions that the driver for @bs 428 * needs on its child @c, based on the cumulative permissions requested by 429 * the parents in @parent_perm and @parent_shared. 430 * 431 * If @c is NULL, return the permissions for attaching a new child for the 432 * given @child_class and @role. 433 * 434 * If @reopen_queue is non-NULL, don't return the currently needed 435 * permissions, but those that will be needed after applying the 436 * @reopen_queue. 437 */ 438 void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c, 439 BdrvChildRole role, 440 BlockReopenQueue *reopen_queue, 441 uint64_t parent_perm, uint64_t parent_shared, 442 uint64_t *nperm, uint64_t *nshared); 443 444 /** 445 * Register/unregister a buffer for I/O. For example, when the driver is 446 * interested to know the memory areas that will later be used in iovs, so 447 * that it can do IOMMU mapping with VFIO etc., in order to get better 448 * performance. In the case of VFIO drivers, this callback is used to do 449 * DMA mapping for hot buffers. 450 */ 451 void (*bdrv_register_buf)(BlockDriverState *bs, void *host, size_t size); 452 void (*bdrv_unregister_buf)(BlockDriverState *bs, void *host); 453 454 /* 455 * This field is modified only under the BQL, and is part of 456 * the global state. 457 */ 458 QLIST_ENTRY(BlockDriver) list; 459 460 /* 461 * I/O API functions. These functions are thread-safe. 462 * 463 * See include/block/block-io.h for more information about 464 * the I/O API. 465 */ 466 467 int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename); 468 469 int coroutine_fn (*bdrv_co_amend)(BlockDriverState *bs, 470 BlockdevAmendOptions *opts, 471 bool force, 472 Error **errp); 473 474 /* aio */ 475 BlockAIOCB *(*bdrv_aio_preadv)(BlockDriverState *bs, 476 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 477 BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque); 478 BlockAIOCB *(*bdrv_aio_pwritev)(BlockDriverState *bs, 479 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 480 BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque); 481 BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, 482 BlockCompletionFunc *cb, void *opaque); 483 BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs, 484 int64_t offset, int bytes, 485 BlockCompletionFunc *cb, void *opaque); 486 487 int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, 488 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); 489 490 /** 491 * @offset: position in bytes to read at 492 * @bytes: number of bytes to read 493 * @qiov: the buffers to fill with read data 494 * @flags: currently unused, always 0 495 * 496 * @offset and @bytes will be a multiple of 'request_alignment', 497 * but the length of individual @qiov elements does not have to 498 * be a multiple. 499 * 500 * @bytes will always equal the total size of @qiov, and will be 501 * no larger than 'max_transfer'. 502 * 503 * The buffer in @qiov may point directly to guest memory. 504 */ 505 int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs, 506 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 507 BdrvRequestFlags flags); 508 509 int coroutine_fn (*bdrv_co_preadv_part)(BlockDriverState *bs, 510 int64_t offset, int64_t bytes, 511 QEMUIOVector *qiov, size_t qiov_offset, 512 BdrvRequestFlags flags); 513 514 int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs, 515 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 516 int flags); 517 /** 518 * @offset: position in bytes to write at 519 * @bytes: number of bytes to write 520 * @qiov: the buffers containing data to write 521 * @flags: zero or more bits allowed by 'supported_write_flags' 522 * 523 * @offset and @bytes will be a multiple of 'request_alignment', 524 * but the length of individual @qiov elements does not have to 525 * be a multiple. 526 * 527 * @bytes will always equal the total size of @qiov, and will be 528 * no larger than 'max_transfer'. 529 * 530 * The buffer in @qiov may point directly to guest memory. 531 */ 532 int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs, 533 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 534 BdrvRequestFlags flags); 535 int coroutine_fn (*bdrv_co_pwritev_part)(BlockDriverState *bs, 536 int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset, 537 BdrvRequestFlags flags); 538 539 /* 540 * Efficiently zero a region of the disk image. Typically an image format 541 * would use a compact metadata representation to implement this. This 542 * function pointer may be NULL or return -ENOSUP and .bdrv_co_writev() 543 * will be called instead. 544 */ 545 int coroutine_fn (*bdrv_co_pwrite_zeroes)(BlockDriverState *bs, 546 int64_t offset, int64_t bytes, BdrvRequestFlags flags); 547 int coroutine_fn (*bdrv_co_pdiscard)(BlockDriverState *bs, 548 int64_t offset, int64_t bytes); 549 550 /* 551 * Map [offset, offset + nbytes) range onto a child of @bs to copy from, 552 * and invoke bdrv_co_copy_range_from(child, ...), or invoke 553 * bdrv_co_copy_range_to() if @bs is the leaf child to copy data from. 554 * 555 * See the comment of bdrv_co_copy_range for the parameter and return value 556 * semantics. 557 */ 558 int coroutine_fn (*bdrv_co_copy_range_from)(BlockDriverState *bs, 559 BdrvChild *src, 560 int64_t offset, 561 BdrvChild *dst, 562 int64_t dst_offset, 563 int64_t bytes, 564 BdrvRequestFlags read_flags, 565 BdrvRequestFlags write_flags); 566 567 /* 568 * Map [offset, offset + nbytes) range onto a child of bs to copy data to, 569 * and invoke bdrv_co_copy_range_to(child, src, ...), or perform the copy 570 * operation if @bs is the leaf and @src has the same BlockDriver. Return 571 * -ENOTSUP if @bs is the leaf but @src has a different BlockDriver. 572 * 573 * See the comment of bdrv_co_copy_range for the parameter and return value 574 * semantics. 575 */ 576 int coroutine_fn (*bdrv_co_copy_range_to)(BlockDriverState *bs, 577 BdrvChild *src, 578 int64_t src_offset, 579 BdrvChild *dst, 580 int64_t dst_offset, 581 int64_t bytes, 582 BdrvRequestFlags read_flags, 583 BdrvRequestFlags write_flags); 584 585 /* 586 * Building block for bdrv_block_status[_above] and 587 * bdrv_is_allocated[_above]. The driver should answer only 588 * according to the current layer, and should only need to set 589 * BDRV_BLOCK_DATA, BDRV_BLOCK_ZERO, BDRV_BLOCK_OFFSET_VALID, 590 * and/or BDRV_BLOCK_RAW; if the current layer defers to a backing 591 * layer, the result should be 0 (and not BDRV_BLOCK_ZERO). See 592 * block.h for the overall meaning of the bits. As a hint, the 593 * flag want_zero is true if the caller cares more about precise 594 * mappings (favor accurate _OFFSET_VALID/_ZERO) or false for 595 * overall allocation (favor larger *pnum, perhaps by reporting 596 * _DATA instead of _ZERO). The block layer guarantees input 597 * clamped to bdrv_getlength() and aligned to request_alignment, 598 * as well as non-NULL pnum, map, and file; in turn, the driver 599 * must return an error or set pnum to an aligned non-zero value. 600 * 601 * Note that @bytes is just a hint on how big of a region the 602 * caller wants to inspect. It is not a limit on *pnum. 603 * Implementations are free to return larger values of *pnum if 604 * doing so does not incur a performance penalty. 605 * 606 * block/io.c's bdrv_co_block_status() will utilize an unclamped 607 * *pnum value for the block-status cache on protocol nodes, prior 608 * to clamping *pnum for return to its caller. 609 */ 610 int coroutine_fn (*bdrv_co_block_status)(BlockDriverState *bs, 611 bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, 612 int64_t *map, BlockDriverState **file); 613 614 /* 615 * Snapshot-access API. 616 * 617 * Block-driver may provide snapshot-access API: special functions to access 618 * some internal "snapshot". The functions are similar with normal 619 * read/block_status/discard handler, but don't have any specific handling 620 * in generic block-layer: no serializing, no alignment, no tracked 621 * requests. So, block-driver that realizes these APIs is fully responsible 622 * for synchronization between snapshot-access API and normal IO requests. 623 * 624 * TODO: To be able to support qcow2's internal snapshots, this API will 625 * need to be extended to: 626 * - be able to select a specific snapshot 627 * - receive the snapshot's actual length (which may differ from bs's 628 * length) 629 */ 630 int coroutine_fn (*bdrv_co_preadv_snapshot)(BlockDriverState *bs, 631 int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); 632 int coroutine_fn (*bdrv_co_snapshot_block_status)(BlockDriverState *bs, 633 bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, 634 int64_t *map, BlockDriverState **file); 635 int coroutine_fn (*bdrv_co_pdiscard_snapshot)(BlockDriverState *bs, 636 int64_t offset, int64_t bytes); 637 638 /* 639 * Invalidate any cached meta-data. 640 */ 641 void coroutine_fn (*bdrv_co_invalidate_cache)(BlockDriverState *bs, 642 Error **errp); 643 644 /* 645 * Flushes all data for all layers by calling bdrv_co_flush for underlying 646 * layers, if needed. This function is needed for deterministic 647 * synchronization of the flush finishing callback. 648 */ 649 int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs); 650 651 /* Delete a created file. */ 652 int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs, 653 Error **errp); 654 655 /* 656 * Flushes all data that was already written to the OS all the way down to 657 * the disk (for example file-posix.c calls fsync()). 658 */ 659 int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); 660 661 /* 662 * Flushes all internal caches to the OS. The data may still sit in a 663 * writeback cache of the host OS, but it will survive a crash of the qemu 664 * process. 665 */ 666 int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); 667 668 /* 669 * Truncate @bs to @offset bytes using the given @prealloc mode 670 * when growing. Modes other than PREALLOC_MODE_OFF should be 671 * rejected when shrinking @bs. 672 * 673 * If @exact is true, @bs must be resized to exactly @offset. 674 * Otherwise, it is sufficient for @bs (if it is a host block 675 * device and thus there is no way to resize it) to be at least 676 * @offset bytes in length. 677 * 678 * If @exact is true and this function fails but would succeed 679 * with @exact = false, it should return -ENOTSUP. 680 */ 681 int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset, 682 bool exact, PreallocMode prealloc, 683 BdrvRequestFlags flags, Error **errp); 684 int64_t (*bdrv_getlength)(BlockDriverState *bs); 685 int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); 686 BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, 687 Error **errp); 688 689 int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs, 690 int64_t offset, int64_t bytes, QEMUIOVector *qiov); 691 int coroutine_fn (*bdrv_co_pwritev_compressed_part)(BlockDriverState *bs, 692 int64_t offset, int64_t bytes, QEMUIOVector *qiov, 693 size_t qiov_offset); 694 695 int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi); 696 697 ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs, 698 Error **errp); 699 BlockStatsSpecific *(*bdrv_get_specific_stats)(BlockDriverState *bs); 700 701 int coroutine_fn (*bdrv_save_vmstate)(BlockDriverState *bs, 702 QEMUIOVector *qiov, 703 int64_t pos); 704 int coroutine_fn (*bdrv_load_vmstate)(BlockDriverState *bs, 705 QEMUIOVector *qiov, 706 int64_t pos); 707 708 /* removable device specific */ 709 bool (*bdrv_is_inserted)(BlockDriverState *bs); 710 void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); 711 void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); 712 713 /* to control generic scsi devices */ 714 BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, 715 unsigned long int req, void *buf, 716 BlockCompletionFunc *cb, void *opaque); 717 int coroutine_fn (*bdrv_co_ioctl)(BlockDriverState *bs, 718 unsigned long int req, void *buf); 719 720 /* 721 * Returns 0 for completed check, -errno for internal errors. 722 * The check results are stored in result. 723 */ 724 int coroutine_fn (*bdrv_co_check)(BlockDriverState *bs, 725 BdrvCheckResult *result, 726 BdrvCheckMode fix); 727 728 void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event); 729 730 /* io queue for linux-aio */ 731 void (*bdrv_io_plug)(BlockDriverState *bs); 732 void (*bdrv_io_unplug)(BlockDriverState *bs); 733 734 /** 735 * bdrv_co_drain_begin is called if implemented in the beginning of a 736 * drain operation to drain and stop any internal sources of requests in 737 * the driver. 738 * bdrv_co_drain_end is called if implemented at the end of the drain. 739 * 740 * They should be used by the driver to e.g. manage scheduled I/O 741 * requests, or toggle an internal state. After the end of the drain new 742 * requests will continue normally. 743 */ 744 void coroutine_fn (*bdrv_co_drain_begin)(BlockDriverState *bs); 745 void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs); 746 747 bool (*bdrv_supports_persistent_dirty_bitmap)(BlockDriverState *bs); 748 bool (*bdrv_co_can_store_new_dirty_bitmap)(BlockDriverState *bs, 749 const char *name, 750 uint32_t granularity, 751 Error **errp); 752 int (*bdrv_co_remove_persistent_dirty_bitmap)(BlockDriverState *bs, 753 const char *name, 754 Error **errp); 755 }; 756 757 static inline bool block_driver_can_compress(BlockDriver *drv) 758 { 759 return drv->bdrv_co_pwritev_compressed || 760 drv->bdrv_co_pwritev_compressed_part; 761 } 762 763 typedef struct BlockLimits { 764 /* 765 * Alignment requirement, in bytes, for offset/length of I/O 766 * requests. Must be a power of 2 less than INT_MAX; defaults to 767 * 1 for drivers with modern byte interfaces, and to 512 768 * otherwise. 769 */ 770 uint32_t request_alignment; 771 772 /* 773 * Maximum number of bytes that can be discarded at once. Must be multiple 774 * of pdiscard_alignment, but need not be power of 2. May be 0 if no 775 * inherent 64-bit limit. 776 */ 777 int64_t max_pdiscard; 778 779 /* 780 * Optimal alignment for discard requests in bytes. A power of 2 781 * is best but not mandatory. Must be a multiple of 782 * bl.request_alignment, and must be less than max_pdiscard if 783 * that is set. May be 0 if bl.request_alignment is good enough 784 */ 785 uint32_t pdiscard_alignment; 786 787 /* 788 * Maximum number of bytes that can zeroized at once. Must be multiple of 789 * pwrite_zeroes_alignment. 0 means no limit. 790 */ 791 int64_t max_pwrite_zeroes; 792 793 /* 794 * Optimal alignment for write zeroes requests in bytes. A power 795 * of 2 is best but not mandatory. Must be a multiple of 796 * bl.request_alignment, and must be less than max_pwrite_zeroes 797 * if that is set. May be 0 if bl.request_alignment is good 798 * enough 799 */ 800 uint32_t pwrite_zeroes_alignment; 801 802 /* 803 * Optimal transfer length in bytes. A power of 2 is best but not 804 * mandatory. Must be a multiple of bl.request_alignment, or 0 if 805 * no preferred size 806 */ 807 uint32_t opt_transfer; 808 809 /* 810 * Maximal transfer length in bytes. Need not be power of 2, but 811 * must be multiple of opt_transfer and bl.request_alignment, or 0 812 * for no 32-bit limit. For now, anything larger than INT_MAX is 813 * clamped down. 814 */ 815 uint32_t max_transfer; 816 817 /* 818 * Maximal hardware transfer length in bytes. Applies whenever 819 * transfers to the device bypass the kernel I/O scheduler, for 820 * example with SG_IO. If larger than max_transfer or if zero, 821 * blk_get_max_hw_transfer will fall back to max_transfer. 822 */ 823 uint64_t max_hw_transfer; 824 825 /* 826 * Maximal number of scatter/gather elements allowed by the hardware. 827 * Applies whenever transfers to the device bypass the kernel I/O 828 * scheduler, for example with SG_IO. If larger than max_iov 829 * or if zero, blk_get_max_hw_iov will fall back to max_iov. 830 */ 831 int max_hw_iov; 832 833 834 /* memory alignment, in bytes so that no bounce buffer is needed */ 835 size_t min_mem_alignment; 836 837 /* memory alignment, in bytes, for bounce buffer */ 838 size_t opt_mem_alignment; 839 840 /* maximum number of iovec elements */ 841 int max_iov; 842 } BlockLimits; 843 844 typedef struct BdrvOpBlocker BdrvOpBlocker; 845 846 typedef struct BdrvAioNotifier { 847 void (*attached_aio_context)(AioContext *new_context, void *opaque); 848 void (*detach_aio_context)(void *opaque); 849 850 void *opaque; 851 bool deleted; 852 853 QLIST_ENTRY(BdrvAioNotifier) list; 854 } BdrvAioNotifier; 855 856 struct BdrvChildClass { 857 /* 858 * If true, bdrv_replace_node() doesn't change the node this BdrvChild 859 * points to. 860 */ 861 bool stay_at_node; 862 863 /* 864 * If true, the parent is a BlockDriverState and bdrv_next_all_states() 865 * will return it. This information is used for drain_all, where every node 866 * will be drained separately, so the drain only needs to be propagated to 867 * non-BDS parents. 868 */ 869 bool parent_is_bds; 870 871 /* 872 * Global state (GS) API. These functions run under the BQL. 873 * 874 * See include/block/block-global-state.h for more information about 875 * the GS API. 876 */ 877 void (*inherit_options)(BdrvChildRole role, bool parent_is_format, 878 int *child_flags, QDict *child_options, 879 int parent_flags, QDict *parent_options); 880 void (*change_media)(BdrvChild *child, bool load); 881 882 /* 883 * Returns a malloced string that describes the parent of the child for a 884 * human reader. This could be a node-name, BlockBackend name, qdev ID or 885 * QOM path of the device owning the BlockBackend, job type and ID etc. The 886 * caller is responsible for freeing the memory. 887 */ 888 char *(*get_parent_desc)(BdrvChild *child); 889 890 /* 891 * Notifies the parent that the child has been activated/inactivated (e.g. 892 * when migration is completing) and it can start/stop requesting 893 * permissions and doing I/O on it. 894 */ 895 void (*activate)(BdrvChild *child, Error **errp); 896 int (*inactivate)(BdrvChild *child); 897 898 void (*attach)(BdrvChild *child); 899 void (*detach)(BdrvChild *child); 900 901 /* 902 * Notifies the parent that the filename of its child has changed (e.g. 903 * because the direct child was removed from the backing chain), so that it 904 * can update its reference. 905 */ 906 int (*update_filename)(BdrvChild *child, BlockDriverState *new_base, 907 const char *filename, Error **errp); 908 909 bool (*change_aio_ctx)(BdrvChild *child, AioContext *ctx, 910 GHashTable *visited, Transaction *tran, 911 Error **errp); 912 913 AioContext *(*get_parent_aio_context)(BdrvChild *child); 914 915 /* 916 * I/O API functions. These functions are thread-safe. 917 * 918 * See include/block/block-io.h for more information about 919 * the I/O API. 920 */ 921 922 void (*resize)(BdrvChild *child); 923 924 /* 925 * Returns a name that is supposedly more useful for human users than the 926 * node name for identifying the node in question (in particular, a BB 927 * name), or NULL if the parent can't provide a better name. 928 */ 929 const char *(*get_name)(BdrvChild *child); 930 931 /* 932 * If this pair of functions is implemented, the parent doesn't issue new 933 * requests after returning from .drained_begin() until .drained_end() is 934 * called. 935 * 936 * These functions must not change the graph (and therefore also must not 937 * call aio_poll(), which could change the graph indirectly). 938 * 939 * If drained_end() schedules background operations, it must atomically 940 * increment *drained_end_counter for each such operation and atomically 941 * decrement it once the operation has settled. 942 * 943 * Note that this can be nested. If drained_begin() was called twice, new 944 * I/O is allowed only after drained_end() was called twice, too. 945 */ 946 void (*drained_begin)(BdrvChild *child); 947 void (*drained_end)(BdrvChild *child, int *drained_end_counter); 948 949 /* 950 * Returns whether the parent has pending requests for the child. This 951 * callback is polled after .drained_begin() has been called until all 952 * activity on the child has stopped. 953 */ 954 bool (*drained_poll)(BdrvChild *child); 955 }; 956 957 extern const BdrvChildClass child_of_bds; 958 959 struct BdrvChild { 960 BlockDriverState *bs; 961 char *name; 962 const BdrvChildClass *klass; 963 BdrvChildRole role; 964 void *opaque; 965 966 /** 967 * Granted permissions for operating on this BdrvChild (BLK_PERM_* bitmask) 968 */ 969 uint64_t perm; 970 971 /** 972 * Permissions that can still be granted to other users of @bs while this 973 * BdrvChild is still attached to it. (BLK_PERM_* bitmask) 974 */ 975 uint64_t shared_perm; 976 977 /* 978 * This link is frozen: the child can neither be replaced nor 979 * detached from the parent. 980 */ 981 bool frozen; 982 983 /* 984 * How many times the parent of this child has been drained 985 * (through klass->drained_*). 986 * Usually, this is equal to bs->quiesce_counter (potentially 987 * reduced by bdrv_drain_all_count). It may differ while the 988 * child is entering or leaving a drained section. 989 */ 990 int parent_quiesce_counter; 991 992 QLIST_ENTRY(BdrvChild) next; 993 QLIST_ENTRY(BdrvChild) next_parent; 994 }; 995 996 /* 997 * Allows bdrv_co_block_status() to cache one data region for a 998 * protocol node. 999 * 1000 * @valid: Whether the cache is valid (should be accessed with atomic 1001 * functions so this can be reset by RCU readers) 1002 * @data_start: Offset where we know (or strongly assume) is data 1003 * @data_end: Offset where the data region ends (which is not necessarily 1004 * the start of a zeroed region) 1005 */ 1006 typedef struct BdrvBlockStatusCache { 1007 struct rcu_head rcu; 1008 1009 bool valid; 1010 int64_t data_start; 1011 int64_t data_end; 1012 } BdrvBlockStatusCache; 1013 1014 struct BlockDriverState { 1015 /* 1016 * Protected by big QEMU lock or read-only after opening. No special 1017 * locking needed during I/O... 1018 */ 1019 int open_flags; /* flags used to open the file, re-used for re-open */ 1020 bool encrypted; /* if true, the media is encrypted */ 1021 bool sg; /* if true, the device is a /dev/sg* */ 1022 bool probed; /* if true, format was probed rather than specified */ 1023 bool force_share; /* if true, always allow all shared permissions */ 1024 bool implicit; /* if true, this filter node was automatically inserted */ 1025 1026 BlockDriver *drv; /* NULL means no media */ 1027 void *opaque; 1028 1029 AioContext *aio_context; /* event loop used for fd handlers, timers, etc */ 1030 /* 1031 * long-running tasks intended to always use the same AioContext as this 1032 * BDS may register themselves in this list to be notified of changes 1033 * regarding this BDS's context 1034 */ 1035 QLIST_HEAD(, BdrvAioNotifier) aio_notifiers; 1036 bool walking_aio_notifiers; /* to make removal during iteration safe */ 1037 1038 char filename[PATH_MAX]; 1039 /* 1040 * If not empty, this image is a diff in relation to backing_file. 1041 * Note that this is the name given in the image header and 1042 * therefore may or may not be equal to .backing->bs->filename. 1043 * If this field contains a relative path, it is to be resolved 1044 * relatively to the overlay's location. 1045 */ 1046 char backing_file[PATH_MAX]; 1047 /* 1048 * The backing filename indicated by the image header. Contrary 1049 * to backing_file, if we ever open this file, auto_backing_file 1050 * is replaced by the resulting BDS's filename (i.e. after a 1051 * bdrv_refresh_filename() run). 1052 */ 1053 char auto_backing_file[PATH_MAX]; 1054 char backing_format[16]; /* if non-zero and backing_file exists */ 1055 1056 QDict *full_open_options; 1057 char exact_filename[PATH_MAX]; 1058 1059 /* I/O Limits */ 1060 BlockLimits bl; 1061 1062 /* 1063 * Flags honored during pread 1064 */ 1065 unsigned int supported_read_flags; 1066 /* 1067 * Flags honored during pwrite (so far: BDRV_REQ_FUA, 1068 * BDRV_REQ_WRITE_UNCHANGED). 1069 * If a driver does not support BDRV_REQ_WRITE_UNCHANGED, those 1070 * writes will be issued as normal writes without the flag set. 1071 * This is important to note for drivers that do not explicitly 1072 * request a WRITE permission for their children and instead take 1073 * the same permissions as their parent did (this is commonly what 1074 * block filters do). Such drivers have to be aware that the 1075 * parent may have taken a WRITE_UNCHANGED permission only and is 1076 * issuing such requests. Drivers either must make sure that 1077 * these requests do not result in plain WRITE accesses (usually 1078 * by supporting BDRV_REQ_WRITE_UNCHANGED, and then forwarding 1079 * every incoming write request as-is, including potentially that 1080 * flag), or they have to explicitly take the WRITE permission for 1081 * their children. 1082 */ 1083 unsigned int supported_write_flags; 1084 /* 1085 * Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, 1086 * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) 1087 */ 1088 unsigned int supported_zero_flags; 1089 /* 1090 * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE). 1091 * 1092 * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure 1093 * that any added space reads as all zeros. If this can't be guaranteed, 1094 * the operation must fail. 1095 */ 1096 unsigned int supported_truncate_flags; 1097 1098 /* the following member gives a name to every node on the bs graph. */ 1099 char node_name[32]; 1100 /* element of the list of named nodes building the graph */ 1101 QTAILQ_ENTRY(BlockDriverState) node_list; 1102 /* element of the list of all BlockDriverStates (all_bdrv_states) */ 1103 QTAILQ_ENTRY(BlockDriverState) bs_list; 1104 /* element of the list of monitor-owned BDS */ 1105 QTAILQ_ENTRY(BlockDriverState) monitor_list; 1106 int refcnt; 1107 1108 /* operation blockers. Protected by BQL. */ 1109 QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; 1110 1111 /* 1112 * The node that this node inherited default options from (and a reopen on 1113 * which can affect this node by changing these defaults). This is always a 1114 * parent node of this node. 1115 */ 1116 BlockDriverState *inherits_from; 1117 1118 /* 1119 * @backing and @file are some of @children or NULL. All these three fields 1120 * (@file, @backing and @children) are modified only in 1121 * bdrv_child_cb_attach() and bdrv_child_cb_detach(). 1122 * 1123 * See also comment in include/block/block.h, to learn how backing and file 1124 * are connected with BdrvChildRole. 1125 */ 1126 QLIST_HEAD(, BdrvChild) children; 1127 BdrvChild *backing; 1128 BdrvChild *file; 1129 1130 QLIST_HEAD(, BdrvChild) parents; 1131 1132 QDict *options; 1133 QDict *explicit_options; 1134 BlockdevDetectZeroesOptions detect_zeroes; 1135 1136 /* The error object in use for blocking operations on backing_hd */ 1137 Error *backing_blocker; 1138 1139 /* Protected by AioContext lock */ 1140 1141 /* 1142 * If we are reading a disk image, give its size in sectors. 1143 * Generally read-only; it is written to by load_snapshot and 1144 * save_snaphost, but the block layer is quiescent during those. 1145 */ 1146 int64_t total_sectors; 1147 1148 /* threshold limit for writes, in bytes. "High water mark". */ 1149 uint64_t write_threshold_offset; 1150 1151 /* 1152 * Writing to the list requires the BQL _and_ the dirty_bitmap_mutex. 1153 * Reading from the list can be done with either the BQL or the 1154 * dirty_bitmap_mutex. Modifying a bitmap only requires 1155 * dirty_bitmap_mutex. 1156 */ 1157 QemuMutex dirty_bitmap_mutex; 1158 QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps; 1159 1160 /* Offset after the highest byte written to */ 1161 Stat64 wr_highest_offset; 1162 1163 /* 1164 * If true, copy read backing sectors into image. Can be >1 if more 1165 * than one client has requested copy-on-read. Accessed with atomic 1166 * ops. 1167 */ 1168 int copy_on_read; 1169 1170 /* 1171 * number of in-flight requests; overall and serialising. 1172 * Accessed with atomic ops. 1173 */ 1174 unsigned int in_flight; 1175 unsigned int serialising_in_flight; 1176 1177 /* 1178 * counter for nested bdrv_io_plug. 1179 * Accessed with atomic ops. 1180 */ 1181 unsigned io_plugged; 1182 1183 /* do we need to tell the quest if we have a volatile write cache? */ 1184 int enable_write_cache; 1185 1186 /* Accessed with atomic ops. */ 1187 int quiesce_counter; 1188 int recursive_quiesce_counter; 1189 1190 unsigned int write_gen; /* Current data generation */ 1191 1192 /* Protected by reqs_lock. */ 1193 CoMutex reqs_lock; 1194 QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; 1195 CoQueue flush_queue; /* Serializing flush queue */ 1196 bool active_flush_req; /* Flush request in flight? */ 1197 1198 /* Only read/written by whoever has set active_flush_req to true. */ 1199 unsigned int flushed_gen; /* Flushed write generation */ 1200 1201 /* BdrvChild links to this node may never be frozen */ 1202 bool never_freeze; 1203 1204 /* Lock for block-status cache RCU writers */ 1205 CoMutex bsc_modify_lock; 1206 /* Always non-NULL, but must only be dereferenced under an RCU read guard */ 1207 BdrvBlockStatusCache *block_status_cache; 1208 }; 1209 1210 struct BlockBackendRootState { 1211 int open_flags; 1212 BlockdevDetectZeroesOptions detect_zeroes; 1213 }; 1214 1215 typedef enum BlockMirrorBackingMode { 1216 /* 1217 * Reuse the existing backing chain from the source for the target. 1218 * - sync=full: Set backing BDS to NULL. 1219 * - sync=top: Use source's backing BDS. 1220 * - sync=none: Use source as the backing BDS. 1221 */ 1222 MIRROR_SOURCE_BACKING_CHAIN, 1223 1224 /* Open the target's backing chain completely anew */ 1225 MIRROR_OPEN_BACKING_CHAIN, 1226 1227 /* Do not change the target's backing BDS after job completion */ 1228 MIRROR_LEAVE_BACKING_CHAIN, 1229 } BlockMirrorBackingMode; 1230 1231 1232 /* 1233 * Essential block drivers which must always be statically linked into qemu, and 1234 * which therefore can be accessed without using bdrv_find_format() 1235 */ 1236 extern BlockDriver bdrv_file; 1237 extern BlockDriver bdrv_raw; 1238 extern BlockDriver bdrv_qcow2; 1239 1240 extern unsigned int bdrv_drain_all_count; 1241 extern QemuOptsList bdrv_create_opts_simple; 1242 1243 /* 1244 * Common functions that are neither I/O nor Global State. 1245 * 1246 * See include/block/block-commmon.h for more information about 1247 * the Common API. 1248 */ 1249 1250 static inline BlockDriverState *child_bs(BdrvChild *child) 1251 { 1252 return child ? child->bs : NULL; 1253 } 1254 1255 int bdrv_check_request(int64_t offset, int64_t bytes, Error **errp); 1256 char *create_tmp_file(Error **errp); 1257 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix, 1258 QDict *options); 1259 1260 1261 int bdrv_check_qiov_request(int64_t offset, int64_t bytes, 1262 QEMUIOVector *qiov, size_t qiov_offset, 1263 Error **errp); 1264 1265 #ifdef _WIN32 1266 int is_windows_drive(const char *filename); 1267 #endif 1268 1269 #endif /* BLOCK_INT_COMMON_H */ 1270