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

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

141 return true;
142
143 segno = GET_SEGNO(sbi, blkaddr);
144 offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
145 se = get_seg_entry(sbi, segno);
146
147 exist = f2fs_test_bit(offset, se->cur_valid_map);
148 if (!exist && type == DATA_GENERIC_ENHANCE) {
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/checkpoint.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

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

141 return true;
142
143 segno = GET_SEGNO(sbi, blkaddr);
144 offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
145 se = get_seg_entry(sbi, segno);
146
147 exist = f2fs_test_bit(offset, se->cur_valid_map);
148 if (!exist && type == DATA_GENERIC_ENHANCE) {
149 f2fs_msg(sbi->sb, KERN_ERR, "Inconsistent error "
150 "blkaddr:%u, sit bitmap:%d", blkaddr, exist);
149 f2fs_err(sbi, "Inconsistent error blkaddr:%u, sit bitmap:%d",
150 blkaddr, exist);
151 set_sbi_flag(sbi, SBI_NEED_FSCK);
152 WARN_ON(1);
153 }
154 return exist;
155}
156
157bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
158 block_t blkaddr, int type)

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

179 blkaddr < MAIN_BLKADDR(sbi)))
180 return false;
181 break;
182 case DATA_GENERIC:
183 case DATA_GENERIC_ENHANCE:
184 case DATA_GENERIC_ENHANCE_READ:
185 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
186 blkaddr < MAIN_BLKADDR(sbi))) {
151 set_sbi_flag(sbi, SBI_NEED_FSCK);
152 WARN_ON(1);
153 }
154 return exist;
155}
156
157bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
158 block_t blkaddr, int type)

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

179 blkaddr < MAIN_BLKADDR(sbi)))
180 return false;
181 break;
182 case DATA_GENERIC:
183 case DATA_GENERIC_ENHANCE:
184 case DATA_GENERIC_ENHANCE_READ:
185 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
186 blkaddr < MAIN_BLKADDR(sbi))) {
187 f2fs_msg(sbi->sb, KERN_WARNING,
188 "access invalid blkaddr:%u", blkaddr);
187 f2fs_warn(sbi, "access invalid blkaddr:%u",
188 blkaddr);
189 set_sbi_flag(sbi, SBI_NEED_FSCK);
190 WARN_ON(1);
191 return false;
192 } else {
193 return __is_bitmap_valid(sbi, blkaddr, type);
194 }
195 break;
196 case META_GENERIC:

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

652 if (ni.blk_addr != NULL_ADDR) {
653 err = -EIO;
654 goto err_out;
655 }
656 return 0;
657
658err_out:
659 set_sbi_flag(sbi, SBI_NEED_FSCK);
189 set_sbi_flag(sbi, SBI_NEED_FSCK);
190 WARN_ON(1);
191 return false;
192 } else {
193 return __is_bitmap_valid(sbi, blkaddr, type);
194 }
195 break;
196 case META_GENERIC:

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

