Lines Matching refs:sbi
37 static int get_device_idx(struct f2fs_sb_info *sbi, uint32_t segno)
42 seg_start_blkaddr = SM_I(sbi)->main_blkaddr +
51 static int get_zone_idx_from_dev(struct f2fs_sb_info *sbi,
54 block_t seg_start_blkaddr = START_BLOCK(sbi, segno);
57 log_base_2(sbi->segs_per_sec * sbi->blocks_per_seg);
60 bool is_usable_seg(struct f2fs_sb_info *sbi, unsigned int segno)
62 unsigned int secno = segno / sbi->segs_per_sec;
63 block_t seg_start = START_BLOCK(sbi, segno);
64 block_t blocks_per_sec = sbi->blocks_per_seg * sbi->segs_per_sec;
65 unsigned int dev_idx = get_device_idx(sbi, segno);
66 unsigned int zone_idx = get_zone_idx_from_dev(sbi, segno, dev_idx);
67 unsigned int sec_off = SM_I(sbi)->main_blkaddr >>
80 unsigned int get_usable_seg_count(struct f2fs_sb_info *sbi)
84 for (i = 0; i < MAIN_SEGS(sbi); i++)
85 if (is_usable_seg(sbi, i))
93 bool is_usable_seg(struct f2fs_sb_info *UNUSED(sbi), unsigned int UNUSED(segno))
98 unsigned int get_usable_seg_count(struct f2fs_sb_info *sbi)
100 return MAIN_SEGS(sbi);
105 u32 get_free_segments(struct f2fs_sb_info *sbi)
109 for (i = 0; i < MAIN_SEGS(sbi); i++) {
110 struct seg_entry *se = get_seg_entry(sbi, i);
112 if (se->valid_blocks == 0x0 && !IS_CUR_SEGNO(sbi, i) &&
113 is_usable_seg(sbi, i))
119 void update_free_segments(struct f2fs_sb_info *sbi)
127 MSG(0, "\r [ %c ] Free segments: 0x%x", progress[i % 5], get_free_segments(sbi));
237 void print_inode_info(struct f2fs_sb_info *sbi,
337 xattr_addr = read_all_xattrs(sbi, node);
348 void print_node_info(struct f2fs_sb_info *sbi,
356 print_inode_info(sbi, node_block, verbose);
433 void print_ckpt_info(struct f2fs_sb_info *sbi)
435 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
651 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
658 if (blkaddr >= SIT_BLK_CNT(sbi))
662 if (blkaddr >= MAIN_BLKADDR(sbi) ||
663 blkaddr < SM_I(sbi)->ssa_blkaddr)
667 if (blkaddr >= SIT_I(sbi)->sit_base_addr ||
668 blkaddr < __start_cp_addr(sbi))
672 if (blkaddr >= MAX_BLKADDR(sbi) ||
673 blkaddr < MAIN_BLKADDR(sbi))
683 static inline block_t current_sit_addr(struct f2fs_sb_info *sbi,
689 int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
697 if (!f2fs_is_valid_blkaddr(sbi, blkno, type))
702 if (blkno >= NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid))
705 blkaddr = current_nat_addr(sbi,
710 blkaddr = current_sit_addr(sbi,
1002 static int check_and_set_one_feature(struct f2fs_sb_info *sbi, int feature)
1005 if (!(sbi->raw_super->feature & cpu_to_le32(feature))) {
1006 sbi->raw_super->feature |= cpu_to_le32(feature);
1013 static void check_and_set_features(struct f2fs_sb_info *sbi, enum SB_ADDR sb_addr)
1016 if (check_and_set_one_feature(sbi, F2FS_FEATURE_EXTRA_ATTR)) {
1021 if (check_and_set_one_feature(sbi, F2FS_FEATURE_PRJQUOTA)) {
1026 if (check_and_set_one_feature(sbi, F2FS_FEATURE_CASEFOLD)) {
1027 struct f2fs_super_block *sb = sbi->raw_super;
1036 update_superblock(sbi->raw_super, SB_MASK(sb_addr));
1042 int validate_super_block(struct f2fs_sb_info *sbi, enum SB_ADDR sb_addr)
1046 sbi->raw_super = malloc(sizeof(struct f2fs_super_block));
1047 if (!sbi->raw_super)
1053 memcpy(sbi->raw_super, buf + F2FS_SUPER_OFFSET,
1056 if (!sanity_check_raw_super(sbi->raw_super, sb_addr)) {
1057 check_and_set_features(sbi, sb_addr);
1067 memcpy(c.sb_version, sbi->raw_super->version, VERSION_NAME_LEN);
1069 memcpy(c.init_version, sbi->raw_super->init_version,
1073 c.force_stop = is_checkpoint_stop(sbi->raw_super, false);
1074 c.abnormal_stop = is_checkpoint_stop(sbi->raw_super, true);
1075 c.fs_errors = is_inconsistent_error(sbi->raw_super);
1080 print_sb_state(sbi->raw_super);
1081 print_sb_stop_reason(sbi->raw_super);
1082 print_sb_errors(sbi->raw_super);
1086 free(sbi->raw_super);
1087 sbi->raw_super = NULL;
1093 int init_sb_info(struct f2fs_sb_info *sbi)
1095 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1099 sbi->log_sectors_per_block = get_sb(log_sectors_per_block);
1100 sbi->log_blocksize = get_sb(log_blocksize);
1101 sbi->blocksize = 1 << sbi->log_blocksize;
1102 sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg);
1103 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
1104 sbi->segs_per_sec = get_sb(segs_per_sec);
1105 sbi->secs_per_zone = get_sb(secs_per_zone);
1106 sbi->total_sections = get_sb(section_count);
1107 sbi->total_node_count = (get_sb(segment_count_nat) / 2) *
1108 sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
1109 sbi->root_ino_num = get_sb(root_ino);
1110 sbi->node_ino_num = get_sb(node_ino);
1111 sbi->meta_ino_num = get_sb(meta_ino);
1112 sbi->cur_victim_sec = NULL_SEGNO;
1153 total_sectors = get_sb(block_count) << sbi->log_sectors_per_block;
1154 MSG(0, "Info: Segments per section = %d\n", sbi->segs_per_sec);
1155 MSG(0, "Info: Sections per zone = %d\n", sbi->secs_per_zone);
1201 void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr,
1214 if (get_cp(cp_pack_total_block_count) > sbi->blocks_per_seg)
1240 int get_valid_checkpoint(struct f2fs_sb_info *sbi)
1242 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1244 unsigned long blk_size = sbi->blocksize;
1255 sbi->ckpt = malloc(cp_blks * blk_size);
1256 if (!sbi->ckpt)
1263 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
1267 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
1272 sbi->cur_cp = 2;
1276 sbi->cur_cp = 1;
1281 sbi->cur_cp = 1;
1285 sbi->cur_cp = 2;
1292 memcpy(sbi->ckpt, cur_page, blk_size);
1304 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
1317 free(sbi->ckpt);
1318 sbi->ckpt = NULL;
1368 int sanity_check_ckpt(struct f2fs_sb_info *sbi)
1371 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1372 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1443 blocks_per_seg = sbi->blocks_per_seg;
1466 cp_pack_start_sum = __start_sum_addr(sbi);
1467 cp_payload = __cp_payload(sbi);
1482 pgoff_t current_nat_addr(struct f2fs_sb_info *sbi, nid_t start, int *pack)
1484 struct f2fs_nm_info *nm_i = NM_I(sbi);
1490 seg_off = block_off >> sbi->log_blocks_per_seg;
1493 (seg_off << sbi->log_blocks_per_seg << 1) +
1494 (block_off & ((1 << sbi->log_blocks_per_seg) -1)));
1499 block_addr += sbi->blocks_per_seg;
1508 static int f2fs_early_init_nid_bitmap(struct f2fs_sb_info *sbi)
1510 struct f2fs_nm_info *nm_i = NM_I(sbi);
1512 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1540 if (!IS_VALID_BLK_ADDR(sbi, addr)) {
1548 if (!IS_VALID_NID(sbi, nid)) {
1561 static int f2fs_late_init_nid_bitmap(struct f2fs_sb_info *sbi)
1563 struct f2fs_nm_info *nm_i = NM_I(sbi);
1577 f2fs_ra_meta_pages(sbi, 0, NAT_BLOCK_OFFSET(nm_i->max_nid),
1583 start_blk = current_nat_addr(sbi, nid, NULL);
1614 void write_nat_bits(struct f2fs_sb_info *sbi,
1617 struct f2fs_nm_info *nm_i = NM_I(sbi);
1687 static int check_nat_bits(struct f2fs_sb_info *sbi,
1690 struct f2fs_nm_info *nm_i = NM_I(sbi);
1697 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1709 blkaddr = get_sb(segment0_blkaddr) + (sbi->cur_cp <<
1766 int init_node_manager(struct f2fs_sb_info *sbi)
1768 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1769 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1770 struct f2fs_nm_info *nm_i = NM_I(sbi);
1785 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
1790 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
1796 return f2fs_early_init_nid_bitmap(sbi);
1799 int build_node_manager(struct f2fs_sb_info *sbi)
1802 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info));
1803 if (!sbi->nm_info)
1806 err = init_node_manager(sbi);
1813 int build_sit_info(struct f2fs_sb_info *sbi)
1815 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1816 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1830 SM_I(sbi)->sit_info = sit_i;
1832 sit_i->sentries = calloc(MAIN_SEGS(sbi) * sizeof(struct seg_entry), 1);
1838 bitmap_size = MAIN_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE;
1840 if (need_fsync_data_record(sbi))
1851 for (start = 0; start < MAIN_SEGS(sbi); start++) {
1855 if (need_fsync_data_record(sbi)) {
1862 bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
1863 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
1874 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
1893 void reset_curseg(struct f2fs_sb_info *sbi, int type)
1895 struct curseg_info *curseg = CURSEG_I(sbi, type);
1905 se = get_seg_entry(sbi, curseg->segno);
1910 static void read_compacted_summaries(struct f2fs_sb_info *sbi)
1918 start = start_sum_block(sbi);
1926 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1929 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1936 struct curseg_info *curseg = CURSEG_I(sbi, i);
1938 reset_curseg(sbi, i);
1941 blk_off = sbi->blocks_per_seg;
1964 static void restore_node_summary(struct f2fs_sb_info *sbi,
1977 addr = START_BLOCK(sbi, segno);
1980 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
1989 static void read_normal_summaries(struct f2fs_sb_info *sbi, int type)
1991 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2001 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type);
2003 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type);
2007 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE,
2010 blk_addr = GET_SUM_BLKADDR(sbi, segno);
2020 restore_node_summary(sbi, segno, sum_blk);
2022 curseg = CURSEG_I(sbi, type);
2024 reset_curseg(sbi, type);
2028 void update_sum_entry(struct f2fs_sb_info *sbi, block_t blk_addr,
2031 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2040 segno = GET_SEGNO(sbi, blk_addr);
2041 offset = OFFSET_IN_SEG(sbi, blk_addr);
2043 se = get_seg_entry(sbi, segno);
2045 sum_blk = get_sum_block(sbi, segno, &type);
2051 ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno));
2059 static void restore_curseg_summaries(struct f2fs_sb_info *sbi)
2063 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) {
2064 read_compacted_summaries(sbi);
2069 read_normal_summaries(sbi, type);
2072 static int build_curseg(struct f2fs_sb_info *sbi)
2074 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2086 SM_I(sbi)->curseg_array = array;
2103 ASSERT(segno < MAIN_SEGS(sbi));
2107 array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno);
2112 restore_curseg_summaries(sbi);
2123 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
2125 unsigned int end_segno = SM_I(sbi)->segment_count - 1;
2129 static inline block_t current_sit_addr(struct f2fs_sb_info *sbi,
2132 struct sit_info *sit_i = SIT_I(sbi);
2136 check_seg_range(sbi, segno);
2145 void get_current_sit_page(struct f2fs_sb_info *sbi,
2148 block_t blk_addr = current_sit_addr(sbi, segno);
2153 void rewrite_current_sit_page(struct f2fs_sb_info *sbi,
2156 block_t blk_addr = current_sit_addr(sbi, segno);
2161 void check_block_count(struct f2fs_sb_info *sbi,
2164 struct f2fs_sm_info *sm_info = SM_I(sbi);
2170 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg)
2201 void seg_info_from_raw_sit(struct f2fs_sb_info *sbi, struct seg_entry *se,
2206 if (!need_fsync_data_record(sbi))
2213 struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
2216 struct sit_info *sit_i = SIT_I(sbi);
2220 unsigned short get_seg_vblocks(struct f2fs_sb_info *sbi, struct seg_entry *se)
2222 if (!need_fsync_data_record(sbi))
2228 unsigned char *get_seg_bitmap(struct f2fs_sb_info *sbi, struct seg_entry *se)
2230 if (!need_fsync_data_record(sbi))
2236 unsigned char get_seg_type(struct f2fs_sb_info *sbi, struct seg_entry *se)
2238 if (!need_fsync_data_record(sbi))
2244 struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi,
2247 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2255 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
2258 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type);
2273 curseg = CURSEG_I(sbi, type);
2300 int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr,
2307 segno = GET_SEGNO(sbi, blk_addr);
2308 offset = OFFSET_IN_SEG(sbi, blk_addr);
2310 sum_blk = get_sum_block(sbi, segno, &type);
2319 static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid,
2327 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0)
2334 block_addr = current_nat_addr(sbi, nid, NULL);
2344 void update_data_blkaddr(struct f2fs_sb_info *sbi, nid_t nid,
2355 get_node_info(sbi, nid, &ni);
2378 get_node_info(sbi, le32_to_cpu(node_blk->footer.ino), &ni);
2396 void update_nat_blkaddr(struct f2fs_sb_info *sbi, nid_t ino,
2408 block_addr = current_nat_addr(sbi, nid, NULL);
2417 F2FS_FSCK(sbi)->entries[nid] = nat_block->entries[entry_off];
2424 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
2429 if (c.func == FSCK && F2FS_FSCK(sbi)->nr_nat_entries) {
2430 node_info_from_raw_nat(ni, &(F2FS_FSCK(sbi)->entries[nid]));
2436 get_nat_entry(sbi, nid, &raw_nat);
2440 static int build_sit_entries(struct f2fs_sb_info *sbi)
2442 struct sit_info *sit_i = SIT_I(sbi);
2443 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2448 int sit_blk_cnt = SIT_BLK_CNT(sbi);
2459 readed = f2fs_ra_meta_pages(sbi, start_blk, MAX_RA_BLOCKS,
2465 for (; segno < end && segno < MAIN_SEGS(sbi); segno++) {
2468 get_current_sit_page(sbi, segno, sit_blk);
2471 check_block_count(sbi, segno, &sit);
2472 seg_info_from_raw_sit(sbi, se, &sit);
2491 if (segno >= MAIN_SEGS(sbi)) {
2501 check_block_count(sbi, segno, &sit);
2502 seg_info_from_raw_sit(sbi, se, &sit);
2507 static int early_build_segment_manager(struct f2fs_sb_info *sbi)
2509 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2510 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2520 sbi->sm_info = sm_info;
2529 if (build_sit_info(sbi) || build_curseg(sbi)) {
2537 static int late_build_segment_manager(struct f2fs_sb_info *sbi)
2539 if (sbi->seg_manager_done)
2542 sbi->seg_manager_done = true;
2543 if (build_sit_entries(sbi)) {
2544 free (sbi->sm_info);
2551 void build_sit_area_bitmap(struct f2fs_sb_info *sbi)
2553 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2554 struct f2fs_sm_info *sm_i = SM_I(sbi);
2568 for (segno = 0; segno < MAIN_SEGS(sbi); segno++) {
2569 se = get_seg_entry(sbi, segno);
2574 if (se->valid_blocks == 0x0 && is_usable_seg(sbi, segno)) {
2575 if (le32_to_cpu(sbi->ckpt->cur_node_segno[0]) == segno ||
2576 le32_to_cpu(sbi->ckpt->cur_data_segno[0]) == segno ||
2577 le32_to_cpu(sbi->ckpt->cur_node_segno[1]) == segno ||
2578 le32_to_cpu(sbi->ckpt->cur_data_segno[1]) == segno ||
2579 le32_to_cpu(sbi->ckpt->cur_node_segno[2]) == segno ||
2580 le32_to_cpu(sbi->ckpt->cur_data_segno[2]) == segno) {
2597 void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi)
2599 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2600 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2601 struct sit_info *sit_i = SIT_I(sbi);
2614 for (segno = 0; segno < MAIN_SEGS(sbi); segno++) {
2621 get_current_sit_page(sbi, segno, sit_blk);
2629 se = get_seg_entry(sbi, segno);
2640 rewrite_current_sit_page(sbi, segno, sit_blk);
2648 static int flush_sit_journal_entries(struct f2fs_sb_info *sbi)
2650 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2652 struct sit_info *sit_i = SIT_I(sbi);
2664 se = get_seg_entry(sbi, segno);
2666 get_current_sit_page(sbi, segno, sit_blk);
2674 rewrite_current_sit_page(sbi, segno, sit_blk);
2682 static int flush_nat_journal_entries(struct f2fs_sb_info *sbi)
2684 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
2705 block_addr = current_nat_addr(sbi, nid, NULL);
2719 void flush_journal_entries(struct f2fs_sb_info *sbi)
2721 int n_nats = flush_nat_journal_entries(sbi);
2722 int n_sits = flush_sit_journal_entries(sbi);
2725 write_checkpoints(sbi);
2728 void flush_sit_entries(struct f2fs_sb_info *sbi)
2730 struct sit_info *sit_i = SIT_I(sbi);
2737 for (segno = 0; segno < MAIN_SEGS(sbi); segno++) {
2741 se = get_seg_entry(sbi, segno);
2746 get_current_sit_page(sbi, segno, sit_blk);
2751 rewrite_current_sit_page(sbi, segno, sit_blk);
2757 int relocate_curseg_offset(struct f2fs_sb_info *sbi, int type)
2759 struct curseg_info *curseg = CURSEG_I(sbi, type);
2760 struct seg_entry *se = get_seg_entry(sbi, curseg->segno);
2766 for (i = 0; i < sbi->blocks_per_seg; i++) {
2771 if (i == sbi->blocks_per_seg)
2784 void set_section_type(struct f2fs_sb_info *sbi, unsigned int segno, int type)
2788 if (sbi->segs_per_sec == 1)
2791 for (i = 0; i < sbi->segs_per_sec; i++) {
2792 struct seg_entry *se = get_seg_entry(sbi, segno + i);
2800 static bool write_pointer_at_zone_start(struct f2fs_sb_info *sbi,
2805 block_t block = START_BLOCK(sbi, zone_segno);
2806 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
2836 static bool write_pointer_at_zone_start(struct f2fs_sb_info *UNUSED(sbi),
2844 int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left,
2847 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2857 if (get_free_segments(sbi) <= SM_I(sbi)->reserved_segments + 1)
2860 while (*to >= SM_I(sbi)->main_blkaddr && *to < end_blkaddr) {
2865 segno = GET_SEGNO(sbi, *to);
2866 offset = OFFSET_IN_SEG(sbi, *to);
2868 se = get_seg_entry(sbi, segno);
2870 vblocks = get_seg_vblocks(sbi, se);
2871 bitmap = get_seg_bitmap(sbi, se);
2872 type = get_seg_type(sbi, se);
2874 if (vblocks == sbi->blocks_per_seg) {
2876 *to = left ? START_BLOCK(sbi, segno) - 1:
2877 START_BLOCK(sbi, segno + 1);
2881 IS_CUR_SEGNO(sbi, segno))
2886 if (vblocks == 0 && !(segno % sbi->segs_per_sec)) {
2890 for (i = 1; i < sbi->segs_per_sec; i++) {
2891 se2 = get_seg_entry(sbi, segno + i);
2892 if (get_seg_vblocks(sbi, se2))
2896 if (i == sbi->segs_per_sec &&
2897 write_pointer_at_zone_start(sbi, segno)) {
2898 set_section_type(sbi, segno, want_type);
2912 static void move_one_curseg_info(struct f2fs_sb_info *sbi, u64 from, int left,
2915 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2916 struct curseg_info *curseg = CURSEG_I(sbi, i);
2928 from = SM_I(sbi)->main_blkaddr;
2931 from = __end_block_addr(sbi);
2937 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
2942 ret = find_next_free_block(sbi, &to, left, i,
2947 curseg->segno = GET_SEGNO(sbi, to);
2948 curseg->next_blkoff = OFFSET_IN_SEG(sbi, to);
2952 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
2959 reset_curseg(sbi, i);
2965 void move_curseg_info(struct f2fs_sb_info *sbi, u64 from, int left)
2971 move_one_curseg_info(sbi, from, left, i);
2974 void update_curseg_info(struct f2fs_sb_info *sbi, int type)
2976 if (!relocate_curseg_offset(sbi, type))
2978 move_one_curseg_info(sbi, SM_I(sbi)->main_blkaddr, 0, type);
2981 void zero_journal_entries(struct f2fs_sb_info *sbi)
2986 CURSEG_I(sbi, i)->sum_blk->journal.n_nats = 0;
2989 void write_curseg_info(struct f2fs_sb_info *sbi)
2991 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2995 cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type;
2997 set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno);
2999 CURSEG_I(sbi, i)->next_blkoff);
3003 set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno);
3005 CURSEG_I(sbi, i)->next_blkoff);
3010 int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid,
3013 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
3028 void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
3030 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
3051 block_addr = current_nat_addr(sbi, nid, NULL);
3056 if (nid == F2FS_NODE_INO(sbi) || nid == F2FS_META_INO(sbi)) {
3071 void duplicate_checkpoint(struct f2fs_sb_info *sbi)
3073 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3079 if (sbi->cp_backuped)
3085 if (sbi->cur_cp == 1) {
3106 sbi->cp_backuped = 1;
3112 void write_checkpoint(struct f2fs_sb_info *sbi)
3114 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
3115 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3123 orphan_blks = __start_sum_addr(sbi) - 1;
3137 set_cp(free_segment_count, get_free_segments(sbi));
3139 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3145 set_cp(valid_block_count, sbi->total_valid_block_count);
3146 set_cp(valid_node_count, sbi->total_valid_node_count);
3147 set_cp(valid_inode_count, sbi->total_valid_inode_count);
3159 if (sbi->cur_cp == 2)
3173 struct curseg_info *curseg = CURSEG_I(sbi, i);
3181 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
3189 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
3203 void write_checkpoints(struct f2fs_sb_info *sbi)
3206 duplicate_checkpoint(sbi);
3209 sbi->cur_cp = 1;
3210 write_checkpoint(sbi);
3213 void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
3215 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
3217 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3218 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3219 struct f2fs_nm_info *nm_i = NM_I(sbi);
3234 sbi->log_blocks_per_seg;
3247 seg_off = block_off >> sbi->log_blocks_per_seg;
3249 (seg_off << sbi->log_blocks_per_seg << 1) +
3250 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
3253 block_addr += sbi->blocks_per_seg;
3262 if ((nid + i) == F2FS_NODE_INO(sbi) ||
3263 (nid + i) == F2FS_META_INO(sbi)) {
3367 static int tune_sb_features(struct f2fs_sb_info *sbi)
3370 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3437 static int find_fsync_inode(struct f2fs_sb_info *sbi, struct list_head *head)
3443 unsigned int free_blocks = MAIN_SEGS(sbi) * sbi->blocks_per_seg -
3444 sbi->total_valid_block_count;
3448 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
3449 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
3457 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
3464 if (!is_recoverable_dnode(sbi, node_blk))
3500 static int do_record_fsync_data(struct f2fs_sb_info *sbi,
3510 segno = GET_SEGNO(sbi, blkaddr);
3511 se = get_seg_entry(sbi, segno);
3512 offset = OFFSET_IN_SEG(sbi, blkaddr);
3541 end = start + ADDRS_PER_PAGE(sbi, node_blk, NULL);
3549 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR)) {
3554 segno = GET_SEGNO(sbi, blkaddr);
3555 se = get_seg_entry(sbi, segno);
3556 offset = OFFSET_IN_SEG(sbi, blkaddr);
3581 static int traverse_dnodes(struct f2fs_sb_info *sbi,
3590 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
3591 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
3599 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
3606 if (!is_recoverable_dnode(sbi, node_blk))
3614 err = do_record_fsync_data(sbi, node_blk, blkaddr);
3628 static int record_fsync_data(struct f2fs_sb_info *sbi)
3633 if (!need_fsync_data_record(sbi))
3636 ret = find_fsync_inode(sbi, &inode_list);
3640 ret = late_build_segment_manager(sbi);
3646 ret = traverse_dnodes(sbi, &inode_list);
3652 int f2fs_do_mount(struct f2fs_sb_info *sbi)
3658 sbi->active_logs = NR_CURSEG_TYPE;
3659 ret = validate_super_block(sbi, SB0_ADDR);
3661 ret = validate_super_block(sbi, SB1_ADDR);
3663 dump_sbi_info(sbi);
3667 sb = F2FS_RAW_SUPER(sbi);
3675 init_sb_info(sbi);
3677 ret = get_valid_checkpoint(sbi);
3680 dump_sbi_info(sbi);
3681 print_ckpt_info(sbi);
3687 if (sanity_check_ckpt(sbi)) {
3689 dump_sbi_info(sbi);
3690 print_ckpt_info(sbi);
3693 cp = F2FS_CKPT(sbi);
3696 !is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) {
3707 memcpy(sbi->raw_super->version,
3709 update_superblock(sbi->raw_super, SB_MASK_ALL);
3714 __le32 *ver_ts_ptr = (__le32 *)(sbi->raw_super->version
3733 memcpy(sbi->raw_super->version,
3738 update_superblock(sbi->raw_super, SB_MASK_ALL);
3743 print_ckpt_info(sbi);
3752 if (tune_sb_features(sbi))
3759 sbi->total_valid_node_count = get_cp(valid_node_count);
3760 sbi->total_valid_inode_count = get_cp(valid_inode_count);
3761 sbi->user_block_count = get_cp(user_block_count);
3762 sbi->total_valid_block_count = get_cp(valid_block_count);
3763 sbi->last_valid_block_count = sbi->total_valid_block_count;
3764 sbi->alloc_valid_block_count = 0;
3766 if (early_build_segment_manager(sbi)) {
3771 if (build_node_manager(sbi)) {
3776 if (record_fsync_data(sbi)) {
3784 if (late_build_segment_manager(sbi) < 0) {
3789 if (f2fs_late_init_nid_bitmap(sbi)) {
3796 if (check_nat_bits(sbi, sb, cp) && c.fix_on)
3797 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
3802 void f2fs_do_umount(struct f2fs_sb_info *sbi)
3804 struct sit_info *sit_i = SIT_I(sbi);
3805 struct f2fs_sm_info *sm_i = SM_I(sbi);
3806 struct f2fs_nm_info *nm_i = NM_I(sbi);
3813 free(sbi->nm_info);
3826 free(sbi->sm_info);
3828 free(sbi->ckpt);
3829 free(sbi->raw_super);
3833 int f2fs_sparse_initialize_meta(struct f2fs_sb_info *sbi)
3835 struct f2fs_super_block *sb = sbi->raw_super;
3899 int f2fs_sparse_initialize_meta(struct f2fs_sb_info *sbi) { return 0; }