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