FAILED: patch "[PATCH] ext4: zero out whole block for clean edges in WRITE_ZEROES" failed to apply to 7.1-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 7.1-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-7.1.y
git checkout FETCH_HEAD
git cherry-pick -x a5179156ac1d9a6646da42254e4c461e1fc20096
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026082417-smokiness-hacker-071d@gregkh' --subject-prefix 'PATCH 7.1.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From a5179156ac1d9a6646da42254e4c461e1fc20096 Mon Sep 17 00:00:00 2001
From: Zhang Yi <[email protected]>
Date: Tue, 14 Jul 2026 16:00:42 +0800
Subject: [PATCH] ext4: zero out whole block for clean edges in WRITE_ZEROES
FALLOC_FL_WRITE_ZEROES requires that all blocks in the requested range end up as written extents with zeroed content. For unaligned edges that were already allocated, ext4_zero_partial_blocks() zeros them directly. However, for unaligned edges whose underlying extent is a clean unwritten extent or a hole, the extent type remains unwritten after partial zeroing, which does not align with the semantics of WRITE_ZEROES.
Therefore, when ext4_zero_partial_blocks() skips partial zeroing, it indicates that the corresponding edges are clean unwritten extents or holes. In this case, we need to expand the aligned allocation range outward to cover such edges, so that ext4_alloc_file_blocks() can correctly allocate blocks for the unaligned range. Edges that were partial-zeroed (i.e., written or dirty) are left untouched.
fs/ext4/extents.c +15 -0
@@ -4760,6 +4760,21 @@ static long ext4_zero_range(struct file *file, loff_t offset,/* Zero range excluding the unaligned edges */ align_start =round_up (offset, blocksize); align_end =round_down (end, blocksize); + +/* +* In WRITE_ZEROES mode, edges that were not partial-zeroed (clean +* unwritten or hole) must be allocated and zeroed as whole blocks. +* Expand the aligned range outward to cover them. +*/ +if (mode &FALLOC_FL_WRITE_ZEROES ) { +if (!IS_ALIGNED (offset, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_START )) + align_start =round_down (offset, blocksize); +if (!IS_ALIGNED (end, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_END )) + align_end =round_up (end, blocksize); + } +if (align_end > align_start) {if (mode &FALLOC_FL_WRITE_ZEROES ) flags =EXT4_GET_BLOCKS_CREATE_ZERO |EXT4_EX_NOCACHE ;
Sasha Levin
maintainerPATCH 1/2 ext4: track partial-zero outcome per edge in ext4_zero_partial_blocks()
From: Zhang Yi <[email protected]>
[ Upstream commit 4c1f6931395ad026415cbdb924ffc240f86eb557 ]
Replace the single bool did_zero output of ext4_zero_partial_blocks() with a bitmask that records which edge (start, end, or both in the single-block case) was actually partial-zeroed. This allows callers to distinguish which edges have been zeroed, preparing for unaligned FALLOC_FL_WRITE_ZEROES handling in later patches.
Stable-dep-of: a5179156ac1d ("ext4: zero out whole block for clean edges in WRITE_ZEROES")
--- fs/ext4/ext4.h | 5 ++++- fs/ext4/extents.c | 2 +- fs/ext4/inode.c | 36 ++++++++++++++++++++++++++++++------ 3 files changed, 35 insertions(+), 8 deletions(-)
fs/ext4/ext4.h +4 -1
@@ -3119,8 +3119,11 @@ extern int ext4_chunk_trans_extent(struct inode *inode, int nrblocks);extern int ext4_meta_trans_blocks (struct inode *inode,int lblocks,int pextents);extern int ext4_block_zero_eof (struct inode *inode,loff_t from,loff_t end); + +#define EXT4_PARTIAL_ZERO_START 0x1 +#define EXT4_PARTIAL_ZERO_END 0x2extern int ext4_zero_partial_blocks (struct inode *inode,loff_t lstart, -loff_t length,bool *did_zero); +loff_t length,unsigned int *partial_zeroed);extern vm_fault_t ext4_page_mkwrite (struct vm_fault *vmf);extern qsize_t *ext4_get_reserved_space (struct inode *inode);extern int ext4_get_projid (struct inode *inode,kprojid_t *projid);
fs/ext4/extents.c +1 -1
@@ -4715,7 +4715,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,loff_t align_start, align_end, new_size =0 ;loff_t end = offset + len;unsigned int blocksize =i_blocksize (inode); -bool partial_zeroed = false; +unsigned int partial_zeroed =0 ;int ret, flags;trace_ext4_zero_range (inode, offset, len, mode);
fs/ext4/inode.c +30 -6
@@ -4253,13 +4253,26 @@ int ext4_block_zero_eof(struct inode *inode, loff_t from, loff_t end)return 0 ; } +/* +* Zero out the unaligned head and tail of the [lstart, lstart+length) +* range. +* +* On return, @partial_zeroed records which edges actually got +* partial-zeroed. Set EXT4_PARTIAL_ZERO_START/EXT4_PARTIAL_ZERO_END if +* the head/tail block got actually partially zeroed (in written, dirty +* unwritten or delalloc state). Cleared if the head/tail block is a +* hole or a clean unwritten block, in which case there is nothing that +* needs zeroing. When the head and tail land in the same block, both +* bits are set together on a successful zeroing. +*/ int ext4_zero_partial_blocks (struct inode *inode,loff_t lstart,loff_t length, -bool *did_zero) +unsigned int *partial_zeroed) {struct super_block *sb = inode->i_sb;unsigned partial_start, partial_end;ext4_fsblk_t start, end;loff_t byte_end = (lstart + length -1 ); +bool did_zero = false;int err =0 ; partial_start = lstart & (sb->s_blocksize -1 );
@@ -4271,21 +4284,32 @@ int ext4_zero_partial_blocks(struct inode *inode, loff_t lstart, loff_t length,/* Handle partial zero within the single block */ if (start == end && (partial_start || (partial_end != sb->s_blocksize -1 ))) { - err =ext4_block_zero_range (inode, lstart, length, did_zero, + err =ext4_block_zero_range (inode, lstart, length, &did_zero,NULL ); +if (did_zero) + *partial_zeroed |= (EXT4_PARTIAL_ZERO_START | +EXT4_PARTIAL_ZERO_END );return err; }/* Handle partial zero out on the start of the range */ if (partial_start) { err =ext4_block_zero_range (inode, lstart, sb->s_blocksize, - did_zero,NULL ); + &did_zero,NULL );if (err)return err; +if (did_zero) + *partial_zeroed |=EXT4_PARTIAL_ZERO_START ; }/* Handle partial zero out on the end of the range */ -if (partial_end != sb->s_blocksize -1 ) +if (partial_end != sb->s_blocksize -1 ) { + did_zero = false; err =ext4_block_zero_range (inode, byte_end - partial_end, - partial_end +1 , did_zero,NULL ); + partial_end +1 , &did_zero,NULL ); +if (err) +return err; +if (did_zero) + *partial_zeroed |=EXT4_PARTIAL_ZERO_END ; + }return err; }
@@ -4434,7 +4458,7 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)loff_t end = offset + length;handle_t *handle;unsigned int credits; -bool partial_zeroed = false; +unsigned int partial_zeroed =0 ;int ret;trace_ext4_punch_hole (inode, offset, length,0 );
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 ext4: zero out whole block for clean edges in WRITE_ZEROES
From: Zhang Yi <[email protected]>
[ Upstream commit a5179156ac1d9a6646da42254e4c461e1fc20096 ]
FALLOC_FL_WRITE_ZEROES requires that all blocks in the requested range end up as written extents with zeroed content. For unaligned edges that were already allocated, ext4_zero_partial_blocks() zeros them directly. However, for unaligned edges whose underlying extent is a clean unwritten extent or a hole, the extent type remains unwritten after partial zeroing, which does not align with the semantics of WRITE_ZEROES.
Therefore, when ext4_zero_partial_blocks() skips partial zeroing, it indicates that the corresponding edges are clean unwritten extents or holes. In this case, we need to expand the aligned allocation range outward to cover such edges, so that ext4_alloc_file_blocks() can correctly allocate blocks for the unaligned range. Edges that were partial-zeroed (i.e., written or dirty) are left untouched.
--- fs/ext4/extents.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/ext4/extents.c +15 -0
@@ -4754,6 +4754,21 @@ static long ext4_zero_range(struct file *file, loff_t offset,/* Zero range excluding the unaligned edges */ align_start =round_up (offset, blocksize); align_end =round_down (end, blocksize); + +/* +* In WRITE_ZEROES mode, edges that were not partial-zeroed (clean +* unwritten or hole) must be allocated and zeroed as whole blocks. +* Expand the aligned range outward to cover them. +*/ +if (mode &FALLOC_FL_WRITE_ZEROES ) { +if (!IS_ALIGNED (offset, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_START )) + align_start =round_down (offset, blocksize); +if (!IS_ALIGNED (end, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_END )) + align_end =round_up (end, blocksize); + } +if (align_end > align_start) {if (mode &FALLOC_FL_WRITE_ZEROES ) flags =EXT4_GET_BLOCKS_CREATE_ZERO |EXT4_EX_NOCACHE ;
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 1/2 ext4: track partial-zero outcome per edge in ext4_zero_partial_blocks()
In reply to [email protected]From: Zhang Yi <[email protected]>
[ Upstream commit 4c1f6931395ad026415cbdb924ffc240f86eb557 ]
Replace the single bool did_zero output of ext4_zero_partial_blocks() with a bitmask that records which edge (start, end, or both in the single-block case) was actually partial-zeroed. This allows callers to distinguish which edges have been zeroed, preparing for unaligned FALLOC_FL_WRITE_ZEROES handling in later patches.
Stable-dep-of: a5179156ac1d ("ext4: zero out whole block for clean edges in WRITE_ZEROES")
--- fs/ext4/ext4.h | 5 ++++- fs/ext4/extents.c | 2 +- fs/ext4/inode.c | 36 ++++++++++++++++++++++++++++++------ 3 files changed, 35 insertions(+), 8 deletions(-)
fs/ext4/ext4.h +4 -1
@@ -3119,8 +3119,11 @@ extern int ext4_chunk_trans_extent(struct inode *inode, int nrblocks);extern int ext4_meta_trans_blocks (struct inode *inode,int lblocks,int pextents);extern int ext4_block_zero_eof (struct inode *inode,loff_t from,loff_t end); + +#define EXT4_PARTIAL_ZERO_START 0x1 +#define EXT4_PARTIAL_ZERO_END 0x2extern int ext4_zero_partial_blocks (struct inode *inode,loff_t lstart, -loff_t length,bool *did_zero); +loff_t length,unsigned int *partial_zeroed);extern vm_fault_t ext4_page_mkwrite (struct vm_fault *vmf);extern qsize_t *ext4_get_reserved_space (struct inode *inode);extern int ext4_get_projid (struct inode *inode,kprojid_t *projid);
fs/ext4/extents.c +1 -1
@@ -4715,7 +4715,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,loff_t align_start, align_end, new_size =0 ;loff_t end = offset + len;unsigned int blocksize =i_blocksize (inode); -bool partial_zeroed = false; +unsigned int partial_zeroed =0 ;int ret, flags;trace_ext4_zero_range (inode, offset, len, mode);
fs/ext4/inode.c +30 -6
@@ -4253,13 +4253,26 @@ int ext4_block_zero_eof(struct inode *inode, loff_t from, loff_t end)return 0 ; } +/* +* Zero out the unaligned head and tail of the [lstart, lstart+length) +* range. +* +* On return, @partial_zeroed records which edges actually got +* partial-zeroed. Set EXT4_PARTIAL_ZERO_START/EXT4_PARTIAL_ZERO_END if +* the head/tail block got actually partially zeroed (in written, dirty +* unwritten or delalloc state). Cleared if the head/tail block is a +* hole or a clean unwritten block, in which case there is nothing that +* needs zeroing. When the head and tail land in the same block, both +* bits are set together on a successful zeroing. +*/ int ext4_zero_partial_blocks (struct inode *inode,loff_t lstart,loff_t length, -bool *did_zero) +unsigned int *partial_zeroed) {struct super_block *sb = inode->i_sb;unsigned partial_start, partial_end;ext4_fsblk_t start, end;loff_t byte_end = (lstart + length -1 ); +bool did_zero = false;int err =0 ; partial_start = lstart & (sb->s_blocksize -1 );
@@ -4271,21 +4284,32 @@ int ext4_zero_partial_blocks(struct inode *inode, loff_t lstart, loff_t length,/* Handle partial zero within the single block */ if (start == end && (partial_start || (partial_end != sb->s_blocksize -1 ))) { - err =ext4_block_zero_range (inode, lstart, length, did_zero, + err =ext4_block_zero_range (inode, lstart, length, &did_zero,NULL ); +if (did_zero) + *partial_zeroed |= (EXT4_PARTIAL_ZERO_START | +EXT4_PARTIAL_ZERO_END );return err; }/* Handle partial zero out on the start of the range */ if (partial_start) { err =ext4_block_zero_range (inode, lstart, sb->s_blocksize, - did_zero,NULL ); + &did_zero,NULL );if (err)return err; +if (did_zero) + *partial_zeroed |=EXT4_PARTIAL_ZERO_START ; }/* Handle partial zero out on the end of the range */ -if (partial_end != sb->s_blocksize -1 ) +if (partial_end != sb->s_blocksize -1 ) { + did_zero = false; err =ext4_block_zero_range (inode, byte_end - partial_end, - partial_end +1 , did_zero,NULL ); + partial_end +1 , &did_zero,NULL ); +if (err) +return err; +if (did_zero) + *partial_zeroed |=EXT4_PARTIAL_ZERO_END ; + }return err; }
@@ -4434,7 +4458,7 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)loff_t end = offset + length;handle_t *handle;unsigned int credits; -bool partial_zeroed = false; +unsigned int partial_zeroed =0 ;int ret;trace_ext4_punch_hole (inode, offset, length,0 );
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 ext4: zero out whole block for clean edges in WRITE_ZEROES
From: Zhang Yi <[email protected]>
[ Upstream commit a5179156ac1d9a6646da42254e4c461e1fc20096 ]
FALLOC_FL_WRITE_ZEROES requires that all blocks in the requested range end up as written extents with zeroed content. For unaligned edges that were already allocated, ext4_zero_partial_blocks() zeros them directly. However, for unaligned edges whose underlying extent is a clean unwritten extent or a hole, the extent type remains unwritten after partial zeroing, which does not align with the semantics of WRITE_ZEROES.
Therefore, when ext4_zero_partial_blocks() skips partial zeroing, it indicates that the corresponding edges are clean unwritten extents or holes. In this case, we need to expand the aligned allocation range outward to cover such edges, so that ext4_alloc_file_blocks() can correctly allocate blocks for the unaligned range. Edges that were partial-zeroed (i.e., written or dirty) are left untouched.
--- fs/ext4/extents.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/ext4/extents.c +15 -0
@@ -4754,6 +4754,21 @@ static long ext4_zero_range(struct file *file, loff_t offset,/* Zero range excluding the unaligned edges */ align_start =round_up (offset, blocksize); align_end =round_down (end, blocksize); + +/* +* In WRITE_ZEROES mode, edges that were not partial-zeroed (clean +* unwritten or hole) must be allocated and zeroed as whole blocks. +* Expand the aligned range outward to cover them. +*/ +if (mode &FALLOC_FL_WRITE_ZEROES ) { +if (!IS_ALIGNED (offset, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_START )) + align_start =round_down (offset, blocksize); +if (!IS_ALIGNED (end, blocksize) && + !(partial_zeroed &EXT4_PARTIAL_ZERO_END )) + align_end =round_up (end, blocksize); + } +if (align_end > align_start) {if (mode &FALLOC_FL_WRITE_ZEROES ) flags =EXT4_GET_BLOCKS_CREATE_ZERO |EXT4_EX_NOCACHE ;
Signature · 1 line
2.53.0