* [Devel] [PATCH hci-8.1 v2 0/3] ext4, xfs: discard the balloon on FITRIM
@ 2026-11-10 22:27 Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it Denis V. Lunev
` (2 more replies)
0 siblings, 3 replies; 7+ messages in thread
From: Denis V. Lunev @ 2026-11-10 22:27 UTC (permalink / raw)
To: khorenko; +Cc: devel
The balloon holds filesystem space that never carries data, but its
blocks are allocated, so FITRIM walks past them, and inflating the
balloon is a plain fallocate() that does not discard either. Once the
balloon is inflated over the blocks of removed files, e.g. on an online
shrink of a Container disk, the ploop or qcow2 image keeps those
clusters mapped for good, and compaction, which is FITRIM, does not
give them back (VSTOR-153590).
This series makes FITRIM discard the unwritten extents of the balloon
after the free space, on ext4 (patch 2) and xfs (patch 3). The walk
holds the inode locks of the balloon exclusively, after waiting for
direct I/O and flushing its page cache, as punch hole does, so no block
can be freed, reused or written under the discard. Physically adjacent
extents are merged, so that the device below gets whole clusters, and
a long run is discarded in interruptible chunks. A balloon inflated
before this series is released by the next FITRIM, no userspace change
is needed. Patch 1 fixes an inode reference leak in xfs_balloon_get()
that FITRIM would now hit too.
The ploop side is openvz/ploop.ovz PR 519: tests for this, and fixes of
the ploop-balloon discard options found on the way:
https://bitbucket.org/openvz/ploop.ovz/pull-requests/519
Changes since v1
(https://lore.virtuozzo.com/kernel/20261110212459.3158424-1-den@openvz.org/):
- take the balloon inode locks exclusively, wait for direct I/O and
flush the page cache before the walk; v1 held the shared lock, which
did not keep writeback and direct I/O from converting an extent the
walk had seen unwritten (Sashiko);
- walk to the end of the file instead of i_size, as fallocate() with
FALLOC_FL_KEEP_SIZE can leave unwritten extents past it (Sashiko);
- discard a merged run in chunks aligned to the discard granularity,
checking for fatal signals and freezing between them;
- drop the read-only mount skip: ploop does not set balloon_ino on a
read-only mount, and the free space pass does not skip one either;
- ext4: do not count the balloon in the trimmed length, so fstrim -v no
longer reports it as freed on every call; no 64-bit division on
i_size any more (Sashiko);
- xfs: fail FITRIM on an error reading the balloon inode, use
GFP_KERNEL, and fix the xfs_balloon_get() leak in patch 1 (Sashiko);
- every FITRIM still discards the balloon again: neither filesystem
bumps a counter on fallocate() of the balloon that a skip could rely
on, and a wrong skip would leave clusters mapped for good, while a
repeated discard of unmapped clusters is cheap.
Tested on 6.12.0-211.52.1.22.19.vz10 rebuilt with this series and the
VSTOR-154159 max_discard_segments fixes:
- ploop and qcow2 images with ext4 and xfs: write 2G, remove it without
a trim, inflate the balloon over the free space, ploop-balloon
discard. Stock: the image keeps mapping the removed 2G. Patched: the
image maps about as much as when it was created, a kept file is
intact, fsck and ploop check / qemu-img check are clean;
- 16G removed under a balloon of about 38G: a full fstrim takes under
3 seconds, a SIGKILL one second into it ends fstrim at once, a
repeated fstrim takes a fraction of a second, fsck is clean;
- test_ploop_balloon.py from PR 519: green on ploop and qcow2. On the
stock kernel only the tests for the space under the balloon fail.
Not covered: ext4 bigalloc, a realtime xfs balloon (skipped). On ploop1
discard works on whole clusters, so up to two clusters at the ends of
each contiguous piece of the balloon stay mapped, as do pieces shorter
than the FITRIM minimum length.
Denis V. Lunev (3):
xfs: release the balloon inode when xfs_balloon_get() refuses it
ext4: discard the balloon on FITRIM
xfs: discard the balloon on FITRIM
fs/ext4/mballoc.c | 126 +++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_discard.c | 144 +++++++++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_super.c | 4 +-
3 files changed, 273 insertions(+), 1 deletion(-)
--
2.53.0
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it
2026-11-10 22:27 [Devel] [PATCH hci-8.1 v2 0/3] ext4, xfs: discard the balloon on FITRIM Denis V. Lunev
@ 2026-11-10 22:27 ` Denis V. Lunev
2026-11-10 22:31 ` no-reply
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 3/3] xfs: " Denis V. Lunev
2 siblings, 1 reply; 7+ messages in thread
From: Denis V. Lunev @ 2026-11-10 22:27 UTC (permalink / raw)
To: khorenko; +Cc: devel
From: Denis V. Lunev <den@openvz.org>
xfs_balloon_get() looks the balloon inode up with xfs_iget() and returns
-EINVAL when it is not a regular file or is immutable, without
releasing the reference it took. Every statfs and every open of the
balloon then leaks a reference on such an inode, which the VFS reports
as a busy inode at unmount.
Release the inode before returning -EINVAL.
https://virtuozzo.atlassian.net/browse/VSTOR-153590
Feature: fs/xfs: fast online shrink support
Signed-off-by: Denis V. Lunev <den@openvz.org>
---
fs/xfs/xfs_super.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index d24ceb045364..6deab3e5d76c 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -924,8 +924,10 @@ xfs_balloon_get(struct xfs_mount *mp, u64 balloon_ino, uint flags)
if (error)
return ERR_PTR(error);
inode = VFS_I(ip);
- if (!S_ISREG(inode->i_mode) || IS_IMMUTABLE(inode))
+ if (!S_ISREG(inode->i_mode) || IS_IMMUTABLE(inode)) {
+ xfs_irele(ip);
return ERR_PTR(-EINVAL);
+ }
return ip;
}
--
2.53.0
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM
2026-11-10 22:27 [Devel] [PATCH hci-8.1 v2 0/3] ext4, xfs: discard the balloon on FITRIM Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it Denis V. Lunev
@ 2026-11-10 22:27 ` Denis V. Lunev
2026-11-10 22:35 ` no-reply
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 3/3] xfs: " Denis V. Lunev
2 siblings, 1 reply; 7+ messages in thread
From: Denis V. Lunev @ 2026-11-10 22:27 UTC (permalink / raw)
To: khorenko; +Cc: devel
From: Denis V. Lunev <den@openvz.org>
The balloon holds file system space that never carries data, but its
blocks are allocated, so ext4_trim_all_free() never discards them, and
inflating the balloon is a plain fallocate() that does not discard
either. Once the balloon is inflated over blocks that held data, e.g.
on an online shrink after files were removed, the device below keeps
them allocated: a ploop or qcow2 image keeps host disk space the
container can never use, and compaction, which is FITRIM, does not give
it back.
Walk the balloon after the free space in ext4_trim_fs() and discard its
unwritten extents that fall into the requested range. The walk goes to
the end of the extent tree, as fallocate() with FALLOC_FL_KEEP_SIZE can
leave extents past i_size. Physically adjacent extents are merged into
one discard, otherwise every cut at the unwritten extent length limit
leaves a partly covered cluster of the image below. A merged run is
discarded in chunks, with a check for fatal signals and freezing
between them.
The walk holds i_rwsem and the invalidate lock exclusively, after
waiting for direct I/O and flushing the page cache of the balloon, as
punch hole does. No block of the balloon can be freed and reused under
the discard, and nothing is written to it meanwhile, so an extent that
is still unwritten reads as zeroes before and after the discard. The
balloon is hidden from lookup and opened only through
EXT4_IOC_OPEN_BALLOON, which takes CAP_SYS_ADMIN, so the lock only
waits for ploop inflating or shrinking it.
Every FITRIM discards the balloon again, which costs little: dm-ploop
completes the discard of an unmapped cluster at once. The balloon is
not counted in the trimmed length reported to userspace, and a discard
error fails FITRIM.
A balloon inflated before this change is released by the next FITRIM.
https://virtuozzo.atlassian.net/browse/VSTOR-153590
Feature: fs/ext4: fast online shrink support
Signed-off-by: Denis V. Lunev <den@openvz.org>
---
fs/ext4/mballoc.c | 126 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 126 insertions(+)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index aaf2c24c514c..5fb87753975d 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -7009,6 +7009,126 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
return ret;
}
+#define EXT4_BALLOON_DISCARD_CHUNK (128U << 20)
+
+static int ext4_trim_balloon_run(struct super_block *sb, ext4_fsblk_t pblk,
+ ext4_fsblk_t len, ext4_fsblk_t start,
+ ext4_fsblk_t end, ext4_fsblk_t minblocks)
+{
+ unsigned int gran = max_t(unsigned int, 1,
+ bdev_discard_granularity(sb->s_bdev) >> sb->s_blocksize_bits);
+ unsigned int chunk = roundup(EXT4_BALLOON_DISCARD_CHUNK >>
+ sb->s_blocksize_bits, gran);
+ ext4_fsblk_t last = pblk + len - 1, next;
+ int ret;
+
+ if (!len)
+ return 0;
+ if (pblk < start)
+ pblk = start;
+ if (last > end)
+ last = end;
+ if (last < pblk || last - pblk + 1 < minblocks)
+ return 0;
+
+ /*
+ * Chunks keep a long run interruptible. They end on multiples of the
+ * discard granularity, so no cluster below is split between two.
+ */
+ while (pblk <= last) {
+ u64 rem = pblk;
+
+ next = pblk + chunk - do_div(rem, chunk);
+ if (next > last + 1)
+ next = last + 1;
+ trace_ext4_discard_blocks(sb, pblk, next - pblk);
+ ret = sb_issue_discard(sb, pblk, next - pblk, GFP_NOFS, 0);
+ if (ret)
+ return ret;
+ pblk = next;
+ if (ext4_trim_interrupted())
+ break;
+ cond_resched();
+ }
+
+ return 0;
+}
+
+/*
+ * Blocks of the balloon never hold data, but they are allocated, so
+ * ext4_trim_all_free() never discards them. Discard its unwritten
+ * extents, merging physically adjacent ones, so that the device below
+ * can release the space as it does for free blocks.
+ */
+static int ext4_trim_balloon(struct super_block *sb, ext4_fsblk_t start,
+ ext4_fsblk_t end, ext4_fsblk_t minblocks)
+{
+ struct ext4_sb_info *sbi = EXT4_SB(sb);
+ ext4_fsblk_t run_pblk = 0, run_len = 0;
+ struct ext4_map_blocks map;
+ struct inode *inode = NULL;
+ ext4_lblk_t lblk;
+ bool unwritten;
+ int ret, err;
+
+ /* ext4_load_balloon() replaces s_balloon_ino under s_umount */
+ down_read(&sb->s_umount);
+ if (sbi->s_balloon_ino)
+ inode = igrab(sbi->s_balloon_ino);
+ up_read(&sb->s_umount);
+ if (!inode)
+ return 0;
+
+ /*
+ * Nobody may write the balloon meanwhile: data written into an
+ * unwritten extent would be discarded with it.
+ */
+ inode_lock(inode);
+ inode_dio_wait(inode);
+ filemap_invalidate_lock(inode->i_mapping);
+ ret = filemap_write_and_wait(inode->i_mapping);
+ if (ret)
+ goto out;
+
+ for (lblk = 0; lblk < EXT_MAX_BLOCKS; lblk += map.m_len) {
+ if (ext4_trim_interrupted())
+ break;
+ cond_resched();
+
+ map.m_lblk = lblk;
+ map.m_len = EXT_MAX_BLOCKS - lblk;
+ err = ext4_map_blocks(NULL, inode, &map, 0);
+ if (err < 0) {
+ ret = err;
+ break;
+ }
+ if (!map.m_len)
+ break;
+
+ unwritten = err > 0 && (map.m_flags & EXT4_MAP_UNWRITTEN);
+ if (unwritten && run_len && run_pblk + run_len == map.m_pblk) {
+ run_len += map.m_len;
+ continue;
+ }
+
+ ret = ext4_trim_balloon_run(sb, run_pblk, run_len, start, end,
+ minblocks);
+ if (ret)
+ break;
+ run_pblk = map.m_pblk;
+ run_len = unwritten ? map.m_len : 0;
+ }
+ if (!ret && !ext4_trim_interrupted())
+ ret = ext4_trim_balloon_run(sb, run_pblk, run_len, start, end,
+ minblocks);
+out:
+ filemap_invalidate_unlock(inode->i_mapping);
+ inode_unlock(inode);
+ iput(inode);
+
+ return ret;
+}
+
/**
* ext4_trim_fs() -- trim ioctl handle function
* @sb: superblock for filesystem
@@ -7028,6 +7148,7 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
ext4_group_t group, first_group, last_group;
ext4_grpblk_t cnt = 0, first_cluster, last_cluster;
uint64_t start, end, minlen, trimmed = 0;
+ ext4_fsblk_t last_blk;
ext4_fsblk_t first_data_blk =
le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
ext4_fsblk_t max_blks = ext4_blocks_count(EXT4_SB(sb)->s_es);
@@ -7061,6 +7182,7 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
&first_group, &first_cluster);
ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) end,
&last_group, &last_cluster);
+ last_blk = end;
/* end now represents the last cluster to discard in this group */
end = EXT4_CLUSTERS_PER_GROUP(sb) - 1;
@@ -7103,6 +7225,10 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range)
first_cluster = 0;
}
+ if (!ret && !ext4_trim_interrupted())
+ ret = ext4_trim_balloon(sb, start, last_blk,
+ EXT4_C2B(EXT4_SB(sb), minlen));
+
if (!ret)
EXT4_SB(sb)->s_last_trim_minblks = minlen;
--
2.53.0
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* [Devel] [PATCH hci-8.1 v2 3/3] xfs: discard the balloon on FITRIM
2026-11-10 22:27 [Devel] [PATCH hci-8.1 v2 0/3] ext4, xfs: discard the balloon on FITRIM Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM Denis V. Lunev
@ 2026-11-10 22:27 ` Denis V. Lunev
2026-11-10 22:36 ` no-reply
2 siblings, 1 reply; 7+ messages in thread
From: Denis V. Lunev @ 2026-11-10 22:27 UTC (permalink / raw)
To: khorenko; +Cc: devel
From: Denis V. Lunev <den@openvz.org>
The balloon holds file system space that never carries data, but its
blocks are allocated, so the free space walk of xfs_ioc_trim() never
discards them, and inflating the balloon is a plain fallocate() that
does not discard either. Once the balloon is inflated over blocks that
held data, e.g. on an online shrink after files were removed, the
device below keeps them allocated: a ploop or qcow2 image keeps host
disk space the container can never use, and compaction, which is
FITRIM, does not give it back.
Walk the balloon after the free space of the data device and discard
its unwritten extents that fall into the requested range, merging
physically adjacent ones into one discard. The walk goes to the end of
the file offset space, as fallocate() with FALLOC_FL_KEEP_SIZE can
leave extents past i_size. A merged run is discarded in chunks, with a
check for fatal signals and freezing between them.
The walk holds the IOLOCK and the MMAPLOCK exclusively, after waiting
for direct I/O and flushing the page cache of the balloon. No block of
the balloon can be freed and reused under the discard, and nothing is
written to it meanwhile, so an extent that is still unwritten reads as
zeroes before and after the discard. The balloon is hidden from lookup
and opened only through XFS_IOC_OPEN_BALLOON, which takes
CAP_SYS_ADMIN, so the locks only wait for ploop inflating or shrinking
it.
Every FITRIM discards the balloon again, which costs little: dm-ploop
completes the discard of an unmapped cluster at once. A discard error
or a failure to read the balloon inode fails FITRIM; a balloon that is
no longer a regular mutable file is skipped.
A balloon inflated before this change is released by the next FITRIM.
https://virtuozzo.atlassian.net/browse/VSTOR-153590
Feature: fs/xfs: fast online shrink support
Signed-off-by: Denis V. Lunev <den@openvz.org>
---
fs/xfs/xfs_discard.c | 144 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 144 insertions(+)
diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
index 93943e698eea..b9b5a28b0d96 100644
--- a/fs/xfs/xfs_discard.c
+++ b/fs/xfs/xfs_discard.c
@@ -22,6 +22,10 @@
#include "xfs_health.h"
#include "xfs_rtbitmap.h"
#include "xfs_rtgroup.h"
+#include "xfs_bit.h"
+#include "xfs_inode.h"
+#include "xfs_bmap.h"
+#include "xfs_super.h"
/*
* Notes on an efficient, low latency fstrim algorithm
@@ -833,6 +837,140 @@ xfs_trim_rtdev_extents(
# define xfs_trim_rtdev_extents(...) (-EOPNOTSUPP)
#endif /* CONFIG_XFS_RT */
+#define XFS_BALLOON_DISCARD_CHUNK_BB ((128U << 20) >> BBSHIFT)
+
+static int
+xfs_trim_balloon_run(
+ struct xfs_mount *mp,
+ xfs_daddr_t daddr,
+ uint64_t len,
+ xfs_daddr_t start,
+ xfs_daddr_t end,
+ xfs_extlen_t minlen)
+{
+ struct block_device *bdev = mp->m_ddev_targp->bt_bdev;
+ unsigned int gran = max(1U,
+ bdev_discard_granularity(bdev) >> BBSHIFT);
+ unsigned int chunk = roundup(XFS_BALLOON_DISCARD_CHUNK_BB, gran);
+ xfs_daddr_t last = daddr + len - 1, next;
+ int error;
+
+ if (!len)
+ return 0;
+ if (daddr < start)
+ daddr = start;
+ if (last > end)
+ last = end;
+ if (last < daddr || last - daddr + 1 < XFS_FSB_TO_BB(mp, minlen))
+ return 0;
+
+ /*
+ * Chunks keep a long run interruptible. They end on multiples of the
+ * discard granularity, so no cluster below is split between two.
+ */
+ while (daddr <= last) {
+ u64 rem = daddr;
+
+ next = daddr + chunk - do_div(rem, chunk);
+ if (next > last + 1)
+ next = last + 1;
+ error = blkdev_issue_discard(bdev, daddr, next - daddr,
+ GFP_KERNEL);
+ if (error)
+ return error;
+ daddr = next;
+ if (xfs_trim_should_stop())
+ break;
+ cond_resched();
+ }
+
+ return 0;
+}
+
+/*
+ * Blocks of the balloon never hold data, but they are allocated, so the
+ * free space btree walk never discards them. Discard its unwritten
+ * extents, merging physically adjacent ones, so that the device below
+ * can release the space as it does for free blocks.
+ */
+static int
+xfs_trim_balloon(
+ struct xfs_mount *mp,
+ xfs_daddr_t start,
+ xfs_daddr_t end,
+ xfs_extlen_t minlen)
+{
+ u64 balloon_ino = READ_ONCE(mp->m_balloon_ino);
+ xfs_daddr_t run_daddr = 0;
+ uint64_t run_len = 0;
+ struct xfs_bmbt_irec map;
+ struct xfs_inode *ip;
+ xfs_fileoff_t off = 0;
+ unsigned int lock_mode;
+ bool unwritten;
+ int nmaps, error;
+
+ if (!balloon_ino)
+ return 0;
+ ip = xfs_balloon_get(mp, balloon_ino, 0);
+ if (IS_ERR(ip))
+ return PTR_ERR(ip) == -EINVAL ? 0 : PTR_ERR(ip);
+ error = 0;
+ if (XFS_IS_REALTIME_INODE(ip))
+ goto out_rele;
+
+ /*
+ * Nobody may write the balloon meanwhile: data written into an
+ * unwritten extent would be discarded with it.
+ */
+ xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
+ inode_dio_wait(VFS_I(ip));
+ error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
+ if (error)
+ goto out_unlock;
+
+ while (off < XFS_MAX_FILEOFF) {
+ if (xfs_trim_should_stop())
+ break;
+ cond_resched();
+
+ nmaps = 1;
+ lock_mode = xfs_ilock_data_map_shared(ip);
+ error = xfs_bmapi_read(ip, off, XFS_MAX_FILEOFF - off, &map,
+ &nmaps, 0);
+ xfs_iunlock(ip, lock_mode);
+ if (error || !nmaps || !map.br_blockcount)
+ break;
+ off = map.br_startoff + map.br_blockcount;
+
+ unwritten = xfs_bmap_is_real_extent(&map) &&
+ map.br_state == XFS_EXT_UNWRITTEN;
+ if (unwritten && run_len && run_daddr + run_len ==
+ XFS_FSB_TO_DADDR(mp, map.br_startblock)) {
+ run_len += XFS_FSB_TO_BB(mp, map.br_blockcount);
+ continue;
+ }
+
+ error = xfs_trim_balloon_run(mp, run_daddr, run_len, start,
+ end, minlen);
+ if (error)
+ break;
+ run_len = 0;
+ if (unwritten) {
+ run_daddr = XFS_FSB_TO_DADDR(mp, map.br_startblock);
+ run_len = XFS_FSB_TO_BB(mp, map.br_blockcount);
+ }
+ }
+ if (!error && !xfs_trim_should_stop())
+ error = xfs_trim_balloon_run(mp, run_daddr, run_len, start,
+ end, minlen);
+out_unlock:
+ xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
+out_rele:
+ xfs_irele(ip);
+ return error;
+}
+
/*
* trim a range of the filesystem.
*
@@ -905,6 +1043,12 @@ xfs_ioc_trim(
error = xfs_trim_datadev_extents(mp, start, end, minlen);
if (error)
last_error = error;
+
+ if (!xfs_trim_should_stop()) {
+ error = xfs_trim_balloon(mp, start, end, minlen);
+ if (error)
+ last_error = error;
+ }
}
if (rt_bdev && !xfs_trim_should_stop()) {
--
2.53.0
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it Denis V. Lunev
@ 2026-11-10 22:31 ` no-reply
0 siblings, 0 replies; 7+ messages in thread
From: no-reply @ 2026-11-10 22:31 UTC (permalink / raw)
To: Denis V. Lunev, khorenko; +Cc: devel
> From: Denis V. Lunev <den@openvz.org>
>
> xfs_balloon_get() looks the balloon inode up with xfs_iget() and returns
> -EINVAL when it is not a regular file or is immutable, without
> releasing the reference it took. Every statfs and every open of the
> balloon then leaks a reference on such an inode, which the VFS reports
> as a busy inode at unmount.
>
> Release the inode before returning -EINVAL.
>
> https://virtuozzo.atlassian.net/browse/VSTOR-153590
>
> Feature: fs/xfs: fast online shrink support
> Signed-off-by: Denis V. Lunev <den@openvz.org>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.vzint.dev/#/patchset/20261110222756.3236854-2-den@openvz.org?part=1
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM Denis V. Lunev
@ 2026-11-10 22:35 ` no-reply
0 siblings, 0 replies; 7+ messages in thread
From: no-reply @ 2026-11-10 22:35 UTC (permalink / raw)
To: Denis V. Lunev, khorenko; +Cc: devel
> From: Denis V. Lunev <den@openvz.org>
>
> The balloon holds file system space that never carries data, but its
> blocks are allocated, so ext4_trim_all_free() never discards them, and
> inflating the balloon is a plain fallocate() that does not discard
> either. Once the balloon is inflated over blocks that held data, e.g.
> on an online shrink after files were removed, the device below keeps
> them allocated: a ploop or qcow2 image keeps host disk space the
> container can never use, and compaction, which is FITRIM, does not give
> it back.
>
> Walk the balloon after the free space in ext4_trim_fs() and discard its
> unwritten extents that fall into the requested range. The walk goes to
> the end of the extent tree, as fallocate() with FALLOC_FL_KEEP_SIZE can
> leave extents past i_size. Physically adjacent extents are merged into
> [ ... ]
>
> https://virtuozzo.atlassian.net/browse/VSTOR-153590
>
> Feature: fs/ext4: fast online shrink support
> Signed-off-by: Denis V. Lunev <den@openvz.org>
Sashiko has reviewed this patch and found no issues. It looks great!
--
Sashiko AI review · https://sashiko.vzint.dev/#/patchset/20261110222756.3236854-2-den@openvz.org?part=2
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Devel] [PATCH hci-8.1 v2 3/3] xfs: discard the balloon on FITRIM
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 3/3] xfs: " Denis V. Lunev
@ 2026-11-10 22:36 ` no-reply
0 siblings, 0 replies; 7+ messages in thread
From: no-reply @ 2026-11-10 22:36 UTC (permalink / raw)
To: khorenko, Denis V. Lunev; +Cc: devel
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] xfs: xfs_trim_balloon() takes exclusive locks and walks balloon regardless of range
- [Low] xfs: xfs_trim_balloon_run() minlen to sector conversion wraps in 32 bits
--
commit 64c2bc84bef60128cd1c02bff575680cb7783bc1
Author: Denis V. Lunev <den@openvz.org>
xfs: discard the balloon on FITRIM
This commit makes xfs_ioc_trim() walk the balloon inode after the data
device free space walk. It discards the balloon's unwritten extents that
fall in the requested range, merging physically adjacent ones and issuing
the discard in chunks.
> diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
> --- a/fs/xfs/xfs_discard.c
> +++ b/fs/xfs/xfs_discard.c
[ ... ]
> +static int
> +xfs_trim_balloon_run(
> + struct xfs_mount *mp,
> + xfs_daddr_t daddr,
> + uint64_t len,
> + xfs_daddr_t start,
> + xfs_daddr_t end,
> + xfs_extlen_t minlen)
> +{
[ ... ]
> + if (last < daddr || last - daddr + 1 < XFS_FSB_TO_BB(mp, minlen))
> + return 0;
[Severity: Low]
Can the minlen conversion wrap here? In xfs_ioc_trim(), minlen is an
xfs_extlen_t (u32) set from XFS_B_TO_FSB(mp, range.minlen).
XFS_FSB_TO_BB() is defined as ((fsbno) << (mp)->m_blkbb_log) with no
widening, so in xfs_trim_balloon_run() the shift is done in 32 bits before
the comparison with the 64-bit run length. Once minlen << m_blkbb_log
reaches 2^32, the result wraps and the minlen filter can be bypassed, so
runs shorter than the requested minlen get discarded.
Would casting minlen to xfs_daddr_t or u64 before the shift avoid this?
[ ... ]
> +static int
> +xfs_trim_balloon(
> + struct xfs_mount *mp,
> + xfs_daddr_t start,
> + xfs_daddr_t end,
> + xfs_extlen_t minlen)
> +{
[ ... ]
> + /*
> + * Nobody may write the balloon meanwhile: data written into an
> + * unwritten extent would be discarded with it.
> + */
> + xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
> + inode_dio_wait(VFS_I(ip));
> + error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
> + if (error)
> + goto out_unlock;
[Severity: Medium]
Is it intended that every FITRIM takes these locks and scans the whole
balloon, even when the requested range cannot overlap it?
xfs_ioc_trim() calls xfs_trim_balloon() whenever the data device supports
discard. If m_balloon_ino is set, xfs_trim_balloon() takes
XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL, runs inode_dio_wait() and
filemap_write_and_wait(), and walks the extent map from offset 0 to
XFS_MAX_FILEOFF. None of this is bounded by the [start, end] range. The
range is only applied per run in xfs_trim_balloon_run().
As a result, a FITRIM on a narrow range still blocks balloon inflate and
shrink and does the full flush and scan.
The commit message says "Every FITRIM discards the balloon again, which
costs little: dm-ploop completes the discard of an unmapped cluster at
once." Does that statement cover the exclusive locks, the DIO wait, the
page cache flush and the full extent walk, which are taken regardless of
the requested range?
[ ... ]
--
Sashiko AI review · https://sashiko.vzint.dev/#/patchset/20261110222756.3236854-2-den@openvz.org?part=3
_______________________________________________
Devel mailing list
Devel@openvz.org
https://lists.openvz.org/mailman/listinfo/devel
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2026-11-10 22:37 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-10 22:27 [Devel] [PATCH hci-8.1 v2 0/3] ext4, xfs: discard the balloon on FITRIM Denis V. Lunev
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 1/3] xfs: release the balloon inode when xfs_balloon_get() refuses it Denis V. Lunev
2026-11-10 22:31 ` no-reply
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 2/3] ext4: discard the balloon on FITRIM Denis V. Lunev
2026-11-10 22:35 ` no-reply
2026-11-10 22:27 ` [Devel] [PATCH hci-8.1 v2 3/3] xfs: " Denis V. Lunev
2026-11-10 22:36 ` no-reply
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox