node.c (355a47ae7ebcf9d605aa809b259d380422e81b8d) node.c (dcbb4c10e6d9693cc9d6fa493b4d130b66a60c7d)
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>

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

29
30/*
31 * Check whether the given nid is within node id range.
32 */
33int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
34{
35 if (unlikely(nid < F2FS_ROOT_INO(sbi) || nid >= NM_I(sbi)->max_nid)) {
36 set_sbi_flag(sbi, SBI_NEED_FSCK);
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>

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

29
30/*
31 * Check whether the given nid is within node id range.
32 */
33int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
34{
35 if (unlikely(nid < F2FS_ROOT_INO(sbi) || nid >= NM_I(sbi)->max_nid)) {
36 set_sbi_flag(sbi, SBI_NEED_FSCK);
37 f2fs_msg(sbi->sb, KERN_WARNING,
38 "%s: out-of-range nid=%x, run fsck to fix.",
39 __func__, nid);
37 f2fs_warn(sbi, "%s: out-of-range nid=%x, run fsck to fix.",
38 __func__, nid);
40 return -EINVAL;
41 }
42 return 0;
43}
44
45bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type)
46{
47 struct f2fs_nm_info *nm_i = NM_I(sbi);

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

1184
1185 /* 0 is possible, after f2fs_new_inode() has failed */
1186 if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {
1187 f2fs_put_dnode(&dn);
1188 return -EIO;
1189 }
1190
1191 if (unlikely(inode->i_blocks != 0 && inode->i_blocks != 8)) {
39 return -EINVAL;
40 }
41 return 0;
42}
43
44bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type)
45{
46 struct f2fs_nm_info *nm_i = NM_I(sbi);

--- 1136 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)) {
1192 f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING,
1193 "Inconsistent i_blocks, ino:%lu, iblocks:%llu",
1194 inode->i_ino,
1195 (unsigned long long)inode->i_blocks);
1191 f2fs_warn(F2FS_I_SB(inode), "Inconsistent i_blocks, ino:%lu, iblocks:%llu",
1192 inode->i_ino, (unsigned long long)inode->i_blocks);
1196 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
1197 }
1198
1199 /* will put inode & node pages */
1200 err = truncate_node(&dn);
1201 if (err) {
1202 f2fs_put_dnode(&dn);
1203 return err;

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

1375 }
1376
1377 if (!f2fs_inode_chksum_verify(sbi, page)) {
1378 err = -EBADMSG;
1379 goto out_err;
1380 }
1381page_hit:
1382 if(unlikely(nid != nid_of_node(page))) {
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;

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

1372 }
1373
1374 if (!f2fs_inode_chksum_verify(sbi, page)) {
1375 err = -EBADMSG;
1376 goto out_err;
1377 }
1378page_hit:
1379 if(unlikely(nid != nid_of_node(page))) {
1383 f2fs_msg(sbi->sb, KERN_WARNING, "inconsistent node block, "
1384 "nid:%lu, node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]",
1385 nid, nid_of_node(page), ino_of_node(page),
1386 ofs_of_node(page), cpver_of_node(page),
1387 next_blkaddr_of_node(page));
1380 f2fs_warn(sbi, "inconsistent node block, nid:%lu, node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]",
1381 nid, nid_of_node(page), ino_of_node(page),
1382 ofs_of_node(page), cpver_of_node(page),
1383 next_blkaddr_of_node(page));
1388 err = -EINVAL;
1389out_err:
1390 ClearPageUptodate(page);
1391 f2fs_put_page(page, 1);
1392 return ERR_PTR(err);
1393 }
1394 return page;
1395}

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

1747 }
1748 pagevec_release(&pvec);
1749 cond_resched();
1750
1751 if (ret || marked)
1752 break;
1753 }
1754 if (!ret && atomic && !marked) {
1384 err = -EINVAL;
1385out_err:
1386 ClearPageUptodate(page);
1387 f2fs_put_page(page, 1);
1388 return ERR_PTR(err);
1389 }
1390 return page;
1391}

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

1743 }
1744 pagevec_release(&pvec);
1745 cond_resched();
1746
1747 if (ret || marked)
1748 break;
1749 }
1750 if (!ret && atomic && !marked) {
1755 f2fs_msg(sbi->sb, KERN_DEBUG,
1756 "Retry to write fsync mark: ino=%u, idx=%lx",
1757 ino, last_page->index);
1751 f2fs_debug(sbi, "Retry to write fsync mark: ino=%u, idx=%lx",
1752 ino, last_page->index);
1758 lock_page(last_page);
1759 f2fs_wait_on_page_writeback(last_page, NODE, true, true);
1760 set_page_dirty(last_page);
1761 unlock_page(last_page);
1762 goto retry;
1763 }
1764out:
1765 if (nwritten)

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

