node.c (8dd06ef34b6e2f41b29fbf5fc1663780f2524285) node.c (0b6d4ca04a86b9dababbb76e58d33c437e127b77)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/node.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 496 unchanged lines hidden (view full) ---

505 spin_lock(&nm_i->nat_list_lock);
506 }
507 spin_unlock(&nm_i->nat_list_lock);
508
509 up_write(&nm_i->nat_tree_lock);
510 return nr - nr_shrink;
511}
512
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/node.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 496 unchanged lines hidden (view full) ---

505 spin_lock(&nm_i->nat_list_lock);
506 }
507 spin_unlock(&nm_i->nat_list_lock);
508
509 up_write(&nm_i->nat_tree_lock);
510 return nr - nr_shrink;
511}
512
513/*
514 * This function always returns success
515 */
516int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
517 struct node_info *ni)
518{
519 struct f2fs_nm_info *nm_i = NM_I(sbi);
520 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
521 struct f2fs_journal *journal = curseg->journal;
522 nid_t start_nid = START_NID(nid);
523 struct f2fs_nat_block *nat_blk;

--- 187 unchanged lines hidden (view full) ---

711 }
712got:
713 return level;
714}
715
716/*
717 * Caller should call f2fs_put_dnode(dn).
718 * Also, it should grab and release a rwsem by calling f2fs_lock_op() and
513int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
514 struct node_info *ni)
515{
516 struct f2fs_nm_info *nm_i = NM_I(sbi);
517 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
518 struct f2fs_journal *journal = curseg->journal;
519 nid_t start_nid = START_NID(nid);
520 struct f2fs_nat_block *nat_blk;

--- 187 unchanged lines hidden (view full) ---

708 }
709got:
710 return level;
711}
712
713/*
714 * Caller should call f2fs_put_dnode(dn).
715 * Also, it should grab and release a rwsem by calling f2fs_lock_op() and
719 * f2fs_unlock_op() only if ro is not set RDONLY_NODE.
720 * In the case of RDONLY_NODE, we don't need to care about mutex.
716 * f2fs_unlock_op() only if mode is set with ALLOC_NODE.
721 */
722int f2fs_get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
723{
724 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
725 struct page *npage[4];
726 struct page *parent = NULL;
727 int offset[4];
728 unsigned int noffset[4];

--- 75 unchanged lines hidden (view full) ---

804 if (i < level) {
805 parent = npage[i];
806 nids[i + 1] = get_nid(parent, offset[i], false);
807 }
808 }
809 dn->nid = nids[level];
810 dn->ofs_in_node = offset[level];
811 dn->node_page = npage[level];
717 */
718int f2fs_get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
719{
720 struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
721 struct page *npage[4];
722 struct page *parent = NULL;
723 int offset[4];
724 unsigned int noffset[4];

--- 75 unchanged lines hidden (view full) ---

800 if (i < level) {
801 parent = npage[i];
802 nids[i + 1] = get_nid(parent, offset[i], false);
803 }
804 }
805 dn->nid = nids[level];
806 dn->ofs_in_node = offset[level];
807 dn->node_page = npage[level];
812 dn->data_blkaddr = datablock_addr(dn->inode,
813 dn->node_page, dn->ofs_in_node);
808 dn->data_blkaddr = f2fs_data_blkaddr(dn);
814 return 0;
815
816release_pages:
817 f2fs_put_page(parent, 1);
818 if (i > 1)
819 f2fs_put_page(npage[0], 0);
820release_out:
821 dn->inode_page = NULL;

--- 361 unchanged lines hidden (view full) ---

