Skip to contentSkip to conversation

xfs: do not tight-pack write large files

PATCH Superseded Damien Le Moal 2 participants 2 messages Oct 13, 2025 XFS filesystem

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 xfs: do not tight-pack write large files

The tick-packing data block allocation which writes blocks of closed files in the same zone is very efficient at improving write performance on HDDs by reducing, and even suppressing, disk head seeks. However, such tight packing does not make sense for large files that require at least a full realtime block group (i.e. a zone). If tight-packing placement is applied for such files, the VM writeback thread switching between inodes result in the large file to be fragmented, thus increasing the garbage collection penalty later when the used realtime block group/zone needs to be reclaimed.

This problem can be avoided with a simple heuristic: if the size of the inode being written back is at least equal to the realtime block group size, do not use tight-packing. Modify xfs_zoned_pack_tight() to always return false in this case.

With this change, a multi-writer workload writing files of 256 MB on a file system backed by an SMR HDD with 256 MB zone size sees all files occupying exactly one zone, thus completely removing the heavy fragmentation observed without this change.

---
 fs/xfs/xfs_zone_alloc.c | 11 +++++++++++
 1 file changed, 11 insertions(+)
fs/xfs/xfs_zone_alloc.c +11 -0
index 1147bacb2da8..c51788550c7c 100644
@@ -622,6 +622,17 @@ static inline enum rw_hint xfs_inode_write_hint(struct xfs_inode *ip)
  */
 static inline bool xfs_zoned_pack_tight(struct xfs_inode *ip)
 {
+	struct xfs_mount *mp = ip->i_mount;
+	size_t zone_capacity =
+		XFS_FSB_TO_B(mp, mp->m_groups[XG_TYPE_RTG].blocks);
+
+	/*
+	 * Do not pack tight large files that are already using a full group
+	 * (zone) to avoid fragmentation.
+	 */
+	if (i_size_read(VFS_I(ip)) >= zone_capacity)
+		return false;
+
 	return !inode_is_open_for_write(VFS_I(ip)) &&
 		!(ip->i_diflags & XFS_DIFLAG_APPEND);
 }
Signature · 1 line
2.51.0
#1 lore raw
Quoted 30 lines · Damien Le Moal

The tick-packing data block allocation which writes blocks of closed files in the same zone is very efficient at improving write performance on HDDs by reducing, and even suppressing, disk head seeks. However, such tight packing does not make sense for large files that require at least a full realtime block group (i.e. a zone). If tight-packing placement is applied for such files, the VM writeback thread switching between inodes result in the large file to be fragmented, thus increasing the garbage collection penalty later when the used realtime block group/zone needs to be reclaimed.

This problem can be avoided with a simple heuristic: if the size of the inode being written back is at least equal to the realtime block group size, do not use tight-packing. Modify xfs_zoned_pack_tight() to always return false in this case.

With this change, a multi-writer workload writing files of 256 MB on a file system backed by an SMR HDD with 256 MB zone size sees all files occupying exactly one zone, thus completely removing the heavy fragmentation observed without this change.

---
 fs/xfs/xfs_zone_alloc.c | 11 +++++++++++
 1 file changed, 11 insertions(+)
fs/xfs/xfs_zone_alloc.c +0 -0
index 1147bacb2da8..c51788550c7c 100644

fs/xfs/xfs_zone_alloc.c static inline enum rw_hint xfs_inode_write_hint(struct xfs_inode *ip) · line 630

Quoted 9 lines
fs/xfs/xfs_zone_alloc.c +6 -0
@@ -622,6 +622,17 @@ static inline enum rw_hint xfs_inode_write_hint(struct xfs_inode *ip)
  */
 static inline bool xfs_zoned_pack_tight(struct xfs_inode *ip)
 {
+	struct xfs_mount *mp = ip->i_mount;
+	size_t zone_capacity =
+		XFS_FSB_TO_B(mp, mp->m_groups[XG_TYPE_RTG].blocks);
+
+	/*
+	 * Do not pack tight large files that are already using a full group

I'm not a native speaker, but shouldn't this be ordered differently

Do not pack large files that are already using a full group (zone) to avoid fragmentation?

Also I'd say either zone or RTG. but not mix both names to avoid confusion.

Otherwise this looks good to me.