mount.c revision 893312ced238b9ee93c5427aa6e6c1f29fe39899
1/** 2 * mount.c 3 * 4 * Copyright (c) 2013 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com/ 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11#include "fsck.h" 12 13void print_inode_info(struct f2fs_inode *inode) 14{ 15 unsigned int i = 0; 16 int namelen = le32_to_cpu(inode->i_namelen); 17 18 DISP_u32(inode, i_mode); 19 DISP_u32(inode, i_uid); 20 DISP_u32(inode, i_gid); 21 DISP_u32(inode, i_links); 22 DISP_u64(inode, i_size); 23 DISP_u64(inode, i_blocks); 24 25 DISP_u64(inode, i_atime); 26 DISP_u32(inode, i_atime_nsec); 27 DISP_u64(inode, i_ctime); 28 DISP_u32(inode, i_ctime_nsec); 29 DISP_u64(inode, i_mtime); 30 DISP_u32(inode, i_mtime_nsec); 31 32 DISP_u32(inode, i_generation); 33 DISP_u32(inode, i_current_depth); 34 DISP_u32(inode, i_xattr_nid); 35 DISP_u32(inode, i_flags); 36 DISP_u32(inode, i_pino); 37 38 if (namelen) { 39 DISP_u32(inode, i_namelen); 40 inode->i_name[namelen] = '\0'; 41 DISP_utf(inode, i_name); 42 } 43 44 printf("i_ext: fofs:%x blkaddr:%x len:%x\n", 45 inode->i_ext.fofs, 46 inode->i_ext.blk_addr, 47 inode->i_ext.len); 48 49 DISP_u32(inode, i_addr[0]); /* Pointers to data blocks */ 50 DISP_u32(inode, i_addr[1]); /* Pointers to data blocks */ 51 DISP_u32(inode, i_addr[2]); /* Pointers to data blocks */ 52 DISP_u32(inode, i_addr[3]); /* Pointers to data blocks */ 53 54 for (i = 4; i < ADDRS_PER_INODE(inode); i++) { 55 if (inode->i_addr[i] != 0x0) { 56 printf("i_addr[0x%x] points data block\r\t\t[0x%4x]\n", 57 i, inode->i_addr[i]); 58 break; 59 } 60 } 61 62 DISP_u32(inode, i_nid[0]); /* direct */ 63 DISP_u32(inode, i_nid[1]); /* direct */ 64 DISP_u32(inode, i_nid[2]); /* indirect */ 65 DISP_u32(inode, i_nid[3]); /* indirect */ 66 DISP_u32(inode, i_nid[4]); /* double indirect */ 67 68 printf("\n"); 69} 70 71void print_node_info(struct f2fs_node *node_block) 72{ 73 nid_t ino = le32_to_cpu(node_block->footer.ino); 74 nid_t nid = le32_to_cpu(node_block->footer.nid); 75 /* Is this inode? */ 76 if (ino == nid) { 77 DBG(0, "Node ID [0x%x:%u] is inode\n", nid, nid); 78 print_inode_info(&node_block->i); 79 } else { 80 int i; 81 u32 *dump_blk = (u32 *)node_block; 82 DBG(0, "Node ID [0x%x:%u] is direct node or indirect node.\n", 83 nid, nid); 84 for (i = 0; i <= 10; i++) 85 MSG(0, "[%d]\t\t\t[0x%8x : %d]\n", 86 i, dump_blk[i], dump_blk[i]); 87 } 88} 89 90void print_raw_sb_info(struct f2fs_sb_info *sbi) 91{ 92 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 93 94 if (!config.dbg_lv) 95 return; 96 97 printf("\n"); 98 printf("+--------------------------------------------------------+\n"); 99 printf("| Super block |\n"); 100 printf("+--------------------------------------------------------+\n"); 101 102 DISP_u32(sb, magic); 103 DISP_u32(sb, major_ver); 104 DISP_u32(sb, minor_ver); 105 DISP_u32(sb, log_sectorsize); 106 DISP_u32(sb, log_sectors_per_block); 107 108 DISP_u32(sb, log_blocksize); 109 DISP_u32(sb, log_blocks_per_seg); 110 DISP_u32(sb, segs_per_sec); 111 DISP_u32(sb, secs_per_zone); 112 DISP_u32(sb, checksum_offset); 113 DISP_u64(sb, block_count); 114 115 DISP_u32(sb, section_count); 116 DISP_u32(sb, segment_count); 117 DISP_u32(sb, segment_count_ckpt); 118 DISP_u32(sb, segment_count_sit); 119 DISP_u32(sb, segment_count_nat); 120 121 DISP_u32(sb, segment_count_ssa); 122 DISP_u32(sb, segment_count_main); 123 DISP_u32(sb, segment0_blkaddr); 124 125 DISP_u32(sb, cp_blkaddr); 126 DISP_u32(sb, sit_blkaddr); 127 DISP_u32(sb, nat_blkaddr); 128 DISP_u32(sb, ssa_blkaddr); 129 DISP_u32(sb, main_blkaddr); 130 131 DISP_u32(sb, root_ino); 132 DISP_u32(sb, node_ino); 133 DISP_u32(sb, meta_ino); 134 DISP_u32(sb, cp_payload); 135 printf("\n"); 136} 137 138void print_ckpt_info(struct f2fs_sb_info *sbi) 139{ 140 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 141 142 if (!config.dbg_lv) 143 return; 144 145 printf("\n"); 146 printf("+--------------------------------------------------------+\n"); 147 printf("| Checkpoint |\n"); 148 printf("+--------------------------------------------------------+\n"); 149 150 DISP_u64(cp, checkpoint_ver); 151 DISP_u64(cp, user_block_count); 152 DISP_u64(cp, valid_block_count); 153 DISP_u32(cp, rsvd_segment_count); 154 DISP_u32(cp, overprov_segment_count); 155 DISP_u32(cp, free_segment_count); 156 157 DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]); 158 DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]); 159 DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]); 160 DISP_u32(cp, cur_node_segno[0]); 161 DISP_u32(cp, cur_node_segno[1]); 162 DISP_u32(cp, cur_node_segno[2]); 163 164 DISP_u32(cp, cur_node_blkoff[0]); 165 DISP_u32(cp, cur_node_blkoff[1]); 166 DISP_u32(cp, cur_node_blkoff[2]); 167 168 169 DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]); 170 DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]); 171 DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]); 172 DISP_u32(cp, cur_data_segno[0]); 173 DISP_u32(cp, cur_data_segno[1]); 174 DISP_u32(cp, cur_data_segno[2]); 175 176 DISP_u32(cp, cur_data_blkoff[0]); 177 DISP_u32(cp, cur_data_blkoff[1]); 178 DISP_u32(cp, cur_data_blkoff[2]); 179 180 DISP_u32(cp, ckpt_flags); 181 DISP_u32(cp, cp_pack_total_block_count); 182 DISP_u32(cp, cp_pack_start_sum); 183 DISP_u32(cp, valid_node_count); 184 DISP_u32(cp, valid_inode_count); 185 DISP_u32(cp, next_free_nid); 186 DISP_u32(cp, sit_ver_bitmap_bytesize); 187 DISP_u32(cp, nat_ver_bitmap_bytesize); 188 DISP_u32(cp, checksum_offset); 189 DISP_u64(cp, elapsed_time); 190 191 DISP_u32(cp, sit_nat_version_bitmap[0]); 192 printf("\n\n"); 193} 194 195int sanity_check_raw_super(struct f2fs_super_block *raw_super) 196{ 197 unsigned int blocksize; 198 199 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) { 200 return -1; 201 } 202 203 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) { 204 return -1; 205 } 206 207 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize); 208 if (F2FS_BLKSIZE != blocksize) { 209 return -1; 210 } 211 212 if (F2FS_LOG_SECTOR_SIZE != le32_to_cpu(raw_super->log_sectorsize)) { 213 return -1; 214 } 215 216 if (F2FS_LOG_SECTORS_PER_BLOCK != 217 le32_to_cpu(raw_super->log_sectors_per_block)) { 218 return -1; 219 } 220 221 return 0; 222} 223 224int validate_super_block(struct f2fs_sb_info *sbi, int block) 225{ 226 u64 offset = (block + 1) * F2FS_SUPER_OFFSET; 227 sbi->raw_super = malloc(sizeof(struct f2fs_super_block)); 228 229 if (dev_read(sbi->raw_super, offset, sizeof(struct f2fs_super_block))) 230 return -1; 231 232 if (!sanity_check_raw_super(sbi->raw_super)) 233 return 0; 234 235 free(sbi->raw_super); 236 MSG(0, "\tCan't find a valid F2FS superblock at 0x%x\n", block); 237 238 return -EINVAL; 239} 240 241int init_sb_info(struct f2fs_sb_info *sbi) 242{ 243 struct f2fs_super_block *raw_super = sbi->raw_super; 244 245 sbi->log_sectors_per_block = 246 le32_to_cpu(raw_super->log_sectors_per_block); 247 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize); 248 sbi->blocksize = 1 << sbi->log_blocksize; 249 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 250 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 251 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec); 252 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone); 253 sbi->total_sections = le32_to_cpu(raw_super->section_count); 254 sbi->total_node_count = 255 (le32_to_cpu(raw_super->segment_count_nat) / 2) 256 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 257 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino); 258 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino); 259 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino); 260 sbi->cur_victim_sec = NULL_SEGNO; 261 return 0; 262} 263 264void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, 265 unsigned long long *version) 266{ 267 void *cp_page_1, *cp_page_2; 268 struct f2fs_checkpoint *cp_block; 269 unsigned long blk_size = sbi->blocksize; 270 unsigned long long cur_version = 0, pre_version = 0; 271 unsigned int crc = 0; 272 size_t crc_offset; 273 274 /* Read the 1st cp block in this CP pack */ 275 cp_page_1 = malloc(PAGE_SIZE); 276 if (dev_read_block(cp_page_1, cp_addr) < 0) 277 return NULL; 278 279 cp_block = (struct f2fs_checkpoint *)cp_page_1; 280 crc_offset = le32_to_cpu(cp_block->checksum_offset); 281 if (crc_offset >= blk_size) 282 goto invalid_cp1; 283 284 crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset); 285 if (f2fs_crc_valid(crc, cp_block, crc_offset)) 286 goto invalid_cp1; 287 288 pre_version = le64_to_cpu(cp_block->checkpoint_ver); 289 290 /* Read the 2nd cp block in this CP pack */ 291 cp_page_2 = malloc(PAGE_SIZE); 292 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1; 293 294 if (dev_read_block(cp_page_2, cp_addr) < 0) 295 goto invalid_cp2; 296 297 cp_block = (struct f2fs_checkpoint *)cp_page_2; 298 crc_offset = le32_to_cpu(cp_block->checksum_offset); 299 if (crc_offset >= blk_size) 300 goto invalid_cp2; 301 302 crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset); 303 if (f2fs_crc_valid(crc, cp_block, crc_offset)) 304 goto invalid_cp2; 305 306 cur_version = le64_to_cpu(cp_block->checkpoint_ver); 307 308 if (cur_version == pre_version) { 309 *version = cur_version; 310 free(cp_page_2); 311 return cp_page_1; 312 } 313 314invalid_cp2: 315 free(cp_page_2); 316invalid_cp1: 317 free(cp_page_1); 318 return NULL; 319} 320 321int get_valid_checkpoint(struct f2fs_sb_info *sbi) 322{ 323 struct f2fs_super_block *raw_sb = sbi->raw_super; 324 void *cp1, *cp2, *cur_page; 325 unsigned long blk_size = sbi->blocksize; 326 unsigned long long cp1_version = 0, cp2_version = 0; 327 unsigned long long cp_start_blk_no; 328 unsigned int cp_blks = 1 + le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload); 329 int ret; 330 331 sbi->ckpt = malloc(cp_blks * blk_size); 332 if (!sbi->ckpt) 333 return -ENOMEM; 334 /* 335 * Finding out valid cp block involves read both 336 * sets( cp pack1 and cp pack 2) 337 */ 338 cp_start_blk_no = le32_to_cpu(raw_sb->cp_blkaddr); 339 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); 340 341 /* The second checkpoint pack should start at the next segment */ 342 cp_start_blk_no += 1 << le32_to_cpu(raw_sb->log_blocks_per_seg); 343 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); 344 345 if (cp1 && cp2) { 346 if (ver_after(cp2_version, cp1_version)) { 347 cur_page = cp2; 348 sbi->cur_cp = 2; 349 } else { 350 cur_page = cp1; 351 sbi->cur_cp = 1; 352 } 353 } else if (cp1) { 354 cur_page = cp1; 355 sbi->cur_cp = 1; 356 } else if (cp2) { 357 cur_page = cp2; 358 sbi->cur_cp = 2; 359 } else { 360 free(cp1); 361 free(cp2); 362 goto fail_no_cp; 363 } 364 365 memcpy(sbi->ckpt, cur_page, blk_size); 366 367 if (cp_blks > 1) { 368 unsigned int i; 369 unsigned long long cp_blk_no; 370 371 cp_blk_no = le32_to_cpu(raw_sb->cp_blkaddr); 372 if (cur_page == cp2) 373 cp_blk_no += 1 << 374 le32_to_cpu(raw_sb->log_blocks_per_seg); 375 /* copy sit bitmap */ 376 for (i = 1; i < cp_blks; i++) { 377 unsigned char *ckpt = (unsigned char *)sbi->ckpt; 378 ret = dev_read_block(cur_page, cp_blk_no + i); 379 ASSERT(ret >= 0); 380 memcpy(ckpt + i * blk_size, cur_page, blk_size); 381 } 382 } 383 free(cp1); 384 free(cp2); 385 return 0; 386 387fail_no_cp: 388 free(sbi->ckpt); 389 return -EINVAL; 390} 391 392int sanity_check_ckpt(struct f2fs_sb_info *sbi) 393{ 394 unsigned int total, fsmeta; 395 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 396 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 397 398 total = le32_to_cpu(raw_super->segment_count); 399 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt); 400 fsmeta += le32_to_cpu(raw_super->segment_count_sit); 401 fsmeta += le32_to_cpu(raw_super->segment_count_nat); 402 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count); 403 fsmeta += le32_to_cpu(raw_super->segment_count_ssa); 404 405 if (fsmeta >= total) 406 return 1; 407 408 return 0; 409} 410 411int init_node_manager(struct f2fs_sb_info *sbi) 412{ 413 struct f2fs_super_block *sb_raw = F2FS_RAW_SUPER(sbi); 414 struct f2fs_nm_info *nm_i = NM_I(sbi); 415 unsigned char *version_bitmap; 416 unsigned int nat_segs, nat_blocks; 417 418 nm_i->nat_blkaddr = le32_to_cpu(sb_raw->nat_blkaddr); 419 420 /* segment_count_nat includes pair segment so divide to 2. */ 421 nat_segs = le32_to_cpu(sb_raw->segment_count_nat) >> 1; 422 nat_blocks = nat_segs << le32_to_cpu(sb_raw->log_blocks_per_seg); 423 nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks; 424 nm_i->fcnt = 0; 425 nm_i->nat_cnt = 0; 426 nm_i->init_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid); 427 nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid); 428 429 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); 430 431 nm_i->nat_bitmap = malloc(nm_i->bitmap_size); 432 if (!nm_i->nat_bitmap) 433 return -ENOMEM; 434 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP); 435 if (!version_bitmap) 436 return -EFAULT; 437 438 /* copy version bitmap */ 439 memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size); 440 return 0; 441} 442 443int build_node_manager(struct f2fs_sb_info *sbi) 444{ 445 int err; 446 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info)); 447 if (!sbi->nm_info) 448 return -ENOMEM; 449 450 err = init_node_manager(sbi); 451 if (err) 452 return err; 453 454 return 0; 455} 456 457int build_sit_info(struct f2fs_sb_info *sbi) 458{ 459 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi); 460 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 461 struct sit_info *sit_i; 462 unsigned int sit_segs, start; 463 char *src_bitmap, *dst_bitmap; 464 unsigned int bitmap_size; 465 466 sit_i = malloc(sizeof(struct sit_info)); 467 if (!sit_i) 468 return -ENOMEM; 469 470 SM_I(sbi)->sit_info = sit_i; 471 472 sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1); 473 474 for (start = 0; start < TOTAL_SEGS(sbi); start++) { 475 sit_i->sentries[start].cur_valid_map 476 = calloc(SIT_VBLOCK_MAP_SIZE, 1); 477 sit_i->sentries[start].ckpt_valid_map 478 = calloc(SIT_VBLOCK_MAP_SIZE, 1); 479 if (!sit_i->sentries[start].cur_valid_map 480 || !sit_i->sentries[start].ckpt_valid_map) 481 return -ENOMEM; 482 } 483 484 sit_segs = le32_to_cpu(raw_sb->segment_count_sit) >> 1; 485 bitmap_size = __bitmap_size(sbi, SIT_BITMAP); 486 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); 487 488 dst_bitmap = malloc(bitmap_size); 489 memcpy(dst_bitmap, src_bitmap, bitmap_size); 490 491 sit_i->sit_base_addr = le32_to_cpu(raw_sb->sit_blkaddr); 492 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; 493 sit_i->written_valid_blocks = le64_to_cpu(ckpt->valid_block_count); 494 sit_i->sit_bitmap = dst_bitmap; 495 sit_i->bitmap_size = bitmap_size; 496 sit_i->dirty_sentries = 0; 497 sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; 498 sit_i->elapsed_time = le64_to_cpu(ckpt->elapsed_time); 499 return 0; 500} 501 502void reset_curseg(struct f2fs_sb_info *sbi, int type) 503{ 504 struct curseg_info *curseg = CURSEG_I(sbi, type); 505 struct summary_footer *sum_footer; 506 struct seg_entry *se; 507 508 curseg->segno = curseg->next_segno; 509 curseg->zone = GET_ZONENO_FROM_SEGNO(sbi, curseg->segno); 510 curseg->next_blkoff = 0; 511 curseg->next_segno = NULL_SEGNO; 512 513 sum_footer = &(curseg->sum_blk->footer); 514 memset(sum_footer, 0, sizeof(struct summary_footer)); 515 if (IS_DATASEG(type)) 516 SET_SUM_TYPE(sum_footer, SUM_TYPE_DATA); 517 if (IS_NODESEG(type)) 518 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE); 519 se = get_seg_entry(sbi, curseg->segno); 520 se->type = type; 521} 522 523static void read_compacted_summaries(struct f2fs_sb_info *sbi) 524{ 525 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 526 struct curseg_info *curseg; 527 unsigned int i, j, offset; 528 block_t start; 529 char *kaddr; 530 int ret; 531 532 start = start_sum_block(sbi); 533 534 kaddr = (char *)malloc(PAGE_SIZE); 535 ret = dev_read_block(kaddr, start++); 536 ASSERT(ret >= 0); 537 538 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 539 memcpy(&curseg->sum_blk->n_nats, kaddr, SUM_JOURNAL_SIZE); 540 541 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 542 memcpy(&curseg->sum_blk->n_sits, kaddr + SUM_JOURNAL_SIZE, 543 SUM_JOURNAL_SIZE); 544 545 offset = 2 * SUM_JOURNAL_SIZE; 546 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) { 547 unsigned short blk_off; 548 unsigned int segno; 549 550 curseg = CURSEG_I(sbi, i); 551 segno = le32_to_cpu(ckpt->cur_data_segno[i]); 552 blk_off = le16_to_cpu(ckpt->cur_data_blkoff[i]); 553 curseg->next_segno = segno; 554 reset_curseg(sbi, i); 555 curseg->alloc_type = ckpt->alloc_type[i]; 556 curseg->next_blkoff = blk_off; 557 558 if (curseg->alloc_type == SSR) 559 blk_off = sbi->blocks_per_seg; 560 561 for (j = 0; j < blk_off; j++) { 562 struct f2fs_summary *s; 563 s = (struct f2fs_summary *)(kaddr + offset); 564 curseg->sum_blk->entries[j] = *s; 565 offset += SUMMARY_SIZE; 566 if (offset + SUMMARY_SIZE <= 567 PAGE_CACHE_SIZE - SUM_FOOTER_SIZE) 568 continue; 569 memset(kaddr, 0, PAGE_SIZE); 570 ret = dev_read_block(kaddr, start++); 571 ASSERT(ret >= 0); 572 offset = 0; 573 } 574 } 575 free(kaddr); 576} 577 578static void restore_node_summary(struct f2fs_sb_info *sbi, 579 unsigned int segno, struct f2fs_summary_block *sum_blk) 580{ 581 struct f2fs_node *node_blk; 582 struct f2fs_summary *sum_entry; 583 block_t addr; 584 unsigned int i; 585 int ret; 586 587 node_blk = malloc(F2FS_BLKSIZE); 588 ASSERT(node_blk); 589 590 /* scan the node segment */ 591 addr = START_BLOCK(sbi, segno); 592 sum_entry = &sum_blk->entries[0]; 593 594 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) { 595 ret = dev_read_block(node_blk, addr); 596 ASSERT(ret >= 0); 597 sum_entry->nid = node_blk->footer.nid; 598 addr++; 599 } 600 free(node_blk); 601} 602 603static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) 604{ 605 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 606 struct f2fs_summary_block *sum_blk; 607 struct curseg_info *curseg; 608 unsigned short blk_off; 609 unsigned int segno = 0; 610 block_t blk_addr = 0; 611 int ret; 612 613 if (IS_DATASEG(type)) { 614 segno = le32_to_cpu(ckpt->cur_data_segno[type]); 615 blk_off = le16_to_cpu(ckpt->cur_data_blkoff[type - 616 CURSEG_HOT_DATA]); 617 618 if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG)) 619 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); 620 else 621 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); 622 } else { 623 segno = le32_to_cpu(ckpt->cur_node_segno[type - 624 CURSEG_HOT_NODE]); 625 blk_off = le16_to_cpu(ckpt->cur_node_blkoff[type - 626 CURSEG_HOT_NODE]); 627 628 if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG)) 629 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, 630 type - CURSEG_HOT_NODE); 631 else 632 blk_addr = GET_SUM_BLKADDR(sbi, segno); 633 } 634 635 sum_blk = (struct f2fs_summary_block *)malloc(PAGE_SIZE); 636 ret = dev_read_block(sum_blk, blk_addr); 637 ASSERT(ret >= 0); 638 639 if (IS_NODESEG(type) && !is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG)) 640 restore_node_summary(sbi, segno, sum_blk); 641 642 curseg = CURSEG_I(sbi, type); 643 memcpy(curseg->sum_blk, sum_blk, PAGE_CACHE_SIZE); 644 curseg->next_segno = segno; 645 reset_curseg(sbi, type); 646 curseg->alloc_type = ckpt->alloc_type[type]; 647 curseg->next_blkoff = blk_off; 648 free(sum_blk); 649} 650 651static void restore_curseg_summaries(struct f2fs_sb_info *sbi) 652{ 653 int type = CURSEG_HOT_DATA; 654 655 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) { 656 read_compacted_summaries(sbi); 657 type = CURSEG_HOT_NODE; 658 } 659 660 for (; type <= CURSEG_COLD_NODE; type++) 661 read_normal_summaries(sbi, type); 662} 663 664static void build_curseg(struct f2fs_sb_info *sbi) 665{ 666 struct curseg_info *array; 667 int i; 668 669 array = malloc(sizeof(*array) * NR_CURSEG_TYPE); 670 ASSERT(array); 671 672 SM_I(sbi)->curseg_array = array; 673 674 for (i = 0; i < NR_CURSEG_TYPE; i++) { 675 array[i].sum_blk = malloc(PAGE_CACHE_SIZE); 676 ASSERT(array[i].sum_blk); 677 array[i].segno = NULL_SEGNO; 678 array[i].next_blkoff = 0; 679 } 680 restore_curseg_summaries(sbi); 681} 682 683inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno) 684{ 685 unsigned int end_segno = SM_I(sbi)->segment_count - 1; 686 ASSERT(segno <= end_segno); 687} 688 689static struct f2fs_sit_block *get_current_sit_page(struct f2fs_sb_info *sbi, 690 unsigned int segno) 691{ 692 struct sit_info *sit_i = SIT_I(sbi); 693 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno); 694 block_t blk_addr = sit_i->sit_base_addr + offset; 695 struct f2fs_sit_block *sit_blk = calloc(BLOCK_SZ, 1); 696 int ret; 697 698 check_seg_range(sbi, segno); 699 700 /* calculate sit block address */ 701 if (f2fs_test_bit(offset, sit_i->sit_bitmap)) 702 blk_addr += sit_i->sit_blocks; 703 704 ret = dev_read_block(sit_blk, blk_addr); 705 ASSERT(ret >= 0); 706 707 return sit_blk; 708} 709 710void rewrite_current_sit_page(struct f2fs_sb_info *sbi, 711 unsigned int segno, struct f2fs_sit_block *sit_blk) 712{ 713 struct sit_info *sit_i = SIT_I(sbi); 714 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno); 715 block_t blk_addr = sit_i->sit_base_addr + offset; 716 int ret; 717 718 /* calculate sit block address */ 719 if (f2fs_test_bit(offset, sit_i->sit_bitmap)) 720 blk_addr += sit_i->sit_blocks; 721 722 ret = dev_write_block(sit_blk, blk_addr); 723 ASSERT(ret >= 0); 724} 725 726void check_block_count(struct f2fs_sb_info *sbi, 727 unsigned int segno, struct f2fs_sit_entry *raw_sit) 728{ 729 struct f2fs_sm_info *sm_info = SM_I(sbi); 730 unsigned int end_segno = sm_info->segment_count - 1; 731 int valid_blocks = 0; 732 unsigned int i; 733 734 /* check segment usage */ 735 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg) 736 ASSERT_MSG("Invalid SIT vblocks: segno=0x%x, %u", 737 segno, GET_SIT_VBLOCKS(raw_sit)); 738 739 /* check boundary of a given segment number */ 740 if (segno > end_segno) 741 ASSERT_MSG("Invalid SEGNO: 0x%x", segno); 742 743 /* check bitmap with valid block count */ 744 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++) 745 valid_blocks += get_bits_in_byte(raw_sit->valid_map[i]); 746 747 if (GET_SIT_VBLOCKS(raw_sit) != valid_blocks) 748 ASSERT_MSG("Wrong SIT valid blocks: segno=0x%x, %u vs. %u", 749 segno, GET_SIT_VBLOCKS(raw_sit), valid_blocks); 750 751 if (GET_SIT_TYPE(raw_sit) >= NO_CHECK_TYPE) 752 ASSERT_MSG("Wrong SIT type: segno=0x%x, %u", 753 segno, GET_SIT_TYPE(raw_sit)); 754} 755 756void seg_info_from_raw_sit(struct seg_entry *se, 757 struct f2fs_sit_entry *raw_sit) 758{ 759 se->valid_blocks = GET_SIT_VBLOCKS(raw_sit); 760 se->ckpt_valid_blocks = GET_SIT_VBLOCKS(raw_sit); 761 memcpy(se->cur_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE); 762 memcpy(se->ckpt_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE); 763 se->type = GET_SIT_TYPE(raw_sit); 764 se->mtime = le64_to_cpu(raw_sit->mtime); 765} 766 767struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi, 768 unsigned int segno) 769{ 770 struct sit_info *sit_i = SIT_I(sbi); 771 return &sit_i->sentries[segno]; 772} 773 774int get_sum_block(struct f2fs_sb_info *sbi, unsigned int segno, 775 struct f2fs_summary_block *sum_blk) 776{ 777 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 778 struct curseg_info *curseg; 779 int type, ret; 780 u64 ssa_blk; 781 782 ssa_blk = GET_SUM_BLKADDR(sbi, segno); 783 for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { 784 if (segno == ckpt->cur_node_segno[type]) { 785 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); 786 if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { 787 ASSERT_MSG("segno [0x%x] indicates a data " 788 "segment, but should be node", 789 segno); 790 return -EINVAL; 791 } 792 memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ); 793 return SEG_TYPE_CUR_NODE; 794 } 795 } 796 797 for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { 798 if (segno == ckpt->cur_data_segno[type]) { 799 curseg = CURSEG_I(sbi, type); 800 if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { 801 ASSERT_MSG("segno [0x%x] indicates a node " 802 "segment, but should be data", 803 segno); 804 return -EINVAL; 805 } 806 DBG(2, "segno [0x%x] is current data seg[0x%x]\n", 807 segno, type); 808 memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ); 809 return SEG_TYPE_CUR_DATA; 810 } 811 } 812 813 ret = dev_read_block(sum_blk, ssa_blk); 814 ASSERT(ret >= 0); 815 816 if (IS_SUM_NODE_SEG(sum_blk->footer)) 817 return SEG_TYPE_NODE; 818 else 819 return SEG_TYPE_DATA; 820 821} 822 823int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr, 824 struct f2fs_summary *sum_entry) 825{ 826 struct f2fs_summary_block *sum_blk; 827 u32 segno, offset; 828 int ret; 829 830 segno = GET_SEGNO(sbi, blk_addr); 831 offset = OFFSET_IN_SEG(sbi, blk_addr); 832 833 sum_blk = calloc(BLOCK_SZ, 1); 834 835 ret = get_sum_block(sbi, segno, sum_blk); 836 memcpy(sum_entry, &(sum_blk->entries[offset]), 837 sizeof(struct f2fs_summary)); 838 free(sum_blk); 839 return ret; 840} 841 842static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid, 843 struct f2fs_nat_entry *raw_nat) 844{ 845 struct f2fs_nm_info *nm_i = NM_I(sbi); 846 struct f2fs_nat_block *nat_block; 847 pgoff_t block_off; 848 pgoff_t block_addr; 849 int seg_off, entry_off; 850 int ret; 851 852 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0) 853 return; 854 855 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 856 857 block_off = nid / NAT_ENTRY_PER_BLOCK; 858 entry_off = nid % NAT_ENTRY_PER_BLOCK; 859 860 seg_off = block_off >> sbi->log_blocks_per_seg; 861 block_addr = (pgoff_t)(nm_i->nat_blkaddr + 862 (seg_off << sbi->log_blocks_per_seg << 1) + 863 (block_off & ((1 << sbi->log_blocks_per_seg) - 1))); 864 865 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) 866 block_addr += sbi->blocks_per_seg; 867 868 ret = dev_read_block(nat_block, block_addr); 869 ASSERT(ret >= 0); 870 871 memcpy(raw_nat, &nat_block->entries[entry_off], 872 sizeof(struct f2fs_nat_entry)); 873 free(nat_block); 874} 875 876void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni) 877{ 878 struct f2fs_nat_entry raw_nat; 879 get_nat_entry(sbi, nid, &raw_nat); 880 ni->nid = nid; 881 node_info_from_raw_nat(ni, &raw_nat); 882} 883 884void build_sit_entries(struct f2fs_sb_info *sbi) 885{ 886 struct sit_info *sit_i = SIT_I(sbi); 887 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 888 struct f2fs_summary_block *sum = curseg->sum_blk; 889 unsigned int segno; 890 891 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 892 struct seg_entry *se = &sit_i->sentries[segno]; 893 struct f2fs_sit_block *sit_blk; 894 struct f2fs_sit_entry sit; 895 int i; 896 897 for (i = 0; i < sits_in_cursum(sum); i++) { 898 if (le32_to_cpu(segno_in_journal(sum, i)) == segno) { 899 sit = sit_in_journal(sum, i); 900 goto got_it; 901 } 902 } 903 sit_blk = get_current_sit_page(sbi, segno); 904 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 905 free(sit_blk); 906got_it: 907 check_block_count(sbi, segno, &sit); 908 seg_info_from_raw_sit(se, &sit); 909 } 910 911} 912 913int build_segment_manager(struct f2fs_sb_info *sbi) 914{ 915 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 916 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 917 struct f2fs_sm_info *sm_info; 918 919 sm_info = malloc(sizeof(struct f2fs_sm_info)); 920 if (!sm_info) 921 return -ENOMEM; 922 923 /* init sm info */ 924 sbi->sm_info = sm_info; 925 sm_info->seg0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr); 926 sm_info->main_blkaddr = le32_to_cpu(raw_super->main_blkaddr); 927 sm_info->segment_count = le32_to_cpu(raw_super->segment_count); 928 sm_info->reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count); 929 sm_info->ovp_segments = le32_to_cpu(ckpt->overprov_segment_count); 930 sm_info->main_segments = le32_to_cpu(raw_super->segment_count_main); 931 sm_info->ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr); 932 933 build_sit_info(sbi); 934 935 build_curseg(sbi); 936 937 build_sit_entries(sbi); 938 939 return 0; 940} 941 942void build_sit_area_bitmap(struct f2fs_sb_info *sbi) 943{ 944 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 945 struct f2fs_sm_info *sm_i = SM_I(sbi); 946 unsigned int segno = 0; 947 char *ptr = NULL; 948 u32 sum_vblocks = 0; 949 u32 free_segs = 0; 950 struct seg_entry *se; 951 952 fsck->sit_area_bitmap_sz = sm_i->main_segments * SIT_VBLOCK_MAP_SIZE; 953 fsck->sit_area_bitmap = calloc(1, fsck->sit_area_bitmap_sz); 954 ptr = fsck->sit_area_bitmap; 955 956 ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz); 957 958 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 959 se = get_seg_entry(sbi, segno); 960 961 memcpy(ptr, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 962 ptr += SIT_VBLOCK_MAP_SIZE; 963 964 if (se->valid_blocks == 0x0) { 965 if (sbi->ckpt->cur_node_segno[0] == segno || 966 sbi->ckpt->cur_data_segno[0] == segno || 967 sbi->ckpt->cur_node_segno[1] == segno || 968 sbi->ckpt->cur_data_segno[1] == segno || 969 sbi->ckpt->cur_node_segno[2] == segno || 970 sbi->ckpt->cur_data_segno[2] == segno) { 971 continue; 972 } else { 973 free_segs++; 974 } 975 } else { 976 sum_vblocks += se->valid_blocks; 977 } 978 } 979 fsck->chk.sit_valid_blocks = sum_vblocks; 980 fsck->chk.sit_free_segs = free_segs; 981 982 DBG(1, "Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n", 983 sum_vblocks, sum_vblocks, 984 free_segs, free_segs); 985} 986 987void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi) 988{ 989 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 990 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 991 struct sit_info *sit_i = SIT_I(sbi); 992 unsigned int segno = 0; 993 struct f2fs_summary_block *sum = curseg->sum_blk; 994 char *ptr = NULL; 995 996 /* remove sit journal */ 997 sum->n_sits = 0; 998 999 fsck->chk.free_segs = 0; 1000 1001 ptr = fsck->main_area_bitmap; 1002 1003 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 1004 struct f2fs_sit_block *sit_blk; 1005 struct f2fs_sit_entry *sit; 1006 struct seg_entry *se; 1007 u16 valid_blocks = 0; 1008 u16 type; 1009 int i; 1010 1011 sit_blk = get_current_sit_page(sbi, segno); 1012 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 1013 memcpy(sit->valid_map, ptr, SIT_VBLOCK_MAP_SIZE); 1014 1015 /* update valid block count */ 1016 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++) 1017 valid_blocks += get_bits_in_byte(sit->valid_map[i]); 1018 1019 se = get_seg_entry(sbi, segno); 1020 type = se->type; 1021 if (type >= NO_CHECK_TYPE) { 1022 ASSERT(valid_blocks); 1023 type = 0; 1024 } 1025 sit->vblocks = cpu_to_le16((type << SIT_VBLOCKS_SHIFT) | 1026 valid_blocks); 1027 rewrite_current_sit_page(sbi, segno, sit_blk); 1028 free(sit_blk); 1029 1030 if (valid_blocks == 0 && 1031 sbi->ckpt->cur_node_segno[0] != segno && 1032 sbi->ckpt->cur_data_segno[0] != segno && 1033 sbi->ckpt->cur_node_segno[1] != segno && 1034 sbi->ckpt->cur_data_segno[1] != segno && 1035 sbi->ckpt->cur_node_segno[2] != segno && 1036 sbi->ckpt->cur_data_segno[2] != segno) 1037 fsck->chk.free_segs++; 1038 1039 ptr += SIT_VBLOCK_MAP_SIZE; 1040 } 1041} 1042 1043int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid, 1044 struct f2fs_nat_entry *raw_nat) 1045{ 1046 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1047 struct f2fs_summary_block *sum = curseg->sum_blk; 1048 int i = 0; 1049 1050 for (i = 0; i < nats_in_cursum(sum); i++) { 1051 if (le32_to_cpu(nid_in_journal(sum, i)) == nid) { 1052 memcpy(raw_nat, &nat_in_journal(sum, i), 1053 sizeof(struct f2fs_nat_entry)); 1054 DBG(3, "==> Found nid [0x%x] in nat cache\n", nid); 1055 return i; 1056 } 1057 } 1058 return -1; 1059} 1060 1061void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid) 1062{ 1063 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1064 struct f2fs_summary_block *sum = curseg->sum_blk; 1065 struct f2fs_nm_info *nm_i = NM_I(sbi); 1066 struct f2fs_nat_block *nat_block; 1067 pgoff_t block_off; 1068 pgoff_t block_addr; 1069 int seg_off, entry_off; 1070 int ret; 1071 int i = 0; 1072 1073 /* check in journal */ 1074 for (i = 0; i < nats_in_cursum(sum); i++) { 1075 if (le32_to_cpu(nid_in_journal(sum, i)) == nid) { 1076 memset(&nat_in_journal(sum, i), 0, 1077 sizeof(struct f2fs_nat_entry)); 1078 FIX_MSG("Remove nid [0x%x] in nat journal\n", nid); 1079 return; 1080 } 1081 } 1082 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 1083 1084 block_off = nid / NAT_ENTRY_PER_BLOCK; 1085 entry_off = nid % NAT_ENTRY_PER_BLOCK; 1086 1087 seg_off = block_off >> sbi->log_blocks_per_seg; 1088 block_addr = (pgoff_t)(nm_i->nat_blkaddr + 1089 (seg_off << sbi->log_blocks_per_seg << 1) + 1090 (block_off & ((1 << sbi->log_blocks_per_seg) - 1))); 1091 1092 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) 1093 block_addr += sbi->blocks_per_seg; 1094 1095 ret = dev_read_block(nat_block, block_addr); 1096 ASSERT(ret >= 0); 1097 1098 memset(&nat_block->entries[entry_off], 0, 1099 sizeof(struct f2fs_nat_entry)); 1100 1101 ret = dev_write_block(nat_block, block_addr); 1102 ASSERT(ret >= 0); 1103 free(nat_block); 1104} 1105 1106void build_nat_area_bitmap(struct f2fs_sb_info *sbi) 1107{ 1108 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 1109 struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi); 1110 struct f2fs_nm_info *nm_i = NM_I(sbi); 1111 struct f2fs_nat_block *nat_block; 1112 u32 nid, nr_nat_blks; 1113 pgoff_t block_off; 1114 pgoff_t block_addr; 1115 int seg_off; 1116 int ret; 1117 unsigned int i; 1118 1119 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 1120 ASSERT(nat_block); 1121 1122 /* Alloc & build nat entry bitmap */ 1123 nr_nat_blks = (le32_to_cpu(raw_sb->segment_count_nat) / 2) << 1124 sbi->log_blocks_per_seg; 1125 1126 fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; 1127 fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8; 1128 fsck->nat_area_bitmap = calloc(fsck->nat_area_bitmap_sz, 1); 1129 ASSERT(fsck->nat_area_bitmap != NULL); 1130 1131 for (block_off = 0; block_off < nr_nat_blks; block_off++) { 1132 1133 seg_off = block_off >> sbi->log_blocks_per_seg; 1134 block_addr = (pgoff_t)(nm_i->nat_blkaddr + 1135 (seg_off << sbi->log_blocks_per_seg << 1) + 1136 (block_off & ((1 << sbi->log_blocks_per_seg) - 1))); 1137 1138 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) 1139 block_addr += sbi->blocks_per_seg; 1140 1141 ret = dev_read_block(nat_block, block_addr); 1142 ASSERT(ret >= 0); 1143 1144 nid = block_off * NAT_ENTRY_PER_BLOCK; 1145 for (i = 0; i < NAT_ENTRY_PER_BLOCK; i++) { 1146 struct f2fs_nat_entry raw_nat; 1147 struct node_info ni; 1148 ni.nid = nid + i; 1149 1150 if ((nid + i) == F2FS_NODE_INO(sbi) || 1151 (nid + i) == F2FS_META_INO(sbi)) { 1152 ASSERT(nat_block->entries[i].block_addr != 0x0); 1153 continue; 1154 } 1155 1156 if (lookup_nat_in_journal(sbi, nid + i, 1157 &raw_nat) >= 0) { 1158 node_info_from_raw_nat(&ni, &raw_nat); 1159 if (ni.blk_addr != 0x0) { 1160 f2fs_set_bit(nid + i, 1161 fsck->nat_area_bitmap); 1162 fsck->chk.valid_nat_entry_cnt++; 1163 DBG(3, "nid[0x%x] in nat cache\n", 1164 nid + i); 1165 } 1166 } else { 1167 node_info_from_raw_nat(&ni, 1168 &nat_block->entries[i]); 1169 if (ni.blk_addr == 0) 1170 continue; 1171 ASSERT(nid + i != 0x0); 1172 1173 DBG(3, "nid[0x%8x] addr[0x%16x] ino[0x%8x]\n", 1174 nid + i, ni.blk_addr, ni.ino); 1175 f2fs_set_bit(nid + i, fsck->nat_area_bitmap); 1176 fsck->chk.valid_nat_entry_cnt++; 1177 } 1178 } 1179 } 1180 free(nat_block); 1181 1182 DBG(1, "valid nat entries (block_addr != 0x0) [0x%8x : %u]\n", 1183 fsck->chk.valid_nat_entry_cnt, 1184 fsck->chk.valid_nat_entry_cnt); 1185} 1186 1187int f2fs_do_mount(struct f2fs_sb_info *sbi) 1188{ 1189 int ret; 1190 sbi->active_logs = NR_CURSEG_TYPE; 1191 ret = validate_super_block(sbi, 0); 1192 if (ret) { 1193 ret = validate_super_block(sbi, 1); 1194 if (ret) 1195 return -1; 1196 } 1197 1198 print_raw_sb_info(sbi); 1199 1200 init_sb_info(sbi); 1201 1202 ret = get_valid_checkpoint(sbi); 1203 if (ret) { 1204 ERR_MSG("Can't find valid checkpoint\n"); 1205 return -1; 1206 } 1207 1208 if (sanity_check_ckpt(sbi)) { 1209 ERR_MSG("Checkpoint is polluted\n"); 1210 return -1; 1211 } 1212 1213 print_ckpt_info(sbi); 1214 1215 sbi->total_valid_node_count = le32_to_cpu(sbi->ckpt->valid_node_count); 1216 sbi->total_valid_inode_count = 1217 le32_to_cpu(sbi->ckpt->valid_inode_count); 1218 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count); 1219 sbi->total_valid_block_count = 1220 le64_to_cpu(sbi->ckpt->valid_block_count); 1221 sbi->last_valid_block_count = sbi->total_valid_block_count; 1222 sbi->alloc_valid_block_count = 0; 1223 1224 if (build_segment_manager(sbi)) { 1225 ERR_MSG("build_segment_manager failed\n"); 1226 return -1; 1227 } 1228 1229 if (build_node_manager(sbi)) { 1230 ERR_MSG("build_segment_manager failed\n"); 1231 return -1; 1232 } 1233 1234 return ret; 1235} 1236 1237void f2fs_do_umount(struct f2fs_sb_info *sbi) 1238{ 1239 struct sit_info *sit_i = SIT_I(sbi); 1240 struct f2fs_sm_info *sm_i = SM_I(sbi); 1241 struct f2fs_nm_info *nm_i = NM_I(sbi); 1242 unsigned int i; 1243 1244 /* free nm_info */ 1245 free(nm_i->nat_bitmap); 1246 free(sbi->nm_info); 1247 1248 /* free sit_info */ 1249 for (i = 0; i < TOTAL_SEGS(sbi); i++) { 1250 free(sit_i->sentries[i].cur_valid_map); 1251 free(sit_i->sentries[i].ckpt_valid_map); 1252 } 1253 free(sit_i->sit_bitmap); 1254 free(sm_i->sit_info); 1255 1256 /* free sm_info */ 1257 for (i = 0; i < NR_CURSEG_TYPE; i++) 1258 free(sm_i->curseg_array[i].sum_blk); 1259 1260 free(sm_i->curseg_array); 1261 free(sbi->sm_info); 1262 1263 free(sbi->ckpt); 1264 free(sbi->raw_super); 1265} 1266