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 "node.h" 13 #include "xattr.h" 14 #include <locale.h> 15 #include <stdbool.h> 16 #ifdef HAVE_LINUX_POSIX_ACL_H 17 #include <linux/posix_acl.h> 18 #endif 19 #ifdef HAVE_SYS_ACL_H 20 #include <sys/acl.h> 21 #endif 22 23 #ifndef ACL_UNDEFINED_TAG 24 #define ACL_UNDEFINED_TAG (0x00) 25 #define ACL_USER_OBJ (0x01) 26 #define ACL_USER (0x02) 27 #define ACL_GROUP_OBJ (0x04) 28 #define ACL_GROUP (0x08) 29 #define ACL_MASK (0x10) 30 #define ACL_OTHER (0x20) 31 #endif 32 33 u32 get_free_segments(struct f2fs_sb_info *sbi) 34 { 35 u32 i, free_segs = 0; 36 37 for (i = 0; i < TOTAL_SEGS(sbi); i++) { 38 struct seg_entry *se = get_seg_entry(sbi, i); 39 40 if (se->valid_blocks == 0x0 && !IS_CUR_SEGNO(sbi, i)) 41 free_segs++; 42 } 43 return free_segs; 44 } 45 46 void update_free_segments(struct f2fs_sb_info *sbi) 47 { 48 char *progress = "-*|*-"; 49 static int i = 0; 50 51 if (c.dbg_lv) 52 return; 53 54 MSG(0, "\r [ %c ] Free segments: 0x%x", progress[i % 5], get_free_segments(sbi)); 55 fflush(stdout); 56 i++; 57 } 58 59 #if defined(HAVE_LINUX_POSIX_ACL_H) || defined(HAVE_SYS_ACL_H) 60 static void print_acl(const u8 *value, int size) 61 { 62 const struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value; 63 const struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1); 64 const u8 *end = value + size; 65 int i, count; 66 67 if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION)) { 68 MSG(0, "Invalid ACL version [0x%x : 0x%x]\n", 69 le32_to_cpu(hdr->a_version), F2FS_ACL_VERSION); 70 return; 71 } 72 73 count = f2fs_acl_count(size); 74 if (count <= 0) { 75 MSG(0, "Invalid ACL value size %d\n", size); 76 return; 77 } 78 79 for (i = 0; i < count; i++) { 80 if ((u8 *)entry > end) { 81 MSG(0, "Invalid ACL entries count %d\n", count); 82 return; 83 } 84 85 switch (le16_to_cpu(entry->e_tag)) { 86 case ACL_USER_OBJ: 87 case ACL_GROUP_OBJ: 88 case ACL_MASK: 89 case ACL_OTHER: 90 MSG(0, "tag:0x%x perm:0x%x\n", 91 le16_to_cpu(entry->e_tag), 92 le16_to_cpu(entry->e_perm)); 93 entry = (struct f2fs_acl_entry *)((char *)entry + 94 sizeof(struct f2fs_acl_entry_short)); 95 break; 96 case ACL_USER: 97 MSG(0, "tag:0x%x perm:0x%x uid:%u\n", 98 le16_to_cpu(entry->e_tag), 99 le16_to_cpu(entry->e_perm), 100 le32_to_cpu(entry->e_id)); 101 entry = (struct f2fs_acl_entry *)((char *)entry + 102 sizeof(struct f2fs_acl_entry)); 103 break; 104 case ACL_GROUP: 105 MSG(0, "tag:0x%x perm:0x%x gid:%u\n", 106 le16_to_cpu(entry->e_tag), 107 le16_to_cpu(entry->e_perm), 108 le32_to_cpu(entry->e_id)); 109 entry = (struct f2fs_acl_entry *)((char *)entry + 110 sizeof(struct f2fs_acl_entry)); 111 break; 112 default: 113 MSG(0, "Unknown ACL tag 0x%x\n", 114 le16_to_cpu(entry->e_tag)); 115 return; 116 } 117 } 118 } 119 #endif /* HAVE_LINUX_POSIX_ACL_H || HAVE_SYS_ACL_H */ 120 121 static void print_xattr_entry(const struct f2fs_xattr_entry *ent) 122 { 123 const u8 *value = (const u8 *)&ent->e_name[ent->e_name_len]; 124 const int size = le16_to_cpu(ent->e_value_size); 125 const struct fscrypt_context *ctx; 126 int i; 127 128 MSG(0, "\nxattr: e_name_index:%d e_name:", ent->e_name_index); 129 for (i = 0; i < ent->e_name_len; i++) 130 MSG(0, "%c", ent->e_name[i]); 131 MSG(0, " e_name_len:%d e_value_size:%d e_value:\n", 132 ent->e_name_len, size); 133 134 switch (ent->e_name_index) { 135 #if defined(HAVE_LINUX_POSIX_ACL_H) || defined(HAVE_SYS_ACL_H) 136 case F2FS_XATTR_INDEX_POSIX_ACL_ACCESS: 137 case F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT: 138 print_acl(value, size); 139 return; 140 #endif 141 case F2FS_XATTR_INDEX_ENCRYPTION: 142 ctx = (const struct fscrypt_context *)value; 143 if (size != sizeof(*ctx) || 144 ctx->format != FS_ENCRYPTION_CONTEXT_FORMAT_V1) 145 break; 146 MSG(0, "format: %d\n", ctx->format); 147 MSG(0, "contents_encryption_mode: 0x%x\n", ctx->contents_encryption_mode); 148 MSG(0, "filenames_encryption_mode: 0x%x\n", ctx->filenames_encryption_mode); 149 MSG(0, "flags: 0x%x\n", ctx->flags); 150 MSG(0, "master_key_descriptor: "); 151 for (i = 0; i < FS_KEY_DESCRIPTOR_SIZE; i++) 152 MSG(0, "%02X", ctx->master_key_descriptor[i]); 153 MSG(0, "\nnonce: "); 154 for (i = 0; i < FS_KEY_DERIVATION_NONCE_SIZE; i++) 155 MSG(0, "%02X", ctx->nonce[i]); 156 MSG(0, "\n"); 157 return; 158 } 159 for (i = 0; i < size; i++) 160 MSG(0, "%02X", value[i]); 161 MSG(0, "\n"); 162 } 163 164 void print_inode_info(struct f2fs_sb_info *sbi, 165 struct f2fs_node *node, int name) 166 { 167 struct f2fs_inode *inode = &node->i; 168 void *xattr_addr; 169 struct f2fs_xattr_entry *ent; 170 char en[F2FS_PRINT_NAMELEN]; 171 unsigned int i = 0; 172 u32 namelen = le32_to_cpu(inode->i_namelen); 173 int enc_name = file_enc_name(inode); 174 int ofs = get_extra_isize(node); 175 176 pretty_print_filename(inode->i_name, namelen, en, enc_name); 177 if (name && en[0]) { 178 MSG(0, " - File name : %s%s\n", en, 179 enc_name ? " <encrypted>" : ""); 180 setlocale(LC_ALL, ""); 181 MSG(0, " - File size : %'llu (bytes)\n", 182 le64_to_cpu(inode->i_size)); 183 return; 184 } 185 186 DISP_u32(inode, i_mode); 187 DISP_u32(inode, i_advise); 188 DISP_u32(inode, i_uid); 189 DISP_u32(inode, i_gid); 190 DISP_u32(inode, i_links); 191 DISP_u64(inode, i_size); 192 DISP_u64(inode, i_blocks); 193 194 DISP_u64(inode, i_atime); 195 DISP_u32(inode, i_atime_nsec); 196 DISP_u64(inode, i_ctime); 197 DISP_u32(inode, i_ctime_nsec); 198 DISP_u64(inode, i_mtime); 199 DISP_u32(inode, i_mtime_nsec); 200 201 DISP_u32(inode, i_generation); 202 DISP_u32(inode, i_current_depth); 203 DISP_u32(inode, i_xattr_nid); 204 DISP_u32(inode, i_flags); 205 DISP_u32(inode, i_inline); 206 DISP_u32(inode, i_pino); 207 DISP_u32(inode, i_dir_level); 208 209 if (en[0]) { 210 DISP_u32(inode, i_namelen); 211 printf("%-30s\t\t[%s]\n", "i_name", en); 212 } 213 214 printf("i_ext: fofs:%x blkaddr:%x len:%x\n", 215 le32_to_cpu(inode->i_ext.fofs), 216 le32_to_cpu(inode->i_ext.blk_addr), 217 le32_to_cpu(inode->i_ext.len)); 218 219 if (c.feature & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) { 220 DISP_u16(inode, i_extra_isize); 221 if (c.feature & cpu_to_le32(F2FS_FEATURE_FLEXIBLE_INLINE_XATTR)) 222 DISP_u16(inode, i_inline_xattr_size); 223 if (c.feature & cpu_to_le32(F2FS_FEATURE_PRJQUOTA)) 224 DISP_u32(inode, i_projid); 225 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM)) 226 DISP_u32(inode, i_inode_checksum); 227 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CRTIME)) { 228 DISP_u64(inode, i_crtime); 229 DISP_u32(inode, i_crtime_nsec); 230 } 231 if (c.feature & cpu_to_le32(F2FS_FEATURE_COMPRESSION)) { 232 DISP_u64(inode, i_compr_blocks); 233 DISP_u32(inode, i_compress_algrithm); 234 DISP_u32(inode, i_log_cluster_size); 235 DISP_u32(inode, i_padding); 236 } 237 } 238 239 for (i = 0; i < ADDRS_PER_INODE(inode); i++) { 240 block_t blkaddr; 241 char *flag = ""; 242 243 if (i + ofs >= DEF_ADDRS_PER_INODE) 244 break; 245 246 blkaddr = le32_to_cpu(inode->i_addr[i + ofs]); 247 248 if (blkaddr == 0x0) 249 continue; 250 if (blkaddr == COMPRESS_ADDR) 251 flag = "cluster flag"; 252 else if (blkaddr == NEW_ADDR) 253 flag = "reserved flag"; 254 printf("i_addr[0x%x] %-16s\t\t[0x%8x : %u]\n", i + ofs, flag, 255 blkaddr, blkaddr); 256 } 257 258 DISP_u32(inode, i_nid[0]); /* direct */ 259 DISP_u32(inode, i_nid[1]); /* direct */ 260 DISP_u32(inode, i_nid[2]); /* indirect */ 261 DISP_u32(inode, i_nid[3]); /* indirect */ 262 DISP_u32(inode, i_nid[4]); /* double indirect */ 263 264 xattr_addr = read_all_xattrs(sbi, node); 265 if (xattr_addr) { 266 list_for_each_xattr(ent, xattr_addr) { 267 print_xattr_entry(ent); 268 } 269 free(xattr_addr); 270 } 271 272 printf("\n"); 273 } 274 275 void print_node_info(struct f2fs_sb_info *sbi, 276 struct f2fs_node *node_block, int verbose) 277 { 278 nid_t ino = le32_to_cpu(node_block->footer.ino); 279 nid_t nid = le32_to_cpu(node_block->footer.nid); 280 /* Is this inode? */ 281 if (ino == nid) { 282 DBG(verbose, "Node ID [0x%x:%u] is inode\n", nid, nid); 283 print_inode_info(sbi, node_block, verbose); 284 } else { 285 int i; 286 u32 *dump_blk = (u32 *)node_block; 287 DBG(verbose, 288 "Node ID [0x%x:%u] is direct node or indirect node.\n", 289 nid, nid); 290 for (i = 0; i < DEF_ADDRS_PER_BLOCK; i++) 291 MSG(verbose, "[%d]\t\t\t[0x%8x : %d]\n", 292 i, dump_blk[i], dump_blk[i]); 293 } 294 } 295 296 static void DISP_label(u_int16_t *name) 297 { 298 char buffer[MAX_VOLUME_NAME]; 299 300 utf16_to_utf8(buffer, name, MAX_VOLUME_NAME, MAX_VOLUME_NAME); 301 printf("%-30s" "\t\t[%s]\n", "volum_name", buffer); 302 } 303 304 void print_raw_sb_info(struct f2fs_super_block *sb) 305 { 306 if (!c.dbg_lv) 307 return; 308 309 printf("\n"); 310 printf("+--------------------------------------------------------+\n"); 311 printf("| Super block |\n"); 312 printf("+--------------------------------------------------------+\n"); 313 314 DISP_u32(sb, magic); 315 DISP_u32(sb, major_ver); 316 317 DISP_label(sb->volume_name); 318 319 DISP_u32(sb, minor_ver); 320 DISP_u32(sb, log_sectorsize); 321 DISP_u32(sb, log_sectors_per_block); 322 323 DISP_u32(sb, log_blocksize); 324 DISP_u32(sb, log_blocks_per_seg); 325 DISP_u32(sb, segs_per_sec); 326 DISP_u32(sb, secs_per_zone); 327 DISP_u32(sb, checksum_offset); 328 DISP_u64(sb, block_count); 329 330 DISP_u32(sb, section_count); 331 DISP_u32(sb, segment_count); 332 DISP_u32(sb, segment_count_ckpt); 333 DISP_u32(sb, segment_count_sit); 334 DISP_u32(sb, segment_count_nat); 335 336 DISP_u32(sb, segment_count_ssa); 337 DISP_u32(sb, segment_count_main); 338 DISP_u32(sb, segment0_blkaddr); 339 340 DISP_u32(sb, cp_blkaddr); 341 DISP_u32(sb, sit_blkaddr); 342 DISP_u32(sb, nat_blkaddr); 343 DISP_u32(sb, ssa_blkaddr); 344 DISP_u32(sb, main_blkaddr); 345 346 DISP_u32(sb, root_ino); 347 DISP_u32(sb, node_ino); 348 DISP_u32(sb, meta_ino); 349 DISP_u32(sb, cp_payload); 350 DISP_u32(sb, crc); 351 DISP("%-.256s", sb, version); 352 printf("\n"); 353 } 354 355 void print_ckpt_info(struct f2fs_sb_info *sbi) 356 { 357 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 358 359 if (!c.dbg_lv) 360 return; 361 362 printf("\n"); 363 printf("+--------------------------------------------------------+\n"); 364 printf("| Checkpoint |\n"); 365 printf("+--------------------------------------------------------+\n"); 366 367 DISP_u64(cp, checkpoint_ver); 368 DISP_u64(cp, user_block_count); 369 DISP_u64(cp, valid_block_count); 370 DISP_u32(cp, rsvd_segment_count); 371 DISP_u32(cp, overprov_segment_count); 372 DISP_u32(cp, free_segment_count); 373 374 DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]); 375 DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]); 376 DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]); 377 DISP_u32(cp, cur_node_segno[0]); 378 DISP_u32(cp, cur_node_segno[1]); 379 DISP_u32(cp, cur_node_segno[2]); 380 381 DISP_u32(cp, cur_node_blkoff[0]); 382 DISP_u32(cp, cur_node_blkoff[1]); 383 DISP_u32(cp, cur_node_blkoff[2]); 384 385 386 DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]); 387 DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]); 388 DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]); 389 DISP_u32(cp, cur_data_segno[0]); 390 DISP_u32(cp, cur_data_segno[1]); 391 DISP_u32(cp, cur_data_segno[2]); 392 393 DISP_u32(cp, cur_data_blkoff[0]); 394 DISP_u32(cp, cur_data_blkoff[1]); 395 DISP_u32(cp, cur_data_blkoff[2]); 396 397 DISP_u32(cp, ckpt_flags); 398 DISP_u32(cp, cp_pack_total_block_count); 399 DISP_u32(cp, cp_pack_start_sum); 400 DISP_u32(cp, valid_node_count); 401 DISP_u32(cp, valid_inode_count); 402 DISP_u32(cp, next_free_nid); 403 DISP_u32(cp, sit_ver_bitmap_bytesize); 404 DISP_u32(cp, nat_ver_bitmap_bytesize); 405 DISP_u32(cp, checksum_offset); 406 DISP_u64(cp, elapsed_time); 407 408 DISP_u32(cp, sit_nat_version_bitmap[0]); 409 printf("\n\n"); 410 } 411 412 void print_cp_state(u32 flag) 413 { 414 MSG(0, "Info: checkpoint state = %x : ", flag); 415 if (flag & CP_QUOTA_NEED_FSCK_FLAG) 416 MSG(0, "%s", " quota_need_fsck"); 417 if (flag & CP_LARGE_NAT_BITMAP_FLAG) 418 MSG(0, "%s", " large_nat_bitmap"); 419 if (flag & CP_NOCRC_RECOVERY_FLAG) 420 MSG(0, "%s", " allow_nocrc"); 421 if (flag & CP_TRIMMED_FLAG) 422 MSG(0, "%s", " trimmed"); 423 if (flag & CP_NAT_BITS_FLAG) 424 MSG(0, "%s", " nat_bits"); 425 if (flag & CP_CRC_RECOVERY_FLAG) 426 MSG(0, "%s", " crc"); 427 if (flag & CP_FASTBOOT_FLAG) 428 MSG(0, "%s", " fastboot"); 429 if (flag & CP_FSCK_FLAG) 430 MSG(0, "%s", " fsck"); 431 if (flag & CP_ERROR_FLAG) 432 MSG(0, "%s", " error"); 433 if (flag & CP_COMPACT_SUM_FLAG) 434 MSG(0, "%s", " compacted_summary"); 435 if (flag & CP_ORPHAN_PRESENT_FLAG) 436 MSG(0, "%s", " orphan_inodes"); 437 if (flag & CP_DISABLED_FLAG) 438 MSG(0, "%s", " disabled"); 439 if (flag & CP_RESIZEFS_FLAG) 440 MSG(0, "%s", " resizefs"); 441 if (flag & CP_UMOUNT_FLAG) 442 MSG(0, "%s", " unmount"); 443 else 444 MSG(0, "%s", " sudden-power-off"); 445 MSG(0, "\n"); 446 } 447 448 void print_sb_state(struct f2fs_super_block *sb) 449 { 450 __le32 f = sb->feature; 451 int i; 452 453 MSG(0, "Info: superblock features = %x : ", f); 454 if (f & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) { 455 MSG(0, "%s", " encrypt"); 456 } 457 if (f & cpu_to_le32(F2FS_FEATURE_VERITY)) { 458 MSG(0, "%s", " verity"); 459 } 460 if (f & cpu_to_le32(F2FS_FEATURE_BLKZONED)) { 461 MSG(0, "%s", " blkzoned"); 462 } 463 if (f & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) { 464 MSG(0, "%s", " extra_attr"); 465 } 466 if (f & cpu_to_le32(F2FS_FEATURE_PRJQUOTA)) { 467 MSG(0, "%s", " project_quota"); 468 } 469 if (f & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM)) { 470 MSG(0, "%s", " inode_checksum"); 471 } 472 if (f & cpu_to_le32(F2FS_FEATURE_FLEXIBLE_INLINE_XATTR)) { 473 MSG(0, "%s", " flexible_inline_xattr"); 474 } 475 if (f & cpu_to_le32(F2FS_FEATURE_QUOTA_INO)) { 476 MSG(0, "%s", " quota_ino"); 477 } 478 if (f & cpu_to_le32(F2FS_FEATURE_INODE_CRTIME)) { 479 MSG(0, "%s", " inode_crtime"); 480 } 481 if (f & cpu_to_le32(F2FS_FEATURE_LOST_FOUND)) { 482 MSG(0, "%s", " lost_found"); 483 } 484 if (f & cpu_to_le32(F2FS_FEATURE_SB_CHKSUM)) { 485 MSG(0, "%s", " sb_checksum"); 486 } 487 if (f & cpu_to_le32(F2FS_FEATURE_CASEFOLD)) { 488 MSG(0, "%s", " casefold"); 489 } 490 if (f & cpu_to_le32(F2FS_FEATURE_COMPRESSION)) { 491 MSG(0, "%s", " compression"); 492 } 493 MSG(0, "\n"); 494 MSG(0, "Info: superblock encrypt level = %d, salt = ", 495 sb->encryption_level); 496 for (i = 0; i < 16; i++) 497 MSG(0, "%02x", sb->encrypt_pw_salt[i]); 498 MSG(0, "\n"); 499 } 500 501 static inline bool is_valid_data_blkaddr(block_t blkaddr) 502 { 503 if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR || 504 blkaddr == COMPRESS_ADDR) 505 return 0; 506 return 1; 507 } 508 509 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi, 510 block_t blkaddr, int type) 511 { 512 switch (type) { 513 case META_NAT: 514 break; 515 case META_SIT: 516 if (blkaddr >= SIT_BLK_CNT(sbi)) 517 return 0; 518 break; 519 case META_SSA: 520 if (blkaddr >= MAIN_BLKADDR(sbi) || 521 blkaddr < SM_I(sbi)->ssa_blkaddr) 522 return 0; 523 break; 524 case META_CP: 525 if (blkaddr >= SIT_I(sbi)->sit_base_addr || 526 blkaddr < __start_cp_addr(sbi)) 527 return 0; 528 break; 529 case META_POR: 530 if (blkaddr >= MAX_BLKADDR(sbi) || 531 blkaddr < MAIN_BLKADDR(sbi)) 532 return 0; 533 break; 534 default: 535 ASSERT(0); 536 } 537 538 return 1; 539 } 540 541 static inline block_t current_sit_addr(struct f2fs_sb_info *sbi, 542 unsigned int start); 543 544 /* 545 * Readahead CP/NAT/SIT/SSA pages 546 */ 547 int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, 548 int type) 549 { 550 block_t blkno = start; 551 block_t blkaddr, start_blk = 0, len = 0; 552 553 for (; nrpages-- > 0; blkno++) { 554 555 if (!f2fs_is_valid_blkaddr(sbi, blkno, type)) 556 goto out; 557 558 switch (type) { 559 case META_NAT: 560 if (blkno >= NAT_BLOCK_OFFSET(NM_I(sbi)->max_nid)) 561 blkno = 0; 562 /* get nat block addr */ 563 blkaddr = current_nat_addr(sbi, 564 blkno * NAT_ENTRY_PER_BLOCK, NULL); 565 break; 566 case META_SIT: 567 /* get sit block addr */ 568 blkaddr = current_sit_addr(sbi, 569 blkno * SIT_ENTRY_PER_BLOCK); 570 break; 571 case META_SSA: 572 case META_CP: 573 case META_POR: 574 blkaddr = blkno; 575 break; 576 default: 577 ASSERT(0); 578 } 579 580 if (!len) { 581 start_blk = blkaddr; 582 len = 1; 583 } else if (start_blk + len == blkaddr) { 584 len++; 585 } else { 586 dev_readahead(start_blk << F2FS_BLKSIZE_BITS, 587 len << F2FS_BLKSIZE_BITS); 588 } 589 } 590 out: 591 if (len) 592 dev_readahead(start_blk << F2FS_BLKSIZE_BITS, 593 len << F2FS_BLKSIZE_BITS); 594 return blkno - start; 595 } 596 597 void update_superblock(struct f2fs_super_block *sb, int sb_mask) 598 { 599 int addr, ret; 600 u_int8_t *buf; 601 u32 old_crc, new_crc; 602 603 buf = calloc(BLOCK_SZ, 1); 604 ASSERT(buf); 605 606 if (get_sb(feature) & F2FS_FEATURE_SB_CHKSUM) { 607 old_crc = get_sb(crc); 608 new_crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, sb, 609 SB_CHKSUM_OFFSET); 610 set_sb(crc, new_crc); 611 MSG(1, "Info: SB CRC is updated (0x%x -> 0x%x)\n", 612 old_crc, new_crc); 613 } 614 615 memcpy(buf + F2FS_SUPER_OFFSET, sb, sizeof(*sb)); 616 for (addr = SB0_ADDR; addr < SB_MAX_ADDR; addr++) { 617 if (SB_MASK(addr) & sb_mask) { 618 ret = dev_write_block(buf, addr); 619 ASSERT(ret >= 0); 620 } 621 } 622 623 free(buf); 624 DBG(0, "Info: Done to update superblock\n"); 625 } 626 627 static inline int sanity_check_area_boundary(struct f2fs_super_block *sb, 628 enum SB_ADDR sb_addr) 629 { 630 u32 segment0_blkaddr = get_sb(segment0_blkaddr); 631 u32 cp_blkaddr = get_sb(cp_blkaddr); 632 u32 sit_blkaddr = get_sb(sit_blkaddr); 633 u32 nat_blkaddr = get_sb(nat_blkaddr); 634 u32 ssa_blkaddr = get_sb(ssa_blkaddr); 635 u32 main_blkaddr = get_sb(main_blkaddr); 636 u32 segment_count_ckpt = get_sb(segment_count_ckpt); 637 u32 segment_count_sit = get_sb(segment_count_sit); 638 u32 segment_count_nat = get_sb(segment_count_nat); 639 u32 segment_count_ssa = get_sb(segment_count_ssa); 640 u32 segment_count_main = get_sb(segment_count_main); 641 u32 segment_count = get_sb(segment_count); 642 u32 log_blocks_per_seg = get_sb(log_blocks_per_seg); 643 u64 main_end_blkaddr = main_blkaddr + 644 (segment_count_main << log_blocks_per_seg); 645 u64 seg_end_blkaddr = segment0_blkaddr + 646 (segment_count << log_blocks_per_seg); 647 648 if (segment0_blkaddr != cp_blkaddr) { 649 MSG(0, "\tMismatch segment0(%u) cp_blkaddr(%u)\n", 650 segment0_blkaddr, cp_blkaddr); 651 return -1; 652 } 653 654 if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) != 655 sit_blkaddr) { 656 MSG(0, "\tWrong CP boundary, start(%u) end(%u) blocks(%u)\n", 657 cp_blkaddr, sit_blkaddr, 658 segment_count_ckpt << log_blocks_per_seg); 659 return -1; 660 } 661 662 if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) != 663 nat_blkaddr) { 664 MSG(0, "\tWrong SIT boundary, start(%u) end(%u) blocks(%u)\n", 665 sit_blkaddr, nat_blkaddr, 666 segment_count_sit << log_blocks_per_seg); 667 return -1; 668 } 669 670 if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) != 671 ssa_blkaddr) { 672 MSG(0, "\tWrong NAT boundary, start(%u) end(%u) blocks(%u)\n", 673 nat_blkaddr, ssa_blkaddr, 674 segment_count_nat << log_blocks_per_seg); 675 return -1; 676 } 677 678 if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) != 679 main_blkaddr) { 680 MSG(0, "\tWrong SSA boundary, start(%u) end(%u) blocks(%u)\n", 681 ssa_blkaddr, main_blkaddr, 682 segment_count_ssa << log_blocks_per_seg); 683 return -1; 684 } 685 686 if (main_end_blkaddr > seg_end_blkaddr) { 687 MSG(0, "\tWrong MAIN_AREA, start(%u) end(%u) block(%u)\n", 688 main_blkaddr, 689 segment0_blkaddr + 690 (segment_count << log_blocks_per_seg), 691 segment_count_main << log_blocks_per_seg); 692 return -1; 693 } else if (main_end_blkaddr < seg_end_blkaddr) { 694 set_sb(segment_count, (main_end_blkaddr - 695 segment0_blkaddr) >> log_blocks_per_seg); 696 697 update_superblock(sb, SB_MASK(sb_addr)); 698 MSG(0, "Info: Fix alignment: start(%u) end(%u) block(%u)\n", 699 main_blkaddr, 700 segment0_blkaddr + 701 (segment_count << log_blocks_per_seg), 702 segment_count_main << log_blocks_per_seg); 703 } 704 return 0; 705 } 706 707 static int verify_sb_chksum(struct f2fs_super_block *sb) 708 { 709 if (SB_CHKSUM_OFFSET != get_sb(checksum_offset)) { 710 MSG(0, "\tInvalid SB CRC offset: %u\n", 711 get_sb(checksum_offset)); 712 return -1; 713 } 714 if (f2fs_crc_valid(get_sb(crc), sb, 715 get_sb(checksum_offset))) { 716 MSG(0, "\tInvalid SB CRC: 0x%x\n", get_sb(crc)); 717 return -1; 718 } 719 return 0; 720 } 721 722 int sanity_check_raw_super(struct f2fs_super_block *sb, enum SB_ADDR sb_addr) 723 { 724 unsigned int blocksize; 725 unsigned int segment_count, segs_per_sec, secs_per_zone; 726 unsigned int total_sections, blocks_per_seg; 727 728 if ((get_sb(feature) & F2FS_FEATURE_SB_CHKSUM) && 729 verify_sb_chksum(sb)) 730 return -1; 731 732 if (F2FS_SUPER_MAGIC != get_sb(magic)) { 733 MSG(0, "Magic Mismatch, valid(0x%x) - read(0x%x)\n", 734 F2FS_SUPER_MAGIC, get_sb(magic)); 735 return -1; 736 } 737 738 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) { 739 MSG(0, "Invalid page_cache_size (%d), supports only 4KB\n", 740 PAGE_CACHE_SIZE); 741 return -1; 742 } 743 744 blocksize = 1 << get_sb(log_blocksize); 745 if (F2FS_BLKSIZE != blocksize) { 746 MSG(0, "Invalid blocksize (%u), supports only 4KB\n", 747 blocksize); 748 return -1; 749 } 750 751 /* check log blocks per segment */ 752 if (get_sb(log_blocks_per_seg) != 9) { 753 MSG(0, "Invalid log blocks per segment (%u)\n", 754 get_sb(log_blocks_per_seg)); 755 return -1; 756 } 757 758 /* Currently, support 512/1024/2048/4096 bytes sector size */ 759 if (get_sb(log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE || 760 get_sb(log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE) { 761 MSG(0, "Invalid log sectorsize (%u)\n", get_sb(log_sectorsize)); 762 return -1; 763 } 764 765 if (get_sb(log_sectors_per_block) + get_sb(log_sectorsize) != 766 F2FS_MAX_LOG_SECTOR_SIZE) { 767 MSG(0, "Invalid log sectors per block(%u) log sectorsize(%u)\n", 768 get_sb(log_sectors_per_block), 769 get_sb(log_sectorsize)); 770 return -1; 771 } 772 773 segment_count = get_sb(segment_count); 774 segs_per_sec = get_sb(segs_per_sec); 775 secs_per_zone = get_sb(secs_per_zone); 776 total_sections = get_sb(section_count); 777 778 /* blocks_per_seg should be 512, given the above check */ 779 blocks_per_seg = 1 << get_sb(log_blocks_per_seg); 780 781 if (segment_count > F2FS_MAX_SEGMENT || 782 segment_count < F2FS_MIN_SEGMENTS) { 783 MSG(0, "\tInvalid segment count (%u)\n", segment_count); 784 return -1; 785 } 786 787 if (total_sections > segment_count || 788 total_sections < F2FS_MIN_SEGMENTS || 789 segs_per_sec > segment_count || !segs_per_sec) { 790 MSG(0, "\tInvalid segment/section count (%u, %u x %u)\n", 791 segment_count, total_sections, segs_per_sec); 792 return 1; 793 } 794 795 if ((segment_count / segs_per_sec) < total_sections) { 796 MSG(0, "Small segment_count (%u < %u * %u)\n", 797 segment_count, segs_per_sec, total_sections); 798 return 1; 799 } 800 801 if (segment_count > (get_sb(block_count) >> 9)) { 802 MSG(0, "Wrong segment_count / block_count (%u > %llu)\n", 803 segment_count, get_sb(block_count)); 804 return 1; 805 } 806 807 if (sb->devs[0].path[0]) { 808 unsigned int dev_segs = le32_to_cpu(sb->devs[0].total_segments); 809 int i = 1; 810 811 while (i < MAX_DEVICES && sb->devs[i].path[0]) { 812 dev_segs += le32_to_cpu(sb->devs[i].total_segments); 813 i++; 814 } 815 if (segment_count != dev_segs) { 816 MSG(0, "Segment count (%u) mismatch with total segments from devices (%u)", 817 segment_count, dev_segs); 818 return 1; 819 } 820 } 821 822 if (secs_per_zone > total_sections || !secs_per_zone) { 823 MSG(0, "Wrong secs_per_zone / total_sections (%u, %u)\n", 824 secs_per_zone, total_sections); 825 return 1; 826 } 827 if (get_sb(extension_count) > F2FS_MAX_EXTENSION || 828 sb->hot_ext_count > F2FS_MAX_EXTENSION || 829 get_sb(extension_count) + 830 sb->hot_ext_count > F2FS_MAX_EXTENSION) { 831 MSG(0, "Corrupted extension count (%u + %u > %u)\n", 832 get_sb(extension_count), 833 sb->hot_ext_count, 834 F2FS_MAX_EXTENSION); 835 return 1; 836 } 837 838 if (get_sb(cp_payload) > (blocks_per_seg - F2FS_CP_PACKS)) { 839 MSG(0, "Insane cp_payload (%u > %u)\n", 840 get_sb(cp_payload), blocks_per_seg - F2FS_CP_PACKS); 841 return 1; 842 } 843 844 /* check reserved ino info */ 845 if (get_sb(node_ino) != 1 || get_sb(meta_ino) != 2 || 846 get_sb(root_ino) != 3) { 847 MSG(0, "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)\n", 848 get_sb(node_ino), get_sb(meta_ino), get_sb(root_ino)); 849 return -1; 850 } 851 852 /* Check zoned block device feature */ 853 if (c.devices[0].zoned_model == F2FS_ZONED_HM && 854 !(sb->feature & cpu_to_le32(F2FS_FEATURE_BLKZONED))) { 855 MSG(0, "\tMissing zoned block device feature\n"); 856 return -1; 857 } 858 859 if (sanity_check_area_boundary(sb, sb_addr)) 860 return -1; 861 return 0; 862 } 863 864 int validate_super_block(struct f2fs_sb_info *sbi, enum SB_ADDR sb_addr) 865 { 866 char buf[F2FS_BLKSIZE]; 867 868 sbi->raw_super = malloc(sizeof(struct f2fs_super_block)); 869 if (!sbi->raw_super) 870 return -ENOMEM; 871 872 if (dev_read_block(buf, sb_addr)) 873 return -1; 874 875 memcpy(sbi->raw_super, buf + F2FS_SUPER_OFFSET, 876 sizeof(struct f2fs_super_block)); 877 878 if (!sanity_check_raw_super(sbi->raw_super, sb_addr)) { 879 /* get kernel version */ 880 if (c.kd >= 0) { 881 dev_read_version(c.version, 0, VERSION_LEN); 882 get_kernel_version(c.version); 883 } else { 884 get_kernel_uname_version(c.version); 885 } 886 887 /* build sb version */ 888 memcpy(c.sb_version, sbi->raw_super->version, VERSION_LEN); 889 get_kernel_version(c.sb_version); 890 memcpy(c.init_version, sbi->raw_super->init_version, VERSION_LEN); 891 get_kernel_version(c.init_version); 892 893 MSG(0, "Info: MKFS version\n \"%s\"\n", c.init_version); 894 MSG(0, "Info: FSCK version\n from \"%s\"\n to \"%s\"\n", 895 c.sb_version, c.version); 896 if (!c.no_kernel_check && 897 memcmp(c.sb_version, c.version, VERSION_LEN)) { 898 memcpy(sbi->raw_super->version, 899 c.version, VERSION_LEN); 900 update_superblock(sbi->raw_super, SB_MASK(sb_addr)); 901 902 c.auto_fix = 0; 903 c.fix_on = 1; 904 } 905 print_sb_state(sbi->raw_super); 906 return 0; 907 } 908 909 free(sbi->raw_super); 910 sbi->raw_super = NULL; 911 MSG(0, "\tCan't find a valid F2FS superblock at 0x%x\n", sb_addr); 912 913 return -EINVAL; 914 } 915 916 int init_sb_info(struct f2fs_sb_info *sbi) 917 { 918 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 919 u64 total_sectors; 920 int i; 921 922 sbi->log_sectors_per_block = get_sb(log_sectors_per_block); 923 sbi->log_blocksize = get_sb(log_blocksize); 924 sbi->blocksize = 1 << sbi->log_blocksize; 925 sbi->log_blocks_per_seg = get_sb(log_blocks_per_seg); 926 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 927 sbi->segs_per_sec = get_sb(segs_per_sec); 928 sbi->secs_per_zone = get_sb(secs_per_zone); 929 sbi->total_sections = get_sb(section_count); 930 sbi->total_node_count = (get_sb(segment_count_nat) / 2) * 931 sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 932 sbi->root_ino_num = get_sb(root_ino); 933 sbi->node_ino_num = get_sb(node_ino); 934 sbi->meta_ino_num = get_sb(meta_ino); 935 sbi->cur_victim_sec = NULL_SEGNO; 936 937 for (i = 0; i < MAX_DEVICES; i++) { 938 if (!sb->devs[i].path[0]) 939 break; 940 941 if (i) { 942 c.devices[i].path = strdup((char *)sb->devs[i].path); 943 if (get_device_info(i)) 944 ASSERT(0); 945 } else { 946 ASSERT(!strcmp((char *)sb->devs[i].path, 947 (char *)c.devices[i].path)); 948 } 949 950 c.devices[i].total_segments = 951 le32_to_cpu(sb->devs[i].total_segments); 952 if (i) 953 c.devices[i].start_blkaddr = 954 c.devices[i - 1].end_blkaddr + 1; 955 c.devices[i].end_blkaddr = c.devices[i].start_blkaddr + 956 c.devices[i].total_segments * 957 c.blks_per_seg - 1; 958 if (i == 0) 959 c.devices[i].end_blkaddr += get_sb(segment0_blkaddr); 960 961 c.ndevs = i + 1; 962 MSG(0, "Info: Device[%d] : %s blkaddr = %"PRIx64"--%"PRIx64"\n", 963 i, c.devices[i].path, 964 c.devices[i].start_blkaddr, 965 c.devices[i].end_blkaddr); 966 } 967 968 total_sectors = get_sb(block_count) << sbi->log_sectors_per_block; 969 MSG(0, "Info: total FS sectors = %"PRIu64" (%"PRIu64" MB)\n", 970 total_sectors, total_sectors >> 971 (20 - get_sb(log_sectorsize))); 972 return 0; 973 } 974 975 static int verify_checksum_chksum(struct f2fs_checkpoint *cp) 976 { 977 unsigned int chksum_offset = get_cp(checksum_offset); 978 unsigned int crc, cal_crc; 979 980 if (chksum_offset < CP_MIN_CHKSUM_OFFSET || 981 chksum_offset > CP_CHKSUM_OFFSET) { 982 MSG(0, "\tInvalid CP CRC offset: %u\n", chksum_offset); 983 return -1; 984 } 985 986 crc = le32_to_cpu(*(__le32 *)((unsigned char *)cp + chksum_offset)); 987 cal_crc = f2fs_checkpoint_chksum(cp); 988 if (cal_crc != crc) { 989 MSG(0, "\tInvalid CP CRC: offset:%u, crc:0x%x, calc:0x%x\n", 990 chksum_offset, crc, cal_crc); 991 return -1; 992 } 993 return 0; 994 } 995 996 static void *get_checkpoint_version(block_t cp_addr) 997 { 998 void *cp_page; 999 1000 cp_page = malloc(PAGE_SIZE); 1001 ASSERT(cp_page); 1002 1003 if (dev_read_block(cp_page, cp_addr) < 0) 1004 ASSERT(0); 1005 1006 if (verify_checksum_chksum((struct f2fs_checkpoint *)cp_page)) 1007 goto out; 1008 return cp_page; 1009 out: 1010 free(cp_page); 1011 return NULL; 1012 } 1013 1014 void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr, 1015 unsigned long long *version) 1016 { 1017 void *cp_page_1, *cp_page_2; 1018 struct f2fs_checkpoint *cp; 1019 unsigned long long cur_version = 0, pre_version = 0; 1020 1021 /* Read the 1st cp block in this CP pack */ 1022 cp_page_1 = get_checkpoint_version(cp_addr); 1023 if (!cp_page_1) 1024 return NULL; 1025 1026 cp = (struct f2fs_checkpoint *)cp_page_1; 1027 if (get_cp(cp_pack_total_block_count) > sbi->blocks_per_seg) 1028 goto invalid_cp1; 1029 1030 pre_version = get_cp(checkpoint_ver); 1031 1032 /* Read the 2nd cp block in this CP pack */ 1033 cp_addr += get_cp(cp_pack_total_block_count) - 1; 1034 cp_page_2 = get_checkpoint_version(cp_addr); 1035 if (!cp_page_2) 1036 goto invalid_cp1; 1037 1038 cp = (struct f2fs_checkpoint *)cp_page_2; 1039 cur_version = get_cp(checkpoint_ver); 1040 1041 if (cur_version == pre_version) { 1042 *version = cur_version; 1043 free(cp_page_2); 1044 return cp_page_1; 1045 } 1046 1047 free(cp_page_2); 1048 invalid_cp1: 1049 free(cp_page_1); 1050 return NULL; 1051 } 1052 1053 int get_valid_checkpoint(struct f2fs_sb_info *sbi) 1054 { 1055 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 1056 void *cp1, *cp2, *cur_page; 1057 unsigned long blk_size = sbi->blocksize; 1058 unsigned long long cp1_version = 0, cp2_version = 0, version; 1059 unsigned long long cp_start_blk_no; 1060 unsigned int cp_payload, cp_blks; 1061 int ret; 1062 1063 cp_payload = get_sb(cp_payload); 1064 if (cp_payload > F2FS_BLK_ALIGN(MAX_SIT_BITMAP_SIZE)) 1065 return -EINVAL; 1066 1067 cp_blks = 1 + cp_payload; 1068 sbi->ckpt = malloc(cp_blks * blk_size); 1069 if (!sbi->ckpt) 1070 return -ENOMEM; 1071 /* 1072 * Finding out valid cp block involves read both 1073 * sets( cp pack1 and cp pack 2) 1074 */ 1075 cp_start_blk_no = get_sb(cp_blkaddr); 1076 cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version); 1077 1078 /* The second checkpoint pack should start at the next segment */ 1079 cp_start_blk_no += 1 << get_sb(log_blocks_per_seg); 1080 cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version); 1081 1082 if (cp1 && cp2) { 1083 if (ver_after(cp2_version, cp1_version)) { 1084 cur_page = cp2; 1085 sbi->cur_cp = 2; 1086 version = cp2_version; 1087 } else { 1088 cur_page = cp1; 1089 sbi->cur_cp = 1; 1090 version = cp1_version; 1091 } 1092 } else if (cp1) { 1093 cur_page = cp1; 1094 sbi->cur_cp = 1; 1095 version = cp1_version; 1096 } else if (cp2) { 1097 cur_page = cp2; 1098 sbi->cur_cp = 2; 1099 version = cp2_version; 1100 } else 1101 goto fail_no_cp; 1102 1103 MSG(0, "Info: CKPT version = %llx\n", version); 1104 1105 memcpy(sbi->ckpt, cur_page, blk_size); 1106 1107 if (cp_blks > 1) { 1108 unsigned int i; 1109 unsigned long long cp_blk_no; 1110 1111 cp_blk_no = get_sb(cp_blkaddr); 1112 if (cur_page == cp2) 1113 cp_blk_no += 1 << get_sb(log_blocks_per_seg); 1114 1115 /* copy sit bitmap */ 1116 for (i = 1; i < cp_blks; i++) { 1117 unsigned char *ckpt = (unsigned char *)sbi->ckpt; 1118 ret = dev_read_block(cur_page, cp_blk_no + i); 1119 ASSERT(ret >= 0); 1120 memcpy(ckpt + i * blk_size, cur_page, blk_size); 1121 } 1122 } 1123 if (cp1) 1124 free(cp1); 1125 if (cp2) 1126 free(cp2); 1127 return 0; 1128 1129 fail_no_cp: 1130 free(sbi->ckpt); 1131 sbi->ckpt = NULL; 1132 return -EINVAL; 1133 } 1134 1135 /* 1136 * For a return value of 1, caller should further check for c.fix_on state 1137 * and take appropriate action. 1138 */ 1139 static int f2fs_should_proceed(struct f2fs_super_block *sb, u32 flag) 1140 { 1141 if (!c.fix_on && (c.auto_fix || c.preen_mode)) { 1142 if (flag & CP_FSCK_FLAG || 1143 flag & CP_QUOTA_NEED_FSCK_FLAG || 1144 (exist_qf_ino(sb) && (flag & CP_ERROR_FLAG))) { 1145 c.fix_on = 1; 1146 } else if (!c.preen_mode) { 1147 print_cp_state(flag); 1148 return 0; 1149 } 1150 } 1151 return 1; 1152 } 1153 1154 int sanity_check_ckpt(struct f2fs_sb_info *sbi) 1155 { 1156 unsigned int total, fsmeta; 1157 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 1158 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 1159 unsigned int flag = get_cp(ckpt_flags); 1160 unsigned int ovp_segments, reserved_segments; 1161 unsigned int main_segs, blocks_per_seg; 1162 unsigned int sit_segs, nat_segs; 1163 unsigned int sit_bitmap_size, nat_bitmap_size; 1164 unsigned int log_blocks_per_seg; 1165 unsigned int segment_count_main; 1166 unsigned int cp_pack_start_sum, cp_payload; 1167 block_t user_block_count; 1168 int i; 1169 1170 total = get_sb(segment_count); 1171 fsmeta = get_sb(segment_count_ckpt); 1172 sit_segs = get_sb(segment_count_sit); 1173 fsmeta += sit_segs; 1174 nat_segs = get_sb(segment_count_nat); 1175 fsmeta += nat_segs; 1176 fsmeta += get_cp(rsvd_segment_count); 1177 fsmeta += get_sb(segment_count_ssa); 1178 1179 if (fsmeta >= total) 1180 return 1; 1181 1182 ovp_segments = get_cp(overprov_segment_count); 1183 reserved_segments = get_cp(rsvd_segment_count); 1184 1185 if (fsmeta < F2FS_MIN_SEGMENT || ovp_segments == 0 || 1186 reserved_segments == 0) { 1187 MSG(0, "\tWrong layout: check mkfs.f2fs version\n"); 1188 return 1; 1189 } 1190 1191 user_block_count = get_cp(user_block_count); 1192 segment_count_main = get_sb(segment_count_main); 1193 log_blocks_per_seg = get_sb(log_blocks_per_seg); 1194 if (!user_block_count || user_block_count >= 1195 segment_count_main << log_blocks_per_seg) { 1196 ASSERT_MSG("\tWrong user_block_count(%u)\n", user_block_count); 1197 1198 if (!f2fs_should_proceed(sb, flag)) 1199 return 1; 1200 if (!c.fix_on) 1201 return 1; 1202 1203 if (flag & (CP_FSCK_FLAG | CP_RESIZEFS_FLAG)) { 1204 u32 valid_user_block_cnt; 1205 u32 seg_cnt_main = get_sb(segment_count) - 1206 (get_sb(segment_count_ckpt) + 1207 get_sb(segment_count_sit) + 1208 get_sb(segment_count_nat) + 1209 get_sb(segment_count_ssa)); 1210 1211 /* validate segment_count_main in sb first */ 1212 if (seg_cnt_main != get_sb(segment_count_main)) { 1213 MSG(0, "Inconsistent segment_cnt_main %u in sb\n", 1214 segment_count_main << log_blocks_per_seg); 1215 return 1; 1216 } 1217 valid_user_block_cnt = ((get_sb(segment_count_main) - 1218 get_cp(overprov_segment_count)) * c.blks_per_seg); 1219 MSG(0, "Info: Fix wrong user_block_count in CP: (%u) -> (%u)\n", 1220 user_block_count, valid_user_block_cnt); 1221 set_cp(user_block_count, valid_user_block_cnt); 1222 c.bug_on = 1; 1223 } 1224 } 1225 1226 main_segs = get_sb(segment_count_main); 1227 blocks_per_seg = sbi->blocks_per_seg; 1228 1229 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) { 1230 if (get_cp(cur_node_segno[i]) >= main_segs || 1231 get_cp(cur_node_blkoff[i]) >= blocks_per_seg) 1232 return 1; 1233 } 1234 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) { 1235 if (get_cp(cur_data_segno[i]) >= main_segs || 1236 get_cp(cur_data_blkoff[i]) >= blocks_per_seg) 1237 return 1; 1238 } 1239 1240 sit_bitmap_size = get_cp(sit_ver_bitmap_bytesize); 1241 nat_bitmap_size = get_cp(nat_ver_bitmap_bytesize); 1242 1243 if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 || 1244 nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) { 1245 MSG(0, "\tWrong bitmap size: sit(%u), nat(%u)\n", 1246 sit_bitmap_size, nat_bitmap_size); 1247 return 1; 1248 } 1249 1250 cp_pack_start_sum = __start_sum_addr(sbi); 1251 cp_payload = __cp_payload(sbi); 1252 if (cp_pack_start_sum < cp_payload + 1 || 1253 cp_pack_start_sum > blocks_per_seg - 1 - 1254 NR_CURSEG_TYPE) { 1255 MSG(0, "\tWrong cp_pack_start_sum(%u) or cp_payload(%u)\n", 1256 cp_pack_start_sum, cp_payload); 1257 if ((get_sb(feature) & F2FS_FEATURE_SB_CHKSUM)) 1258 return 1; 1259 set_sb(cp_payload, cp_pack_start_sum - 1); 1260 update_superblock(sb, SB_MASK_ALL); 1261 } 1262 1263 return 0; 1264 } 1265 1266 pgoff_t current_nat_addr(struct f2fs_sb_info *sbi, nid_t start, int *pack) 1267 { 1268 struct f2fs_nm_info *nm_i = NM_I(sbi); 1269 pgoff_t block_off; 1270 pgoff_t block_addr; 1271 int seg_off; 1272 1273 block_off = NAT_BLOCK_OFFSET(start); 1274 seg_off = block_off >> sbi->log_blocks_per_seg; 1275 1276 block_addr = (pgoff_t)(nm_i->nat_blkaddr + 1277 (seg_off << sbi->log_blocks_per_seg << 1) + 1278 (block_off & ((1 << sbi->log_blocks_per_seg) -1))); 1279 if (pack) 1280 *pack = 1; 1281 1282 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) { 1283 block_addr += sbi->blocks_per_seg; 1284 if (pack) 1285 *pack = 2; 1286 } 1287 1288 return block_addr; 1289 } 1290 1291 /* will not init nid_bitmap from nat */ 1292 static int f2fs_early_init_nid_bitmap(struct f2fs_sb_info *sbi) 1293 { 1294 struct f2fs_nm_info *nm_i = NM_I(sbi); 1295 int nid_bitmap_size = (nm_i->max_nid + BITS_PER_BYTE - 1) / BITS_PER_BYTE; 1296 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1297 struct f2fs_summary_block *sum = curseg->sum_blk; 1298 struct f2fs_journal *journal = &sum->journal; 1299 nid_t nid; 1300 int i; 1301 1302 if (!(c.func == SLOAD || c.func == FSCK)) 1303 return 0; 1304 1305 nm_i->nid_bitmap = (char *)calloc(nid_bitmap_size, 1); 1306 if (!nm_i->nid_bitmap) 1307 return -ENOMEM; 1308 1309 /* arbitrarily set 0 bit */ 1310 f2fs_set_bit(0, nm_i->nid_bitmap); 1311 1312 if (nats_in_cursum(journal) > NAT_JOURNAL_ENTRIES) { 1313 MSG(0, "\tError: f2fs_init_nid_bitmap truncate n_nats(%u) to " 1314 "NAT_JOURNAL_ENTRIES(%lu)\n", 1315 nats_in_cursum(journal), NAT_JOURNAL_ENTRIES); 1316 journal->n_nats = cpu_to_le16(NAT_JOURNAL_ENTRIES); 1317 c.fix_on = 1; 1318 } 1319 1320 for (i = 0; i < nats_in_cursum(journal); i++) { 1321 block_t addr; 1322 1323 addr = le32_to_cpu(nat_in_journal(journal, i).block_addr); 1324 if (!IS_VALID_BLK_ADDR(sbi, addr)) { 1325 MSG(0, "\tError: f2fs_init_nid_bitmap: addr(%u) is invalid!!!\n", addr); 1326 journal->n_nats = cpu_to_le16(i); 1327 c.fix_on = 1; 1328 continue; 1329 } 1330 1331 nid = le32_to_cpu(nid_in_journal(journal, i)); 1332 if (!IS_VALID_NID(sbi, nid)) { 1333 MSG(0, "\tError: f2fs_init_nid_bitmap: nid(%u) is invalid!!!\n", nid); 1334 journal->n_nats = cpu_to_le16(i); 1335 c.fix_on = 1; 1336 continue; 1337 } 1338 if (addr != NULL_ADDR) 1339 f2fs_set_bit(nid, nm_i->nid_bitmap); 1340 } 1341 return 0; 1342 } 1343 1344 /* will init nid_bitmap from nat */ 1345 static int f2fs_late_init_nid_bitmap(struct f2fs_sb_info *sbi) 1346 { 1347 struct f2fs_nm_info *nm_i = NM_I(sbi); 1348 struct f2fs_nat_block *nat_block; 1349 block_t start_blk; 1350 nid_t nid; 1351 1352 if (!(c.func == SLOAD || c.func == FSCK)) 1353 return 0; 1354 1355 nat_block = malloc(F2FS_BLKSIZE); 1356 if (!nat_block) { 1357 free(nm_i->nid_bitmap); 1358 return -ENOMEM; 1359 } 1360 1361 f2fs_ra_meta_pages(sbi, 0, NAT_BLOCK_OFFSET(nm_i->max_nid), 1362 META_NAT); 1363 for (nid = 0; nid < nm_i->max_nid; nid++) { 1364 if (!(nid % NAT_ENTRY_PER_BLOCK)) { 1365 int ret; 1366 1367 start_blk = current_nat_addr(sbi, nid, NULL); 1368 ret = dev_read_block(nat_block, start_blk); 1369 ASSERT(ret >= 0); 1370 } 1371 1372 if (nat_block->entries[nid % NAT_ENTRY_PER_BLOCK].block_addr) 1373 f2fs_set_bit(nid, nm_i->nid_bitmap); 1374 } 1375 1376 free(nat_block); 1377 return 0; 1378 } 1379 1380 u32 update_nat_bits_flags(struct f2fs_super_block *sb, 1381 struct f2fs_checkpoint *cp, u32 flags) 1382 { 1383 u_int32_t nat_bits_bytes, nat_bits_blocks; 1384 1385 nat_bits_bytes = get_sb(segment_count_nat) << 5; 1386 nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) + 8 + 1387 F2FS_BLKSIZE - 1); 1388 if (get_cp(cp_pack_total_block_count) <= 1389 (1 << get_sb(log_blocks_per_seg)) - nat_bits_blocks) 1390 flags |= CP_NAT_BITS_FLAG; 1391 else 1392 flags &= (~CP_NAT_BITS_FLAG); 1393 1394 return flags; 1395 } 1396 1397 /* should call flush_journal_entries() bfore this */ 1398 void write_nat_bits(struct f2fs_sb_info *sbi, 1399 struct f2fs_super_block *sb, struct f2fs_checkpoint *cp, int set) 1400 { 1401 struct f2fs_nm_info *nm_i = NM_I(sbi); 1402 u_int32_t nat_blocks = get_sb(segment_count_nat) << 1403 (get_sb(log_blocks_per_seg) - 1); 1404 u_int32_t nat_bits_bytes = nat_blocks >> 3; 1405 u_int32_t nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) + 1406 8 + F2FS_BLKSIZE - 1); 1407 unsigned char *nat_bits, *full_nat_bits, *empty_nat_bits; 1408 struct f2fs_nat_block *nat_block; 1409 u_int32_t i, j; 1410 block_t blkaddr; 1411 int ret; 1412 1413 nat_bits = calloc(F2FS_BLKSIZE, nat_bits_blocks); 1414 ASSERT(nat_bits); 1415 1416 nat_block = malloc(F2FS_BLKSIZE); 1417 ASSERT(nat_block); 1418 1419 full_nat_bits = nat_bits + 8; 1420 empty_nat_bits = full_nat_bits + nat_bits_bytes; 1421 1422 memset(full_nat_bits, 0, nat_bits_bytes); 1423 memset(empty_nat_bits, 0, nat_bits_bytes); 1424 1425 for (i = 0; i < nat_blocks; i++) { 1426 int seg_off = i >> get_sb(log_blocks_per_seg); 1427 int valid = 0; 1428 1429 blkaddr = (pgoff_t)(get_sb(nat_blkaddr) + 1430 (seg_off << get_sb(log_blocks_per_seg) << 1) + 1431 (i & ((1 << get_sb(log_blocks_per_seg)) - 1))); 1432 1433 /* 1434 * Should consider new nat_blocks is larger than old 1435 * nm_i->nat_blocks, since nm_i->nat_bitmap is based on 1436 * old one. 1437 */ 1438 if (i < nm_i->nat_blocks && f2fs_test_bit(i, nm_i->nat_bitmap)) 1439 blkaddr += (1 << get_sb(log_blocks_per_seg)); 1440 1441 ret = dev_read_block(nat_block, blkaddr); 1442 ASSERT(ret >= 0); 1443 1444 for (j = 0; j < NAT_ENTRY_PER_BLOCK; j++) { 1445 if ((i == 0 && j == 0) || 1446 nat_block->entries[j].block_addr != NULL_ADDR) 1447 valid++; 1448 } 1449 if (valid == 0) 1450 test_and_set_bit_le(i, empty_nat_bits); 1451 else if (valid == NAT_ENTRY_PER_BLOCK) 1452 test_and_set_bit_le(i, full_nat_bits); 1453 } 1454 *(__le64 *)nat_bits = get_cp_crc(cp); 1455 free(nat_block); 1456 1457 blkaddr = get_sb(segment0_blkaddr) + (set << 1458 get_sb(log_blocks_per_seg)) - nat_bits_blocks; 1459 1460 DBG(1, "\tWriting NAT bits pages, at offset 0x%08x\n", blkaddr); 1461 1462 for (i = 0; i < nat_bits_blocks; i++) { 1463 if (dev_write_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i)) 1464 ASSERT_MSG("\tError: write NAT bits to disk!!!\n"); 1465 } 1466 MSG(0, "Info: Write valid nat_bits in checkpoint\n"); 1467 1468 free(nat_bits); 1469 } 1470 1471 static int check_nat_bits(struct f2fs_sb_info *sbi, 1472 struct f2fs_super_block *sb, struct f2fs_checkpoint *cp) 1473 { 1474 struct f2fs_nm_info *nm_i = NM_I(sbi); 1475 u_int32_t nat_blocks = get_sb(segment_count_nat) << 1476 (get_sb(log_blocks_per_seg) - 1); 1477 u_int32_t nat_bits_bytes = nat_blocks >> 3; 1478 u_int32_t nat_bits_blocks = F2FS_BYTES_TO_BLK((nat_bits_bytes << 1) + 1479 8 + F2FS_BLKSIZE - 1); 1480 unsigned char *nat_bits, *full_nat_bits, *empty_nat_bits; 1481 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1482 struct f2fs_journal *journal = &curseg->sum_blk->journal; 1483 u_int32_t i, j; 1484 block_t blkaddr; 1485 int err = 0; 1486 1487 nat_bits = calloc(F2FS_BLKSIZE, nat_bits_blocks); 1488 ASSERT(nat_bits); 1489 1490 full_nat_bits = nat_bits + 8; 1491 empty_nat_bits = full_nat_bits + nat_bits_bytes; 1492 1493 blkaddr = get_sb(segment0_blkaddr) + (sbi->cur_cp << 1494 get_sb(log_blocks_per_seg)) - nat_bits_blocks; 1495 1496 for (i = 0; i < nat_bits_blocks; i++) { 1497 if (dev_read_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i)) 1498 ASSERT_MSG("\tError: read NAT bits to disk!!!\n"); 1499 } 1500 1501 if (*(__le64 *)nat_bits != get_cp_crc(cp) || nats_in_cursum(journal)) { 1502 /* 1503 * if there is a journal, f2fs was not shutdown cleanly. Let's 1504 * flush them with nat_bits. 1505 */ 1506 if (c.fix_on) 1507 err = -1; 1508 /* Otherwise, kernel will disable nat_bits */ 1509 goto out; 1510 } 1511 1512 for (i = 0; i < nat_blocks; i++) { 1513 u_int32_t start_nid = i * NAT_ENTRY_PER_BLOCK; 1514 u_int32_t valid = 0; 1515 int empty = test_bit_le(i, empty_nat_bits); 1516 int full = test_bit_le(i, full_nat_bits); 1517 1518 for (j = 0; j < NAT_ENTRY_PER_BLOCK; j++) { 1519 if (f2fs_test_bit(start_nid + j, nm_i->nid_bitmap)) 1520 valid++; 1521 } 1522 if (valid == 0) { 1523 if (!empty || full) { 1524 err = -1; 1525 goto out; 1526 } 1527 } else if (valid == NAT_ENTRY_PER_BLOCK) { 1528 if (empty || !full) { 1529 err = -1; 1530 goto out; 1531 } 1532 } else { 1533 if (empty || full) { 1534 err = -1; 1535 goto out; 1536 } 1537 } 1538 } 1539 out: 1540 free(nat_bits); 1541 if (!err) { 1542 MSG(0, "Info: Checked valid nat_bits in checkpoint\n"); 1543 } else { 1544 c.bug_nat_bits = 1; 1545 MSG(0, "Info: Corrupted valid nat_bits in checkpoint\n"); 1546 } 1547 return err; 1548 } 1549 1550 int init_node_manager(struct f2fs_sb_info *sbi) 1551 { 1552 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 1553 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 1554 struct f2fs_nm_info *nm_i = NM_I(sbi); 1555 unsigned char *version_bitmap; 1556 unsigned int nat_segs; 1557 1558 nm_i->nat_blkaddr = get_sb(nat_blkaddr); 1559 1560 /* segment_count_nat includes pair segment so divide to 2. */ 1561 nat_segs = get_sb(segment_count_nat) >> 1; 1562 nm_i->nat_blocks = nat_segs << get_sb(log_blocks_per_seg); 1563 nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nm_i->nat_blocks; 1564 nm_i->fcnt = 0; 1565 nm_i->nat_cnt = 0; 1566 nm_i->init_scan_nid = get_cp(next_free_nid); 1567 nm_i->next_scan_nid = get_cp(next_free_nid); 1568 1569 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); 1570 1571 nm_i->nat_bitmap = malloc(nm_i->bitmap_size); 1572 if (!nm_i->nat_bitmap) 1573 return -ENOMEM; 1574 version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP); 1575 if (!version_bitmap) 1576 return -EFAULT; 1577 1578 /* copy version bitmap */ 1579 memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size); 1580 return f2fs_early_init_nid_bitmap(sbi); 1581 } 1582 1583 int build_node_manager(struct f2fs_sb_info *sbi) 1584 { 1585 int err; 1586 sbi->nm_info = malloc(sizeof(struct f2fs_nm_info)); 1587 if (!sbi->nm_info) 1588 return -ENOMEM; 1589 1590 err = init_node_manager(sbi); 1591 if (err) 1592 return err; 1593 1594 return 0; 1595 } 1596 1597 int build_sit_info(struct f2fs_sb_info *sbi) 1598 { 1599 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 1600 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 1601 struct sit_info *sit_i; 1602 unsigned int sit_segs; 1603 int start; 1604 char *src_bitmap, *dst_bitmap; 1605 unsigned char *bitmap; 1606 unsigned int bitmap_size; 1607 1608 sit_i = malloc(sizeof(struct sit_info)); 1609 if (!sit_i) { 1610 MSG(1, "\tError: Malloc failed for build_sit_info!\n"); 1611 return -ENOMEM; 1612 } 1613 1614 SM_I(sbi)->sit_info = sit_i; 1615 1616 sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1); 1617 if (!sit_i->sentries) { 1618 MSG(1, "\tError: Calloc failed for build_sit_info!\n"); 1619 goto free_sit_info; 1620 } 1621 1622 bitmap_size = TOTAL_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE; 1623 1624 if (need_fsync_data_record(sbi)) 1625 bitmap_size += bitmap_size; 1626 1627 sit_i->bitmap = calloc(bitmap_size, 1); 1628 if (!sit_i->bitmap) { 1629 MSG(1, "\tError: Calloc failed for build_sit_info!!\n"); 1630 goto free_sentries; 1631 } 1632 1633 bitmap = sit_i->bitmap; 1634 1635 for (start = 0; start < TOTAL_SEGS(sbi); start++) { 1636 sit_i->sentries[start].cur_valid_map = bitmap; 1637 bitmap += SIT_VBLOCK_MAP_SIZE; 1638 1639 if (need_fsync_data_record(sbi)) { 1640 sit_i->sentries[start].ckpt_valid_map = bitmap; 1641 bitmap += SIT_VBLOCK_MAP_SIZE; 1642 } 1643 } 1644 1645 sit_segs = get_sb(segment_count_sit) >> 1; 1646 bitmap_size = __bitmap_size(sbi, SIT_BITMAP); 1647 src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP); 1648 1649 dst_bitmap = malloc(bitmap_size); 1650 if (!dst_bitmap) { 1651 MSG(1, "\tError: Malloc failed for build_sit_info!!\n"); 1652 goto free_validity_maps; 1653 } 1654 1655 memcpy(dst_bitmap, src_bitmap, bitmap_size); 1656 1657 sit_i->sit_base_addr = get_sb(sit_blkaddr); 1658 sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg; 1659 sit_i->written_valid_blocks = get_cp(valid_block_count); 1660 sit_i->sit_bitmap = dst_bitmap; 1661 sit_i->bitmap_size = bitmap_size; 1662 sit_i->dirty_sentries = 0; 1663 sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK; 1664 sit_i->elapsed_time = get_cp(elapsed_time); 1665 return 0; 1666 1667 free_validity_maps: 1668 free(sit_i->bitmap); 1669 free_sentries: 1670 free(sit_i->sentries); 1671 free_sit_info: 1672 free(sit_i); 1673 1674 return -ENOMEM; 1675 } 1676 1677 void reset_curseg(struct f2fs_sb_info *sbi, int type) 1678 { 1679 struct curseg_info *curseg = CURSEG_I(sbi, type); 1680 struct summary_footer *sum_footer; 1681 struct seg_entry *se; 1682 1683 sum_footer = &(curseg->sum_blk->footer); 1684 memset(sum_footer, 0, sizeof(struct summary_footer)); 1685 if (IS_DATASEG(type)) 1686 SET_SUM_TYPE(sum_footer, SUM_TYPE_DATA); 1687 if (IS_NODESEG(type)) 1688 SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE); 1689 se = get_seg_entry(sbi, curseg->segno); 1690 se->type = type; 1691 se->dirty = 1; 1692 } 1693 1694 static void read_compacted_summaries(struct f2fs_sb_info *sbi) 1695 { 1696 struct curseg_info *curseg; 1697 unsigned int i, j, offset; 1698 block_t start; 1699 char *kaddr; 1700 int ret; 1701 1702 start = start_sum_block(sbi); 1703 1704 kaddr = (char *)malloc(PAGE_SIZE); 1705 ASSERT(kaddr); 1706 1707 ret = dev_read_block(kaddr, start++); 1708 ASSERT(ret >= 0); 1709 1710 curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1711 memcpy(&curseg->sum_blk->journal.n_nats, kaddr, SUM_JOURNAL_SIZE); 1712 1713 curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 1714 memcpy(&curseg->sum_blk->journal.n_sits, kaddr + SUM_JOURNAL_SIZE, 1715 SUM_JOURNAL_SIZE); 1716 1717 offset = 2 * SUM_JOURNAL_SIZE; 1718 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) { 1719 unsigned short blk_off; 1720 struct curseg_info *curseg = CURSEG_I(sbi, i); 1721 1722 reset_curseg(sbi, i); 1723 1724 if (curseg->alloc_type == SSR) 1725 blk_off = sbi->blocks_per_seg; 1726 else 1727 blk_off = curseg->next_blkoff; 1728 1729 ASSERT(blk_off <= ENTRIES_IN_SUM); 1730 1731 for (j = 0; j < blk_off; j++) { 1732 struct f2fs_summary *s; 1733 s = (struct f2fs_summary *)(kaddr + offset); 1734 curseg->sum_blk->entries[j] = *s; 1735 offset += SUMMARY_SIZE; 1736 if (offset + SUMMARY_SIZE <= 1737 PAGE_CACHE_SIZE - SUM_FOOTER_SIZE) 1738 continue; 1739 memset(kaddr, 0, PAGE_SIZE); 1740 ret = dev_read_block(kaddr, start++); 1741 ASSERT(ret >= 0); 1742 offset = 0; 1743 } 1744 } 1745 free(kaddr); 1746 } 1747 1748 static void restore_node_summary(struct f2fs_sb_info *sbi, 1749 unsigned int segno, struct f2fs_summary_block *sum_blk) 1750 { 1751 struct f2fs_node *node_blk; 1752 struct f2fs_summary *sum_entry; 1753 block_t addr; 1754 unsigned int i; 1755 int ret; 1756 1757 node_blk = malloc(F2FS_BLKSIZE); 1758 ASSERT(node_blk); 1759 1760 /* scan the node segment */ 1761 addr = START_BLOCK(sbi, segno); 1762 sum_entry = &sum_blk->entries[0]; 1763 1764 for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) { 1765 ret = dev_read_block(node_blk, addr); 1766 ASSERT(ret >= 0); 1767 sum_entry->nid = node_blk->footer.nid; 1768 addr++; 1769 } 1770 free(node_blk); 1771 } 1772 1773 static void read_normal_summaries(struct f2fs_sb_info *sbi, int type) 1774 { 1775 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 1776 struct f2fs_summary_block *sum_blk; 1777 struct curseg_info *curseg; 1778 unsigned int segno = 0; 1779 block_t blk_addr = 0; 1780 int ret; 1781 1782 if (IS_DATASEG(type)) { 1783 segno = get_cp(cur_data_segno[type]); 1784 if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) 1785 blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type); 1786 else 1787 blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type); 1788 } else { 1789 segno = get_cp(cur_node_segno[type - CURSEG_HOT_NODE]); 1790 if (is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) 1791 blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE, 1792 type - CURSEG_HOT_NODE); 1793 else 1794 blk_addr = GET_SUM_BLKADDR(sbi, segno); 1795 } 1796 1797 sum_blk = (struct f2fs_summary_block *)malloc(PAGE_SIZE); 1798 ASSERT(sum_blk); 1799 1800 ret = dev_read_block(sum_blk, blk_addr); 1801 ASSERT(ret >= 0); 1802 1803 if (IS_NODESEG(type) && !is_set_ckpt_flags(cp, CP_UMOUNT_FLAG)) 1804 restore_node_summary(sbi, segno, sum_blk); 1805 1806 curseg = CURSEG_I(sbi, type); 1807 memcpy(curseg->sum_blk, sum_blk, PAGE_CACHE_SIZE); 1808 reset_curseg(sbi, type); 1809 free(sum_blk); 1810 } 1811 1812 void update_sum_entry(struct f2fs_sb_info *sbi, block_t blk_addr, 1813 struct f2fs_summary *sum) 1814 { 1815 struct f2fs_summary_block *sum_blk; 1816 u32 segno, offset; 1817 int type, ret; 1818 struct seg_entry *se; 1819 1820 segno = GET_SEGNO(sbi, blk_addr); 1821 offset = OFFSET_IN_SEG(sbi, blk_addr); 1822 1823 se = get_seg_entry(sbi, segno); 1824 1825 sum_blk = get_sum_block(sbi, segno, &type); 1826 memcpy(&sum_blk->entries[offset], sum, sizeof(*sum)); 1827 sum_blk->footer.entry_type = IS_NODESEG(se->type) ? SUM_TYPE_NODE : 1828 SUM_TYPE_DATA; 1829 1830 /* write SSA all the time */ 1831 ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno)); 1832 ASSERT(ret >= 0); 1833 1834 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA || 1835 type == SEG_TYPE_MAX) 1836 free(sum_blk); 1837 } 1838 1839 static void restore_curseg_summaries(struct f2fs_sb_info *sbi) 1840 { 1841 int type = CURSEG_HOT_DATA; 1842 1843 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) { 1844 read_compacted_summaries(sbi); 1845 type = CURSEG_HOT_NODE; 1846 } 1847 1848 for (; type <= CURSEG_COLD_NODE; type++) 1849 read_normal_summaries(sbi, type); 1850 } 1851 1852 static int build_curseg(struct f2fs_sb_info *sbi) 1853 { 1854 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 1855 struct curseg_info *array; 1856 unsigned short blk_off; 1857 unsigned int segno; 1858 int i; 1859 1860 array = malloc(sizeof(*array) * NR_CURSEG_TYPE); 1861 if (!array) { 1862 MSG(1, "\tError: Malloc failed for build_curseg!\n"); 1863 return -ENOMEM; 1864 } 1865 1866 SM_I(sbi)->curseg_array = array; 1867 1868 for (i = 0; i < NR_CURSEG_TYPE; i++) { 1869 array[i].sum_blk = malloc(PAGE_CACHE_SIZE); 1870 if (!array[i].sum_blk) { 1871 MSG(1, "\tError: Malloc failed for build_curseg!!\n"); 1872 goto seg_cleanup; 1873 } 1874 1875 if (i <= CURSEG_COLD_DATA) { 1876 blk_off = get_cp(cur_data_blkoff[i]); 1877 segno = get_cp(cur_data_segno[i]); 1878 } 1879 if (i > CURSEG_COLD_DATA) { 1880 blk_off = get_cp(cur_node_blkoff[i - CURSEG_HOT_NODE]); 1881 segno = get_cp(cur_node_segno[i - CURSEG_HOT_NODE]); 1882 } 1883 ASSERT(segno < TOTAL_SEGS(sbi)); 1884 ASSERT(blk_off < DEFAULT_BLOCKS_PER_SEGMENT); 1885 1886 array[i].segno = segno; 1887 array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno); 1888 array[i].next_segno = NULL_SEGNO; 1889 array[i].next_blkoff = blk_off; 1890 array[i].alloc_type = cp->alloc_type[i]; 1891 } 1892 restore_curseg_summaries(sbi); 1893 return 0; 1894 1895 seg_cleanup: 1896 for(--i ; i >=0; --i) 1897 free(array[i].sum_blk); 1898 free(array); 1899 1900 return -ENOMEM; 1901 } 1902 1903 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno) 1904 { 1905 unsigned int end_segno = SM_I(sbi)->segment_count - 1; 1906 ASSERT(segno <= end_segno); 1907 } 1908 1909 static inline block_t current_sit_addr(struct f2fs_sb_info *sbi, 1910 unsigned int segno) 1911 { 1912 struct sit_info *sit_i = SIT_I(sbi); 1913 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno); 1914 block_t blk_addr = sit_i->sit_base_addr + offset; 1915 1916 check_seg_range(sbi, segno); 1917 1918 /* calculate sit block address */ 1919 if (f2fs_test_bit(offset, sit_i->sit_bitmap)) 1920 blk_addr += sit_i->sit_blocks; 1921 1922 return blk_addr; 1923 } 1924 1925 void get_current_sit_page(struct f2fs_sb_info *sbi, 1926 unsigned int segno, struct f2fs_sit_block *sit_blk) 1927 { 1928 block_t blk_addr = current_sit_addr(sbi, segno); 1929 1930 ASSERT(dev_read_block(sit_blk, blk_addr) >= 0); 1931 } 1932 1933 void rewrite_current_sit_page(struct f2fs_sb_info *sbi, 1934 unsigned int segno, struct f2fs_sit_block *sit_blk) 1935 { 1936 block_t blk_addr = current_sit_addr(sbi, segno); 1937 1938 ASSERT(dev_write_block(sit_blk, blk_addr) >= 0); 1939 } 1940 1941 void check_block_count(struct f2fs_sb_info *sbi, 1942 unsigned int segno, struct f2fs_sit_entry *raw_sit) 1943 { 1944 struct f2fs_sm_info *sm_info = SM_I(sbi); 1945 unsigned int end_segno = sm_info->segment_count - 1; 1946 int valid_blocks = 0; 1947 unsigned int i; 1948 1949 /* check segment usage */ 1950 if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg) 1951 ASSERT_MSG("Invalid SIT vblocks: segno=0x%x, %u", 1952 segno, GET_SIT_VBLOCKS(raw_sit)); 1953 1954 /* check boundary of a given segment number */ 1955 if (segno > end_segno) 1956 ASSERT_MSG("Invalid SEGNO: 0x%x", segno); 1957 1958 /* check bitmap with valid block count */ 1959 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++) 1960 valid_blocks += get_bits_in_byte(raw_sit->valid_map[i]); 1961 1962 if (GET_SIT_VBLOCKS(raw_sit) != valid_blocks) 1963 ASSERT_MSG("Wrong SIT valid blocks: segno=0x%x, %u vs. %u", 1964 segno, GET_SIT_VBLOCKS(raw_sit), valid_blocks); 1965 1966 if (GET_SIT_TYPE(raw_sit) >= NO_CHECK_TYPE) 1967 ASSERT_MSG("Wrong SIT type: segno=0x%x, %u", 1968 segno, GET_SIT_TYPE(raw_sit)); 1969 } 1970 1971 void __seg_info_from_raw_sit(struct seg_entry *se, 1972 struct f2fs_sit_entry *raw_sit) 1973 { 1974 se->valid_blocks = GET_SIT_VBLOCKS(raw_sit); 1975 memcpy(se->cur_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE); 1976 se->type = GET_SIT_TYPE(raw_sit); 1977 se->orig_type = GET_SIT_TYPE(raw_sit); 1978 se->mtime = le64_to_cpu(raw_sit->mtime); 1979 } 1980 1981 void seg_info_from_raw_sit(struct f2fs_sb_info *sbi, struct seg_entry *se, 1982 struct f2fs_sit_entry *raw_sit) 1983 { 1984 __seg_info_from_raw_sit(se, raw_sit); 1985 1986 if (!need_fsync_data_record(sbi)) 1987 return; 1988 se->ckpt_valid_blocks = se->valid_blocks; 1989 memcpy(se->ckpt_valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 1990 se->ckpt_type = se->type; 1991 } 1992 1993 struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi, 1994 unsigned int segno) 1995 { 1996 struct sit_info *sit_i = SIT_I(sbi); 1997 return &sit_i->sentries[segno]; 1998 } 1999 2000 unsigned short get_seg_vblocks(struct f2fs_sb_info *sbi, struct seg_entry *se) 2001 { 2002 if (!need_fsync_data_record(sbi)) 2003 return se->valid_blocks; 2004 else 2005 return se->ckpt_valid_blocks; 2006 } 2007 2008 unsigned char *get_seg_bitmap(struct f2fs_sb_info *sbi, struct seg_entry *se) 2009 { 2010 if (!need_fsync_data_record(sbi)) 2011 return se->cur_valid_map; 2012 else 2013 return se->ckpt_valid_map; 2014 } 2015 2016 unsigned char get_seg_type(struct f2fs_sb_info *sbi, struct seg_entry *se) 2017 { 2018 if (!need_fsync_data_record(sbi)) 2019 return se->type; 2020 else 2021 return se->ckpt_type; 2022 } 2023 2024 struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *sbi, 2025 unsigned int segno, int *ret_type) 2026 { 2027 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 2028 struct f2fs_summary_block *sum_blk; 2029 struct curseg_info *curseg; 2030 int type, ret; 2031 u64 ssa_blk; 2032 2033 *ret_type= SEG_TYPE_MAX; 2034 2035 ssa_blk = GET_SUM_BLKADDR(sbi, segno); 2036 for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) { 2037 if (segno == get_cp(cur_node_segno[type])) { 2038 curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type); 2039 if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { 2040 ASSERT_MSG("segno [0x%x] indicates a data " 2041 "segment, but should be node", 2042 segno); 2043 *ret_type = -SEG_TYPE_CUR_NODE; 2044 } else { 2045 *ret_type = SEG_TYPE_CUR_NODE; 2046 } 2047 return curseg->sum_blk; 2048 } 2049 } 2050 2051 for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) { 2052 if (segno == get_cp(cur_data_segno[type])) { 2053 curseg = CURSEG_I(sbi, type); 2054 if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) { 2055 ASSERT_MSG("segno [0x%x] indicates a node " 2056 "segment, but should be data", 2057 segno); 2058 *ret_type = -SEG_TYPE_CUR_DATA; 2059 } else { 2060 *ret_type = SEG_TYPE_CUR_DATA; 2061 } 2062 return curseg->sum_blk; 2063 } 2064 } 2065 2066 sum_blk = calloc(BLOCK_SZ, 1); 2067 ASSERT(sum_blk); 2068 2069 ret = dev_read_block(sum_blk, ssa_blk); 2070 ASSERT(ret >= 0); 2071 2072 if (IS_SUM_NODE_SEG(sum_blk->footer)) 2073 *ret_type = SEG_TYPE_NODE; 2074 else if (IS_SUM_DATA_SEG(sum_blk->footer)) 2075 *ret_type = SEG_TYPE_DATA; 2076 2077 return sum_blk; 2078 } 2079 2080 int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr, 2081 struct f2fs_summary *sum_entry) 2082 { 2083 struct f2fs_summary_block *sum_blk; 2084 u32 segno, offset; 2085 int type; 2086 2087 segno = GET_SEGNO(sbi, blk_addr); 2088 offset = OFFSET_IN_SEG(sbi, blk_addr); 2089 2090 sum_blk = get_sum_block(sbi, segno, &type); 2091 memcpy(sum_entry, &(sum_blk->entries[offset]), 2092 sizeof(struct f2fs_summary)); 2093 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA || 2094 type == SEG_TYPE_MAX) 2095 free(sum_blk); 2096 return type; 2097 } 2098 2099 static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid, 2100 struct f2fs_nat_entry *raw_nat) 2101 { 2102 struct f2fs_nat_block *nat_block; 2103 pgoff_t block_addr; 2104 int entry_off; 2105 int ret; 2106 2107 if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0) 2108 return; 2109 2110 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 2111 ASSERT(nat_block); 2112 2113 entry_off = nid % NAT_ENTRY_PER_BLOCK; 2114 block_addr = current_nat_addr(sbi, nid, NULL); 2115 2116 ret = dev_read_block(nat_block, block_addr); 2117 ASSERT(ret >= 0); 2118 2119 memcpy(raw_nat, &nat_block->entries[entry_off], 2120 sizeof(struct f2fs_nat_entry)); 2121 free(nat_block); 2122 } 2123 2124 void update_data_blkaddr(struct f2fs_sb_info *sbi, nid_t nid, 2125 u16 ofs_in_node, block_t newaddr) 2126 { 2127 struct f2fs_node *node_blk = NULL; 2128 struct node_info ni; 2129 block_t oldaddr, startaddr, endaddr; 2130 int ret; 2131 2132 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1); 2133 ASSERT(node_blk); 2134 2135 get_node_info(sbi, nid, &ni); 2136 2137 /* read node_block */ 2138 ret = dev_read_block(node_blk, ni.blk_addr); 2139 ASSERT(ret >= 0); 2140 2141 /* check its block address */ 2142 if (node_blk->footer.nid == node_blk->footer.ino) { 2143 int ofs = get_extra_isize(node_blk); 2144 2145 oldaddr = le32_to_cpu(node_blk->i.i_addr[ofs + ofs_in_node]); 2146 node_blk->i.i_addr[ofs + ofs_in_node] = cpu_to_le32(newaddr); 2147 ret = write_inode(node_blk, ni.blk_addr); 2148 ASSERT(ret >= 0); 2149 } else { 2150 oldaddr = le32_to_cpu(node_blk->dn.addr[ofs_in_node]); 2151 node_blk->dn.addr[ofs_in_node] = cpu_to_le32(newaddr); 2152 ret = dev_write_block(node_blk, ni.blk_addr); 2153 ASSERT(ret >= 0); 2154 } 2155 2156 /* check extent cache entry */ 2157 if (node_blk->footer.nid != node_blk->footer.ino) { 2158 get_node_info(sbi, le32_to_cpu(node_blk->footer.ino), &ni); 2159 2160 /* read inode block */ 2161 ret = dev_read_block(node_blk, ni.blk_addr); 2162 ASSERT(ret >= 0); 2163 } 2164 2165 startaddr = le32_to_cpu(node_blk->i.i_ext.blk_addr); 2166 endaddr = startaddr + le32_to_cpu(node_blk->i.i_ext.len); 2167 if (oldaddr >= startaddr && oldaddr < endaddr) { 2168 node_blk->i.i_ext.len = 0; 2169 2170 /* update inode block */ 2171 ASSERT(write_inode(node_blk, ni.blk_addr) >= 0); 2172 } 2173 free(node_blk); 2174 } 2175 2176 void update_nat_blkaddr(struct f2fs_sb_info *sbi, nid_t ino, 2177 nid_t nid, block_t newaddr) 2178 { 2179 struct f2fs_nat_block *nat_block; 2180 pgoff_t block_addr; 2181 int entry_off; 2182 int ret; 2183 2184 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 2185 ASSERT(nat_block); 2186 2187 entry_off = nid % NAT_ENTRY_PER_BLOCK; 2188 block_addr = current_nat_addr(sbi, nid, NULL); 2189 2190 ret = dev_read_block(nat_block, block_addr); 2191 ASSERT(ret >= 0); 2192 2193 if (ino) 2194 nat_block->entries[entry_off].ino = cpu_to_le32(ino); 2195 nat_block->entries[entry_off].block_addr = cpu_to_le32(newaddr); 2196 if (c.func == FSCK) 2197 F2FS_FSCK(sbi)->entries[nid] = nat_block->entries[entry_off]; 2198 2199 ret = dev_write_block(nat_block, block_addr); 2200 ASSERT(ret >= 0); 2201 free(nat_block); 2202 } 2203 2204 void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni) 2205 { 2206 struct f2fs_nat_entry raw_nat; 2207 2208 ni->nid = nid; 2209 if (c.func == FSCK && F2FS_FSCK(sbi)->nr_nat_entries) { 2210 node_info_from_raw_nat(ni, &(F2FS_FSCK(sbi)->entries[nid])); 2211 if (ni->blk_addr) 2212 return; 2213 /* nat entry is not cached, read it */ 2214 } 2215 2216 get_nat_entry(sbi, nid, &raw_nat); 2217 node_info_from_raw_nat(ni, &raw_nat); 2218 } 2219 2220 static int build_sit_entries(struct f2fs_sb_info *sbi) 2221 { 2222 struct sit_info *sit_i = SIT_I(sbi); 2223 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 2224 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2225 struct f2fs_sit_block *sit_blk; 2226 struct seg_entry *se; 2227 struct f2fs_sit_entry sit; 2228 int sit_blk_cnt = SIT_BLK_CNT(sbi); 2229 unsigned int i, segno, end; 2230 unsigned int readed, start_blk = 0; 2231 2232 sit_blk = calloc(BLOCK_SZ, 1); 2233 if (!sit_blk) { 2234 MSG(1, "\tError: Calloc failed for build_sit_entries!\n"); 2235 return -ENOMEM; 2236 } 2237 2238 do { 2239 readed = f2fs_ra_meta_pages(sbi, start_blk, MAX_RA_BLOCKS, 2240 META_SIT); 2241 2242 segno = start_blk * sit_i->sents_per_block; 2243 end = (start_blk + readed) * sit_i->sents_per_block; 2244 2245 for (; segno < end && segno < TOTAL_SEGS(sbi); segno++) { 2246 se = &sit_i->sentries[segno]; 2247 2248 get_current_sit_page(sbi, segno, sit_blk); 2249 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 2250 2251 check_block_count(sbi, segno, &sit); 2252 seg_info_from_raw_sit(sbi, se, &sit); 2253 } 2254 start_blk += readed; 2255 } while (start_blk < sit_blk_cnt); 2256 2257 2258 free(sit_blk); 2259 2260 if (sits_in_cursum(journal) > SIT_JOURNAL_ENTRIES) { 2261 MSG(0, "\tError: build_sit_entries truncate n_sits(%u) to " 2262 "SIT_JOURNAL_ENTRIES(%lu)\n", 2263 sits_in_cursum(journal), SIT_JOURNAL_ENTRIES); 2264 journal->n_sits = cpu_to_le16(SIT_JOURNAL_ENTRIES); 2265 c.fix_on = 1; 2266 } 2267 2268 for (i = 0; i < sits_in_cursum(journal); i++) { 2269 segno = le32_to_cpu(segno_in_journal(journal, i)); 2270 2271 if (segno >= TOTAL_SEGS(sbi)) { 2272 MSG(0, "\tError: build_sit_entries: segno(%u) is invalid!!!\n", segno); 2273 journal->n_sits = cpu_to_le16(i); 2274 c.fix_on = 1; 2275 continue; 2276 } 2277 2278 se = &sit_i->sentries[segno]; 2279 sit = sit_in_journal(journal, i); 2280 2281 check_block_count(sbi, segno, &sit); 2282 seg_info_from_raw_sit(sbi, se, &sit); 2283 } 2284 return 0; 2285 } 2286 2287 static int early_build_segment_manager(struct f2fs_sb_info *sbi) 2288 { 2289 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 2290 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 2291 struct f2fs_sm_info *sm_info; 2292 2293 sm_info = malloc(sizeof(struct f2fs_sm_info)); 2294 if (!sm_info) { 2295 MSG(1, "\tError: Malloc failed for build_segment_manager!\n"); 2296 return -ENOMEM; 2297 } 2298 2299 /* init sm info */ 2300 sbi->sm_info = sm_info; 2301 sm_info->seg0_blkaddr = get_sb(segment0_blkaddr); 2302 sm_info->main_blkaddr = get_sb(main_blkaddr); 2303 sm_info->segment_count = get_sb(segment_count); 2304 sm_info->reserved_segments = get_cp(rsvd_segment_count); 2305 sm_info->ovp_segments = get_cp(overprov_segment_count); 2306 sm_info->main_segments = get_sb(segment_count_main); 2307 sm_info->ssa_blkaddr = get_sb(ssa_blkaddr); 2308 2309 if (build_sit_info(sbi) || build_curseg(sbi)) { 2310 free(sm_info); 2311 return -ENOMEM; 2312 } 2313 2314 return 0; 2315 } 2316 2317 static int late_build_segment_manager(struct f2fs_sb_info *sbi) 2318 { 2319 if (sbi->seg_manager_done) 2320 return 1; /* this function was already called */ 2321 2322 sbi->seg_manager_done = true; 2323 if (build_sit_entries(sbi)) { 2324 free (sbi->sm_info); 2325 return -ENOMEM; 2326 } 2327 2328 return 0; 2329 } 2330 2331 void build_sit_area_bitmap(struct f2fs_sb_info *sbi) 2332 { 2333 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 2334 struct f2fs_sm_info *sm_i = SM_I(sbi); 2335 unsigned int segno = 0; 2336 char *ptr = NULL; 2337 u32 sum_vblocks = 0; 2338 u32 free_segs = 0; 2339 struct seg_entry *se; 2340 2341 fsck->sit_area_bitmap_sz = sm_i->main_segments * SIT_VBLOCK_MAP_SIZE; 2342 fsck->sit_area_bitmap = calloc(1, fsck->sit_area_bitmap_sz); 2343 ASSERT(fsck->sit_area_bitmap); 2344 ptr = fsck->sit_area_bitmap; 2345 2346 ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz); 2347 2348 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 2349 se = get_seg_entry(sbi, segno); 2350 2351 memcpy(ptr, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 2352 ptr += SIT_VBLOCK_MAP_SIZE; 2353 2354 if (se->valid_blocks == 0x0) { 2355 if (le32_to_cpu(sbi->ckpt->cur_node_segno[0]) == segno || 2356 le32_to_cpu(sbi->ckpt->cur_data_segno[0]) == segno || 2357 le32_to_cpu(sbi->ckpt->cur_node_segno[1]) == segno || 2358 le32_to_cpu(sbi->ckpt->cur_data_segno[1]) == segno || 2359 le32_to_cpu(sbi->ckpt->cur_node_segno[2]) == segno || 2360 le32_to_cpu(sbi->ckpt->cur_data_segno[2]) == segno) { 2361 continue; 2362 } else { 2363 free_segs++; 2364 } 2365 } else { 2366 sum_vblocks += se->valid_blocks; 2367 } 2368 } 2369 fsck->chk.sit_valid_blocks = sum_vblocks; 2370 fsck->chk.sit_free_segs = free_segs; 2371 2372 DBG(1, "Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n", 2373 sum_vblocks, sum_vblocks, 2374 free_segs, free_segs); 2375 } 2376 2377 void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi) 2378 { 2379 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 2380 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 2381 struct sit_info *sit_i = SIT_I(sbi); 2382 struct f2fs_sit_block *sit_blk; 2383 unsigned int segno = 0; 2384 struct f2fs_summary_block *sum = curseg->sum_blk; 2385 char *ptr = NULL; 2386 2387 sit_blk = calloc(BLOCK_SZ, 1); 2388 ASSERT(sit_blk); 2389 /* remove sit journal */ 2390 sum->journal.n_sits = 0; 2391 2392 ptr = fsck->main_area_bitmap; 2393 2394 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 2395 struct f2fs_sit_entry *sit; 2396 struct seg_entry *se; 2397 u16 valid_blocks = 0; 2398 u16 type; 2399 int i; 2400 2401 get_current_sit_page(sbi, segno, sit_blk); 2402 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 2403 memcpy(sit->valid_map, ptr, SIT_VBLOCK_MAP_SIZE); 2404 2405 /* update valid block count */ 2406 for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++) 2407 valid_blocks += get_bits_in_byte(sit->valid_map[i]); 2408 2409 se = get_seg_entry(sbi, segno); 2410 memcpy(se->cur_valid_map, ptr, SIT_VBLOCK_MAP_SIZE); 2411 se->valid_blocks = valid_blocks; 2412 type = se->type; 2413 if (type >= NO_CHECK_TYPE) { 2414 ASSERT_MSG("Invalide type and valid blocks=%x,%x", 2415 segno, valid_blocks); 2416 type = 0; 2417 } 2418 sit->vblocks = cpu_to_le16((type << SIT_VBLOCKS_SHIFT) | 2419 valid_blocks); 2420 rewrite_current_sit_page(sbi, segno, sit_blk); 2421 2422 ptr += SIT_VBLOCK_MAP_SIZE; 2423 } 2424 2425 free(sit_blk); 2426 } 2427 2428 static int flush_sit_journal_entries(struct f2fs_sb_info *sbi) 2429 { 2430 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 2431 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2432 struct sit_info *sit_i = SIT_I(sbi); 2433 struct f2fs_sit_block *sit_blk; 2434 unsigned int segno; 2435 int i; 2436 2437 sit_blk = calloc(BLOCK_SZ, 1); 2438 ASSERT(sit_blk); 2439 for (i = 0; i < sits_in_cursum(journal); i++) { 2440 struct f2fs_sit_entry *sit; 2441 struct seg_entry *se; 2442 2443 segno = segno_in_journal(journal, i); 2444 se = get_seg_entry(sbi, segno); 2445 2446 get_current_sit_page(sbi, segno, sit_blk); 2447 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 2448 2449 memcpy(sit->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 2450 sit->vblocks = cpu_to_le16((se->type << SIT_VBLOCKS_SHIFT) | 2451 se->valid_blocks); 2452 sit->mtime = cpu_to_le64(se->mtime); 2453 2454 rewrite_current_sit_page(sbi, segno, sit_blk); 2455 } 2456 2457 free(sit_blk); 2458 journal->n_sits = 0; 2459 return i; 2460 } 2461 2462 static int flush_nat_journal_entries(struct f2fs_sb_info *sbi) 2463 { 2464 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 2465 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2466 struct f2fs_nat_block *nat_block; 2467 pgoff_t block_addr; 2468 int entry_off; 2469 nid_t nid; 2470 int ret; 2471 int i = 0; 2472 2473 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 2474 ASSERT(nat_block); 2475 next: 2476 if (i >= nats_in_cursum(journal)) { 2477 free(nat_block); 2478 journal->n_nats = 0; 2479 return i; 2480 } 2481 2482 nid = le32_to_cpu(nid_in_journal(journal, i)); 2483 2484 entry_off = nid % NAT_ENTRY_PER_BLOCK; 2485 block_addr = current_nat_addr(sbi, nid, NULL); 2486 2487 ret = dev_read_block(nat_block, block_addr); 2488 ASSERT(ret >= 0); 2489 2490 memcpy(&nat_block->entries[entry_off], &nat_in_journal(journal, i), 2491 sizeof(struct f2fs_nat_entry)); 2492 2493 ret = dev_write_block(nat_block, block_addr); 2494 ASSERT(ret >= 0); 2495 i++; 2496 goto next; 2497 } 2498 2499 void flush_journal_entries(struct f2fs_sb_info *sbi) 2500 { 2501 int n_nats = flush_nat_journal_entries(sbi); 2502 int n_sits = flush_sit_journal_entries(sbi); 2503 2504 if (n_nats || n_sits) 2505 write_checkpoints(sbi); 2506 } 2507 2508 void flush_sit_entries(struct f2fs_sb_info *sbi) 2509 { 2510 struct sit_info *sit_i = SIT_I(sbi); 2511 struct f2fs_sit_block *sit_blk; 2512 unsigned int segno = 0; 2513 2514 sit_blk = calloc(BLOCK_SZ, 1); 2515 ASSERT(sit_blk); 2516 /* update free segments */ 2517 for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) { 2518 struct f2fs_sit_entry *sit; 2519 struct seg_entry *se; 2520 2521 se = get_seg_entry(sbi, segno); 2522 2523 if (!se->dirty) 2524 continue; 2525 2526 get_current_sit_page(sbi, segno, sit_blk); 2527 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)]; 2528 memcpy(sit->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 2529 sit->vblocks = cpu_to_le16((se->type << SIT_VBLOCKS_SHIFT) | 2530 se->valid_blocks); 2531 rewrite_current_sit_page(sbi, segno, sit_blk); 2532 } 2533 2534 free(sit_blk); 2535 } 2536 2537 int relocate_curseg_offset(struct f2fs_sb_info *sbi, int type) 2538 { 2539 struct curseg_info *curseg = CURSEG_I(sbi, type); 2540 struct seg_entry *se = get_seg_entry(sbi, curseg->segno); 2541 unsigned int i; 2542 2543 if (c.zoned_model == F2FS_ZONED_HM) 2544 return -EINVAL; 2545 2546 for (i = 0; i < sbi->blocks_per_seg; i++) { 2547 if (!f2fs_test_bit(i, (const char *)se->cur_valid_map)) 2548 break; 2549 } 2550 2551 if (i == sbi->blocks_per_seg) 2552 return -EINVAL; 2553 2554 DBG(1, "Update curseg[%d].next_blkoff %u -> %u, alloc_type %s -> SSR\n", 2555 type, curseg->next_blkoff, i, 2556 curseg->alloc_type == LFS ? "LFS" : "SSR"); 2557 2558 curseg->next_blkoff = i; 2559 curseg->alloc_type = SSR; 2560 2561 return 0; 2562 } 2563 2564 void set_section_type(struct f2fs_sb_info *sbi, unsigned int segno, int type) 2565 { 2566 unsigned int i; 2567 2568 if (sbi->segs_per_sec == 1) 2569 return; 2570 2571 for (i = 0; i < sbi->segs_per_sec; i++) { 2572 struct seg_entry *se = get_seg_entry(sbi, segno + i); 2573 2574 se->type = type; 2575 } 2576 } 2577 2578 #ifdef HAVE_LINUX_BLKZONED_H 2579 2580 static bool write_pointer_at_zone_start(struct f2fs_sb_info *sbi, 2581 unsigned int zone_segno) 2582 { 2583 u_int64_t sector; 2584 struct blk_zone blkz; 2585 block_t block = START_BLOCK(sbi, zone_segno); 2586 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT; 2587 int ret, j; 2588 2589 if (c.zoned_model != F2FS_ZONED_HM) 2590 return true; 2591 2592 for (j = 0; j < MAX_DEVICES; j++) { 2593 if (!c.devices[j].path) 2594 break; 2595 if (c.devices[j].start_blkaddr <= block && 2596 block <= c.devices[j].end_blkaddr) 2597 break; 2598 } 2599 2600 if (j >= MAX_DEVICES) 2601 return false; 2602 2603 sector = (block - c.devices[j].start_blkaddr) << log_sectors_per_block; 2604 ret = f2fs_report_zone(j, sector, &blkz); 2605 if (ret) 2606 return false; 2607 2608 if (blk_zone_type(&blkz) != BLK_ZONE_TYPE_SEQWRITE_REQ) 2609 return true; 2610 2611 return blk_zone_sector(&blkz) == blk_zone_wp_sector(&blkz); 2612 } 2613 2614 #else 2615 2616 static bool write_pointer_at_zone_start(struct f2fs_sb_info *UNUSED(sbi), 2617 unsigned int UNUSED(zone_segno)) 2618 { 2619 return true; 2620 } 2621 2622 #endif 2623 2624 int find_next_free_block(struct f2fs_sb_info *sbi, u64 *to, int left, 2625 int want_type, bool new_sec) 2626 { 2627 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 2628 struct seg_entry *se; 2629 u32 segno; 2630 u32 offset; 2631 int not_enough = 0; 2632 u64 end_blkaddr = (get_sb(segment_count_main) << 2633 get_sb(log_blocks_per_seg)) + get_sb(main_blkaddr); 2634 2635 if (*to > 0) 2636 *to -= left; 2637 if (get_free_segments(sbi) <= SM_I(sbi)->reserved_segments + 1) 2638 not_enough = 1; 2639 2640 while (*to >= SM_I(sbi)->main_blkaddr && *to < end_blkaddr) { 2641 unsigned short vblocks; 2642 unsigned char *bitmap; 2643 unsigned char type; 2644 2645 segno = GET_SEGNO(sbi, *to); 2646 offset = OFFSET_IN_SEG(sbi, *to); 2647 2648 se = get_seg_entry(sbi, segno); 2649 2650 vblocks = get_seg_vblocks(sbi, se); 2651 bitmap = get_seg_bitmap(sbi, se); 2652 type = get_seg_type(sbi, se); 2653 2654 if (vblocks == sbi->blocks_per_seg || 2655 IS_CUR_SEGNO(sbi, segno)) { 2656 *to = left ? START_BLOCK(sbi, segno) - 1: 2657 START_BLOCK(sbi, segno + 1); 2658 continue; 2659 } 2660 2661 if (vblocks == 0 && not_enough) { 2662 *to = left ? START_BLOCK(sbi, segno) - 1: 2663 START_BLOCK(sbi, segno + 1); 2664 continue; 2665 } 2666 2667 if (vblocks == 0 && !(segno % sbi->segs_per_sec)) { 2668 struct seg_entry *se2; 2669 unsigned int i; 2670 2671 for (i = 1; i < sbi->segs_per_sec; i++) { 2672 se2 = get_seg_entry(sbi, segno + i); 2673 if (get_seg_vblocks(sbi, se2)) 2674 break; 2675 } 2676 2677 if (i == sbi->segs_per_sec && 2678 write_pointer_at_zone_start(sbi, segno)) { 2679 set_section_type(sbi, segno, want_type); 2680 return 0; 2681 } 2682 } 2683 2684 if (type == want_type && !new_sec && 2685 !f2fs_test_bit(offset, (const char *)bitmap)) 2686 return 0; 2687 2688 *to = left ? *to - 1: *to + 1; 2689 } 2690 return -1; 2691 } 2692 2693 static void move_one_curseg_info(struct f2fs_sb_info *sbi, u64 from, int left, 2694 int i) 2695 { 2696 struct curseg_info *curseg = CURSEG_I(sbi, i); 2697 struct f2fs_summary_block buf; 2698 u32 old_segno; 2699 u64 ssa_blk, to; 2700 int ret; 2701 2702 /* update original SSA too */ 2703 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno); 2704 ret = dev_write_block(curseg->sum_blk, ssa_blk); 2705 ASSERT(ret >= 0); 2706 2707 to = from; 2708 ret = find_next_free_block(sbi, &to, left, i, 2709 c.zoned_model == F2FS_ZONED_HM); 2710 ASSERT(ret == 0); 2711 2712 old_segno = curseg->segno; 2713 curseg->segno = GET_SEGNO(sbi, to); 2714 curseg->next_blkoff = OFFSET_IN_SEG(sbi, to); 2715 curseg->alloc_type = c.zoned_model == F2FS_ZONED_HM ? LFS : SSR; 2716 2717 /* update new segno */ 2718 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno); 2719 ret = dev_read_block(&buf, ssa_blk); 2720 ASSERT(ret >= 0); 2721 2722 memcpy(curseg->sum_blk, &buf, SUM_ENTRIES_SIZE); 2723 2724 /* update se->types */ 2725 reset_curseg(sbi, i); 2726 2727 FIX_MSG("Move curseg[%d] %x -> %x after %"PRIx64"\n", 2728 i, old_segno, curseg->segno, from); 2729 } 2730 2731 void move_curseg_info(struct f2fs_sb_info *sbi, u64 from, int left) 2732 { 2733 int i; 2734 2735 /* update summary blocks having nullified journal entries */ 2736 for (i = 0; i < NO_CHECK_TYPE; i++) 2737 move_one_curseg_info(sbi, from, left, i); 2738 } 2739 2740 void update_curseg_info(struct f2fs_sb_info *sbi, int type) 2741 { 2742 if (!relocate_curseg_offset(sbi, type)) 2743 return; 2744 move_one_curseg_info(sbi, SM_I(sbi)->main_blkaddr, 0, type); 2745 } 2746 2747 void zero_journal_entries(struct f2fs_sb_info *sbi) 2748 { 2749 int i; 2750 2751 for (i = 0; i < NO_CHECK_TYPE; i++) 2752 CURSEG_I(sbi, i)->sum_blk->journal.n_nats = 0; 2753 } 2754 2755 void write_curseg_info(struct f2fs_sb_info *sbi) 2756 { 2757 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 2758 int i; 2759 2760 for (i = 0; i < NO_CHECK_TYPE; i++) { 2761 cp->alloc_type[i] = CURSEG_I(sbi, i)->alloc_type; 2762 if (i < CURSEG_HOT_NODE) { 2763 set_cp(cur_data_segno[i], CURSEG_I(sbi, i)->segno); 2764 set_cp(cur_data_blkoff[i], 2765 CURSEG_I(sbi, i)->next_blkoff); 2766 } else { 2767 int n = i - CURSEG_HOT_NODE; 2768 2769 set_cp(cur_node_segno[n], CURSEG_I(sbi, i)->segno); 2770 set_cp(cur_node_blkoff[n], 2771 CURSEG_I(sbi, i)->next_blkoff); 2772 } 2773 } 2774 } 2775 2776 int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid, 2777 struct f2fs_nat_entry *raw_nat) 2778 { 2779 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 2780 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2781 int i = 0; 2782 2783 for (i = 0; i < nats_in_cursum(journal); i++) { 2784 if (le32_to_cpu(nid_in_journal(journal, i)) == nid) { 2785 memcpy(raw_nat, &nat_in_journal(journal, i), 2786 sizeof(struct f2fs_nat_entry)); 2787 DBG(3, "==> Found nid [0x%x] in nat cache\n", nid); 2788 return i; 2789 } 2790 } 2791 return -1; 2792 } 2793 2794 void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid) 2795 { 2796 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 2797 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2798 struct f2fs_nat_block *nat_block; 2799 pgoff_t block_addr; 2800 int entry_off; 2801 int ret; 2802 int i = 0; 2803 2804 /* check in journal */ 2805 for (i = 0; i < nats_in_cursum(journal); i++) { 2806 if (le32_to_cpu(nid_in_journal(journal, i)) == nid) { 2807 memset(&nat_in_journal(journal, i), 0, 2808 sizeof(struct f2fs_nat_entry)); 2809 FIX_MSG("Remove nid [0x%x] in nat journal", nid); 2810 return; 2811 } 2812 } 2813 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 2814 ASSERT(nat_block); 2815 2816 entry_off = nid % NAT_ENTRY_PER_BLOCK; 2817 block_addr = current_nat_addr(sbi, nid, NULL); 2818 2819 ret = dev_read_block(nat_block, block_addr); 2820 ASSERT(ret >= 0); 2821 2822 if (nid == F2FS_NODE_INO(sbi) || nid == F2FS_META_INO(sbi)) { 2823 FIX_MSG("nid [0x%x] block_addr= 0x%x -> 0x1", nid, 2824 le32_to_cpu(nat_block->entries[entry_off].block_addr)); 2825 nat_block->entries[entry_off].block_addr = cpu_to_le32(0x1); 2826 } else { 2827 memset(&nat_block->entries[entry_off], 0, 2828 sizeof(struct f2fs_nat_entry)); 2829 FIX_MSG("Remove nid [0x%x] in NAT", nid); 2830 } 2831 2832 ret = dev_write_block(nat_block, block_addr); 2833 ASSERT(ret >= 0); 2834 free(nat_block); 2835 } 2836 2837 void duplicate_checkpoint(struct f2fs_sb_info *sbi) 2838 { 2839 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 2840 unsigned long long dst, src; 2841 void *buf; 2842 unsigned int seg_size = 1 << get_sb(log_blocks_per_seg); 2843 int ret; 2844 2845 if (sbi->cp_backuped) 2846 return; 2847 2848 buf = malloc(F2FS_BLKSIZE * seg_size); 2849 ASSERT(buf); 2850 2851 if (sbi->cur_cp == 1) { 2852 src = get_sb(cp_blkaddr); 2853 dst = src + seg_size; 2854 } else { 2855 dst = get_sb(cp_blkaddr); 2856 src = dst + seg_size; 2857 } 2858 2859 ret = dev_read(buf, src << F2FS_BLKSIZE_BITS, 2860 seg_size << F2FS_BLKSIZE_BITS); 2861 ASSERT(ret >= 0); 2862 2863 ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS, 2864 seg_size << F2FS_BLKSIZE_BITS); 2865 ASSERT(ret >= 0); 2866 2867 free(buf); 2868 2869 ret = f2fs_fsync_device(); 2870 ASSERT(ret >= 0); 2871 2872 sbi->cp_backuped = 1; 2873 2874 MSG(0, "Info: Duplicate valid checkpoint to mirror position " 2875 "%llu -> %llu\n", src, dst); 2876 } 2877 2878 void write_checkpoint(struct f2fs_sb_info *sbi) 2879 { 2880 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi); 2881 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 2882 block_t orphan_blks = 0; 2883 unsigned long long cp_blk_no; 2884 u32 flags = CP_UMOUNT_FLAG; 2885 int i, ret; 2886 u_int32_t crc = 0; 2887 2888 if (is_set_ckpt_flags(cp, CP_ORPHAN_PRESENT_FLAG)) { 2889 orphan_blks = __start_sum_addr(sbi) - 1; 2890 flags |= CP_ORPHAN_PRESENT_FLAG; 2891 } 2892 if (is_set_ckpt_flags(cp, CP_TRIMMED_FLAG)) 2893 flags |= CP_TRIMMED_FLAG; 2894 if (is_set_ckpt_flags(cp, CP_DISABLED_FLAG)) 2895 flags |= CP_DISABLED_FLAG; 2896 if (is_set_ckpt_flags(cp, CP_LARGE_NAT_BITMAP_FLAG)) { 2897 flags |= CP_LARGE_NAT_BITMAP_FLAG; 2898 set_cp(checksum_offset, CP_MIN_CHKSUM_OFFSET); 2899 } else { 2900 set_cp(checksum_offset, CP_CHKSUM_OFFSET); 2901 } 2902 2903 set_cp(free_segment_count, get_free_segments(sbi)); 2904 if (c.func == FSCK) { 2905 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 2906 2907 set_cp(valid_block_count, fsck->chk.valid_blk_cnt); 2908 set_cp(valid_node_count, fsck->chk.valid_node_cnt); 2909 set_cp(valid_inode_count, fsck->chk.valid_inode_cnt); 2910 } else { 2911 set_cp(valid_block_count, sbi->total_valid_block_count); 2912 set_cp(valid_node_count, sbi->total_valid_node_count); 2913 set_cp(valid_inode_count, sbi->total_valid_inode_count); 2914 } 2915 set_cp(cp_pack_total_block_count, 8 + orphan_blks + get_sb(cp_payload)); 2916 2917 flags = update_nat_bits_flags(sb, cp, flags); 2918 set_cp(ckpt_flags, flags); 2919 2920 crc = f2fs_checkpoint_chksum(cp); 2921 *((__le32 *)((unsigned char *)cp + get_cp(checksum_offset))) = 2922 cpu_to_le32(crc); 2923 2924 cp_blk_no = get_sb(cp_blkaddr); 2925 if (sbi->cur_cp == 2) 2926 cp_blk_no += 1 << get_sb(log_blocks_per_seg); 2927 2928 /* write the first cp */ 2929 ret = dev_write_block(cp, cp_blk_no++); 2930 ASSERT(ret >= 0); 2931 2932 /* skip payload */ 2933 cp_blk_no += get_sb(cp_payload); 2934 /* skip orphan blocks */ 2935 cp_blk_no += orphan_blks; 2936 2937 /* update summary blocks having nullified journal entries */ 2938 for (i = 0; i < NO_CHECK_TYPE; i++) { 2939 struct curseg_info *curseg = CURSEG_I(sbi, i); 2940 u64 ssa_blk; 2941 2942 ret = dev_write_block(curseg->sum_blk, cp_blk_no++); 2943 ASSERT(ret >= 0); 2944 2945 /* update original SSA too */ 2946 ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno); 2947 ret = dev_write_block(curseg->sum_blk, ssa_blk); 2948 ASSERT(ret >= 0); 2949 } 2950 2951 /* Write nat bits */ 2952 if (flags & CP_NAT_BITS_FLAG) 2953 write_nat_bits(sbi, sb, cp, sbi->cur_cp); 2954 2955 /* in case of sudden power off */ 2956 ret = f2fs_fsync_device(); 2957 ASSERT(ret >= 0); 2958 2959 /* write the last cp */ 2960 ret = dev_write_block(cp, cp_blk_no++); 2961 ASSERT(ret >= 0); 2962 2963 ret = f2fs_fsync_device(); 2964 ASSERT(ret >= 0); 2965 } 2966 2967 void write_checkpoints(struct f2fs_sb_info *sbi) 2968 { 2969 /* copy valid checkpoint to its mirror position */ 2970 duplicate_checkpoint(sbi); 2971 2972 /* repair checkpoint at CP #0 position */ 2973 sbi->cur_cp = 1; 2974 write_checkpoint(sbi); 2975 } 2976 2977 void build_nat_area_bitmap(struct f2fs_sb_info *sbi) 2978 { 2979 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 2980 struct f2fs_journal *journal = &curseg->sum_blk->journal; 2981 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 2982 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 2983 struct f2fs_nm_info *nm_i = NM_I(sbi); 2984 struct f2fs_nat_block *nat_block; 2985 struct node_info ni; 2986 u32 nid, nr_nat_blks; 2987 pgoff_t block_off; 2988 pgoff_t block_addr; 2989 int seg_off; 2990 int ret; 2991 unsigned int i; 2992 2993 nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1); 2994 ASSERT(nat_block); 2995 2996 /* Alloc & build nat entry bitmap */ 2997 nr_nat_blks = (get_sb(segment_count_nat) / 2) << 2998 sbi->log_blocks_per_seg; 2999 3000 fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK; 3001 fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8; 3002 fsck->nat_area_bitmap = calloc(fsck->nat_area_bitmap_sz, 1); 3003 ASSERT(fsck->nat_area_bitmap); 3004 3005 fsck->entries = calloc(sizeof(struct f2fs_nat_entry), 3006 fsck->nr_nat_entries); 3007 ASSERT(fsck->entries); 3008 3009 for (block_off = 0; block_off < nr_nat_blks; block_off++) { 3010 3011 seg_off = block_off >> sbi->log_blocks_per_seg; 3012 block_addr = (pgoff_t)(nm_i->nat_blkaddr + 3013 (seg_off << sbi->log_blocks_per_seg << 1) + 3014 (block_off & ((1 << sbi->log_blocks_per_seg) - 1))); 3015 3016 if (f2fs_test_bit(block_off, nm_i->nat_bitmap)) 3017 block_addr += sbi->blocks_per_seg; 3018 3019 ret = dev_read_block(nat_block, block_addr); 3020 ASSERT(ret >= 0); 3021 3022 nid = block_off * NAT_ENTRY_PER_BLOCK; 3023 for (i = 0; i < NAT_ENTRY_PER_BLOCK; i++) { 3024 ni.nid = nid + i; 3025 3026 if ((nid + i) == F2FS_NODE_INO(sbi) || 3027 (nid + i) == F2FS_META_INO(sbi)) { 3028 /* 3029 * block_addr of node/meta inode should be 0x1. 3030 * Set this bit, and fsck_verify will fix it. 3031 */ 3032 if (le32_to_cpu(nat_block->entries[i].block_addr) != 0x1) { 3033 ASSERT_MSG("\tError: ino[0x%x] block_addr[0x%x] is invalid\n", 3034 nid + i, le32_to_cpu(nat_block->entries[i].block_addr)); 3035 f2fs_set_bit(nid + i, fsck->nat_area_bitmap); 3036 } 3037 continue; 3038 } 3039 3040 node_info_from_raw_nat(&ni, &nat_block->entries[i]); 3041 if (ni.blk_addr == 0x0) 3042 continue; 3043 if (ni.ino == 0x0) { 3044 ASSERT_MSG("\tError: ino[0x%8x] or blk_addr[0x%16x]" 3045 " is invalid\n", ni.ino, ni.blk_addr); 3046 } 3047 if (ni.ino == (nid + i)) { 3048 fsck->nat_valid_inode_cnt++; 3049 DBG(3, "ino[0x%8x] maybe is inode\n", ni.ino); 3050 } 3051 if (nid + i == 0) { 3052 /* 3053 * nat entry [0] must be null. If 3054 * it is corrupted, set its bit in 3055 * nat_area_bitmap, fsck_verify will 3056 * nullify it 3057 */ 3058 ASSERT_MSG("Invalid nat entry[0]: " 3059 "blk_addr[0x%x]\n", ni.blk_addr); 3060 fsck->chk.valid_nat_entry_cnt--; 3061 } 3062 3063 DBG(3, "nid[0x%8x] addr[0x%16x] ino[0x%8x]\n", 3064 nid + i, ni.blk_addr, ni.ino); 3065 f2fs_set_bit(nid + i, fsck->nat_area_bitmap); 3066 fsck->chk.valid_nat_entry_cnt++; 3067 3068 fsck->entries[nid + i] = nat_block->entries[i]; 3069 } 3070 } 3071 3072 /* Traverse nat journal, update the corresponding entries */ 3073 for (i = 0; i < nats_in_cursum(journal); i++) { 3074 struct f2fs_nat_entry raw_nat; 3075 nid = le32_to_cpu(nid_in_journal(journal, i)); 3076 ni.nid = nid; 3077 3078 DBG(3, "==> Found nid [0x%x] in nat cache, update it\n", nid); 3079 3080 /* Clear the original bit and count */ 3081 if (fsck->entries[nid].block_addr != 0x0) { 3082 fsck->chk.valid_nat_entry_cnt--; 3083 f2fs_clear_bit(nid, fsck->nat_area_bitmap); 3084 if (fsck->entries[nid].ino == nid) 3085 fsck->nat_valid_inode_cnt--; 3086 } 3087 3088 /* Use nat entries in journal */ 3089 memcpy(&raw_nat, &nat_in_journal(journal, i), 3090 sizeof(struct f2fs_nat_entry)); 3091 node_info_from_raw_nat(&ni, &raw_nat); 3092 if (ni.blk_addr != 0x0) { 3093 if (ni.ino == 0x0) 3094 ASSERT_MSG("\tError: ino[0x%8x] or blk_addr[0x%16x]" 3095 " is invalid\n", ni.ino, ni.blk_addr); 3096 if (ni.ino == nid) { 3097 fsck->nat_valid_inode_cnt++; 3098 DBG(3, "ino[0x%8x] maybe is inode\n", ni.ino); 3099 } 3100 f2fs_set_bit(nid, fsck->nat_area_bitmap); 3101 fsck->chk.valid_nat_entry_cnt++; 3102 DBG(3, "nid[0x%x] in nat cache\n", nid); 3103 } 3104 fsck->entries[nid] = raw_nat; 3105 } 3106 free(nat_block); 3107 3108 DBG(1, "valid nat entries (block_addr != 0x0) [0x%8x : %u]\n", 3109 fsck->chk.valid_nat_entry_cnt, 3110 fsck->chk.valid_nat_entry_cnt); 3111 } 3112 3113 static int check_sector_size(struct f2fs_super_block *sb) 3114 { 3115 u_int32_t log_sectorsize, log_sectors_per_block; 3116 3117 log_sectorsize = log_base_2(c.sector_size); 3118 log_sectors_per_block = log_base_2(c.sectors_per_blk); 3119 3120 if (log_sectorsize == get_sb(log_sectorsize) && 3121 log_sectors_per_block == get_sb(log_sectors_per_block)) 3122 return 0; 3123 3124 set_sb(log_sectorsize, log_sectorsize); 3125 set_sb(log_sectors_per_block, log_sectors_per_block); 3126 3127 update_superblock(sb, SB_MASK_ALL); 3128 return 0; 3129 } 3130 3131 static int tune_sb_features(struct f2fs_sb_info *sbi) 3132 { 3133 int sb_changed = 0; 3134 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi); 3135 3136 if (!(sb->feature & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) && 3137 c.feature & cpu_to_le32(F2FS_FEATURE_ENCRYPT)) { 3138 sb->feature |= cpu_to_le32(F2FS_FEATURE_ENCRYPT); 3139 MSG(0, "Info: Set Encryption feature\n"); 3140 sb_changed = 1; 3141 } 3142 if (!(sb->feature & cpu_to_le32(F2FS_FEATURE_CASEFOLD)) && 3143 c.feature & cpu_to_le32(F2FS_FEATURE_CASEFOLD)) { 3144 if (!c.s_encoding) { 3145 ERR_MSG("ERROR: Must specify encoding to enable casefolding.\n"); 3146 return -1; 3147 } 3148 sb->feature |= cpu_to_le32(F2FS_FEATURE_CASEFOLD); 3149 MSG(0, "Info: Set Casefold feature\n"); 3150 sb_changed = 1; 3151 } 3152 /* TODO: quota needs to allocate inode numbers */ 3153 3154 c.feature = sb->feature; 3155 if (!sb_changed) 3156 return 0; 3157 3158 update_superblock(sb, SB_MASK_ALL); 3159 return 0; 3160 } 3161 3162 static struct fsync_inode_entry *get_fsync_inode(struct list_head *head, 3163 nid_t ino) 3164 { 3165 struct fsync_inode_entry *entry; 3166 3167 list_for_each_entry(entry, head, list) 3168 if (entry->ino == ino) 3169 return entry; 3170 3171 return NULL; 3172 } 3173 3174 static struct fsync_inode_entry *add_fsync_inode(struct list_head *head, 3175 nid_t ino) 3176 { 3177 struct fsync_inode_entry *entry; 3178 3179 entry = calloc(sizeof(struct fsync_inode_entry), 1); 3180 if (!entry) 3181 return NULL; 3182 entry->ino = ino; 3183 list_add_tail(&entry->list, head); 3184 return entry; 3185 } 3186 3187 static void del_fsync_inode(struct fsync_inode_entry *entry) 3188 { 3189 list_del(&entry->list); 3190 free(entry); 3191 } 3192 3193 static void destroy_fsync_dnodes(struct list_head *head) 3194 { 3195 struct fsync_inode_entry *entry, *tmp; 3196 3197 list_for_each_entry_safe(entry, tmp, head, list) 3198 del_fsync_inode(entry); 3199 } 3200 3201 static int find_fsync_inode(struct f2fs_sb_info *sbi, struct list_head *head) 3202 { 3203 struct curseg_info *curseg; 3204 struct f2fs_node *node_blk; 3205 block_t blkaddr; 3206 unsigned int loop_cnt = 0; 3207 unsigned int free_blocks = TOTAL_SEGS(sbi) * sbi->blocks_per_seg - 3208 sbi->total_valid_block_count; 3209 int err = 0; 3210 3211 /* get node pages in the current segment */ 3212 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE); 3213 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg); 3214 3215 node_blk = calloc(F2FS_BLKSIZE, 1); 3216 ASSERT(node_blk); 3217 3218 while (1) { 3219 struct fsync_inode_entry *entry; 3220 3221 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR)) 3222 break; 3223 3224 err = dev_read_block(node_blk, blkaddr); 3225 if (err) 3226 break; 3227 3228 if (!is_recoverable_dnode(sbi, node_blk)) 3229 break; 3230 3231 if (!is_fsync_dnode(node_blk)) 3232 goto next; 3233 3234 entry = get_fsync_inode(head, ino_of_node(node_blk)); 3235 if (!entry) { 3236 entry = add_fsync_inode(head, ino_of_node(node_blk)); 3237 if (!entry) { 3238 err = -1; 3239 break; 3240 } 3241 } 3242 entry->blkaddr = blkaddr; 3243 3244 if (IS_INODE(node_blk) && is_dent_dnode(node_blk)) 3245 entry->last_dentry = blkaddr; 3246 next: 3247 /* sanity check in order to detect looped node chain */ 3248 if (++loop_cnt >= free_blocks || 3249 blkaddr == next_blkaddr_of_node(node_blk)) { 3250 MSG(0, "\tdetect looped node chain, blkaddr:%u, next:%u\n", 3251 blkaddr, 3252 next_blkaddr_of_node(node_blk)); 3253 err = -1; 3254 break; 3255 } 3256 3257 blkaddr = next_blkaddr_of_node(node_blk); 3258 } 3259 3260 free(node_blk); 3261 return err; 3262 } 3263 3264 static int do_record_fsync_data(struct f2fs_sb_info *sbi, 3265 struct f2fs_node *node_blk, 3266 block_t blkaddr) 3267 { 3268 unsigned int segno, offset; 3269 struct seg_entry *se; 3270 unsigned int ofs_in_node = 0; 3271 unsigned int start, end; 3272 int err = 0, recorded = 0; 3273 3274 segno = GET_SEGNO(sbi, blkaddr); 3275 se = get_seg_entry(sbi, segno); 3276 offset = OFFSET_IN_SEG(sbi, blkaddr); 3277 3278 if (f2fs_test_bit(offset, (char *)se->cur_valid_map)) { 3279 ASSERT(0); 3280 return -1; 3281 } 3282 if (f2fs_test_bit(offset, (char *)se->ckpt_valid_map)) { 3283 ASSERT(0); 3284 return -1; 3285 } 3286 3287 if (!se->ckpt_valid_blocks) 3288 se->ckpt_type = CURSEG_WARM_NODE; 3289 3290 se->ckpt_valid_blocks++; 3291 f2fs_set_bit(offset, (char *)se->ckpt_valid_map); 3292 3293 MSG(1, "do_record_fsync_data: [node] ino = %u, nid = %u, blkaddr = %u\n", 3294 ino_of_node(node_blk), ofs_of_node(node_blk), blkaddr); 3295 3296 /* inline data */ 3297 if (IS_INODE(node_blk) && (node_blk->i.i_inline & F2FS_INLINE_DATA)) 3298 return 0; 3299 /* xattr node */ 3300 if (ofs_of_node(node_blk) == XATTR_NODE_OFFSET) 3301 return 0; 3302 3303 /* step 3: recover data indices */ 3304 start = start_bidx_of_node(ofs_of_node(node_blk), node_blk); 3305 end = start + ADDRS_PER_PAGE(sbi, node_blk, NULL); 3306 3307 for (; start < end; start++, ofs_in_node++) { 3308 blkaddr = datablock_addr(node_blk, ofs_in_node); 3309 3310 if (!is_valid_data_blkaddr(blkaddr)) 3311 continue; 3312 3313 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR)) { 3314 err = -1; 3315 goto out; 3316 } 3317 3318 segno = GET_SEGNO(sbi, blkaddr); 3319 se = get_seg_entry(sbi, segno); 3320 offset = OFFSET_IN_SEG(sbi, blkaddr); 3321 3322 if (f2fs_test_bit(offset, (char *)se->cur_valid_map)) 3323 continue; 3324 if (f2fs_test_bit(offset, (char *)se->ckpt_valid_map)) 3325 continue; 3326 3327 if (!se->ckpt_valid_blocks) 3328 se->ckpt_type = CURSEG_WARM_DATA; 3329 3330 se->ckpt_valid_blocks++; 3331 f2fs_set_bit(offset, (char *)se->ckpt_valid_map); 3332 3333 MSG(1, "do_record_fsync_data: [data] ino = %u, nid = %u, blkaddr = %u\n", 3334 ino_of_node(node_blk), ofs_of_node(node_blk), blkaddr); 3335 3336 recorded++; 3337 } 3338 out: 3339 MSG(1, "recover_data: ino = %u, nid = %u, recorded = %d, err = %d\n", 3340 ino_of_node(node_blk), ofs_of_node(node_blk), 3341 recorded, err); 3342 return err; 3343 } 3344 3345 static int traverse_dnodes(struct f2fs_sb_info *sbi, 3346 struct list_head *inode_list) 3347 { 3348 struct curseg_info *curseg; 3349 struct f2fs_node *node_blk; 3350 block_t blkaddr; 3351 int err = 0; 3352 3353 /* get node pages in the current segment */ 3354 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE); 3355 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg); 3356 3357 node_blk = calloc(F2FS_BLKSIZE, 1); 3358 ASSERT(node_blk); 3359 3360 while (1) { 3361 struct fsync_inode_entry *entry; 3362 3363 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR)) 3364 break; 3365 3366 err = dev_read_block(node_blk, blkaddr); 3367 if (err) 3368 break; 3369 3370 if (!is_recoverable_dnode(sbi, node_blk)) 3371 break; 3372 3373 entry = get_fsync_inode(inode_list, 3374 ino_of_node(node_blk)); 3375 if (!entry) 3376 goto next; 3377 3378 err = do_record_fsync_data(sbi, node_blk, blkaddr); 3379 if (err) 3380 break; 3381 3382 if (entry->blkaddr == blkaddr) 3383 del_fsync_inode(entry); 3384 next: 3385 blkaddr = next_blkaddr_of_node(node_blk); 3386 } 3387 3388 free(node_blk); 3389 return err; 3390 } 3391 3392 static int record_fsync_data(struct f2fs_sb_info *sbi) 3393 { 3394 struct list_head inode_list = LIST_HEAD_INIT(inode_list); 3395 int ret; 3396 3397 if (!need_fsync_data_record(sbi)) 3398 return 0; 3399 3400 ret = find_fsync_inode(sbi, &inode_list); 3401 if (ret) 3402 goto out; 3403 3404 ret = late_build_segment_manager(sbi); 3405 if (ret < 0) { 3406 ERR_MSG("late_build_segment_manager failed\n"); 3407 goto out; 3408 } 3409 3410 ret = traverse_dnodes(sbi, &inode_list); 3411 out: 3412 destroy_fsync_dnodes(&inode_list); 3413 return ret; 3414 } 3415 3416 int f2fs_do_mount(struct f2fs_sb_info *sbi) 3417 { 3418 struct f2fs_checkpoint *cp = NULL; 3419 struct f2fs_super_block *sb = NULL; 3420 int ret; 3421 3422 sbi->active_logs = NR_CURSEG_TYPE; 3423 ret = validate_super_block(sbi, SB0_ADDR); 3424 if (ret) { 3425 ret = validate_super_block(sbi, SB1_ADDR); 3426 if (ret) 3427 return -1; 3428 } 3429 sb = F2FS_RAW_SUPER(sbi); 3430 3431 ret = check_sector_size(sb); 3432 if (ret) 3433 return -1; 3434 3435 print_raw_sb_info(sb); 3436 3437 init_sb_info(sbi); 3438 3439 ret = get_valid_checkpoint(sbi); 3440 if (ret) { 3441 ERR_MSG("Can't find valid checkpoint\n"); 3442 return -1; 3443 } 3444 3445 c.bug_on = 0; 3446 3447 if (sanity_check_ckpt(sbi)) { 3448 ERR_MSG("Checkpoint is polluted\n"); 3449 return -1; 3450 } 3451 cp = F2FS_CKPT(sbi); 3452 3453 if (c.func != FSCK && c.func != DUMP && 3454 !is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) { 3455 ERR_MSG("Mount unclean image to replay log first\n"); 3456 return -1; 3457 } 3458 3459 print_ckpt_info(sbi); 3460 3461 if (c.quota_fix) { 3462 if (get_cp(ckpt_flags) & CP_QUOTA_NEED_FSCK_FLAG) 3463 c.fix_on = 1; 3464 } 3465 3466 if (tune_sb_features(sbi)) 3467 return -1; 3468 3469 /* precompute checksum seed for metadata */ 3470 if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM)) 3471 c.chksum_seed = f2fs_cal_crc32(~0, sb->uuid, sizeof(sb->uuid)); 3472 3473 sbi->total_valid_node_count = get_cp(valid_node_count); 3474 sbi->total_valid_inode_count = get_cp(valid_inode_count); 3475 sbi->user_block_count = get_cp(user_block_count); 3476 sbi->total_valid_block_count = get_cp(valid_block_count); 3477 sbi->last_valid_block_count = sbi->total_valid_block_count; 3478 sbi->alloc_valid_block_count = 0; 3479 3480 if (early_build_segment_manager(sbi)) { 3481 ERR_MSG("early_build_segment_manager failed\n"); 3482 return -1; 3483 } 3484 3485 if (build_node_manager(sbi)) { 3486 ERR_MSG("build_node_manager failed\n"); 3487 return -1; 3488 } 3489 3490 if (record_fsync_data(sbi)) { 3491 ERR_MSG("record_fsync_data failed\n"); 3492 return -1; 3493 } 3494 3495 if (!f2fs_should_proceed(sb, get_cp(ckpt_flags))) 3496 return 1; 3497 3498 if (late_build_segment_manager(sbi) < 0) { 3499 ERR_MSG("late_build_segment_manager failed\n"); 3500 return -1; 3501 } 3502 3503 if (f2fs_late_init_nid_bitmap(sbi)) { 3504 ERR_MSG("f2fs_late_init_nid_bitmap failed\n"); 3505 return -1; 3506 } 3507 3508 /* Check nat_bits */ 3509 if (c.func == FSCK && is_set_ckpt_flags(cp, CP_NAT_BITS_FLAG)) { 3510 if (check_nat_bits(sbi, sb, cp) && c.fix_on) 3511 write_nat_bits(sbi, sb, cp, sbi->cur_cp); 3512 } 3513 return 0; 3514 } 3515 3516 void f2fs_do_umount(struct f2fs_sb_info *sbi) 3517 { 3518 struct sit_info *sit_i = SIT_I(sbi); 3519 struct f2fs_sm_info *sm_i = SM_I(sbi); 3520 struct f2fs_nm_info *nm_i = NM_I(sbi); 3521 unsigned int i; 3522 3523 /* free nm_info */ 3524 if (c.func == SLOAD || c.func == FSCK) 3525 free(nm_i->nid_bitmap); 3526 free(nm_i->nat_bitmap); 3527 free(sbi->nm_info); 3528 3529 /* free sit_info */ 3530 free(sit_i->bitmap); 3531 free(sit_i->sit_bitmap); 3532 free(sit_i->sentries); 3533 free(sm_i->sit_info); 3534 3535 /* free sm_info */ 3536 for (i = 0; i < NR_CURSEG_TYPE; i++) 3537 free(sm_i->curseg_array[i].sum_blk); 3538 3539 free(sm_i->curseg_array); 3540 free(sbi->sm_info); 3541 3542 free(sbi->ckpt); 3543 free(sbi->raw_super); 3544 } 3545 3546 #ifdef WITH_ANDROID 3547 int f2fs_sparse_initialize_meta(struct f2fs_sb_info *sbi) 3548 { 3549 struct f2fs_super_block *sb = sbi->raw_super; 3550 u_int32_t sit_seg_count, sit_size; 3551 u_int32_t nat_seg_count, nat_size; 3552 u_int64_t sit_seg_addr, nat_seg_addr, payload_addr; 3553 u_int32_t seg_size = 1 << get_sb(log_blocks_per_seg); 3554 int ret; 3555 3556 if (!c.sparse_mode) 3557 return 0; 3558 3559 sit_seg_addr = get_sb(sit_blkaddr); 3560 sit_seg_count = get_sb(segment_count_sit); 3561 sit_size = sit_seg_count * seg_size; 3562 3563 DBG(1, "\tSparse: filling sit area at block offset: 0x%08"PRIx64" len: %u\n", 3564 sit_seg_addr, sit_size); 3565 ret = dev_fill(NULL, sit_seg_addr * F2FS_BLKSIZE, 3566 sit_size * F2FS_BLKSIZE); 3567 if (ret) { 3568 MSG(1, "\tError: While zeroing out the sit area " 3569 "on disk!!!\n"); 3570 return -1; 3571 } 3572 3573 nat_seg_addr = get_sb(nat_blkaddr); 3574 nat_seg_count = get_sb(segment_count_nat); 3575 nat_size = nat_seg_count * seg_size; 3576 3577 DBG(1, "\tSparse: filling nat area at block offset 0x%08"PRIx64" len: %u\n", 3578 nat_seg_addr, nat_size); 3579 ret = dev_fill(NULL, nat_seg_addr * F2FS_BLKSIZE, 3580 nat_size * F2FS_BLKSIZE); 3581 if (ret) { 3582 MSG(1, "\tError: While zeroing out the nat area " 3583 "on disk!!!\n"); 3584 return -1; 3585 } 3586 3587 payload_addr = get_sb(segment0_blkaddr) + 1; 3588 3589 DBG(1, "\tSparse: filling bitmap area at block offset 0x%08"PRIx64" len: %u\n", 3590 payload_addr, get_sb(cp_payload)); 3591 ret = dev_fill(NULL, payload_addr * F2FS_BLKSIZE, 3592 get_sb(cp_payload) * F2FS_BLKSIZE); 3593 if (ret) { 3594 MSG(1, "\tError: While zeroing out the nat/sit bitmap area " 3595 "on disk!!!\n"); 3596 return -1; 3597 } 3598 3599 payload_addr += seg_size; 3600 3601 DBG(1, "\tSparse: filling bitmap area at block offset 0x%08"PRIx64" len: %u\n", 3602 payload_addr, get_sb(cp_payload)); 3603 ret = dev_fill(NULL, payload_addr * F2FS_BLKSIZE, 3604 get_sb(cp_payload) * F2FS_BLKSIZE); 3605 if (ret) { 3606 MSG(1, "\tError: While zeroing out the nat/sit bitmap area " 3607 "on disk!!!\n"); 3608 return -1; 3609 } 3610 return 0; 3611 } 3612 #else 3613 int f2fs_sparse_initialize_meta(struct f2fs_sb_info *sbi) { return 0; } 3614 #endif 3615