spacepaste

Paste details

reply | raw

  1.  
  2. commit 18076aac0276719f1476f5371d942328a6483a1b (HEAD -> master)
  3. Author: Luke Dashjr <luke-jr+git@utopios.org>
  4. Date: Sat Aug 25 02:25:31 2018 +0000
  6. rebase rebuild-root.diff
  8. diff --git a/fsck/fsck.c b/fsck/fsck.c
  9. index 05a6301..08b117b 100644
  10. --- a/fsck/fsck.c
  11. +++ b/fsck/fsck.c
  12. @@ -391,6 +391,8 @@ static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
  13. ASSERT_MSG("nid[0x%x] ino is 0", nid);
  14. return -EINVAL;
  15. }
  16. + if (nid == 3)
  17. + printf("DEBUG: %s: root inode blk_addr %#x\n", __func__, ni->blk_addr);
  19. if (ni->blk_addr == NEW_ADDR) {
  20. ASSERT_MSG("nid is NEW_ADDR. [0x%x]", nid);
  21. @@ -563,6 +565,457 @@ err:
  22. return -EINVAL;
  23. }
  25. +struct wrapper {
  26. + union {
  27. + /*
  28. + * direct/indirect/double-indirect and xattr
  29. + * offs in node_footer->flags is used to sort nodes
  30. + */
  31. + struct f2fs_node *node;
  32. + /* FIXME: data block should be all dentries */
  33. + struct data {
  34. + struct f2fs_dentry_block *dentry;
  35. + /* sum_entry->ofs_in_node is used to sort data */
  36. + struct f2fs_summary *sum;
  37. + } data;
  38. + };
  39. + block_t blk_addr;
  40. + struct wrapper *next;
  41. +};
  42. +struct wrapper *node_head = NULL, *data_head = NULL, *xattr_head = NULL;
  43. +/*
  44. + * if nat entry of root inode is corrupted, we may find correct root inode
  45. + * block during scanning. So we save them
  46. + */
  47. +struct wrapper *root_head = NULL;
  48. +
  49. +static void add_wrapper(struct wrapper **head, struct wrapper *new)
  50. +{
  51. + if (*head == NULL) {
  52. + *head = new;
  53. + } else {
  54. + new->next = *head;
  55. + *head = new;
  56. + }
  57. +}
  58. +
  59. +static int get_all_wrappers(struct f2fs_sb_info *sbi)
  60. +{
  61. + struct seg_entry *se;
  62. + struct f2fs_dentry_block *dentry_blk;
  63. + struct f2fs_node *node_blk;
  64. + struct f2fs_summary_block *sum_blk;
  65. + struct f2fs_summary *sum_entry;
  66. + u32 seg_idx, sum_idx;
  67. + int sum_type, ret;
  68. + nid_t root_ino = F2FS_ROOT_INO(sbi);
  69. + struct wrapper *new;
  70. +
  71. + for (seg_idx = 0; seg_idx < TOTAL_SEGS(sbi); seg_idx++) {
  72. + se = get_seg_entry(sbi, seg_idx);
  73. + if (!se->valid_blocks)
  74. + /* skip unused segment */
  75. + continue;
  76. +
  77. + sum_blk = get_sum_block(sbi, seg_idx, &sum_type);
  78. + if (!sum_blk)
  79. + return -ENOMEM;
  80. +
  81. + for (sum_idx = 0; sum_idx < ENTRIES_IN_SUM; sum_idx++) {
  82. + block_t blkaddr = SM_I(sbi)->main_blkaddr +
  83. + seg_idx * sbi->blocks_per_seg +
  84. + sum_idx;
  85. +
  86. + if (!f2fs_test_sit_bitmap(sbi, blkaddr))
  87. + /* skip unused block */
  88. + continue;
  89. +
  90. + sum_entry = &sum_blk->entries[sum_idx];
  91. + if (le32_to_cpu(sum_entry->nid) != root_ino)
  92. + /* skip block whose parent nid is not root ino */
  93. + continue;
  94. +
  95. + new = (struct wrapper *)calloc(sizeof(struct wrapper), 1);
  96. + ASSERT(new);
  97. +
  98. + if (sum_type == SEG_TYPE_NODE || sum_type == SEG_TYPE_CUR_NODE) {
  99. + node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
  100. + ASSERT(node_blk);
  101. +
  102. + ret = dev_read_block(node_blk, blkaddr);
  103. + ASSERT(ret >= 0);
  104. + if (le32_to_cpu(node_blk->footer.ino) == le32_to_cpu(node_blk->footer.nid)) {
  105. + /* skip the root inode itself */
  106. + if (le32_to_cpu(node_blk->footer.ino) == root_ino) {
  107. + DBG(1, "add block %#x to root_head\n", blkaddr);
  108. + new->node = node_blk;
  109. + new->blk_addr = blkaddr;
  110. + new->next = NULL;
  111. + add_wrapper(&root_head, new);
  112. + continue;
  113. + }
  114. + }
  115. + /* FIXME: shall we do some check here? if it
  116. + * does not pass, we should drop the data
  117. + * block.
  118. + * Or, we don't need to check this, fsck
  119. + * will do this later
  120. + */
  121. + new->node = node_blk;
  122. + new->blk_addr = blkaddr;
  123. + new->next = NULL;
  124. + if (ofs_of_node(node_blk) == XATTR_NODE_OFFSET)
  125. + add_wrapper(&xattr_head, new);
  126. + else
  127. + add_wrapper(&node_head, new);
  128. + } else if (sum_type == SEG_TYPE_DATA || sum_type == SEG_TYPE_CUR_DATA) {
  129. + dentry_blk = (struct f2fs_dentry_block *)calloc(BLOCK_SZ, 1);
  130. + ASSERT(dentry_blk);
  131. +
  132. + ret = dev_read_block(dentry_blk, blkaddr);
  133. + ASSERT(ret >= 0);
  134. + /* FIXME: shall we do some check here? if it
  135. + * does not pass, we should drop the data
  136. + * block.
  137. + * Or, we don't need to check this, fsck
  138. + * will do this later
  139. + */
  140. + new->data.dentry = dentry_blk;
  141. + new->data.sum = calloc(sizeof(struct f2fs_summary), 1);
  142. + memcpy(new->data.sum, sum_entry, sizeof(struct f2fs_summary));
  143. + new->blk_addr = blkaddr;
  144. + new->next = NULL;
  145. + add_wrapper(&data_head, new);
  146. + } else {
  147. + ASSERT_MSG("segment 0x%x: unknown summary type %d\n",
  148. + seg_idx, sum_type);
  149. + break;
  150. + }
  151. + }
  152. + if (sum_type == SEG_TYPE_NODE ||
  153. + sum_type == SEG_TYPE_DATA ||
  154. + sum_type == SEG_TYPE_MAX)
  155. + free(sum_blk);
  156. + }
  157. + return 0;
  158. +}
  159. +
  160. +static int update_nat_entry(struct f2fs_sb_info *sbi, u32 nid, block_t newblk)
  161. +{
  162. + struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
  163. + struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
  164. + struct f2fs_summary_block *sum = curseg->sum_blk;
  165. + struct f2fs_nm_info *nm_i = NM_I(sbi);
  166. + struct f2fs_nat_block *nat_block;
  167. + struct f2fs_nat_entry *ne;
  168. + pgoff_t block_off;
  169. + pgoff_t nat_blk_addr;
  170. + block_t wrong_addr;
  171. + int seg_off, entry_off;
  172. + int i, ret;
  173. +
  174. + /* look up nat entry in journal */
  175. + for (i = 0; i < nats_in_cursum((&sum->journal)); i++) {
  176. + if (le32_to_cpu(nid_in_journal((&sum->journal), i)) == nid) {
  177. + ne = &nat_in_journal((&sum->journal), i);
  178. + wrong_addr = le32_to_cpu(ne->block_addr);
  179. + ne->block_addr = cpu_to_le32(newblk);
  180. + goto out;
  181. + }
  182. + }
  183. +
  184. + /* look up nat entry in NAT area */
  185. + nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
  186. + ASSERT(nat_block);
  187. +
  188. + block_off = nid / NAT_ENTRY_PER_BLOCK;
  189. + entry_off = nid % NAT_ENTRY_PER_BLOCK;
  190. +
  191. + seg_off = block_off >> sbi->log_blocks_per_seg;
  192. + nat_blk_addr = (pgoff_t)(nm_i->nat_blkaddr +
  193. + (seg_off << sbi->log_blocks_per_seg << 1) +
  194. + (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
  195. +
  196. + if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
  197. + nat_blk_addr += sbi->blocks_per_seg;
  198. +
  199. + ret = dev_read_block(nat_block, nat_blk_addr);
  200. + ASSERT(ret >= 0);
  201. +
  202. + ne = &nat_block->entries[entry_off];
  203. + wrong_addr = le32_to_cpu(ne->block_addr);
  204. + ne->block_addr = cpu_to_le32(newblk);
  205. +
  206. + dev_write_block(nat_block, nat_blk_addr);
  207. +
  208. +out:
  209. + f2fs_set_bit(nid, fsck->nat_area_bitmap);
  210. + FIX_MSG("nat entry [%d] block_addr [0x%x] -> [0x%x]\n",
  211. + i, wrong_addr, newblk);
  212. + return 0;
  213. +}
  214. +
  215. +static int update_sit_entry(struct f2fs_sb_info *sbi, block_t blk_addr)
  216. +{
  217. + struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
  218. + struct seg_entry *se;
  219. +
  220. + if (f2fs_test_sit_bitmap(sbi, blk_addr)) {
  221. + se = get_seg_entry(sbi, GET_SEGNO(sbi, blk_addr));
  222. + se->valid_blocks += 1;
  223. + f2fs_set_bit(OFFSET_IN_SEG(sbi, blk_addr), (char *)se->cur_valid_map);
  224. + f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk_addr), fsck->sit_area_bitmap);
  225. + }
  226. +
  227. + return 0;
  228. +}
  229. +
  230. +static int do_fix_root_inode(struct f2fs_sb_info *sbi,
  231. + struct f2fs_node *root_node)
  232. +{
  233. + struct node_info ni;
  234. + u32 noffset;
  235. + u64 cnt;
  236. + struct wrapper *new, *ptr = NULL;
  237. + struct f2fs_inode *root_inode;
  238. + block_t blkaddr;
  239. + /* shall we truct that the inode block really is root inode block */
  240. + int weight = 0, pre_weight = 0;
  241. + int fixed = 0;
  242. + nid_t root_ino = F2FS_ROOT_INO(sbi);
  243. + int ret;
  244. +
  245. + /* get inode block */
  246. + ASSERT(root_node);
  247. + new = (struct wrapper *)calloc(sizeof(struct wrapper), 1);
  248. + get_node_info(sbi, root_ino, &ni);
  249. + new->node = root_node;
  250. + new->blk_addr = ni.blk_addr;
  251. + new->next = NULL;
  252. + add_wrapper(&root_head, new);
  253. +
  254. + /*
  255. + * check if the inode block is really the root inode block, choose
  256. + * the node block which has the largest weight
  257. + */
  258. + while (root_head) {
  259. + if (le32_to_cpu(root_head->node->footer.ino) == root_ino)
  260. + weight++;
  261. + if (le32_to_cpu(root_head->node->footer.nid) == root_ino)
  262. + weight++;
  263. + if (S_ISDIR(le16_to_cpu(root_head->node->i.i_mode)))
  264. + weight++;
  265. + /* FIXME: more weight? */
  266. +
  267. + if (weight > pre_weight) {
  268. + /* FIXME: then how about >=? */
  269. + new = root_head;
  270. + pre_weight = weight;
  271. + DBG(1, "find new root_node block %#x\n", new->blk_addr);
  272. + root_head = root_head->next;
  273. + continue;
  274. + }
  275. + ptr = root_head;
  276. + root_head = root_head->next;
  277. + free(ptr->node);
  278. + free(ptr);
  279. + }
  280. + if (pre_weight < 2) {
  281. + /*
  282. + * nat entry may be corrupted, we should not trust what we
  283. + * read. We should select a new place to write it back
  284. + */
  285. + blkaddr = 0; //FIXME: find a new position
  286. + } else {
  287. + blkaddr = new->blk_addr;
  288. + root_node = new->node;
  289. + }
  290. + if (new->blk_addr != ni.blk_addr || root_node != new->node) {
  291. + ret = update_nat_entry(sbi, root_ino, new->blk_addr);
  292. + ASSERT(ret == 0);
  293. + ret = update_sit_entry(sbi, new->blk_addr);
  294. + ASSERT(ret == 0);
  295. + }
  296. +
  297. + root_inode = &root_node->i;
  298. + /* recover i_addr[] */
  299. + cnt = 0;
  300. + while (data_head) {
  301. + ASSERT(cnt < DEF_ADDRS_PER_INODE);
  302. + noffset = le32_to_cpu(data_head->data.sum->ofs_in_node);
  303. + if (le32_to_cpu(root_inode->i_addr[noffset]) != data_head->blk_addr) {
  304. + ASSERT_MSG("root inode: i_addr[%u] = 0x%x, 0x%x\n",
  305. + noffset, le32_to_cpu(root_inode->i_addr[noffset]),
  306. + data_head->blk_addr);
  307. + root_inode->i_addr[noffset] = cpu_to_le32(data_head->blk_addr);
  308. + FIX_MSG("set i_addr[%u] = 0x%x\n", noffset, data_head->blk_addr);
  309. + fixed = 1;
  310. + }
  311. + ptr = data_head;
  312. + data_head = data_head->next;
  313. + free(ptr->data.dentry);
  314. + free(ptr->data.sum);
  315. + free(ptr);
  316. + cnt++;
  317. + }
  318. + DBG(1, "root inode: data blocks %lu\n", cnt);
  319. +
  320. + /* recover i_nid[] */
  321. + cnt = 0;
  322. + while (node_head) {
  323. + ASSERT(cnt < 5);
  324. + noffset = ofs_of_node(node_head->node);
  325. + /* check if noffset is valid */
  326. + if (noffset == 1 || noffset == 2 || noffset == 3) {
  327. + /* noffset is valid, calc the index in i_nid */
  328. + noffset = noffset - 1;
  329. + } else if (noffset == 4 + ADDRS_PER_BLOCK) {
  330. + /* i_nid[3] */
  331. + noffset = 3;
  332. + } else if (noffset == 4 + ADDRS_PER_BLOCK + NIDS_PER_BLOCK) {
  333. + /* i_nid[4] */
  334. + noffset = 4;
  335. + } else {
  336. + /* noffset = 0, node is in i_addr, this must be wrong.
  337. + * noffset = other value, node is in indirect/didirect
  338. + * node. We drop these nodes.
  339. + */
  340. + ASSERT_MSG("root inode: offset of node 0x%x\n", noffset);
  341. + FIX_MSG(" drop node block 0x%x\n", node_head->blk_addr);
  342. + fixed = 1;
  343. + break;
  344. + }
  345. + if (root_inode->i_nid[noffset] != node_head->node->footer.nid) {
  346. + ASSERT_MSG("root inode: i_nid[%u] = 0x%x, 0x%x\n",
  347. + noffset, le32_to_cpu(root_inode->i_nid[noffset]),
  348. + le32_to_cpu(node_head->node->footer.nid));
  349. + root_inode->i_nid[noffset] = node_head->node->footer.nid;
  350. + FIX_MSG("set i_nid[%u] = 0x%x\n", noffset,
  351. + le32_to_cpu(node_head->node->footer.nid));
  352. + fixed = 1;
  353. + }
  354. + ptr = node_head;
  355. + node_head = node_head->next;
  356. + free(ptr->node);
  357. + free(ptr);
  358. + cnt++;
  359. + }
  360. + DBG(1, "root inode: node blocks %lu\n", cnt);
  361. +
  362. + /* recover i_xattr_nid */
  363. + cnt = 0;
  364. + while (xattr_head) {
  365. + ASSERT(cnt < 1);
  366. + if (root_inode->i_xattr_nid != xattr_head->node->footer.nid) {
  367. + root_inode->i_xattr_nid = xattr_head->node->footer.nid;
  368. + FIX_MSG("set i_xattr_nid = 0x%x\n",
  369. + le32_to_cpu(xattr_head->node->footer.nid));
  370. + fixed = 1;
  371. + }
  372. + ptr = xattr_head;
  373. + xattr_head = xattr_head->next;
  374. + free(ptr->node);
  375. + free(ptr);
  376. + cnt++;
  377. + }
  378. + DBG(1, "root inode: xattr blocks %lu\n", cnt);
  379. +
  380. + /* recover other meta of root inode */
  381. + if (le16_to_cpu(root_inode->i_mode) != 0x41ed) {
  382. + root_inode->i_mode = cpu_to_le16(0x41ed); // from f2fs_write_root_inode
  383. + FIX_MSG("set i_mode = 0x41ed\n");
  384. + fixed = 1;
  385. + }
  386. + /* FIXME: how to set appropriate values to these 2 level */
  387. + if (le32_to_cpu(root_inode->i_current_depth) > MAX_DIR_HASH_DEPTH) {
  388. + root_inode->i_current_depth = cpu_to_le32(MAX_DIR_HASH_DEPTH);
  389. + FIX_MSG("set i_current_depth = %u\n", MAX_DIR_HASH_DEPTH);
  390. + fixed = 1;
  391. + }
  392. + if (le32_to_cpu(root_inode->i_dir_level) > MAX_DIR_HASH_DEPTH) {
  393. + root_inode->i_dir_level = cpu_to_le32(DEF_DIR_LEVEL);
  394. + FIX_MSG("set i_dir_level = %u\n", DEF_DIR_LEVEL);
  395. + fixed = 1;
  396. + }
  397. + /* FIXME: is root_inode->i_pino 3? why I get 0 in my case? */
  398. +// if (le32_to_cpu(root_inode->i_pino) != root_ino) {
  399. +// root_inode->i_pino = cpu_to_le32(root_ino);
  400. +// FIX_MSG("set i_pino = %u\n", root_ino);
  401. +// fixed = 1;
  402. +// }
  403. + /*
  404. + * XXX: i_advise, i_inline, i_uid, i_gid, i_*time, i_*time_nsec,
  405. + * i_generation, i_flagsi_flags, i_namelen, i_name
  406. + *
  407. + * XXX: the later fsck -f will fix: i_links, i_blocks, i_ext
  408. + */
  409. +
  410. + if (fixed && !c.ro) {
  411. + ret = dev_write_block(root_node, blkaddr);
  412. + ASSERT(ret >= 0);
  413. + }
  414. +
  415. + return fixed;
  416. +}
  417. +
  418. +/*
  419. + * we can only recover root inode by scanning SSA. Because inode may
  420. + * contains data, only SSA saves which nid the block belonging to
  421. + */
  422. +static int fix_root_inode(struct f2fs_sb_info *sbi, struct f2fs_node *root_node)
  423. +{
  424. + int ret;
  425. +
  426. + /* 1. get all node/data blocks of root inode */
  427. + ret = get_all_wrappers(sbi);
  428. + if (ret)
  429. + return ret;
  430. +
  431. + /* 2. recover root inode and write it back */
  432. + ret = do_fix_root_inode(sbi, root_node);
  433. + if (ret)
  434. + FIX_MSG("fixed root inode\n");
  435. +
  436. + return 0;
  437. +}
  438. +
  439. +int fsck_chk_fs(struct f2fs_sb_info *sbi, u32 *blk_cnt)
  440. +{
  441. + struct node_info ni;
  442. + struct f2fs_node *node_blk = NULL;
  443. + struct f2fs_inode *root_inode;
  444. + enum FILE_TYPE ftype = F2FS_FT_DIR;
  445. + enum NODE_TYPE ntype = TYPE_INODE;
  446. + u32 ino = F2FS_ROOT_INO(sbi);
  447. + int retries = 0, ret;
  448. +
  449. + node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
  450. + ASSERT(node_blk != NULL);
  451. +
  452. +retry:
  453. + /* check if F2FS_ROOT_INO is a correct inode */
  454. + ret = sanity_check_nid(sbi, ino, node_blk, ftype, ntype, &ni);
  455. + if (ret)
  456. + goto fix;
  457. +
  458. + root_inode = &node_blk->i;
  459. +
  460. + /* check if F2FS_ROOT_INO is a directory */
  461. + if (!S_ISDIR(le16_to_cpu(root_inode->i_mode))) {
  462. + ASSERT_MSG("Root inode is not a directory\n");
  463. + goto fix;
  464. + }
  465. +
  466. + fsck_chk_inode_blk(sbi, ino, ftype, node_blk, blk_cnt, &ni, NULL);
  467. + return 0;
  468. +fix:
  469. + ret = fix_root_inode(sbi, node_blk);
  470. + retries++;
  471. + ASSERT(ret == 0);
  472. + ASSERT(retries < 2); // FIXME: how many times to retry?
  473. + goto retry;
  474. +}
  475. +
  476. static inline void get_extent_info(struct extent_info *ext,
  477. struct f2fs_extent *i_ext)
  478. {
  479. @@ -1410,6 +1863,8 @@ static int __chk_dentries(struct f2fs_sb_info *sbi, struct child_info *child,
  480. }
  482. i++;
  483. + print_dentry(fsck->dentry_depth, name, bitmap,
  484. + dentry, max, i, last_blk, enc_name);
  485. free(name);
  486. continue;
  487. }
  488. diff --git a/fsck/fsck.h b/fsck/fsck.h
  489. index 8e133fa..2267492 100644
  490. --- a/fsck/fsck.h
  491. +++ b/fsck/fsck.h
  492. @@ -125,6 +125,7 @@ struct selabel_handle;
  493. extern int fsck_chk_orphan_node(struct f2fs_sb_info *);
  494. extern int fsck_chk_quota_node(struct f2fs_sb_info *);
  495. extern int fsck_chk_quota_files(struct f2fs_sb_info *);
  496. +extern int fsck_chk_fs(struct f2fs_sb_info *sbi, u32 *blk_cnt);
  497. extern int fsck_chk_node_blk(struct f2fs_sb_info *, struct f2fs_inode *, u32,
  498. enum FILE_TYPE, enum NODE_TYPE, u32 *,
  499. struct child_info *);
  500. diff --git a/fsck/main.c b/fsck/main.c
  501. index bbf82c3..97a0d9d 100644
  502. --- a/fsck/main.c
  503. +++ b/fsck/main.c
  504. @@ -562,8 +562,7 @@ static void do_fsck(struct f2fs_sb_info *sbi)
  505. }
  506. }
  507. fsck_chk_orphan_node(sbi);
  508. - fsck_chk_node_blk(sbi, NULL, sbi->root_ino_num,
  509. - F2FS_FT_DIR, TYPE_INODE, &blk_cnt, NULL);
  510. + fsck_chk_fs(sbi, &blk_cnt);
  511. fsck_chk_quota_files(sbi);
  513. fsck_verify(sbi);
  514. diff --git a/fsck/mount.c b/fsck/mount.c
  515. index 4a14320..dd874e5 100644
  516. --- a/fsck/mount.c
  517. +++ b/fsck/mount.c
  518. @@ -245,10 +245,11 @@ void print_inode_info(struct f2fs_sb_info *sbi,
  519. DISP_u32(inode, i_addr[ofs + 3]); /* Pointers to data blocks */
  521. for (i = ofs + 3; i < ADDRS_PER_INODE(inode); i++) {
  522. - if (inode->i_addr[i] == 0x0)
  523. - break;
  524. - printf("i_addr[0x%x] points data block\t\t[0x%4x]\n",
  525. - i, le32_to_cpu(inode->i_addr[i]));
  526. +// if (inode->i_addr[i] == 0x0)
  527. +// break;
  528. +// printf("i_addr[0x%x] points data block\t\t[0x%4x]\n",
  529. +// i, le32_to_cpu(inode->i_addr[i]));
  530. + DISP_u32(inode, i_addr[i]); /* Pointers to data blocks */
  531. }
  533. DISP_u32(inode, i_nid[0]); /* direct */
  534.  
Powered by spacepaste. Paste removal.