node.c (c9f289701540baeef9ac7c9977d67a7259f404db) node.c (f40f31cadc0ea5dcdd224c8b324add26469c2379)
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;

--- 356 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
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;

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

1553 DATA_GENERIC_ENHANCE)) {
1554 up_read(&sbi->node_write);
1555 goto redirty_out;
1556 }
1557
1558 if (atomic && !test_opt(sbi, NOBARRIER))
1559 fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
1560
1565 set_page_writeback(page);
1566 ClearPageError(page);
1567
1561 /* 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
1562 if (f2fs_in_warm_node_list(sbi, page)) {
1563 seq = f2fs_add_fsync_node_entry(sbi, page);
1564 if (seq_id)
1565 *seq_id = seq;
1566 }
1567
1568 set_page_writeback(page);
1569 ClearPageError(page);
1570
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);

--- 392 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 */
1571 fio.old_blkaddr = ni.blk_addr;
1572 f2fs_do_write_node_page(nid, &fio);
1573 set_node_addr(sbi, &ni, fio.new_blkaddr, is_fsync_dnode(page));
1574 dec_page_count(sbi, F2FS_DIRTY_NODES);
1575 up_read(&sbi->node_write);
1576
1577 if (wbc->for_reclaim) {
1578 f2fs_submit_merged_write_cond(sbi, NULL, page, 0, NODE);

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

1971 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
1972 struct blk_plug plug;
1973 long diff;
1974
1975 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1976 goto skip_write;
1977
1978 /* balancing f2fs's metadata in background */
1982 f2fs_balance_fs_bg(sbi);
1979 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)

--- 606 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) {
1980
1981 /* collect a number of dirty node pages and write together */
1982 if (wbc->sync_mode != WB_SYNC_ALL &&
1983 get_pages(sbi, F2FS_DIRTY_NODES) <
1984 nr_pages_to_skip(sbi, NODE))
1985 goto skip_write;
1986
1987 if (wbc->sync_mode == WB_SYNC_ALL)

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

2594 if (err)
2595 return err;
2596
2597 if (unlikely(old_ni.blk_addr != NULL_ADDR))
2598 return -EINVAL;
2599retry:
2600 ipage = f2fs_grab_cache_page(NODE_MAPPING(sbi), ino, false);
2601 if (!ipage) {
2605 congestion_wait(BLK_RW_ASYNC, HZ/50);
2602 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);

--- 574 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{
2603 goto retry;
2604 }
2605
2606 /* Should not use this inode from free nid list */
2607 remove_free_nid(sbi, ino);
2608
2609 if (!PageUptodate(ipage))
2610 SetPageUptodate(ipage);

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

3185 kvfree(nm_i->nat_bitmap_mir);
3186#endif
3187 sbi->nm_info = NULL;
3188 kvfree(nm_i);
3189}
3190
3191int __init f2fs_create_node_manager_caches(void)
3192{
3196 nat_entry_slab = f2fs_kmem_cache_create("nat_entry",
3193 nat_entry_slab = f2fs_kmem_cache_create("f2fs_nat_entry",
3197 sizeof(struct nat_entry));
3198 if (!nat_entry_slab)
3199 goto fail;
3200
3194 sizeof(struct nat_entry));
3195 if (!nat_entry_slab)
3196 goto fail;
3197
3201 free_nid_slab = f2fs_kmem_cache_create("free_nid",
3198 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
3199 sizeof(struct free_nid));
3200 if (!free_nid_slab)
3201 goto destroy_nat_entry;
3202
3206 nat_entry_set_slab = f2fs_kmem_cache_create("nat_entry_set",
3203 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
3204 sizeof(struct nat_entry_set));
3205 if (!nat_entry_set_slab)
3206 goto destroy_free_nid;
3207
3211 fsync_node_entry_slab = f2fs_kmem_cache_create("fsync_node_entry",
3208 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 --- 		3209 sizeof(struct fsync_node_entry));
3210 if (!fsync_node_entry_slab)
3211 goto destroy_nat_entry_set;
3212 return 0;
3213
3214destroy_nat_entry_set:
3215 kmem_cache_destroy(nat_entry_set_slab);
3216destroy_free_nid:

--- 14 unchanged lines hidden ---