* 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 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
* [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
* [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
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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).