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 #include "xattr.h"
13 #include "quotaio.h"
14 #include <time.h>
15
16 char *tree_mark;
17 uint32_t tree_mark_size = 256;
18
f2fs_set_main_bitmap(struct f2fs_sb_info * sbi,u32 blk,int type)19 int f2fs_set_main_bitmap(struct f2fs_sb_info *sbi, u32 blk, int type)
20 {
21 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
22 struct seg_entry *se;
23 int fix = 0;
24
25 se = get_seg_entry(sbi, GET_SEGNO(sbi, blk));
26 if (se->type >= NO_CHECK_TYPE)
27 fix = 1;
28 else if (IS_DATASEG(se->type) != IS_DATASEG(type))
29 fix = 1;
30
31 /* just check data and node types */
32 if (fix) {
33 DBG(1, "Wrong segment type [0x%x] %x -> %x",
34 GET_SEGNO(sbi, blk), se->type, type);
35 se->type = type;
36 }
37 return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->main_area_bitmap);
38 }
39
f2fs_test_main_bitmap(struct f2fs_sb_info * sbi,u32 blk)40 static inline int f2fs_test_main_bitmap(struct f2fs_sb_info *sbi, u32 blk)
41 {
42 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
43
44 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk),
45 fsck->main_area_bitmap);
46 }
47
f2fs_clear_main_bitmap(struct f2fs_sb_info * sbi,u32 blk)48 static inline int f2fs_clear_main_bitmap(struct f2fs_sb_info *sbi, u32 blk)
49 {
50 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
51
52 return f2fs_clear_bit(BLKOFF_FROM_MAIN(sbi, blk),
53 fsck->main_area_bitmap);
54 }
55
f2fs_test_sit_bitmap(struct f2fs_sb_info * sbi,u32 blk)56 static inline int f2fs_test_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk)
57 {
58 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
59
60 return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap);
61 }
62
f2fs_set_sit_bitmap(struct f2fs_sb_info * sbi,u32 blk)63 int f2fs_set_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk)
64 {
65 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
66
67 return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap);
68 }
69
add_into_hard_link_list(struct f2fs_sb_info * sbi,u32 nid,u32 link_cnt)70 static int add_into_hard_link_list(struct f2fs_sb_info *sbi,
71 u32 nid, u32 link_cnt)
72 {
73 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
74 struct hard_link_node *node = NULL, *tmp = NULL, *prev = NULL;
75
76 node = calloc(sizeof(struct hard_link_node), 1);
77 ASSERT(node != NULL);
78
79 node->nid = nid;
80 node->links = link_cnt;
81 node->actual_links = 1;
82 node->next = NULL;
83
84 if (fsck->hard_link_list_head == NULL) {
85 fsck->hard_link_list_head = node;
86 goto out;
87 }
88
89 tmp = fsck->hard_link_list_head;
90
91 /* Find insertion position */
92 while (tmp && (nid < tmp->nid)) {
93 ASSERT(tmp->nid != nid);
94 prev = tmp;
95 tmp = tmp->next;
96 }
97
98 if (tmp == fsck->hard_link_list_head) {
99 node->next = tmp;
100 fsck->hard_link_list_head = node;
101 } else {
102 prev->next = node;
103 node->next = tmp;
104 }
105
106 out:
107 DBG(2, "ino[0x%x] has hard links [0x%x]\n", nid, link_cnt);
108 return 0;
109 }
110
find_and_dec_hard_link_list(struct f2fs_sb_info * sbi,u32 nid)111 static int find_and_dec_hard_link_list(struct f2fs_sb_info *sbi, u32 nid)
112 {
113 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
114 struct hard_link_node *node = NULL, *prev = NULL;
115
116 if (fsck->hard_link_list_head == NULL)
117 return -EINVAL;
118
119 node = fsck->hard_link_list_head;
120
121 while (node && (nid < node->nid)) {
122 prev = node;
123 node = node->next;
124 }
125
126 if (node == NULL || (nid != node->nid))
127 return -EINVAL;
128
129 /* Decrease link count */
130 node->links = node->links - 1;
131 node->actual_links++;
132
133 /* if link count becomes one, remove the node */
134 if (node->links == 1) {
135 if (fsck->hard_link_list_head == node)
136 fsck->hard_link_list_head = node->next;
137 else
138 prev->next = node->next;
139 free(node);
140 }
141 return 0;
142 }
143
is_valid_ssa_node_blk(struct f2fs_sb_info * sbi,u32 nid,u32 blk_addr)144 static int is_valid_ssa_node_blk(struct f2fs_sb_info *sbi, u32 nid,
145 u32 blk_addr)
146 {
147 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
148 struct f2fs_summary_block *sum_blk;
149 struct f2fs_summary *sum_entry;
150 struct seg_entry * se;
151 u32 segno, offset;
152 int need_fix = 0, ret = 0;
153 int type;
154
155 if (get_sb(feature) & cpu_to_le32(F2FS_FEATURE_RO))
156 return 0;
157
158 segno = GET_SEGNO(sbi, blk_addr);
159 offset = OFFSET_IN_SEG(sbi, blk_addr);
160
161 sum_blk = get_sum_block(sbi, segno, &type);
162
163 if (type != SEG_TYPE_NODE && type != SEG_TYPE_CUR_NODE) {
164 /* can't fix current summary, then drop the block */
165 if (!c.fix_on || type < 0) {
166 ASSERT_MSG("Summary footer is not for node segment");
167 ret = -EINVAL;
168 goto out;
169 }
170
171 need_fix = 1;
172 se = get_seg_entry(sbi, segno);
173 if(IS_NODESEG(se->type)) {
174 FIX_MSG("Summary footer indicates a node segment: 0x%x", segno);
175 sum_blk->footer.entry_type = SUM_TYPE_NODE;
176 } else {
177 ret = -EINVAL;
178 goto out;
179 }
180 }
181
182 sum_entry = &(sum_blk->entries[offset]);
183
184 if (le32_to_cpu(sum_entry->nid) != nid) {
185 if (!c.fix_on || type < 0) {
186 DBG(0, "nid [0x%x]\n", nid);
187 DBG(0, "target blk_addr [0x%x]\n", blk_addr);
188 DBG(0, "summary blk_addr [0x%x]\n",
189 GET_SUM_BLKADDR(sbi,
190 GET_SEGNO(sbi, blk_addr)));
191 DBG(0, "seg no / offset [0x%x / 0x%x]\n",
192 GET_SEGNO(sbi, blk_addr),
193 OFFSET_IN_SEG(sbi, blk_addr));
194 DBG(0, "summary_entry.nid [0x%x]\n",
195 le32_to_cpu(sum_entry->nid));
196 DBG(0, "--> node block's nid [0x%x]\n", nid);
197 ASSERT_MSG("Invalid node seg summary\n");
198 ret = -EINVAL;
199 } else {
200 FIX_MSG("Set node summary 0x%x -> [0x%x] [0x%x]",
201 segno, nid, blk_addr);
202 sum_entry->nid = cpu_to_le32(nid);
203 need_fix = 1;
204 }
205 }
206 if (need_fix && f2fs_dev_is_writable()) {
207 u64 ssa_blk;
208 int ret2;
209
210 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
211 ret2 = dev_write_block(sum_blk, ssa_blk);
212 ASSERT(ret2 >= 0);
213 }
214 out:
215 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA ||
216 type == SEG_TYPE_MAX)
217 free(sum_blk);
218 return ret;
219 }
220
is_valid_summary(struct f2fs_sb_info * sbi,struct f2fs_summary * sum,u32 blk_addr)221 static int is_valid_summary(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
222 u32 blk_addr)
223 {
224 u16 ofs_in_node = le16_to_cpu(sum->ofs_in_node);
225 u32 nid = le32_to_cpu(sum->nid);
226 struct f2fs_node *node_blk = NULL;
227 __le32 target_blk_addr;
228 struct node_info ni;
229 int ret = 0;
230
231 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
232 ASSERT(node_blk != NULL);
233
234 if (!IS_VALID_NID(sbi, nid))
235 goto out;
236
237 get_node_info(sbi, nid, &ni);
238
239 if (!IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
240 goto out;
241
242 /* read node_block */
243 ret = dev_read_block(node_blk, ni.blk_addr);
244 ASSERT(ret >= 0);
245
246 if (le32_to_cpu(node_blk->footer.nid) != nid)
247 goto out;
248
249 /* check its block address */
250 if (node_blk->footer.nid == node_blk->footer.ino) {
251 int ofs = get_extra_isize(node_blk);
252
253 if (ofs + ofs_in_node >= DEF_ADDRS_PER_INODE)
254 goto out;
255 target_blk_addr = node_blk->i.i_addr[ofs + ofs_in_node];
256 } else {
257 if (ofs_in_node >= DEF_ADDRS_PER_BLOCK)
258 goto out;
259 target_blk_addr = node_blk->dn.addr[ofs_in_node];
260 }
261
262 if (blk_addr == le32_to_cpu(target_blk_addr))
263 ret = 1;
264 out:
265 free(node_blk);
266 return ret;
267 }
268
is_valid_ssa_data_blk(struct f2fs_sb_info * sbi,u32 blk_addr,u32 parent_nid,u16 idx_in_node,u8 version)269 static int is_valid_ssa_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr,
270 u32 parent_nid, u16 idx_in_node, u8 version)
271 {
272 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
273 struct f2fs_summary_block *sum_blk;
274 struct f2fs_summary *sum_entry;
275 struct seg_entry * se;
276 u32 segno, offset;
277 int need_fix = 0, ret = 0;
278 int type;
279
280 if (get_sb(feature) & cpu_to_le32(F2FS_FEATURE_RO))
281 return 0;
282
283 segno = GET_SEGNO(sbi, blk_addr);
284 offset = OFFSET_IN_SEG(sbi, blk_addr);
285
286 sum_blk = get_sum_block(sbi, segno, &type);
287
288 if (type != SEG_TYPE_DATA && type != SEG_TYPE_CUR_DATA) {
289 /* can't fix current summary, then drop the block */
290 if (!c.fix_on || type < 0) {
291 ASSERT_MSG("Summary footer is not for data segment");
292 ret = -EINVAL;
293 goto out;
294 }
295
296 need_fix = 1;
297 se = get_seg_entry(sbi, segno);
298 if (IS_DATASEG(se->type)) {
299 FIX_MSG("Summary footer indicates a data segment: 0x%x", segno);
300 sum_blk->footer.entry_type = SUM_TYPE_DATA;
301 } else {
302 ret = -EINVAL;
303 goto out;
304 }
305 }
306
307 sum_entry = &(sum_blk->entries[offset]);
308
309 if (le32_to_cpu(sum_entry->nid) != parent_nid ||
310 sum_entry->version != version ||
311 le16_to_cpu(sum_entry->ofs_in_node) != idx_in_node) {
312 if (!c.fix_on || type < 0) {
313 DBG(0, "summary_entry.nid [0x%x]\n",
314 le32_to_cpu(sum_entry->nid));
315 DBG(0, "summary_entry.version [0x%x]\n",
316 sum_entry->version);
317 DBG(0, "summary_entry.ofs_in_node [0x%x]\n",
318 le16_to_cpu(sum_entry->ofs_in_node));
319 DBG(0, "parent nid [0x%x]\n",
320 parent_nid);
321 DBG(0, "version from nat [0x%x]\n", version);
322 DBG(0, "idx in parent node [0x%x]\n",
323 idx_in_node);
324
325 DBG(0, "Target data block addr [0x%x]\n", blk_addr);
326 ASSERT_MSG("Invalid data seg summary\n");
327 ret = -EINVAL;
328 } else if (is_valid_summary(sbi, sum_entry, blk_addr)) {
329 /* delete wrong index */
330 ret = -EINVAL;
331 } else {
332 FIX_MSG("Set data summary 0x%x -> [0x%x] [0x%x] [0x%x]",
333 segno, parent_nid, version, idx_in_node);
334 sum_entry->nid = cpu_to_le32(parent_nid);
335 sum_entry->version = version;
336 sum_entry->ofs_in_node = cpu_to_le16(idx_in_node);
337 need_fix = 1;
338 }
339 }
340 if (need_fix && f2fs_dev_is_writable()) {
341 u64 ssa_blk;
342 int ret2;
343
344 ssa_blk = GET_SUM_BLKADDR(sbi, segno);
345 ret2 = dev_write_block(sum_blk, ssa_blk);
346 ASSERT(ret2 >= 0);
347 }
348 out:
349 if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA ||
350 type == SEG_TYPE_MAX)
351 free(sum_blk);
352 return ret;
353 }
354
__check_inode_mode(u32 nid,enum FILE_TYPE ftype,u16 mode)355 static int __check_inode_mode(u32 nid, enum FILE_TYPE ftype, u16 mode)
356 {
357 if (ftype >= F2FS_FT_MAX)
358 return 0;
359 /* f2fs_iget will return -EIO if mode is not valid file type */
360 if (!S_ISLNK(mode) && !S_ISREG(mode) && !S_ISDIR(mode) &&
361 !S_ISCHR(mode) && !S_ISBLK(mode) && !S_ISFIFO(mode) &&
362 !S_ISSOCK(mode)) {
363 ASSERT_MSG("inode [0x%x] unknown file type i_mode [0x%x]",
364 nid, mode);
365 return -1;
366 }
367
368 if (S_ISLNK(mode) && ftype != F2FS_FT_SYMLINK)
369 goto err;
370 if (S_ISREG(mode) && ftype != F2FS_FT_REG_FILE)
371 goto err;
372 if (S_ISDIR(mode) && ftype != F2FS_FT_DIR)
373 goto err;
374 if (S_ISCHR(mode) && ftype != F2FS_FT_CHRDEV)
375 goto err;
376 if (S_ISBLK(mode) && ftype != F2FS_FT_BLKDEV)
377 goto err;
378 if (S_ISFIFO(mode) && ftype != F2FS_FT_FIFO)
379 goto err;
380 if (S_ISSOCK(mode) && ftype != F2FS_FT_SOCK)
381 goto err;
382 return 0;
383 err:
384 ASSERT_MSG("inode [0x%x] mismatch i_mode [0x%x vs. 0x%x]",
385 nid, ftype, mode);
386 return -1;
387 }
388
sanity_check_nid(struct f2fs_sb_info * sbi,u32 nid,struct f2fs_node * node_blk,enum FILE_TYPE ftype,enum NODE_TYPE ntype,struct node_info * ni)389 static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
390 struct f2fs_node *node_blk,
391 enum FILE_TYPE ftype, enum NODE_TYPE ntype,
392 struct node_info *ni)
393 {
394 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
395 int ret;
396
397 if (!IS_VALID_NID(sbi, nid)) {
398 ASSERT_MSG("nid is not valid. [0x%x]", nid);
399 return -EINVAL;
400 }
401
402 get_node_info(sbi, nid, ni);
403 if (ni->ino == 0) {
404 ASSERT_MSG("nid[0x%x] ino is 0", nid);
405 return -EINVAL;
406 }
407
408 if (ni->blk_addr == NEW_ADDR) {
409 ASSERT_MSG("nid is NEW_ADDR. [0x%x]", nid);
410 return -EINVAL;
411 }
412
413 if (!IS_VALID_BLK_ADDR(sbi, ni->blk_addr)) {
414 ASSERT_MSG("blkaddress is not valid. [0x%x]", ni->blk_addr);
415 return -EINVAL;
416 }
417
418 ret = dev_read_block(node_blk, ni->blk_addr);
419 ASSERT(ret >= 0);
420
421 if (ntype == TYPE_INODE &&
422 node_blk->footer.nid != node_blk->footer.ino) {
423 ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]",
424 nid, le32_to_cpu(node_blk->footer.nid),
425 le32_to_cpu(node_blk->footer.ino));
426 return -EINVAL;
427 }
428 if (ni->ino != le32_to_cpu(node_blk->footer.ino)) {
429 ASSERT_MSG("nid[0x%x] nat_entry->ino[0x%x] footer.ino[0x%x]",
430 nid, ni->ino, le32_to_cpu(node_blk->footer.ino));
431 return -EINVAL;
432 }
433 if (ntype != TYPE_INODE &&
434 node_blk->footer.nid == node_blk->footer.ino) {
435 ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]",
436 nid, le32_to_cpu(node_blk->footer.nid),
437 le32_to_cpu(node_blk->footer.ino));
438 return -EINVAL;
439 }
440
441 if (le32_to_cpu(node_blk->footer.nid) != nid) {
442 ASSERT_MSG("nid[0x%x] blk_addr[0x%x] footer.nid[0x%x]",
443 nid, ni->blk_addr,
444 le32_to_cpu(node_blk->footer.nid));
445 return -EINVAL;
446 }
447
448 if (ntype == TYPE_XATTR) {
449 u32 flag = le32_to_cpu(node_blk->footer.flag);
450
451 if ((flag >> OFFSET_BIT_SHIFT) != XATTR_NODE_OFFSET) {
452 ASSERT_MSG("xnid[0x%x] has wrong ofs:[0x%x]",
453 nid, flag);
454 return -EINVAL;
455 }
456 }
457
458 if ((ntype == TYPE_INODE && ftype == F2FS_FT_DIR) ||
459 (ntype == TYPE_XATTR && ftype == F2FS_FT_XATTR)) {
460 /* not included '.' & '..' */
461 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) != 0) {
462 ASSERT_MSG("Duplicated node blk. nid[0x%x][0x%x]\n",
463 nid, ni->blk_addr);
464 return -EINVAL;
465 }
466 }
467
468 /* this if only from fix_hard_links */
469 if (ftype == F2FS_FT_MAX)
470 return 0;
471
472 if (ntype == TYPE_INODE &&
473 __check_inode_mode(nid, ftype, le16_to_cpu(node_blk->i.i_mode)))
474 return -EINVAL;
475
476 /* workaround to fix later */
477 if (ftype != F2FS_FT_ORPHAN ||
478 f2fs_test_bit(nid, fsck->nat_area_bitmap) != 0) {
479 f2fs_clear_bit(nid, fsck->nat_area_bitmap);
480 /* avoid reusing nid when reconnecting files */
481 f2fs_set_bit(nid, NM_I(sbi)->nid_bitmap);
482 } else
483 ASSERT_MSG("orphan or xattr nid is duplicated [0x%x]\n",
484 nid);
485
486 if (is_valid_ssa_node_blk(sbi, nid, ni->blk_addr)) {
487 ASSERT_MSG("summary node block is not valid. [0x%x]", nid);
488 return -EINVAL;
489 }
490
491 if (f2fs_test_sit_bitmap(sbi, ni->blk_addr) == 0)
492 ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]",
493 ni->blk_addr);
494
495 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
496
497 fsck->chk.valid_blk_cnt++;
498 fsck->chk.valid_node_cnt++;
499
500 /* Progress report */
501 if (!c.show_file_map && sbi->total_valid_node_count > 1000) {
502 unsigned int p10 = sbi->total_valid_node_count / 10;
503
504 if (sbi->fsck->chk.checked_node_cnt++ % p10)
505 return 0;
506
507 printf("[FSCK] Check node %"PRIu64" / %u (%.2f%%)\n",
508 sbi->fsck->chk.checked_node_cnt,
509 sbi->total_valid_node_count,
510 10 * (float)sbi->fsck->chk.checked_node_cnt /
511 p10);
512 }
513 }
514 return 0;
515 }
516
fsck_sanity_check_nid(struct f2fs_sb_info * sbi,u32 nid,struct f2fs_node * node_blk,enum FILE_TYPE ftype,enum NODE_TYPE ntype,struct node_info * ni)517 int fsck_sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
518 struct f2fs_node *node_blk,
519 enum FILE_TYPE ftype, enum NODE_TYPE ntype,
520 struct node_info *ni)
521 {
522 return sanity_check_nid(sbi, nid, node_blk, ftype, ntype, ni);
523 }
524
fsck_chk_xattr_blk(struct f2fs_sb_info * sbi,u32 ino,u32 x_nid,u32 * blk_cnt)525 static int fsck_chk_xattr_blk(struct f2fs_sb_info *sbi, u32 ino,
526 u32 x_nid, u32 *blk_cnt)
527 {
528 struct f2fs_node *node_blk = NULL;
529 struct node_info ni;
530 int ret = 0;
531
532 if (x_nid == 0x0)
533 return 0;
534
535 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
536 ASSERT(node_blk != NULL);
537
538 /* Sanity check */
539 if (sanity_check_nid(sbi, x_nid, node_blk,
540 F2FS_FT_XATTR, TYPE_XATTR, &ni)) {
541 ret = -EINVAL;
542 goto out;
543 }
544
545 *blk_cnt = *blk_cnt + 1;
546 f2fs_set_main_bitmap(sbi, ni.blk_addr, CURSEG_COLD_NODE);
547 DBG(2, "ino[0x%x] x_nid[0x%x]\n", ino, x_nid);
548 out:
549 free(node_blk);
550 return ret;
551 }
552
fsck_chk_node_blk(struct f2fs_sb_info * sbi,struct f2fs_inode * inode,u32 nid,enum FILE_TYPE ftype,enum NODE_TYPE ntype,u32 * blk_cnt,struct f2fs_compr_blk_cnt * cbc,struct child_info * child)553 int fsck_chk_node_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
554 u32 nid, enum FILE_TYPE ftype, enum NODE_TYPE ntype,
555 u32 *blk_cnt, struct f2fs_compr_blk_cnt *cbc,
556 struct child_info *child)
557 {
558 struct node_info ni;
559 struct f2fs_node *node_blk = NULL;
560
561 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
562 ASSERT(node_blk != NULL);
563
564 if (sanity_check_nid(sbi, nid, node_blk, ftype, ntype, &ni))
565 goto err;
566
567 if (ntype == TYPE_INODE) {
568 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
569
570 fsck_chk_inode_blk(sbi, nid, ftype, node_blk, blk_cnt, cbc,
571 &ni, child);
572 quota_add_inode_usage(fsck->qctx, nid, &node_blk->i);
573 } else {
574 switch (ntype) {
575 case TYPE_DIRECT_NODE:
576 f2fs_set_main_bitmap(sbi, ni.blk_addr,
577 CURSEG_WARM_NODE);
578 fsck_chk_dnode_blk(sbi, inode, nid, ftype, node_blk,
579 blk_cnt, cbc, child, &ni);
580 break;
581 case TYPE_INDIRECT_NODE:
582 f2fs_set_main_bitmap(sbi, ni.blk_addr,
583 CURSEG_COLD_NODE);
584 fsck_chk_idnode_blk(sbi, inode, ftype, node_blk,
585 blk_cnt, cbc, child);
586 break;
587 case TYPE_DOUBLE_INDIRECT_NODE:
588 f2fs_set_main_bitmap(sbi, ni.blk_addr,
589 CURSEG_COLD_NODE);
590 fsck_chk_didnode_blk(sbi, inode, ftype, node_blk,
591 blk_cnt, cbc, child);
592 break;
593 default:
594 ASSERT(0);
595 }
596 }
597 free(node_blk);
598 return 0;
599 err:
600 free(node_blk);
601 return -EINVAL;
602 }
603
get_extent_info(struct extent_info * ext,struct f2fs_extent * i_ext)604 static inline void get_extent_info(struct extent_info *ext,
605 struct f2fs_extent *i_ext)
606 {
607 ext->fofs = le32_to_cpu(i_ext->fofs);
608 ext->blk = le32_to_cpu(i_ext->blk_addr);
609 ext->len = le32_to_cpu(i_ext->len);
610 }
611
check_extent_info(struct child_info * child,block_t blkaddr,int last)612 static void check_extent_info(struct child_info *child,
613 block_t blkaddr, int last)
614 {
615 struct extent_info *ei = &child->ei;
616 u32 pgofs = child->pgofs;
617 int is_hole = 0;
618
619 if (!ei->len)
620 return;
621
622 if (child->state & FSCK_UNMATCHED_EXTENT)
623 return;
624
625 if ((child->state & FSCK_INLINE_INODE) && ei->len)
626 goto unmatched;
627
628 if (last) {
629 /* hole exist in the back of extent */
630 if (child->last_blk != ei->blk + ei->len - 1)
631 child->state |= FSCK_UNMATCHED_EXTENT;
632 return;
633 }
634
635 if (blkaddr == NULL_ADDR || blkaddr == NEW_ADDR)
636 is_hole = 1;
637
638 if (pgofs >= ei->fofs && pgofs < ei->fofs + ei->len) {
639 /* unmatched blkaddr */
640 if (is_hole || (blkaddr != pgofs - ei->fofs + ei->blk))
641 goto unmatched;
642
643 if (!child->last_blk) {
644 /* hole exists in the front of extent */
645 if (pgofs != ei->fofs)
646 goto unmatched;
647 } else if (child->last_blk + 1 != blkaddr) {
648 /* hole exists in the middle of extent */
649 goto unmatched;
650 }
651 child->last_blk = blkaddr;
652 return;
653 }
654
655 if (is_hole)
656 return;
657
658 if (blkaddr < ei->blk || blkaddr >= ei->blk + ei->len)
659 return;
660 /* unmatched file offset */
661 unmatched:
662 child->state |= FSCK_UNMATCHED_EXTENT;
663 }
664
fsck_reada_node_block(struct f2fs_sb_info * sbi,u32 nid)665 void fsck_reada_node_block(struct f2fs_sb_info *sbi, u32 nid)
666 {
667 struct node_info ni;
668
669 if (nid != 0 && IS_VALID_NID(sbi, nid)) {
670 get_node_info(sbi, nid, &ni);
671 if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
672 dev_reada_block(ni.blk_addr);
673 }
674 }
675
fsck_reada_all_direct_node_blocks(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk)676 void fsck_reada_all_direct_node_blocks(struct f2fs_sb_info *sbi,
677 struct f2fs_node *node_blk)
678 {
679 int i;
680
681 for (i = 0; i < NIDS_PER_BLOCK; i++) {
682 u32 nid = le32_to_cpu(node_blk->in.nid[i]);
683
684 fsck_reada_node_block(sbi, nid);
685 }
686 }
687
688 /* start with valid nid and blkaddr */
fsck_chk_inode_blk(struct f2fs_sb_info * sbi,u32 nid,enum FILE_TYPE ftype,struct f2fs_node * node_blk,u32 * blk_cnt,struct f2fs_compr_blk_cnt * cbc,struct node_info * ni,struct child_info * child_d)689 void fsck_chk_inode_blk(struct f2fs_sb_info *sbi, u32 nid,
690 enum FILE_TYPE ftype, struct f2fs_node *node_blk,
691 u32 *blk_cnt, struct f2fs_compr_blk_cnt *cbc,
692 struct node_info *ni, struct child_info *child_d)
693 {
694 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
695 struct child_info child;
696 enum NODE_TYPE ntype;
697 u32 i_links = le32_to_cpu(node_blk->i.i_links);
698 u64 i_size = le64_to_cpu(node_blk->i.i_size);
699 u64 i_blocks = le64_to_cpu(node_blk->i.i_blocks);
700 bool compr_supported = c.feature & cpu_to_le32(F2FS_FEATURE_COMPRESSION);
701 u32 i_flags = le32_to_cpu(node_blk->i.i_flags);
702 bool compressed = i_flags & F2FS_COMPR_FL;
703 bool compr_rel = node_blk->i.i_inline & F2FS_COMPRESS_RELEASED;
704 u64 i_compr_blocks = le64_to_cpu(node_blk->i.i_compr_blocks);
705 nid_t i_xattr_nid = le32_to_cpu(node_blk->i.i_xattr_nid);
706 int ofs;
707 char *en;
708 u32 namelen;
709 unsigned int addrs, idx = 0;
710 unsigned short i_gc_failures;
711 int need_fix = 0;
712 int ret;
713 u32 cluster_size = 1 << node_blk->i.i_log_cluster_size;
714
715 if (!compressed)
716 goto check_next;
717
718 if (!compr_supported || (node_blk->i.i_inline & F2FS_INLINE_DATA)) {
719 /*
720 * The 'compression' flag in i_flags affects the traverse of
721 * the node tree. Thus, it must be fixed unconditionally
722 * in the memory (node_blk).
723 */
724 node_blk->i.i_flags &= ~cpu_to_le32(F2FS_COMPR_FL);
725 compressed = false;
726 if (c.fix_on) {
727 need_fix = 1;
728 FIX_MSG("[0x%x] i_flags=0x%x -> 0x%x",
729 nid, i_flags, node_blk->i.i_flags);
730 }
731 i_flags &= ~F2FS_COMPR_FL;
732 }
733 check_next:
734 memset(&child, 0, sizeof(child));
735 child.links = 2;
736 child.p_ino = nid;
737 child.pp_ino = le32_to_cpu(node_blk->i.i_pino);
738 child.dir_level = node_blk->i.i_dir_level;
739
740 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0)
741 fsck->chk.valid_inode_cnt++;
742
743 if (ftype == F2FS_FT_DIR) {
744 f2fs_set_main_bitmap(sbi, ni->blk_addr, CURSEG_HOT_NODE);
745 namelen = le32_to_cpu(node_blk->i.i_namelen);
746 if (namelen > F2FS_NAME_LEN)
747 namelen = F2FS_NAME_LEN;
748 memcpy(child.p_name, node_blk->i.i_name, namelen);
749 } else {
750 if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
751 f2fs_set_main_bitmap(sbi, ni->blk_addr,
752 CURSEG_WARM_NODE);
753 if (i_links > 1 && ftype != F2FS_FT_ORPHAN &&
754 !is_qf_ino(F2FS_RAW_SUPER(sbi), nid)) {
755 /* First time. Create new hard link node */
756 add_into_hard_link_list(sbi, nid, i_links);
757 fsck->chk.multi_hard_link_files++;
758 }
759 } else {
760 DBG(3, "[0x%x] has hard links [0x%x]\n", nid, i_links);
761 if (find_and_dec_hard_link_list(sbi, nid)) {
762 ASSERT_MSG("[0x%x] needs more i_links=0x%x",
763 nid, i_links);
764 if (c.fix_on) {
765 node_blk->i.i_links =
766 cpu_to_le32(i_links + 1);
767 need_fix = 1;
768 FIX_MSG("File: 0x%x "
769 "i_links= 0x%x -> 0x%x",
770 nid, i_links, i_links + 1);
771 }
772 goto skip_blkcnt_fix;
773 }
774 /* No need to go deep into the node */
775 return;
776 }
777 }
778
779 /* readahead xattr node block */
780 fsck_reada_node_block(sbi, i_xattr_nid);
781
782 if (fsck_chk_xattr_blk(sbi, nid, i_xattr_nid, blk_cnt)) {
783 if (c.fix_on) {
784 node_blk->i.i_xattr_nid = 0;
785 need_fix = 1;
786 FIX_MSG("Remove xattr block: 0x%x, x_nid = 0x%x",
787 nid, i_xattr_nid);
788 }
789 }
790
791 if (ftype == F2FS_FT_CHRDEV || ftype == F2FS_FT_BLKDEV ||
792 ftype == F2FS_FT_FIFO || ftype == F2FS_FT_SOCK)
793 goto check;
794
795 /* init extent info */
796 get_extent_info(&child.ei, &node_blk->i.i_ext);
797 child.last_blk = 0;
798
799 if (f2fs_has_extra_isize(&node_blk->i)) {
800 if (c.feature & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) {
801 unsigned int isize =
802 le16_to_cpu(node_blk->i.i_extra_isize);
803 if (isize > 4 * DEF_ADDRS_PER_INODE) {
804 ASSERT_MSG("[0x%x] wrong i_extra_isize=0x%x",
805 nid, isize);
806 if (c.fix_on) {
807 FIX_MSG("ino[0x%x] recover i_extra_isize "
808 "from %u to %u",
809 nid, isize,
810 calc_extra_isize());
811 node_blk->i.i_extra_isize =
812 cpu_to_le16(calc_extra_isize());
813 need_fix = 1;
814 }
815 }
816 } else {
817 ASSERT_MSG("[0x%x] wrong extra_attr flag", nid);
818 if (c.fix_on) {
819 FIX_MSG("ino[0x%x] remove F2FS_EXTRA_ATTR "
820 "flag in i_inline:%u",
821 nid, node_blk->i.i_inline);
822 /* we don't support tuning F2FS_FEATURE_EXTRA_ATTR now */
823 node_blk->i.i_inline &= ~F2FS_EXTRA_ATTR;
824 need_fix = 1;
825 }
826 }
827
828 if ((c.feature &
829 cpu_to_le32(F2FS_FEATURE_FLEXIBLE_INLINE_XATTR)) &&
830 (node_blk->i.i_inline & F2FS_INLINE_XATTR)) {
831 unsigned int inline_size =
832 le16_to_cpu(node_blk->i.i_inline_xattr_size);
833
834 if (!inline_size ||
835 inline_size > MAX_INLINE_XATTR_SIZE) {
836 ASSERT_MSG("[0x%x] wrong inline_xattr_size:%u",
837 nid, inline_size);
838 if (c.fix_on) {
839 FIX_MSG("ino[0x%x] recover inline xattr size "
840 "from %u to %u",
841 nid, inline_size,
842 DEFAULT_INLINE_XATTR_ADDRS);
843 node_blk->i.i_inline_xattr_size =
844 cpu_to_le16(DEFAULT_INLINE_XATTR_ADDRS);
845 need_fix = 1;
846 }
847 }
848 }
849 }
850 ofs = get_extra_isize(node_blk);
851
852 if ((node_blk->i.i_flags & cpu_to_le32(F2FS_CASEFOLD_FL)) &&
853 (ftype != F2FS_FT_DIR ||
854 !(c.feature & cpu_to_le32(F2FS_FEATURE_CASEFOLD)))) {
855 ASSERT_MSG("[0x%x] unexpected casefold flag", nid);
856 if (c.fix_on) {
857 FIX_MSG("ino[0x%x] clear casefold flag", nid);
858 node_blk->i.i_flags &= ~cpu_to_le32(F2FS_CASEFOLD_FL);
859 need_fix = 1;
860 }
861 }
862
863 if ((node_blk->i.i_inline & F2FS_INLINE_DATA)) {
864 unsigned int inline_size = MAX_INLINE_DATA(node_blk);
865 if (cur_qtype != -1)
866 qf_szchk_type[cur_qtype] = QF_SZCHK_INLINE;
867 block_t blkaddr = le32_to_cpu(node_blk->i.i_addr[ofs]);
868
869 if (blkaddr != 0) {
870 ASSERT_MSG("[0x%x] wrong inline reserve blkaddr:%u",
871 nid, blkaddr);
872 if (c.fix_on) {
873 FIX_MSG("inline_data has wrong 0'th block = %x",
874 blkaddr);
875 node_blk->i.i_addr[ofs] = 0;
876 node_blk->i.i_blocks = cpu_to_le64(*blk_cnt);
877 need_fix = 1;
878 }
879 }
880 if (i_size > inline_size) {
881 ASSERT_MSG("[0x%x] wrong inline size:%lu",
882 nid, (unsigned long)i_size);
883 if (c.fix_on) {
884 node_blk->i.i_size = cpu_to_le64(inline_size);
885 FIX_MSG("inline_data has wrong i_size %lu",
886 (unsigned long)i_size);
887 need_fix = 1;
888 }
889 }
890 if (!(node_blk->i.i_inline & F2FS_DATA_EXIST)) {
891 char buf[MAX_INLINE_DATA(node_blk)];
892 memset(buf, 0, MAX_INLINE_DATA(node_blk));
893
894 if (memcmp(buf, inline_data_addr(node_blk),
895 MAX_INLINE_DATA(node_blk))) {
896 ASSERT_MSG("[0x%x] junk inline data", nid);
897 if (c.fix_on) {
898 FIX_MSG("inline_data has DATA_EXIST");
899 node_blk->i.i_inline |= F2FS_DATA_EXIST;
900 need_fix = 1;
901 }
902 }
903 }
904 DBG(3, "ino[0x%x] has inline data!\n", nid);
905 child.state |= FSCK_INLINE_INODE;
906 goto check;
907 }
908
909 if ((node_blk->i.i_inline & F2FS_INLINE_DENTRY)) {
910 block_t blkaddr = le32_to_cpu(node_blk->i.i_addr[ofs]);
911
912 DBG(3, "ino[0x%x] has inline dentry!\n", nid);
913 if (blkaddr != 0) {
914 ASSERT_MSG("[0x%x] wrong inline reserve blkaddr:%u",
915 nid, blkaddr);
916 if (c.fix_on) {
917 FIX_MSG("inline_dentry has wrong 0'th block = %x",
918 blkaddr);
919 node_blk->i.i_addr[ofs] = 0;
920 node_blk->i.i_blocks = cpu_to_le64(*blk_cnt);
921 need_fix = 1;
922 }
923 }
924
925 ret = fsck_chk_inline_dentries(sbi, node_blk, &child);
926 if (ret < 0) {
927 if (c.fix_on)
928 need_fix = 1;
929 }
930 child.state |= FSCK_INLINE_INODE;
931 goto check;
932 }
933
934 /* check data blocks in inode */
935 addrs = ADDRS_PER_INODE(&node_blk->i);
936 if (cur_qtype != -1) {
937 u64 addrs_per_blk = (u64)ADDRS_PER_BLOCK(&node_blk->i);
938 qf_szchk_type[cur_qtype] = QF_SZCHK_REGFILE;
939 qf_maxsize[cur_qtype] = (u64)(addrs + 2 * addrs_per_blk +
940 2 * addrs_per_blk * NIDS_PER_BLOCK +
941 addrs_per_blk * NIDS_PER_BLOCK *
942 NIDS_PER_BLOCK) * F2FS_BLKSIZE;
943 }
944 for (idx = 0; idx < addrs; idx++, child.pgofs++) {
945 block_t blkaddr = le32_to_cpu(node_blk->i.i_addr[ofs + idx]);
946
947 /* check extent info */
948 check_extent_info(&child, blkaddr, 0);
949
950 if (blkaddr == NULL_ADDR)
951 continue;
952 if (blkaddr == COMPRESS_ADDR) {
953 if (!compressed || (child.pgofs &
954 (cluster_size - 1)) != 0) {
955 if (c.fix_on) {
956 node_blk->i.i_addr[ofs + idx] =
957 NULL_ADDR;
958 need_fix = 1;
959 FIX_MSG("[0x%x] i_addr[%d] = 0", nid,
960 ofs + idx);
961 }
962 continue;
963 }
964 if (!compr_rel) {
965 fsck->chk.valid_blk_cnt++;
966 *blk_cnt = *blk_cnt + 1;
967 cbc->cheader_pgofs = child.pgofs;
968 cbc->cnt++;
969 }
970 continue;
971 }
972 if (!compr_rel && blkaddr == NEW_ADDR &&
973 child.pgofs - cbc->cheader_pgofs < cluster_size)
974 cbc->cnt++;
975 ret = fsck_chk_data_blk(sbi,
976 IS_CASEFOLDED(&node_blk->i),
977 blkaddr,
978 &child, (i_blocks == *blk_cnt),
979 ftype, nid, idx, ni->version,
980 file_is_encrypt(&node_blk->i));
981 if (!ret) {
982 *blk_cnt = *blk_cnt + 1;
983 if (cur_qtype != -1 && blkaddr != NEW_ADDR)
984 qf_last_blkofs[cur_qtype] = child.pgofs;
985 } else if (c.fix_on) {
986 node_blk->i.i_addr[ofs + idx] = 0;
987 need_fix = 1;
988 FIX_MSG("[0x%x] i_addr[%d] = 0", nid, ofs + idx);
989 }
990 }
991
992 /* readahead node blocks */
993 for (idx = 0; idx < 5; idx++) {
994 u32 nid = le32_to_cpu(node_blk->i.i_nid[idx]);
995 fsck_reada_node_block(sbi, nid);
996 }
997
998 /* check node blocks in inode */
999 for (idx = 0; idx < 5; idx++) {
1000 nid_t i_nid = le32_to_cpu(node_blk->i.i_nid[idx]);
1001
1002 if (idx == 0 || idx == 1)
1003 ntype = TYPE_DIRECT_NODE;
1004 else if (idx == 2 || idx == 3)
1005 ntype = TYPE_INDIRECT_NODE;
1006 else if (idx == 4)
1007 ntype = TYPE_DOUBLE_INDIRECT_NODE;
1008 else
1009 ASSERT(0);
1010
1011 if (i_nid == 0x0)
1012 goto skip;
1013
1014 ret = fsck_chk_node_blk(sbi, &node_blk->i, i_nid,
1015 ftype, ntype, blk_cnt, cbc, &child);
1016 if (!ret) {
1017 *blk_cnt = *blk_cnt + 1;
1018 } else if (ret == -EINVAL) {
1019 if (c.fix_on) {
1020 node_blk->i.i_nid[idx] = 0;
1021 need_fix = 1;
1022 FIX_MSG("[0x%x] i_nid[%d] = 0", nid, idx);
1023 }
1024 skip:
1025 if (ntype == TYPE_DIRECT_NODE)
1026 child.pgofs += ADDRS_PER_BLOCK(&node_blk->i);
1027 else if (ntype == TYPE_INDIRECT_NODE)
1028 child.pgofs += ADDRS_PER_BLOCK(&node_blk->i) *
1029 NIDS_PER_BLOCK;
1030 else
1031 child.pgofs += ADDRS_PER_BLOCK(&node_blk->i) *
1032 NIDS_PER_BLOCK * NIDS_PER_BLOCK;
1033 }
1034
1035 }
1036
1037 check:
1038 /* check uncovered range in the back of extent */
1039 check_extent_info(&child, 0, 1);
1040
1041 if (child.state & FSCK_UNMATCHED_EXTENT) {
1042 ASSERT_MSG("ino: 0x%x has wrong ext: [pgofs:%u, blk:%u, len:%u]",
1043 nid, child.ei.fofs, child.ei.blk, child.ei.len);
1044 if (c.fix_on)
1045 need_fix = 1;
1046 }
1047
1048 if (i_blocks != *blk_cnt) {
1049 ASSERT_MSG("ino: 0x%x has i_blocks: %08"PRIx64", "
1050 "but has %u blocks",
1051 nid, i_blocks, *blk_cnt);
1052 if (c.fix_on) {
1053 node_blk->i.i_blocks = cpu_to_le64(*blk_cnt);
1054 need_fix = 1;
1055 FIX_MSG("[0x%x] i_blocks=0x%08"PRIx64" -> 0x%x",
1056 nid, i_blocks, *blk_cnt);
1057 }
1058 }
1059
1060 if (compressed && i_compr_blocks != cbc->cnt) {
1061 if (c.fix_on) {
1062 node_blk->i.i_compr_blocks = cpu_to_le64(cbc->cnt);
1063 need_fix = 1;
1064 FIX_MSG("[0x%x] i_compr_blocks=0x%08"PRIx64" -> 0x%x",
1065 nid, i_compr_blocks, cbc->cnt);
1066 }
1067 }
1068
1069 skip_blkcnt_fix:
1070 en = malloc(F2FS_PRINT_NAMELEN);
1071 ASSERT(en);
1072
1073 namelen = le32_to_cpu(node_blk->i.i_namelen);
1074 if (namelen > F2FS_NAME_LEN) {
1075 if (child_d && child_d->i_namelen <= F2FS_NAME_LEN) {
1076 ASSERT_MSG("ino: 0x%x has i_namelen: 0x%x, "
1077 "but has %d characters for name",
1078 nid, namelen, child_d->i_namelen);
1079 if (c.fix_on) {
1080 FIX_MSG("[0x%x] i_namelen=0x%x -> 0x%x", nid, namelen,
1081 child_d->i_namelen);
1082 node_blk->i.i_namelen = cpu_to_le32(child_d->i_namelen);
1083 need_fix = 1;
1084 }
1085 namelen = child_d->i_namelen;
1086 } else
1087 namelen = F2FS_NAME_LEN;
1088 }
1089 pretty_print_filename(node_blk->i.i_name, namelen, en,
1090 file_enc_name(&node_blk->i));
1091 if (ftype == F2FS_FT_ORPHAN)
1092 DBG(1, "Orphan Inode: 0x%x [%s] i_blocks: %u\n\n",
1093 le32_to_cpu(node_blk->footer.ino),
1094 en, (u32)i_blocks);
1095
1096 if (is_qf_ino(F2FS_RAW_SUPER(sbi), nid))
1097 DBG(1, "Quota Inode: 0x%x [%s] i_blocks: %u\n\n",
1098 le32_to_cpu(node_blk->footer.ino),
1099 en, (u32)i_blocks);
1100
1101 if (ftype == F2FS_FT_DIR) {
1102 DBG(1, "Directory Inode: 0x%x [%s] depth: %d has %d files\n\n",
1103 le32_to_cpu(node_blk->footer.ino), en,
1104 le32_to_cpu(node_blk->i.i_current_depth),
1105 child.files);
1106
1107 if (i_links != child.links) {
1108 ASSERT_MSG("ino: 0x%x i_links: %u, real links: %u",
1109 nid, i_links, child.links);
1110 if (c.fix_on) {
1111 node_blk->i.i_links = cpu_to_le32(child.links);
1112 need_fix = 1;
1113 FIX_MSG("Dir: 0x%x i_links= 0x%x -> 0x%x",
1114 nid, i_links, child.links);
1115 }
1116 }
1117 if (child.dots < 2 &&
1118 !(node_blk->i.i_inline & F2FS_INLINE_DOTS)) {
1119 ASSERT_MSG("ino: 0x%x dots: %u",
1120 nid, child.dots);
1121 if (c.fix_on) {
1122 node_blk->i.i_inline |= F2FS_INLINE_DOTS;
1123 need_fix = 1;
1124 FIX_MSG("Dir: 0x%x set inline_dots", nid);
1125 }
1126 }
1127 }
1128
1129 i_gc_failures = le16_to_cpu(node_blk->i.i_gc_failures);
1130
1131 /*
1132 * old kernel initialized i_gc_failures as 0x01, in preen mode 2,
1133 * let's skip repairing.
1134 */
1135 if (ftype == F2FS_FT_REG_FILE && i_gc_failures &&
1136 (c.preen_mode != PREEN_MODE_2 || i_gc_failures != 0x01)) {
1137
1138 DBG(1, "Regular Inode: 0x%x [%s] depth: %d\n\n",
1139 le32_to_cpu(node_blk->footer.ino), en,
1140 i_gc_failures);
1141
1142 if (c.fix_on) {
1143 node_blk->i.i_gc_failures = cpu_to_le16(0);
1144 need_fix = 1;
1145 FIX_MSG("Regular: 0x%x reset i_gc_failures from 0x%x to 0x00",
1146 nid, i_gc_failures);
1147 }
1148 }
1149
1150 free(en);
1151
1152 if (ftype == F2FS_FT_SYMLINK && i_size == 0 &&
1153 i_blocks == (i_xattr_nid ? 3 : 2)) {
1154 node_blk->i.i_size = cpu_to_le64(F2FS_BLKSIZE);
1155 need_fix = 1;
1156 FIX_MSG("Symlink: recover 0x%x with i_size=%lu",
1157 nid, (unsigned long)F2FS_BLKSIZE);
1158 }
1159
1160 if (ftype == F2FS_FT_ORPHAN && i_links) {
1161 ASSERT_MSG("ino: 0x%x is orphan inode, but has i_links: %u",
1162 nid, i_links);
1163 if (c.fix_on) {
1164 node_blk->i.i_links = 0;
1165 need_fix = 1;
1166 FIX_MSG("ino: 0x%x orphan_inode, i_links= 0x%x -> 0",
1167 nid, i_links);
1168 }
1169 }
1170
1171 /* drop extent information to avoid potential wrong access */
1172 if (need_fix && f2fs_dev_is_writable())
1173 node_blk->i.i_ext.len = 0;
1174
1175 if ((c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM)) &&
1176 f2fs_has_extra_isize(&node_blk->i)) {
1177 __u32 provided, calculated;
1178
1179 provided = le32_to_cpu(node_blk->i.i_inode_checksum);
1180 calculated = f2fs_inode_chksum(node_blk);
1181
1182 if (provided != calculated) {
1183 ASSERT_MSG("ino: 0x%x chksum:0x%x, but calculated one is: 0x%x",
1184 nid, provided, calculated);
1185 if (c.fix_on) {
1186 node_blk->i.i_inode_checksum =
1187 cpu_to_le32(calculated);
1188 need_fix = 1;
1189 FIX_MSG("ino: 0x%x recover, i_inode_checksum= 0x%x -> 0x%x",
1190 nid, provided, calculated);
1191 }
1192 }
1193 }
1194
1195 if (need_fix && f2fs_dev_is_writable()) {
1196 ret = dev_write_block(node_blk, ni->blk_addr);
1197 ASSERT(ret >= 0);
1198 }
1199 }
1200
fsck_chk_dnode_blk(struct f2fs_sb_info * sbi,struct f2fs_inode * inode,u32 nid,enum FILE_TYPE ftype,struct f2fs_node * node_blk,u32 * blk_cnt,struct f2fs_compr_blk_cnt * cbc,struct child_info * child,struct node_info * ni)1201 int fsck_chk_dnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1202 u32 nid, enum FILE_TYPE ftype, struct f2fs_node *node_blk,
1203 u32 *blk_cnt, struct f2fs_compr_blk_cnt *cbc,
1204 struct child_info *child, struct node_info *ni)
1205 {
1206 int idx, ret;
1207 int need_fix = 0;
1208 child->p_ino = nid;
1209 child->pp_ino = le32_to_cpu(inode->i_pino);
1210 u32 i_flags = le32_to_cpu(inode->i_flags);
1211 bool compressed = i_flags & F2FS_COMPR_FL;
1212 bool compr_rel = inode->i_inline & F2FS_COMPRESS_RELEASED;
1213 u32 cluster_size = 1 << inode->i_log_cluster_size;
1214
1215 for (idx = 0; idx < ADDRS_PER_BLOCK(inode); idx++, child->pgofs++) {
1216 block_t blkaddr = le32_to_cpu(node_blk->dn.addr[idx]);
1217
1218 check_extent_info(child, blkaddr, 0);
1219
1220 if (blkaddr == NULL_ADDR)
1221 continue;
1222 if (blkaddr == COMPRESS_ADDR) {
1223 if (!compressed || (child->pgofs &
1224 (cluster_size - 1)) != 0) {
1225 if (c.fix_on) {
1226 node_blk->dn.addr[idx] = NULL_ADDR;
1227 need_fix = 1;
1228 FIX_MSG("[0x%x] dn.addr[%d] = 0", nid,
1229 idx);
1230 }
1231 continue;
1232 }
1233 if (!compr_rel) {
1234 F2FS_FSCK(sbi)->chk.valid_blk_cnt++;
1235 *blk_cnt = *blk_cnt + 1;
1236 cbc->cheader_pgofs = child->pgofs;
1237 cbc->cnt++;
1238 }
1239 continue;
1240 }
1241 if (!compr_rel && blkaddr == NEW_ADDR && child->pgofs -
1242 cbc->cheader_pgofs < cluster_size)
1243 cbc->cnt++;
1244 ret = fsck_chk_data_blk(sbi, IS_CASEFOLDED(inode),
1245 blkaddr, child,
1246 le64_to_cpu(inode->i_blocks) == *blk_cnt, ftype,
1247 nid, idx, ni->version,
1248 file_is_encrypt(inode));
1249 if (!ret) {
1250 *blk_cnt = *blk_cnt + 1;
1251 if (cur_qtype != -1 && blkaddr != NEW_ADDR)
1252 qf_last_blkofs[cur_qtype] = child->pgofs;
1253 } else if (c.fix_on) {
1254 node_blk->dn.addr[idx] = NULL_ADDR;
1255 need_fix = 1;
1256 FIX_MSG("[0x%x] dn.addr[%d] = 0", nid, idx);
1257 }
1258 }
1259 if (need_fix && f2fs_dev_is_writable()) {
1260 ret = dev_write_block(node_blk, ni->blk_addr);
1261 ASSERT(ret >= 0);
1262 }
1263 return 0;
1264 }
1265
fsck_chk_idnode_blk(struct f2fs_sb_info * sbi,struct f2fs_inode * inode,enum FILE_TYPE ftype,struct f2fs_node * node_blk,u32 * blk_cnt,struct f2fs_compr_blk_cnt * cbc,struct child_info * child)1266 int fsck_chk_idnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1267 enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt,
1268 struct f2fs_compr_blk_cnt *cbc, struct child_info *child)
1269 {
1270 int need_fix = 0, ret;
1271 int i = 0;
1272
1273 fsck_reada_all_direct_node_blocks(sbi, node_blk);
1274
1275 for (i = 0; i < NIDS_PER_BLOCK; i++) {
1276 if (le32_to_cpu(node_blk->in.nid[i]) == 0x0)
1277 goto skip;
1278 ret = fsck_chk_node_blk(sbi, inode,
1279 le32_to_cpu(node_blk->in.nid[i]),
1280 ftype, TYPE_DIRECT_NODE, blk_cnt,
1281 cbc, child);
1282 if (!ret)
1283 *blk_cnt = *blk_cnt + 1;
1284 else if (ret == -EINVAL) {
1285 if (!c.fix_on)
1286 printf("should delete in.nid[i] = 0;\n");
1287 else {
1288 node_blk->in.nid[i] = 0;
1289 need_fix = 1;
1290 FIX_MSG("Set indirect node 0x%x -> 0", i);
1291 }
1292 skip:
1293 child->pgofs += ADDRS_PER_BLOCK(&node_blk->i);
1294 }
1295 }
1296
1297 if (need_fix && f2fs_dev_is_writable()) {
1298 struct node_info ni;
1299 nid_t nid = le32_to_cpu(node_blk->footer.nid);
1300
1301 get_node_info(sbi, nid, &ni);
1302 ret = dev_write_block(node_blk, ni.blk_addr);
1303 ASSERT(ret >= 0);
1304 }
1305
1306 return 0;
1307 }
1308
fsck_chk_didnode_blk(struct f2fs_sb_info * sbi,struct f2fs_inode * inode,enum FILE_TYPE ftype,struct f2fs_node * node_blk,u32 * blk_cnt,struct f2fs_compr_blk_cnt * cbc,struct child_info * child)1309 int fsck_chk_didnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
1310 enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt,
1311 struct f2fs_compr_blk_cnt *cbc, struct child_info *child)
1312 {
1313 int i = 0;
1314 int need_fix = 0, ret = 0;
1315
1316 fsck_reada_all_direct_node_blocks(sbi, node_blk);
1317
1318 for (i = 0; i < NIDS_PER_BLOCK; i++) {
1319 if (le32_to_cpu(node_blk->in.nid[i]) == 0x0)
1320 goto skip;
1321 ret = fsck_chk_node_blk(sbi, inode,
1322 le32_to_cpu(node_blk->in.nid[i]),
1323 ftype, TYPE_INDIRECT_NODE, blk_cnt, cbc, child);
1324 if (!ret)
1325 *blk_cnt = *blk_cnt + 1;
1326 else if (ret == -EINVAL) {
1327 if (!c.fix_on)
1328 printf("should delete in.nid[i] = 0;\n");
1329 else {
1330 node_blk->in.nid[i] = 0;
1331 need_fix = 1;
1332 FIX_MSG("Set double indirect node 0x%x -> 0", i);
1333 }
1334 skip:
1335 child->pgofs += ADDRS_PER_BLOCK(&node_blk->i) *
1336 NIDS_PER_BLOCK;
1337 }
1338 }
1339
1340 if (need_fix && f2fs_dev_is_writable()) {
1341 struct node_info ni;
1342 nid_t nid = le32_to_cpu(node_blk->footer.nid);
1343
1344 get_node_info(sbi, nid, &ni);
1345 ret = dev_write_block(node_blk, ni.blk_addr);
1346 ASSERT(ret >= 0);
1347 }
1348
1349 return 0;
1350 }
1351
1352 static const char *lookup_table =
1353 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
1354
1355 /**
1356 * base64_encode() -
1357 *
1358 * Encodes the input string using characters from the set [A-Za-z0-9+,].
1359 * The encoded string is roughly 4/3 times the size of the input string.
1360 */
base64_encode(const u8 * src,int len,char * dst)1361 static int base64_encode(const u8 *src, int len, char *dst)
1362 {
1363 int i, bits = 0, ac = 0;
1364 char *cp = dst;
1365
1366 for (i = 0; i < len; i++) {
1367 ac += src[i] << bits;
1368 bits += 8;
1369 do {
1370 *cp++ = lookup_table[ac & 0x3f];
1371 ac >>= 6;
1372 bits -= 6;
1373 } while (bits >= 6);
1374 }
1375 if (bits)
1376 *cp++ = lookup_table[ac & 0x3f];
1377 return cp - dst;
1378 }
1379
pretty_print_filename(const u8 * raw_name,u32 len,char out[F2FS_PRINT_NAMELEN],int enc_name)1380 void pretty_print_filename(const u8 *raw_name, u32 len,
1381 char out[F2FS_PRINT_NAMELEN], int enc_name)
1382 {
1383 len = min(len, (u32)F2FS_NAME_LEN);
1384
1385 if (enc_name)
1386 len = base64_encode(raw_name, len, out);
1387 else
1388 memcpy(out, raw_name, len);
1389 out[len] = 0;
1390 }
1391
print_dentry(struct f2fs_sb_info * sbi,__u8 * name,u8 * bitmap,struct f2fs_dir_entry * dentry,int max,int idx,int last_blk,int enc_name)1392 static void print_dentry(struct f2fs_sb_info *sbi, __u8 *name,
1393 u8 *bitmap, struct f2fs_dir_entry *dentry,
1394 int max, int idx, int last_blk, int enc_name)
1395 {
1396 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1397 u32 depth = fsck->dentry_depth;
1398 int last_de = 0;
1399 int next_idx = 0;
1400 u32 name_len;
1401 unsigned int i;
1402 int bit_offset;
1403 char new[F2FS_PRINT_NAMELEN];
1404
1405 if (!c.show_dentry && !c.show_file_map)
1406 return;
1407
1408 name_len = le16_to_cpu(dentry[idx].name_len);
1409 next_idx = idx + (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
1410
1411 bit_offset = find_next_bit_le(bitmap, max, next_idx);
1412 if (bit_offset >= max && last_blk)
1413 last_de = 1;
1414
1415 if (tree_mark_size <= depth) {
1416 tree_mark_size *= 2;
1417 ASSERT(tree_mark_size != 0);
1418 tree_mark = realloc(tree_mark, tree_mark_size);
1419 ASSERT(tree_mark != NULL);
1420 }
1421
1422 if (last_de)
1423 tree_mark[depth] = '`';
1424 else
1425 tree_mark[depth] = '|';
1426
1427 if (tree_mark[depth - 1] == '`')
1428 tree_mark[depth - 1] = ' ';
1429
1430 pretty_print_filename(name, name_len, new, enc_name);
1431
1432 if (c.show_file_map) {
1433 struct f2fs_dentry *d = fsck->dentry;
1434
1435 if (dentry[idx].file_type != F2FS_FT_REG_FILE)
1436 return;
1437
1438 while (d) {
1439 if (d->depth > 1)
1440 printf("/%s", d->name);
1441 d = d->next;
1442 }
1443 printf("/%s", new);
1444 if (dump_node(sbi, le32_to_cpu(dentry[idx].ino), 0))
1445 printf("\33[2K\r");
1446 } else {
1447 for (i = 1; i < depth; i++)
1448 printf("%c ", tree_mark[i]);
1449
1450 printf("%c-- %s <ino = 0x%x>, <encrypted (%d)>\n",
1451 last_de ? '`' : '|',
1452 new, le32_to_cpu(dentry[idx].ino),
1453 enc_name);
1454 }
1455 }
1456
f2fs_check_hash_code(int encoding,int casefolded,struct f2fs_dir_entry * dentry,const unsigned char * name,u32 len,int enc_name)1457 static int f2fs_check_hash_code(int encoding, int casefolded,
1458 struct f2fs_dir_entry *dentry,
1459 const unsigned char *name, u32 len, int enc_name)
1460 {
1461 /* Casefolded Encrypted names require a key to compute siphash */
1462 if (enc_name && casefolded)
1463 return 0;
1464
1465 f2fs_hash_t hash_code = f2fs_dentry_hash(encoding, casefolded, name, len);
1466 /* fix hash_code made by old buggy code */
1467 if (dentry->hash_code != hash_code) {
1468 char new[F2FS_PRINT_NAMELEN];
1469
1470 pretty_print_filename(name, len, new, enc_name);
1471 FIX_MSG("Mismatch hash_code for \"%s\" [%x:%x]",
1472 new, le32_to_cpu(dentry->hash_code),
1473 hash_code);
1474 dentry->hash_code = cpu_to_le32(hash_code);
1475 return 1;
1476 }
1477 return 0;
1478 }
1479
1480
__get_current_level(int dir_level,u32 pgofs)1481 static int __get_current_level(int dir_level, u32 pgofs)
1482 {
1483 unsigned int bidx = 0;
1484 int i;
1485
1486 for (i = 0; i < MAX_DIR_HASH_DEPTH; i++) {
1487 bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
1488 if (bidx > pgofs)
1489 break;
1490 }
1491 return i;
1492 }
1493
f2fs_check_dirent_position(const struct f2fs_dir_entry * dentry,const char * printable_name,u32 pgofs,u8 dir_level,u32 pino)1494 static int f2fs_check_dirent_position(const struct f2fs_dir_entry *dentry,
1495 const char *printable_name,
1496 u32 pgofs, u8 dir_level, u32 pino)
1497 {
1498 unsigned int nbucket, nblock;
1499 unsigned int bidx, end_block;
1500 int level;
1501
1502 level = __get_current_level(dir_level, pgofs);
1503
1504 nbucket = dir_buckets(level, dir_level);
1505 nblock = bucket_blocks(level);
1506
1507 bidx = dir_block_index(level, dir_level,
1508 le32_to_cpu(dentry->hash_code) % nbucket);
1509 end_block = bidx + nblock;
1510
1511 if (pgofs >= bidx && pgofs < end_block)
1512 return 0;
1513
1514 ASSERT_MSG("Wrong position of dirent pino:%u, name:%s, level:%d, "
1515 "dir_level:%d, pgofs:%u, correct range:[%u, %u]\n",
1516 pino, printable_name, level, dir_level, pgofs, bidx,
1517 end_block - 1);
1518 return 1;
1519 }
1520
__chk_dots_dentries(struct f2fs_sb_info * sbi,int casefolded,struct f2fs_dir_entry * dentry,struct child_info * child,u8 * name,int len,__u8 (* filename)[F2FS_SLOT_LEN],int enc_name)1521 static int __chk_dots_dentries(struct f2fs_sb_info *sbi,
1522 int casefolded,
1523 struct f2fs_dir_entry *dentry,
1524 struct child_info *child,
1525 u8 *name, int len,
1526 __u8 (*filename)[F2FS_SLOT_LEN],
1527 int enc_name)
1528 {
1529 int fixed = 0;
1530
1531 if ((name[0] == '.' && len == 1)) {
1532 if (le32_to_cpu(dentry->ino) != child->p_ino) {
1533 ASSERT_MSG("Bad inode number[0x%x] for '.', parent_ino is [0x%x]\n",
1534 le32_to_cpu(dentry->ino), child->p_ino);
1535 dentry->ino = cpu_to_le32(child->p_ino);
1536 fixed = 1;
1537 }
1538 }
1539
1540 if (name[0] == '.' && name[1] == '.' && len == 2) {
1541 if (child->p_ino == F2FS_ROOT_INO(sbi)) {
1542 if (le32_to_cpu(dentry->ino) != F2FS_ROOT_INO(sbi)) {
1543 ASSERT_MSG("Bad inode number[0x%x] for '..'\n",
1544 le32_to_cpu(dentry->ino));
1545 dentry->ino = cpu_to_le32(F2FS_ROOT_INO(sbi));
1546 fixed = 1;
1547 }
1548 } else if (le32_to_cpu(dentry->ino) != child->pp_ino) {
1549 ASSERT_MSG("Bad inode number[0x%x] for '..', parent parent ino is [0x%x]\n",
1550 le32_to_cpu(dentry->ino), child->pp_ino);
1551 dentry->ino = cpu_to_le32(child->pp_ino);
1552 fixed = 1;
1553 }
1554 }
1555
1556 if (f2fs_check_hash_code(get_encoding(sbi), casefolded, dentry, name, len, enc_name))
1557 fixed = 1;
1558
1559 if (name[len] != '\0') {
1560 ASSERT_MSG("'.' is not NULL terminated\n");
1561 name[len] = '\0';
1562 memcpy(*filename, name, len);
1563 fixed = 1;
1564 }
1565 return fixed;
1566 }
1567
nullify_dentry(struct f2fs_dir_entry * dentry,int offs,__u8 (* filename)[F2FS_SLOT_LEN],u8 ** bitmap)1568 static void nullify_dentry(struct f2fs_dir_entry *dentry, int offs,
1569 __u8 (*filename)[F2FS_SLOT_LEN], u8 **bitmap)
1570 {
1571 memset(dentry, 0, sizeof(struct f2fs_dir_entry));
1572 test_and_clear_bit_le(offs, *bitmap);
1573 memset(*filename, 0, F2FS_SLOT_LEN);
1574 }
1575
__chk_dentries(struct f2fs_sb_info * sbi,int casefolded,struct child_info * child,u8 * bitmap,struct f2fs_dir_entry * dentry,__u8 (* filenames)[F2FS_SLOT_LEN],int max,int last_blk,int enc_name)1576 static int __chk_dentries(struct f2fs_sb_info *sbi, int casefolded,
1577 struct child_info *child,
1578 u8 *bitmap, struct f2fs_dir_entry *dentry,
1579 __u8 (*filenames)[F2FS_SLOT_LEN],
1580 int max, int last_blk, int enc_name)
1581 {
1582 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1583 enum FILE_TYPE ftype;
1584 int dentries = 0;
1585 u32 blk_cnt;
1586 struct f2fs_compr_blk_cnt cbc;
1587 u8 *name;
1588 char en[F2FS_PRINT_NAMELEN];
1589 u16 name_len;
1590 int ret = 0;
1591 int fixed = 0;
1592 int i, slots;
1593
1594 /* readahead inode blocks */
1595 for (i = 0; i < max; i++) {
1596 u32 ino;
1597
1598 if (test_bit_le(i, bitmap) == 0)
1599 continue;
1600
1601 ino = le32_to_cpu(dentry[i].ino);
1602
1603 if (IS_VALID_NID(sbi, ino)) {
1604 struct node_info ni;
1605
1606 get_node_info(sbi, ino, &ni);
1607 if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr)) {
1608 dev_reada_block(ni.blk_addr);
1609 name_len = le16_to_cpu(dentry[i].name_len);
1610 if (name_len > 0)
1611 i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN - 1;
1612 }
1613 }
1614 }
1615
1616 for (i = 0; i < max;) {
1617 if (test_bit_le(i, bitmap) == 0) {
1618 i++;
1619 continue;
1620 }
1621 if (!IS_VALID_NID(sbi, le32_to_cpu(dentry[i].ino))) {
1622 ASSERT_MSG("Bad dentry 0x%x with invalid NID/ino 0x%x",
1623 i, le32_to_cpu(dentry[i].ino));
1624 if (c.fix_on) {
1625 FIX_MSG("Clear bad dentry 0x%x with bad ino 0x%x",
1626 i, le32_to_cpu(dentry[i].ino));
1627 test_and_clear_bit_le(i, bitmap);
1628 fixed = 1;
1629 }
1630 i++;
1631 continue;
1632 }
1633
1634 ftype = dentry[i].file_type;
1635 if ((ftype <= F2FS_FT_UNKNOWN || ftype > F2FS_FT_LAST_FILE_TYPE)) {
1636 ASSERT_MSG("Bad dentry 0x%x with unexpected ftype 0x%x",
1637 le32_to_cpu(dentry[i].ino), ftype);
1638 if (c.fix_on) {
1639 FIX_MSG("Clear bad dentry 0x%x with bad ftype 0x%x",
1640 i, ftype);
1641 test_and_clear_bit_le(i, bitmap);
1642 fixed = 1;
1643 }
1644 i++;
1645 continue;
1646 }
1647
1648 name_len = le16_to_cpu(dentry[i].name_len);
1649
1650 if (name_len == 0 || name_len > F2FS_NAME_LEN) {
1651 ASSERT_MSG("Bad dentry 0x%x with invalid name_len", i);
1652 if (c.fix_on) {
1653 FIX_MSG("Clear bad dentry 0x%x", i);
1654 test_and_clear_bit_le(i, bitmap);
1655 fixed = 1;
1656 }
1657 i++;
1658 continue;
1659 }
1660 name = calloc(name_len + 1, 1);
1661 ASSERT(name);
1662
1663 memcpy(name, filenames[i], name_len);
1664 slots = (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
1665
1666 /* Becareful. 'dentry.file_type' is not imode. */
1667 if (ftype == F2FS_FT_DIR) {
1668 if ((name[0] == '.' && name_len == 1) ||
1669 (name[0] == '.' && name[1] == '.' &&
1670 name_len == 2)) {
1671 ret = __chk_dots_dentries(sbi, casefolded, &dentry[i],
1672 child, name, name_len, &filenames[i],
1673 enc_name);
1674 switch (ret) {
1675 case 1:
1676 fixed = 1;
1677 fallthrough;
1678 case 0:
1679 child->dots++;
1680 break;
1681 }
1682
1683 if (child->dots > 2) {
1684 ASSERT_MSG("More than one '.' or '..', should delete the extra one\n");
1685 nullify_dentry(&dentry[i], i,
1686 &filenames[i], &bitmap);
1687 child->dots--;
1688 fixed = 1;
1689 }
1690
1691 i++;
1692 free(name);
1693 continue;
1694 }
1695 }
1696
1697 if (f2fs_check_hash_code(get_encoding(sbi), casefolded, dentry + i, name, name_len, enc_name))
1698 fixed = 1;
1699
1700 pretty_print_filename(name, name_len, en, enc_name);
1701
1702 if (max == NR_DENTRY_IN_BLOCK) {
1703 ret = f2fs_check_dirent_position(dentry + i, en,
1704 child->pgofs, child->dir_level,
1705 child->p_ino);
1706 if (ret) {
1707 if (c.fix_on) {
1708 FIX_MSG("Clear bad dentry 0x%x", i);
1709 test_and_clear_bit_le(i, bitmap);
1710 fixed = 1;
1711 }
1712 i++;
1713 free(name);
1714 continue;
1715 }
1716 }
1717
1718 DBG(1, "[%3u]-[0x%x] name[%s] len[0x%x] ino[0x%x] type[0x%x]\n",
1719 fsck->dentry_depth, i, en, name_len,
1720 le32_to_cpu(dentry[i].ino),
1721 dentry[i].file_type);
1722
1723 print_dentry(sbi, name, bitmap,
1724 dentry, max, i, last_blk, enc_name);
1725
1726 blk_cnt = 1;
1727 cbc.cnt = 0;
1728 cbc.cheader_pgofs = CHEADER_PGOFS_NONE;
1729 child->i_namelen = name_len;
1730 ret = fsck_chk_node_blk(sbi,
1731 NULL, le32_to_cpu(dentry[i].ino),
1732 ftype, TYPE_INODE, &blk_cnt, &cbc, child);
1733
1734 if (ret && c.fix_on) {
1735 int j;
1736
1737 for (j = 0; j < slots; j++)
1738 test_and_clear_bit_le(i + j, bitmap);
1739 FIX_MSG("Unlink [0x%x] - %s len[0x%x], type[0x%x]",
1740 le32_to_cpu(dentry[i].ino),
1741 en, name_len,
1742 dentry[i].file_type);
1743 fixed = 1;
1744 } else if (ret == 0) {
1745 if (ftype == F2FS_FT_DIR)
1746 child->links++;
1747 dentries++;
1748 child->files++;
1749 }
1750
1751 i += slots;
1752 free(name);
1753 }
1754 return fixed ? -1 : dentries;
1755 }
1756
fsck_chk_inline_dentries(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk,struct child_info * child)1757 int fsck_chk_inline_dentries(struct f2fs_sb_info *sbi,
1758 struct f2fs_node *node_blk, struct child_info *child)
1759 {
1760 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1761 struct f2fs_dentry *cur_dentry = fsck->dentry_end;
1762 struct f2fs_dentry *new_dentry;
1763 struct f2fs_dentry_ptr d;
1764 void *inline_dentry;
1765 int dentries;
1766
1767 inline_dentry = inline_data_addr(node_blk);
1768 ASSERT(inline_dentry != NULL);
1769
1770 make_dentry_ptr(&d, node_blk, inline_dentry, 2);
1771
1772 fsck->dentry_depth++;
1773 new_dentry = calloc(sizeof(struct f2fs_dentry), 1);
1774 ASSERT(new_dentry != NULL);
1775
1776 new_dentry->depth = fsck->dentry_depth;
1777 memcpy(new_dentry->name, child->p_name, F2FS_NAME_LEN);
1778 cur_dentry->next = new_dentry;
1779 fsck->dentry_end = new_dentry;
1780
1781 dentries = __chk_dentries(sbi, IS_CASEFOLDED(&node_blk->i), child,
1782 d.bitmap, d.dentry, d.filename, d.max, 1,
1783 file_is_encrypt(&node_blk->i));// pass through
1784 if (dentries < 0) {
1785 DBG(1, "[%3d] Inline Dentry Block Fixed hash_codes\n\n",
1786 fsck->dentry_depth);
1787 } else {
1788 DBG(1, "[%3d] Inline Dentry Block Done : "
1789 "dentries:%d in %d slots (len:%d)\n\n",
1790 fsck->dentry_depth, dentries,
1791 d.max, F2FS_NAME_LEN);
1792 }
1793 fsck->dentry = cur_dentry;
1794 fsck->dentry_end = cur_dentry;
1795 cur_dentry->next = NULL;
1796 free(new_dentry);
1797 fsck->dentry_depth--;
1798 return dentries;
1799 }
1800
fsck_chk_dentry_blk(struct f2fs_sb_info * sbi,int casefolded,u32 blk_addr,struct child_info * child,int last_blk,int enc_name)1801 int fsck_chk_dentry_blk(struct f2fs_sb_info *sbi, int casefolded, u32 blk_addr,
1802 struct child_info *child, int last_blk, int enc_name)
1803 {
1804 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1805 struct f2fs_dentry_block *de_blk;
1806 struct f2fs_dentry *cur_dentry = fsck->dentry_end;
1807 struct f2fs_dentry *new_dentry;
1808 int dentries, ret;
1809
1810 de_blk = (struct f2fs_dentry_block *)calloc(BLOCK_SZ, 1);
1811 ASSERT(de_blk != NULL);
1812
1813 ret = dev_read_block(de_blk, blk_addr);
1814 ASSERT(ret >= 0);
1815
1816 fsck->dentry_depth++;
1817 new_dentry = calloc(sizeof(struct f2fs_dentry), 1);
1818 ASSERT(new_dentry != NULL);
1819 new_dentry->depth = fsck->dentry_depth;
1820 memcpy(new_dentry->name, child->p_name, F2FS_NAME_LEN);
1821 cur_dentry->next = new_dentry;
1822 fsck->dentry_end = new_dentry;
1823
1824 dentries = __chk_dentries(sbi, casefolded, child,
1825 de_blk->dentry_bitmap,
1826 de_blk->dentry, de_blk->filename,
1827 NR_DENTRY_IN_BLOCK, last_blk, enc_name);
1828
1829 if (dentries < 0 && f2fs_dev_is_writable()) {
1830 ret = dev_write_block(de_blk, blk_addr);
1831 ASSERT(ret >= 0);
1832 DBG(1, "[%3d] Dentry Block [0x%x] Fixed hash_codes\n\n",
1833 fsck->dentry_depth, blk_addr);
1834 } else {
1835 DBG(1, "[%3d] Dentry Block [0x%x] Done : "
1836 "dentries:%d in %d slots (len:%d)\n\n",
1837 fsck->dentry_depth, blk_addr, dentries,
1838 NR_DENTRY_IN_BLOCK, F2FS_NAME_LEN);
1839 }
1840 fsck->dentry = cur_dentry;
1841 fsck->dentry_end = cur_dentry;
1842 cur_dentry->next = NULL;
1843 free(new_dentry);
1844 fsck->dentry_depth--;
1845 free(de_blk);
1846 return 0;
1847 }
1848
fsck_chk_data_blk(struct f2fs_sb_info * sbi,int casefolded,u32 blk_addr,struct child_info * child,int last_blk,enum FILE_TYPE ftype,u32 parent_nid,u16 idx_in_node,u8 ver,int enc_name)1849 int fsck_chk_data_blk(struct f2fs_sb_info *sbi, int casefolded,
1850 u32 blk_addr, struct child_info *child, int last_blk,
1851 enum FILE_TYPE ftype, u32 parent_nid, u16 idx_in_node, u8 ver,
1852 int enc_name)
1853 {
1854 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
1855
1856 /* Is it reserved block? */
1857 if (blk_addr == NEW_ADDR) {
1858 fsck->chk.valid_blk_cnt++;
1859 return 0;
1860 }
1861
1862 if (!IS_VALID_BLK_ADDR(sbi, blk_addr)) {
1863 ASSERT_MSG("blkaddress is not valid. [0x%x]", blk_addr);
1864 return -EINVAL;
1865 }
1866
1867 if (is_valid_ssa_data_blk(sbi, blk_addr, parent_nid,
1868 idx_in_node, ver)) {
1869 ASSERT_MSG("summary data block is not valid. [0x%x]",
1870 parent_nid);
1871 return -EINVAL;
1872 }
1873
1874 if (f2fs_test_sit_bitmap(sbi, blk_addr) == 0)
1875 ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]", blk_addr);
1876
1877 if (f2fs_test_main_bitmap(sbi, blk_addr) != 0)
1878 ASSERT_MSG("Duplicated data [0x%x]. pnid[0x%x] idx[0x%x]",
1879 blk_addr, parent_nid, idx_in_node);
1880
1881 fsck->chk.valid_blk_cnt++;
1882
1883 if (ftype == F2FS_FT_DIR) {
1884 f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_HOT_DATA);
1885 return fsck_chk_dentry_blk(sbi, casefolded, blk_addr, child,
1886 last_blk, enc_name);
1887 } else {
1888 f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_WARM_DATA);
1889 }
1890 return 0;
1891 }
1892
fsck_chk_orphan_node(struct f2fs_sb_info * sbi)1893 int fsck_chk_orphan_node(struct f2fs_sb_info *sbi)
1894 {
1895 u32 blk_cnt = 0;
1896 struct f2fs_compr_blk_cnt cbc = {0, CHEADER_PGOFS_NONE};
1897 block_t start_blk, orphan_blkaddr, i, j;
1898 struct f2fs_orphan_block *orphan_blk, *new_blk;
1899 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1900 u32 entry_count;
1901
1902 if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
1903 return 0;
1904
1905 start_blk = __start_cp_addr(sbi) + 1 + get_sb(cp_payload);
1906 orphan_blkaddr = __start_sum_addr(sbi) - 1 - get_sb(cp_payload);
1907
1908 f2fs_ra_meta_pages(sbi, start_blk, orphan_blkaddr, META_CP);
1909
1910 orphan_blk = calloc(BLOCK_SZ, 1);
1911 ASSERT(orphan_blk);
1912
1913 new_blk = calloc(BLOCK_SZ, 1);
1914 ASSERT(new_blk);
1915
1916 for (i = 0; i < orphan_blkaddr; i++) {
1917 int ret = dev_read_block(orphan_blk, start_blk + i);
1918 u32 new_entry_count = 0;
1919
1920 ASSERT(ret >= 0);
1921 entry_count = le32_to_cpu(orphan_blk->entry_count);
1922
1923 for (j = 0; j < entry_count; j++) {
1924 nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
1925 DBG(1, "[%3d] ino [0x%x]\n", i, ino);
1926 struct node_info ni;
1927 blk_cnt = 1;
1928 cbc.cnt = 0;
1929 cbc.cheader_pgofs = CHEADER_PGOFS_NONE;
1930
1931 if (c.preen_mode == PREEN_MODE_1 && !c.fix_on) {
1932 get_node_info(sbi, ino, &ni);
1933 if (!IS_VALID_NID(sbi, ino) ||
1934 !IS_VALID_BLK_ADDR(sbi, ni.blk_addr)) {
1935 free(orphan_blk);
1936 free(new_blk);
1937 return -EINVAL;
1938 }
1939
1940 continue;
1941 }
1942
1943 ret = fsck_chk_node_blk(sbi, NULL, ino,
1944 F2FS_FT_ORPHAN, TYPE_INODE, &blk_cnt,
1945 &cbc, NULL);
1946 if (!ret)
1947 new_blk->ino[new_entry_count++] =
1948 orphan_blk->ino[j];
1949 else if (ret && c.fix_on)
1950 FIX_MSG("[0x%x] remove from orphan list", ino);
1951 else if (ret)
1952 ASSERT_MSG("[0x%x] wrong orphan inode", ino);
1953 }
1954 if (f2fs_dev_is_writable() && c.fix_on &&
1955 entry_count != new_entry_count) {
1956 new_blk->entry_count = cpu_to_le32(new_entry_count);
1957 ret = dev_write_block(new_blk, start_blk + i);
1958 ASSERT(ret >= 0);
1959 }
1960 memset(orphan_blk, 0, BLOCK_SZ);
1961 memset(new_blk, 0, BLOCK_SZ);
1962 }
1963 free(orphan_blk);
1964 free(new_blk);
1965
1966 return 0;
1967 }
1968
fsck_chk_quota_node(struct f2fs_sb_info * sbi)1969 int fsck_chk_quota_node(struct f2fs_sb_info *sbi)
1970 {
1971 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
1972 enum quota_type qtype;
1973 int ret = 0;
1974 u32 blk_cnt = 0;
1975 struct f2fs_compr_blk_cnt cbc = {0, CHEADER_PGOFS_NONE};
1976
1977 for (qtype = 0; qtype < F2FS_MAX_QUOTAS; qtype++) {
1978 cur_qtype = qtype;
1979 if (sb->qf_ino[qtype] == 0)
1980 continue;
1981 nid_t ino = QUOTA_INO(sb, qtype);
1982 struct node_info ni;
1983
1984 DBG(1, "qtype [%d] ino [0x%x]\n", qtype, ino);
1985 blk_cnt = 1;
1986 cbc.cnt = 0;
1987 cbc.cheader_pgofs = CHEADER_PGOFS_NONE;
1988
1989 if (c.preen_mode == PREEN_MODE_1 && !c.fix_on) {
1990 get_node_info(sbi, ino, &ni);
1991 if (!IS_VALID_NID(sbi, ino) ||
1992 !IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
1993 return -EINVAL;
1994 continue;
1995 }
1996 ret = fsck_chk_node_blk(sbi, NULL, ino,
1997 F2FS_FT_REG_FILE, TYPE_INODE, &blk_cnt,
1998 &cbc, NULL);
1999 if (ret) {
2000 ASSERT_MSG("wrong quota inode, qtype [%d] ino [0x%x]",
2001 qtype, ino);
2002 qf_szchk_type[qtype] = QF_SZCHK_ERR;
2003 if (c.fix_on)
2004 f2fs_rebuild_qf_inode(sbi, qtype);
2005 }
2006 }
2007 cur_qtype = -1;
2008 return ret;
2009 }
2010
fsck_chk_quota_files(struct f2fs_sb_info * sbi)2011 int fsck_chk_quota_files(struct f2fs_sb_info *sbi)
2012 {
2013 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2014 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2015 enum quota_type qtype;
2016 f2fs_ino_t ino;
2017 int ret = 0;
2018 int needs_writeout;
2019
2020 /* Return if quota feature is disabled */
2021 if (!fsck->qctx)
2022 return 0;
2023
2024 for (qtype = 0; qtype < F2FS_MAX_QUOTAS; qtype++) {
2025 ino = sb->qf_ino[qtype];
2026 if (!ino)
2027 continue;
2028
2029 DBG(1, "Checking Quota file ([%3d] ino [0x%x])\n", qtype, ino);
2030 needs_writeout = 0;
2031 ret = quota_compare_and_update(sbi, qtype, &needs_writeout,
2032 c.preserve_limits);
2033 if (ret == 0 && needs_writeout == 0) {
2034 DBG(1, "OK\n");
2035 continue;
2036 }
2037
2038 /* Something is wrong */
2039 if (c.fix_on) {
2040 DBG(0, "Fixing Quota file ([%3d] ino [0x%x])\n",
2041 qtype, ino);
2042 f2fs_filesize_update(sbi, ino, 0);
2043 ret = quota_write_inode(sbi, qtype);
2044 if (!ret) {
2045 c.quota_fixed = true;
2046 DBG(1, "OK\n");
2047 } else {
2048 ASSERT_MSG("Unable to write quota file");
2049 }
2050 } else {
2051 ASSERT_MSG("Quota file is missing or invalid"
2052 " quota file content found.");
2053 }
2054 }
2055 return ret;
2056 }
2057
fsck_chk_meta(struct f2fs_sb_info * sbi)2058 int fsck_chk_meta(struct f2fs_sb_info *sbi)
2059 {
2060 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2061 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2062 struct seg_entry *se;
2063 unsigned int sit_valid_segs = 0, sit_node_blks = 0;
2064 unsigned int i;
2065
2066 /* 1. check sit usage with CP: curseg is lost? */
2067 for (i = 0; i < MAIN_SEGS(sbi); i++) {
2068 se = get_seg_entry(sbi, i);
2069 if (se->valid_blocks != 0)
2070 sit_valid_segs++;
2071 else if (IS_CUR_SEGNO(sbi, i)) {
2072 /* curseg has not been written back to device */
2073 MSG(1, "\tInfo: curseg %u is counted in valid segs\n", i);
2074 sit_valid_segs++;
2075 }
2076 if (IS_NODESEG(se->type))
2077 sit_node_blks += se->valid_blocks;
2078 }
2079 if (fsck->chk.sit_free_segs + sit_valid_segs !=
2080 get_usable_seg_count(sbi)) {
2081 ASSERT_MSG("SIT usage does not match: sit_free_segs %u, "
2082 "sit_valid_segs %u, total_segs %u",
2083 fsck->chk.sit_free_segs, sit_valid_segs,
2084 get_usable_seg_count(sbi));
2085 return -EINVAL;
2086 }
2087
2088 /* 2. check node count */
2089 if (fsck->chk.valid_nat_entry_cnt != sit_node_blks) {
2090 ASSERT_MSG("node count does not match: valid_nat_entry_cnt %u,"
2091 " sit_node_blks %u",
2092 fsck->chk.valid_nat_entry_cnt, sit_node_blks);
2093 return -EINVAL;
2094 }
2095
2096 /* 3. check SIT with CP */
2097 if (fsck->chk.sit_free_segs != le32_to_cpu(cp->free_segment_count)) {
2098 ASSERT_MSG("free segs does not match: sit_free_segs %u, "
2099 "free_segment_count %u",
2100 fsck->chk.sit_free_segs,
2101 le32_to_cpu(cp->free_segment_count));
2102 return -EINVAL;
2103 }
2104
2105 /* 4. check NAT with CP */
2106 if (fsck->chk.valid_nat_entry_cnt !=
2107 le32_to_cpu(cp->valid_node_count)) {
2108 ASSERT_MSG("valid node does not match: valid_nat_entry_cnt %u,"
2109 " valid_node_count %u",
2110 fsck->chk.valid_nat_entry_cnt,
2111 le32_to_cpu(cp->valid_node_count));
2112 return -EINVAL;
2113 }
2114
2115 /* 4. check orphan inode simply */
2116 if (fsck_chk_orphan_node(sbi))
2117 return -EINVAL;
2118
2119 /* 5. check nat entry -- must be done before quota check */
2120 for (i = 0; i < fsck->nr_nat_entries; i++) {
2121 u32 blk = le32_to_cpu(fsck->entries[i].block_addr);
2122 nid_t ino = le32_to_cpu(fsck->entries[i].ino);
2123
2124 if (!blk)
2125 /*
2126 * skip entry whose ino is 0, otherwise, we will
2127 * get a negative number by BLKOFF_FROM_MAIN(sbi, blk)
2128 */
2129 continue;
2130
2131 if (!IS_VALID_BLK_ADDR(sbi, blk)) {
2132 MSG(0, "\tError: nat entry[ino %u block_addr 0x%x]"
2133 " is in valid\n",
2134 ino, blk);
2135 return -EINVAL;
2136 }
2137
2138 if (!f2fs_test_sit_bitmap(sbi, blk)) {
2139 MSG(0, "\tError: nat entry[ino %u block_addr 0x%x]"
2140 " not find it in sit_area_bitmap\n",
2141 ino, blk);
2142 return -EINVAL;
2143 }
2144
2145 if (!IS_VALID_NID(sbi, ino)) {
2146 MSG(0, "\tError: nat_entry->ino %u exceeds the range"
2147 " of nat entries %u\n",
2148 ino, fsck->nr_nat_entries);
2149 return -EINVAL;
2150 }
2151
2152 if (!f2fs_test_bit(ino, fsck->nat_area_bitmap)) {
2153 MSG(0, "\tError: nat_entry->ino %u is not set in"
2154 " nat_area_bitmap\n", ino);
2155 return -EINVAL;
2156 }
2157 }
2158
2159 /* 6. check quota inode simply */
2160 if (fsck_chk_quota_node(sbi))
2161 return -EINVAL;
2162
2163 if (fsck->nat_valid_inode_cnt != le32_to_cpu(cp->valid_inode_count)) {
2164 ASSERT_MSG("valid inode does not match: nat_valid_inode_cnt %u,"
2165 " valid_inode_count %u",
2166 fsck->nat_valid_inode_cnt,
2167 le32_to_cpu(cp->valid_inode_count));
2168 return -EINVAL;
2169 }
2170
2171 return 0;
2172 }
2173
fsck_chk_checkpoint(struct f2fs_sb_info * sbi)2174 void fsck_chk_checkpoint(struct f2fs_sb_info *sbi)
2175 {
2176 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2177
2178 if (get_cp(ckpt_flags) & CP_LARGE_NAT_BITMAP_FLAG) {
2179 if (get_cp(checksum_offset) != CP_MIN_CHKSUM_OFFSET) {
2180 ASSERT_MSG("Deprecated layout of large_nat_bitmap, "
2181 "chksum_offset:%u", get_cp(checksum_offset));
2182 c.fix_chksum = 1;
2183 }
2184 }
2185 }
2186
fsck_init(struct f2fs_sb_info * sbi)2187 void fsck_init(struct f2fs_sb_info *sbi)
2188 {
2189 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2190 struct f2fs_sm_info *sm_i = SM_I(sbi);
2191
2192 /*
2193 * We build three bitmap for main/sit/nat so that may check consistency
2194 * of filesystem.
2195 * 1. main_area_bitmap will be used to check whether all blocks of main
2196 * area is used or not.
2197 * 2. nat_area_bitmap has bitmap information of used nid in NAT.
2198 * 3. sit_area_bitmap has bitmap information of used main block.
2199 * At Last sequence, we compare main_area_bitmap with sit_area_bitmap.
2200 */
2201 fsck->nr_main_blks = sm_i->main_segments << sbi->log_blocks_per_seg;
2202 fsck->main_area_bitmap_sz = (fsck->nr_main_blks + 7) / 8;
2203 fsck->main_area_bitmap = calloc(fsck->main_area_bitmap_sz, 1);
2204 ASSERT(fsck->main_area_bitmap != NULL);
2205
2206 build_nat_area_bitmap(sbi);
2207
2208 build_sit_area_bitmap(sbi);
2209
2210 ASSERT(tree_mark_size != 0);
2211 tree_mark = calloc(tree_mark_size, 1);
2212 ASSERT(tree_mark != NULL);
2213 fsck->dentry = calloc(sizeof(struct f2fs_dentry), 1);
2214 ASSERT(fsck->dentry != NULL);
2215 memcpy(fsck->dentry->name, "/", 1);
2216 fsck->dentry_end = fsck->dentry;
2217
2218 c.quota_fixed = false;
2219 }
2220
fix_hard_links(struct f2fs_sb_info * sbi)2221 static void fix_hard_links(struct f2fs_sb_info *sbi)
2222 {
2223 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2224 struct hard_link_node *tmp, *node;
2225 struct f2fs_node *node_blk = NULL;
2226 struct node_info ni;
2227 int ret;
2228
2229 if (fsck->hard_link_list_head == NULL)
2230 return;
2231
2232 node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
2233 ASSERT(node_blk != NULL);
2234
2235 node = fsck->hard_link_list_head;
2236 while (node) {
2237 /* Sanity check */
2238 if (sanity_check_nid(sbi, node->nid, node_blk,
2239 F2FS_FT_MAX, TYPE_INODE, &ni))
2240 FIX_MSG("Failed to fix, rerun fsck.f2fs");
2241
2242 node_blk->i.i_links = cpu_to_le32(node->actual_links);
2243
2244 FIX_MSG("File: 0x%x i_links= 0x%x -> 0x%x",
2245 node->nid, node->links, node->actual_links);
2246
2247 ret = dev_write_block(node_blk, ni.blk_addr);
2248 ASSERT(ret >= 0);
2249 tmp = node;
2250 node = node->next;
2251 free(tmp);
2252 }
2253 free(node_blk);
2254 }
2255
fix_nat_entries(struct f2fs_sb_info * sbi)2256 static void fix_nat_entries(struct f2fs_sb_info *sbi)
2257 {
2258 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2259 u32 i;
2260
2261 for (i = 0; i < fsck->nr_nat_entries; i++)
2262 if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0)
2263 nullify_nat_entry(sbi, i);
2264 }
2265
flush_curseg_sit_entries(struct f2fs_sb_info * sbi)2266 static void flush_curseg_sit_entries(struct f2fs_sb_info *sbi)
2267 {
2268 struct sit_info *sit_i = SIT_I(sbi);
2269 struct f2fs_sit_block *sit_blk;
2270 int i;
2271
2272 sit_blk = calloc(BLOCK_SZ, 1);
2273 ASSERT(sit_blk);
2274 /* update curseg sit entries, since we may change
2275 * a segment type in move_curseg_info
2276 */
2277 for (i = 0; i < NO_CHECK_TYPE; i++) {
2278 struct curseg_info *curseg = CURSEG_I(sbi, i);
2279 struct f2fs_sit_entry *sit;
2280 struct seg_entry *se;
2281
2282 se = get_seg_entry(sbi, curseg->segno);
2283 get_current_sit_page(sbi, curseg->segno, sit_blk);
2284 sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, curseg->segno)];
2285 sit->vblocks = cpu_to_le16((se->type << SIT_VBLOCKS_SHIFT) |
2286 se->valid_blocks);
2287 rewrite_current_sit_page(sbi, curseg->segno, sit_blk);
2288 }
2289
2290 free(sit_blk);
2291 }
2292
fix_checksum(struct f2fs_sb_info * sbi)2293 static void fix_checksum(struct f2fs_sb_info *sbi)
2294 {
2295 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2296 struct f2fs_nm_info *nm_i = NM_I(sbi);
2297 struct sit_info *sit_i = SIT_I(sbi);
2298 void *bitmap_offset;
2299
2300 if (!c.fix_chksum)
2301 return;
2302
2303 bitmap_offset = cp->sit_nat_version_bitmap + sizeof(__le32);
2304
2305 memcpy(bitmap_offset, nm_i->nat_bitmap, nm_i->bitmap_size);
2306 memcpy(bitmap_offset + nm_i->bitmap_size,
2307 sit_i->sit_bitmap, sit_i->bitmap_size);
2308 }
2309
fix_checkpoint(struct f2fs_sb_info * sbi)2310 static void fix_checkpoint(struct f2fs_sb_info *sbi)
2311 {
2312 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2313 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2314 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
2315 unsigned long long cp_blk_no;
2316 u32 flags = c.alloc_failed ? CP_FSCK_FLAG: CP_UMOUNT_FLAG;
2317 block_t orphan_blks = 0;
2318 block_t cp_blocks;
2319 u32 i;
2320 int ret;
2321 uint32_t crc = 0;
2322
2323 /* should call from fsck */
2324 ASSERT(c.func == FSCK);
2325
2326 if (is_set_ckpt_flags(cp, CP_ORPHAN_PRESENT_FLAG)) {
2327 orphan_blks = __start_sum_addr(sbi) - 1;
2328 flags |= CP_ORPHAN_PRESENT_FLAG;
2329 }
2330 if (is_set_ckpt_flags(cp, CP_TRIMMED_FLAG))
2331 flags |= CP_TRIMMED_FLAG;
2332 if (is_set_ckpt_flags(cp, CP_DISABLED_FLAG))
2333 flags |= CP_DISABLED_FLAG;
2334 if (is_set_ckpt_flags(cp, CP_LARGE_NAT_BITMAP_FLAG)) {
2335 flags |= CP_LARGE_NAT_BITMAP_FLAG;
2336 set_cp(checksum_offset, CP_MIN_CHKSUM_OFFSET);
2337 } else {
2338 set_cp(checksum_offset, CP_CHKSUM_OFFSET);
2339 }
2340
2341 if (flags & CP_UMOUNT_FLAG)
2342 cp_blocks = 8;
2343 else
2344 cp_blocks = 5;
2345
2346 set_cp(cp_pack_total_block_count, cp_blocks +
2347 orphan_blks + get_sb(cp_payload));
2348
2349 flags = update_nat_bits_flags(sb, cp, flags);
2350 flags |= CP_NOCRC_RECOVERY_FLAG;
2351 set_cp(ckpt_flags, flags);
2352
2353 set_cp(free_segment_count, get_free_segments(sbi));
2354 set_cp(valid_block_count, fsck->chk.valid_blk_cnt);
2355 set_cp(valid_node_count, fsck->chk.valid_node_cnt);
2356 set_cp(valid_inode_count, fsck->chk.valid_inode_cnt);
2357
2358 crc = f2fs_checkpoint_chksum(cp);
2359 *((__le32 *)((unsigned char *)cp + get_cp(checksum_offset))) =
2360 cpu_to_le32(crc);
2361
2362 cp_blk_no = get_sb(cp_blkaddr);
2363 if (sbi->cur_cp == 2)
2364 cp_blk_no += 1 << get_sb(log_blocks_per_seg);
2365
2366 ret = dev_write_block(cp, cp_blk_no++);
2367 ASSERT(ret >= 0);
2368
2369 for (i = 0; i < get_sb(cp_payload); i++) {
2370 ret = dev_write_block(((unsigned char *)cp) +
2371 (i + 1) * F2FS_BLKSIZE, cp_blk_no++);
2372 ASSERT(ret >= 0);
2373 }
2374
2375 cp_blk_no += orphan_blks;
2376
2377 for (i = 0; i < NO_CHECK_TYPE; i++) {
2378 struct curseg_info *curseg = CURSEG_I(sbi, i);
2379
2380 if (!(flags & CP_UMOUNT_FLAG) && IS_NODESEG(i))
2381 continue;
2382
2383 ret = dev_write_block(curseg->sum_blk, cp_blk_no++);
2384 ASSERT(ret >= 0);
2385 }
2386
2387 /* Write nat bits */
2388 if (flags & CP_NAT_BITS_FLAG)
2389 write_nat_bits(sbi, sb, cp, sbi->cur_cp);
2390
2391 ret = f2fs_fsync_device();
2392 ASSERT(ret >= 0);
2393
2394 ret = dev_write_block(cp, cp_blk_no++);
2395 ASSERT(ret >= 0);
2396
2397 ret = f2fs_fsync_device();
2398 ASSERT(ret >= 0);
2399 }
2400
fix_checkpoints(struct f2fs_sb_info * sbi)2401 static void fix_checkpoints(struct f2fs_sb_info *sbi)
2402 {
2403 /* copy valid checkpoint to its mirror position */
2404 duplicate_checkpoint(sbi);
2405
2406 /* repair checkpoint at CP #0 position */
2407 sbi->cur_cp = 1;
2408 fix_checkpoint(sbi);
2409 }
2410
2411 #ifdef HAVE_LINUX_BLKZONED_H
2412
2413 /*
2414 * Refer valid block map and return offset of the last valid block in the zone.
2415 * Obtain valid block map from SIT and fsync data.
2416 * If there is no valid block in the zone, return -1.
2417 */
last_vblk_off_in_zone(struct f2fs_sb_info * sbi,unsigned int zone_segno)2418 static int last_vblk_off_in_zone(struct f2fs_sb_info *sbi,
2419 unsigned int zone_segno)
2420 {
2421 int s, b;
2422 unsigned int segs_per_zone = sbi->segs_per_sec * sbi->secs_per_zone;
2423 struct seg_entry *se;
2424
2425 for (s = segs_per_zone - 1; s >= 0; s--) {
2426 se = get_seg_entry(sbi, zone_segno + s);
2427
2428 /*
2429 * Refer not cur_valid_map but ckpt_valid_map which reflects
2430 * fsync data.
2431 */
2432 ASSERT(se->ckpt_valid_map);
2433 for (b = sbi->blocks_per_seg - 1; b >= 0; b--)
2434 if (f2fs_test_bit(b, (const char*)se->ckpt_valid_map))
2435 return b + (s << sbi->log_blocks_per_seg);
2436 }
2437
2438 return -1;
2439 }
2440
check_curseg_write_pointer(struct f2fs_sb_info * sbi,int type)2441 static int check_curseg_write_pointer(struct f2fs_sb_info *sbi, int type)
2442 {
2443 struct curseg_info *curseg = CURSEG_I(sbi, type);
2444 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2445 struct blk_zone blkz;
2446 block_t cs_block, wp_block, zone_last_vblock;
2447 uint64_t cs_sector, wp_sector;
2448 int i, ret;
2449 unsigned int zone_segno;
2450 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
2451
2452 /* get the device the curseg points to */
2453 cs_block = START_BLOCK(sbi, curseg->segno) + curseg->next_blkoff;
2454 for (i = 0; i < MAX_DEVICES; i++) {
2455 if (!c.devices[i].path)
2456 break;
2457 if (c.devices[i].start_blkaddr <= cs_block &&
2458 cs_block <= c.devices[i].end_blkaddr)
2459 break;
2460 }
2461
2462 if (i >= MAX_DEVICES)
2463 return -EINVAL;
2464
2465 if (c.devices[i].zoned_model != F2FS_ZONED_HM)
2466 return 0;
2467
2468 /* get write pointer position of the zone the curseg points to */
2469 cs_sector = (cs_block - c.devices[i].start_blkaddr)
2470 << log_sectors_per_block;
2471 ret = f2fs_report_zone(i, cs_sector, &blkz);
2472 if (ret)
2473 return ret;
2474
2475 if (blk_zone_type(&blkz) != BLK_ZONE_TYPE_SEQWRITE_REQ)
2476 return 0;
2477
2478 /* check consistency between the curseg and the write pointer */
2479 wp_block = c.devices[i].start_blkaddr +
2480 (blk_zone_wp_sector(&blkz) >> log_sectors_per_block);
2481 wp_sector = blk_zone_wp_sector(&blkz);
2482
2483 if (cs_sector == wp_sector)
2484 return 0;
2485
2486 if (cs_sector > wp_sector) {
2487 MSG(0, "Inconsistent write pointer with curseg %d: "
2488 "curseg %d[0x%x,0x%x] > wp[0x%x,0x%x]\n",
2489 type, type, curseg->segno, curseg->next_blkoff,
2490 GET_SEGNO(sbi, wp_block), OFFSET_IN_SEG(sbi, wp_block));
2491 fsck->chk.wp_inconsistent_zones++;
2492 return -EINVAL;
2493 }
2494
2495 MSG(0, "Write pointer goes advance from curseg %d: "
2496 "curseg %d[0x%x,0x%x] wp[0x%x,0x%x]\n",
2497 type, type, curseg->segno, curseg->next_blkoff,
2498 GET_SEGNO(sbi, wp_block), OFFSET_IN_SEG(sbi, wp_block));
2499
2500 zone_segno = GET_SEG_FROM_SEC(sbi,
2501 GET_SEC_FROM_SEG(sbi, curseg->segno));
2502 zone_last_vblock = START_BLOCK(sbi, zone_segno) +
2503 last_vblk_off_in_zone(sbi, zone_segno);
2504
2505 /*
2506 * If valid blocks exist between the curseg position and the write
2507 * pointer, they are fsync data. This is not an error to fix. Leave it
2508 * for kernel to recover later.
2509 * If valid blocks exist between the curseg's zone start and the curseg
2510 * position, or if there is no valid block in the curseg's zone, fix
2511 * the inconsistency between the curseg and the writ pointer.
2512 * Of Note is that if there is no valid block in the curseg's zone,
2513 * last_vblk_off_in_zone() returns -1 and zone_last_vblock is always
2514 * smaller than cs_block.
2515 */
2516 if (cs_block <= zone_last_vblock && zone_last_vblock < wp_block) {
2517 MSG(0, "Curseg has fsync data: curseg %d[0x%x,0x%x] "
2518 "last valid block in zone[0x%x,0x%x]\n",
2519 type, curseg->segno, curseg->next_blkoff,
2520 GET_SEGNO(sbi, zone_last_vblock),
2521 OFFSET_IN_SEG(sbi, zone_last_vblock));
2522 return 0;
2523 }
2524
2525 fsck->chk.wp_inconsistent_zones++;
2526 return -EINVAL;
2527 }
2528
2529 #else
2530
check_curseg_write_pointer(struct f2fs_sb_info * UNUSED (sbi),int UNUSED (type))2531 static int check_curseg_write_pointer(struct f2fs_sb_info *UNUSED(sbi),
2532 int UNUSED(type))
2533 {
2534 return 0;
2535 }
2536
2537 #endif
2538
check_curseg_offset(struct f2fs_sb_info * sbi,int type)2539 int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
2540 {
2541 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
2542 struct curseg_info *curseg = CURSEG_I(sbi, type);
2543 struct seg_entry *se;
2544 int j, nblocks;
2545
2546 if (get_sb(feature) & cpu_to_le32(F2FS_FEATURE_RO) &&
2547 type != CURSEG_HOT_DATA && type != CURSEG_HOT_NODE)
2548 return 0;
2549
2550 if ((curseg->next_blkoff >> 3) >= SIT_VBLOCK_MAP_SIZE) {
2551 ASSERT_MSG("Next block offset:%u is invalid, type:%d",
2552 curseg->next_blkoff, type);
2553 return -EINVAL;
2554 }
2555 se = get_seg_entry(sbi, curseg->segno);
2556 if (f2fs_test_bit(curseg->next_blkoff,
2557 (const char *)se->cur_valid_map)) {
2558 ASSERT_MSG("Next block offset is not free, type:%d", type);
2559 return -EINVAL;
2560 }
2561 if (curseg->alloc_type == SSR)
2562 return 0;
2563
2564 nblocks = sbi->blocks_per_seg;
2565 for (j = curseg->next_blkoff + 1; j < nblocks; j++) {
2566 if (f2fs_test_bit(j, (const char *)se->cur_valid_map)) {
2567 ASSERT_MSG("For LFS curseg, space after .next_blkoff "
2568 "should be unused, type:%d", type);
2569 return -EINVAL;
2570 }
2571 }
2572
2573 if (c.zoned_model == F2FS_ZONED_HM)
2574 return check_curseg_write_pointer(sbi, type);
2575
2576 return 0;
2577 }
2578
check_curseg_offsets(struct f2fs_sb_info * sbi)2579 int check_curseg_offsets(struct f2fs_sb_info *sbi)
2580 {
2581 int i, ret;
2582
2583 for (i = 0; i < NO_CHECK_TYPE; i++) {
2584 ret = check_curseg_offset(sbi, i);
2585 if (ret)
2586 return ret;
2587 }
2588 return 0;
2589 }
2590
fix_curseg_info(struct f2fs_sb_info * sbi)2591 static void fix_curseg_info(struct f2fs_sb_info *sbi)
2592 {
2593 int i, need_update = 0;
2594
2595 for (i = 0; i < NO_CHECK_TYPE; i++) {
2596 if (check_curseg_offset(sbi, i)) {
2597 update_curseg_info(sbi, i);
2598 need_update = 1;
2599 }
2600 }
2601
2602 if (need_update) {
2603 write_curseg_info(sbi);
2604 flush_curseg_sit_entries(sbi);
2605 }
2606 }
2607
check_sit_types(struct f2fs_sb_info * sbi)2608 int check_sit_types(struct f2fs_sb_info *sbi)
2609 {
2610 unsigned int i;
2611 int err = 0;
2612
2613 for (i = 0; i < MAIN_SEGS(sbi); i++) {
2614 struct seg_entry *se;
2615
2616 se = get_seg_entry(sbi, i);
2617 if (se->orig_type != se->type) {
2618 if (se->orig_type == CURSEG_COLD_DATA &&
2619 se->type <= CURSEG_COLD_DATA) {
2620 se->type = se->orig_type;
2621 } else {
2622 FIX_MSG("Wrong segment type [0x%x] %x -> %x",
2623 i, se->orig_type, se->type);
2624 err = -EINVAL;
2625 }
2626 }
2627 }
2628 return err;
2629 }
2630
fsck_get_lpf(struct f2fs_sb_info * sbi)2631 static struct f2fs_node *fsck_get_lpf(struct f2fs_sb_info *sbi)
2632 {
2633 struct f2fs_node *node;
2634 struct node_info ni;
2635 nid_t lpf_ino;
2636 int err;
2637
2638 /* read root inode first */
2639 node = calloc(F2FS_BLKSIZE, 1);
2640 ASSERT(node);
2641 get_node_info(sbi, F2FS_ROOT_INO(sbi), &ni);
2642 err = dev_read_block(node, ni.blk_addr);
2643 ASSERT(err >= 0);
2644
2645 /* lookup lost+found in root directory */
2646 lpf_ino = f2fs_lookup(sbi, node, (u8 *)LPF, strlen(LPF));
2647 if (lpf_ino) { /* found */
2648 get_node_info(sbi, lpf_ino, &ni);
2649 err = dev_read_block(node, ni.blk_addr);
2650 ASSERT(err >= 0);
2651 DBG(1, "Found lost+found 0x%x at blkaddr [0x%x]\n",
2652 lpf_ino, ni.blk_addr);
2653 if (!S_ISDIR(le16_to_cpu(node->i.i_mode))) {
2654 ASSERT_MSG("lost+found is not directory [0%o]\n",
2655 le16_to_cpu(node->i.i_mode));
2656 /* FIXME: give up? */
2657 goto out;
2658 }
2659 } else { /* not found, create it */
2660 struct dentry de;
2661
2662 memset(&de, 0, sizeof(de));
2663 de.name = (u8 *) LPF;
2664 de.len = strlen(LPF);
2665 de.mode = 0x41c0;
2666 de.pino = F2FS_ROOT_INO(sbi),
2667 de.file_type = F2FS_FT_DIR,
2668 de.uid = getuid();
2669 de.gid = getgid();
2670 de.mtime = time(NULL);
2671
2672 err = f2fs_mkdir(sbi, &de);
2673 if (err) {
2674 ASSERT_MSG("Failed create lost+found");
2675 goto out;
2676 }
2677
2678 get_node_info(sbi, de.ino, &ni);
2679 err = dev_read_block(node, ni.blk_addr);
2680 ASSERT(err >= 0);
2681 DBG(1, "Create lost+found 0x%x at blkaddr [0x%x]\n",
2682 de.ino, ni.blk_addr);
2683 }
2684
2685 c.lpf_ino = le32_to_cpu(node->footer.ino);
2686 return node;
2687 out:
2688 free(node);
2689 return NULL;
2690 }
2691
fsck_do_reconnect_file(struct f2fs_sb_info * sbi,struct f2fs_node * lpf,struct f2fs_node * fnode)2692 static int fsck_do_reconnect_file(struct f2fs_sb_info *sbi,
2693 struct f2fs_node *lpf,
2694 struct f2fs_node *fnode)
2695 {
2696 char name[80];
2697 size_t namelen;
2698 nid_t ino = le32_to_cpu(fnode->footer.ino);
2699 struct node_info ni;
2700 int ftype, ret;
2701
2702 namelen = snprintf(name, 80, "%u", ino);
2703 if (namelen >= 80)
2704 /* ignore terminating '\0', should never happen */
2705 namelen = 79;
2706
2707 if (f2fs_lookup(sbi, lpf, (u8 *)name, namelen)) {
2708 ASSERT_MSG("Name %s already exist in lost+found", name);
2709 return -EEXIST;
2710 }
2711
2712 get_node_info(sbi, le32_to_cpu(lpf->footer.ino), &ni);
2713 ftype = map_de_type(le16_to_cpu(fnode->i.i_mode));
2714 ret = f2fs_add_link(sbi, lpf, (unsigned char *)name, namelen,
2715 ino, ftype, ni.blk_addr, 0);
2716 if (ret) {
2717 ASSERT_MSG("Failed to add inode [0x%x] to lost+found", ino);
2718 return -EINVAL;
2719 }
2720
2721 /* update fnode */
2722 memcpy(fnode->i.i_name, name, namelen);
2723 fnode->i.i_namelen = cpu_to_le32(namelen);
2724 fnode->i.i_pino = c.lpf_ino;
2725 get_node_info(sbi, le32_to_cpu(fnode->footer.ino), &ni);
2726 ret = dev_write_block(fnode, ni.blk_addr);
2727 ASSERT(ret >= 0);
2728
2729 DBG(1, "Reconnect inode [0x%x] to lost+found\n", ino);
2730 return 0;
2731 }
2732
fsck_failed_reconnect_file_dnode(struct f2fs_sb_info * sbi,nid_t nid)2733 static void fsck_failed_reconnect_file_dnode(struct f2fs_sb_info *sbi,
2734 nid_t nid)
2735 {
2736 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2737 struct f2fs_node *node;
2738 struct node_info ni;
2739 u32 addr;
2740 int i, err;
2741
2742 node = calloc(F2FS_BLKSIZE, 1);
2743 ASSERT(node);
2744
2745 get_node_info(sbi, nid, &ni);
2746 err = dev_read_block(node, ni.blk_addr);
2747 ASSERT(err >= 0);
2748
2749 fsck->chk.valid_node_cnt--;
2750 fsck->chk.valid_blk_cnt--;
2751 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2752
2753 for (i = 0; i < ADDRS_PER_BLOCK(&node->i); i++) {
2754 addr = le32_to_cpu(node->dn.addr[i]);
2755 if (!addr)
2756 continue;
2757 fsck->chk.valid_blk_cnt--;
2758 if (addr == NEW_ADDR)
2759 continue;
2760 f2fs_clear_main_bitmap(sbi, addr);
2761 }
2762
2763 free(node);
2764 }
2765
fsck_failed_reconnect_file_idnode(struct f2fs_sb_info * sbi,nid_t nid)2766 static void fsck_failed_reconnect_file_idnode(struct f2fs_sb_info *sbi,
2767 nid_t nid)
2768 {
2769 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2770 struct f2fs_node *node;
2771 struct node_info ni;
2772 nid_t tmp;
2773 int i, err;
2774
2775 node = calloc(F2FS_BLKSIZE, 1);
2776 ASSERT(node);
2777
2778 get_node_info(sbi, nid, &ni);
2779 err = dev_read_block(node, ni.blk_addr);
2780 ASSERT(err >= 0);
2781
2782 fsck->chk.valid_node_cnt--;
2783 fsck->chk.valid_blk_cnt--;
2784 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2785
2786 for (i = 0; i < NIDS_PER_BLOCK; i++) {
2787 tmp = le32_to_cpu(node->in.nid[i]);
2788 if (!tmp)
2789 continue;
2790 fsck_failed_reconnect_file_dnode(sbi, tmp);
2791 }
2792
2793 free(node);
2794 }
2795
fsck_failed_reconnect_file_didnode(struct f2fs_sb_info * sbi,nid_t nid)2796 static void fsck_failed_reconnect_file_didnode(struct f2fs_sb_info *sbi,
2797 nid_t nid)
2798 {
2799 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2800 struct f2fs_node *node;
2801 struct node_info ni;
2802 nid_t tmp;
2803 int i, err;
2804
2805 node = calloc(F2FS_BLKSIZE, 1);
2806 ASSERT(node);
2807
2808 get_node_info(sbi, nid, &ni);
2809 err = dev_read_block(node, ni.blk_addr);
2810 ASSERT(err >= 0);
2811
2812 fsck->chk.valid_node_cnt--;
2813 fsck->chk.valid_blk_cnt--;
2814 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2815
2816 for (i = 0; i < NIDS_PER_BLOCK; i++) {
2817 tmp = le32_to_cpu(node->in.nid[i]);
2818 if (!tmp)
2819 continue;
2820 fsck_failed_reconnect_file_idnode(sbi, tmp);
2821 }
2822
2823 free(node);
2824 }
2825
2826 /*
2827 * Counters and main_area_bitmap are already changed during checking
2828 * inode block, so clear them. There is no need to clear new blocks
2829 * allocted to lost+found.
2830 */
fsck_failed_reconnect_file(struct f2fs_sb_info * sbi,nid_t ino)2831 static void fsck_failed_reconnect_file(struct f2fs_sb_info *sbi, nid_t ino)
2832 {
2833 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2834 struct f2fs_node *node;
2835 struct node_info ni;
2836 nid_t nid;
2837 int ofs, i, err;
2838
2839 node = calloc(F2FS_BLKSIZE, 1);
2840 ASSERT(node);
2841
2842 get_node_info(sbi, ino, &ni);
2843 err = dev_read_block(node, ni.blk_addr);
2844 ASSERT(err >= 0);
2845
2846 /* clear inode counters */
2847 fsck->chk.valid_inode_cnt--;
2848 fsck->chk.valid_node_cnt--;
2849 fsck->chk.valid_blk_cnt--;
2850 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2851
2852 /* clear xnid counters */
2853 if (node->i.i_xattr_nid) {
2854 nid = le32_to_cpu(node->i.i_xattr_nid);
2855 fsck->chk.valid_node_cnt--;
2856 fsck->chk.valid_blk_cnt--;
2857 get_node_info(sbi, nid, &ni);
2858 f2fs_clear_main_bitmap(sbi, ni.blk_addr);
2859 }
2860
2861 /* clear data counters */
2862 if(!(node->i.i_inline & F2FS_INLINE_DATA)) {
2863 ofs = get_extra_isize(node);
2864 for (i = 0; i < ADDRS_PER_INODE(&node->i); i++) {
2865 block_t addr = le32_to_cpu(node->i.i_addr[ofs + i]);
2866 if (!addr)
2867 continue;
2868 fsck->chk.valid_blk_cnt--;
2869 if (addr == NEW_ADDR)
2870 continue;
2871 f2fs_clear_main_bitmap(sbi, addr);
2872 }
2873 }
2874
2875 for (i = 0; i < 5; i++) {
2876 nid = le32_to_cpu(node->i.i_nid[i]);
2877 if (!nid)
2878 continue;
2879
2880 switch (i) {
2881 case 0: /* direct node */
2882 case 1:
2883 fsck_failed_reconnect_file_dnode(sbi, nid);
2884 break;
2885 case 2: /* indirect node */
2886 case 3:
2887 fsck_failed_reconnect_file_idnode(sbi, nid);
2888 break;
2889 case 4: /* double indirect node */
2890 fsck_failed_reconnect_file_didnode(sbi, nid);
2891 break;
2892 }
2893 }
2894
2895 free(node);
2896 }
2897
2898 /*
2899 * Scan unreachable nids and find only regular file inodes. If these files
2900 * are not corrupted, reconnect them to lost+found.
2901 *
2902 * Since all unreachable nodes are already checked, we can allocate new
2903 * blocks safely.
2904 *
2905 * This function returns the number of files been reconnected.
2906 */
fsck_reconnect_file(struct f2fs_sb_info * sbi)2907 static int fsck_reconnect_file(struct f2fs_sb_info *sbi)
2908 {
2909 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
2910 struct f2fs_node *lpf_node, *node;
2911 struct node_info ni;
2912 char *reconnect_bitmap;
2913 u32 blk_cnt;
2914 struct f2fs_compr_blk_cnt cbc;
2915 nid_t nid;
2916 int err, cnt = 0, ftype;
2917
2918 node = calloc(F2FS_BLKSIZE, 1);
2919 ASSERT(node);
2920
2921 reconnect_bitmap = calloc(fsck->nat_area_bitmap_sz, 1);
2922 ASSERT(reconnect_bitmap);
2923
2924 for (nid = 0; nid < fsck->nr_nat_entries; nid++) {
2925 if (f2fs_test_bit(nid, fsck->nat_area_bitmap)) {
2926 if (is_qf_ino(F2FS_RAW_SUPER(sbi), nid)) {
2927 DBG(1, "Not support quota inode [0x%x]\n",
2928 nid);
2929 continue;
2930 }
2931
2932 get_node_info(sbi, nid, &ni);
2933 err = dev_read_block(node, ni.blk_addr);
2934 ASSERT(err >= 0);
2935
2936 /* reconnection will restore these nodes if needed */
2937 if (node->footer.ino != node->footer.nid) {
2938 DBG(1, "Not support non-inode node [0x%x]\n",
2939 nid);
2940 continue;
2941 }
2942
2943 if (S_ISDIR(le16_to_cpu(node->i.i_mode))) {
2944 DBG(1, "Not support directory inode [0x%x]\n",
2945 nid);
2946 continue;
2947 }
2948
2949 ftype = map_de_type(le16_to_cpu(node->i.i_mode));
2950 if (sanity_check_nid(sbi, nid, node, ftype,
2951 TYPE_INODE, &ni)) {
2952 ASSERT_MSG("Invalid nid [0x%x]\n", nid);
2953 continue;
2954 }
2955
2956 DBG(1, "Check inode 0x%x\n", nid);
2957 blk_cnt = 1;
2958 cbc.cnt = 0;
2959 cbc.cheader_pgofs = CHEADER_PGOFS_NONE;
2960 fsck_chk_inode_blk(sbi, nid, ftype, node,
2961 &blk_cnt, &cbc, &ni, NULL);
2962
2963 f2fs_set_bit(nid, reconnect_bitmap);
2964 }
2965 }
2966
2967 lpf_node = fsck_get_lpf(sbi);
2968 if (!lpf_node)
2969 goto out;
2970
2971 for (nid = 0; nid < fsck->nr_nat_entries; nid++) {
2972 if (f2fs_test_bit(nid, reconnect_bitmap)) {
2973 get_node_info(sbi, nid, &ni);
2974 err = dev_read_block(node, ni.blk_addr);
2975 ASSERT(err >= 0);
2976
2977 if (fsck_do_reconnect_file(sbi, lpf_node, node)) {
2978 DBG(1, "Failed to reconnect inode [0x%x]\n",
2979 nid);
2980 fsck_failed_reconnect_file(sbi, nid);
2981 continue;
2982 }
2983
2984 quota_add_inode_usage(fsck->qctx, nid, &node->i);
2985
2986 DBG(1, "Reconnected inode [0x%x] to lost+found\n", nid);
2987 cnt++;
2988 }
2989 }
2990
2991 out:
2992 free(node);
2993 free(lpf_node);
2994 free(reconnect_bitmap);
2995 return cnt;
2996 }
2997
2998 #ifdef HAVE_LINUX_BLKZONED_H
2999
3000 struct write_pointer_check_data {
3001 struct f2fs_sb_info *sbi;
3002 int dev_index;
3003 };
3004
chk_and_fix_wp_with_sit(int UNUSED (i),void * blkzone,void * opaque)3005 static int chk_and_fix_wp_with_sit(int UNUSED(i), void *blkzone, void *opaque)
3006 {
3007 struct blk_zone *blkz = (struct blk_zone *)blkzone;
3008 struct write_pointer_check_data *wpd = opaque;
3009 struct f2fs_sb_info *sbi = wpd->sbi;
3010 struct device_info *dev = c.devices + wpd->dev_index;
3011 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3012 block_t zone_block, wp_block, wp_blkoff;
3013 unsigned int zone_segno, wp_segno;
3014 struct curseg_info *cs;
3015 int cs_index, ret, last_valid_blkoff;
3016 int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;
3017 unsigned int segs_per_zone = sbi->segs_per_sec * sbi->secs_per_zone;
3018
3019 if (blk_zone_conv(blkz))
3020 return 0;
3021
3022 zone_block = dev->start_blkaddr
3023 + (blk_zone_sector(blkz) >> log_sectors_per_block);
3024 zone_segno = GET_SEGNO(sbi, zone_block);
3025 if (zone_segno >= MAIN_SEGS(sbi))
3026 return 0;
3027
3028 wp_block = dev->start_blkaddr
3029 + (blk_zone_wp_sector(blkz) >> log_sectors_per_block);
3030 wp_segno = GET_SEGNO(sbi, wp_block);
3031 wp_blkoff = wp_block - START_BLOCK(sbi, wp_segno);
3032
3033 /* if a curseg points to the zone, skip the check */
3034 for (cs_index = 0; cs_index < NO_CHECK_TYPE; cs_index++) {
3035 cs = &SM_I(sbi)->curseg_array[cs_index];
3036 if (zone_segno <= cs->segno &&
3037 cs->segno < zone_segno + segs_per_zone)
3038 return 0;
3039 }
3040
3041 last_valid_blkoff = last_vblk_off_in_zone(sbi, zone_segno);
3042
3043 /*
3044 * When there is no valid block in the zone, check write pointer is
3045 * at zone start. If not, reset the write pointer.
3046 */
3047 if (last_valid_blkoff < 0 &&
3048 blk_zone_wp_sector(blkz) != blk_zone_sector(blkz)) {
3049 if (!c.fix_on) {
3050 MSG(0, "Inconsistent write pointer: wp[0x%x,0x%x]\n",
3051 wp_segno, wp_blkoff);
3052 fsck->chk.wp_inconsistent_zones++;
3053 return 0;
3054 }
3055
3056 FIX_MSG("Reset write pointer of zone at segment 0x%x",
3057 zone_segno);
3058 ret = f2fs_reset_zone(wpd->dev_index, blkz);
3059 if (ret) {
3060 printf("[FSCK] Write pointer reset failed: %s\n",
3061 dev->path);
3062 return ret;
3063 }
3064 fsck->chk.wp_fixed = 1;
3065 return 0;
3066 }
3067
3068 /*
3069 * If valid blocks exist in the zone beyond the write pointer, it
3070 * is a bug. No need to fix because the zone is not selected for the
3071 * write. Just report it.
3072 */
3073 if (last_valid_blkoff + zone_block > wp_block) {
3074 MSG(0, "Unexpected invalid write pointer: wp[0x%x,0x%x]\n",
3075 wp_segno, wp_blkoff);
3076 return 0;
3077 }
3078
3079 return 0;
3080 }
3081
fix_wp_sit_alignment(struct f2fs_sb_info * sbi)3082 static void fix_wp_sit_alignment(struct f2fs_sb_info *sbi)
3083 {
3084 unsigned int i;
3085 struct write_pointer_check_data wpd = { sbi, 0 };
3086
3087 if (c.zoned_model != F2FS_ZONED_HM)
3088 return;
3089
3090 for (i = 0; i < MAX_DEVICES; i++) {
3091 if (!c.devices[i].path)
3092 break;
3093 if (c.devices[i].zoned_model != F2FS_ZONED_HM)
3094 break;
3095
3096 wpd.dev_index = i;
3097 if (f2fs_report_zones(i, chk_and_fix_wp_with_sit, &wpd)) {
3098 printf("[FSCK] Write pointer check failed: %s\n",
3099 c.devices[i].path);
3100 return;
3101 }
3102 }
3103 }
3104
3105 #else
3106
fix_wp_sit_alignment(struct f2fs_sb_info * UNUSED (sbi))3107 static void fix_wp_sit_alignment(struct f2fs_sb_info *UNUSED(sbi))
3108 {
3109 return;
3110 }
3111
3112 #endif
3113
3114 /*
3115 * Check and fix consistency with write pointers at the beginning of
3116 * fsck so that following writes by fsck do not fail.
3117 */
fsck_chk_and_fix_write_pointers(struct f2fs_sb_info * sbi)3118 void fsck_chk_and_fix_write_pointers(struct f2fs_sb_info *sbi)
3119 {
3120 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3121
3122 if (c.zoned_model != F2FS_ZONED_HM)
3123 return;
3124
3125 if (check_curseg_offsets(sbi) && c.fix_on) {
3126 fix_curseg_info(sbi);
3127 fsck->chk.wp_fixed = 1;
3128 }
3129
3130 fix_wp_sit_alignment(sbi);
3131 }
3132
fsck_chk_curseg_info(struct f2fs_sb_info * sbi)3133 int fsck_chk_curseg_info(struct f2fs_sb_info *sbi)
3134 {
3135 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3136 struct curseg_info *curseg;
3137 struct seg_entry *se;
3138 struct f2fs_summary_block *sum_blk;
3139 int i, ret = 0;
3140
3141 for (i = 0; i < NO_CHECK_TYPE; i++) {
3142 curseg = CURSEG_I(sbi, i);
3143 se = get_seg_entry(sbi, curseg->segno);
3144 sum_blk = curseg->sum_blk;
3145
3146 if ((get_sb(feature) & cpu_to_le32(F2FS_FEATURE_RO)) &&
3147 (i != CURSEG_HOT_DATA && i != CURSEG_HOT_NODE))
3148 continue;
3149
3150 if (se->type != i) {
3151 ASSERT_MSG("Incorrect curseg [%d]: segno [0x%x] "
3152 "type(SIT) [%d]", i, curseg->segno,
3153 se->type);
3154 if (c.fix_on || c.preen_mode)
3155 se->type = i;
3156 ret = -1;
3157 }
3158 if (i <= CURSEG_COLD_DATA && IS_SUM_DATA_SEG(sum_blk->footer)) {
3159 continue;
3160 } else if (i > CURSEG_COLD_DATA && IS_SUM_NODE_SEG(sum_blk->footer)) {
3161 continue;
3162 } else {
3163 ASSERT_MSG("Incorrect curseg [%d]: segno [0x%x] "
3164 "type(SSA) [%d]", i, curseg->segno,
3165 sum_blk->footer.entry_type);
3166 if (c.fix_on || c.preen_mode)
3167 sum_blk->footer.entry_type =
3168 i <= CURSEG_COLD_DATA ?
3169 SUM_TYPE_DATA : SUM_TYPE_NODE;
3170 ret = -1;
3171 }
3172 }
3173
3174 return ret;
3175 }
3176
fsck_verify(struct f2fs_sb_info * sbi)3177 int fsck_verify(struct f2fs_sb_info *sbi)
3178 {
3179 unsigned int i = 0;
3180 int ret = 0;
3181 int force = 0;
3182 u32 nr_unref_nid = 0;
3183 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3184 struct hard_link_node *node = NULL;
3185 bool verify_failed = false;
3186 uint64_t max_blks, data_secs, node_secs, free_blks;
3187
3188 if (c.show_file_map)
3189 return 0;
3190
3191 printf("\n");
3192
3193 if (c.zoned_model == F2FS_ZONED_HM) {
3194 printf("[FSCK] Write pointers consistency ");
3195 if (fsck->chk.wp_inconsistent_zones == 0x0) {
3196 printf(" [Ok..]\n");
3197 } else {
3198 printf(" [Fail] [0x%x]\n",
3199 fsck->chk.wp_inconsistent_zones);
3200 verify_failed = true;
3201 }
3202
3203 if (fsck->chk.wp_fixed && c.fix_on)
3204 force = 1;
3205 }
3206
3207 if (c.feature & cpu_to_le32(F2FS_FEATURE_LOST_FOUND)) {
3208 for (i = 0; i < fsck->nr_nat_entries; i++)
3209 if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0)
3210 break;
3211 if (i < fsck->nr_nat_entries) {
3212 i = fsck_reconnect_file(sbi);
3213 printf("[FSCK] Reconnect %u files to lost+found\n", i);
3214 }
3215 }
3216
3217 for (i = 0; i < fsck->nr_nat_entries; i++) {
3218 if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0) {
3219 struct node_info ni;
3220
3221 get_node_info(sbi, i, &ni);
3222 printf("NID[0x%x] is unreachable, blkaddr:0x%x\n",
3223 i, ni.blk_addr);
3224 nr_unref_nid++;
3225 }
3226 }
3227
3228 if (fsck->hard_link_list_head != NULL) {
3229 node = fsck->hard_link_list_head;
3230 while (node) {
3231 printf("NID[0x%x] has [0x%x] more unreachable links\n",
3232 node->nid, node->links);
3233 node = node->next;
3234 }
3235 c.bug_on = 1;
3236 }
3237
3238 data_secs = round_up(sbi->total_valid_node_count, BLKS_PER_SEC(sbi));
3239 node_secs = round_up(sbi->total_valid_block_count -
3240 sbi->total_valid_node_count, BLKS_PER_SEC(sbi));
3241 free_blks = (sbi->total_sections - data_secs - node_secs) *
3242 BLKS_PER_SEC(sbi);
3243 max_blks = SM_I(sbi)->main_blkaddr + (data_secs + node_secs) *
3244 BLKS_PER_SEC(sbi);
3245 printf("[FSCK] Max image size: %"PRIu64" MB, Free space: %"PRIu64" MB\n",
3246 max_blks >> 8, free_blks >> 8);
3247 printf("[FSCK] Unreachable nat entries ");
3248 if (nr_unref_nid == 0x0) {
3249 printf(" [Ok..] [0x%x]\n", nr_unref_nid);
3250 } else {
3251 printf(" [Fail] [0x%x]\n", nr_unref_nid);
3252 verify_failed = true;
3253 }
3254
3255 printf("[FSCK] SIT valid block bitmap checking ");
3256 if (memcmp(fsck->sit_area_bitmap, fsck->main_area_bitmap,
3257 fsck->sit_area_bitmap_sz) == 0x0) {
3258 printf("[Ok..]\n");
3259 } else {
3260 printf("[Fail]\n");
3261 verify_failed = true;
3262 }
3263
3264 printf("[FSCK] Hard link checking for regular file ");
3265 if (fsck->hard_link_list_head == NULL) {
3266 printf(" [Ok..] [0x%x]\n", fsck->chk.multi_hard_link_files);
3267 } else {
3268 printf(" [Fail] [0x%x]\n", fsck->chk.multi_hard_link_files);
3269 verify_failed = true;
3270 }
3271
3272 printf("[FSCK] valid_block_count matching with CP ");
3273 if (sbi->total_valid_block_count == fsck->chk.valid_blk_cnt) {
3274 printf(" [Ok..] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt);
3275 } else {
3276 printf(" [Fail] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt);
3277 verify_failed = true;
3278 }
3279
3280 printf("[FSCK] valid_node_count matching with CP (de lookup) ");
3281 if (sbi->total_valid_node_count == fsck->chk.valid_node_cnt) {
3282 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_node_cnt);
3283 } else {
3284 printf(" [Fail] [0x%x]\n", fsck->chk.valid_node_cnt);
3285 verify_failed = true;
3286 }
3287
3288 printf("[FSCK] valid_node_count matching with CP (nat lookup)");
3289 if (sbi->total_valid_node_count == fsck->chk.valid_nat_entry_cnt) {
3290 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
3291 } else {
3292 printf(" [Fail] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
3293 verify_failed = true;
3294 }
3295
3296 printf("[FSCK] valid_inode_count matched with CP ");
3297 if (sbi->total_valid_inode_count == fsck->chk.valid_inode_cnt) {
3298 printf(" [Ok..] [0x%x]\n", fsck->chk.valid_inode_cnt);
3299 } else {
3300 printf(" [Fail] [0x%x]\n", fsck->chk.valid_inode_cnt);
3301 verify_failed = true;
3302 }
3303
3304 printf("[FSCK] free segment_count matched with CP ");
3305 if (le32_to_cpu(F2FS_CKPT(sbi)->free_segment_count) ==
3306 fsck->chk.sit_free_segs) {
3307 printf(" [Ok..] [0x%x]\n", fsck->chk.sit_free_segs);
3308 } else {
3309 printf(" [Fail] [0x%x]\n", fsck->chk.sit_free_segs);
3310 verify_failed = true;
3311 }
3312
3313 printf("[FSCK] next block offset is free ");
3314 if (check_curseg_offsets(sbi) == 0) {
3315 printf(" [Ok..]\n");
3316 } else {
3317 printf(" [Fail]\n");
3318 verify_failed = true;
3319 }
3320
3321 printf("[FSCK] fixing SIT types\n");
3322 if (check_sit_types(sbi) != 0)
3323 force = 1;
3324
3325 printf("[FSCK] other corrupted bugs ");
3326 if (c.bug_on == 0) {
3327 printf(" [Ok..]\n");
3328 } else {
3329 printf(" [Fail]\n");
3330 ret = EXIT_ERR_CODE;
3331 }
3332
3333 if (verify_failed) {
3334 ret = EXIT_ERR_CODE;
3335 c.bug_on = 1;
3336 }
3337
3338 #ifndef WITH_ANDROID
3339 if (nr_unref_nid && !c.ro) {
3340 char ans[255] = {0};
3341 int res;
3342
3343 printf("\nDo you want to restore lost files into ./lost_found/? [Y/N] ");
3344 res = scanf("%s", ans);
3345 ASSERT(res >= 0);
3346 if (!strcasecmp(ans, "y")) {
3347 for (i = 0; i < fsck->nr_nat_entries; i++) {
3348 if (f2fs_test_bit(i, fsck->nat_area_bitmap))
3349 dump_node(sbi, i, 1);
3350 }
3351 }
3352 }
3353 #endif
3354
3355 /* fix global metadata */
3356 if (force || (c.fix_on && f2fs_dev_is_writable())) {
3357 struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
3358 struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
3359
3360 if (force || c.bug_on || c.bug_nat_bits || c.quota_fixed) {
3361 /* flush nats to write_nit_bits below */
3362 flush_journal_entries(sbi);
3363 fix_hard_links(sbi);
3364 fix_nat_entries(sbi);
3365 rewrite_sit_area_bitmap(sbi);
3366 fix_wp_sit_alignment(sbi);
3367 fix_curseg_info(sbi);
3368 fix_checksum(sbi);
3369 fix_checkpoints(sbi);
3370 } else if (is_set_ckpt_flags(cp, CP_FSCK_FLAG) ||
3371 is_set_ckpt_flags(cp, CP_QUOTA_NEED_FSCK_FLAG)) {
3372 write_checkpoints(sbi);
3373 }
3374
3375 if (c.abnormal_stop)
3376 memset(sb->s_stop_reason, 0, MAX_STOP_REASON);
3377
3378 if (c.fs_errors)
3379 memset(sb->s_errors, 0, MAX_F2FS_ERRORS);
3380
3381 if (c.abnormal_stop || c.fs_errors)
3382 update_superblock(sb, SB_MASK_ALL);
3383
3384 /* to return FSCK_ERROR_CORRECTED */
3385 ret = 0;
3386 }
3387 return ret;
3388 }
3389
fsck_free(struct f2fs_sb_info * sbi)3390 void fsck_free(struct f2fs_sb_info *sbi)
3391 {
3392 struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
3393
3394 if (fsck->qctx)
3395 quota_release_context(&fsck->qctx);
3396
3397 if (fsck->main_area_bitmap)
3398 free(fsck->main_area_bitmap);
3399
3400 if (fsck->nat_area_bitmap)
3401 free(fsck->nat_area_bitmap);
3402
3403 if (fsck->sit_area_bitmap)
3404 free(fsck->sit_area_bitmap);
3405
3406 if (fsck->entries)
3407 free(fsck->entries);
3408
3409 if (tree_mark)
3410 free(tree_mark);
3411
3412 while (fsck->dentry) {
3413 struct f2fs_dentry *dentry = fsck->dentry;
3414
3415 fsck->dentry = fsck->dentry->next;
3416 free(dentry);
3417 }
3418 }
3419