Lines Matching refs:sbi
19 int f2fs_set_main_bitmap(struct f2fs_sb_info *sbi, u32 blk, int type)
21 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
25 se = get_seg_entry(sbi, GET_SEGNO(sbi, blk));
34 GET_SEGNO(sbi, blk), se->type, type);
37 return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->main_area_bitmap);
40 static inline int f2fs_test_main_bitmap(struct f2fs_sb_info *sbi, u32 blk)
42 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
44 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk),
48 static inline int f2fs_clear_main_bitmap(struct f2fs_sb_info *sbi, u32 blk)
50 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
52 return f2fs_clear_bit(BLKOFF_FROM_MAIN(sbi, blk),
56 static inline int f2fs_test_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk)
58 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
60 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap);
63 int f2fs_set_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk)
65 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
67 return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap);
70 static int add_into_hard_link_list(struct f2fs_sb_info *sbi,
73 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
111 static int find_and_dec_hard_link_list(struct f2fs_sb_info *sbi, u32 nid)
113 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
144 static int is_valid_ssa_node_blk(struct f2fs_sb_info *sbi, u32 nid,
147 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
158 segno = GET_SEGNO(sbi, blk_addr);
159 offset = OFFSET_IN_SEG(sbi, blk_addr);
161 sum_blk = get_sum_block(sbi, segno, &type);
172 se = get_seg_entry(sbi, segno);
189 GET_SUM_BLKADDR(sbi,
190 GET_SEGNO(sbi, blk_addr)));
192 GET_SEGNO(sbi, blk_addr),
193 OFFSET_IN_SEG(sbi, blk_addr));
210 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
221 static int is_valid_summary(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
234 if (!IS_VALID_NID(sbi, nid))
237 get_node_info(sbi, nid, &ni);
239 if (!IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
269 static int is_valid_ssa_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr,
272 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
283 segno = GET_SEGNO(sbi, blk_addr);
284 offset = OFFSET_IN_SEG(sbi, blk_addr);
286 sum_blk = get_sum_block(sbi, segno, &type);
297 se = get_seg_entry(sbi, segno);
328 } else if (is_valid_summary(sbi, sum_entry, blk_addr)) {
344 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
389 static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
394 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
397 if (!IS_VALID_NID(sbi, nid)) {
402 get_node_info(sbi, nid, ni);
413 if (!IS_VALID_BLK_ADDR(sbi, ni->blk_addr)) {
461 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) != 0) {
481 f2fs_set_bit(nid, NM_I(sbi)->nid_bitmap);
486 if (is_valid_ssa_node_blk(sbi, nid, ni->blk_addr)) {
491 if (f2fs_test_sit_bitmap(sbi, ni->blk_addr) == 0)
495 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
501 if (!c.show_file_map && sbi->total_valid_node_count > 1000) {
502 unsigned int p10 = sbi->total_valid_node_count / 10;
504 if (sbi->fsck->chk.checked_node_cnt++ % p10)
508 sbi->fsck->chk.checked_node_cnt,
509 sbi->total_valid_node_count,
510 10 * (float)sbi->fsck->chk.checked_node_cnt /
517 int fsck_sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
522 return sanity_check_nid(sbi, nid, node_blk, ftype, ntype, ni);
525 static int fsck_chk_xattr_blk(struct f2fs_sb_info *sbi, u32 ino,
539 if (sanity_check_nid(sbi, x_nid, node_blk,
546 f2fs_set_main_bitmap(sbi, ni.blk_addr, CURSEG_COLD_NODE);
553 int fsck_chk_node_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
564 if (sanity_check_nid(sbi, nid, node_blk, ftype, ntype, &ni))
568 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
570 fsck_chk_inode_blk(sbi, nid, ftype, node_blk, blk_cnt, cbc,
576 f2fs_set_main_bitmap(sbi, ni.blk_addr,
578 fsck_chk_dnode_blk(sbi, inode, nid, ftype, node_blk,
582 f2fs_set_main_bitmap(sbi, ni.blk_addr,
584 fsck_chk_idnode_blk(sbi, inode, ftype, node_blk,
588 f2fs_set_main_bitmap(sbi, ni.blk_addr,
590 fsck_chk_didnode_blk(sbi, inode, ftype, node_blk,
665 void fsck_reada_node_block(struct f2fs_sb_info *sbi, u32 nid)
669 if (nid != 0 && IS_VALID_NID(sbi, nid)) {
670 get_node_info(sbi, nid, &ni);
671 if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
676 void fsck_reada_all_direct_node_blocks(struct f2fs_sb_info *sbi,
684 fsck_reada_node_block(sbi, nid);
689 void fsck_chk_inode_blk(struct f2fs_sb_info *sbi, u32 nid,
694 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
740 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0)
744 f2fs_set_main_bitmap(sbi, ni->blk_addr, CURSEG_HOT_NODE);
750 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
751 f2fs_set_main_bitmap(sbi, ni->blk_addr,
754 !is_qf_ino(F2FS_RAW_SUPER(sbi), nid)) {
756 add_into_hard_link_list(sbi, nid, i_links);
761 if (find_and_dec_hard_link_list(sbi, nid)) {
780 fsck_reada_node_block(sbi, i_xattr_nid);
782 if (fsck_chk_xattr_blk(sbi, nid, i_xattr_nid, blk_cnt)) {
925 ret = fsck_chk_inline_dentries(sbi, node_blk, &child);
975 ret = fsck_chk_data_blk(sbi,
995 fsck_reada_node_block(sbi, nid);
1014 ret = fsck_chk_node_blk(sbi, &node_blk->i, i_nid,
1096 if (is_qf_ino(F2FS_RAW_SUPER(sbi), nid))
1201 int fsck_chk_dnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1234 F2FS_FSCK(sbi)->chk.valid_blk_cnt++;
1244 ret = fsck_chk_data_blk(sbi, IS_CASEFOLDED(inode),
1266 int fsck_chk_idnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1273 fsck_reada_all_direct_node_blocks(sbi, node_blk);
1278 ret = fsck_chk_node_blk(sbi, inode,
1301 get_node_info(sbi, nid, &ni);
1309 int fsck_chk_didnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1316 fsck_reada_all_direct_node_blocks(sbi, node_blk);
1321 ret = fsck_chk_node_blk(sbi, inode,
1344 get_node_info(sbi, nid, &ni);
1392 static void print_dentry(struct f2fs_sb_info *sbi, __u8 *name,
1396 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1444 if (dump_node(sbi, le32_to_cpu(dentry[idx].ino), 0))
1521 static int __chk_dots_dentries(struct f2fs_sb_info *sbi,
1541 if (child->p_ino == F2FS_ROOT_INO(sbi)) {
1542 if (le32_to_cpu(dentry->ino) != F2FS_ROOT_INO(sbi)) {
1545 dentry->ino = cpu_to_le32(F2FS_ROOT_INO(sbi));
1556 if (f2fs_check_hash_code(get_encoding(sbi), casefolded, dentry, name, len, enc_name))
1576 static int __chk_dentries(struct f2fs_sb_info *sbi, int casefolded,
1582 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1603 if (IS_VALID_NID(sbi, ino)) {
1606 get_node_info(sbi, ino, &ni);
1607 if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr)) {
1621 if (!IS_VALID_NID(sbi, le32_to_cpu(dentry[i].ino))) {
1671 ret = __chk_dots_dentries(sbi, casefolded, &dentry[i],
1697 if (f2fs_check_hash_code(get_encoding(sbi), casefolded, dentry + i, name, name_len, enc_name))
1723 print_dentry(sbi, name, bitmap,
1730 ret = fsck_chk_node_blk(sbi,
1757 int fsck_chk_inline_dentries(struct f2fs_sb_info *sbi,
1760 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1781 dentries = __chk_dentries(sbi, IS_CASEFOLDED(&node_blk->i), child,
1801 int fsck_chk_dentry_blk(struct f2fs_sb_info *sbi, int casefolded, u32 blk_addr,
1804 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1824 dentries = __chk_dentries(sbi, casefolded, child,
1849 int fsck_chk_data_blk(struct f2fs_sb_info *sbi, int casefolded,
1854 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1862 if (!IS_VALID_BLK_ADDR(sbi, blk_addr)) {
1867 if (is_valid_ssa_data_blk(sbi, blk_addr, parent_nid,
1874 if (f2fs_test_sit_bitmap(sbi, blk_addr) == 0)
1877 if (f2fs_test_main_bitmap(sbi, blk_addr) != 0)
1884 f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_HOT_DATA);
1885 return fsck_chk_dentry_blk(sbi, casefolded, blk_addr, child,
1888 f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_WARM_DATA);
1893 int fsck_chk_orphan_node(struct f2fs_sb_info *sbi)
1899 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1902 if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
1905 start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload);
1906 orphan_blkaddr = __start_sum_addr(sbi) - 1 - get_sb(cp_payload);
1908 f2fs_ra_meta_pages(sbi, start_blk, orphan_blkaddr, META_CP);
1932 get_node_info(sbi, ino, &ni);
1933 if (!IS_VALID_NID(sbi, ino) ||
1934 !IS_VALID_BLK_ADDR(sbi, ni.blk_addr)) {
1943 ret = fsck_chk_node_blk(sbi, NULL, ino,
1969 int fsck_chk_quota_node(struct f2fs_sb_info *sbi)
1971 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1990 get_node_info(sbi, ino, &ni);
1991 if (!IS_VALID_NID(sbi, ino) ||
1992 !IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
1996 ret = fsck_chk_node_blk(sbi, NULL, ino,
2004 f2fs_rebuild_qf_inode(sbi, qtype);
2011 int fsck_chk_quota_files(struct f2fs_sb_info *sbi)
2013 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2014 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2031 ret = quota_compare_and_update(sbi, qtype, &needs_writeout,
2042 f2fs_filesize_update(sbi, ino, 0);
2043 ret = quota_write_inode(sbi, qtype);
2058 int fsck_chk_meta(struct f2fs_sb_info *sbi)
2060 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2061 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2067 for (i = 0; i < MAIN_SEGS(sbi); i++) {
2068 se = get_seg_entry(sbi, i);
2071 else if (IS_CUR_SEGNO(sbi, i)) {
2080 get_usable_seg_count(sbi)) {
2084 get_usable_seg_count(sbi));
2116 if (fsck_chk_orphan_node(sbi))
2127 * get a negative number by BLKOFF_FROM_MAIN(sbi, blk)
2131 if (!IS_VALID_BLK_ADDR(sbi, blk)) {
2138 if (!f2fs_test_sit_bitmap(sbi, blk)) {
2145 if (!IS_VALID_NID(sbi, ino)) {
2160 if (fsck_chk_quota_node(sbi))
2174 void fsck_chk_checkpoint(struct f2fs_sb_info *sbi)
2176 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2187 void fsck_init(struct f2fs_sb_info *sbi)
2189 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2190 struct f2fs_sm_info *sm_i = SM_I(sbi);
2201 fsck->nr_main_blks = sm_i->main_segments << sbi->log_blocks_per_seg;
2206 build_nat_area_bitmap(sbi);
2208 build_sit_area_bitmap(sbi);
2221 static void fix_hard_links(struct f2fs_sb_info *sbi)
2223 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2238 if (sanity_check_nid(sbi, node->nid, node_blk,
2256 static void fix_nat_entries(struct f2fs_sb_info *sbi)
2258 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2263 nullify_nat_entry(sbi, i);
2266 static void flush_curseg_sit_entries(struct f2fs_sb_info *sbi)
2268 struct sit_info *sit_i = SIT_I(sbi);
2278 struct curseg_info *curseg = CURSEG_I(sbi, i);
2282 se = get_seg_entry(sbi, curseg->segno);
2283 get_current_sit_page(sbi, curseg->segno, sit_blk);
2287 rewrite_current_sit_page(sbi, curseg->segno, sit_blk);
2293 static void fix_checksum(struct f2fs_sb_info *sbi)
2295 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2296 struct f2fs_nm_info *nm_i = NM_I(sbi);
2297 struct sit_info *sit_i = SIT_I(sbi);
2310 static void fix_checkpoint(struct f2fs_sb_info *sbi)
2312 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2313 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2314 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2327 orphan_blks = __start_sum_addr(sbi) - 1;
2353 set_cp(free_segment_count, get_free_segments(sbi));
2363 if (sbi->cur_cp == 2)
2378 struct curseg_info *curseg = CURSEG_I(sbi, i);
2389 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
2401 static void fix_checkpoints(struct f2fs_sb_info *sbi)
2404 duplicate_checkpoint(sbi);
2407 sbi->cur_cp = 1;
2408 fix_checkpoint(sbi);
2418 static int last_vblk_off_in_zone(struct f2fs_sb_info *sbi,
2422 unsigned int segs_per_zone = sbi->segs_per_sec * sbi->secs_per_zone;
2426 se = get_seg_entry(sbi, zone_segno + s);
2433 for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
2435 return b + (s << sbi->log_blocks_per_seg);
2441 static int check_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
2443 struct curseg_info *curseg = CURSEG_I(sbi, type);
2444 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2450 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
2453 cs_block = START_BLOCK(sbi, curseg->segno) + curseg->next_blkoff;
2490 GET_SEGNO(sbi, wp_block), OFFSET_IN_SEG(sbi, wp_block));
2498 GET_SEGNO(sbi, wp_block), OFFSET_IN_SEG(sbi, wp_block));
2500 zone_segno = GET_SEG_FROM_SEC(sbi,
2501 GET_SEC_FROM_SEG(sbi, curseg->segno));
2502 zone_last_vblock = START_BLOCK(sbi, zone_segno) +
2503 last_vblk_off_in_zone(sbi, zone_segno);
2520 GET_SEGNO(sbi, zone_last_vblock),
2521 OFFSET_IN_SEG(sbi, zone_last_vblock));
2531 static int check_curseg_write_pointer(struct f2fs_sb_info *UNUSED(sbi),
2539 int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
2541 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2542 struct curseg_info *curseg = CURSEG_I(sbi, type);
2555 se = get_seg_entry(sbi, curseg->segno);
2564 nblocks = sbi->blocks_per_seg;
2574 return check_curseg_write_pointer(sbi, type);
2579 int check_curseg_offsets(struct f2fs_sb_info *sbi)
2584 ret = check_curseg_offset(sbi, i);
2591 static void fix_curseg_info(struct f2fs_sb_info *sbi)
2596 if (check_curseg_offset(sbi, i)) {
2597 update_curseg_info(sbi, i);
2603 write_curseg_info(sbi);
2604 flush_curseg_sit_entries(sbi);
2608 int check_sit_types(struct f2fs_sb_info *sbi)
2613 for (i = 0; i < MAIN_SEGS(sbi); i++) {
2616 se = get_seg_entry(sbi, i);
2631 static struct f2fs_node *fsck_get_lpf(struct f2fs_sb_info *sbi)
2641 get_node_info(sbi, F2FS_ROOT_INO(sbi), &ni);
2646 lpf_ino = f2fs_lookup(sbi, node, (u8 *)LPF, strlen(LPF));
2648 get_node_info(sbi, lpf_ino, &ni);
2666 de.pino = F2FS_ROOT_INO(sbi),
2672 err = f2fs_mkdir(sbi, &de);
2678 get_node_info(sbi, de.ino, &ni);
2692 static int fsck_do_reconnect_file(struct f2fs_sb_info *sbi,
2707 if (f2fs_lookup(sbi, lpf, (u8 *)name, namelen)) {
2712 get_node_info(sbi, le32_to_cpu(lpf->footer.ino), &ni);
2714 ret = f2fs_add_link(sbi, lpf, (unsigned char *)name, namelen,
2725 get_node_info(sbi, le32_to_cpu(fnode->footer.ino), &ni);
2733 static void fsck_failed_reconnect_file_dnode(struct f2fs_sb_info *sbi,
2736 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2745 get_node_info(sbi, nid, &ni);
2751 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2760 f2fs_clear_main_bitmap(sbi, addr);
2766 static void fsck_failed_reconnect_file_idnode(struct f2fs_sb_info *sbi,
2769 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2778 get_node_info(sbi, nid, &ni);
2784 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2790 fsck_failed_reconnect_file_dnode(sbi, tmp);
2796 static void fsck_failed_reconnect_file_didnode(struct f2fs_sb_info *sbi,
2799 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2808 get_node_info(sbi, nid, &ni);
2814 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2820 fsck_failed_reconnect_file_idnode(sbi, tmp);
2831 static void fsck_failed_reconnect_file(struct f2fs_sb_info *sbi, nid_t ino)
2833 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2842 get_node_info(sbi, ino, &ni);
2850 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2857 get_node_info(sbi, nid, &ni);
2858 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2871 f2fs_clear_main_bitmap(sbi, addr);
2883 fsck_failed_reconnect_file_dnode(sbi, nid);
2887 fsck_failed_reconnect_file_idnode(sbi, nid);
2890 fsck_failed_reconnect_file_didnode(sbi, nid);
2907 static int fsck_reconnect_file(struct f2fs_sb_info *sbi)
2909 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2926 if (is_qf_ino(F2FS_RAW_SUPER(sbi), nid)) {
2932 get_node_info(sbi, nid, &ni);
2950 if (sanity_check_nid(sbi, nid, node, ftype,
2960 fsck_chk_inode_blk(sbi, nid, ftype, node,
2967 lpf_node = fsck_get_lpf(sbi);
2973 get_node_info(sbi, nid, &ni);
2977 if (fsck_do_reconnect_file(sbi, lpf_node, node)) {
2980 fsck_failed_reconnect_file(sbi, nid);
3001 struct f2fs_sb_info *sbi;
3009 struct f2fs_sb_info *sbi = wpd->sbi;
3011 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3016 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
3017 unsigned int segs_per_zone = sbi->segs_per_sec * sbi->secs_per_zone;
3024 zone_segno = GET_SEGNO(sbi, zone_block);
3025 if (zone_segno >= MAIN_SEGS(sbi))
3030 wp_segno = GET_SEGNO(sbi, wp_block);
3031 wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
3035 cs = &SM_I(sbi)->curseg_array[cs_index];
3041 last_valid_blkoff = last_vblk_off_in_zone(sbi, zone_segno);
3082 static void fix_wp_sit_alignment(struct f2fs_sb_info *sbi)
3085 struct write_pointer_check_data wpd = { sbi, 0 };
3107 static void fix_wp_sit_alignment(struct f2fs_sb_info *UNUSED(sbi))
3118 void fsck_chk_and_fix_write_pointers(struct f2fs_sb_info *sbi)
3120 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3125 if (check_curseg_offsets(sbi) && c.fix_on) {
3126 fix_curseg_info(sbi);
3130 fix_wp_sit_alignment(sbi);
3133 int fsck_chk_curseg_info(struct f2fs_sb_info *sbi)
3135 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3142 curseg = CURSEG_I(sbi, i);
3143 se = get_seg_entry(sbi, curseg->segno);
3177 int fsck_verify(struct f2fs_sb_info *sbi)
3183 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3212 i = fsck_reconnect_file(sbi);
3221 get_node_info(sbi, i, &ni);
3238 data_secs = round_up(sbi->total_valid_node_count, BLKS_PER_SEC(sbi));
3239 node_secs = round_up(sbi->total_valid_block_count -
3240 sbi->total_valid_node_count, BLKS_PER_SEC(sbi));
3241 free_blks = (sbi->total_sections - data_secs - node_secs) *
3242 BLKS_PER_SEC(sbi);
3243 max_blks = SM_I(sbi)->main_blkaddr + (data_secs + node_secs) *
3244 BLKS_PER_SEC(sbi);
3273 if (sbi->total_valid_block_count == fsck->chk.valid_blk_cnt) {
3281 if (sbi->total_valid_node_count == fsck->chk.valid_node_cnt) {
3289 if (sbi->total_valid_node_count == fsck->chk.valid_nat_entry_cnt) {
3297 if (sbi->total_valid_inode_count == fsck->chk.valid_inode_cnt) {
3305 if (le32_to_cpu(F2FS_CKPT(sbi)->free_segment_count) ==
3314 if (check_curseg_offsets(sbi) == 0) {
3322 if (check_sit_types(sbi) != 0)
3349 dump_node(sbi, i, 1);
3357 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
3358 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3362 flush_journal_entries(sbi);
3363 fix_hard_links(sbi);
3364 fix_nat_entries(sbi);
3365 rewrite_sit_area_bitmap(sbi);
3366 fix_wp_sit_alignment(sbi);
3367 fix_curseg_info(sbi);
3368 fix_checksum(sbi);
3369 fix_checkpoints(sbi);
3372 write_checkpoints(sbi);
3390 void fsck_free(struct f2fs_sb_info *sbi)
3392 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);