[Devel] [PATCH hci-8.1 v2 3/7] dm-qcow2: prepare process_one_qio() for fastpath

Andrey Zhadchenko andrey.zhadchenko at virtuozzo.com
Tue Nov 10 16:50:53 MSK 2026


This whole situation is pre-existing in general (the same scenario is 
possible for base dm-qcow2). Theoretically this issue exists but 
practically higly higly unlikely because on each re-allocation we first 
do fallocate to punch zeroes which takes inode lock on xfs/ext4 like 
discard does.
So not only there should be concurrent write/discard, there also should 
be third write, and the write into discarding cluster should be paused 
for astronomically big amount of time: after first query it should at 
least outsleep two inode-wide exclusive IO locks and a lot of actions 
in-between.
Despite the gap becoming bigger after this series, given the 
pre-existing nature, I have not planned to change this behavior as this 
is a separate patchset that implements per-md write counters or locking 
for discards.

On 11/10/26 12:59, no-reply at sashiko.virtuozzo.com wrote:
> Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
> - [Medium] dm-qcow2: fast path uses unpinned L2 mapping between parse_metadata() and data submit
> --
> 
> commit a3dc5e64e9aa8f73ed35df62194a86cf78276045
> Author: Andrey Zhadchenko <andrey.zhadchenko at virtuozzo.com>
> 
> dm-qcow2: prepare process_one_qio() for fastpath
> 
> This patch adds an avoid_metadata_changes flag to process_one_qio(),
> handle_metadata() and parse_metadata(). With the flag set, a qio that needs
> metadata changes, R1/R2 lookups or a compressed cluster is handed back to the
> main kwork through the new QIO_NEEDS_MAIN_KWORK return code. All callers in
> this patch pass false.
> 
> Link: https://virtuozzo.atlassian.net/browse/VSTOR-95494
> 
>> diff --git a/drivers/md/dm-qcow2-map.c b/drivers/md/dm-qcow2-map.c
>> --- a/drivers/md/dm-qcow2-map.c
>> +++ b/drivers/md/dm-qcow2-map.c
> 
> [ ... ]
> 
>> @@ -2075,6 +2084,9 @@ static int parse_metadata(struct qcow2 *qcow2, struct qio **qio,
>>   	if (!qio_may_modify_image(qcow2, *qio))
>>   		return 0;
>>   
>> +	if (avoid_metadata_changes)
>> +		return QIO_NEEDS_MAIN_KWORK;
>> +
>>   	/* Now refcounters table/block */
>>   	ret = qcow2_handle_r1r2_maps(qcow2, pos, qio, &map->r1,
>>   			       &map->r2, map->compressed);
> 
> [Severity: Medium]
> In this patch alone the flag is only ever passed as false, so this path is
> not reachable yet. It becomes live with the later patches that add per-qio
> fast processing and per-cpu fast workers. Those call process_one_qio(...,
> true) from outside the main kwork. Is the L2 mapping stable between
> parse_metadata() and the data submit in that case?
> 
> parse_metadata() drops md_pages_lock at its unlock label before this point.
> A qio that continues on the fast path then carries map->data_clu_pos and
> map->l2.md with no lock, pin or wpc_readers reference:
> 
> process_one_qio()
>    handle_metadata()
>      parse_metadata()          /* md_pages_lock dropped at unlock */
>    process_read_qio() or perform_rw_mapped()
>      map_and_submit_rw(qcow2, map->data_clu_pos, qio)
> 
> Meanwhile the main kwork can run the discard path:
> 
> prepare_cluster_discard()
>    prepare_l_entry_replace()
> issue_discard()
>    qcow2_punch_hole(qcow2->file, pos, qio->bi_iter.bi_size)
> 
> issue_discard() punches the hole immediately. It does not wait for fast
> path qios that already parsed the same L2 entry.
> 
> Can a fast-path read or write then go to a cluster that a concurrent
> discard has already unmapped and freed, and which may have been reallocated
> to another guest offset? That would return stale or foreign data on a read,
> or write into a reused cluster.
> 
> As far as I can see, wpc_readers is taken only for compressed and shared
> clusters in submit_read_whole_cow_clu() and submit_read_compressed(), and
> this patch excludes compressed clusters from the fast path. The other
> mechanisms only affect qios that parse later: delay_if_wpc_readers_locked()
> and md_index_set_locked() do not cover a qio that has already parsed.
> perform_rw_mapped() only revalidates the DIRTY and WRITEBACK state.
> 
> Fully allocated, non-COW, non-compressed clusters were already untracked
> before this patch, so the new exposure is the added parse-to-submit window
> in the per-cpu worker. That window can stretch if the worker is preempted.
> 
> The commit message says "if the request does not require metadata changes
> we should be able to immediately dispatch it." What keeps the L2 entry and
> data cluster stable for such a qio until its data I/O is submitted?
> 
> [ ... ]
> 
>> -static void process_one_qio(struct qcow2 *qcow2, struct qio *qio)
>> +static int process_one_qio(struct qcow2 *qcow2, struct qio *qio, bool avoid_metadata_changes)
>>   {
>>   	struct qcow2_map map = { .qcow2 = qcow2, };
>>   	bool write;
>> +	int ret;
>>   
>> -	if (!handle_metadata(qcow2, &qio, &map))
>> -		return;
>> +	ret = handle_metadata(qcow2, &qio, &map, avoid_metadata_changes);
>> +	if (!ret)
>> +		return 0;
>> +	else if (ret == QIO_NEEDS_MAIN_KWORK)
>> +		return 1;
> 
> [Severity: Medium]
> This is the other side of the same concern. When handle_metadata() returns 1
> with avoid_metadata_changes set, the code below goes on to
> process_read_qio() or perform_rw_mapped() without any protection against a
> concurrent discard on the main kwork, as described above. Is there something
> that closes this window?
> 



More information about the Devel mailing list