* [RFC PATCH 0/4] do more check in sanity_check_nid and clean up
@ 2016-01-30 9:16 Sheng Yong
2016-01-30 9:16 ` [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} Sheng Yong
` (3 more replies)
0 siblings, 4 replies; 9+ messages in thread
From: Sheng Yong @ 2016-01-30 9:16 UTC (permalink / raw)
To: jaegeuk, chao2.yu; +Cc: linux-f2fs-devel
PATCH 1/4 cleans up get_{sb|cp} and set_{sb|cp} to integrate them into
get_val and set_val to avoid dumplicated definition of macro.
PATCH 3/4 and 4/4 check nat_entry->ino. If it is wrong, we drop
corresponding nodes.
thanks,
Sheng
Sheng Yong (4):
f2fs-tools: simplify get_{sb|cp} and set_{sb|cp}
f2fs-tools: fix endianness of on-disk check_sum in summary_footer
fsck.f2fs: check ino of an used nat entry
fsck.f2fs: check ino of an inode
fsck/fsck.c | 30 ++++---
fsck/main.c | 8 +-
fsck/mount.c | 146 ++++++++++++++++-----------------
include/f2fs_fs.h | 86 +++++++-------------
mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++---------------------------
5 files changed, 243 insertions(+), 261 deletions(-)
--
1.9.1
------------------------------------------------------------------------------
Site24x7 APM Insight: Get Deep Visibility into Application Performance
APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month
Monitor end-to-end web transactions and take corrective actions now
Troubleshoot faster and improve end-user experience. Signup Now!
http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140
^ permalink raw reply [flat|nested] 9+ messages in thread* [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} 2016-01-30 9:16 [RFC PATCH 0/4] do more check in sanity_check_nid and clean up Sheng Yong @ 2016-01-30 9:16 ` Sheng Yong 2016-01-30 1:46 ` Jaegeuk Kim 2016-01-30 9:16 ` [RFC PATCH 2/4] f2fs-tools: fix endianness of on-disk check_sum in summary_footer Sheng Yong ` (2 subsequent siblings) 3 siblings, 1 reply; 9+ messages in thread From: Sheng Yong @ 2016-01-30 9:16 UTC (permalink / raw) To: jaegeuk, chao2.yu; +Cc: linux-f2fs-devel * Remove dumplicated definitions of get_{sb|cp} and set_{sb|cp}, and introduce micros get_val and set_val instead. * Add a new parameter to get_val and set_val so that they are not depended on implied definition of `sb' and `cp'. Signed-off-by: Sheng Yong <shengyong1@huawei.com> --- fsck/fsck.c | 20 ++--- fsck/main.c | 8 +- fsck/mount.c | 146 ++++++++++++++++----------------- include/f2fs_fs.h | 84 +++++++------------ mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++--------------------------- 5 files changed, 232 insertions(+), 260 deletions(-) diff --git a/fsck/fsck.c b/fsck/fsck.c index e7dd02f..4fbb56d 100644 --- a/fsck/fsck.c +++ b/fsck/fsck.c @@ -1191,7 +1191,7 @@ void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) return; - start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload); + start_blk = __start_cp_addr(sbi) + 1 + get_val(sb, cp_payload); orphan_blkaddr = __start_sum_addr(sbi) - 1; orphan_blk = calloc(BLOCK_SZ, 1); @@ -1324,25 +1324,25 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi) flags |= CP_ORPHAN_PRESENT_FLAG; } - set_cp(ckpt_flags, flags); - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); + set_val(cp, ckpt_flags, flags); + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); - set_cp(free_segment_count, fsck->chk.free_segs); - set_cp(valid_block_count, fsck->chk.valid_blk_cnt); - set_cp(valid_node_count, fsck->chk.valid_node_cnt); - set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); + set_val(cp, free_segment_count, fsck->chk.free_segs); + set_val(cp, valid_block_count, fsck->chk.valid_blk_cnt); + set_val(cp, valid_node_count, fsck->chk.valid_node_cnt); + set_val(cp, valid_inode_count, fsck->chk.valid_inode_cnt); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (sbi->cur_cp == 2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); ret = dev_write_block(cp, cp_blk_no++); ASSERT(ret >= 0); - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { ret = dev_write_block(((unsigned char *)cp) + i * F2FS_BLKSIZE, cp_blk_no++); ASSERT(ret >= 0); diff --git a/fsck/main.c b/fsck/main.c index 54dbb2d..7fcaa5d 100644 --- a/fsck/main.c +++ b/fsck/main.c @@ -255,7 +255,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) { struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); - if (config.defrag_start > get_sb(block_count)) + if (config.defrag_start > get_val(sb, block_count)) goto out_range; if (config.defrag_start < SM_I(sbi)->main_blkaddr) config.defrag_start = SM_I(sbi)->main_blkaddr; @@ -263,8 +263,8 @@ static int do_defrag(struct f2fs_sb_info *sbi) if (config.defrag_len == 0) config.defrag_len = sbi->blocks_per_seg; - if (config.defrag_start + config.defrag_len > get_sb(block_count)) - config.defrag_len = get_sb(block_count) - config.defrag_start; + if (config.defrag_start + config.defrag_len > get_val(sb, block_count)) + config.defrag_len = get_val(sb, block_count) - config.defrag_start; if (config.defrag_target == 0) { config.defrag_target = config.defrag_start - 1; @@ -273,7 +273,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) } if (config.defrag_target < SM_I(sbi)->main_blkaddr || - config.defrag_target > get_sb(block_count)) + config.defrag_target > get_val(sb, block_count)) goto out_range; if (config.defrag_target >= config.defrag_start && config.defrag_target < config.defrag_start + config.defrag_len) diff --git a/fsck/mount.c b/fsck/mount.c index 4c807f9..6e6d230 100644 --- a/fsck/mount.c +++ b/fsck/mount.c @@ -269,21 +269,21 @@ int sanity_check_raw_super(struct f2fs_super_block *sb) { unsigned int blocksize; - if (F2FS_SUPER_MAGIC != get_sb(magic)) + if (F2FS_SUPER_MAGIC != get_val(sb, magic)) return -1; if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) return -1; - blocksize = 1 << get_sb(log_blocksize); + blocksize = 1 << get_val(sb, log_blocksize); if (F2FS_BLKSIZE != blocksize) return -1; - if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || - get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) + if (get_val(sb, log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || + get_val(sb, log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) return -1; - if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != + if (get_val(sb, log_sectors_per_block) + get_val(sb, log_sectorsize) != F2FS_MAX_LOG_SECTOR_SIZE) return -1; @@ -350,22 +350,22 @@ int init_sb_info(struct f2fs_sb_info *sbi) struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); u64 total_sectors; - sbi->log_sectors_per_block = get_sb(log_sectors_per_block); - sbi->log_blocksize = get_sb(log_blocksize); + sbi->log_sectors_per_block = get_val(sb, log_sectors_per_block); + sbi->log_blocksize = get_val(sb, log_blocksize); sbi->blocksize = 1 << sbi->log_blocksize; - sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); + sbi->log_blocks_per_seg = get_val(sb, log_blocks_per_seg); sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; - sbi->segs_per_sec = get_sb(segs_per_sec); - sbi->secs_per_zone = get_sb(secs_per_zone); - sbi->total_sections = get_sb(section_count); - sbi->total_node_count = (get_sb(segment_count_nat) / 2) * + sbi->segs_per_sec = get_val(sb, segs_per_sec); + sbi->secs_per_zone = get_val(sb, secs_per_zone); + sbi->total_sections = get_val(sb, section_count); + sbi->total_node_count = (get_val(sb, segment_count_nat) / 2) * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; - sbi->root_ino_num = get_sb(root_ino); - sbi->node_ino_num = get_sb(node_ino); - sbi->meta_ino_num = get_sb(meta_ino); + sbi->root_ino_num = get_val(sb, root_ino); + sbi->node_ino_num = get_val(sb, node_ino); + sbi->meta_ino_num = get_val(sb, meta_ino); sbi->cur_victim_sec = NULL_SEGNO; - total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; + total_sectors = get_val(sb, block_count) << sbi->log_sectors_per_block; MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", total_sectors, total_sectors >> 11); return 0; @@ -387,7 +387,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, return NULL; cp = (struct f2fs_checkpoint *)cp_page_1; - crc_offset = get_cp(checksum_offset); + crc_offset = get_val(cp, checksum_offset); if (crc_offset >= blk_size) goto invalid_cp1; @@ -395,17 +395,17 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, if (f2fs_crc_valid(crc, cp, crc_offset)) goto invalid_cp1; - pre_version = get_cp(checkpoint_ver); + pre_version = get_val(cp, checkpoint_ver); /* Read the 2nd cp block in this CP pack */ cp_page_2 = malloc(PAGE_SIZE); - cp_addr += get_cp(cp_pack_total_block_count) - 1; + cp_addr += get_val(cp, cp_pack_total_block_count) - 1; if (dev_read_block(cp_page_2, cp_addr) < 0) goto invalid_cp2; cp = (struct f2fs_checkpoint *)cp_page_2; - crc_offset = get_cp(checksum_offset); + crc_offset = get_val(cp, checksum_offset); if (crc_offset >= blk_size) goto invalid_cp2; @@ -413,7 +413,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, if (f2fs_crc_valid(crc, cp, crc_offset)) goto invalid_cp2; - cur_version = get_cp(checkpoint_ver); + cur_version = get_val(cp, checkpoint_ver); if (cur_version == pre_version) { *version = cur_version; @@ -435,7 +435,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) unsigned long blk_size = sbi->blocksize; unsigned long long cp1_version = 0, cp2_version = 0, version; unsigned long long cp_start_blk_no; - unsigned int cp_blks = 1 + get_sb(cp_payload); + unsigned int cp_blks = 1 + get_val(sb, cp_payload); int ret; sbi->ckpt = malloc(cp_blks * blk_size); @@ -445,11 +445,11 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) * Finding out valid cp block involves read both * sets( cp pack1 and cp pack 2) */ - cp_start_blk_no = get_sb(cp_blkaddr); + cp_start_blk_no = get_val(sb, cp_blkaddr); cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); /* The second checkpoint pack should start at the next segment */ - cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_start_blk_no += 1 << get_val(sb, log_blocks_per_seg); cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); if (cp1 && cp2) { @@ -481,9 +481,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) unsigned int i; unsigned long long cp_blk_no; - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (cur_page == cp2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); /* copy sit bitmap */ for (i = 1; i < cp_blks; i++) { @@ -510,12 +510,12 @@ int sanity_check_ckpt(struct f2fs_sb_info *sbi) struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); - total = get_sb(segment_count); - fsmeta = get_sb(segment_count_ckpt); - fsmeta += get_sb(segment_count_sit); - fsmeta += get_sb(segment_count_nat); - fsmeta += get_cp(rsvd_segment_count); - fsmeta += get_sb(segment_count_ssa); + total = get_val(sb, segment_count); + fsmeta = get_val(sb, segment_count_ckpt); + fsmeta += get_val(sb, segment_count_sit); + fsmeta += get_val(sb, segment_count_nat); + fsmeta += get_val(cp, rsvd_segment_count); + fsmeta += get_val(sb, segment_count_ssa); if (fsmeta >= total) return 1; @@ -531,16 +531,16 @@ int init_node_manager(struct f2fs_sb_info *sbi) unsigned char *version_bitmap; unsigned int nat_segs, nat_blocks; - nm_i->nat_blkaddr = get_sb(nat_blkaddr); + nm_i->nat_blkaddr = get_val(sb, nat_blkaddr); /* segment_count_nat includes pair segment so divide to 2. */ - nat_segs = get_sb(segment_count_nat) >> 1; - nat_blocks = nat_segs << get_sb(log_blocks_per_seg); + nat_segs = get_val(sb, segment_count_nat) >> 1; + nat_blocks = nat_segs << get_val(sb, log_blocks_per_seg); nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; nm_i->fcnt = 0; nm_i->nat_cnt = 0; - nm_i->init_scan_nid = get_cp(next_free_nid); - nm_i->next_scan_nid = get_cp(next_free_nid); + nm_i->init_scan_nid = get_val(cp, next_free_nid); + nm_i->next_scan_nid = get_val(cp, next_free_nid); nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); @@ -597,21 +597,21 @@ int build_sit_info(struct f2fs_sb_info *sbi) return -ENOMEM; } - sit_segs = get_sb(segment_count_sit) >> 1; + sit_segs = get_val(sb, segment_count_sit) >> 1; bitmap_size = __bitmap_size(sbi, SIT_BITMAP); src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); dst_bitmap = malloc(bitmap_size); memcpy(dst_bitmap, src_bitmap, bitmap_size); - sit_i->sit_base_addr = get_sb(sit_blkaddr); + sit_i->sit_base_addr = get_val(sb, sit_blkaddr); sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; - sit_i->written_valid_blocks = get_cp(valid_block_count); + sit_i->written_valid_blocks = get_val(cp, valid_block_count); sit_i->sit_bitmap = dst_bitmap; sit_i->bitmap_size = bitmap_size; sit_i->dirty_sentries = 0; sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; - sit_i->elapsed_time = get_cp(elapsed_time); + sit_i->elapsed_time = get_val(cp, elapsed_time); return 0; } @@ -716,13 +716,13 @@ static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) int ret; if (IS_DATASEG(type)) { - segno = get_cp(cur_data_segno[type]); + segno = get_val(cp, cur_data_segno[type]); if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); else blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); } else { - segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); + segno = get_val(cp, cur_node_segno[type - CURSEG_HOT_NODE]); if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, type - CURSEG_HOT_NODE); @@ -803,12 +803,12 @@ static void build_curseg(struct f2fs_sb_info *sbi) array[i].sum_blk = malloc(PAGE_CACHE_SIZE); ASSERT(array[i].sum_blk); if (i <= CURSEG_COLD_DATA) { - blk_off = get_cp(cur_data_blkoff[i]); - segno = get_cp(cur_data_segno[i]); + blk_off = get_val(cp, cur_data_blkoff[i]); + segno = get_val(cp, cur_data_segno[i]); } if (i > CURSEG_COLD_DATA) { - blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); - segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); + blk_off = get_val(cp, cur_node_blkoff[i - CURSEG_HOT_NODE]); + segno = get_val(cp, cur_node_segno[i - CURSEG_HOT_NODE]); } array[i].segno = segno; array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); @@ -924,7 +924,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, ssa_blk = GET_SUM_BLKADDR(sbi, segno); for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { - if (segno == get_cp(cur_node_segno[type])) { + if (segno == get_val(cp, cur_node_segno[type])) { curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { ASSERT_MSG("segno [0x%x] indicates a data " @@ -939,7 +939,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, } for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { - if (segno == get_cp(cur_data_segno[type])) { + if (segno == get_val(cp, cur_data_segno[type])) { curseg = CURSEG_I(sbi, type); if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { ASSERT_MSG("segno [0x%x] indicates a node " @@ -1151,13 +1151,13 @@ int build_segment_manager(struct f2fs_sb_info *sbi) /* init sm info */ sbi->sm_info = sm_info; - sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); - sm_info->main_blkaddr = get_sb(main_blkaddr); - sm_info->segment_count = get_sb(segment_count); - sm_info->reserved_segments = get_cp(rsvd_segment_count); - sm_info->ovp_segments = get_cp(overprov_segment_count); - sm_info->main_segments = get_sb(segment_count_main); - sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); + sm_info->seg0_blkaddr = get_val(sb, segment0_blkaddr); + sm_info->main_blkaddr = get_val(sb, main_blkaddr); + sm_info->segment_count = get_val(sb, segment_count); + sm_info->reserved_segments = get_val(cp, rsvd_segment_count); + sm_info->ovp_segments = get_val(cp, overprov_segment_count); + sm_info->main_segments = get_val(sb, segment_count_main); + sm_info->ssa_blkaddr = get_val(sb, ssa_blkaddr); build_sit_info(sbi); @@ -1384,7 +1384,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi) free_segs++; } - set_cp(free_segment_count, free_segs); + set_val(cp, free_segment_count, free_segs); } int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type) @@ -1487,14 +1487,14 @@ void write_curseg_info(struct f2fs_sb_info *sbi) for (i = 0; i < NO_CHECK_TYPE; i++) { cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; if (i < CURSEG_HOT_NODE) { - set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); - set_cp(cur_data_blkoff[i], + set_val(cp, cur_data_segno[i], CURSEG_I(sbi, i)->segno); + set_val(cp, cur_data_blkoff[i], CURSEG_I(sbi, i)->next_blkoff); } else { int n = i - CURSEG_HOT_NODE; - set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); - set_cp(cur_node_blkoff[n], + set_val(cp, cur_node_segno[n], CURSEG_I(sbi, i)->segno); + set_val(cp, cur_node_blkoff[n], CURSEG_I(sbi, i)->next_blkoff); } } @@ -1578,24 +1578,24 @@ void write_checkpoint(struct f2fs_sb_info *sbi) flags |= CP_ORPHAN_PRESENT_FLAG; } - set_cp(ckpt_flags, flags); + set_val(cp, ckpt_flags, flags); - set_cp(free_segment_count, get_free_segments(sbi)); - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); + set_val(cp, free_segment_count, get_free_segments(sbi)); + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (sbi->cur_cp == 2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); /* write the first cp */ ret = dev_write_block(cp, cp_blk_no++); ASSERT(ret >= 0); /* skip payload */ - cp_blk_no += get_sb(cp_payload); + cp_blk_no += get_val(sb, cp_payload); /* skip orphan blocks */ cp_blk_no += orphan_blks; @@ -1635,7 +1635,7 @@ void build_nat_area_bitmap(struct f2fs_sb_info *sbi) ASSERT(nat_block); /* Alloc & build nat entry bitmap */ - nr_nat_blks = (get_sb(segment_count_nat) / 2) << + nr_nat_blks = (get_val(sb, segment_count_nat) / 2) << sbi->log_blocks_per_seg; fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; @@ -1731,7 +1731,7 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) print_ckpt_info(sbi); if (config.auto_fix) { - u32 flag = get_cp(ckpt_flags); + u32 flag = get_val(cp, ckpt_flags); if (flag & CP_FSCK_FLAG) config.fix_on = 1; @@ -1741,10 +1741,10 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) config.bug_on = 0; - sbi->total_valid_node_count = get_cp(valid_node_count); - sbi->total_valid_inode_count = get_cp(valid_inode_count); - sbi->user_block_count = get_cp(user_block_count); - sbi->total_valid_block_count = get_cp(valid_block_count); + sbi->total_valid_node_count = get_val(cp, valid_node_count); + sbi->total_valid_inode_count = get_val(cp, valid_inode_count); + sbi->user_block_count = get_val(cp, user_block_count); + sbi->total_valid_block_count = get_val(cp, valid_block_count); sbi->last_valid_block_count = sbi->total_valid_block_count; sbi->alloc_valid_block_count = 0; diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h index e1eeb6e..2ab9f49 100644 --- a/include/f2fs_fs.h +++ b/include/f2fs_fs.h @@ -270,60 +270,32 @@ struct f2fs_configuration { #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG)) #define BIT_WORD(nr) (nr / BITS_PER_LONG) -#define set_sb_le64(member, val) (sb->member = cpu_to_le64(val)) -#define set_sb_le32(member, val) (sb->member = cpu_to_le32(val)) -#define set_sb_le16(member, val) (sb->member = cpu_to_le16(val)) -#define get_sb_le64(member) le64_to_cpu(sb->member) -#define get_sb_le32(member) le32_to_cpu(sb->member) -#define get_sb_le16(member) le16_to_cpu(sb->member) - -#define set_sb(member, val) \ - do { \ - typeof(sb->member) t; \ - switch (sizeof(t)) { \ - case 8: set_sb_le64(member, val); break; \ - case 4: set_sb_le32(member, val); break; \ - case 2: set_sb_le16(member, val); break; \ - } \ +#define set_le64(ptr, member, val) ((ptr)->member = cpu_to_le64(val)) +#define set_le32(ptr, member, val) ((ptr)->member = cpu_to_le32(val)) +#define set_le16(ptr, member, val) ((ptr)->member = cpu_to_le16(val)) +#define get_le64(ptr, member) le64_to_cpu((ptr)->member) +#define get_le32(ptr, member) le32_to_cpu((ptr)->member) +#define get_le16(ptr, member) le16_to_cpu((ptr)->member) + +#define set_val(ptr, member, val) \ + do { \ + typeof((ptr)->member) t; \ + switch (sizeof(t)) { \ + case 8: set_le64(ptr, member, val); break; \ + case 4: set_le32(ptr, member, val); break; \ + case 2: set_le16(ptr, member, val); break; \ + } \ } while(0) -#define get_sb(member) \ - ({ \ - typeof(sb->member) t; \ - switch (sizeof(t)) { \ - case 8: t = get_sb_le64(member); break; \ - case 4: t = get_sb_le32(member); break; \ - case 2: t = get_sb_le16(member); break; \ - } \ - t; \ - }) - -#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val)) -#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val)) -#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val)) -#define get_cp_le64(member) le64_to_cpu(cp->member) -#define get_cp_le32(member) le32_to_cpu(cp->member) -#define get_cp_le16(member) le16_to_cpu(cp->member) - -#define set_cp(member, val) \ - do { \ - typeof(cp->member) t; \ - switch (sizeof(t)) { \ - case 8: set_cp_le64(member, val); break; \ - case 4: set_cp_le32(member, val); break; \ - case 2: set_cp_le16(member, val); break; \ - } \ - } while(0) - -#define get_cp(member) \ - ({ \ - typeof(cp->member) t; \ - switch (sizeof(t)) { \ - case 8: t = get_cp_le64(member); break; \ - case 4: t = get_cp_le32(member); break; \ - case 2: t = get_cp_le16(member); break; \ - } \ - t; \ +#define get_val(ptr, member) \ + ({ \ + typeof((ptr)->member) t; \ + switch (sizeof(t)) { \ + case 8: t = get_le64(ptr, member); break; \ + case 4: t = get_le32(ptr, member); break; \ + case 2: t = get_le16(ptr, member); break; \ + } \ + t; \ }) /* @@ -899,7 +871,7 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) double reserved, ovp, candidate, end, diff, space; double max_ovp = 0, max_space = 0; - if (get_sb(segment_count_main) < 256) { + if (get_val(sb, segment_count_main) < 256) { candidate = 10; end = 95; diff = 5; @@ -911,9 +883,9 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) for (; candidate <= end; candidate += diff) { reserved = (2 * (100 / candidate + 1) + 6) * - get_sb(segs_per_sec); - ovp = (get_sb(segment_count_main) - reserved) * candidate / 100; - space = get_sb(segment_count_main) - reserved - ovp; + get_val(sb, segs_per_sec); + ovp = (get_val(sb, segment_count_main) - reserved) * candidate / 100; + space = get_val(sb, segment_count_main) - reserved - ovp; if (max_space < space) { max_space = space; max_ovp = candidate; diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c index 645c2aa..db5348e 100644 --- a/mkfs/f2fs_format.c +++ b/mkfs/f2fs_format.c @@ -83,7 +83,7 @@ static void configure_extension_list(void) int name_len; int i = 0; - set_sb(extension_count, 0); + set_val(sb, extension_count, 0); memset(sb->extension_list, 0, sizeof(sb->extension_list)); while (*extlist) { @@ -91,7 +91,7 @@ static void configure_extension_list(void) memcpy(sb->extension_list[i++], *extlist, name_len); extlist++; } - set_sb(extension_count, i); + set_val(sb, extension_count, i); if (!ext_str) return; @@ -112,7 +112,7 @@ next: break; } - set_sb(extension_count, i); + set_val(sb, extension_count, i); free(config.extension_list); } @@ -132,23 +132,23 @@ static int f2fs_prepare_super_block(void) u_int32_t max_nat_bitmap_size, max_nat_segments; u_int32_t total_zones; - set_sb(magic, F2FS_SUPER_MAGIC); - set_sb(major_ver, F2FS_MAJOR_VERSION); - set_sb(minor_ver, F2FS_MINOR_VERSION); + set_val(sb, magic, F2FS_SUPER_MAGIC); + set_val(sb, major_ver, F2FS_MAJOR_VERSION); + set_val(sb, minor_ver, F2FS_MINOR_VERSION); log_sectorsize = log_base_2(config.sector_size); log_sectors_per_block = log_base_2(config.sectors_per_blk); log_blocksize = log_sectorsize + log_sectors_per_block; log_blks_per_seg = log_base_2(config.blks_per_seg); - set_sb(log_sectorsize, log_sectorsize); - set_sb(log_sectors_per_block, log_sectors_per_block); + set_val(sb, log_sectorsize, log_sectorsize); + set_val(sb, log_sectors_per_block, log_sectors_per_block); - set_sb(log_blocksize, log_blocksize); - set_sb(log_blocks_per_seg, log_blks_per_seg); + set_val(sb, log_blocksize, log_blocksize); + set_val(sb, log_blocks_per_seg, log_blks_per_seg); - set_sb(segs_per_sec, config.segs_per_sec); - set_sb(secs_per_zone, config.secs_per_zone); + set_val(sb, segs_per_sec, config.segs_per_sec); + set_val(sb, secs_per_zone, config.secs_per_zone); blk_size_bytes = 1 << log_blocksize; segment_size_bytes = blk_size_bytes * config.blks_per_seg; @@ -156,9 +156,9 @@ static int f2fs_prepare_super_block(void) blk_size_bytes * config.secs_per_zone * config.segs_per_sec * config.blks_per_seg; - set_sb(checksum_offset, 0); + set_val(sb, checksum_offset, 0); - set_sb(block_count, config.total_sectors >> log_sectors_per_block); + set_val(sb, block_count, config.total_sectors >> log_sectors_per_block); zone_align_start_offset = (config.start_sector * config.sector_size + @@ -174,41 +174,41 @@ static int f2fs_prepare_super_block(void) config.sectors_per_blk); } - set_sb(segment_count, (config.total_sectors * config.sector_size - + set_val(sb, segment_count, (config.total_sectors * config.sector_size - zone_align_start_offset) / segment_size_bytes); - set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes); + set_val(sb, segment0_blkaddr, zone_align_start_offset / blk_size_bytes); sb->cp_blkaddr = sb->segment0_blkaddr; - MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr)); + MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_val(sb, segment0_blkaddr)); - set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); + set_val(sb, segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); - set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) * + set_val(sb, sit_blkaddr, get_val(sb, segment0_blkaddr) + get_val(sb, segment_count_ckpt) * config.blks_per_seg); - blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK); + blocks_for_sit = ALIGN(get_val(sb, segment_count), SIT_ENTRY_PER_BLOCK); sit_segments = SEG_ALIGN(blocks_for_sit); - set_sb(segment_count_sit, sit_segments * 2); + set_val(sb, segment_count_sit, sit_segments * 2); - set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) * + set_val(sb, nat_blkaddr, get_val(sb, sit_blkaddr) + get_val(sb, segment_count_sit) * config.blks_per_seg); - total_valid_blks_available = (get_sb(segment_count) - - (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) * + total_valid_blks_available = (get_val(sb, segment_count) - + (get_val(sb, segment_count_ckpt) + get_val(sb, segment_count_sit))) * config.blks_per_seg; blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK); - set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat)); + set_val(sb, segment_count_nat, SEG_ALIGN(blocks_for_nat)); /* * The number of node segments should not be exceeded a "Threshold". * This number resizes NAT bitmap area in a CP page. * So the threshold is determined not to overflow one CP page */ - sit_bitmap_size = ((get_sb(segment_count_sit) / 2) << + sit_bitmap_size = ((get_val(sb, segment_count_sit) / 2) << log_blks_per_seg) / 8; if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE) @@ -223,55 +223,55 @@ static int f2fs_prepare_super_block(void) if (max_sit_bitmap_size > (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - 64)) { max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1; - set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); + set_val(sb, cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); } else { max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - max_sit_bitmap_size; - set_sb(cp_payload, 0); + set_val(sb, cp_payload, 0); } max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; - if (get_sb(segment_count_nat) > max_nat_segments) - set_sb(segment_count_nat, max_nat_segments); + if (get_val(sb, segment_count_nat) > max_nat_segments) + set_val(sb, segment_count_nat, max_nat_segments); - set_sb(segment_count_nat, get_sb(segment_count_nat) * 2); + set_val(sb, segment_count_nat, get_val(sb, segment_count_nat) * 2); - set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) * + set_val(sb, ssa_blkaddr, get_val(sb, nat_blkaddr) + get_val(sb, segment_count_nat) * config.blks_per_seg); - total_valid_blks_available = (get_sb(segment_count) - - (get_sb(segment_count_ckpt) + - get_sb(segment_count_sit) + - get_sb(segment_count_nat))) * + total_valid_blks_available = (get_val(sb, segment_count) - + (get_val(sb, segment_count_ckpt) + + get_val(sb, segment_count_sit) + + get_val(sb, segment_count_nat))) * config.blks_per_seg; blocks_for_ssa = total_valid_blks_available / config.blks_per_seg + 1; - set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); + set_val(sb, segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); - total_meta_segments = get_sb(segment_count_ckpt) + - get_sb(segment_count_sit) + - get_sb(segment_count_nat) + - get_sb(segment_count_ssa); + total_meta_segments = get_val(sb, segment_count_ckpt) + + get_val(sb, segment_count_sit) + + get_val(sb, segment_count_nat) + + get_val(sb, segment_count_ssa); diff = total_meta_segments % (config.segs_per_zone); if (diff) - set_sb(segment_count_ssa, get_sb(segment_count_ssa) + + set_val(sb, segment_count_ssa, get_val(sb, segment_count_ssa) + (config.segs_per_zone - diff)); total_meta_zones = ZONE_ALIGN(total_meta_segments * config.blks_per_seg); - set_sb(main_blkaddr, get_sb(segment0_blkaddr) + total_meta_zones * + set_val(sb, main_blkaddr, get_val(sb, segment0_blkaddr) + total_meta_zones * config.segs_per_zone * config.blks_per_seg); - total_zones = get_sb(segment_count) / (config.segs_per_zone) - + total_zones = get_val(sb, segment_count) / (config.segs_per_zone) - total_meta_zones; - set_sb(section_count, total_zones * config.secs_per_zone); + set_val(sb, section_count, total_zones * config.secs_per_zone); - set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec); + set_val(sb, segment_count_main, get_val(sb, section_count) * config.segs_per_sec); /* Let's determine the best reserved and overprovisioned space */ if (config.overprovision == 0) @@ -281,12 +281,12 @@ static int f2fs_prepare_super_block(void) (2 * (100 / config.overprovision + 1) + 6) * config.segs_per_sec; - if ((get_sb(segment_count_main) - 2) < + if ((get_val(sb, segment_count_main) - 2) < config.reserved_segments) { MSG(1, "\tError: Device size is not sufficient for F2FS volume,\ more segment needed =%u", config.reserved_segments - - (get_sb(segment_count_main) - 2)); + (get_val(sb, segment_count_main) - 2)); return -1; } @@ -294,9 +294,9 @@ static int f2fs_prepare_super_block(void) utf8_to_utf16(sb->volume_name, (const char *)config.vol_label, MAX_VOLUME_NAME, strlen(config.vol_label)); - set_sb(node_ino, 1); - set_sb(meta_ino, 2); - set_sb(root_ino, 3); + set_val(sb, node_ino, 1); + set_val(sb, meta_ino, 2); + set_val(sb, root_ino, 3); if (total_zones <= 6) { MSG(1, "\tError: %d zones: Need more zones \ @@ -346,8 +346,8 @@ static int f2fs_init_sit_area(void) u_int64_t sit_seg_addr = 0; u_int8_t *zero_buf = NULL; - blk_size = 1 << get_sb(log_blocksize); - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; + blk_size = 1 << get_val(sb, log_blocksize); + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; zero_buf = calloc(sizeof(u_int8_t), seg_size); if(zero_buf == NULL) { @@ -355,11 +355,11 @@ static int f2fs_init_sit_area(void) return -1; } - sit_seg_addr = get_sb(sit_blkaddr); + sit_seg_addr = get_val(sb, sit_blkaddr); sit_seg_addr *= blk_size; DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr); - for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) { + for (index = 0; index < (get_val(sb, segment_count_sit) / 2); index++) { if (dev_fill(zero_buf, sit_seg_addr, seg_size)) { MSG(1, "\tError: While zeroing out the sit area \ on disk!!!\n"); @@ -380,8 +380,8 @@ static int f2fs_init_nat_area(void) u_int64_t nat_seg_addr = 0; u_int8_t *nat_buf = NULL; - blk_size = 1 << get_sb(log_blocksize); - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; + blk_size = 1 << get_val(sb, log_blocksize); + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; nat_buf = calloc(sizeof(u_int8_t), seg_size); if (nat_buf == NULL) { @@ -389,11 +389,11 @@ static int f2fs_init_nat_area(void) return -1; } - nat_seg_addr = get_sb(nat_blkaddr); + nat_seg_addr = get_val(sb, nat_blkaddr); nat_seg_addr *= blk_size; DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr); - for (index = 0; index < get_sb(segment_count_nat) / 2; index++) { + for (index = 0; index < get_val(sb, segment_count_nat) / 2; index++) { if (dev_fill(nat_buf, nat_seg_addr, seg_size)) { MSG(1, "\tError: While zeroing out the nat area \ on disk!!!\n"); @@ -445,58 +445,58 @@ static int f2fs_write_check_point_pack(void) } /* 1. cp page 1 of checkpoint pack 1 */ - set_cp(checkpoint_ver, 1); - set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); - set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); - set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); - set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); - set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); - set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); + set_val(cp, checkpoint_ver, 1); + set_val(cp, cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); + set_val(cp, cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); + set_val(cp, cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); + set_val(cp, cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); + set_val(cp, cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); + set_val(cp, cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { - set_cp(cur_node_segno[i], 0xffffffff); - set_cp(cur_data_segno[i], 0xffffffff); + set_val(cp, cur_node_segno[i], 0xffffffff); + set_val(cp, cur_data_segno[i], 0xffffffff); } - set_cp(cur_node_blkoff[0], 1); - set_cp(cur_data_blkoff[0], 1); - set_cp(valid_block_count, 2); - set_cp(rsvd_segment_count, config.reserved_segments); - set_cp(overprov_segment_count, (get_sb(segment_count_main) - - get_cp(rsvd_segment_count)) * + set_val(cp, cur_node_blkoff[0], 1); + set_val(cp, cur_data_blkoff[0], 1); + set_val(cp, valid_block_count, 2); + set_val(cp, rsvd_segment_count, config.reserved_segments); + set_val(cp, overprov_segment_count, (get_val(sb, segment_count_main) - + get_val(cp, rsvd_segment_count)) * config.overprovision / 100); - set_cp(overprov_segment_count, get_cp(overprov_segment_count) + - get_cp(rsvd_segment_count)); + set_val(cp, overprov_segment_count, get_val(cp, overprov_segment_count) + + get_val(cp, rsvd_segment_count)); MSG(0, "Info: Overprovision ratio = %.3lf%%\n", config.overprovision); MSG(0, "Info: Overprovision segments = %u (GC reserved = %u)\n", - get_cp(overprov_segment_count), + get_val(cp, overprov_segment_count), config.reserved_segments); /* main segments - reserved segments - (node + data segments) */ - set_cp(free_segment_count, get_sb(segment_count_main) - 6); - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - - get_cp(overprov_segment_count)) * config.blks_per_seg)); + set_val(cp, free_segment_count, get_val(sb, segment_count_main) - 6); + set_val(cp, user_block_count, ((get_val(cp, free_segment_count) + 6 - + get_val(cp, overprov_segment_count)) * config.blks_per_seg)); /* cp page (2), data summaries (1), node summaries (3) */ - set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); - set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); - set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); - set_cp(valid_node_count, 1); - set_cp(valid_inode_count, 1); - set_cp(next_free_nid, get_sb(root_ino) + 1); - set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << - get_sb(log_blocks_per_seg)) / 8); + set_val(cp, cp_pack_total_block_count, 6 + get_val(sb, cp_payload)); + set_val(cp, ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); + set_val(cp, cp_pack_start_sum, 1 + get_val(sb, cp_payload)); + set_val(cp, valid_node_count, 1); + set_val(cp, valid_inode_count, 1); + set_val(cp, next_free_nid, get_val(sb, root_ino) + 1); + set_val(cp, sit_ver_bitmap_bytesize, ((get_val(sb, segment_count_sit) / 2) << + get_val(sb, log_blocks_per_seg)) / 8); - set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) << - get_sb(log_blocks_per_seg)) / 8); + set_val(cp, nat_ver_bitmap_bytesize, ((get_val(sb, segment_count_nat) / 2) << + get_val(sb, log_blocks_per_seg)) / 8); - set_cp(checksum_offset, CHECKSUM_OFFSET); + set_val(cp, checksum_offset, CHECKSUM_OFFSET); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - blk_size_bytes = 1 << get_sb(log_blocksize); - cp_seg_blk_offset = get_sb(segment0_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + cp_seg_blk_offset = get_val(sb, segment0_blkaddr); cp_seg_blk_offset *= blk_size_bytes; DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); @@ -505,7 +505,7 @@ static int f2fs_write_check_point_pack(void) goto free_cp_payload; } - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { cp_seg_blk_offset += blk_size_bytes; if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While zeroing out the sit bitmap area \ @@ -537,8 +537,8 @@ static int f2fs_write_check_point_pack(void) sum->nat_j.entries[0].ne.version = 0; sum->nat_j.entries[0].ne.ino = sb->root_ino; sum->nat_j.entries[0].ne.block_addr = cpu_to_le32( - get_sb(main_blkaddr) + - get_cp(cur_node_segno[0]) * config.blks_per_seg); + get_val(sb, main_blkaddr) + + get_val(cp, cur_node_segno[0]) * config.blks_per_seg); memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE); sum_compact_p += SUM_JOURNAL_SIZE; @@ -635,7 +635,7 @@ static int f2fs_write_check_point_pack(void) crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_seg_blk_offset = (get_sb(segment0_blkaddr) + + cp_seg_blk_offset = (get_val(sb, segment0_blkaddr) + config.blks_per_seg) * blk_size_bytes; DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); @@ -644,7 +644,7 @@ static int f2fs_write_check_point_pack(void) goto free_cp_payload; } - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { cp_seg_blk_offset += blk_size_bytes; if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While zeroing out the sit bitmap area \ @@ -655,7 +655,7 @@ static int f2fs_write_check_point_pack(void) /* cp page 2 of check point pack 2 */ cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count) - - get_sb(cp_payload) - 1); + - get_val(sb, cp_payload) - 1); DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While writing the cp to disk!!!\n"); @@ -701,8 +701,8 @@ static int f2fs_write_super_block(void) static int discard_obsolete_dnode(struct f2fs_node *raw_node, u_int64_t offset) { do { - if (offset < get_sb(main_blkaddr) || - offset >= get_sb(main_blkaddr) + get_sb(block_count)) + if (offset < get_val(sb, main_blkaddr) || + offset >= get_val(sb, main_blkaddr) + get_val(sb, block_count)) break; if (dev_read_block(raw_node, offset)) { @@ -740,7 +740,7 @@ static int f2fs_write_root_inode(void) raw_node->footer.ino = sb->root_ino; raw_node->footer.cp_ver = cpu_to_le64(1); raw_node->footer.next_blkaddr = cpu_to_le32( - get_sb(main_blkaddr) + + get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg + 1); @@ -749,7 +749,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_uid = cpu_to_le32(getuid()); raw_node->i.i_gid = cpu_to_le32(getgid()); - blk_size_bytes = 1 << get_sb(log_blocksize); + blk_size_bytes = 1 << get_val(sb, log_blocksize); raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */ raw_node->i.i_blocks = cpu_to_le64(2); @@ -765,7 +765,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_current_depth = cpu_to_le32(1); raw_node->i.i_dir_level = DEF_DIR_LEVEL; - data_blk_nor = get_sb(main_blkaddr) + + data_blk_nor = get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor); @@ -773,7 +773,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_ext.blk_addr = 0; raw_node->i.i_ext.len = 0; - main_area_node_seg_blk_offset = get_sb(main_blkaddr); + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg; main_area_node_seg_blk_offset *= blk_size_bytes; @@ -786,7 +786,7 @@ static int f2fs_write_root_inode(void) } /* avoid power-off-recovery based on roll-forward policy */ - main_area_node_seg_blk_offset = get_sb(main_blkaddr); + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] * config.blks_per_seg; @@ -813,21 +813,21 @@ static int f2fs_update_nat_root(void) } /* update root */ - nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32( - get_sb(main_blkaddr) + + nat_blk->entries[get_val(sb, root_ino)].block_addr = cpu_to_le32( + get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg); - nat_blk->entries[get_sb(root_ino)].ino = sb->root_ino; + nat_blk->entries[get_val(sb, root_ino)].ino = sb->root_ino; /* update node nat */ - nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1); - nat_blk->entries[get_sb(node_ino)].ino = sb->node_ino; + nat_blk->entries[get_val(sb, node_ino)].block_addr = cpu_to_le32(1); + nat_blk->entries[get_val(sb, node_ino)].ino = sb->node_ino; /* update meta nat */ - nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1); - nat_blk->entries[get_sb(meta_ino)].ino = sb->meta_ino; + nat_blk->entries[get_val(sb, meta_ino)].block_addr = cpu_to_le32(1); + nat_blk->entries[get_val(sb, meta_ino)].ino = sb->meta_ino; - blk_size_bytes = 1 << get_sb(log_blocksize); - nat_seg_blk_offset = get_sb(nat_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + nat_seg_blk_offset = get_val(sb, nat_blkaddr); nat_seg_blk_offset *= blk_size_bytes; DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset); @@ -867,8 +867,8 @@ static int f2fs_add_default_dentry_root(void) /* bitmap for . and .. */ test_and_set_bit_le(0, dent_blk->dentry_bitmap); test_and_set_bit_le(1, dent_blk->dentry_bitmap); - blk_size_bytes = 1 << get_sb(log_blocksize); - data_blk_offset = get_sb(main_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + data_blk_offset = get_val(sb, main_blkaddr); data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; data_blk_offset *= blk_size_bytes; -- 1.9.1 ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} 2016-01-30 9:16 ` [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} Sheng Yong @ 2016-01-30 1:46 ` Jaegeuk Kim 2016-01-30 2:25 ` Sheng Yong 0 siblings, 1 reply; 9+ messages in thread From: Jaegeuk Kim @ 2016-01-30 1:46 UTC (permalink / raw) To: Sheng Yong; +Cc: linux-f2fs-devel Hi Sheng, This is not a good way. You're asking to change all the pending patches as well. Why not just adding two definitions like these? #define get_sb(member) get_val(sb, member) #define set_sb(member, val) set_sb(sb, member, val) #define get_cp(member) get_val(cp, member) #define set_cp(member, val) set_sb(cp, member, val) Thanks, On Sat, Jan 30, 2016 at 09:16:36AM +0000, Sheng Yong wrote: > * Remove dumplicated definitions of get_{sb|cp} and set_{sb|cp}, and introduce > micros get_val and set_val instead. > * Add a new parameter to get_val and set_val so that they are not depended on > implied definition of `sb' and `cp'. > > Signed-off-by: Sheng Yong <shengyong1@huawei.com> > --- > fsck/fsck.c | 20 ++--- > fsck/main.c | 8 +- > fsck/mount.c | 146 ++++++++++++++++----------------- > include/f2fs_fs.h | 84 +++++++------------ > mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++--------------------------- > 5 files changed, 232 insertions(+), 260 deletions(-) > > diff --git a/fsck/fsck.c b/fsck/fsck.c > index e7dd02f..4fbb56d 100644 > --- a/fsck/fsck.c > +++ b/fsck/fsck.c > @@ -1191,7 +1191,7 @@ void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) > if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) > return; > > - start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload); > + start_blk = __start_cp_addr(sbi) + 1 + get_val(sb, cp_payload); > orphan_blkaddr = __start_sum_addr(sbi) - 1; > > orphan_blk = calloc(BLOCK_SZ, 1); > @@ -1324,25 +1324,25 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi) > flags |= CP_ORPHAN_PRESENT_FLAG; > } > > - set_cp(ckpt_flags, flags); > - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); > + set_val(cp, ckpt_flags, flags); > + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); > > - set_cp(free_segment_count, fsck->chk.free_segs); > - set_cp(valid_block_count, fsck->chk.valid_blk_cnt); > - set_cp(valid_node_count, fsck->chk.valid_node_cnt); > - set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); > + set_val(cp, free_segment_count, fsck->chk.free_segs); > + set_val(cp, valid_block_count, fsck->chk.valid_blk_cnt); > + set_val(cp, valid_node_count, fsck->chk.valid_node_cnt); > + set_val(cp, valid_inode_count, fsck->chk.valid_inode_cnt); > > crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); > > - cp_blk_no = get_sb(cp_blkaddr); > + cp_blk_no = get_val(sb, cp_blkaddr); > if (sbi->cur_cp == 2) > - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > > ret = dev_write_block(cp, cp_blk_no++); > ASSERT(ret >= 0); > > - for (i = 0; i < get_sb(cp_payload); i++) { > + for (i = 0; i < get_val(sb, cp_payload); i++) { > ret = dev_write_block(((unsigned char *)cp) + i * F2FS_BLKSIZE, > cp_blk_no++); > ASSERT(ret >= 0); > diff --git a/fsck/main.c b/fsck/main.c > index 54dbb2d..7fcaa5d 100644 > --- a/fsck/main.c > +++ b/fsck/main.c > @@ -255,7 +255,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) > { > struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > > - if (config.defrag_start > get_sb(block_count)) > + if (config.defrag_start > get_val(sb, block_count)) > goto out_range; > if (config.defrag_start < SM_I(sbi)->main_blkaddr) > config.defrag_start = SM_I(sbi)->main_blkaddr; > @@ -263,8 +263,8 @@ static int do_defrag(struct f2fs_sb_info *sbi) > if (config.defrag_len == 0) > config.defrag_len = sbi->blocks_per_seg; > > - if (config.defrag_start + config.defrag_len > get_sb(block_count)) > - config.defrag_len = get_sb(block_count) - config.defrag_start; > + if (config.defrag_start + config.defrag_len > get_val(sb, block_count)) > + config.defrag_len = get_val(sb, block_count) - config.defrag_start; > > if (config.defrag_target == 0) { > config.defrag_target = config.defrag_start - 1; > @@ -273,7 +273,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) > } > > if (config.defrag_target < SM_I(sbi)->main_blkaddr || > - config.defrag_target > get_sb(block_count)) > + config.defrag_target > get_val(sb, block_count)) > goto out_range; > if (config.defrag_target >= config.defrag_start && > config.defrag_target < config.defrag_start + config.defrag_len) > diff --git a/fsck/mount.c b/fsck/mount.c > index 4c807f9..6e6d230 100644 > --- a/fsck/mount.c > +++ b/fsck/mount.c > @@ -269,21 +269,21 @@ int sanity_check_raw_super(struct f2fs_super_block *sb) > { > unsigned int blocksize; > > - if (F2FS_SUPER_MAGIC != get_sb(magic)) > + if (F2FS_SUPER_MAGIC != get_val(sb, magic)) > return -1; > > if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) > return -1; > > - blocksize = 1 << get_sb(log_blocksize); > + blocksize = 1 << get_val(sb, log_blocksize); > if (F2FS_BLKSIZE != blocksize) > return -1; > > - if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || > - get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) > + if (get_val(sb, log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || > + get_val(sb, log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) > return -1; > > - if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != > + if (get_val(sb, log_sectors_per_block) + get_val(sb, log_sectorsize) != > F2FS_MAX_LOG_SECTOR_SIZE) > return -1; > > @@ -350,22 +350,22 @@ int init_sb_info(struct f2fs_sb_info *sbi) > struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > u64 total_sectors; > > - sbi->log_sectors_per_block = get_sb(log_sectors_per_block); > - sbi->log_blocksize = get_sb(log_blocksize); > + sbi->log_sectors_per_block = get_val(sb, log_sectors_per_block); > + sbi->log_blocksize = get_val(sb, log_blocksize); > sbi->blocksize = 1 << sbi->log_blocksize; > - sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); > + sbi->log_blocks_per_seg = get_val(sb, log_blocks_per_seg); > sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; > - sbi->segs_per_sec = get_sb(segs_per_sec); > - sbi->secs_per_zone = get_sb(secs_per_zone); > - sbi->total_sections = get_sb(section_count); > - sbi->total_node_count = (get_sb(segment_count_nat) / 2) * > + sbi->segs_per_sec = get_val(sb, segs_per_sec); > + sbi->secs_per_zone = get_val(sb, secs_per_zone); > + sbi->total_sections = get_val(sb, section_count); > + sbi->total_node_count = (get_val(sb, segment_count_nat) / 2) * > sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; > - sbi->root_ino_num = get_sb(root_ino); > - sbi->node_ino_num = get_sb(node_ino); > - sbi->meta_ino_num = get_sb(meta_ino); > + sbi->root_ino_num = get_val(sb, root_ino); > + sbi->node_ino_num = get_val(sb, node_ino); > + sbi->meta_ino_num = get_val(sb, meta_ino); > sbi->cur_victim_sec = NULL_SEGNO; > > - total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; > + total_sectors = get_val(sb, block_count) << sbi->log_sectors_per_block; > MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", > total_sectors, total_sectors >> 11); > return 0; > @@ -387,7 +387,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > return NULL; > > cp = (struct f2fs_checkpoint *)cp_page_1; > - crc_offset = get_cp(checksum_offset); > + crc_offset = get_val(cp, checksum_offset); > if (crc_offset >= blk_size) > goto invalid_cp1; > > @@ -395,17 +395,17 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > if (f2fs_crc_valid(crc, cp, crc_offset)) > goto invalid_cp1; > > - pre_version = get_cp(checkpoint_ver); > + pre_version = get_val(cp, checkpoint_ver); > > /* Read the 2nd cp block in this CP pack */ > cp_page_2 = malloc(PAGE_SIZE); > - cp_addr += get_cp(cp_pack_total_block_count) - 1; > + cp_addr += get_val(cp, cp_pack_total_block_count) - 1; > > if (dev_read_block(cp_page_2, cp_addr) < 0) > goto invalid_cp2; > > cp = (struct f2fs_checkpoint *)cp_page_2; > - crc_offset = get_cp(checksum_offset); > + crc_offset = get_val(cp, checksum_offset); > if (crc_offset >= blk_size) > goto invalid_cp2; > > @@ -413,7 +413,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > if (f2fs_crc_valid(crc, cp, crc_offset)) > goto invalid_cp2; > > - cur_version = get_cp(checkpoint_ver); > + cur_version = get_val(cp, checkpoint_ver); > > if (cur_version == pre_version) { > *version = cur_version; > @@ -435,7 +435,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > unsigned long blk_size = sbi->blocksize; > unsigned long long cp1_version = 0, cp2_version = 0, version; > unsigned long long cp_start_blk_no; > - unsigned int cp_blks = 1 + get_sb(cp_payload); > + unsigned int cp_blks = 1 + get_val(sb, cp_payload); > int ret; > > sbi->ckpt = malloc(cp_blks * blk_size); > @@ -445,11 +445,11 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > * Finding out valid cp block involves read both > * sets( cp pack1 and cp pack 2) > */ > - cp_start_blk_no = get_sb(cp_blkaddr); > + cp_start_blk_no = get_val(sb, cp_blkaddr); > cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); > > /* The second checkpoint pack should start at the next segment */ > - cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); > + cp_start_blk_no += 1 << get_val(sb, log_blocks_per_seg); > cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); > > if (cp1 && cp2) { > @@ -481,9 +481,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > unsigned int i; > unsigned long long cp_blk_no; > > - cp_blk_no = get_sb(cp_blkaddr); > + cp_blk_no = get_val(sb, cp_blkaddr); > if (cur_page == cp2) > - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > > /* copy sit bitmap */ > for (i = 1; i < cp_blks; i++) { > @@ -510,12 +510,12 @@ int sanity_check_ckpt(struct f2fs_sb_info *sbi) > struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); > > - total = get_sb(segment_count); > - fsmeta = get_sb(segment_count_ckpt); > - fsmeta += get_sb(segment_count_sit); > - fsmeta += get_sb(segment_count_nat); > - fsmeta += get_cp(rsvd_segment_count); > - fsmeta += get_sb(segment_count_ssa); > + total = get_val(sb, segment_count); > + fsmeta = get_val(sb, segment_count_ckpt); > + fsmeta += get_val(sb, segment_count_sit); > + fsmeta += get_val(sb, segment_count_nat); > + fsmeta += get_val(cp, rsvd_segment_count); > + fsmeta += get_val(sb, segment_count_ssa); > > if (fsmeta >= total) > return 1; > @@ -531,16 +531,16 @@ int init_node_manager(struct f2fs_sb_info *sbi) > unsigned char *version_bitmap; > unsigned int nat_segs, nat_blocks; > > - nm_i->nat_blkaddr = get_sb(nat_blkaddr); > + nm_i->nat_blkaddr = get_val(sb, nat_blkaddr); > > /* segment_count_nat includes pair segment so divide to 2. */ > - nat_segs = get_sb(segment_count_nat) >> 1; > - nat_blocks = nat_segs << get_sb(log_blocks_per_seg); > + nat_segs = get_val(sb, segment_count_nat) >> 1; > + nat_blocks = nat_segs << get_val(sb, log_blocks_per_seg); > nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; > nm_i->fcnt = 0; > nm_i->nat_cnt = 0; > - nm_i->init_scan_nid = get_cp(next_free_nid); > - nm_i->next_scan_nid = get_cp(next_free_nid); > + nm_i->init_scan_nid = get_val(cp, next_free_nid); > + nm_i->next_scan_nid = get_val(cp, next_free_nid); > > nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); > > @@ -597,21 +597,21 @@ int build_sit_info(struct f2fs_sb_info *sbi) > return -ENOMEM; > } > > - sit_segs = get_sb(segment_count_sit) >> 1; > + sit_segs = get_val(sb, segment_count_sit) >> 1; > bitmap_size = __bitmap_size(sbi, SIT_BITMAP); > src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); > > dst_bitmap = malloc(bitmap_size); > memcpy(dst_bitmap, src_bitmap, bitmap_size); > > - sit_i->sit_base_addr = get_sb(sit_blkaddr); > + sit_i->sit_base_addr = get_val(sb, sit_blkaddr); > sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; > - sit_i->written_valid_blocks = get_cp(valid_block_count); > + sit_i->written_valid_blocks = get_val(cp, valid_block_count); > sit_i->sit_bitmap = dst_bitmap; > sit_i->bitmap_size = bitmap_size; > sit_i->dirty_sentries = 0; > sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; > - sit_i->elapsed_time = get_cp(elapsed_time); > + sit_i->elapsed_time = get_val(cp, elapsed_time); > return 0; > } > > @@ -716,13 +716,13 @@ static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) > int ret; > > if (IS_DATASEG(type)) { > - segno = get_cp(cur_data_segno[type]); > + segno = get_val(cp, cur_data_segno[type]); > if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) > blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); > else > blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); > } else { > - segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); > + segno = get_val(cp, cur_node_segno[type - CURSEG_HOT_NODE]); > if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) > blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, > type - CURSEG_HOT_NODE); > @@ -803,12 +803,12 @@ static void build_curseg(struct f2fs_sb_info *sbi) > array[i].sum_blk = malloc(PAGE_CACHE_SIZE); > ASSERT(array[i].sum_blk); > if (i <= CURSEG_COLD_DATA) { > - blk_off = get_cp(cur_data_blkoff[i]); > - segno = get_cp(cur_data_segno[i]); > + blk_off = get_val(cp, cur_data_blkoff[i]); > + segno = get_val(cp, cur_data_segno[i]); > } > if (i > CURSEG_COLD_DATA) { > - blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); > - segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); > + blk_off = get_val(cp, cur_node_blkoff[i - CURSEG_HOT_NODE]); > + segno = get_val(cp, cur_node_segno[i - CURSEG_HOT_NODE]); > } > array[i].segno = segno; > array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); > @@ -924,7 +924,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, > > ssa_blk = GET_SUM_BLKADDR(sbi, segno); > for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { > - if (segno == get_cp(cur_node_segno[type])) { > + if (segno == get_val(cp, cur_node_segno[type])) { > curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); > if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { > ASSERT_MSG("segno [0x%x] indicates a data " > @@ -939,7 +939,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, > } > > for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { > - if (segno == get_cp(cur_data_segno[type])) { > + if (segno == get_val(cp, cur_data_segno[type])) { > curseg = CURSEG_I(sbi, type); > if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { > ASSERT_MSG("segno [0x%x] indicates a node " > @@ -1151,13 +1151,13 @@ int build_segment_manager(struct f2fs_sb_info *sbi) > > /* init sm info */ > sbi->sm_info = sm_info; > - sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); > - sm_info->main_blkaddr = get_sb(main_blkaddr); > - sm_info->segment_count = get_sb(segment_count); > - sm_info->reserved_segments = get_cp(rsvd_segment_count); > - sm_info->ovp_segments = get_cp(overprov_segment_count); > - sm_info->main_segments = get_sb(segment_count_main); > - sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); > + sm_info->seg0_blkaddr = get_val(sb, segment0_blkaddr); > + sm_info->main_blkaddr = get_val(sb, main_blkaddr); > + sm_info->segment_count = get_val(sb, segment_count); > + sm_info->reserved_segments = get_val(cp, rsvd_segment_count); > + sm_info->ovp_segments = get_val(cp, overprov_segment_count); > + sm_info->main_segments = get_val(sb, segment_count_main); > + sm_info->ssa_blkaddr = get_val(sb, ssa_blkaddr); > > build_sit_info(sbi); > > @@ -1384,7 +1384,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi) > free_segs++; > } > > - set_cp(free_segment_count, free_segs); > + set_val(cp, free_segment_count, free_segs); > } > > int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type) > @@ -1487,14 +1487,14 @@ void write_curseg_info(struct f2fs_sb_info *sbi) > for (i = 0; i < NO_CHECK_TYPE; i++) { > cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; > if (i < CURSEG_HOT_NODE) { > - set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); > - set_cp(cur_data_blkoff[i], > + set_val(cp, cur_data_segno[i], CURSEG_I(sbi, i)->segno); > + set_val(cp, cur_data_blkoff[i], > CURSEG_I(sbi, i)->next_blkoff); > } else { > int n = i - CURSEG_HOT_NODE; > > - set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); > - set_cp(cur_node_blkoff[n], > + set_val(cp, cur_node_segno[n], CURSEG_I(sbi, i)->segno); > + set_val(cp, cur_node_blkoff[n], > CURSEG_I(sbi, i)->next_blkoff); > } > } > @@ -1578,24 +1578,24 @@ void write_checkpoint(struct f2fs_sb_info *sbi) > flags |= CP_ORPHAN_PRESENT_FLAG; > } > > - set_cp(ckpt_flags, flags); > + set_val(cp, ckpt_flags, flags); > > - set_cp(free_segment_count, get_free_segments(sbi)); > - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); > + set_val(cp, free_segment_count, get_free_segments(sbi)); > + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); > > crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); > > - cp_blk_no = get_sb(cp_blkaddr); > + cp_blk_no = get_val(sb, cp_blkaddr); > if (sbi->cur_cp == 2) > - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > > /* write the first cp */ > ret = dev_write_block(cp, cp_blk_no++); > ASSERT(ret >= 0); > > /* skip payload */ > - cp_blk_no += get_sb(cp_payload); > + cp_blk_no += get_val(sb, cp_payload); > /* skip orphan blocks */ > cp_blk_no += orphan_blks; > > @@ -1635,7 +1635,7 @@ void build_nat_area_bitmap(struct f2fs_sb_info *sbi) > ASSERT(nat_block); > > /* Alloc & build nat entry bitmap */ > - nr_nat_blks = (get_sb(segment_count_nat) / 2) << > + nr_nat_blks = (get_val(sb, segment_count_nat) / 2) << > sbi->log_blocks_per_seg; > > fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; > @@ -1731,7 +1731,7 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) > print_ckpt_info(sbi); > > if (config.auto_fix) { > - u32 flag = get_cp(ckpt_flags); > + u32 flag = get_val(cp, ckpt_flags); > > if (flag & CP_FSCK_FLAG) > config.fix_on = 1; > @@ -1741,10 +1741,10 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) > > config.bug_on = 0; > > - sbi->total_valid_node_count = get_cp(valid_node_count); > - sbi->total_valid_inode_count = get_cp(valid_inode_count); > - sbi->user_block_count = get_cp(user_block_count); > - sbi->total_valid_block_count = get_cp(valid_block_count); > + sbi->total_valid_node_count = get_val(cp, valid_node_count); > + sbi->total_valid_inode_count = get_val(cp, valid_inode_count); > + sbi->user_block_count = get_val(cp, user_block_count); > + sbi->total_valid_block_count = get_val(cp, valid_block_count); > sbi->last_valid_block_count = sbi->total_valid_block_count; > sbi->alloc_valid_block_count = 0; > > diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h > index e1eeb6e..2ab9f49 100644 > --- a/include/f2fs_fs.h > +++ b/include/f2fs_fs.h > @@ -270,60 +270,32 @@ struct f2fs_configuration { > #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG)) > #define BIT_WORD(nr) (nr / BITS_PER_LONG) > > -#define set_sb_le64(member, val) (sb->member = cpu_to_le64(val)) > -#define set_sb_le32(member, val) (sb->member = cpu_to_le32(val)) > -#define set_sb_le16(member, val) (sb->member = cpu_to_le16(val)) > -#define get_sb_le64(member) le64_to_cpu(sb->member) > -#define get_sb_le32(member) le32_to_cpu(sb->member) > -#define get_sb_le16(member) le16_to_cpu(sb->member) > - > -#define set_sb(member, val) \ > - do { \ > - typeof(sb->member) t; \ > - switch (sizeof(t)) { \ > - case 8: set_sb_le64(member, val); break; \ > - case 4: set_sb_le32(member, val); break; \ > - case 2: set_sb_le16(member, val); break; \ > - } \ > +#define set_le64(ptr, member, val) ((ptr)->member = cpu_to_le64(val)) > +#define set_le32(ptr, member, val) ((ptr)->member = cpu_to_le32(val)) > +#define set_le16(ptr, member, val) ((ptr)->member = cpu_to_le16(val)) > +#define get_le64(ptr, member) le64_to_cpu((ptr)->member) > +#define get_le32(ptr, member) le32_to_cpu((ptr)->member) > +#define get_le16(ptr, member) le16_to_cpu((ptr)->member) > + > +#define set_val(ptr, member, val) \ > + do { \ > + typeof((ptr)->member) t; \ > + switch (sizeof(t)) { \ > + case 8: set_le64(ptr, member, val); break; \ > + case 4: set_le32(ptr, member, val); break; \ > + case 2: set_le16(ptr, member, val); break; \ > + } \ > } while(0) > > -#define get_sb(member) \ > - ({ \ > - typeof(sb->member) t; \ > - switch (sizeof(t)) { \ > - case 8: t = get_sb_le64(member); break; \ > - case 4: t = get_sb_le32(member); break; \ > - case 2: t = get_sb_le16(member); break; \ > - } \ > - t; \ > - }) > - > -#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val)) > -#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val)) > -#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val)) > -#define get_cp_le64(member) le64_to_cpu(cp->member) > -#define get_cp_le32(member) le32_to_cpu(cp->member) > -#define get_cp_le16(member) le16_to_cpu(cp->member) > - > -#define set_cp(member, val) \ > - do { \ > - typeof(cp->member) t; \ > - switch (sizeof(t)) { \ > - case 8: set_cp_le64(member, val); break; \ > - case 4: set_cp_le32(member, val); break; \ > - case 2: set_cp_le16(member, val); break; \ > - } \ > - } while(0) > - > -#define get_cp(member) \ > - ({ \ > - typeof(cp->member) t; \ > - switch (sizeof(t)) { \ > - case 8: t = get_cp_le64(member); break; \ > - case 4: t = get_cp_le32(member); break; \ > - case 2: t = get_cp_le16(member); break; \ > - } \ > - t; \ > +#define get_val(ptr, member) \ > + ({ \ > + typeof((ptr)->member) t; \ > + switch (sizeof(t)) { \ > + case 8: t = get_le64(ptr, member); break; \ > + case 4: t = get_le32(ptr, member); break; \ > + case 2: t = get_le16(ptr, member); break; \ > + } \ > + t; \ > }) > > /* > @@ -899,7 +871,7 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) > double reserved, ovp, candidate, end, diff, space; > double max_ovp = 0, max_space = 0; > > - if (get_sb(segment_count_main) < 256) { > + if (get_val(sb, segment_count_main) < 256) { > candidate = 10; > end = 95; > diff = 5; > @@ -911,9 +883,9 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) > > for (; candidate <= end; candidate += diff) { > reserved = (2 * (100 / candidate + 1) + 6) * > - get_sb(segs_per_sec); > - ovp = (get_sb(segment_count_main) - reserved) * candidate / 100; > - space = get_sb(segment_count_main) - reserved - ovp; > + get_val(sb, segs_per_sec); > + ovp = (get_val(sb, segment_count_main) - reserved) * candidate / 100; > + space = get_val(sb, segment_count_main) - reserved - ovp; > if (max_space < space) { > max_space = space; > max_ovp = candidate; > diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c > index 645c2aa..db5348e 100644 > --- a/mkfs/f2fs_format.c > +++ b/mkfs/f2fs_format.c > @@ -83,7 +83,7 @@ static void configure_extension_list(void) > int name_len; > int i = 0; > > - set_sb(extension_count, 0); > + set_val(sb, extension_count, 0); > memset(sb->extension_list, 0, sizeof(sb->extension_list)); > > while (*extlist) { > @@ -91,7 +91,7 @@ static void configure_extension_list(void) > memcpy(sb->extension_list[i++], *extlist, name_len); > extlist++; > } > - set_sb(extension_count, i); > + set_val(sb, extension_count, i); > > if (!ext_str) > return; > @@ -112,7 +112,7 @@ next: > break; > } > > - set_sb(extension_count, i); > + set_val(sb, extension_count, i); > > free(config.extension_list); > } > @@ -132,23 +132,23 @@ static int f2fs_prepare_super_block(void) > u_int32_t max_nat_bitmap_size, max_nat_segments; > u_int32_t total_zones; > > - set_sb(magic, F2FS_SUPER_MAGIC); > - set_sb(major_ver, F2FS_MAJOR_VERSION); > - set_sb(minor_ver, F2FS_MINOR_VERSION); > + set_val(sb, magic, F2FS_SUPER_MAGIC); > + set_val(sb, major_ver, F2FS_MAJOR_VERSION); > + set_val(sb, minor_ver, F2FS_MINOR_VERSION); > > log_sectorsize = log_base_2(config.sector_size); > log_sectors_per_block = log_base_2(config.sectors_per_blk); > log_blocksize = log_sectorsize + log_sectors_per_block; > log_blks_per_seg = log_base_2(config.blks_per_seg); > > - set_sb(log_sectorsize, log_sectorsize); > - set_sb(log_sectors_per_block, log_sectors_per_block); > + set_val(sb, log_sectorsize, log_sectorsize); > + set_val(sb, log_sectors_per_block, log_sectors_per_block); > > - set_sb(log_blocksize, log_blocksize); > - set_sb(log_blocks_per_seg, log_blks_per_seg); > + set_val(sb, log_blocksize, log_blocksize); > + set_val(sb, log_blocks_per_seg, log_blks_per_seg); > > - set_sb(segs_per_sec, config.segs_per_sec); > - set_sb(secs_per_zone, config.secs_per_zone); > + set_val(sb, segs_per_sec, config.segs_per_sec); > + set_val(sb, secs_per_zone, config.secs_per_zone); > > blk_size_bytes = 1 << log_blocksize; > segment_size_bytes = blk_size_bytes * config.blks_per_seg; > @@ -156,9 +156,9 @@ static int f2fs_prepare_super_block(void) > blk_size_bytes * config.secs_per_zone * > config.segs_per_sec * config.blks_per_seg; > > - set_sb(checksum_offset, 0); > + set_val(sb, checksum_offset, 0); > > - set_sb(block_count, config.total_sectors >> log_sectors_per_block); > + set_val(sb, block_count, config.total_sectors >> log_sectors_per_block); > > zone_align_start_offset = > (config.start_sector * config.sector_size + > @@ -174,41 +174,41 @@ static int f2fs_prepare_super_block(void) > config.sectors_per_blk); > } > > - set_sb(segment_count, (config.total_sectors * config.sector_size - > + set_val(sb, segment_count, (config.total_sectors * config.sector_size - > zone_align_start_offset) / segment_size_bytes); > > - set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes); > + set_val(sb, segment0_blkaddr, zone_align_start_offset / blk_size_bytes); > sb->cp_blkaddr = sb->segment0_blkaddr; > > - MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr)); > + MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_val(sb, segment0_blkaddr)); > > - set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); > + set_val(sb, segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); > > - set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) * > + set_val(sb, sit_blkaddr, get_val(sb, segment0_blkaddr) + get_val(sb, segment_count_ckpt) * > config.blks_per_seg); > > - blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK); > + blocks_for_sit = ALIGN(get_val(sb, segment_count), SIT_ENTRY_PER_BLOCK); > > sit_segments = SEG_ALIGN(blocks_for_sit); > > - set_sb(segment_count_sit, sit_segments * 2); > + set_val(sb, segment_count_sit, sit_segments * 2); > > - set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) * > + set_val(sb, nat_blkaddr, get_val(sb, sit_blkaddr) + get_val(sb, segment_count_sit) * > config.blks_per_seg); > > - total_valid_blks_available = (get_sb(segment_count) - > - (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) * > + total_valid_blks_available = (get_val(sb, segment_count) - > + (get_val(sb, segment_count_ckpt) + get_val(sb, segment_count_sit))) * > config.blks_per_seg; > > blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK); > > - set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat)); > + set_val(sb, segment_count_nat, SEG_ALIGN(blocks_for_nat)); > /* > * The number of node segments should not be exceeded a "Threshold". > * This number resizes NAT bitmap area in a CP page. > * So the threshold is determined not to overflow one CP page > */ > - sit_bitmap_size = ((get_sb(segment_count_sit) / 2) << > + sit_bitmap_size = ((get_val(sb, segment_count_sit) / 2) << > log_blks_per_seg) / 8; > > if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE) > @@ -223,55 +223,55 @@ static int f2fs_prepare_super_block(void) > if (max_sit_bitmap_size > > (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - 64)) { > max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1; > - set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); > + set_val(sb, cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); > } else { > max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 > - max_sit_bitmap_size; > - set_sb(cp_payload, 0); > + set_val(sb, cp_payload, 0); > } > > max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; > > - if (get_sb(segment_count_nat) > max_nat_segments) > - set_sb(segment_count_nat, max_nat_segments); > + if (get_val(sb, segment_count_nat) > max_nat_segments) > + set_val(sb, segment_count_nat, max_nat_segments); > > - set_sb(segment_count_nat, get_sb(segment_count_nat) * 2); > + set_val(sb, segment_count_nat, get_val(sb, segment_count_nat) * 2); > > - set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) * > + set_val(sb, ssa_blkaddr, get_val(sb, nat_blkaddr) + get_val(sb, segment_count_nat) * > config.blks_per_seg); > > - total_valid_blks_available = (get_sb(segment_count) - > - (get_sb(segment_count_ckpt) + > - get_sb(segment_count_sit) + > - get_sb(segment_count_nat))) * > + total_valid_blks_available = (get_val(sb, segment_count) - > + (get_val(sb, segment_count_ckpt) + > + get_val(sb, segment_count_sit) + > + get_val(sb, segment_count_nat))) * > config.blks_per_seg; > > blocks_for_ssa = total_valid_blks_available / > config.blks_per_seg + 1; > > - set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); > + set_val(sb, segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); > > - total_meta_segments = get_sb(segment_count_ckpt) + > - get_sb(segment_count_sit) + > - get_sb(segment_count_nat) + > - get_sb(segment_count_ssa); > + total_meta_segments = get_val(sb, segment_count_ckpt) + > + get_val(sb, segment_count_sit) + > + get_val(sb, segment_count_nat) + > + get_val(sb, segment_count_ssa); > diff = total_meta_segments % (config.segs_per_zone); > if (diff) > - set_sb(segment_count_ssa, get_sb(segment_count_ssa) + > + set_val(sb, segment_count_ssa, get_val(sb, segment_count_ssa) + > (config.segs_per_zone - diff)); > > total_meta_zones = ZONE_ALIGN(total_meta_segments * > config.blks_per_seg); > > - set_sb(main_blkaddr, get_sb(segment0_blkaddr) + total_meta_zones * > + set_val(sb, main_blkaddr, get_val(sb, segment0_blkaddr) + total_meta_zones * > config.segs_per_zone * config.blks_per_seg); > > - total_zones = get_sb(segment_count) / (config.segs_per_zone) - > + total_zones = get_val(sb, segment_count) / (config.segs_per_zone) - > total_meta_zones; > > - set_sb(section_count, total_zones * config.secs_per_zone); > + set_val(sb, section_count, total_zones * config.secs_per_zone); > > - set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec); > + set_val(sb, segment_count_main, get_val(sb, section_count) * config.segs_per_sec); > > /* Let's determine the best reserved and overprovisioned space */ > if (config.overprovision == 0) > @@ -281,12 +281,12 @@ static int f2fs_prepare_super_block(void) > (2 * (100 / config.overprovision + 1) + 6) > * config.segs_per_sec; > > - if ((get_sb(segment_count_main) - 2) < > + if ((get_val(sb, segment_count_main) - 2) < > config.reserved_segments) { > MSG(1, "\tError: Device size is not sufficient for F2FS volume,\ > more segment needed =%u", > config.reserved_segments - > - (get_sb(segment_count_main) - 2)); > + (get_val(sb, segment_count_main) - 2)); > return -1; > } > > @@ -294,9 +294,9 @@ static int f2fs_prepare_super_block(void) > > utf8_to_utf16(sb->volume_name, (const char *)config.vol_label, > MAX_VOLUME_NAME, strlen(config.vol_label)); > - set_sb(node_ino, 1); > - set_sb(meta_ino, 2); > - set_sb(root_ino, 3); > + set_val(sb, node_ino, 1); > + set_val(sb, meta_ino, 2); > + set_val(sb, root_ino, 3); > > if (total_zones <= 6) { > MSG(1, "\tError: %d zones: Need more zones \ > @@ -346,8 +346,8 @@ static int f2fs_init_sit_area(void) > u_int64_t sit_seg_addr = 0; > u_int8_t *zero_buf = NULL; > > - blk_size = 1 << get_sb(log_blocksize); > - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; > + blk_size = 1 << get_val(sb, log_blocksize); > + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; > > zero_buf = calloc(sizeof(u_int8_t), seg_size); > if(zero_buf == NULL) { > @@ -355,11 +355,11 @@ static int f2fs_init_sit_area(void) > return -1; > } > > - sit_seg_addr = get_sb(sit_blkaddr); > + sit_seg_addr = get_val(sb, sit_blkaddr); > sit_seg_addr *= blk_size; > > DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr); > - for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) { > + for (index = 0; index < (get_val(sb, segment_count_sit) / 2); index++) { > if (dev_fill(zero_buf, sit_seg_addr, seg_size)) { > MSG(1, "\tError: While zeroing out the sit area \ > on disk!!!\n"); > @@ -380,8 +380,8 @@ static int f2fs_init_nat_area(void) > u_int64_t nat_seg_addr = 0; > u_int8_t *nat_buf = NULL; > > - blk_size = 1 << get_sb(log_blocksize); > - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; > + blk_size = 1 << get_val(sb, log_blocksize); > + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; > > nat_buf = calloc(sizeof(u_int8_t), seg_size); > if (nat_buf == NULL) { > @@ -389,11 +389,11 @@ static int f2fs_init_nat_area(void) > return -1; > } > > - nat_seg_addr = get_sb(nat_blkaddr); > + nat_seg_addr = get_val(sb, nat_blkaddr); > nat_seg_addr *= blk_size; > > DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr); > - for (index = 0; index < get_sb(segment_count_nat) / 2; index++) { > + for (index = 0; index < get_val(sb, segment_count_nat) / 2; index++) { > if (dev_fill(nat_buf, nat_seg_addr, seg_size)) { > MSG(1, "\tError: While zeroing out the nat area \ > on disk!!!\n"); > @@ -445,58 +445,58 @@ static int f2fs_write_check_point_pack(void) > } > > /* 1. cp page 1 of checkpoint pack 1 */ > - set_cp(checkpoint_ver, 1); > - set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); > - set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); > - set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); > - set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); > - set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); > - set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); > + set_val(cp, checkpoint_ver, 1); > + set_val(cp, cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); > + set_val(cp, cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); > + set_val(cp, cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); > + set_val(cp, cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); > + set_val(cp, cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); > + set_val(cp, cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); > for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { > - set_cp(cur_node_segno[i], 0xffffffff); > - set_cp(cur_data_segno[i], 0xffffffff); > + set_val(cp, cur_node_segno[i], 0xffffffff); > + set_val(cp, cur_data_segno[i], 0xffffffff); > } > > - set_cp(cur_node_blkoff[0], 1); > - set_cp(cur_data_blkoff[0], 1); > - set_cp(valid_block_count, 2); > - set_cp(rsvd_segment_count, config.reserved_segments); > - set_cp(overprov_segment_count, (get_sb(segment_count_main) - > - get_cp(rsvd_segment_count)) * > + set_val(cp, cur_node_blkoff[0], 1); > + set_val(cp, cur_data_blkoff[0], 1); > + set_val(cp, valid_block_count, 2); > + set_val(cp, rsvd_segment_count, config.reserved_segments); > + set_val(cp, overprov_segment_count, (get_val(sb, segment_count_main) - > + get_val(cp, rsvd_segment_count)) * > config.overprovision / 100); > - set_cp(overprov_segment_count, get_cp(overprov_segment_count) + > - get_cp(rsvd_segment_count)); > + set_val(cp, overprov_segment_count, get_val(cp, overprov_segment_count) + > + get_val(cp, rsvd_segment_count)); > > MSG(0, "Info: Overprovision ratio = %.3lf%%\n", config.overprovision); > MSG(0, "Info: Overprovision segments = %u (GC reserved = %u)\n", > - get_cp(overprov_segment_count), > + get_val(cp, overprov_segment_count), > config.reserved_segments); > > /* main segments - reserved segments - (node + data segments) */ > - set_cp(free_segment_count, get_sb(segment_count_main) - 6); > - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - > - get_cp(overprov_segment_count)) * config.blks_per_seg)); > + set_val(cp, free_segment_count, get_val(sb, segment_count_main) - 6); > + set_val(cp, user_block_count, ((get_val(cp, free_segment_count) + 6 - > + get_val(cp, overprov_segment_count)) * config.blks_per_seg)); > /* cp page (2), data summaries (1), node summaries (3) */ > - set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); > - set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); > - set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); > - set_cp(valid_node_count, 1); > - set_cp(valid_inode_count, 1); > - set_cp(next_free_nid, get_sb(root_ino) + 1); > - set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << > - get_sb(log_blocks_per_seg)) / 8); > + set_val(cp, cp_pack_total_block_count, 6 + get_val(sb, cp_payload)); > + set_val(cp, ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); > + set_val(cp, cp_pack_start_sum, 1 + get_val(sb, cp_payload)); > + set_val(cp, valid_node_count, 1); > + set_val(cp, valid_inode_count, 1); > + set_val(cp, next_free_nid, get_val(sb, root_ino) + 1); > + set_val(cp, sit_ver_bitmap_bytesize, ((get_val(sb, segment_count_sit) / 2) << > + get_val(sb, log_blocks_per_seg)) / 8); > > - set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) << > - get_sb(log_blocks_per_seg)) / 8); > + set_val(cp, nat_ver_bitmap_bytesize, ((get_val(sb, segment_count_nat) / 2) << > + get_val(sb, log_blocks_per_seg)) / 8); > > - set_cp(checksum_offset, CHECKSUM_OFFSET); > + set_val(cp, checksum_offset, CHECKSUM_OFFSET); > > crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = > cpu_to_le32(crc); > > - blk_size_bytes = 1 << get_sb(log_blocksize); > - cp_seg_blk_offset = get_sb(segment0_blkaddr); > + blk_size_bytes = 1 << get_val(sb, log_blocksize); > + cp_seg_blk_offset = get_val(sb, segment0_blkaddr); > cp_seg_blk_offset *= blk_size_bytes; > > DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > @@ -505,7 +505,7 @@ static int f2fs_write_check_point_pack(void) > goto free_cp_payload; > } > > - for (i = 0; i < get_sb(cp_payload); i++) { > + for (i = 0; i < get_val(sb, cp_payload); i++) { > cp_seg_blk_offset += blk_size_bytes; > if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { > MSG(1, "\tError: While zeroing out the sit bitmap area \ > @@ -537,8 +537,8 @@ static int f2fs_write_check_point_pack(void) > sum->nat_j.entries[0].ne.version = 0; > sum->nat_j.entries[0].ne.ino = sb->root_ino; > sum->nat_j.entries[0].ne.block_addr = cpu_to_le32( > - get_sb(main_blkaddr) + > - get_cp(cur_node_segno[0]) * config.blks_per_seg); > + get_val(sb, main_blkaddr) + > + get_val(cp, cur_node_segno[0]) * config.blks_per_seg); > > memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE); > sum_compact_p += SUM_JOURNAL_SIZE; > @@ -635,7 +635,7 @@ static int f2fs_write_check_point_pack(void) > crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = > cpu_to_le32(crc); > - cp_seg_blk_offset = (get_sb(segment0_blkaddr) + > + cp_seg_blk_offset = (get_val(sb, segment0_blkaddr) + > config.blks_per_seg) * > blk_size_bytes; > DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > @@ -644,7 +644,7 @@ static int f2fs_write_check_point_pack(void) > goto free_cp_payload; > } > > - for (i = 0; i < get_sb(cp_payload); i++) { > + for (i = 0; i < get_val(sb, cp_payload); i++) { > cp_seg_blk_offset += blk_size_bytes; > if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { > MSG(1, "\tError: While zeroing out the sit bitmap area \ > @@ -655,7 +655,7 @@ static int f2fs_write_check_point_pack(void) > > /* cp page 2 of check point pack 2 */ > cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count) > - - get_sb(cp_payload) - 1); > + - get_val(sb, cp_payload) - 1); > DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) { > MSG(1, "\tError: While writing the cp to disk!!!\n"); > @@ -701,8 +701,8 @@ static int f2fs_write_super_block(void) > static int discard_obsolete_dnode(struct f2fs_node *raw_node, u_int64_t offset) > { > do { > - if (offset < get_sb(main_blkaddr) || > - offset >= get_sb(main_blkaddr) + get_sb(block_count)) > + if (offset < get_val(sb, main_blkaddr) || > + offset >= get_val(sb, main_blkaddr) + get_val(sb, block_count)) > break; > > if (dev_read_block(raw_node, offset)) { > @@ -740,7 +740,7 @@ static int f2fs_write_root_inode(void) > raw_node->footer.ino = sb->root_ino; > raw_node->footer.cp_ver = cpu_to_le64(1); > raw_node->footer.next_blkaddr = cpu_to_le32( > - get_sb(main_blkaddr) + > + get_val(sb, main_blkaddr) + > config.cur_seg[CURSEG_HOT_NODE] * > config.blks_per_seg + 1); > > @@ -749,7 +749,7 @@ static int f2fs_write_root_inode(void) > raw_node->i.i_uid = cpu_to_le32(getuid()); > raw_node->i.i_gid = cpu_to_le32(getgid()); > > - blk_size_bytes = 1 << get_sb(log_blocksize); > + blk_size_bytes = 1 << get_val(sb, log_blocksize); > raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */ > raw_node->i.i_blocks = cpu_to_le64(2); > > @@ -765,7 +765,7 @@ static int f2fs_write_root_inode(void) > raw_node->i.i_current_depth = cpu_to_le32(1); > raw_node->i.i_dir_level = DEF_DIR_LEVEL; > > - data_blk_nor = get_sb(main_blkaddr) + > + data_blk_nor = get_val(sb, main_blkaddr) + > config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; > raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor); > > @@ -773,7 +773,7 @@ static int f2fs_write_root_inode(void) > raw_node->i.i_ext.blk_addr = 0; > raw_node->i.i_ext.len = 0; > > - main_area_node_seg_blk_offset = get_sb(main_blkaddr); > + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); > main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] * > config.blks_per_seg; > main_area_node_seg_blk_offset *= blk_size_bytes; > @@ -786,7 +786,7 @@ static int f2fs_write_root_inode(void) > } > > /* avoid power-off-recovery based on roll-forward policy */ > - main_area_node_seg_blk_offset = get_sb(main_blkaddr); > + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); > main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] * > config.blks_per_seg; > > @@ -813,21 +813,21 @@ static int f2fs_update_nat_root(void) > } > > /* update root */ > - nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32( > - get_sb(main_blkaddr) + > + nat_blk->entries[get_val(sb, root_ino)].block_addr = cpu_to_le32( > + get_val(sb, main_blkaddr) + > config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg); > - nat_blk->entries[get_sb(root_ino)].ino = sb->root_ino; > + nat_blk->entries[get_val(sb, root_ino)].ino = sb->root_ino; > > /* update node nat */ > - nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1); > - nat_blk->entries[get_sb(node_ino)].ino = sb->node_ino; > + nat_blk->entries[get_val(sb, node_ino)].block_addr = cpu_to_le32(1); > + nat_blk->entries[get_val(sb, node_ino)].ino = sb->node_ino; > > /* update meta nat */ > - nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1); > - nat_blk->entries[get_sb(meta_ino)].ino = sb->meta_ino; > + nat_blk->entries[get_val(sb, meta_ino)].block_addr = cpu_to_le32(1); > + nat_blk->entries[get_val(sb, meta_ino)].ino = sb->meta_ino; > > - blk_size_bytes = 1 << get_sb(log_blocksize); > - nat_seg_blk_offset = get_sb(nat_blkaddr); > + blk_size_bytes = 1 << get_val(sb, log_blocksize); > + nat_seg_blk_offset = get_val(sb, nat_blkaddr); > nat_seg_blk_offset *= blk_size_bytes; > > DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset); > @@ -867,8 +867,8 @@ static int f2fs_add_default_dentry_root(void) > /* bitmap for . and .. */ > test_and_set_bit_le(0, dent_blk->dentry_bitmap); > test_and_set_bit_le(1, dent_blk->dentry_bitmap); > - blk_size_bytes = 1 << get_sb(log_blocksize); > - data_blk_offset = get_sb(main_blkaddr); > + blk_size_bytes = 1 << get_val(sb, log_blocksize); > + data_blk_offset = get_val(sb, main_blkaddr); > data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] * > config.blks_per_seg; > data_blk_offset *= blk_size_bytes; > -- > 1.9.1 > > > ------------------------------------------------------------------------------ > Site24x7 APM Insight: Get Deep Visibility into Application Performance > APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month > Monitor end-to-end web transactions and take corrective actions now > Troubleshoot faster and improve end-user experience. Signup Now! > http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 > _______________________________________________ > Linux-f2fs-devel mailing list > Linux-f2fs-devel@lists.sourceforge.net > https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} 2016-01-30 1:46 ` Jaegeuk Kim @ 2016-01-30 2:25 ` Sheng Yong 2016-01-30 10:03 ` [RFC PATCH v2] " Sheng Yong 2016-02-02 0:27 ` [RFC PATCH 1/4] " Jaegeuk Kim 0 siblings, 2 replies; 9+ messages in thread From: Sheng Yong @ 2016-01-30 2:25 UTC (permalink / raw) To: Jaegeuk Kim; +Cc: linux-f2fs-devel Hi, Kim On 1/30/2016 9:46 AM, Jaegeuk Kim wrote: > Hi Sheng, > > This is not a good way. > You're asking to change all the pending patches as well. > > Why not just adding two definitions like these? > > #define get_sb(member) get_val(sb, member) > #define set_sb(member, val) set_sb(sb, member, val) > #define get_cp(member) get_val(cp, member) > #define set_cp(member, val) set_sb(cp, member, val) > You mean we should still keep the get_{sb|cp} and set_{sb|cp} for some time but mark them as deprecated? Anyway, this is a trivial cleanup. I think it's ok to keep it as it is now :) thanks, Sheng > Thanks, > > On Sat, Jan 30, 2016 at 09:16:36AM +0000, Sheng Yong wrote: >> * Remove dumplicated definitions of get_{sb|cp} and set_{sb|cp}, and introduce >> micros get_val and set_val instead. >> * Add a new parameter to get_val and set_val so that they are not depended on >> implied definition of `sb' and `cp'. >> >> Signed-off-by: Sheng Yong <shengyong1@huawei.com> >> --- >> fsck/fsck.c | 20 ++--- >> fsck/main.c | 8 +- >> fsck/mount.c | 146 ++++++++++++++++----------------- >> include/f2fs_fs.h | 84 +++++++------------ >> mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++--------------------------- >> 5 files changed, 232 insertions(+), 260 deletions(-) >> >> diff --git a/fsck/fsck.c b/fsck/fsck.c >> index e7dd02f..4fbb56d 100644 >> --- a/fsck/fsck.c >> +++ b/fsck/fsck.c >> @@ -1191,7 +1191,7 @@ void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) >> if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) >> return; >> >> - start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload); >> + start_blk = __start_cp_addr(sbi) + 1 + get_val(sb, cp_payload); >> orphan_blkaddr = __start_sum_addr(sbi) - 1; >> >> orphan_blk = calloc(BLOCK_SZ, 1); >> @@ -1324,25 +1324,25 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi) >> flags |= CP_ORPHAN_PRESENT_FLAG; >> } >> >> - set_cp(ckpt_flags, flags); >> - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); >> + set_val(cp, ckpt_flags, flags); >> + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); >> >> - set_cp(free_segment_count, fsck->chk.free_segs); >> - set_cp(valid_block_count, fsck->chk.valid_blk_cnt); >> - set_cp(valid_node_count, fsck->chk.valid_node_cnt); >> - set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); >> + set_val(cp, free_segment_count, fsck->chk.free_segs); >> + set_val(cp, valid_block_count, fsck->chk.valid_blk_cnt); >> + set_val(cp, valid_node_count, fsck->chk.valid_node_cnt); >> + set_val(cp, valid_inode_count, fsck->chk.valid_inode_cnt); >> >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); >> >> - cp_blk_no = get_sb(cp_blkaddr); >> + cp_blk_no = get_val(sb, cp_blkaddr); >> if (sbi->cur_cp == 2) >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); >> >> ret = dev_write_block(cp, cp_blk_no++); >> ASSERT(ret >= 0); >> >> - for (i = 0; i < get_sb(cp_payload); i++) { >> + for (i = 0; i < get_val(sb, cp_payload); i++) { >> ret = dev_write_block(((unsigned char *)cp) + i * F2FS_BLKSIZE, >> cp_blk_no++); >> ASSERT(ret >= 0); >> diff --git a/fsck/main.c b/fsck/main.c >> index 54dbb2d..7fcaa5d 100644 >> --- a/fsck/main.c >> +++ b/fsck/main.c >> @@ -255,7 +255,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) >> { >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); >> >> - if (config.defrag_start > get_sb(block_count)) >> + if (config.defrag_start > get_val(sb, block_count)) >> goto out_range; >> if (config.defrag_start < SM_I(sbi)->main_blkaddr) >> config.defrag_start = SM_I(sbi)->main_blkaddr; >> @@ -263,8 +263,8 @@ static int do_defrag(struct f2fs_sb_info *sbi) >> if (config.defrag_len == 0) >> config.defrag_len = sbi->blocks_per_seg; >> >> - if (config.defrag_start + config.defrag_len > get_sb(block_count)) >> - config.defrag_len = get_sb(block_count) - config.defrag_start; >> + if (config.defrag_start + config.defrag_len > get_val(sb, block_count)) >> + config.defrag_len = get_val(sb, block_count) - config.defrag_start; >> >> if (config.defrag_target == 0) { >> config.defrag_target = config.defrag_start - 1; >> @@ -273,7 +273,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) >> } >> >> if (config.defrag_target < SM_I(sbi)->main_blkaddr || >> - config.defrag_target > get_sb(block_count)) >> + config.defrag_target > get_val(sb, block_count)) >> goto out_range; >> if (config.defrag_target >= config.defrag_start && >> config.defrag_target < config.defrag_start + config.defrag_len) >> diff --git a/fsck/mount.c b/fsck/mount.c >> index 4c807f9..6e6d230 100644 >> --- a/fsck/mount.c >> +++ b/fsck/mount.c >> @@ -269,21 +269,21 @@ int sanity_check_raw_super(struct f2fs_super_block *sb) >> { >> unsigned int blocksize; >> >> - if (F2FS_SUPER_MAGIC != get_sb(magic)) >> + if (F2FS_SUPER_MAGIC != get_val(sb, magic)) >> return -1; >> >> if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) >> return -1; >> >> - blocksize = 1 << get_sb(log_blocksize); >> + blocksize = 1 << get_val(sb, log_blocksize); >> if (F2FS_BLKSIZE != blocksize) >> return -1; >> >> - if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || >> - get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) >> + if (get_val(sb, log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || >> + get_val(sb, log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) >> return -1; >> >> - if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != >> + if (get_val(sb, log_sectors_per_block) + get_val(sb, log_sectorsize) != >> F2FS_MAX_LOG_SECTOR_SIZE) >> return -1; >> >> @@ -350,22 +350,22 @@ int init_sb_info(struct f2fs_sb_info *sbi) >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); >> u64 total_sectors; >> >> - sbi->log_sectors_per_block = get_sb(log_sectors_per_block); >> - sbi->log_blocksize = get_sb(log_blocksize); >> + sbi->log_sectors_per_block = get_val(sb, log_sectors_per_block); >> + sbi->log_blocksize = get_val(sb, log_blocksize); >> sbi->blocksize = 1 << sbi->log_blocksize; >> - sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); >> + sbi->log_blocks_per_seg = get_val(sb, log_blocks_per_seg); >> sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; >> - sbi->segs_per_sec = get_sb(segs_per_sec); >> - sbi->secs_per_zone = get_sb(secs_per_zone); >> - sbi->total_sections = get_sb(section_count); >> - sbi->total_node_count = (get_sb(segment_count_nat) / 2) * >> + sbi->segs_per_sec = get_val(sb, segs_per_sec); >> + sbi->secs_per_zone = get_val(sb, secs_per_zone); >> + sbi->total_sections = get_val(sb, section_count); >> + sbi->total_node_count = (get_val(sb, segment_count_nat) / 2) * >> sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; >> - sbi->root_ino_num = get_sb(root_ino); >> - sbi->node_ino_num = get_sb(node_ino); >> - sbi->meta_ino_num = get_sb(meta_ino); >> + sbi->root_ino_num = get_val(sb, root_ino); >> + sbi->node_ino_num = get_val(sb, node_ino); >> + sbi->meta_ino_num = get_val(sb, meta_ino); >> sbi->cur_victim_sec = NULL_SEGNO; >> >> - total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; >> + total_sectors = get_val(sb, block_count) << sbi->log_sectors_per_block; >> MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", >> total_sectors, total_sectors >> 11); >> return 0; >> @@ -387,7 +387,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, >> return NULL; >> >> cp = (struct f2fs_checkpoint *)cp_page_1; >> - crc_offset = get_cp(checksum_offset); >> + crc_offset = get_val(cp, checksum_offset); >> if (crc_offset >= blk_size) >> goto invalid_cp1; >> >> @@ -395,17 +395,17 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, >> if (f2fs_crc_valid(crc, cp, crc_offset)) >> goto invalid_cp1; >> >> - pre_version = get_cp(checkpoint_ver); >> + pre_version = get_val(cp, checkpoint_ver); >> >> /* Read the 2nd cp block in this CP pack */ >> cp_page_2 = malloc(PAGE_SIZE); >> - cp_addr += get_cp(cp_pack_total_block_count) - 1; >> + cp_addr += get_val(cp, cp_pack_total_block_count) - 1; >> >> if (dev_read_block(cp_page_2, cp_addr) < 0) >> goto invalid_cp2; >> >> cp = (struct f2fs_checkpoint *)cp_page_2; >> - crc_offset = get_cp(checksum_offset); >> + crc_offset = get_val(cp, checksum_offset); >> if (crc_offset >= blk_size) >> goto invalid_cp2; >> >> @@ -413,7 +413,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, >> if (f2fs_crc_valid(crc, cp, crc_offset)) >> goto invalid_cp2; >> >> - cur_version = get_cp(checkpoint_ver); >> + cur_version = get_val(cp, checkpoint_ver); >> >> if (cur_version == pre_version) { >> *version = cur_version; >> @@ -435,7 +435,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) >> unsigned long blk_size = sbi->blocksize; >> unsigned long long cp1_version = 0, cp2_version = 0, version; >> unsigned long long cp_start_blk_no; >> - unsigned int cp_blks = 1 + get_sb(cp_payload); >> + unsigned int cp_blks = 1 + get_val(sb, cp_payload); >> int ret; >> >> sbi->ckpt = malloc(cp_blks * blk_size); >> @@ -445,11 +445,11 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) >> * Finding out valid cp block involves read both >> * sets( cp pack1 and cp pack 2) >> */ >> - cp_start_blk_no = get_sb(cp_blkaddr); >> + cp_start_blk_no = get_val(sb, cp_blkaddr); >> cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); >> >> /* The second checkpoint pack should start at the next segment */ >> - cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); >> + cp_start_blk_no += 1 << get_val(sb, log_blocks_per_seg); >> cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); >> >> if (cp1 && cp2) { >> @@ -481,9 +481,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) >> unsigned int i; >> unsigned long long cp_blk_no; >> >> - cp_blk_no = get_sb(cp_blkaddr); >> + cp_blk_no = get_val(sb, cp_blkaddr); >> if (cur_page == cp2) >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); >> >> /* copy sit bitmap */ >> for (i = 1; i < cp_blks; i++) { >> @@ -510,12 +510,12 @@ int sanity_check_ckpt(struct f2fs_sb_info *sbi) >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); >> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); >> >> - total = get_sb(segment_count); >> - fsmeta = get_sb(segment_count_ckpt); >> - fsmeta += get_sb(segment_count_sit); >> - fsmeta += get_sb(segment_count_nat); >> - fsmeta += get_cp(rsvd_segment_count); >> - fsmeta += get_sb(segment_count_ssa); >> + total = get_val(sb, segment_count); >> + fsmeta = get_val(sb, segment_count_ckpt); >> + fsmeta += get_val(sb, segment_count_sit); >> + fsmeta += get_val(sb, segment_count_nat); >> + fsmeta += get_val(cp, rsvd_segment_count); >> + fsmeta += get_val(sb, segment_count_ssa); >> >> if (fsmeta >= total) >> return 1; >> @@ -531,16 +531,16 @@ int init_node_manager(struct f2fs_sb_info *sbi) >> unsigned char *version_bitmap; >> unsigned int nat_segs, nat_blocks; >> >> - nm_i->nat_blkaddr = get_sb(nat_blkaddr); >> + nm_i->nat_blkaddr = get_val(sb, nat_blkaddr); >> >> /* segment_count_nat includes pair segment so divide to 2. */ >> - nat_segs = get_sb(segment_count_nat) >> 1; >> - nat_blocks = nat_segs << get_sb(log_blocks_per_seg); >> + nat_segs = get_val(sb, segment_count_nat) >> 1; >> + nat_blocks = nat_segs << get_val(sb, log_blocks_per_seg); >> nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; >> nm_i->fcnt = 0; >> nm_i->nat_cnt = 0; >> - nm_i->init_scan_nid = get_cp(next_free_nid); >> - nm_i->next_scan_nid = get_cp(next_free_nid); >> + nm_i->init_scan_nid = get_val(cp, next_free_nid); >> + nm_i->next_scan_nid = get_val(cp, next_free_nid); >> >> nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); >> >> @@ -597,21 +597,21 @@ int build_sit_info(struct f2fs_sb_info *sbi) >> return -ENOMEM; >> } >> >> - sit_segs = get_sb(segment_count_sit) >> 1; >> + sit_segs = get_val(sb, segment_count_sit) >> 1; >> bitmap_size = __bitmap_size(sbi, SIT_BITMAP); >> src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); >> >> dst_bitmap = malloc(bitmap_size); >> memcpy(dst_bitmap, src_bitmap, bitmap_size); >> >> - sit_i->sit_base_addr = get_sb(sit_blkaddr); >> + sit_i->sit_base_addr = get_val(sb, sit_blkaddr); >> sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; >> - sit_i->written_valid_blocks = get_cp(valid_block_count); >> + sit_i->written_valid_blocks = get_val(cp, valid_block_count); >> sit_i->sit_bitmap = dst_bitmap; >> sit_i->bitmap_size = bitmap_size; >> sit_i->dirty_sentries = 0; >> sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; >> - sit_i->elapsed_time = get_cp(elapsed_time); >> + sit_i->elapsed_time = get_val(cp, elapsed_time); >> return 0; >> } >> >> @@ -716,13 +716,13 @@ static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) >> int ret; >> >> if (IS_DATASEG(type)) { >> - segno = get_cp(cur_data_segno[type]); >> + segno = get_val(cp, cur_data_segno[type]); >> if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); >> else >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); >> } else { >> - segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); >> + segno = get_val(cp, cur_node_segno[type - CURSEG_HOT_NODE]); >> if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, >> type - CURSEG_HOT_NODE); >> @@ -803,12 +803,12 @@ static void build_curseg(struct f2fs_sb_info *sbi) >> array[i].sum_blk = malloc(PAGE_CACHE_SIZE); >> ASSERT(array[i].sum_blk); >> if (i <= CURSEG_COLD_DATA) { >> - blk_off = get_cp(cur_data_blkoff[i]); >> - segno = get_cp(cur_data_segno[i]); >> + blk_off = get_val(cp, cur_data_blkoff[i]); >> + segno = get_val(cp, cur_data_segno[i]); >> } >> if (i > CURSEG_COLD_DATA) { >> - blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); >> - segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); >> + blk_off = get_val(cp, cur_node_blkoff[i - CURSEG_HOT_NODE]); >> + segno = get_val(cp, cur_node_segno[i - CURSEG_HOT_NODE]); >> } >> array[i].segno = segno; >> array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); >> @@ -924,7 +924,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, >> >> ssa_blk = GET_SUM_BLKADDR(sbi, segno); >> for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { >> - if (segno == get_cp(cur_node_segno[type])) { >> + if (segno == get_val(cp, cur_node_segno[type])) { >> curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); >> if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { >> ASSERT_MSG("segno [0x%x] indicates a data " >> @@ -939,7 +939,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, >> } >> >> for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { >> - if (segno == get_cp(cur_data_segno[type])) { >> + if (segno == get_val(cp, cur_data_segno[type])) { >> curseg = CURSEG_I(sbi, type); >> if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { >> ASSERT_MSG("segno [0x%x] indicates a node " >> @@ -1151,13 +1151,13 @@ int build_segment_manager(struct f2fs_sb_info *sbi) >> >> /* init sm info */ >> sbi->sm_info = sm_info; >> - sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); >> - sm_info->main_blkaddr = get_sb(main_blkaddr); >> - sm_info->segment_count = get_sb(segment_count); >> - sm_info->reserved_segments = get_cp(rsvd_segment_count); >> - sm_info->ovp_segments = get_cp(overprov_segment_count); >> - sm_info->main_segments = get_sb(segment_count_main); >> - sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); >> + sm_info->seg0_blkaddr = get_val(sb, segment0_blkaddr); >> + sm_info->main_blkaddr = get_val(sb, main_blkaddr); >> + sm_info->segment_count = get_val(sb, segment_count); >> + sm_info->reserved_segments = get_val(cp, rsvd_segment_count); >> + sm_info->ovp_segments = get_val(cp, overprov_segment_count); >> + sm_info->main_segments = get_val(sb, segment_count_main); >> + sm_info->ssa_blkaddr = get_val(sb, ssa_blkaddr); >> >> build_sit_info(sbi); >> >> @@ -1384,7 +1384,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi) >> free_segs++; >> } >> >> - set_cp(free_segment_count, free_segs); >> + set_val(cp, free_segment_count, free_segs); >> } >> >> int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type) >> @@ -1487,14 +1487,14 @@ void write_curseg_info(struct f2fs_sb_info *sbi) >> for (i = 0; i < NO_CHECK_TYPE; i++) { >> cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; >> if (i < CURSEG_HOT_NODE) { >> - set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); >> - set_cp(cur_data_blkoff[i], >> + set_val(cp, cur_data_segno[i], CURSEG_I(sbi, i)->segno); >> + set_val(cp, cur_data_blkoff[i], >> CURSEG_I(sbi, i)->next_blkoff); >> } else { >> int n = i - CURSEG_HOT_NODE; >> >> - set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); >> - set_cp(cur_node_blkoff[n], >> + set_val(cp, cur_node_segno[n], CURSEG_I(sbi, i)->segno); >> + set_val(cp, cur_node_blkoff[n], >> CURSEG_I(sbi, i)->next_blkoff); >> } >> } >> @@ -1578,24 +1578,24 @@ void write_checkpoint(struct f2fs_sb_info *sbi) >> flags |= CP_ORPHAN_PRESENT_FLAG; >> } >> >> - set_cp(ckpt_flags, flags); >> + set_val(cp, ckpt_flags, flags); >> >> - set_cp(free_segment_count, get_free_segments(sbi)); >> - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); >> + set_val(cp, free_segment_count, get_free_segments(sbi)); >> + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); >> >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); >> >> - cp_blk_no = get_sb(cp_blkaddr); >> + cp_blk_no = get_val(sb, cp_blkaddr); >> if (sbi->cur_cp == 2) >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); >> >> /* write the first cp */ >> ret = dev_write_block(cp, cp_blk_no++); >> ASSERT(ret >= 0); >> >> /* skip payload */ >> - cp_blk_no += get_sb(cp_payload); >> + cp_blk_no += get_val(sb, cp_payload); >> /* skip orphan blocks */ >> cp_blk_no += orphan_blks; >> >> @@ -1635,7 +1635,7 @@ void build_nat_area_bitmap(struct f2fs_sb_info *sbi) >> ASSERT(nat_block); >> >> /* Alloc & build nat entry bitmap */ >> - nr_nat_blks = (get_sb(segment_count_nat) / 2) << >> + nr_nat_blks = (get_val(sb, segment_count_nat) / 2) << >> sbi->log_blocks_per_seg; >> >> fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; >> @@ -1731,7 +1731,7 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) >> print_ckpt_info(sbi); >> >> if (config.auto_fix) { >> - u32 flag = get_cp(ckpt_flags); >> + u32 flag = get_val(cp, ckpt_flags); >> >> if (flag & CP_FSCK_FLAG) >> config.fix_on = 1; >> @@ -1741,10 +1741,10 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) >> >> config.bug_on = 0; >> >> - sbi->total_valid_node_count = get_cp(valid_node_count); >> - sbi->total_valid_inode_count = get_cp(valid_inode_count); >> - sbi->user_block_count = get_cp(user_block_count); >> - sbi->total_valid_block_count = get_cp(valid_block_count); >> + sbi->total_valid_node_count = get_val(cp, valid_node_count); >> + sbi->total_valid_inode_count = get_val(cp, valid_inode_count); >> + sbi->user_block_count = get_val(cp, user_block_count); >> + sbi->total_valid_block_count = get_val(cp, valid_block_count); >> sbi->last_valid_block_count = sbi->total_valid_block_count; >> sbi->alloc_valid_block_count = 0; >> >> diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h >> index e1eeb6e..2ab9f49 100644 >> --- a/include/f2fs_fs.h >> +++ b/include/f2fs_fs.h >> @@ -270,60 +270,32 @@ struct f2fs_configuration { >> #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG)) >> #define BIT_WORD(nr) (nr / BITS_PER_LONG) >> >> -#define set_sb_le64(member, val) (sb->member = cpu_to_le64(val)) >> -#define set_sb_le32(member, val) (sb->member = cpu_to_le32(val)) >> -#define set_sb_le16(member, val) (sb->member = cpu_to_le16(val)) >> -#define get_sb_le64(member) le64_to_cpu(sb->member) >> -#define get_sb_le32(member) le32_to_cpu(sb->member) >> -#define get_sb_le16(member) le16_to_cpu(sb->member) >> - >> -#define set_sb(member, val) \ >> - do { \ >> - typeof(sb->member) t; \ >> - switch (sizeof(t)) { \ >> - case 8: set_sb_le64(member, val); break; \ >> - case 4: set_sb_le32(member, val); break; \ >> - case 2: set_sb_le16(member, val); break; \ >> - } \ >> +#define set_le64(ptr, member, val) ((ptr)->member = cpu_to_le64(val)) >> +#define set_le32(ptr, member, val) ((ptr)->member = cpu_to_le32(val)) >> +#define set_le16(ptr, member, val) ((ptr)->member = cpu_to_le16(val)) >> +#define get_le64(ptr, member) le64_to_cpu((ptr)->member) >> +#define get_le32(ptr, member) le32_to_cpu((ptr)->member) >> +#define get_le16(ptr, member) le16_to_cpu((ptr)->member) >> + >> +#define set_val(ptr, member, val) \ >> + do { \ >> + typeof((ptr)->member) t; \ >> + switch (sizeof(t)) { \ >> + case 8: set_le64(ptr, member, val); break; \ >> + case 4: set_le32(ptr, member, val); break; \ >> + case 2: set_le16(ptr, member, val); break; \ >> + } \ >> } while(0) >> >> -#define get_sb(member) \ >> - ({ \ >> - typeof(sb->member) t; \ >> - switch (sizeof(t)) { \ >> - case 8: t = get_sb_le64(member); break; \ >> - case 4: t = get_sb_le32(member); break; \ >> - case 2: t = get_sb_le16(member); break; \ >> - } \ >> - t; \ >> - }) >> - >> -#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val)) >> -#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val)) >> -#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val)) >> -#define get_cp_le64(member) le64_to_cpu(cp->member) >> -#define get_cp_le32(member) le32_to_cpu(cp->member) >> -#define get_cp_le16(member) le16_to_cpu(cp->member) >> - >> -#define set_cp(member, val) \ >> - do { \ >> - typeof(cp->member) t; \ >> - switch (sizeof(t)) { \ >> - case 8: set_cp_le64(member, val); break; \ >> - case 4: set_cp_le32(member, val); break; \ >> - case 2: set_cp_le16(member, val); break; \ >> - } \ >> - } while(0) >> - >> -#define get_cp(member) \ >> - ({ \ >> - typeof(cp->member) t; \ >> - switch (sizeof(t)) { \ >> - case 8: t = get_cp_le64(member); break; \ >> - case 4: t = get_cp_le32(member); break; \ >> - case 2: t = get_cp_le16(member); break; \ >> - } \ >> - t; \ >> +#define get_val(ptr, member) \ >> + ({ \ >> + typeof((ptr)->member) t; \ >> + switch (sizeof(t)) { \ >> + case 8: t = get_le64(ptr, member); break; \ >> + case 4: t = get_le32(ptr, member); break; \ >> + case 2: t = get_le16(ptr, member); break; \ >> + } \ >> + t; \ >> }) >> >> /* >> @@ -899,7 +871,7 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) >> double reserved, ovp, candidate, end, diff, space; >> double max_ovp = 0, max_space = 0; >> >> - if (get_sb(segment_count_main) < 256) { >> + if (get_val(sb, segment_count_main) < 256) { >> candidate = 10; >> end = 95; >> diff = 5; >> @@ -911,9 +883,9 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) >> >> for (; candidate <= end; candidate += diff) { >> reserved = (2 * (100 / candidate + 1) + 6) * >> - get_sb(segs_per_sec); >> - ovp = (get_sb(segment_count_main) - reserved) * candidate / 100; >> - space = get_sb(segment_count_main) - reserved - ovp; >> + get_val(sb, segs_per_sec); >> + ovp = (get_val(sb, segment_count_main) - reserved) * candidate / 100; >> + space = get_val(sb, segment_count_main) - reserved - ovp; >> if (max_space < space) { >> max_space = space; >> max_ovp = candidate; >> diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c >> index 645c2aa..db5348e 100644 >> --- a/mkfs/f2fs_format.c >> +++ b/mkfs/f2fs_format.c >> @@ -83,7 +83,7 @@ static void configure_extension_list(void) >> int name_len; >> int i = 0; >> >> - set_sb(extension_count, 0); >> + set_val(sb, extension_count, 0); >> memset(sb->extension_list, 0, sizeof(sb->extension_list)); >> >> while (*extlist) { >> @@ -91,7 +91,7 @@ static void configure_extension_list(void) >> memcpy(sb->extension_list[i++], *extlist, name_len); >> extlist++; >> } >> - set_sb(extension_count, i); >> + set_val(sb, extension_count, i); >> >> if (!ext_str) >> return; >> @@ -112,7 +112,7 @@ next: >> break; >> } >> >> - set_sb(extension_count, i); >> + set_val(sb, extension_count, i); >> >> free(config.extension_list); >> } >> @@ -132,23 +132,23 @@ static int f2fs_prepare_super_block(void) >> u_int32_t max_nat_bitmap_size, max_nat_segments; >> u_int32_t total_zones; >> >> - set_sb(magic, F2FS_SUPER_MAGIC); >> - set_sb(major_ver, F2FS_MAJOR_VERSION); >> - set_sb(minor_ver, F2FS_MINOR_VERSION); >> + set_val(sb, magic, F2FS_SUPER_MAGIC); >> + set_val(sb, major_ver, F2FS_MAJOR_VERSION); >> + set_val(sb, minor_ver, F2FS_MINOR_VERSION); >> >> log_sectorsize = log_base_2(config.sector_size); >> log_sectors_per_block = log_base_2(config.sectors_per_blk); >> log_blocksize = log_sectorsize + log_sectors_per_block; >> log_blks_per_seg = log_base_2(config.blks_per_seg); >> >> - set_sb(log_sectorsize, log_sectorsize); >> - set_sb(log_sectors_per_block, log_sectors_per_block); >> + set_val(sb, log_sectorsize, log_sectorsize); >> + set_val(sb, log_sectors_per_block, log_sectors_per_block); >> >> - set_sb(log_blocksize, log_blocksize); >> - set_sb(log_blocks_per_seg, log_blks_per_seg); >> + set_val(sb, log_blocksize, log_blocksize); >> + set_val(sb, log_blocks_per_seg, log_blks_per_seg); >> >> - set_sb(segs_per_sec, config.segs_per_sec); >> - set_sb(secs_per_zone, config.secs_per_zone); >> + set_val(sb, segs_per_sec, config.segs_per_sec); >> + set_val(sb, secs_per_zone, config.secs_per_zone); >> >> blk_size_bytes = 1 << log_blocksize; >> segment_size_bytes = blk_size_bytes * config.blks_per_seg; >> @@ -156,9 +156,9 @@ static int f2fs_prepare_super_block(void) >> blk_size_bytes * config.secs_per_zone * >> config.segs_per_sec * config.blks_per_seg; >> >> - set_sb(checksum_offset, 0); >> + set_val(sb, checksum_offset, 0); >> >> - set_sb(block_count, config.total_sectors >> log_sectors_per_block); >> + set_val(sb, block_count, config.total_sectors >> log_sectors_per_block); >> >> zone_align_start_offset = >> (config.start_sector * config.sector_size + >> @@ -174,41 +174,41 @@ static int f2fs_prepare_super_block(void) >> config.sectors_per_blk); >> } >> >> - set_sb(segment_count, (config.total_sectors * config.sector_size - >> + set_val(sb, segment_count, (config.total_sectors * config.sector_size - >> zone_align_start_offset) / segment_size_bytes); >> >> - set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes); >> + set_val(sb, segment0_blkaddr, zone_align_start_offset / blk_size_bytes); >> sb->cp_blkaddr = sb->segment0_blkaddr; >> >> - MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr)); >> + MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_val(sb, segment0_blkaddr)); >> >> - set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); >> + set_val(sb, segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); >> >> - set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) * >> + set_val(sb, sit_blkaddr, get_val(sb, segment0_blkaddr) + get_val(sb, segment_count_ckpt) * >> config.blks_per_seg); >> >> - blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK); >> + blocks_for_sit = ALIGN(get_val(sb, segment_count), SIT_ENTRY_PER_BLOCK); >> >> sit_segments = SEG_ALIGN(blocks_for_sit); >> >> - set_sb(segment_count_sit, sit_segments * 2); >> + set_val(sb, segment_count_sit, sit_segments * 2); >> >> - set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) * >> + set_val(sb, nat_blkaddr, get_val(sb, sit_blkaddr) + get_val(sb, segment_count_sit) * >> config.blks_per_seg); >> >> - total_valid_blks_available = (get_sb(segment_count) - >> - (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) * >> + total_valid_blks_available = (get_val(sb, segment_count) - >> + (get_val(sb, segment_count_ckpt) + get_val(sb, segment_count_sit))) * >> config.blks_per_seg; >> >> blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK); >> >> - set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat)); >> + set_val(sb, segment_count_nat, SEG_ALIGN(blocks_for_nat)); >> /* >> * The number of node segments should not be exceeded a "Threshold". >> * This number resizes NAT bitmap area in a CP page. >> * So the threshold is determined not to overflow one CP page >> */ >> - sit_bitmap_size = ((get_sb(segment_count_sit) / 2) << >> + sit_bitmap_size = ((get_val(sb, segment_count_sit) / 2) << >> log_blks_per_seg) / 8; >> >> if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE) >> @@ -223,55 +223,55 @@ static int f2fs_prepare_super_block(void) >> if (max_sit_bitmap_size > >> (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - 64)) { >> max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1; >> - set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); >> + set_val(sb, cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); >> } else { >> max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 >> - max_sit_bitmap_size; >> - set_sb(cp_payload, 0); >> + set_val(sb, cp_payload, 0); >> } >> >> max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; >> >> - if (get_sb(segment_count_nat) > max_nat_segments) >> - set_sb(segment_count_nat, max_nat_segments); >> + if (get_val(sb, segment_count_nat) > max_nat_segments) >> + set_val(sb, segment_count_nat, max_nat_segments); >> >> - set_sb(segment_count_nat, get_sb(segment_count_nat) * 2); >> + set_val(sb, segment_count_nat, get_val(sb, segment_count_nat) * 2); >> >> - set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) * >> + set_val(sb, ssa_blkaddr, get_val(sb, nat_blkaddr) + get_val(sb, segment_count_nat) * >> config.blks_per_seg); >> >> - total_valid_blks_available = (get_sb(segment_count) - >> - (get_sb(segment_count_ckpt) + >> - get_sb(segment_count_sit) + >> - get_sb(segment_count_nat))) * >> + total_valid_blks_available = (get_val(sb, segment_count) - >> + (get_val(sb, segment_count_ckpt) + >> + get_val(sb, segment_count_sit) + >> + get_val(sb, segment_count_nat))) * >> config.blks_per_seg; >> >> blocks_for_ssa = total_valid_blks_available / >> config.blks_per_seg + 1; >> >> - set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); >> + set_val(sb, segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); >> >> - total_meta_segments = get_sb(segment_count_ckpt) + >> - get_sb(segment_count_sit) + >> - get_sb(segment_count_nat) + >> - get_sb(segment_count_ssa); >> + total_meta_segments = get_val(sb, segment_count_ckpt) + >> + get_val(sb, segment_count_sit) + >> + get_val(sb, segment_count_nat) + >> + get_val(sb, segment_count_ssa); >> diff = total_meta_segments % (config.segs_per_zone); >> if (diff) >> - set_sb(segment_count_ssa, get_sb(segment_count_ssa) + >> + set_val(sb, segment_count_ssa, get_val(sb, segment_count_ssa) + >> (config.segs_per_zone - diff)); >> >> total_meta_zones = ZONE_ALIGN(total_meta_segments * >> config.blks_per_seg); >> >> - set_sb(main_blkaddr, get_sb(segment0_blkaddr) + total_meta_zones * >> + set_val(sb, main_blkaddr, get_val(sb, segment0_blkaddr) + total_meta_zones * >> config.segs_per_zone * config.blks_per_seg); >> >> - total_zones = get_sb(segment_count) / (config.segs_per_zone) - >> + total_zones = get_val(sb, segment_count) / (config.segs_per_zone) - >> total_meta_zones; >> >> - set_sb(section_count, total_zones * config.secs_per_zone); >> + set_val(sb, section_count, total_zones * config.secs_per_zone); >> >> - set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec); >> + set_val(sb, segment_count_main, get_val(sb, section_count) * config.segs_per_sec); >> >> /* Let's determine the best reserved and overprovisioned space */ >> if (config.overprovision == 0) >> @@ -281,12 +281,12 @@ static int f2fs_prepare_super_block(void) >> (2 * (100 / config.overprovision + 1) + 6) >> * config.segs_per_sec; >> >> - if ((get_sb(segment_count_main) - 2) < >> + if ((get_val(sb, segment_count_main) - 2) < >> config.reserved_segments) { >> MSG(1, "\tError: Device size is not sufficient for F2FS volume,\ >> more segment needed =%u", >> config.reserved_segments - >> - (get_sb(segment_count_main) - 2)); >> + (get_val(sb, segment_count_main) - 2)); >> return -1; >> } >> >> @@ -294,9 +294,9 @@ static int f2fs_prepare_super_block(void) >> >> utf8_to_utf16(sb->volume_name, (const char *)config.vol_label, >> MAX_VOLUME_NAME, strlen(config.vol_label)); >> - set_sb(node_ino, 1); >> - set_sb(meta_ino, 2); >> - set_sb(root_ino, 3); >> + set_val(sb, node_ino, 1); >> + set_val(sb, meta_ino, 2); >> + set_val(sb, root_ino, 3); >> >> if (total_zones <= 6) { >> MSG(1, "\tError: %d zones: Need more zones \ >> @@ -346,8 +346,8 @@ static int f2fs_init_sit_area(void) >> u_int64_t sit_seg_addr = 0; >> u_int8_t *zero_buf = NULL; >> >> - blk_size = 1 << get_sb(log_blocksize); >> - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; >> + blk_size = 1 << get_val(sb, log_blocksize); >> + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; >> >> zero_buf = calloc(sizeof(u_int8_t), seg_size); >> if(zero_buf == NULL) { >> @@ -355,11 +355,11 @@ static int f2fs_init_sit_area(void) >> return -1; >> } >> >> - sit_seg_addr = get_sb(sit_blkaddr); >> + sit_seg_addr = get_val(sb, sit_blkaddr); >> sit_seg_addr *= blk_size; >> >> DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr); >> - for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) { >> + for (index = 0; index < (get_val(sb, segment_count_sit) / 2); index++) { >> if (dev_fill(zero_buf, sit_seg_addr, seg_size)) { >> MSG(1, "\tError: While zeroing out the sit area \ >> on disk!!!\n"); >> @@ -380,8 +380,8 @@ static int f2fs_init_nat_area(void) >> u_int64_t nat_seg_addr = 0; >> u_int8_t *nat_buf = NULL; >> >> - blk_size = 1 << get_sb(log_blocksize); >> - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; >> + blk_size = 1 << get_val(sb, log_blocksize); >> + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; >> >> nat_buf = calloc(sizeof(u_int8_t), seg_size); >> if (nat_buf == NULL) { >> @@ -389,11 +389,11 @@ static int f2fs_init_nat_area(void) >> return -1; >> } >> >> - nat_seg_addr = get_sb(nat_blkaddr); >> + nat_seg_addr = get_val(sb, nat_blkaddr); >> nat_seg_addr *= blk_size; >> >> DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr); >> - for (index = 0; index < get_sb(segment_count_nat) / 2; index++) { >> + for (index = 0; index < get_val(sb, segment_count_nat) / 2; index++) { >> if (dev_fill(nat_buf, nat_seg_addr, seg_size)) { >> MSG(1, "\tError: While zeroing out the nat area \ >> on disk!!!\n"); >> @@ -445,58 +445,58 @@ static int f2fs_write_check_point_pack(void) >> } >> >> /* 1. cp page 1 of checkpoint pack 1 */ >> - set_cp(checkpoint_ver, 1); >> - set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); >> - set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); >> - set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); >> - set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); >> - set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); >> - set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); >> + set_val(cp, checkpoint_ver, 1); >> + set_val(cp, cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); >> + set_val(cp, cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); >> + set_val(cp, cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); >> + set_val(cp, cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); >> + set_val(cp, cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); >> + set_val(cp, cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); >> for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { >> - set_cp(cur_node_segno[i], 0xffffffff); >> - set_cp(cur_data_segno[i], 0xffffffff); >> + set_val(cp, cur_node_segno[i], 0xffffffff); >> + set_val(cp, cur_data_segno[i], 0xffffffff); >> } >> >> - set_cp(cur_node_blkoff[0], 1); >> - set_cp(cur_data_blkoff[0], 1); >> - set_cp(valid_block_count, 2); >> - set_cp(rsvd_segment_count, config.reserved_segments); >> - set_cp(overprov_segment_count, (get_sb(segment_count_main) - >> - get_cp(rsvd_segment_count)) * >> + set_val(cp, cur_node_blkoff[0], 1); >> + set_val(cp, cur_data_blkoff[0], 1); >> + set_val(cp, valid_block_count, 2); >> + set_val(cp, rsvd_segment_count, config.reserved_segments); >> + set_val(cp, overprov_segment_count, (get_val(sb, segment_count_main) - >> + get_val(cp, rsvd_segment_count)) * >> config.overprovision / 100); >> - set_cp(overprov_segment_count, get_cp(overprov_segment_count) + >> - get_cp(rsvd_segment_count)); >> + set_val(cp, overprov_segment_count, get_val(cp, overprov_segment_count) + >> + get_val(cp, rsvd_segment_count)); >> >> MSG(0, "Info: Overprovision ratio = %.3lf%%\n", config.overprovision); >> MSG(0, "Info: Overprovision segments = %u (GC reserved = %u)\n", >> - get_cp(overprov_segment_count), >> + get_val(cp, overprov_segment_count), >> config.reserved_segments); >> >> /* main segments - reserved segments - (node + data segments) */ >> - set_cp(free_segment_count, get_sb(segment_count_main) - 6); >> - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - >> - get_cp(overprov_segment_count)) * config.blks_per_seg)); >> + set_val(cp, free_segment_count, get_val(sb, segment_count_main) - 6); >> + set_val(cp, user_block_count, ((get_val(cp, free_segment_count) + 6 - >> + get_val(cp, overprov_segment_count)) * config.blks_per_seg)); >> /* cp page (2), data summaries (1), node summaries (3) */ >> - set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); >> - set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); >> - set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); >> - set_cp(valid_node_count, 1); >> - set_cp(valid_inode_count, 1); >> - set_cp(next_free_nid, get_sb(root_ino) + 1); >> - set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << >> - get_sb(log_blocks_per_seg)) / 8); >> + set_val(cp, cp_pack_total_block_count, 6 + get_val(sb, cp_payload)); >> + set_val(cp, ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); >> + set_val(cp, cp_pack_start_sum, 1 + get_val(sb, cp_payload)); >> + set_val(cp, valid_node_count, 1); >> + set_val(cp, valid_inode_count, 1); >> + set_val(cp, next_free_nid, get_val(sb, root_ino) + 1); >> + set_val(cp, sit_ver_bitmap_bytesize, ((get_val(sb, segment_count_sit) / 2) << >> + get_val(sb, log_blocks_per_seg)) / 8); >> >> - set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) << >> - get_sb(log_blocks_per_seg)) / 8); >> + set_val(cp, nat_ver_bitmap_bytesize, ((get_val(sb, segment_count_nat) / 2) << >> + get_val(sb, log_blocks_per_seg)) / 8); >> >> - set_cp(checksum_offset, CHECKSUM_OFFSET); >> + set_val(cp, checksum_offset, CHECKSUM_OFFSET); >> >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = >> cpu_to_le32(crc); >> >> - blk_size_bytes = 1 << get_sb(log_blocksize); >> - cp_seg_blk_offset = get_sb(segment0_blkaddr); >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); >> + cp_seg_blk_offset = get_val(sb, segment0_blkaddr); >> cp_seg_blk_offset *= blk_size_bytes; >> >> DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); >> @@ -505,7 +505,7 @@ static int f2fs_write_check_point_pack(void) >> goto free_cp_payload; >> } >> >> - for (i = 0; i < get_sb(cp_payload); i++) { >> + for (i = 0; i < get_val(sb, cp_payload); i++) { >> cp_seg_blk_offset += blk_size_bytes; >> if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { >> MSG(1, "\tError: While zeroing out the sit bitmap area \ >> @@ -537,8 +537,8 @@ static int f2fs_write_check_point_pack(void) >> sum->nat_j.entries[0].ne.version = 0; >> sum->nat_j.entries[0].ne.ino = sb->root_ino; >> sum->nat_j.entries[0].ne.block_addr = cpu_to_le32( >> - get_sb(main_blkaddr) + >> - get_cp(cur_node_segno[0]) * config.blks_per_seg); >> + get_val(sb, main_blkaddr) + >> + get_val(cp, cur_node_segno[0]) * config.blks_per_seg); >> >> memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE); >> sum_compact_p += SUM_JOURNAL_SIZE; >> @@ -635,7 +635,7 @@ static int f2fs_write_check_point_pack(void) >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = >> cpu_to_le32(crc); >> - cp_seg_blk_offset = (get_sb(segment0_blkaddr) + >> + cp_seg_blk_offset = (get_val(sb, segment0_blkaddr) + >> config.blks_per_seg) * >> blk_size_bytes; >> DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); >> @@ -644,7 +644,7 @@ static int f2fs_write_check_point_pack(void) >> goto free_cp_payload; >> } >> >> - for (i = 0; i < get_sb(cp_payload); i++) { >> + for (i = 0; i < get_val(sb, cp_payload); i++) { >> cp_seg_blk_offset += blk_size_bytes; >> if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { >> MSG(1, "\tError: While zeroing out the sit bitmap area \ >> @@ -655,7 +655,7 @@ static int f2fs_write_check_point_pack(void) >> >> /* cp page 2 of check point pack 2 */ >> cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count) >> - - get_sb(cp_payload) - 1); >> + - get_val(sb, cp_payload) - 1); >> DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); >> if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) { >> MSG(1, "\tError: While writing the cp to disk!!!\n"); >> @@ -701,8 +701,8 @@ static int f2fs_write_super_block(void) >> static int discard_obsolete_dnode(struct f2fs_node *raw_node, u_int64_t offset) >> { >> do { >> - if (offset < get_sb(main_blkaddr) || >> - offset >= get_sb(main_blkaddr) + get_sb(block_count)) >> + if (offset < get_val(sb, main_blkaddr) || >> + offset >= get_val(sb, main_blkaddr) + get_val(sb, block_count)) >> break; >> >> if (dev_read_block(raw_node, offset)) { >> @@ -740,7 +740,7 @@ static int f2fs_write_root_inode(void) >> raw_node->footer.ino = sb->root_ino; >> raw_node->footer.cp_ver = cpu_to_le64(1); >> raw_node->footer.next_blkaddr = cpu_to_le32( >> - get_sb(main_blkaddr) + >> + get_val(sb, main_blkaddr) + >> config.cur_seg[CURSEG_HOT_NODE] * >> config.blks_per_seg + 1); >> >> @@ -749,7 +749,7 @@ static int f2fs_write_root_inode(void) >> raw_node->i.i_uid = cpu_to_le32(getuid()); >> raw_node->i.i_gid = cpu_to_le32(getgid()); >> >> - blk_size_bytes = 1 << get_sb(log_blocksize); >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); >> raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */ >> raw_node->i.i_blocks = cpu_to_le64(2); >> >> @@ -765,7 +765,7 @@ static int f2fs_write_root_inode(void) >> raw_node->i.i_current_depth = cpu_to_le32(1); >> raw_node->i.i_dir_level = DEF_DIR_LEVEL; >> >> - data_blk_nor = get_sb(main_blkaddr) + >> + data_blk_nor = get_val(sb, main_blkaddr) + >> config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; >> raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor); >> >> @@ -773,7 +773,7 @@ static int f2fs_write_root_inode(void) >> raw_node->i.i_ext.blk_addr = 0; >> raw_node->i.i_ext.len = 0; >> >> - main_area_node_seg_blk_offset = get_sb(main_blkaddr); >> + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); >> main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] * >> config.blks_per_seg; >> main_area_node_seg_blk_offset *= blk_size_bytes; >> @@ -786,7 +786,7 @@ static int f2fs_write_root_inode(void) >> } >> >> /* avoid power-off-recovery based on roll-forward policy */ >> - main_area_node_seg_blk_offset = get_sb(main_blkaddr); >> + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); >> main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] * >> config.blks_per_seg; >> >> @@ -813,21 +813,21 @@ static int f2fs_update_nat_root(void) >> } >> >> /* update root */ >> - nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32( >> - get_sb(main_blkaddr) + >> + nat_blk->entries[get_val(sb, root_ino)].block_addr = cpu_to_le32( >> + get_val(sb, main_blkaddr) + >> config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg); >> - nat_blk->entries[get_sb(root_ino)].ino = sb->root_ino; >> + nat_blk->entries[get_val(sb, root_ino)].ino = sb->root_ino; >> >> /* update node nat */ >> - nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1); >> - nat_blk->entries[get_sb(node_ino)].ino = sb->node_ino; >> + nat_blk->entries[get_val(sb, node_ino)].block_addr = cpu_to_le32(1); >> + nat_blk->entries[get_val(sb, node_ino)].ino = sb->node_ino; >> >> /* update meta nat */ >> - nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1); >> - nat_blk->entries[get_sb(meta_ino)].ino = sb->meta_ino; >> + nat_blk->entries[get_val(sb, meta_ino)].block_addr = cpu_to_le32(1); >> + nat_blk->entries[get_val(sb, meta_ino)].ino = sb->meta_ino; >> >> - blk_size_bytes = 1 << get_sb(log_blocksize); >> - nat_seg_blk_offset = get_sb(nat_blkaddr); >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); >> + nat_seg_blk_offset = get_val(sb, nat_blkaddr); >> nat_seg_blk_offset *= blk_size_bytes; >> >> DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset); >> @@ -867,8 +867,8 @@ static int f2fs_add_default_dentry_root(void) >> /* bitmap for . and .. */ >> test_and_set_bit_le(0, dent_blk->dentry_bitmap); >> test_and_set_bit_le(1, dent_blk->dentry_bitmap); >> - blk_size_bytes = 1 << get_sb(log_blocksize); >> - data_blk_offset = get_sb(main_blkaddr); >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); >> + data_blk_offset = get_val(sb, main_blkaddr); >> data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] * >> config.blks_per_seg; >> data_blk_offset *= blk_size_bytes; >> -- >> 1.9.1 >> >> >> ------------------------------------------------------------------------------ >> Site24x7 APM Insight: Get Deep Visibility into Application Performance >> APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month >> Monitor end-to-end web transactions and take corrective actions now >> Troubleshoot faster and improve end-user experience. Signup Now! >> http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 >> _______________________________________________ >> Linux-f2fs-devel mailing list >> Linux-f2fs-devel@lists.sourceforge.net >> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel > > . > ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply [flat|nested] 9+ messages in thread
* [RFC PATCH v2] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} 2016-01-30 2:25 ` Sheng Yong @ 2016-01-30 10:03 ` Sheng Yong 2016-02-02 0:27 ` [RFC PATCH 1/4] " Jaegeuk Kim 1 sibling, 0 replies; 9+ messages in thread From: Sheng Yong @ 2016-01-30 10:03 UTC (permalink / raw) To: Jaegeuk Kim; +Cc: linux-f2fs-devel * Remove dumplicated definitions of get_{sb|cp} and set_{sb|cp}, and introduce micros get_val and set_val instead. * Add a new parameter to get_val and set_val so that they do not depended on implied definition of `sb' and `cp'. * Keep get_{sb|cp} and set_{sb|cp} for compatible reason. Signed-off-by: Sheng Yong <shengyong1@huawei.com> --- fsck/fsck.c | 20 ++--- fsck/main.c | 8 +- fsck/mount.c | 146 ++++++++++++++++----------------- include/f2fs_fs.h | 88 ++++++++------------ mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++--------------------------- 5 files changed, 237 insertions(+), 259 deletions(-) diff --git a/fsck/fsck.c b/fsck/fsck.c index e7dd02f..4fbb56d 100644 --- a/fsck/fsck.c +++ b/fsck/fsck.c @@ -1191,7 +1191,7 @@ void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) return; - start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload); + start_blk = __start_cp_addr(sbi) + 1 + get_val(sb, cp_payload); orphan_blkaddr = __start_sum_addr(sbi) - 1; orphan_blk = calloc(BLOCK_SZ, 1); @@ -1324,25 +1324,25 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi) flags |= CP_ORPHAN_PRESENT_FLAG; } - set_cp(ckpt_flags, flags); - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); + set_val(cp, ckpt_flags, flags); + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); - set_cp(free_segment_count, fsck->chk.free_segs); - set_cp(valid_block_count, fsck->chk.valid_blk_cnt); - set_cp(valid_node_count, fsck->chk.valid_node_cnt); - set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); + set_val(cp, free_segment_count, fsck->chk.free_segs); + set_val(cp, valid_block_count, fsck->chk.valid_blk_cnt); + set_val(cp, valid_node_count, fsck->chk.valid_node_cnt); + set_val(cp, valid_inode_count, fsck->chk.valid_inode_cnt); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (sbi->cur_cp == 2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); ret = dev_write_block(cp, cp_blk_no++); ASSERT(ret >= 0); - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { ret = dev_write_block(((unsigned char *)cp) + i * F2FS_BLKSIZE, cp_blk_no++); ASSERT(ret >= 0); diff --git a/fsck/main.c b/fsck/main.c index 54dbb2d..7fcaa5d 100644 --- a/fsck/main.c +++ b/fsck/main.c @@ -255,7 +255,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) { struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); - if (config.defrag_start > get_sb(block_count)) + if (config.defrag_start > get_val(sb, block_count)) goto out_range; if (config.defrag_start < SM_I(sbi)->main_blkaddr) config.defrag_start = SM_I(sbi)->main_blkaddr; @@ -263,8 +263,8 @@ static int do_defrag(struct f2fs_sb_info *sbi) if (config.defrag_len == 0) config.defrag_len = sbi->blocks_per_seg; - if (config.defrag_start + config.defrag_len > get_sb(block_count)) - config.defrag_len = get_sb(block_count) - config.defrag_start; + if (config.defrag_start + config.defrag_len > get_val(sb, block_count)) + config.defrag_len = get_val(sb, block_count) - config.defrag_start; if (config.defrag_target == 0) { config.defrag_target = config.defrag_start - 1; @@ -273,7 +273,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) } if (config.defrag_target < SM_I(sbi)->main_blkaddr || - config.defrag_target > get_sb(block_count)) + config.defrag_target > get_val(sb, block_count)) goto out_range; if (config.defrag_target >= config.defrag_start && config.defrag_target < config.defrag_start + config.defrag_len) diff --git a/fsck/mount.c b/fsck/mount.c index 4c807f9..6e6d230 100644 --- a/fsck/mount.c +++ b/fsck/mount.c @@ -269,21 +269,21 @@ int sanity_check_raw_super(struct f2fs_super_block *sb) { unsigned int blocksize; - if (F2FS_SUPER_MAGIC != get_sb(magic)) + if (F2FS_SUPER_MAGIC != get_val(sb, magic)) return -1; if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) return -1; - blocksize = 1 << get_sb(log_blocksize); + blocksize = 1 << get_val(sb, log_blocksize); if (F2FS_BLKSIZE != blocksize) return -1; - if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || - get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) + if (get_val(sb, log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || + get_val(sb, log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) return -1; - if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != + if (get_val(sb, log_sectors_per_block) + get_val(sb, log_sectorsize) != F2FS_MAX_LOG_SECTOR_SIZE) return -1; @@ -350,22 +350,22 @@ int init_sb_info(struct f2fs_sb_info *sbi) struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); u64 total_sectors; - sbi->log_sectors_per_block = get_sb(log_sectors_per_block); - sbi->log_blocksize = get_sb(log_blocksize); + sbi->log_sectors_per_block = get_val(sb, log_sectors_per_block); + sbi->log_blocksize = get_val(sb, log_blocksize); sbi->blocksize = 1 << sbi->log_blocksize; - sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); + sbi->log_blocks_per_seg = get_val(sb, log_blocks_per_seg); sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; - sbi->segs_per_sec = get_sb(segs_per_sec); - sbi->secs_per_zone = get_sb(secs_per_zone); - sbi->total_sections = get_sb(section_count); - sbi->total_node_count = (get_sb(segment_count_nat) / 2) * + sbi->segs_per_sec = get_val(sb, segs_per_sec); + sbi->secs_per_zone = get_val(sb, secs_per_zone); + sbi->total_sections = get_val(sb, section_count); + sbi->total_node_count = (get_val(sb, segment_count_nat) / 2) * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; - sbi->root_ino_num = get_sb(root_ino); - sbi->node_ino_num = get_sb(node_ino); - sbi->meta_ino_num = get_sb(meta_ino); + sbi->root_ino_num = get_val(sb, root_ino); + sbi->node_ino_num = get_val(sb, node_ino); + sbi->meta_ino_num = get_val(sb, meta_ino); sbi->cur_victim_sec = NULL_SEGNO; - total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; + total_sectors = get_val(sb, block_count) << sbi->log_sectors_per_block; MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", total_sectors, total_sectors >> 11); return 0; @@ -387,7 +387,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, return NULL; cp = (struct f2fs_checkpoint *)cp_page_1; - crc_offset = get_cp(checksum_offset); + crc_offset = get_val(cp, checksum_offset); if (crc_offset >= blk_size) goto invalid_cp1; @@ -395,17 +395,17 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, if (f2fs_crc_valid(crc, cp, crc_offset)) goto invalid_cp1; - pre_version = get_cp(checkpoint_ver); + pre_version = get_val(cp, checkpoint_ver); /* Read the 2nd cp block in this CP pack */ cp_page_2 = malloc(PAGE_SIZE); - cp_addr += get_cp(cp_pack_total_block_count) - 1; + cp_addr += get_val(cp, cp_pack_total_block_count) - 1; if (dev_read_block(cp_page_2, cp_addr) < 0) goto invalid_cp2; cp = (struct f2fs_checkpoint *)cp_page_2; - crc_offset = get_cp(checksum_offset); + crc_offset = get_val(cp, checksum_offset); if (crc_offset >= blk_size) goto invalid_cp2; @@ -413,7 +413,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, if (f2fs_crc_valid(crc, cp, crc_offset)) goto invalid_cp2; - cur_version = get_cp(checkpoint_ver); + cur_version = get_val(cp, checkpoint_ver); if (cur_version == pre_version) { *version = cur_version; @@ -435,7 +435,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) unsigned long blk_size = sbi->blocksize; unsigned long long cp1_version = 0, cp2_version = 0, version; unsigned long long cp_start_blk_no; - unsigned int cp_blks = 1 + get_sb(cp_payload); + unsigned int cp_blks = 1 + get_val(sb, cp_payload); int ret; sbi->ckpt = malloc(cp_blks * blk_size); @@ -445,11 +445,11 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) * Finding out valid cp block involves read both * sets( cp pack1 and cp pack 2) */ - cp_start_blk_no = get_sb(cp_blkaddr); + cp_start_blk_no = get_val(sb, cp_blkaddr); cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); /* The second checkpoint pack should start at the next segment */ - cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_start_blk_no += 1 << get_val(sb, log_blocks_per_seg); cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); if (cp1 && cp2) { @@ -481,9 +481,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) unsigned int i; unsigned long long cp_blk_no; - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (cur_page == cp2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); /* copy sit bitmap */ for (i = 1; i < cp_blks; i++) { @@ -510,12 +510,12 @@ int sanity_check_ckpt(struct f2fs_sb_info *sbi) struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); - total = get_sb(segment_count); - fsmeta = get_sb(segment_count_ckpt); - fsmeta += get_sb(segment_count_sit); - fsmeta += get_sb(segment_count_nat); - fsmeta += get_cp(rsvd_segment_count); - fsmeta += get_sb(segment_count_ssa); + total = get_val(sb, segment_count); + fsmeta = get_val(sb, segment_count_ckpt); + fsmeta += get_val(sb, segment_count_sit); + fsmeta += get_val(sb, segment_count_nat); + fsmeta += get_val(cp, rsvd_segment_count); + fsmeta += get_val(sb, segment_count_ssa); if (fsmeta >= total) return 1; @@ -531,16 +531,16 @@ int init_node_manager(struct f2fs_sb_info *sbi) unsigned char *version_bitmap; unsigned int nat_segs, nat_blocks; - nm_i->nat_blkaddr = get_sb(nat_blkaddr); + nm_i->nat_blkaddr = get_val(sb, nat_blkaddr); /* segment_count_nat includes pair segment so divide to 2. */ - nat_segs = get_sb(segment_count_nat) >> 1; - nat_blocks = nat_segs << get_sb(log_blocks_per_seg); + nat_segs = get_val(sb, segment_count_nat) >> 1; + nat_blocks = nat_segs << get_val(sb, log_blocks_per_seg); nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; nm_i->fcnt = 0; nm_i->nat_cnt = 0; - nm_i->init_scan_nid = get_cp(next_free_nid); - nm_i->next_scan_nid = get_cp(next_free_nid); + nm_i->init_scan_nid = get_val(cp, next_free_nid); + nm_i->next_scan_nid = get_val(cp, next_free_nid); nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); @@ -597,21 +597,21 @@ int build_sit_info(struct f2fs_sb_info *sbi) return -ENOMEM; } - sit_segs = get_sb(segment_count_sit) >> 1; + sit_segs = get_val(sb, segment_count_sit) >> 1; bitmap_size = __bitmap_size(sbi, SIT_BITMAP); src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); dst_bitmap = malloc(bitmap_size); memcpy(dst_bitmap, src_bitmap, bitmap_size); - sit_i->sit_base_addr = get_sb(sit_blkaddr); + sit_i->sit_base_addr = get_val(sb, sit_blkaddr); sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; - sit_i->written_valid_blocks = get_cp(valid_block_count); + sit_i->written_valid_blocks = get_val(cp, valid_block_count); sit_i->sit_bitmap = dst_bitmap; sit_i->bitmap_size = bitmap_size; sit_i->dirty_sentries = 0; sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; - sit_i->elapsed_time = get_cp(elapsed_time); + sit_i->elapsed_time = get_val(cp, elapsed_time); return 0; } @@ -716,13 +716,13 @@ static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) int ret; if (IS_DATASEG(type)) { - segno = get_cp(cur_data_segno[type]); + segno = get_val(cp, cur_data_segno[type]); if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); else blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); } else { - segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); + segno = get_val(cp, cur_node_segno[type - CURSEG_HOT_NODE]); if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, type - CURSEG_HOT_NODE); @@ -803,12 +803,12 @@ static void build_curseg(struct f2fs_sb_info *sbi) array[i].sum_blk = malloc(PAGE_CACHE_SIZE); ASSERT(array[i].sum_blk); if (i <= CURSEG_COLD_DATA) { - blk_off = get_cp(cur_data_blkoff[i]); - segno = get_cp(cur_data_segno[i]); + blk_off = get_val(cp, cur_data_blkoff[i]); + segno = get_val(cp, cur_data_segno[i]); } if (i > CURSEG_COLD_DATA) { - blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); - segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); + blk_off = get_val(cp, cur_node_blkoff[i - CURSEG_HOT_NODE]); + segno = get_val(cp, cur_node_segno[i - CURSEG_HOT_NODE]); } array[i].segno = segno; array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); @@ -924,7 +924,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, ssa_blk = GET_SUM_BLKADDR(sbi, segno); for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { - if (segno == get_cp(cur_node_segno[type])) { + if (segno == get_val(cp, cur_node_segno[type])) { curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { ASSERT_MSG("segno [0x%x] indicates a data " @@ -939,7 +939,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, } for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { - if (segno == get_cp(cur_data_segno[type])) { + if (segno == get_val(cp, cur_data_segno[type])) { curseg = CURSEG_I(sbi, type); if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { ASSERT_MSG("segno [0x%x] indicates a node " @@ -1151,13 +1151,13 @@ int build_segment_manager(struct f2fs_sb_info *sbi) /* init sm info */ sbi->sm_info = sm_info; - sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); - sm_info->main_blkaddr = get_sb(main_blkaddr); - sm_info->segment_count = get_sb(segment_count); - sm_info->reserved_segments = get_cp(rsvd_segment_count); - sm_info->ovp_segments = get_cp(overprov_segment_count); - sm_info->main_segments = get_sb(segment_count_main); - sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); + sm_info->seg0_blkaddr = get_val(sb, segment0_blkaddr); + sm_info->main_blkaddr = get_val(sb, main_blkaddr); + sm_info->segment_count = get_val(sb, segment_count); + sm_info->reserved_segments = get_val(cp, rsvd_segment_count); + sm_info->ovp_segments = get_val(cp, overprov_segment_count); + sm_info->main_segments = get_val(sb, segment_count_main); + sm_info->ssa_blkaddr = get_val(sb, ssa_blkaddr); build_sit_info(sbi); @@ -1384,7 +1384,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi) free_segs++; } - set_cp(free_segment_count, free_segs); + set_val(cp, free_segment_count, free_segs); } int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type) @@ -1487,14 +1487,14 @@ void write_curseg_info(struct f2fs_sb_info *sbi) for (i = 0; i < NO_CHECK_TYPE; i++) { cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; if (i < CURSEG_HOT_NODE) { - set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); - set_cp(cur_data_blkoff[i], + set_val(cp, cur_data_segno[i], CURSEG_I(sbi, i)->segno); + set_val(cp, cur_data_blkoff[i], CURSEG_I(sbi, i)->next_blkoff); } else { int n = i - CURSEG_HOT_NODE; - set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); - set_cp(cur_node_blkoff[n], + set_val(cp, cur_node_segno[n], CURSEG_I(sbi, i)->segno); + set_val(cp, cur_node_blkoff[n], CURSEG_I(sbi, i)->next_blkoff); } } @@ -1578,24 +1578,24 @@ void write_checkpoint(struct f2fs_sb_info *sbi) flags |= CP_ORPHAN_PRESENT_FLAG; } - set_cp(ckpt_flags, flags); + set_val(cp, ckpt_flags, flags); - set_cp(free_segment_count, get_free_segments(sbi)); - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); + set_val(cp, free_segment_count, get_free_segments(sbi)); + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_blk_no = get_sb(cp_blkaddr); + cp_blk_no = get_val(sb, cp_blkaddr); if (sbi->cur_cp == 2) - cp_blk_no += 1 << get_sb(log_blocks_per_seg); + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); /* write the first cp */ ret = dev_write_block(cp, cp_blk_no++); ASSERT(ret >= 0); /* skip payload */ - cp_blk_no += get_sb(cp_payload); + cp_blk_no += get_val(sb, cp_payload); /* skip orphan blocks */ cp_blk_no += orphan_blks; @@ -1635,7 +1635,7 @@ void build_nat_area_bitmap(struct f2fs_sb_info *sbi) ASSERT(nat_block); /* Alloc & build nat entry bitmap */ - nr_nat_blks = (get_sb(segment_count_nat) / 2) << + nr_nat_blks = (get_val(sb, segment_count_nat) / 2) << sbi->log_blocks_per_seg; fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; @@ -1731,7 +1731,7 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) print_ckpt_info(sbi); if (config.auto_fix) { - u32 flag = get_cp(ckpt_flags); + u32 flag = get_val(cp, ckpt_flags); if (flag & CP_FSCK_FLAG) config.fix_on = 1; @@ -1741,10 +1741,10 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) config.bug_on = 0; - sbi->total_valid_node_count = get_cp(valid_node_count); - sbi->total_valid_inode_count = get_cp(valid_inode_count); - sbi->user_block_count = get_cp(user_block_count); - sbi->total_valid_block_count = get_cp(valid_block_count); + sbi->total_valid_node_count = get_val(cp, valid_node_count); + sbi->total_valid_inode_count = get_val(cp, valid_inode_count); + sbi->user_block_count = get_val(cp, user_block_count); + sbi->total_valid_block_count = get_val(cp, valid_block_count); sbi->last_valid_block_count = sbi->total_valid_block_count; sbi->alloc_valid_block_count = 0; diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h index e1eeb6e..dcea541 100644 --- a/include/f2fs_fs.h +++ b/include/f2fs_fs.h @@ -270,61 +270,39 @@ struct f2fs_configuration { #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG)) #define BIT_WORD(nr) (nr / BITS_PER_LONG) -#define set_sb_le64(member, val) (sb->member = cpu_to_le64(val)) -#define set_sb_le32(member, val) (sb->member = cpu_to_le32(val)) -#define set_sb_le16(member, val) (sb->member = cpu_to_le16(val)) -#define get_sb_le64(member) le64_to_cpu(sb->member) -#define get_sb_le32(member) le32_to_cpu(sb->member) -#define get_sb_le16(member) le16_to_cpu(sb->member) - -#define set_sb(member, val) \ - do { \ - typeof(sb->member) t; \ - switch (sizeof(t)) { \ - case 8: set_sb_le64(member, val); break; \ - case 4: set_sb_le32(member, val); break; \ - case 2: set_sb_le16(member, val); break; \ - } \ +#define set_le64(ptr, member, val) ((ptr)->member = cpu_to_le64(val)) +#define set_le32(ptr, member, val) ((ptr)->member = cpu_to_le32(val)) +#define set_le16(ptr, member, val) ((ptr)->member = cpu_to_le16(val)) +#define get_le64(ptr, member) le64_to_cpu((ptr)->member) +#define get_le32(ptr, member) le32_to_cpu((ptr)->member) +#define get_le16(ptr, member) le16_to_cpu((ptr)->member) + +#define set_val(ptr, member, val) \ + do { \ + typeof((ptr)->member) t; \ + switch (sizeof(t)) { \ + case 8: set_le64(ptr, member, val); break; \ + case 4: set_le32(ptr, member, val); break; \ + case 2: set_le16(ptr, member, val); break; \ + } \ } while(0) -#define get_sb(member) \ - ({ \ - typeof(sb->member) t; \ - switch (sizeof(t)) { \ - case 8: t = get_sb_le64(member); break; \ - case 4: t = get_sb_le32(member); break; \ - case 2: t = get_sb_le16(member); break; \ - } \ - t; \ +#define get_val(ptr, member) \ + ({ \ + typeof((ptr)->member) t; \ + switch (sizeof(t)) { \ + case 8: t = get_le64(ptr, member); break; \ + case 4: t = get_le32(ptr, member); break; \ + case 2: t = get_le16(ptr, member); break; \ + } \ + t; \ }) -#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val)) -#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val)) -#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val)) -#define get_cp_le64(member) le64_to_cpu(cp->member) -#define get_cp_le32(member) le32_to_cpu(cp->member) -#define get_cp_le16(member) le16_to_cpu(cp->member) - -#define set_cp(member, val) \ - do { \ - typeof(cp->member) t; \ - switch (sizeof(t)) { \ - case 8: set_cp_le64(member, val); break; \ - case 4: set_cp_le32(member, val); break; \ - case 2: set_cp_le16(member, val); break; \ - } \ - } while(0) - -#define get_cp(member) \ - ({ \ - typeof(cp->member) t; \ - switch (sizeof(t)) { \ - case 8: t = get_cp_le64(member); break; \ - case 4: t = get_cp_le32(member); break; \ - case 2: t = get_cp_le16(member); break; \ - } \ - t; \ - }) +/* These are deprecated, please use get_val and set_val */ +#define get_sb(member) get_val(sb, member) +#define set_sb(member) set_val(sb, member) +#define get_cp(member) get_val(cp, member) +#define set_cp(member) set_val(cp, member) /* * Copied from include/linux/kernel.h @@ -899,7 +877,7 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) double reserved, ovp, candidate, end, diff, space; double max_ovp = 0, max_space = 0; - if (get_sb(segment_count_main) < 256) { + if (get_val(sb, segment_count_main) < 256) { candidate = 10; end = 95; diff = 5; @@ -911,9 +889,9 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) for (; candidate <= end; candidate += diff) { reserved = (2 * (100 / candidate + 1) + 6) * - get_sb(segs_per_sec); - ovp = (get_sb(segment_count_main) - reserved) * candidate / 100; - space = get_sb(segment_count_main) - reserved - ovp; + get_val(sb, segs_per_sec); + ovp = (get_val(sb, segment_count_main) - reserved) * candidate / 100; + space = get_val(sb, segment_count_main) - reserved - ovp; if (max_space < space) { max_space = space; max_ovp = candidate; diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c index 645c2aa..db5348e 100644 --- a/mkfs/f2fs_format.c +++ b/mkfs/f2fs_format.c @@ -83,7 +83,7 @@ static void configure_extension_list(void) int name_len; int i = 0; - set_sb(extension_count, 0); + set_val(sb, extension_count, 0); memset(sb->extension_list, 0, sizeof(sb->extension_list)); while (*extlist) { @@ -91,7 +91,7 @@ static void configure_extension_list(void) memcpy(sb->extension_list[i++], *extlist, name_len); extlist++; } - set_sb(extension_count, i); + set_val(sb, extension_count, i); if (!ext_str) return; @@ -112,7 +112,7 @@ next: break; } - set_sb(extension_count, i); + set_val(sb, extension_count, i); free(config.extension_list); } @@ -132,23 +132,23 @@ static int f2fs_prepare_super_block(void) u_int32_t max_nat_bitmap_size, max_nat_segments; u_int32_t total_zones; - set_sb(magic, F2FS_SUPER_MAGIC); - set_sb(major_ver, F2FS_MAJOR_VERSION); - set_sb(minor_ver, F2FS_MINOR_VERSION); + set_val(sb, magic, F2FS_SUPER_MAGIC); + set_val(sb, major_ver, F2FS_MAJOR_VERSION); + set_val(sb, minor_ver, F2FS_MINOR_VERSION); log_sectorsize = log_base_2(config.sector_size); log_sectors_per_block = log_base_2(config.sectors_per_blk); log_blocksize = log_sectorsize + log_sectors_per_block; log_blks_per_seg = log_base_2(config.blks_per_seg); - set_sb(log_sectorsize, log_sectorsize); - set_sb(log_sectors_per_block, log_sectors_per_block); + set_val(sb, log_sectorsize, log_sectorsize); + set_val(sb, log_sectors_per_block, log_sectors_per_block); - set_sb(log_blocksize, log_blocksize); - set_sb(log_blocks_per_seg, log_blks_per_seg); + set_val(sb, log_blocksize, log_blocksize); + set_val(sb, log_blocks_per_seg, log_blks_per_seg); - set_sb(segs_per_sec, config.segs_per_sec); - set_sb(secs_per_zone, config.secs_per_zone); + set_val(sb, segs_per_sec, config.segs_per_sec); + set_val(sb, secs_per_zone, config.secs_per_zone); blk_size_bytes = 1 << log_blocksize; segment_size_bytes = blk_size_bytes * config.blks_per_seg; @@ -156,9 +156,9 @@ static int f2fs_prepare_super_block(void) blk_size_bytes * config.secs_per_zone * config.segs_per_sec * config.blks_per_seg; - set_sb(checksum_offset, 0); + set_val(sb, checksum_offset, 0); - set_sb(block_count, config.total_sectors >> log_sectors_per_block); + set_val(sb, block_count, config.total_sectors >> log_sectors_per_block); zone_align_start_offset = (config.start_sector * config.sector_size + @@ -174,41 +174,41 @@ static int f2fs_prepare_super_block(void) config.sectors_per_blk); } - set_sb(segment_count, (config.total_sectors * config.sector_size - + set_val(sb, segment_count, (config.total_sectors * config.sector_size - zone_align_start_offset) / segment_size_bytes); - set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes); + set_val(sb, segment0_blkaddr, zone_align_start_offset / blk_size_bytes); sb->cp_blkaddr = sb->segment0_blkaddr; - MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr)); + MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_val(sb, segment0_blkaddr)); - set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); + set_val(sb, segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); - set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) * + set_val(sb, sit_blkaddr, get_val(sb, segment0_blkaddr) + get_val(sb, segment_count_ckpt) * config.blks_per_seg); - blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK); + blocks_for_sit = ALIGN(get_val(sb, segment_count), SIT_ENTRY_PER_BLOCK); sit_segments = SEG_ALIGN(blocks_for_sit); - set_sb(segment_count_sit, sit_segments * 2); + set_val(sb, segment_count_sit, sit_segments * 2); - set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) * + set_val(sb, nat_blkaddr, get_val(sb, sit_blkaddr) + get_val(sb, segment_count_sit) * config.blks_per_seg); - total_valid_blks_available = (get_sb(segment_count) - - (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) * + total_valid_blks_available = (get_val(sb, segment_count) - + (get_val(sb, segment_count_ckpt) + get_val(sb, segment_count_sit))) * config.blks_per_seg; blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK); - set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat)); + set_val(sb, segment_count_nat, SEG_ALIGN(blocks_for_nat)); /* * The number of node segments should not be exceeded a "Threshold". * This number resizes NAT bitmap area in a CP page. * So the threshold is determined not to overflow one CP page */ - sit_bitmap_size = ((get_sb(segment_count_sit) / 2) << + sit_bitmap_size = ((get_val(sb, segment_count_sit) / 2) << log_blks_per_seg) / 8; if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE) @@ -223,55 +223,55 @@ static int f2fs_prepare_super_block(void) if (max_sit_bitmap_size > (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - 64)) { max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1; - set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); + set_val(sb, cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); } else { max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - max_sit_bitmap_size; - set_sb(cp_payload, 0); + set_val(sb, cp_payload, 0); } max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; - if (get_sb(segment_count_nat) > max_nat_segments) - set_sb(segment_count_nat, max_nat_segments); + if (get_val(sb, segment_count_nat) > max_nat_segments) + set_val(sb, segment_count_nat, max_nat_segments); - set_sb(segment_count_nat, get_sb(segment_count_nat) * 2); + set_val(sb, segment_count_nat, get_val(sb, segment_count_nat) * 2); - set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) * + set_val(sb, ssa_blkaddr, get_val(sb, nat_blkaddr) + get_val(sb, segment_count_nat) * config.blks_per_seg); - total_valid_blks_available = (get_sb(segment_count) - - (get_sb(segment_count_ckpt) + - get_sb(segment_count_sit) + - get_sb(segment_count_nat))) * + total_valid_blks_available = (get_val(sb, segment_count) - + (get_val(sb, segment_count_ckpt) + + get_val(sb, segment_count_sit) + + get_val(sb, segment_count_nat))) * config.blks_per_seg; blocks_for_ssa = total_valid_blks_available / config.blks_per_seg + 1; - set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); + set_val(sb, segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); - total_meta_segments = get_sb(segment_count_ckpt) + - get_sb(segment_count_sit) + - get_sb(segment_count_nat) + - get_sb(segment_count_ssa); + total_meta_segments = get_val(sb, segment_count_ckpt) + + get_val(sb, segment_count_sit) + + get_val(sb, segment_count_nat) + + get_val(sb, segment_count_ssa); diff = total_meta_segments % (config.segs_per_zone); if (diff) - set_sb(segment_count_ssa, get_sb(segment_count_ssa) + + set_val(sb, segment_count_ssa, get_val(sb, segment_count_ssa) + (config.segs_per_zone - diff)); total_meta_zones = ZONE_ALIGN(total_meta_segments * config.blks_per_seg); - set_sb(main_blkaddr, get_sb(segment0_blkaddr) + total_meta_zones * + set_val(sb, main_blkaddr, get_val(sb, segment0_blkaddr) + total_meta_zones * config.segs_per_zone * config.blks_per_seg); - total_zones = get_sb(segment_count) / (config.segs_per_zone) - + total_zones = get_val(sb, segment_count) / (config.segs_per_zone) - total_meta_zones; - set_sb(section_count, total_zones * config.secs_per_zone); + set_val(sb, section_count, total_zones * config.secs_per_zone); - set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec); + set_val(sb, segment_count_main, get_val(sb, section_count) * config.segs_per_sec); /* Let's determine the best reserved and overprovisioned space */ if (config.overprovision == 0) @@ -281,12 +281,12 @@ static int f2fs_prepare_super_block(void) (2 * (100 / config.overprovision + 1) + 6) * config.segs_per_sec; - if ((get_sb(segment_count_main) - 2) < + if ((get_val(sb, segment_count_main) - 2) < config.reserved_segments) { MSG(1, "\tError: Device size is not sufficient for F2FS volume,\ more segment needed =%u", config.reserved_segments - - (get_sb(segment_count_main) - 2)); + (get_val(sb, segment_count_main) - 2)); return -1; } @@ -294,9 +294,9 @@ static int f2fs_prepare_super_block(void) utf8_to_utf16(sb->volume_name, (const char *)config.vol_label, MAX_VOLUME_NAME, strlen(config.vol_label)); - set_sb(node_ino, 1); - set_sb(meta_ino, 2); - set_sb(root_ino, 3); + set_val(sb, node_ino, 1); + set_val(sb, meta_ino, 2); + set_val(sb, root_ino, 3); if (total_zones <= 6) { MSG(1, "\tError: %d zones: Need more zones \ @@ -346,8 +346,8 @@ static int f2fs_init_sit_area(void) u_int64_t sit_seg_addr = 0; u_int8_t *zero_buf = NULL; - blk_size = 1 << get_sb(log_blocksize); - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; + blk_size = 1 << get_val(sb, log_blocksize); + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; zero_buf = calloc(sizeof(u_int8_t), seg_size); if(zero_buf == NULL) { @@ -355,11 +355,11 @@ static int f2fs_init_sit_area(void) return -1; } - sit_seg_addr = get_sb(sit_blkaddr); + sit_seg_addr = get_val(sb, sit_blkaddr); sit_seg_addr *= blk_size; DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr); - for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) { + for (index = 0; index < (get_val(sb, segment_count_sit) / 2); index++) { if (dev_fill(zero_buf, sit_seg_addr, seg_size)) { MSG(1, "\tError: While zeroing out the sit area \ on disk!!!\n"); @@ -380,8 +380,8 @@ static int f2fs_init_nat_area(void) u_int64_t nat_seg_addr = 0; u_int8_t *nat_buf = NULL; - blk_size = 1 << get_sb(log_blocksize); - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; + blk_size = 1 << get_val(sb, log_blocksize); + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; nat_buf = calloc(sizeof(u_int8_t), seg_size); if (nat_buf == NULL) { @@ -389,11 +389,11 @@ static int f2fs_init_nat_area(void) return -1; } - nat_seg_addr = get_sb(nat_blkaddr); + nat_seg_addr = get_val(sb, nat_blkaddr); nat_seg_addr *= blk_size; DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr); - for (index = 0; index < get_sb(segment_count_nat) / 2; index++) { + for (index = 0; index < get_val(sb, segment_count_nat) / 2; index++) { if (dev_fill(nat_buf, nat_seg_addr, seg_size)) { MSG(1, "\tError: While zeroing out the nat area \ on disk!!!\n"); @@ -445,58 +445,58 @@ static int f2fs_write_check_point_pack(void) } /* 1. cp page 1 of checkpoint pack 1 */ - set_cp(checkpoint_ver, 1); - set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); - set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); - set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); - set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); - set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); - set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); + set_val(cp, checkpoint_ver, 1); + set_val(cp, cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); + set_val(cp, cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); + set_val(cp, cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); + set_val(cp, cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); + set_val(cp, cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); + set_val(cp, cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { - set_cp(cur_node_segno[i], 0xffffffff); - set_cp(cur_data_segno[i], 0xffffffff); + set_val(cp, cur_node_segno[i], 0xffffffff); + set_val(cp, cur_data_segno[i], 0xffffffff); } - set_cp(cur_node_blkoff[0], 1); - set_cp(cur_data_blkoff[0], 1); - set_cp(valid_block_count, 2); - set_cp(rsvd_segment_count, config.reserved_segments); - set_cp(overprov_segment_count, (get_sb(segment_count_main) - - get_cp(rsvd_segment_count)) * + set_val(cp, cur_node_blkoff[0], 1); + set_val(cp, cur_data_blkoff[0], 1); + set_val(cp, valid_block_count, 2); + set_val(cp, rsvd_segment_count, config.reserved_segments); + set_val(cp, overprov_segment_count, (get_val(sb, segment_count_main) - + get_val(cp, rsvd_segment_count)) * config.overprovision / 100); - set_cp(overprov_segment_count, get_cp(overprov_segment_count) + - get_cp(rsvd_segment_count)); + set_val(cp, overprov_segment_count, get_val(cp, overprov_segment_count) + + get_val(cp, rsvd_segment_count)); MSG(0, "Info: Overprovision ratio = %.3lf%%\n", config.overprovision); MSG(0, "Info: Overprovision segments = %u (GC reserved = %u)\n", - get_cp(overprov_segment_count), + get_val(cp, overprov_segment_count), config.reserved_segments); /* main segments - reserved segments - (node + data segments) */ - set_cp(free_segment_count, get_sb(segment_count_main) - 6); - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - - get_cp(overprov_segment_count)) * config.blks_per_seg)); + set_val(cp, free_segment_count, get_val(sb, segment_count_main) - 6); + set_val(cp, user_block_count, ((get_val(cp, free_segment_count) + 6 - + get_val(cp, overprov_segment_count)) * config.blks_per_seg)); /* cp page (2), data summaries (1), node summaries (3) */ - set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); - set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); - set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); - set_cp(valid_node_count, 1); - set_cp(valid_inode_count, 1); - set_cp(next_free_nid, get_sb(root_ino) + 1); - set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << - get_sb(log_blocks_per_seg)) / 8); + set_val(cp, cp_pack_total_block_count, 6 + get_val(sb, cp_payload)); + set_val(cp, ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); + set_val(cp, cp_pack_start_sum, 1 + get_val(sb, cp_payload)); + set_val(cp, valid_node_count, 1); + set_val(cp, valid_inode_count, 1); + set_val(cp, next_free_nid, get_val(sb, root_ino) + 1); + set_val(cp, sit_ver_bitmap_bytesize, ((get_val(sb, segment_count_sit) / 2) << + get_val(sb, log_blocks_per_seg)) / 8); - set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) << - get_sb(log_blocks_per_seg)) / 8); + set_val(cp, nat_ver_bitmap_bytesize, ((get_val(sb, segment_count_nat) / 2) << + get_val(sb, log_blocks_per_seg)) / 8); - set_cp(checksum_offset, CHECKSUM_OFFSET); + set_val(cp, checksum_offset, CHECKSUM_OFFSET); crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - blk_size_bytes = 1 << get_sb(log_blocksize); - cp_seg_blk_offset = get_sb(segment0_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + cp_seg_blk_offset = get_val(sb, segment0_blkaddr); cp_seg_blk_offset *= blk_size_bytes; DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); @@ -505,7 +505,7 @@ static int f2fs_write_check_point_pack(void) goto free_cp_payload; } - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { cp_seg_blk_offset += blk_size_bytes; if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While zeroing out the sit bitmap area \ @@ -537,8 +537,8 @@ static int f2fs_write_check_point_pack(void) sum->nat_j.entries[0].ne.version = 0; sum->nat_j.entries[0].ne.ino = sb->root_ino; sum->nat_j.entries[0].ne.block_addr = cpu_to_le32( - get_sb(main_blkaddr) + - get_cp(cur_node_segno[0]) * config.blks_per_seg); + get_val(sb, main_blkaddr) + + get_val(cp, cur_node_segno[0]) * config.blks_per_seg); memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE); sum_compact_p += SUM_JOURNAL_SIZE; @@ -635,7 +635,7 @@ static int f2fs_write_check_point_pack(void) crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); - cp_seg_blk_offset = (get_sb(segment0_blkaddr) + + cp_seg_blk_offset = (get_val(sb, segment0_blkaddr) + config.blks_per_seg) * blk_size_bytes; DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); @@ -644,7 +644,7 @@ static int f2fs_write_check_point_pack(void) goto free_cp_payload; } - for (i = 0; i < get_sb(cp_payload); i++) { + for (i = 0; i < get_val(sb, cp_payload); i++) { cp_seg_blk_offset += blk_size_bytes; if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While zeroing out the sit bitmap area \ @@ -655,7 +655,7 @@ static int f2fs_write_check_point_pack(void) /* cp page 2 of check point pack 2 */ cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count) - - get_sb(cp_payload) - 1); + - get_val(sb, cp_payload) - 1); DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) { MSG(1, "\tError: While writing the cp to disk!!!\n"); @@ -701,8 +701,8 @@ static int f2fs_write_super_block(void) static int discard_obsolete_dnode(struct f2fs_node *raw_node, u_int64_t offset) { do { - if (offset < get_sb(main_blkaddr) || - offset >= get_sb(main_blkaddr) + get_sb(block_count)) + if (offset < get_val(sb, main_blkaddr) || + offset >= get_val(sb, main_blkaddr) + get_val(sb, block_count)) break; if (dev_read_block(raw_node, offset)) { @@ -740,7 +740,7 @@ static int f2fs_write_root_inode(void) raw_node->footer.ino = sb->root_ino; raw_node->footer.cp_ver = cpu_to_le64(1); raw_node->footer.next_blkaddr = cpu_to_le32( - get_sb(main_blkaddr) + + get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg + 1); @@ -749,7 +749,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_uid = cpu_to_le32(getuid()); raw_node->i.i_gid = cpu_to_le32(getgid()); - blk_size_bytes = 1 << get_sb(log_blocksize); + blk_size_bytes = 1 << get_val(sb, log_blocksize); raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */ raw_node->i.i_blocks = cpu_to_le64(2); @@ -765,7 +765,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_current_depth = cpu_to_le32(1); raw_node->i.i_dir_level = DEF_DIR_LEVEL; - data_blk_nor = get_sb(main_blkaddr) + + data_blk_nor = get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor); @@ -773,7 +773,7 @@ static int f2fs_write_root_inode(void) raw_node->i.i_ext.blk_addr = 0; raw_node->i.i_ext.len = 0; - main_area_node_seg_blk_offset = get_sb(main_blkaddr); + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg; main_area_node_seg_blk_offset *= blk_size_bytes; @@ -786,7 +786,7 @@ static int f2fs_write_root_inode(void) } /* avoid power-off-recovery based on roll-forward policy */ - main_area_node_seg_blk_offset = get_sb(main_blkaddr); + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] * config.blks_per_seg; @@ -813,21 +813,21 @@ static int f2fs_update_nat_root(void) } /* update root */ - nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32( - get_sb(main_blkaddr) + + nat_blk->entries[get_val(sb, root_ino)].block_addr = cpu_to_le32( + get_val(sb, main_blkaddr) + config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg); - nat_blk->entries[get_sb(root_ino)].ino = sb->root_ino; + nat_blk->entries[get_val(sb, root_ino)].ino = sb->root_ino; /* update node nat */ - nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1); - nat_blk->entries[get_sb(node_ino)].ino = sb->node_ino; + nat_blk->entries[get_val(sb, node_ino)].block_addr = cpu_to_le32(1); + nat_blk->entries[get_val(sb, node_ino)].ino = sb->node_ino; /* update meta nat */ - nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1); - nat_blk->entries[get_sb(meta_ino)].ino = sb->meta_ino; + nat_blk->entries[get_val(sb, meta_ino)].block_addr = cpu_to_le32(1); + nat_blk->entries[get_val(sb, meta_ino)].ino = sb->meta_ino; - blk_size_bytes = 1 << get_sb(log_blocksize); - nat_seg_blk_offset = get_sb(nat_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + nat_seg_blk_offset = get_val(sb, nat_blkaddr); nat_seg_blk_offset *= blk_size_bytes; DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset); @@ -867,8 +867,8 @@ static int f2fs_add_default_dentry_root(void) /* bitmap for . and .. */ test_and_set_bit_le(0, dent_blk->dentry_bitmap); test_and_set_bit_le(1, dent_blk->dentry_bitmap); - blk_size_bytes = 1 << get_sb(log_blocksize); - data_blk_offset = get_sb(main_blkaddr); + blk_size_bytes = 1 << get_val(sb, log_blocksize); + data_blk_offset = get_val(sb, main_blkaddr); data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; data_blk_offset *= blk_size_bytes; -- 1.9.1 ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} 2016-01-30 2:25 ` Sheng Yong 2016-01-30 10:03 ` [RFC PATCH v2] " Sheng Yong @ 2016-02-02 0:27 ` Jaegeuk Kim 1 sibling, 0 replies; 9+ messages in thread From: Jaegeuk Kim @ 2016-02-02 0:27 UTC (permalink / raw) To: Sheng Yong; +Cc: linux-f2fs-devel Hello, On Sat, Jan 30, 2016 at 10:25:05AM +0800, Sheng Yong wrote: > Hi, Kim > > On 1/30/2016 9:46 AM, Jaegeuk Kim wrote: > > Hi Sheng, > > > > This is not a good way. > > You're asking to change all the pending patches as well. > > > > Why not just adding two definitions like these? > > > > #define get_sb(member) get_val(sb, member) > > #define set_sb(member, val) set_sb(sb, member, val) > > #define get_cp(member) get_val(cp, member) > > #define set_cp(member, val) set_sb(cp, member, val) > > > You mean we should still keep the get_{sb|cp} and set_{sb|cp} for some time but > mark them as deprecated? Anyway, this is a trivial cleanup. I think it's ok to > keep it as it is now :) No, I don't agree. IMO, there is no reason to remove get_{sb|cp} and set_{sb|cp}. What benefits can you describe in this patch? I just thought that you tried to remove redundant macros in f2fs_fs.h. If so, the only worthy change looks like adding wrapper macros like above. Thanks, > > thanks, > Sheng > > Thanks, > > > > On Sat, Jan 30, 2016 at 09:16:36AM +0000, Sheng Yong wrote: > >> * Remove dumplicated definitions of get_{sb|cp} and set_{sb|cp}, and introduce > >> micros get_val and set_val instead. > >> * Add a new parameter to get_val and set_val so that they are not depended on > >> implied definition of `sb' and `cp'. > >> > >> Signed-off-by: Sheng Yong <shengyong1@huawei.com> > >> --- > >> fsck/fsck.c | 20 ++--- > >> fsck/main.c | 8 +- > >> fsck/mount.c | 146 ++++++++++++++++----------------- > >> include/f2fs_fs.h | 84 +++++++------------ > >> mkfs/f2fs_format.c | 234 ++++++++++++++++++++++++++--------------------------- > >> 5 files changed, 232 insertions(+), 260 deletions(-) > >> > >> diff --git a/fsck/fsck.c b/fsck/fsck.c > >> index e7dd02f..4fbb56d 100644 > >> --- a/fsck/fsck.c > >> +++ b/fsck/fsck.c > >> @@ -1191,7 +1191,7 @@ void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) > >> if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) > >> return; > >> > >> - start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload); > >> + start_blk = __start_cp_addr(sbi) + 1 + get_val(sb, cp_payload); > >> orphan_blkaddr = __start_sum_addr(sbi) - 1; > >> > >> orphan_blk = calloc(BLOCK_SZ, 1); > >> @@ -1324,25 +1324,25 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi) > >> flags |= CP_ORPHAN_PRESENT_FLAG; > >> } > >> > >> - set_cp(ckpt_flags, flags); > >> - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); > >> + set_val(cp, ckpt_flags, flags); > >> + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); > >> > >> - set_cp(free_segment_count, fsck->chk.free_segs); > >> - set_cp(valid_block_count, fsck->chk.valid_blk_cnt); > >> - set_cp(valid_node_count, fsck->chk.valid_node_cnt); > >> - set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); > >> + set_val(cp, free_segment_count, fsck->chk.free_segs); > >> + set_val(cp, valid_block_count, fsck->chk.valid_blk_cnt); > >> + set_val(cp, valid_node_count, fsck->chk.valid_node_cnt); > >> + set_val(cp, valid_inode_count, fsck->chk.valid_inode_cnt); > >> > >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); > >> > >> - cp_blk_no = get_sb(cp_blkaddr); > >> + cp_blk_no = get_val(sb, cp_blkaddr); > >> if (sbi->cur_cp == 2) > >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > >> > >> ret = dev_write_block(cp, cp_blk_no++); > >> ASSERT(ret >= 0); > >> > >> - for (i = 0; i < get_sb(cp_payload); i++) { > >> + for (i = 0; i < get_val(sb, cp_payload); i++) { > >> ret = dev_write_block(((unsigned char *)cp) + i * F2FS_BLKSIZE, > >> cp_blk_no++); > >> ASSERT(ret >= 0); > >> diff --git a/fsck/main.c b/fsck/main.c > >> index 54dbb2d..7fcaa5d 100644 > >> --- a/fsck/main.c > >> +++ b/fsck/main.c > >> @@ -255,7 +255,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) > >> { > >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > >> > >> - if (config.defrag_start > get_sb(block_count)) > >> + if (config.defrag_start > get_val(sb, block_count)) > >> goto out_range; > >> if (config.defrag_start < SM_I(sbi)->main_blkaddr) > >> config.defrag_start = SM_I(sbi)->main_blkaddr; > >> @@ -263,8 +263,8 @@ static int do_defrag(struct f2fs_sb_info *sbi) > >> if (config.defrag_len == 0) > >> config.defrag_len = sbi->blocks_per_seg; > >> > >> - if (config.defrag_start + config.defrag_len > get_sb(block_count)) > >> - config.defrag_len = get_sb(block_count) - config.defrag_start; > >> + if (config.defrag_start + config.defrag_len > get_val(sb, block_count)) > >> + config.defrag_len = get_val(sb, block_count) - config.defrag_start; > >> > >> if (config.defrag_target == 0) { > >> config.defrag_target = config.defrag_start - 1; > >> @@ -273,7 +273,7 @@ static int do_defrag(struct f2fs_sb_info *sbi) > >> } > >> > >> if (config.defrag_target < SM_I(sbi)->main_blkaddr || > >> - config.defrag_target > get_sb(block_count)) > >> + config.defrag_target > get_val(sb, block_count)) > >> goto out_range; > >> if (config.defrag_target >= config.defrag_start && > >> config.defrag_target < config.defrag_start + config.defrag_len) > >> diff --git a/fsck/mount.c b/fsck/mount.c > >> index 4c807f9..6e6d230 100644 > >> --- a/fsck/mount.c > >> +++ b/fsck/mount.c > >> @@ -269,21 +269,21 @@ int sanity_check_raw_super(struct f2fs_super_block *sb) > >> { > >> unsigned int blocksize; > >> > >> - if (F2FS_SUPER_MAGIC != get_sb(magic)) > >> + if (F2FS_SUPER_MAGIC != get_val(sb, magic)) > >> return -1; > >> > >> if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) > >> return -1; > >> > >> - blocksize = 1 << get_sb(log_blocksize); > >> + blocksize = 1 << get_val(sb, log_blocksize); > >> if (F2FS_BLKSIZE != blocksize) > >> return -1; > >> > >> - if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || > >> - get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) > >> + if (get_val(sb, log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || > >> + get_val(sb, log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) > >> return -1; > >> > >> - if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != > >> + if (get_val(sb, log_sectors_per_block) + get_val(sb, log_sectorsize) != > >> F2FS_MAX_LOG_SECTOR_SIZE) > >> return -1; > >> > >> @@ -350,22 +350,22 @@ int init_sb_info(struct f2fs_sb_info *sbi) > >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > >> u64 total_sectors; > >> > >> - sbi->log_sectors_per_block = get_sb(log_sectors_per_block); > >> - sbi->log_blocksize = get_sb(log_blocksize); > >> + sbi->log_sectors_per_block = get_val(sb, log_sectors_per_block); > >> + sbi->log_blocksize = get_val(sb, log_blocksize); > >> sbi->blocksize = 1 << sbi->log_blocksize; > >> - sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); > >> + sbi->log_blocks_per_seg = get_val(sb, log_blocks_per_seg); > >> sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; > >> - sbi->segs_per_sec = get_sb(segs_per_sec); > >> - sbi->secs_per_zone = get_sb(secs_per_zone); > >> - sbi->total_sections = get_sb(section_count); > >> - sbi->total_node_count = (get_sb(segment_count_nat) / 2) * > >> + sbi->segs_per_sec = get_val(sb, segs_per_sec); > >> + sbi->secs_per_zone = get_val(sb, secs_per_zone); > >> + sbi->total_sections = get_val(sb, section_count); > >> + sbi->total_node_count = (get_val(sb, segment_count_nat) / 2) * > >> sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; > >> - sbi->root_ino_num = get_sb(root_ino); > >> - sbi->node_ino_num = get_sb(node_ino); > >> - sbi->meta_ino_num = get_sb(meta_ino); > >> + sbi->root_ino_num = get_val(sb, root_ino); > >> + sbi->node_ino_num = get_val(sb, node_ino); > >> + sbi->meta_ino_num = get_val(sb, meta_ino); > >> sbi->cur_victim_sec = NULL_SEGNO; > >> > >> - total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; > >> + total_sectors = get_val(sb, block_count) << sbi->log_sectors_per_block; > >> MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", > >> total_sectors, total_sectors >> 11); > >> return 0; > >> @@ -387,7 +387,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > >> return NULL; > >> > >> cp = (struct f2fs_checkpoint *)cp_page_1; > >> - crc_offset = get_cp(checksum_offset); > >> + crc_offset = get_val(cp, checksum_offset); > >> if (crc_offset >= blk_size) > >> goto invalid_cp1; > >> > >> @@ -395,17 +395,17 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > >> if (f2fs_crc_valid(crc, cp, crc_offset)) > >> goto invalid_cp1; > >> > >> - pre_version = get_cp(checkpoint_ver); > >> + pre_version = get_val(cp, checkpoint_ver); > >> > >> /* Read the 2nd cp block in this CP pack */ > >> cp_page_2 = malloc(PAGE_SIZE); > >> - cp_addr += get_cp(cp_pack_total_block_count) - 1; > >> + cp_addr += get_val(cp, cp_pack_total_block_count) - 1; > >> > >> if (dev_read_block(cp_page_2, cp_addr) < 0) > >> goto invalid_cp2; > >> > >> cp = (struct f2fs_checkpoint *)cp_page_2; > >> - crc_offset = get_cp(checksum_offset); > >> + crc_offset = get_val(cp, checksum_offset); > >> if (crc_offset >= blk_size) > >> goto invalid_cp2; > >> > >> @@ -413,7 +413,7 @@ void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, > >> if (f2fs_crc_valid(crc, cp, crc_offset)) > >> goto invalid_cp2; > >> > >> - cur_version = get_cp(checkpoint_ver); > >> + cur_version = get_val(cp, checkpoint_ver); > >> > >> if (cur_version == pre_version) { > >> *version = cur_version; > >> @@ -435,7 +435,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > >> unsigned long blk_size = sbi->blocksize; > >> unsigned long long cp1_version = 0, cp2_version = 0, version; > >> unsigned long long cp_start_blk_no; > >> - unsigned int cp_blks = 1 + get_sb(cp_payload); > >> + unsigned int cp_blks = 1 + get_val(sb, cp_payload); > >> int ret; > >> > >> sbi->ckpt = malloc(cp_blks * blk_size); > >> @@ -445,11 +445,11 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > >> * Finding out valid cp block involves read both > >> * sets( cp pack1 and cp pack 2) > >> */ > >> - cp_start_blk_no = get_sb(cp_blkaddr); > >> + cp_start_blk_no = get_val(sb, cp_blkaddr); > >> cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); > >> > >> /* The second checkpoint pack should start at the next segment */ > >> - cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); > >> + cp_start_blk_no += 1 << get_val(sb, log_blocks_per_seg); > >> cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); > >> > >> if (cp1 && cp2) { > >> @@ -481,9 +481,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) > >> unsigned int i; > >> unsigned long long cp_blk_no; > >> > >> - cp_blk_no = get_sb(cp_blkaddr); > >> + cp_blk_no = get_val(sb, cp_blkaddr); > >> if (cur_page == cp2) > >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > >> > >> /* copy sit bitmap */ > >> for (i = 1; i < cp_blks; i++) { > >> @@ -510,12 +510,12 @@ int sanity_check_ckpt(struct f2fs_sb_info *sbi) > >> struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); > >> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); > >> > >> - total = get_sb(segment_count); > >> - fsmeta = get_sb(segment_count_ckpt); > >> - fsmeta += get_sb(segment_count_sit); > >> - fsmeta += get_sb(segment_count_nat); > >> - fsmeta += get_cp(rsvd_segment_count); > >> - fsmeta += get_sb(segment_count_ssa); > >> + total = get_val(sb, segment_count); > >> + fsmeta = get_val(sb, segment_count_ckpt); > >> + fsmeta += get_val(sb, segment_count_sit); > >> + fsmeta += get_val(sb, segment_count_nat); > >> + fsmeta += get_val(cp, rsvd_segment_count); > >> + fsmeta += get_val(sb, segment_count_ssa); > >> > >> if (fsmeta >= total) > >> return 1; > >> @@ -531,16 +531,16 @@ int init_node_manager(struct f2fs_sb_info *sbi) > >> unsigned char *version_bitmap; > >> unsigned int nat_segs, nat_blocks; > >> > >> - nm_i->nat_blkaddr = get_sb(nat_blkaddr); > >> + nm_i->nat_blkaddr = get_val(sb, nat_blkaddr); > >> > >> /* segment_count_nat includes pair segment so divide to 2. */ > >> - nat_segs = get_sb(segment_count_nat) >> 1; > >> - nat_blocks = nat_segs << get_sb(log_blocks_per_seg); > >> + nat_segs = get_val(sb, segment_count_nat) >> 1; > >> + nat_blocks = nat_segs << get_val(sb, log_blocks_per_seg); > >> nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; > >> nm_i->fcnt = 0; > >> nm_i->nat_cnt = 0; > >> - nm_i->init_scan_nid = get_cp(next_free_nid); > >> - nm_i->next_scan_nid = get_cp(next_free_nid); > >> + nm_i->init_scan_nid = get_val(cp, next_free_nid); > >> + nm_i->next_scan_nid = get_val(cp, next_free_nid); > >> > >> nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); > >> > >> @@ -597,21 +597,21 @@ int build_sit_info(struct f2fs_sb_info *sbi) > >> return -ENOMEM; > >> } > >> > >> - sit_segs = get_sb(segment_count_sit) >> 1; > >> + sit_segs = get_val(sb, segment_count_sit) >> 1; > >> bitmap_size = __bitmap_size(sbi, SIT_BITMAP); > >> src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); > >> > >> dst_bitmap = malloc(bitmap_size); > >> memcpy(dst_bitmap, src_bitmap, bitmap_size); > >> > >> - sit_i->sit_base_addr = get_sb(sit_blkaddr); > >> + sit_i->sit_base_addr = get_val(sb, sit_blkaddr); > >> sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; > >> - sit_i->written_valid_blocks = get_cp(valid_block_count); > >> + sit_i->written_valid_blocks = get_val(cp, valid_block_count); > >> sit_i->sit_bitmap = dst_bitmap; > >> sit_i->bitmap_size = bitmap_size; > >> sit_i->dirty_sentries = 0; > >> sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; > >> - sit_i->elapsed_time = get_cp(elapsed_time); > >> + sit_i->elapsed_time = get_val(cp, elapsed_time); > >> return 0; > >> } > >> > >> @@ -716,13 +716,13 @@ static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) > >> int ret; > >> > >> if (IS_DATASEG(type)) { > >> - segno = get_cp(cur_data_segno[type]); > >> + segno = get_val(cp, cur_data_segno[type]); > >> if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) > >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); > >> else > >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); > >> } else { > >> - segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); > >> + segno = get_val(cp, cur_node_segno[type - CURSEG_HOT_NODE]); > >> if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) > >> blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, > >> type - CURSEG_HOT_NODE); > >> @@ -803,12 +803,12 @@ static void build_curseg(struct f2fs_sb_info *sbi) > >> array[i].sum_blk = malloc(PAGE_CACHE_SIZE); > >> ASSERT(array[i].sum_blk); > >> if (i <= CURSEG_COLD_DATA) { > >> - blk_off = get_cp(cur_data_blkoff[i]); > >> - segno = get_cp(cur_data_segno[i]); > >> + blk_off = get_val(cp, cur_data_blkoff[i]); > >> + segno = get_val(cp, cur_data_segno[i]); > >> } > >> if (i > CURSEG_COLD_DATA) { > >> - blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); > >> - segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); > >> + blk_off = get_val(cp, cur_node_blkoff[i - CURSEG_HOT_NODE]); > >> + segno = get_val(cp, cur_node_segno[i - CURSEG_HOT_NODE]); > >> } > >> array[i].segno = segno; > >> array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); > >> @@ -924,7 +924,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, > >> > >> ssa_blk = GET_SUM_BLKADDR(sbi, segno); > >> for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { > >> - if (segno == get_cp(cur_node_segno[type])) { > >> + if (segno == get_val(cp, cur_node_segno[type])) { > >> curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); > >> if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { > >> ASSERT_MSG("segno [0x%x] indicates a data " > >> @@ -939,7 +939,7 @@ struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, > >> } > >> > >> for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { > >> - if (segno == get_cp(cur_data_segno[type])) { > >> + if (segno == get_val(cp, cur_data_segno[type])) { > >> curseg = CURSEG_I(sbi, type); > >> if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { > >> ASSERT_MSG("segno [0x%x] indicates a node " > >> @@ -1151,13 +1151,13 @@ int build_segment_manager(struct f2fs_sb_info *sbi) > >> > >> /* init sm info */ > >> sbi->sm_info = sm_info; > >> - sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); > >> - sm_info->main_blkaddr = get_sb(main_blkaddr); > >> - sm_info->segment_count = get_sb(segment_count); > >> - sm_info->reserved_segments = get_cp(rsvd_segment_count); > >> - sm_info->ovp_segments = get_cp(overprov_segment_count); > >> - sm_info->main_segments = get_sb(segment_count_main); > >> - sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); > >> + sm_info->seg0_blkaddr = get_val(sb, segment0_blkaddr); > >> + sm_info->main_blkaddr = get_val(sb, main_blkaddr); > >> + sm_info->segment_count = get_val(sb, segment_count); > >> + sm_info->reserved_segments = get_val(cp, rsvd_segment_count); > >> + sm_info->ovp_segments = get_val(cp, overprov_segment_count); > >> + sm_info->main_segments = get_val(sb, segment_count_main); > >> + sm_info->ssa_blkaddr = get_val(sb, ssa_blkaddr); > >> > >> build_sit_info(sbi); > >> > >> @@ -1384,7 +1384,7 @@ void flush_sit_entries(struct f2fs_sb_info *sbi) > >> free_segs++; > >> } > >> > >> - set_cp(free_segment_count, free_segs); > >> + set_val(cp, free_segment_count, free_segs); > >> } > >> > >> int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type) > >> @@ -1487,14 +1487,14 @@ void write_curseg_info(struct f2fs_sb_info *sbi) > >> for (i = 0; i < NO_CHECK_TYPE; i++) { > >> cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; > >> if (i < CURSEG_HOT_NODE) { > >> - set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); > >> - set_cp(cur_data_blkoff[i], > >> + set_val(cp, cur_data_segno[i], CURSEG_I(sbi, i)->segno); > >> + set_val(cp, cur_data_blkoff[i], > >> CURSEG_I(sbi, i)->next_blkoff); > >> } else { > >> int n = i - CURSEG_HOT_NODE; > >> > >> - set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); > >> - set_cp(cur_node_blkoff[n], > >> + set_val(cp, cur_node_segno[n], CURSEG_I(sbi, i)->segno); > >> + set_val(cp, cur_node_blkoff[n], > >> CURSEG_I(sbi, i)->next_blkoff); > >> } > >> } > >> @@ -1578,24 +1578,24 @@ void write_checkpoint(struct f2fs_sb_info *sbi) > >> flags |= CP_ORPHAN_PRESENT_FLAG; > >> } > >> > >> - set_cp(ckpt_flags, flags); > >> + set_val(cp, ckpt_flags, flags); > >> > >> - set_cp(free_segment_count, get_free_segments(sbi)); > >> - set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); > >> + set_val(cp, free_segment_count, get_free_segments(sbi)); > >> + set_val(cp, cp_pack_total_block_count, 8 + orphan_blks + get_val(sb, cp_payload)); > >> > >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = cpu_to_le32(crc); > >> > >> - cp_blk_no = get_sb(cp_blkaddr); > >> + cp_blk_no = get_val(sb, cp_blkaddr); > >> if (sbi->cur_cp == 2) > >> - cp_blk_no += 1 << get_sb(log_blocks_per_seg); > >> + cp_blk_no += 1 << get_val(sb, log_blocks_per_seg); > >> > >> /* write the first cp */ > >> ret = dev_write_block(cp, cp_blk_no++); > >> ASSERT(ret >= 0); > >> > >> /* skip payload */ > >> - cp_blk_no += get_sb(cp_payload); > >> + cp_blk_no += get_val(sb, cp_payload); > >> /* skip orphan blocks */ > >> cp_blk_no += orphan_blks; > >> > >> @@ -1635,7 +1635,7 @@ void build_nat_area_bitmap(struct f2fs_sb_info *sbi) > >> ASSERT(nat_block); > >> > >> /* Alloc & build nat entry bitmap */ > >> - nr_nat_blks = (get_sb(segment_count_nat) / 2) << > >> + nr_nat_blks = (get_val(sb, segment_count_nat) / 2) << > >> sbi->log_blocks_per_seg; > >> > >> fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; > >> @@ -1731,7 +1731,7 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) > >> print_ckpt_info(sbi); > >> > >> if (config.auto_fix) { > >> - u32 flag = get_cp(ckpt_flags); > >> + u32 flag = get_val(cp, ckpt_flags); > >> > >> if (flag & CP_FSCK_FLAG) > >> config.fix_on = 1; > >> @@ -1741,10 +1741,10 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi) > >> > >> config.bug_on = 0; > >> > >> - sbi->total_valid_node_count = get_cp(valid_node_count); > >> - sbi->total_valid_inode_count = get_cp(valid_inode_count); > >> - sbi->user_block_count = get_cp(user_block_count); > >> - sbi->total_valid_block_count = get_cp(valid_block_count); > >> + sbi->total_valid_node_count = get_val(cp, valid_node_count); > >> + sbi->total_valid_inode_count = get_val(cp, valid_inode_count); > >> + sbi->user_block_count = get_val(cp, user_block_count); > >> + sbi->total_valid_block_count = get_val(cp, valid_block_count); > >> sbi->last_valid_block_count = sbi->total_valid_block_count; > >> sbi->alloc_valid_block_count = 0; > >> > >> diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h > >> index e1eeb6e..2ab9f49 100644 > >> --- a/include/f2fs_fs.h > >> +++ b/include/f2fs_fs.h > >> @@ -270,60 +270,32 @@ struct f2fs_configuration { > >> #define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG)) > >> #define BIT_WORD(nr) (nr / BITS_PER_LONG) > >> > >> -#define set_sb_le64(member, val) (sb->member = cpu_to_le64(val)) > >> -#define set_sb_le32(member, val) (sb->member = cpu_to_le32(val)) > >> -#define set_sb_le16(member, val) (sb->member = cpu_to_le16(val)) > >> -#define get_sb_le64(member) le64_to_cpu(sb->member) > >> -#define get_sb_le32(member) le32_to_cpu(sb->member) > >> -#define get_sb_le16(member) le16_to_cpu(sb->member) > >> - > >> -#define set_sb(member, val) \ > >> - do { \ > >> - typeof(sb->member) t; \ > >> - switch (sizeof(t)) { \ > >> - case 8: set_sb_le64(member, val); break; \ > >> - case 4: set_sb_le32(member, val); break; \ > >> - case 2: set_sb_le16(member, val); break; \ > >> - } \ > >> +#define set_le64(ptr, member, val) ((ptr)->member = cpu_to_le64(val)) > >> +#define set_le32(ptr, member, val) ((ptr)->member = cpu_to_le32(val)) > >> +#define set_le16(ptr, member, val) ((ptr)->member = cpu_to_le16(val)) > >> +#define get_le64(ptr, member) le64_to_cpu((ptr)->member) > >> +#define get_le32(ptr, member) le32_to_cpu((ptr)->member) > >> +#define get_le16(ptr, member) le16_to_cpu((ptr)->member) > >> + > >> +#define set_val(ptr, member, val) \ > >> + do { \ > >> + typeof((ptr)->member) t; \ > >> + switch (sizeof(t)) { \ > >> + case 8: set_le64(ptr, member, val); break; \ > >> + case 4: set_le32(ptr, member, val); break; \ > >> + case 2: set_le16(ptr, member, val); break; \ > >> + } \ > >> } while(0) > >> > >> -#define get_sb(member) \ > >> - ({ \ > >> - typeof(sb->member) t; \ > >> - switch (sizeof(t)) { \ > >> - case 8: t = get_sb_le64(member); break; \ > >> - case 4: t = get_sb_le32(member); break; \ > >> - case 2: t = get_sb_le16(member); break; \ > >> - } \ > >> - t; \ > >> - }) > >> - > >> -#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val)) > >> -#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val)) > >> -#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val)) > >> -#define get_cp_le64(member) le64_to_cpu(cp->member) > >> -#define get_cp_le32(member) le32_to_cpu(cp->member) > >> -#define get_cp_le16(member) le16_to_cpu(cp->member) > >> - > >> -#define set_cp(member, val) \ > >> - do { \ > >> - typeof(cp->member) t; \ > >> - switch (sizeof(t)) { \ > >> - case 8: set_cp_le64(member, val); break; \ > >> - case 4: set_cp_le32(member, val); break; \ > >> - case 2: set_cp_le16(member, val); break; \ > >> - } \ > >> - } while(0) > >> - > >> -#define get_cp(member) \ > >> - ({ \ > >> - typeof(cp->member) t; \ > >> - switch (sizeof(t)) { \ > >> - case 8: t = get_cp_le64(member); break; \ > >> - case 4: t = get_cp_le32(member); break; \ > >> - case 2: t = get_cp_le16(member); break; \ > >> - } \ > >> - t; \ > >> +#define get_val(ptr, member) \ > >> + ({ \ > >> + typeof((ptr)->member) t; \ > >> + switch (sizeof(t)) { \ > >> + case 8: t = get_le64(ptr, member); break; \ > >> + case 4: t = get_le32(ptr, member); break; \ > >> + case 2: t = get_le16(ptr, member); break; \ > >> + } \ > >> + t; \ > >> }) > >> > >> /* > >> @@ -899,7 +871,7 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) > >> double reserved, ovp, candidate, end, diff, space; > >> double max_ovp = 0, max_space = 0; > >> > >> - if (get_sb(segment_count_main) < 256) { > >> + if (get_val(sb, segment_count_main) < 256) { > >> candidate = 10; > >> end = 95; > >> diff = 5; > >> @@ -911,9 +883,9 @@ static inline double get_best_overprovision(struct f2fs_super_block *sb) > >> > >> for (; candidate <= end; candidate += diff) { > >> reserved = (2 * (100 / candidate + 1) + 6) * > >> - get_sb(segs_per_sec); > >> - ovp = (get_sb(segment_count_main) - reserved) * candidate / 100; > >> - space = get_sb(segment_count_main) - reserved - ovp; > >> + get_val(sb, segs_per_sec); > >> + ovp = (get_val(sb, segment_count_main) - reserved) * candidate / 100; > >> + space = get_val(sb, segment_count_main) - reserved - ovp; > >> if (max_space < space) { > >> max_space = space; > >> max_ovp = candidate; > >> diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c > >> index 645c2aa..db5348e 100644 > >> --- a/mkfs/f2fs_format.c > >> +++ b/mkfs/f2fs_format.c > >> @@ -83,7 +83,7 @@ static void configure_extension_list(void) > >> int name_len; > >> int i = 0; > >> > >> - set_sb(extension_count, 0); > >> + set_val(sb, extension_count, 0); > >> memset(sb->extension_list, 0, sizeof(sb->extension_list)); > >> > >> while (*extlist) { > >> @@ -91,7 +91,7 @@ static void configure_extension_list(void) > >> memcpy(sb->extension_list[i++], *extlist, name_len); > >> extlist++; > >> } > >> - set_sb(extension_count, i); > >> + set_val(sb, extension_count, i); > >> > >> if (!ext_str) > >> return; > >> @@ -112,7 +112,7 @@ next: > >> break; > >> } > >> > >> - set_sb(extension_count, i); > >> + set_val(sb, extension_count, i); > >> > >> free(config.extension_list); > >> } > >> @@ -132,23 +132,23 @@ static int f2fs_prepare_super_block(void) > >> u_int32_t max_nat_bitmap_size, max_nat_segments; > >> u_int32_t total_zones; > >> > >> - set_sb(magic, F2FS_SUPER_MAGIC); > >> - set_sb(major_ver, F2FS_MAJOR_VERSION); > >> - set_sb(minor_ver, F2FS_MINOR_VERSION); > >> + set_val(sb, magic, F2FS_SUPER_MAGIC); > >> + set_val(sb, major_ver, F2FS_MAJOR_VERSION); > >> + set_val(sb, minor_ver, F2FS_MINOR_VERSION); > >> > >> log_sectorsize = log_base_2(config.sector_size); > >> log_sectors_per_block = log_base_2(config.sectors_per_blk); > >> log_blocksize = log_sectorsize + log_sectors_per_block; > >> log_blks_per_seg = log_base_2(config.blks_per_seg); > >> > >> - set_sb(log_sectorsize, log_sectorsize); > >> - set_sb(log_sectors_per_block, log_sectors_per_block); > >> + set_val(sb, log_sectorsize, log_sectorsize); > >> + set_val(sb, log_sectors_per_block, log_sectors_per_block); > >> > >> - set_sb(log_blocksize, log_blocksize); > >> - set_sb(log_blocks_per_seg, log_blks_per_seg); > >> + set_val(sb, log_blocksize, log_blocksize); > >> + set_val(sb, log_blocks_per_seg, log_blks_per_seg); > >> > >> - set_sb(segs_per_sec, config.segs_per_sec); > >> - set_sb(secs_per_zone, config.secs_per_zone); > >> + set_val(sb, segs_per_sec, config.segs_per_sec); > >> + set_val(sb, secs_per_zone, config.secs_per_zone); > >> > >> blk_size_bytes = 1 << log_blocksize; > >> segment_size_bytes = blk_size_bytes * config.blks_per_seg; > >> @@ -156,9 +156,9 @@ static int f2fs_prepare_super_block(void) > >> blk_size_bytes * config.secs_per_zone * > >> config.segs_per_sec * config.blks_per_seg; > >> > >> - set_sb(checksum_offset, 0); > >> + set_val(sb, checksum_offset, 0); > >> > >> - set_sb(block_count, config.total_sectors >> log_sectors_per_block); > >> + set_val(sb, block_count, config.total_sectors >> log_sectors_per_block); > >> > >> zone_align_start_offset = > >> (config.start_sector * config.sector_size + > >> @@ -174,41 +174,41 @@ static int f2fs_prepare_super_block(void) > >> config.sectors_per_blk); > >> } > >> > >> - set_sb(segment_count, (config.total_sectors * config.sector_size - > >> + set_val(sb, segment_count, (config.total_sectors * config.sector_size - > >> zone_align_start_offset) / segment_size_bytes); > >> > >> - set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes); > >> + set_val(sb, segment0_blkaddr, zone_align_start_offset / blk_size_bytes); > >> sb->cp_blkaddr = sb->segment0_blkaddr; > >> > >> - MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr)); > >> + MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_val(sb, segment0_blkaddr)); > >> > >> - set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); > >> + set_val(sb, segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK); > >> > >> - set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) * > >> + set_val(sb, sit_blkaddr, get_val(sb, segment0_blkaddr) + get_val(sb, segment_count_ckpt) * > >> config.blks_per_seg); > >> > >> - blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK); > >> + blocks_for_sit = ALIGN(get_val(sb, segment_count), SIT_ENTRY_PER_BLOCK); > >> > >> sit_segments = SEG_ALIGN(blocks_for_sit); > >> > >> - set_sb(segment_count_sit, sit_segments * 2); > >> + set_val(sb, segment_count_sit, sit_segments * 2); > >> > >> - set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) * > >> + set_val(sb, nat_blkaddr, get_val(sb, sit_blkaddr) + get_val(sb, segment_count_sit) * > >> config.blks_per_seg); > >> > >> - total_valid_blks_available = (get_sb(segment_count) - > >> - (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) * > >> + total_valid_blks_available = (get_val(sb, segment_count) - > >> + (get_val(sb, segment_count_ckpt) + get_val(sb, segment_count_sit))) * > >> config.blks_per_seg; > >> > >> blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK); > >> > >> - set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat)); > >> + set_val(sb, segment_count_nat, SEG_ALIGN(blocks_for_nat)); > >> /* > >> * The number of node segments should not be exceeded a "Threshold". > >> * This number resizes NAT bitmap area in a CP page. > >> * So the threshold is determined not to overflow one CP page > >> */ > >> - sit_bitmap_size = ((get_sb(segment_count_sit) / 2) << > >> + sit_bitmap_size = ((get_val(sb, segment_count_sit) / 2) << > >> log_blks_per_seg) / 8; > >> > >> if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE) > >> @@ -223,55 +223,55 @@ static int f2fs_prepare_super_block(void) > >> if (max_sit_bitmap_size > > >> (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 - 64)) { > >> max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1; > >> - set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); > >> + set_val(sb, cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size)); > >> } else { > >> max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1 > >> - max_sit_bitmap_size; > >> - set_sb(cp_payload, 0); > >> + set_val(sb, cp_payload, 0); > >> } > >> > >> max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg; > >> > >> - if (get_sb(segment_count_nat) > max_nat_segments) > >> - set_sb(segment_count_nat, max_nat_segments); > >> + if (get_val(sb, segment_count_nat) > max_nat_segments) > >> + set_val(sb, segment_count_nat, max_nat_segments); > >> > >> - set_sb(segment_count_nat, get_sb(segment_count_nat) * 2); > >> + set_val(sb, segment_count_nat, get_val(sb, segment_count_nat) * 2); > >> > >> - set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) * > >> + set_val(sb, ssa_blkaddr, get_val(sb, nat_blkaddr) + get_val(sb, segment_count_nat) * > >> config.blks_per_seg); > >> > >> - total_valid_blks_available = (get_sb(segment_count) - > >> - (get_sb(segment_count_ckpt) + > >> - get_sb(segment_count_sit) + > >> - get_sb(segment_count_nat))) * > >> + total_valid_blks_available = (get_val(sb, segment_count) - > >> + (get_val(sb, segment_count_ckpt) + > >> + get_val(sb, segment_count_sit) + > >> + get_val(sb, segment_count_nat))) * > >> config.blks_per_seg; > >> > >> blocks_for_ssa = total_valid_blks_available / > >> config.blks_per_seg + 1; > >> > >> - set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); > >> + set_val(sb, segment_count_ssa, SEG_ALIGN(blocks_for_ssa)); > >> > >> - total_meta_segments = get_sb(segment_count_ckpt) + > >> - get_sb(segment_count_sit) + > >> - get_sb(segment_count_nat) + > >> - get_sb(segment_count_ssa); > >> + total_meta_segments = get_val(sb, segment_count_ckpt) + > >> + get_val(sb, segment_count_sit) + > >> + get_val(sb, segment_count_nat) + > >> + get_val(sb, segment_count_ssa); > >> diff = total_meta_segments % (config.segs_per_zone); > >> if (diff) > >> - set_sb(segment_count_ssa, get_sb(segment_count_ssa) + > >> + set_val(sb, segment_count_ssa, get_val(sb, segment_count_ssa) + > >> (config.segs_per_zone - diff)); > >> > >> total_meta_zones = ZONE_ALIGN(total_meta_segments * > >> config.blks_per_seg); > >> > >> - set_sb(main_blkaddr, get_sb(segment0_blkaddr) + total_meta_zones * > >> + set_val(sb, main_blkaddr, get_val(sb, segment0_blkaddr) + total_meta_zones * > >> config.segs_per_zone * config.blks_per_seg); > >> > >> - total_zones = get_sb(segment_count) / (config.segs_per_zone) - > >> + total_zones = get_val(sb, segment_count) / (config.segs_per_zone) - > >> total_meta_zones; > >> > >> - set_sb(section_count, total_zones * config.secs_per_zone); > >> + set_val(sb, section_count, total_zones * config.secs_per_zone); > >> > >> - set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec); > >> + set_val(sb, segment_count_main, get_val(sb, section_count) * config.segs_per_sec); > >> > >> /* Let's determine the best reserved and overprovisioned space */ > >> if (config.overprovision == 0) > >> @@ -281,12 +281,12 @@ static int f2fs_prepare_super_block(void) > >> (2 * (100 / config.overprovision + 1) + 6) > >> * config.segs_per_sec; > >> > >> - if ((get_sb(segment_count_main) - 2) < > >> + if ((get_val(sb, segment_count_main) - 2) < > >> config.reserved_segments) { > >> MSG(1, "\tError: Device size is not sufficient for F2FS volume,\ > >> more segment needed =%u", > >> config.reserved_segments - > >> - (get_sb(segment_count_main) - 2)); > >> + (get_val(sb, segment_count_main) - 2)); > >> return -1; > >> } > >> > >> @@ -294,9 +294,9 @@ static int f2fs_prepare_super_block(void) > >> > >> utf8_to_utf16(sb->volume_name, (const char *)config.vol_label, > >> MAX_VOLUME_NAME, strlen(config.vol_label)); > >> - set_sb(node_ino, 1); > >> - set_sb(meta_ino, 2); > >> - set_sb(root_ino, 3); > >> + set_val(sb, node_ino, 1); > >> + set_val(sb, meta_ino, 2); > >> + set_val(sb, root_ino, 3); > >> > >> if (total_zones <= 6) { > >> MSG(1, "\tError: %d zones: Need more zones \ > >> @@ -346,8 +346,8 @@ static int f2fs_init_sit_area(void) > >> u_int64_t sit_seg_addr = 0; > >> u_int8_t *zero_buf = NULL; > >> > >> - blk_size = 1 << get_sb(log_blocksize); > >> - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; > >> + blk_size = 1 << get_val(sb, log_blocksize); > >> + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; > >> > >> zero_buf = calloc(sizeof(u_int8_t), seg_size); > >> if(zero_buf == NULL) { > >> @@ -355,11 +355,11 @@ static int f2fs_init_sit_area(void) > >> return -1; > >> } > >> > >> - sit_seg_addr = get_sb(sit_blkaddr); > >> + sit_seg_addr = get_val(sb, sit_blkaddr); > >> sit_seg_addr *= blk_size; > >> > >> DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr); > >> - for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) { > >> + for (index = 0; index < (get_val(sb, segment_count_sit) / 2); index++) { > >> if (dev_fill(zero_buf, sit_seg_addr, seg_size)) { > >> MSG(1, "\tError: While zeroing out the sit area \ > >> on disk!!!\n"); > >> @@ -380,8 +380,8 @@ static int f2fs_init_nat_area(void) > >> u_int64_t nat_seg_addr = 0; > >> u_int8_t *nat_buf = NULL; > >> > >> - blk_size = 1 << get_sb(log_blocksize); > >> - seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size; > >> + blk_size = 1 << get_val(sb, log_blocksize); > >> + seg_size = (1 << get_val(sb, log_blocks_per_seg)) * blk_size; > >> > >> nat_buf = calloc(sizeof(u_int8_t), seg_size); > >> if (nat_buf == NULL) { > >> @@ -389,11 +389,11 @@ static int f2fs_init_nat_area(void) > >> return -1; > >> } > >> > >> - nat_seg_addr = get_sb(nat_blkaddr); > >> + nat_seg_addr = get_val(sb, nat_blkaddr); > >> nat_seg_addr *= blk_size; > >> > >> DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr); > >> - for (index = 0; index < get_sb(segment_count_nat) / 2; index++) { > >> + for (index = 0; index < get_val(sb, segment_count_nat) / 2; index++) { > >> if (dev_fill(nat_buf, nat_seg_addr, seg_size)) { > >> MSG(1, "\tError: While zeroing out the nat area \ > >> on disk!!!\n"); > >> @@ -445,58 +445,58 @@ static int f2fs_write_check_point_pack(void) > >> } > >> > >> /* 1. cp page 1 of checkpoint pack 1 */ > >> - set_cp(checkpoint_ver, 1); > >> - set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); > >> - set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); > >> - set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); > >> - set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); > >> - set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); > >> - set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); > >> + set_val(cp, checkpoint_ver, 1); > >> + set_val(cp, cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]); > >> + set_val(cp, cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]); > >> + set_val(cp, cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]); > >> + set_val(cp, cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]); > >> + set_val(cp, cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]); > >> + set_val(cp, cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]); > >> for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) { > >> - set_cp(cur_node_segno[i], 0xffffffff); > >> - set_cp(cur_data_segno[i], 0xffffffff); > >> + set_val(cp, cur_node_segno[i], 0xffffffff); > >> + set_val(cp, cur_data_segno[i], 0xffffffff); > >> } > >> > >> - set_cp(cur_node_blkoff[0], 1); > >> - set_cp(cur_data_blkoff[0], 1); > >> - set_cp(valid_block_count, 2); > >> - set_cp(rsvd_segment_count, config.reserved_segments); > >> - set_cp(overprov_segment_count, (get_sb(segment_count_main) - > >> - get_cp(rsvd_segment_count)) * > >> + set_val(cp, cur_node_blkoff[0], 1); > >> + set_val(cp, cur_data_blkoff[0], 1); > >> + set_val(cp, valid_block_count, 2); > >> + set_val(cp, rsvd_segment_count, config.reserved_segments); > >> + set_val(cp, overprov_segment_count, (get_val(sb, segment_count_main) - > >> + get_val(cp, rsvd_segment_count)) * > >> config.overprovision / 100); > >> - set_cp(overprov_segment_count, get_cp(overprov_segment_count) + > >> - get_cp(rsvd_segment_count)); > >> + set_val(cp, overprov_segment_count, get_val(cp, overprov_segment_count) + > >> + get_val(cp, rsvd_segment_count)); > >> > >> MSG(0, "Info: Overprovision ratio = %.3lf%%\n", config.overprovision); > >> MSG(0, "Info: Overprovision segments = %u (GC reserved = %u)\n", > >> - get_cp(overprov_segment_count), > >> + get_val(cp, overprov_segment_count), > >> config.reserved_segments); > >> > >> /* main segments - reserved segments - (node + data segments) */ > >> - set_cp(free_segment_count, get_sb(segment_count_main) - 6); > >> - set_cp(user_block_count, ((get_cp(free_segment_count) + 6 - > >> - get_cp(overprov_segment_count)) * config.blks_per_seg)); > >> + set_val(cp, free_segment_count, get_val(sb, segment_count_main) - 6); > >> + set_val(cp, user_block_count, ((get_val(cp, free_segment_count) + 6 - > >> + get_val(cp, overprov_segment_count)) * config.blks_per_seg)); > >> /* cp page (2), data summaries (1), node summaries (3) */ > >> - set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload)); > >> - set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); > >> - set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload)); > >> - set_cp(valid_node_count, 1); > >> - set_cp(valid_inode_count, 1); > >> - set_cp(next_free_nid, get_sb(root_ino) + 1); > >> - set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) << > >> - get_sb(log_blocks_per_seg)) / 8); > >> + set_val(cp, cp_pack_total_block_count, 6 + get_val(sb, cp_payload)); > >> + set_val(cp, ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG); > >> + set_val(cp, cp_pack_start_sum, 1 + get_val(sb, cp_payload)); > >> + set_val(cp, valid_node_count, 1); > >> + set_val(cp, valid_inode_count, 1); > >> + set_val(cp, next_free_nid, get_val(sb, root_ino) + 1); > >> + set_val(cp, sit_ver_bitmap_bytesize, ((get_val(sb, segment_count_sit) / 2) << > >> + get_val(sb, log_blocks_per_seg)) / 8); > >> > >> - set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) << > >> - get_sb(log_blocks_per_seg)) / 8); > >> + set_val(cp, nat_ver_bitmap_bytesize, ((get_val(sb, segment_count_nat) / 2) << > >> + get_val(sb, log_blocks_per_seg)) / 8); > >> > >> - set_cp(checksum_offset, CHECKSUM_OFFSET); > >> + set_val(cp, checksum_offset, CHECKSUM_OFFSET); > >> > >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = > >> cpu_to_le32(crc); > >> > >> - blk_size_bytes = 1 << get_sb(log_blocksize); > >> - cp_seg_blk_offset = get_sb(segment0_blkaddr); > >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); > >> + cp_seg_blk_offset = get_val(sb, segment0_blkaddr); > >> cp_seg_blk_offset *= blk_size_bytes; > >> > >> DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > >> @@ -505,7 +505,7 @@ static int f2fs_write_check_point_pack(void) > >> goto free_cp_payload; > >> } > >> > >> - for (i = 0; i < get_sb(cp_payload); i++) { > >> + for (i = 0; i < get_val(sb, cp_payload); i++) { > >> cp_seg_blk_offset += blk_size_bytes; > >> if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { > >> MSG(1, "\tError: While zeroing out the sit bitmap area \ > >> @@ -537,8 +537,8 @@ static int f2fs_write_check_point_pack(void) > >> sum->nat_j.entries[0].ne.version = 0; > >> sum->nat_j.entries[0].ne.ino = sb->root_ino; > >> sum->nat_j.entries[0].ne.block_addr = cpu_to_le32( > >> - get_sb(main_blkaddr) + > >> - get_cp(cur_node_segno[0]) * config.blks_per_seg); > >> + get_val(sb, main_blkaddr) + > >> + get_val(cp, cur_node_segno[0]) * config.blks_per_seg); > >> > >> memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE); > >> sum_compact_p += SUM_JOURNAL_SIZE; > >> @@ -635,7 +635,7 @@ static int f2fs_write_check_point_pack(void) > >> crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET); > >> *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) = > >> cpu_to_le32(crc); > >> - cp_seg_blk_offset = (get_sb(segment0_blkaddr) + > >> + cp_seg_blk_offset = (get_val(sb, segment0_blkaddr) + > >> config.blks_per_seg) * > >> blk_size_bytes; > >> DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > >> @@ -644,7 +644,7 @@ static int f2fs_write_check_point_pack(void) > >> goto free_cp_payload; > >> } > >> > >> - for (i = 0; i < get_sb(cp_payload); i++) { > >> + for (i = 0; i < get_val(sb, cp_payload); i++) { > >> cp_seg_blk_offset += blk_size_bytes; > >> if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) { > >> MSG(1, "\tError: While zeroing out the sit bitmap area \ > >> @@ -655,7 +655,7 @@ static int f2fs_write_check_point_pack(void) > >> > >> /* cp page 2 of check point pack 2 */ > >> cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count) > >> - - get_sb(cp_payload) - 1); > >> + - get_val(sb, cp_payload) - 1); > >> DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset); > >> if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) { > >> MSG(1, "\tError: While writing the cp to disk!!!\n"); > >> @@ -701,8 +701,8 @@ static int f2fs_write_super_block(void) > >> static int discard_obsolete_dnode(struct f2fs_node *raw_node, u_int64_t offset) > >> { > >> do { > >> - if (offset < get_sb(main_blkaddr) || > >> - offset >= get_sb(main_blkaddr) + get_sb(block_count)) > >> + if (offset < get_val(sb, main_blkaddr) || > >> + offset >= get_val(sb, main_blkaddr) + get_val(sb, block_count)) > >> break; > >> > >> if (dev_read_block(raw_node, offset)) { > >> @@ -740,7 +740,7 @@ static int f2fs_write_root_inode(void) > >> raw_node->footer.ino = sb->root_ino; > >> raw_node->footer.cp_ver = cpu_to_le64(1); > >> raw_node->footer.next_blkaddr = cpu_to_le32( > >> - get_sb(main_blkaddr) + > >> + get_val(sb, main_blkaddr) + > >> config.cur_seg[CURSEG_HOT_NODE] * > >> config.blks_per_seg + 1); > >> > >> @@ -749,7 +749,7 @@ static int f2fs_write_root_inode(void) > >> raw_node->i.i_uid = cpu_to_le32(getuid()); > >> raw_node->i.i_gid = cpu_to_le32(getgid()); > >> > >> - blk_size_bytes = 1 << get_sb(log_blocksize); > >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); > >> raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */ > >> raw_node->i.i_blocks = cpu_to_le64(2); > >> > >> @@ -765,7 +765,7 @@ static int f2fs_write_root_inode(void) > >> raw_node->i.i_current_depth = cpu_to_le32(1); > >> raw_node->i.i_dir_level = DEF_DIR_LEVEL; > >> > >> - data_blk_nor = get_sb(main_blkaddr) + > >> + data_blk_nor = get_val(sb, main_blkaddr) + > >> config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg; > >> raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor); > >> > >> @@ -773,7 +773,7 @@ static int f2fs_write_root_inode(void) > >> raw_node->i.i_ext.blk_addr = 0; > >> raw_node->i.i_ext.len = 0; > >> > >> - main_area_node_seg_blk_offset = get_sb(main_blkaddr); > >> + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); > >> main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] * > >> config.blks_per_seg; > >> main_area_node_seg_blk_offset *= blk_size_bytes; > >> @@ -786,7 +786,7 @@ static int f2fs_write_root_inode(void) > >> } > >> > >> /* avoid power-off-recovery based on roll-forward policy */ > >> - main_area_node_seg_blk_offset = get_sb(main_blkaddr); > >> + main_area_node_seg_blk_offset = get_val(sb, main_blkaddr); > >> main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] * > >> config.blks_per_seg; > >> > >> @@ -813,21 +813,21 @@ static int f2fs_update_nat_root(void) > >> } > >> > >> /* update root */ > >> - nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32( > >> - get_sb(main_blkaddr) + > >> + nat_blk->entries[get_val(sb, root_ino)].block_addr = cpu_to_le32( > >> + get_val(sb, main_blkaddr) + > >> config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg); > >> - nat_blk->entries[get_sb(root_ino)].ino = sb->root_ino; > >> + nat_blk->entries[get_val(sb, root_ino)].ino = sb->root_ino; > >> > >> /* update node nat */ > >> - nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1); > >> - nat_blk->entries[get_sb(node_ino)].ino = sb->node_ino; > >> + nat_blk->entries[get_val(sb, node_ino)].block_addr = cpu_to_le32(1); > >> + nat_blk->entries[get_val(sb, node_ino)].ino = sb->node_ino; > >> > >> /* update meta nat */ > >> - nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1); > >> - nat_blk->entries[get_sb(meta_ino)].ino = sb->meta_ino; > >> + nat_blk->entries[get_val(sb, meta_ino)].block_addr = cpu_to_le32(1); > >> + nat_blk->entries[get_val(sb, meta_ino)].ino = sb->meta_ino; > >> > >> - blk_size_bytes = 1 << get_sb(log_blocksize); > >> - nat_seg_blk_offset = get_sb(nat_blkaddr); > >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); > >> + nat_seg_blk_offset = get_val(sb, nat_blkaddr); > >> nat_seg_blk_offset *= blk_size_bytes; > >> > >> DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset); > >> @@ -867,8 +867,8 @@ static int f2fs_add_default_dentry_root(void) > >> /* bitmap for . and .. */ > >> test_and_set_bit_le(0, dent_blk->dentry_bitmap); > >> test_and_set_bit_le(1, dent_blk->dentry_bitmap); > >> - blk_size_bytes = 1 << get_sb(log_blocksize); > >> - data_blk_offset = get_sb(main_blkaddr); > >> + blk_size_bytes = 1 << get_val(sb, log_blocksize); > >> + data_blk_offset = get_val(sb, main_blkaddr); > >> data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] * > >> config.blks_per_seg; > >> data_blk_offset *= blk_size_bytes; > >> -- > >> 1.9.1 > >> > >> > >> ------------------------------------------------------------------------------ > >> Site24x7 APM Insight: Get Deep Visibility into Application Performance > >> APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month > >> Monitor end-to-end web transactions and take corrective actions now > >> Troubleshoot faster and improve end-user experience. Signup Now! > >> http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 > >> _______________________________________________ > >> Linux-f2fs-devel mailing list > >> Linux-f2fs-devel@lists.sourceforge.net > >> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel > > > > . > > ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply [flat|nested] 9+ messages in thread
* [RFC PATCH 2/4] f2fs-tools: fix endianness of on-disk check_sum in summary_footer 2016-01-30 9:16 [RFC PATCH 0/4] do more check in sanity_check_nid and clean up Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} Sheng Yong @ 2016-01-30 9:16 ` Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 3/4] fsck.f2fs: check ino of an used nat entry Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 4/4] fsck.f2fs: check ino of an inode Sheng Yong 3 siblings, 0 replies; 9+ messages in thread From: Sheng Yong @ 2016-01-30 9:16 UTC (permalink / raw) To: jaegeuk, chao2.yu; +Cc: linux-f2fs-devel Signed-off-by: Sheng Yong <shengyong1@huawei.com> --- include/f2fs_fs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h index 2ab9f49..1b02d16 100644 --- a/include/f2fs_fs.h +++ b/include/f2fs_fs.h @@ -677,7 +677,7 @@ struct f2fs_summary { struct summary_footer { unsigned char entry_type; /* SUM_TYPE_XXX */ - __u32 check_sum; /* summary checksum */ + __le32 check_sum; /* summary checksum */ } __attribute__((packed)); #define SUM_JOURNAL_SIZE (F2FS_BLKSIZE - SUM_FOOTER_SIZE -\ -- 1.9.1 ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [RFC PATCH 3/4] fsck.f2fs: check ino of an used nat entry 2016-01-30 9:16 [RFC PATCH 0/4] do more check in sanity_check_nid and clean up Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 2/4] f2fs-tools: fix endianness of on-disk check_sum in summary_footer Sheng Yong @ 2016-01-30 9:16 ` Sheng Yong 2016-01-30 9:16 ` [RFC PATCH 4/4] fsck.f2fs: check ino of an inode Sheng Yong 3 siblings, 0 replies; 9+ messages in thread From: Sheng Yong @ 2016-01-30 9:16 UTC (permalink / raw) To: jaegeuk, chao2.yu; +Cc: linux-f2fs-devel If a nid is valid, the ino in its nat entry should record its parent nid. However if the ino is zero, we should drop the node. Signed-off-by: Sheng Yong <shengyong1@huawei.com> Signed-off-by: Xue Liu <liuxueliu.liu@huawei.com> --- fsck/fsck.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/fsck/fsck.c b/fsck/fsck.c index 4fbb56d..c018d3a 100644 --- a/fsck/fsck.c +++ b/fsck/fsck.c @@ -342,6 +342,11 @@ static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid, } get_node_info(sbi, nid, ni); + if (ni->ino == 0) { + ASSERT_MSG("nid[0x%x] ino is 0", nid); + return -EINVAL; + } + if (ni->blk_addr == NEW_ADDR) { ASSERT_MSG("nid is NEW_ADDR. [0x%x]", nid); return -EINVAL; -- 1.9.1 ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* [RFC PATCH 4/4] fsck.f2fs: check ino of an inode 2016-01-30 9:16 [RFC PATCH 0/4] do more check in sanity_check_nid and clean up Sheng Yong ` (2 preceding siblings ...) 2016-01-30 9:16 ` [RFC PATCH 3/4] fsck.f2fs: check ino of an used nat entry Sheng Yong @ 2016-01-30 9:16 ` Sheng Yong 3 siblings, 0 replies; 9+ messages in thread From: Sheng Yong @ 2016-01-30 9:16 UTC (permalink / raw) To: jaegeuk, chao2.yu; +Cc: linux-f2fs-devel If the node is an inode, its ino in the nat entry should be equal to the ino in its node footer. Otherwise, we drop the file. Signed-off-by: Sheng Yong <shengyong1@huawei.com> Signed-off-by: Xue Liu <liuxueliu.liu@huawei.com> --- fsck/fsck.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/fsck/fsck.c b/fsck/fsck.c index c018d3a..312583e 100644 --- a/fsck/fsck.c +++ b/fsck/fsck.c @@ -372,6 +372,11 @@ static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid, le32_to_cpu(node_blk->footer.ino)); return -EINVAL; } + if (ntype == TYPE_INODE && ni->ino != node_blk->footer.ino) { + ASSERT_MSG("nid[0x%x] TYPE_INODE nat_entry->ino[0x%x] footer.ino[0x%x]", + nid, ni->ino, le32_to_cpu(node_blk->footer.ino)); + return -EINVAL; + } if (ntype != TYPE_INODE && node_blk->footer.nid == node_blk->footer.ino) { ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]", -- 1.9.1 ------------------------------------------------------------------------------ Site24x7 APM Insight: Get Deep Visibility into Application Performance APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month Monitor end-to-end web transactions and take corrective actions now Troubleshoot faster and improve end-user experience. Signup Now! http://pubads.g.doubleclick.net/gampad/clk?id=267308311&iu=/4140 ^ permalink raw reply related [flat|nested] 9+ messages in thread
end of thread, other threads:[~2016-02-02 0:27 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2016-01-30 9:16 [RFC PATCH 0/4] do more check in sanity_check_nid and clean up Sheng Yong
2016-01-30 9:16 ` [RFC PATCH 1/4] f2fs-tools: simplify get_{sb|cp} and set_{sb|cp} Sheng Yong
2016-01-30 1:46 ` Jaegeuk Kim
2016-01-30 2:25 ` Sheng Yong
2016-01-30 10:03 ` [RFC PATCH v2] " Sheng Yong
2016-02-02 0:27 ` [RFC PATCH 1/4] " Jaegeuk Kim
2016-01-30 9:16 ` [RFC PATCH 2/4] f2fs-tools: fix endianness of on-disk check_sum in summary_footer Sheng Yong
2016-01-30 9:16 ` [RFC PATCH 3/4] fsck.f2fs: check ino of an used nat entry Sheng Yong
2016-01-30 9:16 ` [RFC PATCH 4/4] fsck.f2fs: check ino of an inode Sheng Yong
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.