f2fs: fix to avoid potential section-unaligned pinfile
Chao Yu
maintainerPATCH 1/1 f2fs: fix to avoid potential section-unaligned pinfile
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in f2fs_setattr().
- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
- f2fs_fallocate
- f2fs_expand_inode_data
- f2fs_allocate_pinning_section
- f2fs_map_blocks
- f2fs_map_lock
- __allocate_data_block
- file_need_truncate
: w/ FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated while open() if f2fs is not umount abnormally
- f2fs_map_unlock
: following f2fs checkpoint and sudden power-cut
- mount
- open pinfile
- f2fs_file_open
- finish_preallocate_blocks
- truncate_setsize
: filesize is 8mb
- f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesize
--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +17 -11
@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED (attr->ia_size, -F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) { +/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ; +/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ +else if (!IS_ALIGNED (attr->ia_size, +F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) {
Signature · 1 line
2.49.0
Chao Yu via Linux-f2fs-devel <[email protected]>
Quoted 20 lines · 于2026年6月29日周一 19:52写道:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cut
Quoted 9 lines
- mount
- open pinfile
-f2fs_file_open
-finish_preallocate_blocks
-truncate_setsize
: filesize is 8mb
-f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesize
Hi Chao,
8MB is section alinged when fallocated by f2fs_allocate_pinning_section?? so How could there are unaligned blocks inside filesize?
Quoted 26 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")Cc Daeho Jeong <[email protected]>Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)fs/f2fs/file.c +0
-9@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED(attr->ia_size,
fs/f2fs/file.c int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, · line 1117
Quoted 10 lines
fs/f2fs/file.c +8
-2- F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) { +/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ;
Is it ok if we allow larger size truncation and also limit it to aligned "F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)"? thanks!
Quoted 21 lines
fs/f2fs/file.c +9
-1+/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ + else if (!IS_ALIGNED(attr->ia_size, + F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) { --2.49.0
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Chao Yu
maintainerQuoted 31 lines · Zhiguo Niu
Chao Yu via Linux-f2fs-devel <[email protected]>
Quoted 20 lines · 于2026年6月29日周一 19:52写道:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cutQuoted 9 lines
- mount
- open pinfile
-f2fs_file_open
-finish_preallocate_blocks
-truncate_setsize
: filesize is 8mb
-f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesize
Quoted 3 lines
Hi Chao,
8MB is section alinged when fallocated byf2fs_allocate_pinning_section?? so How could there are unaligned blocks inside filesize?
Zhiguo,
As partial blkaddrs were persisted and recovered, see comments around f2fs_map_unlock().
Quoted 30 lines
Quoted 30 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")Cc Daeho Jeong <[email protected]>Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)fs/f2fs/file.c +2
-11@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED (attr->ia_size, -F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) {
Quoted 8 lines
fs/f2fs/file.c int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, · line 1117
Quoted 6 lines
fs/f2fs/file.c +6
-0+/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ;Is it ok if we allow larger size truncation and also limit it to aligned "F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)"?
No, I think above example will still suffer section-unaligned issue.
Thanks,
Quoted 22 lines
thanks!
Quoted 21 lines
fs/f2fs/file.c +9
-1+/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ + else if (!IS_ALIGNED(attr->ia_size, + F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) { --2.49.0
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Zhiguo Niu
Reviewed-byQuoted 81 lines · Chao Yu <[email protected]> 于2026年6月30日周二 19:02写道:
Quoted 31 lines · Zhiguo Niu
Chao Yu via Linux-f2fs-devel <[email protected]>
Quoted 20 lines · 于2026年6月29日周一 19:52写道:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cutQuoted 9 lines
- mount
- open pinfile
-f2fs_file_open
-finish_preallocate_blocks
-truncate_setsize
: filesize is 8mb
-f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesizeQuoted 3 lines
Hi Chao,
8MB is section alinged when fallocated byf2fs_allocate_pinning_section?? so How could there are unaligned blocks inside filesize?Zhiguo,
As partial blkaddrs were persisted and recovered, see comments around
f2fs_map_unlock().Quoted 30 lines
Quoted 30 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")Cc Daeho Jeong <[email protected]>Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)fs/f2fs/file.c +2
-11@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED (attr->ia_size, -F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) {Quoted 8 lines
fs/f2fs/file.c int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, · line 1117
Quoted 6 lines
fs/f2fs/file.c +6
-0+/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ;Is it ok if we allow larger size truncation and also limit it to aligned "F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)"?
Quoted 3 lines
No, I think above example will still suffer section-unaligned issue.
Thanks,
Hi Chao,
got it and thanks for your explaination, so
thanks!
Quoted 24 lines
Quoted 23 lines
thanks!
Quoted 21 lines
fs/f2fs/file.c +9
-1+/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ + else if (!IS_ALIGNED(attr->ia_size, + F2FS_BLK_TO_BYTES(CAP_BLKS_PER_SEC(sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) { --2.49.0
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerHi Chao,
Quoted 19 lines · On 06/29, Chao Yu via Linux-f2fs-devel wrote:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cut
Quoted 9 lines
- mount
- open pinfile
-f2fs_file_open
-finish_preallocate_blocks
-truncate_setsize
: filesize is 8mb
-f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesize
Have we reproduced this?
Quoted 57 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")Cc Daeho Jeong <[email protected]>Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)fs/f2fs/file.c +17
-11@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED (attr->ia_size, -F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) { +/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ; +/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ +else if (!IS_ALIGNED (attr->ia_size, +F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) {Signature · 8 lines
2.49.0 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Chao Yu
maintainerQuoted 32 lines · Jaegeuk Kim
Hi Chao,
Quoted 19 lines · On 06/29, Chao Yu via Linux-f2fs-devel wrote:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cutQuoted 9 lines
- mount
- open pinfile
-f2fs_file_open
-finish_preallocate_blocks
-truncate_setsize
: filesize is 8mb
-f2fs_truncate
: can only truncate block outside filesize, rather than truncating
unaligned blocks inside filesize
Quoted 1 line
Have we reproduced this?
Jaegeuk, I reproduced w/ below script:
#!/bin/bash
set -euo pipefail
DEV="/dev/vdb"
MNT="/mnt/f2fs"
PINFILE="${MNT}/pinfile"
CHUNK_SIZE=$((2 * 1024 * 1024)) # 2MB
# Ensure running as root
if [[ "${EUID:-$(id -u)}" -ne 0 ]]; then
echo "Error: This script must be run as root." >&2 exit 1
fi
# 0. Format f2fs image w/ /dev/vdb, and mount /dev/vdb to /mnt/f2fs/ echo "[+] Unmounting ${MNT} if currently mounted..." umount "${MNT}" 2>/dev/null || true
echo "[+] Formatting ${DEV} with f2fs..."
mkfs.f2fs -f "${DEV}"
echo "[+] Creating mount point ${MNT} and mounting..." mkdir -p "${MNT}"
mount "${DEV}" "${MNT}"
# 1. Create a pinfile in f2fs image
echo "[+] Creating pinfile at ${PINFILE}..."
touch "${PINFILE}"f2fs_io pinfile set "${PINFILE}" 2>/dev/null || f2fs_io pinfile 1 "${PINFILE}" truncate -s 8G "${PINFILE}"
sync
# Task 1: Call appendly fallocate on pinfile inside the range of [0, filesize]
task1_fallocate_append() {
local file="$1"
local chunk="$2"
local max_size
max_size=$(stat -c %s "$file" 2>/dev/null || echo 0)
if [ "$max_size" -eq 0 ]; then
max_size=$((8 * 1024 * 1024 * 1024))
fi
local offset=0
while true; do
# Try standard fallocate, fallback to f2fs_io fallocate
fallocate -o "$offset" -l "$chunk" "$file" 2>/dev/null || \
f2fs_io fallocate 0 "$offset" "$chunk" "$file" 2>/dev/null || break
offset=$((offset + chunk))
if [ "$offset" -ge "$max_size" ]; then
offset=0
fi
done
}# Task 2: Call f2fs checkpoint ioctl and then call shutdown 2 ioctl task2_checkpoint_shutdown() {
local target="$1"
# Small delay to allow Task 1 to begin appending sleep 2
# Call F2FS shutdown ioctl level 2
f2fs_io shutdown 1 "$target"
}
# Check mapping alignment using f2fs_io fiemap
check_mapping_alignment() {
local file="$1"
local align_2mb=$((2 * 1024 * 1024)) # 2MB in bytes
local align_blocks=512 # 2MB in 4KB blocks
local fiemap_out
fiemap_out=$(f2fs_io fiemap 0 4294967295 "$file" 2>/dev/null || f2fs_io fiemap "$file" 2>/dev/null || true)
if [[ -z "$fiemap_out" ]]; then
echo "Error: Failed to run f2fs_io fiemap on $file" >&2
return 1
fi
echo "$fiemap_out"
local aligned=true
while IFS= read -r line; do
[[ -z "$line" || "$line" =~ [Ff]iemap|[Ll]ogical|[Pp]hysical|[Ll]ength|[Ff]lags ]] && continue
local -a cols
read -r -a cols <<< "$line"
local phy_str len_str
if [[ ${#cols[@]} -ge 5 ]]; then
phy_str="${cols[2]}"
len_str="${cols[3]}"
elif [[ ${#cols[@]} -ge 3 ]]; then
phy_str="${cols[1]}"
len_str="${cols[2]}"
else
continue
fi
local phy_val len_val
if [[ "$phy_str" =~ ^0x || "$phy_str" =~ [a-fA-F] || "${#phy_str}" -gt 10 ]]; then
phy_val=$((16#${phy_str#0x}))
else
phy_val=$((phy_str))
fi
if [[ "$len_str" =~ ^0x || "$len_str" =~ [a-fA-F] || "${#len_str}" -gt 10 ]]; then
len_val=$((16#${len_str#0x}))
else
len_val=$((len_str))
fi
local unit_align=$align_blocks
[[ "$len_val" -ge 4096 ]] && unit_align=$align_2mb
if [[ $((phy_val % unit_align)) -ne 0 || $((len_val % unit_align)) -ne 0 ]]; then
echo "[!] Unaligned extent mapping detected: $line" >&2
aligned=false
fi
done <<< "$fiemap_out"
$aligned
}# 2. Test loop running the two tasks
iteration=0
while true; do
iteration=$((iteration + 1))
echo "[*] --- Iteration ${iteration} ---"
# Task 1: call appendly fallocate on pinfile inside [0, filesize]
task1_fallocate_append "${PINFILE}" "${CHUNK_SIZE}" &
task1_pid=$!
# Task 2: call f2fs checkpoint ioctl and then call shutdown 2 ioctl
task2_checkpoint_shutdown "${PINFILE}" &
task2_pid=$!
# Wait for Task 2 to complete shutdown
wait "${task2_pid}" 2>/dev/null || true
# Terminate Task 1 and any child fallocate processes
pkill -9 -P "${task1_pid}" 2>/dev/null || true
kill -9 "${task1_pid}" 2>/dev/null || true
wait "${task1_pid}" 2>/dev/null || true
# Umount the image -> mount the image
umount "${MNT}"
mount "${DEV}" "${MNT}"
# Use f2fs_io fiemap to check mapping
if ! check_mapping_alignment "${PINFILE}"; then
echo "[-] Mapping is not 2MB aligned. Print and break out."
break
fi
echo "[+] Mapping is 2MB aligned."
# Check space after test; if space exceed 80%, remove the file and call sync
used_pct=$(df --output=pcent "${MNT}" | tail -n 1 | tr -dc '0-9')
if [[ "${used_pct:-0}" -ge 80 ]]; then
echo "[!] Space (${used_pct}%) exceeded 80%. Removing file and calling sync..."
rm -f "${PINFILE}"
sync
touch "${PINFILE}"
f2fs_io pinfile set "${PINFILE}" 2>/dev/null || f2fs_io pinfile 1 "${PINFILE}"
truncate -s 8G "${PINFILE}"
fidone
Quoted 58 lines
Quoted 58 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")Cc Daeho Jeong <[email protected]>Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/file.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-)fs/f2fs/file.c +17
-11@@ -1107,17 +1107,23 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, !IS_ALIGNED (attr->ia_size, F2FS_BLK_TO_BYTES(fi->i_cluster_size))) return -EINVAL; -/* -* To prevent scattered pin block generation, we don't allow -* smaller/equal size unaligned truncation for pinned file. -* We only support overwrite IO to pinned file, so don't -* care about larger size truncation. -*/ -if (f2fs_is_pinned_file (inode) && - attr->ia_size <=i_size_read (inode) && - !IS_ALIGNED (attr->ia_size, -F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) -return -EINVAL ; + +if (f2fs_is_pinned_file (inode)) { +/* +* It may break section-aligned fallocate recovery +* mechanism, so do not allow larger size truncation. +*/ +if (attr->ia_size >i_size_read (inode)) +return -EINVAL ; +/* +* To prevent scattered pin block generation, we don't +* allow smaller/equal size unaligned truncation for +* pinned file. +*/ +else if (!IS_ALIGNED (attr->ia_size, +F2FS_BLK_TO_BYTES (CAP_BLKS_PER_SEC (sbi)))) +return -EINVAL ; + } }if (is_quota_modification (idmap, inode, attr)) {Signature · 8 lines
2.49.0 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
This patch was applied to jaegeuk/f2fs.git (dev) by Jaegeuk Kim <[email protected]>:
Hello:
This patch was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <[email protected]>:
Quoted 19 lines · On Mon, 29 Jun 2026 11:49:18 +0000 you wrote:
Blocks of pinfile may not aligned to section size due to wrong use on pinfile, result in heavy overhead of GC, let avoid this by adding additional check condition in
f2fs_setattr().- truncate -s 8mb pinfile
: random checkpoint may persist filesize w/ inode
- fallocate -o 0 -l 8mb pinfile
-f2fs_fallocate
-f2fs_expand_inode_data
-f2fs_allocate_pinning_section
-f2fs_map_blocks
-f2fs_map_lock
-__allocate_data_block
-file_need_truncate
: w/FADVISE_TRUNC_BIT, we can expect unaligned mapping can be
truncated whileopen()if f2fs is not umount abnormally
-f2fs_map_unlock
: following f2fs checkpoint and sudden power-cut
Quoted 1 line
[...]
Here is the summary with links:
- [f2fs-dev] f2fs: fix to avoid potential section-unaligned pinfile
https://git.kernel.org/jaegeuk/f2fs/c/bf4272cef5ec
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html