1/** 2 * fsck.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 13char *tree_mark; 14uint32_t tree_mark_size = 256; 15 16static inline int f2fs_set_main_bitmap(struct f2fs_sb_info *sbi, u32 blk) 17{ 18 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 19 20 return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->main_area_bitmap); 21} 22 23static inline int f2fs_test_main_bitmap(struct f2fs_sb_info *sbi, u32 blk) 24{ 25 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 26 27 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk), 28 fsck->main_area_bitmap); 29} 30 31static inline int f2fs_test_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk) 32{ 33 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 34 35 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap); 36} 37 38static int add_into_hard_link_list(struct f2fs_sb_info *sbi, 39 u32 nid, u32 link_cnt) 40{ 41 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 42 struct hard_link_node *node = NULL, *tmp = NULL, *prev = NULL; 43 44 node = calloc(sizeof(struct hard_link_node), 1); 45 ASSERT(node != NULL); 46 47 node->nid = nid; 48 node->links = link_cnt; 49 node->next = NULL; 50 51 if (fsck->hard_link_list_head == NULL) { 52 fsck->hard_link_list_head = node; 53 goto out; 54 } 55 56 tmp = fsck->hard_link_list_head; 57 58 /* Find insertion position */ 59 while (tmp && (nid < tmp->nid)) { 60 ASSERT(tmp->nid != nid); 61 prev = tmp; 62 tmp = tmp->next; 63 } 64 65 if (tmp == fsck->hard_link_list_head) { 66 node->next = tmp; 67 fsck->hard_link_list_head = node; 68 } else { 69 prev->next = node; 70 node->next = tmp; 71 } 72 73out: 74 DBG(2, "ino[0x%x] has hard links [0x%x]\n", nid, link_cnt); 75 return 0; 76} 77 78static int find_and_dec_hard_link_list(struct f2fs_sb_info *sbi, u32 nid) 79{ 80 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 81 struct hard_link_node *node = NULL, *prev = NULL; 82 83 if (fsck->hard_link_list_head == NULL) 84 return -EINVAL; 85 86 node = fsck->hard_link_list_head; 87 88 while (node && (nid < node->nid)) { 89 prev = node; 90 node = node->next; 91 } 92 93 if (node == NULL || (nid != node->nid)) 94 return -EINVAL; 95 96 /* Decrease link count */ 97 node->links = node->links - 1; 98 99 /* if link count becomes one, remove the node */ 100 if (node->links == 1) { 101 if (fsck->hard_link_list_head == node) 102 fsck->hard_link_list_head = node->next; 103 else 104 prev->next = node->next; 105 free(node); 106 } 107 return 0; 108} 109 110static int is_valid_ssa_node_blk(struct f2fs_sb_info *sbi, u32 nid, 111 u32 blk_addr) 112{ 113 int ret = 0; 114 struct f2fs_summary sum_entry; 115 116 ret = get_sum_entry(sbi, blk_addr, &sum_entry); 117 118 if (ret != SEG_TYPE_NODE && ret != SEG_TYPE_CUR_NODE) { 119 ASSERT_MSG("Summary footer is not for node segment"); 120 return -EINVAL; 121 } 122 123 if (le32_to_cpu(sum_entry.nid) != nid) { 124 DBG(0, "nid [0x%x]\n", nid); 125 DBG(0, "target blk_addr [0x%x]\n", blk_addr); 126 DBG(0, "summary blk_addr [0x%x]\n", 127 GET_SUM_BLKADDR(sbi, 128 GET_SEGNO(sbi, blk_addr))); 129 DBG(0, "seg no / offset [0x%x / 0x%x]\n", 130 GET_SEGNO(sbi, blk_addr), 131 OFFSET_IN_SEG(sbi, blk_addr)); 132 DBG(0, "summary_entry.nid [0x%x]\n", 133 le32_to_cpu(sum_entry.nid)); 134 DBG(0, "--> node block's nid [0x%x]\n", nid); 135 ASSERT_MSG("Invalid node seg summary\n"); 136 return -EINVAL; 137 } 138 return 0; 139} 140 141static int is_valid_ssa_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr, 142 u32 parent_nid, u16 idx_in_node, u8 version) 143{ 144 int ret = 0; 145 struct f2fs_summary sum_entry; 146 147 ret = get_sum_entry(sbi, blk_addr, &sum_entry); 148 149 if (ret != SEG_TYPE_DATA && ret != SEG_TYPE_CUR_DATA) { 150 ASSERT_MSG("Summary footer is not for data segment"); 151 return -EINVAL; 152 } 153 154 if (le32_to_cpu(sum_entry.nid) != parent_nid || 155 sum_entry.version != version || 156 le16_to_cpu(sum_entry.ofs_in_node) != idx_in_node) { 157 158 DBG(0, "summary_entry.nid [0x%x]\n", 159 le32_to_cpu(sum_entry.nid)); 160 DBG(0, "summary_entry.version [0x%x]\n", 161 sum_entry.version); 162 DBG(0, "summary_entry.ofs_in_node [0x%x]\n", 163 le16_to_cpu(sum_entry.ofs_in_node)); 164 DBG(0, "parent nid [0x%x]\n", parent_nid); 165 DBG(0, "version from nat [0x%x]\n", version); 166 DBG(0, "idx in parent node [0x%x]\n", idx_in_node); 167 168 DBG(0, "Target data block addr [0x%x]\n", blk_addr); 169 ASSERT_MSG("Invalid data seg summary\n"); 170 return -EINVAL; 171 } 172 return 0; 173} 174 175static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid, 176 struct f2fs_node *node_blk, 177 enum FILE_TYPE ftype, enum NODE_TYPE ntype, 178 struct node_info *ni) 179{ 180 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 181 int ret; 182 183 if (!IS_VALID_NID(sbi, nid)) { 184 ASSERT_MSG("nid is not valid. [0x%x]", nid); 185 return -EINVAL; 186 } 187 188 get_node_info(sbi, nid, ni); 189 if (ni->blk_addr == NEW_ADDR) { 190 ASSERT_MSG("nid is NEW_ADDR. [0x%x]", nid); 191 return -EINVAL; 192 } 193 194 if (!IS_VALID_BLK_ADDR(sbi, ni->blk_addr)) { 195 ASSERT_MSG("blkaddres is not valid. [0x%x]", ni->blk_addr); 196 return -EINVAL; 197 } 198 199 if (is_valid_ssa_node_blk(sbi, nid, ni->blk_addr)) { 200 ASSERT_MSG("summary node block is not valid. [0x%x]", nid); 201 return -EINVAL; 202 } 203 204 ret = dev_read_block(node_blk, ni->blk_addr); 205 ASSERT(ret >= 0); 206 207 if (ntype == TYPE_INODE && 208 node_blk->footer.nid != node_blk->footer.ino) { 209 ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]", 210 nid, le32_to_cpu(node_blk->footer.nid), 211 le32_to_cpu(node_blk->footer.ino)); 212 return -EINVAL; 213 } 214 if (ntype != TYPE_INODE && 215 node_blk->footer.nid == node_blk->footer.ino) { 216 ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]", 217 nid, le32_to_cpu(node_blk->footer.nid), 218 le32_to_cpu(node_blk->footer.ino)); 219 return -EINVAL; 220 } 221 222 if (le32_to_cpu(node_blk->footer.nid) != nid) { 223 ASSERT_MSG("nid[0x%x] blk_addr[0x%x] footer.nid[0x%x]", 224 nid, ni->blk_addr, 225 le32_to_cpu(node_blk->footer.nid)); 226 return -EINVAL; 227 } 228 229 if (ntype == TYPE_XATTR) { 230 u32 flag = le32_to_cpu(node_blk->footer.flag); 231 232 if ((flag >> OFFSET_BIT_SHIFT) != XATTR_NODE_OFFSET) { 233 ASSERT_MSG("xnid[0x%x] has wrong ofs:[0x%x]", 234 nid, flag); 235 return -EINVAL; 236 } 237 } 238 239 if ((ntype == TYPE_INODE && ftype == F2FS_FT_DIR) || 240 (ntype == TYPE_XATTR && ftype == F2FS_FT_XATTR)) { 241 /* not included '.' & '..' */ 242 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) != 0) { 243 ASSERT_MSG("Duplicated node blk. nid[0x%x][0x%x]\n", 244 nid, ni->blk_addr); 245 return -EINVAL; 246 } 247 } 248 249 /* workaround to fix later */ 250 if (ftype != F2FS_FT_ORPHAN || 251 f2fs_test_bit(nid, fsck->nat_area_bitmap) != 0) 252 f2fs_clear_bit(nid, fsck->nat_area_bitmap); 253 else 254 ASSERT_MSG("orphan or xattr nid is duplicated [0x%x]\n", 255 nid); 256 257 if (f2fs_test_sit_bitmap(sbi, ni->blk_addr) == 0) 258 ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]", 259 ni->blk_addr); 260 261 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) { 262 fsck->chk.valid_blk_cnt++; 263 fsck->chk.valid_node_cnt++; 264 } 265 return 0; 266} 267 268static int fsck_chk_xattr_blk(struct f2fs_sb_info *sbi, u32 ino, 269 u32 x_nid, u32 *blk_cnt) 270{ 271 struct f2fs_node *node_blk = NULL; 272 struct node_info ni; 273 int ret = 0; 274 275 if (x_nid == 0x0) 276 return 0; 277 278 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1); 279 ASSERT(node_blk != NULL); 280 281 /* Sanity check */ 282 if (sanity_check_nid(sbi, x_nid, node_blk, 283 F2FS_FT_XATTR, TYPE_XATTR, &ni)) { 284 ret = -EINVAL; 285 goto out; 286 } 287 288 *blk_cnt = *blk_cnt + 1; 289 f2fs_set_main_bitmap(sbi, ni.blk_addr); 290 DBG(2, "ino[0x%x] x_nid[0x%x]\n", ino, x_nid); 291out: 292 free(node_blk); 293 return ret; 294} 295 296int fsck_chk_node_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, 297 u32 nid, enum FILE_TYPE ftype, enum NODE_TYPE ntype, 298 u32 *blk_cnt) 299{ 300 struct node_info ni; 301 struct f2fs_node *node_blk = NULL; 302 303 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1); 304 ASSERT(node_blk != NULL); 305 306 if (sanity_check_nid(sbi, nid, node_blk, ftype, ntype, &ni)) 307 goto err; 308 309 if (ntype == TYPE_INODE) { 310 fsck_chk_inode_blk(sbi, nid, ftype, node_blk, blk_cnt, &ni); 311 } else { 312 f2fs_set_main_bitmap(sbi, ni.blk_addr); 313 314 switch (ntype) { 315 case TYPE_DIRECT_NODE: 316 fsck_chk_dnode_blk(sbi, inode, nid, ftype, node_blk, 317 blk_cnt, &ni); 318 break; 319 case TYPE_INDIRECT_NODE: 320 fsck_chk_idnode_blk(sbi, inode, ftype, node_blk, 321 blk_cnt); 322 break; 323 case TYPE_DOUBLE_INDIRECT_NODE: 324 fsck_chk_didnode_blk(sbi, inode, ftype, node_blk, 325 blk_cnt); 326 break; 327 default: 328 ASSERT(0); 329 } 330 } 331 free(node_blk); 332 return 0; 333err: 334 free(node_blk); 335 return -EINVAL; 336} 337 338/* start with valid nid and blkaddr */ 339void fsck_chk_inode_blk(struct f2fs_sb_info *sbi, u32 nid, 340 enum FILE_TYPE ftype, struct f2fs_node *node_blk, 341 u32 *blk_cnt, struct node_info *ni) 342{ 343 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 344 u32 child_cnt = 0, child_files = 0; 345 enum NODE_TYPE ntype; 346 u32 i_links = le32_to_cpu(node_blk->i.i_links); 347 u64 i_blocks = le64_to_cpu(node_blk->i.i_blocks); 348 unsigned int idx = 0; 349 int need_fix = 0; 350 int ret; 351 352 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) 353 fsck->chk.valid_inode_cnt++; 354 355 if (ftype == F2FS_FT_DIR) { 356 f2fs_set_main_bitmap(sbi, ni->blk_addr); 357 } else { 358 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) { 359 f2fs_set_main_bitmap(sbi, ni->blk_addr); 360 if (i_links > 1) { 361 /* First time. Create new hard link node */ 362 add_into_hard_link_list(sbi, nid, i_links); 363 fsck->chk.multi_hard_link_files++; 364 } 365 } else { 366 DBG(3, "[0x%x] has hard links [0x%x]\n", nid, i_links); 367 if (find_and_dec_hard_link_list(sbi, nid)) { 368 ASSERT_MSG("[0x%x] needs more i_links=0x%x", 369 nid, i_links); 370 if (config.fix_on) { 371 node_blk->i.i_links = 372 cpu_to_le32(i_links + 1); 373 need_fix = 1; 374 FIX_MSG("File: 0x%x " 375 "i_links= 0x%x -> 0x%x", 376 nid, i_links, i_links + 1); 377 } 378 goto check; 379 } 380 /* No need to go deep into the node */ 381 return; 382 } 383 } 384 385 if (fsck_chk_xattr_blk(sbi, nid, 386 le32_to_cpu(node_blk->i.i_xattr_nid), blk_cnt) && 387 config.fix_on) { 388 node_blk->i.i_xattr_nid = 0; 389 need_fix = 1; 390 FIX_MSG("Remove xattr block: 0x%x, x_nid = 0x%x", 391 nid, le32_to_cpu(node_blk->i.i_xattr_nid)); 392 } 393 394 if (ftype == F2FS_FT_CHRDEV || ftype == F2FS_FT_BLKDEV || 395 ftype == F2FS_FT_FIFO || ftype == F2FS_FT_SOCK) 396 goto check; 397 398 if((node_blk->i.i_inline & F2FS_INLINE_DATA)) { 399 if (le32_to_cpu(node_blk->i.i_addr[0]) != 0) { 400 /* should fix this bug all the time */ 401 FIX_MSG("inline_data has wrong 0'th block = %x", 402 le32_to_cpu(node_blk->i.i_addr[0])); 403 node_blk->i.i_addr[0] = 0; 404 node_blk->i.i_blocks = cpu_to_le64(*blk_cnt); 405 need_fix = 1; 406 } 407 if (!(node_blk->i.i_inline & F2FS_DATA_EXIST)) { 408 char buf[MAX_INLINE_DATA]; 409 memset(buf, 0, MAX_INLINE_DATA); 410 411 if (memcmp(buf, &node_blk->i.i_addr[1], 412 MAX_INLINE_DATA)) { 413 FIX_MSG("inline_data has DATA_EXIST"); 414 node_blk->i.i_inline |= F2FS_DATA_EXIST; 415 need_fix = 1; 416 } 417 } 418 DBG(3, "ino[0x%x] has inline data!\n", nid); 419 goto check; 420 } 421 if((node_blk->i.i_inline & F2FS_INLINE_DENTRY)) { 422 DBG(3, "ino[0x%x] has inline dentry!\n", nid); 423 ret = fsck_chk_inline_dentries(sbi, node_blk, 424 &child_cnt, &child_files); 425 if (ret < 0) { 426 /* should fix this bug all the time */ 427 need_fix = 1; 428 } 429 goto check; 430 } 431 432 /* check data blocks in inode */ 433 for (idx = 0; idx < ADDRS_PER_INODE(&node_blk->i); idx++) { 434 if (le32_to_cpu(node_blk->i.i_addr[idx]) != 0) { 435 ret = fsck_chk_data_blk(sbi, 436 le32_to_cpu(node_blk->i.i_addr[idx]), 437 &child_cnt, &child_files, 438 (i_blocks == *blk_cnt), 439 ftype, nid, idx, ni->version); 440 if (!ret) { 441 *blk_cnt = *blk_cnt + 1; 442 } else if (config.fix_on) { 443 node_blk->i.i_addr[idx] = 0; 444 need_fix = 1; 445 FIX_MSG("[0x%x] i_addr[%d] = 0", nid, idx); 446 } 447 } 448 } 449 450 /* check node blocks in inode */ 451 for (idx = 0; idx < 5; idx++) { 452 if (idx == 0 || idx == 1) 453 ntype = TYPE_DIRECT_NODE; 454 else if (idx == 2 || idx == 3) 455 ntype = TYPE_INDIRECT_NODE; 456 else if (idx == 4) 457 ntype = TYPE_DOUBLE_INDIRECT_NODE; 458 else 459 ASSERT(0); 460 461 if (le32_to_cpu(node_blk->i.i_nid[idx]) != 0) { 462 ret = fsck_chk_node_blk(sbi, &node_blk->i, 463 le32_to_cpu(node_blk->i.i_nid[idx]), 464 ftype, ntype, blk_cnt); 465 if (!ret) { 466 *blk_cnt = *blk_cnt + 1; 467 } else if (config.fix_on) { 468 node_blk->i.i_nid[idx] = 0; 469 need_fix = 1; 470 FIX_MSG("[0x%x] i_nid[%d] = 0", nid, idx); 471 } 472 } 473 } 474check: 475 if (ftype == F2FS_FT_DIR) 476 DBG(1, "Directory Inode: 0x%x [%s] depth: %d has %d files\n\n", 477 le32_to_cpu(node_blk->footer.ino), 478 node_blk->i.i_name, 479 le32_to_cpu(node_blk->i.i_current_depth), 480 child_files); 481 if (ftype == F2FS_FT_ORPHAN) 482 DBG(1, "Orphan Inode: 0x%x [%s] i_blocks: %u\n\n", 483 le32_to_cpu(node_blk->footer.ino), 484 node_blk->i.i_name, 485 (u32)i_blocks); 486 487 if (i_blocks != *blk_cnt) { 488 ASSERT_MSG("ino: 0x%x has i_blocks: %08"PRIx64", " 489 "but has %u blocks", 490 nid, i_blocks, *blk_cnt); 491 if (config.fix_on) { 492 node_blk->i.i_blocks = cpu_to_le64(*blk_cnt); 493 need_fix = 1; 494 FIX_MSG("[0x%x] i_blocks=0x%08"PRIx64" -> 0x%x", 495 nid, i_blocks, *blk_cnt); 496 } 497 } 498 if (ftype == F2FS_FT_DIR && i_links != child_cnt) { 499 ASSERT_MSG("ino: 0x%x has i_links: %u but real links: %u", 500 nid, i_links, child_cnt); 501 if (config.fix_on) { 502 node_blk->i.i_links = cpu_to_le32(child_cnt); 503 need_fix = 1; 504 FIX_MSG("Dir: 0x%x i_links= 0x%x -> 0x%x", 505 nid, i_links, child_cnt); 506 } 507 } 508 509 if (ftype == F2FS_FT_ORPHAN && i_links) 510 ASSERT_MSG("ino: 0x%x is orphan inode, but has i_links: %u", 511 nid, i_links); 512 if (need_fix) { 513 ret = dev_write_block(node_blk, ni->blk_addr); 514 ASSERT(ret >= 0); 515 } 516} 517 518int fsck_chk_dnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, 519 u32 nid, enum FILE_TYPE ftype, struct f2fs_node *node_blk, 520 u32 *blk_cnt, struct node_info *ni) 521{ 522 int idx, ret; 523 u32 child_cnt = 0, child_files = 0; 524 525 for (idx = 0; idx < ADDRS_PER_BLOCK; idx++) { 526 if (le32_to_cpu(node_blk->dn.addr[idx]) == 0x0) 527 continue; 528 ret = fsck_chk_data_blk(sbi, 529 le32_to_cpu(node_blk->dn.addr[idx]), 530 &child_cnt, &child_files, 531 le64_to_cpu(inode->i_blocks) == *blk_cnt, ftype, 532 nid, idx, ni->version); 533 if (!ret) 534 *blk_cnt = *blk_cnt + 1; 535 } 536 return 0; 537} 538 539int fsck_chk_idnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, 540 enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt) 541{ 542 int ret; 543 int i = 0; 544 545 for (i = 0 ; i < NIDS_PER_BLOCK; i++) { 546 if (le32_to_cpu(node_blk->in.nid[i]) == 0x0) 547 continue; 548 ret = fsck_chk_node_blk(sbi, inode, 549 le32_to_cpu(node_blk->in.nid[i]), 550 ftype, TYPE_DIRECT_NODE, blk_cnt); 551 if (!ret) 552 *blk_cnt = *blk_cnt + 1; 553 else if (ret == -EINVAL) 554 printf("delete in.nid[i] = 0;\n"); 555 } 556 return 0; 557} 558 559int fsck_chk_didnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode, 560 enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt) 561{ 562 int i = 0; 563 int ret = 0; 564 565 for (i = 0; i < NIDS_PER_BLOCK; i++) { 566 if (le32_to_cpu(node_blk->in.nid[i]) == 0x0) 567 continue; 568 ret = fsck_chk_node_blk(sbi, inode, 569 le32_to_cpu(node_blk->in.nid[i]), 570 ftype, TYPE_INDIRECT_NODE, blk_cnt); 571 if (!ret) 572 *blk_cnt = *blk_cnt + 1; 573 else if (ret == -EINVAL) 574 printf("delete in.nid[i] = 0;\n"); 575 } 576 return 0; 577} 578 579static void print_dentry(__u32 depth, __u8 *name, 580 unsigned long *bitmap, 581 struct f2fs_dir_entry *dentry, 582 int max, int idx, int last_blk) 583{ 584 int last_de = 0; 585 int next_idx = 0; 586 int name_len; 587 unsigned int i; 588 int bit_offset; 589 590 if (config.dbg_lv != -1) 591 return; 592 593 name_len = le16_to_cpu(dentry[idx].name_len); 594 next_idx = idx + (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN; 595 596 bit_offset = find_next_bit(bitmap, max, next_idx); 597 if (bit_offset >= max && last_blk) 598 last_de = 1; 599 600 if (tree_mark_size <= depth) { 601 tree_mark_size *= 2; 602 tree_mark = realloc(tree_mark, tree_mark_size); 603 } 604 605 if (last_de) 606 tree_mark[depth] = '`'; 607 else 608 tree_mark[depth] = '|'; 609 610 if (tree_mark[depth - 1] == '`') 611 tree_mark[depth - 1] = ' '; 612 613 614 for (i = 1; i < depth; i++) 615 printf("%c ", tree_mark[i]); 616 printf("%c-- %s 0x%x\n", last_de ? '`' : '|', 617 name, le32_to_cpu(dentry[idx].ino)); 618} 619 620static int __chk_dentries(struct f2fs_sb_info *sbi, u32 *child_cnt, 621 u32* child_files, 622 unsigned long *bitmap, 623 struct f2fs_dir_entry *dentry, 624 __u8 (*filenames)[F2FS_SLOT_LEN], 625 int max, int last_blk) 626{ 627 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 628 enum FILE_TYPE ftype; 629 int dentries = 0; 630 u32 blk_cnt; 631 u8 *name; 632 u32 hash_code; 633 u16 name_len;; 634 int ret = 0; 635 int fixed = 0; 636 int i; 637 638 for (i = 0; i < max;) { 639 if (test_bit(i, bitmap) == 0) { 640 i++; 641 continue; 642 } 643 if (!IS_VALID_NID(sbi, le32_to_cpu(dentry[i].ino))) { 644 DBG(1, "Bad dentry 0x%x with invalid NID/ino 0x%x", 645 i, le32_to_cpu(dentry[i].ino)); 646 if (config.fix_on) { 647 FIX_MSG("Clear bad dentry 0x%x with bad ino 0x%x", 648 i, le32_to_cpu(dentry[i].ino)); 649 clear_bit(i, bitmap); 650 i++; 651 fixed = 1; 652 continue; 653 } 654 } 655 ftype = dentry[i].file_type; 656 if ((ftype <= F2FS_FT_UNKNOWN || ftype > F2FS_FT_LAST_FILE_TYPE) && config.fix_on) { 657 DBG(1, "Bad dentry 0x%x with unexpected ftype 0x%x", 658 i, ftype); 659 if (config.fix_on) { 660 FIX_MSG("Clear bad dentry 0x%x with bad ftype 0x%x", 661 i, ftype); 662 clear_bit(i, bitmap); 663 i++; 664 fixed = 1; 665 continue; 666 } 667 } 668 name_len = le16_to_cpu(dentry[i].name_len); 669 name = calloc(name_len + 1, 1); 670 memcpy(name, filenames[i], name_len); 671 hash_code = f2fs_dentry_hash((const unsigned char *)name, 672 name_len); 673 674 /* fix hash_code made by old buggy code */ 675 if (le32_to_cpu(dentry[i].hash_code) != hash_code) { 676 dentry[i].hash_code = hash_code; 677 fixed = 1; 678 FIX_MSG("hash_code[%d] of %s", i, name); 679 } 680 681 /* Becareful. 'dentry.file_type' is not imode. */ 682 if (ftype == F2FS_FT_DIR) { 683 *child_cnt = *child_cnt + 1; 684 if ((name[0] == '.' && name_len == 1) || 685 (name[0] == '.' && name[1] == '.' && 686 name_len == 2)) { 687 i++; 688 free(name); 689 continue; 690 } 691 } 692 693 DBG(1, "[%3u]-[0x%x] name[%s] len[0x%x] ino[0x%x] type[0x%x]\n", 694 fsck->dentry_depth, i, name, name_len, 695 le32_to_cpu(dentry[i].ino), 696 dentry[i].file_type); 697 698 print_dentry(fsck->dentry_depth, name, bitmap, 699 dentry, max, i, last_blk); 700 701 blk_cnt = 1; 702 ret = fsck_chk_node_blk(sbi, 703 NULL, le32_to_cpu(dentry[i].ino), 704 ftype, TYPE_INODE, &blk_cnt); 705 706 if (ret && config.fix_on) { 707 int j; 708 int slots = (name_len + F2FS_SLOT_LEN - 1) / 709 F2FS_SLOT_LEN; 710 for (j = 0; j < slots; j++) 711 clear_bit(i + j, bitmap); 712 FIX_MSG("Unlink [0x%x] - %s len[0x%x], type[0x%x]", 713 le32_to_cpu(dentry[i].ino), 714 name, name_len, 715 dentry[i].file_type); 716 i += slots; 717 free(name); 718 continue; 719 } 720 721 i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN; 722 dentries++; 723 *child_files = *child_files + 1; 724 free(name); 725 } 726 return fixed ? -1 : dentries; 727} 728 729int fsck_chk_inline_dentries(struct f2fs_sb_info *sbi, 730 struct f2fs_node *node_blk, u32 *child_cnt, u32 *child_files) 731{ 732 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 733 struct f2fs_inline_dentry *de_blk; 734 int dentries; 735 736 de_blk = inline_data_addr(node_blk); 737 ASSERT(de_blk != NULL); 738 739 fsck->dentry_depth++; 740 dentries = __chk_dentries(sbi, child_cnt, child_files, 741 (unsigned long *)de_blk->dentry_bitmap, 742 de_blk->dentry, de_blk->filename, 743 NR_INLINE_DENTRY, 1); 744 if (dentries < 0) { 745 DBG(1, "[%3d] Inline Dentry Block Fixed hash_codes\n\n", 746 fsck->dentry_depth); 747 } else { 748 DBG(1, "[%3d] Inline Dentry Block Done : " 749 "dentries:%d in %d slots (len:%d)\n\n", 750 fsck->dentry_depth, dentries, 751 (int)NR_INLINE_DENTRY, F2FS_NAME_LEN); 752 } 753 fsck->dentry_depth--; 754 return dentries; 755} 756 757int fsck_chk_dentry_blk(struct f2fs_sb_info *sbi, u32 blk_addr, 758 u32 *child_cnt, u32 *child_files, int last_blk) 759{ 760 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 761 struct f2fs_dentry_block *de_blk; 762 int dentries, ret; 763 764 de_blk = (struct f2fs_dentry_block *)calloc(BLOCK_SZ, 1); 765 ASSERT(de_blk != NULL); 766 767 ret = dev_read_block(de_blk, blk_addr); 768 ASSERT(ret >= 0); 769 770 fsck->dentry_depth++; 771 dentries = __chk_dentries(sbi, child_cnt, child_files, 772 (unsigned long *)de_blk->dentry_bitmap, 773 de_blk->dentry, de_blk->filename, 774 NR_DENTRY_IN_BLOCK, last_blk); 775 776 if (dentries < 0) { 777 ret = dev_write_block(de_blk, blk_addr); 778 ASSERT(ret >= 0); 779 DBG(1, "[%3d] Dentry Block [0x%x] Fixed hash_codes\n\n", 780 fsck->dentry_depth, blk_addr); 781 } else { 782 DBG(1, "[%3d] Dentry Block [0x%x] Done : " 783 "dentries:%d in %d slots (len:%d)\n\n", 784 fsck->dentry_depth, blk_addr, dentries, 785 NR_DENTRY_IN_BLOCK, F2FS_NAME_LEN); 786 } 787 fsck->dentry_depth--; 788 free(de_blk); 789 return 0; 790} 791 792int fsck_chk_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr, 793 u32 *child_cnt, u32 *child_files, int last_blk, 794 enum FILE_TYPE ftype, u32 parent_nid, u16 idx_in_node, u8 ver) 795{ 796 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 797 798 /* Is it reserved block? */ 799 if (blk_addr == NEW_ADDR) { 800 fsck->chk.valid_blk_cnt++; 801 return 0; 802 } 803 804 if (!IS_VALID_BLK_ADDR(sbi, blk_addr)) { 805 ASSERT_MSG("blkaddres is not valid. [0x%x]", blk_addr); 806 return -EINVAL; 807 } 808 809 if (is_valid_ssa_data_blk(sbi, blk_addr, parent_nid, 810 idx_in_node, ver)) { 811 ASSERT_MSG("summary data block is not valid. [0x%x]", 812 parent_nid); 813 return -EINVAL; 814 } 815 816 if (f2fs_test_sit_bitmap(sbi, blk_addr) == 0) 817 ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]", blk_addr); 818 819 if (f2fs_test_main_bitmap(sbi, blk_addr) != 0) 820 ASSERT_MSG("Duplicated data [0x%x]. pnid[0x%x] idx[0x%x]", 821 blk_addr, parent_nid, idx_in_node); 822 823 f2fs_set_main_bitmap(sbi, blk_addr); 824 825 fsck->chk.valid_blk_cnt++; 826 827 if (ftype == F2FS_FT_DIR) 828 return fsck_chk_dentry_blk(sbi, blk_addr, child_cnt, 829 child_files, last_blk); 830 return 0; 831} 832 833void fsck_chk_orphan_node(struct f2fs_sb_info *sbi) 834{ 835 u32 blk_cnt = 0; 836 block_t start_blk, orphan_blkaddr, i, j; 837 struct f2fs_orphan_block *orphan_blk; 838 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 839 840 if (!is_set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG)) 841 return; 842 843 if (config.fix_on) 844 return; 845 846 start_blk = __start_cp_addr(sbi) + 1 + 847 le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload); 848 orphan_blkaddr = __start_sum_addr(sbi) - 1; 849 orphan_blk = calloc(BLOCK_SZ, 1); 850 851 for (i = 0; i < orphan_blkaddr; i++) { 852 int ret = dev_read_block(orphan_blk, start_blk + i); 853 854 ASSERT(ret >= 0); 855 856 for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) { 857 nid_t ino = le32_to_cpu(orphan_blk->ino[j]); 858 DBG(1, "[%3d] ino [0x%x]\n", i, ino); 859 blk_cnt = 1; 860 fsck_chk_node_blk(sbi, NULL, ino, 861 F2FS_FT_ORPHAN, TYPE_INODE, &blk_cnt); 862 } 863 memset(orphan_blk, 0, BLOCK_SZ); 864 } 865 free(orphan_blk); 866} 867 868void fsck_init(struct f2fs_sb_info *sbi) 869{ 870 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 871 struct f2fs_sm_info *sm_i = SM_I(sbi); 872 873 /* 874 * We build three bitmap for main/sit/nat so that may check consistency 875 * of filesystem. 876 * 1. main_area_bitmap will be used to check whether all blocks of main 877 * area is used or not. 878 * 2. nat_area_bitmap has bitmap information of used nid in NAT. 879 * 3. sit_area_bitmap has bitmap information of used main block. 880 * At Last sequence, we compare main_area_bitmap with sit_area_bitmap. 881 */ 882 fsck->nr_main_blks = sm_i->main_segments << sbi->log_blocks_per_seg; 883 fsck->main_area_bitmap_sz = (fsck->nr_main_blks + 7) / 8; 884 fsck->main_area_bitmap = calloc(fsck->main_area_bitmap_sz, 1); 885 ASSERT(fsck->main_area_bitmap != NULL); 886 887 build_nat_area_bitmap(sbi); 888 889 build_sit_area_bitmap(sbi); 890 891 tree_mark = calloc(tree_mark_size, 1); 892 ASSERT(tree_mark != NULL); 893} 894 895static void fix_nat_entries(struct f2fs_sb_info *sbi) 896{ 897 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 898 u32 i; 899 900 for (i = 0; i < fsck->nr_nat_entries; i++) 901 if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0) 902 nullify_nat_entry(sbi, i); 903} 904 905static void fix_checkpoint(struct f2fs_sb_info *sbi) 906{ 907 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 908 struct f2fs_super_block *raw_sb = sbi->raw_super; 909 struct f2fs_checkpoint *ckp = F2FS_CKPT(sbi); 910 unsigned long long cp_blk_no; 911 u32 i; 912 int ret; 913 u_int32_t crc = 0; 914 915 ckp->ckpt_flags = cpu_to_le32(CP_UMOUNT_FLAG); 916 ckp->cp_pack_total_block_count = 917 cpu_to_le32(8 + le32_to_cpu(raw_sb->cp_payload)); 918 ckp->cp_pack_start_sum = cpu_to_le32(1 + 919 le32_to_cpu(raw_sb->cp_payload)); 920 921 ckp->free_segment_count = cpu_to_le32(fsck->chk.free_segs); 922 ckp->valid_block_count = cpu_to_le32(fsck->chk.valid_blk_cnt); 923 ckp->valid_node_count = cpu_to_le32(fsck->chk.valid_node_cnt); 924 ckp->valid_inode_count = cpu_to_le32(fsck->chk.valid_inode_cnt); 925 926 crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, ckp, CHECKSUM_OFFSET); 927 *((__le32 *)((unsigned char *)ckp + CHECKSUM_OFFSET)) = 928 cpu_to_le32(crc); 929 930 cp_blk_no = le32_to_cpu(raw_sb->cp_blkaddr); 931 if (sbi->cur_cp == 2) 932 cp_blk_no += 1 << le32_to_cpu(raw_sb->log_blocks_per_seg); 933 934 ret = dev_write_block(ckp, cp_blk_no++); 935 ASSERT(ret >= 0); 936 937 for (i = 0; i < le32_to_cpu(raw_sb->cp_payload); i++) { 938 ret = dev_write_block(((unsigned char *)ckp) + i * F2FS_BLKSIZE, 939 cp_blk_no++); 940 ASSERT(ret >= 0); 941 } 942 943 for (i = 0; i < NO_CHECK_TYPE; i++) { 944 struct curseg_info *curseg = CURSEG_I(sbi, i); 945 946 ret = dev_write_block(curseg->sum_blk, cp_blk_no++); 947 ASSERT(ret >= 0); 948 } 949 950 ret = dev_write_block(ckp, cp_blk_no++); 951 ASSERT(ret >= 0); 952} 953 954int check_curseg_offset(struct f2fs_sb_info *sbi) 955{ 956 int i; 957 958 for (i = 0; i < NO_CHECK_TYPE; i++) { 959 struct curseg_info *curseg = CURSEG_I(sbi, i); 960 struct seg_entry *se; 961 962 se = get_seg_entry(sbi, curseg->segno); 963 if (f2fs_test_bit(curseg->next_blkoff, 964 (const char *)se->cur_valid_map) == 1) { 965 ASSERT_MSG("Next block offset is not free, type:%d", i); 966 return -EINVAL; 967 } 968 } 969 return 0; 970} 971 972int fsck_verify(struct f2fs_sb_info *sbi) 973{ 974 unsigned int i = 0; 975 int ret = 0; 976 u32 nr_unref_nid = 0; 977 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 978 struct hard_link_node *node = NULL; 979 980 printf("\n"); 981 982 for (i = 0; i < fsck->nr_nat_entries; i++) { 983 if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0) { 984 printf("NID[0x%x] is unreachable\n", i); 985 nr_unref_nid++; 986 } 987 } 988 989 if (fsck->hard_link_list_head != NULL) { 990 node = fsck->hard_link_list_head; 991 while (node) { 992 printf("NID[0x%x] has [0x%x] more unreachable links\n", 993 node->nid, node->links); 994 node = node->next; 995 } 996 config.bug_on = 1; 997 } 998 999 printf("[FSCK] Unreachable nat entries "); 1000 if (nr_unref_nid == 0x0) { 1001 printf(" [Ok..] [0x%x]\n", nr_unref_nid); 1002 } else { 1003 printf(" [Fail] [0x%x]\n", nr_unref_nid); 1004 ret = EXIT_ERR_CODE; 1005 config.bug_on = 1; 1006 } 1007 1008 printf("[FSCK] SIT valid block bitmap checking "); 1009 if (memcmp(fsck->sit_area_bitmap, fsck->main_area_bitmap, 1010 fsck->sit_area_bitmap_sz) == 0x0) { 1011 printf("[Ok..]\n"); 1012 } else { 1013 printf("[Fail]\n"); 1014 ret = EXIT_ERR_CODE; 1015 config.bug_on = 1; 1016 } 1017 1018 printf("[FSCK] Hard link checking for regular file "); 1019 if (fsck->hard_link_list_head == NULL) { 1020 printf(" [Ok..] [0x%x]\n", fsck->chk.multi_hard_link_files); 1021 } else { 1022 printf(" [Fail] [0x%x]\n", fsck->chk.multi_hard_link_files); 1023 ret = EXIT_ERR_CODE; 1024 config.bug_on = 1; 1025 } 1026 1027 printf("[FSCK] valid_block_count matching with CP "); 1028 if (sbi->total_valid_block_count == fsck->chk.valid_blk_cnt) { 1029 printf(" [Ok..] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt); 1030 } else { 1031 printf(" [Fail] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt); 1032 ret = EXIT_ERR_CODE; 1033 config.bug_on = 1; 1034 } 1035 1036 printf("[FSCK] valid_node_count matcing with CP (de lookup) "); 1037 if (sbi->total_valid_node_count == fsck->chk.valid_node_cnt) { 1038 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_node_cnt); 1039 } else { 1040 printf(" [Fail] [0x%x]\n", fsck->chk.valid_node_cnt); 1041 ret = EXIT_ERR_CODE; 1042 config.bug_on = 1; 1043 } 1044 1045 printf("[FSCK] valid_node_count matcing with CP (nat lookup) "); 1046 if (sbi->total_valid_node_count == fsck->chk.valid_nat_entry_cnt) { 1047 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_nat_entry_cnt); 1048 } else { 1049 printf(" [Fail] [0x%x]\n", fsck->chk.valid_nat_entry_cnt); 1050 ret = EXIT_ERR_CODE; 1051 config.bug_on = 1; 1052 } 1053 1054 printf("[FSCK] valid_inode_count matched with CP "); 1055 if (sbi->total_valid_inode_count == fsck->chk.valid_inode_cnt) { 1056 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_inode_cnt); 1057 } else { 1058 printf(" [Fail] [0x%x]\n", fsck->chk.valid_inode_cnt); 1059 ret = EXIT_ERR_CODE; 1060 config.bug_on = 1; 1061 } 1062 1063 printf("[FSCK] free segment_count matched with CP "); 1064 if (le32_to_cpu(F2FS_CKPT(sbi)->free_segment_count) == 1065 fsck->chk.sit_free_segs) { 1066 printf(" [Ok..] [0x%x]\n", fsck->chk.sit_free_segs); 1067 } else { 1068 printf(" [Fail] [0x%x]\n", fsck->chk.sit_free_segs); 1069 ret = EXIT_ERR_CODE; 1070 config.bug_on = 1; 1071 } 1072 1073 printf("[FSCK] next block offset is free "); 1074 if (check_curseg_offset(sbi) == 0) { 1075 printf(" [Ok..]\n"); 1076 } else { 1077 printf(" [Fail]\n"); 1078 ret = EXIT_ERR_CODE; 1079 config.bug_on = 1; 1080 } 1081 1082 printf("[FSCK] other corrupted bugs "); 1083 if (config.bug_on == 0) { 1084 printf(" [Ok..]\n"); 1085 } else { 1086 printf(" [Fail]\n"); 1087 ret = EXIT_ERR_CODE; 1088 config.bug_on = 1; 1089 } 1090 1091 /* fix global metadata */ 1092 if (config.bug_on && config.fix_on) { 1093 fix_nat_entries(sbi); 1094 rewrite_sit_area_bitmap(sbi); 1095 fix_checkpoint(sbi); 1096 } 1097 return ret; 1098} 1099 1100void fsck_free(struct f2fs_sb_info *sbi) 1101{ 1102 struct f2fs_fsck *fsck = F2FS_FSCK(sbi); 1103 if (fsck->main_area_bitmap) 1104 free(fsck->main_area_bitmap); 1105 1106 if (fsck->nat_area_bitmap) 1107 free(fsck->nat_area_bitmap); 1108 1109 if (fsck->sit_area_bitmap) 1110 free(fsck->sit_area_bitmap); 1111 1112 if (tree_mark) 1113 free(tree_mark); 1114} 1115