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

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

1752 sector_t sector, nr_sects;
1753 block_t lblkstart = blkstart;
1754 int devi = 0;
1755
1756 if (f2fs_is_multi_device(sbi)) {
1757 devi = f2fs_target_device_index(sbi, blkstart);
1758 if (blkstart < FDEV(devi).start_blk ||
1759 blkstart > FDEV(devi).end_blk) {
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/segment.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

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

1752 sector_t sector, nr_sects;
1753 block_t lblkstart = blkstart;
1754 int devi = 0;
1755
1756 if (f2fs_is_multi_device(sbi)) {
1757 devi = f2fs_target_device_index(sbi, blkstart);
1758 if (blkstart < FDEV(devi).start_blk ||
1759 blkstart > FDEV(devi).end_blk) {
1760 f2fs_msg(sbi->sb, KERN_ERR, "Invalid block %x",
1761 blkstart);
1760 f2fs_err(sbi, "Invalid block %x", blkstart);
1762 return -EIO;
1763 }
1764 blkstart -= FDEV(devi).start_blk;
1765 }
1766
1767 /* For sequential zones, reset the zone write pointer */
1768 if (f2fs_blkz_is_seq(sbi, devi, blkstart)) {
1769 sector = SECTOR_FROM_BLOCK(blkstart);
1770 nr_sects = SECTOR_FROM_BLOCK(blklen);
1771
1772 if (sector & (bdev_zone_sectors(bdev) - 1) ||
1773 nr_sects != bdev_zone_sectors(bdev)) {
1761 return -EIO;
1762 }
1763 blkstart -= FDEV(devi).start_blk;
1764 }
1765
1766 /* For sequential zones, reset the zone write pointer */
1767 if (f2fs_blkz_is_seq(sbi, devi, blkstart)) {
1768 sector = SECTOR_FROM_BLOCK(blkstart);
1769 nr_sects = SECTOR_FROM_BLOCK(blklen);
1770
1771 if (sector & (bdev_zone_sectors(bdev) - 1) ||
1772 nr_sects != bdev_zone_sectors(bdev)) {
1774 f2fs_msg(sbi->sb, KERN_ERR,
1775 "(%d) %s: Unaligned zone reset attempted (block %x + %x)",
1776 devi, sbi->s_ndevs ? FDEV(devi).path: "",
1777 blkstart, blklen);
1773 f2fs_err(sbi, "(%d) %s: Unaligned zone reset attempted (block %x + %x)",
1774 devi, sbi->s_ndevs ? FDEV(devi).path : "",
1775 blkstart, blklen);
1778 return -EIO;
1779 }
1780 trace_f2fs_issue_reset_zone(bdev, blkstart);
1781 return blkdev_reset_zones(bdev, sector, nr_sects, GFP_NOFS);
1782 }
1783
1784 /* For conventional zones, use regular discard if supported */
1785 return __queue_discard_cmd(sbi, bdev, lblkstart, blklen);

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

2133
2134 /* Update valid block bitmap */
2135 if (del > 0) {
2136 exist = f2fs_test_and_set_bit(offset, se->cur_valid_map);
2137#ifdef CONFIG_F2FS_CHECK_FS
2138 mir_exist = f2fs_test_and_set_bit(offset,
2139 se->cur_valid_map_mir);
2140 if (unlikely(exist != mir_exist)) {
1776 return -EIO;
1777 }
1778 trace_f2fs_issue_reset_zone(bdev, blkstart);
1779 return blkdev_reset_zones(bdev, sector, nr_sects, GFP_NOFS);
1780 }
1781
1782 /* For conventional zones, use regular discard if supported */
1783 return __queue_discard_cmd(sbi, bdev, lblkstart, blklen);

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

2131
2132 /* Update valid block bitmap */
2133 if (del > 0) {
2134 exist = f2fs_test_and_set_bit(offset, se->cur_valid_map);
2135#ifdef CONFIG_F2FS_CHECK_FS
2136 mir_exist = f2fs_test_and_set_bit(offset,
2137 se->cur_valid_map_mir);
2138 if (unlikely(exist != mir_exist)) {
2141 f2fs_msg(sbi->sb, KERN_ERR, "Inconsistent error "
2142 "when setting bitmap, blk:%u, old bit:%d",
2143 blkaddr, exist);
2139 f2fs_err(sbi, "Inconsistent error when setting bitmap, blk:%u, old bit:%d",
2140 blkaddr, exist);
2144 f2fs_bug_on(sbi, 1);
2145 }
2146#endif
2147 if (unlikely(exist)) {
2141 f2fs_bug_on(sbi, 1);
2142 }
2143#endif
2144 if (unlikely(exist)) {
2148 f2fs_msg(sbi->sb, KERN_ERR,
2149 "Bitmap was wrongly set, blk:%u", blkaddr);
2145 f2fs_err(sbi, "Bitmap was wrongly set, blk:%u",
2146 blkaddr);
2150 f2fs_bug_on(sbi, 1);
2151 se->valid_blocks--;
2152 del = 0;
2153 }
2154
2155 if (!f2fs_test_and_set_bit(offset, se->discard_map))
2156 sbi->discard_blks--;
2157

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

2162 se->ckpt_valid_blocks++;
2163 }
2164 } else {
2165 exist = f2fs_test_and_clear_bit(offset, se->cur_valid_map);
2166#ifdef CONFIG_F2FS_CHECK_FS
2167 mir_exist = f2fs_test_and_clear_bit(offset,
2168 se->cur_valid_map_mir);
2169 if (unlikely(exist != mir_exist)) {
2147 f2fs_bug_on(sbi, 1);
2148 se->valid_blocks--;
2149 del = 0;
2150 }
2151
2152 if (!f2fs_test_and_set_bit(offset, se->discard_map))
2153 sbi->discard_blks--;
2154

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

2159 se->ckpt_valid_blocks++;
2160 }
2161 } else {
2162 exist = f2fs_test_and_clear_bit(offset, se->cur_valid_map);
2163#ifdef CONFIG_F2FS_CHECK_FS
2164 mir_exist = f2fs_test_and_clear_bit(offset,
2165 se->cur_valid_map_mir);
2166 if (unlikely(exist != mir_exist)) {
2170 f2fs_msg(sbi->sb, KERN_ERR, "Inconsistent error "
2171 "when clearing bitmap, blk:%u, old bit:%d",
2172 blkaddr, exist);
2167 f2fs_err(sbi, "Inconsistent error when clearing bitmap, blk:%u, old bit:%d",
2168 blkaddr, exist);
2173 f2fs_bug_on(sbi, 1);
2174 }
2175#endif
2176 if (unlikely(!exist)) {
2169 f2fs_bug_on(sbi, 1);
2170 }
2171#endif
2172 if (unlikely(!exist)) {
2177 f2fs_msg(sbi->sb, KERN_ERR,
2178 "Bitmap was wrongly cleared, blk:%u", blkaddr);
2173 f2fs_err(sbi, "Bitmap was wrongly cleared, blk:%u",
2174 blkaddr);
2179 f2fs_bug_on(sbi, 1);
2180 se->valid_blocks++;
2181 del = 0;
2182 } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2183 /*
2184 * If checkpoints are off, we must not reuse data that
2185 * was used in the previous checkpoint. If it was used
2186 * before, we must track that to know how much space we

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

2678
2679 stat_inc_seg_type(sbi, curseg);
2680
2681 locate_dirty_segment(sbi, segno);
2682unlock:
2683 up_write(&SIT_I(sbi)->sentry_lock);
2684
2685 if (segno != curseg->segno)
2175 f2fs_bug_on(sbi, 1);
2176 se->valid_blocks++;
2177 del = 0;
2178 } else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2179 /*
2180 * If checkpoints are off, we must not reuse data that
2181 * was used in the previous checkpoint. If it was used
2182 * before, we must track that to know how much space we

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

2674
2675 stat_inc_seg_type(sbi, curseg);
2676
2677 locate_dirty_segment(sbi, segno);
2678unlock:
2679 up_write(&SIT_I(sbi)->sentry_lock);
2680
2681 if (segno != curseg->segno)
2686 f2fs_msg(sbi->sb, KERN_NOTICE,
2687 "For resize: curseg of type %d: %u ==> %u",
2688 type, segno, curseg->segno);
2682 f2fs_notice(sbi, "For resize: curseg of type %d: %u ==> %u",
2683 type, segno, curseg->segno);
2689
2690 mutex_unlock(&curseg->curseg_mutex);
2691 up_read(&SM_I(sbi)->curseg_lock);
2692}
2693
2694void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi)
2695{
2696 struct curseg_info *curseg;

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

2818
2819 if (start >= MAX_BLKADDR(sbi) || range->len < sbi->blocksize)
2820 return -EINVAL;
2821
2822 if (end < MAIN_BLKADDR(sbi))
2823 goto out;
2824
2825 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {
2684
2685 mutex_unlock(&curseg->curseg_mutex);
2686 up_read(&SM_I(sbi)->curseg_lock);
2687}
2688
2689void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi)
2690{
2691 struct curseg_info *curseg;

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

2813
2814 if (start >= MAX_BLKADDR(sbi) || range->len < sbi->blocksize)
2815 return -EINVAL;
2816
2817 if (end < MAIN_BLKADDR(sbi))
2818 goto out;
2819
2820 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {
2826 f2fs_msg(sbi->sb, KERN_WARNING,
2827 "Found FS corruption, run fsck to fix.");
2821 f2fs_warn(sbi, "Found FS corruption, run fsck to fix.");
2828 return -EIO;
2829 }
2830
2831 /* start/end segment number in main_area */
2832 start_segno = (start <= MAIN_BLKADDR(sbi)) ? 0 : GET_SEGNO(sbi, start);
2833 end_segno = (end >= MAX_BLKADDR(sbi)) ? MAIN_SEGS(sbi) - 1 :
2834 GET_SEGNO(sbi, end);
2835 if (need_align) {

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

3580 err = read_normal_summaries(sbi, type);
3581 if (err)
3582 return err;
3583 }
3584
3585 /* sanity check for summary blocks */
3586 if (nats_in_cursum(nat_j) > NAT_JOURNAL_ENTRIES ||
3587 sits_in_cursum(sit_j) > SIT_JOURNAL_ENTRIES) {
2822 return -EIO;
2823 }
2824
2825 /* start/end segment number in main_area */
2826 start_segno = (start <= MAIN_BLKADDR(sbi)) ? 0 : GET_SEGNO(sbi, start);
2827 end_segno = (end >= MAX_BLKADDR(sbi)) ? MAIN_SEGS(sbi) - 1 :
2828 GET_SEGNO(sbi, end);
2829 if (need_align) {

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

3574 err = read_normal_summaries(sbi, type);
3575 if (err)
3576 return err;
3577 }
3578
3579 /* sanity check for summary blocks */
3580 if (nats_in_cursum(nat_j) > NAT_JOURNAL_ENTRIES ||
3581 sits_in_cursum(sit_j) > SIT_JOURNAL_ENTRIES) {
3588 f2fs_msg(sbi->sb, KERN_ERR,
3589 "invalid journal entries nats %u sits %u\n",
3590 nats_in_cursum(nat_j), sits_in_cursum(sit_j));
3582 f2fs_err(sbi, "invalid journal entries nats %u sits %u\n",
3583 nats_in_cursum(nat_j), sits_in_cursum(sit_j));
3591 return -EINVAL;
3592 }
3593
3594 return 0;
3595}
3596
3597static void write_compacted_summaries(struct f2fs_sb_info *sbi, block_t blkaddr)
3598{

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

4150 } while (start_blk < sit_blk_cnt);
4151
4152 down_read(&curseg->journal_rwsem);
4153 for (i = 0; i < sits_in_cursum(journal); i++) {
4154 unsigned int old_valid_blocks;
4155
4156 start = le32_to_cpu(segno_in_journal(journal, i));
4157 if (start >= MAIN_SEGS(sbi)) {
3584 return -EINVAL;
3585 }
3586
3587 return 0;
3588}
3589
3590static void write_compacted_summaries(struct f2fs_sb_info *sbi, block_t blkaddr)
3591{

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

4143 } while (start_blk < sit_blk_cnt);
4144
4145 down_read(&curseg->journal_rwsem);
4146 for (i = 0; i < sits_in_cursum(journal); i++) {
4147 unsigned int old_valid_blocks;
4148
4149 start = le32_to_cpu(segno_in_journal(journal, i));
4150 if (start >= MAIN_SEGS(sbi)) {
4158 f2fs_msg(sbi->sb, KERN_ERR,
4159 "Wrong journal entry on segno %u",
4160 start);
4151 f2fs_err(sbi, "Wrong journal entry on segno %u",
4152 start);
4161 set_sbi_flag(sbi, SBI_NEED_FSCK);
4162 err = -EINVAL;
4163 break;
4164 }
4165
4166 se = &sit_i->sentries[start];
4167 sit = sit_in_journal(journal, i);
4168

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

4191 se->valid_blocks;
4192 get_sec_entry(sbi, start)->valid_blocks -=
4193 old_valid_blocks;
4194 }
4195 }
4196 up_read(&curseg->journal_rwsem);
4197
4198 if (!err && total_node_blocks != valid_node_count(sbi)) {
4153 set_sbi_flag(sbi, SBI_NEED_FSCK);
4154 err = -EINVAL;
4155 break;
4156 }
4157
4158 se = &sit_i->sentries[start];
4159 sit = sit_in_journal(journal, i);
4160

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