1183
1184 /* 0 is possible, after f2fs_new_inode() has failed */
1185 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
1186 f2fs_put_dnode(&dn);
1187 return -EIO;
1188 }
1189
1190 if (unlikely(inode->i_blocks != 0 && inode->i_blocks != 8)) {
809 return 0;
810
811release_pages:
812 f2fs_put_page(parent, 1);
813 if (i > 1)
814 f2fs_put_page(npage[0], 0);
815release_out:
816 dn->inode_page = NULL;

--- 361 unchanged lines hidden (view full) ---

1178
1179 /* 0 is possible, after f2fs_new_inode() has failed */
1180 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
1181 f2fs_put_dnode(&dn);
1182 return -EIO;
1183 }
1184
1185 if (unlikely(inode->i_blocks != 0 && inode->i_blocks != 8)) {
1191 f2fs_warn(F2FS_I_SB(inode), "Inconsistent i_blocks, ino:%lu, iblocks:%llu",
1192 inode->i_ino, (unsigned long long)inode->i_blocks);
1186 f2fs_warn(F2FS_I_SB(inode),
1187 "f2fs_remove_inode_page: inconsistent i_blocks, ino:%lu, iblocks:%llu",
1188 inode->i_ino, (unsigned long long)inode->i_blocks);
1193 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
1194 }
1195
1196 /* will put inode & node pages */
1197 err = truncate_node(&dn);
1198 if (err) {
1199 f2fs_put_dnode(&dn);
1200 return err;

--- 98 unchanged lines hidden (view full) ---

1299
1300 if (unlikely(ni.blk_addr == NULL_ADDR) ||
1301 is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN)) {
1302 ClearPageUptodate(page);
1303 return -ENOENT;
1304 }
1305
1306 fio.new_blkaddr = fio.old_blkaddr = ni.blk_addr;
1189 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
1190 }
1191
1192 /* will put inode & node pages */
1193 err = truncate_node(&dn);
1194 if (err) {
1195 f2fs_put_dnode(&dn);
1196 return err;

--- 98 unchanged lines hidden (view full) ---

1295
1296 if (unlikely(ni.blk_addr == NULL_ADDR) ||
1297 is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN)) {
1298 ClearPageUptodate(page);
1299 return -ENOENT;
1300 }
1301
1302 fio.new_blkaddr = fio.old_blkaddr = ni.blk_addr;
1307 return f2fs_submit_page_bio(&fio);
1303
1304 err = f2fs_submit_page_bio(&fio);
1305
1306 if (!err)
1307 f2fs_update_iostat(sbi, FS_NODE_READ_IO, F2FS_BLKSIZE);
1308
1309 return err;
1308}
1309
1310/*
1311 * Readahead a node page
1312 */
1313void f2fs_ra_node_page(struct f2fs_sb_info *sbi, nid_t nid)
1314{
1315 struct page *apage;

--- 197 unchanged lines hidden (view full) ---

1513 .submitted = false,
1514 .io_type = io_type,
1515 .io_wbc = wbc,
1516 };
1517 unsigned int seq;
1518
1519 trace_f2fs_writepage(page, NODE);
1520
1310}
1311
1312/*
1313 * Readahead a node page
1314 */
1315void f2fs_ra_node_page(struct f2fs_sb_info *sbi, nid_t nid)
1316{
1317 struct page *apage;

--- 197 unchanged lines hidden (view full) ---

1515 .submitted = false,
1516 .io_type = io_type,
1517 .io_wbc = wbc,
1518 };
1519 unsigned int seq;
1520
1521 trace_f2fs_writepage(page, NODE);
1522
1521 if (unlikely(f2fs_cp_error(sbi)))
1523 if (unlikely(f2fs_cp_error(sbi))) {
1524 if (is_sbi_flag_set(sbi, SBI_IS_CLOSE)) {
1525 ClearPageUptodate(page);
1526 dec_page_count(sbi, F2FS_DIRTY_NODES);
1527 unlock_page(page);
1528 return 0;
1529 }
1522 goto redirty_out;
1530 goto redirty_out;
1531 }
1523
1524 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1525 goto redirty_out;
1526
1527 if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
1528 wbc->sync_mode == WB_SYNC_NONE &&
1529 IS_DNODE(page) && is_cold_node(page))
1530 goto redirty_out;

--- 26 unchanged lines hidden (view full) ---

1557 DATA_GENERIC_ENHANCE)) {
1558 up_read(&sbi->node_write);
1559 goto redirty_out;
1560 }
1561
1562 if (atomic && !test_opt(sbi, NOBARRIER))
1563 fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
1564
1532
1533 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1534 goto redirty_out;
1535
1536 if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
1537 wbc->sync_mode == WB_SYNC_NONE &&
1538 IS_DNODE(page) && is_cold_node(page))
1539 goto redirty_out;

--- 26 unchanged lines hidden (view full) ---