652 if (ni.blk_addr != NULL_ADDR) {
653 err = -EIO;
654 goto err_out;
655 }
656 return 0;
657
658err_out:
659 set_sbi_flag(sbi, SBI_NEED_FSCK);
660 f2fs_msg(sbi->sb, KERN_WARNING,
661 "%s: orphan failed (ino=%x), run fsck to fix.",
662 __func__, ino);
660 f2fs_warn(sbi, "%s: orphan failed (ino=%x), run fsck to fix.",
661 __func__, ino);
663 return err;
664}
665
666int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi)
667{
668 block_t start_blk, orphan_blocks, i, j;
669 unsigned int s_flags = sbi->sb->s_flags;
670 int err = 0;
671#ifdef CONFIG_QUOTA
672 int quota_enabled;
673#endif
674
675 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
676 return 0;
677
678 if (bdev_read_only(sbi->sb->s_bdev)) {
662 return err;
663}
664
665int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi)
666{
667 block_t start_blk, orphan_blocks, i, j;
668 unsigned int s_flags = sbi->sb->s_flags;
669 int err = 0;
670#ifdef CONFIG_QUOTA
671 int quota_enabled;
672#endif
673
674 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
675 return 0;
676
677 if (bdev_read_only(sbi->sb->s_bdev)) {
679 f2fs_msg(sbi->sb, KERN_INFO, "write access "
680 "unavailable, skipping orphan cleanup");
678 f2fs_info(sbi, "write access unavailable, skipping orphan cleanup");
681 return 0;
682 }
683
684 if (s_flags & SB_RDONLY) {
679 return 0;
680 }
681
682 if (s_flags & SB_RDONLY) {
685 f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");
683 f2fs_info(sbi, "orphan cleanup on readonly fs");
686 sbi->sb->s_flags &= ~SB_RDONLY;
687 }
688
689#ifdef CONFIG_QUOTA
690 /* Needed for iput() to work correctly and not trash data */
691 sbi->sb->s_flags |= SB_ACTIVE;
692
693 /*

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

822 return PTR_ERR(*cp_page);
823
824 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);
825
826 crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
827 if (crc_offset < CP_MIN_CHKSUM_OFFSET ||
828 crc_offset > CP_CHKSUM_OFFSET) {
829 f2fs_put_page(*cp_page, 1);
684 sbi->sb->s_flags &= ~SB_RDONLY;
685 }
686
687#ifdef CONFIG_QUOTA
688 /* Needed for iput() to work correctly and not trash data */
689 sbi->sb->s_flags |= SB_ACTIVE;
690
691 /*

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

820 return PTR_ERR(*cp_page);
821
822 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);
823
824 crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
825 if (crc_offset < CP_MIN_CHKSUM_OFFSET ||
826 crc_offset > CP_CHKSUM_OFFSET) {
827 f2fs_put_page(*cp_page, 1);
830 f2fs_msg(sbi->sb, KERN_WARNING,
831 "invalid crc_offset: %zu", crc_offset);
828 f2fs_warn(sbi, "invalid crc_offset: %zu", crc_offset);
832 return -EINVAL;
833 }
834
835 crc = f2fs_checkpoint_chksum(sbi, *cp_block);
836 if (crc != cur_cp_crc(*cp_block)) {
837 f2fs_put_page(*cp_page, 1);
829 return -EINVAL;
830 }
831
832 crc = f2fs_checkpoint_chksum(sbi, *cp_block);
833 if (crc != cur_cp_crc(*cp_block)) {
834 f2fs_put_page(*cp_page, 1);
838 f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value");
835 f2fs_warn(sbi, "invalid crc value");
839 return -EINVAL;
840 }
841
842 *version = cur_cp_version(*cp_block);
843 return 0;
844}
845
846static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,

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

853
854 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
855 &cp_page_1, version);
856 if (err)
857 return NULL;
858
859 if (le32_to_cpu(cp_block->cp_pack_total_block_count) >
860 sbi->blocks_per_seg) {
836 return -EINVAL;
837 }
838
839 *version = cur_cp_version(*cp_block);
840 return 0;
841}
842
843static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,

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

850
851 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
852 &cp_page_1, version);
853 if (err)
854 return NULL;
855
856 if (le32_to_cpu(cp_block->cp_pack_total_block_count) >
857 sbi->blocks_per_seg) {
861 f2fs_msg(sbi->sb, KERN_WARNING,
862 "invalid cp_pack_total_block_count:%u",
863 le32_to_cpu(cp_block->cp_pack_total_block_count));
858 f2fs_warn(sbi, "invalid cp_pack_total_block_count:%u",
859 le32_to_cpu(cp_block->cp_pack_total_block_count));
864 goto invalid_cp;
865 }
866 pre_version = *version;
867
868 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
869 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
870 &cp_page_2, version);
871 if (err)

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

1554 int err = 0;
1555
1556 if (f2fs_readonly(sbi->sb) || f2fs_hw_is_readonly(sbi))
1557 return -EROFS;
1558
1559 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
1560 if (cpc->reason != CP_PAUSE)
1561 return 0;
860 goto invalid_cp;
861 }
862 pre_version = *version;
863
864 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
865 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
866 &cp_page_2, version);
867 if (err)

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

1550 int err = 0;
1551
1552 if (f2fs_readonly(sbi->sb) || f2fs_hw_is_readonly(sbi))
1553 return -EROFS;
1554
1555 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
1556 if (cpc->reason != CP_PAUSE)
1557 return 0;
1562 f2fs_msg(sbi->sb, KERN_WARNING,
1563 "Start checkpoint disabled!");
1558 f2fs_warn(sbi, "Start checkpoint disabled!");
1564 }
1565 mutex_lock(&sbi->cp_mutex);
1566
1567 if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
1568 ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
1569 ((cpc->reason & CP_DISCARD) && !sbi->discard_blks)))
1570 goto out;
1571 if (unlikely(f2fs_cp_error(sbi))) {

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

1621 f2fs_release_discard_addrs(sbi);
1622 else
1623 f2fs_clear_prefree_segments(sbi, cpc);
1624stop:
1625 unblock_operations(sbi);
1626 stat_inc_cp_count(sbi->stat_info);
1627
1628 if (cpc->reason & CP_RECOVERY)
1559 }
1560 mutex_lock(&sbi->cp_mutex);
1561
1562 if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
1563 ((cpc->reason & CP_FASTBOOT) || (cpc->reason & CP_SYNC) ||
1564 ((cpc->reason & CP_DISCARD) && !sbi->discard_blks)))
1565 goto out;
1566 if (unlikely(f2fs_cp_error(sbi))) {

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

1616 f2fs_release_discard_addrs(sbi);
1617 else
1618 f2fs_clear_prefree_segments(sbi, cpc);
1619stop:
1620 unblock_operations(sbi);
1621 stat_inc_cp_count(sbi->stat_info);
1622
1623 if (cpc->reason & CP_RECOVERY)
1629 f2fs_msg(sbi->sb, KERN_NOTICE,
1630 "checkpoint: version = %llx", ckpt_ver);
1624 f2fs_notice(sbi, "checkpoint: version = %llx", ckpt_ver);
1631
1632 /* do checkpoint periodically */
1633 f2fs_update_time(sbi, CP_TIME);
1634 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
1635out:
1636 mutex_unlock(&sbi->cp_mutex);
1637 return err;
1638}

--- 39 unchanged lines hidden --- 		1625
1626 /* do checkpoint periodically */
1627 f2fs_update_time(sbi, CP_TIME);
1628 trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
1629out:
1630 mutex_unlock(&sbi->cp_mutex);
1631 return err;
1632}

--- 39 unchanged lines hidden ---