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 B6B3C803F6 for ; Tue, 17 Nov 2026 17:20:06 +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 6AHHIr2p011183; Tue, 17 Nov 2026 20:18:53 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AHHIr2p011183 Authentication-Results: mail.openvz.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=virtuozzo.com header.i=@virtuozzo.com header.b="NxvsZUBr" Received: from mail-wm1-f69.google.com (mail-wm1-f69.google.com [209.85.128.69]) by mail.openvz.org (8.14.4/8.14.4) with ESMTP id 6AHHIpt8011179 (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128 verify=FAIL) for ; Tue, 17 Nov 2026 20:18:51 +0300 DKIM-Filter: OpenDKIM Filter v2.11.0 mail.openvz.org 6AHHIpt8011179 Received: by mail-wm1-f69.google.com with SMTP id 5b1f17b1804b1-4a0284121c6so521925e9.3 for ; Tue, 17 Nov 2026 09:18:51 -0800 (PST) X-Forwarded-Encrypted: i=2; AL+hErGymnSbHBeuKBoEwPDy7iipD3DYmyPaKdkt2AX7wWj8EiYjsZ30b0zzTaFijva8i3keLVTzjg==@openvz.org X-Gm-Message-State: APuU4Z8l+T9ZrBiMlXYUS9S4OcR4NYCpv4aULFUR22+ayLkUV5MTMbYT aVmKbDU69WHIP/95i3uSrhh+oe+xx3FD4tXgQG2a7yMvUJHD+zA+XNfpqmYkgHaP9LGkgPK0Yw5 53+GvLRhHzv/rQHlut+BGjXplAa47Z2lgW1EVA5YN6B0RJwvgEwmNEQ== X-Gm-Gg: AYBFou1OTLdqRx27vCjaUP8BNdOZvQ/NU3rDLEZQnf6fmlXIaPqzjyk6mmnVVm8yHD+ +Ot27Wugry5DU39tdsMHN9bVauCphWQqJzz56XiN2UdSxLVf4Oo6fEqH5WM1BFf2ELlJtWusuS3 kYOba62My1j1XKI/SvBdzmv22etXZRB7ZvFvU/Hve13rEweiWJypKqFpIPFqeyWmruVYEcKjXim rH011kJHIffc4fUit9+sQ3K88/dN/qpGNeg9DW+eAmJvw3sCL7N4nIYnP1cPCHqfeHR31SSEP0w Nob8dXguoeLALdmpbVd8CgY9tRWpSoZPTVhIEue1ONZqaQ8D3tYCPjqTWckJCm8Hy4IWwshkZ0V HM7TCWjQ4Fb+OQMGA/l7eRnoC0lww X-Received: by 2002:a05:600c:8b8c:b0:4a1:fbd2:f689 with SMTP id 5b1f17b1804b1-4bb609ae053mr259478165e9.7.1794935930910; Tue, 17 Nov 2026 09:18:50 -0800 (PST) X-Received: by 2002:a05:600c:8b8c:b0:4a1:fbd2:f689 with SMTP id 5b1f17b1804b1-4bb609ae053mr259477215e9.7.1794935930168; Tue, 17 Nov 2026 09:18:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1794935930; cv=none; d=google.com; s=arc-20260327; b=nbLXOlmmNEbVR7hRRMK30hh04FvF7fuGia2DRf8fwXhYryhQtUcjpZ5f3lJcCXnPvo q3wxzUjyikecvQ/OK3nwPsDjhuYAbaHhul4v/T6jYG4gicFqW1RC8yX6N24mRZ5XuYIH 332HF9ruhfsOnkSHGj2yciVXwvBnOKiBvTyvavrEld+sVTWz2BCquamerQGnG7iCyODP cG1qQvZPGQjmmCz00asBPYbelKgfwlpcIyOaQhs6eJK9XTF6CCQ4FTWfAE9CeaPd1CAP 31GwQf1Jt6cUkPNlhaYWKF7F6975164sB9nEK/JAPrXh1awyjk20BueKfWhmX688O47Y higA== 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=jjDU0iteRF117+Dek+7JlTvABPn26ldgRVC7CI40+dM=; fh=CMILZ+goaghq6B4UpCDhf0EQp6kYD0LAlmOkUiVCOvs=; b=lfpkWt5kG1l/mZgqdO9MREfBLetcLPRNZwZi+EemwYcogu0EvGBK6qcYcF24Bptn3S Kjrz/6Jkl9XKd8dL5Q6xGjTpsCCyG3bx2ge6Gx+hMUG2ELBzNlrw+Pomi2EAX7tW3oq1 4PsWEzC5JKrAcoSf2AsqCLIo8VgYXu9nZwtaGNPGi7P1N5jP0DJtlJoXkVe4U27FF+3A bB7Noz9C1q4EWSkGbE4IujO06Xng9v9l0WK7z/s4GNCSmRxuyg05w0KbtzmOlJfZNKeh QfepUK2wYHO7y0G/ZwSivBH8Ws5oHOcV9873JDyoqXfvPr0tJbpB8ULgKiRns+WXIxPQ Um9g==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@virtuozzo.com header.s=relay header.b=NxvsZUBr; spf=pass (google.com: domain of alexander.ivanov@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=alexander.ivanov@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 5b1f17b1804b1-4bb7ad8be9csi44659555e9.23.2026.11.17.09.18.50 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Nov 2026 09:18:50 -0800 (PST) Received-SPF: pass (google.com: domain of alexander.ivanov@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=NxvsZUBr; spf=pass (google.com: domain of alexander.ivanov@virtuozzo.com designates 130.117.225.111 as permitted sender) smtp.mailfrom=alexander.ivanov@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=jjDU0iteRF117+Dek+7JlTvABPn26ldgRVC7CI40+dM=; b=NxvsZUBrEe+O ygOZVMQ6rAtZd9xUgf49s6Q4B5aCgnuEMB3Rn/m5dvCxqMjrxt3iB/f6+YfNf4rDYPkFad2000ASG Aa/if35rwBorOpFKOx6ZNwuXcaZHRofmu5zK6JULSBsxl5RylNXVtyhrlrJPz094eiNmOeBwav2Ra 8gJFQ/HxZj3IbamBrIu0LIKL8VfSH6Jl3u2qrXZqWINdX4JDwrT0G9BQtnRsx7pSBuEy4NYl3G8d2 dfXPsX58pdyrzWeAgu5nY/+OMRuEROLEN00dLcbntXQwQGvF1Zd2cFMWEtWLlNxfKIgC5twMMo2p5 QTFAsvuxbZH6aZmPuHk00g==; Received: from ch-vpn.virtuozzo.com ([130.117.225.6] helo=sky) by relay.virtuozzo.com with esmtps (TLS1.3) tls TLS_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1xTMkH-00HOVM-1O; Tue, 17 Nov 2026 18:17:40 +0100 From: Alexander Ivanov To: andrey.zhadchenko@virtuozzo.com Date: Tue, 17 Nov 2026 18:17:43 +0100 Message-ID: <20261117171743.3216794-11-alexander.ivanov@virtuozzo.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20261117171743.3216794-1-alexander.ivanov@virtuozzo.com> References: <20261117171743.3216794-1-alexander.ivanov@virtuozzo.com> MIME-Version: 1.0 X-OZ-Fwd: true Cc: devel@openvz.org Subject: [Devel] [PATCH hci-8.1 v7 10/10] dm-ploop: truncate unused tail of top delta on suspend 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 Preallocated space and clusters at the end of the top delta freed by discard are never given back, so the file size never shrinks. Now that ploop reloads metadata on resume, we can truncate the top delta on suspend: the next resumed ploop (maybe of reloaded table) picks up the new file size. Add ploop_calc_used_end(), which returns the end of the last cluster used by the delta: either BAT area, the last mapped cluster or format extension. Metadata is read from disk rather than taken from memory: the next table load checks BAT entries against the file size (-EPROTO otherwise), while in-memory BAT may differ from on-disk one after failed BAT writeback. Skip it if md pages are not clean, as on-disk BAT may miss allocated clusters then. Userspace writes format extension (CBT) behind the last data cluster of suspended device on umount, resumes it, and then removes the device, which suspends it again. So keep the area up to the end of format extension header, which is the last cluster of the extension, as userspace does. Name the corresponding header field properly instead of m_Reserved. The field was never interpreted before, so if it is not cluster-aligned or out of range, don't truncate anything: unaligned truncation would make the next resume fail with -EPROTO. Truncate the top delta to the used end in ploop_postsuspend() after pending preallocation is completed. Do it under ctl_rwsem, so that ploop messages (e.g. resize) don't change the image in parallel. Skip read-only devices and raw top delta. On error just leave the file as is. Skip devices in standby mode as well: the top delta file is dead then, and the truncation may hang with md->suspend_lock held, so dm_replace() of libploop could neither replace nor remove the device. Also skip it if the file size differs from top->file_size. Then another ploop on the same images writes to the top delta (e.g. a live one left by libploop error path), and on-disk BAT may miss clusters it has just allocated, so the truncation would cut its data. https://virtuozzo.atlassian.net/browse/VSTOR-148171 Feature: dm-ploop: ploop target driver Signed-off-by: Alexander Ivanov --- drivers/md/dm-ploop-bat.c | 56 +++++++++++++++++++++++++ drivers/md/dm-ploop-target.c | 79 ++++++++++++++++++++++++++++++------ drivers/md/dm-ploop.h | 3 +- 3 files changed, 125 insertions(+), 13 deletions(-) diff --git a/drivers/md/dm-ploop-bat.c b/drivers/md/dm-ploop-bat.c index c060afdd8d3e..7bab746a3707 100644 --- a/drivers/md/dm-ploop-bat.c +++ b/drivers/md/dm-ploop-bat.c @@ -709,6 +709,62 @@ int ploop_reload_metadata(struct ploop *ploop) } ALLOW_ERROR_INJECTION(ploop_reload_metadata, ERRNO); +/* + * Returns the end of the last cluster of delta @file used by BAT area, + * mapped clusters or format extension, according to on-disk metadata. + * Must be called on suspended device. + */ +loff_t ploop_calc_used_end(struct ploop *ploop, struct file *file) +{ + u32 i, end, nr_be, dst_clu, used_clus, *bat_entries; + struct rb_root md_root = RB_ROOT; + struct ploop_pvd_header *hdr; + struct rb_node *node; + struct md_page *md; + u64 ext_off, ext_clu; + loff_t used_end; + int ret; + + /* BAT on disk may miss allocated clusters until writeback is done */ + if (WARN_ON_ONCE(!ploop_md_pages_are_clean(ploop))) + return -EBUSY; + + ret = ploop_read_delta_metadata(ploop, file, &md_root, &nr_be); + if (ret) + return ret; + + used_clus = ploop_nr_bat_clusters(ploop, nr_be); + rb_root_for_each_md_page(&md_root, md, node) { + bat_entries = md->kmpage; + init_be_iter(nr_be, md->id, &i, &end); + for (; i <= end; i++) { + dst_clu = READ_ONCE(bat_entries[i]); + if (dst_clu != BAT_ENTRY_NONE && dst_clu >= used_clus) + used_clus = dst_clu + 1; + } + } + + /* The header is the last cluster, see delta_save_optional_header() */ + hdr = ploop_md_first_entry(&md_root)->kmpage; + ext_off = le64_to_cpu(hdr->m_FormatExtensionOffset); + if (ext_off) { + ext_clu = SEC_TO_CLU(ploop, ext_off); + if (CLU_TO_SEC(ploop, ext_clu) != ext_off || + ext_clu >= BAT_ENTRY_NONE) { + used_end = -EPROTO; + goto out; + } + if (ext_clu >= used_clus) + used_clus = ext_clu + 1; + } + + used_end = CLU_TO_POS(ploop, used_clus); +out: + ploop_free_md_pages_tree(&md_root); + return used_end; +} +ALLOW_ERROR_INJECTION(ploop_calc_used_end, ERRNO); + void ploop_put_delta(struct ploop *ploop, struct ploop_delta *delta) { int i; diff --git a/drivers/md/dm-ploop-target.c b/drivers/md/dm-ploop-target.c index 968a608c67f4..aa71f22352aa 100644 --- a/drivers/md/dm-ploop-target.c +++ b/drivers/md/dm-ploop-target.c @@ -451,8 +451,9 @@ static struct ploop_worker *ploop_worker_create(struct ploop *ploop, * ploop_dtr, as ploop_dtr is called on the old ploop after the new one is * resumed, so we can't possibly modify the image from the old ploop context * at this point, as new ploop may be already doing its own IO or - * preallocation. This truncation should be done on ploop_*suspend (see - * dm-qcow2 as it already implements that in qcow2_truncate_unused_tail). + * preallocation. So this truncation is done on ploop_postsuspend (see + * ploop_truncate_unused_tail), and the new ploop picks up the new size + * of the top delta on metadata reload. */ static int ploop_ctr(struct dm_target *ti, unsigned int argc, char **argv) { @@ -715,14 +716,6 @@ static void ploop_set_wants_suspend(struct dm_target *ti, bool wants) ploop->wants_suspend = wants; spin_unlock_irq(&ploop->deferred_lock); } -static void ploop_set_suspended(struct dm_target *ti, bool suspended) -{ - struct ploop *ploop = ti->private; - - down_write(&ploop->ctl_rwsem); - ploop->suspended = suspended; - up_write(&ploop->ctl_rwsem); -} static bool ploop_is_standby(struct ploop *ploop) { @@ -751,10 +744,66 @@ static void ploop_presuspend_undo(struct dm_target *ti) { ploop_set_wants_suspend(ti, false); } + +/* + * Truncate preallocations and the tail of the top delta, which became + * unused after discard. The next resumed ploop (maybe of reloaded + * table) re-reads the size of the top delta in ploop_preresume(). + */ +static void ploop_truncate_unused_tail(struct ploop *ploop) +{ + struct ploop_delta *top = ploop_top_delta(ploop); + unsigned long flags; + loff_t end; + int ret; + + lockdep_assert_held_write(&ploop->ctl_rwsem); + + if (ploop_is_ro(ploop) || top->is_raw) + return; + if (ploop_is_standby(ploop)) + return; + if (!ploop_no_pending_prealloc(ploop)) + return; + if (i_size_read(file_inode(top->file)) != top->file_size) { + PL_ERR("Top delta is changed by someone else, don't truncate it"); + return; + } + + end = ploop_calc_used_end(ploop, top->file); + if (end < 0) { + PL_ERR("Can't find used end of top delta: %lld", end); + return; + } + if (end >= top->file_size) + return; + + /* BAT writeback finished after ploop_presuspend() is not durable yet */ + ret = vfs_fsync(top->file, 0); + if (ret) { + PL_ERR("Can't sync top delta: %d", ret); + return; + } + + ret = do_ftruncate(top->file, end, 0); + if (ret) { + PL_ERR("Can't truncate unused tail of top delta: %d", ret); + return; + } + + spin_lock_irqsave(&ploop->bat_lock, flags); + top->file_size = end; + if (top->file_preallocated_area_start > end) + top->file_preallocated_area_start = end; + spin_unlock_irqrestore(&ploop->bat_lock, flags); +} + static void ploop_postsuspend(struct dm_target *ti) { struct ploop *ploop = ti->private; + unsigned int noio_flags; + down_write(&ploop->ctl_rwsem); /* * Let the next resumed ploop (maybe of reloaded table) * see final size of the top delta. Don't wait in standby @@ -770,10 +819,16 @@ static void ploop_postsuspend(struct dm_target *ti) /* * Data bios are completed before BAT writeback is finished * (see ploop_put_piwb()), so wait for it explicitly to make - * md pages clean for ploop_reload_metadata(). + * md pages clean for ploop_reload_metadata() and + * ploop_calc_used_end(). */ wait_event(ploop->inflight_md_wq, !atomic_read(&ploop->inflight_md)); - ploop_set_suspended(ti, true); + /* The device is suspended, see ploop_preresume() */ + noio_flags = memalloc_noio_save(); + ploop_truncate_unused_tail(ploop); + memalloc_noio_restore(noio_flags); + ploop->suspended = true; + up_write(&ploop->ctl_rwsem); } static int ploop_preresume(struct dm_target *ti) { diff --git a/drivers/md/dm-ploop.h b/drivers/md/dm-ploop.h index 97841e13568b..55bc0ade6db5 100644 --- a/drivers/md/dm-ploop.h +++ b/drivers/md/dm-ploop.h @@ -37,7 +37,7 @@ struct ploop_pvd_header { __u32 m_DiskInUse; /* Disk in use */ __u32 m_FirstBlockOffset; /* First data block offset (in sectors) */ __u32 m_Flags; /* Misc flags */ - __u8 m_Reserved[8]; /* Reserved */ + __u64 m_FormatExtensionOffset; /* Format extension offset (in sectors) */ }; #pragma pack(pop) @@ -644,6 +644,7 @@ extern void ploop_pio_prepare_offsets(struct ploop *ploop, struct pio *pio, u32 extern int ploop_setup_metadata(struct ploop *ploop, struct page *page, bool check_in_use); extern int ploop_reload_metadata(struct ploop *ploop); +extern loff_t ploop_calc_used_end(struct ploop *ploop, struct file *file); extern int ploop_read_delta_metadata(struct ploop *ploop, struct file *file, struct rb_root *md_root, u32 *delta_nr_be); extern void ploop_index_wb_init(struct ploop_index_wb *piwb, -- 2.53.0 _______________________________________________ Devel mailing list Devel@openvz.org https://lists.openvz.org/mailman/listinfo/devel