f2fs: adjust zone capacity when considering valid block count

This patch fixes counting unusable blocks set by zone capacity when
checking the valid block count in a section.

Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index c92625ef16d0bf000949910d80389364514094b3..c01471573977ac7dba2d0d72bf68b91b0de3d51e 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -39,7 +39,7 @@ void f2fs_update_sit_info(struct f2fs_sb_info *sbi)
 
        bimodal = 0;
        total_vblocks = 0;
-       blks_per_sec = BLKS_PER_SEC(sbi);
+       blks_per_sec = CAP_BLKS_PER_SEC(sbi);
        hblks_per_sec = blks_per_sec / 2;
        for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
                vblocks = get_valid_blocks(sbi, segno, true);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 2d1114b0ceefeac411d3c2bec5096d65ce565dd4..0f29af7876a64273ea947299aa2ce96d78c821aa 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1681,7 +1681,7 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
                return 0;
 
        if (f2fs_is_pinned_file(inode)) {
-               block_t sec_blks = BLKS_PER_SEC(sbi);
+               block_t sec_blks = CAP_BLKS_PER_SEC(sbi);
                block_t sec_len = roundup(map.m_len, sec_blks);
 
                map.m_len = sec_blks;
@@ -2432,7 +2432,7 @@ do_more:
                        ret = -EAGAIN;
                goto out;
        }
-       range->start += BLKS_PER_SEC(sbi);
+       range->start += CAP_BLKS_PER_SEC(sbi);
        if (range->start <= end)
                goto do_more;
 out:
@@ -2557,7 +2557,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
                goto out;
        }
 
-       sec_num = DIV_ROUND_UP(total, BLKS_PER_SEC(sbi));
+       sec_num = DIV_ROUND_UP(total, CAP_BLKS_PER_SEC(sbi));
 
        /*
         * make sure there are enough free section for LFS allocation, this can

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index d5fb426e07474300147b32da984ab3f1648251a0..c38bdaf831af1f024b72e0eb3613d21aabd68813 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -487,7 +487,7 @@ static void atgc_lookup_victim(struct f2fs_sb_info *sbi,
        unsigned long long age, u, accu;
        unsigned long long max_mtime = sit_i->dirty_max_mtime;
        unsigned long long min_mtime = sit_i->dirty_min_mtime;
-       unsigned int sec_blocks = BLKS_PER_SEC(sbi);
+       unsigned int sec_blocks = CAP_BLKS_PER_SEC(sbi);
        unsigned int vblocks;
        unsigned int dirty_threshold = max(am->max_candidate_count,
                                        am->candidate_ratio *
@@ -1487,7 +1487,7 @@ next_step:
                 */
                if ((gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0)) ||
                        (!force_migrate && get_valid_blocks(sbi, segno, true) ==
-                                                       BLKS_PER_SEC(sbi)))
+                                                       CAP_BLKS_PER_SEC(sbi)))
                        return submitted;
 
                if (check_valid_map(sbi, segno, off) == 0)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 447b03579049210f61d6e2e7442b81f271802491..ce571c0d712696360128772382108cb5d6298ff7 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -728,7 +728,7 @@ static void __locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
                                get_valid_blocks(sbi, segno, true);
 
                        f2fs_bug_on(sbi, unlikely(!valid_blocks ||
-                                       valid_blocks == BLKS_PER_SEC(sbi)));
+                                       valid_blocks == CAP_BLKS_PER_SEC(sbi)));
 
                        if (!IS_CURSEC(sbi, secno))
                                set_bit(secno, dirty_i->dirty_secmap);
@@ -764,7 +764,7 @@ static void __remove_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
                        unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
 
                        if (!valid_blocks ||
-                                       valid_blocks == BLKS_PER_SEC(sbi)) {
+                                       valid_blocks == CAP_BLKS_PER_SEC(sbi)) {
                                clear_bit(secno, dirty_i->dirty_secmap);
                                return;
                        }
@@ -4483,7 +4483,6 @@ static void init_dirty_segmap(struct f2fs_sb_info *sbi)
        struct free_segmap_info *free_i = FREE_I(sbi);
        unsigned int segno = 0, offset = 0, secno;
        block_t valid_blocks, usable_blks_in_seg;
-       block_t blks_per_sec = BLKS_PER_SEC(sbi);
 
        while (1) {
                /* find dirty segment based on free segmap */
@@ -4512,7 +4511,7 @@ static void init_dirty_segmap(struct f2fs_sb_info *sbi)
                valid_blocks = get_valid_blocks(sbi, segno, true);
                secno = GET_SEC_FROM_SEG(sbi, segno);
 
-               if (!valid_blocks || valid_blocks == blks_per_sec)
+               if (!valid_blocks || valid_blocks == CAP_BLKS_PER_SEC(sbi))
                        continue;
                if (IS_CURSEC(sbi, secno))
                        continue;

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 813a892cd979d9c999cab71d52a989ec2f98d5f6..d1d63766f2c7e57cded48edcb67798c9217dd69d 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -612,10 +612,10 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi,
                                        get_pages(sbi, F2FS_DIRTY_DENTS) +
                                        get_pages(sbi, F2FS_DIRTY_IMETA);
        unsigned int total_dent_blocks = get_pages(sbi, F2FS_DIRTY_DENTS);
-       unsigned int node_secs = total_node_blocks / BLKS_PER_SEC(sbi);
-       unsigned int dent_secs = total_dent_blocks / BLKS_PER_SEC(sbi);
-       unsigned int node_blocks = total_node_blocks % BLKS_PER_SEC(sbi);
-       unsigned int dent_blocks = total_dent_blocks % BLKS_PER_SEC(sbi);
+       unsigned int node_secs = total_node_blocks / CAP_BLKS_PER_SEC(sbi);
+       unsigned int dent_secs = total_dent_blocks / CAP_BLKS_PER_SEC(sbi);
+       unsigned int node_blocks = total_node_blocks % CAP_BLKS_PER_SEC(sbi);
+       unsigned int dent_blocks = total_dent_blocks % CAP_BLKS_PER_SEC(sbi);
        unsigned int free, need_lower, need_upper;
 
        if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))