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