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