1566 DATA_GENERIC_ENHANCE)) {
1567 up_read(&sbi->node_write);
1568 goto redirty_out;
1569 }
1570
1571 if (atomic && !test_opt(sbi, NOBARRIER))
1572 fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
1573
1565 set_page_writeback(page);
1566 ClearPageError(page);
1567
1574 /* should add to global list before clearing PAGECACHE status */
1568 if (f2fs_in_warm_node_list(sbi, page)) {
1569 seq = f2fs_add_fsync_node_entry(sbi, page);
1570 if (seq_id)
1571 *seq_id = seq;
1572 }
1573
1575 if (f2fs_in_warm_node_list(sbi, page)) {
1576 seq = f2fs_add_fsync_node_entry(sbi, page);
1577 if (seq_id)
1578 *seq_id = seq;
1579 }
1580
1581 set_page_writeback(page);
1582 ClearPageError(page);
1583
1574 fio.old_blkaddr = ni.blk_addr;
1575 f2fs_do_write_node_page(nid, &fio);
1576 set_node_addr(sbi, &ni, fio.new_blkaddr, is_fsync_dnode(page));
1577 dec_page_count(sbi, F2FS_DIRTY_NODES);
1578 up_read(&sbi->node_write);
1579
1580 if (wbc->for_reclaim) {
1581 f2fs_submit_merged_write_cond(sbi, NULL, page, 0, NODE);

--- 217 unchanged lines hidden (view full) ---

1799
1800 f2fs_update_inode(inode, page);
1801 unlock_page(page);
1802
1803 iput(inode);
1804 return true;
1805}
1806
1584 fio.old_blkaddr = ni.blk_addr;
1585 f2fs_do_write_node_page(nid, &fio);
1586 set_node_addr(sbi, &ni, fio.new_blkaddr, is_fsync_dnode(page));
1587 dec_page_count(sbi, F2FS_DIRTY_NODES);
1588 up_read(&sbi->node_write);
1589
1590 if (wbc->for_reclaim) {
1591 f2fs_submit_merged_write_cond(sbi, NULL, page, 0, NODE);

--- 217 unchanged lines hidden (view full) ---

1809
1810 f2fs_update_inode(inode, page);
1811 unlock_page(page);
1812
1813 iput(inode);
1814 return true;
1815}
1816
1817int f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
1818{
1819 pgoff_t index = 0;
1820 struct pagevec pvec;
1821 int nr_pages;
1822 int ret = 0;
1823
1824 pagevec_init(&pvec);
1825
1826 while ((nr_pages = pagevec_lookup_tag(&pvec,
1827 NODE_MAPPING(sbi), &index, PAGECACHE_TAG_DIRTY))) {
1828 int i;
1829
1830 for (i = 0; i < nr_pages; i++) {
1831 struct page *page = pvec.pages[i];
1832
1833 if (!IS_DNODE(page))
1834 continue;
1835
1836 lock_page(page);
1837
1838 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
1839continue_unlock:
1840 unlock_page(page);
1841 continue;
1842 }
1843
1844 if (!PageDirty(page)) {
1845 /* someone wrote it for us */
1846 goto continue_unlock;
1847 }
1848
1849 /* flush inline_data, if it's async context. */
1850 if (is_inline_node(page)) {
1851 clear_inline_node(page);
1852 unlock_page(page);
1853 flush_inline_data(sbi, ino_of_node(page));
1854 continue;
1855 }
1856 unlock_page(page);
1857 }
1858 pagevec_release(&pvec);
1859 cond_resched();
1860 }
1861 return ret;
1862}
1863
1807int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
1808 struct writeback_control *wbc,
1809 bool do_balance, enum iostat_type io_type)
1810{
1811 pgoff_t index;
1812 struct pagevec pvec;
1813 int step = 0;
1814 int nwritten = 0;

--- 47 unchanged lines hidden (view full) ---

1862 continue;
1863 }
1864
1865 if (!PageDirty(page)) {
1866 /* someone wrote it for us */
1867 goto continue_unlock;
1868 }
1869
1864int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
1865 struct writeback_control *wbc,
1866 bool do_balance, enum iostat_type io_type)
1867{
1868 pgoff_t index;
1869 struct pagevec pvec;
1870 int step = 0;
1871 int nwritten = 0;

--- 47 unchanged lines hidden (view full) ---

1919 continue;
1920 }
1921
1922 if (!PageDirty(page)) {
1923 /* someone wrote it for us */
1924 goto continue_unlock;
1925 }
1926
1870 /* flush inline_data */
1871 if (is_inline_node(page)) {
1927 /* flush inline_data, if it's async context. */
1928 if (do_balance && is_inline_node(page)) {
1872 clear_inline_node(page);
1873 unlock_page(page);
1874 flush_inline_data(sbi, ino_of_node(page));
1875 goto lock_node;
1876 }
1877
1878 /* flush dirty inode */
1879 if (IS_INODE(page) && may_dirty) {

--- 94 unchanged lines hidden (view full) ---

1974 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
1975 struct blk_plug plug;
1976 long diff;
1977
1978 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1979 goto skip_write;
1980
1981 /* balancing f2fs's metadata in background */
1929 clear_inline_node(page);
1930 unlock_page(page);
1931 flush_inline_data(sbi, ino_of_node(page));
1932 goto lock_node;
1933 }
1934
1935 /* flush dirty inode */
1936 if (IS_INODE(page) && may_dirty) {

--- 94 unchanged lines hidden (view full) ---

2031 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
2032 struct blk_plug plug;
2033 long diff;
2034
2035 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
2036 goto skip_write;
2037
2038 /* balancing f2fs's metadata in background */
1982 f2fs_balance_fs_bg(sbi);
2039 f2fs_balance_fs_bg(sbi, true);
1983
1984 /* collect a number of dirty node pages and write together */
1985 if (wbc->sync_mode != WB_SYNC_ALL &&
1986 get_pages(sbi, F2FS_DIRTY_NODES) <
1987 nr_pages_to_skip(sbi, NODE))
1988 goto skip_write;
1989
1990 if (wbc->sync_mode == WB_SYNC_ALL)

--- 489 unchanged lines hidden (view full) ---

2480
2481 if (need_free)
2482 kmem_cache_free(free_nid_slab, i);
2483}
2484
2485int f2fs_try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink)
2486{
2487 struct f2fs_nm_info *nm_i = NM_I(sbi);
2040
2041 /* collect a number of dirty node pages and write together */
2042 if (wbc->sync_mode != WB_SYNC_ALL &&
2043 get_pages(sbi, F2FS_DIRTY_NODES) <
2044 nr_pages_to_skip(sbi, NODE))
2045 goto skip_write;
2046
2047 if (wbc->sync_mode == WB_SYNC_ALL)

--- 489 unchanged lines hidden (view full) ---

2537
2538 if (need_free)
2539 kmem_cache_free(free_nid_slab, i);
2540}
2541
2542int f2fs_try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink)
2543{
2544 struct f2fs_nm_info *nm_i = NM_I(sbi);
2488 struct free_nid *i, *next;
2489 int nr = nr_shrink;
2490
2491 if (nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS)
2492 return 0;
2493
2494 if (!mutex_trylock(&nm_i->build_lock))
2495 return 0;
2496
2545 int nr = nr_shrink;
2546
2547 if (nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS)
2548 return 0;
2549
2550 if (!mutex_trylock(&nm_i->build_lock))
2551 return 0;
2552
2497 spin_lock(&nm_i->nid_list_lock);
2498 list_for_each_entry_safe(i, next, &nm_i->free_nid_list, list) {
2499 if (nr_shrink <= 0 ||
2500 nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS)
2501 break;
2553 while (nr_shrink && nm_i->nid_cnt[FREE_NID] > MAX_FREE_NIDS) {
2554 struct free_nid *i, *next;
2555 unsigned int batch = SHRINK_NID_BATCH_SIZE;
2502
2556
2503 __remove_free_nid(sbi, i, FREE_NID);
2504 kmem_cache_free(free_nid_slab, i);
2505 nr_shrink--;
2557 spin_lock(&nm_i->nid_list_lock);
2558 list_for_each_entry_safe(i, next, &nm_i->free_nid_list, list) {
2559 if (!nr_shrink || !batch ||
2560 nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS)
2561 break;
2562 __remove_free_nid(sbi, i, FREE_NID);
2563 kmem_cache_free(free_nid_slab, i);
2564 nr_shrink--;
2565 batch--;
2566 }
2567 spin_unlock(&nm_i->nid_list_lock);
2506 }
2568 }
2507 spin_unlock(&nm_i->nid_list_lock);
2569
2508 mutex_unlock(&nm_i->build_lock);
2509
2510 return nr - nr_shrink;
2511}
2512
2513void f2fs_recover_inline_xattr(struct inode *inode, struct page *page)
2514{
2515 void *src_addr, *dst_addr;

--- 81 unchanged lines hidden (view full) ---

2597 if (err)
2598 return err;
2599
2600 if (unlikely(old_ni.blk_addr != NULL_ADDR))
2601 return -EINVAL;
2602retry:
2603 ipage = f2fs_grab_cache_page(NODE_MAPPING(sbi), ino, false);
2604 if (!ipage) {
2570 mutex_unlock(&nm_i->build_lock);
2571
2572 return nr - nr_shrink;
2573}
2574
2575void f2fs_recover_inline_xattr(struct inode *inode, struct page *page)
2576{
2577 void *src_addr, *dst_addr;

--- 81 unchanged lines hidden (view full) ---

2659 if (err)
2660 return err;
2661
2662 if (unlikely(old_ni.blk_addr != NULL_ADDR))
2663 return -EINVAL;
2664retry:
2665 ipage = f2fs_grab_cache_page(NODE_MAPPING(sbi), ino, false);
2666 if (!ipage) {
2605 congestion_wait(BLK_RW_ASYNC, HZ/50);
2667 congestion_wait(BLK_RW_ASYNC, DEFAULT_IO_TIMEOUT);
2606 goto retry;
2607 }
2608
2609 /* Should not use this inode from free nid list */
2610 remove_free_nid(sbi, ino);
2611
2612 if (!PageUptodate(ipage))
2613 SetPageUptodate(ipage);

--- 312 unchanged lines hidden (view full) ---

2926 unsigned int i;
2927 __u64 cp_ver = cur_cp_version(ckpt);
2928 block_t nat_bits_addr;
2929
2930 if (!enabled_nat_bits(sbi, NULL))
2931 return 0;
2932
2933 nm_i->nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);
2668 goto retry;
2669 }
2670
2671 /* Should not use this inode from free nid list */
2672 remove_free_nid(sbi, ino);
2673
2674 if (!PageUptodate(ipage))
2675 SetPageUptodate(ipage);

