Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

f2fs: introduce is_cur{seg,sec}() 

There are redundant codes in IS_CUR{SEG,SEC}() macros, let's introduce
inline is_cur{seg,sec}() functions, and use a loop in it for cleanup.

Meanwhile, it enhances expansibility, as it doesn't need to change
is_cur{seg,sec}() when we add a new log header.

Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
This commit is contained in:
Chao Yu 2025-07-07 19:46:14 +08:00 committed by Jaegeuk Kim
parent a509a55f8e
commit c1cfc87e49
4 changed files with 38 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/f2fs/debug.c
View File

@ -91,7 +91,7 @@ static void update_multidevice_stats(struct f2fs_sb_info *sbi)
seg_blks = get_seg_entry(sbi, j)->valid_blocks; seg_blks = get_seg_entry(sbi, j)->valid_blocks;
/* update segment stats */ /* update segment stats */
if (IS_CURSEG(sbi, j)) if (is_curseg(sbi, j))
dev_stats[i].devstats[0][DEVSTAT_INUSE]++; dev_stats[i].devstats[0][DEVSTAT_INUSE]++;
else if (seg_blks == BLKS_PER_SEG(sbi)) else if (seg_blks == BLKS_PER_SEG(sbi))
dev_stats[i].devstats[0][DEVSTAT_FULL]++; dev_stats[i].devstats[0][DEVSTAT_FULL]++;
@ -109,7 +109,7 @@ static void update_multidevice_stats(struct f2fs_sb_info *sbi)
sec_blks = get_sec_entry(sbi, j)->valid_blocks; sec_blks = get_sec_entry(sbi, j)->valid_blocks;
/* update section stats */ /* update section stats */
if (IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, j))) if (is_cursec(sbi, GET_SEC_FROM_SEG(sbi, j)))
dev_stats[i].devstats[1][DEVSTAT_INUSE]++; dev_stats[i].devstats[1][DEVSTAT_INUSE]++;
else if (sec_blks == BLKS_PER_SEC(sbi)) else if (sec_blks == BLKS_PER_SEC(sbi))
dev_stats[i].devstats[1][DEVSTAT_FULL]++; dev_stats[i].devstats[1][DEVSTAT_FULL]++;

2
fs/f2fs/gc.c
View File

@ -2065,7 +2065,7 @@ int f2fs_gc_range(struct f2fs_sb_info *sbi,
.iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS), .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS),
}; };
if (IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, segno))) if (is_cursec(sbi, GET_SEC_FROM_SEG(sbi, segno)))
continue; continue;
do_garbage_collect(sbi, segno, &gc_list, FG_GC, true, false); do_garbage_collect(sbi, segno, &gc_list, FG_GC, true, false);

22
fs/f2fs/segment.c
View File

