f2fs: change GC bitmaps to apply the section granularity

This patch removes a bitmap for victim segments selected by foreground GC, and
modifies the other bitmap for victim segments selected by background GC.

1) foreground GC bitmap
 : We don't need to manage this, since we just only one previous victim section
   number instead of the whole victim history.
   The f2fs uses the victim section number in order not to allocate currently
   GC'ed section to current active logs.

2) background GC bitmap
 : This bitmap is used to avoid selecting victims repeatedly by background GCs.
   In addition, the victims are able to be selected by foreground GCs, since
   there is no need to read victim blocks during foreground GCs.

   By the fact that the foreground GC reclaims segments in a section unit, it'd
   be better to manage this bitmap based on the section granularity.

Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

1 files changed, 24 insertions, 19 deletions

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 2e3eb2d4fc30..09b8a907400b 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -160,18 +160,21 @@ static unsigned int get_max_cost(struct f2fs_sb_info *sbi,
 static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
 {
         struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
-        unsigned int segno;
+        unsigned int hint = 0;
+        unsigned int secno;
 
         /*
          * If the gc_type is FG_GC, we can select victim segments
          * selected by background GC before.
          * Those segments guarantee they have small valid blocks.
          */
-        segno = find_next_bit(dirty_i->victim_segmap[BG_GC],
-                                                TOTAL_SEGS(sbi), 0);
-        if (segno < TOTAL_SEGS(sbi)) {
-                clear_bit(segno, dirty_i->victim_segmap[BG_GC]);
-                return segno;
+next:
+        secno = find_next_bit(dirty_i->victim_secmap, TOTAL_SECS(sbi), hint++);
+        if (secno < TOTAL_SECS(sbi)) {
+                if (sec_usage_check(sbi, secno))
+                        goto next;
+                clear_bit(secno, dirty_i->victim_secmap);
+                return secno * sbi->segs_per_sec;
         }
         return NULL_SEGNO;
 }
@@ -234,7 +237,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
 {
         struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
         struct victim_sel_policy p;
-        unsigned int segno;
+        unsigned int secno;
         int nsearched = 0;
 
         p.alloc_mode = alloc_mode;
@@ -253,6 +256,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
 
         while (1) {
                 unsigned long cost;
+                unsigned int segno;
 
                 segno = find_next_bit(p.dirty_segmap,
                                                 TOTAL_SEGS(sbi), p.offset);
@@ -265,13 +269,11 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
                         break;
                 }
                 p.offset = ((segno / p.ofs_unit) * p.ofs_unit) + p.ofs_unit;
+                secno = GET_SECNO(sbi, segno);
 
-                if (test_bit(segno, dirty_i->victim_segmap[FG_GC]))
+                if (sec_usage_check(sbi, secno))
                         continue;
-                if (gc_type == BG_GC &&
-                                test_bit(segno, dirty_i->victim_segmap[BG_GC]))
-                        continue;
-                if (IS_CURSEC(sbi, GET_SECNO(sbi, segno)))
+                if (gc_type == BG_GC && test_bit(secno, dirty_i->victim_secmap))
                         continue;
 
                 cost = get_gc_cost(sbi, segno, &p);
@@ -291,13 +293,14 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
         }
 got_it:
         if (p.min_segno != NULL_SEGNO) {
-                *result = (p.min_segno / p.ofs_unit) * p.ofs_unit;
                 if (p.alloc_mode == LFS) {
-                        int i;
-                        for (i = 0; i < p.ofs_unit; i++)
-                                set_bit(*result + i,
-                                        dirty_i->victim_segmap[gc_type]);
+                        secno = GET_SECNO(sbi, p.min_segno);
+                        if (gc_type == FG_GC)
+                                sbi->cur_victim_sec = secno;
+                        else
+                                set_bit(secno, dirty_i->victim_secmap);
                 }
+                *result = (p.min_segno / p.ofs_unit) * p.ofs_unit;
         }
         mutex_unlock(&dirty_i->seglist_lock);
 
@@ -662,9 +665,11 @@ gc_more:
         for (i = 0; i < sbi->segs_per_sec; i++)
                 do_garbage_collect(sbi, segno + i, &ilist, gc_type);
 
-        if (gc_type == FG_GC &&
-                        get_valid_blocks(sbi, segno, sbi->segs_per_sec) == 0)
+        if (gc_type == FG_GC) {
+                sbi->cur_victim_sec = NULL_SEGNO;
                 nfree++;
+                WARN_ON(get_valid_blocks(sbi, segno, sbi->segs_per_sec));
+        }
 
         if (has_not_enough_free_secs(sbi, nfree))
                 goto gc_more;