block layer: split block APIs in global state and I/O
Subsystems (2)
v5 cover block layer: split block APIs in global state and I/O
Currently, block layer APIs like block.h contain a mix of functions that are either running in the main loop and under the BQL, or are thread-safe functions and run in iothreads performing I/O. The functions running under BQL also take care of modifying the block graph, by using drain and/or aio_context_acquire/release. This makes it very confusing to understand where each function runs, and what assumptions it provided with regards to thread safety.
We call the functions running under BQL "global state (GS) API", and distinguish them from the thread-safe "I/O API".
The aim of this series is to split the relevant block headers in global state and I/O sub-headers. The division will be done in this way:header.h will be split in header-global-state.h, header-io.h and header-common.h. The latter will just contain the data structures needed by header-global-state and header-io, and common helpers that are neither in GS nor in I/O. header.h will remain for legacy and to avoid changing all includes in all QEMU c files, but will only include the two new headers. No function shall be added in header.c .
Once we split all relevant headers, it will be much easier to see what uses the AioContext lock and remove it, which is the overall main goal of this and other series that I posted/will post.
In addition to splitting the relevant headers shown in this series, it is also very helpful splitting the function pointers in some block structures, to understand what runs under AioContext lock and what doesn't. This is what patches 21-27 do.
Each function in the GS API will have an assertion, checking that it is always running under BQL.
I/O functions are instead thread safe (or so should be), meaning that they *can* run under BQL, but also in an iothread in another AioContext. Therefore they do not provide any assertion, and need to be audited manually to verify the correctness.
Adding assetions has helped finding 2 bugs already, as shown in my series "Migration: fix missing iothread locking".
Tested this series by running unit tests, qemu-iotests and qtests (x86_64).
Some functions in the GS API are used everywhere but not properly tested. Therefore their assertion is never actually run in the tests, so despite my very careful auditing, it is not impossible to exclude that some will trigger while actually using QEMU.
Patch 1 introduces qemu_in_main_thread(), the function used in all assertions. This had to be introduced otherwise all unit tests would fail, since they run in the main loop but use the code in stubs/iothread.c
Patches 2-27 (with the exception of patch 9-10, that are an additional assert) are all structured in the same way: first we split the header and in the next (or same, if small) patch we add assertions. Patch 28-31 take care instead of the block layer permission API, fixing some bugs where they are used in I/O functions.
Next steps once this get reviewed:
1) audit the GS API and replace the AioContext lock with drains, or remove them when not necessary (requires further discussion).
2) [optional as it should be already the case] audit the I/O API and check that thread safety is guaranteed
In order to keep this series a little bit smaller, move some refactoring patches in another series, "block: minor refactoring in preparation to the block layer API split".
Based-on: <[email protected]>
---
v5 -> v6:
* In short, apply all Hanna's comments. More in details, the following functions in the following headers have been moved:
block-backend:
blk_replace_bs (to gs)
blk_nb_sectors (to io)
blk_name (to io)
blk_set_perm (to io)
blk_get_perm (to io)
blk_drain (to io)
blk_abort_aio_request (to io)
blk_make_empty (to gs)
blk_invalidate_cache (was in io, but had GS assertion) blk_aio_cancel (to gs)
block:
bdrv_replace_child_bs (to gs)
bdrv_get_device_name (to io) bdrv_get_device_or_node_name (to io) bdrv_drained_end_no_poll (to io)
bdrv_block_status (was in io, but had GS assertion) bdrv_drain (to io)
bdrv_co_drain (to io)
bdrv_make_zero (was in GS, but did not have the assertion) bdrv_save_vmstate (to io)
bdrv_load_vmstate (to io)
bdrv_aio_cancel_async (to io)
block_int:
bdrv_get_parent_name (to io) bdrv_apply_subtree_drain (to io) bdrv_unapply_subtree_drain (to io) bdrv_co_copy_range_from (was in io, but had GS assertion) bdrv_co_copy_range_to (was in io, but had GS assertion) ->bdrv_save_vmstate (to io)
->bdrv_load_vmstate (to io)
coding style (assertion after definitions):
bdrv_save_vmstate
bdrv_load_vmstate
block_job_next
block_job_get
new patches:
block.c: modify .attach and .detach callbacks of child_of_bds introduce pre_run as JobDriver callback to handle
bdrv_co_amend usage of permission function
leave blk_set/get_perm as a TODO in fuse.c
make sure bdrv_co_invalidate_cache does not use permissions
if BQL is not held
minor changes:
put back TODO for include block/block.h in block-backend-common.h rebase on kwolf/block branch
modify where are used assert_bdrv_graph_writable, due to rebase
v4 -> v5:
* Moved the following functions from block-io to block-global-state (+ assertion):
- bdrv_apply_auto_read_only
- bdrv_can_set_read_only
* Moved the following functions from block-backend-io to block-backend-global-state (+ assertion):
- blk_ioctl
* added patch 4 to distinguish assertions added to static functions in block.c
* block/coroutines: it seems that blk_co_do_ioctl and blk_do_ioctl are global state too
v3 -> v4:
* blockdev.h (patch 14): blockdev_mark_auto_del, blockdev_auto_del and blk_legacy_dinfo as GS API.
* add copyright header to block.h, block-io.h and block-global-state.h
* rebase on current master (c5b2f55981)
v2 -> v3:
* rename "graph API" into "global state API"
* change order of patches, block.h comes before block-backend.h
* change GS and I/O comment headers to avoid redundancy, all other headers refer to block-global-state.h and block-io.h
* fix typo on GS and I/O headers
* use assert instead of g_assert
* move bdrv_pwrite_sync, bdrv_block_status and bdrv_co_copy_range_{from/to} to the I/O API
* change assert_bdrv_graph_writable implementation, since we need to introduce additional drains
* remove transactions API split
* add preparation patch for blockdev.h (patch 13)
* backup-top -> copy-on-write
* change I/O comment in job.h into a better meaningful explanation
* fix all warnings given by checkpatch, mostly due to /* */ to be split in separate lines
* rebase on current master (c09124dcb8), and split the following new functions:
blk_replace_bs (I/O) bdrv_bsc_is_data (I/O) bdrv_bsc_invalidate_range (I/O) bdrv_bsc_fill (I/O) bdrv_new_open_driver_opts (GS) blk_get_max_hw_iov (I/O)
they are all added in patches 4 and 6.
v1 -> v2:
* remove the iothread locking bug fix, and send it as separate patch
* rename graph API -> global state API
* better documented patch 1 (qemu_in_main_thread)
* add and split all other block layer headers
* fix warnings given by checkpatch on multiline comments
Emanuele Giuseppe Esposito (31):
main-loop.h: introduce qemu_in_main_thread() include/block/block: split header into I/O and global state API assertions for block global state API include/sysemu/block-backend: split header into I/O and global state
(GS) API
block-backend: special comments for blk_set/get_perm due to fuse block/block-backend.c: assertions for block-backend include/block/block_int: split header into I/O and global state API assertions for block_int global state API
block: introduce assert_bdrv_graph_writable
block.c: modify .attach and .detach callbacks of child_of_bds include/block/blockjob_int.h: split header into I/O and GS API assertions for blockjob_int.h
block.c: add assertions to static functions include/block/blockjob.h: global state API
assertions for blockjob.h global state API include/sysemu/blockdev.h: global state API
assertions for blockdev.h global state API include/block/snapshot: global state API + assertions block/copy-before-write.h: global state API + assertions block/coroutines: I/O API
block_int-common.h: split function pointers in BlockDriver block_int-common.h: assertion in the callers of BlockDriver function
pointers
block_int-common.h: split function pointers in BdrvChildClass block_int-common.h: assertions in the callers of BdrvChildClass
function pointers
block-backend-common.h: split function pointers in BlockDevOps job.h: split function pointers in JobDriver
job.h: assertions in the callers of JobDriver funcion pointers block.c: assert BQL lock held in bdrv_co_invalidate_cache
jobs: introduce pre_run function in JobDriver
crypto: delegate permission functions to JobDriver .pre_run block.c: assertions to the block layer permissions API
block/copy-before-write.h | 7 + block/coroutines.h | 6 + include/block/block-common.h | 380 +++++ include/block/block-global-state.h | 271 ++++ include/block/block-io.h | 322 ++++ include/block/block.h | 878 +---------- include/block/block_int-common.h | 1204 +++++++++++++++ include/block/block_int-global-state.h | 323 ++++ include/block/block_int-io.h | 167 +++ include/block/block_int.h | 1475 +------------------ include/block/blockjob.h | 9 + include/block/blockjob_int.h | 28 + include/block/snapshot.h | 13 +- include/qemu/job.h | 31 + include/qemu/main-loop.h | 13 + include/sysemu/block-backend-common.h | 102 ++ include/sysemu/block-backend-global-state.h | 121 ++ include/sysemu/block-backend-io.h | 139 ++ include/sysemu/block-backend.h | 269 +--- include/sysemu/blockdev.h | 13 +- block.c | 272 +++- block/amend.c | 20 + block/backup.c | 1 + block/block-backend.c | 108 +- block/commit.c | 4 + block/copy-before-write.c | 2 + block/create.c | 10 + block/crypto.c | 18 +- block/dirty-bitmap.c | 1 + block/export/fuse.c | 16 +- block/io.c | 26 + block/mirror.c | 4 + block/monitor/bitmap-qmp-cmds.c | 6 + block/snapshot.c | 28 + block/stream.c | 2 + blockdev.c | 28 + blockjob.c | 14 + job.c | 23 + migration/savevm.c | 2 + softmmu/cpus.c | 5 + softmmu/qdev-monitor.c | 2 + stubs/iothread-lock.c | 5 + block/meson.build | 7 +- 43 files changed, 3758 insertions(+), 2617 deletions(-) create mode 100644 include/block/block-common.h create mode 100644 include/block/block-global-state.h create mode 100644 include/block/block-io.h create mode 100644 include/block/block_int-common.h create mode 100644 include/block/block_int-global-state.h create mode 100644 include/block/block_int-io.h create mode 100644 include/sysemu/block-backend-common.h create mode 100644 include/sysemu/block-backend-global-state.h create mode 100644 include/sysemu/block-backend-io.h
Signature · 1 line
2.27.0
PATCH v5 1/31 main-loop.h: introduce qemu_in_main_thread()
When invoked from the main loop, this function is the same as qemu_mutex_iothread_locked, and returns true if the BQL is held. When invoked from iothreads or tests, it returns true only if the current AioContext is the Main Loop.
This essentially just extends qemu_mutex_iothread_locked to work also in unit tests or other users like storage-daemon, that run in the Main Loop but end up using the implementation in stubs/iothread-lock.c.
Using qemu_mutex_iothread_locked in unit tests defaults to false because they use the implementation in stubs/iothread-lock, making all assertions added in next patches fail despite the AioContext is still the main loop.
--- include/qemu/main-loop.h | 13 +++++++++++++ softmmu/cpus.c | 5 +++++ stubs/iothread-lock.c | 5 +++++ 3 files changed, 23 insertions(+)
include/qemu/main-loop.h +13 -0
@@ -245,6 +245,19 @@ AioContext *iohandler_get_aio_context(void);*/ bool qemu_mutex_iothread_locked (void ); +/** +* qemu_in_main_thread: same as qemu_mutex_iothread_locked when +* softmmu/cpus.c implementation is linked. Otherwise this function +* checks that the current AioContext is the global AioContext +* (main loop). +* +* This is useful when checking that the BQL is held, to avoid +* returning false when invoked by unit tests or other users like +* storage-daemon that end up using stubs/iothread-lock.c +* implementation. +*/ +bool qemu_in_main_thread (void ); +/** * qemu_mutex_lock_iothread: Lock the main loop mutex. *
softmmu/cpus.c +5 -0
@@ -481,6 +481,11 @@ bool qemu_mutex_iothread_locked(void)return iothread_locked; } +bool qemu_in_main_thread (void ) +{ +return qemu_mutex_iothread_locked (); +} +/* * The BQL is taken from so many places that it is worth profiling the * callers directly, instead of funneling them all through a single function.
stubs/iothread-lock.c +5 -0
@@ -6,6 +6,11 @@ bool qemu_mutex_iothread_locked(void)return false; } +bool qemu_in_main_thread (void ) +{ +return qemu_get_current_aio_context () ==qemu_get_aio_context (); +} +void qemu_mutex_lock_iothread_impl (const char *file,int line) { }
Signature · 1 line
2.27.0
PATCH v5 2/31 include/block/block: split header into I/O and global state API
In reply to Emanuele Giuseppe Espositoblock.h currently contains a mix of functions:
some of them run under the BQL and modify the block layer graph, others are instead thread-safe and perform I/O in iothreads. It is not easy to understand which function is part of which group (I/O vs GS), and this patch aims to clarify it.
The "GS" functions need the BQL, and often use aio_context_acquire/release and/or drain to be sure they can modify the graph safely.
The I/O function are instead thread safe, and can run in any AioContext.
By splitting the header in two files, block-io.h and block-global-state.h we have a clearer view on what needs what kind of protection. block-common.h contains common structures shared by both headers.
block.h is left there for legacy and to avoid changing all includes in all c files that use the block APIs.
Assertions are added in the next patch.
--- include/block/block-common.h | 380 +++++++++++++ include/block/block-global-state.h | 271 +++++++++ include/block/block-io.h | 322 +++++++++++ include/block/block.h | 878 +---------------------------- block.c | 3 + block/meson.build | 7 +- 6 files changed, 1004 insertions(+), 857 deletions(-) create mode 100644 include/block/block-common.h create mode 100644 include/block/block-global-state.h create mode 100644 include/block/block-io.h
include/block/block-common.h new file +380 -0
@@ -0,0 +1,380 @@ +#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. +*/ +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 , + +/** +* This permission is required to change the node that this BdrvChild +* points to. +*/ +BLK_PERM_GRAPH_MOD =0x10 , + +BLK_PERM_ALL =0x1f , + +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 */ + +int bdrv_parse_aio (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); +char *bdrv_get_full_backing_filename (BlockDriverState *bs,Error **errp); + +#endif /* BLOCK_COMMON_H */
include/block/block-global-state.h new file +271 -0
271 lines not on this page · raw message
include/block/block-io.h new file +322 -0
322 lines not on this page · raw message
include/block/block.h +23 -855
887 lines not on this page · raw message
block.c +3 -0
@@ -67,12 +67,15 @@#define NOT_DONE 0x7fffffff/* used while emulated sync operation in progress */ +/* Protected by BQL */ static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =QTAILQ_HEAD_INITIALIZER (graph_bdrv_states); +/* Protected by BQL */ static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =QTAILQ_HEAD_INITIALIZER (all_bdrv_states); +/* Protected by BQL */ static QLIST_HEAD(, BlockDriver) bdrv_drivers =QLIST_HEAD_INITIALIZER (bdrv_drivers);
block/meson.build +5 -2
@@ -113,8 +113,11 @@ block_ss.add(module_block_h) wrapper_py = find_program('../scripts/block-coroutine-wrapper.py') block_gen_c = custom_target('block-gen.c', output: 'block-gen.c', - input: files('../include/block/block.h', - 'coroutines.h'), + input: files( + '../include/block/block-io.h', + '../include/block/block-global-state.h', + 'coroutines.h' + ), command: [wrapper_py, '@OUTPUT@', '@INPUT@']) block_ss.add(block_gen_c)
Signature · 1 line
2.27.0
PATCH v5 3/31 assertions for block global state API
In reply to Emanuele Giuseppe EspositoAll the global state (GS) API functions will check that qemu_in_main_thread() returns true. If not, it means that the safety of BQL cannot be guaranteed, and they need to be moved to I/O.
--- block.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++- block/commit.c | 2 + block/io.c | 14 +++++ blockdev.c | 1 + 4 files changed, 150 insertions(+), 2 deletions(-)
block.c +133 -2
@@ -278,6 +278,8 @@ bool bdrv_is_read_only(BlockDriverState *bs)int bdrv_can_set_read_only (BlockDriverState *bs,bool read_only,bool ignore_allow_rdw,Error **errp) { +assert (qemu_in_main_thread ()); +/* Do not set read_only if copy_on_read is enabled */ if (bs->copy_on_read && read_only) { error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
@@ -311,6 +313,7 @@ int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg, Error **errp) {int ret =0 ; +assert (qemu_in_main_thread ());if (!(bs->open_flags &BDRV_O_RDWR )) {return 0 ;
@@ -393,6 +396,7 @@ char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp)void bdrv_register (BlockDriver *bdrv) {assert (bdrv->format_name); +assert (qemu_in_main_thread ());QLIST_INSERT_HEAD (&bdrv_drivers, bdrv, list); }
@@ -401,6 +405,8 @@ BlockDriverState *bdrv_new(void)BlockDriverState *bs;int i; +assert (qemu_in_main_thread ()); + bs =g_new0 (BlockDriverState,1 );QLIST_INIT (&bs->dirty_bitmaps);for (i =0 ; i <BLOCK_OP_TYPE_MAX ; i++) {
@@ -443,6 +449,8 @@ BlockDriver *bdrv_find_format(const char *format_name)BlockDriver *drv1;int i; +assert (qemu_in_main_thread ()); + drv1 =bdrv_do_find_format (format_name);if (drv1) {return drv1;
@@ -492,11 +500,13 @@ static int bdrv_format_is_whitelisted(const char *format_name, bool read_only)int bdrv_is_whitelisted (BlockDriver *drv,bool read_only) { +assert (qemu_in_main_thread ());return bdrv_format_is_whitelisted (drv->format_name, read_only); }bool bdrv_uses_whitelist (void ) { +assert (qemu_in_main_thread ());return use_bdrv_whitelist; }
@@ -527,6 +537,8 @@ int bdrv_create(BlockDriver *drv, const char* filename, {int ret; +assert (qemu_in_main_thread ()); +Coroutine *co;CreateCo cco = { .drv = drv,
@@ -702,6 +714,8 @@ int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)QDict *qdict;int ret; +assert (qemu_in_main_thread ()); + drv =bdrv_find_protocol (filename, true, errp);if (drv ==NULL ) {return -ENOENT ;
@@ -799,6 +813,7 @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) {BlockDriver *drv = bs->drv;BlockDriverState *filtered =bdrv_filter_bs (bs); +assert (qemu_in_main_thread ());if (drv && drv->bdrv_probe_blocksizes) {return drv->bdrv_probe_blocksizes (bs, bsz);
@@ -819,6 +834,7 @@ int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) {BlockDriver *drv = bs->drv;BlockDriverState *filtered =bdrv_filter_bs (bs); +assert (qemu_in_main_thread ());if (drv && drv->bdrv_probe_geometry) {return drv->bdrv_probe_geometry (bs, geo);
@@ -910,6 +926,7 @@ BlockDriver *bdrv_find_protocol(const char *filename,const char *p;int i; +assert (qemu_in_main_thread ());/* TODO Drivers without bdrv_file_open must be specified explicitly */ /*
@@ -975,6 +992,7 @@ BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, {int score_max =0 , score;BlockDriver *drv =NULL , *d; +assert (qemu_in_main_thread ()); QLIST_FOREACH(d, &bdrv_drivers, list) {if (d->bdrv_probe) {
@@ -1122,6 +1140,7 @@ int bdrv_parse_aio(const char *mode, int *flags)*/ int bdrv_parse_discard_flags (const char *mode,int *flags) { +assert (qemu_in_main_thread ()); *flags &= ~BDRV_O_UNMAP ;if (!strcmp (mode,"off" ) || !strcmp (mode,"ignore" )) {
@@ -1142,6 +1161,7 @@ int bdrv_parse_discard_flags(const char *mode, int *flags)*/ int bdrv_parse_cache_mode (const char *mode,int *flags,bool *writethrough) { +assert (qemu_in_main_thread ()); *flags &= ~BDRV_O_CACHE_MASK ;if (!strcmp (mode,"off" ) || !strcmp (mode,"none" )) {
@@ -1634,6 +1654,8 @@ BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,BlockDriverState *bs;int ret; +assert (qemu_in_main_thread ()); + bs =bdrv_new (); bs->open_flags = flags; bs->options = options ?:qdict_new ();
@@ -1659,6 +1681,7 @@ BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,BlockDriverState *bdrv_new_open_driver (BlockDriver *drv,const char *node_name,int flags,Error **errp) { +assert (qemu_in_main_thread ());return bdrv_new_open_driver_opts (drv, node_name,NULL , flags, errp); }
@@ -2480,6 +2503,8 @@ void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,char *bdrv_perm_names (uint64_t perm) { +assert (qemu_in_main_thread ()); +struct perm_name {uint64_t perm;const char *name;
@@ -2718,6 +2743,8 @@ void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,uint64_t bdrv_qapi_perm_to_blk_perm (BlockPermission qapi_perm) { +assert (qemu_in_main_thread ()); +static const uint64_t permissions[] = { [BLOCK_PERMISSION_CONSISTENT_READ ] =BLK_PERM_CONSISTENT_READ , [BLOCK_PERMISSION_WRITE ] =BLK_PERM_WRITE ,
@@ -3097,6 +3124,8 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,BdrvChild *child =NULL ;Transaction *tran =tran_new (); +assert (qemu_in_main_thread ()); + ret =bdrv_attach_child_noperm (parent_bs, child_bs, child_name, child_class, child_role, &child, tran, errp);if (ret <0 ) {
@@ -3123,6 +3152,8 @@ void bdrv_root_unref_child(BdrvChild *child) {BlockDriverState *child_bs; +assert (qemu_in_main_thread ()); + child_bs = child->bs;bdrv_detach_child (&child);bdrv_unref (child_bs);
@@ -3197,6 +3228,7 @@ static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child,/* Callers must ensure that child->frozen is false. */ void bdrv_unref_child (BlockDriverState *parent,BdrvChild *child) { +assert (qemu_in_main_thread ());if (child ==NULL ) {return ; }
@@ -3347,6 +3379,8 @@ int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,int ret;Transaction *tran =tran_new (); +assert (qemu_in_main_thread ()); + ret =bdrv_set_backing_noperm (bs, backing_hd, tran, errp);if (ret <0 ) { goto out;
@@ -3382,6 +3416,8 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,QDict *tmp_parent_options =NULL ;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); +if (bs->backing !=NULL ) { goto free_exit; }
@@ -3541,6 +3577,8 @@ BdrvChild *bdrv_open_child(const char *filename, {BlockDriverState *bs; +assert (qemu_in_main_thread ()); + bs =bdrv_open_child_bs (filename, options, bdref_key, parent, child_class, child_role, allow_none, errp);if (bs ==NULL ) {
@@ -3563,6 +3601,8 @@ BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)const char *reference =NULL ;Visitor *v =NULL ; +assert (qemu_in_main_thread ()); +if (ref->type ==QTYPE_QSTRING ) { reference = ref->u.reference; }else {
@@ -3960,6 +4000,8 @@ close_and_fail:BlockDriverState *bdrv_open (const char *filename,const char *reference,QDict *options,int flags,Error **errp) { +assert (qemu_in_main_thread ()); +return bdrv_open_inherit (filename, reference, options, flags,NULL ,NULL ,0 , errp); }
@@ -4214,12 +4256,15 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, BlockDriverState *bs, QDict *options, bool keep_old_opts) { +assert (qemu_in_main_thread ()); +return bdrv_reopen_queue_child (bs_queue, bs, options,NULL ,0 , false,NULL ,0 , keep_old_opts); }void bdrv_reopen_queue_free (BlockReopenQueue *bs_queue) { +assert (qemu_in_main_thread ());if (bs_queue) {BlockReopenQueueEntry *bs_entry, *next; QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
@@ -4367,6 +4412,8 @@ int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts,BlockReopenQueue *queue;int ret; +assert (qemu_in_main_thread ()); +bdrv_subtree_drained_begin (bs);if (ctx !=qemu_get_aio_context ()) {aio_context_release (ctx);
@@ -4388,6 +4435,8 @@ int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only, {QDict *opts =qdict_new (); +assert (qemu_in_main_thread ()); +qdict_put_bool (opts,BDRV_OPT_READ_ONLY , read_only);return bdrv_reopen (bs, opts, true, errp);
@@ -4842,6 +4891,7 @@ static void bdrv_close(BlockDriverState *bs)void bdrv_close_all (void ) {assert (job_next (NULL ) ==NULL ); +assert (qemu_in_main_thread ());/* Drop references from requests still in flight, such as canceled block * jobs whose AIO context has not been polled yet */
@@ -5156,11 +5206,15 @@ out:int bdrv_replace_node (BlockDriverState *from,BlockDriverState *to,Error **errp) { +assert (qemu_in_main_thread ()); +return bdrv_replace_node_common (from, to, true, false, errp); }int bdrv_drop_filter (BlockDriverState *bs,Error **errp) { +assert (qemu_in_main_thread ()); +return bdrv_replace_node_common (bs,bdrv_filter_or_cow_bs (bs), true, true, errp); }
@@ -5183,6 +5237,8 @@ int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,int ret;Transaction *tran =tran_new (); +assert (qemu_in_main_thread ()); +assert (!bs_new->backing); ret = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
@@ -5216,6 +5272,8 @@ int bdrv_replace_child_bs(BdrvChild *child, BlockDriverState *new_bs,g_autoptr (GSList) refresh_list =NULL ;BlockDriverState *old_bs = child->bs; +assert (qemu_in_main_thread ()); +bdrv_ref (old_bs);bdrv_drained_begin (old_bs);bdrv_drained_begin (new_bs);
@@ -5287,6 +5345,8 @@ BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *options, node_name =qdict_get_try_str (options,"node-name" ); +assert (qemu_in_main_thread ()); + new_node_bs =bdrv_new_open_driver_opts (drv, node_name, options, flags, errp); options =NULL ;/* bdrv_new_open_driver() eats options */
@@ -5347,6 +5407,8 @@ int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,BlockDriver *drv = bs->drv;int ret; +assert (qemu_in_main_thread ()); +if (!drv) {return -ENOMEDIUM ; }
@@ -5388,6 +5450,9 @@ int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,BlockDriverState *bdrv_find_overlay (BlockDriverState *active,BlockDriverState *bs) { + +assert (qemu_in_main_thread ()); + bs =bdrv_skip_filters (bs); active =bdrv_skip_filters (active);
@@ -5405,6 +5470,8 @@ BlockDriverState *bdrv_find_overlay(BlockDriverState *active,/* Given a BDS, searches for the base layer. */ BlockDriverState *bdrv_find_base (BlockDriverState *bs) { +assert (qemu_in_main_thread ()); +return bdrv_find_overlay (bs,NULL ); }
@@ -5419,6 +5486,8 @@ bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,BlockDriverState *i;BdrvChild *child; +assert (qemu_in_main_thread ()); +for (i = bs; i != base; i =child_bs (child)) { child =bdrv_filter_or_cow_child (i);
@@ -5445,6 +5514,8 @@ int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,BlockDriverState *i;BdrvChild *child; +assert (qemu_in_main_thread ()); +if (bdrv_is_backing_chain_frozen (bs, base, errp)) {return -EPERM ; }
@@ -5479,6 +5550,8 @@ void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)BlockDriverState *i;BdrvChild *child; +assert (qemu_in_main_thread ()); +for (i = bs; i != base; i =child_bs (child)) { child =bdrv_filter_or_cow_child (i);if (child) {
@@ -5528,6 +5601,8 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,g_autoptr (GSList) updated_children =NULL ;GSList *p; +assert (qemu_in_main_thread ()); +bdrv_ref (top);bdrv_subtree_drained_begin (top);
@@ -5789,6 +5864,8 @@ void bdrv_iterate_format(void (*it)(void *opaque, const char *name),int i;const char **formats =NULL ; +assert (qemu_in_main_thread ()); + QLIST_FOREACH(drv, &bdrv_drivers, list) {if (drv->format_name) {bool found = false;
@@ -5847,6 +5924,7 @@ BlockDriverState *bdrv_find_node(const char *node_name)BlockDriverState *bs;assert (node_name); +assert (qemu_in_main_thread ()); QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {if (!strcmp (node_name, bs->node_name)) {
@@ -5863,6 +5941,8 @@ BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,BlockDeviceInfoList *list;BlockDriverState *bs; +assert (qemu_in_main_thread ()); + list =NULL ; QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {BlockDeviceInfo *info =bdrv_block_device_info (NULL , bs, flat, errp);
@@ -5968,6 +6048,8 @@ XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)BdrvChild *child;XDbgBlockGraphConstructor *gr =xdbg_graph_new (); +assert (qemu_in_main_thread ()); +for (blk =blk_all_next (NULL ); blk; blk =blk_all_next (blk)) {char *allocated_name =NULL ;const char *name =blk_name (blk);
@@ -6011,6 +6093,8 @@ BlockDriverState *bdrv_lookup_bs(const char *device,BlockBackend *blk;BlockDriverState *bs; +assert (qemu_in_main_thread ()); +if (device) { blk =blk_by_name (device);
@@ -6042,6 +6126,9 @@ BlockDriverState *bdrv_lookup_bs(const char *device,* return false. If either argument is NULL, return false. */ bool bdrv_chain_contains (BlockDriverState *top,BlockDriverState *base) { + +assert (qemu_in_main_thread ()); +while (top && top != base) { top =bdrv_filter_or_cow_bs (top); }
@@ -6051,6 +6138,7 @@ bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)BlockDriverState *bdrv_next_node (BlockDriverState *bs) { +assert (qemu_in_main_thread ());if (!bs) {return QTAILQ_FIRST (&graph_bdrv_states); }
@@ -6059,6 +6147,7 @@ BlockDriverState *bdrv_next_node(BlockDriverState *bs)BlockDriverState *bdrv_next_all_states (BlockDriverState *bs) { +assert (qemu_in_main_thread ());if (!bs) {return QTAILQ_FIRST (&all_bdrv_states); }
@@ -6105,17 +6194,20 @@ const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)int bdrv_get_flags (BlockDriverState *bs) { +assert (qemu_in_main_thread ());return bs->open_flags; }int bdrv_has_zero_init_1 (BlockDriverState *bs) { +assert (qemu_in_main_thread ());return 1 ; }int bdrv_has_zero_init (BlockDriverState *bs) {BlockDriverState *filtered; +assert (qemu_in_main_thread ());if (!bs->drv) {return 0 ;
@@ -6227,6 +6319,7 @@ static BlockDriverState *bdrv_find_debug_node(BlockDriverState *bs)int bdrv_debug_breakpoint (BlockDriverState *bs,const char *event,const char *tag) { +assert (qemu_in_main_thread ()); bs =bdrv_find_debug_node (bs);if (bs) {return bs->drv->bdrv_debug_breakpoint (bs, event, tag);
@@ -6237,6 +6330,7 @@ int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,int bdrv_debug_remove_breakpoint (BlockDriverState *bs,const char *tag) { +assert (qemu_in_main_thread ()); bs =bdrv_find_debug_node (bs);if (bs) {return bs->drv->bdrv_debug_remove_breakpoint (bs, tag);
@@ -6247,6 +6341,7 @@ int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)int bdrv_debug_resume (BlockDriverState *bs,const char *tag) { +assert (qemu_in_main_thread ());while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { bs =bdrv_primary_bs (bs); }
@@ -6260,6 +6355,7 @@ int bdrv_debug_resume(BlockDriverState *bs, const char *tag)bool bdrv_debug_is_suspended (BlockDriverState *bs,const char *tag) { +assert (qemu_in_main_thread ());while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { bs =bdrv_primary_bs (bs); }
@@ -6287,6 +6383,8 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,BlockDriverState *retval =NULL ;BlockDriverState *bs_below; +assert (qemu_in_main_thread ()); +if (!bs || !bs->drv || !backing_file) {return NULL ; }
@@ -6385,6 +6483,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,void bdrv_init (void ) { +assert (qemu_in_main_thread ());#ifdef CONFIG_BDRV_WHITELIST_TOOLS use_bdrv_whitelist =1 ;#endif
@@ -6393,6 +6492,7 @@ void bdrv_init(void)void bdrv_init_with_whitelist (void ) { +assert (qemu_in_main_thread ()); use_bdrv_whitelist =1 ;bdrv_init (); }
@@ -6477,6 +6577,8 @@ void bdrv_invalidate_cache_all(Error **errp)BlockDriverState *bs;BdrvNextIterator it; +assert (qemu_in_main_thread ()); +for (bs =bdrv_first (&it); bs; bs =bdrv_next (&it)) {AioContext *aio_context =bdrv_get_aio_context (bs);int ret;
@@ -6576,6 +6678,8 @@ int bdrv_inactivate_all(void)int ret =0 ;GSList *aio_ctxs =NULL , *ctx; +assert (qemu_in_main_thread ()); +for (bs =bdrv_first (&it); bs; bs =bdrv_next (&it)) {AioContext *aio_context =bdrv_get_aio_context (bs);
@@ -6653,6 +6757,7 @@ void bdrv_eject(BlockDriverState *bs, bool eject_flag)void bdrv_lock_medium (BlockDriverState *bs,bool locked) {BlockDriver *drv = bs->drv; +assert (qemu_in_main_thread ());trace_bdrv_lock_medium (bs, locked);
@@ -6664,6 +6769,7 @@ void bdrv_lock_medium(BlockDriverState *bs, bool locked)/* Get a reference to bs */ void bdrv_ref (BlockDriverState *bs) { +assert (qemu_in_main_thread ()); bs->refcnt++; }
@@ -6672,6 +6778,7 @@ void bdrv_ref(BlockDriverState *bs)* deleted. */ void bdrv_unref (BlockDriverState *bs) { +assert (qemu_in_main_thread ());if (!bs) {return ; }
@@ -6689,6 +6796,7 @@ struct BdrvOpBlocker {bool bdrv_op_is_blocked (BlockDriverState *bs,BlockOpType op,Error **errp) {BdrvOpBlocker *blocker; +assert (qemu_in_main_thread ());assert ((int ) op >=0 && op <BLOCK_OP_TYPE_MAX );if (!QLIST_EMPTY (&bs->op_blockers[op])) { blocker =QLIST_FIRST (&bs->op_blockers[op]);
@@ -6703,6 +6811,7 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)void bdrv_op_block (BlockDriverState *bs,BlockOpType op,Error *reason) {BdrvOpBlocker *blocker; +assert (qemu_in_main_thread ());assert ((int ) op >=0 && op <BLOCK_OP_TYPE_MAX ); blocker =g_new0 (BdrvOpBlocker,1 );
@@ -6713,6 +6822,7 @@ void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)void bdrv_op_unblock (BlockDriverState *bs,BlockOpType op,Error *reason) {BdrvOpBlocker *blocker, *next; +assert (qemu_in_main_thread ());assert ((int ) op >=0 && op <BLOCK_OP_TYPE_MAX ); QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {if (blocker->reason == reason) {
@@ -6725,6 +6835,7 @@ void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)void bdrv_op_block_all (BlockDriverState *bs,Error *reason) {int i; +assert (qemu_in_main_thread ());for (i =0 ; i <BLOCK_OP_TYPE_MAX ; i++) {bdrv_op_block (bs, i, reason); }
@@ -6733,6 +6844,7 @@ void bdrv_op_block_all(BlockDriverState *bs, Error *reason)void bdrv_op_unblock_all (BlockDriverState *bs,Error *reason) {int i; +assert (qemu_in_main_thread ());for (i =0 ; i <BLOCK_OP_TYPE_MAX ; i++) {bdrv_op_unblock (bs, i, reason); }
@@ -6741,7 +6853,7 @@ void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)bool bdrv_op_blocker_is_empty (BlockDriverState *bs) {int i; - +assert (qemu_in_main_thread ());for (i =0 ; i <BLOCK_OP_TYPE_MAX ; i++) {if (!QLIST_EMPTY (&bs->op_blockers[i])) {return false;
@@ -6763,6 +6875,8 @@ void bdrv_img_create(const char *filename, const char *fmt,Error *local_err =NULL ;int ret =0 ; +assert (qemu_in_main_thread ()); +/* Find driver and parse its options */ drv =bdrv_find_format (fmt);if (!drv) {
@@ -7179,6 +7293,7 @@ static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx,bool bdrv_child_can_set_aio_context (BdrvChild *c,AioContext *ctx,GSList **ignore,Error **errp) { +assert (qemu_in_main_thread ());if (g_slist_find (*ignore, c)) {return true; }
@@ -7197,6 +7312,8 @@ bool bdrv_can_set_aio_context(BlockDriverState *bs, AioContext *ctx,return true; } +assert (qemu_in_main_thread ()); + QLIST_FOREACH(c, &bs->parents, next_parent) {if (!bdrv_parent_can_set_aio_context (c, ctx, ignore, errp)) {return false;
@@ -7217,6 +7334,8 @@ int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,GSList *ignore;bool ret; +assert (qemu_in_main_thread ()); + ignore = ignore_child ?g_slist_prepend (NULL , ignore_child) :NULL ; ret =bdrv_can_set_aio_context (bs, ctx, &ignore, errp);g_slist_free (ignore);
@@ -7235,6 +7354,7 @@ int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,int bdrv_try_set_aio_context (BlockDriverState *bs,AioContext *ctx,Error **errp) { +assert (qemu_in_main_thread ());return bdrv_child_try_set_aio_context (bs, ctx,NULL , errp); }
@@ -7248,6 +7368,7 @@ void bdrv_add_aio_context_notifier(BlockDriverState *bs, .detach_aio_context = detach_aio_context, .opaque = opaque }; +assert (qemu_in_main_thread ());QLIST_INSERT_HEAD (&bs->aio_notifiers, ban, list); }
@@ -7259,6 +7380,7 @@ void bdrv_remove_aio_context_notifier(BlockDriverState *bs, void *opaque) {BdrvAioNotifier *ban, *ban_next; +assert (qemu_in_main_thread ()); QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { if (ban->attached_aio_context == attached_aio_context &&
@@ -7283,6 +7405,7 @@ int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,bool force, Error **errp) { +assert (qemu_in_main_thread ());if (!bs->drv) {error_setg (errp,"Node is ejected" );return -ENOMEDIUM ;
@@ -7353,6 +7476,8 @@ BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,BlockDriverState *to_replace_bs =bdrv_find_node (node_name);AioContext *aio_context; +assert (qemu_in_main_thread ()); +if (!to_replace_bs) {error_setg (errp,"Failed to find node with node-name='%s'" , node_name);return NULL ;
@@ -7514,6 +7639,8 @@ void bdrv_refresh_filename(BlockDriverState *bs)bool generate_json_filename;/* Whether our default implementation should fill exact_filename (false) or not (true) */ +assert (qemu_in_main_thread ()); +if (!drv) {return ; }
@@ -7636,6 +7763,8 @@ char *bdrv_dirname(BlockDriverState *bs, Error **errp)BlockDriver *drv = bs->drv;BlockDriverState *child_bs; +assert (qemu_in_main_thread ()); +if (!drv) {error_setg (errp,"Node '%s' is ejected" , bs->node_name);return NULL ;
@@ -7667,7 +7796,7 @@ char *bdrv_dirname(BlockDriverState *bs, Error **errp)void bdrv_add_child (BlockDriverState *parent_bs,BlockDriverState *child_bs,Error **errp) { - +assert (qemu_in_main_thread ());if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {error_setg (errp,"The node %s does not support adding a child" ,bdrv_get_device_or_node_name (parent_bs));
@@ -7687,6 +7816,7 @@ void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp) {BdrvChild *tmp; +assert (qemu_in_main_thread ());if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {error_setg (errp,"The node %s does not support removing a child" ,bdrv_get_device_or_node_name (parent_bs));
@@ -7714,6 +7844,7 @@ int bdrv_make_empty(BdrvChild *c, Error **errp)BlockDriver *drv = c->bs->drv;int ret; +assert (qemu_in_main_thread ());assert (c->perm & (BLK_PERM_WRITE |BLK_PERM_WRITE_UNCHANGED ));if (!drv->bdrv_make_empty) {
block/commit.c +2 -0
@@ -433,6 +433,8 @@ int bdrv_commit(BlockDriverState *bs) QEMU_AUTO_VFREE uint8_t *buf = NULL;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); +if (!drv)return -ENOMEDIUM ;
block/io.c +14 -0
@@ -164,6 +164,8 @@ void bdrv_refresh_limits(BlockDriverState *bs, Transaction *tran, Error **errp)BdrvChild *c;bool have_limits; +assert (qemu_in_main_thread ()); +if (tran) {BdrvRefreshLimitsState *s =g_new (BdrvRefreshLimitsState,1 ); *s = (BdrvRefreshLimitsState ) {
@@ -612,6 +614,7 @@ static bool bdrv_drain_all_poll(void) {BlockDriverState *bs =NULL ;bool result = false; +assert (qemu_in_main_thread ());/* bdrv_drain_poll() can't make changes to the graph and we are holding the * main AioContext lock, so iterating bdrv_next_all_states() is safe. */
@@ -640,6 +643,7 @@ static bool bdrv_drain_all_poll(void)void bdrv_drain_all_begin (void ) {BlockDriverState *bs =NULL ; +assert (qemu_in_main_thread ());if (qemu_in_coroutine ()) {bdrv_co_yield_to_drain (NULL , true, false,NULL , true, true,NULL );
@@ -696,6 +700,7 @@ void bdrv_drain_all_end(void) {BlockDriverState *bs =NULL ;int drained_end_counter =0 ; +assert (qemu_in_main_thread ());/* * bdrv queue is managed by record/replay,
@@ -723,6 +728,7 @@ void bdrv_drain_all_end(void)void bdrv_drain_all (void ) { +assert (qemu_in_main_thread ());bdrv_drain_all_begin ();bdrv_drain_all_end (); }
@@ -1059,6 +1065,8 @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)int64_t target_size, bytes, offset =0 ;BlockDriverState *bs = child->bs; +assert (qemu_in_main_thread ()); + target_size =bdrv_getlength (bs);if (target_size <0 ) {return target_size;
@@ -2345,6 +2353,8 @@ int bdrv_flush_all(void)BlockDriverState *bs =NULL ;int result =0 ; +assert (qemu_in_main_thread ()); +/* * bdrv queue is managed by record/replay, * creating new flush request for stopping
@@ -2898,6 +2908,7 @@ int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,void bdrv_aio_cancel (BlockAIOCB *acb) { +assert (qemu_in_main_thread ());qemu_aio_ref (acb);bdrv_aio_cancel_async (acb);while (acb->refcnt >1 ) {
@@ -3292,6 +3303,7 @@ void bdrv_register_buf(BlockDriverState *bs, void *host, size_t size) {BdrvChild *child; +assert (qemu_in_main_thread ());if (bs->drv && bs->drv->bdrv_register_buf) { bs->drv->bdrv_register_buf (bs, host, size); }
@@ -3304,6 +3316,7 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host) {BdrvChild *child; +assert (qemu_in_main_thread ());if (bs->drv && bs->drv->bdrv_unregister_buf) { bs->drv->bdrv_unregister_buf (bs, host); }
@@ -3575,6 +3588,7 @@ out:void bdrv_cancel_in_flight (BlockDriverState *bs) { +assert (qemu_in_main_thread ());if (!bs || !bs->drv) {return ; }
blockdev.c +1 -0
@@ -648,6 +648,7 @@ void blockdev_close_all_bdrv_states(void)/* Iterates over the list of monitor-owned BlockDriverStates */ BlockDriverState *bdrv_next_monitor_owned (BlockDriverState *bs) { +assert (qemu_in_main_thread ());return bs ?QTAILQ_NEXT (bs, monitor_list) :QTAILQ_FIRST (&monitor_bdrv_states); }
Signature · 1 line
2.27.0
Re: [PATCH v5 03/31] assertions for block global state API
Quoted 17 lines · Emanuele Giuseppe Esposito
All the global state (GS) API functions will check that
qemu_in_main_thread()returns true. If not, it means that the safety of BQL cannot be guaranteed, and they need to be moved to I/O.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++++- block/commit.c | 2 + block/io.c | 14 +++++ blockdev.c | 1 + 4 files changed, 150 insertions(+), 2 deletions(-)block.c +0
-0
[...]
block.c BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, · line 995
Quoted 5 lines
block.c +1
-0@@ -975,6 +992,7 @@ BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, {int score_max =0 , score;BlockDriver *drv =NULL , *d; +assert (qemu_in_main_thread ());
While reviewing patch 13 and the find_image_format() it touches, I noticed that this function is called from raw_co_pwritev() to prevent the guest from writing image headers into probed-raw images.
Reproducible like so:
$ qemu-img create -f raw test.img 64M Formatting 'test.img', fmt=raw size=67108864 $ ./qemu-system-x86_64 \ -object iothread,id=iothr0 \ -drive if=none,id=drv0,file=test.img \ -device virtio-blk,drive=drv0,iothread=iothr0 \ -monitor stdio WARNING: Image format was not specified for 'test.img' and probing guessed raw. Automatically detecting the format is dangerous for raw images, write operations on block 0 will be restricted. Specify the 'raw' format explicitly to remove the restrictions. QEMU 6.1.93 monitor - type 'help' for more information (qemu) qemu-io drv0 "write 0 512" qemu-system-x86_64: ../block.c:1004: bdrv_probe_all: Assertion `qemu_in_main_thread()' failed. [1] 108256 IOT instruction (core dumped) ./qemu-system-x86_64 -object iothread,id=iothr0 -drive -device -monitor
I don’t think there’s any reason not to classify bdrv_probe_all() as an I/O function then, is there?
(Also, bdrv_probe_all() is part of block_int.h, so this assertion would actually belong in patch 8, not here.)
Hanna
Quoted 3 lines
block.c +0
-0QLIST_FOREACH(d, &bdrv_drivers, list) {if (d->bdrv_probe) {
PATCH v5 4/31 include/sysemu/block-backend: split header into I/O and global state (GS) API
In reply to Emanuele Giuseppe EspositoSimilarly to the previous patches, split block-backend.h in block-backend-io.h and block-backend-global-state.h
In addition, remove "block/block.h" include as it seems it is not necessary anymore, together with "qemu/iov.h"
block-backend-common.h contains the structures shared between the two headers, and the functions that can't be categorized as I/O or global state.
Assertions are added in the next patch.
--- include/sysemu/block-backend-common.h | 84 ++++++ include/sysemu/block-backend-global-state.h | 121 +++++++++ include/sysemu/block-backend-io.h | 139 ++++++++++ include/sysemu/block-backend.h | 269 +------------------- block/block-backend.c | 9 +- 5 files changed, 353 insertions(+), 269 deletions(-) create mode 100644 include/sysemu/block-backend-common.h create mode 100644 include/sysemu/block-backend-global-state.h create mode 100644 include/sysemu/block-backend-io.h
include/sysemu/block-backend-common.h new file +84 -0
@@ -0,0 +1,84 @@ +/* +* QEMU Block backends +* +* Copyright (C) 2014-2016 Red Hat, Inc. +* +* Authors: +* Markus Armbruster <[email protected]>, +* +* This work is licensed under the terms of the GNU LGPL, version 2.1 +* or later. See the COPYING.LIB file in the top-level directory. +*/ + +#ifndef BLOCK_BACKEND_COMMON_H +#define BLOCK_BACKEND_COMMON_H + +#include "qemu/iov.h" +#include "block/throttle-groups.h" + +/* +* TODO Have to include block/block.h for a bunch of block layer +* types. Unfortunately, this pulls in the whole BlockDriverState +* API, which we don't want used by many BlockBackend users. Some of +* the types belong here, and the rest should be split into a common +* header and one for the BlockDriverState API. +*/ +#include "block/block.h" + +/* Callbacks for block device models */ +typedef struct BlockDevOps { +/* +* Runs when virtual media changed (monitor commands eject, change) +* Argument load is true on load and false on eject. +* Beware: doesn't run when a host device's physical media +* changes. Sure would be useful if it did. +* Device models with removable media must implement this callback. +*/ +void (*change_media_cb)(void *opaque,bool load,Error **errp); +/* +* Runs when an eject request is issued from the monitor, the tray +* is closed, and the medium is locked. +* Device models that do not implement is_medium_locked will not need +* this callback. Device models that can lock the medium or tray might +* want to implement the callback and unlock the tray when "force" is +* true, even if they do not support eject requests. +*/ +void (*eject_request_cb)(void *opaque,bool force); +/* +* Is the virtual tray open? +* Device models implement this only when the device has a tray. +*/ +bool (*is_tray_open)(void *opaque); +/* +* Is the virtual medium locked into the device? +* Device models implement this only when device has such a lock. +*/ +bool (*is_medium_locked)(void *opaque); +/* +* Runs when the size changed (e.g. monitor command block_resize) +*/ +void (*resize_cb)(void *opaque); +/* +* Runs when the backend receives a drain request. +*/ +void (*drained_begin)(void *opaque); +/* +* Runs when the backend's last drain request ends. +*/ +void (*drained_end)(void *opaque); +/* +* Is the device still busy? +*/ +bool (*drained_poll)(void *opaque); +}BlockDevOps ; + +/* +* This struct is embedded in (the private) BlockBackend struct and contains +* fields that must be public. This is in particular for QLIST_ENTRY() and +* friends so that BlockBackends can be kept in lists outside block-backend.c +*/ +typedef struct BlockBackendPublic { +ThrottleGroupMember throttle_group_member; +}BlockBackendPublic ; + +#endif /* BLOCK_BACKEND_COMMON_H */
include/sysemu/block-backend-global-state.h new file +121 -0
121 lines not on this page · raw message
include/sysemu/block-backend-io.h new file +139 -0
139 lines not on this page · raw message
include/sysemu/block-backend.h +3 -266
275 lines not on this page · raw message
block/block-backend.c +6 -3
@@ -79,6 +79,7 @@ struct BlockBackend {bool allow_aio_context_change;bool allow_write_beyond_eof; +/* Protected by BQL lock */ NotifierList remove_bs_notifiers, insert_bs_notifiers; QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
@@ -111,12 +112,14 @@ static const AIOCBInfo block_backend_aiocb_info = {static void drive_info_del (DriveInfo *dinfo);static BlockBackend *bdrv_first_blk (BlockDriverState *bs); -/* All BlockBackends */ +/* All BlockBackends. Protected by BQL lock. */ static QTAILQ_HEAD(, BlockBackend) block_backends =QTAILQ_HEAD_INITIALIZER (block_backends); -/* All BlockBackends referenced by the monitor and which are iterated through by -* blk_next() */ +/* +* All BlockBackends referenced by the monitor and which are iterated through by +* blk_next(). Protected by BQL lock. +*/ static QTAILQ_HEAD(, BlockBackend) monitor_block_backends =QTAILQ_HEAD_INITIALIZER (monitor_block_backends);
Signature · 1 line
2.27.0
Re: [PATCH v5 04/31] include/sysemu/block-backend: split header into I/O and global state (GS) API
Quoted 23 lines · Emanuele Giuseppe Esposito
Similarly to the previous patches, split
block-backend.hinblock-backend-io.handblock-backend-global-state.hIn addition, remove "
block/block.h" include as it seems it is not necessary anymore, together with "qemu/iov.h"
block-backend-common.hcontains the structures shared between the two headers, and the functions that can't be categorized as I/O or global state.Assertions are added in the next patch.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- include/sysemu/block-backend-common.h | 84 ++++++ include/sysemu/block-backend-global-state.h | 121 +++++++++ include/sysemu/block-backend-io.h | 139 ++++++++++ include/sysemu/block-backend.h | 269 +------------------- block/block-backend.c | 9 +- 5 files changed, 353 insertions(+), 269 deletions(-)create mode 100644
include/sysemu/block-backend-common.hcreate mode 100644include/sysemu/block-backend-global-state.hcreate mode 100644include/sysemu/block-backend-io.h
[...]
Quoted 5 lines
include/sysemu/block-backend-global-state.h new file +0
-0
[...]
Quoted 1 line
+int
blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
I don’t quite follow what makes blk_ioctl() a GS function. (It’s possible that I forgot something about this from v4, though, and can’t find it anymore...)
I suppose it can be said that in the context of the block layer, ioctl functions are generally used outside of I/O threads as something that kind of affects the global data state, but... bdrv_co_ioctl() is in block-io.h, and internally we definitely do use ioctl in I/O threads (various uses in file-posix.c, e.g. to zero out areas). I also don’t understand why blk_ioctl() is GS, and blk_aio_ioctl() is I/O.
And if you have a virtio-scsi device in an iothread, and then create a scsi-generic device on it, will bdrv_co_ioctl() not run in the I/O thread still...? Hm, testing (on patch 6), it appears that not – I think that’s because it mostly uses blk_aio_ioctl(), apart from *_realize() and scsi_SG_IO_FROM_DEV() (whatever that is; and this makes me a bit cautious, too). Still, I’m not quite sure how it’s more global state than e.g. writing zeroes or, well, blk_aio_ioctl().
However, testing brought some other problems to light:
$ ls /dev/sg? /dev/sg0
$ sudo modprobe scsi_debug max_luns=1 num_tgts=1 add_host=1
$ ls /dev/sg? /dev/sg0 /dev/sg1
$ ./qemu-system-x86_64 \ -object iothread,id=foo \ -device virtio-scsi,iothread=foo \ -blockdev host_device,filename=/dev/sg1,node-name=bar \ -device scsi-generic,drive=bar qemu-system-x86_64: ../block/block-backend.c:2038: blk_set_guest_block_size: Assertion `qemu_in_main_thread()' failed. [1] 121353 IOT instruction (core dumped) ./qemu-system-x86_64 -object iothread,id=foo -device virtio-scsi,iothread=foo
And:
$ ./qemu-system-x86_64 \ -object iothread,id=foo \ -device virtio-scsi,iothread=foo \ -blockdev null-co,read-zeroes=true,node-name=bar \ -device scsi-hd,drive=bar \ -cdrom ~/tmp/arch.iso \ -enable-kvm \ -m 1g qemu-system-x86_64: ../block/block-backend.c:1918: blk_enable_write_cache: Assertion `qemu_in_main_thread()' failed. [1] 127203 IOT instruction (core dumped) ./qemu-system-x86_64 -object iothread,id=foo -device virtio-scsi,iothread=foo
If I boot from a CD under virtio-scsi (in an iothread), I also get an error for blk_lock_medium(), and if I eject such a CD, for blk_eject() and blk_get_attached_dev_id() (called from blk_eject()).
It appears like scsi_disk_emulate_command() is always run in the BB’s AioContext, and so everything it (indirectly) calls cannot assume to be in the main thread. As for blk_set_guest_block_size(), that one’s called from scsi-generic’s scsi_read_complete().
Hanna
PATCH v5 5/31 block-backend: special comments for blk_set/get_perm due to fuse
In reply to Emanuele Giuseppe EspositoFuse logic can be classified as I/O, so there is no BQL held during its execution. And yet, it uses blk_{get/set}_perm functions, that are classified as BQL and clearly require the BQL lock. Since there is no easy solution for this, add a couple of TODOs and FIXME in the relevant sections of the code.
--- block/block-backend.c | 10 ++++++++++ block/export/fuse.c | 16 ++++++++++++++-- 2 files changed, 24 insertions(+), 2 deletions(-)
block/block-backend.c +10 -0
@@ -888,6 +888,11 @@ int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm, Error **errp) {int ret; +/* +* FIXME: blk_{get/set}_perm should be always called under +* BQL, but it is not the case right now (see block/export/fuse.c) +*/ +/* assert(qemu_in_main_thread()); */ if (blk->root && !blk->disable_perm) { ret =bdrv_child_try_set_perm (blk->root, perm, shared_perm, errp);
@@ -904,6 +909,11 @@ int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,void blk_get_perm (BlockBackend *blk,uint64_t *perm,uint64_t *shared_perm) { +/* +* FIXME: blk_{get/set}_perm should be always called under +* BQL, but it is not the case right now (see block/export/fuse.c) +*/ +/* assert(qemu_in_main_thread()); */ *perm = blk->perm; *shared_perm = blk->shared_perm; }
block/export/fuse.c +14 -2
@@ -89,7 +89,10 @@ static int fuse_export_create(BlockExport *blk_exp,/* For growable exports, take the RESIZE permission */ if (args->growable) {uint64_t blk_perm, blk_shared_perm; - +/* +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/ blk_get_perm (exp->common.blk, &blk_perm, &blk_shared_perm); ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE,
@@ -400,6 +403,11 @@ static int fuse_do_truncate(const FuseExport *exp, int64_t size,/* Growable exports have a permanent RESIZE permission */ if (!exp->growable) { + +/* +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/ blk_get_perm (exp->common.blk, &blk_perm, &blk_shared_perm); ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE,
@@ -413,7 +421,11 @@ static int fuse_do_truncate(const FuseExport *exp, int64_t size, truncate_flags, NULL);if (!exp->growable) { -/* Must succeed, because we are only giving up the RESIZE permission */ +/* +* Must succeed, because we are only giving up the RESIZE permission. +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/ blk_set_perm (exp->common.blk, blk_perm, blk_shared_perm, &error_abort); }
Signature · 1 line
2.27.0
Re: [PATCH v5 05/31] block-backend: special comments for blk_set/get_perm due to fuse
Quoted 6 lines · Emanuele Giuseppe Esposito
Fuse logic can be classified as I/O, so there is no BQL held during its execution. And yet, it uses blk_{get/set}_perm functions, that are classified as BQL and clearly require the BQL lock. Since there is no easy solution for this, add a couple of TODOs and FIXME in the relevant sections of the code.
Well, the problem goes deeper, because we still consider them GS functions. So it’s fine for the permission function raw_handle_perm_lock() to call bdrv_get_flags(), which is a GS function, and then you still get:
qemu-storage-daemon: ../block.c:6195: bdrv_get_flags: Assertion `qemu_in_main_thread()' failed.
It looks like in this case making bdrv_get_flags() not a GS function would be feasible and might solve the problem, but I guess we should instead think about adding something like
if (!exp->growable && !qemu_in_main_thread()) {
/* Changing permissions like below only works in the main thread */ return -EPERM;
}
to fuse_do_truncate().
Ideally, to make up for this, we should probably take the RESIZE permission in fuse_export_create() for writable exports in iothreads.
Quoted 39 lines
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block/block-backend.c | 10 ++++++++++ block/export/fuse.c | 16 ++++++++++++++-- 2 files changed, 24 insertions(+), 2 deletions(-)block/block-backend.c +10
-0@@ -888,6 +888,11 @@ int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm, Error **errp) {int ret; +/* +* FIXME: blk_{get/set}_perm should be always called under +* BQL, but it is not the case right now (see block/export/fuse.c) +*/ +/* assert(qemu_in_main_thread()); */ if (blk->root && !blk->disable_perm) { ret =bdrv_child_try_set_perm (blk->root, perm, shared_perm, errp);@@ -904,6 +909,11 @@ int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,void blk_get_perm (BlockBackend *blk,uint64_t *perm,uint64_t *shared_perm) { +/* +* FIXME: blk_{get/set}_perm should be always called under +* BQL, but it is not the case right now (see block/export/fuse.c) +*/ +/* assert(qemu_in_main_thread()); */ *perm = blk->perm; *shared_perm = blk->shared_perm; }block/export/fuse.c +0
-0
block/export/fuse.c static int fuse_export_create(BlockExport *blk_exp, · line 95
Quoted 8 lines
block/export/fuse.c +4
-1@@ -89,7 +89,10 @@ static int fuse_export_create(BlockExport *blk_exp,/* For growable exports, take the RESIZE permission */ if (args->growable) {uint64_t blk_perm, blk_shared_perm; - +/* +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/
I believe we are, BlockExportDriver.create() is called by blk_exp_add(), which looks very much like it runs in the main thread (calling bdrv_lookup_bs(), bdrv_try_set_aio_context(), blk_new(), and whatnot).
Hanna
Quoted 28 lines
block/export/fuse.c +10
-1blk_get_perm (exp->common.blk, &blk_perm, &blk_shared_perm); ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE,@@ -400,6 +403,11 @@ static int fuse_do_truncate(const FuseExport *exp, int64_t size,/* Growable exports have a permanent RESIZE permission */ if (!exp->growable) { + +/* +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/ blk_get_perm (exp->common.blk, &blk_perm, &blk_shared_perm); ret = blk_set_perm(exp->common.blk, blk_perm | BLK_PERM_RESIZE,@@ -413,7 +421,11 @@ static int fuse_do_truncate(const FuseExport *exp, int64_t size, truncate_flags, NULL);if (!exp->growable) { -/* Must succeed, because we are only giving up the RESIZE permission */ +/* +* Must succeed, because we are only giving up the RESIZE permission. +* FIXME: blk_{get/set}_perm should not be here, as permissions +* should be modified only under BQL and here we are not! +*/ blk_set_perm (exp->common.blk, blk_perm, blk_shared_perm, &error_abort); }
Re: [PATCH v5 05/31] block-backend: special comments for blk_set/get_perm due to fuse
Quoted 14 lines · Hanna Reitz
Quoted 6 lines · Emanuele Giuseppe Esposito
Fuse logic can be classified as I/O, so there is no BQL held during its execution. And yet, it uses blk_{get/set}_perm functions, that are classified as BQL and clearly require the BQL lock. Since there is no easy solution for this, add a couple of TODOs and FIXME in the relevant sections of the code.
Well, the problem goes deeper, because we still consider them GS functions. So it’s fine for the permission function
raw_handle_perm_lock()to callbdrv_get_flags(), which is a GS function, and then you still get:qemu-storage-daemon:
../block.c:6195:bdrv_get_flags: Assertion `qemu_in_main_thread()' failed.It looks like in this case making
bdrv_get_flags()not a GS function would be feasible and might solve the problem, but I guess we should instead think about adding something like
Quoted 8 lines
if (!exp->growable && !qemu_in_main_thread()) {
/* Changing permissions like below only works in the main thread */ return-EPERM;
}to
fuse_do_truncate().Ideally, to make up for this, we should probably take the RESIZE permission in
fuse_export_create()for writable exports in iothreads.
I think I got it. I will send the RESIZE permission fix in a separate patch.
Thank you,
Emanuele
Re: [PATCH v5 05/31] block-backend: special comments for blk_set/get_perm due to fuse
Quoted 11 lines · Emanuele Giuseppe Esposito
Quoted 8 lines · Hanna Reitz
Quoted 6 lines · Emanuele Giuseppe Esposito
Fuse logic can be classified as I/O, so there is no BQL held during its execution. And yet, it uses blk_{get/set}_perm functions, that are classified as BQL and clearly require the BQL lock. Since there is no easy solution for this, add a couple of TODOs and FIXME in the relevant sections of the code.
Quoted 3 lines
Quoted 3 lines
Well, the problem goes deeper, because we still consider them GS functions. So it’s fine for the permission function
raw_handle_perm_lock()to callbdrv_get_flags(), which is a GS function, and then you still get:qemu-storage-daemon:
../block.c:6195:bdrv_get_flags: Assertion `qemu_in_main_thread()' failed.
Wait... Now that I read it more carefully I am confused about this. I don't think the above has to do with fuse, right? Can you share the command that makes qemu-storage-daemon fail?
raw_handle_perm_lock() is currently called by these three callbacks:
.bdrv_check_perm = raw_check_perm,
.bdrv_set_perm = raw_set_perm,
.bdrv_abort_perm_update = raw_abort_perm_update,
all three function pointers are defined as GS functions. So I don't understand why is this failing.
Quoted 16 lines
Quoted 11 lines
It looks like in this case making
bdrv_get_flags()not a GS function would be feasible and might solve the problem, but I guess we should instead think about adding something likeif (!exp->growable && !qemu_in_main_thread()) {
/* Changing permissions like below only works in the main thread */ return-EPERM;
}to
fuse_do_truncate().Ideally, to make up for this, we should probably take the RESIZE permission in
fuse_export_create()for writable exports in iothreads.I think I got it. I will send the RESIZE permission fix in a separate patch.
Thank you,
Emanuele
Re: [PATCH v5 05/31] block-backend: special comments for blk_set/get_perm due to fuse
Quoted 14 lines · Emanuele Giuseppe Esposito
Quoted 11 lines · Emanuele Giuseppe Esposito
Quoted 8 lines · Hanna Reitz
Quoted 6 lines · Emanuele Giuseppe Esposito
Fuse logic can be classified as I/O, so there is no BQL held during its execution. And yet, it uses blk_{get/set}_perm functions, that are classified as BQL and clearly require the BQL lock. Since there is no easy solution for this, add a couple of TODOs and FIXME in the relevant sections of the code.
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
Well, the problem goes deeper, because we still consider them GS functions. So it’s fine for the permission function
raw_handle_perm_lock()to callbdrv_get_flags(), which is a GS function, and then you still get:qemu-storage-daemon:
../block.c:6195:bdrv_get_flags: Assertion `qemu_in_main_thread()' failed.Wait... Now that I read it more carefully I am confused about this. I don't think the above has to do with fuse, right?
It does, because the problem is that the FUSE export code (fuse_do_truncate()) calls a permission function (blk_set_perm()), and then we assume in those permission functions that they can call GS functions, like bdrv_get_flags() (called from raw_handle_perm_lock()). So in practice, the permission functions are still effectively GS functions, and just dropping the assertions from blk_set/get_perm() doesn’t really help.
(This is the state on this patch; patch 7 adds an assertion in bdrv_child_try_set_perm(), and so from then on, that assertion fails before the one in bdrv_get_flags() can.)
Quoted 1 line
Can you share the command that makes qemu-storage-daemon fail?
Sure:
$ touch /tmp/fuse-export
$ storage-daemon/qemu-storage-daemon \ --object iothread,id=iothr0 \ --blockdev file,node-name=node0,filename=/tmp/fuse-export \ --export fuse,id=exp0,node-name=node0,mountpoint=/tmp/fuse-export,iothread=iothr0,writable=true \ & [1] 96997
$ truncate /tmp/fuse-export -s 1M qemu-storage-daemon: ../block.c:6197: bdrv_get_flags: Assertion `qemu_in_main_thread()' failed. truncate: failed to truncate '/tmp/fuse-export' at 1048576 bytes: Software caused connection abort truncate: failed to close '/tmp/fuse-export': Transport endpoint is not connected [1] + 96997 IOT instruction (core dumped) storage-daemon/qemu-storage-daemon --object iothread,id=iothr0 --blockdev
$ fusermount -u /tmp/fuse-export
Relevant part of the stacktrace:
#5 0x00007f68322243a6 in __GI___assert_fail (assertion=assertion@entry=0x562380ca2f53 "qemu_in_main_thread()", file=file@entry=0x562380ca53cd "../block.c", line=line@entry=6197, function=function@entry=0x562380ca78e8 <__PRETTY_FUNCTION__.63> "bdrv_get_flags") at assert.c:101
#6 0x0000562380b64283 in bdrv_get_flags (bs=0x562382440680) at ../block.c:6197
#7 0x0000562380b68506 in bdrv_get_flags (bs=bs@entry=0x562382440680) at ../block.c:6199
#8 0x0000562380be6d18 in raw_handle_perm_lock (errp=0x7f68277103b0, new_shared=31, new_perm=11, op=RAW_PL_PREPARE, bs=0x562382440680) at ../block/file-posix.c:975
#9 raw_check_perm (bs=0x562382440680, perm=11, shared=31, errp=0x7f68277103b0) at ../block/file-posix.c:3172
#10 0x0000562380b66db5 in bdrv_drv_set_perm (errp=0x7f68277103b0, tran=0x7f68180038b0, shared_perm=31, perm=11, bs=0x562382440680) at ../block.c:2272
#11 bdrv_node_refresh_perm (errp=0x7f68277103b0, tran=0x7f68180038b0, q=0x0, bs=0x562382440680) at ../block.c:2441
#12 bdrv_list_refresh_perms (list=list@entry=0x56238243a1c0 = {...}, q=q@entry=0x0, tran=tran@entry=0x7f68180038b0, errp=errp@entry=0x7f68277103b0) at ../block.c:2479 #13 0x0000562380b67098 in bdrv_refresh_perms (bs=0x562382440680, errp=errp@entry=0x7f68277103b0) at ../block.c:2542
#14 0x0000562380b6727c in bdrv_child_try_set_perm (c=0x56238243cf70, perm=11, shared=31, errp=0x0) at ../block.c:2557
#15 0x0000562380b8632d in blk_set_perm (blk=0x56238243e7a0, perm=11, shared_perm=31, errp=errp@entry=0x0) at ../block/block-backend.c:890
#16 0x0000562380b57a7d in fuse_do_truncate (exp=exp@entry=0x56238243eb20, size=1048576, req_zero_write=req_zero_write@entry=true, prealloc=prealloc@entry=PREALLOC_MODE_OFF) at ../block/export/fuse.c:405 #17 0x0000562380b58121 in fuse_setattr (req=0x7f6818003800, inode=1, statbuf=0x7f68277104e0, to_set=8, fi=0x7f68277104b0) at ../block/export/fuse.c:476
Quoted 6 lines
raw_handle_perm_lock()is currently called by these three callbacks:
.bdrv_check_perm =raw_check_perm,
.bdrv_set_perm =raw_set_perm, .bdrv_abort_perm_update =raw_abort_perm_update,all three function pointers are defined as GS functions. So I don't understand why is this failing.
Because this patch explicitly allows I/O code to call blk_set/get_perm(). But as you rightly say, all permission functions are still classified as GS code, so we can’t allow it.
Hanna
Quoted 17 lines
Quoted 16 lines
Quoted 11 lines
It looks like in this case making
bdrv_get_flags()not a GS function would be feasible and might solve the problem, but I guess we should instead think about adding something likeif (!exp->growable && !qemu_in_main_thread()) {
/* Changing permissions like below only works in the main thread */ return-EPERM;
}to
fuse_do_truncate().Ideally, to make up for this, we should probably take the RESIZE permission in
fuse_export_create()for writable exports in iothreads.I think I got it. I will send the RESIZE permission fix in a separate patch.
Thank you,
Emanuele
PATCH v5 6/31 block/block-backend.c: assertions for block-backend
In reply to Emanuele Giuseppe EspositoAll the global state (GS) API functions will check that qemu_in_main_thread() returns true. If not, it means that the safety of BQL cannot be guaranteed, and they need to be moved to I/O.
--- block/block-backend.c | 83 ++++++++++++++++++++++++++++++++++++++++++ softmmu/qdev-monitor.c | 2 + 2 files changed, 85 insertions(+)
block/block-backend.c +83 -0
@@ -228,6 +228,7 @@ static void blk_root_activate(BdrvChild *child, Error **errp)void blk_set_force_allow_inactivate (BlockBackend *blk) { +assert (qemu_in_main_thread ()); blk->force_allow_inactivate = true; }
@@ -346,6 +347,8 @@ BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm) {BlockBackend *blk; +assert (qemu_in_main_thread ()); + blk =g_new0 (BlockBackend,1 ); blk->refcnt =1 ; blk->ctx = ctx;
@@ -383,6 +386,8 @@ BlockBackend *blk_new_with_bs(BlockDriverState *bs, uint64_t perm, {BlockBackend *blk =blk_new (bdrv_get_aio_context (bs), perm, shared_perm); +assert (qemu_in_main_thread ()); +if (blk_insert_bs (blk, bs, errp) <0 ) {blk_unref (blk);return NULL ;
@@ -411,6 +416,8 @@ BlockBackend *blk_new_open(const char *filename, const char *reference,uint64_t perm =0 ;uint64_t shared =BLK_PERM_ALL ; +assert (qemu_in_main_thread ()); +/* * blk_new_open() is mainly used in .bdrv_create implementations and the * tools where sharing isn't a major concern because the BDS stays private
@@ -488,6 +495,7 @@ static void drive_info_del(DriveInfo *dinfo)int blk_get_refcnt (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk ? blk->refcnt :0 ; }
@@ -498,6 +506,7 @@ int blk_get_refcnt(BlockBackend *blk)void blk_ref (BlockBackend *blk) {assert (blk->refcnt >0 ); +assert (qemu_in_main_thread ()); blk->refcnt++; }
@@ -508,6 +517,7 @@ void blk_ref(BlockBackend *blk)*/ void blk_unref (BlockBackend *blk) { +assert (qemu_in_main_thread ());if (blk) {assert (blk->refcnt >0 );if (blk->refcnt >1 ) {
@@ -528,6 +538,7 @@ void blk_unref(BlockBackend *blk)*/ BlockBackend *blk_all_next (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk ?QTAILQ_NEXT (blk, link) :QTAILQ_FIRST (&block_backends); }
@@ -536,6 +547,8 @@ void blk_remove_all_bs(void) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ()); +while ((blk =blk_all_next (blk)) !=NULL ) {AioContext *ctx =blk_get_aio_context (blk);
@@ -559,6 +572,7 @@ void blk_remove_all_bs(void)*/ BlockBackend *blk_next (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk ?QTAILQ_NEXT (blk, monitor_link) :QTAILQ_FIRST (&monitor_block_backends); }
@@ -625,6 +639,7 @@ static void bdrv_next_reset(BdrvNextIterator *it)BlockDriverState *bdrv_first (BdrvNextIterator *it) { +assert (qemu_in_main_thread ());bdrv_next_reset (it);return bdrv_next (it); }
@@ -662,6 +677,7 @@ bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp) {assert (!blk->name);assert (name && name[0 ]); +assert (qemu_in_main_thread ());if (!id_wellformed (name)) {error_setg (errp,"Invalid device name" );
@@ -689,6 +705,8 @@ bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp)*/ void monitor_remove_blk (BlockBackend *blk) { +assert (qemu_in_main_thread ()); +if (!blk->name) {return ; }
@@ -715,6 +733,7 @@ BlockBackend *blk_by_name(const char *name) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ());assert (name);while ((blk =blk_next (blk)) !=NULL ) {if (!strcmp (name, blk->name)) {
@@ -749,6 +768,7 @@ static BlockBackend *bdrv_first_blk(BlockDriverState *bs)*/ bool bdrv_has_blk (BlockDriverState *bs) { +assert (qemu_in_main_thread ());return bdrv_first_blk (bs) !=NULL ; }
@@ -759,6 +779,7 @@ bool bdrv_is_root_node(BlockDriverState *bs) {BdrvChild *c; +assert (qemu_in_main_thread ()); QLIST_FOREACH(c, &bs->parents, next_parent) {if (c->klass != &child_root) {return false;
@@ -808,6 +829,7 @@ BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)*/ BlockBackendPublic *blk_get_public (BlockBackend *blk) { +assert (qemu_in_main_thread ());return &blk->public; }
@@ -816,6 +838,7 @@ BlockBackendPublic *blk_get_public(BlockBackend *blk)*/ BlockBackend *blk_by_public (BlockBackendPublic *public) { +assert (qemu_in_main_thread ());return container_of (public, BlockBackend, public); }
@@ -828,6 +851,8 @@ void blk_remove_bs(BlockBackend *blk)BlockDriverState *bs;BdrvChild *root; +assert (qemu_in_main_thread ()); +notifier_list_notify (&blk->remove_bs_notifiers, blk);if (tgm->throttle_state) { bs =blk_bs (blk);
@@ -855,6 +880,7 @@ void blk_remove_bs(BlockBackend *blk)int blk_insert_bs (BlockBackend *blk,BlockDriverState *bs,Error **errp) {ThrottleGroupMember *tgm = &blk->public.throttle_group_member; +assert (qemu_in_main_thread ());bdrv_ref (bs); blk->root = bdrv_root_attach_child(bs, "root", &child_root, BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -878,6 +904,7 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)*/ int blk_replace_bs (BlockBackend *blk,BlockDriverState *new_bs,Error **errp) { +assert (qemu_in_main_thread ());return bdrv_replace_child_bs (blk->root, new_bs, errp); }
@@ -924,6 +951,7 @@ void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm)*/ int blk_attach_dev (BlockBackend *blk,DeviceState *dev) { +assert (qemu_in_main_thread ());if (blk->dev) {return -EBUSY ; }
@@ -949,6 +977,7 @@ int blk_attach_dev(BlockBackend *blk, DeviceState *dev)void blk_detach_dev (BlockBackend *blk,DeviceState *dev) {assert (blk->dev == dev); +assert (qemu_in_main_thread ()); blk->dev =NULL ; blk->dev_ops =NULL ; blk->dev_opaque =NULL ;
@@ -962,6 +991,7 @@ void blk_detach_dev(BlockBackend *blk, DeviceState *dev)*/ DeviceState *blk_get_attached_dev (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->dev; }
@@ -970,6 +1000,7 @@ DeviceState *blk_get_attached_dev(BlockBackend *blk)char *blk_get_attached_dev_id (BlockBackend *blk) {DeviceState *dev = blk->dev; +assert (qemu_in_main_thread ());if (!dev) {return g_strdup ("" );
@@ -990,6 +1021,8 @@ BlockBackend *blk_by_dev(void *dev) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ()); +assert (dev !=NULL );while ((blk =blk_all_next (blk)) !=NULL ) {if (blk->dev == dev) {
@@ -1007,6 +1040,7 @@ BlockBackend *blk_by_dev(void *dev)void blk_set_dev_ops (BlockBackend *blk,const BlockDevOps *ops,void *opaque) { +assert (qemu_in_main_thread ()); blk->dev_ops = ops; blk->dev_opaque = opaque;
@@ -1028,6 +1062,7 @@ void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,*/ void blk_dev_change_media_cb (BlockBackend *blk,bool load,Error **errp) { +assert (qemu_in_main_thread ());if (blk->dev_ops && blk->dev_ops->change_media_cb) {bool tray_was_open, tray_is_open;Error *local_err =NULL ;
@@ -1119,6 +1154,7 @@ static void blk_root_resize(BdrvChild *child)void blk_iostatus_enable (BlockBackend *blk) { +assert (qemu_in_main_thread ()); blk->iostatus_enabled = true; blk->iostatus =BLOCK_DEVICE_IO_STATUS_OK ; }
@@ -1127,6 +1163,7 @@ void blk_iostatus_enable(BlockBackend *blk)* enables it _and_ the VM is configured to stop on errors */ bool blk_iostatus_is_enabled (const BlockBackend *blk) { +assert (qemu_in_main_thread ()); return (blk->iostatus_enabled && (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC || blk->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
@@ -1135,16 +1172,19 @@ bool blk_iostatus_is_enabled(const BlockBackend *blk)BlockDeviceIoStatus blk_iostatus (const BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->iostatus; }void blk_iostatus_disable (BlockBackend *blk) { +assert (qemu_in_main_thread ()); blk->iostatus_enabled = false; }void blk_iostatus_reset (BlockBackend *blk) { +assert (qemu_in_main_thread ());if (blk_iostatus_is_enabled (blk)) { blk->iostatus =BLOCK_DEVICE_IO_STATUS_OK ; }
@@ -1152,6 +1192,7 @@ void blk_iostatus_reset(BlockBackend *blk)void blk_iostatus_set_err (BlockBackend *blk,int error) { +assert (qemu_in_main_thread ());assert (blk_iostatus_is_enabled (blk));if (blk->iostatus ==BLOCK_DEVICE_IO_STATUS_OK ) { blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
@@ -1351,6 +1392,7 @@ int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,int blk_make_zero (BlockBackend *blk,BdrvRequestFlags flags) { +assert (qemu_in_main_thread ());return bdrv_make_zero (blk->root, flags); }
@@ -1560,6 +1602,7 @@ BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,void blk_aio_cancel (BlockAIOCB *acb) { +assert (qemu_in_main_thread ());bdrv_aio_cancel (acb); }
@@ -1584,6 +1627,7 @@ blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)int blk_ioctl (BlockBackend *blk,unsigned long int req,void *buf) {int ret; +assert (qemu_in_main_thread ());blk_inc_in_flight (blk); ret =blk_do_ioctl (blk, req, buf);
@@ -1734,6 +1778,8 @@ void blk_drain_all(void) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ()); +bdrv_drain_all_begin ();while ((blk =blk_all_next (blk)) !=NULL ) {
@@ -1753,6 +1799,7 @@ void blk_drain_all(void)void blk_set_on_error (BlockBackend *blk,BlockdevOnError on_read_error,BlockdevOnError on_write_error) { +assert (qemu_in_main_thread ()); blk->on_read_error = on_read_error; blk->on_write_error = on_write_error; }
@@ -1836,6 +1883,7 @@ void blk_error_action(BlockBackend *blk, BlockErrorAction action,bool blk_supports_write_perm (BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {return !bdrv_is_read_only (bs);
@@ -1856,6 +1904,7 @@ bool blk_is_writable(BlockBackend *blk)bool blk_is_sg (BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (!bs) {return false;
@@ -1866,11 +1915,13 @@ bool blk_is_sg(BlockBackend *blk)bool blk_enable_write_cache (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->enable_write_cache; }void blk_set_enable_write_cache (BlockBackend *blk,bool wce) { +assert (qemu_in_main_thread ()); blk->enable_write_cache = wce; }
@@ -1901,6 +1952,7 @@ bool blk_is_available(BlockBackend *blk)void blk_lock_medium (BlockBackend *blk,bool locked) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {bdrv_lock_medium (bs, locked);
@@ -1910,6 +1962,8 @@ void blk_lock_medium(BlockBackend *blk, bool locked)void blk_eject (BlockBackend *blk,bool eject_flag) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ()); +char *id;if (bs) {
@@ -1927,6 +1981,7 @@ void blk_eject(BlockBackend *blk, bool eject_flag)int blk_get_flags (BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {return bdrv_get_flags (bs);
@@ -1980,6 +2035,7 @@ int blk_get_max_iov(BlockBackend *blk)void blk_set_guest_block_size (BlockBackend *blk,int align) { +assert (qemu_in_main_thread ()); blk->guest_block_size = align; }
@@ -1996,6 +2052,7 @@ void *blk_blockalign(BlockBackend *blk, size_t size)bool blk_op_is_blocked (BlockBackend *blk,BlockOpType op,Error **errp) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (!bs) {return false;
@@ -2007,6 +2064,7 @@ bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)void blk_op_unblock (BlockBackend *blk,BlockOpType op,Error *reason) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {bdrv_op_unblock (bs, op, reason);
@@ -2016,6 +2074,7 @@ void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)void blk_op_block_all (BlockBackend *blk,Error *reason) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {bdrv_op_block_all (bs, reason);
@@ -2025,6 +2084,7 @@ void blk_op_block_all(BlockBackend *blk, Error *reason)void blk_op_unblock_all (BlockBackend *blk,Error *reason) {BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ());if (bs) {bdrv_op_unblock_all (bs, reason);
@@ -2079,6 +2139,7 @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,int blk_set_aio_context (BlockBackend *blk,AioContext *new_context,Error **errp) { +assert (qemu_in_main_thread ());return blk_do_set_aio_context (blk, new_context, true, errp); }
@@ -2115,6 +2176,7 @@ void blk_add_aio_context_notifier(BlockBackend *blk, {BlockBackendAioNotifier *notifier;BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ()); notifier =g_new (BlockBackendAioNotifier,1 ); notifier->attached_aio_context = attached_aio_context;
@@ -2137,6 +2199,8 @@ void blk_remove_aio_context_notifier(BlockBackend *blk,BlockBackendAioNotifier *notifier;BlockDriverState *bs =blk_bs (blk); +assert (qemu_in_main_thread ()); +if (bs) {bdrv_remove_aio_context_notifier (bs, attached_aio_context, detach_aio_context, opaque);
@@ -2157,11 +2221,13 @@ void blk_remove_aio_context_notifier(BlockBackend *blk,void blk_add_remove_bs_notifier (BlockBackend *blk,Notifier *notify) { +assert (qemu_in_main_thread ());notifier_list_add (&blk->remove_bs_notifiers, notify); }void blk_add_insert_bs_notifier (BlockBackend *blk,Notifier *notify) { +assert (qemu_in_main_thread ());notifier_list_add (&blk->insert_bs_notifiers, notify); }
@@ -2224,6 +2290,7 @@ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, int64_t pos, int size) { int ret; +assert (qemu_in_main_thread ());if (!blk_is_available (blk)) {return -ENOMEDIUM ;
@@ -2243,6 +2310,7 @@ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,int blk_load_vmstate (BlockBackend *blk,uint8_t *buf,int64_t pos,int size) { +assert (qemu_in_main_thread ());if (!blk_is_available (blk)) {return -ENOMEDIUM ; }
@@ -2252,6 +2320,7 @@ int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)int blk_probe_blocksizes (BlockBackend *blk,BlockSizes *bsz) { +assert (qemu_in_main_thread ());if (!blk_is_available (blk)) {return -ENOMEDIUM ; }
@@ -2261,6 +2330,7 @@ int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)int blk_probe_geometry (BlockBackend *blk,HDGeometry *geo) { +assert (qemu_in_main_thread ());if (!blk_is_available (blk)) {return -ENOMEDIUM ; }
@@ -2274,6 +2344,7 @@ int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)*/ void blk_update_root_state (BlockBackend *blk) { +assert (qemu_in_main_thread ());assert (blk->root); blk->root_state.open_flags = blk->root->bs->open_flags;
@@ -2286,6 +2357,7 @@ void blk_update_root_state(BlockBackend *blk)*/ bool blk_get_detect_zeroes_from_root_state (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->root_state.detect_zeroes; }
@@ -2295,17 +2367,20 @@ bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk)*/ int blk_get_open_flags_from_root_state (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->root_state.open_flags; }BlockBackendRootState *blk_get_root_state (BlockBackend *blk) { +assert (qemu_in_main_thread ());return &blk->root_state; }int blk_commit_all (void ) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ());while ((blk =blk_all_next (blk)) !=NULL ) {AioContext *aio_context =blk_get_aio_context (blk);
@@ -2330,6 +2405,7 @@ int blk_commit_all(void)/* throttling disk I/O limits */ void blk_set_io_limits (BlockBackend *blk,ThrottleConfig *cfg) { +assert (qemu_in_main_thread ());throttle_group_config (&blk->public.throttle_group_member, cfg); }
@@ -2338,6 +2414,7 @@ void blk_io_limits_disable(BlockBackend *blk)BlockDriverState *bs =blk_bs (blk);ThrottleGroupMember *tgm = &blk->public.throttle_group_member;assert (tgm->throttle_state); +assert (qemu_in_main_thread ());if (bs) {bdrv_drained_begin (bs); }
@@ -2351,12 +2428,14 @@ void blk_io_limits_disable(BlockBackend *blk)void blk_io_limits_enable (BlockBackend *blk,const char *group) {assert (!blk->public.throttle_group_member.throttle_state); +assert (qemu_in_main_thread ());throttle_group_register_tgm (&blk->public.throttle_group_member, group,blk_get_aio_context (blk)); }void blk_io_limits_update_group (BlockBackend *blk,const char *group) { +assert (qemu_in_main_thread ());/* this BB is not part of any group */ if (!blk->public.throttle_group_member.throttle_state) {return ;
@@ -2424,11 +2503,13 @@ static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)void blk_register_buf (BlockBackend *blk,void *host,size_t size) { +assert (qemu_in_main_thread ());bdrv_register_buf (blk_bs (blk), host, size); }void blk_unregister_buf (BlockBackend *blk,void *host) { +assert (qemu_in_main_thread ());bdrv_unregister_buf (blk_bs (blk), host); }
@@ -2453,11 +2534,13 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,const BdrvChild *blk_root (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->root; }int blk_make_empty (BlockBackend *blk,Error **errp) { +assert (qemu_in_main_thread ());if (!blk_is_available (blk)) {error_setg (errp,"No medium inserted" );return -ENOMEDIUM ;
softmmu/qdev-monitor.c +2 -0
@@ -969,6 +969,8 @@ BlockBackend *blk_by_qdev_id(const char *id, Error **errp)DeviceState *dev;BlockBackend *blk; +assert (qemu_in_main_thread ()); + dev =find_device_state (id, errp);if (dev ==NULL ) {return NULL ;
Signature · 1 line
2.27.0
Re: [PATCH v5 06/31] block/block-backend.c: assertions for block-backend
Quoted 10 lines · Emanuele Giuseppe Esposito
All the global state (GS) API functions will check that
qemu_in_main_thread()returns true. If not, it means that the safety of BQL cannot be guaranteed, and they need to be moved to I/O.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block/block-backend.c | 83 ++++++++++++++++++++++++++++++++++++++++++ softmmu/qdev-monitor.c | 2 + 2 files changed, 85 insertions(+)
So given my thoughts on patch 5, I believe that blk_set_perm() and blk_get_perm() should get assertions here.
Hanna
PATCH v5 7/31 include/block/block_int: split header into I/O and global state API
In reply to Emanuele Giuseppe EspositoSimilarly to the previous patch, split block_int.h in block_int-io.h and block_int-global-state.h
block_int-common.h contains the structures shared between the two headers, and the functions that can't be categorized as I/O or global state.
Assertions are added in the next patch.
--- include/block/block_int-common.h | 1161 +++++++++++++++++++ include/block/block_int-global-state.h | 315 +++++ include/block/block_int-io.h | 167 +++ include/block/block_int.h | 1475 +----------------------- blockdev.c | 5 + 5 files changed, 1651 insertions(+), 1472 deletions(-) create mode 100644 include/block/block_int-common.h create mode 100644 include/block/block_int-global-state.h create mode 100644 include/block/block_int-io.h
include/block/block_int-common.h new file +1161 -0
@@ -0,0 +1,1161 @@ +/* +* 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_INT_COMMON_H +#define BLOCK_INT_COMMON_H + +#include "block/accounting.h" +#include "block/block.h" +#include "block/aio-wait.h" +#include "qemu/queue.h" +#include "qemu/coroutine.h" +#include "qemu/stats64.h" +#include "qemu/timer.h" +#include "qemu/hbitmap.h" +#include "block/snapshot.h" +#include "qemu/throttle.h" +#include "qemu/rcu.h" + +#define BLOCK_FLAG_LAZY_REFCOUNTS 8 + +#define BLOCK_OPT_SIZE "size" +#define BLOCK_OPT_ENCRYPT "encryption" +#define BLOCK_OPT_ENCRYPT_FORMAT "encrypt.format" +#define BLOCK_OPT_COMPAT6 "compat6" +#define BLOCK_OPT_HWVERSION "hwversion" +#define BLOCK_OPT_BACKING_FILE "backing_file" +#define BLOCK_OPT_BACKING_FMT "backing_fmt" +#define BLOCK_OPT_CLUSTER_SIZE "cluster_size" +#define BLOCK_OPT_TABLE_SIZE "table_size" +#define BLOCK_OPT_PREALLOC "preallocation" +#define BLOCK_OPT_SUBFMT "subformat" +#define BLOCK_OPT_COMPAT_LEVEL "compat" +#define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts" +#define BLOCK_OPT_ADAPTER_TYPE "adapter_type" +#define BLOCK_OPT_REDUNDANCY "redundancy" +#define BLOCK_OPT_NOCOW "nocow" +#define BLOCK_OPT_EXTENT_SIZE_HINT "extent_size_hint" +#define BLOCK_OPT_OBJECT_SIZE "object_size" +#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits" +#define BLOCK_OPT_DATA_FILE "data_file" +#define BLOCK_OPT_DATA_FILE_RAW "data_file_raw" +#define BLOCK_OPT_COMPRESSION_TYPE "compression_type" +#define BLOCK_OPT_EXTL2 "extended_l2" + +#define BLOCK_PROBE_BUF_SIZE 512 + +enum BdrvTrackedRequestType { +BDRV_TRACKED_READ , +BDRV_TRACKED_WRITE , +BDRV_TRACKED_DISCARD , +BDRV_TRACKED_TRUNCATE , +}; + +/* +* That is not quite good that BdrvTrackedRequest structure is public, +* as block/io.c is very careful about incoming offset/bytes being +* correct. Be sure to assert bdrv_check_request() succeeded after any +* modification of BdrvTrackedRequest object out of block/io.c +*/ +typedef struct BdrvTrackedRequest { +BlockDriverState *bs; +int64_t offset; +int64_t bytes; +enum BdrvTrackedRequestType type; + +bool serialising; +int64_t overlap_offset; +int64_t overlap_bytes; + +QLIST_ENTRY (BdrvTrackedRequest) list; +Coroutine *co;/* owner, used for deadlock detection */ +CoQueue wait_queue;/* coroutines blocked on this request */ + +struct BdrvTrackedRequest *waiting_for; +}BdrvTrackedRequest ; + + +struct BlockDriver { +const char *format_name; +int instance_size; + +/* +* Set to true if the BlockDriver is a block filter. Block filters pass +* certain callbacks that refer to data (see block.c) to their bs->file +* or bs->backing (whichever one exists) if the driver doesn't implement +* them. Drivers that do not wish to forward must implement them and return +* -ENOTSUP. +* Note that filters are not allowed to modify data. +* +* Filters generally cannot have more than a single filtered child, +* because the data they present must at all times be the same as +* that on their filtered child. That would be impossible to +* achieve for multiple filtered children. +* (And this filtered child must then be bs->file or bs->backing.) +*/ +bool is_filter; +/* +* Set to true if the BlockDriver is a format driver. Format nodes +* generally do not expect their children to be other format nodes +* (except for backing files), and so format probing is disabled +* on those children. +*/ +bool is_format; +/* +* Return true if @to_replace can be replaced by a BDS with the +* same data as @bs without it affecting @bs's behavior (that is, +* without it being visible to @bs's parents). +*/ +bool (*bdrv_recurse_can_replace)(BlockDriverState *bs, +BlockDriverState *to_replace); + +int (*bdrv_probe)(const uint8_t *buf,int buf_size,const char *filename); +int (*bdrv_probe_device)(const char *filename); + +/* +* Any driver implementing this callback is expected to be able to handle +* NULL file names in its .bdrv_open() implementation. +*/ +void (*bdrv_parse_filename)(const char *filename,QDict *options, +Error **errp); +/* +* Drivers not implementing bdrv_parse_filename nor bdrv_open should have +* this field set to true, except ones that are defined only by their +* child's bs. +* An example of the last type will be the quorum block driver. +*/ +bool bdrv_needs_filename; + +/* +* Set if a driver can support backing files. This also implies the +* following semantics: +* +* - Return status 0 of .bdrv_co_block_status means that corresponding +* blocks are not allocated in this layer of backing-chain +* - For such (unallocated) blocks, read will: +* - fill buffer with zeros if there is no backing file +* - read from the backing file otherwise, where the block layer +* takes care of reading zeros beyond EOF if backing file is short +*/ +bool supports_backing; + +/* For handling image reopen for split or non-split files */ +int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, +BlockReopenQueue *queue,Error **errp); +void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state); +void (*bdrv_reopen_commit_post)(BDRVReopenState *reopen_state); +void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); +void (*bdrv_join_options)(QDict *options,QDict *old_options); + +int (*bdrv_open)(BlockDriverState *bs,QDict *options,int flags, +Error **errp); + +/* Protocol drivers should implement this instead of bdrv_open */ +int (*bdrv_file_open)(BlockDriverState *bs,QDict *options,int flags, +Error **errp); +void (*bdrv_close)(BlockDriverState *bs); + + + int coroutine_fn (*bdrv_co_create)(BlockdevCreateOptions *opts, +Error **errp); + int coroutine_fn (*bdrv_co_create_opts)(BlockDriver *drv, +const char *filename, +QemuOpts *opts, +Error **errp); + + int coroutine_fn (*bdrv_co_amend)(BlockDriverState *bs, +BlockdevAmendOptions *opts, +bool force, +Error **errp); + +int (*bdrv_amend_options)(BlockDriverState *bs, +QemuOpts *opts, +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque, +bool force, +Error **errp); + +int (*bdrv_make_empty)(BlockDriverState *bs); + +/* +* Refreshes the bs->exact_filename field. If that is impossible, +* bs->exact_filename has to be left empty. +*/ +void (*bdrv_refresh_filename)(BlockDriverState *bs); + +/* +* Gathers the open options for all children into @target. +* A simple format driver (without backing file support) might +* implement this function like this: +* +* QINCREF(bs->file->bs->full_open_options); +* qdict_put(target, "file", bs->file->bs->full_open_options); +* +* If not specified, the generic implementation will simply put +* all children's options under their respective name. +* +* @backing_overridden is true when bs->backing seems not to be +* the child that would result from opening bs->backing_file. +* Therefore, if it is true, the backing child's options should be +* gathered; otherwise, there is no need since the backing child +* is the one implied by the image header. +* +* Note that ideally this function would not be needed. Every +* block driver which implements it is probably doing something +* shady regarding its runtime option structure. +*/ +void (*bdrv_gather_child_options)(BlockDriverState *bs,QDict *target, +bool backing_overridden); + +/* +* Returns an allocated string which is the directory name of this BDS: It +* will be used to make relative filenames absolute by prepending this +* function's return value to them. +*/ +char *(*bdrv_dirname)(BlockDriverState *bs,Error **errp); + +/* aio */ +BlockAIOCB *(*bdrv_aio_preadv)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov, +BdrvRequestFlags flags,BlockCompletionFunc *cb,void *opaque); +BlockAIOCB *(*bdrv_aio_pwritev)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov, +BdrvRequestFlags flags,BlockCompletionFunc *cb,void *opaque); +BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, +BlockCompletionFunc *cb,void *opaque); +BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs, +int64_t offset,int bytes, +BlockCompletionFunc *cb,void *opaque); + + int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, +int64_t sector_num,int nb_sectors,QEMUIOVector *qiov); + +/** +* @offset: position in bytes to read at +* @bytes: number of bytes to read +* @qiov: the buffers to fill with read data +* @flags: currently unused, always 0 +* +* @offset and @bytes will be a multiple of 'request_alignment', +* but the length of individual @qiov elements does not have to +* be a multiple. +* +* @bytes will always equal the total size of @qiov, and will be +* no larger than 'max_transfer'. +* +* The buffer in @qiov may point directly to guest memory. +*/ + int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov, +BdrvRequestFlags flags); + + int coroutine_fn (*bdrv_co_preadv_part)(BlockDriverState *bs, +int64_t offset,int64_t bytes, +QEMUIOVector *qiov,size_t qiov_offset, +BdrvRequestFlags flags); + + int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs, +int64_t sector_num,int nb_sectors,QEMUIOVector *qiov, +int flags); +/** +* @offset: position in bytes to write at +* @bytes: number of bytes to write +* @qiov: the buffers containing data to write +* @flags: zero or more bits allowed by 'supported_write_flags' +* +* @offset and @bytes will be a multiple of 'request_alignment', +* but the length of individual @qiov elements does not have to +* be a multiple. +* +* @bytes will always equal the total size of @qiov, and will be +* no larger than 'max_transfer'. +* +* The buffer in @qiov may point directly to guest memory. +*/ + int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov, +BdrvRequestFlags flags); + int coroutine_fn (*bdrv_co_pwritev_part)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov,size_t qiov_offset, +BdrvRequestFlags flags); + +/* +* Efficiently zero a region of the disk image. Typically an image format +* would use a compact metadata representation to implement this. This +* function pointer may be NULL or return -ENOSUP and .bdrv_co_writev() +* will be called instead. +*/ + int coroutine_fn (*bdrv_co_pwrite_zeroes)(BlockDriverState *bs, +int64_t offset,int64_t bytes,BdrvRequestFlags flags); + int coroutine_fn (*bdrv_co_pdiscard)(BlockDriverState *bs, +int64_t offset,int64_t bytes); + +/* +* Map [offset, offset + nbytes) range onto a child of @bs to copy from, +* and invoke bdrv_co_copy_range_from(child, ...), or invoke +* bdrv_co_copy_range_to() if @bs is the leaf child to copy data from. +* +* See the comment of bdrv_co_copy_range for the parameter and return value +* semantics. +*/ + int coroutine_fn (*bdrv_co_copy_range_from)(BlockDriverState *bs, +BdrvChild *src, +int64_t offset, +BdrvChild *dst, +int64_t dst_offset, +int64_t bytes, +BdrvRequestFlags read_flags, +BdrvRequestFlags write_flags); + +/* +* Map [offset, offset + nbytes) range onto a child of bs to copy data to, +* and invoke bdrv_co_copy_range_to(child, src, ...), or perform the copy +* operation if @bs is the leaf and @src has the same BlockDriver. Return +* -ENOTSUP if @bs is the leaf but @src has a different BlockDriver. +* +* See the comment of bdrv_co_copy_range for the parameter and return value +* semantics. +*/ + int coroutine_fn (*bdrv_co_copy_range_to)(BlockDriverState *bs, +BdrvChild *src, +int64_t src_offset, +BdrvChild *dst, +int64_t dst_offset, +int64_t bytes, +BdrvRequestFlags read_flags, +BdrvRequestFlags write_flags); + +/* +* Building block for bdrv_block_status[_above] and +* bdrv_is_allocated[_above]. The driver should answer only +* according to the current layer, and should only need to set +* BDRV_BLOCK_DATA, BDRV_BLOCK_ZERO, BDRV_BLOCK_OFFSET_VALID, +* and/or BDRV_BLOCK_RAW; if the current layer defers to a backing +* layer, the result should be 0 (and not BDRV_BLOCK_ZERO). See +* block.h for the overall meaning of the bits. As a hint, the +* flag want_zero is true if the caller cares more about precise +* mappings (favor accurate _OFFSET_VALID/_ZERO) or false for +* overall allocation (favor larger *pnum, perhaps by reporting +* _DATA instead of _ZERO). The block layer guarantees input +* clamped to bdrv_getlength() and aligned to request_alignment, +* as well as non-NULL pnum, map, and file; in turn, the driver +* must return an error or set pnum to an aligned non-zero value. +* +* Note that @bytes is just a hint on how big of a region the +* caller wants to inspect. It is not a limit on *pnum. +* Implementations are free to return larger values of *pnum if +* doing so does not incur a performance penalty. +* +* block/io.c's bdrv_co_block_status() will utilize an unclamped +* *pnum value for the block-status cache on protocol nodes, prior +* to clamping *pnum for return to its caller. +*/ + int coroutine_fn (*bdrv_co_block_status)(BlockDriverState *bs, +bool want_zero,int64_t offset,int64_t bytes,int64_t *pnum, +int64_t *map,BlockDriverState **file); + +/* +* This informs the driver that we are no longer interested in the result +* of in-flight requests, so don't waste the time if possible. +* +* One example usage is to avoid waiting for an nbd target node reconnect +* timeout during job-cancel with force=true. +*/ +void (*bdrv_cancel_in_flight)(BlockDriverState *bs); + +/* +* Invalidate any cached meta-data. +*/ + void coroutine_fn (*bdrv_co_invalidate_cache)(BlockDriverState *bs, +Error **errp); +int (*bdrv_inactivate)(BlockDriverState *bs); + +/* +* Flushes all data for all layers by calling bdrv_co_flush for underlying +* layers, if needed. This function is needed for deterministic +* synchronization of the flush finishing callback. +*/ + int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs); + +/* Delete a created file. */ + int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs, +Error **errp); + +/* +* Flushes all data that was already written to the OS all the way down to +* the disk (for example file-posix.c calls fsync()). +*/ + int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); + +/* +* Flushes all internal caches to the OS. The data may still sit in a +* writeback cache of the host OS, but it will survive a crash of the qemu +* process. +*/ + int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); + +/* +* Drivers setting this field must be able to work with just a plain +* filename with '<protocol_name>:' as a prefix, and no other options. +* Options may be extracted from the filename by implementing +* bdrv_parse_filename. +*/ +const char *protocol_name; + +/* +* Truncate @bs to @offset bytes using the given @prealloc mode +* when growing. Modes other than PREALLOC_MODE_OFF should be +* rejected when shrinking @bs. +* +* If @exact is true, @bs must be resized to exactly @offset. +* Otherwise, it is sufficient for @bs (if it is a host block +* device and thus there is no way to resize it) to be at least +* @offset bytes in length. +* +* If @exact is true and this function fails but would succeed +* with @exact = false, it should return -ENOTSUP. +*/ + int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset, +bool exact,PreallocMode prealloc, +BdrvRequestFlags flags,Error **errp); +int64_t (*bdrv_getlength)(BlockDriverState *bs); +bool has_variable_length; +int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); +BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts,BlockDriverState *in_bs, +Error **errp); + + int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov); + int coroutine_fn (*bdrv_co_pwritev_compressed_part)(BlockDriverState *bs, +int64_t offset,int64_t bytes,QEMUIOVector *qiov, +size_t qiov_offset); + +int (*bdrv_snapshot_create)(BlockDriverState *bs, +QEMUSnapshotInfo *sn_info); +int (*bdrv_snapshot_goto)(BlockDriverState *bs, +const char *snapshot_id); +int (*bdrv_snapshot_delete)(BlockDriverState *bs, +const char *snapshot_id, +const char *name, +Error **errp); +int (*bdrv_snapshot_list)(BlockDriverState *bs, +QEMUSnapshotInfo **psn_info); +int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, +const char *snapshot_id, +const char *name, +Error **errp); +int (*bdrv_get_info)(BlockDriverState *bs,BlockDriverInfo *bdi); + +ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs, +Error **errp); +BlockStatsSpecific *(*bdrv_get_specific_stats)(BlockDriverState *bs); + + int coroutine_fn (*bdrv_save_vmstate)(BlockDriverState *bs, +QEMUIOVector *qiov, +int64_t pos); + int coroutine_fn (*bdrv_load_vmstate)(BlockDriverState *bs, +QEMUIOVector *qiov, +int64_t pos); + +int (*bdrv_change_backing_file)(BlockDriverState *bs, +const char *backing_file,const char *backing_fmt); + +/* removable device specific */ +bool (*bdrv_is_inserted)(BlockDriverState *bs); +void (*bdrv_eject)(BlockDriverState *bs,bool eject_flag); +void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked); + +/* to control generic scsi devices */ +BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, +unsigned long int req,void *buf, +BlockCompletionFunc *cb,void *opaque); + int coroutine_fn (*bdrv_co_ioctl)(BlockDriverState *bs, +unsigned long int req,void *buf); + +/* List of options for creating images, terminated by name == NULL */ +QemuOptsList *create_opts; + +/* List of options for image amend */ +QemuOptsList *amend_opts; + +/* +* If this driver supports reopening images this contains a +* NULL-terminated list of the runtime options that can be +* modified. If an option in this list is unspecified during +* reopen then it _must_ be reset to its default value or return +* an error. +*/ +const char *const *mutable_opts; + +/* +* Returns 0 for completed check, -errno for internal errors. +* The check results are stored in result. +*/ + int coroutine_fn (*bdrv_co_check)(BlockDriverState *bs, +BdrvCheckResult *result, +BdrvCheckMode fix); + +void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event); + +/* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ +int (*bdrv_debug_breakpoint)(BlockDriverState *bs,const char *event, +const char *tag); +int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, +const char *tag); +int (*bdrv_debug_resume)(BlockDriverState *bs,const char *tag); +bool (*bdrv_debug_is_suspended)(BlockDriverState *bs,const char *tag); + +void (*bdrv_refresh_limits)(BlockDriverState *bs,Error **errp); + +/* +* Returns 1 if newly created images are guaranteed to contain only +* zeros, 0 otherwise. +*/ +int (*bdrv_has_zero_init)(BlockDriverState *bs); + +/* +* Remove fd handlers, timers, and other event loop callbacks so the event +* loop is no longer in use. Called with no in-flight requests and in +* depth-first traversal order with parents before child nodes. +*/ +void (*bdrv_detach_aio_context)(BlockDriverState *bs); + +/* +* Add fd handlers, timers, and other event loop callbacks so I/O requests +* can be processed again. Called with no in-flight requests and in +* depth-first traversal order with child nodes before parent nodes. +*/ +void (*bdrv_attach_aio_context)(BlockDriverState *bs, +AioContext *new_context); + +/* io queue for linux-aio */ +void (*bdrv_io_plug)(BlockDriverState *bs); +void (*bdrv_io_unplug)(BlockDriverState *bs); + +/** +* Try to get @bs's logical and physical block size. +* On success, store them in @bsz and return zero. +* On failure, return negative errno. +*/ +int (*bdrv_probe_blocksizes)(BlockDriverState *bs,BlockSizes *bsz); +/** +* Try to get @bs's geometry (cyls, heads, sectors) +* On success, store them in @geo and return 0. +* On failure return -errno. +* Only drivers that want to override guest geometry implement this +* callback; see hd_geometry_guess(). +*/ +int (*bdrv_probe_geometry)(BlockDriverState *bs,HDGeometry *geo); + +/** +* bdrv_co_drain_begin is called if implemented in the beginning of a +* drain operation to drain and stop any internal sources of requests in +* the driver. +* bdrv_co_drain_end is called if implemented at the end of the drain. +* +* They should be used by the driver to e.g. manage scheduled I/O +* requests, or toggle an internal state. After the end of the drain new +* requests will continue normally. +*/ + void coroutine_fn (*bdrv_co_drain_begin)(BlockDriverState *bs); + void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs); + +void (*bdrv_add_child)(BlockDriverState *parent,BlockDriverState *child, +Error **errp); +void (*bdrv_del_child)(BlockDriverState *parent,BdrvChild *child, +Error **errp); + +/** +* Informs the block driver that a permission change is intended. The +* driver checks whether the change is permissible and may take other +* preparations for the change (e.g. get file system locks). This operation +* is always followed either by a call to either .bdrv_set_perm or +* .bdrv_abort_perm_update. +* +* Checks whether the requested set of cumulative permissions in @perm +* can be granted for accessing @bs and whether no other users are using +* permissions other than those given in @shared (both arguments take +* BLK_PERM_* bitmasks). +* +* If both conditions are met, 0 is returned. Otherwise, -errno is returned +* and errp is set to an error describing the conflict. +*/ +int (*bdrv_check_perm)(BlockDriverState *bs,uint64_t perm, +uint64_t shared,Error **errp); + +/** +* Called to inform the driver that the set of cumulative set of used +* permissions for @bs has changed to @perm, and the set of sharable +* permission to @shared. The driver can use this to propagate changes to +* its children (i.e. request permissions only if a parent actually needs +* them). +* +* This function is only invoked after bdrv_check_perm(), so block drivers +* may rely on preparations made in their .bdrv_check_perm implementation. +*/ +void (*bdrv_set_perm)(BlockDriverState *bs,uint64_t perm,uint64_t shared); + +/* +* Called to inform the driver that after a previous bdrv_check_perm() +* call, the permission update is not performed and any preparations made +* for it (e.g. taken file locks) need to be undone. +* +* This function can be called even for nodes that never saw a +* bdrv_check_perm() call. It is a no-op then. +*/ +void (*bdrv_abort_perm_update)(BlockDriverState *bs); + +/** +* Returns in @nperm and @nshared the permissions that the driver for @bs +* needs on its child @c, based on the cumulative permissions requested by +* the parents in @parent_perm and @parent_shared. +* +* If @c is NULL, return the permissions for attaching a new child for the +* given @child_class and @role. +* +* If @reopen_queue is non-NULL, don't return the currently needed +* permissions, but those that will be needed after applying the +* @reopen_queue. +*/ +void (*bdrv_child_perm)(BlockDriverState *bs,BdrvChild *c, +BdrvChildRole role, +BlockReopenQueue *reopen_queue, +uint64_t parent_perm,uint64_t parent_shared, +uint64_t *nperm,uint64_t *nshared); + +bool (*bdrv_supports_persistent_dirty_bitmap)(BlockDriverState *bs); +bool (*bdrv_co_can_store_new_dirty_bitmap)(BlockDriverState *bs, +const char *name, +uint32_t granularity, +Error **errp); +int (*bdrv_co_remove_persistent_dirty_bitmap)(BlockDriverState *bs, +const char *name, +Error **errp); + +/** +* Register/unregister a buffer for I/O. For example, when the driver is +* interested to know the memory areas that will later be used in iovs, so +* that it can do IOMMU mapping with VFIO etc., in order to get better +* performance. In the case of VFIO drivers, this callback is used to do +* DMA mapping for hot buffers. +*/ +void (*bdrv_register_buf)(BlockDriverState *bs,void *host,size_t size); +void (*bdrv_unregister_buf)(BlockDriverState *bs,void *host); +QLIST_ENTRY (BlockDriver) list; + +/* +* Pointer to a NULL-terminated array of names of strong options +* that can be specified for bdrv_open(). A strong option is one +* that changes the data of a BDS. +* If this pointer is NULL, the array is considered empty. +* "filename" and "driver" are always considered strong. +*/ +const char *const *strong_runtime_opts; +}; + +static inline bool block_driver_can_compress (BlockDriver *drv) +{ +return drv->bdrv_co_pwritev_compressed || + drv->bdrv_co_pwritev_compressed_part; +} + +typedef struct BlockLimits { +/* +* Alignment requirement, in bytes, for offset/length of I/O +* requests. Must be a power of 2 less than INT_MAX; defaults to +* 1 for drivers with modern byte interfaces, and to 512 +* otherwise. +*/ +uint32_t request_alignment; + +/* +* Maximum number of bytes that can be discarded at once. Must be multiple +* of pdiscard_alignment, but need not be power of 2. May be 0 if no +* inherent 64-bit limit. +*/ +int64_t max_pdiscard; + +/* +* Optimal alignment for discard requests in bytes. A power of 2 +* is best but not mandatory. Must be a multiple of +* bl.request_alignment, and must be less than max_pdiscard if +* that is set. May be 0 if bl.request_alignment is good enough +*/ +uint32_t pdiscard_alignment; + +/* +* Maximum number of bytes that can zeroized at once. Must be multiple of +* pwrite_zeroes_alignment. 0 means no limit. +*/ +int64_t max_pwrite_zeroes; + +/* +* Optimal alignment for write zeroes requests in bytes. A power +* of 2 is best but not mandatory. Must be a multiple of +* bl.request_alignment, and must be less than max_pwrite_zeroes +* if that is set. May be 0 if bl.request_alignment is good +* enough +*/ +uint32_t pwrite_zeroes_alignment; + +/* +* Optimal transfer length in bytes. A power of 2 is best but not +* mandatory. Must be a multiple of bl.request_alignment, or 0 if +* no preferred size +*/ +uint32_t opt_transfer; + +/* +* Maximal transfer length in bytes. Need not be power of 2, but +* must be multiple of opt_transfer and bl.request_alignment, or 0 +* for no 32-bit limit. For now, anything larger than INT_MAX is +* clamped down. +*/ +uint32_t max_transfer; + +/* +* Maximal hardware transfer length in bytes. Applies whenever +* transfers to the device bypass the kernel I/O scheduler, for +* example with SG_IO. If larger than max_transfer or if zero, +* blk_get_max_hw_transfer will fall back to max_transfer. +*/ +uint64_t max_hw_transfer; + +/* +* Maximal number of scatter/gather elements allowed by the hardware. +* Applies whenever transfers to the device bypass the kernel I/O +* scheduler, for example with SG_IO. If larger than max_iov +* or if zero, blk_get_max_hw_iov will fall back to max_iov. +*/ +int max_hw_iov; + + +/* memory alignment, in bytes so that no bounce buffer is needed */ +size_t min_mem_alignment; + +/* memory alignment, in bytes, for bounce buffer */ +size_t opt_mem_alignment; + +/* maximum number of iovec elements */ +int max_iov; +}BlockLimits ; + +typedef struct BdrvOpBlocker BdrvOpBlocker ; + +typedef struct BdrvAioNotifier { +void (*attached_aio_context)(AioContext *new_context,void *opaque); +void (*detach_aio_context)(void *opaque); + +void *opaque; +bool deleted; + +QLIST_ENTRY (BdrvAioNotifier) list; +}BdrvAioNotifier ; + +struct BdrvChildClass { +/* +* If true, bdrv_replace_node() doesn't change the node this BdrvChild +* points to. +*/ +bool stay_at_node; + +/* +* If true, the parent is a BlockDriverState and bdrv_next_all_states() +* will return it. This information is used for drain_all, where every node +* will be drained separately, so the drain only needs to be propagated to +* non-BDS parents. +*/ +bool parent_is_bds; + +void (*inherit_options)(BdrvChildRole role,bool parent_is_format, +int *child_flags,QDict *child_options, +int parent_flags,QDict *parent_options); + +void (*change_media)(BdrvChild *child,bool load); +void (*resize)(BdrvChild *child); + +/* +* Returns a name that is supposedly more useful for human users than the +* node name for identifying the node in question (in particular, a BB +* name), or NULL if the parent can't provide a better name. +*/ +const char *(*get_name)(BdrvChild *child); + +/* +* Returns a malloced string that describes the parent of the child for a +* human reader. This could be a node-name, BlockBackend name, qdev ID or +* QOM path of the device owning the BlockBackend, job type and ID etc. The +* caller is responsible for freeing the memory. +*/ +char *(*get_parent_desc)(BdrvChild *child); + +/* +* If this pair of functions is implemented, the parent doesn't issue new +* requests after returning from .drained_begin() until .drained_end() is +* called. +* +* These functions must not change the graph (and therefore also must not +* call aio_poll(), which could change the graph indirectly). +* +* If drained_end() schedules background operations, it must atomically +* increment *drained_end_counter for each such operation and atomically +* decrement it once the operation has settled. +* +* Note that this can be nested. If drained_begin() was called twice, new +* I/O is allowed only after drained_end() was called twice, too. +*/ +void (*drained_begin)(BdrvChild *child); +void (*drained_end)(BdrvChild *child,int *drained_end_counter); + +/* +* Returns whether the parent has pending requests for the child. This +* callback is polled after .drained_begin() has been called until all +* activity on the child has stopped. +*/ +bool (*drained_poll)(BdrvChild *child); + +/* +* Notifies the parent that the child has been activated/inactivated (e.g. +* when migration is completing) and it can start/stop requesting +* permissions and doing I/O on it. +*/ +void (*activate)(BdrvChild *child,Error **errp); +int (*inactivate)(BdrvChild *child); + +void (*attach)(BdrvChild *child); +void (*detach)(BdrvChild *child); + +/* +* Notifies the parent that the filename of its child has changed (e.g. +* because the direct child was removed from the backing chain), so that it +* can update its reference. +*/ +int (*update_filename)(BdrvChild *child,BlockDriverState *new_base, +const char *filename,Error **errp); + +bool (*can_set_aio_ctx)(BdrvChild *child,AioContext *ctx, +GSList **ignore,Error **errp); +void (*set_aio_ctx)(BdrvChild *child,AioContext *ctx,GSList **ignore); + +AioContext *(*get_parent_aio_context)(BdrvChild *child); +}; + +extern const BdrvChildClass child_of_bds; + +struct BdrvChild { +BlockDriverState *bs; +char *name; +const BdrvChildClass *klass; +BdrvChildRole role; +void *opaque; + +/** +* Granted permissions for operating on this BdrvChild (BLK_PERM_* bitmask) +*/ +uint64_t perm; + +/** +* Permissions that can still be granted to other users of @bs while this +* BdrvChild is still attached to it. (BLK_PERM_* bitmask) +*/ +uint64_t shared_perm; + +/* +* This link is frozen: the child can neither be replaced nor +* detached from the parent. +*/ +bool frozen; + +/* +* How many times the parent of this child has been drained +* (through klass->drained_*). +* Usually, this is equal to bs->quiesce_counter (potentially +* reduced by bdrv_drain_all_count). It may differ while the +* child is entering or leaving a drained section. +*/ +int parent_quiesce_counter; + +QLIST_ENTRY (BdrvChild) next; +QLIST_ENTRY (BdrvChild) next_parent; +}; + +/* +* Allows bdrv_co_block_status() to cache one data region for a +* protocol node. +* +* @valid: Whether the cache is valid (should be accessed with atomic +* functions so this can be reset by RCU readers) +* @data_start: Offset where we know (or strongly assume) is data +* @data_end: Offset where the data region ends (which is not necessarily +* the start of a zeroed region) +*/ +typedef struct BdrvBlockStatusCache { +struct rcu_head rcu; + +bool valid; +int64_t data_start; +int64_t data_end; +}BdrvBlockStatusCache ; + +struct BlockDriverState { +/* +* Protected by big QEMU lock or read-only after opening. No special +* locking needed during I/O... +*/ +int open_flags;/* flags used to open the file, re-used for re-open */ +bool encrypted;/* if true, the media is encrypted */ +bool sg;/* if true, the device is a /dev/sg* */ +bool probed;/* if true, format was probed rather than specified */ +bool force_share;/* if true, always allow all shared permissions */ +bool implicit;/* if true, this filter node was automatically inserted */ + +BlockDriver *drv;/* NULL means no media */ +void *opaque; + +AioContext *aio_context;/* event loop used for fd handlers, timers, etc */ +/* +* long-running tasks intended to always use the same AioContext as this +* BDS may register themselves in this list to be notified of changes +* regarding this BDS's context +*/ + QLIST_HEAD(, BdrvAioNotifier) aio_notifiers; +bool walking_aio_notifiers;/* to make removal during iteration safe */ + +char filename[PATH_MAX ]; +/* +* If not empty, this image is a diff in relation to backing_file. +* Note that this is the name given in the image header and +* therefore may or may not be equal to .backing->bs->filename. +* If this field contains a relative path, it is to be resolved +* relatively to the overlay's location. +*/ +char backing_file[PATH_MAX ]; +/* +* The backing filename indicated by the image header. Contrary +* to backing_file, if we ever open this file, auto_backing_file +* is replaced by the resulting BDS's filename (i.e. after a +* bdrv_refresh_filename() run). +*/ +char auto_backing_file[PATH_MAX ]; +char backing_format[16 ];/* if non-zero and backing_file exists */ + +QDict *full_open_options; +char exact_filename[PATH_MAX ]; + +BdrvChild *backing; +BdrvChild *file; + +/* I/O Limits */ +BlockLimits bl; + +/* +* Flags honored during pread +*/ +unsigned int supported_read_flags; +/* +* Flags honored during pwrite (so far: BDRV_REQ_FUA, +* BDRV_REQ_WRITE_UNCHANGED). +* If a driver does not support BDRV_REQ_WRITE_UNCHANGED, those +* writes will be issued as normal writes without the flag set. +* This is important to note for drivers that do not explicitly +* request a WRITE permission for their children and instead take +* the same permissions as their parent did (this is commonly what +* block filters do). Such drivers have to be aware that the +* parent may have taken a WRITE_UNCHANGED permission only and is +* issuing such requests. Drivers either must make sure that +* these requests do not result in plain WRITE accesses (usually +* by supporting BDRV_REQ_WRITE_UNCHANGED, and then forwarding +* every incoming write request as-is, including potentially that +* flag), or they have to explicitly take the WRITE permission for +* their children. +*/ +unsigned int supported_write_flags; +/* +* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, +* BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) +*/ +unsigned int supported_zero_flags; +/* +* Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE). +* +* If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure +* that any added space reads as all zeros. If this can't be guaranteed, +* the operation must fail. +*/ +unsigned int supported_truncate_flags; + +/* the following member gives a name to every node on the bs graph. */ +char node_name[32 ]; +/* element of the list of named nodes building the graph */ +QTAILQ_ENTRY (BlockDriverState) node_list; +/* element of the list of all BlockDriverStates (all_bdrv_states) */ +QTAILQ_ENTRY (BlockDriverState) bs_list; +/* element of the list of monitor-owned BDS */ +QTAILQ_ENTRY (BlockDriverState) monitor_list; +int refcnt; + +/* operation blockers. Protected by BQL. */ + QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; + +/* +* The node that this node inherited default options from (and a reopen on +* which can affect this node by changing these defaults). This is always a +* parent node of this node. +*/ +BlockDriverState *inherits_from; + QLIST_HEAD(, BdrvChild) children; + QLIST_HEAD(, BdrvChild) parents; + +QDict *options; +QDict *explicit_options; +BlockdevDetectZeroesOptions detect_zeroes; + +/* The error object in use for blocking operations on backing_hd */ +Error *backing_blocker; + +/* Protected by AioContext lock */ + +/* +* If we are reading a disk image, give its size in sectors. +* Generally read-only; it is written to by load_snapshot and +* save_snaphost, but the block layer is quiescent during those. +*/ +int64_t total_sectors; + +/* threshold limit for writes, in bytes. "High water mark". */ +uint64_t write_threshold_offset; + +/* +* Writing to the list requires the BQL _and_ the dirty_bitmap_mutex. +* Reading from the list can be done with either the BQL or the +* dirty_bitmap_mutex. Modifying a bitmap only requires +* dirty_bitmap_mutex. +*/ +QemuMutex dirty_bitmap_mutex; + QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps; + +/* Offset after the highest byte written to */ +Stat64 wr_highest_offset; + +/* +* If true, copy read backing sectors into image. Can be >1 if more +* than one client has requested copy-on-read. Accessed with atomic +* ops. +*/ +int copy_on_read; + +/* +* number of in-flight requests; overall and serialising. +* Accessed with atomic ops. +*/ +unsigned int in_flight; +unsigned int serialising_in_flight; + +/* +* counter for nested bdrv_io_plug. +* Accessed with atomic ops. +*/ +unsigned io_plugged; + +/* do we need to tell the quest if we have a volatile write cache? */ +int enable_write_cache; + +/* Accessed with atomic ops. */ +int quiesce_counter; +int recursive_quiesce_counter; + +unsigned int write_gen;/* Current data generation */ + +/* Protected by reqs_lock. */ +CoMutex reqs_lock; + QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; +CoQueue flush_queue;/* Serializing flush queue */ +bool active_flush_req;/* Flush request in flight? */ + +/* Only read/written by whoever has set active_flush_req to true. */ +unsigned int flushed_gen;/* Flushed write generation */ + +/* BdrvChild links to this node may never be frozen */ +bool never_freeze; + +/* Lock for block-status cache RCU writers */ +CoMutex bsc_modify_lock; +/* Always non-NULL, but must only be dereferenced under an RCU read guard */ +BdrvBlockStatusCache *block_status_cache; +}; + +struct BlockBackendRootState { +int open_flags; +BlockdevDetectZeroesOptions detect_zeroes; +}; + +typedef enum BlockMirrorBackingMode { +/* +* Reuse the existing backing chain from the source for the target. +* - sync=full: Set backing BDS to NULL. +* - sync=top: Use source's backing BDS. +* - sync=none: Use source as the backing BDS. +*/ +MIRROR_SOURCE_BACKING_CHAIN , + +/* Open the target's backing chain completely anew */ +MIRROR_OPEN_BACKING_CHAIN , + +/* Do not change the target's backing BDS after job completion */ +MIRROR_LEAVE_BACKING_CHAIN , +}BlockMirrorBackingMode ; + + +/* +* Essential block drivers which must always be statically linked into qemu, and +* which therefore can be accessed without using bdrv_find_format() +*/ +extern BlockDriver bdrv_file; +extern BlockDriver bdrv_raw; +extern BlockDriver bdrv_qcow2; + +extern unsigned int bdrv_drain_all_count; +extern QemuOptsList bdrv_create_opts_simple; + +/* Common functions that are neither I/O nor Global State */ + +static inline BlockDriverState *child_bs (BdrvChild *child) +{ +return child ? child->bs :NULL ; +} + +int bdrv_check_request (int64_t offset,int64_t bytes,Error **errp); +int get_tmp_filename (char *filename,int size); +void bdrv_parse_filename_strip_prefix (const char *filename,const char *prefix, +QDict *options); + + +int bdrv_check_qiov_request (int64_t offset,int64_t bytes, +QEMUIOVector *qiov,size_t qiov_offset, +Error **errp); + +#ifdef _WIN32 +int is_windows_drive (const char *filename); +#endif + +#endif /* BLOCK_INT_COMMON_H */
include/block/block_int-global-state.h new file +315 -0
315 lines not on this page · raw message
include/block/block_int-io.h new file +167 -0
167 lines not on this page · raw message
include/block/block_int.h +3 -1472
1,357 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.27.0
Part of the diff is not shown here. View the raw message.
PATCH v5 8/31 assertions for block_int global state API
In reply to Emanuele Giuseppe Esposito--- block.c | 15 +++++++++++++++ block/backup.c | 1 + block/block-backend.c | 3 +++ block/commit.c | 2 ++ block/dirty-bitmap.c | 1 + block/io.c | 1 + block/mirror.c | 4 ++++ block/monitor/bitmap-qmp-cmds.c | 6 ++++++ block/stream.c | 2 ++ blockdev.c | 7 +++++++ 10 files changed, 42 insertions(+)
block.c +15 -0
@@ -662,6 +662,8 @@ int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv,Error *local_err =NULL ;int ret; +assert (qemu_in_main_thread ()); + size =qemu_opt_get_size_del (opts,BLOCK_OPT_SIZE ,0 ); buf =qemu_opt_get_del (opts,BLOCK_OPT_PREALLOC ); prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
@@ -2492,6 +2494,8 @@ void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,uint64_t cumulative_perms =0 ;uint64_t cumulative_shared_perms =BLK_PERM_ALL ; +assert (qemu_in_main_thread ()); + QLIST_FOREACH(c, &bs->parents, next_parent) { cumulative_perms |= c->perm; cumulative_shared_perms &= c->shared_perm;
@@ -2552,6 +2556,8 @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,Transaction *tran =tran_new ();int ret; +assert (qemu_in_main_thread ()); +bdrv_child_set_perm (c, perm, shared, tran); ret =bdrv_refresh_perms (c->bs, &local_err);
@@ -2582,6 +2588,8 @@ int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)uint64_t parent_perms, parent_shared;uint64_t perms, shared; +assert (qemu_in_main_thread ()); +bdrv_get_cumulative_perm (bs, &parent_perms, &parent_shared);bdrv_child_perm (bs, c->bs, c, c->role,NULL , parent_perms, parent_shared, &perms, &shared);
@@ -2724,6 +2732,7 @@ void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c, uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared) { +assert (qemu_in_main_thread ());if (role &BDRV_CHILD_FILTERED ) {assert (!(role & (BDRV_CHILD_DATA |BDRV_CHILD_METADATA |BDRV_CHILD_COW )));
@@ -3084,6 +3093,8 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,BdrvChild *child =NULL ;Transaction *tran =tran_new (); +assert (qemu_in_main_thread ()); + ret =bdrv_attach_child_common (child_bs, child_name, child_class, child_role, perm, shared_perm, opaque, &child, tran, errp);
@@ -7436,6 +7447,8 @@ bool bdrv_recurse_can_replace(BlockDriverState *bs, {BlockDriverState *filtered; +assert (qemu_in_main_thread ()); +if (!bs || !bs->drv) {return false; }
@@ -7607,6 +7620,7 @@ static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)* would result in exactly bs->backing. */ static bool bdrv_backing_overridden (BlockDriverState *bs) { +assert (qemu_in_main_thread ());if (bs->backing) {return strcmp (bs->auto_backing_file, bs->backing->bs->filename);
@@ -7995,6 +8009,7 @@ static BlockDriverState *bdrv_do_skip_filters(BlockDriverState *bs,*/ BlockDriverState *bdrv_skip_implicit_filters (BlockDriverState *bs) { +assert (qemu_in_main_thread ());return bdrv_do_skip_filters (bs, true); }
block/backup.c +1 -0
@@ -372,6 +372,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,assert (bs);assert (target); +assert (qemu_in_main_thread ());/* QMP interface protects us from these cases */ assert (sync_mode !=MIRROR_SYNC_MODE_INCREMENTAL );
block/block-backend.c +3 -0
@@ -1095,6 +1095,7 @@ static void blk_root_change_media(BdrvChild *child, bool load)*/ bool blk_dev_has_removable_media (BlockBackend *blk) { +assert (qemu_in_main_thread ());return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb); }
@@ -1112,6 +1113,7 @@ bool blk_dev_has_tray(BlockBackend *blk)*/ void blk_dev_eject_request (BlockBackend *blk,bool force) { +assert (qemu_in_main_thread ());if (blk->dev_ops && blk->dev_ops->eject_request_cb) { blk->dev_ops->eject_request_cb (blk->dev_opaque, force); }
@@ -1134,6 +1136,7 @@ bool blk_dev_is_tray_open(BlockBackend *blk)*/ bool blk_dev_is_medium_locked (BlockBackend *blk) { +assert (qemu_in_main_thread ());if (blk->dev_ops && blk->dev_ops->is_medium_locked) {return blk->dev_ops->is_medium_locked (blk->dev_opaque); }
block/commit.c +2 -0
@@ -253,6 +253,8 @@ void commit_start(const char *job_id, BlockDriverState *bs,uint64_t base_perms, iter_shared_perms;int ret; +assert (qemu_in_main_thread ()); +assert (top != bs);if (bdrv_skip_filters (top) ==bdrv_skip_filters (base)) {error_setg (errp,"Invalid files for merge: top and base are the same" );
block/dirty-bitmap.c +1 -0
@@ -673,6 +673,7 @@ void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup) {HBitmap *tmp = bitmap->bitmap;assert (!bdrv_dirty_bitmap_readonly (bitmap)); +assert (qemu_in_main_thread ()); bitmap->bitmap = backup;hbitmap_free (tmp); }
block/io.c +1 -0
@@ -687,6 +687,7 @@ void bdrv_drain_all_end_quiesce(BlockDriverState *bs) {int drained_end_counter =0 ; +assert (qemu_in_main_thread ());g_assert (bs->quiesce_counter >0 );g_assert (!bs->refcnt);
block/mirror.c +4 -0
@@ -1880,6 +1880,8 @@ void mirror_start(const char *job_id, BlockDriverState *bs,bool is_none_mode;BlockDriverState *base; +assert (qemu_in_main_thread ()); +if ((mode ==MIRROR_SYNC_MODE_INCREMENTAL ) || (mode ==MIRROR_SYNC_MODE_BITMAP )) { error_setg(errp, "Sync mode '%s' not supported",
@@ -1905,6 +1907,8 @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,bool base_read_only;BlockJob *job; +assert (qemu_in_main_thread ()); + base_read_only =bdrv_is_read_only (base);if (base_read_only) {
block/monitor/bitmap-qmp-cmds.c +6 -0
@@ -56,6 +56,8 @@ BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,BlockDriverState *bs;BdrvDirtyBitmap *bitmap; +assert (qemu_in_main_thread ()); +if (!node) {error_setg (errp,"Node cannot be NULL" );return NULL ;
@@ -155,6 +157,8 @@ BdrvDirtyBitmap *block_dirty_bitmap_remove(const char *node, const char *name,BdrvDirtyBitmap *bitmap;AioContext *aio_context; +assert (qemu_in_main_thread ()); + bitmap =block_dirty_bitmap_lookup (node, name, &bs, errp);if (!bitmap || !bs) {return NULL ;
@@ -261,6 +265,8 @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,BlockDirtyBitmapMergeSourceList *lst;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); + dst =block_dirty_bitmap_lookup (node, target, &bs, errp);if (!dst) {return NULL ;
block/stream.c +2 -0
@@ -219,6 +219,8 @@ void stream_start(const char *job_id, BlockDriverState *bs,QDict *opts;int ret; +assert (qemu_in_main_thread ()); +assert (!(base && bottom));assert (!(backing_file_str && bottom));
blockdev.c +7 -0
@@ -69,6 +69,7 @@ QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =void bdrv_set_monitor_owned (BlockDriverState *bs) { +assert (qemu_in_main_thread ());QTAILQ_INSERT_TAIL (&monitor_bdrv_states, bs, monitor_list); }
@@ -619,6 +620,7 @@ BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp) {int bdrv_flags =0 ; +assert (qemu_in_main_thread ());/* bdrv_open() defaults to the values in bdrv_flags (for compatibility * with other callers) rather than what we want as the real defaults. * Apply the defaults here instead. */
@@ -637,6 +639,7 @@ void blockdev_close_all_bdrv_states(void) {BlockDriverState *bs, *next_bs; +assert (qemu_in_main_thread ()); QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) {AioContext *ctx =bdrv_get_aio_context (bs);
@@ -2290,6 +2293,8 @@ void qmp_transaction(TransactionActionList *dev_list,BlkActionState *state, *next;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); + QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;QTAILQ_INIT (&snap_bdrv_states);
@@ -3583,6 +3588,8 @@ void qmp_blockdev_del(const char *node_name, Error **errp)AioContext *aio_context;BlockDriverState *bs; +assert (qemu_in_main_thread ()); + bs =bdrv_find_node (node_name);if (!bs) {error_setg (errp,"Failed to find node with node-name='%s'" , node_name);
Signature · 1 line
2.27.0
PATCH v5 9/31 block: introduce assert_bdrv_graph_writable
In reply to Emanuele Giuseppe EspositoWe want to be sure that the functions that write the child and parent list of a bs are under BQL and drain.
BQL prevents from concurrent writings from the GS API, while drains protect from I/O.
TODO: drains are missing in some functions using this assert. Therefore a proper assertion will fail. Because adding drains requires additional discussions, they will be added in future series.
--- include/block/block_int-global-state.h | 10 +++++++++- block.c | 4 ++++ block/io.c | 11 +++++++++++ 3 files changed, 24 insertions(+), 1 deletion(-)
include/block/block_int-global-state.h +9 -1
@@ -312,4 +312,12 @@ void bdrv_remove_aio_context_notifier(BlockDriverState *bs,*/ void bdrv_drain_all_end_quiesce (BlockDriverState *bs); -#endif /* BLOCK_INT_GLOBAL_STATE*/ +/** +* Make sure that the function is running under both drain and BQL. +* The latter protects from concurrent writings +* from the GS API, while the former prevents concurrent reads +* from I/O. +*/ +void assert_bdrv_graph_writable (BlockDriverState *bs); + +#endif /* BLOCK_INT_GLOBAL_STATE */
block.c +4 -0
@@ -1416,6 +1416,7 @@ static void bdrv_child_cb_attach(BdrvChild *child) {BlockDriverState *bs = child->opaque; +assert_bdrv_graph_writable (bs);QLIST_INSERT_HEAD (&bs->children, child, next);if (child->role &BDRV_CHILD_COW ) {
@@ -1435,6 +1436,7 @@ static void bdrv_child_cb_detach(BdrvChild *child)bdrv_unapply_subtree_drain (child, bs); +assert_bdrv_graph_writable (bs);QLIST_REMOVE (child, next); }
@@ -2818,6 +2820,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp,if (child->klass->detach) { child->klass->detach (child); } +assert_bdrv_graph_writable (old_bs);QLIST_REMOVE (child, next_parent); }
@@ -2827,6 +2830,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp, }if (new_bs) { +assert_bdrv_graph_writable (new_bs);QLIST_INSERT_HEAD (&new_bs->parents, child, next_parent);/*
block/io.c +11 -0
@@ -734,6 +734,17 @@ void bdrv_drain_all(void)bdrv_drain_all_end (); } +void assert_bdrv_graph_writable (BlockDriverState *bs) +{ +/* +* TODO: this function is incomplete. Because the users of this +* assert lack the necessary drains, check only for BQL. +* Once the necessary drains are added, +* assert also for qatomic_read(&bs->quiesce_counter) > 0 +*/ +assert (qemu_in_main_thread ()); +} +/** * Remove an active request from the tracked requests list *
Signature · 1 line
2.27.0
Re: [PATCH v5 09/31] block: introduce assert_bdrv_graph_writable
Quoted 23 lines · Emanuele Giuseppe Esposito
We want to be sure that the functions that write the child and parent list of a bs are under BQL and drain.
BQL prevents from concurrent writings from the GS API, while drains protect from I/O.
TODO: drains are missing in some functions using this assert. Therefore a proper assertion will fail. Because adding drains requires additional discussions, they will be added in future series.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- include/block/block_int-global-state.h | 10 +++++++++- block.c | 4 ++++ block/io.c | 11 +++++++++++ 3 files changed, 24 insertions(+), 1 deletion(-)include/block/block_int-global-state.h +0
-0
include/block/block_int-global-state.h void bdrv_remove_aio_context_notifier(BlockDriverState *bs, · line 315
Quoted 4 lines
include/block/block_int-global-state.h +0
-1@@ -312,4 +312,12 @@ void bdrv_remove_aio_context_notifier(BlockDriverState *bs,*/ void bdrv_drain_all_end_quiesce (BlockDriverState *bs); -#endif /* BLOCK_INT_GLOBAL_STATE*/
This looks like it should be squashed into patch 7, sorry I missed this in v4...
(Rest of this patch looks good to me, for the record – and while I’m at it, for patches I didn’t reply to so far, I planned to send an R-b later. But then there’s things like patches 2/3 looking good to me, but it turned out in my review for patch 4 that bdrv_lock_medium() is used in an I/O path, so I can’t really send an R-b now anymore...)
Hanna
Quoted 67 lines
include/block/block_int-global-state.h +9
-0+/** +* Make sure that the function is running under both drain and BQL. +* The latter protects from concurrent writings +* from the GS API, while the former prevents concurrent reads +* from I/O. +*/ +void assert_bdrv_graph_writable (BlockDriverState *bs); + +#endif /* BLOCK_INT_GLOBAL_STATE */ block.c +4
-0@@ -1416,6 +1416,7 @@ static void bdrv_child_cb_attach(BdrvChild *child) {BlockDriverState *bs = child->opaque; +assert_bdrv_graph_writable (bs);QLIST_INSERT_HEAD (&bs->children, child, next);if (child->role &BDRV_CHILD_COW ) {@@ -1435,6 +1436,7 @@ static void bdrv_child_cb_detach(BdrvChild *child)bdrv_unapply_subtree_drain (child, bs); +assert_bdrv_graph_writable (bs);QLIST_REMOVE (child, next); }@@ -2818,6 +2820,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp,if (child->klass->detach) { child->klass->detach (child); } +assert_bdrv_graph_writable (old_bs);QLIST_REMOVE (child, next_parent); }@@ -2827,6 +2830,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp, }if (new_bs) { +assert_bdrv_graph_writable (new_bs);QLIST_INSERT_HEAD (&new_bs->parents, child, next_parent);/* block/io.c +11
-0@@ -734,6 +734,17 @@ void bdrv_drain_all(void)bdrv_drain_all_end (); } +void assert_bdrv_graph_writable (BlockDriverState *bs) +{ +/* +* TODO: this function is incomplete. Because the users of this +* assert lack the necessary drains, check only for BQL. +* Once the necessary drains are added, +* assert also for qatomic_read(&bs->quiesce_counter) > 0 +*/ +assert (qemu_in_main_thread ()); +} +/** * Remove an active request from the tracked requests list *
Re: [PATCH v5 09/31] block: introduce assert_bdrv_graph_writable
Quoted 31 lines · Hanna Reitz
Quoted 23 lines · Emanuele Giuseppe Esposito
We want to be sure that the functions that write the child and parent list of a bs are under BQL and drain.
BQL prevents from concurrent writings from the GS API, while drains protect from I/O.
TODO: drains are missing in some functions using this assert. Therefore a proper assertion will fail. Because adding drains requires additional discussions, they will be added in future series.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
include/block/block_int-global-state.h| 10 +++++++++- block.c | 4 ++++ block/io.c | 11 +++++++++++3 files changed, 24 insertions(+), 1 deletion(-)include/block/block_int-global-state.h +0
-0include/block/block_int-global-state.h void · line 315
Quoted 4 lines
include/block/block_int-global-state.h +0
-1@@ -312,4 +312,12 @@ voidbdrv_remove_aio_context_notifier(BlockDriverState *bs, */ void bdrv_drain_all_end_quiesce(BlockDriverState *bs); -#endif /* BLOCK_INT_GLOBAL_STATE*/ This looks like it should be squashed into patch 7, sorry I missed this in v4...
Quoted 2 lines
(Rest of this patch looks good to me, for the record – and while I’m at it, for patches I didn’t reply to so far, I planned to send an R-b later. But then there’s things like patches 2/3 looking good to me, but it turned out in my review for patch 4 that
bdrv_lock_medium()is used in an I/O path, so I can’t really send an R-b now anymore...)
Sorry I don't understand this, what should be squashed into patch 7? The assertion? If so, why?
Thank you,
Emanuele
Re: [PATCH v5 09/31] block: introduce assert_bdrv_graph_writable
Quoted 34 lines · Emanuele Giuseppe Esposito
Quoted 31 lines · Hanna Reitz
Quoted 23 lines · Emanuele Giuseppe Esposito
We want to be sure that the functions that write the child and parent list of a bs are under BQL and drain.
BQL prevents from concurrent writings from the GS API, while drains protect from I/O.
TODO: drains are missing in some functions using this assert. Therefore a proper assertion will fail. Because adding drains requires additional discussions, they will be added in future series.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
include/block/block_int-global-state.h| 10 +++++++++- block.c | 4 ++++ block/io.c | 11 +++++++++++3 files changed, 24 insertions(+), 1 deletion(-)include/block/block_int-global-state.h +0
-0include/block/block_int-global-state.h void · line 315
Quoted 4 lines
include/block/block_int-global-state.h +0
-1@@ -312,4 +312,12 @@ voidbdrv_remove_aio_context_notifier(BlockDriverState *bs, */ void bdrv_drain_all_end_quiesce(BlockDriverState *bs); -#endif /* BLOCK_INT_GLOBAL_STATE*/ This looks like it should be squashed into patch 7, sorry I missed this in v4...
Quoted 3 lines
Quoted 2 lines
(Rest of this patch looks good to me, for the record – and while I’m at it, for patches I didn’t reply to so far, I planned to send an R-b later. But then there’s things like patches 2/3 looking good to me, but it turned out in my review for patch 4 that
bdrv_lock_medium()is used in an I/O path, so I can’t really send an R-b now anymore...)Sorry I don't understand this, what should be squashed into patch 7? The assertion? If so, why?
No, the
-#endif /* BLOCK_INT_GLOBAL_STATE*/
+#endif /* BLOCK_INT_GLOBAL_STATE */
part of the hunk.
Hanna
PATCH v5 10/31 block.c: modify .attach and .detach callbacks of child_of_bds
In reply to Emanuele Giuseppe EspositoAccording to the assertions put in the previous patch, we should first drain and then modify the ->children list. In this way we prevent other iothreads to read the list while it is being updated.
In this case, moving the drain won't cause any harm, because child is a parameter of the drain function so it will still be included in the operation, despite not being in the list.
--- block.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
block.c +2 -3
@@ -1416,6 +1416,7 @@ static void bdrv_child_cb_attach(BdrvChild *child) {BlockDriverState *bs = child->opaque; +bdrv_apply_subtree_drain (child, bs);assert_bdrv_graph_writable (bs);QLIST_INSERT_HEAD (&bs->children, child, next);
@@ -1423,7 +1424,6 @@ static void bdrv_child_cb_attach(BdrvChild *child)bdrv_backing_attach (child); } -bdrv_apply_subtree_drain (child, bs); }static void bdrv_child_cb_detach (BdrvChild *child)
@@ -1434,10 +1434,9 @@ static void bdrv_child_cb_detach(BdrvChild *child)bdrv_backing_detach (child); } -bdrv_unapply_subtree_drain (child, bs); -assert_bdrv_graph_writable (bs);QLIST_REMOVE (child, next); +bdrv_unapply_subtree_drain (child, bs); } static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
Signature · 1 line
2.27.0
Re: [PATCH v5 10/31] block.c: modify .attach and .detach callbacks of child_of_bds
Quoted 8 lines · Emanuele Giuseppe Esposito
According to the assertions put in the previous patch, we should first drain and then modify the ->children list. In this way we prevent other iothreads to read the list while it is being updated.
In this case, moving the drain won't cause any harm, because child is a parameter of the drain function so it will still be included in the operation, despite not being in the list.
Sounds good.
Quoted 18 lines
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)block.c +1
-0@@ -1416,6 +1416,7 @@ static void bdrv_child_cb_attach(BdrvChild *child) {BlockDriverState *bs = child->opaque; +bdrv_apply_subtree_drain (child, bs);assert_bdrv_graph_writable (bs);QLIST_INSERT_HEAD (&bs->children, child, next);
block.c static void bdrv_child_cb_attach(BdrvChild *child) · line 1426
Quoted 4 lines
block.c +0
-1@@ -1423,7 +1424,6 @@ static void bdrv_child_cb_attach(BdrvChild *child)bdrv_backing_attach (child); } -bdrv_apply_subtree_drain (child, bs);
I think we should also remove the empty line above.
Hanna
Quoted 15 lines
block.c +1
-2}static void bdrv_child_cb_detach (BdrvChild *child)@@ -1434,10 +1434,9 @@ static void bdrv_child_cb_detach(BdrvChild *child)bdrv_backing_detach (child); } -bdrv_unapply_subtree_drain (child, bs); -assert_bdrv_graph_writable (bs);QLIST_REMOVE (child, next); +bdrv_unapply_subtree_drain (child, bs); } static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
Re: [PATCH v5 10/31] block.c: modify .attach and .detach callbacks of child_of_bds
Quoted 11 lines · Hanna Reitz
Quoted 8 lines · Emanuele Giuseppe Esposito
According to the assertions put in the previous patch, we should first drain and then modify the ->children list. In this way we prevent other iothreads to read the list while it is being updated.
In this case, moving the drain won't cause any harm, because child is a parameter of the drain function so it will still be included in the operation, despite not being in the list.
Sounds good.
Uhm.. I don't think this is useful at all. I was thinking to drop this patch in v6.
My plans on subtree drains, ->children and ->parent lists are explained in "Removal of Aiocontext lock and usage of subtree drains in aborted transactions"
https://patchew.org/QEMU/[email protected]/
And as I say there, commit d736f119da makes sure that it is safe to modify the graph even side a bdrv_subtree_drained_begin/end() section. So this should be unnecessary.
Thank you,
Emanuele
Quoted 38 lines
Quoted 17 lines
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 5 ++---1 file changed, 2 insertions(+), 3 deletions(-)block.c +1
-0@@ -1416,6 +1416,7 @@ static void bdrv_child_cb_attach(BdrvChild *child) { BlockDriverState *bs = child->opaque; + bdrv_apply_subtree_drain(child, bs); assert_bdrv_graph_writable(bs); QLIST_INSERT_HEAD(&bs->children, child, next);block.c static void bdrv_child_cb_attach(BdrvChild *child) · line 1425
Quoted 3 lines
block.c +0
-1@@ -1423,7 +1424,6 @@ static void bdrv_child_cb_attach(BdrvChild *child) bdrv_backing_attach(child); } - bdrv_apply_subtree_drain(child, bs);I think we should also remove the empty line above.
Hanna
Quoted 12 lines
block.c +1
-2} static void bdrv_child_cb_detach(BdrvChild *child)@@ -1434,10 +1434,9 @@ static void bdrv_child_cb_detach(BdrvChild *child) bdrv_backing_detach(child); } - bdrv_unapply_subtree_drain(child, bs); - assert_bdrv_graph_writable(bs); QLIST_REMOVE(child, next); + bdrv_unapply_subtree_drain(child, bs); } static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
Re: [PATCH v5 10/31] block.c: modify .attach and .detach callbacks of child_of_bds
Quoted 15 lines · Emanuele Giuseppe Esposito
Quoted 11 lines · Hanna Reitz
Quoted 8 lines · Emanuele Giuseppe Esposito
According to the assertions put in the previous patch, we should first drain and then modify the ->children list. In this way we prevent other iothreads to read the list while it is being updated.
In this case, moving the drain won't cause any harm, because child is a parameter of the drain function so it will still be included in the operation, despite not being in the list.
Sounds good.
Quoted 8 lines
Uhm.. I don't think this is useful at all. I was thinking to drop this patch in v6.
My plans on subtree drains, ->children and ->parent lists are explained in "Removal of Aiocontext lock and usage of subtree drains in aborted transactions"
https://patchew.org/QEMU/[email protected]/
And as I say there, commit
d736f119damakes sure that it is safe to modify the graph even side a bdrv_subtree_drained_begin/end() section. So this should be unnecessary.
Sounds good, too. :)
Hanna
PATCH v5 11/31 include/block/blockjob_int.h: split header into I/O and GS API
In reply to Emanuele Giuseppe EspositoSince the I/O functions are not many, keep a single file. Also split the function pointers in BlockJobDriver.
--- include/block/blockjob_int.h | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
include/block/blockjob_int.h +28 -0
@@ -38,6 +38,13 @@ struct BlockJobDriver {/** Generic JobDriver callbacks and settings */ JobDriver job_driver; +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ +/* * Returns whether the job has pending requests for the child or will * submit new requests before the next pause point. This callback is polled
@@ -46,6 +53,13 @@ struct BlockJobDriver {*/ bool (*drained_poll)(BlockJob *job); +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ +/* * If the callback is not NULL, it will be invoked before the job is * resumed in a new AioContext. This is the place to move any resources
@@ -56,6 +70,13 @@ struct BlockJobDriver {void (*set_speed)(BlockJob *job,int64_t speed); }; +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ +/** * block_job_create: * @job_id: The id of the newly-created job, or %NULL to have one
@@ -98,6 +119,13 @@ void block_job_free(Job *job);*/ void block_job_user_resume (Job *job); +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ +/** * block_job_ratelimit_get_delay: *
Signature · 1 line
2.27.0
PATCH v5 12/31 assertions for blockjob_int.h
In reply to Emanuele Giuseppe Esposito--- blockjob.c | 4 ++++ 1 file changed, 4 insertions(+)
blockjob.c +4 -0
@@ -84,6 +84,7 @@ BlockJob *block_job_get(const char *id)void block_job_free (Job *job) {BlockJob *bjob =container_of (job, BlockJob, job); +assert (qemu_in_main_thread ());block_job_remove_all_bdrv (bjob);blk_unref (bjob->blk);
@@ -436,6 +437,8 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,BlockBackend *blk;BlockJob *job; +assert (qemu_in_main_thread ()); +if (job_id ==NULL && !(flags &JOB_INTERNAL )) { job_id =bdrv_get_device_name (bs); }
@@ -505,6 +508,7 @@ void block_job_iostatus_reset(BlockJob *job)void block_job_user_resume (Job *job) {BlockJob *bjob =container_of (job, BlockJob, job); +assert (qemu_in_main_thread ());block_job_iostatus_reset (bjob); }
Signature · 1 line
2.27.0
PATCH v5 13/31 block.c: add assertions to static functions
In reply to Emanuele Giuseppe EspositoFollowing the assertion derived from the API split, propagate the assertion also in the static functions.
--- block.c | 45 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-)
block.c +44 -1
@@ -434,6 +434,7 @@ BlockDriverState *bdrv_new(void)static BlockDriver *bdrv_do_find_format (const char *format_name) {BlockDriver *drv1; +assert (qemu_in_main_thread ()); QLIST_FOREACH(drv1, &bdrv_drivers, list) {if (!strcmp (drv1->format_name, format_name)) {
@@ -593,6 +594,8 @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,int64_t size;int ret; +assert (qemu_in_main_thread ()); + ret =blk_truncate (blk, minimum_size, false,PREALLOC_MODE_OFF ,0 , &local_err);if (ret <0 && ret != -ENOTSUP ) {
@@ -631,6 +634,8 @@ static int create_file_fallback_zero_first_sector(BlockBackend *blk,int64_t bytes_to_clear;int ret; +assert (qemu_in_main_thread ()); + bytes_to_clear =MIN (current_size,BDRV_SECTOR_SIZE );if (bytes_to_clear) { ret =blk_pwrite_zeroes (blk,0 , bytes_to_clear,BDRV_REQ_MAY_UNMAP );
@@ -891,6 +896,7 @@ static BlockDriver *find_hdev_driver(const char *filename) {int score_max =0 , score;BlockDriver *drv =NULL , *d; +assert (qemu_in_main_thread ()); QLIST_FOREACH(d, &bdrv_drivers, list) {if (d->bdrv_probe_device) {
@@ -908,6 +914,7 @@ static BlockDriver *find_hdev_driver(const char *filename)static BlockDriver *bdrv_do_find_protocol (const char *protocol) {BlockDriver *drv1; +assert (qemu_in_main_thread ()); QLIST_FOREACH(drv1, &bdrv_drivers, list) {if (drv1->protocol_name && !strcmp (drv1->protocol_name, protocol)) {
@@ -1016,6 +1023,8 @@ static int find_image_format(BlockBackend *file, const char *filename,uint8_t buf[BLOCK_PROBE_BUF_SIZE ];int ret =0 ; +assert (qemu_in_main_thread ()); +/* Return the raw BlockDriver * to scsi-generic devices or empty drives */ if (blk_is_sg (file) || !blk_is_inserted (file) ||blk_getlength (file) ==0 ) { *pdrv = &bdrv_raw;
@@ -1097,6 +1106,7 @@ static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,BlockdevDetectZeroesOptions detect_zeroes =qapi_enum_parse (&BlockdevDetectZeroesOptions_lookup, value,BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF , &local_err); +assert (qemu_in_main_thread ());g_free (value);if (local_err) {error_propagate (errp, local_err);
@@ -1214,6 +1224,7 @@ static void bdrv_child_cb_drained_end(BdrvChild *child,static int bdrv_child_cb_inactivate (BdrvChild *child) {BlockDriverState *bs = child->opaque; +assert (qemu_in_main_thread ());assert (bs->open_flags &BDRV_O_INACTIVE );return 0 ; }
@@ -1241,6 +1252,7 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, int parent_flags, QDict *parent_options) { *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT ) |BDRV_O_TEMPORARY ; +assert (qemu_in_main_thread ());/* For temporary files, unconditional cache=unsafe is fine */ qdict_set_default_str (child_options,BDRV_OPT_CACHE_DIRECT ,"off" );
@@ -1260,6 +1272,7 @@ static void bdrv_backing_attach(BdrvChild *c)BlockDriverState *parent = c->opaque;BlockDriverState *backing_hd = c->bs; +assert (qemu_in_main_thread ());assert (!parent->backing_blocker); error_setg(&parent->backing_blocker, "node is used as backing hd of '%s'",
@@ -1298,6 +1311,7 @@ static void bdrv_backing_detach(BdrvChild *c) {BlockDriverState *parent = c->opaque; +assert (qemu_in_main_thread ());assert (parent->backing_blocker);bdrv_op_unblock_all (c->bs, parent->backing_blocker);error_free (parent->backing_blocker);
@@ -1310,6 +1324,7 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,BlockDriverState *parent = c->opaque;bool read_only =bdrv_is_read_only (parent);int ret; +assert (qemu_in_main_thread ());if (read_only) { ret =bdrv_reopen_set_read_only (parent, false, errp);
@@ -1341,6 +1356,7 @@ static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format, int parent_flags, QDict *parent_options) { int flags = parent_flags; +assert (qemu_in_main_thread ());/* * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
@@ -1479,6 +1495,7 @@ AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)static int bdrv_open_flags (BlockDriverState *bs,int flags) {int open_flags = flags; +assert (qemu_in_main_thread ());/* * Clear flags that are internal to the block layer before opening the
@@ -1491,6 +1508,8 @@ static int bdrv_open_flags(BlockDriverState *bs, int flags)static void update_flags_from_options (int *flags,QemuOpts *opts) { +assert (qemu_in_main_thread ()); + *flags &= ~(BDRV_O_CACHE_MASK |BDRV_O_RDWR |BDRV_O_AUTO_RDONLY );if (qemu_opt_get_bool_del (opts,BDRV_OPT_CACHE_NO_FLUSH , false)) {
@@ -1512,6 +1531,7 @@ static void update_flags_from_options(int *flags, QemuOpts *opts)static void update_options_from_flags (QDict *options,int flags) { +assert (qemu_in_main_thread ());if (!qdict_haskey (options,BDRV_OPT_CACHE_DIRECT )) {qdict_put_bool (options,BDRV_OPT_CACHE_DIRECT , flags &BDRV_O_NOCACHE ); }
@@ -1533,6 +1553,7 @@ static void bdrv_assign_node_name(BlockDriverState *bs, Error **errp) {char *gen_node_name =NULL ; +assert (qemu_in_main_thread ());if (!node_name) { node_name = gen_node_name =id_generate (ID_BLOCK );
@@ -1779,6 +1800,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,assert (bs->file ==NULL );assert (options !=NULL && bs->options != options); +assert (qemu_in_main_thread ()); opts =qemu_opts_create (&bdrv_runtime_opts,NULL ,0 , &error_abort);if (!qemu_opts_absorb_qdict (opts, options, errp)) {
@@ -1904,6 +1926,7 @@ static QDict *parse_json_filename(const char *filename, Error **errp)QObject *options_obj;QDict *options;int ret; +assert (qemu_in_main_thread ()); ret =strstart (filename,"json:" , &filename);assert (ret);
@@ -1931,6 +1954,7 @@ static void parse_json_protocol(QDict *options, const char **pfilename, {QDict *json_options;Error *local_err =NULL ; +assert (qemu_in_main_thread ());/* Parse json: pseudo-protocol */ if (!*pfilename || !g_str_has_prefix (*pfilename,"json:" )) {
@@ -2184,6 +2208,8 @@ static GSList *bdrv_topological_dfs(GSList *list, GHashTable *found,BdrvChild *child;g_autoptr (GHashTable) local_found =NULL ; +assert (qemu_in_main_thread ()); +if (!found) {assert (!list); found = local_found =g_hash_table_new (NULL ,NULL );
@@ -2295,6 +2321,7 @@ typedef struct BdrvReplaceChildState {static void bdrv_replace_child_commit (void *opaque) {BdrvReplaceChildState *s = opaque; +assert (qemu_in_main_thread ());if (s->free_empty_child && !s->child->bs) {bdrv_child_free (s->child);
@@ -2307,6 +2334,7 @@ static void bdrv_replace_child_abort(void *opaque)BdrvReplaceChildState *s = opaque;BlockDriverState *new_bs = s->child->bs; +assert (qemu_in_main_thread ());/* * old_bs reference is transparently moved from @s to s->child. *
@@ -2872,6 +2900,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp,static void bdrv_child_free (BdrvChild *child) {assert (!child->bs); +assert (qemu_in_main_thread ());assert (!child->next.le_prev);/* not in children list */ g_free (child->name);
@@ -2952,6 +2981,7 @@ static int bdrv_attach_child_common(BlockDriverState *child_bs,assert (child);assert (*child ==NULL );assert (child_class->get_parent_desc); +assert (qemu_in_main_thread ()); new_child =g_new (BdrvChild,1 ); *new_child = (BdrvChild ) {
@@ -3032,6 +3062,7 @@ static int bdrv_attach_child_noperm(BlockDriverState *parent_bs,uint64_t perm, shared_perm;assert (parent_bs->drv); +assert (qemu_in_main_thread ());if (bdrv_recurse_has_child (child_bs, parent_bs)) { error_setg(errp, "Making '%s' a %s child of '%s' would create a cycle",
@@ -3057,6 +3088,7 @@ static void bdrv_detach_child(BdrvChild **childp) {BlockDriverState *old_bs = (*childp)->bs; +assert (qemu_in_main_thread ());bdrv_replace_child_noperm (childp,NULL , true);if (old_bs) {
@@ -3305,6 +3337,8 @@ static int bdrv_set_file_or_backing_noperm(BlockDriverState *parent_bs,BdrvChild *child = is_backing ? parent_bs->backing : parent_bs->file;BdrvChildRole role; +assert (qemu_in_main_thread ()); +if (!parent_bs->drv) {/* * Node without drv is an object without a class :/. TODO: finally fix
@@ -3384,6 +3418,7 @@ static int bdrv_set_backing_noperm(BlockDriverState *bs, BlockDriverState *backing_hd, Transaction *tran, Error **errp) { +assert (qemu_in_main_thread ());return bdrv_set_file_or_backing_noperm (bs, backing_hd, true, tran, errp); }
@@ -3659,6 +3694,8 @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,BlockDriverState *bs_snapshot =NULL ;int ret; +assert (qemu_in_main_thread ()); +/* if snapshot, we create a temporary backing file and open it instead of opening 'filename' directly */
@@ -4485,6 +4522,8 @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,QObject *value;const char *str; +assert (qemu_in_main_thread ()); + value =qdict_get (reopen_state->options, child_name);if (value ==NULL ) {return 0 ;
@@ -5024,7 +5063,7 @@ static void bdrv_remove_filter_or_cow_child_abort(void *opaque)static void bdrv_remove_filter_or_cow_child_commit (void *opaque) {BdrvRemoveFilterOrCowChild *s = opaque; - +assert (qemu_in_main_thread ());bdrv_child_free (s->child); }
@@ -5157,6 +5196,7 @@ static int bdrv_replace_node_common(BlockDriverState *from,BlockDriverState *to_cow_parent =NULL ;int ret; +assert (qemu_in_main_thread ());assert (to !=NULL );if (detach_subchain) {
@@ -5315,6 +5355,7 @@ static void bdrv_delete(BlockDriverState *bs) {assert (bdrv_op_blocker_is_empty (bs));assert (!bs->refcnt); +assert (qemu_in_main_thread ());/* remove from list, if necessary */ if (bs->node_name[0 ] !='\0' ) {
@@ -6318,6 +6359,7 @@ void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)static BlockDriverState *bdrv_find_debug_node (BlockDriverState *bs) { +assert (qemu_in_main_thread ());while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { bs =bdrv_primary_bs (bs); }
@@ -7128,6 +7170,7 @@ void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)static void bdrv_do_remove_aio_context_notifier (BdrvAioNotifier *ban) { +assert (qemu_in_main_thread ());QLIST_REMOVE (ban, list);g_free (ban); }
Signature · 1 line
2.27.0
Re: [PATCH v5 13/31] block.c: add assertions to static functions
Quoted 7 lines · Emanuele Giuseppe Esposito
Following the assertion derived from the API split, propagate the assertion also in the static functions.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block.c | 45 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-)
Looks good to me, just one small question:
Quoted 4 lines
block.c +0
-0
[...]
block.c static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, · line 1255
Quoted 5 lines
block.c +1
-0@@ -1241,6 +1252,7 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, int parent_flags, QDict *parent_options) { *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT ) |BDRV_O_TEMPORARY ; +assert (qemu_in_main_thread ());
Stylistically, it’s a bit strange that in other places, this assertion comes right after all local variable declarations, or after some assertions that are already present in that place; but here, it follows a normal statement. Is that on purpose?
Quoted 3 lines
block.c +0
-0/* For temporary files, unconditional cache=unsafe is fine */ qdict_set_default_str (child_options,BDRV_OPT_CACHE_DIRECT ,"off" );
Re: [PATCH v5 13/31] block.c: add assertions to static functions
Quoted 18 lines · Hanna Reitz
Quoted 7 lines · Emanuele Giuseppe Esposito
Following the assertion derived from the API split, propagate the assertion also in the static functions.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 45 ++++++++++++++++++++++++++++++++++++++++++++-1 file changed, 44 insertions(+), 1 deletion(-)Looks good to me, just one small question:
Quoted 4 lines
block.c +0
-0[...]
Quoted 8 lines
block.c static void bdrv_temp_snapshot_options(int · line 1256
Quoted 6 lines
block.c +1
-0@@ -1241,6 +1252,7 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, int parent_flags, QDict *parent_options) { *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY; + assert(qemu_in_main_thread());Stylistically, it’s a bit strange that in other places, this assertion comes right after all local variable declarations, or after some assertions that are already present in that place; but here, it follows a normal statement. Is that on purpose?
Nope :) Just a misread, I don't even recall when I added this. But I appreciate the investigative spirit :)
Quoted 4 lines
Quoted 3 lines
block.c +0
-0/* For temporary files, unconditional cache=unsafe is fine */ qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
PATCH v5 14/31 include/block/blockjob.h: global state API
In reply to Emanuele Giuseppe Espositoblockjob functions run always under the BQL lock.
--- include/block/blockjob.h | 9 +++++++++ 1 file changed, 9 insertions(+)
include/block/blockjob.h +9 -0
@@ -77,6 +77,13 @@ typedef struct BlockJob {GSList *nodes; } BlockJob; +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ +/** * block_job_next: * @job: A block job, or %NULL.
@@ -158,6 +165,8 @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp);*/ void block_job_iostatus_reset (BlockJob *job); +/* Common functions that are neither I/O nor Global State */ +/** * block_job_is_internal: * @job: The job to determine if it is user-visible or not.
Signature · 1 line
2.27.0
PATCH v5 15/31 assertions for blockjob.h global state API
In reply to Emanuele Giuseppe Esposito--- blockjob.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
blockjob.c +10 -0
@@ -62,6 +62,7 @@ static bool is_block_job(Job *job)BlockJob *block_job_next (BlockJob *bjob) {Job *job = bjob ? &bjob->job :NULL ; +assert (qemu_in_main_thread ()); do { job = job_next(job);
@@ -73,6 +74,7 @@ BlockJob *block_job_next(BlockJob *bjob)BlockJob *block_job_get (const char *id) {Job *job =job_get (id); +assert (qemu_in_main_thread ());if (job &&is_block_job (job)) {return container_of (job, BlockJob, job);
@@ -185,6 +187,7 @@ static const BdrvChildClass child_job = {void block_job_remove_all_bdrv (BlockJob *job) { +assert (qemu_in_main_thread ());/* * bdrv_root_unref_child() may reach child_job_[can_]set_aio_ctx(), * which will also traverse job->nodes, so consume the list one by
@@ -207,6 +210,7 @@ void block_job_remove_all_bdrv(BlockJob *job)bool block_job_has_bdrv (BlockJob *job,BlockDriverState *bs) {GSList *el; +assert (qemu_in_main_thread ());for (el = job->nodes; el; el = el->next) {BdrvChild *c = el->data;
@@ -223,6 +227,7 @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs, {BdrvChild *c;bool need_context_ops; +assert (qemu_in_main_thread ());bdrv_ref (bs);
@@ -272,6 +277,8 @@ bool block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)const BlockJobDriver *drv =block_job_driver (job);int64_t old_speed = job->speed; +assert (qemu_in_main_thread ()); +if (job_apply_verb (&job->job,JOB_VERB_SET_SPEED , errp) <0 ) {return false; }
@@ -309,6 +316,8 @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)BlockJobInfo *info;uint64_t progress_current, progress_total; +assert (qemu_in_main_thread ()); +if (block_job_is_internal (job)) {error_setg (errp,"Cannot query QEMU internal jobs" );return NULL ;
@@ -498,6 +507,7 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,void block_job_iostatus_reset (BlockJob *job) { +assert (qemu_in_main_thread ());if (job->iostatus ==BLOCK_DEVICE_IO_STATUS_OK ) {return ; }
Signature · 1 line
2.27.0
PATCH v5 16/31 include/sysemu/blockdev.h: global state API
In reply to Emanuele Giuseppe Espositoblockdev functions run always under the BQL lock.
--- include/sysemu/blockdev.h | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
include/sysemu/blockdev.h +10 -3
@@ -13,9 +13,6 @@#include "block/block.h" #include "qemu/queue.h" -void blockdev_mark_auto_del (BlockBackend *blk); -void blockdev_auto_del (BlockBackend *blk); - typedef enum { IF_DEFAULT = -1, /* for use with drive_add() only */ /*
@@ -40,6 +37,16 @@ struct DriveInfo {QTAILQ_ENTRY (DriveInfo) next; }; +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ + +void blockdev_mark_auto_del (BlockBackend *blk); +void blockdev_auto_del (BlockBackend *blk); +DriveInfo *blk_legacy_dinfo (BlockBackend *blk);DriveInfo *blk_set_legacy_dinfo (BlockBackend *blk,DriveInfo *dinfo);BlockBackend *blk_by_legacy_dinfo (DriveInfo *dinfo);
Signature · 1 line
2.27.0
PATCH v5 17/31 assertions for blockdev.h global state API
In reply to Emanuele Giuseppe Esposito--- block/block-backend.c | 3 +++ blockdev.c | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
block/block-backend.c +3 -0
@@ -794,6 +794,7 @@ bool bdrv_is_root_node(BlockDriverState *bs)*/ DriveInfo *blk_legacy_dinfo (BlockBackend *blk) { +assert (qemu_in_main_thread ());return blk->legacy_dinfo; }
@@ -805,6 +806,7 @@ DriveInfo *blk_legacy_dinfo(BlockBackend *blk)DriveInfo *blk_set_legacy_dinfo (BlockBackend *blk,DriveInfo *dinfo) {assert (!blk->legacy_dinfo); +assert (qemu_in_main_thread ());return blk->legacy_dinfo = dinfo; }
@@ -815,6 +817,7 @@ DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)BlockBackend *blk_by_legacy_dinfo (DriveInfo *dinfo) {BlockBackend *blk =NULL ; +assert (qemu_in_main_thread ());while ((blk =blk_next (blk)) !=NULL ) {if (blk->legacy_dinfo == dinfo) {
blockdev.c +15 -0
@@ -113,6 +113,8 @@ void override_max_devs(BlockInterfaceType type, int max_devs)BlockBackend *blk;DriveInfo *dinfo; +assert (qemu_in_main_thread ()); +if (max_devs <=0 ) {return ; }
@@ -142,6 +144,8 @@ void blockdev_mark_auto_del(BlockBackend *blk)DriveInfo *dinfo =blk_legacy_dinfo (blk);BlockJob *job; +assert (qemu_in_main_thread ()); +if (!dinfo) {return ; }
@@ -163,6 +167,7 @@ void blockdev_mark_auto_del(BlockBackend *blk)void blockdev_auto_del (BlockBackend *blk) {DriveInfo *dinfo =blk_legacy_dinfo (blk); +assert (qemu_in_main_thread ());if (dinfo && dinfo->auto_del) {monitor_remove_blk (blk);
@@ -187,6 +192,8 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)BlockBackend *blk;DriveInfo *dinfo; +assert (qemu_in_main_thread ()); +for (blk =blk_next (NULL ); blk; blk =blk_next (blk)) { dinfo =blk_legacy_dinfo (blk); if (dinfo && dinfo->type == type
@@ -209,6 +216,8 @@ void drive_check_orphaned(void)Location loc;bool orphans = false; +assert (qemu_in_main_thread ()); +for (blk =blk_next (NULL ); blk; blk =blk_next (blk)) { dinfo =blk_legacy_dinfo (blk);/*
@@ -242,6 +251,7 @@ void drive_check_orphaned(void)DriveInfo *drive_get_by_index (BlockInterfaceType type,int index) { +assert (qemu_in_main_thread ());return drive_get (type,drive_index_to_bus_id (type, index),drive_index_to_unit_id (type, index));
@@ -253,6 +263,8 @@ int drive_get_max_bus(BlockInterfaceType type)BlockBackend *blk;DriveInfo *dinfo; +assert (qemu_in_main_thread ()); + max_bus =-1 ;for (blk =blk_next (NULL ); blk; blk =blk_next (blk)) { dinfo =blk_legacy_dinfo (blk);
@@ -269,6 +281,7 @@ int drive_get_max_bus(BlockInterfaceType type)DriveInfo *drive_get_next (BlockInterfaceType type) {static int next_block_unit[IF_COUNT ]; +assert (qemu_in_main_thread ());return drive_get (type,0 , next_block_unit[type]++); }
@@ -749,6 +762,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,const char *filename;int i; +assert (qemu_in_main_thread ()); +/* Change legacy command line options into QMP ones */ static const struct { const char *from;
Signature · 1 line
2.27.0
PATCH v5 18/31 include/block/snapshot: global state API + assertions
In reply to Emanuele Giuseppe EspositoSnapshots run also under the BQL lock, so they all are in the global state API. The aiocontext lock that they hold is currently an overkill and in future could be removed.
--- include/block/snapshot.h | 13 +++++++++++-- block/snapshot.c | 28 ++++++++++++++++++++++++++++ migration/savevm.c | 2 ++ 3 files changed, 41 insertions(+), 2 deletions(-)
include/block/snapshot.h +11 -2
@@ -45,6 +45,13 @@ typedef struct QEMUSnapshotInfo {uint64_t icount;/* record/replay step */ } QEMUSnapshotInfo; +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ +int bdrv_snapshot_find (BlockDriverState *bs,QEMUSnapshotInfo *sn_info,const char *name); bool bdrv_snapshot_find_by_id_and_name(BlockDriverState *bs,
@@ -73,9 +80,11 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs, Error **errp); -/* Group operations. All block drivers are involved. +/* +* Group operations. All block drivers are involved. * These functions will properly handle dataplane (take aio_context_acquire -* when appropriate for appropriate block drivers */ +* when appropriate for appropriate block drivers +*/ bool bdrv_all_can_snapshot (bool has_devices,strList *devices,Error **errp);
block/snapshot.c +28 -0
@@ -57,6 +57,8 @@ int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,QEMUSnapshotInfo *sn_tab, *sn;int nb_sns, i, ret; +assert (qemu_in_main_thread ()); + ret = -ENOENT ; nb_sns =bdrv_snapshot_list (bs, &sn_tab);if (nb_sns <0 ) {
@@ -105,6 +107,7 @@ bool bdrv_snapshot_find_by_id_and_name(BlockDriverState *bs,bool ret = false;assert (id || name); +assert (qemu_in_main_thread ()); nb_sns =bdrv_snapshot_list (bs, &sn_tab);if (nb_sns <0 ) {
@@ -200,6 +203,7 @@ static BlockDriverState *bdrv_snapshot_fallback(BlockDriverState *bs)int bdrv_can_snapshot (BlockDriverState *bs) {BlockDriver *drv = bs->drv; +assert (qemu_in_main_thread ());if (!drv || !bdrv_is_inserted (bs) ||bdrv_is_read_only (bs)) {return 0 ; }
@@ -220,6 +224,9 @@ int bdrv_snapshot_create(BlockDriverState *bs, {BlockDriver *drv = bs->drv;BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs); + +assert (qemu_in_main_thread ()); +if (!drv) {return -ENOMEDIUM ; }
@@ -240,6 +247,8 @@ int bdrv_snapshot_goto(BlockDriverState *bs,BdrvChild **fallback_ptr;int ret, open_ret; +assert (qemu_in_main_thread ()); +if (!drv) {error_setg (errp,"Block driver is closed" );return -ENOMEDIUM ;
@@ -348,6 +357,8 @@ int bdrv_snapshot_delete(BlockDriverState *bs,BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs);int ret; +assert (qemu_in_main_thread ()); +if (!drv) {error_setg (errp,QERR_DEVICE_HAS_NO_MEDIUM ,bdrv_get_device_name (bs));return -ENOMEDIUM ;
@@ -380,6 +391,8 @@ int bdrv_snapshot_list(BlockDriverState *bs, {BlockDriver *drv = bs->drv;BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs); + +assert (qemu_in_main_thread ());if (!drv) {return -ENOMEDIUM ; }
@@ -419,6 +432,8 @@ int bdrv_snapshot_load_tmp(BlockDriverState *bs, {BlockDriver *drv = bs->drv; +assert (qemu_in_main_thread ()); +if (!drv) {error_setg (errp,QERR_DEVICE_HAS_NO_MEDIUM ,bdrv_get_device_name (bs));return -ENOMEDIUM ;
@@ -447,6 +462,8 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,int ret;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); + ret =bdrv_snapshot_load_tmp (bs, id_or_name,NULL , &local_err);if (ret == -ENOENT || ret == -EINVAL ) {error_free (local_err);
@@ -515,6 +532,8 @@ bool bdrv_all_can_snapshot(bool has_devices, strList *devices,g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ()); +if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return false; }
@@ -549,6 +568,8 @@ int bdrv_all_delete_snapshot(const char *name,g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ()); +if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return -1 ; }
@@ -588,6 +609,8 @@ int bdrv_all_goto_snapshot(const char *name,g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ()); +if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return -1 ; }
@@ -622,6 +645,8 @@ int bdrv_all_has_snapshot(const char *name,g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ()); +if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return -1 ; }
@@ -663,6 +688,7 @@ int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn, {g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ());if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return -1 ;
@@ -703,6 +729,8 @@ BlockDriverState *bdrv_all_find_vmstate_bs(const char *vmstate_bs,g_autoptr (GList) bdrvs =NULL ;GList *iterbdrvs; +assert (qemu_in_main_thread ()); +if (bdrv_all_get_snapshot_devices (has_devices, devices, &bdrvs, errp) <0 ) {return NULL ; }
migration/savevm.c +2 -0
@@ -2786,6 +2786,8 @@ bool save_snapshot(const char *name, bool overwrite, const char *vmstate,g_autoptr (GDateTime) now =g_date_time_new_now_local ();AioContext *aio_context; +assert (qemu_in_main_thread ()); +if (migration_is_blocked (errp)) {return false; }
Signature · 1 line
2.27.0
PATCH v5 19/31 block/copy-before-write.h: global state API + assertions
In reply to Emanuele Giuseppe Espositocopy-before-write functions always run under BQL lock.
--- block/copy-before-write.h | 7 +++++++ block/copy-before-write.c | 2 ++ 2 files changed, 9 insertions(+)
block/copy-before-write.h +7 -0
@@ -29,6 +29,13 @@#include "block/block_int.h" #include "block/block-copy.h" +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ + BlockDriverState *bdrv_cbw_append(BlockDriverState *source, BlockDriverState *target, const char *filter_node_name,
block/copy-before-write.c +2 -0
@@ -223,6 +223,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,QDict *opts;assert (source->total_sectors == target->total_sectors); +assert (qemu_in_main_thread ()); opts =qdict_new ();qdict_put_str (opts,"driver" ,"copy-before-write" );
@@ -245,6 +246,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,void bdrv_cbw_drop (BlockDriverState *bs) { +assert (qemu_in_main_thread ());bdrv_drop_filter (bs, &error_abort);bdrv_unref (bs); }
Signature · 1 line
2.27.0
PATCH v5 20/31 block/coroutines: I/O API
In reply to Emanuele Giuseppe Espositoblock coroutines functions run in different aiocontext, and are not protected by the BQL. Therefore are I/O.
--- block/coroutines.h | 6 ++++++ 1 file changed, 6 insertions(+)
block/coroutines.h +6 -0
@@ -29,6 +29,12 @@/* For blk_bs() in generated block/block-gen.c */ #include "sysemu/block-backend.h" +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ int coroutine_fn bdrv_co_check(BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix);
Signature · 1 line
2.27.0
PATCH v5 21/31 block_int-common.h: split function pointers in BlockDriver
In reply to Emanuele Giuseppe EspositoSimilar to the header split, also the function pointers in BlockDriver can be split in I/O and global state.
--- include/block/block_int-common.h | 440 +++++++++++++++++-------------- 1 file changed, 235 insertions(+), 205 deletions(-)
include/block/block_int-common.h +235 -205
@@ -96,6 +96,11 @@ typedef struct BdrvTrackedRequest {struct BlockDriver { +/* +* These fields are initialized when this object is created, +* and are never changed afterwards. +*/ +const char *format_name;int instance_size;
@@ -121,23 +126,7 @@ struct BlockDriver {* on those children. */ bool is_format; -/* -* Return true if @to_replace can be replaced by a BDS with the -* same data as @bs without it affecting @bs's behavior (that is, -* without it being visible to @bs's parents). -*/ -bool (*bdrv_recurse_can_replace)(BlockDriverState *bs, -BlockDriverState *to_replace); - -int (*bdrv_probe)(const uint8_t *buf,int buf_size,const char *filename); -int (*bdrv_probe_device)(const char *filename); -/* -* Any driver implementing this callback is expected to be able to handle -* NULL file names in its .bdrv_open() implementation. -*/ -void (*bdrv_parse_filename)(const char *filename,QDict *options, -Error **errp);/* * Drivers not implementing bdrv_parse_filename nor bdrv_open should have * this field set to true, except ones that are defined only by their
@@ -159,7 +148,66 @@ struct BlockDriver {*/ bool supports_backing; -/* For handling image reopen for split or non-split files */ +bool has_variable_length; + +/* +* Drivers setting this field must be able to work with just a plain +* filename with '<protocol_name>:' as a prefix, and no other options. +* Options may be extracted from the filename by implementing +* bdrv_parse_filename. +*/ +const char *protocol_name; + +/* List of options for creating images, terminated by name == NULL */ +QemuOptsList *create_opts; + +/* List of options for image amend */ +QemuOptsList *amend_opts; + +/* +* If this driver supports reopening images this contains a +* NULL-terminated list of the runtime options that can be +* modified. If an option in this list is unspecified during +* reopen then it _must_ be reset to its default value or return +* an error. +*/ +const char *const *mutable_opts; + +/* +* Pointer to a NULL-terminated array of names of strong options +* that can be specified for bdrv_open(). A strong option is one +* that changes the data of a BDS. +* If this pointer is NULL, the array is considered empty. +* "filename" and "driver" are always considered strong. +*/ +const char *const *strong_runtime_opts; + +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ + +/* +* Return true if @to_replace can be replaced by a BDS with the +* same data as @bs without it affecting @bs's behavior (that is, +* without it being visible to @bs's parents). +*/ +bool (*bdrv_recurse_can_replace)(BlockDriverState *bs, +BlockDriverState *to_replace); + +int (*bdrv_probe)(const uint8_t *buf,int buf_size,const char *filename); +int (*bdrv_probe_device)(const char *filename); + +/* +* Any driver implementing this callback is expected to be able to handle +* NULL file names in its .bdrv_open() implementation. +*/ +void (*bdrv_parse_filename)(const char *filename,QDict *options, +Error **errp); + +/* For handling image reopen for split or non-split files. */ int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state,BlockReopenQueue *queue,Error **errp);void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state);
@@ -175,7 +223,6 @@ struct BlockDriver { Error **errp);void (*bdrv_close)(BlockDriverState *bs); - int coroutine_fn (*bdrv_co_create)(BlockdevCreateOptions *opts,Error **errp); int coroutine_fn (*bdrv_co_create_opts)(BlockDriver *drv,
@@ -183,11 +230,6 @@ struct BlockDriver { QemuOpts *opts, Error **errp); - int coroutine_fn (*bdrv_co_amend)(BlockDriverState *bs, -BlockdevAmendOptions *opts, -bool force, -Error **errp); - int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts, BlockDriverAmendStatusCB *status_cb,
@@ -234,6 +276,176 @@ struct BlockDriver {*/ char *(*bdrv_dirname)(BlockDriverState *bs,Error **errp); +/* +* This informs the driver that we are no longer interested in the result +* of in-flight requests, so don't waste the time if possible. +* +* One example usage is to avoid waiting for an nbd target node reconnect +* timeout during job-cancel with force=true. +*/ +void (*bdrv_cancel_in_flight)(BlockDriverState *bs); + +int (*bdrv_inactivate)(BlockDriverState *bs); + +int (*bdrv_snapshot_create)(BlockDriverState *bs, +QEMUSnapshotInfo *sn_info); +int (*bdrv_snapshot_goto)(BlockDriverState *bs, +const char *snapshot_id); +int (*bdrv_snapshot_delete)(BlockDriverState *bs, +const char *snapshot_id, +const char *name, +Error **errp); +int (*bdrv_snapshot_list)(BlockDriverState *bs, +QEMUSnapshotInfo **psn_info); +int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, +const char *snapshot_id, +const char *name, +Error **errp); + +int (*bdrv_change_backing_file)(BlockDriverState *bs, +const char *backing_file,const char *backing_fmt); + +/* removable device specific */ +void (*bdrv_eject)(BlockDriverState *bs,bool eject_flag); +void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked); + +/* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ +int (*bdrv_debug_breakpoint)(BlockDriverState *bs,const char *event, +const char *tag); +int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, +const char *tag); +int (*bdrv_debug_resume)(BlockDriverState *bs,const char *tag); +bool (*bdrv_debug_is_suspended)(BlockDriverState *bs,const char *tag); + +void (*bdrv_refresh_limits)(BlockDriverState *bs,Error **errp); + +/* +* Returns 1 if newly created images are guaranteed to contain only +* zeros, 0 otherwise. +*/ +int (*bdrv_has_zero_init)(BlockDriverState *bs); + +/* +* Remove fd handlers, timers, and other event loop callbacks so the event +* loop is no longer in use. Called with no in-flight requests and in +* depth-first traversal order with parents before child nodes. +*/ +void (*bdrv_detach_aio_context)(BlockDriverState *bs); + +/* +* Add fd handlers, timers, and other event loop callbacks so I/O requests +* can be processed again. Called with no in-flight requests and in +* depth-first traversal order with child nodes before parent nodes. +*/ +void (*bdrv_attach_aio_context)(BlockDriverState *bs, +AioContext *new_context); + +/** +* Try to get @bs's logical and physical block size. +* On success, store them in @bsz and return zero. +* On failure, return negative errno. +*/ +int (*bdrv_probe_blocksizes)(BlockDriverState *bs,BlockSizes *bsz); +/** +* Try to get @bs's geometry (cyls, heads, sectors) +* On success, store them in @geo and return 0. +* On failure return -errno. +* Only drivers that want to override guest geometry implement this +* callback; see hd_geometry_guess(). +*/ +int (*bdrv_probe_geometry)(BlockDriverState *bs,HDGeometry *geo); + +void (*bdrv_add_child)(BlockDriverState *parent,BlockDriverState *child, +Error **errp); +void (*bdrv_del_child)(BlockDriverState *parent,BdrvChild *child, +Error **errp); + +/** +* Informs the block driver that a permission change is intended. The +* driver checks whether the change is permissible and may take other +* preparations for the change (e.g. get file system locks). This operation +* is always followed either by a call to either .bdrv_set_perm or +* .bdrv_abort_perm_update. +* +* Checks whether the requested set of cumulative permissions in @perm +* can be granted for accessing @bs and whether no other users are using +* permissions other than those given in @shared (both arguments take +* BLK_PERM_* bitmasks). +* +* If both conditions are met, 0 is returned. Otherwise, -errno is returned +* and errp is set to an error describing the conflict. +*/ +int (*bdrv_check_perm)(BlockDriverState *bs,uint64_t perm, +uint64_t shared,Error **errp); + +/** +* Called to inform the driver that the set of cumulative set of used +* permissions for @bs has changed to @perm, and the set of sharable +* permission to @shared. The driver can use this to propagate changes to +* its children (i.e. request permissions only if a parent actually needs +* them). +* +* This function is only invoked after bdrv_check_perm(), so block drivers +* may rely on preparations made in their .bdrv_check_perm implementation. +*/ +void (*bdrv_set_perm)(BlockDriverState *bs,uint64_t perm,uint64_t shared); + +/* +* Called to inform the driver that after a previous bdrv_check_perm() +* call, the permission update is not performed and any preparations made +* for it (e.g. taken file locks) need to be undone. +* +* This function can be called even for nodes that never saw a +* bdrv_check_perm() call. It is a no-op then. +*/ +void (*bdrv_abort_perm_update)(BlockDriverState *bs); + +/** +* Returns in @nperm and @nshared the permissions that the driver for @bs +* needs on its child @c, based on the cumulative permissions requested by +* the parents in @parent_perm and @parent_shared. +* +* If @c is NULL, return the permissions for attaching a new child for the +* given @child_class and @role. +* +* If @reopen_queue is non-NULL, don't return the currently needed +* permissions, but those that will be needed after applying the +* @reopen_queue. +*/ +void (*bdrv_child_perm)(BlockDriverState *bs,BdrvChild *c, +BdrvChildRole role, +BlockReopenQueue *reopen_queue, +uint64_t parent_perm,uint64_t parent_shared, +uint64_t *nperm,uint64_t *nshared); + +/** +* Register/unregister a buffer for I/O. For example, when the driver is +* interested to know the memory areas that will later be used in iovs, so +* that it can do IOMMU mapping with VFIO etc., in order to get better +* performance. In the case of VFIO drivers, this callback is used to do +* DMA mapping for hot buffers. +*/ +void (*bdrv_register_buf)(BlockDriverState *bs,void *host,size_t size); +void (*bdrv_unregister_buf)(BlockDriverState *bs,void *host); + +/* +* This field is modified only under the BQL, and is part of +* the global state. +*/ +QLIST_ENTRY (BlockDriver) list; + +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ + + int coroutine_fn (*bdrv_co_amend)(BlockDriverState *bs, +BlockdevAmendOptions *opts, +bool force, +Error **errp); +/* aio */ BlockAIOCB *(*bdrv_aio_preadv)(BlockDriverState *bs, int64_t offset, int64_t bytes, QEMUIOVector *qiov,
@@ -374,21 +586,11 @@ struct BlockDriver { bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, int64_t *map, BlockDriverState **file); -/* -* This informs the driver that we are no longer interested in the result -* of in-flight requests, so don't waste the time if possible. -* -* One example usage is to avoid waiting for an nbd target node reconnect -* timeout during job-cancel with force=true. -*/ -void (*bdrv_cancel_in_flight)(BlockDriverState *bs); -/* * Invalidate any cached meta-data. */ void coroutine_fn (*bdrv_co_invalidate_cache)(BlockDriverState *bs,Error **errp); -int (*bdrv_inactivate)(BlockDriverState *bs);/* * Flushes all data for all layers by calling bdrv_co_flush for underlying
@@ -414,14 +616,6 @@ struct BlockDriver {*/ int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); -/* -* Drivers setting this field must be able to work with just a plain -* filename with '<protocol_name>:' as a prefix, and no other options. -* Options may be extracted from the filename by implementing -* bdrv_parse_filename. -*/ -const char *protocol_name; -/* * Truncate @bs to @offset bytes using the given @prealloc mode * when growing. Modes other than PREALLOC_MODE_OFF should be
@@ -439,7 +633,6 @@ struct BlockDriver { bool exact, PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);int64_t (*bdrv_getlength)(BlockDriverState *bs); -bool has_variable_length;int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, Error **errp);
@@ -450,20 +643,6 @@ struct BlockDriver { int64_t offset, int64_t bytes, QEMUIOVector *qiov, size_t qiov_offset); -int (*bdrv_snapshot_create)(BlockDriverState *bs, -QEMUSnapshotInfo *sn_info); -int (*bdrv_snapshot_goto)(BlockDriverState *bs, -const char *snapshot_id); -int (*bdrv_snapshot_delete)(BlockDriverState *bs, -const char *snapshot_id, -const char *name, -Error **errp); -int (*bdrv_snapshot_list)(BlockDriverState *bs, -QEMUSnapshotInfo **psn_info); -int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, -const char *snapshot_id, -const char *name, -Error **errp);int (*bdrv_get_info)(BlockDriverState *bs,BlockDriverInfo *bdi); ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs,
@@ -477,13 +656,8 @@ struct BlockDriver {QEMUIOVector *qiov, int64_t pos); -int (*bdrv_change_backing_file)(BlockDriverState *bs, -const char *backing_file,const char *backing_fmt); -/* removable device specific */ bool (*bdrv_is_inserted)(BlockDriverState *bs); -void (*bdrv_eject)(BlockDriverState *bs,bool eject_flag); -void (*bdrv_lock_medium)(BlockDriverState *bs,bool locked);/* to control generic scsi devices */ BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs,
@@ -492,21 +666,6 @@ struct BlockDriver { int coroutine_fn (*bdrv_co_ioctl)(BlockDriverState *bs,unsigned long int req,void *buf); -/* List of options for creating images, terminated by name == NULL */ -QemuOptsList *create_opts; - -/* List of options for image amend */ -QemuOptsList *amend_opts; - -/* -* If this driver supports reopening images this contains a -* NULL-terminated list of the runtime options that can be -* modified. If an option in this list is unspecified during -* reopen then it _must_ be reset to its default value or return -* an error. -*/ -const char *const *mutable_opts; -/* * Returns 0 for completed check, -errno for internal errors. * The check results are stored in result.
@@ -517,56 +676,10 @@ struct BlockDriver {void (*bdrv_debug_event)(BlockDriverState *bs,BlkdebugEvent event); -/* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ -int (*bdrv_debug_breakpoint)(BlockDriverState *bs,const char *event, -const char *tag); -int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, -const char *tag); -int (*bdrv_debug_resume)(BlockDriverState *bs,const char *tag); -bool (*bdrv_debug_is_suspended)(BlockDriverState *bs,const char *tag); - -void (*bdrv_refresh_limits)(BlockDriverState *bs,Error **errp); - -/* -* Returns 1 if newly created images are guaranteed to contain only -* zeros, 0 otherwise. -*/ -int (*bdrv_has_zero_init)(BlockDriverState *bs); - -/* -* Remove fd handlers, timers, and other event loop callbacks so the event -* loop is no longer in use. Called with no in-flight requests and in -* depth-first traversal order with parents before child nodes. -*/ -void (*bdrv_detach_aio_context)(BlockDriverState *bs); - -/* -* Add fd handlers, timers, and other event loop callbacks so I/O requests -* can be processed again. Called with no in-flight requests and in -* depth-first traversal order with child nodes before parent nodes. -*/ -void (*bdrv_attach_aio_context)(BlockDriverState *bs, -AioContext *new_context); -/* io queue for linux-aio */ void (*bdrv_io_plug)(BlockDriverState *bs);void (*bdrv_io_unplug)(BlockDriverState *bs); -/** -* Try to get @bs's logical and physical block size. -* On success, store them in @bsz and return zero. -* On failure, return negative errno. -*/ -int (*bdrv_probe_blocksizes)(BlockDriverState *bs,BlockSizes *bsz); -/** -* Try to get @bs's geometry (cyls, heads, sectors) -* On success, store them in @geo and return 0. -* On failure return -errno. -* Only drivers that want to override guest geometry implement this -* callback; see hd_geometry_guess(). -*/ -int (*bdrv_probe_geometry)(BlockDriverState *bs,HDGeometry *geo); -/** * bdrv_co_drain_begin is called if implemented in the beginning of a * drain operation to drain and stop any internal sources of requests in
@@ -580,69 +693,6 @@ struct BlockDriver { void coroutine_fn (*bdrv_co_drain_begin)(BlockDriverState *bs); void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs); -void (*bdrv_add_child)(BlockDriverState *parent,BlockDriverState *child, -Error **errp); -void (*bdrv_del_child)(BlockDriverState *parent,BdrvChild *child, -Error **errp); - -/** -* Informs the block driver that a permission change is intended. The -* driver checks whether the change is permissible and may take other -* preparations for the change (e.g. get file system locks). This operation -* is always followed either by a call to either .bdrv_set_perm or -* .bdrv_abort_perm_update. -* -* Checks whether the requested set of cumulative permissions in @perm -* can be granted for accessing @bs and whether no other users are using -* permissions other than those given in @shared (both arguments take -* BLK_PERM_* bitmasks). -* -* If both conditions are met, 0 is returned. Otherwise, -errno is returned -* and errp is set to an error describing the conflict. -*/ -int (*bdrv_check_perm)(BlockDriverState *bs,uint64_t perm, -uint64_t shared,Error **errp); - -/** -* Called to inform the driver that the set of cumulative set of used -* permissions for @bs has changed to @perm, and the set of sharable -* permission to @shared. The driver can use this to propagate changes to -* its children (i.e. request permissions only if a parent actually needs -* them). -* -* This function is only invoked after bdrv_check_perm(), so block drivers -* may rely on preparations made in their .bdrv_check_perm implementation. -*/ -void (*bdrv_set_perm)(BlockDriverState *bs,uint64_t perm,uint64_t shared); - -/* -* Called to inform the driver that after a previous bdrv_check_perm() -* call, the permission update is not performed and any preparations made -* for it (e.g. taken file locks) need to be undone. -* -* This function can be called even for nodes that never saw a -* bdrv_check_perm() call. It is a no-op then. -*/ -void (*bdrv_abort_perm_update)(BlockDriverState *bs); - -/** -* Returns in @nperm and @nshared the permissions that the driver for @bs -* needs on its child @c, based on the cumulative permissions requested by -* the parents in @parent_perm and @parent_shared. -* -* If @c is NULL, return the permissions for attaching a new child for the -* given @child_class and @role. -* -* If @reopen_queue is non-NULL, don't return the currently needed -* permissions, but those that will be needed after applying the -* @reopen_queue. -*/ -void (*bdrv_child_perm)(BlockDriverState *bs,BdrvChild *c, -BdrvChildRole role, -BlockReopenQueue *reopen_queue, -uint64_t parent_perm,uint64_t parent_shared, -uint64_t *nperm,uint64_t *nshared); -bool (*bdrv_supports_persistent_dirty_bitmap)(BlockDriverState *bs); bool (*bdrv_co_can_store_new_dirty_bitmap)(BlockDriverState *bs, const char *name,
@@ -651,26 +701,6 @@ struct BlockDriver {int (*bdrv_co_remove_persistent_dirty_bitmap)(BlockDriverState *bs,const char *name,Error **errp); - -/** -* Register/unregister a buffer for I/O. For example, when the driver is -* interested to know the memory areas that will later be used in iovs, so -* that it can do IOMMU mapping with VFIO etc., in order to get better -* performance. In the case of VFIO drivers, this callback is used to do -* DMA mapping for hot buffers. -*/ -void (*bdrv_register_buf)(BlockDriverState *bs,void *host,size_t size); -void (*bdrv_unregister_buf)(BlockDriverState *bs,void *host); -QLIST_ENTRY (BlockDriver) list; - -/* -* Pointer to a NULL-terminated array of names of strong options -* that can be specified for bdrv_open(). A strong option is one -* that changes the data of a BDS. -* If this pointer is NULL, the array is considered empty. -* "filename" and "driver" are always considered strong. -*/ -const char *const *strong_runtime_opts; };static inline bool block_driver_can_compress (BlockDriver *drv)
Signature · 1 line
2.27.0
PATCH v5 22/31 block_int-common.h: assertion in the callers of BlockDriver function pointers
In reply to Emanuele Giuseppe Esposito--- block.c | 18 ++++++++++++++++++ block/create.c | 10 ++++++++++ 2 files changed, 28 insertions(+)
block.c +18 -0
@@ -526,6 +526,7 @@ static void coroutine_fn bdrv_create_co_entry(void *opaque)CreateCo *cco = opaque;assert (cco->drv); +assert (qemu_in_main_thread ()); ret = cco->drv->bdrv_co_create_opts (cco->drv, cco->filename, cco->opts, &local_err);
@@ -1090,6 +1091,7 @@ int refresh_total_sectors(BlockDriverState *bs, int64_t hint)static void bdrv_join_options (BlockDriverState *bs,QDict *options,QDict *old_options) { +assert (qemu_in_main_thread ());if (bs->drv && bs->drv->bdrv_join_options) { bs->drv->bdrv_join_options (options, old_options); }else {
@@ -1598,6 +1600,7 @@ static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, {Error *local_err =NULL ;int i, ret; +assert (qemu_in_main_thread ());bdrv_assign_node_name (bs, node_name, &local_err);if (local_err) {
@@ -1989,6 +1992,8 @@ static int bdrv_fill_options(QDict **options, const char *filename,BlockDriver *drv =NULL ;Error *local_err =NULL ; +assert (qemu_in_main_thread ()); +/* * Caution: while qdict_get_try_str() is fine, getting non-string * types would require more care. When @options come from
@@ -2182,6 +2187,7 @@ static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs, uint64_t *nperm, uint64_t *nshared) { assert(bs->drv && bs->drv->bdrv_child_perm); +assert (qemu_in_main_thread ()); bs->drv->bdrv_child_perm (bs, c, role, reopen_queue, parent_perm, parent_shared, nperm, nshared);
@@ -2267,6 +2273,7 @@ static void bdrv_drv_set_perm_commit(void *opaque) {BlockDriverState *bs = opaque;uint64_t cumulative_perms, cumulative_shared_perms; +assert (qemu_in_main_thread ());if (bs->drv->bdrv_set_perm) { bdrv_get_cumulative_perm(bs, &cumulative_perms,
@@ -2278,6 +2285,7 @@ static void bdrv_drv_set_perm_commit(void *opaque)static void bdrv_drv_set_perm_abort (void *opaque) {BlockDriverState *bs = opaque; +assert (qemu_in_main_thread ());if (bs->drv->bdrv_abort_perm_update) { bs->drv->bdrv_abort_perm_update (bs);
@@ -2293,6 +2301,7 @@ static int bdrv_drv_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared_perm, Transaction *tran, Error **errp) { +assert (qemu_in_main_thread ());if (!bs->drv) {return 0 ; }
@@ -4357,6 +4366,7 @@ int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)assert (qemu_get_current_aio_context () ==qemu_get_aio_context ());assert (bs_queue !=NULL ); +assert (qemu_in_main_thread ()); QTAILQ_FOREACH(bs_entry, bs_queue, entry) { ctx =bdrv_get_aio_context (bs_entry->state.bs);
@@ -4622,6 +4632,7 @@ static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,assert (reopen_state !=NULL );assert (reopen_state->bs->drv !=NULL ); +assert (qemu_in_main_thread ()); drv = reopen_state->bs->drv;/* This function and each driver's bdrv_reopen_prepare() remove
@@ -4832,6 +4843,7 @@ static void bdrv_reopen_commit(BDRVReopenState *reopen_state) bs = reopen_state->bs; drv = bs->drv;assert (drv !=NULL ); +assert (qemu_in_main_thread ());/* If there are any driver level actions to take */ if (drv->bdrv_reopen_commit) {
@@ -4873,6 +4885,7 @@ static void bdrv_reopen_abort(BDRVReopenState *reopen_state)assert (reopen_state !=NULL ); drv = reopen_state->bs->drv;assert (drv !=NULL ); +assert (qemu_in_main_thread ());if (drv->bdrv_reopen_abort) { drv->bdrv_reopen_abort (reopen_state);
@@ -4886,6 +4899,7 @@ static void bdrv_close(BlockDriverState *bs)BdrvChild *child, *next;assert (!bs->refcnt); +assert (qemu_in_main_thread ());bdrv_drained_begin (bs);/* complete I/O */ bdrv_flush (bs);
@@ -6671,6 +6685,8 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs)int ret;uint64_t cumulative_perms, cumulative_shared_perms; +assert (qemu_in_main_thread ()); +if (!bs->drv) {return -ENOMEDIUM ; }
@@ -7180,6 +7196,7 @@ static void bdrv_detach_aio_context(BlockDriverState *bs)BdrvAioNotifier *baf, *baf_tmp;assert (!bs->walking_aio_notifiers); +assert (qemu_in_main_thread ()); bs->walking_aio_notifiers = true; QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {if (baf->deleted) {
@@ -7207,6 +7224,7 @@ static void bdrv_attach_aio_context(BlockDriverState *bs, AioContext *new_context) {BdrvAioNotifier *ban, *ban_tmp; +assert (qemu_in_main_thread ());if (bs->quiesce_counter) {aio_disable_external (new_context);
block/create.c +10 -0
@@ -42,6 +42,16 @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)BlockdevCreateJob *s =container_of (job, BlockdevCreateJob, common);int ret; +/* +* Currently there is nothing preventing this +* function from being called in an iothread context. +* However, since it will crash anyways because of the +* aiocontext lock not taken, we might as well make it +* crash with a more meaningful error, by checking that +* we are in the main loop +*/ +assert (qemu_in_main_thread ()); +job_progress_set_remaining (&s->common,1 ); ret = s->drv->bdrv_co_create (s->opts, errp);job_progress_update (&s->common,1 );
Signature · 1 line
2.27.0
Re: [PATCH v5 22/31] block_int-common.h: assertion in the callers of BlockDriver function pointers
Quoted 6 lines · Emanuele Giuseppe Esposito
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Reviewed-by Stefan Hajnoczi <[email protected]>--- block.c | 18 ++++++++++++++++++ block/create.c | 10 ++++++++++ 2 files changed, 28 insertions(+)
[...]
Quoted 7 lines
block/create.c +0
-0@@ -42,6 +42,16 @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)BlockdevCreateJob *s =container_of (job, BlockdevCreateJob, common);int ret;
block/create.c static int coroutine_fn blockdev_create_run(Job *job, Error **errp) · line 53
Quoted 10 lines
block/create.c +9
-0+/* +* Currently there is nothing preventing this +* function from being called in an iothread context. +* However, since it will crash anyways because of the +* aiocontext lock not taken, we might as well make it +* crash with a more meaningful error, by checking that +* we are in the main loop +*/ +assert (qemu_in_main_thread ());
Mostly agreed. This function is always run in the main loop right now, so this assertion will never fail.
But that’s the “mostly”: Adding this assertion won’t give a more meaningful error, because the problem still remains that block drivers do not error out when encountering (or correctly handle) BDSs in non-main contexts, and so it remains a “qemu_mutex_unlock_impl: Operation not permitted”.
Not trying to say that that’s your problem. It’s pre-existing, and this assertion is good. Just wanting to clarify something about the comment that seemed unclear to me (in that I found it implied that the qemu_mutex_unlock_impl error would be replaced by this assertion failing).
Hanna
Quoted 4 lines
block/create.c +1
-0+job_progress_set_remaining (&s->common,1 ); ret = s->drv->bdrv_co_create (s->opts, errp);job_progress_update (&s->common,1 );
Re: [PATCH v5 22/31] block_int-common.h: assertion in the callers of BlockDriver function pointers
Quoted 30 lines · Hanna Reitz
Quoted 6 lines · Emanuele Giuseppe Esposito
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Reviewed-by Stefan Hajnoczi <[email protected]>---
block.c | 18 ++++++++++++++++++
block/create.c| 10 ++++++++++2 files changed, 28 insertions(+)[...]
Quoted 7 lines
block/create.c +0
-0@@ -42,6 +42,16 @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp) BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);block/create.c static int coroutine_fn blockdev_create_run(Job · line 53
Quoted 10 lines
block/create.c +9
-0int ret; + /* + * Currently there is nothing preventing this + * function from being called in an iothread context. + * However, since it will crash anyways because of the + * aiocontext lock not taken, we might as well make it + * crash with a more meaningful error, by checking that + * we are in the main loop + */ + assert(qemu_in_main_thread());Mostly agreed. This function is always run in the main loop right now, so this assertion will never fail.
Quoted 4 lines
But that’s the “mostly”: Adding this assertion won’t give a more meaningful error, because the problem still remains that block drivers do not error out when encountering (or correctly handle) BDSs in non-main contexts, and so it remains a “qemu_mutex_unlock_impl: Operation not permitted”.
Not trying to say that that’s your problem. It’s pre-existing, and this assertion is good. Just wanting to clarify something about the comment that seemed unclear to me (in that I found it implied that the
qemu_mutex_unlock_implerror would be replaced by this assertion failing).
You are right. Trying your example given in v4:
$ touch /tmp/iothread-create-test.qcow2
$ ./qemu-system-x86_64 -object iothread,id=iothr0 -qmp stdio <<EOF
{"execute": "qmp_capabilities"}
{"execute":"blockdev-add","arguments":{"node-name":"proto","driver":"file","filename":"/tmp/iothread-create-test.qcow2"}}
{"execute":"x-blockdev-set-iothread","arguments":{"node-name":"proto","iothread":"iothr0"}}
{"execute":"blockdev-create","arguments":{"job-id":"create","options":{"driver":"qcow2","file":"proto","size":0}}}
EOFI still get "qemu_mutex_unlock_impl: Operation not permitted"
I will remove the comment above the assertion, makes no sense.
Or should I replace it with a TODO/FIXME explaining the above? Something like:
/*
* TODO: it is currently possible to run a blockdev-create job in an
* I/O thread, for example by doing:
* [ command line above ]
* This should not be allowed.
*/
What do you think?
Emanuele
Quoted 6 lines
Quoted 5 lines
block/create.c +1
-0+ job_progress_set_remaining(&s->common, 1); ret = s->drv->bdrv_co_create(s->opts, errp); job_progress_update(&s->common, 1);
Re: [PATCH v5 22/31] block_int-common.h: assertion in the callers of BlockDriver function pointers
Quoted 55 lines · Emanuele Giuseppe Esposito
Quoted 30 lines · Hanna Reitz
Quoted 6 lines · Emanuele Giuseppe Esposito
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>Reviewed-by Stefan Hajnoczi <[email protected]>---
block.c | 18 ++++++++++++++++++
block/create.c| 10 ++++++++++2 files changed, 28 insertions(+)[...]
Quoted 7 lines
block/create.c +0
-0@@ -42,6 +42,16 @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp) BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);block/create.c static int coroutine_fn blockdev_create_run(Job · line 53
Quoted 10 lines
block/create.c +9
-0int ret; + /* + * Currently there is nothing preventing this + * function from being called in an iothread context. + * However, since it will crash anyways because of the + * aiocontext lock not taken, we might as well make it + * crash with a more meaningful error, by checking that + * we are in the main loop + */ + assert(qemu_in_main_thread());Mostly agreed. This function is always run in the main loop right now, so this assertion will never fail.
Quoted 4 lines
But that’s the “mostly”: Adding this assertion won’t give a more meaningful error, because the problem still remains that block drivers do not error out when encountering (or correctly handle) BDSs in non-main contexts, and so it remains a “qemu_mutex_unlock_impl: Operation not permitted”.
Not trying to say that that’s your problem. It’s pre-existing, and this assertion is good. Just wanting to clarify something about the comment that seemed unclear to me (in that I found it implied that the
qemu_mutex_unlock_implerror would be replaced by this assertion failing).You are right. Trying your example given in v4:
$ touch /tmp/iothread-create-test.qcow2 $ ./qemu-system-x86_64 -object iothread,id=iothr0 -qmp stdio <<EOF {"execute": "qmp_capabilities"} {"execute":"blockdev-add","arguments":{"node-name":"proto","driver":"file","filename":"/tmp/iothread-create-test.qcow2"}}{"execute":"x-blockdev-set-iothread","arguments":{"node-name":"proto","iothread":"iothr0"}}
{"execute":"blockdev-create","arguments":{"job-id":"create","options":{"driver":"qcow2","file":"proto","size":0}}}
EOF
I still get "
qemu_mutex_unlock_impl: Operation not permitted"I will remove the comment above the assertion, makes no sense.
Quoted 8 lines
Or should I replace it with a TODO/FIXME explaining the above? Something like:
/*
* TODO: it is currently possible to run a blockdev-create job in an
* I/O thread, for example by doing:
* [ command line above ]
* This should not be allowed.
*/
Just removing it makes the most sense to me. We already have a TODO comment to that effect (block/create.c:86).
(And to be precise, it is *not* possible to run a blockdev-create job in an I/O thread, it’s always run in the main thread. It is possible to run a blockdev-create job involving nodes in I/O threads, and it’s fine that that’s possible, but in such cases the block drivers’ .bdrv_co_create() implementations should at least error out with a benign error, which they don’t.)
Hanna
PATCH v5 23/31 block_int-common.h: split function pointers in BdrvChildClass
In reply to Emanuele Giuseppe Esposito--- include/block/block_int-common.h | 67 +++++++++++++++++++------------- 1 file changed, 40 insertions(+), 27 deletions(-)
include/block/block_int-common.h +40 -27
@@ -817,12 +817,16 @@ struct BdrvChildClass {*/ bool parent_is_bds; +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ void (*inherit_options)(BdrvChildRole role,bool parent_is_format,int *child_flags,QDict *child_options,int parent_flags,QDict *parent_options); -void (*change_media)(BdrvChild *child,bool load); -void (*resize)(BdrvChild *child);/* * Returns a name that is supposedly more useful for human users than the
@@ -839,6 +843,40 @@ struct BdrvChildClass {*/ char *(*get_parent_desc)(BdrvChild *child); +/* +* Notifies the parent that the child has been activated/inactivated (e.g. +* when migration is completing) and it can start/stop requesting +* permissions and doing I/O on it. +*/ +void (*activate)(BdrvChild *child,Error **errp); +int (*inactivate)(BdrvChild *child); + +void (*attach)(BdrvChild *child); +void (*detach)(BdrvChild *child); + +/* +* Notifies the parent that the filename of its child has changed (e.g. +* because the direct child was removed from the backing chain), so that it +* can update its reference. +*/ +int (*update_filename)(BdrvChild *child,BlockDriverState *new_base, +const char *filename,Error **errp); + +bool (*can_set_aio_ctx)(BdrvChild *child,AioContext *ctx, +GSList **ignore,Error **errp); +void (*set_aio_ctx)(BdrvChild *child,AioContext *ctx,GSList **ignore); + + AioContext *(*get_parent_aio_context)(BdrvChild *child); + +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ + +void (*resize)(BdrvChild *child); +/* * If this pair of functions is implemented, the parent doesn't issue new * requests after returning from .drained_begin() until .drained_end() is
@@ -863,31 +901,6 @@ struct BdrvChildClass {* activity on the child has stopped. */ bool (*drained_poll)(BdrvChild *child); - -/* -* Notifies the parent that the child has been activated/inactivated (e.g. -* when migration is completing) and it can start/stop requesting -* permissions and doing I/O on it. -*/ -void (*activate)(BdrvChild *child,Error **errp); -int (*inactivate)(BdrvChild *child); - -void (*attach)(BdrvChild *child); -void (*detach)(BdrvChild *child); - -/* -* Notifies the parent that the filename of its child has changed (e.g. -* because the direct child was removed from the backing chain), so that it -* can update its reference. -*/ -int (*update_filename)(BdrvChild *child,BlockDriverState *new_base, -const char *filename,Error **errp); - -bool (*can_set_aio_ctx)(BdrvChild *child,AioContext *ctx, -GSList **ignore,Error **errp); -void (*set_aio_ctx)(BdrvChild *child,AioContext *ctx,GSList **ignore); - - AioContext *(*get_parent_aio_context)(BdrvChild *child); };extern const BdrvChildClass child_of_bds;
Signature · 1 line
2.27.0
PATCH v5 24/31 block_int-common.h: assertions in the callers of BdrvChildClass function pointers
In reply to Emanuele Giuseppe Esposito--- block.c | 9 +++++++++ 1 file changed, 9 insertions(+)
block.c +9 -0
@@ -1491,6 +1491,7 @@ const BdrvChildClass child_of_bds = {AioContext *bdrv_child_get_parent_aio_context (BdrvChild *c) { +assert (qemu_in_main_thread ());return c->klass->get_parent_aio_context (c); }
@@ -2120,6 +2121,7 @@ bool bdrv_is_writable(BlockDriverState *bs)static char *bdrv_child_user_desc (BdrvChild *c) { +assert (qemu_in_main_thread ());return c->klass->get_parent_desc (c); }
@@ -2832,6 +2834,7 @@ static void bdrv_replace_child_noperm(BdrvChild **childp,assert (!child->frozen);assert (old_bs != new_bs); +assert (qemu_in_main_thread ());if (old_bs && new_bs) {assert (bdrv_get_aio_context (old_bs) ==bdrv_get_aio_context (new_bs));
@@ -2928,6 +2931,7 @@ static void bdrv_attach_child_common_abort(void *opaque)BdrvChild *child = *s->child;BlockDriverState *bs = child->bs; +assert (qemu_in_main_thread ());/* * Pass free_empty_child=false, because we still need the child * for the AioContext operations on the parent below; those
@@ -3296,6 +3300,7 @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)static void bdrv_parent_cb_change_media (BlockDriverState *bs,bool load) {BdrvChild *c; +assert (qemu_in_main_thread ()); QLIST_FOREACH(c, &bs->parents, next_parent) {if (c->klass->change_media) { c->klass->change_media (c, load);
@@ -3792,6 +3797,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,assert (!child_class || !flags);assert (!child_class == !parent); +assert (qemu_in_main_thread ());if (reference) {bool options_non_empty = options ?qdict_size (options) : false;
@@ -4178,6 +4184,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,* important to avoid graph changes between the recursive queuing here and * bdrv_reopen_multiple(). */ assert (bs->quiesce_counter >0 ); +assert (qemu_in_main_thread ());if (bs_queue ==NULL ) { bs_queue =g_new0 (BlockReopenQueue,1 );
@@ -7271,6 +7278,7 @@ void bdrv_set_aio_context_ignore(BlockDriverState *bs,BdrvChild *child, *parent;g_assert (qemu_get_current_aio_context () ==qemu_get_aio_context ()); +assert (qemu_in_main_thread ());if (old_context == new_context) {return ;
@@ -7343,6 +7351,7 @@ void bdrv_set_aio_context_ignore(BlockDriverState *bs,static bool bdrv_parent_can_set_aio_context (BdrvChild *c,AioContext *ctx,GSList **ignore,Error **errp) { +assert (qemu_in_main_thread ());if (g_slist_find (*ignore, c)) {return true; }
Signature · 1 line
2.27.0
PATCH v5 25/31 block-backend-common.h: split function pointers in BlockDevOps
In reply to Emanuele Giuseppe EspositoAssertions in the callers of the function pointrs are already added by previous patches.
--- include/sysemu/block-backend-common.h | 28 ++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-)
include/sysemu/block-backend-common.h +23 -5
@@ -27,6 +27,14 @@/* Callbacks for block device models */ typedef struct BlockDevOps { + + /* + * Global state (GS) API. These functions run under the BQL lock. + * + * See include/block/block-global-state.h for more information about + * the GS API. + */ + /* * Runs when virtual media changed (monitor commands eject, change) * Argument load is true on load and false on eject.
@@ -44,16 +52,26 @@ typedef struct BlockDevOps {* true, even if they do not support eject requests. */ void (*eject_request_cb)(void *opaque,bool force); -/* -* Is the virtual tray open? -* Device models implement this only when the device has a tray. -*/ -bool (*is_tray_open)(void *opaque); +/* * Is the virtual medium locked into the device? * Device models implement this only when device has such a lock. */ bool (*is_medium_locked)(void *opaque); + +/* +* I/O API functions. These functions are thread-safe. +* +* See include/block/block-io.h for more information about +* the I/O API. +*/ + +/* +* Is the virtual tray open? +* Device models implement this only when the device has a tray. +*/ +bool (*is_tray_open)(void *opaque); +/* * Runs when the size changed (e.g. monitor command block_resize) */
Signature · 1 line
2.27.0
PATCH v5 26/31 job.h: split function pointers in JobDriver
In reply to Emanuele Giuseppe EspositoThe job API will be handled separately in another serie.
--- include/qemu/job.h | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
include/qemu/job.h +22 -0
@@ -169,6 +169,12 @@ typedef struct Job {* Callbacks and other information about a Job driver. */ struct JobDriver { + +/* +* These fields are initialized when this object is created, +* and are never changed afterwards +*/ +/** Derived Job struct size */ size_t instance_size;
@@ -184,9 +190,18 @@ struct JobDriver {* aborted. If it returns zero, the job moves into the WAITING state. If it * is the last job to complete in its transaction, all jobs in the * transaction move from WAITING to PENDING. +* +* This callback must be run in the job's context. */ int coroutine_fn (*run)(Job *job, Error **errp); +/* +* Functions run without regard to the BQL that may run in any +* arbitrary thread. These functions do not need to be thread-safe +* because the caller ensures that they are invoked from one +* thread at time. +*/ +/** * If the callback is not NULL, it will be invoked when the job transitions * into the paused state. Paused jobs must not perform any asynchronous
@@ -201,6 +216,13 @@ struct JobDriver {*/ void coroutine_fn (*resume)(Job *job); +/* +* Global state (GS) API. These functions run under the BQL lock. +* +* See include/block/block-global-state.h for more information about +* the GS API. +*/ +/** * Called when the job is resumed by the user (i.e. user_paused becomes * false). .user_resume is called before .resume.
Signature · 1 line
2.27.0
PATCH v5 27/31 job.h: assertions in the callers of JobDriver funcion pointers
In reply to Emanuele Giuseppe EspositoAlso assert that job->run() callback is called in the job aiocontext.
--- job.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
job.c +10 -0
@@ -380,6 +380,8 @@ void job_ref(Job *job)void job_unref (Job *job) { +assert (qemu_in_main_thread ()); +if (--job->refcnt ==0 ) {assert (job->status ==JOB_STATUS_NULL );assert (!timer_pending (&job->sleep_timer));
@@ -601,6 +603,7 @@ bool job_user_paused(Job *job)void job_user_resume (Job *job,Error **errp) {assert (job); +assert (qemu_in_main_thread ());if (!job->user_paused || job->pause_count <=0 ) {error_setg (errp,"Can't resume a job that was not paused" );return ;
@@ -671,6 +674,7 @@ static void job_update_rc(Job *job)static void job_commit (Job *job) {assert (!job->ret); +assert (qemu_in_main_thread ());if (job->driver->commit) { job->driver->commit (job); }
@@ -679,6 +683,7 @@ static void job_commit(Job *job)static void job_abort (Job *job) {assert (job->ret); +assert (qemu_in_main_thread ());if (job->driver->abort) { job->driver->abort (job); }
@@ -686,6 +691,7 @@ static void job_abort(Job *job)static void job_clean (Job *job) { +assert (qemu_in_main_thread ());if (job->driver->clean) { job->driver->clean (job); }
@@ -725,6 +731,7 @@ static int job_finalize_single(Job *job)static void job_cancel_async (Job *job,bool force) { +assert (qemu_in_main_thread ());if (job->driver->cancel) { force = job->driver->cancel (job, force); }else {
@@ -824,6 +831,7 @@ static void job_completed_txn_abort(Job *job)static int job_prepare (Job *job) { +assert (qemu_in_main_thread ());if (job->ret ==0 && job->driver->prepare) { job->ret = job->driver->prepare (job);job_update_rc (job);
@@ -950,6 +958,7 @@ static void coroutine_fn job_co_entry(void *opaque) {Job *job = opaque; +assert (job->aio_context ==qemu_get_current_aio_context ());assert (job && job->driver && job->driver->run);job_pause_point (job); job->ret = job->driver->run (job, &job->err);
@@ -1053,6 +1062,7 @@ void job_complete(Job *job, Error **errp) {/* Should not be reachable via external interface for internal jobs */ assert (job->id); +assert (qemu_in_main_thread ());if (job_apply_verb (job,JOB_VERB_COMPLETE , errp)) {return ; }
Signature · 1 line
2.27.0
PATCH v5 28/31 block.c: assert BQL lock held in bdrv_co_invalidate_cache
In reply to Emanuele Giuseppe Espositobdrv_co_invalidate_cache is special: it is an I/O function, but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain BDRV_O_INACTIVE.
--- block.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
block.c +26 -0
@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void)bdrv_init (); } +static bool bdrv_is_active (BlockDriverState *bs) +{ +BdrvChild *parent; + +if (bs->open_flags &BDRV_O_INACTIVE ) { +return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { +if (parent->klass->parent_is_bds) { +BlockDriverState *parent_bs = parent->opaque; +if (!bdrv_is_active (parent_bs)) { +return false; + } + } + } + +return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) {BdrvChild *child, *parent;
@@ -6585,6 +6605,12 @@ int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)return -ENOMEDIUM ; } +/* +* No need to muck with permissions if bs is active. +* TODO: should activation be a separate function? +*/ +assert (qemu_in_main_thread () ||bdrv_is_active (bs)); + QLIST_FOREACH(child, &bs->children, next) {bdrv_co_invalidate_cache (child->bs, &local_err);if (local_err) {
Signature · 1 line
2.27.0
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,
I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 21 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void)bdrv_init (); } +static bool bdrv_is_active (BlockDriverState *bs)
block.c void bdrv_init_with_whitelist(void) · line 6587
Quoted 10 lines
block.c +10
-0+{ +BdrvChild *parent; + +if (bs->open_flags &BDRV_O_INACTIVE ) { +return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { +if (parent->klass->parent_is_bds) { +BlockDriverState *parent_bs = parent->opaque;
This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke bdrv_co_invalidate_cache() on the parents, too, but then we could simply let the assertion fail there.
Quoted 13 lines
block.c +9
-0+if (!bdrv_is_active (parent_bs)) { +return false; + } + } + } + +return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) {BdrvChild *child, *parent;
block.c int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)return -ENOMEDIUM ; } +/* +* No need to muck with permissions if bs is active. +* TODO: should activation be a separate function? +*/ +assert (qemu_in_main_thread () ||bdrv_is_active (bs)); +
I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Hanna
Quoted 3 lines
block.c +0
-0QLIST_FOREACH(child, &bs->children, next) {bdrv_co_invalidate_cache (child->bs, &local_err);if (local_err) {
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 67 lines · Hanna Reitz
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 13 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) { BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 1 line
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the qemu_in_main_thread() assertion makes test 307 (./check 307) fail. I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.
I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.
Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.0x00007ffff68af54d in sendmsg () from target:/lib64/libc.so.6
(gdb) bt
#0 0x00007ffff68af54d in sendmsg () from target:/lib64/libc.so.6
#1 0x0000555555c13cc9 in qio_channel_socket_writev (ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0)
at ../io/channel-socket.c:561
#2 0x0000555555c19b18 in qio_channel_writev_full_all (ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0,
nfds=nfds@entry=0, errp=errp@entry=0x0) at ../io/channel.c:240
#3 0x0000555555c19bd2 in qio_channel_writev_all (errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at ../io/channel.c:220
#4 qio_channel_write_all (ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at ../io/channel.c:330
#5 0x0000555555c27e75 in nbd_write (errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at ../nbd/nbd-internal.h:71
#6 nbd_negotiate_send_rep_len (client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at ../nbd/server.c:203
#7 0x0000555555c29db1 in nbd_negotiate_send_rep (errp=0x0, type=1, client=0x555556f60930) at ../nbd/server.c:211--Type <RET> for more, q to quit, c to continue without paging--
#8 nbd_negotiate_options (errp=0x7fffe8dffe88, client=<optimized out>) at ../nbd/server.c:1224
#9 nbd_negotiate (errp=0x7fffe8dffe88, client=<optimized out>) at ../nbd/server.c:1340
#10 nbd_co_client_start (opaque=<optimized out>) at ../nbd/server.c:2715
#11 0x0000555555d70423 in coroutine_trampoline (i0=<optimized out>, i1=<optimized out>) at ../util/coroutine-ucontext.c:173 #12 0x00007ffff67f3820 in ?? () from target:/lib64/libc.so.6
#13 0x00007fffffffca80 in ?? ()
Emanuele
Quoted 7 lines
Hanna
Quoted 3 lines
block.c +0
-0QLIST_FOREACH(child, &bs->children, next) { bdrv_co_invalidate_cache(child->bs, &local_err); if (local_err) {
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 92 lines · Emanuele Giuseppe Esposito
Quoted 67 lines · Hanna Reitz
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 13 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) { BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 1 line
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the
qemu_in_main_thread()assertion makes test 307 (./check 307) fail. I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.
0x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
(gdb) bt
#00x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
#10x0000555555c13cc9inqio_channel_socket_writev(ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0)
at../io/channel-socket.c:561
#20x0000555555c19b18inqio_channel_writev_full_all(ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0,
nfds=nfds@entry=0, errp=errp@entry=0x0) at../io/channel.c:240
#30x0000555555c19bd2inqio_channel_writev_all(errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at../io/channel.c:220#4qio_channel_write_all(ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at../io/channel.c:330#50x0000555555c27e75innbd_write(errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at../nbd/nbd-internal.h:71#6nbd_negotiate_send_rep_len(client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at../nbd/server.c:203
Quoted 9 lines
#7
0x0000555555c29db1innbd_negotiate_send_rep(errp=0x0, type=1, client=0x555556f60930) at../nbd/server.c:211--Type <RET> for more, q to quit, c to continue without paging--
#8nbd_negotiate_options(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1224
#9nbd_negotiate(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1340
#10nbd_co_client_start(opaque=<optimized out>) at../nbd/server.c:2715
#110x0000555555d70423incoroutine_trampoline(i0=<optimized out>, i1=<optimized out>) at../util/coroutine-ucontext.c:173#120x00007ffff67f3820in ?? () from target:/lib64/libc.so.6
#130x00007fffffffca80in ?? ()
Ok the reason for this is line 89 of tests/qemu-iotests/307:
# Should ignore the iothread conflict, but then fail because of the
# permission conflict (and not crash)
vm.qmp_log('block-export-add', id='export1', type='nbd', node_name='null',
iothread='iothread1', fixed_iothread=False, writable=True)This calls qmp_block_export_add() and then blk_exp_add(), that calls bdrv_invalidate_cache().
Both functions are running in the main thread, but then bdrv_invalidate_cache invokes bdrv_co_invalidate_cache() as a coroutine in the AioContext of the given bs, so not the main loop.
So Hanna, what should we do here? This seems very similar to the discussion in patch 22, ie run blockdev-create (in this case block-export-add, which seems similar?) involving nodes in I/O threads.
Thank you,
Emanuele
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 108 lines · Emanuele Giuseppe Esposito
Quoted 92 lines · Emanuele Giuseppe Esposito
Quoted 67 lines · Hanna Reitz
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 13 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) { BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 1 line
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the
qemu_in_main_thread()assertion makes test 307 (./check 307) fail. I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.
0x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
(gdb) bt
#00x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
#10x0000555555c13cc9inqio_channel_socket_writev(ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0) at../io/channel-socket.c:561
#20x0000555555c19b18inqio_channel_writev_full_all(ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0, nfds=nfds@entry=0, errp=errp@entry=0x0) at../io/channel.c:240
#30x0000555555c19bd2inqio_channel_writev_all(errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at../io/channel.c:220#4qio_channel_write_all(ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at../io/channel.c:330#50x0000555555c27e75innbd_write(errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at../nbd/nbd-internal.h:71#6nbd_negotiate_send_rep_len(client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at../nbd/server.c:203Quoted 9 lines
#7
0x0000555555c29db1innbd_negotiate_send_rep(errp=0x0, type=1, client=0x555556f60930) at../nbd/server.c:211--Type <RET> for more, q to quit, c to continue without paging--
#8nbd_negotiate_options(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1224
#9nbd_negotiate(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1340
#10nbd_co_client_start(opaque=<optimized out>) at../nbd/server.c:2715
#110x0000555555d70423incoroutine_trampoline(i0=<optimized out>, i1=<optimized out>) at../util/coroutine-ucontext.c:173#120x00007ffff67f3820in ?? () from target:/lib64/libc.so.6
#130x00007fffffffca80in ?? ()Ok the reason for this is line 89 of tests/qemu-iotests/307:
# Should ignore the iothread conflict, but then fail because of the
Quoted 8 lines
# permission conflict (and not crash) vm.qmp_log('block-export-add', id='export1', type='nbd', node_name='null', iothread='iothread1', fixed_iothread=False, writable=True)This calls
qmp_block_export_add()and thenblk_exp_add(), that callsbdrv_invalidate_cache().
Both functions are running in the main thread, but thenbdrv_invalidate_cacheinvokesbdrv_co_invalidate_cache()as a coroutine in the AioContext of the given bs, so not the main loop.So Hanna, what should we do here? This seems very similar to the discussion in patch 22, ie run blockdev-create (in this case block-export-add, which seems similar?) involving nodes in I/O threads.
Honestly, I’m still thinking about this and haven’t come to a conclusion. It doesn’t seem invalid to run bdrv_co_invalidate_cache() in the context of the BDS here, but then the assertion that the BDS is already active seems kind of just lucky to work.
I plan to look into whether I can reproduce some case where the assertion doesn’t hold (thinking of migration with a block device in an iothread), and then see what I learn from this. :/
Hanna
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 113 lines · Hanna Reitz
Quoted 112 lines · Emanuele Giuseppe Esposito
Quoted 92 lines · Emanuele Giuseppe Esposito
Quoted 67 lines · Hanna Reitz
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 13 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) { BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 1 line
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the
qemu_in_main_thread()assertion makes test 307 (./check 307) fail. I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.
0x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
(gdb) bt
#00x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
#10x0000555555c13cc9inqio_channel_socket_writev(ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0) at../io/channel-socket.c:561
#20x0000555555c19b18inqio_channel_writev_full_all(ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0, nfds=nfds@entry=0, errp=errp@entry=0x0) at../io/channel.c:240
#30x0000555555c19bd2inqio_channel_writev_all(errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at../io/channel.c:220#4qio_channel_write_all(ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at../io/channel.c:330#50x0000555555c27e75innbd_write(errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at../nbd/nbd-internal.h:71#6nbd_negotiate_send_rep_len(client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at../nbd/server.c:203Quoted 9 lines
#7
0x0000555555c29db1innbd_negotiate_send_rep(errp=0x0, type=1, client=0x555556f60930) at../nbd/server.c:211--Type <RET> for more, q to quit, c to continue without paging--
#8nbd_negotiate_options(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1224
#9nbd_negotiate(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1340
#10nbd_co_client_start(opaque=<optimized out>) at../nbd/server.c:2715
#110x0000555555d70423incoroutine_trampoline(i0=<optimized out>, i1=<optimized out>) at../util/coroutine-ucontext.c:173#120x00007ffff67f3820in ?? () from target:/lib64/libc.so.6
#130x00007fffffffca80in ?? ()Ok the reason for this is line 89 of tests/qemu-iotests/307:
# Should ignore the iothread conflict, but then fail because of the
# permission conflict (and not crash) vm.qmp_log('block-export-add', id='export1', type='nbd', node_name='null', iothread='iothread1', fixed_iothread=False, writable=True)
Quoted 8 lines
Quoted 4 lines
This calls
qmp_block_export_add()and thenblk_exp_add(), that callsbdrv_invalidate_cache().
Both functions are running in the main thread, but thenbdrv_invalidate_cacheinvokesbdrv_co_invalidate_cache()as a coroutine in the AioContext of the given bs, so not the main loop.So Hanna, what should we do here? This seems very similar to the discussion in patch 22, ie run blockdev-create (in this case block-export-add, which seems similar?) involving nodes in I/O threads.
Honestly, I’m still thinking about this and haven’t come to a conclusion. It doesn’t seem invalid to run
bdrv_co_invalidate_cache()in the context of the BDS here, but then the assertion that the BDS is already active seems kind of just lucky to work.I plan to look into whether I can reproduce some case where the assertion doesn’t hold (thinking of migration with a block device in an iothread), and then see what I learn from this. :/
OK, so. I nearly couldn’t reproduce a case where the assertion doesn’t hold, and I was also very close to believing that your condition is entirely correct; on migration, we generally inactivate block nodes (BlockDriverStates) only after they have been detached from their respective block devices, and so they’re in the main context. On the destination, it’s the other way around: We invalidate their caches before attaching them to the respective block devices, so they are again in the main context.
There are exceptions where we call bdrv_invalidate_cache() on error paths and so on, basically just to be sure, while the guest devices are connected to block nodes. But in that case, we have never inactivated them (or have already re-activated them), and that’s where the bdrv_is_active() condition comes in.
But then I wanted to find out what happens when you don’t have a guest device, but an NBD export on top of the block node, and this happens:
$ ./qemu-system-x86_64 \
-incoming defer \
-qmp stdio \
-object iothread,id=iothr0 \
-blockdev null-co,node-name=node0 \
<<EOF
{"execute": "qmp_capabilities"}
{"execute":"nbd-server-start","arguments":{"addr":{"type":"unix","data":{"path":"/tmp/nbd.sock"}}}}
{"execute":"block-export-add","arguments":{"type":"nbd","id":"exp0","iothread":"iothr0","node-name":"node0","name":"exp0"}}
EOF
{"QMP": {"version": {"qemu": {"micro": 91, "minor": 2, "major": 6}, "package": "v6.2.0-rc1-47-g043ab68869"}, "capabilities": ["oob"]}}
{"return": {}}
{"return": {}}
qemu-system-x86_64: ../block.c:6612: bdrv_co_invalidate_cache: Assertion `qemu_in_main_thread() || bdrv_is_active(bs)' failed.
[1] 155729 abort (core dumped) ./qemu-system-x86_64 -incoming defer -qmp stdio -object iothread,id=iothr0The problem here is that blk_exp_add() invalidates the cache after moving the node to the target context. I think we can solve this particular problem by simply moving its bdrv_invalidate_cache() call before the if (export->has_iothread) block above it.
But it does mean the search isn’t over and I’ll need to look a bit further still... At least your assertion condition now makes more sense to me.
Hanna
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 117 lines · Hanna Reitz
Quoted 116 lines · Hanna Reitz
Quoted 115 lines · Emanuele Giuseppe Esposito
Quoted 92 lines · Emanuele Giuseppe Esposito
Quoted 67 lines · Hanna Reitz
Quoted 1 line · Emanuele Giuseppe Esposito
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 13 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} + int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp) { BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 1 line
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the
qemu_in_main_thread()assertion makes test 307 (./check 307) fail. I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.
0x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
(gdb) bt
#00x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6
#10x0000555555c13cc9inqio_channel_socket_writev(ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0) at../io/channel-socket.c:561
#20x0000555555c19b18inqio_channel_writev_full_all(ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0, nfds=nfds@entry=0, errp=errp@entry=0x0) at../io/channel.c:240
#30x0000555555c19bd2inqio_channel_writev_all(errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at../io/channel.c:220#4qio_channel_write_all(ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at../io/channel.c:330#50x0000555555c27e75innbd_write(errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at../nbd/nbd-internal.h:71#6nbd_negotiate_send_rep_len(client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at../nbd/server.c:203Quoted 9 lines
#7
0x0000555555c29db1innbd_negotiate_send_rep(errp=0x0, type=1, client=0x555556f60930) at../nbd/server.c:211--Type <RET> for more, q to quit, c to continue without paging--
#8nbd_negotiate_options(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1224
#9nbd_negotiate(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1340
#10nbd_co_client_start(opaque=<optimized out>) at../nbd/server.c:2715
#110x0000555555d70423incoroutine_trampoline(i0=<optimized out>, i1=<optimized out>) at../util/coroutine-ucontext.c:173#120x00007ffff67f3820in ?? () from target:/lib64/libc.so.6
#130x00007fffffffca80in ?? ()Ok the reason for this is line 89 of tests/qemu-iotests/307:
# Should ignore the iothread conflict, but then fail because of the
# permission conflict (and not crash) vm.qmp_log('block-export-add', id='export1', type='nbd', node_name='null', iothread='iothread1', fixed_iothread=False, writable=True)This calls
qmp_block_export_add()and thenblk_exp_add(), that callsbdrv_invalidate_cache().
Both functions are running in the main thread, but thenbdrv_invalidate_cacheinvokesbdrv_co_invalidate_cache()as a coroutine in the AioContext of the given bs, so not the main loop.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
So Hanna, what should we do here? This seems very similar to the discussion in patch 22, ie run blockdev-create (in this case block-export-add, which seems similar?) involving nodes in I/O threads.
Honestly, I’m still thinking about this and haven’t come to a conclusion. It doesn’t seem invalid to run
bdrv_co_invalidate_cache()in the context of the BDS here, but then the assertion that the BDS is already active seems kind of just lucky to work.I plan to look into whether I can reproduce some case where the assertion doesn’t hold (thinking of migration with a block device in an iothread), and then see what I learn from this. :/
OK, so. I nearly couldn’t reproduce a case where the assertion doesn’t hold, and I was also very close to believing that your condition is entirely correct; on migration, we generally inactivate block nodes (BlockDriverStates) only after they have been detached from their respective block devices, and so they’re in the main context. On the destination, it’s the other way around: We invalidate their caches before attaching them to the respective block devices, so they are again in the main context.
Correcting myself: It doesn’t have to do anything with attaching/detaching, it’s that the guest puts the BDS into the non-main context only if the vmstate is “running”.
(virtio_pci_vmstate_change() is invoked on vmstate changes, and virtio_blk_class_init() registers virtio_blk_data_plane_{start,stop}() as the {start,stop}_ioeventfd callbacks.)
So it’s even better, the devices actually take care to put the BDS nodes into the main context while migration is ongoing.
Quoted 15 lines
There are exceptions where we call
bdrv_invalidate_cache()on error paths and so on, basically just to be sure, while the guest devices are connected to block nodes. But in that case, we have never inactivated them (or have already re-activated them), and that’s where thebdrv_is_active()condition comes in.But then I wanted to find out what happens when you don’t have a guest device, but an NBD export on top of the block node, and this happens:
$ ./qemu-system-x86_64 \ -incoming defer \ -qmp stdio \ -object iothread,id=iothr0 \ -blockdev null-co,node-name=node0 \ <<EOF {"execute": "qmp_capabilities"} {"execute":"nbd-server-start","arguments":{"addr":{"type":"unix","data":{"path":"/tmp/nbd.sock"}}}}{"execute":"block-export-add","arguments":{"type":"nbd","id":"exp0","iothread":"iothr0","node-name":"node0","name":"exp0"}}
Quoted 8 lines
EOF
{"QMP": {"version": {"qemu": {"micro": 91, "minor": 2, "major": 6}, "package": "v6.2.0-rc1-47-g043ab68869"}, "capabilities": ["oob"]}} {"return": {}}
{"return": {}}
qemu-system-x86_64:../block.c:6612:bdrv_co_invalidate_cache: Assertion `qemu_in_main_thread() ||bdrv_is_active(bs)' failed. [1] 155729 abort (core dumped) ./qemu-system-x86_64 -incoming defer -qmp stdio -object iothread,id=iothr0The problem here is that
blk_exp_add()invalidates the cache after moving the node to the target context. I think we can solve this particular problem by simply moving itsbdrv_invalidate_cache()call before theif (export->has_iothread)block above it.
And that means that this makes even more sense, because if the virtio devices take care to keep their block device in the main context while migration is ongoing, blk_exp_add() should do the same when it calls a “migration function” (bdrv_invalidate_cache()).
Quoted 1 line
But it does mean the search isn’t over and I’ll need to look a bit further still...
Did look further, couldn’t find anything else interesting.
So I think(TM) that this blk_exp_add() is the only thing that needs fixing.
Hanna
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
In reply to Emanuele Giuseppe EspositoAm 20.12.2021 um 13:20 hat Emanuele Giuseppe Esposito geschrieben:
Quoted 149 lines · Emanuele Giuseppe Esposito
Quoted 123 lines · Hanna Reitz
Quoted 79 lines · Emanuele Giuseppe Esposito
Quoted 1 line
bdrv_co_invalidate_cacheis special: it is an I/O function,I still don’t believe it is, but well.
(Yes, it is called by a test in an iothread, but I believe we’ve seen that the tests simply sometimes test things that shouldn’t be allowed.)
Quoted 20 lines
but uses the block layer permission API, which is GS.
Because of this, we can assert that either the function is being called with BQL held, and thus can use the permission API, or make sure that the permission API is not used, by ensuring that bs (and parents) .open_flags does not contain
BDRV_O_INACTIVE.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block.c| 26 ++++++++++++++++++++++++++1 file changed, 26 insertions(+)block.c +1
-0@@ -6574,6 +6574,26 @@ void bdrv_init_with_whitelist(void) bdrv_init(); } +static bool bdrv_is_active (BlockDriverState *bs)block.c void bdrv_init_with_whitelist(void) · line 6586
Quoted 10 lines
block.c +10
-0+{ + BdrvChild *parent; + + if (bs->open_flags & BDRV_O_INACTIVE) { + return false; + } + + QLIST_FOREACH(parent, &bs->parents, next_parent) { + if (parent->klass->parent_is_bds) { + BlockDriverState *parent_bs = parent->opaque;This looks like a really bad hack to me. We purposefully have made the parent link opaque so that a BDS cannot easily reach its parents. All accesses should go through BdrvChildClass methods.
I also don’t understand why we need to query parents at all. The only fact that determines whether the current BDS will have its permissions changed is whether the BDS itself is active or inactive. Sure, we’ll invoke
bdrv_co_invalidate_cache()on the parents, too, but then we could simply let the assertion fail there.Quoted 14 lines
block.c +9
-0+ if (!bdrv_is_active(parent_bs)) { + return false; + } + } + } + + return true; +} +int
coroutine_fnbdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)
{
BdrvChild *child, *parent;block.c int coroutine_fn · line 6613
Quoted 9 lines
block.c +6
-0@@ -6585,6 +6605,12 @@ int coroutine_fnbdrv_co_invalidate_cache (BlockDriverState *bs, Error **errp) return -ENOMEDIUM; } + /* + * No need to muck with permissions if bs is active. + * TODO: should activation be a separate function? + */ + assert(qemu_in_main_thread() || bdrv_is_active(bs)); +I don’t understand this, really. It looks to me like “if you don’t call this in the main thread, this better be a no-op”, i.e., you must never call this function in an I/O thread if you really want to use it. I.e. what I’d classify as a GS function.
Quoted 2 lines
It sounds like this is just a special case for said test, and special-casing code for tests sounds like a bad idea.
Ok, but trying to leave just the
qemu_in_main_thread()assertion makes test 307 (./check 307) fail.
I am actually not sure on why it fails, but I am sure it is because of the assertion, since without it it passes.I tried with gdb (./check -gdb 307 on one terminal and
gdb -iex "target remote localhost:12345"
in another) but it points me to this below, which I think is the ndb server getting the socket closed (because on the other side it crashed), and not the actual error.Thread 1 "qemu-system-x86" received signal SIGPIPE, Broken pipe.
0x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6 (gdb) bt
#00x00007ffff68af54din sendmsg () from target:/lib64/libc.so.6 #10x0000555555c13cc9inqio_channel_socket_writev(ioc=<optimized out>, iov=0x5555569a4870, niov=1, fds=0x0, nfds=<optimized out>, errp=0x0)
at../io/channel-socket.c:561
#20x0000555555c19b18inqio_channel_writev_full_all(ioc=0x55555763b800, iov=iov@entry=0x7fffe8dffd80, niov=niov@entry=1, fds=fds@entry=0x0,
nfds=nfds@entry=0, errp=errp@entry=0x0) at../io/channel.c:240
#30x0000555555c19bd2inqio_channel_writev_all(errp=0x0, niov=1, iov=0x7fffe8dffd80, ioc=<optimized out>) at../io/channel.c:220#4qio_channel_write_all(ioc=<optimized out>, buf=buf@entry=0x7fffe8dffdd0 "", buflen=buflen@entry=20, errp=errp@entry=0x0) at../io/channel.c:330
#50x0000555555c27e75innbd_write(errp=0x0, size=20, buffer=0x7fffe8dffdd0, ioc=<optimized out>) at../nbd/nbd-internal.h:71#6nbd_negotiate_send_rep_len(client=client@entry=0x555556f60930, type=type@entry=1, len=len@entry=0, errp=errp@entry=0x0) at../nbd/server.c:203
#70x0000555555c29db1innbd_negotiate_send_rep(errp=0x0, type=1, client=0x555556f60930) at../nbd/server.c:211
--Type <RET> for more, q to quit, c to continue without paging-- #8nbd_negotiate_options(errp=0x7fffe8dffe88, client=<optimized out>)Quoted 9 lines
at
../nbd/server.c:1224
#9nbd_negotiate(errp=0x7fffe8dffe88, client=<optimized out>) at../nbd/server.c:1340
#10nbd_co_client_start(opaque=<optimized out>) at../nbd/server.c:2715#110x0000555555d70423incoroutine_trampoline(i0=<optimized out>, i1=<optimized out>) at../util/coroutine-ucontext.c:173
#120x00007ffff67f3820in ?? () from target:/lib64/libc.so.6 #130x00007fffffffca80in ?? ()Ok the reason for this is line 89 of tests/qemu-iotests/307:
# Should ignore the iothread conflict, but then fail because of the
# permission conflict (and not crash) vm.qmp_log('block-export-add', id='export1', type='nbd', node_name='null', iothread='iothread1', fixed_iothread=False, writable=True)This calls
qmp_block_export_add()and thenblk_exp_add(), that callsbdrv_invalidate_cache().
Both functions are running in the main thread, but thenbdrv_invalidate_cacheinvokesbdrv_co_invalidate_cache()as a coroutine in the AioContext of the given bs, so not the main loop.
Quoted 3 lines
So Hanna, what should we do here? This seems very similar to the discussion in patch 22, ie run blockdev-create (in this case block-export-add, which seems similar?) involving nodes in I/O threads.
My gut feeling is that the bug is that we're entering coroutine context in the node's iothread too early. I think the only place where we really need it is the bs->drv->bdrv_co_invalidate_cache() call.
In fact, not only permission code, but also parent->klass->activate() must be run in the main thread. The only implementation of the callback is blk_root_activate(), and it calls some permissions functions, too, but also qemu_add_vm_change_state_handler(), which doesn't look thread safe. Unlikely to ever cause problems and if it does, it won't be reproducible, but still a bug.
So if we go back to a bdrv_invalidate_cache() that does all the graph manipulations (and asserts that we're in the main loop) and then have a much smaller bdrv_co_invalidate_cache() that basically just calls into the driver, would that solve the problem?
Kevin
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 4 lines · Kevin Wolf
So if we go back to a
bdrv_invalidate_cache()that does all the graph manipulations (and asserts that we're in the main loop) and then have a much smallerbdrv_co_invalidate_cache()that basically just calls into the driver, would that solve the problem?
I was going to suggest something similar, and even name the former bdrv_activate(). Then bdrv_activate() is a graph manipulation function, while bdrv_co_invalidate_cache() is an I/O function.
Paolo
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Am 20.01.2022 um 14:22 hat Paolo Bonzini geschrieben:
Quoted 9 lines · Kevin Wolf
Quoted 4 lines
So if we go back to a
bdrv_invalidate_cache()that does all the graph manipulations (and asserts that we're in the main loop) and then have a much smallerbdrv_co_invalidate_cache()that basically just calls into the driver, would that solve the problem?I was going to suggest something similar, and even name the former
bdrv_activate(). Thenbdrv_activate()is a graph manipulation function, whilebdrv_co_invalidate_cache()is an I/O function.
I like this. The naming inconsistency between inactivate and invalidate_cache has always bothered me.
Kevin
Re: [PATCH v5 28/31] block.c: assert BQL lock held in bdrv_co_invalidate_cache
Quoted 7 lines · Kevin Wolf
Am 20.01.2022 um 14:22 hat Paolo Bonzini geschrieben:
Quoted 6 lines · Kevin Wolf
Quoted 4 lines
So if we go back to a
bdrv_invalidate_cache()that does all the graph manipulations (and asserts that we're in the main loop) and then have a much smallerbdrv_co_invalidate_cache()that basically just calls into the driver, would that solve the problem?
Quoted 7 lines
Quoted 3 lines
I was going to suggest something similar, and even name the former
bdrv_activate(). Thenbdrv_activate()is a graph manipulation function, whilebdrv_co_invalidate_cache()is an I/O function.I like this. The naming inconsistency between inactivate and
invalidate_cachehas always bothered me.
Ok, I am going to apply this. Thank you for the suggestion!
Quoted 2 lines
Did look further, couldn’t find anything else interesting.
So I think(TM) that thisblk_exp_add()is the only thing that needs fixing.
When splitting the logic between bdrv_activate and bdrv_co_invalidate_cache, there is no need anymore to fix blk_exp_add :)
I am going to send v6 by the end of today.
Thank you,
Emanuele
PATCH v5 29/31 jobs: introduce pre_run function in JobDriver
In reply to Emanuele Giuseppe Esposito.pre_run takes care of doing some initial job setup just before the job is run inside the coroutine. Doing so can be useful to invoke GS functions that require the BQL held.
--- include/qemu/job.h | 9 +++++++++ job.c | 13 +++++++++++++ 2 files changed, 22 insertions(+)
include/qemu/job.h +9 -0
@@ -223,6 +223,15 @@ struct JobDriver {* the GS API. */ +/** +* Called in the Main Loop context, before the job coroutine +* is started in the job aiocontext. Useful to perform operations +* that needs to be done under BQL (like permissions setup). +* On success, it returns 0. Otherwise the job failed to initialize +* and won't start. +*/ +int (*pre_run)(Job *job,Error **errp); +/** * Called when the job is resumed by the user (i.e. user_paused becomes * false). .user_resume is called before .resume.
job.c +13 -0
@@ -967,11 +967,24 @@ static void coroutine_fn job_co_entry(void *opaque)aio_bh_schedule_oneshot (qemu_get_aio_context (), job_exit, job); } +static int job_pre_run (Job *job) +{ +assert (qemu_in_main_thread ()); +if (job->driver->pre_run) { +return job->driver->pre_run (job, &job->err); + } + +return 0 ; +} +void job_start (Job *job) {assert (job && !job_started (job) && job->paused && job->driver && job->driver->run); job->co =qemu_coroutine_create (job_co_entry, job); +if (job_pre_run (job)) { +return ; + } job->pause_count--; job->busy = true; job->paused = false;
Signature · 1 line
2.27.0
PATCH v5 30/31 crypto: delegate permission functions to JobDriver .pre_run
In reply to Emanuele Giuseppe Espositoblock_crypto_amend_options_generic_luks uses the block layer permission API, therefore it should be called with the BQL held.
However, the same function is being called ib two BlockDriver
callbacks: bdrv_amend_options (under BQL) and bdrv_co_amend (I/O).
The latter is I/O because it is invoked by block/amend.c's blockdev_amend_run(), a .run callback of the amend JobDriver
Therefore we want to 1) change block_crypto_amend_options_generic_luks to use the permission API only when the BQL is held, and
2) use the .pre_run JobDriver callback to check for permissions before switching to the job aiocontext. This has also the benefit of applying the same permission operation to all amend implementations, not only luks.
--- block/amend.c | 20 ++++++++++++++++++++ block/crypto.c | 18 ++++++++++++------ 2 files changed, 32 insertions(+), 6 deletions(-)
block/amend.c +20 -0
@@ -53,10 +53,30 @@ static int coroutine_fn blockdev_amend_run(Job *job, Error **errp)return ret; } +static int blockdev_amend_refresh_perms (Job *job,Error **errp) +{ +BlockdevAmendJob *s =container_of (job, BlockdevAmendJob, common); + +return bdrv_child_refresh_perms (s->bs, s->bs->file, errp); +} + +static int blockdev_amend_pre_run (Job *job,Error **errp) +{ +return blockdev_amend_refresh_perms (job, errp); +} + +static void blockdev_amend_clean (Job *job) +{ +Error *errp; +blockdev_amend_refresh_perms (job, &errp); +} +static const JobDriver blockdev_amend_job_driver = { .instance_size =sizeof (BlockdevAmendJob), .job_type =JOB_TYPE_AMEND , .run = blockdev_amend_run, + .pre_run = blockdev_amend_pre_run, + .clean = blockdev_amend_clean, }; void qmp_x_blockdev_amend(const char *job_id,
block/crypto.c +12 -6
@@ -780,6 +780,7 @@ block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp)static int block_crypto_amend_options_generic_luks (BlockDriverState *bs,QCryptoBlockAmendOptions *amend_options, +bool under_bql,bool force,Error **errp) {
@@ -791,9 +792,12 @@ block_crypto_amend_options_generic_luks(BlockDriverState *bs,/* apply for exclusive read/write permissions to the underlying file*/ crypto->updating_keys = true; - ret =bdrv_child_refresh_perms (bs, bs->file, errp); -if (ret) { - goto cleanup; + +if (under_bql) { + ret =bdrv_child_refresh_perms (bs, bs->file, errp); +if (ret) { + goto cleanup; + } } ret = qcrypto_block_amend_options(crypto->block,
@@ -806,7 +810,9 @@ block_crypto_amend_options_generic_luks(BlockDriverState *bs, cleanup:/* release exclusive read/write permissions to the underlying file*/ crypto->updating_keys = false; -bdrv_child_refresh_perms (bs, bs->file, errp); +if (under_bql) { +bdrv_child_refresh_perms (bs, bs->file, errp); + }return ret; }
@@ -834,7 +840,7 @@ block_crypto_amend_options_luks(BlockDriverState *bs, goto cleanup; } ret =block_crypto_amend_options_generic_luks (bs, amend_options, - force, errp); + true, force, errp); cleanup:qapi_free_QCryptoBlockAmendOptions (amend_options);return ret;
@@ -853,7 +859,7 @@ coroutine_fn block_crypto_co_amend_luks(BlockDriverState *bs, .u.luks = *qapi_BlockdevAmendOptionsLUKS_base(&opts->u.luks), };return block_crypto_amend_options_generic_luks (bs, &amend_opts, - force, errp); + false, force, errp); } static void
Signature · 1 line
2.27.0
Re: [PATCH v5 30/31] crypto: delegate permission functions to JobDriver .pre_run
Quoted 4 lines · Emanuele Giuseppe Esposito
block_crypto_amend_options_generic_luksuses the block layer permission API, therefore it should be called with the BQL held.However, the same function is being called ib two BlockDriver
s/ ib / by /
Quoted 23 lines
callbacks:
bdrv_amend_options(under BQL) andbdrv_co_amend(I/O).The latter is I/O because it is invoked by block/amend.c's
blockdev_amend_run(), a .run callback of the amend JobDriverTherefore we want to 1) change
block_crypto_amend_options_generic_luksto use the permission API only when the BQL is held, and
2) use the .pre_run JobDriver callback to check for permissions before switching to the job aiocontext. This has also the benefit of applying the same permission operation to all amend implementations, not only luks.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- block/amend.c | 20 ++++++++++++++++++++ block/crypto.c | 18 ++++++++++++------ 2 files changed, 32 insertions(+), 6 deletions(-)block/amend.c +0
-0
block/amend.c static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) · line 61
Quoted 9 lines
block/amend.c +6
-0@@ -53,10 +53,30 @@ static int coroutine_fn blockdev_amend_run(Job *job, Error **errp)return ret; } +static int blockdev_amend_refresh_perms (Job *job,Error **errp) +{ +BlockdevAmendJob *s =container_of (job, BlockdevAmendJob, common); + +return bdrv_child_refresh_perms (s->bs, s->bs->file, errp); +}
I miss some documentation for this function, why we do it and how it works together with the bdrv_co_amend implementation.
I was trying to come up with an example text, but then I wondered – how does it actually work? bdrv_child_refresh_perms() eventually ends up in block_crypto_child_perms(). However, that will only return exceptional permissions if crypto->updating_keys is true. But that’s set only in block_crypto_amend_options_generic_luks() – i.e. when the job runs. That’s exactly why that function calls bdrv_child_refresh_perms() only after it has modified crypto->updating_keys.
Reproducer (amend on a LUKS image with read-only=true, so it doesn’t have the WRITE permission continuously, but needs to take it as an exception in block_crypto_child_perms()):
$ qemu-img create \ -f luks \ --object secret,id=sec0,data=123456 \ -o key-secret=sec0 \ test.luks \ 64M Formatting 'test.luks', fmt=luks size=67108864 key-secret=sec0
$ ./qemu-system-x86_64 \
-object secret,id=sec0,data=123456 \
-object iothread,id=iothr0 \
-blockdev file,node-name=node0,filename=test.luks \
-blockdev luks,node-name=node1,key-secret=sec0,file=node0,read-only=true \
-device virtio-blk,drive=node1,iothread=iothr0 -qmp stdio \
<<EOF
{"execute": "qmp_capabilities"}
{
"execute": "x-blockdev-amend",
"arguments": {
"job-id": "amend0",
"node-name": "node1",
"options": {
"driver": "luks",
"state": "active",
"new-secret": "sec0"
}
}
}
EOF{"QMP": {"version": {"qemu": {"micro": 93, "minor": 1, "major": 6}, "package": "v6.2.0-rc3-50-gdb635fc4e7"}, "capabilities": ["oob"]}} {"return": {}}
{"timestamp": {"seconds": 1639742600, "microseconds": 574641}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "amend0"}} {"timestamp": {"seconds": 1639742600, "microseconds": 574919}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "amend0"}} {"return": {}}
qemu-system-x86_64: ../block/io.c:2041: bdrv_co_write_req_prepare: Assertion `child->perm & BLK_PERM_WRITE' failed. [1] 55880 IOT instruction (core dumped) ./qemu-system-x86_64 -object secret,id=sec0,data=123456 -object -blockdev
I believe this means we need some new block driver function to prepare for an amendment operation. If so, another question comes up, which is whether this preparatory function should then also call bdrv_child_refresh_perms(), and then whether we should have a clean-up function for symmetry.
block/amend.c static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) · line 71
Quoted 10 lines
block/amend.c +10
-0+ +static int blockdev_amend_pre_run (Job *job,Error **errp) +{ +return blockdev_amend_refresh_perms (job, errp); +} + +static void blockdev_amend_clean (Job *job) +{ +Error *errp; +blockdev_amend_refresh_perms (job, &errp);
Do we really want to ignore this error? If so, we shouldn’t pass a pointer to an unused local variable, but NULL.
If we don’t want to ignore it, we have the option of doing what you do here and then at least reporting a potential error with error_report_err(), and then freeing it, and we also must initialize errp to NULL in this case.
If we expect no error to happen (e.g. because we require the amend implementation to only release/share permissions and not acquire/unshare them), then I’d expect passing &error_abort here.
Quoted 16 lines
block/amend.c +4
-0+} +static const JobDriver blockdev_amend_job_driver = { .instance_size =sizeof (BlockdevAmendJob), .job_type =JOB_TYPE_AMEND , .run = blockdev_amend_run, + .pre_run = blockdev_amend_pre_run, + .clean = blockdev_amend_clean, }; void qmp_x_blockdev_amend(const char *job_id,block/crypto.c +0
-0
block/crypto.c block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp) · line 783
Quoted 4 lines
block/crypto.c +1
-0@@ -780,6 +780,7 @@ block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp) static int block_crypto_amend_options_generic_luks(BlockDriverState *bs, QCryptoBlockAmendOptions *amend_options, + bool under_bql,
This name makes sense in the context of this series, but not so much outside of it.
I’d rename it to e.g. “in_amend_job” (and invert its value), and then explain that we don’t need to refresh the child permissions when running in an amend job, because that job has already taken care of that.
OTOH, given that I believe we need some separate preparatory function anyway, perhaps we should just pull out the bdrv_child_refresh_perms() from this function altogether, so that we have:
block_crypto_amend_options_luks():
/* sets updating_keys to true, and invokes bdrv_child_refresh_perms() */ block_crypto_amend_options_prepare(); block_crypto_amend_options_generic_luks();
/* sets updating_keys to false, and invokes bdrv_child_refresh_perms() */ block_crypto_amend_options_clean();
block_crypto_co_amend_luks():
/* No need to prepare or clean up, that is taken care of by the amend job */ block_crypto_amend_options_generic_luks();
(If we decide not to put bdrv_child_refresh_perms() into prepare()/clean(), then it would need to be called by block_crypto_amend_options_luks(); and if we decide not to have a block_crypto_amend_options_clean(), then we’d need to inline it fully.)
Hanna
Quoted 48 lines
block/crypto.c +11
-6bool force, Error **errp) {@@ -791,9 +792,12 @@ block_crypto_amend_options_generic_luks(BlockDriverState *bs,/* apply for exclusive read/write permissions to the underlying file*/ crypto->updating_keys = true; - ret =bdrv_child_refresh_perms (bs, bs->file, errp); -if (ret) { - goto cleanup; + +if (under_bql) { + ret =bdrv_child_refresh_perms (bs, bs->file, errp); +if (ret) { + goto cleanup; + } } ret = qcrypto_block_amend_options(crypto->block,@@ -806,7 +810,9 @@ block_crypto_amend_options_generic_luks(BlockDriverState *bs, cleanup:/* release exclusive read/write permissions to the underlying file*/ crypto->updating_keys = false; -bdrv_child_refresh_perms (bs, bs->file, errp); +if (under_bql) { +bdrv_child_refresh_perms (bs, bs->file, errp); + }return ret; }@@ -834,7 +840,7 @@ block_crypto_amend_options_luks(BlockDriverState *bs, goto cleanup; } ret =block_crypto_amend_options_generic_luks (bs, amend_options, - force, errp); + true, force, errp); cleanup:qapi_free_QCryptoBlockAmendOptions (amend_options);return ret;@@ -853,7 +859,7 @@ coroutine_fn block_crypto_co_amend_luks(BlockDriverState *bs, .u.luks = *qapi_BlockdevAmendOptionsLUKS_base(&opts->u.luks), };return block_crypto_amend_options_generic_luks (bs, &amend_opts, - force, errp); + false, force, errp); } static void
Re: [PATCH v5 30/31] crypto: delegate permission functions to JobDriver .pre_run
Quoted 77 lines · Hanna Reitz
Quoted 4 lines · Emanuele Giuseppe Esposito
block_crypto_amend_options_generic_luksuses the block layer permission API, therefore it should be called with the BQL held.However, the same function is being called ib two BlockDriver
s/ ib / by /
Quoted 23 lines
callbacks:
bdrv_amend_options(under BQL) andbdrv_co_amend(I/O).The latter is I/O because it is invoked by block/amend.c's
blockdev_amend_run(), a .run callback of the amend JobDriverTherefore we want to 1) change
block_crypto_amend_options_generic_luksto use the permission API only when the BQL is held, and
2) use the .pre_run JobDriver callback to check for permissions before switching to the job aiocontext. This has also the benefit of applying the same permission operation to all amend implementations, not only luks.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block/amend.c | 20 ++++++++++++++++++++
block/crypto.c| 18 ++++++++++++------2 files changed, 32 insertions(+), 6 deletions(-)block/amend.c +0
-0block/amend.c static int coroutine_fn blockdev_amend_run(Job · line 61
Quoted 9 lines
block/amend.c +5
-0@@ -53,10 +53,30 @@ static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) return ret; } +static int blockdev_amend_refresh_perms(Job *job, Error **errp) +{ + BlockdevAmendJob *s = container_of(job, BlockdevAmendJob, common); + + return bdrv_child_refresh_perms(s->bs, s->bs->file, errp); +}I miss some documentation for this function, why we do it and how it works together with the
bdrv_co_amendimplementation.I was trying to come up with an example text, but then I wondered – how does it actually work?
bdrv_child_refresh_perms()eventually ends up in block_crypto_child_perms(). However, that will only return exceptional permissions ifcrypto->updating_keysis true. But that’s set only inblock_crypto_amend_options_generic_luks()– i.e. when the job runs. That’s exactly why that function callsbdrv_child_refresh_perms()only after it has modifiedcrypto->updating_keys.Reproducer (amend on a LUKS image with read-only=true, so it doesn’t have the WRITE permission continuously, but needs to take it as an exception in
block_crypto_child_perms()):$ qemu-img create \ -f luks \ --object secret,id=sec0,data=123456 \ -o key-secret=sec0 \ test.luks \ 64M Formatting 'test.luks', fmt=luks size=67108864 key-secret=sec0$ ./qemu-system-x86_64 \ -object secret,id=sec0,data=123456 \ -object iothread,id=iothr0 \ -blockdev file,node-name=node0,filename=test.luks \ -blockdev luks,node-name=node1,key-secret=sec0,file=node0,read-only=true \ -device virtio-blk,drive=node1,iothread=iothr0 -qmp stdio \ <<EOF {"execute": "qmp_capabilities"} { "execute": "x-blockdev-amend", "arguments": { "job-id": "amend0", "node-name": "node1", "options": { "driver": "luks", "state": "active", "new-secret": "sec0" } } } EOF
Quoted 8 lines
{"QMP": {"version": {"qemu": {"micro": 93, "minor": 1, "major": 6}, "package": "v6.2.0-rc3-50-gdb635fc4e7"}, "capabilities": ["oob"]}} {"return": {}}
{"timestamp": {"seconds": 1639742600, "microseconds": 574641}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "amend0"}} {"timestamp": {"seconds": 1639742600, "microseconds": 574919}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "amend0"}} {"return": {}}
qemu-system-x86_64:../block/io.c:2041:bdrv_co_write_req_prepare: Assertion `child->perm &BLK_PERM_WRITE' failed. [1] 55880 IOT instruction (core dumped) ./qemu-system-x86_64
-object secret,id=sec0,data=123456 -object -blockdev
Addendum: Running the iotests, I realized that (because 295 and 296 fail for luks) of course it doesn’t matter whether the job runs in the main loop or not in order to reproduce this assertion failure, so the -object iothread,id=iothr0 and -device virtio-blk,drive=node1,iothread=iothr0 can be dropped from the qemu command line.
Hanna
Re: [PATCH v5 30/31] crypto: delegate permission functions to JobDriver .pre_run
In reply to Hanna ReitzQuoted 88 lines · Hanna Reitz
Quoted 4 lines · Emanuele Giuseppe Esposito
block_crypto_amend_options_generic_luksuses the block layer permission API, therefore it should be called with the BQL held.However, the same function is being called ib two BlockDriver
s/ ib / by /
Quoted 23 lines
callbacks:
bdrv_amend_options(under BQL) andbdrv_co_amend(I/O).The latter is I/O because it is invoked by block/amend.c's
blockdev_amend_run(), a .run callback of the amend JobDriverTherefore we want to 1) change
block_crypto_amend_options_generic_luksto use the permission API only when the BQL is held, and
2) use the .pre_run JobDriver callback to check for permissions before switching to the job aiocontext. This has also the benefit of applying the same permission operation to all amend implementations, not only luks.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block/amend.c | 20 ++++++++++++++++++++
block/crypto.c| 18 ++++++++++++------2 files changed, 32 insertions(+), 6 deletions(-)block/amend.c +0
-0block/amend.c static int coroutine_fn blockdev_amend_run(Job · line 61
Quoted 9 lines
block/amend.c +6
-0@@ -53,10 +53,30 @@ static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) return ret; } +static int blockdev_amend_refresh_perms (Job *job,Error **errp) +{ + BlockdevAmendJob *s = container_of(job, BlockdevAmendJob, common); + + return bdrv_child_refresh_perms(s->bs, s->bs->file, errp); +}I miss some documentation for this function, why we do it and how it works together with the
bdrv_co_amendimplementation.I was trying to come up with an example text, but then I wondered – how does it actually work?
bdrv_child_refresh_perms()eventually ends up in block_crypto_child_perms(). However, that will only return exceptional permissions ifcrypto->updating_keysis true. But that’s set only inblock_crypto_amend_options_generic_luks()– i.e. when the job runs. That’s exactly why that function callsbdrv_child_refresh_perms()only after it has modifiedcrypto->updating_keys.Reproducer (amend on a LUKS image with read-only=true, so it doesn’t have the WRITE permission continuously, but needs to take it as an exception in
block_crypto_child_perms()):$ qemu-img create \ -f luks \ --object secret,id=sec0,data=123456 \ -o key-secret=sec0 \ test.luks \ 64M Formatting 'test.luks', fmt=luks size=67108864 key-secret=sec0$ ./qemu-system-x86_64 \ -object secret,id=sec0,data=123456 \ -object iothread,id=iothr0 \ -blockdev file,node-name=node0,filename=test.luks \ -blockdev luks,node-name=node1,key-secret=sec0,file=node0,read-only=true \ -device virtio-blk,drive=node1,iothread=iothr0 -qmp stdio \ <<EOF {"execute": "qmp_capabilities"} { "execute": "x-blockdev-amend", "arguments": { "job-id": "amend0", "node-name": "node1", "options": { "driver": "luks", "state": "active", "new-secret": "sec0" } } } EOF{"QMP": {"version": {"qemu": {"micro": 93, "minor": 1, "major": 6}, "package": "v6.2.0-rc3-50-gdb635fc4e7"}, "capabilities": ["oob"]}} {"return": {}}
{"timestamp": {"seconds": 1639742600, "microseconds": 574641}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "amend0"}} {"timestamp": {"seconds": 1639742600, "microseconds": 574919}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "amend0"}} {"return": {}}
qemu-system-x86_64:../block/io.c:2041:bdrv_co_write_req_prepare: Assertion `child->perm &BLK_PERM_WRITE' failed. [1] 55880 IOT instruction (core dumped) ./qemu-system-x86_64 -object secret,id=sec0,data=123456 -object -blockdev
Quoted 2 lines
I believe this means we need some new block driver function to prepare for an amendment operation. If so, another question comes up, which is whether this preparatory function should then also call
bdrv_child_refresh_perms(), and then whether we should have a clean-up function for symmetry.
Yes, unfortunately it means that (see at the end of the mail for more).
I think it does not work because of crypto->updating_keys missing in blockdev_amend_pre_run(). That is why the permission is not correctly set and the example fails.
Quoted 13 lines
block/amend.c static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) · line 71
Quoted 10 lines
block/amend.c +10
-0+ +static int blockdev_amend_pre_run (Job *job,Error **errp) +{ + return blockdev_amend_refresh_perms(job, errp); +} + +static void blockdev_amend_clean (Job *job) +{ + Error *errp; + blockdev_amend_refresh_perms(job, &errp);Do we really want to ignore this error? If so, we shouldn’t pass a pointer to an unused local variable, but NULL.
Quoted 1 line
If we don’t want to ignore it, we have the option of doing what you do here and then at least reporting a potential error with
error_report_err(), and then freeing it, and we also must initialize errp to NULL in this case.
Going with this one above, thanks.
Quoted 39 lines
If we expect no error to happen (e.g. because we require the amend implementation to only release/share permissions and not acquire/unshare them), then I’d expect passing
&error_aborthere.Quoted 16 lines
block/amend.c +4
-0+} + static const JobDriver blockdev_amend_job_driver = { .instance_size = sizeof(BlockdevAmendJob), .job_type = JOB_TYPE_AMEND, .run = blockdev_amend_run, + .pre_run = blockdev_amend_pre_run, + .clean = blockdev_amend_clean, }; void qmp_x_blockdev_amend(const char *job_id,block/crypto.c +0
-0@@ -780,6 +780,7 @@block_crypto_get_specific_info_luks (BlockDriverState *bs, Error **errp)Quoted 4 lines
static int
block_crypto_amend_options_generic_luks(BlockDriverState *bs, QCryptoBlockAmendOptions*amend_options, + boolunder_bql,This name makes sense in the context of this series, but not so much outside of it.
I’d rename it to e.g. “in_amend_job” (and invert its value), and then explain that we don’t need to refresh the child permissions when running in an amend job, because that job has already taken care of that.
OTOH, given that I believe we need some separate preparatory function anyway, perhaps we should just pull out the
bdrv_child_refresh_perms()from this function altogether, so that we have:
block_crypto_amend_options_luks():/* sets
updating_keysto true, and invokesbdrv_child_refresh_perms()*/block_crypto_amend_options_prepare();block_crypto_amend_options_generic_luks();
/* setsupdating_keysto false, and invokesbdrv_child_refresh_perms()*/block_crypto_amend_options_clean();
Quoted 7 lines
block_crypto_co_amend_luks():/* No need to prepare or clean up, that is taken care of by the amend job */
block_crypto_amend_options_generic_luks();(If we decide not to put
bdrv_child_refresh_perms()into prepare()/clean(), then it would need to be called byblock_crypto_amend_options_luks(); and if we decide not to have ablock_crypto_amend_options_clean(), then we’d need to inline it fully.)
So a couple of things I will change (according with your feedbacks):
- Remove the assertion job->aio_context == qemu_in_main_thread() done in job_co_entry, as it is wrong. I don't know why I added that, but we cannot assume that job->run() always run in the main context, because the job aiocontext can be different. I don't think there is a test doing that now, but it is possible. If run() was in the main context, then bdrv_co_amend (called only in blockdev_amend_run) would be GS too, but it isn't, also according with your comment in v4:
"[...] .bdrv_co_amend very much strikes me like a GS function, but it isn’t. I’m afraid it must work on nodes that are not in the main context, and it launches a job, so AFAIU we absolutely cannot run it under the BQL."
- Introduce block_crypto_amend_options_prepare and block_crypto_amend_options_clean, as you suggested above. These fix the GS call stack of block_crypto_amend_options_generic_luks()
- Introduce .bdrv_pre_run() and .bdrv_cleanup(), respectively called by .job_pre_run() and .job_cleanup(). The reason is that we need to set crypto->updating_keys, otherwise the job amend won't temporary give the write permission so the example above would fail.
So for the I/O callstack of block_crypto_amend_options_generic_luks() we will have:job->pre_run():
.bdrv_pre_run(); crypto->update_keys = true; blockdev_amend_refresh_perms()
job->run():
block_crypto_amend_options_generic_luks()
job->cleanup():
.bdrv_cleanup(); crypto->update_keys = false; blockdev_amend_refresh_perms()
Thank you,
Emanuele
Quoted 51 lines
Hanna
Quoted 47 lines
bool force, Error **errp) {
block/crypto.c +6
-3@@ -791,9 +792,12 @@block_crypto_amend_options_generic_luks (BlockDriverState *bs, /* apply for exclusive read/write permissions to the underlying file*/ crypto->updating_keys = true; - ret = bdrv_child_refresh_perms(bs, bs->file, errp); - if (ret) { - goto cleanup; + + if (under_bql) { + ret = bdrv_child_refresh_perms(bs, bs->file, errp); + if (ret) { + goto cleanup; + } } ret = qcrypto_block_amend_options(crypto->block,@@ -806,7 +810,9 @@ block_crypto_amend_options_generic_luks(BlockDriverState *bs,cleanup:
/* release exclusive read/write permissions to the underlying file*/crypto->updating_keys= false;
-bdrv_child_refresh_perms(bs, bs->file, errp);
+ if (under_bql) {
+bdrv_child_refresh_perms(bs, bs->file, errp);
+ }
return ret;
}block/crypto.c +1
-1@@ -834,7 +840,7 @@ block_crypto_amend_options_luks(BlockDriverState *bs, goto cleanup; } ret = block_crypto_amend_options_generic_luks(bs, amend_options, - force, errp); + true, force, errp);cleanup:
qapi_free_QCryptoBlockAmendOptions(amend_options); return ret;block/crypto.c +1
-1@@ -853,7 +859,7 @@ coroutine_fn block_crypto_co_amend_luks(BlockDriverState *bs, .u.luks = *qapi_BlockdevAmendOptionsLUKS_base(&opts->u.luks), }; return block_crypto_amend_options_generic_luks(bs, &amend_opts, - force, errp); + false, force, errp); }static void
Re: [PATCH v5 30/31] crypto: delegate permission functions to JobDriver .pre_run
Quoted 184 lines · Emanuele Giuseppe Esposito
Quoted 88 lines · Hanna Reitz
Quoted 4 lines · Emanuele Giuseppe Esposito
block_crypto_amend_options_generic_luksuses the block layer permission API, therefore it should be called with the BQL held.However, the same function is being called ib two BlockDriver
s/ ib / by /
Quoted 23 lines
callbacks:
bdrv_amend_options(under BQL) andbdrv_co_amend(I/O).The latter is I/O because it is invoked by block/amend.c's
blockdev_amend_run(), a .run callback of the amend JobDriverTherefore we want to 1) change
block_crypto_amend_options_generic_luksto use the permission API only when the BQL is held, and
2) use the .pre_run JobDriver callback to check for permissions before switching to the job aiocontext. This has also the benefit of applying the same permission operation to all amend implementations, not only luks.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
block/amend.c | 20 ++++++++++++++++++++
block/crypto.c| 18 ++++++++++++------2 files changed, 32 insertions(+), 6 deletions(-)block/amend.c +0
-0block/amend.c static int coroutine_fn blockdev_amend_run(Job · line 61
Quoted 9 lines
block/amend.c +6
-0@@ -53,10 +53,30 @@ static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) return ret; } +static int blockdev_amend_refresh_perms (Job *job,Error **errp) +{ + BlockdevAmendJob *s = container_of(job, BlockdevAmendJob, common); + + return bdrv_child_refresh_perms(s->bs, s->bs->file, errp); +}I miss some documentation for this function, why we do it and how it works together with the
bdrv_co_amendimplementation.I was trying to come up with an example text, but then I wondered – how does it actually work?
bdrv_child_refresh_perms()eventually ends up in block_crypto_child_perms(). However, that will only return exceptional permissions ifcrypto->updating_keysis true. But that’s set only inblock_crypto_amend_options_generic_luks()– i.e. when the job runs. That’s exactly why that function callsbdrv_child_refresh_perms()only after it has modifiedcrypto->updating_keys.Reproducer (amend on a LUKS image with read-only=true, so it doesn’t have the WRITE permission continuously, but needs to take it as an exception in
block_crypto_child_perms()):$ qemu-img create \ -f luks \ --object secret,id=sec0,data=123456 \ -o key-secret=sec0 \ test.luks \ 64M Formatting 'test.luks', fmt=luks size=67108864 key-secret=sec0$ ./qemu-system-x86_64 \ -object secret,id=sec0,data=123456 \ -object iothread,id=iothr0 \ -blockdev file,node-name=node0,filename=test.luks \ -blockdev luks,node-name=node1,key-secret=sec0,file=node0,read-only=true \ -device virtio-blk,drive=node1,iothread=iothr0 -qmp stdio \ <<EOF {"execute": "qmp_capabilities"} { "execute": "x-blockdev-amend", "arguments": { "job-id": "amend0", "node-name": "node1", "options": { "driver": "luks", "state": "active", "new-secret": "sec0" } } } EOF{"QMP": {"version": {"qemu": {"micro": 93, "minor": 1, "major": 6}, "package": "v6.2.0-rc3-50-gdb635fc4e7"}, "capabilities": ["oob"]}} {"return": {}}
{"timestamp": {"seconds": 1639742600, "microseconds": 574641}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "amend0"}} {"timestamp": {"seconds": 1639742600, "microseconds": 574919}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "amend0"}} {"return": {}}
qemu-system-x86_64:../block/io.c:2041:bdrv_co_write_req_prepare: Assertion `child->perm &BLK_PERM_WRITE' failed. [1] 55880 IOT instruction (core dumped) ./qemu-system-x86_64
-object secret,id=sec0,data=123456 -object -blockdevQuoted 2 lines
I believe this means we need some new block driver function to prepare for an amendment operation. If so, another question comes up, which is whether this preparatory function should then also call
bdrv_child_refresh_perms(), and then whether we should have a clean-up function for symmetry.Yes, unfortunately it means that (see at the end of the mail for more).
I think it does not work because of
crypto->updating_keysmissing inblockdev_amend_pre_run(). That is why the permission is not correctly set and the example fails.Quoted 13 lines
block/amend.c static int coroutine_fn blockdev_amend_run(Job *job, Error **errp) · line 71
Quoted 10 lines
block/amend.c +10
-0+ +static int blockdev_amend_pre_run (Job *job,Error **errp) +{ + return blockdev_amend_refresh_perms(job, errp); +} + +static void blockdev_amend_clean (Job *job) +{ + Error *errp; + blockdev_amend_refresh_perms(job, &errp);Do we really want to ignore this error? If so, we shouldn’t pass a pointer to an unused local variable, but NULL.
Quoted 1 line
If we don’t want to ignore it, we have the option of doing what you do here and then at least reporting a potential error with
error_report_err(), and then freeing it, and we also must initialize errp to NULL in this case.Going with this one above, thanks.
Quoted 39 lines
If we expect no error to happen (e.g. because we require the amend implementation to only release/share permissions and not acquire/unshare them), then I’d expect passing
&error_aborthere.Quoted 16 lines
block/amend.c +4
-0+} + static const JobDriver blockdev_amend_job_driver = { .instance_size = sizeof(BlockdevAmendJob), .job_type = JOB_TYPE_AMEND, .run = blockdev_amend_run, + .pre_run = blockdev_amend_pre_run, + .clean = blockdev_amend_clean, }; void qmp_x_blockdev_amend(const char *job_id,block/crypto.c +0
-0@@ -780,6 +780,7 @@block_crypto_get_specific_info_luks (BlockDriverState *bs, Error **errp)Quoted 4 lines
static int block_crypto_amend_options_generic_luks(BlockDriverState *bs, QCryptoBlockAmendOptions
*amend_options,
+ boolunder_bql,This name makes sense in the context of this series, but not so much outside of it.
I’d rename it to e.g. “in_amend_job” (and invert its value), and then explain that we don’t need to refresh the child permissions when running in an amend job, because that job has already taken care of that.
OTOH, given that I believe we need some separate preparatory function anyway, perhaps we should just pull out the
bdrv_child_refresh_perms()from this function altogether, so that we have:
block_crypto_amend_options_luks():/* sets
updating_keysto true, and invokesbdrv_child_refresh_perms()*/block_crypto_amend_options_prepare();block_crypto_amend_options_generic_luks();
/* setsupdating_keysto false, and invokesbdrv_child_refresh_perms()*/block_crypto_amend_options_clean();Quoted 7 lines
block_crypto_co_amend_luks():/* No need to prepare or clean up, that is taken care of by the amend job */
block_crypto_amend_options_generic_luks();(If we decide not to put
bdrv_child_refresh_perms()into prepare()/clean(), then it would need to be called byblock_crypto_amend_options_luks(); and if we decide not to have ablock_crypto_amend_options_clean(), then we’d need to inline it fully.)So a couple of things I will change (according with your feedbacks):
- Remove the assertion
job->aio_context==qemu_in_main_thread()done
injob_co_entry, as it is wrong. I don't know why I added that, but we cannot assume thatjob->run()always run in the main context, because the job aiocontext can be different. I don't think there is a test doing that now, but it is possible. Ifrun()was in the main context, thenbdrv_co_amend(called only inblockdev_amend_run) would be GS too, but it isn't, also according with your comment in v4:"[...] .bdrv_co_amend very much strikes me like a GS function, but it isn’t. I’m afraid it must work on nodes that are not in the main context, and it launches a job, so AFAIU we absolutely cannot run it under the BQL."
- Introduce
block_crypto_amend_options_prepareandblock_crypto_amend_options_clean, as you suggested above. These fix the GS call stack ofblock_crypto_amend_options_generic_luks()- Introduce .bdrv_pre_run() and .bdrv_cleanup(), respectively called
by .job_pre_run() and .job_cleanup(). The reason is that we need to setcrypto->updating_keys, otherwise the job amend won't temporary give the write permission so the example above would fail.So for the I/O callstack of
block_crypto_amend_options_generic_luks()we will have:job->pre_run():
.bdrv_pre_run();
crypto->update_keys= true;
blockdev_amend_refresh_perms()
Quoted 7 lines
job->run():
block_crypto_amend_options_generic_luks()
job->cleanup():
.bdrv_cleanup();
crypto->update_keys= false;
blockdev_amend_refresh_perms()
Sounds good! The only adjustment I’d make is to add “amend” somewhere in the .bdrv functions (e.g. “.bdrv_amend_pre_run” and “.bdrv_amend_cleanup”), because AFAIU they’ll still be amend-specific, right?
(Happy holidays :))
Hanna
PATCH v5 31/31 block.c: assertions to the block layer permissions API
In reply to Emanuele Giuseppe EspositoNow that we "covered" the three main cases where the permission API was being used under BQL (fuse, amend and invalidate_cache), we can safely assert for the permission functions implemented in block.c
--- block.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
block.c +12 -0
@@ -2138,6 +2138,7 @@ static bool bdrv_a_allow_b(BdrvChild *a, BdrvChild *b, Error **errp)assert (a->bs);assert (a->bs == b->bs); +assert (qemu_in_main_thread ());if ((b->perm & a->shared_perm) == b->perm) {return true;
@@ -2161,6 +2162,7 @@ static bool bdrv_a_allow_b(BdrvChild *a, BdrvChild *b, Error **errp)static bool bdrv_parent_perms_conflict (BlockDriverState *bs,Error **errp) {BdrvChild *a, *b; +assert (qemu_in_main_thread ());/* * During the loop we'll look at each pair twice. That's correct because
@@ -2245,6 +2247,8 @@ static void bdrv_child_set_perm_abort(void *opaque) {BdrvChildSetPermState *s = opaque; +assert (qemu_in_main_thread ()); + s->child->perm = s->old_perm; s->child->shared_perm = s->old_shared_perm; }
@@ -2258,6 +2262,7 @@ static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared, Transaction *tran) { BdrvChildSetPermState *s = g_new(BdrvChildSetPermState, 1); +assert (qemu_in_main_thread ()); *s = (BdrvChildSetPermState) { .child = c,
@@ -2442,6 +2447,7 @@ static int bdrv_node_refresh_perm(BlockDriverState *bs, BlockReopenQueue *q,BdrvChild *c;int ret;uint64_t cumulative_perms, cumulative_shared_perms; +assert (qemu_in_main_thread ());bdrv_get_cumulative_perm (bs, &cumulative_perms, &cumulative_shared_perms);
@@ -2510,6 +2516,7 @@ static int bdrv_list_refresh_perms(GSList *list, BlockReopenQueue *q, {int ret;BlockDriverState *bs; +assert (qemu_in_main_thread ());for ( ; list; list = list->next) { bs = list->data;
@@ -2582,6 +2589,7 @@ static int bdrv_refresh_perms(BlockDriverState *bs, Error **errp)int ret;Transaction *tran =tran_new ();g_autoptr (GSList) list =bdrv_topological_dfs (NULL ,NULL , bs); +assert (qemu_in_main_thread ()); ret =bdrv_list_refresh_perms (list,NULL , tran, errp);tran_finalize (tran, ret);
@@ -2648,6 +2656,7 @@ static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c, uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared) { +assert (qemu_in_main_thread ()); *nperm = perm &DEFAULT_PERM_PASSTHROUGH ; *nshared = (shared &DEFAULT_PERM_PASSTHROUGH ) |DEFAULT_PERM_UNCHANGED ; }
@@ -2659,6 +2668,7 @@ static void bdrv_default_perms_for_cow(BlockDriverState *bs, BdrvChild *c, uint64_t *nperm, uint64_t *nshared) { assert(role & BDRV_CHILD_COW); +assert (qemu_in_main_thread ());/* * We want consistent read from backing files if the parent needs it.
@@ -2696,6 +2706,7 @@ static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c, {int flags; +assert (qemu_in_main_thread ());assert (role & (BDRV_CHILD_METADATA |BDRV_CHILD_DATA )); flags =bdrv_reopen_get_flags (reopen_queue, bs);
@@ -6094,6 +6105,7 @@ static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent, {BlockPermission qapi_perm;XDbgBlockGraphEdge *edge; +assert (qemu_in_main_thread ()); edge =g_new0 (XDbgBlockGraphEdge,1 );
Signature · 1 line
2.27.0
Quoted 49 lines · Emanuele Giuseppe Esposito
v5 -> v6:
* In short, apply all Hanna's comments. More in details, the following functions in the following headers have been moved:
block-backend:
blk_replace_bs(to gs)
blk_nb_sectors(to io)
blk_name(to io)
blk_set_perm(to io)
blk_get_perm(to io)
blk_drain(to io)
blk_abort_aio_request(to io)
blk_make_empty(to gs)
blk_invalidate_cache(was in io, but had GS assertion)blk_aio_cancel(to gs)
block:
bdrv_replace_child_bs(to gs)
bdrv_get_device_name(to io)bdrv_get_device_or_node_name(to io)bdrv_drained_end_no_poll(to io)
bdrv_block_status(was in io, but had GS assertion)bdrv_drain(to io)
bdrv_co_drain(to io)
bdrv_make_zero(was in GS, but did not have the assertion)bdrv_save_vmstate(to io)
bdrv_load_vmstate(to io)
bdrv_aio_cancel_async(to io)
block_int:
bdrv_get_parent_name(to io)bdrv_apply_subtree_drain(to io)bdrv_unapply_subtree_drain(to io)bdrv_co_copy_range_from(was in io, but had GS assertion)bdrv_co_copy_range_to(was in io, but had GS assertion) ->bdrv_save_vmstate (to io)
->bdrv_load_vmstate (to io)coding style (assertion after definitions):
bdrv_save_vmstate
bdrv_load_vmstate
block_job_next
block_job_getnew patches:
block.c: modify .attach and .detach callbacks ofchild_of_bdsintroducepre_runas JobDriver callback to handle
bdrv_co_amendusage of permission function
leave blk_set/get_perm as a TODO infuse.c
make surebdrv_co_invalidate_cachedoes not use permissions
if BQL is not held
Quoted 4 lines
minor changes:
put back TODO for includeblock/block.hinblock-backend-common.hrebase on kwolf/block branch
modify where are usedassert_bdrv_graph_writable, due to rebase
These changes sound fine to me. Hanna or Kevin can merge the series when they are happy.
Stefan
Quoted 50 lines · Stefan Hajnoczi
Quoted 49 lines · Emanuele Giuseppe Esposito
v5 -> v6:
* In short, apply all Hanna's comments. More in details, the following functions in the following headers have been moved:
block-backend:
blk_replace_bs(to gs)
blk_nb_sectors(to io)
blk_name(to io)
blk_set_perm(to io)
blk_get_perm(to io)
blk_drain(to io)
blk_abort_aio_request(to io)
blk_make_empty(to gs)
blk_invalidate_cache(was in io, but had GS assertion)blk_aio_cancel(to gs)
block:
bdrv_replace_child_bs(to gs)
bdrv_get_device_name(to io)bdrv_get_device_or_node_name(to io)bdrv_drained_end_no_poll(to io)
bdrv_block_status(was in io, but had GS assertion)bdrv_drain(to io)
bdrv_co_drain(to io)
bdrv_make_zero(was in GS, but did not have the assertion)bdrv_save_vmstate(to io)
bdrv_load_vmstate(to io)
bdrv_aio_cancel_async(to io)
block_int:
bdrv_get_parent_name(to io)bdrv_apply_subtree_drain(to io)bdrv_unapply_subtree_drain(to io)bdrv_co_copy_range_from(was in io, but had GS assertion)bdrv_co_copy_range_to(was in io, but had GS assertion) ->bdrv_save_vmstate (to io)
->bdrv_load_vmstate (to io)coding style (assertion after definitions):
bdrv_save_vmstate
bdrv_load_vmstate
block_job_next
block_job_getnew patches:
block.c: modify .attach and .detach callbacks ofchild_of_bdsintroducepre_runas JobDriver callback to handle
bdrv_co_amendusage of permission function
leave blk_set/get_perm as a TODO infuse.c
make surebdrv_co_invalidate_cachedoes not use permissions
if BQL is not held
Quoted 8 lines
Quoted 4 lines
minor changes:
put back TODO for includeblock/block.hinblock-backend-common.hrebase on kwolf/block branch
modify where are usedassert_bdrv_graph_writable, due to rebaseThese changes sound fine to me. Hanna or Kevin can merge the series when they are happy.
Just a tiny nitpick, I would just not merge patch 10: "block.c: modify .attach and .detach callbacks of child_of_bds". It is not wrong and should produce no side effect, but does not do what it was intended for (ie using the drain to protect the bs's list of children). I will work on that in a future serie. Apologies.
Thank you,
Emanuele