@ -773,7 +773,7 @@ static void __locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
/* need not be added */ /* need not be added */
if (IS_CURSEG(sbi, segno)) if (is_curseg(sbi, segno))
return; return;
if (!test_and_set_bit(segno, dirty_i->dirty_segmap[dirty_type])) if (!test_and_set_bit(segno, dirty_i->dirty_segmap[dirty_type]))
@ -800,7 +800,7 @@ static void __locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
!valid_blocks) || !valid_blocks) ||
valid_blocks == CAP_BLKS_PER_SEC(sbi)); valid_blocks == CAP_BLKS_PER_SEC(sbi));
if (!IS_CURSEC(sbi, secno)) if (!is_cursec(sbi, secno))
set_bit(secno, dirty_i->dirty_secmap); set_bit(secno, dirty_i->dirty_secmap);
} }
} }
@ -839,7 +839,7 @@ static void __remove_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
return; return;
} }
if (!IS_CURSEC(sbi, secno)) if (!is_cursec(sbi, secno))
set_bit(secno, dirty_i->dirty_secmap); set_bit(secno, dirty_i->dirty_secmap);
} }
} }
@ -856,7 +856,7 @@ static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
unsigned short valid_blocks, ckpt_valid_blocks; unsigned short valid_blocks, ckpt_valid_blocks;
unsigned int usable_blocks; unsigned int usable_blocks;
if (segno == NULL_SEGNO || IS_CURSEG(sbi, segno)) if (segno == NULL_SEGNO || is_curseg(sbi, segno))
return; return;
usable_blocks = f2fs_usable_blks_in_seg(sbi, segno); usable_blocks = f2fs_usable_blks_in_seg(sbi, segno);
@ -889,7 +889,7 @@ void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi)
for_each_set_bit(segno, dirty_i->dirty_segmap[DIRTY], MAIN_SEGS(sbi)) { for_each_set_bit(segno, dirty_i->dirty_segmap[DIRTY], MAIN_SEGS(sbi)) {
if (get_valid_blocks(sbi, segno, false)) if (get_valid_blocks(sbi, segno, false))
continue; continue;
if (IS_CURSEG(sbi, segno)) if (is_curseg(sbi, segno))
continue; continue;
__locate_dirty_segment(sbi, segno, PRE); __locate_dirty_segment(sbi, segno, PRE);
__remove_dirty_segment(sbi, segno, DIRTY); __remove_dirty_segment(sbi, segno, DIRTY);
@ -2108,7 +2108,7 @@ static bool add_discard_addrs(struct f2fs_sb_info *sbi, struct cp_control *cpc,
if (!force) { if (!force) {
if (!f2fs_realtime_discard_enable(sbi) || if (!f2fs_realtime_discard_enable(sbi) ||
(!se->valid_blocks && (!se->valid_blocks &&
!IS_CURSEG(sbi, cpc->trim_start)) || !is_curseg(sbi, cpc->trim_start)) ||
SM_I(sbi)->dcc_info->nr_discards >= SM_I(sbi)->dcc_info->nr_discards >=
SM_I(sbi)->dcc_info->max_discards) SM_I(sbi)->dcc_info->max_discards)
return false; return false;
@ -2236,7 +2236,7 @@ void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
next: next:
secno = GET_SEC_FROM_SEG(sbi, start); secno = GET_SEC_FROM_SEG(sbi, start);
start_segno = GET_SEG_FROM_SEC(sbi, secno); start_segno = GET_SEG_FROM_SEC(sbi, secno);
if (!IS_CURSEC(sbi, secno) && if (!is_cursec(sbi, secno) &&
!get_valid_blocks(sbi, start, true)) !get_valid_blocks(sbi, start, true))
f2fs_issue_discard(sbi, START_BLOCK(sbi, start_segno), f2fs_issue_discard(sbi, START_BLOCK(sbi, start_segno),
BLKS_PER_SEC(sbi)); BLKS_PER_SEC(sbi));
@ -4107,14 +4107,14 @@ void f2fs_do_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
if (!recover_curseg) { if (!recover_curseg) {
/* for recovery flow */ /* for recovery flow */
if (se->valid_blocks == 0 && !IS_CURSEG(sbi, segno)) { if (se->valid_blocks == 0 && !is_curseg(sbi, segno)) {
if (old_blkaddr == NULL_ADDR) if (old_blkaddr == NULL_ADDR)
type = CURSEG_COLD_DATA; type = CURSEG_COLD_DATA;
else else
type = CURSEG_WARM_DATA; type = CURSEG_WARM_DATA;
} }
} else { } else {
if (IS_CURSEG(sbi, segno)) { if (is_curseg(sbi, segno)) {
/* se->type is volatile as SSR allocation */ /* se->type is volatile as SSR allocation */
type = __f2fs_get_curseg(sbi, segno); type = __f2fs_get_curseg(sbi, segno);
f2fs_bug_on(sbi, type == NO_CHECK_TYPE); f2fs_bug_on(sbi, type == NO_CHECK_TYPE);
@ -5150,7 +5150,7 @@ static void init_dirty_segmap(struct f2fs_sb_info *sbi)
if (!valid_blocks || valid_blocks == CAP_BLKS_PER_SEC(sbi)) if (!valid_blocks || valid_blocks == CAP_BLKS_PER_SEC(sbi))
continue; continue;
if (IS_CURSEC(sbi, secno)) if (is_cursec(sbi, secno))
continue; continue;
set_bit(secno, dirty_i->dirty_secmap); set_bit(secno, dirty_i->dirty_secmap);
} }
@ -5286,7 +5286,7 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
* Get # of valid block of the zone. * Get # of valid block of the zone.
*/ */
valid_block_cnt = get_valid_blocks(sbi, zone_segno, true); valid_block_cnt = get_valid_blocks(sbi, zone_segno, true);
if (IS_CURSEC(sbi, GET_SEC_FROM_SEG(sbi, zone_segno))) { if (is_cursec(sbi, GET_SEC_FROM_SEG(sbi, zone_segno))) {
f2fs_notice(sbi, "Open zones: valid block[0x%x,0x%x] cond[%s]", f2fs_notice(sbi, "Open zones: valid block[0x%x,0x%x] cond[%s]",
zone_segno, valid_block_cnt, zone_segno, valid_block_cnt,
blk_zone_cond_str(zone->cond)); blk_zone_cond_str(zone->cond));

54
fs/f2fs/segment.h
View File

@ -34,34 +34,6 @@ static inline void sanity_check_seg_type(struct f2fs_sb_info *sbi,
f2fs_bug_on(sbi, seg_type >= NR_PERSISTENT_LOG); f2fs_bug_on(sbi, seg_type >= NR_PERSISTENT_LOG);
} }
#define IS_CURSEG(sbi, seg) \
(((seg) == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_COLD_DATA_PINNED)->segno) || \
((seg) == CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC)->segno))
#define IS_CURSEC(sbi, secno) \
(((secno) == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_COLD_DATA_PINNED)->segno / \
SEGS_PER_SEC(sbi)) || \
((secno) == CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC)->segno / \
SEGS_PER_SEC(sbi)))
#define MAIN_BLKADDR(sbi) \ #define MAIN_BLKADDR(sbi) \
(SM_I(sbi) ? SM_I(sbi)->main_blkaddr : \ (SM_I(sbi) ? SM_I(sbi)->main_blkaddr : \
le32_to_cpu(F2FS_RAW_SUPER(sbi)->main_blkaddr)) le32_to_cpu(F2FS_RAW_SUPER(sbi)->main_blkaddr))
@ -318,6 +290,28 @@ static inline struct curseg_info *CURSEG_I(struct f2fs_sb_info *sbi, int type)
return (struct curseg_info *)(SM_I(sbi)->curseg_array + type); return (struct curseg_info *)(SM_I(sbi)->curseg_array + type);
} }
static inline bool is_curseg(struct f2fs_sb_info *sbi, unsigned int segno)
{
int i;
for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
if (segno == CURSEG_I(sbi, i)->segno)
return true;
}
return false;
}
static inline bool is_cursec(struct f2fs_sb_info *sbi, unsigned int secno)
{
int i;
for (i = CURSEG_HOT_DATA; i < NO_CHECK_TYPE; i++) {
if (secno == GET_SEC_FROM_SEG(sbi, CURSEG_I(sbi, i)->segno))
return true;
}
return false;
}
static inline struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi, static inline struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
unsigned int segno) unsigned int segno)
{ {
@ -509,7 +503,7 @@ static inline void __set_test_and_free(struct f2fs_sb_info *sbi,
free_i->free_segments++; free_i->free_segments++;
if (!inmem && IS_CURSEC(sbi, secno)) if (!inmem && is_cursec(sbi, secno))
goto unlock_out; goto unlock_out;
/* check large section */ /* check large section */
@ -986,7 +980,7 @@ static inline block_t sum_blk_addr(struct f2fs_sb_info *sbi, int base, int type)
static inline bool sec_usage_check(struct f2fs_sb_info *sbi, unsigned int secno) static inline bool sec_usage_check(struct f2fs_sb_info *sbi, unsigned int secno)
{ {
if (IS_CURSEC(sbi, secno) || (sbi->cur_victim_sec == secno)) if (is_cursec(sbi, secno) || (sbi->cur_victim_sec == secno))
return true; return true;
return false; return false;
} }