From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.openvz.org (mail.openvz.org [69.168.225.77]) by lore.virtuozzo.com (Postfix) with ESMTPS id EDE4A803F6 for ; Fri, 13 Nov 2026 11:18:16 +0000 (UTC) Received: from mail.openvz.org (localhost [127.0.0.1]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6ADBG01M016620; Fri, 13 Nov 2026 14:16:01 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6ADBG01M016620 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="uXbJnEt2" Received: from mail-wm1-f70.google.com (mail-wm1-f70.google.com [209.85.128.70]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6ADBFlau016571 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Fri, 13 Nov 2026 14:15:47 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6ADBFlau016571 Received: by mail-wm1-f70.google.com with SMTP id 5b1f17b1804b1-4a1fdde384cso4128735e9.3 for ; Fri, 13 Nov 2026 03:15:47 -0800 (PST) X-Gm-Message-State: APuU4Z+oa+L+Vl6xoXC/eh9Rx3xvmoqv8EKKBU/6ta5a8/W1yqVZlp5u KRampZDk3m2TDrWeGpb4P19W0U6zOViczYfTHrfLMsTN98GWOPD2LEoXDNyVEg/RgsEO0G2dhOo yMerGawuE4tPnRpjQqFDfMnCA5bESea5tlaQBdE8FWW0v76k2r/LJ9g== X-Gm-Gg: AYBFou1rpRvgHsYrXmse0D/kvVbgWu0wk+08fNhHDFSmoP49jQDVsL9SYtilzanUfaO IPlnD5ABUezHU8zPTUzxQ4eeYg3oTzuBslM8BAt92AsRbLvRvTDYq+h4cF7aIWx8ZZNG5vlVQXX w6+Bj53EdT0Bm05wHI4YRfngj9TofB4XMZS/oG2o7iJ53xQZfEeCmoaVe60+3+UyGbyyovKLoHp tTE3voBibXuiphWToPnoGQDFWge/HHOGjCrDy+w0Dn0Pklsj8oMDr5FYURwKv2Tr9enj4YTzTOE yS5uUItZcXDnKr0ir3jGqiWICVJVZJT6Nsi7SZh4Rur2fnk78eMVEQVQskIk7i82yzk9P8pVeQs z7edrhIRSFx3pEyQvMDH7EadfCtgT5A== X-Received: by 2002:a05:600d:2:b0:4b0:a307:46f8 with SMTP id 5b1f17b1804b1-4bb55a57c2cmr34714335e9.10.1794568546686; Fri, 13 Nov 2026 03:15:46 -0800 (PST) X-Received: by 2002:a05:600d:2:b0:4b0:a307:46f8 with SMTP id 5b1f17b1804b1-4bb55a57c2cmr34713985e9.10.1794568546213; Fri, 13 Nov 2026 03:15:46 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1794568546; cv=none; d=google.com; s=arc-20260327; b=OvK8lDSFzwKem/ipQFvks8UjtIOSib8TdaU3e+wDXxgI3HIXJsHM7cTW3LcZ5Z5nXl For+hiQ+HxZMivP3vlSl5kGZw4t1uCUfq/yOitPPHyjnnyYG/maM0Cxt2PbDvz0Fizbu 7J5mLBqi9qIVXsifIwF6d66rZZg5lN00042J/Q01k4000xrc9+29rLL71D+aqRJWD1f5 Fxyr9gFxzb/PRL1clWRVw3/avCBPd/xU7FV+9qgM8M+61SB4Vh4tjTbQXCU4ndNiBF0P qYl1f3XYnyoaEwWGtR3tlG/sDyzMQcRQXdeDRa5HFssbXmusawUiBwywIW7FSCAPMPFO IXKA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=D8qkbWiaxvgkYLlpY/MClpE1+BFMBoVLCIn13W4tkq4=; fh=ElTTnnNtphHTCCOZ+58STyaWac7y7ytLDJZIF4HMMJ4=; b=Mnq+Y3BB6h0X76v8bdUxfvbFRGOf9PwWa/5ecY89AnRROpXOIyEA0SpC4IGzhG+Wxw 24FDrqBJ4NJhw4HpGDa9Y/9clKa1mDq7dsMfmDhwrMXcWLih0o/g8UItm+UCnBwz39FZ diegkPOAS+Jnp3pjvQAFsKrmCeJQ44pTSW9ieztoGk3aDUtlCk5HSh0svf94Ei1OBto0 Vkf5fKG7lY0a15zLP2BKsPxK1ColW9MupWd4G/ujisqHLJMPfUXIrftYsXKEcuo77h23 3bQTxVPyAOFQvva1tjWWWel21q//lgxt0vQaVPhdYgB2cUCyQ8YTL0dKAQ7JR7x3doLI vECA==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=uXbJnEt2; spf=pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=andrey.zhadchenko@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com Received: from relay.virtuozzo.com (relay.virtuozzo.com. [130.117.225.111]) by mx.google.com with ESMTPS id ffacd0b85a97d-49c64177d8bsi5366271f8f.276.2026.11.13.03.15.46 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Nov 2026 03:15:46 -0800 (PST) Received-SPF: pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 130.117.225.111 as permitted sender) client-ip=130.117.225.111; Authentication-Results: mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=uXbJnEt2; spf=pass (google.com: domain of andrey.zhadchenko@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=andrey.zhadchenko@virtuozzo.com; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=virtuozzo.com DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=virtuozzo.com; s=relay; h=MIME-Version:Message-ID:Date:Subject:From: Content-Type; bh=D8qkbWiaxvgkYLlpY/MClpE1+BFMBoVLCIn13W4tkq4=; b=uXbJnEt28v7y i4aQKbU1P8WTyrpdILm6NqHUQg1VX3zfCv8cEQmgvY13DlYbXJPU+TyW+PNIVYXUYzNfpjpyTQ4MW gpw1UOopJUSKJr2LYzcyLLd5zFvmgi+NbOg8kV/zzJiQ6cxdzaxoQe2YMmhEX5tKvzfHV87DYG0Wz khgiNbS/ebM4lMKVXQSAYx01UY6/2k9f+YkvyJl4oreiveHdmtr8PmnroF2LT+uW5ZWT+Qm5hhFwc PiYeKKWQzjkpoC4VePh/eNDgDWMjhTOVDW7nDjkiJGxhXzKobQTujCm0EKF5s4Ywr2jpdARurtIhv BcT3L3ug2XBbBJiaAfZ+2g==; Received: from [130.117.225.5] (helo=vz9-demens-1.aci.vzint.dev) by relay.virtuozzo.com with esmtp (Exim 4.96) (envelope-from ) id 1xRpBn-007Dd6-1j; Fri, 13 Nov 2026 12:15:42 +0100 From: Andrey Zhadchenko To: khorenko@virtuozzo.com, alexander.ivanov@virtuozzo.com Date: Fri, 13 Nov 2026 14:11:20 +0300 Message-ID: <20261113111126.793039-3-andrey.zhadchenko@virtuozzo.com> X-Mailer: git-send-email 2.43.5 In-Reply-To: <20261113111126.793039-1-andrey.zhadchenko@virtuozzo.com> References: <20261113111126.793039-1-andrey.zhadchenko@virtuozzo.com> MIME-Version: 1.0 X-OZ-Fwd: true Cc: devel@openvz.org Subject: [Devel] [PATCH hci-8.1 v3 2/8] dm-qcow2: prepare process_one_qio() for fastpath X-BeenThere: devel@openvz.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: OpenVZ development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: devel-bounces@openvz.org Errors-To: devel-bounces@openvz.org dm-qcow2 heavily relies on main kwork do_qcow2_work() being sequential. All metadata change happens there and cannot run in parallel. Unfortunately that caps dm-qcow2 performance. But if the request does not require metadata changes we should be able to immediately dispatch it. process_one_qio() and handle_metadata() already know what to do: just add a fast flag to process_one_qio(), passed as avoid_metadata_changes to handle_metadata(), and return codes. While at it, just return in handle_metadata() instead of setting ret to 0 and jumping to if (ret < 0) label. Also pass the flag to parse_metadata() and return to the slow path before it looks up R1/R2 pages. They are needed only by COW writes and cluster unmapping discards, which go to the slow path anyway. Besides the useless lookup, R1 is unstable outside main kwork: an R1 page read in parallel with relocate_refcount_table() may stay cached under a stale page id. Return to the slow path from parse_metadata() also for a write to an index changed in a dirty or under writeback L2 page, i.e. to a cluster whose allocation is not on disk yet. Such a write must be attached to md->wbd, or wait for the writeback end, so it is not acked before its L2 entry is written. Leave this to main kwork, so the fast path never refers to md->wbd. Also exclude compressed clusters as there are some complications with wpc_readers. https://virtuozzo.atlassian.net/browse/VSTOR-95494 Feature: dm-qcow2: block device over QCOW2 files driver Signed-off-by: Andrey Zhadchenko --- v2: return to the slow path before R1/R2 lookup in parse_metadata(); QIO_NEEDS_MAIN_KWORK instead of magic 2; fixed the "avoid_metadata_changes() flag" typo v3: a write to an index changed in a dirty or under writeback L2 page goes to main kwork from parse_metadata(); process_one_qio() parameter renamed to fast; dropped redundant else drivers/md/dm-qcow2-map.c | 63 +++++++++++++++++++++++++++++++-------- 1 file changed, 50 insertions(+), 13 deletions(-) diff --git a/drivers/md/dm-qcow2-map.c b/drivers/md/dm-qcow2-map.c index 58b95d7a955cf..5e254c11ae7b8 100644 --- a/drivers/md/dm-qcow2-map.c +++ b/drivers/md/dm-qcow2-map.c @@ -2094,6 +2094,12 @@ static int qcow2_handle_r1r2_maps(struct qcow2 *qcow2, loff_t pos, struct qio ** return ret; } +/* + * Returned by parse_metadata() and handle_metadata() with + * @avoid_metadata_changes, when @qio must be processed by main kwork. + */ +#define QIO_NEEDS_MAIN_KWORK 2 + /* * This caches pages of allocated on disk md levels, which are * required for submission @qio, and checks they are stable. @@ -2101,11 +2107,17 @@ static int qcow2_handle_r1r2_maps(struct qcow2 *qcow2, loff_t pos, struct qio ** * Returns: negative in case of error, or 0 if success. * Special case: return 0 with zeroed @qio means @qio was deferred * till some event: reading of md page, end of writeback, etc. + * With @avoid_metadata_changes, return QIO_NEEDS_MAIN_KWORK if @qio + * needs R1/R2: outside main kwork R1 is unstable, see + * __handle_r1r2_maps(). The same for a write to an index changed in + * a dirty or under writeback L2 page: it must be attached to md->wbd + * or wait for the writeback, which is left to main kwork. */ static int parse_metadata(struct qcow2 *qcow2, struct qio **qio, - struct qcow2_map *map) + struct qcow2_map *map, bool avoid_metadata_changes) { bool write = op_is_write((*qio)->bi_op); + bool l2_in_flight = false; struct md_page *md; u64 pos; s64 ret; @@ -2148,10 +2160,15 @@ static int parse_metadata(struct qcow2 *qcow2, struct qio **qio, /* Find DATA cluster (from L2 page) */ pos = ret = parse_l2(qcow2, map, qio, write); + if (ret > 0 && write && avoid_metadata_changes) + l2_in_flight = dirty_or_writeback(qcow2, md, + map->l2.index_in_page + !!(qcow2->ext_l2)); unlock: spin_unlock_irq(&qcow2->md_pages_lock); if (ret <= 0) /* Err, delayed, DATA is not allocated, or zero read */ return ret; + if (l2_in_flight) + return QIO_NEEDS_MAIN_KWORK; map->data_clu_pos = pos; if (!write) @@ -2167,6 +2184,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); @@ -3716,24 +3736,31 @@ static int prepare_cluster_discard(struct qcow2 *qcow2, struct qio **qio, } static int handle_metadata(struct qcow2 *qcow2, struct qio **qio, - struct qcow2_map *map) + struct qcow2_map *map, bool avoid_metadata_changes) { bool write = op_is_write((*qio)->bi_op); int ret; - ret = parse_metadata(qcow2, qio, map); + ret = parse_metadata(qcow2, qio, map, avoid_metadata_changes); if (ret < 0 || !*qio) /* Error or postponed */ goto check_err; + if (ret == QIO_NEEDS_MAIN_KWORK) + return QIO_NEEDS_MAIN_KWORK; + + if (avoid_metadata_changes && map->compressed) + return QIO_NEEDS_MAIN_KWORK; ret = 1; if (unlikely(qcow2->backward_merge_in_process)) { + if (avoid_metadata_changes) + return QIO_NEEDS_MAIN_KWORK; /* Keep in mind the below may replace *qio */ ret = prepare_backward_merge(qcow2, qio, map, write); } else if (unlikely(fake_l1cow_qio(*qio)) && (!map->clu_is_cow || (map->level & L2_LEVEL))) { /* Nothing to COW or L1 is mapped exactly once */ qio_endio(*qio); - ret = 0; + return 0; } else if (unlikely(op_is_discard((*qio)->bi_op))) { /* * Discard carries no data and is advisory. If it does not @@ -3741,13 +3768,17 @@ static int handle_metadata(struct qcow2 *qcow2, struct qio **qio, * is not present, end early. */ if (qio_discard_updates_metadata(qcow2, *qio, map)) { + if (avoid_metadata_changes) + return QIO_NEEDS_MAIN_KWORK; ret = prepare_cluster_discard(qcow2, qio, map); } else if (!map->data_clu_alloced || map->clu_is_cow) { qio_endio(*qio); - ret = 0; + return 0; } } else if (write && (!qio_is_fully_alloced(qcow2, *qio, map) || map->clu_is_cow)) { + if (avoid_metadata_changes) + return QIO_NEEDS_MAIN_KWORK; if (map->clu_is_cow) { /* COW to compressed or shared with snapshot cluster */ ret = prepare_l1l2_replace(qcow2, *qio, map); @@ -3859,13 +3890,17 @@ static void process_read_qio(struct qcow2 *qcow2, struct qio *qio, qio_endio(qio); } -static void process_one_qio(struct qcow2 *qcow2, struct qio *qio) +static int process_one_qio(struct qcow2 *qcow2, struct qio *qio, bool fast) { struct qcow2_map map = { .qcow2 = qcow2, }; bool write; + int ret; - if (!handle_metadata(qcow2, &qio, &map)) - return; + ret = handle_metadata(qcow2, &qio, &map, fast); + if (!ret) + return 0; + if (ret == QIO_NEEDS_MAIN_KWORK) + return 1; /* * Merge machinery makes out of order merges for present @@ -3877,7 +3912,7 @@ static void process_one_qio(struct qcow2 *qcow2, struct qio *qio) if (unlikely(qcow2->backward_merge_in_process) && (fake_merge_qio(qio) || qcow2_file_is_writable(qcow2))) { submit_top_delta_read(&map, qio); - return; + return 0; } write = op_is_write(qio->bi_op); @@ -3885,13 +3920,13 @@ static void process_one_qio(struct qcow2 *qcow2, struct qio *qio) /* Process discard early. Don't do COW just to discard */ if (unlikely(op_is_discard(qio->bi_op))) { issue_discard(&map, qio); - return; + return 0; } if (unlikely(map.compressed)) { /* Compressed qio never uses sub-clus */ submit_read_compressed(&map, qio, write); - return; + return 0; } if (!write) { @@ -3904,6 +3939,8 @@ static void process_one_qio(struct qcow2 *qcow2, struct qio *qio) else perform_rw_mapped(&map, qio); } + + return 0; } static struct bio_vec *create_bvec_from_rq(struct request *rq) @@ -4006,7 +4043,7 @@ static void process_deferred_qios(struct qcow2 *qcow2, struct list_head *qios) continue; } - process_one_qio(qcow2, qio); + process_one_qio(qcow2, qio, false); } } @@ -4946,7 +4983,7 @@ static int qcow2_llseek_hole_qio(struct qio *qio, int whence, loff_t *result) map.qcow2 = qio->qcow2; qptr = qio; - ret = parse_metadata(qio->qcow2, &qptr, &map); + ret = parse_metadata(qio->qcow2, &qptr, &map, false); if (ret < 0) break; if (qptr == NULL) { -- 2.43.5 _______________________________________________ Devel mailing list Devel@openvz.org https://lists.openvz.org/mailman/listinfo/devel