1 /* 2 * fs/f2fs/gc.c 3 * 4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com/ 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/fs.h> 12 #include <linux/module.h> 13 #include <linux/backing-dev.h> 14 #include <linux/init.h> 15 #include <linux/f2fs_fs.h> 16 #include <linux/kthread.h> 17 #include <linux/delay.h> 18 #include <linux/freezer.h> 19 #include <linux/blkdev.h> 20 21 #include "f2fs.h" 22 #include "node.h" 23 #include "segment.h" 24 #include "gc.h" 25 #include <trace/events/f2fs.h> 26 27 static struct kmem_cache *winode_slab; 28 29 static int gc_thread_func(void *data) 30 { 31 struct f2fs_sb_info *sbi = data; 32 struct f2fs_gc_kthread *gc_th = sbi->gc_thread; 33 wait_queue_head_t *wq = &sbi->gc_thread->gc_wait_queue_head; 34 long wait_ms; 35 36 wait_ms = gc_th->min_sleep_time; 37 38 do { 39 if (try_to_freeze()) 40 continue; 41 else 42 wait_event_interruptible_timeout(*wq, 43 kthread_should_stop(), 44 msecs_to_jiffies(wait_ms)); 45 if (kthread_should_stop()) 46 break; 47 48 if (sbi->sb->s_writers.frozen >= SB_FREEZE_WRITE) { 49 wait_ms = increase_sleep_time(gc_th, wait_ms); 50 continue; 51 } 52 53 /* 54 * [GC triggering condition] 55 * 0. GC is not conducted currently. 56 * 1. There are enough dirty segments. 57 * 2. IO subsystem is idle by checking the # of writeback pages. 58 * 3. IO subsystem is idle by checking the # of requests in 59 * bdev's request list. 60 * 61 * Note) We have to avoid triggering GCs too much frequently. 62 * Because it is possible that some segments can be 63 * invalidated soon after by user update or deletion. 64 * So, I'd like to wait some time to collect dirty segments. 65 */ 66 if (!mutex_trylock(&sbi->gc_mutex)) 67 continue; 68 69 if (!is_idle(sbi)) { 70 wait_ms = increase_sleep_time(gc_th, wait_ms); 71 mutex_unlock(&sbi->gc_mutex); 72 continue; 73 } 74 75 if (has_enough_invalid_blocks(sbi)) 76 wait_ms = decrease_sleep_time(gc_th, wait_ms); 77 else 78 wait_ms = increase_sleep_time(gc_th, wait_ms); 79 80 stat_inc_bggc_count(sbi); 81 82 /* if return value is not zero, no victim was selected */ 83 if (f2fs_gc(sbi)) 84 wait_ms = gc_th->no_gc_sleep_time; 85 86 /* balancing f2fs's metadata periodically */ 87 f2fs_balance_fs_bg(sbi); 88 89 } while (!kthread_should_stop()); 90 return 0; 91 } 92 93 int start_gc_thread(struct f2fs_sb_info *sbi) 94 { 95 struct f2fs_gc_kthread *gc_th; 96 dev_t dev = sbi->sb->s_bdev->bd_dev; 97 int err = 0; 98 99 if (!test_opt(sbi, BG_GC)) 100 goto out; 101 gc_th = kmalloc(sizeof(struct f2fs_gc_kthread), GFP_KERNEL); 102 if (!gc_th) { 103 err = -ENOMEM; 104 goto out; 105 } 106 107 gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME; 108 gc_th->max_sleep_time = DEF_GC_THREAD_MAX_SLEEP_TIME; 109 gc_th->no_gc_sleep_time = DEF_GC_THREAD_NOGC_SLEEP_TIME; 110 111 gc_th->gc_idle = 0; 112 113 sbi->gc_thread = gc_th; 114 init_waitqueue_head(&sbi->gc_thread->gc_wait_queue_head); 115 sbi->gc_thread->f2fs_gc_task = kthread_run(gc_thread_func, sbi, 116 "f2fs_gc-%u:%u", MAJOR(dev), MINOR(dev)); 117 if (IS_ERR(gc_th->f2fs_gc_task)) { 118 err = PTR_ERR(gc_th->f2fs_gc_task); 119 kfree(gc_th); 120 sbi->gc_thread = NULL; 121 } 122 out: 123 return err; 124 } 125 126 void stop_gc_thread(struct f2fs_sb_info *sbi) 127 { 128 struct f2fs_gc_kthread *gc_th = sbi->gc_thread; 129 if (!gc_th) 130 return; 131 kthread_stop(gc_th->f2fs_gc_task); 132 kfree(gc_th); 133 sbi->gc_thread = NULL; 134 } 135 136 static int select_gc_type(struct f2fs_gc_kthread *gc_th, int gc_type) 137 { 138 int gc_mode = (gc_type == BG_GC) ? GC_CB : GC_GREEDY; 139 140 if (gc_th && gc_th->gc_idle) { 141 if (gc_th->gc_idle == 1) 142 gc_mode = GC_CB; 143 else if (gc_th->gc_idle == 2) 144 gc_mode = GC_GREEDY; 145 } 146 return gc_mode; 147 } 148 149 static void select_policy(struct f2fs_sb_info *sbi, int gc_type, 150 int type, struct victim_sel_policy *p) 151 { 152 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 153 154 if (p->alloc_mode == SSR) { 155 p->gc_mode = GC_GREEDY; 156 p->dirty_segmap = dirty_i->dirty_segmap[type]; 157 p->max_search = dirty_i->nr_dirty[type]; 158 p->ofs_unit = 1; 159 } else { 160 p->gc_mode = select_gc_type(sbi->gc_thread, gc_type); 161 p->dirty_segmap = dirty_i->dirty_segmap[DIRTY]; 162 p->max_search = dirty_i->nr_dirty[DIRTY]; 163 p->ofs_unit = sbi->segs_per_sec; 164 } 165 166 if (p->max_search > sbi->max_victim_search) 167 p->max_search = sbi->max_victim_search; 168 169 p->offset = sbi->last_victim[p->gc_mode]; 170 } 171 172 static unsigned int get_max_cost(struct f2fs_sb_info *sbi, 173 struct victim_sel_policy *p) 174 { 175 /* SSR allocates in a segment unit */ 176 if (p->alloc_mode == SSR) 177 return 1 << sbi->log_blocks_per_seg; 178 if (p->gc_mode == GC_GREEDY) 179 return (1 << sbi->log_blocks_per_seg) * p->ofs_unit; 180 else if (p->gc_mode == GC_CB) 181 return UINT_MAX; 182 else /* No other gc_mode */ 183 return 0; 184 } 185 186 static unsigned int check_bg_victims(struct f2fs_sb_info *sbi) 187 { 188 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 189 unsigned int secno; 190 191 /* 192 * If the gc_type is FG_GC, we can select victim segments 193 * selected by background GC before. 194 * Those segments guarantee they have small valid blocks. 195 */ 196 for_each_set_bit(secno, dirty_i->victim_secmap, TOTAL_SECS(sbi)) { 197 if (sec_usage_check(sbi, secno)) 198 continue; 199 clear_bit(secno, dirty_i->victim_secmap); 200 return secno * sbi->segs_per_sec; 201 } 202 return NULL_SEGNO; 203 } 204 205 static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno) 206 { 207 struct sit_info *sit_i = SIT_I(sbi); 208 unsigned int secno = GET_SECNO(sbi, segno); 209 unsigned int start = secno * sbi->segs_per_sec; 210 unsigned long long mtime = 0; 211 unsigned int vblocks; 212 unsigned char age = 0; 213 unsigned char u; 214 unsigned int i; 215 216 for (i = 0; i < sbi->segs_per_sec; i++) 217 mtime += get_seg_entry(sbi, start + i)->mtime; 218 vblocks = get_valid_blocks(sbi, segno, sbi->segs_per_sec); 219 220 mtime = div_u64(mtime, sbi->segs_per_sec); 221 vblocks = div_u64(vblocks, sbi->segs_per_sec); 222 223 u = (vblocks * 100) >> sbi->log_blocks_per_seg; 224 225 /* Handle if the system time is changed by user */ 226 if (mtime < sit_i->min_mtime) 227 sit_i->min_mtime = mtime; 228 if (mtime > sit_i->max_mtime) 229 sit_i->max_mtime = mtime; 230 if (sit_i->max_mtime != sit_i->min_mtime) 231 age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime), 232 sit_i->max_mtime - sit_i->min_mtime); 233 234 return UINT_MAX - ((100 * (100 - u) * age) / (100 + u)); 235 } 236 237 static inline unsigned int get_gc_cost(struct f2fs_sb_info *sbi, 238 unsigned int segno, struct victim_sel_policy *p) 239 { 240 if (p->alloc_mode == SSR) 241 return get_seg_entry(sbi, segno)->ckpt_valid_blocks; 242 243 /* alloc_mode == LFS */ 244 if (p->gc_mode == GC_GREEDY) 245 return get_valid_blocks(sbi, segno, sbi->segs_per_sec); 246 else 247 return get_cb_cost(sbi, segno); 248 } 249 250 /* 251 * This function is called from two paths. 252 * One is garbage collection and the other is SSR segment selection. 253 * When it is called during GC, it just gets a victim segment 254 * and it does not remove it from dirty seglist. 255 * When it is called from SSR segment selection, it finds a segment 256 * which has minimum valid blocks and removes it from dirty seglist. 257 */ 258 static int get_victim_by_default(struct f2fs_sb_info *sbi, 259 unsigned int *result, int gc_type, int type, char alloc_mode) 260 { 261 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 262 struct victim_sel_policy p; 263 unsigned int secno, max_cost; 264 int nsearched = 0; 265 266 p.alloc_mode = alloc_mode; 267 select_policy(sbi, gc_type, type, &p); 268 269 p.min_segno = NULL_SEGNO; 270 p.min_cost = max_cost = get_max_cost(sbi, &p); 271 272 mutex_lock(&dirty_i->seglist_lock); 273 274 if (p.alloc_mode == LFS && gc_type == FG_GC) { 275 p.min_segno = check_bg_victims(sbi); 276 if (p.min_segno != NULL_SEGNO) 277 goto got_it; 278 } 279 280 while (1) { 281 unsigned long cost; 282 unsigned int segno; 283 284 segno = find_next_bit(p.dirty_segmap, 285 TOTAL_SEGS(sbi), p.offset); 286 if (segno >= TOTAL_SEGS(sbi)) { 287 if (sbi->last_victim[p.gc_mode]) { 288 sbi->last_victim[p.gc_mode] = 0; 289 p.offset = 0; 290 continue; 291 } 292 break; 293 } 294 295 p.offset = segno + p.ofs_unit; 296 if (p.ofs_unit > 1) 297 p.offset -= segno % p.ofs_unit; 298 299 secno = GET_SECNO(sbi, segno); 300 301 if (sec_usage_check(sbi, secno)) 302 continue; 303 if (gc_type == BG_GC && test_bit(secno, dirty_i->victim_secmap)) 304 continue; 305 306 cost = get_gc_cost(sbi, segno, &p); 307 308 if (p.min_cost > cost) { 309 p.min_segno = segno; 310 p.min_cost = cost; 311 } else if (unlikely(cost == max_cost)) { 312 continue; 313 } 314 315 if (nsearched++ >= p.max_search) { 316 sbi->last_victim[p.gc_mode] = segno; 317 break; 318 } 319 } 320 if (p.min_segno != NULL_SEGNO) { 321 got_it: 322 if (p.alloc_mode == LFS) { 323 secno = GET_SECNO(sbi, p.min_segno); 324 if (gc_type == FG_GC) 325 sbi->cur_victim_sec = secno; 326 else 327 set_bit(secno, dirty_i->victim_secmap); 328 } 329 *result = (p.min_segno / p.ofs_unit) * p.ofs_unit; 330 331 trace_f2fs_get_victim(sbi->sb, type, gc_type, &p, 332 sbi->cur_victim_sec, 333 prefree_segments(sbi), free_segments(sbi)); 334 } 335 mutex_unlock(&dirty_i->seglist_lock); 336 337 return (p.min_segno == NULL_SEGNO) ? 0 : 1; 338 } 339 340 static const struct victim_selection default_v_ops = { 341 .get_victim = get_victim_by_default, 342 }; 343 344 static struct inode *find_gc_inode(nid_t ino, struct list_head *ilist) 345 { 346 struct inode_entry *ie; 347 348 list_for_each_entry(ie, ilist, list) 349 if (ie->inode->i_ino == ino) 350 return ie->inode; 351 return NULL; 352 } 353 354 static void add_gc_inode(struct inode *inode, struct list_head *ilist) 355 { 356 struct inode_entry *new_ie; 357 358 if (inode == find_gc_inode(inode->i_ino, ilist)) { 359 iput(inode); 360 return; 361 } 362 363 new_ie = f2fs_kmem_cache_alloc(winode_slab, GFP_NOFS); 364 new_ie->inode = inode; 365 list_add_tail(&new_ie->list, ilist); 366 } 367 368 static void put_gc_inode(struct list_head *ilist) 369 { 370 struct inode_entry *ie, *next_ie; 371 list_for_each_entry_safe(ie, next_ie, ilist, list) { 372 iput(ie->inode); 373 list_del(&ie->list); 374 kmem_cache_free(winode_slab, ie); 375 } 376 } 377 378 static int check_valid_map(struct f2fs_sb_info *sbi, 379 unsigned int segno, int offset) 380 { 381 struct sit_info *sit_i = SIT_I(sbi); 382 struct seg_entry *sentry; 383 int ret; 384 385 mutex_lock(&sit_i->sentry_lock); 386 sentry = get_seg_entry(sbi, segno); 387 ret = f2fs_test_bit(offset, sentry->cur_valid_map); 388 mutex_unlock(&sit_i->sentry_lock); 389 return ret; 390 } 391 392 /* 393 * This function compares node address got in summary with that in NAT. 394 * On validity, copy that node with cold status, otherwise (invalid node) 395 * ignore that. 396 */ 397 static void gc_node_segment(struct f2fs_sb_info *sbi, 398 struct f2fs_summary *sum, unsigned int segno, int gc_type) 399 { 400 bool initial = true; 401 struct f2fs_summary *entry; 402 int off; 403 404 next_step: 405 entry = sum; 406 407 for (off = 0; off < sbi->blocks_per_seg; off++, entry++) { 408 nid_t nid = le32_to_cpu(entry->nid); 409 struct page *node_page; 410 411 /* stop BG_GC if there is not enough free sections. */ 412 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0)) 413 return; 414 415 if (check_valid_map(sbi, segno, off) == 0) 416 continue; 417 418 if (initial) { 419 ra_node_page(sbi, nid); 420 continue; 421 } 422 node_page = get_node_page(sbi, nid); 423 if (IS_ERR(node_page)) 424 continue; 425 426 /* set page dirty and write it */ 427 if (gc_type == FG_GC) { 428 f2fs_wait_on_page_writeback(node_page, NODE); 429 set_page_dirty(node_page); 430 } else { 431 if (!PageWriteback(node_page)) 432 set_page_dirty(node_page); 433 } 434 f2fs_put_page(node_page, 1); 435 stat_inc_node_blk_count(sbi, 1); 436 } 437 438 if (initial) { 439 initial = false; 440 goto next_step; 441 } 442 443 if (gc_type == FG_GC) { 444 struct writeback_control wbc = { 445 .sync_mode = WB_SYNC_ALL, 446 .nr_to_write = LONG_MAX, 447 .for_reclaim = 0, 448 }; 449 sync_node_pages(sbi, 0, &wbc); 450 451 /* 452 * In the case of FG_GC, it'd be better to reclaim this victim 453 * completely. 454 */ 455 if (get_valid_blocks(sbi, segno, 1) != 0) 456 goto next_step; 457 } 458 } 459 460 /* 461 * Calculate start block index indicating the given node offset. 462 * Be careful, caller should give this node offset only indicating direct node 463 * blocks. If any node offsets, which point the other types of node blocks such 464 * as indirect or double indirect node blocks, are given, it must be a caller's 465 * bug. 466 */ 467 block_t start_bidx_of_node(unsigned int node_ofs, struct f2fs_inode_info *fi) 468 { 469 unsigned int indirect_blks = 2 * NIDS_PER_BLOCK + 4; 470 unsigned int bidx; 471 472 if (node_ofs == 0) 473 return 0; 474 475 if (node_ofs <= 2) { 476 bidx = node_ofs - 1; 477 } else if (node_ofs <= indirect_blks) { 478 int dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1); 479 bidx = node_ofs - 2 - dec; 480 } else { 481 int dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1); 482 bidx = node_ofs - 5 - dec; 483 } 484 return bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi); 485 } 486 487 static int check_dnode(struct f2fs_sb_info *sbi, struct f2fs_summary *sum, 488 struct node_info *dni, block_t blkaddr, unsigned int *nofs) 489 { 490 struct page *node_page; 491 nid_t nid; 492 unsigned int ofs_in_node; 493 block_t source_blkaddr; 494 495 nid = le32_to_cpu(sum->nid); 496 ofs_in_node = le16_to_cpu(sum->ofs_in_node); 497 498 node_page = get_node_page(sbi, nid); 499 if (IS_ERR(node_page)) 500 return 0; 501 502 get_node_info(sbi, nid, dni); 503 504 if (sum->version != dni->version) { 505 f2fs_put_page(node_page, 1); 506 return 0; 507 } 508 509 *nofs = ofs_of_node(node_page); 510 source_blkaddr = datablock_addr(node_page, ofs_in_node); 511 f2fs_put_page(node_page, 1); 512 513 if (source_blkaddr != blkaddr) 514 return 0; 515 return 1; 516 } 517 518 static void move_data_page(struct inode *inode, struct page *page, int gc_type) 519 { 520 struct f2fs_io_info fio = { 521 .type = DATA, 522 .rw = WRITE_SYNC, 523 }; 524 525 if (gc_type == BG_GC) { 526 if (PageWriteback(page)) 527 goto out; 528 set_page_dirty(page); 529 set_cold_data(page); 530 } else { 531 f2fs_wait_on_page_writeback(page, DATA); 532 533 if (clear_page_dirty_for_io(page)) 534 inode_dec_dirty_dents(inode); 535 set_cold_data(page); 536 do_write_data_page(page, &fio); 537 clear_cold_data(page); 538 } 539 out: 540 f2fs_put_page(page, 1); 541 } 542 543 /* 544 * This function tries to get parent node of victim data block, and identifies 545 * data block validity. If the block is valid, copy that with cold status and 546 * modify parent node. 547 * If the parent node is not valid or the data block address is different, 548 * the victim data block is ignored. 549 */ 550 static void gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum, 551 struct list_head *ilist, unsigned int segno, int gc_type) 552 { 553 struct super_block *sb = sbi->sb; 554 struct f2fs_summary *entry; 555 block_t start_addr; 556 int off; 557 int phase = 0; 558 559 start_addr = START_BLOCK(sbi, segno); 560 561 next_step: 562 entry = sum; 563 564 for (off = 0; off < sbi->blocks_per_seg; off++, entry++) { 565 struct page *data_page; 566 struct inode *inode; 567 struct node_info dni; /* dnode info for the data */ 568 unsigned int ofs_in_node, nofs; 569 block_t start_bidx; 570 571 /* stop BG_GC if there is not enough free sections. */ 572 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0)) 573 return; 574 575 if (check_valid_map(sbi, segno, off) == 0) 576 continue; 577 578 if (phase == 0) { 579 ra_node_page(sbi, le32_to_cpu(entry->nid)); 580 continue; 581 } 582 583 /* Get an inode by ino with checking validity */ 584 if (check_dnode(sbi, entry, &dni, start_addr + off, &nofs) == 0) 585 continue; 586 587 if (phase == 1) { 588 ra_node_page(sbi, dni.ino); 589 continue; 590 } 591 592 ofs_in_node = le16_to_cpu(entry->ofs_in_node); 593 594 if (phase == 2) { 595 inode = f2fs_iget(sb, dni.ino); 596 if (IS_ERR(inode)) 597 continue; 598 599 start_bidx = start_bidx_of_node(nofs, F2FS_I(inode)); 600 601 data_page = find_data_page(inode, 602 start_bidx + ofs_in_node, false); 603 if (IS_ERR(data_page)) 604 goto next_iput; 605 606 f2fs_put_page(data_page, 0); 607 add_gc_inode(inode, ilist); 608 } else { 609 inode = find_gc_inode(dni.ino, ilist); 610 if (inode) { 611 start_bidx = start_bidx_of_node(nofs, 612 F2FS_I(inode)); 613 data_page = get_lock_data_page(inode, 614 start_bidx + ofs_in_node); 615 if (IS_ERR(data_page)) 616 continue; 617 move_data_page(inode, data_page, gc_type); 618 stat_inc_data_blk_count(sbi, 1); 619 } 620 } 621 continue; 622 next_iput: 623 iput(inode); 624 } 625 626 if (++phase < 4) 627 goto next_step; 628 629 if (gc_type == FG_GC) { 630 f2fs_submit_merged_bio(sbi, DATA, WRITE); 631 632 /* 633 * In the case of FG_GC, it'd be better to reclaim this victim 634 * completely. 635 */ 636 if (get_valid_blocks(sbi, segno, 1) != 0) { 637 phase = 2; 638 goto next_step; 639 } 640 } 641 } 642 643 static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim, 644 int gc_type, int type) 645 { 646 struct sit_info *sit_i = SIT_I(sbi); 647 int ret; 648 mutex_lock(&sit_i->sentry_lock); 649 ret = DIRTY_I(sbi)->v_ops->get_victim(sbi, victim, gc_type, type, LFS); 650 mutex_unlock(&sit_i->sentry_lock); 651 return ret; 652 } 653 654 static void do_garbage_collect(struct f2fs_sb_info *sbi, unsigned int segno, 655 struct list_head *ilist, int gc_type) 656 { 657 struct page *sum_page; 658 struct f2fs_summary_block *sum; 659 struct blk_plug plug; 660 661 /* read segment summary of victim */ 662 sum_page = get_sum_page(sbi, segno); 663 664 blk_start_plug(&plug); 665 666 sum = page_address(sum_page); 667 668 switch (GET_SUM_TYPE((&sum->footer))) { 669 case SUM_TYPE_NODE: 670 gc_node_segment(sbi, sum->entries, segno, gc_type); 671 break; 672 case SUM_TYPE_DATA: 673 gc_data_segment(sbi, sum->entries, ilist, segno, gc_type); 674 break; 675 } 676 blk_finish_plug(&plug); 677 678 stat_inc_seg_count(sbi, GET_SUM_TYPE((&sum->footer))); 679 stat_inc_call_count(sbi->stat_info); 680 681 f2fs_put_page(sum_page, 1); 682 } 683 684 int f2fs_gc(struct f2fs_sb_info *sbi) 685 { 686 struct list_head ilist; 687 unsigned int segno, i; 688 int gc_type = BG_GC; 689 int nfree = 0; 690 int ret = -1; 691 692 INIT_LIST_HEAD(&ilist); 693 gc_more: 694 if (unlikely(!(sbi->sb->s_flags & MS_ACTIVE))) 695 goto stop; 696 if (unlikely(is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ERROR_FLAG))) 697 goto stop; 698 699 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, nfree)) { 700 gc_type = FG_GC; 701 write_checkpoint(sbi, false); 702 } 703 704 if (!__get_victim(sbi, &segno, gc_type, NO_CHECK_TYPE)) 705 goto stop; 706 ret = 0; 707 708 /* readahead multi ssa blocks those have contiguous address */ 709 if (sbi->segs_per_sec > 1) 710 ra_meta_pages(sbi, GET_SUM_BLOCK(sbi, segno), sbi->segs_per_sec, 711 META_SSA); 712 713 for (i = 0; i < sbi->segs_per_sec; i++) 714 do_garbage_collect(sbi, segno + i, &ilist, gc_type); 715 716 if (gc_type == FG_GC) { 717 sbi->cur_victim_sec = NULL_SEGNO; 718 nfree++; 719 WARN_ON(get_valid_blocks(sbi, segno, sbi->segs_per_sec)); 720 } 721 722 if (has_not_enough_free_secs(sbi, nfree)) 723 goto gc_more; 724 725 if (gc_type == FG_GC) 726 write_checkpoint(sbi, false); 727 stop: 728 mutex_unlock(&sbi->gc_mutex); 729 730 put_gc_inode(&ilist); 731 return ret; 732 } 733 734 void build_gc_manager(struct f2fs_sb_info *sbi) 735 { 736 DIRTY_I(sbi)->v_ops = &default_v_ops; 737 } 738 739 int __init create_gc_caches(void) 740 { 741 winode_slab = f2fs_kmem_cache_create("f2fs_gc_inodes", 742 sizeof(struct inode_entry)); 743 if (!winode_slab) 744 return -ENOMEM; 745 return 0; 746 } 747 748 void destroy_gc_caches(void) 749 { 750 kmem_cache_destroy(winode_slab); 751 } 752