Lines Matching refs:sbi
14 u32 get_free_segments(struct f2fs_sb_info *sbi)
18 for (i = 0; i < TOTAL_SEGS(sbi); i++) {
19 struct seg_entry *se = get_seg_entry(sbi, i);
22 !IS_CUR_SEGNO(sbi, i, NO_CHECK_TYPE))
28 void update_free_segments(struct f2fs_sb_info *sbi)
33 MSG(0, "\r [ %c ] Free segments: 0x%x", progress[i % 5], get_free_segments(sbi));
190 void print_ckpt_info(struct f2fs_sb_info *sbi)
192 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
421 int validate_super_block(struct f2fs_sb_info *sbi, int block)
425 sbi->raw_super = malloc(sizeof(struct f2fs_super_block));
432 if (dev_read(sbi->raw_super, offset, sizeof(struct f2fs_super_block)))
435 if (!sanity_check_raw_super(sbi->raw_super, offset)) {
445 memcpy(c.sb_version, sbi->raw_super->version, VERSION_LEN);
447 memcpy(c.init_version, sbi->raw_super->init_version, VERSION_LEN);
456 memcpy(sbi->raw_super->version,
458 ret = dev_write(sbi->raw_super, offset,
465 print_sb_state(sbi->raw_super);
469 free(sbi->raw_super);
470 sbi->raw_super = NULL;
476 int init_sb_info(struct f2fs_sb_info *sbi)
478 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
482 sbi->log_sectors_per_block = get_sb(log_sectors_per_block);
483 sbi->log_blocksize = get_sb(log_blocksize);
484 sbi->blocksize = 1 << sbi->log_blocksize;
485 sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg);
486 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
487 sbi->segs_per_sec = get_sb(segs_per_sec);
488 sbi->secs_per_zone = get_sb(secs_per_zone);
489 sbi->total_sections = get_sb(section_count);
490 sbi->total_node_count = (get_sb(segment_count_nat) / 2) *
491 sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
492 sbi->root_ino_num = get_sb(root_ino);
493 sbi->node_ino_num = get_sb(node_ino);
494 sbi->meta_ino_num = get_sb(meta_ino);
495 sbi->cur_victim_sec = NULL_SEGNO;
528 total_sectors = get_sb(block_count) << sbi->log_sectors_per_block;
535 void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr,
540 unsigned long blk_size = sbi->blocksize;
592 int get_valid_checkpoint(struct f2fs_sb_info *sbi)
594 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
596 unsigned long blk_size = sbi->blocksize;
607 sbi->ckpt = malloc(cp_blks * blk_size);
608 if (!sbi->ckpt)
615 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
619 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
624 sbi->cur_cp = 2;
628 sbi->cur_cp = 1;
633 sbi->cur_cp = 1;
637 sbi->cur_cp = 2;
644 memcpy(sbi->ckpt, cur_page, blk_size);
656 unsigned char *ckpt = (unsigned char *)sbi->ckpt;
669 free(sbi->ckpt);
670 sbi->ckpt = NULL;
674 int sanity_check_ckpt(struct f2fs_sb_info *sbi)
677 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
678 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
693 static pgoff_t current_nat_addr(struct f2fs_sb_info *sbi, nid_t start)
695 struct f2fs_nm_info *nm_i = NM_I(sbi);
701 seg_off = block_off >> sbi->log_blocks_per_seg;
704 (seg_off << sbi->log_blocks_per_seg << 1) +
705 (block_off & ((1 << sbi->log_blocks_per_seg) -1)));
708 block_addr += sbi->blocks_per_seg;
713 static int f2fs_init_nid_bitmap(struct f2fs_sb_info *sbi)
715 struct f2fs_nm_info *nm_i = NM_I(sbi);
717 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
741 start_blk = current_nat_addr(sbi, nid);
779 void write_nat_bits(struct f2fs_sb_info *sbi,
782 struct f2fs_nm_info *nm_i = NM_I(sbi);
847 int init_node_manager(struct f2fs_sb_info *sbi)
849 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
850 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
851 struct f2fs_nm_info *nm_i = NM_I(sbi);
866 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
871 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
877 return f2fs_init_nid_bitmap(sbi);
880 int build_node_manager(struct f2fs_sb_info *sbi)
883 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info));
884 if (!sbi->nm_info)
887 err = init_node_manager(sbi);
894 int build_sit_info(struct f2fs_sb_info *sbi)
896 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
897 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
907 SM_I(sbi)->sit_info = sit_i;
909 sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1);
913 for (start = 0; start < TOTAL_SEGS(sbi); start++) {
924 bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
925 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
931 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
941 void reset_curseg(struct f2fs_sb_info *sbi, int type)
943 struct curseg_info *curseg = CURSEG_I(sbi, type);
953 se = get_seg_entry(sbi, curseg->segno);
957 static void read_compacted_summaries(struct f2fs_sb_info *sbi)
965 start = start_sum_block(sbi);
971 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
974 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
981 struct curseg_info *curseg = CURSEG_I(sbi, i);
983 reset_curseg(sbi, i);
986 blk_off = sbi->blocks_per_seg;
1009 static void restore_node_summary(struct f2fs_sb_info *sbi,
1022 addr = START_BLOCK(sbi, segno);
1025 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
1034 static void read_normal_summaries(struct f2fs_sb_info *sbi, int type)
1036 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1046 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type);
1048 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type);
1052 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE,
1055 blk_addr = GET_SUM_BLKADDR(sbi, segno);
1063 restore_node_summary(sbi, segno, sum_blk);
1065 curseg = CURSEG_I(sbi, type);
1067 reset_curseg(sbi, type);
1071 void update_sum_entry(struct f2fs_sb_info *sbi, block_t blk_addr,
1079 segno = GET_SEGNO(sbi, blk_addr);
1080 offset = OFFSET_IN_SEG(sbi, blk_addr);
1082 se = get_seg_entry(sbi, segno);
1084 sum_blk = get_sum_block(sbi, segno, &type);
1090 ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno));
1098 static void restore_curseg_summaries(struct f2fs_sb_info *sbi)
1102 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) {
1103 read_compacted_summaries(sbi);
1108 read_normal_summaries(sbi, type);
1111 static void build_curseg(struct f2fs_sb_info *sbi)
1113 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1122 SM_I(sbi)->curseg_array = array;
1135 ASSERT(segno < TOTAL_SEGS(sbi));
1139 array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno);
1144 restore_curseg_summaries(sbi);
1147 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
1149 unsigned int end_segno = SM_I(sbi)->segment_count - 1;
1153 struct f2fs_sit_block *get_current_sit_page(struct f2fs_sb_info *sbi,
1156 struct sit_info *sit_i = SIT_I(sbi);
1164 check_seg_range(sbi, segno);
1176 void rewrite_current_sit_page(struct f2fs_sb_info *sbi,
1179 struct sit_info *sit_i = SIT_I(sbi);
1192 void check_block_count(struct f2fs_sb_info *sbi,
1195 struct f2fs_sm_info *sm_info = SM_I(sbi);
1201 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg)
1234 struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
1237 struct sit_info *sit_i = SIT_I(sbi);
1241 struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi,
1244 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1252 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
1255 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type);
1270 curseg = CURSEG_I(sbi, type);
1297 int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr,
1304 segno = GET_SEGNO(sbi, blk_addr);
1305 offset = OFFSET_IN_SEG(sbi, blk_addr);
1307 sum_blk = get_sum_block(sbi, segno, &type);
1316 static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid,
1324 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0)
1331 block_addr = current_nat_addr(sbi, nid);
1341 void update_data_blkaddr(struct f2fs_sb_info *sbi, nid_t nid,
1352 get_node_info(sbi, nid, &ni);
1372 get_node_info(sbi, le32_to_cpu(node_blk->footer.ino), &ni);
1391 void update_nat_blkaddr(struct f2fs_sb_info *sbi, nid_t ino,
1403 block_addr = current_nat_addr(sbi, nid);
1417 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
1420 get_nat_entry(sbi, nid, &raw_nat);
1425 void build_sit_entries(struct f2fs_sb_info *sbi)
1427 struct sit_info *sit_i = SIT_I(sbi);
1428 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1434 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1438 sit_blk = get_current_sit_page(sbi, segno);
1442 check_block_count(sbi, segno, &sit);
1451 check_block_count(sbi, segno, &sit);
1457 int build_segment_manager(struct f2fs_sb_info *sbi)
1459 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1460 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1468 sbi->sm_info = sm_info;
1477 build_sit_info(sbi);
1479 build_curseg(sbi);
1481 build_sit_entries(sbi);
1486 void build_sit_area_bitmap(struct f2fs_sb_info *sbi)
1488 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1489 struct f2fs_sm_info *sm_i = SM_I(sbi);
1503 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1504 se = get_seg_entry(sbi, segno);
1510 if (le32_to_cpu(sbi->ckpt->cur_node_segno[0]) == segno ||
1511 le32_to_cpu(sbi->ckpt->cur_data_segno[0]) == segno ||
1512 le32_to_cpu(sbi->ckpt->cur_node_segno[1]) == segno ||
1513 le32_to_cpu(sbi->ckpt->cur_data_segno[1]) == segno ||
1514 le32_to_cpu(sbi->ckpt->cur_node_segno[2]) == segno ||
1515 le32_to_cpu(sbi->ckpt->cur_data_segno[2]) == segno) {
1532 void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi)
1534 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1535 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1536 struct sit_info *sit_i = SIT_I(sbi);
1546 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1554 sit_blk = get_current_sit_page(sbi, segno);
1562 se = get_seg_entry(sbi, segno);
1573 rewrite_current_sit_page(sbi, segno, sit_blk);
1580 static int flush_sit_journal_entries(struct f2fs_sb_info *sbi)
1582 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
1584 struct sit_info *sit_i = SIT_I(sbi);
1594 se = get_seg_entry(sbi, segno);
1596 sit_blk = get_current_sit_page(sbi, segno);
1604 rewrite_current_sit_page(sbi, segno, sit_blk);
1612 static int flush_nat_journal_entries(struct f2fs_sb_info *sbi)
1614 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1635 block_addr = current_nat_addr(sbi, nid);
1649 void flush_journal_entries(struct f2fs_sb_info *sbi)
1651 int n_nats = flush_nat_journal_entries(sbi);
1652 int n_sits = flush_sit_journal_entries(sbi);
1655 write_checkpoint(sbi);
1658 void flush_sit_entries(struct f2fs_sb_info *sbi)
1660 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1661 struct sit_info *sit_i = SIT_I(sbi);
1666 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
1671 se = get_seg_entry(sbi, segno);
1676 sit_blk = get_current_sit_page(sbi, segno);
1681 rewrite_current_sit_page(sbi, segno, sit_blk);
1685 !IS_CUR_SEGNO(sbi, segno, NO_CHECK_TYPE))
1692 int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, int type)
1694 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1702 if (get_free_segments(sbi) <= SM_I(sbi)->reserved_segments + 1)
1705 while (*to >= SM_I(sbi)->main_blkaddr && *to < end_blkaddr) {
1706 segno = GET_SEGNO(sbi, *to);
1707 offset = OFFSET_IN_SEG(sbi, *to);
1709 se = get_seg_entry(sbi, segno);
1711 if (se->valid_blocks == sbi->blocks_per_seg ||
1712 IS_CUR_SEGNO(sbi, segno, type)) {
1713 *to = left ? START_BLOCK(sbi, segno) - 1:
1714 START_BLOCK(sbi, segno + 1);
1719 *to = left ? START_BLOCK(sbi, segno) - 1:
1720 START_BLOCK(sbi, segno + 1);
1724 if (se->valid_blocks == 0 && !(segno % sbi->segs_per_sec)) {
1728 for (i = 1; i < sbi->segs_per_sec; i++) {
1729 se2 = get_seg_entry(sbi, segno + i);
1733 if (i == sbi->segs_per_sec)
1746 void move_curseg_info(struct f2fs_sb_info *sbi, u64 from)
1752 struct curseg_info *curseg = CURSEG_I(sbi, i);
1758 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
1763 ret = find_next_free_block(sbi, &to, 0, i);
1767 curseg->segno = GET_SEGNO(sbi, to);
1768 curseg->next_blkoff = OFFSET_IN_SEG(sbi, to);
1772 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
1779 reset_curseg(sbi, i);
1786 void zero_journal_entries(struct f2fs_sb_info *sbi)
1791 CURSEG_I(sbi, i)->sum_blk->journal.n_nats = 0;
1794 void write_curseg_info(struct f2fs_sb_info *sbi)
1796 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1800 cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type;
1802 set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno);
1804 CURSEG_I(sbi, i)->next_blkoff);
1808 set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno);
1810 CURSEG_I(sbi, i)->next_blkoff);
1815 int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid,
1818 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1833 void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
1835 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1856 block_addr = current_nat_addr(sbi, nid);
1869 void write_checkpoint(struct f2fs_sb_info *sbi)
1871 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
1872 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1880 orphan_blks = __start_sum_addr(sbi) - 1;
1884 set_cp(free_segment_count, get_free_segments(sbi));
1885 set_cp(valid_block_count, sbi->total_valid_block_count);
1895 if (sbi->cur_cp == 2)
1909 struct curseg_info *curseg = CURSEG_I(sbi, i);
1916 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
1927 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
1930 void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
1932 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
1934 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1935 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1936 struct f2fs_nm_info *nm_i = NM_I(sbi);
1951 sbi->log_blocks_per_seg;
1964 seg_off = block_off >> sbi->log_blocks_per_seg;
1966 (seg_off << sbi->log_blocks_per_seg << 1) +
1967 (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
1970 block_addr += sbi->blocks_per_seg;
1979 if ((nid + i) == F2FS_NODE_INO(sbi) ||
1980 (nid + i) == F2FS_META_INO(sbi)) {
2100 int f2fs_do_mount(struct f2fs_sb_info *sbi)
2106 sbi->active_logs = NR_CURSEG_TYPE;
2107 ret = validate_super_block(sbi, 0);
2109 ret = validate_super_block(sbi, 1);
2113 sb = F2FS_RAW_SUPER(sbi);
2121 init_sb_info(sbi);
2123 ret = get_valid_checkpoint(sbi);
2129 if (sanity_check_ckpt(sbi)) {
2133 cp = F2FS_CKPT(sbi);
2135 print_ckpt_info(sbi);
2148 sbi->total_valid_node_count = get_cp(valid_node_count);
2149 sbi->total_valid_inode_count = get_cp(valid_inode_count);
2150 sbi->user_block_count = get_cp(user_block_count);
2151 sbi->total_valid_block_count = get_cp(valid_block_count);
2152 sbi->last_valid_block_count = sbi->total_valid_block_count;
2153 sbi->alloc_valid_block_count = 0;
2155 if (build_segment_manager(sbi)) {
2160 if (build_node_manager(sbi)) {
2172 if (sbi->cur_cp == 2)
2184 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
2192 void f2fs_do_umount(struct f2fs_sb_info *sbi)
2194 struct sit_info *sit_i = SIT_I(sbi);
2195 struct f2fs_sm_info *sm_i = SM_I(sbi);
2196 struct f2fs_nm_info *nm_i = NM_I(sbi);
2203 free(sbi->nm_info);
2206 for (i = 0; i < TOTAL_SEGS(sbi); i++) {
2218 free(sbi->sm_info);
2220 free(sbi->ckpt);
2221 free(sbi->raw_super);
