p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

f2fs: clean up some macros in terms of GET_SEGNO 

This patch cleans several macros by introducing:
- BLKS_PER_SEC
- GET_SEC_FROM_SEG
- GET_SEG_FROM_SEC
- GET_ZONE_FROM_SEC
- GET_ZONE_FROM_SEG

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
This commit is contained in:
Jaegeuk Kim 2017-04-07 15:08:17 -07:00
parent 302bd34882
commit 4ddb1a4d4d
6 changed files with 45 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/f2fs/debug.c
View File

@ -109,8 +109,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_NODE; i++) { for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_NODE; i++) {
struct curseg_info *curseg = CURSEG_I(sbi, i); struct curseg_info *curseg = CURSEG_I(sbi, i);
si->curseg[i] = curseg->segno; si->curseg[i] = curseg->segno;
si->cursec[i] = curseg->segno / sbi->segs_per_sec; si->cursec[i] = GET_SEC_FROM_SEG(sbi, curseg->segno);
si->curzone[i] = si->cursec[i] / sbi->secs_per_zone; si->curzone[i] = GET_ZONE_FROM_SEC(sbi, si->cursec[i]);
} }
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
@ -134,7 +134,7 @@ static void update_sit_info(struct f2fs_sb_info *sbi)
bimodal = 0; bimodal = 0;
total_vblocks = 0; total_vblocks = 0;
blks_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg; blks_per_sec = BLKS_PER_SEC(sbi);
hblks_per_sec = blks_per_sec / 2; hblks_per_sec = blks_per_sec / 2;
for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) { for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
vblocks = get_valid_blocks(sbi, segno, true); vblocks = get_valid_blocks(sbi, segno, true);

7
fs/f2fs/f2fs.h
View File

@ -135,12 +135,11 @@ enum {
#define DEF_BATCHED_TRIM_SECTIONS 2048 #define DEF_BATCHED_TRIM_SECTIONS 2048
#define BATCHED_TRIM_SEGMENTS(sbi) \ #define BATCHED_TRIM_SEGMENTS(sbi) \
(SM_I(sbi)->trim_sections * (sbi)->segs_per_sec) (GET_SEG_FROM_SEC(sbi, SM_I(sbi)->trim_sections))
#define BATCHED_TRIM_BLOCKS(sbi) \ #define BATCHED_TRIM_BLOCKS(sbi) \
(BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg) (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
#define MAX_DISCARD_BLOCKS(sbi) \ #define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
((1 << (sbi)->log_blocks_per_seg) * (sbi)->segs_per_sec) #define DISCARD_ISSUE_RATE 8
#define DISCARD_ISSUE_RATE 8
#define DEF_CP_INTERVAL 60 /* 60 secs */ #define DEF_CP_INTERVAL 60 /* 60 secs */
#define DEF_IDLE_INTERVAL 5 /* 5 secs */ #define DEF_IDLE_INTERVAL 5 /* 5 secs */

3
fs/f2fs/file.c
View File

@ -1892,7 +1892,6 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
pgoff_t pg_start, pg_end; pgoff_t pg_start, pg_end;
unsigned int blk_per_seg = sbi->blocks_per_seg; unsigned int blk_per_seg = sbi->blocks_per_seg;
unsigned int total = 0, sec_num; unsigned int total = 0, sec_num;
unsigned int pages_per_sec = sbi->segs_per_sec * blk_per_seg;
block_t blk_end = 0; block_t blk_end = 0;
bool fragmented = false; bool fragmented = false;
int err; int err;
@ -1956,7 +1955,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
map.m_lblk = pg_start; map.m_lblk = pg_start;
map.m_len = pg_end - pg_start; map.m_len = pg_end - pg_start;
sec_num = (map.m_len + pages_per_sec - 1) / pages_per_sec; sec_num = (map.m_len + BLKS_PER_SEC(sbi) - 1) / BLKS_PER_SEC(sbi);
/* /*
* make sure there are enough free section for LFS allocation, this can * make sure there are enough free section for LFS allocation, this can

17
fs/f2fs/gc.c
View File

@ -211,7 +211,7 @@ static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
continue; continue;
clear_bit(secno, dirty_i->victim_secmap); clear_bit(secno, dirty_i->victim_secmap);
return secno * sbi->segs_per_sec; return GET_SEG_FROM_SEC(sbi, secno);
} }
return NULL_SEGNO; return NULL_SEGNO;
} }
@ -219,8 +219,8 @@ static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno) static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno)
{ {
struct sit_info *sit_i = SIT_I(sbi); struct sit_info *sit_i = SIT_I(sbi);
unsigned int secno = GET_SECNO(sbi, segno); unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
unsigned int start = secno * sbi->segs_per_sec; unsigned int start = GET_SEG_FROM_SEC(sbi, secno);
unsigned long long mtime = 0; unsigned long long mtime = 0;
unsigned int vblocks; unsigned int vblocks;
unsigned char age = 0; unsigned char age = 0;
@ -343,7 +343,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
nsearched++; nsearched++;
} }
secno = GET_SECNO(sbi, segno); secno = GET_SEC_FROM_SEG(sbi, segno);
if (sec_usage_check(sbi, secno)) if (sec_usage_check(sbi, secno))
goto next; goto next;
@ -372,7 +372,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
if (p.min_segno != NULL_SEGNO) { if (p.min_segno != NULL_SEGNO) {
got_it: got_it:
if (p.alloc_mode == LFS) { if (p.alloc_mode == LFS) {
secno = GET_SECNO(sbi, p.min_segno); secno = GET_SEC_FROM_SEG(sbi, p.min_segno);
if (gc_type == FG_GC) if (gc_type == FG_GC)
sbi->cur_victim_sec = secno; sbi->cur_victim_sec = secno;
else else
@ -1006,7 +1006,7 @@ int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background)
void build_gc_manager(struct f2fs_sb_info *sbi) void build_gc_manager(struct f2fs_sb_info *sbi)
{ {
u64 main_count, resv_count, ovp_count, blocks_per_sec; u64 main_count, resv_count, ovp_count;
DIRTY_I(sbi)->v_ops = &default_v_ops; DIRTY_I(sbi)->v_ops = &default_v_ops;
@ -1014,8 +1014,7 @@ void build_gc_manager(struct f2fs_sb_info *sbi)
main_count = SM_I(sbi)->main_segments << sbi->log_blocks_per_seg; main_count = SM_I(sbi)->main_segments << sbi->log_blocks_per_seg;
resv_count = SM_I(sbi)->reserved_segments << sbi->log_blocks_per_seg; resv_count = SM_I(sbi)->reserved_segments << sbi->log_blocks_per_seg;
ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg; ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg;
blocks_per_sec = sbi->blocks_per_seg * sbi->segs_per_sec;
sbi->fggc_threshold = div64_u64((main_count - ovp_count) * blocks_per_sec, sbi->fggc_threshold = div64_u64((main_count - ovp_count) *
(main_count - resv_count)); BLKS_PER_SEC(sbi), (main_count - resv_count));
} }

20
fs/f2fs/segment.c
View File

@ -637,7 +637,7 @@ static void __remove_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
dirty_i->nr_dirty[t]--; dirty_i->nr_dirty[t]--;
if (get_valid_blocks(sbi, segno, true) == 0) if (get_valid_blocks(sbi, segno, true) == 0)
clear_bit(GET_SECNO(sbi, segno), clear_bit(GET_SEC_FROM_SEG(sbi, segno),
dirty_i->victim_secmap); dirty_i->victim_secmap);
} }
} }
@ -1106,8 +1106,8 @@ void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc)
continue; continue;
} }
next: next:
secno = GET_SECNO(sbi, start); secno = GET_SEC_FROM_SEG(sbi, start);
start_segno = secno * sbi->segs_per_sec; 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),
@ -1462,8 +1462,8 @@ static void get_new_segment(struct f2fs_sb_info *sbi,
struct free_segmap_info *free_i = FREE_I(sbi); struct free_segmap_info *free_i = FREE_I(sbi);
unsigned int segno, secno, zoneno; unsigned int segno, secno, zoneno;
unsigned int total_zones = MAIN_SECS(sbi) / sbi->secs_per_zone; unsigned int total_zones = MAIN_SECS(sbi) / sbi->secs_per_zone;
unsigned int hint = *newseg / sbi->segs_per_sec; unsigned int hint = GET_SEC_FROM_SEG(sbi, *newseg);
unsigned int old_zoneno = GET_ZONENO_FROM_SEGNO(sbi, *newseg); unsigned int old_zoneno = GET_ZONE_FROM_SEG(sbi, *newseg);
unsigned int left_start = hint; unsigned int left_start = hint;
bool init = true; bool init = true;
int go_left = 0; int go_left = 0;
@ -1473,8 +1473,8 @@ static void get_new_segment(struct f2fs_sb_info *sbi,
if (!new_sec && ((*newseg + 1) % sbi->segs_per_sec)) { if (!new_sec && ((*newseg + 1) % sbi->segs_per_sec)) {
segno = find_next_zero_bit(free_i->free_segmap, segno = find_next_zero_bit(free_i->free_segmap,
(hint + 1) * sbi->segs_per_sec, *newseg + 1); GET_SEG_FROM_SEC(sbi, hint + 1), *newseg + 1);
if (segno < (hint + 1) * sbi->segs_per_sec) if (segno < GET_SEG_FROM_SEC(sbi, hint + 1))
goto got_it; goto got_it;
} }
find_other_zone: find_other_zone:
@ -1505,8 +1505,8 @@ static void get_new_segment(struct f2fs_sb_info *sbi,
secno = left_start; secno = left_start;
skip_left: skip_left:
hint = secno; hint = secno;
segno = secno * sbi->segs_per_sec; segno = GET_SEG_FROM_SEC(sbi, secno);
zoneno = secno / sbi->secs_per_zone; zoneno = GET_ZONE_FROM_SEC(sbi, secno);
/* give up on finding another zone */ /* give up on finding another zone */
if (!init) if (!init)
@ -1550,7 +1550,7 @@ static void reset_curseg(struct f2fs_sb_info *sbi, int type, int modified)
struct summary_footer *sum_footer; struct summary_footer *sum_footer;
curseg->segno = curseg->next_segno; curseg->segno = curseg->next_segno;
curseg->zone = GET_ZONENO_FROM_SEGNO(sbi, curseg->segno); curseg->zone = GET_ZONE_FROM_SEG(sbi, curseg->segno);
curseg->next_blkoff = 0; curseg->next_blkoff = 0;
curseg->next_segno = NULL_SEGNO; curseg->next_segno = NULL_SEGNO;

34
fs/f2fs/segment.h
View File

@ -78,12 +78,16 @@
((((blk_addr) == NULL_ADDR) || ((blk_addr) == NEW_ADDR)) ? \ ((((blk_addr) == NULL_ADDR) || ((blk_addr) == NEW_ADDR)) ? \
NULL_SEGNO : GET_L2R_SEGNO(FREE_I(sbi), \ NULL_SEGNO : GET_L2R_SEGNO(FREE_I(sbi), \
GET_SEGNO_FROM_SEG0(sbi, blk_addr))) GET_SEGNO_FROM_SEG0(sbi, blk_addr)))
#define GET_SECNO(sbi, segno) \ #define BLKS_PER_SEC(sbi) \
((sbi)->segs_per_sec * (sbi)->blocks_per_seg)
#define GET_SEC_FROM_SEG(sbi, segno) \
((segno) / (sbi)->segs_per_sec) ((segno) / (sbi)->segs_per_sec)
#define GET_SEGNO_FROM_SECNO(sbi, secno) \ #define GET_SEG_FROM_SEC(sbi, secno) \
((secno) * (sbi)->segs_per_sec) ((secno) * (sbi)->segs_per_sec)
#define GET_ZONENO_FROM_SEGNO(sbi, segno) \ #define GET_ZONE_FROM_SEC(sbi, secno) \
(((segno) / (sbi)->segs_per_sec) / (sbi)->secs_per_zone) ((secno) / (sbi)->secs_per_zone)
#define GET_ZONE_FROM_SEG(sbi, segno) \
GET_ZONE_FROM_SEC(sbi, GET_SEC_FROM_SEG(sbi, segno))
#define GET_SUM_BLOCK(sbi, segno) \ #define GET_SUM_BLOCK(sbi, segno) \
((sbi)->sm_info->ssa_blkaddr + (segno)) ((sbi)->sm_info->ssa_blkaddr + (segno))
@ -305,7 +309,7 @@ static inline struct sec_entry *get_sec_entry(struct f2fs_sb_info *sbi,
unsigned int segno) unsigned int segno)
{ {
struct sit_info *sit_i = SIT_I(sbi); struct sit_info *sit_i = SIT_I(sbi);
return &sit_i->sec_entries[GET_SECNO(sbi, segno)]; return &sit_i->sec_entries[GET_SEC_FROM_SEG(sbi, segno)];
} }
static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi, static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi,
@ -360,8 +364,8 @@ static inline unsigned int find_next_inuse(struct free_segmap_info *free_i,
static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno) static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno)
{ {
struct free_segmap_info *free_i = FREE_I(sbi); struct free_segmap_info *free_i = FREE_I(sbi);
unsigned int secno = segno / sbi->segs_per_sec; unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
unsigned int start_segno = secno * sbi->segs_per_sec; unsigned int start_segno = GET_SEG_FROM_SEC(sbi, secno);
unsigned int next; unsigned int next;
spin_lock(&free_i->segmap_lock); spin_lock(&free_i->segmap_lock);
@ -381,7 +385,8 @@ static inline void __set_inuse(struct f2fs_sb_info *sbi,
unsigned int segno) unsigned int segno)
{ {
struct free_segmap_info *free_i = FREE_I(sbi); struct free_segmap_info *free_i = FREE_I(sbi);
unsigned int secno = segno / sbi->segs_per_sec; unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
set_bit(segno, free_i->free_segmap); set_bit(segno, free_i->free_segmap);
free_i->free_segments--; free_i->free_segments--;
if (!test_and_set_bit(secno, free_i->free_secmap)) if (!test_and_set_bit(secno, free_i->free_secmap))
@ -392,8 +397,8 @@ static inline void __set_test_and_free(struct f2fs_sb_info *sbi,
unsigned int segno) unsigned int segno)
{ {
struct free_segmap_info *free_i = FREE_I(sbi); struct free_segmap_info *free_i = FREE_I(sbi);
unsigned int secno = segno / sbi->segs_per_sec; unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
unsigned int start_segno = secno * sbi->segs_per_sec; unsigned int start_segno = GET_SEG_FROM_SEC(sbi, secno);
unsigned int next; unsigned int next;
spin_lock(&free_i->segmap_lock); spin_lock(&free_i->segmap_lock);
@ -414,7 +419,8 @@ static inline void __set_test_and_inuse(struct f2fs_sb_info *sbi,
unsigned int segno) unsigned int segno)
{ {
struct free_segmap_info *free_i = FREE_I(sbi); struct free_segmap_info *free_i = FREE_I(sbi);
unsigned int secno = segno / sbi->segs_per_sec; unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
spin_lock(&free_i->segmap_lock); spin_lock(&free_i->segmap_lock);
if (!test_and_set_bit(segno, free_i->free_segmap)) { if (!test_and_set_bit(segno, free_i->free_segmap)) {
free_i->free_segments--; free_i->free_segments--;
@ -479,12 +485,12 @@ static inline int overprovision_segments(struct f2fs_sb_info *sbi)
static inline int overprovision_sections(struct f2fs_sb_info *sbi) static inline int overprovision_sections(struct f2fs_sb_info *sbi)
{ {
return ((unsigned int) overprovision_segments(sbi)) / sbi->segs_per_sec; return GET_SEC_FROM_SEG(sbi, (unsigned int)overprovision_segments(sbi));
} }
static inline int reserved_sections(struct f2fs_sb_info *sbi) static inline int reserved_sections(struct f2fs_sb_info *sbi)
{ {
return ((unsigned int) reserved_segments(sbi)) / sbi->segs_per_sec; return GET_SEC_FROM_SEG(sbi, (unsigned int)reserved_segments(sbi));
} }
static inline bool need_SSR(struct f2fs_sb_info *sbi) static inline bool need_SSR(struct f2fs_sb_info *sbi)
@ -722,7 +728,7 @@ static inline block_t sum_blk_addr(struct f2fs_sb_info *sbi, int base, int type)
static inline bool no_fggc_candidate(struct f2fs_sb_info *sbi, static inline bool no_fggc_candidate(struct f2fs_sb_info *sbi,
unsigned int secno) unsigned int secno)
{ {
if (get_valid_blocks(sbi, GET_SEGNO_FROM_SECNO(sbi, secno), true) >= if (get_valid_blocks(sbi, GET_SEG_FROM_SEC(sbi, secno), true) >=
sbi->fggc_threshold) sbi->fggc_threshold)
return true; return true;
return false; return false;