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