Skip to contentSkip to conversation

f2fs: fix to avoid potential section-unaligned pinfile

PATCH Applied Chao Yu 4 participants 7 messages Jun 29 – Jul 14 F2FS file system

lore
Share & tools
lore

Chao Yu

author maintainer
#0 lore raw

PATCH 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

Fixes f5a53edcf01e ("f2fs: support aligned pinned file")
Cc Daeho Jeong <[email protected]>
---
 fs/f2fs/file.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +17 -11
index f4facd409d9b..11cc8d79c235 100644
@@ -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
#1 lore raw

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 while open() 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]>
---
 fs/f2fs/file.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +0 -9
index f4facd409d9b..11cc8d79c235 100644
@@ -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

author maintainer
#2 lore raw
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 while open() 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

Quoted 3 lines

Hi Chao,
8MB is section alinged when fallocated by f2fs_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]>
---
 fs/f2fs/file.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +2 -11
index f4facd409d9b..11cc8d79c235 100644
@@ -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

Reviewed-by
#3 lore raw
Quoted 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 while open() 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

Quoted 3 lines

Hi Chao,
8MB is section alinged when fallocated by f2fs_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]>
---
 fs/f2fs/file.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +2 -11
index f4facd409d9b..11cc8d79c235 100644
@@ -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

maintainer
#4 lore raw
In reply to Chao Yu

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 while open() 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]>
---
 fs/f2fs/file.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +17 -11
index f4facd409d9b..11cc8d79c235 100644
@@ -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
author maintainer
#5 lore raw
Quoted 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 while open() 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

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}"
    fi

done

Quoted 58 lines
Quoted 58 lines
Fixes f5a53edcf01e ("f2fs: support aligned pinned file")
Cc Daeho Jeong <[email protected]>
---
  fs/f2fs/file.c | 28 +++++++++++++++++-----------
  1 file changed, 17 insertions(+), 11 deletions(-)
fs/f2fs/file.c +17 -11
index f4facd409d9b..11cc8d79c235 100644
@@ -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
#6 lore raw
In reply to Chao Yu
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 while open() 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