Linux f2fs_gc垃圾回收与前GC后GC模式切换

Linux f2fs_gc垃圾回收与前GC后GC模式切换

f2fs是一种基于Log-structured设计的文件系统，所有写操作都追加写入新的block，导致旧block中的有效数据占比逐渐下降。垃圾回收（GC）的任务是回收这些低效segment中的剩余有效数据，将segment整块释放以供后续写入。f2fs的GC分为前GC（Foreground GC）和后GC（Background GC）两种模式。

GC的入口函数是f2fs_gc()，定义在gc.c中：

int f2fs_gc(struct f2fs_sb_info *sbi, bool sync,
bool background, unsigned int segno)
{
unsigned int init_victim_cnt = 0;
unsigned int gc_type = sync ? FG_GC : BG_GC;
int ret;

if (gc_type == BG_GC)
down_read(&sbi->gc_lock);
else
down_write(&sbi->gc_lock);

for (; ;) {
struct victim_sel_policy p;
unsigned int cost;
unsigned int nfree;

nfree = prefree_segments(sbi);
if (nfree > (unsigned int)sbi->gc_thread->gc_min_free_blocks) {
ret = 0;
break;
}

p.min_cost = UINT_MAX;
p.ofs_unit = 1;
p.gc_mode = (gc_type == BG_GC) ? GC_CB : GC_GREEDY;
p.victim_segno = NULL_SEGNO;

ret = f2fs_get_victim(sbi, &segno, gc_type, &p);
if (ret) {
if (gc_type == FG_GC && ret == -ENODATA)
goto stop;
break;
}

ret = f2fs_do_garbage_collect(sbi, segno, gc_type);
if (ret)
break;
}

if (gc_type == BG_GC)
up_read(&sbi->gc_lock);
else
up_write(&sbi->gc_lock);
return ret;
}

f2fs_gc()接收三个参数：sync决定使用前GC还是后GC，background标识是否为后台触发，segno指定特定segment（SSR模式用）。GC类型通过gc_type区分：FG_GC（前GC）和BG_GC（后GC）。前GC使用写锁（down_write），会阻塞所有写入；后GC使用读锁（down_read），允许并发写入。

segment选择策略通过struct victim_sel_policy配置。前GC默认使用GC_GREEDY贪心策略，选择有效block最多的segment进行回收（最大化回收收益）。后GC默认使用GC_CB（Cost-Benefit）策略，综合考虑segment的年龄和有效数据占比：

static unsigned int get_cost(struct f2fs_sb_info *sbi,
unsigned int segno,
struct victim_sel_policy *p)
{
struct seg_entry *se = get_seg_entry(sbi, segno);
unsigned int cost = 0;

if (p->gc_mode == GC_GREEDY) {
cost = se->valid_blocks;
} else if (p->gc_mode == GC_CB) {
unsigned int age = 0;
unsigned long long mtime = se->mtime;
unsigned long long cur = get_mtime(sbi);

if (mtime < cur)
age = cur - mtime;
cost = (se->valid_blocks * 100) / max(1U, (unsigned int)age);
}
return cost;
}

GC_GREEDY下cost等于valid_blocks数量，选择valid_blocks最小的segment。GC_CB下cost = valid_blocks * 100 / age，选择"有效数据少且存在时间长"的segment，这种segment在未来被再次修改的概率更低。

实际的block迁移在f2fs_do_garbage_collect()中执行：

int f2fs_do_garbage_collect(struct f2fs_sb_info *sbi,
unsigned int segno, int gc_type)
{
struct blk_plug plug;
unsigned int sec_start;
unsigned int nr_blocks;
int i, ret = 0;

sec_start = GET_SEC_FROM_SEG(sbi, segno);
nr_blocks = sbi->blocks_per_seg;

blk_start_plug(&plug);
for (i = 0; i < nr_blocks; i++) {
struct page *page;
block_t addr;
struct f2fs_summary sum;

addr = f2fs_get_block_addr(sbi, segno, i);
if (f2fs_check_valid_map(sbi, segno, i))
continue;

page = f2fs_get_lock_data_page(sbi->meta_inode,
addr, false);
f2fs_read_data_page(page);

get_summary(sbi, segno, i, &sum);
f2fs_allocate_data_block(sbi, NULL, addr, NULL,
&new_addr, &sum, gc_type);
f2fs_update_sit_entry(sbi, new_addr, 1);
f2fs_update_sit_entry(sbi, addr, -1);
}
blk_finish_plug(&plug);

f2fs_submit_merged_write(sbi, DATA);
return ret;
}

该函数逐block遍历segment。通过f2fs_check_valid_map()跳过无效block（位图对应bit为0）。对有效block执行：读取数据页、从SSA获取该block所在的文件信息（struct f2fs_summary）、分配新数据block、将数据写入新位置、更新SIT（旧block减1、新block加1）。前GC模式下，写操作同步等待IO完成；后GC模式下写操作为异步。

关键函数f2fs_allocate_data_block()在两种GC模式下行为不同：

void f2fs_allocate_data_block(struct f2fs_sb_info *sbi,
struct page *page, block_t old_addr,
struct block_device **last_dev,
block_t *new_addr,
struct f2fs_summary *sum,
int gc_type)
{
if (gc_type == FG_GC) {
f2fs_wait_on_page_writeback(page, DATA, true, true);
f2fs_submit_merged_write_cond(sbi, NULL, page, DATA);
}
*new_addr = f2fs_new_block(sbi, old_addr, sum, gc_type);
if (gc_type == FG_GC)
f2fs_submit_merged_write(sbi, DATA);
}

前GC在分配新block前等待页面写回完成并刷入合并写请求，确保GC迁移的原子性。后GC不做同步等待，由后台writeback线程异步处理。

后GC由f2fs的GC daemon线程gc_thread_func()驱动，周期性触发：

static int gc_thread_func(void *data)
{
struct f2fs_sb_info *sbi = data;
struct f2fs_gc_thread *gc_th = sbi->gc_thread;
wait_queue_head_t *wq = &gc_th->gc_wait_queue_head;

while (1) {
if (kthread_should_stop())
break;

if (free_segments(sbi) < gc_th->min_free_segments) {
f2fs_gc(sbi, false, true, NULL_SEGNO);
continue;
}

if (wait_event_interruptible_timeout(wq,
kthread_should_stop(),
msecs_to_jiffies(gc_th->gc_sleep_time)))
continue;
}
return 0;
}

当空闲segment数量低于min_free_segments阈值时，GC daemon持续执行后GC。空闲segment充足时进入休眠，休眠时长由sysfs参数gc_sleep_time控制。

前GC的触发路径在f2fs_balance_fs()和f2fs_balance_fs_bg()中。当用户写入操作检测到空闲segment严重不足时，直接在当前进程上下文中调用f2fs_gc(sbi, true, false, NULL_SEGNO)，同步等待GC完成后才返回。这种方式显著增加写入时延但确保写入操作可以继续。

GC的victim segment选择还有一个特殊模式gc_mode == GC_URGENT。当设置URGENT后，f2fs_urgent_gc()被触发，以最高优先级执行GC，适用于用户显式调用或设备空闲容量极低时的紧急回收。