4183 se->valid_blocks;
4184 get_sec_entry(sbi, start)->valid_blocks -=
4185 old_valid_blocks;
4186 }
4187 }
4188 up_read(&curseg->journal_rwsem);
4189
4190 if (!err && total_node_blocks != valid_node_count(sbi)) {
4199 f2fs_msg(sbi->sb, KERN_ERR,
4200 "SIT is corrupted node# %u vs %u",
4201 total_node_blocks, valid_node_count(sbi));
4191 f2fs_err(sbi, "SIT is corrupted node# %u vs %u",
4192 total_node_blocks, valid_node_count(sbi));
4202 set_sbi_flag(sbi, SBI_NEED_FSCK);
4203 err = -EINVAL;
4204 }
4205
4206 return err;
4207}
4208
4209static void init_free_segmap(struct f2fs_sb_info *sbi)

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

4309
4310 if (curseg->alloc_type == SSR)
4311 continue;
4312
4313 for (blkofs += 1; blkofs < sbi->blocks_per_seg; blkofs++) {
4314 if (!f2fs_test_bit(blkofs, se->cur_valid_map))
4315 continue;
4316out:
4193 set_sbi_flag(sbi, SBI_NEED_FSCK);
4194 err = -EINVAL;
4195 }
4196
4197 return err;
4198}
4199
4200static void init_free_segmap(struct f2fs_sb_info *sbi)

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