2299 } else {
2300 ret = scan_nat_page(sbi, page, nid);
2301 f2fs_put_page(page, 1);
2302 }
2303
2304 if (ret) {
2305 up_read(&nm_i->nat_tree_lock);
2306 f2fs_bug_on(sbi, !mount);
1753 lock_page(last_page);
1754 f2fs_wait_on_page_writeback(last_page, NODE, true, true);
1755 set_page_dirty(last_page);
1756 unlock_page(last_page);
1757 goto retry;
1758 }
1759out:
1760 if (nwritten)

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

2294 } else {
2295 ret = scan_nat_page(sbi, page, nid);
2296 f2fs_put_page(page, 1);
2297 }
2298
2299 if (ret) {
2300 up_read(&nm_i->nat_tree_lock);
2301 f2fs_bug_on(sbi, !mount);
2307 f2fs_msg(sbi->sb, KERN_ERR,
2308 "NAT is corrupt, run fsck to fix it");
2302 f2fs_err(sbi, "NAT is corrupt, run fsck to fix it");
2309 return ret;
2310 }
2311 }
2312
2313 nid += (NAT_ENTRY_PER_BLOCK - (nid % NAT_ENTRY_PER_BLOCK));
2314 if (unlikely(nid >= nm_i->max_nid))
2315 nid = 0;
2316

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

2720 if (!enabled_nat_bits(sbi, NULL))
2721 return;
2722
2723 if (nat_index == 0) {
2724 valid = 1;
2725 i = 1;
2726 }
2727 for (; i < NAT_ENTRY_PER_BLOCK; i++) {
2303 return ret;
2304 }
2305 }
2306
2307 nid += (NAT_ENTRY_PER_BLOCK - (nid % NAT_ENTRY_PER_BLOCK));
2308 if (unlikely(nid >= nm_i->max_nid))
2309 nid = 0;
2310

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

2714 if (!enabled_nat_bits(sbi, NULL))
2715 return;
2716
2717 if (nat_index == 0) {
2718 valid = 1;
2719 i = 1;
2720 }
2721 for (; i < NAT_ENTRY_PER_BLOCK; i++) {
2728 if (nat_blk->entries[i].block_addr != NULL_ADDR)
2722 if (le32_to_cpu(nat_blk->entries[i].block_addr) != NULL_ADDR)
2729 valid++;
2730 }
2731 if (valid == 0) {
2732 __set_bit_le(nat_index, nm_i->empty_nat_bits);
2733 __clear_bit_le(nat_index, nm_i->full_nat_bits);
2734 return;
2735 }
2736

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

2910 if (cpu_to_le64(cp_ver) != *(__le64 *)nm_i->nat_bits) {
2911 disable_nat_bits(sbi, true);
2912 return 0;
2913 }
2914
2915 nm_i->full_nat_bits = nm_i->nat_bits + 8;
2916 nm_i->empty_nat_bits = nm_i->full_nat_bits + nat_bits_bytes;
2917
2723 valid++;
2724 }
2725 if (valid == 0) {
2726 __set_bit_le(nat_index, nm_i->empty_nat_bits);
2727 __clear_bit_le(nat_index, nm_i->full_nat_bits);
2728 return;
2729 }
2730

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

2904 if (cpu_to_le64(cp_ver) != *(__le64 *)nm_i->nat_bits) {
2905 disable_nat_bits(sbi, true);
2906 return 0;
2907 }
2908
2909 nm_i->full_nat_bits = nm_i->nat_bits + 8;
2910 nm_i->empty_nat_bits = nm_i->full_nat_bits + nat_bits_bytes;
2911
2918 f2fs_msg(sbi->sb, KERN_NOTICE, "Found nat_bits in checkpoint");
2912 f2fs_notice(sbi, "Found nat_bits in checkpoint");
2919 return 0;
2920}
2921
2922static inline void load_free_nid_bitmap(struct f2fs_sb_info *sbi)
2923{
2924 struct f2fs_nm_info *nm_i = NM_I(sbi);
2925 unsigned int i = 0;
2926 nid_t nid, last_nid;

--- 263 unchanged lines hidden --- 		2913 return 0;
2914}
2915
2916static inline void load_free_nid_bitmap(struct f2fs_sb_info *sbi)
2917{
2918 struct f2fs_nm_info *nm_i = NM_I(sbi);
2919 unsigned int i = 0;
2920 nid_t nid, last_nid;

--- 263 unchanged lines hidden ---