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