| /* |
| * QEMU System Emulator block driver |
| * |
| * Copyright (c) 2003 Fabrice Bellard |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| #ifndef BLOCK_COMMON_H |
| #define BLOCK_COMMON_H |
| |
| #include "block/aio.h" |
| #include "block/aio-wait.h" |
| #include "qemu/iov.h" |
| #include "qemu/coroutine.h" |
| #include "block/accounting.h" |
| #include "block/dirty-bitmap.h" |
| #include "block/blockjob.h" |
| #include "qemu/hbitmap.h" |
| #include "qemu/transactions.h" |
| |
| /* |
| * generated_co_wrapper |
| * |
| * Function specifier, which does nothing but mark functions to be |
| * generated by scripts/block-coroutine-wrapper.py |
| * |
| * Read more in docs/devel/block-coroutine-wrapper.rst |
| */ |
| #define generated_co_wrapper |
| |
| /* block.c */ |
| typedef struct BlockDriver BlockDriver; |
| typedef struct BdrvChild BdrvChild; |
| typedef struct BdrvChildClass BdrvChildClass; |
| |
| typedef struct BlockDriverInfo { |
| /* in bytes, 0 if irrelevant */ |
| int cluster_size; |
| /* offset at which the VM state can be saved (0 if not possible) */ |
| int64_t vm_state_offset; |
| bool is_dirty; |
| /* |
| * True if this block driver only supports compressed writes |
| */ |
| bool needs_compressed_writes; |
| } BlockDriverInfo; |
| |
| typedef struct BlockFragInfo { |
| uint64_t allocated_clusters; |
| uint64_t total_clusters; |
| uint64_t fragmented_clusters; |
| uint64_t compressed_clusters; |
| } BlockFragInfo; |
| |
| typedef enum { |
| BDRV_REQ_COPY_ON_READ = 0x1, |
| BDRV_REQ_ZERO_WRITE = 0x2, |
| |
| /* |
| * The BDRV_REQ_MAY_UNMAP flag is used in write_zeroes requests to indicate |
| * that the block driver should unmap (discard) blocks if it is guaranteed |
| * that the result will read back as zeroes. The flag is only passed to the |
| * driver if the block device is opened with BDRV_O_UNMAP. |
| */ |
| BDRV_REQ_MAY_UNMAP = 0x4, |
| |
| BDRV_REQ_FUA = 0x10, |
| BDRV_REQ_WRITE_COMPRESSED = 0x20, |
| |
| /* |
| * Signifies that this write request will not change the visible disk |
| * content. |
| */ |
| BDRV_REQ_WRITE_UNCHANGED = 0x40, |
| |
| /* |
| * Forces request serialisation. Use only with write requests. |
| */ |
| BDRV_REQ_SERIALISING = 0x80, |
| |
| /* |
| * Execute the request only if the operation can be offloaded or otherwise |
| * be executed efficiently, but return an error instead of using a slow |
| * fallback. |
| */ |
| BDRV_REQ_NO_FALLBACK = 0x100, |
| |
| /* |
| * BDRV_REQ_PREFETCH makes sense only in the context of copy-on-read |
| * (i.e., together with the BDRV_REQ_COPY_ON_READ flag or when a COR |
| * filter is involved), in which case it signals that the COR operation |
| * need not read the data into memory (qiov) but only ensure they are |
| * copied to the top layer (i.e., that COR operation is done). |
| */ |
| BDRV_REQ_PREFETCH = 0x200, |
| |
| /* |
| * If we need to wait for other requests, just fail immediately. Used |
| * only together with BDRV_REQ_SERIALISING. Used only with requests aligned |
| * to request_alignment (corresponding assertions are in block/io.c). |
| */ |
| BDRV_REQ_NO_WAIT = 0x400, |
| |
| /* Mask of valid flags */ |
| BDRV_REQ_MASK = 0x7ff, |
| } BdrvRequestFlags; |
| |
| #define BDRV_O_NO_SHARE 0x0001 /* don't share permissions */ |
| #define BDRV_O_RDWR 0x0002 |
| #define BDRV_O_RESIZE 0x0004 /* request permission for resizing the node */ |
| #define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save |
| writes in a snapshot */ |
| #define BDRV_O_TEMPORARY 0x0010 /* delete the file after use */ |
| #define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */ |
| #define BDRV_O_NATIVE_AIO 0x0080 /* use native AIO instead of the |
| thread pool */ |
| #define BDRV_O_NO_BACKING 0x0100 /* don't open the backing file */ |
| #define BDRV_O_NO_FLUSH 0x0200 /* disable flushing on this disk */ |
| #define BDRV_O_COPY_ON_READ 0x0400 /* copy read backing sectors into image */ |
| #define BDRV_O_INACTIVE 0x0800 /* consistency hint for migration handoff */ |
| #define BDRV_O_CHECK 0x1000 /* open solely for consistency check */ |
| #define BDRV_O_ALLOW_RDWR 0x2000 /* allow reopen to change from r/o to r/w */ |
| #define BDRV_O_UNMAP 0x4000 /* execute guest UNMAP/TRIM operations */ |
| #define BDRV_O_PROTOCOL 0x8000 /* if no block driver is explicitly given: |
| select an appropriate protocol driver, |
| ignoring the format layer */ |
| #define BDRV_O_NO_IO 0x10000 /* don't initialize for I/O */ |
| #define BDRV_O_AUTO_RDONLY 0x20000 /* degrade to read-only if opening |
| read-write fails */ |
| #define BDRV_O_IO_URING 0x40000 /* use io_uring instead of the thread pool */ |
| |
| #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH) |
| |
| |
| /* Option names of options parsed by the block layer */ |
| |
| #define BDRV_OPT_CACHE_WB "cache.writeback" |
| #define BDRV_OPT_CACHE_DIRECT "cache.direct" |
| #define BDRV_OPT_CACHE_NO_FLUSH "cache.no-flush" |
| #define BDRV_OPT_READ_ONLY "read-only" |
| #define BDRV_OPT_AUTO_READ_ONLY "auto-read-only" |
| #define BDRV_OPT_DISCARD "discard" |
| #define BDRV_OPT_FORCE_SHARE "force-share" |
| |
| |
| #define BDRV_SECTOR_BITS 9 |
| #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS) |
| |
| #define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \ |
| INT_MAX >> BDRV_SECTOR_BITS) |
| #define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS) |
| |
| /* |
| * We want allow aligning requests and disk length up to any 32bit alignment |
| * and don't afraid of overflow. |
| * To achieve it, and in the same time use some pretty number as maximum disk |
| * size, let's define maximum "length" (a limit for any offset/bytes request and |
| * for disk size) to be the greatest power of 2 less than INT64_MAX. |
| */ |
| #define BDRV_MAX_ALIGNMENT (1L << 30) |
| #define BDRV_MAX_LENGTH (QEMU_ALIGN_DOWN(INT64_MAX, BDRV_MAX_ALIGNMENT)) |
| |
| /* |
| * Allocation status flags for bdrv_block_status() and friends. |
| * |
| * Public flags: |
| * BDRV_BLOCK_DATA: allocation for data at offset is tied to this layer |
| * BDRV_BLOCK_ZERO: offset reads as zero |
| * BDRV_BLOCK_OFFSET_VALID: an associated offset exists for accessing raw data |
| * BDRV_BLOCK_ALLOCATED: the content of the block is determined by this |
| * layer rather than any backing, set by block layer |
| * BDRV_BLOCK_EOF: the returned pnum covers through end of file for this |
| * layer, set by block layer |
| * |
| * Internal flags: |
| * BDRV_BLOCK_RAW: for use by passthrough drivers, such as raw, to request |
| * that the block layer recompute the answer from the returned |
| * BDS; must be accompanied by just BDRV_BLOCK_OFFSET_VALID. |
| * BDRV_BLOCK_RECURSE: request that the block layer will recursively search for |
| * zeroes in file child of current block node inside |
| * returned region. Only valid together with both |
| * BDRV_BLOCK_DATA and BDRV_BLOCK_OFFSET_VALID. Should not |
| * appear with BDRV_BLOCK_ZERO. |
| * |
| * If BDRV_BLOCK_OFFSET_VALID is set, the map parameter represents the |
| * host offset within the returned BDS that is allocated for the |
| * corresponding raw guest data. However, whether that offset |
| * actually contains data also depends on BDRV_BLOCK_DATA, as follows: |
| * |
| * DATA ZERO OFFSET_VALID |
| * t t t sectors read as zero, returned file is zero at offset |
| * t f t sectors read as valid from file at offset |
| * f t t sectors preallocated, read as zero, returned file not |
| * necessarily zero at offset |
| * f f t sectors preallocated but read from backing_hd, |
| * returned file contains garbage at offset |
| * t t f sectors preallocated, read as zero, unknown offset |
| * t f f sectors read from unknown file or offset |
| * f t f not allocated or unknown offset, read as zero |
| * f f f not allocated or unknown offset, read from backing_hd |
| */ |
| #define BDRV_BLOCK_DATA 0x01 |
| #define BDRV_BLOCK_ZERO 0x02 |
| #define BDRV_BLOCK_OFFSET_VALID 0x04 |
| #define BDRV_BLOCK_RAW 0x08 |
| #define BDRV_BLOCK_ALLOCATED 0x10 |
| #define BDRV_BLOCK_EOF 0x20 |
| #define BDRV_BLOCK_RECURSE 0x40 |
| |
| typedef QTAILQ_HEAD(BlockReopenQueue, BlockReopenQueueEntry) BlockReopenQueue; |
| |
| typedef struct BDRVReopenState { |
| BlockDriverState *bs; |
| int flags; |
| BlockdevDetectZeroesOptions detect_zeroes; |
| bool backing_missing; |
| BlockDriverState *old_backing_bs; /* keep pointer for permissions update */ |
| BlockDriverState *old_file_bs; /* keep pointer for permissions update */ |
| QDict *options; |
| QDict *explicit_options; |
| void *opaque; |
| } BDRVReopenState; |
| |
| /* |
| * Block operation types |
| */ |
| typedef enum BlockOpType { |
| BLOCK_OP_TYPE_BACKUP_SOURCE, |
| BLOCK_OP_TYPE_BACKUP_TARGET, |
| BLOCK_OP_TYPE_CHANGE, |
| BLOCK_OP_TYPE_COMMIT_SOURCE, |
| BLOCK_OP_TYPE_COMMIT_TARGET, |
| BLOCK_OP_TYPE_DATAPLANE, |
| BLOCK_OP_TYPE_DRIVE_DEL, |
| BLOCK_OP_TYPE_EJECT, |
| BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, |
| BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, |
| BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, |
| BLOCK_OP_TYPE_MIRROR_SOURCE, |
| BLOCK_OP_TYPE_MIRROR_TARGET, |
| BLOCK_OP_TYPE_RESIZE, |
| BLOCK_OP_TYPE_STREAM, |
| BLOCK_OP_TYPE_REPLACE, |
| BLOCK_OP_TYPE_MAX, |
| } BlockOpType; |
| |
| /* Block node permission constants */ |
| enum { |
| /** |
| * A user that has the "permission" of consistent reads is guaranteed that |
| * their view of the contents of the block device is complete and |
| * self-consistent, representing the contents of a disk at a specific |
| * point. |
| * |
| * For most block devices (including their backing files) this is true, but |
| * the property cannot be maintained in a few situations like for |
| * intermediate nodes of a commit block job. |
| */ |
| BLK_PERM_CONSISTENT_READ = 0x01, |
| |
| /** This permission is required to change the visible disk contents. */ |
| BLK_PERM_WRITE = 0x02, |
| |
| /** |
| * This permission (which is weaker than BLK_PERM_WRITE) is both enough and |
| * required for writes to the block node when the caller promises that |
| * the visible disk content doesn't change. |
| * |
| * As the BLK_PERM_WRITE permission is strictly stronger, either is |
| * sufficient to perform an unchanging write. |
| */ |
| BLK_PERM_WRITE_UNCHANGED = 0x04, |
| |
| /** This permission is required to change the size of a block node. */ |
| BLK_PERM_RESIZE = 0x08, |
| |
| /** |
| * There was a now-removed bit BLK_PERM_GRAPH_MOD, with value of 0x10. QEMU |
| * 6.1 and earlier may still lock the corresponding byte in block/file-posix |
| * locking. So, implementing some new permission should be very careful to |
| * not interfere with this old unused thing. |
| */ |
| |
| BLK_PERM_ALL = 0x0f, |
| |
| DEFAULT_PERM_PASSTHROUGH = BLK_PERM_CONSISTENT_READ |
| | BLK_PERM_WRITE |
| | BLK_PERM_WRITE_UNCHANGED |
| | BLK_PERM_RESIZE, |
| |
| DEFAULT_PERM_UNCHANGED = BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH, |
| }; |
| |
| /* |
| * Flags that parent nodes assign to child nodes to specify what kind of |
| * role(s) they take. |
| * |
| * At least one of DATA, METADATA, FILTERED, or COW must be set for |
| * every child. |
| */ |
| enum BdrvChildRoleBits { |
| /* |
| * This child stores data. |
| * Any node may have an arbitrary number of such children. |
| */ |
| BDRV_CHILD_DATA = (1 << 0), |
| |
| /* |
| * This child stores metadata. |
| * Any node may have an arbitrary number of metadata-storing |
| * children. |
| */ |
| BDRV_CHILD_METADATA = (1 << 1), |
| |
| /* |
| * A child that always presents exactly the same visible data as |
| * the parent, e.g. by virtue of the parent forwarding all reads |
| * and writes. |
| * This flag is mutually exclusive with DATA, METADATA, and COW. |
| * Any node may have at most one filtered child at a time. |
| */ |
| BDRV_CHILD_FILTERED = (1 << 2), |
| |
| /* |
| * Child from which to read all data that isn't allocated in the |
| * parent (i.e., the backing child); such data is copied to the |
| * parent through COW (and optionally COR). |
| * This field is mutually exclusive with DATA, METADATA, and |
| * FILTERED. |
| * Any node may have at most one such backing child at a time. |
| */ |
| BDRV_CHILD_COW = (1 << 3), |
| |
| /* |
| * The primary child. For most drivers, this is the child whose |
| * filename applies best to the parent node. |
| * Any node may have at most one primary child at a time. |
| */ |
| BDRV_CHILD_PRIMARY = (1 << 4), |
| |
| /* Useful combination of flags */ |
| BDRV_CHILD_IMAGE = BDRV_CHILD_DATA |
| | BDRV_CHILD_METADATA |
| | BDRV_CHILD_PRIMARY, |
| }; |
| |
| /* Mask of BdrvChildRoleBits values */ |
| typedef unsigned int BdrvChildRole; |
| |
| typedef struct BdrvCheckResult { |
| int corruptions; |
| int leaks; |
| int check_errors; |
| int corruptions_fixed; |
| int leaks_fixed; |
| int64_t image_end_offset; |
| BlockFragInfo bfi; |
| } BdrvCheckResult; |
| |
| typedef enum { |
| BDRV_FIX_LEAKS = 1, |
| BDRV_FIX_ERRORS = 2, |
| } BdrvCheckMode; |
| |
| typedef struct BlockSizes { |
| uint32_t phys; |
| uint32_t log; |
| } BlockSizes; |
| |
| typedef struct HDGeometry { |
| uint32_t heads; |
| uint32_t sectors; |
| uint32_t cylinders; |
| } HDGeometry; |
| |
| /* |
| * Common functions that are neither I/O nor Global State. |
| * |
| * These functions must never call any function from other categories |
| * (I/O, "I/O or GS", Global State) except this one, but can be invoked by |
| * all of them. |
| */ |
| |
| char *bdrv_perm_names(uint64_t perm); |
| uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm); |
| |
| void bdrv_init_with_whitelist(void); |
| bool bdrv_uses_whitelist(void); |
| int bdrv_is_whitelisted(BlockDriver *drv, bool read_only); |
| |
| int bdrv_parse_aio(const char *mode, int *flags); |
| int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough); |
| int bdrv_parse_discard_flags(const char *mode, int *flags); |
| |
| int path_has_protocol(const char *path); |
| int path_is_absolute(const char *path); |
| char *path_combine(const char *base_path, const char *filename); |
| |
| char *bdrv_get_full_backing_filename_from_filename(const char *backed, |
| const char *backing, |
| Error **errp); |
| |
| #endif /* BLOCK_COMMON_H */ |
