1 /* 2 * fs/f2fs/checkpoint.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/bio.h> 13 #include <linux/mpage.h> 14 #include <linux/writeback.h> 15 #include <linux/blkdev.h> 16 #include <linux/f2fs_fs.h> 17 #include <linux/pagevec.h> 18 #include <linux/swap.h> 19 20 #include "f2fs.h" 21 #include "node.h" 22 #include "segment.h" 23 #include "trace.h" 24 #include <trace/events/f2fs.h> 25 26 static struct kmem_cache *ino_entry_slab; 27 struct kmem_cache *inode_entry_slab; 28 29 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io) 30 { 31 set_ckpt_flags(sbi, CP_ERROR_FLAG); 32 sbi->sb->s_flags |= MS_RDONLY; 33 if (!end_io) 34 f2fs_flush_merged_bios(sbi); 35 } 36 37 /* 38 * We guarantee no failure on the returned page. 39 */ 40 struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index) 41 { 42 struct address_space *mapping = META_MAPPING(sbi); 43 struct page *page = NULL; 44 repeat: 45 page = f2fs_grab_cache_page(mapping, index, false); 46 if (!page) { 47 cond_resched(); 48 goto repeat; 49 } 50 f2fs_wait_on_page_writeback(page, META, true); 51 if (!PageUptodate(page)) 52 SetPageUptodate(page); 53 return page; 54 } 55 56 /* 57 * We guarantee no failure on the returned page. 58 */ 59 static struct page *__get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index, 60 bool is_meta) 61 { 62 struct address_space *mapping = META_MAPPING(sbi); 63 struct page *page; 64 struct f2fs_io_info fio = { 65 .sbi = sbi, 66 .type = META, 67 .op = REQ_OP_READ, 68 .op_flags = REQ_META | REQ_PRIO, 69 .old_blkaddr = index, 70 .new_blkaddr = index, 71 .encrypted_page = NULL, 72 }; 73 74 if (unlikely(!is_meta)) 75 fio.op_flags &= ~REQ_META; 76 repeat: 77 page = f2fs_grab_cache_page(mapping, index, false); 78 if (!page) { 79 cond_resched(); 80 goto repeat; 81 } 82 if (PageUptodate(page)) 83 goto out; 84 85 fio.page = page; 86 87 if (f2fs_submit_page_bio(&fio)) { 88 f2fs_put_page(page, 1); 89 goto repeat; 90 } 91 92 lock_page(page); 93 if (unlikely(page->mapping != mapping)) { 94 f2fs_put_page(page, 1); 95 goto repeat; 96 } 97 98 /* 99 * if there is any IO error when accessing device, make our filesystem 100 * readonly and make sure do not write checkpoint with non-uptodate 101 * meta page. 102 */ 103 if (unlikely(!PageUptodate(page))) 104 f2fs_stop_checkpoint(sbi, false); 105 out: 106 return page; 107 } 108 109 struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index) 110 { 111 return __get_meta_page(sbi, index, true); 112 } 113 114 /* for POR only */ 115 struct page *get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index) 116 { 117 return __get_meta_page(sbi, index, false); 118 } 119 120 bool is_valid_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type) 121 { 122 switch (type) { 123 case META_NAT: 124 break; 125 case META_SIT: 126 if (unlikely(blkaddr >= SIT_BLK_CNT(sbi))) 127 return false; 128 break; 129 case META_SSA: 130 if (unlikely(blkaddr >= MAIN_BLKADDR(sbi) || 131 blkaddr < SM_I(sbi)->ssa_blkaddr)) 132 return false; 133 break; 134 case META_CP: 135 if (unlikely(blkaddr >= SIT_I(sbi)->sit_base_addr || 136 blkaddr < __start_cp_addr(sbi))) 137 return false; 138 break; 139 case META_POR: 140 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) || 141 blkaddr < MAIN_BLKADDR(sbi))) 142 return false; 143 break; 144 default: 145 BUG(); 146 } 147 148 return true; 149 } 150 151 /* 152 * Readahead CP/NAT/SIT/SSA pages 153 */ 154 int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, 155 int type, bool sync) 156 { 157 struct page *page; 158 block_t blkno = start; 159 struct f2fs_io_info fio = { 160 .sbi = sbi, 161 .type = META, 162 .op = REQ_OP_READ, 163 .op_flags = sync ? (REQ_META | REQ_PRIO) : REQ_RAHEAD, 164 .encrypted_page = NULL, 165 }; 166 struct blk_plug plug; 167 168 if (unlikely(type == META_POR)) 169 fio.op_flags &= ~REQ_META; 170 171 blk_start_plug(&plug); 172 for (; nrpages-- > 0; blkno++) { 173 174 if (!is_valid_blkaddr(sbi, blkno, type)) 175 goto out; 176 177 switch (type) { 178 case META_NAT: 179 if (unlikely(blkno >= 180 NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid))) 181 blkno = 0; 182 /* get nat block addr */ 183 fio.new_blkaddr = current_nat_addr(sbi, 184 blkno * NAT_ENTRY_PER_BLOCK); 185 break; 186 case META_SIT: 187 /* get sit block addr */ 188 fio.new_blkaddr = current_sit_addr(sbi, 189 blkno * SIT_ENTRY_PER_BLOCK); 190 break; 191 case META_SSA: 192 case META_CP: 193 case META_POR: 194 fio.new_blkaddr = blkno; 195 break; 196 default: 197 BUG(); 198 } 199 200 page = f2fs_grab_cache_page(META_MAPPING(sbi), 201 fio.new_blkaddr, false); 202 if (!page) 203 continue; 204 if (PageUptodate(page)) { 205 f2fs_put_page(page, 1); 206 continue; 207 } 208 209 fio.page = page; 210 fio.old_blkaddr = fio.new_blkaddr; 211 f2fs_submit_page_mbio(&fio); 212 f2fs_put_page(page, 0); 213 } 214 out: 215 f2fs_submit_merged_bio(sbi, META, READ); 216 blk_finish_plug(&plug); 217 return blkno - start; 218 } 219 220 void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index) 221 { 222 struct page *page; 223 bool readahead = false; 224 225 page = find_get_page(META_MAPPING(sbi), index); 226 if (!page || !PageUptodate(page)) 227 readahead = true; 228 f2fs_put_page(page, 0); 229 230 if (readahead) 231 ra_meta_pages(sbi, index, BIO_MAX_PAGES, META_POR, true); 232 } 233 234 static int f2fs_write_meta_page(struct page *page, 235 struct writeback_control *wbc) 236 { 237 struct f2fs_sb_info *sbi = F2FS_P_SB(page); 238 239 trace_f2fs_writepage(page, META); 240 241 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) 242 goto redirty_out; 243 if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0)) 244 goto redirty_out; 245 if (unlikely(f2fs_cp_error(sbi))) 246 goto redirty_out; 247 248 write_meta_page(sbi, page); 249 dec_page_count(sbi, F2FS_DIRTY_META); 250 251 if (wbc->for_reclaim) 252 f2fs_submit_merged_bio_cond(sbi, NULL, page, 0, META, WRITE); 253 254 unlock_page(page); 255 256 if (unlikely(f2fs_cp_error(sbi))) 257 f2fs_submit_merged_bio(sbi, META, WRITE); 258 259 return 0; 260 261 redirty_out: 262 redirty_page_for_writepage(wbc, page); 263 return AOP_WRITEPAGE_ACTIVATE; 264 } 265 266 static int f2fs_write_meta_pages(struct address_space *mapping, 267 struct writeback_control *wbc) 268 { 269 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 270 long diff, written; 271 272 /* collect a number of dirty meta pages and write together */ 273 if (wbc->for_kupdate || 274 get_pages(sbi, F2FS_DIRTY_META) < nr_pages_to_skip(sbi, META)) 275 goto skip_write; 276 277 trace_f2fs_writepages(mapping->host, wbc, META); 278 279 /* if mounting is failed, skip writing node pages */ 280 mutex_lock(&sbi->cp_mutex); 281 diff = nr_pages_to_write(sbi, META, wbc); 282 written = sync_meta_pages(sbi, META, wbc->nr_to_write); 283 mutex_unlock(&sbi->cp_mutex); 284 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff); 285 return 0; 286 287 skip_write: 288 wbc->pages_skipped += get_pages(sbi, F2FS_DIRTY_META); 289 trace_f2fs_writepages(mapping->host, wbc, META); 290 return 0; 291 } 292 293 long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, 294 long nr_to_write) 295 { 296 struct address_space *mapping = META_MAPPING(sbi); 297 pgoff_t index = 0, end = ULONG_MAX, prev = ULONG_MAX; 298 struct pagevec pvec; 299 long nwritten = 0; 300 struct writeback_control wbc = { 301 .for_reclaim = 0, 302 }; 303 struct blk_plug plug; 304 305 pagevec_init(&pvec, 0); 306 307 blk_start_plug(&plug); 308 309 while (index <= end) { 310 int i, nr_pages; 311 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, 312 PAGECACHE_TAG_DIRTY, 313 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1); 314 if (unlikely(nr_pages == 0)) 315 break; 316 317 for (i = 0; i < nr_pages; i++) { 318 struct page *page = pvec.pages[i]; 319 320 if (prev == ULONG_MAX) 321 prev = page->index - 1; 322 if (nr_to_write != LONG_MAX && page->index != prev + 1) { 323 pagevec_release(&pvec); 324 goto stop; 325 } 326 327 lock_page(page); 328 329 if (unlikely(page->mapping != mapping)) { 330 continue_unlock: 331 unlock_page(page); 332 continue; 333 } 334 if (!PageDirty(page)) { 335 /* someone wrote it for us */ 336 goto continue_unlock; 337 } 338 339 f2fs_wait_on_page_writeback(page, META, true); 340 341 BUG_ON(PageWriteback(page)); 342 if (!clear_page_dirty_for_io(page)) 343 goto continue_unlock; 344 345 if (mapping->a_ops->writepage(page, &wbc)) { 346 unlock_page(page); 347 break; 348 } 349 nwritten++; 350 prev = page->index; 351 if (unlikely(nwritten >= nr_to_write)) 352 break; 353 } 354 pagevec_release(&pvec); 355 cond_resched(); 356 } 357 stop: 358 if (nwritten) 359 f2fs_submit_merged_bio(sbi, type, WRITE); 360 361 blk_finish_plug(&plug); 362 363 return nwritten; 364 } 365 366 static int f2fs_set_meta_page_dirty(struct page *page) 367 { 368 trace_f2fs_set_page_dirty(page, META); 369 370 if (!PageUptodate(page)) 371 SetPageUptodate(page); 372 if (!PageDirty(page)) { 373 f2fs_set_page_dirty_nobuffers(page); 374 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META); 375 SetPagePrivate(page); 376 f2fs_trace_pid(page); 377 return 1; 378 } 379 return 0; 380 } 381 382 const struct address_space_operations f2fs_meta_aops = { 383 .writepage = f2fs_write_meta_page, 384 .writepages = f2fs_write_meta_pages, 385 .set_page_dirty = f2fs_set_meta_page_dirty, 386 .invalidatepage = f2fs_invalidate_page, 387 .releasepage = f2fs_release_page, 388 #ifdef CONFIG_MIGRATION 389 .migratepage = f2fs_migrate_page, 390 #endif 391 }; 392 393 static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 394 { 395 struct inode_management *im = &sbi->im[type]; 396 struct ino_entry *e, *tmp; 397 398 tmp = f2fs_kmem_cache_alloc(ino_entry_slab, GFP_NOFS); 399 retry: 400 radix_tree_preload(GFP_NOFS | __GFP_NOFAIL); 401 402 spin_lock(&im->ino_lock); 403 e = radix_tree_lookup(&im->ino_root, ino); 404 if (!e) { 405 e = tmp; 406 if (radix_tree_insert(&im->ino_root, ino, e)) { 407 spin_unlock(&im->ino_lock); 408 radix_tree_preload_end(); 409 goto retry; 410 } 411 memset(e, 0, sizeof(struct ino_entry)); 412 e->ino = ino; 413 414 list_add_tail(&e->list, &im->ino_list); 415 if (type != ORPHAN_INO) 416 im->ino_num++; 417 } 418 spin_unlock(&im->ino_lock); 419 radix_tree_preload_end(); 420 421 if (e != tmp) 422 kmem_cache_free(ino_entry_slab, tmp); 423 } 424 425 static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 426 { 427 struct inode_management *im = &sbi->im[type]; 428 struct ino_entry *e; 429 430 spin_lock(&im->ino_lock); 431 e = radix_tree_lookup(&im->ino_root, ino); 432 if (e) { 433 list_del(&e->list); 434 radix_tree_delete(&im->ino_root, ino); 435 im->ino_num--; 436 spin_unlock(&im->ino_lock); 437 kmem_cache_free(ino_entry_slab, e); 438 return; 439 } 440 spin_unlock(&im->ino_lock); 441 } 442 443 void add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 444 { 445 /* add new dirty ino entry into list */ 446 __add_ino_entry(sbi, ino, type); 447 } 448 449 void remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 450 { 451 /* remove dirty ino entry from list */ 452 __remove_ino_entry(sbi, ino, type); 453 } 454 455 /* mode should be APPEND_INO or UPDATE_INO */ 456 bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode) 457 { 458 struct inode_management *im = &sbi->im[mode]; 459 struct ino_entry *e; 460 461 spin_lock(&im->ino_lock); 462 e = radix_tree_lookup(&im->ino_root, ino); 463 spin_unlock(&im->ino_lock); 464 return e ? true : false; 465 } 466 467 void release_ino_entry(struct f2fs_sb_info *sbi, bool all) 468 { 469 struct ino_entry *e, *tmp; 470 int i; 471 472 for (i = all ? ORPHAN_INO: APPEND_INO; i <= UPDATE_INO; i++) { 473 struct inode_management *im = &sbi->im[i]; 474 475 spin_lock(&im->ino_lock); 476 list_for_each_entry_safe(e, tmp, &im->ino_list, list) { 477 list_del(&e->list); 478 radix_tree_delete(&im->ino_root, e->ino); 479 kmem_cache_free(ino_entry_slab, e); 480 im->ino_num--; 481 } 482 spin_unlock(&im->ino_lock); 483 } 484 } 485 486 int acquire_orphan_inode(struct f2fs_sb_info *sbi) 487 { 488 struct inode_management *im = &sbi->im[ORPHAN_INO]; 489 int err = 0; 490 491 spin_lock(&im->ino_lock); 492 493 #ifdef CONFIG_F2FS_FAULT_INJECTION 494 if (time_to_inject(sbi, FAULT_ORPHAN)) { 495 spin_unlock(&im->ino_lock); 496 return -ENOSPC; 497 } 498 #endif 499 if (unlikely(im->ino_num >= sbi->max_orphans)) 500 err = -ENOSPC; 501 else 502 im->ino_num++; 503 spin_unlock(&im->ino_lock); 504 505 return err; 506 } 507 508 void release_orphan_inode(struct f2fs_sb_info *sbi) 509 { 510 struct inode_management *im = &sbi->im[ORPHAN_INO]; 511 512 spin_lock(&im->ino_lock); 513 f2fs_bug_on(sbi, im->ino_num == 0); 514 im->ino_num--; 515 spin_unlock(&im->ino_lock); 516 } 517 518 void add_orphan_inode(struct inode *inode) 519 { 520 /* add new orphan ino entry into list */ 521 __add_ino_entry(F2FS_I_SB(inode), inode->i_ino, ORPHAN_INO); 522 update_inode_page(inode); 523 } 524 525 void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 526 { 527 /* remove orphan entry from orphan list */ 528 __remove_ino_entry(sbi, ino, ORPHAN_INO); 529 } 530 531 static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 532 { 533 struct inode *inode; 534 struct node_info ni; 535 int err = acquire_orphan_inode(sbi); 536 537 if (err) { 538 set_sbi_flag(sbi, SBI_NEED_FSCK); 539 f2fs_msg(sbi->sb, KERN_WARNING, 540 "%s: orphan failed (ino=%x), run fsck to fix.", 541 __func__, ino); 542 return err; 543 } 544 545 __add_ino_entry(sbi, ino, ORPHAN_INO); 546 547 inode = f2fs_iget_retry(sbi->sb, ino); 548 if (IS_ERR(inode)) { 549 /* 550 * there should be a bug that we can't find the entry 551 * to orphan inode. 552 */ 553 f2fs_bug_on(sbi, PTR_ERR(inode) == -ENOENT); 554 return PTR_ERR(inode); 555 } 556 557 clear_nlink(inode); 558 559 /* truncate all the data during iput */ 560 iput(inode); 561 562 get_node_info(sbi, ino, &ni); 563 564 /* ENOMEM was fully retried in f2fs_evict_inode. */ 565 if (ni.blk_addr != NULL_ADDR) { 566 set_sbi_flag(sbi, SBI_NEED_FSCK); 567 f2fs_msg(sbi->sb, KERN_WARNING, 568 "%s: orphan failed (ino=%x), run fsck to fix.", 569 __func__, ino); 570 return -EIO; 571 } 572 __remove_ino_entry(sbi, ino, ORPHAN_INO); 573 return 0; 574 } 575 576 int recover_orphan_inodes(struct f2fs_sb_info *sbi) 577 { 578 block_t start_blk, orphan_blocks, i, j; 579 int err; 580 581 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG)) 582 return 0; 583 584 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi); 585 orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi); 586 587 ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP, true); 588 589 for (i = 0; i < orphan_blocks; i++) { 590 struct page *page = get_meta_page(sbi, start_blk + i); 591 struct f2fs_orphan_block *orphan_blk; 592 593 orphan_blk = (struct f2fs_orphan_block *)page_address(page); 594 for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) { 595 nid_t ino = le32_to_cpu(orphan_blk->ino[j]); 596 err = recover_orphan_inode(sbi, ino); 597 if (err) { 598 f2fs_put_page(page, 1); 599 return err; 600 } 601 } 602 f2fs_put_page(page, 1); 603 } 604 /* clear Orphan Flag */ 605 clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG); 606 return 0; 607 } 608 609 static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) 610 { 611 struct list_head *head; 612 struct f2fs_orphan_block *orphan_blk = NULL; 613 unsigned int nentries = 0; 614 unsigned short index = 1; 615 unsigned short orphan_blocks; 616 struct page *page = NULL; 617 struct ino_entry *orphan = NULL; 618 struct inode_management *im = &sbi->im[ORPHAN_INO]; 619 620 orphan_blocks = GET_ORPHAN_BLOCKS(im->ino_num); 621 622 /* 623 * we don't need to do spin_lock(&im->ino_lock) here, since all the 624 * orphan inode operations are covered under f2fs_lock_op(). 625 * And, spin_lock should be avoided due to page operations below. 626 */ 627 head = &im->ino_list; 628 629 /* loop for each orphan inode entry and write them in Jornal block */ 630 list_for_each_entry(orphan, head, list) { 631 if (!page) { 632 page = grab_meta_page(sbi, start_blk++); 633 orphan_blk = 634 (struct f2fs_orphan_block *)page_address(page); 635 memset(orphan_blk, 0, sizeof(*orphan_blk)); 636 } 637 638 orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino); 639 640 if (nentries == F2FS_ORPHANS_PER_BLOCK) { 641 /* 642 * an orphan block is full of 1020 entries, 643 * then we need to flush current orphan blocks 644 * and bring another one in memory 645 */ 646 orphan_blk->blk_addr = cpu_to_le16(index); 647 orphan_blk->blk_count = cpu_to_le16(orphan_blocks); 648 orphan_blk->entry_count = cpu_to_le32(nentries); 649 set_page_dirty(page); 650 f2fs_put_page(page, 1); 651 index++; 652 nentries = 0; 653 page = NULL; 654 } 655 } 656 657 if (page) { 658 orphan_blk->blk_addr = cpu_to_le16(index); 659 orphan_blk->blk_count = cpu_to_le16(orphan_blocks); 660 orphan_blk->entry_count = cpu_to_le32(nentries); 661 set_page_dirty(page); 662 f2fs_put_page(page, 1); 663 } 664 } 665 666 static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr, 667 struct f2fs_checkpoint **cp_block, struct page **cp_page, 668 unsigned long long *version) 669 { 670 unsigned long blk_size = sbi->blocksize; 671 size_t crc_offset = 0; 672 __u32 crc = 0; 673 674 *cp_page = get_meta_page(sbi, cp_addr); 675 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page); 676 677 crc_offset = le32_to_cpu((*cp_block)->checksum_offset); 678 if (crc_offset >= blk_size) { 679 f2fs_msg(sbi->sb, KERN_WARNING, 680 "invalid crc_offset: %zu", crc_offset); 681 return -EINVAL; 682 } 683 684 crc = le32_to_cpu(*((__le32 *)((unsigned char *)*cp_block 685 + crc_offset))); 686 if (!f2fs_crc_valid(sbi, crc, *cp_block, crc_offset)) { 687 f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value"); 688 return -EINVAL; 689 } 690 691 *version = cur_cp_version(*cp_block); 692 return 0; 693 } 694 695 static struct page *validate_checkpoint(struct f2fs_sb_info *sbi, 696 block_t cp_addr, unsigned long long *version) 697 { 698 struct page *cp_page_1 = NULL, *cp_page_2 = NULL; 699 struct f2fs_checkpoint *cp_block = NULL; 700 unsigned long long cur_version = 0, pre_version = 0; 701 int err; 702 703 err = get_checkpoint_version(sbi, cp_addr, &cp_block, 704 &cp_page_1, version); 705 if (err) 706 goto invalid_cp1; 707 pre_version = *version; 708 709 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1; 710 err = get_checkpoint_version(sbi, cp_addr, &cp_block, 711 &cp_page_2, version); 712 if (err) 713 goto invalid_cp2; 714 cur_version = *version; 715 716 if (cur_version == pre_version) { 717 *version = cur_version; 718 f2fs_put_page(cp_page_2, 1); 719 return cp_page_1; 720 } 721 invalid_cp2: 722 f2fs_put_page(cp_page_2, 1); 723 invalid_cp1: 724 f2fs_put_page(cp_page_1, 1); 725 return NULL; 726 } 727 728 int get_valid_checkpoint(struct f2fs_sb_info *sbi) 729 { 730 struct f2fs_checkpoint *cp_block; 731 struct f2fs_super_block *fsb = sbi->raw_super; 732 struct page *cp1, *cp2, *cur_page; 733 unsigned long blk_size = sbi->blocksize; 734 unsigned long long cp1_version = 0, cp2_version = 0; 735 unsigned long long cp_start_blk_no; 736 unsigned int cp_blks = 1 + __cp_payload(sbi); 737 block_t cp_blk_no; 738 int i; 739 740 sbi->ckpt = kzalloc(cp_blks * blk_size, GFP_KERNEL); 741 if (!sbi->ckpt) 742 return -ENOMEM; 743 /* 744 * Finding out valid cp block involves read both 745 * sets( cp pack1 and cp pack 2) 746 */ 747 cp_start_blk_no = le32_to_cpu(fsb->cp_blkaddr); 748 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); 749 750 /* The second checkpoint pack should start at the next segment */ 751 cp_start_blk_no += ((unsigned long long)1) << 752 le32_to_cpu(fsb->log_blocks_per_seg); 753 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); 754 755 if (cp1 && cp2) { 756 if (ver_after(cp2_version, cp1_version)) 757 cur_page = cp2; 758 else 759 cur_page = cp1; 760 } else if (cp1) { 761 cur_page = cp1; 762 } else if (cp2) { 763 cur_page = cp2; 764 } else { 765 goto fail_no_cp; 766 } 767 768 cp_block = (struct f2fs_checkpoint *)page_address(cur_page); 769 memcpy(sbi->ckpt, cp_block, blk_size); 770 771 /* Sanity checking of checkpoint */ 772 if (sanity_check_ckpt(sbi)) 773 goto free_fail_no_cp; 774 775 if (cur_page == cp1) 776 sbi->cur_cp_pack = 1; 777 else 778 sbi->cur_cp_pack = 2; 779 780 if (cp_blks <= 1) 781 goto done; 782 783 cp_blk_no = le32_to_cpu(fsb->cp_blkaddr); 784 if (cur_page == cp2) 785 cp_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg); 786 787 for (i = 1; i < cp_blks; i++) { 788 void *sit_bitmap_ptr; 789 unsigned char *ckpt = (unsigned char *)sbi->ckpt; 790 791 cur_page = get_meta_page(sbi, cp_blk_no + i); 792 sit_bitmap_ptr = page_address(cur_page); 793 memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size); 794 f2fs_put_page(cur_page, 1); 795 } 796 done: 797 f2fs_put_page(cp1, 1); 798 f2fs_put_page(cp2, 1); 799 return 0; 800 801 free_fail_no_cp: 802 f2fs_put_page(cp1, 1); 803 f2fs_put_page(cp2, 1); 804 fail_no_cp: 805 kfree(sbi->ckpt); 806 return -EINVAL; 807 } 808 809 static void __add_dirty_inode(struct inode *inode, enum inode_type type) 810 { 811 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 812 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE; 813 814 if (is_inode_flag_set(inode, flag)) 815 return; 816 817 set_inode_flag(inode, flag); 818 list_add_tail(&F2FS_I(inode)->dirty_list, &sbi->inode_list[type]); 819 stat_inc_dirty_inode(sbi, type); 820 } 821 822 static void __remove_dirty_inode(struct inode *inode, enum inode_type type) 823 { 824 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE; 825 826 if (get_dirty_pages(inode) || !is_inode_flag_set(inode, flag)) 827 return; 828 829 list_del_init(&F2FS_I(inode)->dirty_list); 830 clear_inode_flag(inode, flag); 831 stat_dec_dirty_inode(F2FS_I_SB(inode), type); 832 } 833 834 void update_dirty_page(struct inode *inode, struct page *page) 835 { 836 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 837 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE; 838 839 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && 840 !S_ISLNK(inode->i_mode)) 841 return; 842 843 spin_lock(&sbi->inode_lock[type]); 844 if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH)) 845 __add_dirty_inode(inode, type); 846 inode_inc_dirty_pages(inode); 847 spin_unlock(&sbi->inode_lock[type]); 848 849 SetPagePrivate(page); 850 f2fs_trace_pid(page); 851 } 852 853 void remove_dirty_inode(struct inode *inode) 854 { 855 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 856 enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE; 857 858 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && 859 !S_ISLNK(inode->i_mode)) 860 return; 861 862 if (type == FILE_INODE && !test_opt(sbi, DATA_FLUSH)) 863 return; 864 865 spin_lock(&sbi->inode_lock[type]); 866 __remove_dirty_inode(inode, type); 867 spin_unlock(&sbi->inode_lock[type]); 868 } 869 870 int sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type) 871 { 872 struct list_head *head; 873 struct inode *inode; 874 struct f2fs_inode_info *fi; 875 bool is_dir = (type == DIR_INODE); 876 877 trace_f2fs_sync_dirty_inodes_enter(sbi->sb, is_dir, 878 get_pages(sbi, is_dir ? 879 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA)); 880 retry: 881 if (unlikely(f2fs_cp_error(sbi))) 882 return -EIO; 883 884 spin_lock(&sbi->inode_lock[type]); 885 886 head = &sbi->inode_list[type]; 887 if (list_empty(head)) { 888 spin_unlock(&sbi->inode_lock[type]); 889 trace_f2fs_sync_dirty_inodes_exit(sbi->sb, is_dir, 890 get_pages(sbi, is_dir ? 891 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA)); 892 return 0; 893 } 894 fi = list_entry(head->next, struct f2fs_inode_info, dirty_list); 895 inode = igrab(&fi->vfs_inode); 896 spin_unlock(&sbi->inode_lock[type]); 897 if (inode) { 898 filemap_fdatawrite(inode->i_mapping); 899 iput(inode); 900 } else { 901 /* 902 * We should submit bio, since it exists several 903 * wribacking dentry pages in the freeing inode. 904 */ 905 f2fs_submit_merged_bio(sbi, DATA, WRITE); 906 cond_resched(); 907 } 908 goto retry; 909 } 910 911 int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi) 912 { 913 struct list_head *head = &sbi->inode_list[DIRTY_META]; 914 struct inode *inode; 915 struct f2fs_inode_info *fi; 916 s64 total = get_pages(sbi, F2FS_DIRTY_IMETA); 917 918 while (total--) { 919 if (unlikely(f2fs_cp_error(sbi))) 920 return -EIO; 921 922 spin_lock(&sbi->inode_lock[DIRTY_META]); 923 if (list_empty(head)) { 924 spin_unlock(&sbi->inode_lock[DIRTY_META]); 925 return 0; 926 } 927 fi = list_entry(head->next, struct f2fs_inode_info, 928 gdirty_list); 929 inode = igrab(&fi->vfs_inode); 930 spin_unlock(&sbi->inode_lock[DIRTY_META]); 931 if (inode) { 932 sync_inode_metadata(inode, 0); 933 934 /* it's on eviction */ 935 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) 936 update_inode_page(inode); 937 iput(inode); 938 } 939 }; 940 return 0; 941 } 942 943 /* 944 * Freeze all the FS-operations for checkpoint. 945 */ 946 static int block_operations(struct f2fs_sb_info *sbi) 947 { 948 struct writeback_control wbc = { 949 .sync_mode = WB_SYNC_ALL, 950 .nr_to_write = LONG_MAX, 951 .for_reclaim = 0, 952 }; 953 struct blk_plug plug; 954 int err = 0; 955 956 blk_start_plug(&plug); 957 958 retry_flush_dents: 959 f2fs_lock_all(sbi); 960 /* write all the dirty dentry pages */ 961 if (get_pages(sbi, F2FS_DIRTY_DENTS)) { 962 f2fs_unlock_all(sbi); 963 err = sync_dirty_inodes(sbi, DIR_INODE); 964 if (err) 965 goto out; 966 goto retry_flush_dents; 967 } 968 969 if (get_pages(sbi, F2FS_DIRTY_IMETA)) { 970 f2fs_unlock_all(sbi); 971 err = f2fs_sync_inode_meta(sbi); 972 if (err) 973 goto out; 974 goto retry_flush_dents; 975 } 976 977 /* 978 * POR: we should ensure that there are no dirty node pages 979 * until finishing nat/sit flush. 980 */ 981 retry_flush_nodes: 982 down_write(&sbi->node_write); 983 984 if (get_pages(sbi, F2FS_DIRTY_NODES)) { 985 up_write(&sbi->node_write); 986 err = sync_node_pages(sbi, &wbc); 987 if (err) { 988 f2fs_unlock_all(sbi); 989 goto out; 990 } 991 goto retry_flush_nodes; 992 } 993 out: 994 blk_finish_plug(&plug); 995 return err; 996 } 997 998 static void unblock_operations(struct f2fs_sb_info *sbi) 999 { 1000 up_write(&sbi->node_write); 1001 1002 build_free_nids(sbi, false); 1003 f2fs_unlock_all(sbi); 1004 } 1005 1006 static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi) 1007 { 1008 DEFINE_WAIT(wait); 1009 1010 for (;;) { 1011 prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE); 1012 1013 if (!get_pages(sbi, F2FS_WB_CP_DATA)) 1014 break; 1015 1016 io_schedule_timeout(5*HZ); 1017 } 1018 finish_wait(&sbi->cp_wait, &wait); 1019 } 1020 1021 static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc) 1022 { 1023 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num; 1024 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1025 1026 spin_lock(&sbi->cp_lock); 1027 1028 if (cpc->reason == CP_UMOUNT) 1029 __set_ckpt_flags(ckpt, CP_UMOUNT_FLAG); 1030 else 1031 __clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG); 1032 1033 if (cpc->reason == CP_FASTBOOT) 1034 __set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG); 1035 else 1036 __clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG); 1037 1038 if (orphan_num) 1039 __set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG); 1040 else 1041 __clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG); 1042 1043 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) 1044 __set_ckpt_flags(ckpt, CP_FSCK_FLAG); 1045 1046 /* set this flag to activate crc|cp_ver for recovery */ 1047 __set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG); 1048 1049 spin_unlock(&sbi->cp_lock); 1050 } 1051 1052 static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 1053 { 1054 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1055 struct f2fs_nm_info *nm_i = NM_I(sbi); 1056 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num; 1057 nid_t last_nid = nm_i->next_scan_nid; 1058 block_t start_blk; 1059 unsigned int data_sum_blocks, orphan_blocks; 1060 __u32 crc32 = 0; 1061 int i; 1062 int cp_payload_blks = __cp_payload(sbi); 1063 struct super_block *sb = sbi->sb; 1064 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE); 1065 u64 kbytes_written; 1066 1067 /* Flush all the NAT/SIT pages */ 1068 while (get_pages(sbi, F2FS_DIRTY_META)) { 1069 sync_meta_pages(sbi, META, LONG_MAX); 1070 if (unlikely(f2fs_cp_error(sbi))) 1071 return -EIO; 1072 } 1073 1074 next_free_nid(sbi, &last_nid); 1075 1076 /* 1077 * modify checkpoint 1078 * version number is already updated 1079 */ 1080 ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi)); 1081 ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi)); 1082 ckpt->free_segment_count = cpu_to_le32(free_segments(sbi)); 1083 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) { 1084 ckpt->cur_node_segno[i] = 1085 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE)); 1086 ckpt->cur_node_blkoff[i] = 1087 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE)); 1088 ckpt->alloc_type[i + CURSEG_HOT_NODE] = 1089 curseg_alloc_type(sbi, i + CURSEG_HOT_NODE); 1090 } 1091 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) { 1092 ckpt->cur_data_segno[i] = 1093 cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA)); 1094 ckpt->cur_data_blkoff[i] = 1095 cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA)); 1096 ckpt->alloc_type[i + CURSEG_HOT_DATA] = 1097 curseg_alloc_type(sbi, i + CURSEG_HOT_DATA); 1098 } 1099 1100 ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi)); 1101 ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi)); 1102 ckpt->next_free_nid = cpu_to_le32(last_nid); 1103 1104 /* 2 cp + n data seg summary + orphan inode blocks */ 1105 data_sum_blocks = npages_for_summary_flush(sbi, false); 1106 spin_lock(&sbi->cp_lock); 1107 if (data_sum_blocks < NR_CURSEG_DATA_TYPE) 1108 __set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG); 1109 else 1110 __clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG); 1111 spin_unlock(&sbi->cp_lock); 1112 1113 orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num); 1114 ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks + 1115 orphan_blocks); 1116 1117 if (__remain_node_summaries(cpc->reason)) 1118 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+ 1119 cp_payload_blks + data_sum_blocks + 1120 orphan_blocks + NR_CURSEG_NODE_TYPE); 1121 else 1122 ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS + 1123 cp_payload_blks + data_sum_blocks + 1124 orphan_blocks); 1125 1126 /* update ckpt flag for checkpoint */ 1127 update_ckpt_flags(sbi, cpc); 1128 1129 /* update SIT/NAT bitmap */ 1130 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP)); 1131 get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP)); 1132 1133 crc32 = f2fs_crc32(sbi, ckpt, le32_to_cpu(ckpt->checksum_offset)); 1134 *((__le32 *)((unsigned char *)ckpt + 1135 le32_to_cpu(ckpt->checksum_offset))) 1136 = cpu_to_le32(crc32); 1137 1138 start_blk = __start_cp_next_addr(sbi); 1139 1140 /* need to wait for end_io results */ 1141 wait_on_all_pages_writeback(sbi); 1142 if (unlikely(f2fs_cp_error(sbi))) 1143 return -EIO; 1144 1145 /* write out checkpoint buffer at block 0 */ 1146 update_meta_page(sbi, ckpt, start_blk++); 1147 1148 for (i = 1; i < 1 + cp_payload_blks; i++) 1149 update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE, 1150 start_blk++); 1151 1152 if (orphan_num) { 1153 write_orphan_inodes(sbi, start_blk); 1154 start_blk += orphan_blocks; 1155 } 1156 1157 write_data_summaries(sbi, start_blk); 1158 start_blk += data_sum_blocks; 1159 1160 /* Record write statistics in the hot node summary */ 1161 kbytes_written = sbi->kbytes_written; 1162 if (sb->s_bdev->bd_part) 1163 kbytes_written += BD_PART_WRITTEN(sbi); 1164 1165 seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written); 1166 1167 if (__remain_node_summaries(cpc->reason)) { 1168 write_node_summaries(sbi, start_blk); 1169 start_blk += NR_CURSEG_NODE_TYPE; 1170 } 1171 1172 /* writeout checkpoint block */ 1173 update_meta_page(sbi, ckpt, start_blk); 1174 1175 /* wait for previous submitted node/meta pages writeback */ 1176 wait_on_all_pages_writeback(sbi); 1177 1178 if (unlikely(f2fs_cp_error(sbi))) 1179 return -EIO; 1180 1181 filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LLONG_MAX); 1182 filemap_fdatawait_range(META_MAPPING(sbi), 0, LLONG_MAX); 1183 1184 /* update user_block_counts */ 1185 sbi->last_valid_block_count = sbi->total_valid_block_count; 1186 percpu_counter_set(&sbi->alloc_valid_block_count, 0); 1187 1188 /* Here, we only have one bio having CP pack */ 1189 sync_meta_pages(sbi, META_FLUSH, LONG_MAX); 1190 1191 /* wait for previous submitted meta pages writeback */ 1192 wait_on_all_pages_writeback(sbi); 1193 1194 release_ino_entry(sbi, false); 1195 1196 if (unlikely(f2fs_cp_error(sbi))) 1197 return -EIO; 1198 1199 clear_sbi_flag(sbi, SBI_IS_DIRTY); 1200 clear_sbi_flag(sbi, SBI_NEED_CP); 1201 __set_cp_next_pack(sbi); 1202 1203 /* 1204 * redirty superblock if metadata like node page or inode cache is 1205 * updated during writing checkpoint. 1206 */ 1207 if (get_pages(sbi, F2FS_DIRTY_NODES) || 1208 get_pages(sbi, F2FS_DIRTY_IMETA)) 1209 set_sbi_flag(sbi, SBI_IS_DIRTY); 1210 1211 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS)); 1212 1213 return 0; 1214 } 1215 1216 /* 1217 * We guarantee that this checkpoint procedure will not fail. 1218 */ 1219 int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 1220 { 1221 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1222 unsigned long long ckpt_ver; 1223 int err = 0; 1224 1225 mutex_lock(&sbi->cp_mutex); 1226 1227 if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && 1228 (cpc->reason == CP_FASTBOOT || cpc->reason == CP_SYNC || 1229 (cpc->reason == CP_DISCARD && !sbi->discard_blks))) 1230 goto out; 1231 if (unlikely(f2fs_cp_error(sbi))) { 1232 err = -EIO; 1233 goto out; 1234 } 1235 if (f2fs_readonly(sbi->sb)) { 1236 err = -EROFS; 1237 goto out; 1238 } 1239 1240 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops"); 1241 1242 err = block_operations(sbi); 1243 if (err) 1244 goto out; 1245 1246 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops"); 1247 1248 f2fs_flush_merged_bios(sbi); 1249 1250 /* this is the case of multiple fstrims without any changes */ 1251 if (cpc->reason == CP_DISCARD && !is_sbi_flag_set(sbi, SBI_IS_DIRTY)) { 1252 f2fs_bug_on(sbi, NM_I(sbi)->dirty_nat_cnt); 1253 f2fs_bug_on(sbi, SIT_I(sbi)->dirty_sentries); 1254 f2fs_bug_on(sbi, prefree_segments(sbi)); 1255 flush_sit_entries(sbi, cpc); 1256 clear_prefree_segments(sbi, cpc); 1257 f2fs_wait_all_discard_bio(sbi); 1258 unblock_operations(sbi); 1259 goto out; 1260 } 1261 1262 /* 1263 * update checkpoint pack index 1264 * Increase the version number so that 1265 * SIT entries and seg summaries are written at correct place 1266 */ 1267 ckpt_ver = cur_cp_version(ckpt); 1268 ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver); 1269 1270 /* write cached NAT/SIT entries to NAT/SIT area */ 1271 flush_nat_entries(sbi); 1272 flush_sit_entries(sbi, cpc); 1273 1274 /* unlock all the fs_lock[] in do_checkpoint() */ 1275 err = do_checkpoint(sbi, cpc); 1276 if (err) { 1277 release_discard_addrs(sbi); 1278 } else { 1279 clear_prefree_segments(sbi, cpc); 1280 f2fs_wait_all_discard_bio(sbi); 1281 } 1282 1283 unblock_operations(sbi); 1284 stat_inc_cp_count(sbi->stat_info); 1285 1286 if (cpc->reason == CP_RECOVERY) 1287 f2fs_msg(sbi->sb, KERN_NOTICE, 1288 "checkpoint: version = %llx", ckpt_ver); 1289 1290 /* do checkpoint periodically */ 1291 f2fs_update_time(sbi, CP_TIME); 1292 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint"); 1293 out: 1294 mutex_unlock(&sbi->cp_mutex); 1295 return err; 1296 } 1297 1298 void init_ino_entry_info(struct f2fs_sb_info *sbi) 1299 { 1300 int i; 1301 1302 for (i = 0; i < MAX_INO_ENTRY; i++) { 1303 struct inode_management *im = &sbi->im[i]; 1304 1305 INIT_RADIX_TREE(&im->ino_root, GFP_ATOMIC); 1306 spin_lock_init(&im->ino_lock); 1307 INIT_LIST_HEAD(&im->ino_list); 1308 im->ino_num = 0; 1309 } 1310 1311 sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS - 1312 NR_CURSEG_TYPE - __cp_payload(sbi)) * 1313 F2FS_ORPHANS_PER_BLOCK; 1314 } 1315 1316 int __init create_checkpoint_caches(void) 1317 { 1318 ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry", 1319 sizeof(struct ino_entry)); 1320 if (!ino_entry_slab) 1321 return -ENOMEM; 1322 inode_entry_slab = f2fs_kmem_cache_create("f2fs_inode_entry", 1323 sizeof(struct inode_entry)); 1324 if (!inode_entry_slab) { 1325 kmem_cache_destroy(ino_entry_slab); 1326 return -ENOMEM; 1327 } 1328 return 0; 1329 } 1330 1331 void destroy_checkpoint_caches(void) 1332 { 1333 kmem_cache_destroy(ino_entry_slab); 1334 kmem_cache_destroy(inode_entry_slab); 1335 } 1336