1 /* 2 * QEMU System Emulator block driver 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #ifndef BLOCK_INT_H 25 #define BLOCK_INT_H 26 27 #include "block/accounting.h" 28 #include "block/block.h" 29 #include "qemu/option.h" 30 #include "qemu/queue.h" 31 #include "qemu/coroutine.h" 32 #include "qemu/stats64.h" 33 #include "qemu/timer.h" 34 #include "qapi-types.h" 35 #include "qemu/hbitmap.h" 36 #include "block/snapshot.h" 37 #include "qemu/main-loop.h" 38 #include "qemu/throttle.h" 39 40 #define BLOCK_FLAG_ENCRYPT 1 41 #define BLOCK_FLAG_LAZY_REFCOUNTS 8 42 43 #define BLOCK_OPT_SIZE "size" 44 #define BLOCK_OPT_ENCRYPT "encryption" 45 #define BLOCK_OPT_COMPAT6 "compat6" 46 #define BLOCK_OPT_HWVERSION "hwversion" 47 #define BLOCK_OPT_BACKING_FILE "backing_file" 48 #define BLOCK_OPT_BACKING_FMT "backing_fmt" 49 #define BLOCK_OPT_CLUSTER_SIZE "cluster_size" 50 #define BLOCK_OPT_TABLE_SIZE "table_size" 51 #define BLOCK_OPT_PREALLOC "preallocation" 52 #define BLOCK_OPT_SUBFMT "subformat" 53 #define BLOCK_OPT_COMPAT_LEVEL "compat" 54 #define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts" 55 #define BLOCK_OPT_ADAPTER_TYPE "adapter_type" 56 #define BLOCK_OPT_REDUNDANCY "redundancy" 57 #define BLOCK_OPT_NOCOW "nocow" 58 #define BLOCK_OPT_OBJECT_SIZE "object_size" 59 #define BLOCK_OPT_REFCOUNT_BITS "refcount_bits" 60 61 #define BLOCK_PROBE_BUF_SIZE 512 62 63 enum BdrvTrackedRequestType { 64 BDRV_TRACKED_READ, 65 BDRV_TRACKED_WRITE, 66 BDRV_TRACKED_DISCARD, 67 }; 68 69 typedef struct BdrvTrackedRequest { 70 BlockDriverState *bs; 71 int64_t offset; 72 unsigned int bytes; 73 enum BdrvTrackedRequestType type; 74 75 bool serialising; 76 int64_t overlap_offset; 77 unsigned int overlap_bytes; 78 79 QLIST_ENTRY(BdrvTrackedRequest) list; 80 Coroutine *co; /* owner, used for deadlock detection */ 81 CoQueue wait_queue; /* coroutines blocked on this request */ 82 83 struct BdrvTrackedRequest *waiting_for; 84 } BdrvTrackedRequest; 85 86 struct BlockDriver { 87 const char *format_name; 88 int instance_size; 89 90 /* set to true if the BlockDriver is a block filter */ 91 bool is_filter; 92 /* for snapshots block filter like Quorum can implement the 93 * following recursive callback. 94 * It's purpose is to recurse on the filter children while calling 95 * bdrv_recurse_is_first_non_filter on them. 96 * For a sample implementation look in the future Quorum block filter. 97 */ 98 bool (*bdrv_recurse_is_first_non_filter)(BlockDriverState *bs, 99 BlockDriverState *candidate); 100 101 int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename); 102 int (*bdrv_probe_device)(const char *filename); 103 104 /* Any driver implementing this callback is expected to be able to handle 105 * NULL file names in its .bdrv_open() implementation */ 106 void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp); 107 /* Drivers not implementing bdrv_parse_filename nor bdrv_open should have 108 * this field set to true, except ones that are defined only by their 109 * child's bs. 110 * An example of the last type will be the quorum block driver. 111 */ 112 bool bdrv_needs_filename; 113 114 /* Set if a driver can support backing files */ 115 bool supports_backing; 116 117 /* For handling image reopen for split or non-split files */ 118 int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, 119 BlockReopenQueue *queue, Error **errp); 120 void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state); 121 void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); 122 void (*bdrv_join_options)(QDict *options, QDict *old_options); 123 124 int (*bdrv_open)(BlockDriverState *bs, QDict *options, int flags, 125 Error **errp); 126 int (*bdrv_file_open)(BlockDriverState *bs, QDict *options, int flags, 127 Error **errp); 128 void (*bdrv_close)(BlockDriverState *bs); 129 int (*bdrv_create)(const char *filename, QemuOpts *opts, Error **errp); 130 int (*bdrv_set_key)(BlockDriverState *bs, const char *key); 131 int (*bdrv_make_empty)(BlockDriverState *bs); 132 133 void (*bdrv_refresh_filename)(BlockDriverState *bs, QDict *options); 134 135 /* aio */ 136 BlockAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, 137 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 138 BlockCompletionFunc *cb, void *opaque); 139 BlockAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, 140 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 141 BlockCompletionFunc *cb, void *opaque); 142 BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, 143 BlockCompletionFunc *cb, void *opaque); 144 BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs, 145 int64_t offset, int bytes, 146 BlockCompletionFunc *cb, void *opaque); 147 148 int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, 149 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); 150 int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs, 151 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags); 152 int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs, 153 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); 154 int coroutine_fn (*bdrv_co_writev_flags)(BlockDriverState *bs, 155 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags); 156 int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs, 157 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags); 158 159 /* 160 * Efficiently zero a region of the disk image. Typically an image format 161 * would use a compact metadata representation to implement this. This 162 * function pointer may be NULL or return -ENOSUP and .bdrv_co_writev() 163 * will be called instead. 164 */ 165 int coroutine_fn (*bdrv_co_pwrite_zeroes)(BlockDriverState *bs, 166 int64_t offset, int bytes, BdrvRequestFlags flags); 167 int coroutine_fn (*bdrv_co_pdiscard)(BlockDriverState *bs, 168 int64_t offset, int bytes); 169 170 /* 171 * Building block for bdrv_block_status[_above]. The driver should 172 * answer only according to the current layer, and should not 173 * set BDRV_BLOCK_ALLOCATED, but may set BDRV_BLOCK_RAW. See block.h 174 * for the meaning of _DATA, _ZERO, and _OFFSET_VALID. 175 */ 176 int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs, 177 int64_t sector_num, int nb_sectors, int *pnum, 178 BlockDriverState **file); 179 180 /* 181 * Invalidate any cached meta-data. 182 */ 183 void (*bdrv_invalidate_cache)(BlockDriverState *bs, Error **errp); 184 int (*bdrv_inactivate)(BlockDriverState *bs); 185 186 /* 187 * Flushes all data for all layers by calling bdrv_co_flush for underlying 188 * layers, if needed. This function is needed for deterministic 189 * synchronization of the flush finishing callback. 190 */ 191 int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs); 192 193 /* 194 * Flushes all data that was already written to the OS all the way down to 195 * the disk (for example file-posix.c calls fsync()). 196 */ 197 int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); 198 199 /* 200 * Flushes all internal caches to the OS. The data may still sit in a 201 * writeback cache of the host OS, but it will survive a crash of the qemu 202 * process. 203 */ 204 int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); 205 206 const char *protocol_name; 207 int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset, Error **errp); 208 209 int64_t (*bdrv_getlength)(BlockDriverState *bs); 210 bool has_variable_length; 211 int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); 212 213 int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs, 214 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov); 215 216 int (*bdrv_snapshot_create)(BlockDriverState *bs, 217 QEMUSnapshotInfo *sn_info); 218 int (*bdrv_snapshot_goto)(BlockDriverState *bs, 219 const char *snapshot_id); 220 int (*bdrv_snapshot_delete)(BlockDriverState *bs, 221 const char *snapshot_id, 222 const char *name, 223 Error **errp); 224 int (*bdrv_snapshot_list)(BlockDriverState *bs, 225 QEMUSnapshotInfo **psn_info); 226 int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, 227 const char *snapshot_id, 228 const char *name, 229 Error **errp); 230 int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi); 231 ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs); 232 233 int coroutine_fn (*bdrv_save_vmstate)(BlockDriverState *bs, 234 QEMUIOVector *qiov, 235 int64_t pos); 236 int coroutine_fn (*bdrv_load_vmstate)(BlockDriverState *bs, 237 QEMUIOVector *qiov, 238 int64_t pos); 239 240 int (*bdrv_change_backing_file)(BlockDriverState *bs, 241 const char *backing_file, const char *backing_fmt); 242 243 /* removable device specific */ 244 bool (*bdrv_is_inserted)(BlockDriverState *bs); 245 int (*bdrv_media_changed)(BlockDriverState *bs); 246 void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); 247 void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); 248 249 /* to control generic scsi devices */ 250 BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, 251 unsigned long int req, void *buf, 252 BlockCompletionFunc *cb, void *opaque); 253 int coroutine_fn (*bdrv_co_ioctl)(BlockDriverState *bs, 254 unsigned long int req, void *buf); 255 256 /* List of options for creating images, terminated by name == NULL */ 257 QemuOptsList *create_opts; 258 259 /* 260 * Returns 0 for completed check, -errno for internal errors. 261 * The check results are stored in result. 262 */ 263 int (*bdrv_check)(BlockDriverState *bs, BdrvCheckResult *result, 264 BdrvCheckMode fix); 265 266 int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts, 267 BlockDriverAmendStatusCB *status_cb, 268 void *cb_opaque); 269 270 void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event); 271 272 /* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ 273 int (*bdrv_debug_breakpoint)(BlockDriverState *bs, const char *event, 274 const char *tag); 275 int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, 276 const char *tag); 277 int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag); 278 bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag); 279 280 void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp); 281 282 /* 283 * Returns 1 if newly created images are guaranteed to contain only 284 * zeros, 0 otherwise. 285 */ 286 int (*bdrv_has_zero_init)(BlockDriverState *bs); 287 288 /* Remove fd handlers, timers, and other event loop callbacks so the event 289 * loop is no longer in use. Called with no in-flight requests and in 290 * depth-first traversal order with parents before child nodes. 291 */ 292 void (*bdrv_detach_aio_context)(BlockDriverState *bs); 293 294 /* Add fd handlers, timers, and other event loop callbacks so I/O requests 295 * can be processed again. Called with no in-flight requests and in 296 * depth-first traversal order with child nodes before parent nodes. 297 */ 298 void (*bdrv_attach_aio_context)(BlockDriverState *bs, 299 AioContext *new_context); 300 301 /* io queue for linux-aio */ 302 void (*bdrv_io_plug)(BlockDriverState *bs); 303 void (*bdrv_io_unplug)(BlockDriverState *bs); 304 305 /** 306 * Try to get @bs's logical and physical block size. 307 * On success, store them in @bsz and return zero. 308 * On failure, return negative errno. 309 */ 310 int (*bdrv_probe_blocksizes)(BlockDriverState *bs, BlockSizes *bsz); 311 /** 312 * Try to get @bs's geometry (cyls, heads, sectors) 313 * On success, store them in @geo and return 0. 314 * On failure return -errno. 315 * Only drivers that want to override guest geometry implement this 316 * callback; see hd_geometry_guess(). 317 */ 318 int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo); 319 320 /** 321 * Drain and stop any internal sources of requests in the driver, and 322 * remain so until next I/O callback (e.g. bdrv_co_writev) is called. 323 */ 324 void (*bdrv_drain)(BlockDriverState *bs); 325 326 void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child, 327 Error **errp); 328 void (*bdrv_del_child)(BlockDriverState *parent, BdrvChild *child, 329 Error **errp); 330 331 /** 332 * Informs the block driver that a permission change is intended. The 333 * driver checks whether the change is permissible and may take other 334 * preparations for the change (e.g. get file system locks). This operation 335 * is always followed either by a call to either .bdrv_set_perm or 336 * .bdrv_abort_perm_update. 337 * 338 * Checks whether the requested set of cumulative permissions in @perm 339 * can be granted for accessing @bs and whether no other users are using 340 * permissions other than those given in @shared (both arguments take 341 * BLK_PERM_* bitmasks). 342 * 343 * If both conditions are met, 0 is returned. Otherwise, -errno is returned 344 * and errp is set to an error describing the conflict. 345 */ 346 int (*bdrv_check_perm)(BlockDriverState *bs, uint64_t perm, 347 uint64_t shared, Error **errp); 348 349 /** 350 * Called to inform the driver that the set of cumulative set of used 351 * permissions for @bs has changed to @perm, and the set of sharable 352 * permission to @shared. The driver can use this to propagate changes to 353 * its children (i.e. request permissions only if a parent actually needs 354 * them). 355 * 356 * This function is only invoked after bdrv_check_perm(), so block drivers 357 * may rely on preparations made in their .bdrv_check_perm implementation. 358 */ 359 void (*bdrv_set_perm)(BlockDriverState *bs, uint64_t perm, uint64_t shared); 360 361 /* 362 * Called to inform the driver that after a previous bdrv_check_perm() 363 * call, the permission update is not performed and any preparations made 364 * for it (e.g. taken file locks) need to be undone. 365 * 366 * This function can be called even for nodes that never saw a 367 * bdrv_check_perm() call. It is a no-op then. 368 */ 369 void (*bdrv_abort_perm_update)(BlockDriverState *bs); 370 371 /** 372 * Returns in @nperm and @nshared the permissions that the driver for @bs 373 * needs on its child @c, based on the cumulative permissions requested by 374 * the parents in @parent_perm and @parent_shared. 375 * 376 * If @c is NULL, return the permissions for attaching a new child for the 377 * given @role. 378 */ 379 void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c, 380 const BdrvChildRole *role, 381 uint64_t parent_perm, uint64_t parent_shared, 382 uint64_t *nperm, uint64_t *nshared); 383 384 QLIST_ENTRY(BlockDriver) list; 385 }; 386 387 typedef struct BlockLimits { 388 /* Alignment requirement, in bytes, for offset/length of I/O 389 * requests. Must be a power of 2 less than INT_MAX; defaults to 390 * 1 for drivers with modern byte interfaces, and to 512 391 * otherwise. */ 392 uint32_t request_alignment; 393 394 /* Maximum number of bytes that can be discarded at once (since it 395 * is signed, it must be < 2G, if set). Must be multiple of 396 * pdiscard_alignment, but need not be power of 2. May be 0 if no 397 * inherent 32-bit limit */ 398 int32_t max_pdiscard; 399 400 /* Optimal alignment for discard requests in bytes. A power of 2 401 * is best but not mandatory. Must be a multiple of 402 * bl.request_alignment, and must be less than max_pdiscard if 403 * that is set. May be 0 if bl.request_alignment is good enough */ 404 uint32_t pdiscard_alignment; 405 406 /* Maximum number of bytes that can zeroized at once (since it is 407 * signed, it must be < 2G, if set). Must be multiple of 408 * pwrite_zeroes_alignment. May be 0 if no inherent 32-bit limit */ 409 int32_t max_pwrite_zeroes; 410 411 /* Optimal alignment for write zeroes requests in bytes. A power 412 * of 2 is best but not mandatory. Must be a multiple of 413 * bl.request_alignment, and must be less than max_pwrite_zeroes 414 * if that is set. May be 0 if bl.request_alignment is good 415 * enough */ 416 uint32_t pwrite_zeroes_alignment; 417 418 /* Optimal transfer length in bytes. A power of 2 is best but not 419 * mandatory. Must be a multiple of bl.request_alignment, or 0 if 420 * no preferred size */ 421 uint32_t opt_transfer; 422 423 /* Maximal transfer length in bytes. Need not be power of 2, but 424 * must be multiple of opt_transfer and bl.request_alignment, or 0 425 * for no 32-bit limit. For now, anything larger than INT_MAX is 426 * clamped down. */ 427 uint32_t max_transfer; 428 429 /* memory alignment, in bytes so that no bounce buffer is needed */ 430 size_t min_mem_alignment; 431 432 /* memory alignment, in bytes, for bounce buffer */ 433 size_t opt_mem_alignment; 434 435 /* maximum number of iovec elements */ 436 int max_iov; 437 } BlockLimits; 438 439 typedef struct BdrvOpBlocker BdrvOpBlocker; 440 441 typedef struct BdrvAioNotifier { 442 void (*attached_aio_context)(AioContext *new_context, void *opaque); 443 void (*detach_aio_context)(void *opaque); 444 445 void *opaque; 446 bool deleted; 447 448 QLIST_ENTRY(BdrvAioNotifier) list; 449 } BdrvAioNotifier; 450 451 struct BdrvChildRole { 452 /* If true, bdrv_replace_node() doesn't change the node this BdrvChild 453 * points to. */ 454 bool stay_at_node; 455 456 void (*inherit_options)(int *child_flags, QDict *child_options, 457 int parent_flags, QDict *parent_options); 458 459 void (*change_media)(BdrvChild *child, bool load); 460 void (*resize)(BdrvChild *child); 461 462 /* Returns a name that is supposedly more useful for human users than the 463 * node name for identifying the node in question (in particular, a BB 464 * name), or NULL if the parent can't provide a better name. */ 465 const char *(*get_name)(BdrvChild *child); 466 467 /* Returns a malloced string that describes the parent of the child for a 468 * human reader. This could be a node-name, BlockBackend name, qdev ID or 469 * QOM path of the device owning the BlockBackend, job type and ID etc. The 470 * caller is responsible for freeing the memory. */ 471 char *(*get_parent_desc)(BdrvChild *child); 472 473 /* 474 * If this pair of functions is implemented, the parent doesn't issue new 475 * requests after returning from .drained_begin() until .drained_end() is 476 * called. 477 * 478 * Note that this can be nested. If drained_begin() was called twice, new 479 * I/O is allowed only after drained_end() was called twice, too. 480 */ 481 void (*drained_begin)(BdrvChild *child); 482 void (*drained_end)(BdrvChild *child); 483 484 /* Notifies the parent that the child has been activated/inactivated (e.g. 485 * when migration is completing) and it can start/stop requesting 486 * permissions and doing I/O on it. */ 487 void (*activate)(BdrvChild *child, Error **errp); 488 int (*inactivate)(BdrvChild *child); 489 490 void (*attach)(BdrvChild *child); 491 void (*detach)(BdrvChild *child); 492 }; 493 494 extern const BdrvChildRole child_file; 495 extern const BdrvChildRole child_format; 496 extern const BdrvChildRole child_backing; 497 498 struct BdrvChild { 499 BlockDriverState *bs; 500 char *name; 501 const BdrvChildRole *role; 502 void *opaque; 503 504 /** 505 * Granted permissions for operating on this BdrvChild (BLK_PERM_* bitmask) 506 */ 507 uint64_t perm; 508 509 /** 510 * Permissions that can still be granted to other users of @bs while this 511 * BdrvChild is still attached to it. (BLK_PERM_* bitmask) 512 */ 513 uint64_t shared_perm; 514 515 QLIST_ENTRY(BdrvChild) next; 516 QLIST_ENTRY(BdrvChild) next_parent; 517 }; 518 519 /* 520 * Note: the function bdrv_append() copies and swaps contents of 521 * BlockDriverStates, so if you add new fields to this struct, please 522 * inspect bdrv_append() to determine if the new fields need to be 523 * copied as well. 524 */ 525 struct BlockDriverState { 526 /* Protected by big QEMU lock or read-only after opening. No special 527 * locking needed during I/O... 528 */ 529 int open_flags; /* flags used to open the file, re-used for re-open */ 530 bool read_only; /* if true, the media is read only */ 531 bool encrypted; /* if true, the media is encrypted */ 532 bool valid_key; /* if true, a valid encryption key has been set */ 533 bool sg; /* if true, the device is a /dev/sg* */ 534 bool probed; /* if true, format was probed rather than specified */ 535 bool force_share; /* if true, always allow all shared permissions */ 536 537 BlockDriver *drv; /* NULL means no media */ 538 void *opaque; 539 540 AioContext *aio_context; /* event loop used for fd handlers, timers, etc */ 541 /* long-running tasks intended to always use the same AioContext as this 542 * BDS may register themselves in this list to be notified of changes 543 * regarding this BDS's context */ 544 QLIST_HEAD(, BdrvAioNotifier) aio_notifiers; 545 bool walking_aio_notifiers; /* to make removal during iteration safe */ 546 547 char filename[PATH_MAX]; 548 char backing_file[PATH_MAX]; /* if non zero, the image is a diff of 549 this file image */ 550 char backing_format[16]; /* if non-zero and backing_file exists */ 551 552 QDict *full_open_options; 553 char exact_filename[PATH_MAX]; 554 555 BdrvChild *backing; 556 BdrvChild *file; 557 558 /* I/O Limits */ 559 BlockLimits bl; 560 561 /* Flags honored during pwrite (so far: BDRV_REQ_FUA) */ 562 unsigned int supported_write_flags; 563 /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, 564 * BDRV_REQ_MAY_UNMAP) */ 565 unsigned int supported_zero_flags; 566 567 /* the following member gives a name to every node on the bs graph. */ 568 char node_name[32]; 569 /* element of the list of named nodes building the graph */ 570 QTAILQ_ENTRY(BlockDriverState) node_list; 571 /* element of the list of all BlockDriverStates (all_bdrv_states) */ 572 QTAILQ_ENTRY(BlockDriverState) bs_list; 573 /* element of the list of monitor-owned BDS */ 574 QTAILQ_ENTRY(BlockDriverState) monitor_list; 575 int refcnt; 576 577 /* operation blockers */ 578 QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; 579 580 /* long-running background operation */ 581 BlockJob *job; 582 583 /* The node that this node inherited default options from (and a reopen on 584 * which can affect this node by changing these defaults). This is always a 585 * parent node of this node. */ 586 BlockDriverState *inherits_from; 587 QLIST_HEAD(, BdrvChild) children; 588 QLIST_HEAD(, BdrvChild) parents; 589 590 QDict *options; 591 QDict *explicit_options; 592 BlockdevDetectZeroesOptions detect_zeroes; 593 594 /* The error object in use for blocking operations on backing_hd */ 595 Error *backing_blocker; 596 597 /* Protected by AioContext lock */ 598 599 /* If we are reading a disk image, give its size in sectors. 600 * Generally read-only; it is written to by load_snapshot and 601 * save_snaphost, but the block layer is quiescent during those. 602 */ 603 int64_t total_sectors; 604 605 /* Callback before write request is processed */ 606 NotifierWithReturnList before_write_notifiers; 607 608 /* threshold limit for writes, in bytes. "High water mark". */ 609 uint64_t write_threshold_offset; 610 NotifierWithReturn write_threshold_notifier; 611 612 /* Writing to the list requires the BQL _and_ the dirty_bitmap_mutex. 613 * Reading from the list can be done with either the BQL or the 614 * dirty_bitmap_mutex. Modifying a bitmap only requires 615 * dirty_bitmap_mutex. */ 616 QemuMutex dirty_bitmap_mutex; 617 QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps; 618 619 /* Offset after the highest byte written to */ 620 Stat64 wr_highest_offset; 621 622 /* If true, copy read backing sectors into image. Can be >1 if more 623 * than one client has requested copy-on-read. Accessed with atomic 624 * ops. 625 */ 626 int copy_on_read; 627 628 /* number of in-flight requests; overall and serialising. 629 * Accessed with atomic ops. 630 */ 631 unsigned int in_flight; 632 unsigned int serialising_in_flight; 633 634 /* Internal to BDRV_POLL_WHILE and bdrv_wakeup. Accessed with atomic 635 * ops. 636 */ 637 bool wakeup; 638 639 /* counter for nested bdrv_io_plug. 640 * Accessed with atomic ops. 641 */ 642 unsigned io_plugged; 643 644 /* do we need to tell the quest if we have a volatile write cache? */ 645 int enable_write_cache; 646 647 /* Accessed with atomic ops. */ 648 int quiesce_counter; 649 unsigned int write_gen; /* Current data generation */ 650 651 /* Protected by reqs_lock. */ 652 CoMutex reqs_lock; 653 QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; 654 CoQueue flush_queue; /* Serializing flush queue */ 655 bool active_flush_req; /* Flush request in flight? */ 656 657 /* Only read/written by whoever has set active_flush_req to true. */ 658 unsigned int flushed_gen; /* Flushed write generation */ 659 }; 660 661 struct BlockBackendRootState { 662 int open_flags; 663 bool read_only; 664 BlockdevDetectZeroesOptions detect_zeroes; 665 }; 666 667 typedef enum BlockMirrorBackingMode { 668 /* Reuse the existing backing chain from the source for the target. 669 * - sync=full: Set backing BDS to NULL. 670 * - sync=top: Use source's backing BDS. 671 * - sync=none: Use source as the backing BDS. */ 672 MIRROR_SOURCE_BACKING_CHAIN, 673 674 /* Open the target's backing chain completely anew */ 675 MIRROR_OPEN_BACKING_CHAIN, 676 677 /* Do not change the target's backing BDS after job completion */ 678 MIRROR_LEAVE_BACKING_CHAIN, 679 } BlockMirrorBackingMode; 680 681 static inline BlockDriverState *backing_bs(BlockDriverState *bs) 682 { 683 return bs->backing ? bs->backing->bs : NULL; 684 } 685 686 687 /* Essential block drivers which must always be statically linked into qemu, and 688 * which therefore can be accessed without using bdrv_find_format() */ 689 extern BlockDriver bdrv_file; 690 extern BlockDriver bdrv_raw; 691 extern BlockDriver bdrv_qcow2; 692 693 int coroutine_fn bdrv_co_preadv(BdrvChild *child, 694 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 695 BdrvRequestFlags flags); 696 int coroutine_fn bdrv_co_pwritev(BdrvChild *child, 697 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 698 BdrvRequestFlags flags); 699 700 int get_tmp_filename(char *filename, int size); 701 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, 702 const char *filename); 703 704 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix, 705 QDict *options); 706 707 708 /** 709 * bdrv_add_before_write_notifier: 710 * 711 * Register a callback that is invoked before write requests are processed but 712 * after any throttling or waiting for overlapping requests. 713 */ 714 void bdrv_add_before_write_notifier(BlockDriverState *bs, 715 NotifierWithReturn *notifier); 716 717 /** 718 * bdrv_detach_aio_context: 719 * 720 * May be called from .bdrv_detach_aio_context() to detach children from the 721 * current #AioContext. This is only needed by block drivers that manage their 722 * own children. Both ->file and ->backing are automatically handled and 723 * block drivers should not call this function on them explicitly. 724 */ 725 void bdrv_detach_aio_context(BlockDriverState *bs); 726 727 /** 728 * bdrv_attach_aio_context: 729 * 730 * May be called from .bdrv_attach_aio_context() to attach children to the new 731 * #AioContext. This is only needed by block drivers that manage their own 732 * children. Both ->file and ->backing are automatically handled and block 733 * drivers should not call this function on them explicitly. 734 */ 735 void bdrv_attach_aio_context(BlockDriverState *bs, 736 AioContext *new_context); 737 738 /** 739 * bdrv_add_aio_context_notifier: 740 * 741 * If a long-running job intends to be always run in the same AioContext as a 742 * certain BDS, it may use this function to be notified of changes regarding the 743 * association of the BDS to an AioContext. 744 * 745 * attached_aio_context() is called after the target BDS has been attached to a 746 * new AioContext; detach_aio_context() is called before the target BDS is being 747 * detached from its old AioContext. 748 */ 749 void bdrv_add_aio_context_notifier(BlockDriverState *bs, 750 void (*attached_aio_context)(AioContext *new_context, void *opaque), 751 void (*detach_aio_context)(void *opaque), void *opaque); 752 753 /** 754 * bdrv_remove_aio_context_notifier: 755 * 756 * Unsubscribe of change notifications regarding the BDS's AioContext. The 757 * parameters given here have to be the same as those given to 758 * bdrv_add_aio_context_notifier(). 759 */ 760 void bdrv_remove_aio_context_notifier(BlockDriverState *bs, 761 void (*aio_context_attached)(AioContext *, 762 void *), 763 void (*aio_context_detached)(void *), 764 void *opaque); 765 766 /** 767 * bdrv_wakeup: 768 * @bs: The BlockDriverState for which an I/O operation has been completed. 769 * 770 * Wake up the main thread if it is waiting on BDRV_POLL_WHILE. During 771 * synchronous I/O on a BlockDriverState that is attached to another 772 * I/O thread, the main thread lets the I/O thread's event loop run, 773 * waiting for the I/O operation to complete. A bdrv_wakeup will wake 774 * up the main thread if necessary. 775 * 776 * Manual calls to bdrv_wakeup are rarely necessary, because 777 * bdrv_dec_in_flight already calls it. 778 */ 779 void bdrv_wakeup(BlockDriverState *bs); 780 781 #ifdef _WIN32 782 int is_windows_drive(const char *filename); 783 #endif 784 785 /** 786 * stream_start: 787 * @job_id: The id of the newly-created job, or %NULL to use the 788 * device name of @bs. 789 * @bs: Block device to operate on. 790 * @base: Block device that will become the new base, or %NULL to 791 * flatten the whole backing file chain onto @bs. 792 * @backing_file_str: The file name that will be written to @bs as the 793 * the new backing file if the job completes. Ignored if @base is %NULL. 794 * @speed: The maximum speed, in bytes per second, or 0 for unlimited. 795 * @on_error: The action to take upon error. 796 * @errp: Error object. 797 * 798 * Start a streaming operation on @bs. Clusters that are unallocated 799 * in @bs, but allocated in any image between @base and @bs (both 800 * exclusive) will be written to @bs. At the end of a successful 801 * streaming job, the backing file of @bs will be changed to 802 * @backing_file_str in the written image and to @base in the live 803 * BlockDriverState. 804 */ 805 void stream_start(const char *job_id, BlockDriverState *bs, 806 BlockDriverState *base, const char *backing_file_str, 807 int64_t speed, BlockdevOnError on_error, Error **errp); 808 809 /** 810 * commit_start: 811 * @job_id: The id of the newly-created job, or %NULL to use the 812 * device name of @bs. 813 * @bs: Active block device. 814 * @top: Top block device to be committed. 815 * @base: Block device that will be written into, and become the new top. 816 * @speed: The maximum speed, in bytes per second, or 0 for unlimited. 817 * @on_error: The action to take upon error. 818 * @backing_file_str: String to use as the backing file in @top's overlay 819 * @filter_node_name: The node name that should be assigned to the filter 820 * driver that the commit job inserts into the graph above @top. NULL means 821 * that a node name should be autogenerated. 822 * @errp: Error object. 823 * 824 */ 825 void commit_start(const char *job_id, BlockDriverState *bs, 826 BlockDriverState *base, BlockDriverState *top, int64_t speed, 827 BlockdevOnError on_error, const char *backing_file_str, 828 const char *filter_node_name, Error **errp); 829 /** 830 * commit_active_start: 831 * @job_id: The id of the newly-created job, or %NULL to use the 832 * device name of @bs. 833 * @bs: Active block device to be committed. 834 * @base: Block device that will be written into, and become the new top. 835 * @creation_flags: Flags that control the behavior of the Job lifetime. 836 * See @BlockJobCreateFlags 837 * @speed: The maximum speed, in bytes per second, or 0 for unlimited. 838 * @on_error: The action to take upon error. 839 * @filter_node_name: The node name that should be assigned to the filter 840 * driver that the commit job inserts into the graph above @bs. NULL means that 841 * a node name should be autogenerated. 842 * @cb: Completion function for the job. 843 * @opaque: Opaque pointer value passed to @cb. 844 * @auto_complete: Auto complete the job. 845 * @errp: Error object. 846 * 847 */ 848 void commit_active_start(const char *job_id, BlockDriverState *bs, 849 BlockDriverState *base, int creation_flags, 850 int64_t speed, BlockdevOnError on_error, 851 const char *filter_node_name, 852 BlockCompletionFunc *cb, void *opaque, 853 bool auto_complete, Error **errp); 854 /* 855 * mirror_start: 856 * @job_id: The id of the newly-created job, or %NULL to use the 857 * device name of @bs. 858 * @bs: Block device to operate on. 859 * @target: Block device to write to. 860 * @replaces: Block graph node name to replace once the mirror is done. Can 861 * only be used when full mirroring is selected. 862 * @speed: The maximum speed, in bytes per second, or 0 for unlimited. 863 * @granularity: The chosen granularity for the dirty bitmap. 864 * @buf_size: The amount of data that can be in flight at one time. 865 * @mode: Whether to collapse all images in the chain to the target. 866 * @backing_mode: How to establish the target's backing chain after completion. 867 * @on_source_error: The action to take upon error reading from the source. 868 * @on_target_error: The action to take upon error writing to the target. 869 * @unmap: Whether to unmap target where source sectors only contain zeroes. 870 * @filter_node_name: The node name that should be assigned to the filter 871 * driver that the mirror job inserts into the graph above @bs. NULL means that 872 * a node name should be autogenerated. 873 * @errp: Error object. 874 * 875 * Start a mirroring operation on @bs. Clusters that are allocated 876 * in @bs will be written to @target until the job is cancelled or 877 * manually completed. At the end of a successful mirroring job, 878 * @bs will be switched to read from @target. 879 */ 880 void mirror_start(const char *job_id, BlockDriverState *bs, 881 BlockDriverState *target, const char *replaces, 882 int64_t speed, uint32_t granularity, int64_t buf_size, 883 MirrorSyncMode mode, BlockMirrorBackingMode backing_mode, 884 BlockdevOnError on_source_error, 885 BlockdevOnError on_target_error, 886 bool unmap, const char *filter_node_name, Error **errp); 887 888 /* 889 * backup_job_create: 890 * @job_id: The id of the newly-created job, or %NULL to use the 891 * device name of @bs. 892 * @bs: Block device to operate on. 893 * @target: Block device to write to. 894 * @speed: The maximum speed, in bytes per second, or 0 for unlimited. 895 * @sync_mode: What parts of the disk image should be copied to the destination. 896 * @sync_bitmap: The dirty bitmap if sync_mode is MIRROR_SYNC_MODE_INCREMENTAL. 897 * @on_source_error: The action to take upon error reading from the source. 898 * @on_target_error: The action to take upon error writing to the target. 899 * @creation_flags: Flags that control the behavior of the Job lifetime. 900 * See @BlockJobCreateFlags 901 * @cb: Completion function for the job. 902 * @opaque: Opaque pointer value passed to @cb. 903 * @txn: Transaction that this job is part of (may be NULL). 904 * 905 * Create a backup operation on @bs. Clusters in @bs are written to @target 906 * until the job is cancelled or manually completed. 907 */ 908 BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, 909 BlockDriverState *target, int64_t speed, 910 MirrorSyncMode sync_mode, 911 BdrvDirtyBitmap *sync_bitmap, 912 bool compress, 913 BlockdevOnError on_source_error, 914 BlockdevOnError on_target_error, 915 int creation_flags, 916 BlockCompletionFunc *cb, void *opaque, 917 BlockJobTxn *txn, Error **errp); 918 919 void hmp_drive_add_node(Monitor *mon, const char *optstr); 920 921 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, 922 const char *child_name, 923 const BdrvChildRole *child_role, 924 uint64_t perm, uint64_t shared_perm, 925 void *opaque, Error **errp); 926 void bdrv_root_unref_child(BdrvChild *child); 927 928 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared, 929 Error **errp); 930 931 /* Default implementation for BlockDriver.bdrv_child_perm() that can be used by 932 * block filters: Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED and RESIZE to 933 * all children */ 934 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c, 935 const BdrvChildRole *role, 936 uint64_t perm, uint64_t shared, 937 uint64_t *nperm, uint64_t *nshared); 938 939 /* Default implementation for BlockDriver.bdrv_child_perm() that can be used by 940 * (non-raw) image formats: Like above for bs->backing, but for bs->file it 941 * requires WRITE | RESIZE for read-write images, always requires 942 * CONSISTENT_READ and doesn't share WRITE. */ 943 void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, 944 const BdrvChildRole *role, 945 uint64_t perm, uint64_t shared, 946 uint64_t *nperm, uint64_t *nshared); 947 948 const char *bdrv_get_parent_name(const BlockDriverState *bs); 949 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp); 950 bool blk_dev_has_removable_media(BlockBackend *blk); 951 bool blk_dev_has_tray(BlockBackend *blk); 952 void blk_dev_eject_request(BlockBackend *blk, bool force); 953 bool blk_dev_is_tray_open(BlockBackend *blk); 954 bool blk_dev_is_medium_locked(BlockBackend *blk); 955 956 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, int64_t nr_sect); 957 bool bdrv_requests_pending(BlockDriverState *bs); 958 959 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out); 960 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in); 961 962 void bdrv_inc_in_flight(BlockDriverState *bs); 963 void bdrv_dec_in_flight(BlockDriverState *bs); 964 965 void blockdev_close_all_bdrv_states(void); 966 967 #endif /* BLOCK_INT_H */ 968