4300
4301 if (curseg->alloc_type == SSR)
4302 continue;
4303
4304 for (blkofs += 1; blkofs < sbi->blocks_per_seg; blkofs++) {
4305 if (!f2fs_test_bit(blkofs, se->cur_valid_map))
4306 continue;
4307out:
4317 f2fs_msg(sbi->sb, KERN_ERR,
4318 "Current segment's next free block offset is "
4319 "inconsistent with bitmap, logtype:%u, "
4320 "segno:%u, type:%u, next_blkoff:%u, blkofs:%u",
4321 i, curseg->segno, curseg->alloc_type,
4322 curseg->next_blkoff, blkofs);
4308 f2fs_err(sbi,
4309 "Current segment's next free block offset is inconsistent with bitmap, logtype:%u, segno:%u, type:%u, next_blkoff:%u, blkofs:%u",
4310 i, curseg->segno, curseg->alloc_type,
4311 curseg->next_blkoff, blkofs);
4323 return -EINVAL;
4324 }
4325 }
4326 return 0;
4327}
4328
4329/*
4330 * Update min, max modified time for cost-benefit GC algorithm

--- 249 unchanged lines hidden --- 		4312 return -EINVAL;
4313 }
4314 }
4315 return 0;
4316}
4317
4318/*
4319 * Update min, max modified time for cost-benefit GC algorithm

--- 249 unchanged lines hidden ---