--- 312 unchanged lines hidden (view full) ---

2988 unsigned int i;
2989 __u64 cp_ver = cur_cp_version(ckpt);
2990 block_t nat_bits_addr;
2991
2992 if (!enabled_nat_bits(sbi, NULL))
2993 return 0;
2994
2995 nm_i->nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);
2934 nm_i->nat_bits = f2fs_kzalloc(sbi,
2996 nm_i->nat_bits = f2fs_kvzalloc(sbi,
2935 nm_i->nat_bits_blocks << F2FS_BLKSIZE_BITS, GFP_KERNEL);
2936 if (!nm_i->nat_bits)
2937 return -ENOMEM;
2938
2939 nat_bits_addr = __start_cp_addr(sbi) + sbi->blocks_per_seg -
2940 nm_i->nat_bits_blocks;
2941 for (i = 0; i < nm_i->nat_bits_blocks; i++) {
2942 struct page *page;

--- 116 unchanged lines hidden (view full) ---

3059}
3060
3061static int init_free_nid_cache(struct f2fs_sb_info *sbi)
3062{
3063 struct f2fs_nm_info *nm_i = NM_I(sbi);
3064 int i;
3065
3066 nm_i->free_nid_bitmap =
2997 nm_i->nat_bits_blocks << F2FS_BLKSIZE_BITS, GFP_KERNEL);
2998 if (!nm_i->nat_bits)
2999 return -ENOMEM;
3000
3001 nat_bits_addr = __start_cp_addr(sbi) + sbi->blocks_per_seg -
3002 nm_i->nat_bits_blocks;
3003 for (i = 0; i < nm_i->nat_bits_blocks; i++) {
3004 struct page *page;

--- 116 unchanged lines hidden (view full) ---

3121}
3122
3123static int init_free_nid_cache(struct f2fs_sb_info *sbi)
3124{
3125 struct f2fs_nm_info *nm_i = NM_I(sbi);
3126 int i;
3127
3128 nm_i->free_nid_bitmap =
3067 f2fs_kzalloc(sbi, array_size(sizeof(unsigned char *),
3068 nm_i->nat_blocks),
3069 GFP_KERNEL);
3129 f2fs_kvzalloc(sbi, array_size(sizeof(unsigned char *),
3130 nm_i->nat_blocks),
3131 GFP_KERNEL);
3070 if (!nm_i->free_nid_bitmap)
3071 return -ENOMEM;
3072
3073 for (i = 0; i < nm_i->nat_blocks; i++) {
3074 nm_i->free_nid_bitmap[i] = f2fs_kvzalloc(sbi,
3075 f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK), GFP_KERNEL);
3076 if (!nm_i->free_nid_bitmap[i])
3077 return -ENOMEM;

--- 110 unchanged lines hidden (view full) ---

3188 kvfree(nm_i->nat_bitmap_mir);
3189#endif
3190 sbi->nm_info = NULL;
3191 kvfree(nm_i);
3192}
3193
3194int __init f2fs_create_node_manager_caches(void)
3195{
3132 if (!nm_i->free_nid_bitmap)
3133 return -ENOMEM;
3134
3135 for (i = 0; i < nm_i->nat_blocks; i++) {
3136 nm_i->free_nid_bitmap[i] = f2fs_kvzalloc(sbi,
3137 f2fs_bitmap_size(NAT_ENTRY_PER_BLOCK), GFP_KERNEL);
3138 if (!nm_i->free_nid_bitmap[i])
3139 return -ENOMEM;

--- 110 unchanged lines hidden (view full) ---

3250 kvfree(nm_i->nat_bitmap_mir);
3251#endif
3252 sbi->nm_info = NULL;
3253 kvfree(nm_i);
3254}
3255
3256int __init f2fs_create_node_manager_caches(void)
3257{
3196 nat_entry_slab = f2fs_kmem_cache_create("nat_entry",
3258 nat_entry_slab = f2fs_kmem_cache_create("f2fs_nat_entry",
3197 sizeof(struct nat_entry));
3198 if (!nat_entry_slab)
3199 goto fail;
3200
3259 sizeof(struct nat_entry));
3260 if (!nat_entry_slab)
3261 goto fail;
3262
3201 free_nid_slab = f2fs_kmem_cache_create("free_nid",
3263 free_nid_slab = f2fs_kmem_cache_create("f2fs_free_nid",
3202 sizeof(struct free_nid));
3203 if (!free_nid_slab)
3204 goto destroy_nat_entry;
3205
3264 sizeof(struct free_nid));
3265 if (!free_nid_slab)
3266 goto destroy_nat_entry;
3267
3206 nat_entry_set_slab = f2fs_kmem_cache_create("nat_entry_set",
3268 nat_entry_set_slab = f2fs_kmem_cache_create("f2fs_nat_entry_set",
3207 sizeof(struct nat_entry_set));
3208 if (!nat_entry_set_slab)
3209 goto destroy_free_nid;
3210
3269 sizeof(struct nat_entry_set));
3270 if (!nat_entry_set_slab)
3271 goto destroy_free_nid;
3272
3211 fsync_node_entry_slab = f2fs_kmem_cache_create("fsync_node_entry",
3273 fsync_node_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_node_entry",
3212 sizeof(struct fsync_node_entry));
3213 if (!fsync_node_entry_slab)
3214 goto destroy_nat_entry_set;
3215 return 0;
3216
3217destroy_nat_entry_set:
3218 kmem_cache_destroy(nat_entry_set_slab);
3219destroy_free_nid:

--- 14 unchanged lines hidden --- 		3274 sizeof(struct fsync_node_entry));
3275 if (!fsync_node_entry_slab)
3276 goto destroy_nat_entry_set;
3277 return 0;
3278
3279destroy_nat_entry_set:
3280 kmem_cache_destroy(nat_entry_set_slab);
3281destroy_free_nid:

--- 14 unchanged lines hidden ---