?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: check: lowmem: Fix silent error if first inode item missing
[btrfs-progs-unstable/devel.git] / cmds-check.c
blobc3914531f43254a78c4024b949db8be17161d2c3
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <getopt.h>
27 #include <uuid/uuid.h>
28 #include "ctree.h"
29 #include "volumes.h"
30 #include "repair.h"
31 #include "disk-io.h"
32 #include "print-tree.h"
33 #include "task-utils.h"
34 #include "transaction.h"
35 #include "utils.h"
36 #include "commands.h"
37 #include "free-space-cache.h"
38 #include "free-space-tree.h"
39 #include "btrfsck.h"
40 #include "qgroup-verify.h"
41 #include "rbtree-utils.h"
42 #include "backref.h"
43 #include "kernel-shared/ulist.h"
44 #include "hash.h"
45 #include "help.h"
46
47 enum task_position {
48 TASK_EXTENTS,
49 TASK_FREE_SPACE,
50 TASK_FS_ROOTS,
51 TASK_NOTHING, /* have to be the last element */
52 };
53
54 struct task_ctx {
55 int progress_enabled;
56 enum task_position tp;
57
58 struct task_info *info;
59 };
60
61 static u64 bytes_used = 0;
62 static u64 total_csum_bytes = 0;
63 static u64 total_btree_bytes = 0;
64 static u64 total_fs_tree_bytes = 0;
65 static u64 total_extent_tree_bytes = 0;
66 static u64 btree_space_waste = 0;
67 static u64 data_bytes_allocated = 0;
68 static u64 data_bytes_referenced = 0;
69 static int found_old_backref = 0;
70 static LIST_HEAD(duplicate_extents);
71 static LIST_HEAD(delete_items);
72 static int no_holes = 0;
73 static int init_extent_tree = 0;
74 static int check_data_csum = 0;
75 static struct btrfs_fs_info *global_info;
76 static struct task_ctx ctx = { 0 };
77 static struct cache_tree *roots_info_cache = NULL;
78
79 enum btrfs_check_mode {
80 CHECK_MODE_ORIGINAL,
81 CHECK_MODE_LOWMEM,
82 CHECK_MODE_UNKNOWN,
83 CHECK_MODE_DEFAULT = CHECK_MODE_ORIGINAL
84 };
85
86 static enum btrfs_check_mode check_mode = CHECK_MODE_DEFAULT;
87
88 struct extent_backref {
89 struct list_head list;
90 unsigned int is_data:1;
91 unsigned int found_extent_tree:1;
92 unsigned int full_backref:1;
93 unsigned int found_ref:1;
94 unsigned int broken:1;
95 };
96
97 static inline struct extent_backref* to_extent_backref(struct list_head *entry)
98 {
99 return list_entry(entry, struct extent_backref, list);
100 }
101
102 struct data_backref {
103 struct extent_backref node;
104 union {
105 u64 parent;
106 u64 root;
107 };
108 u64 owner;
109 u64 offset;
110 u64 disk_bytenr;
111 u64 bytes;
112 u64 ram_bytes;
113 u32 num_refs;
114 u32 found_ref;
115 };
116
117 #define ROOT_DIR_ERROR (1<<1) /* bad ROOT_DIR */
118 #define DIR_ITEM_MISSING (1<<2) /* DIR_ITEM not found */
119 #define DIR_ITEM_MISMATCH (1<<3) /* DIR_ITEM found but not match */
120 #define INODE_REF_MISSING (1<<4) /* INODE_REF/INODE_EXTREF not found */
121 #define INODE_ITEM_MISSING (1<<5) /* INODE_ITEM not found */
122 #define INODE_ITEM_MISMATCH (1<<6) /* INODE_ITEM found but not match */
123 #define FILE_EXTENT_ERROR (1<<7) /* bad FILE_EXTENT */
124 #define ODD_CSUM_ITEM (1<<8) /* CSUM_ITEM error */
125 #define CSUM_ITEM_MISSING (1<<9) /* CSUM_ITEM not found */
126 #define LINK_COUNT_ERROR (1<<10) /* INODE_ITEM nlink count error */
127 #define NBYTES_ERROR (1<<11) /* INODE_ITEM nbytes count error */
128 #define ISIZE_ERROR (1<<12) /* INODE_ITEM size count error */
129 #define ORPHAN_ITEM (1<<13) /* INODE_ITEM no reference */
130 #define NO_INODE_ITEM (1<<14) /* no inode_item */
131 #define LAST_ITEM (1<<15) /* Complete this tree traversal */
132 #define ROOT_REF_MISSING (1<<16) /* ROOT_REF not found */
133 #define ROOT_REF_MISMATCH (1<<17) /* ROOT_REF found but not match */
134
135 static inline struct data_backref* to_data_backref(struct extent_backref *back)
136 {
137 return container_of(back, struct data_backref, node);
138 }
139
140 /*
141 * Much like data_backref, just removed the undetermined members
142 * and change it to use list_head.
143 * During extent scan, it is stored in root->orphan_data_extent.
144 * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
145 */
146 struct orphan_data_extent {
147 struct list_head list;
148 u64 root;
149 u64 objectid;
150 u64 offset;
151 u64 disk_bytenr;
152 u64 disk_len;
153 };
154
155 struct tree_backref {
156 struct extent_backref node;
157 union {
158 u64 parent;
159 u64 root;
160 };
161 };
162
163 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
164 {
165 return container_of(back, struct tree_backref, node);
166 }
167
168 /* Explicit initialization for extent_record::flag_block_full_backref */
169 enum { FLAG_UNSET = 2 };
170
171 struct extent_record {
172 struct list_head backrefs;
173 struct list_head dups;
174 struct list_head list;
175 struct cache_extent cache;
176 struct btrfs_disk_key parent_key;
177 u64 start;
178 u64 max_size;
179 u64 nr;
180 u64 refs;
181 u64 extent_item_refs;
182 u64 generation;
183 u64 parent_generation;
184 u64 info_objectid;
185 u32 num_duplicates;
186 u8 info_level;
187 unsigned int flag_block_full_backref:2;
188 unsigned int found_rec:1;
189 unsigned int content_checked:1;
190 unsigned int owner_ref_checked:1;
191 unsigned int is_root:1;
192 unsigned int metadata:1;
193 unsigned int bad_full_backref:1;
194 unsigned int crossing_stripes:1;
195 unsigned int wrong_chunk_type:1;
196 };
197
198 static inline struct extent_record* to_extent_record(struct list_head *entry)
199 {
200 return container_of(entry, struct extent_record, list);
201 }
202
203 struct inode_backref {
204 struct list_head list;
205 unsigned int found_dir_item:1;
206 unsigned int found_dir_index:1;
207 unsigned int found_inode_ref:1;
208 u8 filetype;
209 u8 ref_type;
210 int errors;
211 u64 dir;
212 u64 index;
213 u16 namelen;
214 char name[0];
215 };
216
217 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
218 {
219 return list_entry(entry, struct inode_backref, list);
220 }
221
222 struct root_item_record {
223 struct list_head list;
224 u64 objectid;
225 u64 bytenr;
226 u64 last_snapshot;
227 u8 level;
228 u8 drop_level;
229 int level_size;
230 struct btrfs_key drop_key;
231 };
232
233 #define REF_ERR_NO_DIR_ITEM (1 << 0)
234 #define REF_ERR_NO_DIR_INDEX (1 << 1)
235 #define REF_ERR_NO_INODE_REF (1 << 2)
236 #define REF_ERR_DUP_DIR_ITEM (1 << 3)
237 #define REF_ERR_DUP_DIR_INDEX (1 << 4)
238 #define REF_ERR_DUP_INODE_REF (1 << 5)
239 #define REF_ERR_INDEX_UNMATCH (1 << 6)
240 #define REF_ERR_FILETYPE_UNMATCH (1 << 7)
241 #define REF_ERR_NAME_TOO_LONG (1 << 8) // 100
242 #define REF_ERR_NO_ROOT_REF (1 << 9)
243 #define REF_ERR_NO_ROOT_BACKREF (1 << 10)
244 #define REF_ERR_DUP_ROOT_REF (1 << 11)
245 #define REF_ERR_DUP_ROOT_BACKREF (1 << 12)
246
247 struct file_extent_hole {
248 struct rb_node node;
249 u64 start;
250 u64 len;
251 };
252
253 struct inode_record {
254 struct list_head backrefs;
255 unsigned int checked:1;
256 unsigned int merging:1;
257 unsigned int found_inode_item:1;
258 unsigned int found_dir_item:1;
259 unsigned int found_file_extent:1;
260 unsigned int found_csum_item:1;
261 unsigned int some_csum_missing:1;
262 unsigned int nodatasum:1;
263 int errors;
264
265 u64 ino;
266 u32 nlink;
267 u32 imode;
268 u64 isize;
269 u64 nbytes;
270
271 u32 found_link;
272 u64 found_size;
273 u64 extent_start;
274 u64 extent_end;
275 struct rb_root holes;
276 struct list_head orphan_extents;
277
278 u32 refs;
279 };
280
281 #define I_ERR_NO_INODE_ITEM (1 << 0)
282 #define I_ERR_NO_ORPHAN_ITEM (1 << 1)
283 #define I_ERR_DUP_INODE_ITEM (1 << 2)
284 #define I_ERR_DUP_DIR_INDEX (1 << 3)
285 #define I_ERR_ODD_DIR_ITEM (1 << 4)
286 #define I_ERR_ODD_FILE_EXTENT (1 << 5)
287 #define I_ERR_BAD_FILE_EXTENT (1 << 6)
288 #define I_ERR_FILE_EXTENT_OVERLAP (1 << 7)
289 #define I_ERR_FILE_EXTENT_DISCOUNT (1 << 8) // 100
290 #define I_ERR_DIR_ISIZE_WRONG (1 << 9)
291 #define I_ERR_FILE_NBYTES_WRONG (1 << 10) // 400
292 #define I_ERR_ODD_CSUM_ITEM (1 << 11)
293 #define I_ERR_SOME_CSUM_MISSING (1 << 12)
294 #define I_ERR_LINK_COUNT_WRONG (1 << 13)
295 #define I_ERR_FILE_EXTENT_ORPHAN (1 << 14)
296
297 struct root_backref {
298 struct list_head list;
299 unsigned int found_dir_item:1;
300 unsigned int found_dir_index:1;
301 unsigned int found_back_ref:1;
302 unsigned int found_forward_ref:1;
303 unsigned int reachable:1;
304 int errors;
305 u64 ref_root;
306 u64 dir;
307 u64 index;
308 u16 namelen;
309 char name[0];
310 };
311
312 static inline struct root_backref* to_root_backref(struct list_head *entry)
313 {
314 return list_entry(entry, struct root_backref, list);
315 }
316
317 struct root_record {
318 struct list_head backrefs;
319 struct cache_extent cache;
320 unsigned int found_root_item:1;
321 u64 objectid;
322 u32 found_ref;
323 };
324
325 struct ptr_node {
326 struct cache_extent cache;
327 void *data;
328 };
329
330 struct shared_node {
331 struct cache_extent cache;
332 struct cache_tree root_cache;
333 struct cache_tree inode_cache;
334 struct inode_record *current;
335 u32 refs;
336 };
337
338 struct block_info {
339 u64 start;
340 u32 size;
341 };
342
343 struct walk_control {
344 struct cache_tree shared;
345 struct shared_node *nodes[BTRFS_MAX_LEVEL];
346 int active_node;
347 int root_level;
348 };
349
350 struct bad_item {
351 struct btrfs_key key;
352 u64 root_id;
353 struct list_head list;
354 };
355
356 struct extent_entry {
357 u64 bytenr;
358 u64 bytes;
359 int count;
360 int broken;
361 struct list_head list;
362 };
363
364 struct root_item_info {
365 /* level of the root */
366 u8 level;
367 /* number of nodes at this level, must be 1 for a root */
368 int node_count;
369 u64 bytenr;
370 u64 gen;
371 struct cache_extent cache_extent;
372 };
373
374 /*
375 * Error bit for low memory mode check.
376 *
377 * Currently no caller cares about it yet. Just internal use for error
378 * classification.
379 */
380 #define BACKREF_MISSING (1 << 0) /* Backref missing in extent tree */
381 #define BACKREF_MISMATCH (1 << 1) /* Backref exists but does not match */
382 #define BYTES_UNALIGNED (1 << 2) /* Some bytes are not aligned */
383 #define REFERENCER_MISSING (1 << 3) /* Referencer not found */
384 #define REFERENCER_MISMATCH (1 << 4) /* Referenceer found but does not match */
385 #define CROSSING_STRIPE_BOUNDARY (1 << 4) /* For kernel scrub workaround */
386 #define ITEM_SIZE_MISMATCH (1 << 5) /* Bad item size */
387 #define UNKNOWN_TYPE (1 << 6) /* Unknown type */
388 #define ACCOUNTING_MISMATCH (1 << 7) /* Used space accounting error */
389 #define CHUNK_TYPE_MISMATCH (1 << 8)
390
391 static void *print_status_check(void *p)
392 {
393 struct task_ctx *priv = p;
394 const char work_indicator[] = { '.', 'o', 'O', 'o' };
395 uint32_t count = 0;
396 static char *task_position_string[] = {
397 "checking extents",
398 "checking free space cache",
399 "checking fs roots",
400 };
401
402 task_period_start(priv->info, 1000 /* 1s */);
403
404 if (priv->tp == TASK_NOTHING)
405 return NULL;
406
407 while (1) {
408 printf("%s [%c]\r", task_position_string[priv->tp],
409 work_indicator[count % 4]);
410 count++;
411 fflush(stdout);
412 task_period_wait(priv->info);
413 }
414 return NULL;
415 }
416
417 static int print_status_return(void *p)
418 {
419 printf("\n");
420 fflush(stdout);
421
422 return 0;
423 }
424
425 static enum btrfs_check_mode parse_check_mode(const char *str)
426 {
427 if (strcmp(str, "lowmem") == 0)
428 return CHECK_MODE_LOWMEM;
429 if (strcmp(str, "orig") == 0)
430 return CHECK_MODE_ORIGINAL;
431 if (strcmp(str, "original") == 0)
432 return CHECK_MODE_ORIGINAL;
433
434 return CHECK_MODE_UNKNOWN;
435 }
436
437 /* Compatible function to allow reuse of old codes */
438 static u64 first_extent_gap(struct rb_root *holes)
439 {
440 struct file_extent_hole *hole;
441
442 if (RB_EMPTY_ROOT(holes))
443 return (u64)-1;
444
445 hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
446 return hole->start;
447 }
448
449 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
450 {
451 struct file_extent_hole *hole1;
452 struct file_extent_hole *hole2;
453
454 hole1 = rb_entry(node1, struct file_extent_hole, node);
455 hole2 = rb_entry(node2, struct file_extent_hole, node);
456
457 if (hole1->start > hole2->start)
458 return -1;
459 if (hole1->start < hole2->start)
460 return 1;
461 /* Now hole1->start == hole2->start */
462 if (hole1->len >= hole2->len)
463 /*
464 * Hole 1 will be merge center
465 * Same hole will be merged later
466 */
467 return -1;
468 /* Hole 2 will be merge center */
469 return 1;
470 }
471
472 /*
473 * Add a hole to the record
474 *
475 * This will do hole merge for copy_file_extent_holes(),
476 * which will ensure there won't be continuous holes.
477 */
478 static int add_file_extent_hole(struct rb_root *holes,
479 u64 start, u64 len)
480 {
481 struct file_extent_hole *hole;
482 struct file_extent_hole *prev = NULL;
483 struct file_extent_hole *next = NULL;
484
485 hole = malloc(sizeof(*hole));
486 if (!hole)
487 return -ENOMEM;
488 hole->start = start;
489 hole->len = len;
490 /* Since compare will not return 0, no -EEXIST will happen */
491 rb_insert(holes, &hole->node, compare_hole);
492
493 /* simple merge with previous hole */
494 if (rb_prev(&hole->node))
495 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
496 node);
497 if (prev && prev->start + prev->len >= hole->start) {
498 hole->len = hole->start + hole->len - prev->start;
499 hole->start = prev->start;
500 rb_erase(&prev->node, holes);
501 free(prev);
502 prev = NULL;
503 }
504
505 /* iterate merge with next holes */
506 while (1) {
507 if (!rb_next(&hole->node))
508 break;
509 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
510 node);
511 if (hole->start + hole->len >= next->start) {
512 if (hole->start + hole->len <= next->start + next->len)
513 hole->len = next->start + next->len -
514 hole->start;
515 rb_erase(&next->node, holes);
516 free(next);
517 next = NULL;
518 } else
519 break;
520 }
521 return 0;
522 }
523
524 static int compare_hole_range(struct rb_node *node, void *data)
525 {
526 struct file_extent_hole *hole;
527 u64 start;
528
529 hole = (struct file_extent_hole *)data;
530 start = hole->start;
531
532 hole = rb_entry(node, struct file_extent_hole, node);
533 if (start < hole->start)
534 return -1;
535 if (start >= hole->start && start < hole->start + hole->len)
536 return 0;
537 return 1;
538 }
539
540 /*
541 * Delete a hole in the record
542 *
543 * This will do the hole split and is much restrict than add.
544 */
545 static int del_file_extent_hole(struct rb_root *holes,
546 u64 start, u64 len)
547 {
548 struct file_extent_hole *hole;
549 struct file_extent_hole tmp;
550 u64 prev_start = 0;
551 u64 prev_len = 0;
552 u64 next_start = 0;
553 u64 next_len = 0;
554 struct rb_node *node;
555 int have_prev = 0;
556 int have_next = 0;
557 int ret = 0;
558
559 tmp.start = start;
560 tmp.len = len;
561 node = rb_search(holes, &tmp, compare_hole_range, NULL);
562 if (!node)
563 return -EEXIST;
564 hole = rb_entry(node, struct file_extent_hole, node);
565 if (start + len > hole->start + hole->len)
566 return -EEXIST;
567
568 /*
569 * Now there will be no overlap, delete the hole and re-add the
570 * split(s) if they exists.
571 */
572 if (start > hole->start) {
573 prev_start = hole->start;
574 prev_len = start - hole->start;
575 have_prev = 1;
576 }
577 if (hole->start + hole->len > start + len) {
578 next_start = start + len;
579 next_len = hole->start + hole->len - start - len;
580 have_next = 1;
581 }
582 rb_erase(node, holes);
583 free(hole);
584 if (have_prev) {
585 ret = add_file_extent_hole(holes, prev_start, prev_len);
586 if (ret < 0)
587 return ret;
588 }
589 if (have_next) {
590 ret = add_file_extent_hole(holes, next_start, next_len);
591 if (ret < 0)
592 return ret;
593 }
594 return 0;
595 }
596
597 static int copy_file_extent_holes(struct rb_root *dst,
598 struct rb_root *src)
599 {
600 struct file_extent_hole *hole;
601 struct rb_node *node;
602 int ret = 0;
603
604 node = rb_first(src);
605 while (node) {
606 hole = rb_entry(node, struct file_extent_hole, node);
607 ret = add_file_extent_hole(dst, hole->start, hole->len);
608 if (ret)
609 break;
610 node = rb_next(node);
611 }
612 return ret;
613 }
614
615 static void free_file_extent_holes(struct rb_root *holes)
616 {
617 struct rb_node *node;
618 struct file_extent_hole *hole;
619
620 node = rb_first(holes);
621 while (node) {
622 hole = rb_entry(node, struct file_extent_hole, node);
623 rb_erase(node, holes);
624 free(hole);
625 node = rb_first(holes);
626 }
627 }
628
629 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
630
631 static void record_root_in_trans(struct btrfs_trans_handle *trans,
632 struct btrfs_root *root)
633 {
634 if (root->last_trans != trans->transid) {
635 root->track_dirty = 1;
636 root->last_trans = trans->transid;
637 root->commit_root = root->node;
638 extent_buffer_get(root->node);
639 }
640 }
641
642 static u8 imode_to_type(u32 imode)
643 {
644 #define S_SHIFT 12
645 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
646 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
647 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
648 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
649 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
650 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
651 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
652 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
653 };
654
655 return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
656 #undef S_SHIFT
657 }
658
659 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
660 {
661 struct device_record *rec1;
662 struct device_record *rec2;
663
664 rec1 = rb_entry(node1, struct device_record, node);
665 rec2 = rb_entry(node2, struct device_record, node);
666 if (rec1->devid > rec2->devid)
667 return -1;
668 else if (rec1->devid < rec2->devid)
669 return 1;
670 else
671 return 0;
672 }
673
674 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
675 {
676 struct inode_record *rec;
677 struct inode_backref *backref;
678 struct inode_backref *orig;
679 struct inode_backref *tmp;
680 struct orphan_data_extent *src_orphan;
681 struct orphan_data_extent *dst_orphan;
682 struct rb_node *rb;
683 size_t size;
684 int ret;
685
686 rec = malloc(sizeof(*rec));
687 if (!rec)
688 return ERR_PTR(-ENOMEM);
689 memcpy(rec, orig_rec, sizeof(*rec));
690 rec->refs = 1;
691 INIT_LIST_HEAD(&rec->backrefs);
692 INIT_LIST_HEAD(&rec->orphan_extents);
693 rec->holes = RB_ROOT;
694
695 list_for_each_entry(orig, &orig_rec->backrefs, list) {
696 size = sizeof(*orig) + orig->namelen + 1;
697 backref = malloc(size);
698 if (!backref) {
699 ret = -ENOMEM;
700 goto cleanup;
701 }
702 memcpy(backref, orig, size);
703 list_add_tail(&backref->list, &rec->backrefs);
704 }
705 list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
706 dst_orphan = malloc(sizeof(*dst_orphan));
707 if (!dst_orphan) {
708 ret = -ENOMEM;
709 goto cleanup;
710 }
711 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
712 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
713 }
714 ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
715 if (ret < 0)
716 goto cleanup_rb;
717
718 return rec;
719
720 cleanup_rb:
721 rb = rb_first(&rec->holes);
722 while (rb) {
723 struct file_extent_hole *hole;
724
725 hole = rb_entry(rb, struct file_extent_hole, node);
726 rb = rb_next(rb);
727 free(hole);
728 }
729
730 cleanup:
731 if (!list_empty(&rec->backrefs))
732 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
733 list_del(&orig->list);
734 free(orig);
735 }
736
737 if (!list_empty(&rec->orphan_extents))
738 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
739 list_del(&orig->list);
740 free(orig);
741 }
742
743 free(rec);
744
745 return ERR_PTR(ret);
746 }
747
748 static void print_orphan_data_extents(struct list_head *orphan_extents,
749 u64 objectid)
750 {
751 struct orphan_data_extent *orphan;
752
753 if (list_empty(orphan_extents))
754 return;
755 printf("The following data extent is lost in tree %llu:\n",
756 objectid);
757 list_for_each_entry(orphan, orphan_extents, list) {
758 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
759 orphan->objectid, orphan->offset, orphan->disk_bytenr,
760 orphan->disk_len);
761 }
762 }
763
764 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
765 {
766 u64 root_objectid = root->root_key.objectid;
767 int errors = rec->errors;
768
769 if (!errors)
770 return;
771 /* reloc root errors, we print its corresponding fs root objectid*/
772 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
773 root_objectid = root->root_key.offset;
774 fprintf(stderr, "reloc");
775 }
776 fprintf(stderr, "root %llu inode %llu errors %x",
777 (unsigned long long) root_objectid,
778 (unsigned long long) rec->ino, rec->errors);
779
780 if (errors & I_ERR_NO_INODE_ITEM)
781 fprintf(stderr, ", no inode item");
782 if (errors & I_ERR_NO_ORPHAN_ITEM)
783 fprintf(stderr, ", no orphan item");
784 if (errors & I_ERR_DUP_INODE_ITEM)
785 fprintf(stderr, ", dup inode item");
786 if (errors & I_ERR_DUP_DIR_INDEX)
787 fprintf(stderr, ", dup dir index");
788 if (errors & I_ERR_ODD_DIR_ITEM)
789 fprintf(stderr, ", odd dir item");
790 if (errors & I_ERR_ODD_FILE_EXTENT)
791 fprintf(stderr, ", odd file extent");
792 if (errors & I_ERR_BAD_FILE_EXTENT)
793 fprintf(stderr, ", bad file extent");
794 if (errors & I_ERR_FILE_EXTENT_OVERLAP)
795 fprintf(stderr, ", file extent overlap");
796 if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
797 fprintf(stderr, ", file extent discount");
798 if (errors & I_ERR_DIR_ISIZE_WRONG)
799 fprintf(stderr, ", dir isize wrong");
800 if (errors & I_ERR_FILE_NBYTES_WRONG)
801 fprintf(stderr, ", nbytes wrong");
802 if (errors & I_ERR_ODD_CSUM_ITEM)
803 fprintf(stderr, ", odd csum item");
804 if (errors & I_ERR_SOME_CSUM_MISSING)
805 fprintf(stderr, ", some csum missing");
806 if (errors & I_ERR_LINK_COUNT_WRONG)
807 fprintf(stderr, ", link count wrong");
808 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
809 fprintf(stderr, ", orphan file extent");
810 fprintf(stderr, "\n");
811 /* Print the orphan extents if needed */
812 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
813 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
814
815 /* Print the holes if needed */
816 if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
817 struct file_extent_hole *hole;
818 struct rb_node *node;
819 int found = 0;
820
821 node = rb_first(&rec->holes);
822 fprintf(stderr, "Found file extent holes:\n");
823 while (node) {
824 found = 1;
825 hole = rb_entry(node, struct file_extent_hole, node);
826 fprintf(stderr, "\tstart: %llu, len: %llu\n",
827 hole->start, hole->len);
828 node = rb_next(node);
829 }
830 if (!found)
831 fprintf(stderr, "\tstart: 0, len: %llu\n",
832 round_up(rec->isize, root->sectorsize));
833 }
834 }
835
836 static void print_ref_error(int errors)
837 {
838 if (errors & REF_ERR_NO_DIR_ITEM)
839 fprintf(stderr, ", no dir item");
840 if (errors & REF_ERR_NO_DIR_INDEX)
841 fprintf(stderr, ", no dir index");
842 if (errors & REF_ERR_NO_INODE_REF)
843 fprintf(stderr, ", no inode ref");
844 if (errors & REF_ERR_DUP_DIR_ITEM)
845 fprintf(stderr, ", dup dir item");
846 if (errors & REF_ERR_DUP_DIR_INDEX)
847 fprintf(stderr, ", dup dir index");
848 if (errors & REF_ERR_DUP_INODE_REF)
849 fprintf(stderr, ", dup inode ref");
850 if (errors & REF_ERR_INDEX_UNMATCH)
851 fprintf(stderr, ", index mismatch");
852 if (errors & REF_ERR_FILETYPE_UNMATCH)
853 fprintf(stderr, ", filetype mismatch");
854 if (errors & REF_ERR_NAME_TOO_LONG)
855 fprintf(stderr, ", name too long");
856 if (errors & REF_ERR_NO_ROOT_REF)
857 fprintf(stderr, ", no root ref");
858 if (errors & REF_ERR_NO_ROOT_BACKREF)
859 fprintf(stderr, ", no root backref");
860 if (errors & REF_ERR_DUP_ROOT_REF)
861 fprintf(stderr, ", dup root ref");
862 if (errors & REF_ERR_DUP_ROOT_BACKREF)
863 fprintf(stderr, ", dup root backref");
864 fprintf(stderr, "\n");
865 }
866
867 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
868 u64 ino, int mod)
869 {
870 struct ptr_node *node;
871 struct cache_extent *cache;
872 struct inode_record *rec = NULL;
873 int ret;
874
875 cache = lookup_cache_extent(inode_cache, ino, 1);
876 if (cache) {
877 node = container_of(cache, struct ptr_node, cache);
878 rec = node->data;
879 if (mod && rec->refs > 1) {
880 node->data = clone_inode_rec(rec);
881 if (IS_ERR(node->data))
882 return node->data;
883 rec->refs--;
884 rec = node->data;
885 }
886 } else if (mod) {
887 rec = calloc(1, sizeof(*rec));
888 if (!rec)
889 return ERR_PTR(-ENOMEM);
890 rec->ino = ino;
891 rec->extent_start = (u64)-1;
892 rec->refs = 1;
893 INIT_LIST_HEAD(&rec->backrefs);
894 INIT_LIST_HEAD(&rec->orphan_extents);
895 rec->holes = RB_ROOT;
896
897 node = malloc(sizeof(*node));
898 if (!node) {
899 free(rec);
900 return ERR_PTR(-ENOMEM);
901 }
902 node->cache.start = ino;
903 node->cache.size = 1;
904 node->data = rec;
905
906 if (ino == BTRFS_FREE_INO_OBJECTID)
907 rec->found_link = 1;
908
909 ret = insert_cache_extent(inode_cache, &node->cache);
910 if (ret)
911 return ERR_PTR(-EEXIST);
912 }
913 return rec;
914 }
915
916 static void free_orphan_data_extents(struct list_head *orphan_extents)
917 {
918 struct orphan_data_extent *orphan;
919
920 while (!list_empty(orphan_extents)) {
921 orphan = list_entry(orphan_extents->next,
922 struct orphan_data_extent, list);
923 list_del(&orphan->list);
924 free(orphan);
925 }
926 }
927
928 static void free_inode_rec(struct inode_record *rec)
929 {
930 struct inode_backref *backref;
931
932 if (--rec->refs > 0)
933 return;
934
935 while (!list_empty(&rec->backrefs)) {
936 backref = to_inode_backref(rec->backrefs.next);
937 list_del(&backref->list);
938 free(backref);
939 }
940 free_orphan_data_extents(&rec->orphan_extents);
941 free_file_extent_holes(&rec->holes);
942 free(rec);
943 }
944
945 static int can_free_inode_rec(struct inode_record *rec)
946 {
947 if (!rec->errors && rec->checked && rec->found_inode_item &&
948 rec->nlink == rec->found_link && list_empty(&rec->backrefs))
949 return 1;
950 return 0;
951 }
952
953 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
954 struct inode_record *rec)
955 {
956 struct cache_extent *cache;
957 struct inode_backref *tmp, *backref;
958 struct ptr_node *node;
959 u8 filetype;
960
961 if (!rec->found_inode_item)
962 return;
963
964 filetype = imode_to_type(rec->imode);
965 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
966 if (backref->found_dir_item && backref->found_dir_index) {
967 if (backref->filetype != filetype)
968 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
969 if (!backref->errors && backref->found_inode_ref &&
970 rec->nlink == rec->found_link) {
971 list_del(&backref->list);
972 free(backref);
973 }
974 }
975 }
976
977 if (!rec->checked || rec->merging)
978 return;
979
980 if (S_ISDIR(rec->imode)) {
981 if (rec->found_size != rec->isize)
982 rec->errors |= I_ERR_DIR_ISIZE_WRONG;
983 if (rec->found_file_extent)
984 rec->errors |= I_ERR_ODD_FILE_EXTENT;
985 } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
986 if (rec->found_dir_item)
987 rec->errors |= I_ERR_ODD_DIR_ITEM;
988 if (rec->found_size != rec->nbytes)
989 rec->errors |= I_ERR_FILE_NBYTES_WRONG;
990 if (rec->nlink > 0 && !no_holes &&
991 (rec->extent_end < rec->isize ||
992 first_extent_gap(&rec->holes) < rec->isize))
993 rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
994 }
995
996 if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
997 if (rec->found_csum_item && rec->nodatasum)
998 rec->errors |= I_ERR_ODD_CSUM_ITEM;
999 if (rec->some_csum_missing && !rec->nodatasum)
1000 rec->errors |= I_ERR_SOME_CSUM_MISSING;
1001 }
1002
1003 BUG_ON(rec->refs != 1);
1004 if (can_free_inode_rec(rec)) {
1005 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
1006 node = container_of(cache, struct ptr_node, cache);
1007 BUG_ON(node->data != rec);
1008 remove_cache_extent(inode_cache, &node->cache);
1009 free(node);
1010 free_inode_rec(rec);
1011 }
1012 }
1013
1014 static int check_orphan_item(struct btrfs_root *root, u64 ino)
1015 {
1016 struct btrfs_path path;
1017 struct btrfs_key key;
1018 int ret;
1019
1020 key.objectid = BTRFS_ORPHAN_OBJECTID;
1021 key.type = BTRFS_ORPHAN_ITEM_KEY;
1022 key.offset = ino;
1023
1024 btrfs_init_path(&path);
1025 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1026 btrfs_release_path(&path);
1027 if (ret > 0)
1028 ret = -ENOENT;
1029 return ret;
1030 }
1031
1032 static int process_inode_item(struct extent_buffer *eb,
1033 int slot, struct btrfs_key *key,
1034 struct shared_node *active_node)
1035 {
1036 struct inode_record *rec;
1037 struct btrfs_inode_item *item;
1038
1039 rec = active_node->current;
1040 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1041 if (rec->found_inode_item) {
1042 rec->errors |= I_ERR_DUP_INODE_ITEM;
1043 return 1;
1044 }
1045 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
1046 rec->nlink = btrfs_inode_nlink(eb, item);
1047 rec->isize = btrfs_inode_size(eb, item);
1048 rec->nbytes = btrfs_inode_nbytes(eb, item);
1049 rec->imode = btrfs_inode_mode(eb, item);
1050 if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
1051 rec->nodatasum = 1;
1052 rec->found_inode_item = 1;
1053 if (rec->nlink == 0)
1054 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
1055 maybe_free_inode_rec(&active_node->inode_cache, rec);
1056 return 0;
1057 }
1058
1059 static struct inode_backref *get_inode_backref(struct inode_record *rec,
1060 const char *name,
1061 int namelen, u64 dir)
1062 {
1063 struct inode_backref *backref;
1064
1065 list_for_each_entry(backref, &rec->backrefs, list) {
1066 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
1067 break;
1068 if (backref->dir != dir || backref->namelen != namelen)
1069 continue;
1070 if (memcmp(name, backref->name, namelen))
1071 continue;
1072 return backref;
1073 }
1074
1075 backref = malloc(sizeof(*backref) + namelen + 1);
1076 if (!backref)
1077 return NULL;
1078 memset(backref, 0, sizeof(*backref));
1079 backref->dir = dir;
1080 backref->namelen = namelen;
1081 memcpy(backref->name, name, namelen);
1082 backref->name[namelen] = '\0';
1083 list_add_tail(&backref->list, &rec->backrefs);
1084 return backref;
1085 }
1086
1087 static int add_inode_backref(struct cache_tree *inode_cache,
1088 u64 ino, u64 dir, u64 index,
1089 const char *name, int namelen,
1090 u8 filetype, u8 itemtype, int errors)
1091 {
1092 struct inode_record *rec;
1093 struct inode_backref *backref;
1094
1095 rec = get_inode_rec(inode_cache, ino, 1);
1096 BUG_ON(IS_ERR(rec));
1097 backref = get_inode_backref(rec, name, namelen, dir);
1098 BUG_ON(!backref);
1099 if (errors)
1100 backref->errors |= errors;
1101 if (itemtype == BTRFS_DIR_INDEX_KEY) {
1102 if (backref->found_dir_index)
1103 backref->errors |= REF_ERR_DUP_DIR_INDEX;
1104 if (backref->found_inode_ref && backref->index != index)
1105 backref->errors |= REF_ERR_INDEX_UNMATCH;
1106 if (backref->found_dir_item && backref->filetype != filetype)
1107 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1108
1109 backref->index = index;
1110 backref->filetype = filetype;
1111 backref->found_dir_index = 1;
1112 } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1113 rec->found_link++;
1114 if (backref->found_dir_item)
1115 backref->errors |= REF_ERR_DUP_DIR_ITEM;
1116 if (backref->found_dir_index && backref->filetype != filetype)
1117 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1118
1119 backref->filetype = filetype;
1120 backref->found_dir_item = 1;
1121 } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1122 (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1123 if (backref->found_inode_ref)
1124 backref->errors |= REF_ERR_DUP_INODE_REF;
1125 if (backref->found_dir_index && backref->index != index)
1126 backref->errors |= REF_ERR_INDEX_UNMATCH;
1127 else
1128 backref->index = index;
1129
1130 backref->ref_type = itemtype;
1131 backref->found_inode_ref = 1;
1132 } else {
1133 BUG_ON(1);
1134 }
1135
1136 maybe_free_inode_rec(inode_cache, rec);
1137 return 0;
1138 }
1139
1140 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1141 struct cache_tree *dst_cache)
1142 {
1143 struct inode_backref *backref;
1144 u32 dir_count = 0;
1145 int ret = 0;
1146
1147 dst->merging = 1;
1148 list_for_each_entry(backref, &src->backrefs, list) {
1149 if (backref->found_dir_index) {
1150 add_inode_backref(dst_cache, dst->ino, backref->dir,
1151 backref->index, backref->name,
1152 backref->namelen, backref->filetype,
1153 BTRFS_DIR_INDEX_KEY, backref->errors);
1154 }
1155 if (backref->found_dir_item) {
1156 dir_count++;
1157 add_inode_backref(dst_cache, dst->ino,
1158 backref->dir, 0, backref->name,
1159 backref->namelen, backref->filetype,
1160 BTRFS_DIR_ITEM_KEY, backref->errors);
1161 }
1162 if (backref->found_inode_ref) {
1163 add_inode_backref(dst_cache, dst->ino,
1164 backref->dir, backref->index,
1165 backref->name, backref->namelen, 0,
1166 backref->ref_type, backref->errors);
1167 }
1168 }
1169
1170 if (src->found_dir_item)
1171 dst->found_dir_item = 1;
1172 if (src->found_file_extent)
1173 dst->found_file_extent = 1;
1174 if (src->found_csum_item)
1175 dst->found_csum_item = 1;
1176 if (src->some_csum_missing)
1177 dst->some_csum_missing = 1;
1178 if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1179 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1180 if (ret < 0)
1181 return ret;
1182 }
1183
1184 BUG_ON(src->found_link < dir_count);
1185 dst->found_link += src->found_link - dir_count;
1186 dst->found_size += src->found_size;
1187 if (src->extent_start != (u64)-1) {
1188 if (dst->extent_start == (u64)-1) {
1189 dst->extent_start = src->extent_start;
1190 dst->extent_end = src->extent_end;
1191 } else {
1192 if (dst->extent_end > src->extent_start)
1193 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1194 else if (dst->extent_end < src->extent_start) {
1195 ret = add_file_extent_hole(&dst->holes,
1196 dst->extent_end,
1197 src->extent_start - dst->extent_end);
1198 }
1199 if (dst->extent_end < src->extent_end)
1200 dst->extent_end = src->extent_end;
1201 }
1202 }
1203
1204 dst->errors |= src->errors;
1205 if (src->found_inode_item) {
1206 if (!dst->found_inode_item) {
1207 dst->nlink = src->nlink;
1208 dst->isize = src->isize;
1209 dst->nbytes = src->nbytes;
1210 dst->imode = src->imode;
1211 dst->nodatasum = src->nodatasum;
1212 dst->found_inode_item = 1;
1213 } else {
1214 dst->errors |= I_ERR_DUP_INODE_ITEM;
1215 }
1216 }
1217 dst->merging = 0;
1218
1219 return 0;
1220 }
1221
1222 static int splice_shared_node(struct shared_node *src_node,
1223 struct shared_node *dst_node)
1224 {
1225 struct cache_extent *cache;
1226 struct ptr_node *node, *ins;
1227 struct cache_tree *src, *dst;
1228 struct inode_record *rec, *conflict;
1229 u64 current_ino = 0;
1230 int splice = 0;
1231 int ret;
1232
1233 if (--src_node->refs == 0)
1234 splice = 1;
1235 if (src_node->current)
1236 current_ino = src_node->current->ino;
1237
1238 src = &src_node->root_cache;
1239 dst = &dst_node->root_cache;
1240 again:
1241 cache = search_cache_extent(src, 0);
1242 while (cache) {
1243 node = container_of(cache, struct ptr_node, cache);
1244 rec = node->data;
1245 cache = next_cache_extent(cache);
1246
1247 if (splice) {
1248 remove_cache_extent(src, &node->cache);
1249 ins = node;
1250 } else {
1251 ins = malloc(sizeof(*ins));
1252 BUG_ON(!ins);
1253 ins->cache.start = node->cache.start;
1254 ins->cache.size = node->cache.size;
1255 ins->data = rec;
1256 rec->refs++;
1257 }
1258 ret = insert_cache_extent(dst, &ins->cache);
1259 if (ret == -EEXIST) {
1260 conflict = get_inode_rec(dst, rec->ino, 1);
1261 BUG_ON(IS_ERR(conflict));
1262 merge_inode_recs(rec, conflict, dst);
1263 if (rec->checked) {
1264 conflict->checked = 1;
1265 if (dst_node->current == conflict)
1266 dst_node->current = NULL;
1267 }
1268 maybe_free_inode_rec(dst, conflict);
1269 free_inode_rec(rec);
1270 free(ins);
1271 } else {
1272 BUG_ON(ret);
1273 }
1274 }
1275
1276 if (src == &src_node->root_cache) {
1277 src = &src_node->inode_cache;
1278 dst = &dst_node->inode_cache;
1279 goto again;
1280 }
1281
1282 if (current_ino > 0 && (!dst_node->current ||
1283 current_ino > dst_node->current->ino)) {
1284 if (dst_node->current) {
1285 dst_node->current->checked = 1;
1286 maybe_free_inode_rec(dst, dst_node->current);
1287 }
1288 dst_node->current = get_inode_rec(dst, current_ino, 1);
1289 BUG_ON(IS_ERR(dst_node->current));
1290 }
1291 return 0;
1292 }
1293
1294 static void free_inode_ptr(struct cache_extent *cache)
1295 {
1296 struct ptr_node *node;
1297 struct inode_record *rec;
1298
1299 node = container_of(cache, struct ptr_node, cache);
1300 rec = node->data;
1301 free_inode_rec(rec);
1302 free(node);
1303 }
1304
1305 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1306
1307 static struct shared_node *find_shared_node(struct cache_tree *shared,
1308 u64 bytenr)
1309 {
1310 struct cache_extent *cache;
1311 struct shared_node *node;
1312
1313 cache = lookup_cache_extent(shared, bytenr, 1);
1314 if (cache) {
1315 node = container_of(cache, struct shared_node, cache);
1316 return node;
1317 }
1318 return NULL;
1319 }
1320
1321 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1322 {
1323 int ret;
1324 struct shared_node *node;
1325
1326 node = calloc(1, sizeof(*node));
1327 if (!node)
1328 return -ENOMEM;
1329 node->cache.start = bytenr;
1330 node->cache.size = 1;
1331 cache_tree_init(&node->root_cache);
1332 cache_tree_init(&node->inode_cache);
1333 node->refs = refs;
1334
1335 ret = insert_cache_extent(shared, &node->cache);
1336
1337 return ret;
1338 }
1339
1340 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1341 struct walk_control *wc, int level)
1342 {
1343 struct shared_node *node;
1344 struct shared_node *dest;
1345 int ret;
1346
1347 if (level == wc->active_node)
1348 return 0;
1349
1350 BUG_ON(wc->active_node <= level);
1351 node = find_shared_node(&wc->shared, bytenr);
1352 if (!node) {
1353 ret = add_shared_node(&wc->shared, bytenr, refs);
1354 BUG_ON(ret);
1355 node = find_shared_node(&wc->shared, bytenr);
1356 wc->nodes[level] = node;
1357 wc->active_node = level;
1358 return 0;
1359 }
1360
1361 if (wc->root_level == wc->active_node &&
1362 btrfs_root_refs(&root->root_item) == 0) {
1363 if (--node->refs == 0) {
1364 free_inode_recs_tree(&node->root_cache);
1365 free_inode_recs_tree(&node->inode_cache);
1366 remove_cache_extent(&wc->shared, &node->cache);
1367 free(node);
1368 }
1369 return 1;
1370 }
1371
1372 dest = wc->nodes[wc->active_node];
1373 splice_shared_node(node, dest);
1374 if (node->refs == 0) {
1375 remove_cache_extent(&wc->shared, &node->cache);
1376 free(node);
1377 }
1378 return 1;
1379 }
1380
1381 static int leave_shared_node(struct btrfs_root *root,
1382 struct walk_control *wc, int level)
1383 {
1384 struct shared_node *node;
1385 struct shared_node *dest;
1386 int i;
1387
1388 if (level == wc->root_level)
1389 return 0;
1390
1391 for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1392 if (wc->nodes[i])
1393 break;
1394 }
1395 BUG_ON(i >= BTRFS_MAX_LEVEL);
1396
1397 node = wc->nodes[wc->active_node];
1398 wc->nodes[wc->active_node] = NULL;
1399 wc->active_node = i;
1400
1401 dest = wc->nodes[wc->active_node];
1402 if (wc->active_node < wc->root_level ||
1403 btrfs_root_refs(&root->root_item) > 0) {
1404 BUG_ON(node->refs <= 1);
1405 splice_shared_node(node, dest);
1406 } else {
1407 BUG_ON(node->refs < 2);
1408 node->refs--;
1409 }
1410 return 0;
1411 }
1412
1413 /*
1414 * Returns:
1415 * < 0 - on error
1416 * 1 - if the root with id child_root_id is a child of root parent_root_id
1417 * 0 - if the root child_root_id isn't a child of the root parent_root_id but
1418 * has other root(s) as parent(s)
1419 * 2 - if the root child_root_id doesn't have any parent roots
1420 */
1421 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1422 u64 child_root_id)
1423 {
1424 struct btrfs_path path;
1425 struct btrfs_key key;
1426 struct extent_buffer *leaf;
1427 int has_parent = 0;
1428 int ret;
1429
1430 btrfs_init_path(&path);
1431
1432 key.objectid = parent_root_id;
1433 key.type = BTRFS_ROOT_REF_KEY;
1434 key.offset = child_root_id;
1435 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1436 0, 0);
1437 if (ret < 0)
1438 return ret;
1439 btrfs_release_path(&path);
1440 if (!ret)
1441 return 1;
1442
1443 key.objectid = child_root_id;
1444 key.type = BTRFS_ROOT_BACKREF_KEY;
1445 key.offset = 0;
1446 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1447 0, 0);
1448 if (ret < 0)
1449 goto out;
1450
1451 while (1) {
1452 leaf = path.nodes[0];
1453 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1454 ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1455 if (ret)
1456 break;
1457 leaf = path.nodes[0];
1458 }
1459
1460 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1461 if (key.objectid != child_root_id ||
1462 key.type != BTRFS_ROOT_BACKREF_KEY)
1463 break;
1464
1465 has_parent = 1;
1466
1467 if (key.offset == parent_root_id) {
1468 btrfs_release_path(&path);
1469 return 1;
1470 }
1471
1472 path.slots[0]++;
1473 }
1474 out:
1475 btrfs_release_path(&path);
1476 if (ret < 0)
1477 return ret;
1478 return has_parent ? 0 : 2;
1479 }
1480
1481 static int process_dir_item(struct extent_buffer *eb,
1482 int slot, struct btrfs_key *key,
1483 struct shared_node *active_node)
1484 {
1485 u32 total;
1486 u32 cur = 0;
1487 u32 len;
1488 u32 name_len;
1489 u32 data_len;
1490 int error;
1491 int nritems = 0;
1492 u8 filetype;
1493 struct btrfs_dir_item *di;
1494 struct inode_record *rec;
1495 struct cache_tree *root_cache;
1496 struct cache_tree *inode_cache;
1497 struct btrfs_key location;
1498 char namebuf[BTRFS_NAME_LEN];
1499
1500 root_cache = &active_node->root_cache;
1501 inode_cache = &active_node->inode_cache;
1502 rec = active_node->current;
1503 rec->found_dir_item = 1;
1504
1505 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1506 total = btrfs_item_size_nr(eb, slot);
1507 while (cur < total) {
1508 nritems++;
1509 btrfs_dir_item_key_to_cpu(eb, di, &location);
1510 name_len = btrfs_dir_name_len(eb, di);
1511 data_len = btrfs_dir_data_len(eb, di);
1512 filetype = btrfs_dir_type(eb, di);
1513
1514 rec->found_size += name_len;
1515 if (name_len <= BTRFS_NAME_LEN) {
1516 len = name_len;
1517 error = 0;
1518 } else {
1519 len = BTRFS_NAME_LEN;
1520 error = REF_ERR_NAME_TOO_LONG;
1521 }
1522 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1523
1524 if (location.type == BTRFS_INODE_ITEM_KEY) {
1525 add_inode_backref(inode_cache, location.objectid,
1526 key->objectid, key->offset, namebuf,
1527 len, filetype, key->type, error);
1528 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1529 add_inode_backref(root_cache, location.objectid,
1530 key->objectid, key->offset,
1531 namebuf, len, filetype,
1532 key->type, error);
1533 } else {
1534 fprintf(stderr, "invalid location in dir item %u\n",
1535 location.type);
1536 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1537 key->objectid, key->offset, namebuf,
1538 len, filetype, key->type, error);
1539 }
1540
1541 len = sizeof(*di) + name_len + data_len;
1542 di = (struct btrfs_dir_item *)((char *)di + len);
1543 cur += len;
1544 }
1545 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1546 rec->errors |= I_ERR_DUP_DIR_INDEX;
1547
1548 return 0;
1549 }
1550
1551 static int process_inode_ref(struct extent_buffer *eb,
1552 int slot, struct btrfs_key *key,
1553 struct shared_node *active_node)
1554 {
1555 u32 total;
1556 u32 cur = 0;
1557 u32 len;
1558 u32 name_len;
1559 u64 index;
1560 int error;
1561 struct cache_tree *inode_cache;
1562 struct btrfs_inode_ref *ref;
1563 char namebuf[BTRFS_NAME_LEN];
1564
1565 inode_cache = &active_node->inode_cache;
1566
1567 ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1568 total = btrfs_item_size_nr(eb, slot);
1569 while (cur < total) {
1570 name_len = btrfs_inode_ref_name_len(eb, ref);
1571 index = btrfs_inode_ref_index(eb, ref);
1572 if (name_len <= BTRFS_NAME_LEN) {
1573 len = name_len;
1574 error = 0;
1575 } else {
1576 len = BTRFS_NAME_LEN;
1577 error = REF_ERR_NAME_TOO_LONG;
1578 }
1579 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1580 add_inode_backref(inode_cache, key->objectid, key->offset,
1581 index, namebuf, len, 0, key->type, error);
1582
1583 len = sizeof(*ref) + name_len;
1584 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1585 cur += len;
1586 }
1587 return 0;
1588 }
1589
1590 static int process_inode_extref(struct extent_buffer *eb,
1591 int slot, struct btrfs_key *key,
1592 struct shared_node *active_node)
1593 {
1594 u32 total;
1595 u32 cur = 0;
1596 u32 len;
1597 u32 name_len;
1598 u64 index;
1599 u64 parent;
1600 int error;
1601 struct cache_tree *inode_cache;
1602 struct btrfs_inode_extref *extref;
1603 char namebuf[BTRFS_NAME_LEN];
1604
1605 inode_cache = &active_node->inode_cache;
1606
1607 extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1608 total = btrfs_item_size_nr(eb, slot);
1609 while (cur < total) {
1610 name_len = btrfs_inode_extref_name_len(eb, extref);
1611 index = btrfs_inode_extref_index(eb, extref);
1612 parent = btrfs_inode_extref_parent(eb, extref);
1613 if (name_len <= BTRFS_NAME_LEN) {
1614 len = name_len;
1615 error = 0;
1616 } else {
1617 len = BTRFS_NAME_LEN;
1618 error = REF_ERR_NAME_TOO_LONG;
1619 }
1620 read_extent_buffer(eb, namebuf,
1621 (unsigned long)(extref + 1), len);
1622 add_inode_backref(inode_cache, key->objectid, parent,
1623 index, namebuf, len, 0, key->type, error);
1624
1625 len = sizeof(*extref) + name_len;
1626 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1627 cur += len;
1628 }
1629 return 0;
1630
1631 }
1632
1633 static int count_csum_range(struct btrfs_root *root, u64 start,
1634 u64 len, u64 *found)
1635 {
1636 struct btrfs_key key;
1637 struct btrfs_path path;
1638 struct extent_buffer *leaf;
1639 int ret;
1640 size_t size;
1641 *found = 0;
1642 u64 csum_end;
1643 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1644
1645 btrfs_init_path(&path);
1646
1647 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1648 key.offset = start;
1649 key.type = BTRFS_EXTENT_CSUM_KEY;
1650
1651 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1652 &key, &path, 0, 0);
1653 if (ret < 0)
1654 goto out;
1655 if (ret > 0 && path.slots[0] > 0) {
1656 leaf = path.nodes[0];
1657 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1658 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1659 key.type == BTRFS_EXTENT_CSUM_KEY)
1660 path.slots[0]--;
1661 }
1662
1663 while (len > 0) {
1664 leaf = path.nodes[0];
1665 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1666 ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1667 if (ret > 0)
1668 break;
1669 else if (ret < 0)
1670 goto out;
1671 leaf = path.nodes[0];
1672 }
1673
1674 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1675 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1676 key.type != BTRFS_EXTENT_CSUM_KEY)
1677 break;
1678
1679 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1680 if (key.offset >= start + len)
1681 break;
1682
1683 if (key.offset > start)
1684 start = key.offset;
1685
1686 size = btrfs_item_size_nr(leaf, path.slots[0]);
1687 csum_end = key.offset + (size / csum_size) * root->sectorsize;
1688 if (csum_end > start) {
1689 size = min(csum_end - start, len);
1690 len -= size;
1691 start += size;
1692 *found += size;
1693 }
1694
1695 path.slots[0]++;
1696 }
1697 out:
1698 btrfs_release_path(&path);
1699 if (ret < 0)
1700 return ret;
1701 return 0;
1702 }
1703
1704 static int process_file_extent(struct btrfs_root *root,
1705 struct extent_buffer *eb,
1706 int slot, struct btrfs_key *key,
1707 struct shared_node *active_node)
1708 {
1709 struct inode_record *rec;
1710 struct btrfs_file_extent_item *fi;
1711 u64 num_bytes = 0;
1712 u64 disk_bytenr = 0;
1713 u64 extent_offset = 0;
1714 u64 mask = root->sectorsize - 1;
1715 int extent_type;
1716 int ret;
1717
1718 rec = active_node->current;
1719 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1720 rec->found_file_extent = 1;
1721
1722 if (rec->extent_start == (u64)-1) {
1723 rec->extent_start = key->offset;
1724 rec->extent_end = key->offset;
1725 }
1726
1727 if (rec->extent_end > key->offset)
1728 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1729 else if (rec->extent_end < key->offset) {
1730 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1731 key->offset - rec->extent_end);
1732 if (ret < 0)
1733 return ret;
1734 }
1735
1736 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1737 extent_type = btrfs_file_extent_type(eb, fi);
1738
1739 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1740 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1741 if (num_bytes == 0)
1742 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1743 rec->found_size += num_bytes;
1744 num_bytes = (num_bytes + mask) & ~mask;
1745 } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1746 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1747 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1748 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1749 extent_offset = btrfs_file_extent_offset(eb, fi);
1750 if (num_bytes == 0 || (num_bytes & mask))
1751 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1752 if (num_bytes + extent_offset >
1753 btrfs_file_extent_ram_bytes(eb, fi))
1754 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1755 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1756 (btrfs_file_extent_compression(eb, fi) ||
1757 btrfs_file_extent_encryption(eb, fi) ||
1758 btrfs_file_extent_other_encoding(eb, fi)))
1759 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1760 if (disk_bytenr > 0)
1761 rec->found_size += num_bytes;
1762 } else {
1763 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1764 }
1765 rec->extent_end = key->offset + num_bytes;
1766
1767 /*
1768 * The data reloc tree will copy full extents into its inode and then
1769 * copy the corresponding csums. Because the extent it copied could be
1770 * a preallocated extent that hasn't been written to yet there may be no
1771 * csums to copy, ergo we won't have csums for our file extent. This is
1772 * ok so just don't bother checking csums if the inode belongs to the
1773 * data reloc tree.
1774 */
1775 if (disk_bytenr > 0 &&
1776 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1777 u64 found;
1778 if (btrfs_file_extent_compression(eb, fi))
1779 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1780 else
1781 disk_bytenr += extent_offset;
1782
1783 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1784 if (ret < 0)
1785 return ret;
1786 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1787 if (found > 0)
1788 rec->found_csum_item = 1;
1789 if (found < num_bytes)
1790 rec->some_csum_missing = 1;
1791 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1792 if (found > 0)
1793 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1794 }
1795 }
1796 return 0;
1797 }
1798
1799 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1800 struct walk_control *wc)
1801 {
1802 struct btrfs_key key;
1803 u32 nritems;
1804 int i;
1805 int ret = 0;
1806 struct cache_tree *inode_cache;
1807 struct shared_node *active_node;
1808
1809 if (wc->root_level == wc->active_node &&
1810 btrfs_root_refs(&root->root_item) == 0)
1811 return 0;
1812
1813 active_node = wc->nodes[wc->active_node];
1814 inode_cache = &active_node->inode_cache;
1815 nritems = btrfs_header_nritems(eb);
1816 for (i = 0; i < nritems; i++) {
1817 btrfs_item_key_to_cpu(eb, &key, i);
1818
1819 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1820 continue;
1821 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1822 continue;
1823
1824 if (active_node->current == NULL ||
1825 active_node->current->ino < key.objectid) {
1826 if (active_node->current) {
1827 active_node->current->checked = 1;
1828 maybe_free_inode_rec(inode_cache,
1829 active_node->current);
1830 }
1831 active_node->current = get_inode_rec(inode_cache,
1832 key.objectid, 1);
1833 BUG_ON(IS_ERR(active_node->current));
1834 }
1835 switch (key.type) {
1836 case BTRFS_DIR_ITEM_KEY:
1837 case BTRFS_DIR_INDEX_KEY:
1838 ret = process_dir_item(eb, i, &key, active_node);
1839 break;
1840 case BTRFS_INODE_REF_KEY:
1841 ret = process_inode_ref(eb, i, &key, active_node);
1842 break;
1843 case BTRFS_INODE_EXTREF_KEY:
1844 ret = process_inode_extref(eb, i, &key, active_node);
1845 break;
1846 case BTRFS_INODE_ITEM_KEY:
1847 ret = process_inode_item(eb, i, &key, active_node);
1848 break;
1849 case BTRFS_EXTENT_DATA_KEY:
1850 ret = process_file_extent(root, eb, i, &key,
1851 active_node);
1852 break;
1853 default:
1854 break;
1855 };
1856 }
1857 return ret;
1858 }
1859
1860 struct node_refs {
1861 u64 bytenr[BTRFS_MAX_LEVEL];
1862 u64 refs[BTRFS_MAX_LEVEL];
1863 int need_check[BTRFS_MAX_LEVEL];
1864 };
1865
1866 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
1867 struct node_refs *nrefs, u64 level);
1868 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1869 unsigned int ext_ref);
1870
1871 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
1872 struct node_refs *nrefs, int *level, int ext_ref)
1873 {
1874 struct extent_buffer *cur = path->nodes[0];
1875 struct btrfs_key key;
1876 u64 cur_bytenr;
1877 u32 nritems;
1878 u64 first_ino = 0;
1879 int root_level = btrfs_header_level(root->node);
1880 int i;
1881 int ret = 0; /* Final return value */
1882 int err = 0; /* Positive error bitmap */
1883
1884 cur_bytenr = cur->start;
1885
1886 /* skip to first inode item or the first inode number change */
1887 nritems = btrfs_header_nritems(cur);
1888 for (i = 0; i < nritems; i++) {
1889 btrfs_item_key_to_cpu(cur, &key, i);
1890 if (i == 0)
1891 first_ino = key.objectid;
1892 if (key.type == BTRFS_INODE_ITEM_KEY ||
1893 (first_ino && first_ino != key.objectid))
1894 break;
1895 }
1896 if (i == nritems) {
1897 path->slots[0] = nritems;
1898 return 0;
1899 }
1900 path->slots[0] = i;
1901
1902 again:
1903 err |= check_inode_item(root, path, ext_ref);
1904
1905 if (err & LAST_ITEM)
1906 goto out;
1907
1908 /* still have inode items in thie leaf */
1909 if (cur->start == cur_bytenr)
1910 goto again;
1911
1912 /*
1913 * we have switched to another leaf, above nodes may
1914 * have changed, here walk down the path, if a node
1915 * or leaf is shared, check whether we can skip this
1916 * node or leaf.
1917 */
1918 for (i = root_level; i >= 0; i--) {
1919 if (path->nodes[i]->start == nrefs->bytenr[i])
1920 continue;
1921
1922 ret = update_nodes_refs(root,
1923 path->nodes[i]->start,
1924 nrefs, i);
1925 if (ret)
1926 goto out;
1927
1928 if (!nrefs->need_check[i]) {
1929 *level += 1;
1930 break;
1931 }
1932 }
1933
1934 for (i = 0; i < *level; i++) {
1935 free_extent_buffer(path->nodes[i]);
1936 path->nodes[i] = NULL;
1937 }
1938 out:
1939 err &= ~LAST_ITEM;
1940 /*
1941 * Convert any error bitmap to -EIO, as we should avoid
1942 * mixing positive and negative return value to represent
1943 * error
1944 */
1945 if (err && !ret)
1946 ret = -EIO;
1947 return ret;
1948 }
1949
1950 static void reada_walk_down(struct btrfs_root *root,
1951 struct extent_buffer *node, int slot)
1952 {
1953 u64 bytenr;
1954 u64 ptr_gen;
1955 u32 nritems;
1956 u32 blocksize;
1957 int i;
1958 int level;
1959
1960 level = btrfs_header_level(node);
1961 if (level != 1)
1962 return;
1963
1964 nritems = btrfs_header_nritems(node);
1965 blocksize = root->nodesize;
1966 for (i = slot; i < nritems; i++) {
1967 bytenr = btrfs_node_blockptr(node, i);
1968 ptr_gen = btrfs_node_ptr_generation(node, i);
1969 readahead_tree_block(root, bytenr, blocksize, ptr_gen);
1970 }
1971 }
1972
1973 /*
1974 * Check the child node/leaf by the following condition:
1975 * 1. the first item key of the node/leaf should be the same with the one
1976 * in parent.
1977 * 2. block in parent node should match the child node/leaf.
1978 * 3. generation of parent node and child's header should be consistent.
1979 *
1980 * Or the child node/leaf pointed by the key in parent is not valid.
1981 *
1982 * We hope to check leaf owner too, but since subvol may share leaves,
1983 * which makes leaf owner check not so strong, key check should be
1984 * sufficient enough for that case.
1985 */
1986 static int check_child_node(struct extent_buffer *parent, int slot,
1987 struct extent_buffer *child)
1988 {
1989 struct btrfs_key parent_key;
1990 struct btrfs_key child_key;
1991 int ret = 0;
1992
1993 btrfs_node_key_to_cpu(parent, &parent_key, slot);
1994 if (btrfs_header_level(child) == 0)
1995 btrfs_item_key_to_cpu(child, &child_key, 0);
1996 else
1997 btrfs_node_key_to_cpu(child, &child_key, 0);
1998
1999 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2000 ret = -EINVAL;
2001 fprintf(stderr,
2002 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2003 parent_key.objectid, parent_key.type, parent_key.offset,
2004 child_key.objectid, child_key.type, child_key.offset);
2005 }
2006 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2007 ret = -EINVAL;
2008 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2009 btrfs_node_blockptr(parent, slot),
2010 btrfs_header_bytenr(child));
2011 }
2012 if (btrfs_node_ptr_generation(parent, slot) !=
2013 btrfs_header_generation(child)) {
2014 ret = -EINVAL;
2015 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2016 btrfs_header_generation(child),
2017 btrfs_node_ptr_generation(parent, slot));
2018 }
2019 return ret;
2020 }
2021
2022 /*
2023 * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2024 * in every fs or file tree check. Here we find its all root ids, and only check
2025 * it in the fs or file tree which has the smallest root id.
2026 */
2027 static int need_check(struct btrfs_root *root, struct ulist *roots)
2028 {
2029 struct rb_node *node;
2030 struct ulist_node *u;
2031
2032 if (roots->nnodes == 1)
2033 return 1;
2034
2035 node = rb_first(&roots->root);
2036 u = rb_entry(node, struct ulist_node, rb_node);
2037 /*
2038 * current root id is not smallest, we skip it and let it be checked
2039 * in the fs or file tree who hash the smallest root id.
2040 */
2041 if (root->objectid != u->val)
2042 return 0;
2043
2044 return 1;
2045 }
2046
2047 /*
2048 * for a tree node or leaf, we record its reference count, so later if we still
2049 * process this node or leaf, don't need to compute its reference count again.
2050 */
2051 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2052 struct node_refs *nrefs, u64 level)
2053 {
2054 int check, ret;
2055 u64 refs;
2056 struct ulist *roots;
2057
2058 if (nrefs->bytenr[level] != bytenr) {
2059 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2060 level, 1, &refs, NULL);
2061 if (ret < 0)
2062 return ret;
2063
2064 nrefs->bytenr[level] = bytenr;
2065 nrefs->refs[level] = refs;
2066 if (refs > 1) {
2067 ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2068 0, &roots);
2069 if (ret)
2070 return -EIO;
2071
2072 check = need_check(root, roots);
2073 ulist_free(roots);
2074 nrefs->need_check[level] = check;
2075 } else {
2076 nrefs->need_check[level] = 1;
2077 }
2078 }
2079
2080 return 0;
2081 }
2082
2083 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2084 struct walk_control *wc, int *level,
2085 struct node_refs *nrefs)
2086 {
2087 enum btrfs_tree_block_status status;
2088 u64 bytenr;
2089 u64 ptr_gen;
2090 struct extent_buffer *next;
2091 struct extent_buffer *cur;
2092 u32 blocksize;
2093 int ret, err = 0;
2094 u64 refs;
2095
2096 WARN_ON(*level < 0);
2097 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2098
2099 if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2100 refs = nrefs->refs[*level];
2101 ret = 0;
2102 } else {
2103 ret = btrfs_lookup_extent_info(NULL, root,
2104 path->nodes[*level]->start,
2105 *level, 1, &refs, NULL);
2106 if (ret < 0) {
2107 err = ret;
2108 goto out;
2109 }
2110 nrefs->bytenr[*level] = path->nodes[*level]->start;
2111 nrefs->refs[*level] = refs;
2112 }
2113
2114 if (refs > 1) {
2115 ret = enter_shared_node(root, path->nodes[*level]->start,
2116 refs, wc, *level);
2117 if (ret > 0) {
2118 err = ret;
2119 goto out;
2120 }
2121 }
2122
2123 while (*level >= 0) {
2124 WARN_ON(*level < 0);
2125 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2126 cur = path->nodes[*level];
2127
2128 if (btrfs_header_level(cur) != *level)
2129 WARN_ON(1);
2130
2131 if (path->slots[*level] >= btrfs_header_nritems(cur))
2132 break;
2133 if (*level == 0) {
2134 ret = process_one_leaf(root, cur, wc);
2135 if (ret < 0)
2136 err = ret;
2137 break;
2138 }
2139 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2140 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2141 blocksize = root->nodesize;
2142
2143 if (bytenr == nrefs->bytenr[*level - 1]) {
2144 refs = nrefs->refs[*level - 1];
2145 } else {
2146 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2147 *level - 1, 1, &refs, NULL);
2148 if (ret < 0) {
2149 refs = 0;
2150 } else {
2151 nrefs->bytenr[*level - 1] = bytenr;
2152 nrefs->refs[*level - 1] = refs;
2153 }
2154 }
2155
2156 if (refs > 1) {
2157 ret = enter_shared_node(root, bytenr, refs,
2158 wc, *level - 1);
2159 if (ret > 0) {
2160 path->slots[*level]++;
2161 continue;
2162 }
2163 }
2164
2165 next = btrfs_find_tree_block(root, bytenr, blocksize);
2166 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2167 free_extent_buffer(next);
2168 reada_walk_down(root, cur, path->slots[*level]);
2169 next = read_tree_block(root, bytenr, blocksize,
2170 ptr_gen);
2171 if (!extent_buffer_uptodate(next)) {
2172 struct btrfs_key node_key;
2173
2174 btrfs_node_key_to_cpu(path->nodes[*level],
2175 &node_key,
2176 path->slots[*level]);
2177 btrfs_add_corrupt_extent_record(root->fs_info,
2178 &node_key,
2179 path->nodes[*level]->start,
2180 root->nodesize, *level);
2181 err = -EIO;
2182 goto out;
2183 }
2184 }
2185
2186 ret = check_child_node(cur, path->slots[*level], next);
2187 if (ret) {
2188 err = ret;
2189 goto out;
2190 }
2191
2192 if (btrfs_is_leaf(next))
2193 status = btrfs_check_leaf(root, NULL, next);
2194 else
2195 status = btrfs_check_node(root, NULL, next);
2196 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2197 free_extent_buffer(next);
2198 err = -EIO;
2199 goto out;
2200 }
2201
2202 *level = *level - 1;
2203 free_extent_buffer(path->nodes[*level]);
2204 path->nodes[*level] = next;
2205 path->slots[*level] = 0;
2206 }
2207 out:
2208 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2209 return err;
2210 }
2211
2212 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2213 unsigned int ext_ref);
2214
2215 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2216 int *level, struct node_refs *nrefs, int ext_ref)
2217 {
2218 enum btrfs_tree_block_status status;
2219 u64 bytenr;
2220 u64 ptr_gen;
2221 struct extent_buffer *next;
2222 struct extent_buffer *cur;
2223 u32 blocksize;
2224 int ret;
2225
2226 WARN_ON(*level < 0);
2227 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2228
2229 ret = update_nodes_refs(root, path->nodes[*level]->start,
2230 nrefs, *level);
2231 if (ret < 0)
2232 return ret;
2233
2234 while (*level >= 0) {
2235 WARN_ON(*level < 0);
2236 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2237 cur = path->nodes[*level];
2238
2239 if (btrfs_header_level(cur) != *level)
2240 WARN_ON(1);
2241
2242 if (path->slots[*level] >= btrfs_header_nritems(cur))
2243 break;
2244 /* Don't forgot to check leaf/node validation */
2245 if (*level == 0) {
2246 ret = btrfs_check_leaf(root, NULL, cur);
2247 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2248 ret = -EIO;
2249 break;
2250 }
2251 ret = process_one_leaf_v2(root, path, nrefs,
2252 level, ext_ref);
2253 break;
2254 } else {
2255 ret = btrfs_check_node(root, NULL, cur);
2256 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2257 ret = -EIO;
2258 break;
2259 }
2260 }
2261 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2262 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2263 blocksize = root->nodesize;
2264
2265 ret = update_nodes_refs(root, bytenr, nrefs, *level - 1);
2266 if (ret)
2267 break;
2268 if (!nrefs->need_check[*level - 1]) {
2269 path->slots[*level]++;
2270 continue;
2271 }
2272
2273 next = btrfs_find_tree_block(root, bytenr, blocksize);
2274 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2275 free_extent_buffer(next);
2276 reada_walk_down(root, cur, path->slots[*level]);
2277 next = read_tree_block(root, bytenr, blocksize,
2278 ptr_gen);
2279 if (!extent_buffer_uptodate(next)) {
2280 struct btrfs_key node_key;
2281
2282 btrfs_node_key_to_cpu(path->nodes[*level],
2283 &node_key,
2284 path->slots[*level]);
2285 btrfs_add_corrupt_extent_record(root->fs_info,
2286 &node_key,
2287 path->nodes[*level]->start,
2288 root->nodesize, *level);
2289 ret = -EIO;
2290 break;
2291 }
2292 }
2293
2294 ret = check_child_node(cur, path->slots[*level], next);
2295 if (ret < 0)
2296 break;
2297
2298 if (btrfs_is_leaf(next))
2299 status = btrfs_check_leaf(root, NULL, next);
2300 else
2301 status = btrfs_check_node(root, NULL, next);
2302 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2303 free_extent_buffer(next);
2304 ret = -EIO;
2305 break;
2306 }
2307
2308 *level = *level - 1;
2309 free_extent_buffer(path->nodes[*level]);
2310 path->nodes[*level] = next;
2311 path->slots[*level] = 0;
2312 }
2313 return ret;
2314 }
2315
2316 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2317 struct walk_control *wc, int *level)
2318 {
2319 int i;
2320 struct extent_buffer *leaf;
2321
2322 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2323 leaf = path->nodes[i];
2324 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2325 path->slots[i]++;
2326 *level = i;
2327 return 0;
2328 } else {
2329 free_extent_buffer(path->nodes[*level]);
2330 path->nodes[*level] = NULL;
2331 BUG_ON(*level > wc->active_node);
2332 if (*level == wc->active_node)
2333 leave_shared_node(root, wc, *level);
2334 *level = i + 1;
2335 }
2336 }
2337 return 1;
2338 }
2339
2340 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2341 int *level)
2342 {
2343 int i;
2344 struct extent_buffer *leaf;
2345
2346 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2347 leaf = path->nodes[i];
2348 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2349 path->slots[i]++;
2350 *level = i;
2351 return 0;
2352 } else {
2353 free_extent_buffer(path->nodes[*level]);
2354 path->nodes[*level] = NULL;
2355 *level = i + 1;
2356 }
2357 }
2358 return 1;
2359 }
2360
2361 static int check_root_dir(struct inode_record *rec)
2362 {
2363 struct inode_backref *backref;
2364 int ret = -1;
2365
2366 if (!rec->found_inode_item || rec->errors)
2367 goto out;
2368 if (rec->nlink != 1 || rec->found_link != 0)
2369 goto out;
2370 if (list_empty(&rec->backrefs))
2371 goto out;
2372 backref = to_inode_backref(rec->backrefs.next);
2373 if (!backref->found_inode_ref)
2374 goto out;
2375 if (backref->index != 0 || backref->namelen != 2 ||
2376 memcmp(backref->name, "..", 2))
2377 goto out;
2378 if (backref->found_dir_index || backref->found_dir_item)
2379 goto out;
2380 ret = 0;
2381 out:
2382 return ret;
2383 }
2384
2385 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2386 struct btrfs_root *root, struct btrfs_path *path,
2387 struct inode_record *rec)
2388 {
2389 struct btrfs_inode_item *ei;
2390 struct btrfs_key key;
2391 int ret;
2392
2393 key.objectid = rec->ino;
2394 key.type = BTRFS_INODE_ITEM_KEY;
2395 key.offset = (u64)-1;
2396
2397 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2398 if (ret < 0)
2399 goto out;
2400 if (ret) {
2401 if (!path->slots[0]) {
2402 ret = -ENOENT;
2403 goto out;
2404 }
2405 path->slots[0]--;
2406 ret = 0;
2407 }
2408 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2409 if (key.objectid != rec->ino) {
2410 ret = -ENOENT;
2411 goto out;
2412 }
2413
2414 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2415 struct btrfs_inode_item);
2416 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2417 btrfs_mark_buffer_dirty(path->nodes[0]);
2418 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2419 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2420 root->root_key.objectid);
2421 out:
2422 btrfs_release_path(path);
2423 return ret;
2424 }
2425
2426 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2427 struct btrfs_root *root,
2428 struct btrfs_path *path,
2429 struct inode_record *rec)
2430 {
2431 int ret;
2432
2433 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2434 btrfs_release_path(path);
2435 if (!ret)
2436 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2437 return ret;
2438 }
2439
2440 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2441 struct btrfs_root *root,
2442 struct btrfs_path *path,
2443 struct inode_record *rec)
2444 {
2445 struct btrfs_inode_item *ei;
2446 struct btrfs_key key;
2447 int ret = 0;
2448
2449 key.objectid = rec->ino;
2450 key.type = BTRFS_INODE_ITEM_KEY;
2451 key.offset = 0;
2452
2453 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2454 if (ret) {
2455 if (ret > 0)
2456 ret = -ENOENT;
2457 goto out;
2458 }
2459
2460 /* Since ret == 0, no need to check anything */
2461 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2462 struct btrfs_inode_item);
2463 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2464 btrfs_mark_buffer_dirty(path->nodes[0]);
2465 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2466 printf("reset nbytes for ino %llu root %llu\n",
2467 rec->ino, root->root_key.objectid);
2468 out:
2469 btrfs_release_path(path);
2470 return ret;
2471 }
2472
2473 static int add_missing_dir_index(struct btrfs_root *root,
2474 struct cache_tree *inode_cache,
2475 struct inode_record *rec,
2476 struct inode_backref *backref)
2477 {
2478 struct btrfs_path path;
2479 struct btrfs_trans_handle *trans;
2480 struct btrfs_dir_item *dir_item;
2481 struct extent_buffer *leaf;
2482 struct btrfs_key key;
2483 struct btrfs_disk_key disk_key;
2484 struct inode_record *dir_rec;
2485 unsigned long name_ptr;
2486 u32 data_size = sizeof(*dir_item) + backref->namelen;
2487 int ret;
2488
2489 trans = btrfs_start_transaction(root, 1);
2490 if (IS_ERR(trans))
2491 return PTR_ERR(trans);
2492
2493 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2494 (unsigned long long)rec->ino);
2495
2496 btrfs_init_path(&path);
2497 key.objectid = backref->dir;
2498 key.type = BTRFS_DIR_INDEX_KEY;
2499 key.offset = backref->index;
2500 ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
2501 BUG_ON(ret);
2502
2503 leaf = path.nodes[0];
2504 dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
2505
2506 disk_key.objectid = cpu_to_le64(rec->ino);
2507 disk_key.type = BTRFS_INODE_ITEM_KEY;
2508 disk_key.offset = 0;
2509
2510 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2511 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2512 btrfs_set_dir_data_len(leaf, dir_item, 0);
2513 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2514 name_ptr = (unsigned long)(dir_item + 1);
2515 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2516 btrfs_mark_buffer_dirty(leaf);
2517 btrfs_release_path(&path);
2518 btrfs_commit_transaction(trans, root);
2519
2520 backref->found_dir_index = 1;
2521 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2522 BUG_ON(IS_ERR(dir_rec));
2523 if (!dir_rec)
2524 return 0;
2525 dir_rec->found_size += backref->namelen;
2526 if (dir_rec->found_size == dir_rec->isize &&
2527 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2528 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2529 if (dir_rec->found_size != dir_rec->isize)
2530 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2531
2532 return 0;
2533 }
2534
2535 static int delete_dir_index(struct btrfs_root *root,
2536 struct inode_backref *backref)
2537 {
2538 struct btrfs_trans_handle *trans;
2539 struct btrfs_dir_item *di;
2540 struct btrfs_path path;
2541 int ret = 0;
2542
2543 trans = btrfs_start_transaction(root, 1);
2544 if (IS_ERR(trans))
2545 return PTR_ERR(trans);
2546
2547 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2548 (unsigned long long)backref->dir,
2549 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2550 (unsigned long long)root->objectid);
2551
2552 btrfs_init_path(&path);
2553 di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
2554 backref->name, backref->namelen,
2555 backref->index, -1);
2556 if (IS_ERR(di)) {
2557 ret = PTR_ERR(di);
2558 btrfs_release_path(&path);
2559 btrfs_commit_transaction(trans, root);
2560 if (ret == -ENOENT)
2561 return 0;
2562 return ret;
2563 }
2564
2565 if (!di)
2566 ret = btrfs_del_item(trans, root, &path);
2567 else
2568 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
2569 BUG_ON(ret);
2570 btrfs_release_path(&path);
2571 btrfs_commit_transaction(trans, root);
2572 return ret;
2573 }
2574
2575 static int create_inode_item(struct btrfs_root *root,
2576 struct inode_record *rec,
2577 int root_dir)
2578 {
2579 struct btrfs_trans_handle *trans;
2580 struct btrfs_inode_item inode_item;
2581 time_t now = time(NULL);
2582 int ret;
2583
2584 trans = btrfs_start_transaction(root, 1);
2585 if (IS_ERR(trans)) {
2586 ret = PTR_ERR(trans);
2587 return ret;
2588 }
2589
2590 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2591 "be incomplete, please check permissions and content after "
2592 "the fsck completes.\n", (unsigned long long)root->objectid,
2593 (unsigned long long)rec->ino);
2594
2595 memset(&inode_item, 0, sizeof(inode_item));
2596 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2597 if (root_dir)
2598 btrfs_set_stack_inode_nlink(&inode_item, 1);
2599 else
2600 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2601 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2602 if (rec->found_dir_item) {
2603 if (rec->found_file_extent)
2604 fprintf(stderr, "root %llu inode %llu has both a dir "
2605 "item and extents, unsure if it is a dir or a "
2606 "regular file so setting it as a directory\n",
2607 (unsigned long long)root->objectid,
2608 (unsigned long long)rec->ino);
2609 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2610 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2611 } else if (!rec->found_dir_item) {
2612 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2613 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2614 }
2615 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2616 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2617 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2618 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2619 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2620 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2621 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2622 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2623
2624 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2625 BUG_ON(ret);
2626 btrfs_commit_transaction(trans, root);
2627 return 0;
2628 }
2629
2630 static int repair_inode_backrefs(struct btrfs_root *root,
2631 struct inode_record *rec,
2632 struct cache_tree *inode_cache,
2633 int delete)
2634 {
2635 struct inode_backref *tmp, *backref;
2636 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2637 int ret = 0;
2638 int repaired = 0;
2639
2640 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2641 if (!delete && rec->ino == root_dirid) {
2642 if (!rec->found_inode_item) {
2643 ret = create_inode_item(root, rec, 1);
2644 if (ret)
2645 break;
2646 repaired++;
2647 }
2648 }
2649
2650 /* Index 0 for root dir's are special, don't mess with it */
2651 if (rec->ino == root_dirid && backref->index == 0)
2652 continue;
2653
2654 if (delete &&
2655 ((backref->found_dir_index && !backref->found_inode_ref) ||
2656 (backref->found_dir_index && backref->found_inode_ref &&
2657 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2658 ret = delete_dir_index(root, backref);
2659 if (ret)
2660 break;
2661 repaired++;
2662 list_del(&backref->list);
2663 free(backref);
2664 }
2665
2666 if (!delete && !backref->found_dir_index &&
2667 backref->found_dir_item && backref->found_inode_ref) {
2668 ret = add_missing_dir_index(root, inode_cache, rec,
2669 backref);
2670 if (ret)
2671 break;
2672 repaired++;
2673 if (backref->found_dir_item &&
2674 backref->found_dir_index &&
2675 backref->found_dir_index) {
2676 if (!backref->errors &&
2677 backref->found_inode_ref) {
2678 list_del(&backref->list);
2679 free(backref);
2680 }
2681 }
2682 }
2683
2684 if (!delete && (!backref->found_dir_index &&
2685 !backref->found_dir_item &&
2686 backref->found_inode_ref)) {
2687 struct btrfs_trans_handle *trans;
2688 struct btrfs_key location;
2689
2690 ret = check_dir_conflict(root, backref->name,
2691 backref->namelen,
2692 backref->dir,
2693 backref->index);
2694 if (ret) {
2695 /*
2696 * let nlink fixing routine to handle it,
2697 * which can do it better.
2698 */
2699 ret = 0;
2700 break;
2701 }
2702 location.objectid = rec->ino;
2703 location.type = BTRFS_INODE_ITEM_KEY;
2704 location.offset = 0;
2705
2706 trans = btrfs_start_transaction(root, 1);
2707 if (IS_ERR(trans)) {
2708 ret = PTR_ERR(trans);
2709 break;
2710 }
2711 fprintf(stderr, "adding missing dir index/item pair "
2712 "for inode %llu\n",
2713 (unsigned long long)rec->ino);
2714 ret = btrfs_insert_dir_item(trans, root, backref->name,
2715 backref->namelen,
2716 backref->dir, &location,
2717 imode_to_type(rec->imode),
2718 backref->index);
2719 BUG_ON(ret);
2720 btrfs_commit_transaction(trans, root);
2721 repaired++;
2722 }
2723
2724 if (!delete && (backref->found_inode_ref &&
2725 backref->found_dir_index &&
2726 backref->found_dir_item &&
2727 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2728 !rec->found_inode_item)) {
2729 ret = create_inode_item(root, rec, 0);
2730 if (ret)
2731 break;
2732 repaired++;
2733 }
2734
2735 }
2736 return ret ? ret : repaired;
2737 }
2738
2739 /*
2740 * To determine the file type for nlink/inode_item repair
2741 *
2742 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2743 * Return -ENOENT if file type is not found.
2744 */
2745 static int find_file_type(struct inode_record *rec, u8 *type)
2746 {
2747 struct inode_backref *backref;
2748
2749 /* For inode item recovered case */
2750 if (rec->found_inode_item) {
2751 *type = imode_to_type(rec->imode);
2752 return 0;
2753 }
2754
2755 list_for_each_entry(backref, &rec->backrefs, list) {
2756 if (backref->found_dir_index || backref->found_dir_item) {
2757 *type = backref->filetype;
2758 return 0;
2759 }
2760 }
2761 return -ENOENT;
2762 }
2763
2764 /*
2765 * To determine the file name for nlink repair
2766 *
2767 * Return 0 if file name is found, set name and namelen.
2768 * Return -ENOENT if file name is not found.
2769 */
2770 static int find_file_name(struct inode_record *rec,
2771 char *name, int *namelen)
2772 {
2773 struct inode_backref *backref;
2774
2775 list_for_each_entry(backref, &rec->backrefs, list) {
2776 if (backref->found_dir_index || backref->found_dir_item ||
2777 backref->found_inode_ref) {
2778 memcpy(name, backref->name, backref->namelen);
2779 *namelen = backref->namelen;
2780 return 0;
2781 }
2782 }
2783 return -ENOENT;
2784 }
2785
2786 /* Reset the nlink of the inode to the correct one */
2787 static int reset_nlink(struct btrfs_trans_handle *trans,
2788 struct btrfs_root *root,
2789 struct btrfs_path *path,
2790 struct inode_record *rec)
2791 {
2792 struct inode_backref *backref;
2793 struct inode_backref *tmp;
2794 struct btrfs_key key;
2795 struct btrfs_inode_item *inode_item;
2796 int ret = 0;
2797
2798 /* We don't believe this either, reset it and iterate backref */
2799 rec->found_link = 0;
2800
2801 /* Remove all backref including the valid ones */
2802 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2803 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2804 backref->index, backref->name,
2805 backref->namelen, 0);
2806 if (ret < 0)
2807 goto out;
2808
2809 /* remove invalid backref, so it won't be added back */
2810 if (!(backref->found_dir_index &&
2811 backref->found_dir_item &&
2812 backref->found_inode_ref)) {
2813 list_del(&backref->list);
2814 free(backref);
2815 } else {
2816 rec->found_link++;
2817 }
2818 }
2819
2820 /* Set nlink to 0 */
2821 key.objectid = rec->ino;
2822 key.type = BTRFS_INODE_ITEM_KEY;
2823 key.offset = 0;
2824 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2825 if (ret < 0)
2826 goto out;
2827 if (ret > 0) {
2828 ret = -ENOENT;
2829 goto out;
2830 }
2831 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2832 struct btrfs_inode_item);
2833 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2834 btrfs_mark_buffer_dirty(path->nodes[0]);
2835 btrfs_release_path(path);
2836
2837 /*
2838 * Add back valid inode_ref/dir_item/dir_index,
2839 * add_link() will handle the nlink inc, so new nlink must be correct
2840 */
2841 list_for_each_entry(backref, &rec->backrefs, list) {
2842 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2843 backref->name, backref->namelen,
2844 backref->filetype, &backref->index, 1);
2845 if (ret < 0)
2846 goto out;
2847 }
2848 out:
2849 btrfs_release_path(path);
2850 return ret;
2851 }
2852
2853 static int get_highest_inode(struct btrfs_trans_handle *trans,
2854 struct btrfs_root *root,
2855 struct btrfs_path *path,
2856 u64 *highest_ino)
2857 {
2858 struct btrfs_key key, found_key;
2859 int ret;
2860
2861 btrfs_init_path(path);
2862 key.objectid = BTRFS_LAST_FREE_OBJECTID;
2863 key.offset = -1;
2864 key.type = BTRFS_INODE_ITEM_KEY;
2865 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2866 if (ret == 1) {
2867 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2868 path->slots[0] - 1);
2869 *highest_ino = found_key.objectid;
2870 ret = 0;
2871 }
2872 if (*highest_ino >= BTRFS_LAST_FREE_OBJECTID)
2873 ret = -EOVERFLOW;
2874 btrfs_release_path(path);
2875 return ret;
2876 }
2877
2878 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2879 struct btrfs_root *root,
2880 struct btrfs_path *path,
2881 struct inode_record *rec)
2882 {
2883 char *dir_name = "lost+found";
2884 char namebuf[BTRFS_NAME_LEN] = {0};
2885 u64 lost_found_ino;
2886 u32 mode = 0700;
2887 u8 type = 0;
2888 int namelen = 0;
2889 int name_recovered = 0;
2890 int type_recovered = 0;
2891 int ret = 0;
2892
2893 /*
2894 * Get file name and type first before these invalid inode ref
2895 * are deleted by remove_all_invalid_backref()
2896 */
2897 name_recovered = !find_file_name(rec, namebuf, &namelen);
2898 type_recovered = !find_file_type(rec, &type);
2899
2900 if (!name_recovered) {
2901 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2902 rec->ino, rec->ino);
2903 namelen = count_digits(rec->ino);
2904 sprintf(namebuf, "%llu", rec->ino);
2905 name_recovered = 1;
2906 }
2907 if (!type_recovered) {
2908 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2909 rec->ino);
2910 type = BTRFS_FT_REG_FILE;
2911 type_recovered = 1;
2912 }
2913
2914 ret = reset_nlink(trans, root, path, rec);
2915 if (ret < 0) {
2916 fprintf(stderr,
2917 "Failed to reset nlink for inode %llu: %s\n",
2918 rec->ino, strerror(-ret));
2919 goto out;
2920 }
2921
2922 if (rec->found_link == 0) {
2923 ret = get_highest_inode(trans, root, path, &lost_found_ino);
2924 if (ret < 0)
2925 goto out;
2926 lost_found_ino++;
2927 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2928 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2929 mode);
2930 if (ret < 0) {
2931 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2932 dir_name, strerror(-ret));
2933 goto out;
2934 }
2935 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2936 namebuf, namelen, type, NULL, 1);
2937 /*
2938 * Add ".INO" suffix several times to handle case where
2939 * "FILENAME.INO" is already taken by another file.
2940 */
2941 while (ret == -EEXIST) {
2942 /*
2943 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2944 */
2945 if (namelen + count_digits(rec->ino) + 1 >
2946 BTRFS_NAME_LEN) {
2947 ret = -EFBIG;
2948 goto out;
2949 }
2950 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2951 ".%llu", rec->ino);
2952 namelen += count_digits(rec->ino) + 1;
2953 ret = btrfs_add_link(trans, root, rec->ino,
2954 lost_found_ino, namebuf,
2955 namelen, type, NULL, 1);
2956 }
2957 if (ret < 0) {
2958 fprintf(stderr,
2959 "Failed to link the inode %llu to %s dir: %s\n",
2960 rec->ino, dir_name, strerror(-ret));
2961 goto out;
2962 }
2963 /*
2964 * Just increase the found_link, don't actually add the
2965 * backref. This will make things easier and this inode
2966 * record will be freed after the repair is done.
2967 * So fsck will not report problem about this inode.
2968 */
2969 rec->found_link++;
2970 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2971 namelen, namebuf, dir_name);
2972 }
2973 printf("Fixed the nlink of inode %llu\n", rec->ino);
2974 out:
2975 /*
2976 * Clear the flag anyway, or we will loop forever for the same inode
2977 * as it will not be removed from the bad inode list and the dead loop
2978 * happens.
2979 */
2980 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2981 btrfs_release_path(path);
2982 return ret;
2983 }
2984
2985 /*
2986 * Check if there is any normal(reg or prealloc) file extent for given
2987 * ino.
2988 * This is used to determine the file type when neither its dir_index/item or
2989 * inode_item exists.
2990 *
2991 * This will *NOT* report error, if any error happens, just consider it does
2992 * not have any normal file extent.
2993 */
2994 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
2995 {
2996 struct btrfs_path path;
2997 struct btrfs_key key;
2998 struct btrfs_key found_key;
2999 struct btrfs_file_extent_item *fi;
3000 u8 type;
3001 int ret = 0;
3002
3003 btrfs_init_path(&path);
3004 key.objectid = ino;
3005 key.type = BTRFS_EXTENT_DATA_KEY;
3006 key.offset = 0;
3007
3008 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3009 if (ret < 0) {
3010 ret = 0;
3011 goto out;
3012 }
3013 if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
3014 ret = btrfs_next_leaf(root, &path);
3015 if (ret) {
3016 ret = 0;
3017 goto out;
3018 }
3019 }
3020 while (1) {
3021 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3022 path.slots[0]);
3023 if (found_key.objectid != ino ||
3024 found_key.type != BTRFS_EXTENT_DATA_KEY)
3025 break;
3026 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3027 struct btrfs_file_extent_item);
3028 type = btrfs_file_extent_type(path.nodes[0], fi);
3029 if (type != BTRFS_FILE_EXTENT_INLINE) {
3030 ret = 1;
3031 goto out;
3032 }
3033 }
3034 out:
3035 btrfs_release_path(&path);
3036 return ret;
3037 }
3038
3039 static u32 btrfs_type_to_imode(u8 type)
3040 {
3041 static u32 imode_by_btrfs_type[] = {
3042 [BTRFS_FT_REG_FILE] = S_IFREG,
3043 [BTRFS_FT_DIR] = S_IFDIR,
3044 [BTRFS_FT_CHRDEV] = S_IFCHR,
3045 [BTRFS_FT_BLKDEV] = S_IFBLK,
3046 [BTRFS_FT_FIFO] = S_IFIFO,
3047 [BTRFS_FT_SOCK] = S_IFSOCK,
3048 [BTRFS_FT_SYMLINK] = S_IFLNK,
3049 };
3050
3051 return imode_by_btrfs_type[(type)];
3052 }
3053
3054 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3055 struct btrfs_root *root,
3056 struct btrfs_path *path,
3057 struct inode_record *rec)
3058 {
3059 u8 filetype;
3060 u32 mode = 0700;
3061 int type_recovered = 0;
3062 int ret = 0;
3063
3064 printf("Trying to rebuild inode:%llu\n", rec->ino);
3065
3066 type_recovered = !find_file_type(rec, &filetype);
3067
3068 /*
3069 * Try to determine inode type if type not found.
3070 *
3071 * For found regular file extent, it must be FILE.
3072 * For found dir_item/index, it must be DIR.
3073 *
3074 * For undetermined one, use FILE as fallback.
3075 *
3076 * TODO:
3077 * 1. If found backref(inode_index/item is already handled) to it,
3078 * it must be DIR.
3079 * Need new inode-inode ref structure to allow search for that.
3080 */
3081 if (!type_recovered) {
3082 if (rec->found_file_extent &&
3083 find_normal_file_extent(root, rec->ino)) {
3084 type_recovered = 1;
3085 filetype = BTRFS_FT_REG_FILE;
3086 } else if (rec->found_dir_item) {
3087 type_recovered = 1;
3088 filetype = BTRFS_FT_DIR;
3089 } else if (!list_empty(&rec->orphan_extents)) {
3090 type_recovered = 1;
3091 filetype = BTRFS_FT_REG_FILE;
3092 } else{
3093 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3094 rec->ino);
3095 type_recovered = 1;
3096 filetype = BTRFS_FT_REG_FILE;
3097 }
3098 }
3099
3100 ret = btrfs_new_inode(trans, root, rec->ino,
3101 mode | btrfs_type_to_imode(filetype));
3102 if (ret < 0)
3103 goto out;
3104
3105 /*
3106 * Here inode rebuild is done, we only rebuild the inode item,
3107 * don't repair the nlink(like move to lost+found).
3108 * That is the job of nlink repair.
3109 *
3110 * We just fill the record and return
3111 */
3112 rec->found_dir_item = 1;
3113 rec->imode = mode | btrfs_type_to_imode(filetype);
3114 rec->nlink = 0;
3115 rec->errors &= ~I_ERR_NO_INODE_ITEM;
3116 /* Ensure the inode_nlinks repair function will be called */
3117 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3118 out:
3119 return ret;
3120 }
3121
3122 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3123 struct btrfs_root *root,
3124 struct btrfs_path *path,
3125 struct inode_record *rec)
3126 {
3127 struct orphan_data_extent *orphan;
3128 struct orphan_data_extent *tmp;
3129 int ret = 0;
3130
3131 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3132 /*
3133 * Check for conflicting file extents
3134 *
3135 * Here we don't know whether the extents is compressed or not,
3136 * so we can only assume it not compressed nor data offset,
3137 * and use its disk_len as extent length.
3138 */
3139 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3140 orphan->offset, orphan->disk_len, 0);
3141 btrfs_release_path(path);
3142 if (ret < 0)
3143 goto out;
3144 if (!ret) {
3145 fprintf(stderr,
3146 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3147 orphan->disk_bytenr, orphan->disk_len);
3148 ret = btrfs_free_extent(trans,
3149 root->fs_info->extent_root,
3150 orphan->disk_bytenr, orphan->disk_len,
3151 0, root->objectid, orphan->objectid,
3152 orphan->offset);
3153 if (ret < 0)
3154 goto out;
3155 }
3156 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3157 orphan->offset, orphan->disk_bytenr,
3158 orphan->disk_len, orphan->disk_len);
3159 if (ret < 0)
3160 goto out;
3161
3162 /* Update file size info */
3163 rec->found_size += orphan->disk_len;
3164 if (rec->found_size == rec->nbytes)
3165 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3166
3167 /* Update the file extent hole info too */
3168 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3169 orphan->disk_len);
3170 if (ret < 0)
3171 goto out;
3172 if (RB_EMPTY_ROOT(&rec->holes))
3173 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3174
3175 list_del(&orphan->list);
3176 free(orphan);
3177 }
3178 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3179 out:
3180 return ret;
3181 }
3182
3183 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3184 struct btrfs_root *root,
3185 struct btrfs_path *path,
3186 struct inode_record *rec)
3187 {
3188 struct rb_node *node;
3189 struct file_extent_hole *hole;
3190 int found = 0;
3191 int ret = 0;
3192
3193 node = rb_first(&rec->holes);
3194
3195 while (node) {
3196 found = 1;
3197 hole = rb_entry(node, struct file_extent_hole, node);
3198 ret = btrfs_punch_hole(trans, root, rec->ino,
3199 hole->start, hole->len);
3200 if (ret < 0)
3201 goto out;
3202 ret = del_file_extent_hole(&rec->holes, hole->start,
3203 hole->len);
3204 if (ret < 0)
3205 goto out;
3206 if (RB_EMPTY_ROOT(&rec->holes))
3207 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3208 node = rb_first(&rec->holes);
3209 }
3210 /* special case for a file losing all its file extent */
3211 if (!found) {
3212 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3213 round_up(rec->isize, root->sectorsize));
3214 if (ret < 0)
3215 goto out;
3216 }
3217 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3218 rec->ino, root->objectid);
3219 out:
3220 return ret;
3221 }
3222
3223 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3224 {
3225 struct btrfs_trans_handle *trans;
3226 struct btrfs_path path;
3227 int ret = 0;
3228
3229 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3230 I_ERR_NO_ORPHAN_ITEM |
3231 I_ERR_LINK_COUNT_WRONG |
3232 I_ERR_NO_INODE_ITEM |
3233 I_ERR_FILE_EXTENT_ORPHAN |
3234 I_ERR_FILE_EXTENT_DISCOUNT|
3235 I_ERR_FILE_NBYTES_WRONG)))
3236 return rec->errors;
3237
3238 /*
3239 * For nlink repair, it may create a dir and add link, so
3240 * 2 for parent(256)'s dir_index and dir_item
3241 * 2 for lost+found dir's inode_item and inode_ref
3242 * 1 for the new inode_ref of the file
3243 * 2 for lost+found dir's dir_index and dir_item for the file
3244 */
3245 trans = btrfs_start_transaction(root, 7);
3246 if (IS_ERR(trans))
3247 return PTR_ERR(trans);
3248
3249 btrfs_init_path(&path);
3250 if (rec->errors & I_ERR_NO_INODE_ITEM)
3251 ret = repair_inode_no_item(trans, root, &path, rec);
3252 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3253 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3254 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3255 ret = repair_inode_discount_extent(trans, root, &path, rec);
3256 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3257 ret = repair_inode_isize(trans, root, &path, rec);
3258 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3259 ret = repair_inode_orphan_item(trans, root, &path, rec);
3260 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3261 ret = repair_inode_nlinks(trans, root, &path, rec);
3262 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3263 ret = repair_inode_nbytes(trans, root, &path, rec);
3264 btrfs_commit_transaction(trans, root);
3265 btrfs_release_path(&path);
3266 return ret;
3267 }
3268
3269 static int check_inode_recs(struct btrfs_root *root,
3270 struct cache_tree *inode_cache)
3271 {
3272 struct cache_extent *cache;
3273 struct ptr_node *node;
3274 struct inode_record *rec;
3275 struct inode_backref *backref;
3276 int stage = 0;
3277 int ret = 0;
3278 int err = 0;
3279 u64 error = 0;
3280 u64 root_dirid = btrfs_root_dirid(&root->root_item);
3281
3282 if (btrfs_root_refs(&root->root_item) == 0) {
3283 if (!cache_tree_empty(inode_cache))
3284 fprintf(stderr, "warning line %d\n", __LINE__);
3285 return 0;
3286 }
3287
3288 /*
3289 * We need to repair backrefs first because we could change some of the
3290 * errors in the inode recs.
3291 *
3292 * We also need to go through and delete invalid backrefs first and then
3293 * add the correct ones second. We do this because we may get EEXIST
3294 * when adding back the correct index because we hadn't yet deleted the
3295 * invalid index.
3296 *
3297 * For example, if we were missing a dir index then the directories
3298 * isize would be wrong, so if we fixed the isize to what we thought it
3299 * would be and then fixed the backref we'd still have a invalid fs, so
3300 * we need to add back the dir index and then check to see if the isize
3301 * is still wrong.
3302 */
3303 while (stage < 3) {
3304 stage++;
3305 if (stage == 3 && !err)
3306 break;
3307
3308 cache = search_cache_extent(inode_cache, 0);
3309 while (repair && cache) {
3310 node = container_of(cache, struct ptr_node, cache);
3311 rec = node->data;
3312 cache = next_cache_extent(cache);
3313
3314 /* Need to free everything up and rescan */
3315 if (stage == 3) {
3316 remove_cache_extent(inode_cache, &node->cache);
3317 free(node);
3318 free_inode_rec(rec);
3319 continue;
3320 }
3321
3322 if (list_empty(&rec->backrefs))
3323 continue;
3324
3325 ret = repair_inode_backrefs(root, rec, inode_cache,
3326 stage == 1);
3327 if (ret < 0) {
3328 err = ret;
3329 stage = 2;
3330 break;
3331 } if (ret > 0) {
3332 err = -EAGAIN;
3333 }
3334 }
3335 }
3336 if (err)
3337 return err;
3338
3339 rec = get_inode_rec(inode_cache, root_dirid, 0);
3340 BUG_ON(IS_ERR(rec));
3341 if (rec) {
3342 ret = check_root_dir(rec);
3343 if (ret) {
3344 fprintf(stderr, "root %llu root dir %llu error\n",
3345 (unsigned long long)root->root_key.objectid,
3346 (unsigned long long)root_dirid);
3347 print_inode_error(root, rec);
3348 error++;
3349 }
3350 } else {
3351 if (repair) {
3352 struct btrfs_trans_handle *trans;
3353
3354 trans = btrfs_start_transaction(root, 1);
3355 if (IS_ERR(trans)) {
3356 err = PTR_ERR(trans);
3357 return err;
3358 }
3359
3360 fprintf(stderr,
3361 "root %llu missing its root dir, recreating\n",
3362 (unsigned long long)root->objectid);
3363
3364 ret = btrfs_make_root_dir(trans, root, root_dirid);
3365 BUG_ON(ret);
3366
3367 btrfs_commit_transaction(trans, root);
3368 return -EAGAIN;
3369 }
3370
3371 fprintf(stderr, "root %llu root dir %llu not found\n",
3372 (unsigned long long)root->root_key.objectid,
3373 (unsigned long long)root_dirid);
3374 }
3375
3376 while (1) {
3377 cache = search_cache_extent(inode_cache, 0);
3378 if (!cache)
3379 break;
3380 node = container_of(cache, struct ptr_node, cache);
3381 rec = node->data;
3382 remove_cache_extent(inode_cache, &node->cache);
3383 free(node);
3384 if (rec->ino == root_dirid ||
3385 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3386 free_inode_rec(rec);
3387 continue;
3388 }
3389
3390 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3391 ret = check_orphan_item(root, rec->ino);
3392 if (ret == 0)
3393 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3394 if (can_free_inode_rec(rec)) {
3395 free_inode_rec(rec);
3396 continue;
3397 }
3398 }
3399
3400 if (!rec->found_inode_item)
3401 rec->errors |= I_ERR_NO_INODE_ITEM;
3402 if (rec->found_link != rec->nlink)
3403 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3404 if (repair) {
3405 ret = try_repair_inode(root, rec);
3406 if (ret == 0 && can_free_inode_rec(rec)) {
3407 free_inode_rec(rec);
3408 continue;
3409 }
3410 ret = 0;
3411 }
3412
3413 if (!(repair && ret == 0))
3414 error++;
3415 print_inode_error(root, rec);
3416 list_for_each_entry(backref, &rec->backrefs, list) {
3417 if (!backref->found_dir_item)
3418 backref->errors |= REF_ERR_NO_DIR_ITEM;
3419 if (!backref->found_dir_index)
3420 backref->errors |= REF_ERR_NO_DIR_INDEX;
3421 if (!backref->found_inode_ref)
3422 backref->errors |= REF_ERR_NO_INODE_REF;
3423 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3424 " namelen %u name %s filetype %d errors %x",
3425 (unsigned long long)backref->dir,
3426 (unsigned long long)backref->index,
3427 backref->namelen, backref->name,
3428 backref->filetype, backref->errors);
3429 print_ref_error(backref->errors);
3430 }
3431 free_inode_rec(rec);
3432 }
3433 return (error > 0) ? -1 : 0;
3434 }
3435
3436 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3437 u64 objectid)
3438 {
3439 struct cache_extent *cache;
3440 struct root_record *rec = NULL;
3441 int ret;
3442
3443 cache = lookup_cache_extent(root_cache, objectid, 1);
3444 if (cache) {
3445 rec = container_of(cache, struct root_record, cache);
3446 } else {
3447 rec = calloc(1, sizeof(*rec));
3448 if (!rec)
3449 return ERR_PTR(-ENOMEM);
3450 rec->objectid = objectid;
3451 INIT_LIST_HEAD(&rec->backrefs);
3452 rec->cache.start = objectid;
3453 rec->cache.size = 1;
3454
3455 ret = insert_cache_extent(root_cache, &rec->cache);
3456 if (ret)
3457 return ERR_PTR(-EEXIST);
3458 }
3459 return rec;
3460 }
3461
3462 static struct root_backref *get_root_backref(struct root_record *rec,
3463 u64 ref_root, u64 dir, u64 index,
3464 const char *name, int namelen)
3465 {
3466 struct root_backref *backref;
3467
3468 list_for_each_entry(backref, &rec->backrefs, list) {
3469 if (backref->ref_root != ref_root || backref->dir != dir ||
3470 backref->namelen != namelen)
3471 continue;
3472 if (memcmp(name, backref->name, namelen))
3473 continue;
3474 return backref;
3475 }
3476
3477 backref = calloc(1, sizeof(*backref) + namelen + 1);
3478 if (!backref)
3479 return NULL;
3480 backref->ref_root = ref_root;
3481 backref->dir = dir;
3482 backref->index = index;
3483 backref->namelen = namelen;
3484 memcpy(backref->name, name, namelen);
3485 backref->name[namelen] = '\0';
3486 list_add_tail(&backref->list, &rec->backrefs);
3487 return backref;
3488 }
3489
3490 static void free_root_record(struct cache_extent *cache)
3491 {
3492 struct root_record *rec;
3493 struct root_backref *backref;
3494
3495 rec = container_of(cache, struct root_record, cache);
3496 while (!list_empty(&rec->backrefs)) {
3497 backref = to_root_backref(rec->backrefs.next);
3498 list_del(&backref->list);
3499 free(backref);
3500 }
3501
3502 free(rec);
3503 }
3504
3505 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3506
3507 static int add_root_backref(struct cache_tree *root_cache,
3508 u64 root_id, u64 ref_root, u64 dir, u64 index,
3509 const char *name, int namelen,
3510 int item_type, int errors)
3511 {
3512 struct root_record *rec;
3513 struct root_backref *backref;
3514
3515 rec = get_root_rec(root_cache, root_id);
3516 BUG_ON(IS_ERR(rec));
3517 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3518 BUG_ON(!backref);
3519
3520 backref->errors |= errors;
3521
3522 if (item_type != BTRFS_DIR_ITEM_KEY) {
3523 if (backref->found_dir_index || backref->found_back_ref ||
3524 backref->found_forward_ref) {
3525 if (backref->index != index)
3526 backref->errors |= REF_ERR_INDEX_UNMATCH;
3527 } else {
3528 backref->index = index;
3529 }
3530 }
3531
3532 if (item_type == BTRFS_DIR_ITEM_KEY) {
3533 if (backref->found_forward_ref)
3534 rec->found_ref++;
3535 backref->found_dir_item = 1;
3536 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3537 backref->found_dir_index = 1;
3538 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3539 if (backref->found_forward_ref)
3540 backref->errors |= REF_ERR_DUP_ROOT_REF;
3541 else if (backref->found_dir_item)
3542 rec->found_ref++;
3543 backref->found_forward_ref = 1;
3544 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3545 if (backref->found_back_ref)
3546 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3547 backref->found_back_ref = 1;
3548 } else {
3549 BUG_ON(1);
3550 }
3551
3552 if (backref->found_forward_ref && backref->found_dir_item)
3553 backref->reachable = 1;
3554 return 0;
3555 }
3556
3557 static int merge_root_recs(struct btrfs_root *root,
3558 struct cache_tree *src_cache,
3559 struct cache_tree *dst_cache)
3560 {
3561 struct cache_extent *cache;
3562 struct ptr_node *node;
3563 struct inode_record *rec;
3564 struct inode_backref *backref;
3565 int ret = 0;
3566
3567 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3568 free_inode_recs_tree(src_cache);
3569 return 0;
3570 }
3571
3572 while (1) {
3573 cache = search_cache_extent(src_cache, 0);
3574 if (!cache)
3575 break;
3576 node = container_of(cache, struct ptr_node, cache);
3577 rec = node->data;
3578 remove_cache_extent(src_cache, &node->cache);
3579 free(node);
3580
3581 ret = is_child_root(root, root->objectid, rec->ino);
3582 if (ret < 0)
3583 break;
3584 else if (ret == 0)
3585 goto skip;
3586
3587 list_for_each_entry(backref, &rec->backrefs, list) {
3588 BUG_ON(backref->found_inode_ref);
3589 if (backref->found_dir_item)
3590 add_root_backref(dst_cache, rec->ino,
3591 root->root_key.objectid, backref->dir,
3592 backref->index, backref->name,
3593 backref->namelen, BTRFS_DIR_ITEM_KEY,
3594 backref->errors);
3595 if (backref->found_dir_index)
3596 add_root_backref(dst_cache, rec->ino,
3597 root->root_key.objectid, backref->dir,
3598 backref->index, backref->name,
3599 backref->namelen, BTRFS_DIR_INDEX_KEY,
3600 backref->errors);
3601 }
3602 skip:
3603 free_inode_rec(rec);
3604 }
3605 if (ret < 0)
3606 return ret;
3607 return 0;
3608 }
3609
3610 static int check_root_refs(struct btrfs_root *root,
3611 struct cache_tree *root_cache)
3612 {
3613 struct root_record *rec;
3614 struct root_record *ref_root;
3615 struct root_backref *backref;
3616 struct cache_extent *cache;
3617 int loop = 1;
3618 int ret;
3619 int error;
3620 int errors = 0;
3621
3622 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3623 BUG_ON(IS_ERR(rec));
3624 rec->found_ref = 1;
3625
3626 /* fixme: this can not detect circular references */
3627 while (loop) {
3628 loop = 0;
3629 cache = search_cache_extent(root_cache, 0);
3630 while (1) {
3631 if (!cache)
3632 break;
3633 rec = container_of(cache, struct root_record, cache);
3634 cache = next_cache_extent(cache);
3635
3636 if (rec->found_ref == 0)
3637 continue;
3638
3639 list_for_each_entry(backref, &rec->backrefs, list) {
3640 if (!backref->reachable)
3641 continue;
3642
3643 ref_root = get_root_rec(root_cache,
3644 backref->ref_root);
3645 BUG_ON(IS_ERR(ref_root));
3646 if (ref_root->found_ref > 0)
3647 continue;
3648
3649 backref->reachable = 0;
3650 rec->found_ref--;
3651 if (rec->found_ref == 0)
3652 loop = 1;
3653 }
3654 }
3655 }
3656
3657 cache = search_cache_extent(root_cache, 0);
3658 while (1) {
3659 if (!cache)
3660 break;
3661 rec = container_of(cache, struct root_record, cache);
3662 cache = next_cache_extent(cache);
3663
3664 if (rec->found_ref == 0 &&
3665 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3666 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3667 ret = check_orphan_item(root->fs_info->tree_root,
3668 rec->objectid);
3669 if (ret == 0)
3670 continue;
3671
3672 /*
3673 * If we don't have a root item then we likely just have
3674 * a dir item in a snapshot for this root but no actual
3675 * ref key or anything so it's meaningless.
3676 */
3677 if (!rec->found_root_item)
3678 continue;
3679 errors++;
3680 fprintf(stderr, "fs tree %llu not referenced\n",
3681 (unsigned long long)rec->objectid);
3682 }
3683
3684 error = 0;
3685 if (rec->found_ref > 0 && !rec->found_root_item)
3686 error = 1;
3687 list_for_each_entry(backref, &rec->backrefs, list) {
3688 if (!backref->found_dir_item)
3689 backref->errors |= REF_ERR_NO_DIR_ITEM;
3690 if (!backref->found_dir_index)
3691 backref->errors |= REF_ERR_NO_DIR_INDEX;
3692 if (!backref->found_back_ref)
3693 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3694 if (!backref->found_forward_ref)
3695 backref->errors |= REF_ERR_NO_ROOT_REF;
3696 if (backref->reachable && backref->errors)
3697 error = 1;
3698 }
3699 if (!error)
3700 continue;
3701
3702 errors++;
3703 fprintf(stderr, "fs tree %llu refs %u %s\n",
3704 (unsigned long long)rec->objectid, rec->found_ref,
3705 rec->found_root_item ? "" : "not found");
3706
3707 list_for_each_entry(backref, &rec->backrefs, list) {
3708 if (!backref->reachable)
3709 continue;
3710 if (!backref->errors && rec->found_root_item)
3711 continue;
3712 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3713 " index %llu namelen %u name %s errors %x\n",
3714 (unsigned long long)backref->ref_root,
3715 (unsigned long long)backref->dir,
3716 (unsigned long long)backref->index,
3717 backref->namelen, backref->name,
3718 backref->errors);
3719 print_ref_error(backref->errors);
3720 }
3721 }
3722 return errors > 0 ? 1 : 0;
3723 }
3724
3725 static int process_root_ref(struct extent_buffer *eb, int slot,
3726 struct btrfs_key *key,
3727 struct cache_tree *root_cache)
3728 {
3729 u64 dirid;
3730 u64 index;
3731 u32 len;
3732 u32 name_len;
3733 struct btrfs_root_ref *ref;
3734 char namebuf[BTRFS_NAME_LEN];
3735 int error;
3736
3737 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3738
3739 dirid = btrfs_root_ref_dirid(eb, ref);
3740 index = btrfs_root_ref_sequence(eb, ref);
3741 name_len = btrfs_root_ref_name_len(eb, ref);
3742
3743 if (name_len <= BTRFS_NAME_LEN) {
3744 len = name_len;
3745 error = 0;
3746 } else {
3747 len = BTRFS_NAME_LEN;
3748 error = REF_ERR_NAME_TOO_LONG;
3749 }
3750 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3751
3752 if (key->type == BTRFS_ROOT_REF_KEY) {
3753 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3754 index, namebuf, len, key->type, error);
3755 } else {
3756 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3757 index, namebuf, len, key->type, error);
3758 }
3759 return 0;
3760 }
3761
3762 static void free_corrupt_block(struct cache_extent *cache)
3763 {
3764 struct btrfs_corrupt_block *corrupt;
3765
3766 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3767 free(corrupt);
3768 }
3769
3770 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3771
3772 /*
3773 * Repair the btree of the given root.
3774 *
3775 * The fix is to remove the node key in corrupt_blocks cache_tree.
3776 * and rebalance the tree.
3777 * After the fix, the btree should be writeable.
3778 */
3779 static int repair_btree(struct btrfs_root *root,
3780 struct cache_tree *corrupt_blocks)
3781 {
3782 struct btrfs_trans_handle *trans;
3783 struct btrfs_path path;
3784 struct btrfs_corrupt_block *corrupt;
3785 struct cache_extent *cache;
3786 struct btrfs_key key;
3787 u64 offset;
3788 int level;
3789 int ret = 0;
3790
3791 if (cache_tree_empty(corrupt_blocks))
3792 return 0;
3793
3794 trans = btrfs_start_transaction(root, 1);
3795 if (IS_ERR(trans)) {
3796 ret = PTR_ERR(trans);
3797 fprintf(stderr, "Error starting transaction: %s\n",
3798 strerror(-ret));
3799 return ret;
3800 }
3801 btrfs_init_path(&path);
3802 cache = first_cache_extent(corrupt_blocks);
3803 while (cache) {
3804 corrupt = container_of(cache, struct btrfs_corrupt_block,
3805 cache);
3806 level = corrupt->level;
3807 path.lowest_level = level;
3808 key.objectid = corrupt->key.objectid;
3809 key.type = corrupt->key.type;
3810 key.offset = corrupt->key.offset;
3811
3812 /*
3813 * Here we don't want to do any tree balance, since it may
3814 * cause a balance with corrupted brother leaf/node,
3815 * so ins_len set to 0 here.
3816 * Balance will be done after all corrupt node/leaf is deleted.
3817 */
3818 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
3819 if (ret < 0)
3820 goto out;
3821 offset = btrfs_node_blockptr(path.nodes[level],
3822 path.slots[level]);
3823
3824 /* Remove the ptr */
3825 ret = btrfs_del_ptr(root, &path, level, path.slots[level]);
3826 if (ret < 0)
3827 goto out;
3828 /*
3829 * Remove the corresponding extent
3830 * return value is not concerned.
3831 */
3832 btrfs_release_path(&path);
3833 ret = btrfs_free_extent(trans, root, offset, root->nodesize,
3834 0, root->root_key.objectid,
3835 level - 1, 0);
3836 cache = next_cache_extent(cache);
3837 }
3838
3839 /* Balance the btree using btrfs_search_slot() */
3840 cache = first_cache_extent(corrupt_blocks);
3841 while (cache) {
3842 corrupt = container_of(cache, struct btrfs_corrupt_block,
3843 cache);
3844 memcpy(&key, &corrupt->key, sizeof(key));
3845 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
3846 if (ret < 0)
3847 goto out;
3848 /* return will always >0 since it won't find the item */
3849 ret = 0;
3850 btrfs_release_path(&path);
3851 cache = next_cache_extent(cache);
3852 }
3853 out:
3854 btrfs_commit_transaction(trans, root);
3855 btrfs_release_path(&path);
3856 return ret;
3857 }
3858
3859 static int check_fs_root(struct btrfs_root *root,
3860 struct cache_tree *root_cache,
3861 struct walk_control *wc)
3862 {
3863 int ret = 0;
3864 int err = 0;
3865 int wret;
3866 int level;
3867 struct btrfs_path path;
3868 struct shared_node root_node;
3869 struct root_record *rec;
3870 struct btrfs_root_item *root_item = &root->root_item;
3871 struct cache_tree corrupt_blocks;
3872 struct orphan_data_extent *orphan;
3873 struct orphan_data_extent *tmp;
3874 enum btrfs_tree_block_status status;
3875 struct node_refs nrefs;
3876
3877 /*
3878 * Reuse the corrupt_block cache tree to record corrupted tree block
3879 *
3880 * Unlike the usage in extent tree check, here we do it in a per
3881 * fs/subvol tree base.
3882 */
3883 cache_tree_init(&corrupt_blocks);
3884 root->fs_info->corrupt_blocks = &corrupt_blocks;
3885
3886 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3887 rec = get_root_rec(root_cache, root->root_key.objectid);
3888 BUG_ON(IS_ERR(rec));
3889 if (btrfs_root_refs(root_item) > 0)
3890 rec->found_root_item = 1;
3891 }
3892
3893 btrfs_init_path(&path);
3894 memset(&root_node, 0, sizeof(root_node));
3895 cache_tree_init(&root_node.root_cache);
3896 cache_tree_init(&root_node.inode_cache);
3897 memset(&nrefs, 0, sizeof(nrefs));
3898
3899 /* Move the orphan extent record to corresponding inode_record */
3900 list_for_each_entry_safe(orphan, tmp,
3901 &root->orphan_data_extents, list) {
3902 struct inode_record *inode;
3903
3904 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3905 1);
3906 BUG_ON(IS_ERR(inode));
3907 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3908 list_move(&orphan->list, &inode->orphan_extents);
3909 }
3910
3911 level = btrfs_header_level(root->node);
3912 memset(wc->nodes, 0, sizeof(wc->nodes));
3913 wc->nodes[level] = &root_node;
3914 wc->active_node = level;
3915 wc->root_level = level;
3916
3917 /* We may not have checked the root block, lets do that now */
3918 if (btrfs_is_leaf(root->node))
3919 status = btrfs_check_leaf(root, NULL, root->node);
3920 else
3921 status = btrfs_check_node(root, NULL, root->node);
3922 if (status != BTRFS_TREE_BLOCK_CLEAN)
3923 return -EIO;
3924
3925 if (btrfs_root_refs(root_item) > 0 ||
3926 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3927 path.nodes[level] = root->node;
3928 extent_buffer_get(root->node);
3929 path.slots[level] = 0;
3930 } else {
3931 struct btrfs_key key;
3932 struct btrfs_disk_key found_key;
3933
3934 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3935 level = root_item->drop_level;
3936 path.lowest_level = level;
3937 if (level > btrfs_header_level(root->node) ||
3938 level >= BTRFS_MAX_LEVEL) {
3939 error("ignoring invalid drop level: %u", level);
3940 goto skip_walking;
3941 }
3942 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3943 if (wret < 0)
3944 goto skip_walking;
3945 btrfs_node_key(path.nodes[level], &found_key,
3946 path.slots[level]);
3947 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3948 sizeof(found_key)));
3949 }
3950
3951 while (1) {
3952 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
3953 if (wret < 0)
3954 ret = wret;
3955 if (wret != 0)
3956 break;
3957
3958 wret = walk_up_tree(root, &path, wc, &level);
3959 if (wret < 0)
3960 ret = wret;
3961 if (wret != 0)
3962 break;
3963 }
3964 skip_walking:
3965 btrfs_release_path(&path);
3966
3967 if (!cache_tree_empty(&corrupt_blocks)) {
3968 struct cache_extent *cache;
3969 struct btrfs_corrupt_block *corrupt;
3970
3971 printf("The following tree block(s) is corrupted in tree %llu:\n",
3972 root->root_key.objectid);
3973 cache = first_cache_extent(&corrupt_blocks);
3974 while (cache) {
3975 corrupt = container_of(cache,
3976 struct btrfs_corrupt_block,
3977 cache);
3978 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
3979 cache->start, corrupt->level,
3980 corrupt->key.objectid, corrupt->key.type,
3981 corrupt->key.offset);
3982 cache = next_cache_extent(cache);
3983 }
3984 if (repair) {
3985 printf("Try to repair the btree for root %llu\n",
3986 root->root_key.objectid);
3987 ret = repair_btree(root, &corrupt_blocks);
3988 if (ret < 0)
3989 fprintf(stderr, "Failed to repair btree: %s\n",
3990 strerror(-ret));
3991 if (!ret)
3992 printf("Btree for root %llu is fixed\n",
3993 root->root_key.objectid);
3994 }
3995 }
3996
3997 err = merge_root_recs(root, &root_node.root_cache, root_cache);
3998 if (err < 0)
3999 ret = err;
4000
4001 if (root_node.current) {
4002 root_node.current->checked = 1;
4003 maybe_free_inode_rec(&root_node.inode_cache,
4004 root_node.current);
4005 }
4006
4007 err = check_inode_recs(root, &root_node.inode_cache);
4008 if (!ret)
4009 ret = err;
4010
4011 free_corrupt_blocks_tree(&corrupt_blocks);
4012 root->fs_info->corrupt_blocks = NULL;
4013 free_orphan_data_extents(&root->orphan_data_extents);
4014 return ret;
4015 }
4016
4017 static int fs_root_objectid(u64 objectid)
4018 {
4019 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4020 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4021 return 1;
4022 return is_fstree(objectid);
4023 }
4024
4025 static int check_fs_roots(struct btrfs_root *root,
4026 struct cache_tree *root_cache)
4027 {
4028 struct btrfs_path path;
4029 struct btrfs_key key;
4030 struct walk_control wc;
4031 struct extent_buffer *leaf, *tree_node;
4032 struct btrfs_root *tmp_root;
4033 struct btrfs_root *tree_root = root->fs_info->tree_root;
4034 int ret;
4035 int err = 0;
4036
4037 if (ctx.progress_enabled) {
4038 ctx.tp = TASK_FS_ROOTS;
4039 task_start(ctx.info);
4040 }
4041
4042 /*
4043 * Just in case we made any changes to the extent tree that weren't
4044 * reflected into the free space cache yet.
4045 */
4046 if (repair)
4047 reset_cached_block_groups(root->fs_info);
4048 memset(&wc, 0, sizeof(wc));
4049 cache_tree_init(&wc.shared);
4050 btrfs_init_path(&path);
4051
4052 again:
4053 key.offset = 0;
4054 key.objectid = 0;
4055 key.type = BTRFS_ROOT_ITEM_KEY;
4056 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4057 if (ret < 0) {
4058 err = 1;
4059 goto out;
4060 }
4061 tree_node = tree_root->node;
4062 while (1) {
4063 if (tree_node != tree_root->node) {
4064 free_root_recs_tree(root_cache);
4065 btrfs_release_path(&path);
4066 goto again;
4067 }
4068 leaf = path.nodes[0];
4069 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4070 ret = btrfs_next_leaf(tree_root, &path);
4071 if (ret) {
4072 if (ret < 0)
4073 err = 1;
4074 break;
4075 }
4076 leaf = path.nodes[0];
4077 }
4078 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4079 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4080 fs_root_objectid(key.objectid)) {
4081 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4082 tmp_root = btrfs_read_fs_root_no_cache(
4083 root->fs_info, &key);
4084 } else {
4085 key.offset = (u64)-1;
4086 tmp_root = btrfs_read_fs_root(
4087 root->fs_info, &key);
4088 }
4089 if (IS_ERR(tmp_root)) {
4090 err = 1;
4091 goto next;
4092 }
4093 ret = check_fs_root(tmp_root, root_cache, &wc);
4094 if (ret == -EAGAIN) {
4095 free_root_recs_tree(root_cache);
4096 btrfs_release_path(&path);
4097 goto again;
4098 }
4099 if (ret)
4100 err = 1;
4101 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4102 btrfs_free_fs_root(tmp_root);
4103 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4104 key.type == BTRFS_ROOT_BACKREF_KEY) {
4105 process_root_ref(leaf, path.slots[0], &key,
4106 root_cache);
4107 }
4108 next:
4109 path.slots[0]++;
4110 }
4111 out:
4112 btrfs_release_path(&path);
4113 if (err)
4114 free_extent_cache_tree(&wc.shared);
4115 if (!cache_tree_empty(&wc.shared))
4116 fprintf(stderr, "warning line %d\n", __LINE__);
4117
4118 task_stop(ctx.info);
4119
4120 return err;
4121 }
4122
4123 /*
4124 * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4125 * INODE_REF/INODE_EXTREF match.
4126 *
4127 * @root: the root of the fs/file tree
4128 * @ref_key: the key of the INODE_REF/INODE_EXTREF
4129 * @key: the key of the DIR_ITEM/DIR_INDEX
4130 * @index: the index in the INODE_REF/INODE_EXTREF, be used to
4131 * distinguish root_dir between normal dir/file
4132 * @name: the name in the INODE_REF/INODE_EXTREF
4133 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4134 * @mode: the st_mode of INODE_ITEM
4135 *
4136 * Return 0 if no error occurred.
4137 * Return ROOT_DIR_ERROR if found DIR_ITEM/DIR_INDEX for root_dir.
4138 * Return DIR_ITEM_MISSING if couldn't find DIR_ITEM/DIR_INDEX for normal
4139 * dir/file.
4140 * Return DIR_ITEM_MISMATCH if INODE_REF/INODE_EXTREF and DIR_ITEM/DIR_INDEX
4141 * not match for normal dir/file.
4142 */
4143 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *ref_key,
4144 struct btrfs_key *key, u64 index, char *name,
4145 u32 namelen, u32 mode)
4146 {
4147 struct btrfs_path path;
4148 struct extent_buffer *node;
4149 struct btrfs_dir_item *di;
4150 struct btrfs_key location;
4151 char namebuf[BTRFS_NAME_LEN] = {0};
4152 u32 total;
4153 u32 cur = 0;
4154 u32 len;
4155 u32 name_len;
4156 u32 data_len;
4157 u8 filetype;
4158 int slot;
4159 int ret;
4160
4161 btrfs_init_path(&path);
4162 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4163 if (ret < 0) {
4164 ret = DIR_ITEM_MISSING;
4165 goto out;
4166 }
4167
4168 /* Process root dir and goto out*/
4169 if (index == 0) {
4170 if (ret == 0) {
4171 ret = ROOT_DIR_ERROR;
4172 error(
4173 "root %llu INODE %s[%llu %llu] ROOT_DIR shouldn't have %s",
4174 root->objectid,
4175 ref_key->type == BTRFS_INODE_REF_KEY ?
4176 "REF" : "EXTREF",
4177 ref_key->objectid, ref_key->offset,
4178 key->type == BTRFS_DIR_ITEM_KEY ?
4179 "DIR_ITEM" : "DIR_INDEX");
4180 } else {
4181 ret = 0;
4182 }
4183
4184 goto out;
4185 }
4186
4187 /* Process normal file/dir */
4188 if (ret > 0) {
4189 ret = DIR_ITEM_MISSING;
4190 error(
4191 "root %llu INODE %s[%llu %llu] doesn't have related %s[%llu %llu] namelen %u filename %s filetype %d",
4192 root->objectid,
4193 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4194 ref_key->objectid, ref_key->offset,
4195 key->type == BTRFS_DIR_ITEM_KEY ?
4196 "DIR_ITEM" : "DIR_INDEX",
4197 key->objectid, key->offset, namelen, name,
4198 imode_to_type(mode));
4199 goto out;
4200 }
4201
4202 /* Check whether inode_id/filetype/name match */
4203 node = path.nodes[0];
4204 slot = path.slots[0];
4205 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4206 total = btrfs_item_size_nr(node, slot);
4207 while (cur < total) {
4208 ret = DIR_ITEM_MISMATCH;
4209 name_len = btrfs_dir_name_len(node, di);
4210 data_len = btrfs_dir_data_len(node, di);
4211
4212 btrfs_dir_item_key_to_cpu(node, di, &location);
4213 if (location.objectid != ref_key->objectid ||
4214 location.type != BTRFS_INODE_ITEM_KEY ||
4215 location.offset != 0)
4216 goto next;
4217
4218 filetype = btrfs_dir_type(node, di);
4219 if (imode_to_type(mode) != filetype)
4220 goto next;
4221
4222 if (name_len <= BTRFS_NAME_LEN) {
4223 len = name_len;
4224 } else {
4225 len = BTRFS_NAME_LEN;
4226 warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4227 root->objectid,
4228 key->type == BTRFS_DIR_ITEM_KEY ?
4229 "DIR_ITEM" : "DIR_INDEX",
4230 key->objectid, key->offset, name_len);
4231 }
4232 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4233 if (len != namelen || strncmp(namebuf, name, len))
4234 goto next;
4235
4236 ret = 0;
4237 goto out;
4238 next:
4239 len = sizeof(*di) + name_len + data_len;
4240 di = (struct btrfs_dir_item *)((char *)di + len);
4241 cur += len;
4242 }
4243 if (ret == DIR_ITEM_MISMATCH)
4244 error(
4245 "root %llu INODE %s[%llu %llu] and %s[%llu %llu] mismatch namelen %u filename %s filetype %d",
4246 root->objectid,
4247 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4248 ref_key->objectid, ref_key->offset,
4249 key->type == BTRFS_DIR_ITEM_KEY ?
4250 "DIR_ITEM" : "DIR_INDEX",
4251 key->objectid, key->offset, namelen, name,
4252 imode_to_type(mode));
4253 out:
4254 btrfs_release_path(&path);
4255 return ret;
4256 }
4257
4258 /*
4259 * Traverse the given INODE_REF and call find_dir_item() to find related
4260 * DIR_ITEM/DIR_INDEX.
4261 *
4262 * @root: the root of the fs/file tree
4263 * @ref_key: the key of the INODE_REF
4264 * @refs: the count of INODE_REF
4265 * @mode: the st_mode of INODE_ITEM
4266 *
4267 * Return 0 if no error occurred.
4268 */
4269 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4270 struct extent_buffer *node, int slot, u64 *refs,
4271 int mode)
4272 {
4273 struct btrfs_key key;
4274 struct btrfs_inode_ref *ref;
4275 char namebuf[BTRFS_NAME_LEN] = {0};
4276 u32 total;
4277 u32 cur = 0;
4278 u32 len;
4279 u32 name_len;
4280 u64 index;
4281 int ret, err = 0;
4282
4283 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4284 total = btrfs_item_size_nr(node, slot);
4285
4286 next:
4287 /* Update inode ref count */
4288 (*refs)++;
4289
4290 index = btrfs_inode_ref_index(node, ref);
4291 name_len = btrfs_inode_ref_name_len(node, ref);
4292 if (name_len <= BTRFS_NAME_LEN) {
4293 len = name_len;
4294 } else {
4295 len = BTRFS_NAME_LEN;
4296 warning("root %llu INODE_REF[%llu %llu] name too long",
4297 root->objectid, ref_key->objectid, ref_key->offset);
4298 }
4299
4300 read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
4301
4302 /* Check root dir ref name */
4303 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4304 error("root %llu INODE_REF[%llu %llu] ROOT_DIR name shouldn't be %s",
4305 root->objectid, ref_key->objectid, ref_key->offset,
4306 namebuf);
4307 err |= ROOT_DIR_ERROR;
4308 }
4309
4310 /* Find related DIR_INDEX */
4311 key.objectid = ref_key->offset;
4312 key.type = BTRFS_DIR_INDEX_KEY;
4313 key.offset = index;
4314 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4315 err |= ret;
4316
4317 /* Find related dir_item */
4318 key.objectid = ref_key->offset;
4319 key.type = BTRFS_DIR_ITEM_KEY;
4320 key.offset = btrfs_name_hash(namebuf, len);
4321 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4322 err |= ret;
4323
4324 len = sizeof(*ref) + name_len;
4325 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4326 cur += len;
4327 if (cur < total)
4328 goto next;
4329
4330 return err;
4331 }
4332
4333 /*
4334 * Traverse the given INODE_EXTREF and call find_dir_item() to find related
4335 * DIR_ITEM/DIR_INDEX.
4336 *
4337 * @root: the root of the fs/file tree
4338 * @ref_key: the key of the INODE_EXTREF
4339 * @refs: the count of INODE_EXTREF
4340 * @mode: the st_mode of INODE_ITEM
4341 *
4342 * Return 0 if no error occurred.
4343 */
4344 static int check_inode_extref(struct btrfs_root *root,
4345 struct btrfs_key *ref_key,
4346 struct extent_buffer *node, int slot, u64 *refs,
4347 int mode)
4348 {
4349 struct btrfs_key key;
4350 struct btrfs_inode_extref *extref;
4351 char namebuf[BTRFS_NAME_LEN] = {0};
4352 u32 total;
4353 u32 cur = 0;
4354 u32 len;
4355 u32 name_len;
4356 u64 index;
4357 u64 parent;
4358 int ret;
4359 int err = 0;
4360
4361 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4362 total = btrfs_item_size_nr(node, slot);
4363
4364 next:
4365 /* update inode ref count */
4366 (*refs)++;
4367 name_len = btrfs_inode_extref_name_len(node, extref);
4368 index = btrfs_inode_extref_index(node, extref);
4369 parent = btrfs_inode_extref_parent(node, extref);
4370 if (name_len <= BTRFS_NAME_LEN) {
4371 len = name_len;
4372 } else {
4373 len = BTRFS_NAME_LEN;
4374 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
4375 root->objectid, ref_key->objectid, ref_key->offset);
4376 }
4377 read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
4378
4379 /* Check root dir ref name */
4380 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4381 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
4382 root->objectid, ref_key->objectid, ref_key->offset,
4383 namebuf);
4384 err |= ROOT_DIR_ERROR;
4385 }
4386
4387 /* find related dir_index */
4388 key.objectid = parent;
4389 key.type = BTRFS_DIR_INDEX_KEY;
4390 key.offset = index;
4391 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4392 err |= ret;
4393
4394 /* find related dir_item */
4395 key.objectid = parent;
4396 key.type = BTRFS_DIR_ITEM_KEY;
4397 key.offset = btrfs_name_hash(namebuf, len);
4398 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4399 err |= ret;
4400
4401 len = sizeof(*extref) + name_len;
4402 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4403 cur += len;
4404
4405 if (cur < total)
4406 goto next;
4407
4408 return err;
4409 }
4410
4411 /*
4412 * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
4413 * DIR_ITEM/DIR_INDEX match.
4414 *
4415 * @root: the root of the fs/file tree
4416 * @key: the key of the INODE_REF/INODE_EXTREF
4417 * @name: the name in the INODE_REF/INODE_EXTREF
4418 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4419 * @index: the index in the INODE_REF/INODE_EXTREF, for DIR_ITEM set index
4420 * to (u64)-1
4421 * @ext_ref: the EXTENDED_IREF feature
4422 *
4423 * Return 0 if no error occurred.
4424 * Return >0 for error bitmap
4425 */
4426 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
4427 char *name, int namelen, u64 index,
4428 unsigned int ext_ref)
4429 {
4430 struct btrfs_path path;
4431 struct btrfs_inode_ref *ref;
4432 struct btrfs_inode_extref *extref;
4433 struct extent_buffer *node;
4434 char ref_namebuf[BTRFS_NAME_LEN] = {0};
4435 u32 total;
4436 u32 cur = 0;
4437 u32 len;
4438 u32 ref_namelen;
4439 u64 ref_index;
4440 u64 parent;
4441 u64 dir_id;
4442 int slot;
4443 int ret;
4444
4445 btrfs_init_path(&path);
4446 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4447 if (ret) {
4448 ret = INODE_REF_MISSING;
4449 goto extref;
4450 }
4451
4452 node = path.nodes[0];
4453 slot = path.slots[0];
4454
4455 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4456 total = btrfs_item_size_nr(node, slot);
4457
4458 /* Iterate all entry of INODE_REF */
4459 while (cur < total) {
4460 ret = INODE_REF_MISSING;
4461
4462 ref_namelen = btrfs_inode_ref_name_len(node, ref);
4463 ref_index = btrfs_inode_ref_index(node, ref);
4464 if (index != (u64)-1 && index != ref_index)
4465 goto next_ref;
4466
4467 if (ref_namelen <= BTRFS_NAME_LEN) {
4468 len = ref_namelen;
4469 } else {
4470 len = BTRFS_NAME_LEN;
4471 warning("root %llu INODE %s[%llu %llu] name too long",
4472 root->objectid,
4473 key->type == BTRFS_INODE_REF_KEY ?
4474 "REF" : "EXTREF",
4475 key->objectid, key->offset);
4476 }
4477 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
4478 len);
4479
4480 if (len != namelen || strncmp(ref_namebuf, name, len))
4481 goto next_ref;
4482
4483 ret = 0;
4484 goto out;
4485 next_ref:
4486 len = sizeof(*ref) + ref_namelen;
4487 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4488 cur += len;
4489 }
4490
4491 extref:
4492 /* Skip if not support EXTENDED_IREF feature */
4493 if (!ext_ref)
4494 goto out;
4495
4496 btrfs_release_path(&path);
4497 btrfs_init_path(&path);
4498
4499 dir_id = key->offset;
4500 key->type = BTRFS_INODE_EXTREF_KEY;
4501 key->offset = btrfs_extref_hash(dir_id, name, namelen);
4502
4503 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4504 if (ret) {
4505 ret = INODE_REF_MISSING;
4506 goto out;
4507 }
4508
4509 node = path.nodes[0];
4510 slot = path.slots[0];
4511
4512 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4513 cur = 0;
4514 total = btrfs_item_size_nr(node, slot);
4515
4516 /* Iterate all entry of INODE_EXTREF */
4517 while (cur < total) {
4518 ret = INODE_REF_MISSING;
4519
4520 ref_namelen = btrfs_inode_extref_name_len(node, extref);
4521 ref_index = btrfs_inode_extref_index(node, extref);
4522 parent = btrfs_inode_extref_parent(node, extref);
4523 if (index != (u64)-1 && index != ref_index)
4524 goto next_extref;
4525
4526 if (parent != dir_id)
4527 goto next_extref;
4528
4529 if (ref_namelen <= BTRFS_NAME_LEN) {
4530 len = ref_namelen;
4531 } else {
4532 len = BTRFS_NAME_LEN;
4533 warning("root %llu INODE %s[%llu %llu] name too long",
4534 root->objectid,
4535 key->type == BTRFS_INODE_REF_KEY ?
4536 "REF" : "EXTREF",
4537 key->objectid, key->offset);
4538 }
4539 read_extent_buffer(node, ref_namebuf,
4540 (unsigned long)(extref + 1), len);
4541
4542 if (len != namelen || strncmp(ref_namebuf, name, len))
4543 goto next_extref;
4544
4545 ret = 0;
4546 goto out;
4547
4548 next_extref:
4549 len = sizeof(*extref) + ref_namelen;
4550 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4551 cur += len;
4552
4553 }
4554 out:
4555 btrfs_release_path(&path);
4556 return ret;
4557 }
4558
4559 /*
4560 * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
4561 * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
4562 *
4563 * @root: the root of the fs/file tree
4564 * @key: the key of the INODE_REF/INODE_EXTREF
4565 * @size: the st_size of the INODE_ITEM
4566 * @ext_ref: the EXTENDED_IREF feature
4567 *
4568 * Return 0 if no error occurred.
4569 */
4570 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4571 struct extent_buffer *node, int slot, u64 *size,
4572 unsigned int ext_ref)
4573 {
4574 struct btrfs_dir_item *di;
4575 struct btrfs_inode_item *ii;
4576 struct btrfs_path path;
4577 struct btrfs_key location;
4578 char namebuf[BTRFS_NAME_LEN] = {0};
4579 u32 total;
4580 u32 cur = 0;
4581 u32 len;
4582 u32 name_len;
4583 u32 data_len;
4584 u8 filetype;
4585 u32 mode;
4586 u64 index;
4587 int ret;
4588 int err = 0;
4589
4590 /*
4591 * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
4592 * ignore index check.
4593 */
4594 index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
4595
4596 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4597 total = btrfs_item_size_nr(node, slot);
4598
4599 while (cur < total) {
4600 data_len = btrfs_dir_data_len(node, di);
4601 if (data_len)
4602 error("root %llu %s[%llu %llu] data_len shouldn't be %u",
4603 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4604 "DIR_ITEM" : "DIR_INDEX",
4605 key->objectid, key->offset, data_len);
4606
4607 name_len = btrfs_dir_name_len(node, di);
4608 if (name_len <= BTRFS_NAME_LEN) {
4609 len = name_len;
4610 } else {
4611 len = BTRFS_NAME_LEN;
4612 warning("root %llu %s[%llu %llu] name too long",
4613 root->objectid,
4614 key->type == BTRFS_DIR_ITEM_KEY ?
4615 "DIR_ITEM" : "DIR_INDEX",
4616 key->objectid, key->offset);
4617 }
4618 (*size) += name_len;
4619
4620 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4621 filetype = btrfs_dir_type(node, di);
4622
4623 btrfs_init_path(&path);
4624 btrfs_dir_item_key_to_cpu(node, di, &location);
4625
4626 /* Ignore related ROOT_ITEM check */
4627 if (location.type == BTRFS_ROOT_ITEM_KEY)
4628 goto next;
4629
4630 /* Check relative INODE_ITEM(existence/filetype) */
4631 ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
4632 if (ret) {
4633 err |= INODE_ITEM_MISSING;
4634 error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
4635 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4636 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4637 key->offset, location.objectid, name_len,
4638 namebuf, filetype);
4639 goto next;
4640 }
4641
4642 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4643 struct btrfs_inode_item);
4644 mode = btrfs_inode_mode(path.nodes[0], ii);
4645
4646 if (imode_to_type(mode) != filetype) {
4647 err |= INODE_ITEM_MISMATCH;
4648 error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
4649 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4650 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4651 key->offset, name_len, namebuf, filetype);
4652 }
4653
4654 /* Check relative INODE_REF/INODE_EXTREF */
4655 location.type = BTRFS_INODE_REF_KEY;
4656 location.offset = key->objectid;
4657 ret = find_inode_ref(root, &location, namebuf, len,
4658 index, ext_ref);
4659 err |= ret;
4660 if (ret & INODE_REF_MISSING)
4661 error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
4662 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4663 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4664 key->offset, name_len, namebuf, filetype);
4665
4666 next:
4667 btrfs_release_path(&path);
4668 len = sizeof(*di) + name_len + data_len;
4669 di = (struct btrfs_dir_item *)((char *)di + len);
4670 cur += len;
4671
4672 if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
4673 error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
4674 root->objectid, key->objectid, key->offset);
4675 break;
4676 }
4677 }
4678
4679 return err;
4680 }
4681
4682 /*
4683 * Check file extent datasum/hole, update the size of the file extents,
4684 * check and update the last offset of the file extent.
4685 *
4686 * @root: the root of fs/file tree.
4687 * @fkey: the key of the file extent.
4688 * @nodatasum: INODE_NODATASUM feature.
4689 * @size: the sum of all EXTENT_DATA items size for this inode.
4690 * @end: the offset of the last extent.
4691 *
4692 * Return 0 if no error occurred.
4693 */
4694 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
4695 struct extent_buffer *node, int slot,
4696 unsigned int nodatasum, u64 *size, u64 *end)
4697 {
4698 struct btrfs_file_extent_item *fi;
4699 u64 disk_bytenr;
4700 u64 disk_num_bytes;
4701 u64 extent_num_bytes;
4702 u64 extent_offset;
4703 u64 csum_found; /* In byte size, sectorsize aligned */
4704 u64 search_start; /* Logical range start we search for csum */
4705 u64 search_len; /* Logical range len we search for csum */
4706 unsigned int extent_type;
4707 unsigned int is_hole;
4708 int compressed = 0;
4709 int ret;
4710 int err = 0;
4711
4712 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4713
4714 /* Check inline extent */
4715 extent_type = btrfs_file_extent_type(node, fi);
4716 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4717 struct btrfs_item *e = btrfs_item_nr(slot);
4718 u32 item_inline_len;
4719
4720 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4721 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4722 compressed = btrfs_file_extent_compression(node, fi);
4723 if (extent_num_bytes == 0) {
4724 error(
4725 "root %llu EXTENT_DATA[%llu %llu] has empty inline extent",
4726 root->objectid, fkey->objectid, fkey->offset);
4727 err |= FILE_EXTENT_ERROR;
4728 }
4729 if (!compressed && extent_num_bytes != item_inline_len) {
4730 error(
4731 "root %llu EXTENT_DATA[%llu %llu] wrong inline size, have: %llu, expected: %u",
4732 root->objectid, fkey->objectid, fkey->offset,
4733 extent_num_bytes, item_inline_len);
4734 err |= FILE_EXTENT_ERROR;
4735 }
4736 *size += extent_num_bytes;
4737 return err;
4738 }
4739
4740 /* Check extent type */
4741 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4742 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4743 err |= FILE_EXTENT_ERROR;
4744 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4745 root->objectid, fkey->objectid, fkey->offset);
4746 return err;
4747 }
4748
4749 /* Check REG_EXTENT/PREALLOC_EXTENT */
4750 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4751 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4752 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4753 extent_offset = btrfs_file_extent_offset(node, fi);
4754 compressed = btrfs_file_extent_compression(node, fi);
4755 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4756
4757 /*
4758 * Check EXTENT_DATA csum
4759 *
4760 * For plain (uncompressed) extent, we should only check the range
4761 * we're referring to, as it's possible that part of prealloc extent
4762 * has been written, and has csum:
4763 *
4764 * |<--- Original large preallocated extent A ---->|
4765 * |<- Prealloc File Extent ->|<- Regular Extent ->|
4766 * No csum Has csum
4767 *
4768 * For compressed extent, we should check the whole range.
4769 */
4770 if (!compressed) {
4771 search_start = disk_bytenr + extent_offset;
4772 search_len = extent_num_bytes;
4773 } else {
4774 search_start = disk_bytenr;
4775 search_len = disk_num_bytes;
4776 }
4777 ret = count_csum_range(root, search_start, search_len, &csum_found);
4778 if (csum_found > 0 && nodatasum) {
4779 err |= ODD_CSUM_ITEM;
4780 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4781 root->objectid, fkey->objectid, fkey->offset);
4782 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4783 !is_hole && (ret < 0 || csum_found < search_len)) {
4784 err |= CSUM_ITEM_MISSING;
4785 error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
4786 root->objectid, fkey->objectid, fkey->offset,
4787 csum_found, search_len);
4788 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
4789 err |= ODD_CSUM_ITEM;
4790 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
4791 root->objectid, fkey->objectid, fkey->offset, csum_found);
4792 }
4793
4794 /* Check EXTENT_DATA hole */
4795 if (no_holes && is_hole) {
4796 err |= FILE_EXTENT_ERROR;
4797 error("root %llu EXTENT_DATA[%llu %llu] shouldn't be hole",
4798 root->objectid, fkey->objectid, fkey->offset);
4799 } else if (!no_holes && *end != fkey->offset) {
4800 err |= FILE_EXTENT_ERROR;
4801 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4802 root->objectid, fkey->objectid, fkey->offset);
4803 }
4804
4805 *end += extent_num_bytes;
4806 if (!is_hole)
4807 *size += extent_num_bytes;
4808
4809 return err;
4810 }
4811
4812 /*
4813 * Check INODE_ITEM and related ITEMs (the same inode number)
4814 * 1. check link count
4815 * 2. check inode ref/extref
4816 * 3. check dir item/index
4817 *
4818 * @ext_ref: the EXTENDED_IREF feature
4819 *
4820 * Return 0 if no error occurred.
4821 * Return >0 for error or hit the traversal is done(by error bitmap)
4822 */
4823 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4824 unsigned int ext_ref)
4825 {
4826 struct extent_buffer *node;
4827 struct btrfs_inode_item *ii;
4828 struct btrfs_key key;
4829 u64 inode_id;
4830 u32 mode;
4831 u64 nlink;
4832 u64 nbytes;
4833 u64 isize;
4834 u64 size = 0;
4835 u64 refs = 0;
4836 u64 extent_end = 0;
4837 u64 extent_size = 0;
4838 unsigned int dir;
4839 unsigned int nodatasum;
4840 int slot;
4841 int ret;
4842 int err = 0;
4843
4844 node = path->nodes[0];
4845 slot = path->slots[0];
4846
4847 btrfs_item_key_to_cpu(node, &key, slot);
4848 inode_id = key.objectid;
4849
4850 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4851 ret = btrfs_next_item(root, path);
4852 if (ret > 0)
4853 err |= LAST_ITEM;
4854 return err;
4855 }
4856
4857 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4858 isize = btrfs_inode_size(node, ii);
4859 nbytes = btrfs_inode_nbytes(node, ii);
4860 mode = btrfs_inode_mode(node, ii);
4861 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4862 nlink = btrfs_inode_nlink(node, ii);
4863 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4864
4865 while (1) {
4866 ret = btrfs_next_item(root, path);
4867 if (ret < 0) {
4868 /* out will fill 'err' rusing current statistics */
4869 goto out;
4870 } else if (ret > 0) {
4871 err |= LAST_ITEM;
4872 goto out;
4873 }
4874
4875 node = path->nodes[0];
4876 slot = path->slots[0];
4877 btrfs_item_key_to_cpu(node, &key, slot);
4878 if (key.objectid != inode_id)
4879 goto out;
4880
4881 switch (key.type) {
4882 case BTRFS_INODE_REF_KEY:
4883 ret = check_inode_ref(root, &key, node, slot, &refs,
4884 mode);
4885 err |= ret;
4886 break;
4887 case BTRFS_INODE_EXTREF_KEY:
4888 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4889 warning("root %llu EXTREF[%llu %llu] isn't supported",
4890 root->objectid, key.objectid,
4891 key.offset);
4892 ret = check_inode_extref(root, &key, node, slot, &refs,
4893 mode);
4894 err |= ret;
4895 break;
4896 case BTRFS_DIR_ITEM_KEY:
4897 case BTRFS_DIR_INDEX_KEY:
4898 if (!dir) {
4899 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4900 root->objectid, inode_id,
4901 imode_to_type(mode), key.objectid,
4902 key.offset);
4903 }
4904 ret = check_dir_item(root, &key, node, slot, &size,
4905 ext_ref);
4906 err |= ret;
4907 break;
4908 case BTRFS_EXTENT_DATA_KEY:
4909 if (dir) {
4910 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4911 root->objectid, inode_id, key.objectid,
4912 key.offset);
4913 }
4914 ret = check_file_extent(root, &key, node, slot,
4915 nodatasum, &extent_size,
4916 &extent_end);
4917 err |= ret;
4918 break;
4919 case BTRFS_XATTR_ITEM_KEY:
4920 break;
4921 default:
4922 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4923 key.objectid, key.type, key.offset);
4924 }
4925 }
4926
4927 out:
4928 /* verify INODE_ITEM nlink/isize/nbytes */
4929 if (dir) {
4930 if (nlink != 1) {
4931 err |= LINK_COUNT_ERROR;
4932 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4933 root->objectid, inode_id, nlink);
4934 }
4935
4936 /*
4937 * Just a warning, as dir inode nbytes is just an
4938 * instructive value.
4939 */
4940 if (!IS_ALIGNED(nbytes, root->nodesize)) {
4941 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
4942 root->objectid, inode_id, root->nodesize);
4943 }
4944
4945 if (isize != size) {
4946 err |= ISIZE_ERROR;
4947 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
4948 root->objectid, inode_id, isize, size);
4949 }
4950 } else {
4951 if (nlink != refs) {
4952 err |= LINK_COUNT_ERROR;
4953 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
4954 root->objectid, inode_id, nlink, refs);
4955 } else if (!nlink) {
4956 err |= ORPHAN_ITEM;
4957 }
4958
4959 if (!nbytes && !no_holes && extent_end < isize) {
4960 err |= NBYTES_ERROR;
4961 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
4962 root->objectid, inode_id, isize);
4963 }
4964
4965 if (nbytes != extent_size) {
4966 err |= NBYTES_ERROR;
4967 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
4968 root->objectid, inode_id, nbytes, extent_size);
4969 }
4970 }
4971
4972 return err;
4973 }
4974
4975 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4976 {
4977 struct btrfs_path path;
4978 struct btrfs_key key;
4979 int err = 0;
4980 int ret;
4981
4982 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4983 key.type = BTRFS_INODE_ITEM_KEY;
4984 key.offset = 0;
4985
4986 /* For root being dropped, we don't need to check first inode */
4987 if (btrfs_root_refs(&root->root_item) == 0 &&
4988 btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
4989 key.objectid)
4990 return 0;
4991
4992 btrfs_init_path(&path);
4993
4994 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4995 if (ret < 0)
4996 goto out;
4997 if (ret > 0) {
4998 ret = 0;
4999 err |= INODE_ITEM_MISSING;
5000 error("first inode item of root %llu is missing",
5001 root->objectid);
5002 }
5003
5004 err |= check_inode_item(root, &path, ext_ref);
5005 err &= ~LAST_ITEM;
5006 if (err && !ret)
5007 ret = -EIO;
5008 out:
5009 btrfs_release_path(&path);
5010 return ret;
5011 }
5012
5013 /*
5014 * Iterate all item on the tree and call check_inode_item() to check.
5015 *
5016 * @root: the root of the tree to be checked.
5017 * @ext_ref: the EXTENDED_IREF feature
5018 *
5019 * Return 0 if no error found.
5020 * Return <0 for error.
5021 */
5022 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
5023 {
5024 struct btrfs_path path;
5025 struct node_refs nrefs;
5026 struct btrfs_root_item *root_item = &root->root_item;
5027 int ret, wret;
5028 int level;
5029
5030 /*
5031 * We need to manually check the first inode item(256)
5032 * As the following traversal function will only start from
5033 * the first inode item in the leaf, if inode item(256) is missing
5034 * we will just skip it forever.
5035 */
5036 ret = check_fs_first_inode(root, ext_ref);
5037 if (ret < 0)
5038 return ret;
5039
5040 memset(&nrefs, 0, sizeof(nrefs));
5041 level = btrfs_header_level(root->node);
5042 btrfs_init_path(&path);
5043
5044 if (btrfs_root_refs(root_item) > 0 ||
5045 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5046 path.nodes[level] = root->node;
5047 path.slots[level] = 0;
5048 extent_buffer_get(root->node);
5049 } else {
5050 struct btrfs_key key;
5051
5052 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5053 level = root_item->drop_level;
5054 path.lowest_level = level;
5055 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5056 if (ret < 0)
5057 goto out;
5058 ret = 0;
5059 }
5060
5061 while (1) {
5062 wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5063 if (wret < 0)
5064 ret = wret;
5065 if (wret != 0)
5066 break;
5067
5068 wret = walk_up_tree_v2(root, &path, &level);
5069 if (wret < 0)
5070 ret = wret;
5071 if (wret != 0)
5072 break;
5073 }
5074
5075 out:
5076 btrfs_release_path(&path);
5077 return ret;
5078 }
5079
5080 /*
5081 * Find the relative ref for root_ref and root_backref.
5082 *
5083 * @root: the root of the root tree.
5084 * @ref_key: the key of the root ref.
5085 *
5086 * Return 0 if no error occurred.
5087 */
5088 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5089 struct extent_buffer *node, int slot)
5090 {
5091 struct btrfs_path path;
5092 struct btrfs_key key;
5093 struct btrfs_root_ref *ref;
5094 struct btrfs_root_ref *backref;
5095 char ref_name[BTRFS_NAME_LEN] = {0};
5096 char backref_name[BTRFS_NAME_LEN] = {0};
5097 u64 ref_dirid;
5098 u64 ref_seq;
5099 u32 ref_namelen;
5100 u64 backref_dirid;
5101 u64 backref_seq;
5102 u32 backref_namelen;
5103 u32 len;
5104 int ret;
5105 int err = 0;
5106
5107 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5108 ref_dirid = btrfs_root_ref_dirid(node, ref);
5109 ref_seq = btrfs_root_ref_sequence(node, ref);
5110 ref_namelen = btrfs_root_ref_name_len(node, ref);
5111
5112 if (ref_namelen <= BTRFS_NAME_LEN) {
5113 len = ref_namelen;
5114 } else {
5115 len = BTRFS_NAME_LEN;
5116 warning("%s[%llu %llu] ref_name too long",
5117 ref_key->type == BTRFS_ROOT_REF_KEY ?
5118 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5119 ref_key->offset);
5120 }
5121 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5122
5123 /* Find relative root_ref */
5124 key.objectid = ref_key->offset;
5125 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5126 key.offset = ref_key->objectid;
5127
5128 btrfs_init_path(&path);
5129 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5130 if (ret) {
5131 err |= ROOT_REF_MISSING;
5132 error("%s[%llu %llu] couldn't find relative ref",
5133 ref_key->type == BTRFS_ROOT_REF_KEY ?
5134 "ROOT_REF" : "ROOT_BACKREF",
5135 ref_key->objectid, ref_key->offset);
5136 goto out;
5137 }
5138
5139 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5140 struct btrfs_root_ref);
5141 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5142 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5143 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5144
5145 if (backref_namelen <= BTRFS_NAME_LEN) {
5146 len = backref_namelen;
5147 } else {
5148 len = BTRFS_NAME_LEN;
5149 warning("%s[%llu %llu] ref_name too long",
5150 key.type == BTRFS_ROOT_REF_KEY ?
5151 "ROOT_REF" : "ROOT_BACKREF",
5152 key.objectid, key.offset);
5153 }
5154 read_extent_buffer(path.nodes[0], backref_name,
5155 (unsigned long)(backref + 1), len);
5156
5157 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5158 ref_namelen != backref_namelen ||
5159 strncmp(ref_name, backref_name, len)) {
5160 err |= ROOT_REF_MISMATCH;
5161 error("%s[%llu %llu] mismatch relative ref",
5162 ref_key->type == BTRFS_ROOT_REF_KEY ?
5163 "ROOT_REF" : "ROOT_BACKREF",
5164 ref_key->objectid, ref_key->offset);
5165 }
5166 out:
5167 btrfs_release_path(&path);
5168 return err;
5169 }
5170
5171 /*
5172 * Check all fs/file tree in low_memory mode.
5173 *
5174 * 1. for fs tree root item, call check_fs_root_v2()
5175 * 2. for fs tree root ref/backref, call check_root_ref()
5176 *
5177 * Return 0 if no error occurred.
5178 */
5179 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5180 {
5181 struct btrfs_root *tree_root = fs_info->tree_root;
5182 struct btrfs_root *cur_root = NULL;
5183 struct btrfs_path path;
5184 struct btrfs_key key;
5185 struct extent_buffer *node;
5186 unsigned int ext_ref;
5187 int slot;
5188 int ret;
5189 int err = 0;
5190
5191 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5192
5193 btrfs_init_path(&path);
5194 key.objectid = BTRFS_FS_TREE_OBJECTID;
5195 key.offset = 0;
5196 key.type = BTRFS_ROOT_ITEM_KEY;
5197
5198 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5199 if (ret < 0) {
5200 err = ret;
5201 goto out;
5202 } else if (ret > 0) {
5203 err = -ENOENT;
5204 goto out;
5205 }
5206
5207 while (1) {
5208 node = path.nodes[0];
5209 slot = path.slots[0];
5210 btrfs_item_key_to_cpu(node, &key, slot);
5211 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5212 goto out;
5213 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5214 fs_root_objectid(key.objectid)) {
5215 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5216 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5217 &key);
5218 } else {
5219 key.offset = (u64)-1;
5220 cur_root = btrfs_read_fs_root(fs_info, &key);
5221 }
5222
5223 if (IS_ERR(cur_root)) {
5224 error("Fail to read fs/subvol tree: %lld",
5225 key.objectid);
5226 err = -EIO;
5227 goto next;
5228 }
5229
5230 ret = check_fs_root_v2(cur_root, ext_ref);
5231 err |= ret;
5232
5233 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5234 btrfs_free_fs_root(cur_root);
5235 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5236 key.type == BTRFS_ROOT_BACKREF_KEY) {
5237 ret = check_root_ref(tree_root, &key, node, slot);
5238 err |= ret;
5239 }
5240 next:
5241 ret = btrfs_next_item(tree_root, &path);
5242 if (ret > 0)
5243 goto out;
5244 if (ret < 0) {
5245 err = ret;
5246 goto out;
5247 }
5248 }
5249
5250 out:
5251 btrfs_release_path(&path);
5252 return err;
5253 }
5254
5255 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5256 {
5257 struct list_head *cur = rec->backrefs.next;
5258 struct extent_backref *back;
5259 struct tree_backref *tback;
5260 struct data_backref *dback;
5261 u64 found = 0;
5262 int err = 0;
5263
5264 while(cur != &rec->backrefs) {
5265 back = to_extent_backref(cur);
5266 cur = cur->next;
5267 if (!back->found_extent_tree) {
5268 err = 1;
5269 if (!print_errs)
5270 goto out;
5271 if (back->is_data) {
5272 dback = to_data_backref(back);
5273 fprintf(stderr, "Backref %llu %s %llu"
5274 " owner %llu offset %llu num_refs %lu"
5275 " not found in extent tree\n",
5276 (unsigned long long)rec->start,
5277 back->full_backref ?
5278 "parent" : "root",
5279 back->full_backref ?
5280 (unsigned long long)dback->parent:
5281 (unsigned long long)dback->root,
5282 (unsigned long long)dback->owner,
5283 (unsigned long long)dback->offset,
5284 (unsigned long)dback->num_refs);
5285 } else {
5286 tback = to_tree_backref(back);
5287 fprintf(stderr, "Backref %llu parent %llu"
5288 " root %llu not found in extent tree\n",
5289 (unsigned long long)rec->start,
5290 (unsigned long long)tback->parent,
5291 (unsigned long long)tback->root);
5292 }
5293 }
5294 if (!back->is_data && !back->found_ref) {
5295 err = 1;
5296 if (!print_errs)
5297 goto out;
5298 tback = to_tree_backref(back);
5299 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5300 (unsigned long long)rec->start,
5301 back->full_backref ? "parent" : "root",
5302 back->full_backref ?
5303 (unsigned long long)tback->parent :
5304 (unsigned long long)tback->root, back);
5305 }
5306 if (back->is_data) {
5307 dback = to_data_backref(back);
5308 if (dback->found_ref != dback->num_refs) {
5309 err = 1;
5310 if (!print_errs)
5311 goto out;
5312 fprintf(stderr, "Incorrect local backref count"
5313 " on %llu %s %llu owner %llu"
5314 " offset %llu found %u wanted %u back %p\n",
5315 (unsigned long long)rec->start,
5316 back->full_backref ?
5317 "parent" : "root",
5318 back->full_backref ?
5319 (unsigned long long)dback->parent:
5320 (unsigned long long)dback->root,
5321 (unsigned long long)dback->owner,
5322 (unsigned long long)dback->offset,
5323 dback->found_ref, dback->num_refs, back);
5324 }
5325 if (dback->disk_bytenr != rec->start) {
5326 err = 1;
5327 if (!print_errs)
5328 goto out;
5329 fprintf(stderr, "Backref disk bytenr does not"
5330 " match extent record, bytenr=%llu, "
5331 "ref bytenr=%llu\n",
5332 (unsigned long long)rec->start,
5333 (unsigned long long)dback->disk_bytenr);
5334 }
5335
5336 if (dback->bytes != rec->nr) {
5337 err = 1;
5338 if (!print_errs)
5339 goto out;
5340 fprintf(stderr, "Backref bytes do not match "
5341 "extent backref, bytenr=%llu, ref "
5342 "bytes=%llu, backref bytes=%llu\n",
5343 (unsigned long long)rec->start,
5344 (unsigned long long)rec->nr,
5345 (unsigned long long)dback->bytes);
5346 }
5347 }
5348 if (!back->is_data) {
5349 found += 1;
5350 } else {
5351 dback = to_data_backref(back);
5352 found += dback->found_ref;
5353 }
5354 }
5355 if (found != rec->refs) {
5356 err = 1;
5357 if (!print_errs)
5358 goto out;
5359 fprintf(stderr, "Incorrect global backref count "
5360 "on %llu found %llu wanted %llu\n",
5361 (unsigned long long)rec->start,
5362 (unsigned long long)found,
5363 (unsigned long long)rec->refs);
5364 }
5365 out:
5366 return err;
5367 }
5368
5369 static int free_all_extent_backrefs(struct extent_record *rec)
5370 {
5371 struct extent_backref *back;
5372 struct list_head *cur;
5373 while (!list_empty(&rec->backrefs)) {
5374 cur = rec->backrefs.next;
5375 back = to_extent_backref(cur);
5376 list_del(cur);
5377 free(back);
5378 }
5379 return 0;
5380 }
5381
5382 static void free_extent_record_cache(struct cache_tree *extent_cache)
5383 {
5384 struct cache_extent *cache;
5385 struct extent_record *rec;
5386
5387 while (1) {
5388 cache = first_cache_extent(extent_cache);
5389 if (!cache)
5390 break;
5391 rec = container_of(cache, struct extent_record, cache);
5392 remove_cache_extent(extent_cache, cache);
5393 free_all_extent_backrefs(rec);
5394 free(rec);
5395 }
5396 }
5397
5398 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5399 struct extent_record *rec)
5400 {
5401 if (rec->content_checked && rec->owner_ref_checked &&
5402 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5403 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5404 !rec->bad_full_backref && !rec->crossing_stripes &&
5405 !rec->wrong_chunk_type) {
5406 remove_cache_extent(extent_cache, &rec->cache);
5407 free_all_extent_backrefs(rec);
5408 list_del_init(&rec->list);
5409 free(rec);
5410 }
5411 return 0;
5412 }
5413
5414 static int check_owner_ref(struct btrfs_root *root,
5415 struct extent_record *rec,
5416 struct extent_buffer *buf)
5417 {
5418 struct extent_backref *node;
5419 struct tree_backref *back;
5420 struct btrfs_root *ref_root;
5421 struct btrfs_key key;
5422 struct btrfs_path path;
5423 struct extent_buffer *parent;
5424 int level;
5425 int found = 0;
5426 int ret;
5427
5428 list_for_each_entry(node, &rec->backrefs, list) {
5429 if (node->is_data)
5430 continue;
5431 if (!node->found_ref)
5432 continue;
5433 if (node->full_backref)
5434 continue;
5435 back = to_tree_backref(node);
5436 if (btrfs_header_owner(buf) == back->root)
5437 return 0;
5438 }
5439 BUG_ON(rec->is_root);
5440
5441 /* try to find the block by search corresponding fs tree */
5442 key.objectid = btrfs_header_owner(buf);
5443 key.type = BTRFS_ROOT_ITEM_KEY;
5444 key.offset = (u64)-1;
5445
5446 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5447 if (IS_ERR(ref_root))
5448 return 1;
5449
5450 level = btrfs_header_level(buf);
5451 if (level == 0)
5452 btrfs_item_key_to_cpu(buf, &key, 0);
5453 else
5454 btrfs_node_key_to_cpu(buf, &key, 0);
5455
5456 btrfs_init_path(&path);
5457 path.lowest_level = level + 1;
5458 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5459 if (ret < 0)
5460 return 0;
5461
5462 parent = path.nodes[level + 1];
5463 if (parent && buf->start == btrfs_node_blockptr(parent,
5464 path.slots[level + 1]))
5465 found = 1;
5466
5467 btrfs_release_path(&path);
5468 return found ? 0 : 1;
5469 }
5470
5471 static int is_extent_tree_record(struct extent_record *rec)
5472 {
5473 struct list_head *cur = rec->backrefs.next;
5474 struct extent_backref *node;
5475 struct tree_backref *back;
5476 int is_extent = 0;
5477
5478 while(cur != &rec->backrefs) {
5479 node = to_extent_backref(cur);
5480 cur = cur->next;
5481 if (node->is_data)
5482 return 0;
5483 back = to_tree_backref(node);
5484 if (node->full_backref)
5485 return 0;
5486 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5487 is_extent = 1;
5488 }
5489 return is_extent;
5490 }
5491
5492
5493 static int record_bad_block_io(struct btrfs_fs_info *info,
5494 struct cache_tree *extent_cache,
5495 u64 start, u64 len)
5496 {
5497 struct extent_record *rec;
5498 struct cache_extent *cache;
5499 struct btrfs_key key;
5500
5501 cache = lookup_cache_extent(extent_cache, start, len);
5502 if (!cache)
5503 return 0;
5504
5505 rec = container_of(cache, struct extent_record, cache);
5506 if (!is_extent_tree_record(rec))
5507 return 0;
5508
5509 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5510 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5511 }
5512
5513 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5514 struct extent_buffer *buf, int slot)
5515 {
5516 if (btrfs_header_level(buf)) {
5517 struct btrfs_key_ptr ptr1, ptr2;
5518
5519 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5520 sizeof(struct btrfs_key_ptr));
5521 read_extent_buffer(buf, &ptr2,
5522 btrfs_node_key_ptr_offset(slot + 1),
5523 sizeof(struct btrfs_key_ptr));
5524 write_extent_buffer(buf, &ptr1,
5525 btrfs_node_key_ptr_offset(slot + 1),
5526 sizeof(struct btrfs_key_ptr));
5527 write_extent_buffer(buf, &ptr2,
5528 btrfs_node_key_ptr_offset(slot),
5529 sizeof(struct btrfs_key_ptr));
5530 if (slot == 0) {
5531 struct btrfs_disk_key key;
5532 btrfs_node_key(buf, &key, 0);
5533 btrfs_fixup_low_keys(root, path, &key,
5534 btrfs_header_level(buf) + 1);
5535 }
5536 } else {
5537 struct btrfs_item *item1, *item2;
5538 struct btrfs_key k1, k2;
5539 char *item1_data, *item2_data;
5540 u32 item1_offset, item2_offset, item1_size, item2_size;
5541
5542 item1 = btrfs_item_nr(slot);
5543 item2 = btrfs_item_nr(slot + 1);
5544 btrfs_item_key_to_cpu(buf, &k1, slot);
5545 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5546 item1_offset = btrfs_item_offset(buf, item1);
5547 item2_offset = btrfs_item_offset(buf, item2);
5548 item1_size = btrfs_item_size(buf, item1);
5549 item2_size = btrfs_item_size(buf, item2);
5550
5551 item1_data = malloc(item1_size);
5552 if (!item1_data)
5553 return -ENOMEM;
5554 item2_data = malloc(item2_size);
5555 if (!item2_data) {
5556 free(item1_data);
5557 return -ENOMEM;
5558 }
5559
5560 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5561 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5562
5563 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5564 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5565 free(item1_data);
5566 free(item2_data);
5567
5568 btrfs_set_item_offset(buf, item1, item2_offset);
5569 btrfs_set_item_offset(buf, item2, item1_offset);
5570 btrfs_set_item_size(buf, item1, item2_size);
5571 btrfs_set_item_size(buf, item2, item1_size);
5572
5573 path->slots[0] = slot;
5574 btrfs_set_item_key_unsafe(root, path, &k2);
5575 path->slots[0] = slot + 1;
5576 btrfs_set_item_key_unsafe(root, path, &k1);
5577 }
5578 return 0;
5579 }
5580
5581 static int fix_key_order(struct btrfs_root *root, struct btrfs_path *path)
5582 {
5583 struct extent_buffer *buf;
5584 struct btrfs_key k1, k2;
5585 int i;
5586 int level = path->lowest_level;
5587 int ret = -EIO;
5588
5589 buf = path->nodes[level];
5590 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5591 if (level) {
5592 btrfs_node_key_to_cpu(buf, &k1, i);
5593 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5594 } else {
5595 btrfs_item_key_to_cpu(buf, &k1, i);
5596 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5597 }
5598 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5599 continue;
5600 ret = swap_values(root, path, buf, i);
5601 if (ret)
5602 break;
5603 btrfs_mark_buffer_dirty(buf);
5604 i = 0;
5605 }
5606 return ret;
5607 }
5608
5609 static int delete_bogus_item(struct btrfs_root *root,
5610 struct btrfs_path *path,
5611 struct extent_buffer *buf, int slot)
5612 {
5613 struct btrfs_key key;
5614 int nritems = btrfs_header_nritems(buf);
5615
5616 btrfs_item_key_to_cpu(buf, &key, slot);
5617
5618 /* These are all the keys we can deal with missing. */
5619 if (key.type != BTRFS_DIR_INDEX_KEY &&
5620 key.type != BTRFS_EXTENT_ITEM_KEY &&
5621 key.type != BTRFS_METADATA_ITEM_KEY &&
5622 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5623 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5624 return -1;
5625
5626 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5627 (unsigned long long)key.objectid, key.type,
5628 (unsigned long long)key.offset, slot, buf->start);
5629 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5630 btrfs_item_nr_offset(slot + 1),
5631 sizeof(struct btrfs_item) *
5632 (nritems - slot - 1));
5633 btrfs_set_header_nritems(buf, nritems - 1);
5634 if (slot == 0) {
5635 struct btrfs_disk_key disk_key;
5636
5637 btrfs_item_key(buf, &disk_key, 0);
5638 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5639 }
5640 btrfs_mark_buffer_dirty(buf);
5641 return 0;
5642 }
5643
5644 static int fix_item_offset(struct btrfs_root *root, struct btrfs_path *path)
5645 {
5646 struct extent_buffer *buf;
5647 int i;
5648 int ret = 0;
5649
5650 /* We should only get this for leaves */
5651 BUG_ON(path->lowest_level);
5652 buf = path->nodes[0];
5653 again:
5654 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5655 unsigned int shift = 0, offset;
5656
5657 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5658 BTRFS_LEAF_DATA_SIZE(root)) {
5659 if (btrfs_item_end_nr(buf, i) >
5660 BTRFS_LEAF_DATA_SIZE(root)) {
5661 ret = delete_bogus_item(root, path, buf, i);
5662 if (!ret)
5663 goto again;
5664 fprintf(stderr, "item is off the end of the "
5665 "leaf, can't fix\n");
5666 ret = -EIO;
5667 break;
5668 }
5669 shift = BTRFS_LEAF_DATA_SIZE(root) -
5670 btrfs_item_end_nr(buf, i);
5671 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5672 btrfs_item_offset_nr(buf, i - 1)) {
5673 if (btrfs_item_end_nr(buf, i) >
5674 btrfs_item_offset_nr(buf, i - 1)) {
5675 ret = delete_bogus_item(root, path, buf, i);
5676 if (!ret)
5677 goto again;
5678 fprintf(stderr, "items overlap, can't fix\n");
5679 ret = -EIO;
5680 break;
5681 }
5682 shift = btrfs_item_offset_nr(buf, i - 1) -
5683 btrfs_item_end_nr(buf, i);
5684 }
5685 if (!shift)
5686 continue;
5687
5688 printf("Shifting item nr %d by %u bytes in block %llu\n",
5689 i, shift, (unsigned long long)buf->start);
5690 offset = btrfs_item_offset_nr(buf, i);
5691 memmove_extent_buffer(buf,
5692 btrfs_leaf_data(buf) + offset + shift,
5693 btrfs_leaf_data(buf) + offset,
5694 btrfs_item_size_nr(buf, i));
5695 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5696 offset + shift);
5697 btrfs_mark_buffer_dirty(buf);
5698 }
5699
5700 /*
5701 * We may have moved things, in which case we want to exit so we don't
5702 * write those changes out. Once we have proper abort functionality in
5703 * progs this can be changed to something nicer.
5704 */
5705 BUG_ON(ret);
5706 return ret;
5707 }
5708
5709 /*
5710 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5711 * then just return -EIO.
5712 */
5713 static int try_to_fix_bad_block(struct btrfs_root *root,
5714 struct extent_buffer *buf,
5715 enum btrfs_tree_block_status status)
5716 {
5717 struct btrfs_trans_handle *trans;
5718 struct ulist *roots;
5719 struct ulist_node *node;
5720 struct btrfs_root *search_root;
5721 struct btrfs_path path;
5722 struct ulist_iterator iter;
5723 struct btrfs_key root_key, key;
5724 int ret;
5725
5726 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5727 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5728 return -EIO;
5729
5730 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5731 if (ret)
5732 return -EIO;
5733
5734 btrfs_init_path(&path);
5735 ULIST_ITER_INIT(&iter);
5736 while ((node = ulist_next(roots, &iter))) {
5737 root_key.objectid = node->val;
5738 root_key.type = BTRFS_ROOT_ITEM_KEY;
5739 root_key.offset = (u64)-1;
5740
5741 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5742 if (IS_ERR(root)) {
5743 ret = -EIO;
5744 break;
5745 }
5746
5747
5748 trans = btrfs_start_transaction(search_root, 0);
5749 if (IS_ERR(trans)) {
5750 ret = PTR_ERR(trans);
5751 break;
5752 }
5753
5754 path.lowest_level = btrfs_header_level(buf);
5755 path.skip_check_block = 1;
5756 if (path.lowest_level)
5757 btrfs_node_key_to_cpu(buf, &key, 0);
5758 else
5759 btrfs_item_key_to_cpu(buf, &key, 0);
5760 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5761 if (ret) {
5762 ret = -EIO;
5763 btrfs_commit_transaction(trans, search_root);
5764 break;
5765 }
5766 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5767 ret = fix_key_order(search_root, &path);
5768 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5769 ret = fix_item_offset(search_root, &path);
5770 if (ret) {
5771 btrfs_commit_transaction(trans, search_root);
5772 break;
5773 }
5774 btrfs_release_path(&path);
5775 btrfs_commit_transaction(trans, search_root);
5776 }
5777 ulist_free(roots);
5778 btrfs_release_path(&path);
5779 return ret;
5780 }
5781
5782 static int check_block(struct btrfs_root *root,
5783 struct cache_tree *extent_cache,
5784 struct extent_buffer *buf, u64 flags)
5785 {
5786 struct extent_record *rec;
5787 struct cache_extent *cache;
5788 struct btrfs_key key;
5789 enum btrfs_tree_block_status status;
5790 int ret = 0;
5791 int level;
5792
5793 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5794 if (!cache)
5795 return 1;
5796 rec = container_of(cache, struct extent_record, cache);
5797 rec->generation = btrfs_header_generation(buf);
5798
5799 level = btrfs_header_level(buf);
5800 if (btrfs_header_nritems(buf) > 0) {
5801
5802 if (level == 0)
5803 btrfs_item_key_to_cpu(buf, &key, 0);
5804 else
5805 btrfs_node_key_to_cpu(buf, &key, 0);
5806
5807 rec->info_objectid = key.objectid;
5808 }
5809 rec->info_level = level;
5810
5811 if (btrfs_is_leaf(buf))
5812 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5813 else
5814 status = btrfs_check_node(root, &rec->parent_key, buf);
5815
5816 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5817 if (repair)
5818 status = try_to_fix_bad_block(root, buf, status);
5819 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5820 ret = -EIO;
5821 fprintf(stderr, "bad block %llu\n",
5822 (unsigned long long)buf->start);
5823 } else {
5824 /*
5825 * Signal to callers we need to start the scan over
5826 * again since we'll have cowed blocks.
5827 */
5828 ret = -EAGAIN;
5829 }
5830 } else {
5831 rec->content_checked = 1;
5832 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5833 rec->owner_ref_checked = 1;
5834 else {
5835 ret = check_owner_ref(root, rec, buf);
5836 if (!ret)
5837 rec->owner_ref_checked = 1;
5838 }
5839 }
5840 if (!ret)
5841 maybe_free_extent_rec(extent_cache, rec);
5842 return ret;
5843 }
5844
5845 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5846 u64 parent, u64 root)
5847 {
5848 struct list_head *cur = rec->backrefs.next;
5849 struct extent_backref *node;
5850 struct tree_backref *back;
5851
5852 while(cur != &rec->backrefs) {
5853 node = to_extent_backref(cur);
5854 cur = cur->next;
5855 if (node->is_data)
5856 continue;
5857 back = to_tree_backref(node);
5858 if (parent > 0) {
5859 if (!node->full_backref)
5860 continue;
5861 if (parent == back->parent)
5862 return back;
5863 } else {
5864 if (node->full_backref)
5865 continue;
5866 if (back->root == root)
5867 return back;
5868 }
5869 }
5870 return NULL;
5871 }
5872
5873 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5874 u64 parent, u64 root)
5875 {
5876 struct tree_backref *ref = malloc(sizeof(*ref));
5877
5878 if (!ref)
5879 return NULL;
5880 memset(&ref->node, 0, sizeof(ref->node));
5881 if (parent > 0) {
5882 ref->parent = parent;
5883 ref->node.full_backref = 1;
5884 } else {
5885 ref->root = root;
5886 ref->node.full_backref = 0;
5887 }
5888 list_add_tail(&ref->node.list, &rec->backrefs);
5889
5890 return ref;
5891 }
5892
5893 static struct data_backref *find_data_backref(struct extent_record *rec,
5894 u64 parent, u64 root,
5895 u64 owner, u64 offset,
5896 int found_ref,
5897 u64 disk_bytenr, u64 bytes)
5898 {
5899 struct list_head *cur = rec->backrefs.next;
5900 struct extent_backref *node;
5901 struct data_backref *back;
5902
5903 while(cur != &rec->backrefs) {
5904 node = to_extent_backref(cur);
5905 cur = cur->next;
5906 if (!node->is_data)
5907 continue;
5908 back = to_data_backref(node);
5909 if (parent > 0) {
5910 if (!node->full_backref)
5911 continue;
5912 if (parent == back->parent)
5913 return back;
5914 } else {
5915 if (node->full_backref)
5916 continue;
5917 if (back->root == root && back->owner == owner &&
5918 back->offset == offset) {
5919 if (found_ref && node->found_ref &&
5920 (back->bytes != bytes ||
5921 back->disk_bytenr != disk_bytenr))
5922 continue;
5923 return back;
5924 }
5925 }
5926 }
5927 return NULL;
5928 }
5929
5930 static struct data_backref *alloc_data_backref(struct extent_record *rec,
5931 u64 parent, u64 root,
5932 u64 owner, u64 offset,
5933 u64 max_size)
5934 {
5935 struct data_backref *ref = malloc(sizeof(*ref));
5936
5937 if (!ref)
5938 return NULL;
5939 memset(&ref->node, 0, sizeof(ref->node));
5940 ref->node.is_data = 1;
5941
5942 if (parent > 0) {
5943 ref->parent = parent;
5944 ref->owner = 0;
5945 ref->offset = 0;
5946 ref->node.full_backref = 1;
5947 } else {
5948 ref->root = root;
5949 ref->owner = owner;
5950 ref->offset = offset;
5951 ref->node.full_backref = 0;
5952 }
5953 ref->bytes = max_size;
5954 ref->found_ref = 0;
5955 ref->num_refs = 0;
5956 list_add_tail(&ref->node.list, &rec->backrefs);
5957 if (max_size > rec->max_size)
5958 rec->max_size = max_size;
5959 return ref;
5960 }
5961
5962 /* Check if the type of extent matches with its chunk */
5963 static void check_extent_type(struct extent_record *rec)
5964 {
5965 struct btrfs_block_group_cache *bg_cache;
5966
5967 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
5968 if (!bg_cache)
5969 return;
5970
5971 /* data extent, check chunk directly*/
5972 if (!rec->metadata) {
5973 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
5974 rec->wrong_chunk_type = 1;
5975 return;
5976 }
5977
5978 /* metadata extent, check the obvious case first */
5979 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
5980 BTRFS_BLOCK_GROUP_METADATA))) {
5981 rec->wrong_chunk_type = 1;
5982 return;
5983 }
5984
5985 /*
5986 * Check SYSTEM extent, as it's also marked as metadata, we can only
5987 * make sure it's a SYSTEM extent by its backref
5988 */
5989 if (!list_empty(&rec->backrefs)) {
5990 struct extent_backref *node;
5991 struct tree_backref *tback;
5992 u64 bg_type;
5993
5994 node = to_extent_backref(rec->backrefs.next);
5995 if (node->is_data) {
5996 /* tree block shouldn't have data backref */
5997 rec->wrong_chunk_type = 1;
5998 return;
5999 }
6000 tback = container_of(node, struct tree_backref, node);
6001
6002 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
6003 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
6004 else
6005 bg_type = BTRFS_BLOCK_GROUP_METADATA;
6006 if (!(bg_cache->flags & bg_type))
6007 rec->wrong_chunk_type = 1;
6008 }
6009 }
6010
6011 /*
6012 * Allocate a new extent record, fill default values from @tmpl and insert int
6013 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
6014 * the cache, otherwise it fails.
6015 */
6016 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
6017 struct extent_record *tmpl)
6018 {
6019 struct extent_record *rec;
6020 int ret = 0;
6021
6022 rec = malloc(sizeof(*rec));
6023 if (!rec)
6024 return -ENOMEM;
6025 rec->start = tmpl->start;
6026 rec->max_size = tmpl->max_size;
6027 rec->nr = max(tmpl->nr, tmpl->max_size);
6028 rec->found_rec = tmpl->found_rec;
6029 rec->content_checked = tmpl->content_checked;
6030 rec->owner_ref_checked = tmpl->owner_ref_checked;
6031 rec->num_duplicates = 0;
6032 rec->metadata = tmpl->metadata;
6033 rec->flag_block_full_backref = FLAG_UNSET;
6034 rec->bad_full_backref = 0;
6035 rec->crossing_stripes = 0;
6036 rec->wrong_chunk_type = 0;
6037 rec->is_root = tmpl->is_root;
6038 rec->refs = tmpl->refs;
6039 rec->extent_item_refs = tmpl->extent_item_refs;
6040 rec->parent_generation = tmpl->parent_generation;
6041 INIT_LIST_HEAD(&rec->backrefs);
6042 INIT_LIST_HEAD(&rec->dups);
6043 INIT_LIST_HEAD(&rec->list);
6044 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6045 rec->cache.start = tmpl->start;
6046 rec->cache.size = tmpl->nr;
6047 ret = insert_cache_extent(extent_cache, &rec->cache);
6048 if (ret) {
6049 free(rec);
6050 return ret;
6051 }
6052 bytes_used += rec->nr;
6053
6054 if (tmpl->metadata)
6055 rec->crossing_stripes = check_crossing_stripes(global_info,
6056 rec->start, global_info->tree_root->nodesize);
6057 check_extent_type(rec);
6058 return ret;
6059 }
6060
6061 /*
6062 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6063 * some are hints:
6064 * - refs - if found, increase refs
6065 * - is_root - if found, set
6066 * - content_checked - if found, set
6067 * - owner_ref_checked - if found, set
6068 *
6069 * If not found, create a new one, initialize and insert.
6070 */
6071 static int add_extent_rec(struct cache_tree *extent_cache,
6072 struct extent_record *tmpl)
6073 {
6074 struct extent_record *rec;
6075 struct cache_extent *cache;
6076 int ret = 0;
6077 int dup = 0;
6078
6079 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6080 if (cache) {
6081 rec = container_of(cache, struct extent_record, cache);
6082 if (tmpl->refs)
6083 rec->refs++;
6084 if (rec->nr == 1)
6085 rec->nr = max(tmpl->nr, tmpl->max_size);
6086
6087 /*
6088 * We need to make sure to reset nr to whatever the extent
6089 * record says was the real size, this way we can compare it to
6090 * the backrefs.
6091 */
6092 if (tmpl->found_rec) {
6093 if (tmpl->start != rec->start || rec->found_rec) {
6094 struct extent_record *tmp;
6095
6096 dup = 1;
6097 if (list_empty(&rec->list))
6098 list_add_tail(&rec->list,
6099 &duplicate_extents);
6100
6101 /*
6102 * We have to do this song and dance in case we
6103 * find an extent record that falls inside of
6104 * our current extent record but does not have
6105 * the same objectid.
6106 */
6107 tmp = malloc(sizeof(*tmp));
6108 if (!tmp)
6109 return -ENOMEM;
6110 tmp->start = tmpl->start;
6111 tmp->max_size = tmpl->max_size;
6112 tmp->nr = tmpl->nr;
6113 tmp->found_rec = 1;
6114 tmp->metadata = tmpl->metadata;
6115 tmp->extent_item_refs = tmpl->extent_item_refs;
6116 INIT_LIST_HEAD(&tmp->list);
6117 list_add_tail(&tmp->list, &rec->dups);
6118 rec->num_duplicates++;
6119 } else {
6120 rec->nr = tmpl->nr;
6121 rec->found_rec = 1;
6122 }
6123 }
6124
6125 if (tmpl->extent_item_refs && !dup) {
6126 if (rec->extent_item_refs) {
6127 fprintf(stderr, "block %llu rec "
6128 "extent_item_refs %llu, passed %llu\n",
6129 (unsigned long long)tmpl->start,
6130 (unsigned long long)
6131 rec->extent_item_refs,
6132 (unsigned long long)tmpl->extent_item_refs);
6133 }
6134 rec->extent_item_refs = tmpl->extent_item_refs;
6135 }
6136 if (tmpl->is_root)
6137 rec->is_root = 1;
6138 if (tmpl->content_checked)
6139 rec->content_checked = 1;
6140 if (tmpl->owner_ref_checked)
6141 rec->owner_ref_checked = 1;
6142 memcpy(&rec->parent_key, &tmpl->parent_key,
6143 sizeof(tmpl->parent_key));
6144 if (tmpl->parent_generation)
6145 rec->parent_generation = tmpl->parent_generation;
6146 if (rec->max_size < tmpl->max_size)
6147 rec->max_size = tmpl->max_size;
6148
6149 /*
6150 * A metadata extent can't cross stripe_len boundary, otherwise
6151 * kernel scrub won't be able to handle it.
6152 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6153 * it.
6154 */
6155 if (tmpl->metadata)
6156 rec->crossing_stripes = check_crossing_stripes(
6157 global_info, rec->start,
6158 global_info->tree_root->nodesize);
6159 check_extent_type(rec);
6160 maybe_free_extent_rec(extent_cache, rec);
6161 return ret;
6162 }
6163
6164 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6165
6166 return ret;
6167 }
6168
6169 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6170 u64 parent, u64 root, int found_ref)
6171 {
6172 struct extent_record *rec;
6173 struct tree_backref *back;
6174 struct cache_extent *cache;
6175 int ret;
6176
6177 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6178 if (!cache) {
6179 struct extent_record tmpl;
6180
6181 memset(&tmpl, 0, sizeof(tmpl));
6182 tmpl.start = bytenr;
6183 tmpl.nr = 1;
6184 tmpl.metadata = 1;
6185
6186 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6187 if (ret)
6188 return ret;
6189
6190 /* really a bug in cache_extent implement now */
6191 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6192 if (!cache)
6193 return -ENOENT;
6194 }
6195
6196 rec = container_of(cache, struct extent_record, cache);
6197 if (rec->start != bytenr) {
6198 /*
6199 * Several cause, from unaligned bytenr to over lapping extents
6200 */
6201 return -EEXIST;
6202 }
6203
6204 back = find_tree_backref(rec, parent, root);
6205 if (!back) {
6206 back = alloc_tree_backref(rec, parent, root);
6207 if (!back)
6208 return -ENOMEM;
6209 }
6210
6211 if (found_ref) {
6212 if (back->node.found_ref) {
6213 fprintf(stderr, "Extent back ref already exists "
6214 "for %llu parent %llu root %llu \n",
6215 (unsigned long long)bytenr,
6216 (unsigned long long)parent,
6217 (unsigned long long)root);
6218 }
6219 back->node.found_ref = 1;
6220 } else {
6221 if (back->node.found_extent_tree) {
6222 fprintf(stderr, "Extent back ref already exists "
6223 "for %llu parent %llu root %llu \n",
6224 (unsigned long long)bytenr,
6225 (unsigned long long)parent,
6226 (unsigned long long)root);
6227 }
6228 back->node.found_extent_tree = 1;
6229 }
6230 check_extent_type(rec);
6231 maybe_free_extent_rec(extent_cache, rec);
6232 return 0;
6233 }
6234
6235 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6236 u64 parent, u64 root, u64 owner, u64 offset,
6237 u32 num_refs, int found_ref, u64 max_size)
6238 {
6239 struct extent_record *rec;
6240 struct data_backref *back;
6241 struct cache_extent *cache;
6242 int ret;
6243
6244 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6245 if (!cache) {
6246 struct extent_record tmpl;
6247
6248 memset(&tmpl, 0, sizeof(tmpl));
6249 tmpl.start = bytenr;
6250 tmpl.nr = 1;
6251 tmpl.max_size = max_size;
6252
6253 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6254 if (ret)
6255 return ret;
6256
6257 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6258 if (!cache)
6259 abort();
6260 }
6261
6262 rec = container_of(cache, struct extent_record, cache);
6263 if (rec->max_size < max_size)
6264 rec->max_size = max_size;
6265
6266 /*
6267 * If found_ref is set then max_size is the real size and must match the
6268 * existing refs. So if we have already found a ref then we need to
6269 * make sure that this ref matches the existing one, otherwise we need
6270 * to add a new backref so we can notice that the backrefs don't match
6271 * and we need to figure out who is telling the truth. This is to
6272 * account for that awful fsync bug I introduced where we'd end up with
6273 * a btrfs_file_extent_item that would have its length include multiple
6274 * prealloc extents or point inside of a prealloc extent.
6275 */
6276 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6277 bytenr, max_size);
6278 if (!back) {
6279 back = alloc_data_backref(rec, parent, root, owner, offset,
6280 max_size);
6281 BUG_ON(!back);
6282 }
6283
6284 if (found_ref) {
6285 BUG_ON(num_refs != 1);
6286 if (back->node.found_ref)
6287 BUG_ON(back->bytes != max_size);
6288 back->node.found_ref = 1;
6289 back->found_ref += 1;
6290 back->bytes = max_size;
6291 back->disk_bytenr = bytenr;
6292 rec->refs += 1;
6293 rec->content_checked = 1;
6294 rec->owner_ref_checked = 1;
6295 } else {
6296 if (back->node.found_extent_tree) {
6297 fprintf(stderr, "Extent back ref already exists "
6298 "for %llu parent %llu root %llu "
6299 "owner %llu offset %llu num_refs %lu\n",
6300 (unsigned long long)bytenr,
6301 (unsigned long long)parent,
6302 (unsigned long long)root,
6303 (unsigned long long)owner,
6304 (unsigned long long)offset,
6305 (unsigned long)num_refs);
6306 }
6307 back->num_refs = num_refs;
6308 back->node.found_extent_tree = 1;
6309 }
6310 maybe_free_extent_rec(extent_cache, rec);
6311 return 0;
6312 }
6313
6314 static int add_pending(struct cache_tree *pending,
6315 struct cache_tree *seen, u64 bytenr, u32 size)
6316 {
6317 int ret;
6318 ret = add_cache_extent(seen, bytenr, size);
6319 if (ret)
6320 return ret;
6321 add_cache_extent(pending, bytenr, size);
6322 return 0;
6323 }
6324
6325 static int pick_next_pending(struct cache_tree *pending,
6326 struct cache_tree *reada,
6327 struct cache_tree *nodes,
6328 u64 last, struct block_info *bits, int bits_nr,
6329 int *reada_bits)
6330 {
6331 unsigned long node_start = last;
6332 struct cache_extent *cache;
6333 int ret;
6334
6335 cache = search_cache_extent(reada, 0);
6336 if (cache) {
6337 bits[0].start = cache->start;
6338 bits[0].size = cache->size;
6339 *reada_bits = 1;
6340 return 1;
6341 }
6342 *reada_bits = 0;
6343 if (node_start > 32768)
6344 node_start -= 32768;
6345
6346 cache = search_cache_extent(nodes, node_start);
6347 if (!cache)
6348 cache = search_cache_extent(nodes, 0);
6349
6350 if (!cache) {
6351 cache = search_cache_extent(pending, 0);
6352 if (!cache)
6353 return 0;
6354 ret = 0;
6355 do {
6356 bits[ret].start = cache->start;
6357 bits[ret].size = cache->size;
6358 cache = next_cache_extent(cache);
6359 ret++;
6360 } while (cache && ret < bits_nr);
6361 return ret;
6362 }
6363
6364 ret = 0;
6365 do {
6366 bits[ret].start = cache->start;
6367 bits[ret].size = cache->size;
6368 cache = next_cache_extent(cache);
6369 ret++;
6370 } while (cache && ret < bits_nr);
6371
6372 if (bits_nr - ret > 8) {
6373 u64 lookup = bits[0].start + bits[0].size;
6374 struct cache_extent *next;
6375 next = search_cache_extent(pending, lookup);
6376 while(next) {
6377 if (next->start - lookup > 32768)
6378 break;
6379 bits[ret].start = next->start;
6380 bits[ret].size = next->size;
6381 lookup = next->start + next->size;
6382 ret++;
6383 if (ret == bits_nr)
6384 break;
6385 next = next_cache_extent(next);
6386 if (!next)
6387 break;
6388 }
6389 }
6390 return ret;
6391 }
6392
6393 static void free_chunk_record(struct cache_extent *cache)
6394 {
6395 struct chunk_record *rec;
6396
6397 rec = container_of(cache, struct chunk_record, cache);
6398 list_del_init(&rec->list);
6399 list_del_init(&rec->dextents);
6400 free(rec);
6401 }
6402
6403 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6404 {
6405 cache_tree_free_extents(chunk_cache, free_chunk_record);
6406 }
6407
6408 static void free_device_record(struct rb_node *node)
6409 {
6410 struct device_record *rec;
6411
6412 rec = container_of(node, struct device_record, node);
6413 free(rec);
6414 }
6415
6416 FREE_RB_BASED_TREE(device_cache, free_device_record);
6417
6418 int insert_block_group_record(struct block_group_tree *tree,
6419 struct block_group_record *bg_rec)
6420 {
6421 int ret;
6422
6423 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6424 if (ret)
6425 return ret;
6426
6427 list_add_tail(&bg_rec->list, &tree->block_groups);
6428 return 0;
6429 }
6430
6431 static void free_block_group_record(struct cache_extent *cache)
6432 {
6433 struct block_group_record *rec;
6434
6435 rec = container_of(cache, struct block_group_record, cache);
6436 list_del_init(&rec->list);
6437 free(rec);
6438 }
6439
6440 void free_block_group_tree(struct block_group_tree *tree)
6441 {
6442 cache_tree_free_extents(&tree->tree, free_block_group_record);
6443 }
6444
6445 int insert_device_extent_record(struct device_extent_tree *tree,
6446 struct device_extent_record *de_rec)
6447 {
6448 int ret;
6449
6450 /*
6451 * Device extent is a bit different from the other extents, because
6452 * the extents which belong to the different devices may have the
6453 * same start and size, so we need use the special extent cache
6454 * search/insert functions.
6455 */
6456 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6457 if (ret)
6458 return ret;
6459
6460 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6461 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6462 return 0;
6463 }
6464
6465 static void free_device_extent_record(struct cache_extent *cache)
6466 {
6467 struct device_extent_record *rec;
6468
6469 rec = container_of(cache, struct device_extent_record, cache);
6470 if (!list_empty(&rec->chunk_list))
6471 list_del_init(&rec->chunk_list);
6472 if (!list_empty(&rec->device_list))
6473 list_del_init(&rec->device_list);
6474 free(rec);
6475 }
6476
6477 void free_device_extent_tree(struct device_extent_tree *tree)
6478 {
6479 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6480 }
6481
6482 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6483 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6484 struct extent_buffer *leaf, int slot)
6485 {
6486 struct btrfs_extent_ref_v0 *ref0;
6487 struct btrfs_key key;
6488 int ret;
6489
6490 btrfs_item_key_to_cpu(leaf, &key, slot);
6491 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6492 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6493 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6494 0, 0);
6495 } else {
6496 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6497 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6498 }
6499 return ret;
6500 }
6501 #endif
6502
6503 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6504 struct btrfs_key *key,
6505 int slot)
6506 {
6507 struct btrfs_chunk *ptr;
6508 struct chunk_record *rec;
6509 int num_stripes, i;
6510
6511 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6512 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6513
6514 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6515 if (!rec) {
6516 fprintf(stderr, "memory allocation failed\n");
6517 exit(-1);
6518 }
6519
6520 INIT_LIST_HEAD(&rec->list);
6521 INIT_LIST_HEAD(&rec->dextents);
6522 rec->bg_rec = NULL;
6523
6524 rec->cache.start = key->offset;
6525 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6526
6527 rec->generation = btrfs_header_generation(leaf);
6528
6529 rec->objectid = key->objectid;
6530 rec->type = key->type;
6531 rec->offset = key->offset;
6532
6533 rec->length = rec->cache.size;
6534 rec->owner = btrfs_chunk_owner(leaf, ptr);
6535 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6536 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6537 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6538 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6539 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6540 rec->num_stripes = num_stripes;
6541 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6542
6543 for (i = 0; i < rec->num_stripes; ++i) {
6544 rec->stripes[i].devid =
6545 btrfs_stripe_devid_nr(leaf, ptr, i);
6546 rec->stripes[i].offset =
6547 btrfs_stripe_offset_nr(leaf, ptr, i);
6548 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6549 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6550 BTRFS_UUID_SIZE);
6551 }
6552
6553 return rec;
6554 }
6555
6556 static int process_chunk_item(struct cache_tree *chunk_cache,
6557 struct btrfs_key *key, struct extent_buffer *eb,
6558 int slot)
6559 {
6560 struct chunk_record *rec;
6561 struct btrfs_chunk *chunk;
6562 int ret = 0;
6563
6564 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6565 /*
6566 * Do extra check for this chunk item,
6567 *
6568 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6569 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6570 * and owner<->key_type check.
6571 */
6572 ret = btrfs_check_chunk_valid(global_info->tree_root, eb, chunk, slot,
6573 key->offset);
6574 if (ret < 0) {
6575 error("chunk(%llu, %llu) is not valid, ignore it",
6576 key->offset, btrfs_chunk_length(eb, chunk));
6577 return 0;
6578 }
6579 rec = btrfs_new_chunk_record(eb, key, slot);
6580 ret = insert_cache_extent(chunk_cache, &rec->cache);
6581 if (ret) {
6582 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6583 rec->offset, rec->length);
6584 free(rec);
6585 }
6586
6587 return ret;
6588 }
6589
6590 static int process_device_item(struct rb_root *dev_cache,
6591 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6592 {
6593 struct btrfs_dev_item *ptr;
6594 struct device_record *rec;
6595 int ret = 0;
6596
6597 ptr = btrfs_item_ptr(eb,
6598 slot, struct btrfs_dev_item);
6599
6600 rec = malloc(sizeof(*rec));
6601 if (!rec) {
6602 fprintf(stderr, "memory allocation failed\n");
6603 return -ENOMEM;
6604 }
6605
6606 rec->devid = key->offset;
6607 rec->generation = btrfs_header_generation(eb);
6608
6609 rec->objectid = key->objectid;
6610 rec->type = key->type;
6611 rec->offset = key->offset;
6612
6613 rec->devid = btrfs_device_id(eb, ptr);
6614 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6615 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6616
6617 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6618 if (ret) {
6619 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6620 free(rec);
6621 }
6622
6623 return ret;
6624 }
6625
6626 struct block_group_record *
6627 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6628 int slot)
6629 {
6630 struct btrfs_block_group_item *ptr;
6631 struct block_group_record *rec;
6632
6633 rec = calloc(1, sizeof(*rec));
6634 if (!rec) {
6635 fprintf(stderr, "memory allocation failed\n");
6636 exit(-1);
6637 }
6638
6639 rec->cache.start = key->objectid;
6640 rec->cache.size = key->offset;
6641
6642 rec->generation = btrfs_header_generation(leaf);
6643
6644 rec->objectid = key->objectid;
6645 rec->type = key->type;
6646 rec->offset = key->offset;
6647
6648 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6649 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6650
6651 INIT_LIST_HEAD(&rec->list);
6652
6653 return rec;
6654 }
6655
6656 static int process_block_group_item(struct block_group_tree *block_group_cache,
6657 struct btrfs_key *key,
6658 struct extent_buffer *eb, int slot)
6659 {
6660 struct block_group_record *rec;
6661 int ret = 0;
6662
6663 rec = btrfs_new_block_group_record(eb, key, slot);
6664 ret = insert_block_group_record(block_group_cache, rec);
6665 if (ret) {
6666 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6667 rec->objectid, rec->offset);
6668 free(rec);
6669 }
6670
6671 return ret;
6672 }
6673
6674 struct device_extent_record *
6675 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6676 struct btrfs_key *key, int slot)
6677 {
6678 struct device_extent_record *rec;
6679 struct btrfs_dev_extent *ptr;
6680
6681 rec = calloc(1, sizeof(*rec));
6682 if (!rec) {
6683 fprintf(stderr, "memory allocation failed\n");
6684 exit(-1);
6685 }
6686
6687 rec->cache.objectid = key->objectid;
6688 rec->cache.start = key->offset;
6689
6690 rec->generation = btrfs_header_generation(leaf);
6691
6692 rec->objectid = key->objectid;
6693 rec->type = key->type;
6694 rec->offset = key->offset;
6695
6696 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6697 rec->chunk_objecteid =
6698 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6699 rec->chunk_offset =
6700 btrfs_dev_extent_chunk_offset(leaf, ptr);
6701 rec->length = btrfs_dev_extent_length(leaf, ptr);
6702 rec->cache.size = rec->length;
6703
6704 INIT_LIST_HEAD(&rec->chunk_list);
6705 INIT_LIST_HEAD(&rec->device_list);
6706
6707 return rec;
6708 }
6709
6710 static int
6711 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6712 struct btrfs_key *key, struct extent_buffer *eb,
6713 int slot)
6714 {
6715 struct device_extent_record *rec;
6716 int ret;
6717
6718 rec = btrfs_new_device_extent_record(eb, key, slot);
6719 ret = insert_device_extent_record(dev_extent_cache, rec);
6720 if (ret) {
6721 fprintf(stderr,
6722 "Device extent[%llu, %llu, %llu] existed.\n",
6723 rec->objectid, rec->offset, rec->length);
6724 free(rec);
6725 }
6726
6727 return ret;
6728 }
6729
6730 static int process_extent_item(struct btrfs_root *root,
6731 struct cache_tree *extent_cache,
6732 struct extent_buffer *eb, int slot)
6733 {
6734 struct btrfs_extent_item *ei;
6735 struct btrfs_extent_inline_ref *iref;
6736 struct btrfs_extent_data_ref *dref;
6737 struct btrfs_shared_data_ref *sref;
6738 struct btrfs_key key;
6739 struct extent_record tmpl;
6740 unsigned long end;
6741 unsigned long ptr;
6742 int ret;
6743 int type;
6744 u32 item_size = btrfs_item_size_nr(eb, slot);
6745 u64 refs = 0;
6746 u64 offset;
6747 u64 num_bytes;
6748 int metadata = 0;
6749
6750 btrfs_item_key_to_cpu(eb, &key, slot);
6751
6752 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6753 metadata = 1;
6754 num_bytes = root->nodesize;
6755 } else {
6756 num_bytes = key.offset;
6757 }
6758
6759 if (!IS_ALIGNED(key.objectid, root->sectorsize)) {
6760 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6761 key.objectid, root->sectorsize);
6762 return -EIO;
6763 }
6764 if (item_size < sizeof(*ei)) {
6765 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6766 struct btrfs_extent_item_v0 *ei0;
6767 BUG_ON(item_size != sizeof(*ei0));
6768 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6769 refs = btrfs_extent_refs_v0(eb, ei0);
6770 #else
6771 BUG();
6772 #endif
6773 memset(&tmpl, 0, sizeof(tmpl));
6774 tmpl.start = key.objectid;
6775 tmpl.nr = num_bytes;
6776 tmpl.extent_item_refs = refs;
6777 tmpl.metadata = metadata;
6778 tmpl.found_rec = 1;
6779 tmpl.max_size = num_bytes;
6780
6781 return add_extent_rec(extent_cache, &tmpl);
6782 }
6783
6784 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6785 refs = btrfs_extent_refs(eb, ei);
6786 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6787 metadata = 1;
6788 else
6789 metadata = 0;
6790 if (metadata && num_bytes != root->nodesize) {
6791 error("ignore invalid metadata extent, length %llu does not equal to %u",
6792 num_bytes, root->nodesize);
6793 return -EIO;
6794 }
6795 if (!metadata && !IS_ALIGNED(num_bytes, root->sectorsize)) {
6796 error("ignore invalid data extent, length %llu is not aligned to %u",
6797 num_bytes, root->sectorsize);
6798 return -EIO;
6799 }
6800
6801 memset(&tmpl, 0, sizeof(tmpl));
6802 tmpl.start = key.objectid;
6803 tmpl.nr = num_bytes;
6804 tmpl.extent_item_refs = refs;
6805 tmpl.metadata = metadata;
6806 tmpl.found_rec = 1;
6807 tmpl.max_size = num_bytes;
6808 add_extent_rec(extent_cache, &tmpl);
6809
6810 ptr = (unsigned long)(ei + 1);
6811 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6812 key.type == BTRFS_EXTENT_ITEM_KEY)
6813 ptr += sizeof(struct btrfs_tree_block_info);
6814
6815 end = (unsigned long)ei + item_size;
6816 while (ptr < end) {
6817 iref = (struct btrfs_extent_inline_ref *)ptr;
6818 type = btrfs_extent_inline_ref_type(eb, iref);
6819 offset = btrfs_extent_inline_ref_offset(eb, iref);
6820 switch (type) {
6821 case BTRFS_TREE_BLOCK_REF_KEY:
6822 ret = add_tree_backref(extent_cache, key.objectid,
6823 0, offset, 0);
6824 if (ret < 0)
6825 error("add_tree_backref failed: %s",
6826 strerror(-ret));
6827 break;
6828 case BTRFS_SHARED_BLOCK_REF_KEY:
6829 ret = add_tree_backref(extent_cache, key.objectid,
6830 offset, 0, 0);
6831 if (ret < 0)
6832 error("add_tree_backref failed: %s",
6833 strerror(-ret));
6834 break;
6835 case BTRFS_EXTENT_DATA_REF_KEY:
6836 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6837 add_data_backref(extent_cache, key.objectid, 0,
6838 btrfs_extent_data_ref_root(eb, dref),
6839 btrfs_extent_data_ref_objectid(eb,
6840 dref),
6841 btrfs_extent_data_ref_offset(eb, dref),
6842 btrfs_extent_data_ref_count(eb, dref),
6843 0, num_bytes);
6844 break;
6845 case BTRFS_SHARED_DATA_REF_KEY:
6846 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6847 add_data_backref(extent_cache, key.objectid, offset,
6848 0, 0, 0,
6849 btrfs_shared_data_ref_count(eb, sref),
6850 0, num_bytes);
6851 break;
6852 default:
6853 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6854 key.objectid, key.type, num_bytes);
6855 goto out;
6856 }
6857 ptr += btrfs_extent_inline_ref_size(type);
6858 }
6859 WARN_ON(ptr > end);
6860 out:
6861 return 0;
6862 }
6863
6864 static int check_cache_range(struct btrfs_root *root,
6865 struct btrfs_block_group_cache *cache,
6866 u64 offset, u64 bytes)
6867 {
6868 struct btrfs_free_space *entry;
6869 u64 *logical;
6870 u64 bytenr;
6871 int stripe_len;
6872 int i, nr, ret;
6873
6874 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6875 bytenr = btrfs_sb_offset(i);
6876 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
6877 cache->key.objectid, bytenr, 0,
6878 &logical, &nr, &stripe_len);
6879 if (ret)
6880 return ret;
6881
6882 while (nr--) {
6883 if (logical[nr] + stripe_len <= offset)
6884 continue;
6885 if (offset + bytes <= logical[nr])
6886 continue;
6887 if (logical[nr] == offset) {
6888 if (stripe_len >= bytes) {
6889 free(logical);
6890 return 0;
6891 }
6892 bytes -= stripe_len;
6893 offset += stripe_len;
6894 } else if (logical[nr] < offset) {
6895 if (logical[nr] + stripe_len >=
6896 offset + bytes) {
6897 free(logical);
6898 return 0;
6899 }
6900 bytes = (offset + bytes) -
6901 (logical[nr] + stripe_len);
6902 offset = logical[nr] + stripe_len;
6903 } else {
6904 /*
6905 * Could be tricky, the super may land in the
6906 * middle of the area we're checking. First
6907 * check the easiest case, it's at the end.
6908 */
6909 if (logical[nr] + stripe_len >=
6910 bytes + offset) {
6911 bytes = logical[nr] - offset;
6912 continue;
6913 }
6914
6915 /* Check the left side */
6916 ret = check_cache_range(root, cache,
6917 offset,
6918 logical[nr] - offset);
6919 if (ret) {
6920 free(logical);
6921 return ret;
6922 }
6923
6924 /* Now we continue with the right side */
6925 bytes = (offset + bytes) -
6926 (logical[nr] + stripe_len);
6927 offset = logical[nr] + stripe_len;
6928 }
6929 }
6930
6931 free(logical);
6932 }
6933
6934 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
6935 if (!entry) {
6936 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
6937 offset, offset+bytes);
6938 return -EINVAL;
6939 }
6940
6941 if (entry->offset != offset) {
6942 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
6943 entry->offset);
6944 return -EINVAL;
6945 }
6946
6947 if (entry->bytes != bytes) {
6948 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
6949 bytes, entry->bytes, offset);
6950 return -EINVAL;
6951 }
6952
6953 unlink_free_space(cache->free_space_ctl, entry);
6954 free(entry);
6955 return 0;
6956 }
6957
6958 static int verify_space_cache(struct btrfs_root *root,
6959 struct btrfs_block_group_cache *cache)
6960 {
6961 struct btrfs_path path;
6962 struct extent_buffer *leaf;
6963 struct btrfs_key key;
6964 u64 last;
6965 int ret = 0;
6966
6967 root = root->fs_info->extent_root;
6968
6969 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
6970
6971 btrfs_init_path(&path);
6972 key.objectid = last;
6973 key.offset = 0;
6974 key.type = BTRFS_EXTENT_ITEM_KEY;
6975 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6976 if (ret < 0)
6977 goto out;
6978 ret = 0;
6979 while (1) {
6980 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
6981 ret = btrfs_next_leaf(root, &path);
6982 if (ret < 0)
6983 goto out;
6984 if (ret > 0) {
6985 ret = 0;
6986 break;
6987 }
6988 }
6989 leaf = path.nodes[0];
6990 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
6991 if (key.objectid >= cache->key.offset + cache->key.objectid)
6992 break;
6993 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
6994 key.type != BTRFS_METADATA_ITEM_KEY) {
6995 path.slots[0]++;
6996 continue;
6997 }
6998
6999 if (last == key.objectid) {
7000 if (key.type == BTRFS_EXTENT_ITEM_KEY)
7001 last = key.objectid + key.offset;
7002 else
7003 last = key.objectid + root->nodesize;
7004 path.slots[0]++;
7005 continue;
7006 }
7007
7008 ret = check_cache_range(root, cache, last,
7009 key.objectid - last);
7010 if (ret)
7011 break;
7012 if (key.type == BTRFS_EXTENT_ITEM_KEY)
7013 last = key.objectid + key.offset;
7014 else
7015 last = key.objectid + root->nodesize;
7016 path.slots[0]++;
7017 }
7018
7019 if (last < cache->key.objectid + cache->key.offset)
7020 ret = check_cache_range(root, cache, last,
7021 cache->key.objectid +
7022 cache->key.offset - last);
7023
7024 out:
7025 btrfs_release_path(&path);
7026
7027 if (!ret &&
7028 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
7029 fprintf(stderr, "There are still entries left in the space "
7030 "cache\n");
7031 ret = -EINVAL;
7032 }
7033
7034 return ret;
7035 }
7036
7037 static int check_space_cache(struct btrfs_root *root)
7038 {
7039 struct btrfs_block_group_cache *cache;
7040 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7041 int ret;
7042 int error = 0;
7043
7044 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7045 btrfs_super_generation(root->fs_info->super_copy) !=
7046 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7047 printf("cache and super generation don't match, space cache "
7048 "will be invalidated\n");
7049 return 0;
7050 }
7051
7052 if (ctx.progress_enabled) {
7053 ctx.tp = TASK_FREE_SPACE;
7054 task_start(ctx.info);
7055 }
7056
7057 while (1) {
7058 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7059 if (!cache)
7060 break;
7061
7062 start = cache->key.objectid + cache->key.offset;
7063 if (!cache->free_space_ctl) {
7064 if (btrfs_init_free_space_ctl(cache,
7065 root->sectorsize)) {
7066 ret = -ENOMEM;
7067 break;
7068 }
7069 } else {
7070 btrfs_remove_free_space_cache(cache);
7071 }
7072
7073 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7074 ret = exclude_super_stripes(root, cache);
7075 if (ret) {
7076 fprintf(stderr, "could not exclude super stripes: %s\n",
7077 strerror(-ret));
7078 error++;
7079 continue;
7080 }
7081 ret = load_free_space_tree(root->fs_info, cache);
7082 free_excluded_extents(root, cache);
7083 if (ret < 0) {
7084 fprintf(stderr, "could not load free space tree: %s\n",
7085 strerror(-ret));
7086 error++;
7087 continue;
7088 }
7089 error += ret;
7090 } else {
7091 ret = load_free_space_cache(root->fs_info, cache);
7092 if (!ret)
7093 continue;
7094 }
7095
7096 ret = verify_space_cache(root, cache);
7097 if (ret) {
7098 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7099 cache->key.objectid);
7100 error++;
7101 }
7102 }
7103
7104 task_stop(ctx.info);
7105
7106 return error ? -EINVAL : 0;
7107 }
7108
7109 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7110 u64 num_bytes, unsigned long leaf_offset,
7111 struct extent_buffer *eb) {
7112
7113 u64 offset = 0;
7114 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7115 char *data;
7116 unsigned long csum_offset;
7117 u32 csum;
7118 u32 csum_expected;
7119 u64 read_len;
7120 u64 data_checked = 0;
7121 u64 tmp;
7122 int ret = 0;
7123 int mirror;
7124 int num_copies;
7125
7126 if (num_bytes % root->sectorsize)
7127 return -EINVAL;
7128
7129 data = malloc(num_bytes);
7130 if (!data)
7131 return -ENOMEM;
7132
7133 while (offset < num_bytes) {
7134 mirror = 0;
7135 again:
7136 read_len = num_bytes - offset;
7137 /* read as much space once a time */
7138 ret = read_extent_data(root, data + offset,
7139 bytenr + offset, &read_len, mirror);
7140 if (ret)
7141 goto out;
7142 data_checked = 0;
7143 /* verify every 4k data's checksum */
7144 while (data_checked < read_len) {
7145 csum = ~(u32)0;
7146 tmp = offset + data_checked;
7147
7148 csum = btrfs_csum_data((char *)data + tmp,
7149 csum, root->sectorsize);
7150 btrfs_csum_final(csum, (u8 *)&csum);
7151
7152 csum_offset = leaf_offset +
7153 tmp / root->sectorsize * csum_size;
7154 read_extent_buffer(eb, (char *)&csum_expected,
7155 csum_offset, csum_size);
7156 /* try another mirror */
7157 if (csum != csum_expected) {
7158 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7159 mirror, bytenr + tmp,
7160 csum, csum_expected);
7161 num_copies = btrfs_num_copies(
7162 &root->fs_info->mapping_tree,
7163 bytenr, num_bytes);
7164 if (mirror < num_copies - 1) {
7165 mirror += 1;
7166 goto again;
7167 }
7168 }
7169 data_checked += root->sectorsize;
7170 }
7171 offset += read_len;
7172 }
7173 out:
7174 free(data);
7175 return ret;
7176 }
7177
7178 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7179 u64 num_bytes)
7180 {
7181 struct btrfs_path path;
7182 struct extent_buffer *leaf;
7183 struct btrfs_key key;
7184 int ret;
7185
7186 btrfs_init_path(&path);
7187 key.objectid = bytenr;
7188 key.type = BTRFS_EXTENT_ITEM_KEY;
7189 key.offset = (u64)-1;
7190
7191 again:
7192 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7193 0, 0);
7194 if (ret < 0) {
7195 fprintf(stderr, "Error looking up extent record %d\n", ret);
7196 btrfs_release_path(&path);
7197 return ret;
7198 } else if (ret) {
7199 if (path.slots[0] > 0) {
7200 path.slots[0]--;
7201 } else {
7202 ret = btrfs_prev_leaf(root, &path);
7203 if (ret < 0) {
7204 goto out;
7205 } else if (ret > 0) {
7206 ret = 0;
7207 goto out;
7208 }
7209 }
7210 }
7211
7212 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7213
7214 /*
7215 * Block group items come before extent items if they have the same
7216 * bytenr, so walk back one more just in case. Dear future traveller,
7217 * first congrats on mastering time travel. Now if it's not too much
7218 * trouble could you go back to 2006 and tell Chris to make the
7219 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7220 * EXTENT_ITEM_KEY please?
7221 */
7222 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7223 if (path.slots[0] > 0) {
7224 path.slots[0]--;
7225 } else {
7226 ret = btrfs_prev_leaf(root, &path);
7227 if (ret < 0) {
7228 goto out;
7229 } else if (ret > 0) {
7230 ret = 0;
7231 goto out;
7232 }
7233 }
7234 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7235 }
7236
7237 while (num_bytes) {
7238 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7239 ret = btrfs_next_leaf(root, &path);
7240 if (ret < 0) {
7241 fprintf(stderr, "Error going to next leaf "
7242 "%d\n", ret);
7243 btrfs_release_path(&path);
7244 return ret;
7245 } else if (ret) {
7246 break;
7247 }
7248 }
7249 leaf = path.nodes[0];
7250 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7251 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7252 path.slots[0]++;
7253 continue;
7254 }
7255 if (key.objectid + key.offset < bytenr) {
7256 path.slots[0]++;
7257 continue;
7258 }
7259 if (key.objectid > bytenr + num_bytes)
7260 break;
7261
7262 if (key.objectid == bytenr) {
7263 if (key.offset >= num_bytes) {
7264 num_bytes = 0;
7265 break;
7266 }
7267 num_bytes -= key.offset;
7268 bytenr += key.offset;
7269 } else if (key.objectid < bytenr) {
7270 if (key.objectid + key.offset >= bytenr + num_bytes) {
7271 num_bytes = 0;
7272 break;
7273 }
7274 num_bytes = (bytenr + num_bytes) -
7275 (key.objectid + key.offset);
7276 bytenr = key.objectid + key.offset;
7277 } else {
7278 if (key.objectid + key.offset < bytenr + num_bytes) {
7279 u64 new_start = key.objectid + key.offset;
7280 u64 new_bytes = bytenr + num_bytes - new_start;
7281
7282 /*
7283 * Weird case, the extent is in the middle of
7284 * our range, we'll have to search one side
7285 * and then the other. Not sure if this happens
7286 * in real life, but no harm in coding it up
7287 * anyway just in case.
7288 */
7289 btrfs_release_path(&path);
7290 ret = check_extent_exists(root, new_start,
7291 new_bytes);
7292 if (ret) {
7293 fprintf(stderr, "Right section didn't "
7294 "have a record\n");
7295 break;
7296 }
7297 num_bytes = key.objectid - bytenr;
7298 goto again;
7299 }
7300 num_bytes = key.objectid - bytenr;
7301 }
7302 path.slots[0]++;
7303 }
7304 ret = 0;
7305
7306 out:
7307 if (num_bytes && !ret) {
7308 fprintf(stderr, "There are no extents for csum range "
7309 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7310 ret = 1;
7311 }
7312
7313 btrfs_release_path(&path);
7314 return ret;
7315 }
7316
7317 static int check_csums(struct btrfs_root *root)
7318 {
7319 struct btrfs_path path;
7320 struct extent_buffer *leaf;
7321 struct btrfs_key key;
7322 u64 offset = 0, num_bytes = 0;
7323 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7324 int errors = 0;
7325 int ret;
7326 u64 data_len;
7327 unsigned long leaf_offset;
7328
7329 root = root->fs_info->csum_root;
7330 if (!extent_buffer_uptodate(root->node)) {
7331 fprintf(stderr, "No valid csum tree found\n");
7332 return -ENOENT;
7333 }
7334
7335 btrfs_init_path(&path);
7336 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7337 key.type = BTRFS_EXTENT_CSUM_KEY;
7338 key.offset = 0;
7339 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7340 if (ret < 0) {
7341 fprintf(stderr, "Error searching csum tree %d\n", ret);
7342 btrfs_release_path(&path);
7343 return ret;
7344 }
7345
7346 if (ret > 0 && path.slots[0])
7347 path.slots[0]--;
7348 ret = 0;
7349
7350 while (1) {
7351 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7352 ret = btrfs_next_leaf(root, &path);
7353 if (ret < 0) {
7354 fprintf(stderr, "Error going to next leaf "
7355 "%d\n", ret);
7356 break;
7357 }
7358 if (ret)
7359 break;
7360 }
7361 leaf = path.nodes[0];
7362
7363 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7364 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7365 path.slots[0]++;
7366 continue;
7367 }
7368
7369 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7370 csum_size) * root->sectorsize;
7371 if (!check_data_csum)
7372 goto skip_csum_check;
7373 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7374 ret = check_extent_csums(root, key.offset, data_len,
7375 leaf_offset, leaf);
7376 if (ret)
7377 break;
7378 skip_csum_check:
7379 if (!num_bytes) {
7380 offset = key.offset;
7381 } else if (key.offset != offset + num_bytes) {
7382 ret = check_extent_exists(root, offset, num_bytes);
7383 if (ret) {
7384 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7385 "there is no extent record\n",
7386 offset, offset+num_bytes);
7387 errors++;
7388 }
7389 offset = key.offset;
7390 num_bytes = 0;
7391 }
7392 num_bytes += data_len;
7393 path.slots[0]++;
7394 }
7395
7396 btrfs_release_path(&path);
7397 return errors;
7398 }
7399
7400 static int is_dropped_key(struct btrfs_key *key,
7401 struct btrfs_key *drop_key) {
7402 if (key->objectid < drop_key->objectid)
7403 return 1;
7404 else if (key->objectid == drop_key->objectid) {
7405 if (key->type < drop_key->type)
7406 return 1;
7407 else if (key->type == drop_key->type) {
7408 if (key->offset < drop_key->offset)
7409 return 1;
7410 }
7411 }
7412 return 0;
7413 }
7414
7415 /*
7416 * Here are the rules for FULL_BACKREF.
7417 *
7418 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7419 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7420 * FULL_BACKREF set.
7421 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7422 * if it happened after the relocation occurred since we'll have dropped the
7423 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7424 * have no real way to know for sure.
7425 *
7426 * We process the blocks one root at a time, and we start from the lowest root
7427 * objectid and go to the highest. So we can just lookup the owner backref for
7428 * the record and if we don't find it then we know it doesn't exist and we have
7429 * a FULL BACKREF.
7430 *
7431 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7432 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7433 * be set or not and then we can check later once we've gathered all the refs.
7434 */
7435 static int calc_extent_flag(struct cache_tree *extent_cache,
7436 struct extent_buffer *buf,
7437 struct root_item_record *ri,
7438 u64 *flags)
7439 {
7440 struct extent_record *rec;
7441 struct cache_extent *cache;
7442 struct tree_backref *tback;
7443 u64 owner = 0;
7444
7445 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7446 /* we have added this extent before */
7447 if (!cache)
7448 return -ENOENT;
7449
7450 rec = container_of(cache, struct extent_record, cache);
7451
7452 /*
7453 * Except file/reloc tree, we can not have
7454 * FULL BACKREF MODE
7455 */
7456 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7457 goto normal;
7458 /*
7459 * root node
7460 */
7461 if (buf->start == ri->bytenr)
7462 goto normal;
7463
7464 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7465 goto full_backref;
7466
7467 owner = btrfs_header_owner(buf);
7468 if (owner == ri->objectid)
7469 goto normal;
7470
7471 tback = find_tree_backref(rec, 0, owner);
7472 if (!tback)
7473 goto full_backref;
7474 normal:
7475 *flags = 0;
7476 if (rec->flag_block_full_backref != FLAG_UNSET &&
7477 rec->flag_block_full_backref != 0)
7478 rec->bad_full_backref = 1;
7479 return 0;
7480 full_backref:
7481 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7482 if (rec->flag_block_full_backref != FLAG_UNSET &&
7483 rec->flag_block_full_backref != 1)
7484 rec->bad_full_backref = 1;
7485 return 0;
7486 }
7487
7488 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7489 {
7490 fprintf(stderr, "Invalid key type(");
7491 print_key_type(stderr, 0, key_type);
7492 fprintf(stderr, ") found in root(");
7493 print_objectid(stderr, rootid, 0);
7494 fprintf(stderr, ")\n");
7495 }
7496
7497 /*
7498 * Check if the key is valid with its extent buffer.
7499 *
7500 * This is a early check in case invalid key exists in a extent buffer
7501 * This is not comprehensive yet, but should prevent wrong key/item passed
7502 * further
7503 */
7504 static int check_type_with_root(u64 rootid, u8 key_type)
7505 {
7506 switch (key_type) {
7507 /* Only valid in chunk tree */
7508 case BTRFS_DEV_ITEM_KEY:
7509 case BTRFS_CHUNK_ITEM_KEY:
7510 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7511 goto err;
7512 break;
7513 /* valid in csum and log tree */
7514 case BTRFS_CSUM_TREE_OBJECTID:
7515 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7516 is_fstree(rootid)))
7517 goto err;
7518 break;
7519 case BTRFS_EXTENT_ITEM_KEY:
7520 case BTRFS_METADATA_ITEM_KEY:
7521 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7522 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7523 goto err;
7524 break;
7525 case BTRFS_ROOT_ITEM_KEY:
7526 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7527 goto err;
7528 break;
7529 case BTRFS_DEV_EXTENT_KEY:
7530 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7531 goto err;
7532 break;
7533 }
7534 return 0;
7535 err:
7536 report_mismatch_key_root(key_type, rootid);
7537 return -EINVAL;
7538 }
7539
7540 static int run_next_block(struct btrfs_root *root,
7541 struct block_info *bits,
7542 int bits_nr,
7543 u64 *last,
7544 struct cache_tree *pending,
7545 struct cache_tree *seen,
7546 struct cache_tree *reada,
7547 struct cache_tree *nodes,
7548 struct cache_tree *extent_cache,
7549 struct cache_tree *chunk_cache,
7550 struct rb_root *dev_cache,
7551 struct block_group_tree *block_group_cache,
7552 struct device_extent_tree *dev_extent_cache,
7553 struct root_item_record *ri)
7554 {
7555 struct extent_buffer *buf;
7556 struct extent_record *rec = NULL;
7557 u64 bytenr;
7558 u32 size;
7559 u64 parent;
7560 u64 owner;
7561 u64 flags;
7562 u64 ptr;
7563 u64 gen = 0;
7564 int ret = 0;
7565 int i;
7566 int nritems;
7567 struct btrfs_key key;
7568 struct cache_extent *cache;
7569 int reada_bits;
7570
7571 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7572 bits_nr, &reada_bits);
7573 if (nritems == 0)
7574 return 1;
7575
7576 if (!reada_bits) {
7577 for(i = 0; i < nritems; i++) {
7578 ret = add_cache_extent(reada, bits[i].start,
7579 bits[i].size);
7580 if (ret == -EEXIST)
7581 continue;
7582
7583 /* fixme, get the parent transid */
7584 readahead_tree_block(root, bits[i].start,
7585 bits[i].size, 0);
7586 }
7587 }
7588 *last = bits[0].start;
7589 bytenr = bits[0].start;
7590 size = bits[0].size;
7591
7592 cache = lookup_cache_extent(pending, bytenr, size);
7593 if (cache) {
7594 remove_cache_extent(pending, cache);
7595 free(cache);
7596 }
7597 cache = lookup_cache_extent(reada, bytenr, size);
7598 if (cache) {
7599 remove_cache_extent(reada, cache);
7600 free(cache);
7601 }
7602 cache = lookup_cache_extent(nodes, bytenr, size);
7603 if (cache) {
7604 remove_cache_extent(nodes, cache);
7605 free(cache);
7606 }
7607 cache = lookup_cache_extent(extent_cache, bytenr, size);
7608 if (cache) {
7609 rec = container_of(cache, struct extent_record, cache);
7610 gen = rec->parent_generation;
7611 }
7612
7613 /* fixme, get the real parent transid */
7614 buf = read_tree_block(root, bytenr, size, gen);
7615 if (!extent_buffer_uptodate(buf)) {
7616 record_bad_block_io(root->fs_info,
7617 extent_cache, bytenr, size);
7618 goto out;
7619 }
7620
7621 nritems = btrfs_header_nritems(buf);
7622
7623 flags = 0;
7624 if (!init_extent_tree) {
7625 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7626 btrfs_header_level(buf), 1, NULL,
7627 &flags);
7628 if (ret < 0) {
7629 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7630 if (ret < 0) {
7631 fprintf(stderr, "Couldn't calc extent flags\n");
7632 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7633 }
7634 }
7635 } else {
7636 flags = 0;
7637 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7638 if (ret < 0) {
7639 fprintf(stderr, "Couldn't calc extent flags\n");
7640 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7641 }
7642 }
7643
7644 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7645 if (ri != NULL &&
7646 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7647 ri->objectid == btrfs_header_owner(buf)) {
7648 /*
7649 * Ok we got to this block from it's original owner and
7650 * we have FULL_BACKREF set. Relocation can leave
7651 * converted blocks over so this is altogether possible,
7652 * however it's not possible if the generation > the
7653 * last snapshot, so check for this case.
7654 */
7655 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7656 btrfs_header_generation(buf) > ri->last_snapshot) {
7657 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7658 rec->bad_full_backref = 1;
7659 }
7660 }
7661 } else {
7662 if (ri != NULL &&
7663 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7664 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7665 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7666 rec->bad_full_backref = 1;
7667 }
7668 }
7669
7670 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7671 rec->flag_block_full_backref = 1;
7672 parent = bytenr;
7673 owner = 0;
7674 } else {
7675 rec->flag_block_full_backref = 0;
7676 parent = 0;
7677 owner = btrfs_header_owner(buf);
7678 }
7679
7680 ret = check_block(root, extent_cache, buf, flags);
7681 if (ret)
7682 goto out;
7683
7684 if (btrfs_is_leaf(buf)) {
7685 btree_space_waste += btrfs_leaf_free_space(root, buf);
7686 for (i = 0; i < nritems; i++) {
7687 struct btrfs_file_extent_item *fi;
7688 btrfs_item_key_to_cpu(buf, &key, i);
7689 /*
7690 * Check key type against the leaf owner.
7691 * Could filter quite a lot of early error if
7692 * owner is correct
7693 */
7694 if (check_type_with_root(btrfs_header_owner(buf),
7695 key.type)) {
7696 fprintf(stderr, "ignoring invalid key\n");
7697 continue;
7698 }
7699 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7700 process_extent_item(root, extent_cache, buf,
7701 i);
7702 continue;
7703 }
7704 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7705 process_extent_item(root, extent_cache, buf,
7706 i);
7707 continue;
7708 }
7709 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7710 total_csum_bytes +=
7711 btrfs_item_size_nr(buf, i);
7712 continue;
7713 }
7714 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7715 process_chunk_item(chunk_cache, &key, buf, i);
7716 continue;
7717 }
7718 if (key.type == BTRFS_DEV_ITEM_KEY) {
7719 process_device_item(dev_cache, &key, buf, i);
7720 continue;
7721 }
7722 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7723 process_block_group_item(block_group_cache,
7724 &key, buf, i);
7725 continue;
7726 }
7727 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7728 process_device_extent_item(dev_extent_cache,
7729 &key, buf, i);
7730 continue;
7731
7732 }
7733 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7734 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7735 process_extent_ref_v0(extent_cache, buf, i);
7736 #else
7737 BUG();
7738 #endif
7739 continue;
7740 }
7741
7742 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7743 ret = add_tree_backref(extent_cache,
7744 key.objectid, 0, key.offset, 0);
7745 if (ret < 0)
7746 error("add_tree_backref failed: %s",
7747 strerror(-ret));
7748 continue;
7749 }
7750 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7751 ret = add_tree_backref(extent_cache,
7752 key.objectid, key.offset, 0, 0);
7753 if (ret < 0)
7754 error("add_tree_backref failed: %s",
7755 strerror(-ret));
7756 continue;
7757 }
7758 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7759 struct btrfs_extent_data_ref *ref;
7760 ref = btrfs_item_ptr(buf, i,
7761 struct btrfs_extent_data_ref);
7762 add_data_backref(extent_cache,
7763 key.objectid, 0,
7764 btrfs_extent_data_ref_root(buf, ref),
7765 btrfs_extent_data_ref_objectid(buf,
7766 ref),
7767 btrfs_extent_data_ref_offset(buf, ref),
7768 btrfs_extent_data_ref_count(buf, ref),
7769 0, root->sectorsize);
7770 continue;
7771 }
7772 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7773 struct btrfs_shared_data_ref *ref;
7774 ref = btrfs_item_ptr(buf, i,
7775 struct btrfs_shared_data_ref);
7776 add_data_backref(extent_cache,
7777 key.objectid, key.offset, 0, 0, 0,
7778 btrfs_shared_data_ref_count(buf, ref),
7779 0, root->sectorsize);
7780 continue;
7781 }
7782 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7783 struct bad_item *bad;
7784
7785 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7786 continue;
7787 if (!owner)
7788 continue;
7789 bad = malloc(sizeof(struct bad_item));
7790 if (!bad)
7791 continue;
7792 INIT_LIST_HEAD(&bad->list);
7793 memcpy(&bad->key, &key,
7794 sizeof(struct btrfs_key));
7795 bad->root_id = owner;
7796 list_add_tail(&bad->list, &delete_items);
7797 continue;
7798 }
7799 if (key.type != BTRFS_EXTENT_DATA_KEY)
7800 continue;
7801 fi = btrfs_item_ptr(buf, i,
7802 struct btrfs_file_extent_item);
7803 if (btrfs_file_extent_type(buf, fi) ==
7804 BTRFS_FILE_EXTENT_INLINE)
7805 continue;
7806 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7807 continue;
7808
7809 data_bytes_allocated +=
7810 btrfs_file_extent_disk_num_bytes(buf, fi);
7811 if (data_bytes_allocated < root->sectorsize) {
7812 abort();
7813 }
7814 data_bytes_referenced +=
7815 btrfs_file_extent_num_bytes(buf, fi);
7816 add_data_backref(extent_cache,
7817 btrfs_file_extent_disk_bytenr(buf, fi),
7818 parent, owner, key.objectid, key.offset -
7819 btrfs_file_extent_offset(buf, fi), 1, 1,
7820 btrfs_file_extent_disk_num_bytes(buf, fi));
7821 }
7822 } else {
7823 int level;
7824 struct btrfs_key first_key;
7825
7826 first_key.objectid = 0;
7827
7828 if (nritems > 0)
7829 btrfs_item_key_to_cpu(buf, &first_key, 0);
7830 level = btrfs_header_level(buf);
7831 for (i = 0; i < nritems; i++) {
7832 struct extent_record tmpl;
7833
7834 ptr = btrfs_node_blockptr(buf, i);
7835 size = root->nodesize;
7836 btrfs_node_key_to_cpu(buf, &key, i);
7837 if (ri != NULL) {
7838 if ((level == ri->drop_level)
7839 && is_dropped_key(&key, &ri->drop_key)) {
7840 continue;
7841 }
7842 }
7843
7844 memset(&tmpl, 0, sizeof(tmpl));
7845 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7846 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7847 tmpl.start = ptr;
7848 tmpl.nr = size;
7849 tmpl.refs = 1;
7850 tmpl.metadata = 1;
7851 tmpl.max_size = size;
7852 ret = add_extent_rec(extent_cache, &tmpl);
7853 if (ret < 0)
7854 goto out;
7855
7856 ret = add_tree_backref(extent_cache, ptr, parent,
7857 owner, 1);
7858 if (ret < 0) {
7859 error("add_tree_backref failed: %s",
7860 strerror(-ret));
7861 continue;
7862 }
7863
7864 if (level > 1) {
7865 add_pending(nodes, seen, ptr, size);
7866 } else {
7867 add_pending(pending, seen, ptr, size);
7868 }
7869 }
7870 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7871 nritems) * sizeof(struct btrfs_key_ptr);
7872 }
7873 total_btree_bytes += buf->len;
7874 if (fs_root_objectid(btrfs_header_owner(buf)))
7875 total_fs_tree_bytes += buf->len;
7876 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7877 total_extent_tree_bytes += buf->len;
7878 if (!found_old_backref &&
7879 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7880 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7881 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7882 found_old_backref = 1;
7883 out:
7884 free_extent_buffer(buf);
7885 return ret;
7886 }
7887
7888 static int add_root_to_pending(struct extent_buffer *buf,
7889 struct cache_tree *extent_cache,
7890 struct cache_tree *pending,
7891 struct cache_tree *seen,
7892 struct cache_tree *nodes,
7893 u64 objectid)
7894 {
7895 struct extent_record tmpl;
7896 int ret;
7897
7898 if (btrfs_header_level(buf) > 0)
7899 add_pending(nodes, seen, buf->start, buf->len);
7900 else
7901 add_pending(pending, seen, buf->start, buf->len);
7902
7903 memset(&tmpl, 0, sizeof(tmpl));
7904 tmpl.start = buf->start;
7905 tmpl.nr = buf->len;
7906 tmpl.is_root = 1;
7907 tmpl.refs = 1;
7908 tmpl.metadata = 1;
7909 tmpl.max_size = buf->len;
7910 add_extent_rec(extent_cache, &tmpl);
7911
7912 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7913 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7914 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7915 0, 1);
7916 else
7917 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7918 1);
7919 return ret;
7920 }
7921
7922 /* as we fix the tree, we might be deleting blocks that
7923 * we're tracking for repair. This hook makes sure we
7924 * remove any backrefs for blocks as we are fixing them.
7925 */
7926 static int free_extent_hook(struct btrfs_trans_handle *trans,
7927 struct btrfs_root *root,
7928 u64 bytenr, u64 num_bytes, u64 parent,
7929 u64 root_objectid, u64 owner, u64 offset,
7930 int refs_to_drop)
7931 {
7932 struct extent_record *rec;
7933 struct cache_extent *cache;
7934 int is_data;
7935 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
7936
7937 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
7938 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
7939 if (!cache)
7940 return 0;
7941
7942 rec = container_of(cache, struct extent_record, cache);
7943 if (is_data) {
7944 struct data_backref *back;
7945 back = find_data_backref(rec, parent, root_objectid, owner,
7946 offset, 1, bytenr, num_bytes);
7947 if (!back)
7948 goto out;
7949 if (back->node.found_ref) {
7950 back->found_ref -= refs_to_drop;
7951 if (rec->refs)
7952 rec->refs -= refs_to_drop;
7953 }
7954 if (back->node.found_extent_tree) {
7955 back->num_refs -= refs_to_drop;
7956 if (rec->extent_item_refs)
7957 rec->extent_item_refs -= refs_to_drop;
7958 }
7959 if (back->found_ref == 0)
7960 back->node.found_ref = 0;
7961 if (back->num_refs == 0)
7962 back->node.found_extent_tree = 0;
7963
7964 if (!back->node.found_extent_tree && back->node.found_ref) {
7965 list_del(&back->node.list);
7966 free(back);
7967 }
7968 } else {
7969 struct tree_backref *back;
7970 back = find_tree_backref(rec, parent, root_objectid);
7971 if (!back)
7972 goto out;
7973 if (back->node.found_ref) {
7974 if (rec->refs)
7975 rec->refs--;
7976 back->node.found_ref = 0;
7977 }
7978 if (back->node.found_extent_tree) {
7979 if (rec->extent_item_refs)
7980 rec->extent_item_refs--;
7981 back->node.found_extent_tree = 0;
7982 }
7983 if (!back->node.found_extent_tree && back->node.found_ref) {
7984 list_del(&back->node.list);
7985 free(back);
7986 }
7987 }
7988 maybe_free_extent_rec(extent_cache, rec);
7989 out:
7990 return 0;
7991 }
7992
7993 static int delete_extent_records(struct btrfs_trans_handle *trans,
7994 struct btrfs_root *root,
7995 struct btrfs_path *path,
7996 u64 bytenr)
7997 {
7998 struct btrfs_key key;
7999 struct btrfs_key found_key;
8000 struct extent_buffer *leaf;
8001 int ret;
8002 int slot;
8003
8004
8005 key.objectid = bytenr;
8006 key.type = (u8)-1;
8007 key.offset = (u64)-1;
8008
8009 while(1) {
8010 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
8011 &key, path, 0, 1);
8012 if (ret < 0)
8013 break;
8014
8015 if (ret > 0) {
8016 ret = 0;
8017 if (path->slots[0] == 0)
8018 break;
8019 path->slots[0]--;
8020 }
8021 ret = 0;
8022
8023 leaf = path->nodes[0];
8024 slot = path->slots[0];
8025
8026 btrfs_item_key_to_cpu(leaf, &found_key, slot);
8027 if (found_key.objectid != bytenr)
8028 break;
8029
8030 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
8031 found_key.type != BTRFS_METADATA_ITEM_KEY &&
8032 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
8033 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
8034 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
8035 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
8036 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
8037 btrfs_release_path(path);
8038 if (found_key.type == 0) {
8039 if (found_key.offset == 0)
8040 break;
8041 key.offset = found_key.offset - 1;
8042 key.type = found_key.type;
8043 }
8044 key.type = found_key.type - 1;
8045 key.offset = (u64)-1;
8046 continue;
8047 }
8048
8049 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8050 found_key.objectid, found_key.type, found_key.offset);
8051
8052 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8053 if (ret)
8054 break;
8055 btrfs_release_path(path);
8056
8057 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8058 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8059 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8060 found_key.offset : root->nodesize;
8061
8062 ret = btrfs_update_block_group(trans, root, bytenr,
8063 bytes, 0, 0);
8064 if (ret)
8065 break;
8066 }
8067 }
8068
8069 btrfs_release_path(path);
8070 return ret;
8071 }
8072
8073 /*
8074 * for a single backref, this will allocate a new extent
8075 * and add the backref to it.
8076 */
8077 static int record_extent(struct btrfs_trans_handle *trans,
8078 struct btrfs_fs_info *info,
8079 struct btrfs_path *path,
8080 struct extent_record *rec,
8081 struct extent_backref *back,
8082 int allocated, u64 flags)
8083 {
8084 int ret = 0;
8085 struct btrfs_root *extent_root = info->extent_root;
8086 struct extent_buffer *leaf;
8087 struct btrfs_key ins_key;
8088 struct btrfs_extent_item *ei;
8089 struct data_backref *dback;
8090 struct btrfs_tree_block_info *bi;
8091
8092 if (!back->is_data)
8093 rec->max_size = max_t(u64, rec->max_size,
8094 info->extent_root->nodesize);
8095
8096 if (!allocated) {
8097 u32 item_size = sizeof(*ei);
8098
8099 if (!back->is_data)
8100 item_size += sizeof(*bi);
8101
8102 ins_key.objectid = rec->start;
8103 ins_key.offset = rec->max_size;
8104 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8105
8106 ret = btrfs_insert_empty_item(trans, extent_root, path,
8107 &ins_key, item_size);
8108 if (ret)
8109 goto fail;
8110
8111 leaf = path->nodes[0];
8112 ei = btrfs_item_ptr(leaf, path->slots[0],
8113 struct btrfs_extent_item);
8114
8115 btrfs_set_extent_refs(leaf, ei, 0);
8116 btrfs_set_extent_generation(leaf, ei, rec->generation);
8117
8118 if (back->is_data) {
8119 btrfs_set_extent_flags(leaf, ei,
8120 BTRFS_EXTENT_FLAG_DATA);
8121 } else {
8122 struct btrfs_disk_key copy_key;;
8123
8124 bi = (struct btrfs_tree_block_info *)(ei + 1);
8125 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8126 sizeof(*bi));
8127
8128 btrfs_set_disk_key_objectid(&copy_key,
8129 rec->info_objectid);
8130 btrfs_set_disk_key_type(&copy_key, 0);
8131 btrfs_set_disk_key_offset(&copy_key, 0);
8132
8133 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8134 btrfs_set_tree_block_key(leaf, bi, &copy_key);
8135
8136 btrfs_set_extent_flags(leaf, ei,
8137 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8138 }
8139
8140 btrfs_mark_buffer_dirty(leaf);
8141 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8142 rec->max_size, 1, 0);
8143 if (ret)
8144 goto fail;
8145 btrfs_release_path(path);
8146 }
8147
8148 if (back->is_data) {
8149 u64 parent;
8150 int i;
8151
8152 dback = to_data_backref(back);
8153 if (back->full_backref)
8154 parent = dback->parent;
8155 else
8156 parent = 0;
8157
8158 for (i = 0; i < dback->found_ref; i++) {
8159 /* if parent != 0, we're doing a full backref
8160 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8161 * just makes the backref allocator create a data
8162 * backref
8163 */
8164 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8165 rec->start, rec->max_size,
8166 parent,
8167 dback->root,
8168 parent ?
8169 BTRFS_FIRST_FREE_OBJECTID :
8170 dback->owner,
8171 dback->offset);
8172 if (ret)
8173 break;
8174 }
8175 fprintf(stderr, "adding new data backref"
8176 " on %llu %s %llu owner %llu"
8177 " offset %llu found %d\n",
8178 (unsigned long long)rec->start,
8179 back->full_backref ?
8180 "parent" : "root",
8181 back->full_backref ?
8182 (unsigned long long)parent :
8183 (unsigned long long)dback->root,
8184 (unsigned long long)dback->owner,
8185 (unsigned long long)dback->offset,
8186 dback->found_ref);
8187 } else {
8188 u64 parent;
8189 struct tree_backref *tback;
8190
8191 tback = to_tree_backref(back);
8192 if (back->full_backref)
8193 parent = tback->parent;
8194 else
8195 parent = 0;
8196
8197 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8198 rec->start, rec->max_size,
8199 parent, tback->root, 0, 0);
8200 fprintf(stderr, "adding new tree backref on "
8201 "start %llu len %llu parent %llu root %llu\n",
8202 rec->start, rec->max_size, parent, tback->root);
8203 }
8204 fail:
8205 btrfs_release_path(path);
8206 return ret;
8207 }
8208
8209 static struct extent_entry *find_entry(struct list_head *entries,
8210 u64 bytenr, u64 bytes)
8211 {
8212 struct extent_entry *entry = NULL;
8213
8214 list_for_each_entry(entry, entries, list) {
8215 if (entry->bytenr == bytenr && entry->bytes == bytes)
8216 return entry;
8217 }
8218
8219 return NULL;
8220 }
8221
8222 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8223 {
8224 struct extent_entry *entry, *best = NULL, *prev = NULL;
8225
8226 list_for_each_entry(entry, entries, list) {
8227 /*
8228 * If there are as many broken entries as entries then we know
8229 * not to trust this particular entry.
8230 */
8231 if (entry->broken == entry->count)
8232 continue;
8233
8234 /*
8235 * Special case, when there are only two entries and 'best' is
8236 * the first one
8237 */
8238 if (!prev) {
8239 best = entry;
8240 prev = entry;
8241 continue;
8242 }
8243
8244 /*
8245 * If our current entry == best then we can't be sure our best
8246 * is really the best, so we need to keep searching.
8247 */
8248 if (best && best->count == entry->count) {
8249 prev = entry;
8250 best = NULL;
8251 continue;
8252 }
8253
8254 /* Prev == entry, not good enough, have to keep searching */
8255 if (!prev->broken && prev->count == entry->count)
8256 continue;
8257
8258 if (!best)
8259 best = (prev->count > entry->count) ? prev : entry;
8260 else if (best->count < entry->count)
8261 best = entry;
8262 prev = entry;
8263 }
8264
8265 return best;
8266 }
8267
8268 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8269 struct data_backref *dback, struct extent_entry *entry)
8270 {
8271 struct btrfs_trans_handle *trans;
8272 struct btrfs_root *root;
8273 struct btrfs_file_extent_item *fi;
8274 struct extent_buffer *leaf;
8275 struct btrfs_key key;
8276 u64 bytenr, bytes;
8277 int ret, err;
8278
8279 key.objectid = dback->root;
8280 key.type = BTRFS_ROOT_ITEM_KEY;
8281 key.offset = (u64)-1;
8282 root = btrfs_read_fs_root(info, &key);
8283 if (IS_ERR(root)) {
8284 fprintf(stderr, "Couldn't find root for our ref\n");
8285 return -EINVAL;
8286 }
8287
8288 /*
8289 * The backref points to the original offset of the extent if it was
8290 * split, so we need to search down to the offset we have and then walk
8291 * forward until we find the backref we're looking for.
8292 */
8293 key.objectid = dback->owner;
8294 key.type = BTRFS_EXTENT_DATA_KEY;
8295 key.offset = dback->offset;
8296 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8297 if (ret < 0) {
8298 fprintf(stderr, "Error looking up ref %d\n", ret);
8299 return ret;
8300 }
8301
8302 while (1) {
8303 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8304 ret = btrfs_next_leaf(root, path);
8305 if (ret) {
8306 fprintf(stderr, "Couldn't find our ref, next\n");
8307 return -EINVAL;
8308 }
8309 }
8310 leaf = path->nodes[0];
8311 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8312 if (key.objectid != dback->owner ||
8313 key.type != BTRFS_EXTENT_DATA_KEY) {
8314 fprintf(stderr, "Couldn't find our ref, search\n");
8315 return -EINVAL;
8316 }
8317 fi = btrfs_item_ptr(leaf, path->slots[0],
8318 struct btrfs_file_extent_item);
8319 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8320 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8321
8322 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8323 break;
8324 path->slots[0]++;
8325 }
8326
8327 btrfs_release_path(path);
8328
8329 trans = btrfs_start_transaction(root, 1);
8330 if (IS_ERR(trans))
8331 return PTR_ERR(trans);
8332
8333 /*
8334 * Ok we have the key of the file extent we want to fix, now we can cow
8335 * down to the thing and fix it.
8336 */
8337 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8338 if (ret < 0) {
8339 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8340 key.objectid, key.type, key.offset, ret);
8341 goto out;
8342 }
8343 if (ret > 0) {
8344 fprintf(stderr, "Well that's odd, we just found this key "
8345 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8346 key.offset);
8347 ret = -EINVAL;
8348 goto out;
8349 }
8350 leaf = path->nodes[0];
8351 fi = btrfs_item_ptr(leaf, path->slots[0],
8352 struct btrfs_file_extent_item);
8353
8354 if (btrfs_file_extent_compression(leaf, fi) &&
8355 dback->disk_bytenr != entry->bytenr) {
8356 fprintf(stderr, "Ref doesn't match the record start and is "
8357 "compressed, please take a btrfs-image of this file "
8358 "system and send it to a btrfs developer so they can "
8359 "complete this functionality for bytenr %Lu\n",
8360 dback->disk_bytenr);
8361 ret = -EINVAL;
8362 goto out;
8363 }
8364
8365 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8366 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8367 } else if (dback->disk_bytenr > entry->bytenr) {
8368 u64 off_diff, offset;
8369
8370 off_diff = dback->disk_bytenr - entry->bytenr;
8371 offset = btrfs_file_extent_offset(leaf, fi);
8372 if (dback->disk_bytenr + offset +
8373 btrfs_file_extent_num_bytes(leaf, fi) >
8374 entry->bytenr + entry->bytes) {
8375 fprintf(stderr, "Ref is past the entry end, please "
8376 "take a btrfs-image of this file system and "
8377 "send it to a btrfs developer, ref %Lu\n",
8378 dback->disk_bytenr);
8379 ret = -EINVAL;
8380 goto out;
8381 }
8382 offset += off_diff;
8383 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8384 btrfs_set_file_extent_offset(leaf, fi, offset);
8385 } else if (dback->disk_bytenr < entry->bytenr) {
8386 u64 offset;
8387
8388 offset = btrfs_file_extent_offset(leaf, fi);
8389 if (dback->disk_bytenr + offset < entry->bytenr) {
8390 fprintf(stderr, "Ref is before the entry start, please"
8391 " take a btrfs-image of this file system and "
8392 "send it to a btrfs developer, ref %Lu\n",
8393 dback->disk_bytenr);
8394 ret = -EINVAL;
8395 goto out;
8396 }
8397
8398 offset += dback->disk_bytenr;
8399 offset -= entry->bytenr;
8400 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8401 btrfs_set_file_extent_offset(leaf, fi, offset);
8402 }
8403
8404 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8405
8406 /*
8407 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8408 * only do this if we aren't using compression, otherwise it's a
8409 * trickier case.
8410 */
8411 if (!btrfs_file_extent_compression(leaf, fi))
8412 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8413 else
8414 printf("ram bytes may be wrong?\n");
8415 btrfs_mark_buffer_dirty(leaf);
8416 out:
8417 err = btrfs_commit_transaction(trans, root);
8418 btrfs_release_path(path);
8419 return ret ? ret : err;
8420 }
8421
8422 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8423 struct extent_record *rec)
8424 {
8425 struct extent_backref *back;
8426 struct data_backref *dback;
8427 struct extent_entry *entry, *best = NULL;
8428 LIST_HEAD(entries);
8429 int nr_entries = 0;
8430 int broken_entries = 0;
8431 int ret = 0;
8432 short mismatch = 0;
8433
8434 /*
8435 * Metadata is easy and the backrefs should always agree on bytenr and
8436 * size, if not we've got bigger issues.
8437 */
8438 if (rec->metadata)
8439 return 0;
8440
8441 list_for_each_entry(back, &rec->backrefs, list) {
8442 if (back->full_backref || !back->is_data)
8443 continue;
8444
8445 dback = to_data_backref(back);
8446
8447 /*
8448 * We only pay attention to backrefs that we found a real
8449 * backref for.
8450 */
8451 if (dback->found_ref == 0)
8452 continue;
8453
8454 /*
8455 * For now we only catch when the bytes don't match, not the
8456 * bytenr. We can easily do this at the same time, but I want
8457 * to have a fs image to test on before we just add repair
8458 * functionality willy-nilly so we know we won't screw up the
8459 * repair.
8460 */
8461
8462 entry = find_entry(&entries, dback->disk_bytenr,
8463 dback->bytes);
8464 if (!entry) {
8465 entry = malloc(sizeof(struct extent_entry));
8466 if (!entry) {
8467 ret = -ENOMEM;
8468 goto out;
8469 }
8470 memset(entry, 0, sizeof(*entry));
8471 entry->bytenr = dback->disk_bytenr;
8472 entry->bytes = dback->bytes;
8473 list_add_tail(&entry->list, &entries);
8474 nr_entries++;
8475 }
8476
8477 /*
8478 * If we only have on entry we may think the entries agree when
8479 * in reality they don't so we have to do some extra checking.
8480 */
8481 if (dback->disk_bytenr != rec->start ||
8482 dback->bytes != rec->nr || back->broken)
8483 mismatch = 1;
8484
8485 if (back->broken) {
8486 entry->broken++;
8487 broken_entries++;
8488 }
8489
8490 entry->count++;
8491 }
8492
8493 /* Yay all the backrefs agree, carry on good sir */
8494 if (nr_entries <= 1 && !mismatch)
8495 goto out;
8496
8497 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8498 "%Lu\n", rec->start);
8499
8500 /*
8501 * First we want to see if the backrefs can agree amongst themselves who
8502 * is right, so figure out which one of the entries has the highest
8503 * count.
8504 */
8505 best = find_most_right_entry(&entries);
8506
8507 /*
8508 * Ok so we may have an even split between what the backrefs think, so
8509 * this is where we use the extent ref to see what it thinks.
8510 */
8511 if (!best) {
8512 entry = find_entry(&entries, rec->start, rec->nr);
8513 if (!entry && (!broken_entries || !rec->found_rec)) {
8514 fprintf(stderr, "Backrefs don't agree with each other "
8515 "and extent record doesn't agree with anybody,"
8516 " so we can't fix bytenr %Lu bytes %Lu\n",
8517 rec->start, rec->nr);
8518 ret = -EINVAL;
8519 goto out;
8520 } else if (!entry) {
8521 /*
8522 * Ok our backrefs were broken, we'll assume this is the
8523 * correct value and add an entry for this range.
8524 */
8525 entry = malloc(sizeof(struct extent_entry));
8526 if (!entry) {
8527 ret = -ENOMEM;
8528 goto out;
8529 }
8530 memset(entry, 0, sizeof(*entry));
8531 entry->bytenr = rec->start;
8532 entry->bytes = rec->nr;
8533 list_add_tail(&entry->list, &entries);
8534 nr_entries++;
8535 }
8536 entry->count++;
8537 best = find_most_right_entry(&entries);
8538 if (!best) {
8539 fprintf(stderr, "Backrefs and extent record evenly "
8540 "split on who is right, this is going to "
8541 "require user input to fix bytenr %Lu bytes "
8542 "%Lu\n", rec->start, rec->nr);
8543 ret = -EINVAL;
8544 goto out;
8545 }
8546 }
8547
8548 /*
8549 * I don't think this can happen currently as we'll abort() if we catch
8550 * this case higher up, but in case somebody removes that we still can't
8551 * deal with it properly here yet, so just bail out of that's the case.
8552 */
8553 if (best->bytenr != rec->start) {
8554 fprintf(stderr, "Extent start and backref starts don't match, "
8555 "please use btrfs-image on this file system and send "
8556 "it to a btrfs developer so they can make fsck fix "
8557 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8558 rec->start, rec->nr);
8559 ret = -EINVAL;
8560 goto out;
8561 }
8562
8563 /*
8564 * Ok great we all agreed on an extent record, let's go find the real
8565 * references and fix up the ones that don't match.
8566 */
8567 list_for_each_entry(back, &rec->backrefs, list) {
8568 if (back->full_backref || !back->is_data)
8569 continue;
8570
8571 dback = to_data_backref(back);
8572
8573 /*
8574 * Still ignoring backrefs that don't have a real ref attached
8575 * to them.
8576 */
8577 if (dback->found_ref == 0)
8578 continue;
8579
8580 if (dback->bytes == best->bytes &&
8581 dback->disk_bytenr == best->bytenr)
8582 continue;
8583
8584 ret = repair_ref(info, path, dback, best);
8585 if (ret)
8586 goto out;
8587 }
8588
8589 /*
8590 * Ok we messed with the actual refs, which means we need to drop our
8591 * entire cache and go back and rescan. I know this is a huge pain and
8592 * adds a lot of extra work, but it's the only way to be safe. Once all
8593 * the backrefs agree we may not need to do anything to the extent
8594 * record itself.
8595 */
8596 ret = -EAGAIN;
8597 out:
8598 while (!list_empty(&entries)) {
8599 entry = list_entry(entries.next, struct extent_entry, list);
8600 list_del_init(&entry->list);
8601 free(entry);
8602 }
8603 return ret;
8604 }
8605
8606 static int process_duplicates(struct cache_tree *extent_cache,
8607 struct extent_record *rec)
8608 {
8609 struct extent_record *good, *tmp;
8610 struct cache_extent *cache;
8611 int ret;
8612
8613 /*
8614 * If we found a extent record for this extent then return, or if we
8615 * have more than one duplicate we are likely going to need to delete
8616 * something.
8617 */
8618 if (rec->found_rec || rec->num_duplicates > 1)
8619 return 0;
8620
8621 /* Shouldn't happen but just in case */
8622 BUG_ON(!rec->num_duplicates);
8623
8624 /*
8625 * So this happens if we end up with a backref that doesn't match the
8626 * actual extent entry. So either the backref is bad or the extent
8627 * entry is bad. Either way we want to have the extent_record actually
8628 * reflect what we found in the extent_tree, so we need to take the
8629 * duplicate out and use that as the extent_record since the only way we
8630 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8631 */
8632 remove_cache_extent(extent_cache, &rec->cache);
8633
8634 good = to_extent_record(rec->dups.next);
8635 list_del_init(&good->list);
8636 INIT_LIST_HEAD(&good->backrefs);
8637 INIT_LIST_HEAD(&good->dups);
8638 good->cache.start = good->start;
8639 good->cache.size = good->nr;
8640 good->content_checked = 0;
8641 good->owner_ref_checked = 0;
8642 good->num_duplicates = 0;
8643 good->refs = rec->refs;
8644 list_splice_init(&rec->backrefs, &good->backrefs);
8645 while (1) {
8646 cache = lookup_cache_extent(extent_cache, good->start,
8647 good->nr);
8648 if (!cache)
8649 break;
8650 tmp = container_of(cache, struct extent_record, cache);
8651
8652 /*
8653 * If we find another overlapping extent and it's found_rec is
8654 * set then it's a duplicate and we need to try and delete
8655 * something.
8656 */
8657 if (tmp->found_rec || tmp->num_duplicates > 0) {
8658 if (list_empty(&good->list))
8659 list_add_tail(&good->list,
8660 &duplicate_extents);
8661 good->num_duplicates += tmp->num_duplicates + 1;
8662 list_splice_init(&tmp->dups, &good->dups);
8663 list_del_init(&tmp->list);
8664 list_add_tail(&tmp->list, &good->dups);
8665 remove_cache_extent(extent_cache, &tmp->cache);
8666 continue;
8667 }
8668
8669 /*
8670 * Ok we have another non extent item backed extent rec, so lets
8671 * just add it to this extent and carry on like we did above.
8672 */
8673 good->refs += tmp->refs;
8674 list_splice_init(&tmp->backrefs, &good->backrefs);
8675 remove_cache_extent(extent_cache, &tmp->cache);
8676 free(tmp);
8677 }
8678 ret = insert_cache_extent(extent_cache, &good->cache);
8679 BUG_ON(ret);
8680 free(rec);
8681 return good->num_duplicates ? 0 : 1;
8682 }
8683
8684 static int delete_duplicate_records(struct btrfs_root *root,
8685 struct extent_record *rec)
8686 {
8687 struct btrfs_trans_handle *trans;
8688 LIST_HEAD(delete_list);
8689 struct btrfs_path path;
8690 struct extent_record *tmp, *good, *n;
8691 int nr_del = 0;
8692 int ret = 0, err;
8693 struct btrfs_key key;
8694
8695 btrfs_init_path(&path);
8696
8697 good = rec;
8698 /* Find the record that covers all of the duplicates. */
8699 list_for_each_entry(tmp, &rec->dups, list) {
8700 if (good->start < tmp->start)
8701 continue;
8702 if (good->nr > tmp->nr)
8703 continue;
8704
8705 if (tmp->start + tmp->nr < good->start + good->nr) {
8706 fprintf(stderr, "Ok we have overlapping extents that "
8707 "aren't completely covered by each other, this "
8708 "is going to require more careful thought. "
8709 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8710 tmp->start, tmp->nr, good->start, good->nr);
8711 abort();
8712 }
8713 good = tmp;
8714 }
8715
8716 if (good != rec)
8717 list_add_tail(&rec->list, &delete_list);
8718
8719 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8720 if (tmp == good)
8721 continue;
8722 list_move_tail(&tmp->list, &delete_list);
8723 }
8724
8725 root = root->fs_info->extent_root;
8726 trans = btrfs_start_transaction(root, 1);
8727 if (IS_ERR(trans)) {
8728 ret = PTR_ERR(trans);
8729 goto out;
8730 }
8731
8732 list_for_each_entry(tmp, &delete_list, list) {
8733 if (tmp->found_rec == 0)
8734 continue;
8735 key.objectid = tmp->start;
8736 key.type = BTRFS_EXTENT_ITEM_KEY;
8737 key.offset = tmp->nr;
8738
8739 /* Shouldn't happen but just in case */
8740 if (tmp->metadata) {
8741 fprintf(stderr, "Well this shouldn't happen, extent "
8742 "record overlaps but is metadata? "
8743 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8744 abort();
8745 }
8746
8747 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8748 if (ret) {
8749 if (ret > 0)
8750 ret = -EINVAL;
8751 break;
8752 }
8753 ret = btrfs_del_item(trans, root, &path);
8754 if (ret)
8755 break;
8756 btrfs_release_path(&path);
8757 nr_del++;
8758 }
8759 err = btrfs_commit_transaction(trans, root);
8760 if (err && !ret)
8761 ret = err;
8762 out:
8763 while (!list_empty(&delete_list)) {
8764 tmp = to_extent_record(delete_list.next);
8765 list_del_init(&tmp->list);
8766 if (tmp == rec)
8767 continue;
8768 free(tmp);
8769 }
8770
8771 while (!list_empty(&rec->dups)) {
8772 tmp = to_extent_record(rec->dups.next);
8773 list_del_init(&tmp->list);
8774 free(tmp);
8775 }
8776
8777 btrfs_release_path(&path);
8778
8779 if (!ret && !nr_del)
8780 rec->num_duplicates = 0;
8781
8782 return ret ? ret : nr_del;
8783 }
8784
8785 static int find_possible_backrefs(struct btrfs_fs_info *info,
8786 struct btrfs_path *path,
8787 struct cache_tree *extent_cache,
8788 struct extent_record *rec)
8789 {
8790 struct btrfs_root *root;
8791 struct extent_backref *back;
8792 struct data_backref *dback;
8793 struct cache_extent *cache;
8794 struct btrfs_file_extent_item *fi;
8795 struct btrfs_key key;
8796 u64 bytenr, bytes;
8797 int ret;
8798
8799 list_for_each_entry(back, &rec->backrefs, list) {
8800 /* Don't care about full backrefs (poor unloved backrefs) */
8801 if (back->full_backref || !back->is_data)
8802 continue;
8803
8804 dback = to_data_backref(back);
8805
8806 /* We found this one, we don't need to do a lookup */
8807 if (dback->found_ref)
8808 continue;
8809
8810 key.objectid = dback->root;
8811 key.type = BTRFS_ROOT_ITEM_KEY;
8812 key.offset = (u64)-1;
8813
8814 root = btrfs_read_fs_root(info, &key);
8815
8816 /* No root, definitely a bad ref, skip */
8817 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8818 continue;
8819 /* Other err, exit */
8820 if (IS_ERR(root))
8821 return PTR_ERR(root);
8822
8823 key.objectid = dback->owner;
8824 key.type = BTRFS_EXTENT_DATA_KEY;
8825 key.offset = dback->offset;
8826 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8827 if (ret) {
8828 btrfs_release_path(path);
8829 if (ret < 0)
8830 return ret;
8831 /* Didn't find it, we can carry on */
8832 ret = 0;
8833 continue;
8834 }
8835
8836 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8837 struct btrfs_file_extent_item);
8838 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8839 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8840 btrfs_release_path(path);
8841 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8842 if (cache) {
8843 struct extent_record *tmp;
8844 tmp = container_of(cache, struct extent_record, cache);
8845
8846 /*
8847 * If we found an extent record for the bytenr for this
8848 * particular backref then we can't add it to our
8849 * current extent record. We only want to add backrefs
8850 * that don't have a corresponding extent item in the
8851 * extent tree since they likely belong to this record
8852 * and we need to fix it if it doesn't match bytenrs.
8853 */
8854 if (tmp->found_rec)
8855 continue;
8856 }
8857
8858 dback->found_ref += 1;
8859 dback->disk_bytenr = bytenr;
8860 dback->bytes = bytes;
8861
8862 /*
8863 * Set this so the verify backref code knows not to trust the
8864 * values in this backref.
8865 */
8866 back->broken = 1;
8867 }
8868
8869 return 0;
8870 }
8871
8872 /*
8873 * Record orphan data ref into corresponding root.
8874 *
8875 * Return 0 if the extent item contains data ref and recorded.
8876 * Return 1 if the extent item contains no useful data ref
8877 * On that case, it may contains only shared_dataref or metadata backref
8878 * or the file extent exists(this should be handled by the extent bytenr
8879 * recovery routine)
8880 * Return <0 if something goes wrong.
8881 */
8882 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8883 struct extent_record *rec)
8884 {
8885 struct btrfs_key key;
8886 struct btrfs_root *dest_root;
8887 struct extent_backref *back;
8888 struct data_backref *dback;
8889 struct orphan_data_extent *orphan;
8890 struct btrfs_path path;
8891 int recorded_data_ref = 0;
8892 int ret = 0;
8893
8894 if (rec->metadata)
8895 return 1;
8896 btrfs_init_path(&path);
8897 list_for_each_entry(back, &rec->backrefs, list) {
8898 if (back->full_backref || !back->is_data ||
8899 !back->found_extent_tree)
8900 continue;
8901 dback = to_data_backref(back);
8902 if (dback->found_ref)
8903 continue;
8904 key.objectid = dback->root;
8905 key.type = BTRFS_ROOT_ITEM_KEY;
8906 key.offset = (u64)-1;
8907
8908 dest_root = btrfs_read_fs_root(fs_info, &key);
8909
8910 /* For non-exist root we just skip it */
8911 if (IS_ERR(dest_root) || !dest_root)
8912 continue;
8913
8914 key.objectid = dback->owner;
8915 key.type = BTRFS_EXTENT_DATA_KEY;
8916 key.offset = dback->offset;
8917
8918 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8919 btrfs_release_path(&path);
8920 /*
8921 * For ret < 0, it's OK since the fs-tree may be corrupted,
8922 * we need to record it for inode/file extent rebuild.
8923 * For ret > 0, we record it only for file extent rebuild.
8924 * For ret == 0, the file extent exists but only bytenr
8925 * mismatch, let the original bytenr fix routine to handle,
8926 * don't record it.
8927 */
8928 if (ret == 0)
8929 continue;
8930 ret = 0;
8931 orphan = malloc(sizeof(*orphan));
8932 if (!orphan) {
8933 ret = -ENOMEM;
8934 goto out;
8935 }
8936 INIT_LIST_HEAD(&orphan->list);
8937 orphan->root = dback->root;
8938 orphan->objectid = dback->owner;
8939 orphan->offset = dback->offset;
8940 orphan->disk_bytenr = rec->cache.start;
8941 orphan->disk_len = rec->cache.size;
8942 list_add(&dest_root->orphan_data_extents, &orphan->list);
8943 recorded_data_ref = 1;
8944 }
8945 out:
8946 btrfs_release_path(&path);
8947 if (!ret)
8948 return !recorded_data_ref;
8949 else
8950 return ret;
8951 }
8952
8953 /*
8954 * when an incorrect extent item is found, this will delete
8955 * all of the existing entries for it and recreate them
8956 * based on what the tree scan found.
8957 */
8958 static int fixup_extent_refs(struct btrfs_fs_info *info,
8959 struct cache_tree *extent_cache,
8960 struct extent_record *rec)
8961 {
8962 struct btrfs_trans_handle *trans = NULL;
8963 int ret;
8964 struct btrfs_path path;
8965 struct list_head *cur = rec->backrefs.next;
8966 struct cache_extent *cache;
8967 struct extent_backref *back;
8968 int allocated = 0;
8969 u64 flags = 0;
8970
8971 if (rec->flag_block_full_backref)
8972 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
8973
8974 btrfs_init_path(&path);
8975 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
8976 /*
8977 * Sometimes the backrefs themselves are so broken they don't
8978 * get attached to any meaningful rec, so first go back and
8979 * check any of our backrefs that we couldn't find and throw
8980 * them into the list if we find the backref so that
8981 * verify_backrefs can figure out what to do.
8982 */
8983 ret = find_possible_backrefs(info, &path, extent_cache, rec);
8984 if (ret < 0)
8985 goto out;
8986 }
8987
8988 /* step one, make sure all of the backrefs agree */
8989 ret = verify_backrefs(info, &path, rec);
8990 if (ret < 0)
8991 goto out;
8992
8993 trans = btrfs_start_transaction(info->extent_root, 1);
8994 if (IS_ERR(trans)) {
8995 ret = PTR_ERR(trans);
8996 goto out;
8997 }
8998
8999 /* step two, delete all the existing records */
9000 ret = delete_extent_records(trans, info->extent_root, &path,
9001 rec->start);
9002
9003 if (ret < 0)
9004 goto out;
9005
9006 /* was this block corrupt? If so, don't add references to it */
9007 cache = lookup_cache_extent(info->corrupt_blocks,
9008 rec->start, rec->max_size);
9009 if (cache) {
9010 ret = 0;
9011 goto out;
9012 }
9013
9014 /* step three, recreate all the refs we did find */
9015 while(cur != &rec->backrefs) {
9016 back = to_extent_backref(cur);
9017 cur = cur->next;
9018
9019 /*
9020 * if we didn't find any references, don't create a
9021 * new extent record
9022 */
9023 if (!back->found_ref)
9024 continue;
9025
9026 rec->bad_full_backref = 0;
9027 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
9028 allocated = 1;
9029
9030 if (ret)
9031 goto out;
9032 }
9033 out:
9034 if (trans) {
9035 int err = btrfs_commit_transaction(trans, info->extent_root);
9036 if (!ret)
9037 ret = err;
9038 }
9039
9040 if (!ret)
9041 fprintf(stderr, "Repaired extent references for %llu\n",
9042 (unsigned long long)rec->start);
9043
9044 btrfs_release_path(&path);
9045 return ret;
9046 }
9047
9048 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9049 struct extent_record *rec)
9050 {
9051 struct btrfs_trans_handle *trans;
9052 struct btrfs_root *root = fs_info->extent_root;
9053 struct btrfs_path path;
9054 struct btrfs_extent_item *ei;
9055 struct btrfs_key key;
9056 u64 flags;
9057 int ret = 0;
9058
9059 key.objectid = rec->start;
9060 if (rec->metadata) {
9061 key.type = BTRFS_METADATA_ITEM_KEY;
9062 key.offset = rec->info_level;
9063 } else {
9064 key.type = BTRFS_EXTENT_ITEM_KEY;
9065 key.offset = rec->max_size;
9066 }
9067
9068 trans = btrfs_start_transaction(root, 0);
9069 if (IS_ERR(trans))
9070 return PTR_ERR(trans);
9071
9072 btrfs_init_path(&path);
9073 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9074 if (ret < 0) {
9075 btrfs_release_path(&path);
9076 btrfs_commit_transaction(trans, root);
9077 return ret;
9078 } else if (ret) {
9079 fprintf(stderr, "Didn't find extent for %llu\n",
9080 (unsigned long long)rec->start);
9081 btrfs_release_path(&path);
9082 btrfs_commit_transaction(trans, root);
9083 return -ENOENT;
9084 }
9085
9086 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9087 struct btrfs_extent_item);
9088 flags = btrfs_extent_flags(path.nodes[0], ei);
9089 if (rec->flag_block_full_backref) {
9090 fprintf(stderr, "setting full backref on %llu\n",
9091 (unsigned long long)key.objectid);
9092 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9093 } else {
9094 fprintf(stderr, "clearing full backref on %llu\n",
9095 (unsigned long long)key.objectid);
9096 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9097 }
9098 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9099 btrfs_mark_buffer_dirty(path.nodes[0]);
9100 btrfs_release_path(&path);
9101 ret = btrfs_commit_transaction(trans, root);
9102 if (!ret)
9103 fprintf(stderr, "Repaired extent flags for %llu\n",
9104 (unsigned long long)rec->start);
9105
9106 return ret;
9107 }
9108
9109 /* right now we only prune from the extent allocation tree */
9110 static int prune_one_block(struct btrfs_trans_handle *trans,
9111 struct btrfs_fs_info *info,
9112 struct btrfs_corrupt_block *corrupt)
9113 {
9114 int ret;
9115 struct btrfs_path path;
9116 struct extent_buffer *eb;
9117 u64 found;
9118 int slot;
9119 int nritems;
9120 int level = corrupt->level + 1;
9121
9122 btrfs_init_path(&path);
9123 again:
9124 /* we want to stop at the parent to our busted block */
9125 path.lowest_level = level;
9126
9127 ret = btrfs_search_slot(trans, info->extent_root,
9128 &corrupt->key, &path, -1, 1);
9129
9130 if (ret < 0)
9131 goto out;
9132
9133 eb = path.nodes[level];
9134 if (!eb) {
9135 ret = -ENOENT;
9136 goto out;
9137 }
9138
9139 /*
9140 * hopefully the search gave us the block we want to prune,
9141 * lets try that first
9142 */
9143 slot = path.slots[level];
9144 found = btrfs_node_blockptr(eb, slot);
9145 if (found == corrupt->cache.start)
9146 goto del_ptr;
9147
9148 nritems = btrfs_header_nritems(eb);
9149
9150 /* the search failed, lets scan this node and hope we find it */
9151 for (slot = 0; slot < nritems; slot++) {
9152 found = btrfs_node_blockptr(eb, slot);
9153 if (found == corrupt->cache.start)
9154 goto del_ptr;
9155 }
9156 /*
9157 * we couldn't find the bad block. TODO, search all the nodes for pointers
9158 * to this block
9159 */
9160 if (eb == info->extent_root->node) {
9161 ret = -ENOENT;
9162 goto out;
9163 } else {
9164 level++;
9165 btrfs_release_path(&path);
9166 goto again;
9167 }
9168
9169 del_ptr:
9170 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9171 ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
9172
9173 out:
9174 btrfs_release_path(&path);
9175 return ret;
9176 }
9177
9178 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9179 {
9180 struct btrfs_trans_handle *trans = NULL;
9181 struct cache_extent *cache;
9182 struct btrfs_corrupt_block *corrupt;
9183
9184 while (1) {
9185 cache = search_cache_extent(info->corrupt_blocks, 0);
9186 if (!cache)
9187 break;
9188 if (!trans) {
9189 trans = btrfs_start_transaction(info->extent_root, 1);
9190 if (IS_ERR(trans))
9191 return PTR_ERR(trans);
9192 }
9193 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9194 prune_one_block(trans, info, corrupt);
9195 remove_cache_extent(info->corrupt_blocks, cache);
9196 }
9197 if (trans)
9198 return btrfs_commit_transaction(trans, info->extent_root);
9199 return 0;
9200 }
9201
9202 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9203 {
9204 struct btrfs_block_group_cache *cache;
9205 u64 start, end;
9206 int ret;
9207
9208 while (1) {
9209 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9210 &start, &end, EXTENT_DIRTY);
9211 if (ret)
9212 break;
9213 clear_extent_dirty(&fs_info->free_space_cache, start, end);
9214 }
9215
9216 start = 0;
9217 while (1) {
9218 cache = btrfs_lookup_first_block_group(fs_info, start);
9219 if (!cache)
9220 break;
9221 if (cache->cached)
9222 cache->cached = 0;
9223 start = cache->key.objectid + cache->key.offset;
9224 }
9225 }
9226
9227 static int check_extent_refs(struct btrfs_root *root,
9228 struct cache_tree *extent_cache)
9229 {
9230 struct extent_record *rec;
9231 struct cache_extent *cache;
9232 int ret = 0;
9233 int had_dups = 0;
9234
9235 if (repair) {
9236 /*
9237 * if we're doing a repair, we have to make sure
9238 * we don't allocate from the problem extents.
9239 * In the worst case, this will be all the
9240 * extents in the FS
9241 */
9242 cache = search_cache_extent(extent_cache, 0);
9243 while(cache) {
9244 rec = container_of(cache, struct extent_record, cache);
9245 set_extent_dirty(root->fs_info->excluded_extents,
9246 rec->start,
9247 rec->start + rec->max_size - 1);
9248 cache = next_cache_extent(cache);
9249 }
9250
9251 /* pin down all the corrupted blocks too */
9252 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9253 while(cache) {
9254 set_extent_dirty(root->fs_info->excluded_extents,
9255 cache->start,
9256 cache->start + cache->size - 1);
9257 cache = next_cache_extent(cache);
9258 }
9259 prune_corrupt_blocks(root->fs_info);
9260 reset_cached_block_groups(root->fs_info);
9261 }
9262
9263 reset_cached_block_groups(root->fs_info);
9264
9265 /*
9266 * We need to delete any duplicate entries we find first otherwise we
9267 * could mess up the extent tree when we have backrefs that actually
9268 * belong to a different extent item and not the weird duplicate one.
9269 */
9270 while (repair && !list_empty(&duplicate_extents)) {
9271 rec = to_extent_record(duplicate_extents.next);
9272 list_del_init(&rec->list);
9273
9274 /* Sometimes we can find a backref before we find an actual
9275 * extent, so we need to process it a little bit to see if there
9276 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9277 * if this is a backref screwup. If we need to delete stuff
9278 * process_duplicates() will return 0, otherwise it will return
9279 * 1 and we
9280 */
9281 if (process_duplicates(extent_cache, rec))
9282 continue;
9283 ret = delete_duplicate_records(root, rec);
9284 if (ret < 0)
9285 return ret;
9286 /*
9287 * delete_duplicate_records will return the number of entries
9288 * deleted, so if it's greater than 0 then we know we actually
9289 * did something and we need to remove.
9290 */
9291 if (ret)
9292 had_dups = 1;
9293 }
9294
9295 if (had_dups)
9296 return -EAGAIN;
9297
9298 while(1) {
9299 int cur_err = 0;
9300 int fix = 0;
9301
9302 cache = search_cache_extent(extent_cache, 0);
9303 if (!cache)
9304 break;
9305 rec = container_of(cache, struct extent_record, cache);
9306 if (rec->num_duplicates) {
9307 fprintf(stderr, "extent item %llu has multiple extent "
9308 "items\n", (unsigned long long)rec->start);
9309 cur_err = 1;
9310 }
9311
9312 if (rec->refs != rec->extent_item_refs) {
9313 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9314 (unsigned long long)rec->start,
9315 (unsigned long long)rec->nr);
9316 fprintf(stderr, "extent item %llu, found %llu\n",
9317 (unsigned long long)rec->extent_item_refs,
9318 (unsigned long long)rec->refs);
9319 ret = record_orphan_data_extents(root->fs_info, rec);
9320 if (ret < 0)
9321 goto repair_abort;
9322 fix = ret;
9323 cur_err = 1;
9324 }
9325 if (all_backpointers_checked(rec, 1)) {
9326 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9327 (unsigned long long)rec->start,
9328 (unsigned long long)rec->nr);
9329 fix = 1;
9330 cur_err = 1;
9331 }
9332 if (!rec->owner_ref_checked) {
9333 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9334 (unsigned long long)rec->start,
9335 (unsigned long long)rec->nr);
9336 fix = 1;
9337 cur_err = 1;
9338 }
9339
9340 if (repair && fix) {
9341 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9342 if (ret)
9343 goto repair_abort;
9344 }
9345
9346
9347 if (rec->bad_full_backref) {
9348 fprintf(stderr, "bad full backref, on [%llu]\n",
9349 (unsigned long long)rec->start);
9350 if (repair) {
9351 ret = fixup_extent_flags(root->fs_info, rec);
9352 if (ret)
9353 goto repair_abort;
9354 fix = 1;
9355 }
9356 cur_err = 1;
9357 }
9358 /*
9359 * Although it's not a extent ref's problem, we reuse this
9360 * routine for error reporting.
9361 * No repair function yet.
9362 */
9363 if (rec->crossing_stripes) {
9364 fprintf(stderr,
9365 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9366 rec->start, rec->start + rec->max_size);
9367 cur_err = 1;
9368 }
9369
9370 if (rec->wrong_chunk_type) {
9371 fprintf(stderr,
9372 "bad extent [%llu, %llu), type mismatch with chunk\n",
9373 rec->start, rec->start + rec->max_size);
9374 cur_err = 1;
9375 }
9376
9377 remove_cache_extent(extent_cache, cache);
9378 free_all_extent_backrefs(rec);
9379 if (!init_extent_tree && repair && (!cur_err || fix))
9380 clear_extent_dirty(root->fs_info->excluded_extents,
9381 rec->start,
9382 rec->start + rec->max_size - 1);
9383 free(rec);
9384 }
9385 repair_abort:
9386 if (repair) {
9387 if (ret && ret != -EAGAIN) {
9388 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9389 exit(1);
9390 } else if (!ret) {
9391 struct btrfs_trans_handle *trans;
9392
9393 root = root->fs_info->extent_root;
9394 trans = btrfs_start_transaction(root, 1);
9395 if (IS_ERR(trans)) {
9396 ret = PTR_ERR(trans);
9397 goto repair_abort;
9398 }
9399
9400 btrfs_fix_block_accounting(trans, root);
9401 ret = btrfs_commit_transaction(trans, root);
9402 if (ret)
9403 goto repair_abort;
9404 }
9405 return ret;
9406 }
9407 return 0;
9408 }
9409
9410 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9411 {
9412 u64 stripe_size;
9413
9414 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9415 stripe_size = length;
9416 stripe_size /= num_stripes;
9417 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9418 stripe_size = length * 2;
9419 stripe_size /= num_stripes;
9420 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9421 stripe_size = length;
9422 stripe_size /= (num_stripes - 1);
9423 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9424 stripe_size = length;
9425 stripe_size /= (num_stripes - 2);
9426 } else {
9427 stripe_size = length;
9428 }
9429 return stripe_size;
9430 }
9431
9432 /*
9433 * Check the chunk with its block group/dev list ref:
9434 * Return 0 if all refs seems valid.
9435 * Return 1 if part of refs seems valid, need later check for rebuild ref
9436 * like missing block group and needs to search extent tree to rebuild them.
9437 * Return -1 if essential refs are missing and unable to rebuild.
9438 */
9439 static int check_chunk_refs(struct chunk_record *chunk_rec,
9440 struct block_group_tree *block_group_cache,
9441 struct device_extent_tree *dev_extent_cache,
9442 int silent)
9443 {
9444 struct cache_extent *block_group_item;
9445 struct block_group_record *block_group_rec;
9446 struct cache_extent *dev_extent_item;
9447 struct device_extent_record *dev_extent_rec;
9448 u64 devid;
9449 u64 offset;
9450 u64 length;
9451 int metadump_v2 = 0;
9452 int i;
9453 int ret = 0;
9454
9455 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9456 chunk_rec->offset,
9457 chunk_rec->length);
9458 if (block_group_item) {
9459 block_group_rec = container_of(block_group_item,
9460 struct block_group_record,
9461 cache);
9462 if (chunk_rec->length != block_group_rec->offset ||
9463 chunk_rec->offset != block_group_rec->objectid ||
9464 (!metadump_v2 &&
9465 chunk_rec->type_flags != block_group_rec->flags)) {
9466 if (!silent)
9467 fprintf(stderr,
9468 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9469 chunk_rec->objectid,
9470 chunk_rec->type,
9471 chunk_rec->offset,
9472 chunk_rec->length,
9473 chunk_rec->offset,
9474 chunk_rec->type_flags,
9475 block_group_rec->objectid,
9476 block_group_rec->type,
9477 block_group_rec->offset,
9478 block_group_rec->offset,
9479 block_group_rec->objectid,
9480 block_group_rec->flags);
9481 ret = -1;
9482 } else {
9483 list_del_init(&block_group_rec->list);
9484 chunk_rec->bg_rec = block_group_rec;
9485 }
9486 } else {
9487 if (!silent)
9488 fprintf(stderr,
9489 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9490 chunk_rec->objectid,
9491 chunk_rec->type,
9492 chunk_rec->offset,
9493 chunk_rec->length,
9494 chunk_rec->offset,
9495 chunk_rec->type_flags);
9496 ret = 1;
9497 }
9498
9499 if (metadump_v2)
9500 return ret;
9501
9502 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9503 chunk_rec->num_stripes);
9504 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9505 devid = chunk_rec->stripes[i].devid;
9506 offset = chunk_rec->stripes[i].offset;
9507 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9508 devid, offset, length);
9509 if (dev_extent_item) {
9510 dev_extent_rec = container_of(dev_extent_item,
9511 struct device_extent_record,
9512 cache);
9513 if (dev_extent_rec->objectid != devid ||
9514 dev_extent_rec->offset != offset ||
9515 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9516 dev_extent_rec->length != length) {
9517 if (!silent)
9518 fprintf(stderr,
9519 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9520 chunk_rec->objectid,
9521 chunk_rec->type,
9522 chunk_rec->offset,
9523 chunk_rec->stripes[i].devid,
9524 chunk_rec->stripes[i].offset,
9525 dev_extent_rec->objectid,
9526 dev_extent_rec->offset,
9527 dev_extent_rec->length);
9528 ret = -1;
9529 } else {
9530 list_move(&dev_extent_rec->chunk_list,
9531 &chunk_rec->dextents);
9532 }
9533 } else {
9534 if (!silent)
9535 fprintf(stderr,
9536 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9537 chunk_rec->objectid,
9538 chunk_rec->type,
9539 chunk_rec->offset,
9540 chunk_rec->stripes[i].devid,
9541 chunk_rec->stripes[i].offset);
9542 ret = -1;
9543 }
9544 }
9545 return ret;
9546 }
9547
9548 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9549 int check_chunks(struct cache_tree *chunk_cache,
9550 struct block_group_tree *block_group_cache,
9551 struct device_extent_tree *dev_extent_cache,
9552 struct list_head *good, struct list_head *bad,
9553 struct list_head *rebuild, int silent)
9554 {
9555 struct cache_extent *chunk_item;
9556 struct chunk_record *chunk_rec;
9557 struct block_group_record *bg_rec;
9558 struct device_extent_record *dext_rec;
9559 int err;
9560 int ret = 0;
9561
9562 chunk_item = first_cache_extent(chunk_cache);
9563 while (chunk_item) {
9564 chunk_rec = container_of(chunk_item, struct chunk_record,
9565 cache);
9566 err = check_chunk_refs(chunk_rec, block_group_cache,
9567 dev_extent_cache, silent);
9568 if (err < 0)
9569 ret = err;
9570 if (err == 0 && good)
9571 list_add_tail(&chunk_rec->list, good);
9572 if (err > 0 && rebuild)
9573 list_add_tail(&chunk_rec->list, rebuild);
9574 if (err < 0 && bad)
9575 list_add_tail(&chunk_rec->list, bad);
9576 chunk_item = next_cache_extent(chunk_item);
9577 }
9578
9579 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9580 if (!silent)
9581 fprintf(stderr,
9582 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9583 bg_rec->objectid,
9584 bg_rec->offset,
9585 bg_rec->flags);
9586 if (!ret)
9587 ret = 1;
9588 }
9589
9590 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9591 chunk_list) {
9592 if (!silent)
9593 fprintf(stderr,
9594 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9595 dext_rec->objectid,
9596 dext_rec->offset,
9597 dext_rec->length);
9598 if (!ret)
9599 ret = 1;
9600 }
9601 return ret;
9602 }
9603
9604
9605 static int check_device_used(struct device_record *dev_rec,
9606 struct device_extent_tree *dext_cache)
9607 {
9608 struct cache_extent *cache;
9609 struct device_extent_record *dev_extent_rec;
9610 u64 total_byte = 0;
9611
9612 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9613 while (cache) {
9614 dev_extent_rec = container_of(cache,
9615 struct device_extent_record,
9616 cache);
9617 if (dev_extent_rec->objectid != dev_rec->devid)
9618 break;
9619
9620 list_del_init(&dev_extent_rec->device_list);
9621 total_byte += dev_extent_rec->length;
9622 cache = next_cache_extent(cache);
9623 }
9624
9625 if (total_byte != dev_rec->byte_used) {
9626 fprintf(stderr,
9627 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9628 total_byte, dev_rec->byte_used, dev_rec->objectid,
9629 dev_rec->type, dev_rec->offset);
9630 return -1;
9631 } else {
9632 return 0;
9633 }
9634 }
9635
9636 /* check btrfs_dev_item -> btrfs_dev_extent */
9637 static int check_devices(struct rb_root *dev_cache,
9638 struct device_extent_tree *dev_extent_cache)
9639 {
9640 struct rb_node *dev_node;
9641 struct device_record *dev_rec;
9642 struct device_extent_record *dext_rec;
9643 int err;
9644 int ret = 0;
9645
9646 dev_node = rb_first(dev_cache);
9647 while (dev_node) {
9648 dev_rec = container_of(dev_node, struct device_record, node);
9649 err = check_device_used(dev_rec, dev_extent_cache);
9650 if (err)
9651 ret = err;
9652
9653 dev_node = rb_next(dev_node);
9654 }
9655 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9656 device_list) {
9657 fprintf(stderr,
9658 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9659 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9660 if (!ret)
9661 ret = 1;
9662 }
9663 return ret;
9664 }
9665
9666 static int add_root_item_to_list(struct list_head *head,
9667 u64 objectid, u64 bytenr, u64 last_snapshot,
9668 u8 level, u8 drop_level,
9669 int level_size, struct btrfs_key *drop_key)
9670 {
9671
9672 struct root_item_record *ri_rec;
9673 ri_rec = malloc(sizeof(*ri_rec));
9674 if (!ri_rec)
9675 return -ENOMEM;
9676 ri_rec->bytenr = bytenr;
9677 ri_rec->objectid = objectid;
9678 ri_rec->level = level;
9679 ri_rec->level_size = level_size;
9680 ri_rec->drop_level = drop_level;
9681 ri_rec->last_snapshot = last_snapshot;
9682 if (drop_key)
9683 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9684 list_add_tail(&ri_rec->list, head);
9685
9686 return 0;
9687 }
9688
9689 static void free_root_item_list(struct list_head *list)
9690 {
9691 struct root_item_record *ri_rec;
9692
9693 while (!list_empty(list)) {
9694 ri_rec = list_first_entry(list, struct root_item_record,
9695 list);
9696 list_del_init(&ri_rec->list);
9697 free(ri_rec);
9698 }
9699 }
9700
9701 static int deal_root_from_list(struct list_head *list,
9702 struct btrfs_root *root,
9703 struct block_info *bits,
9704 int bits_nr,
9705 struct cache_tree *pending,
9706 struct cache_tree *seen,
9707 struct cache_tree *reada,
9708 struct cache_tree *nodes,
9709 struct cache_tree *extent_cache,
9710 struct cache_tree *chunk_cache,
9711 struct rb_root *dev_cache,
9712 struct block_group_tree *block_group_cache,
9713 struct device_extent_tree *dev_extent_cache)
9714 {
9715 int ret = 0;
9716 u64 last;
9717
9718 while (!list_empty(list)) {
9719 struct root_item_record *rec;
9720 struct extent_buffer *buf;
9721 rec = list_entry(list->next,
9722 struct root_item_record, list);
9723 last = 0;
9724 buf = read_tree_block(root->fs_info->tree_root,
9725 rec->bytenr, rec->level_size, 0);
9726 if (!extent_buffer_uptodate(buf)) {
9727 free_extent_buffer(buf);
9728 ret = -EIO;
9729 break;
9730 }
9731 ret = add_root_to_pending(buf, extent_cache, pending,
9732 seen, nodes, rec->objectid);
9733 if (ret < 0)
9734 break;
9735 /*
9736 * To rebuild extent tree, we need deal with snapshot
9737 * one by one, otherwise we deal with node firstly which
9738 * can maximize readahead.
9739 */
9740 while (1) {
9741 ret = run_next_block(root, bits, bits_nr, &last,
9742 pending, seen, reada, nodes,
9743 extent_cache, chunk_cache,
9744 dev_cache, block_group_cache,
9745 dev_extent_cache, rec);
9746 if (ret != 0)
9747 break;
9748 }
9749 free_extent_buffer(buf);
9750 list_del(&rec->list);
9751 free(rec);
9752 if (ret < 0)
9753 break;
9754 }
9755 while (ret >= 0) {
9756 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9757 reada, nodes, extent_cache, chunk_cache,
9758 dev_cache, block_group_cache,
9759 dev_extent_cache, NULL);
9760 if (ret != 0) {
9761 if (ret > 0)
9762 ret = 0;
9763 break;
9764 }
9765 }
9766 return ret;
9767 }
9768
9769 static int check_chunks_and_extents(struct btrfs_root *root)
9770 {
9771 struct rb_root dev_cache;
9772 struct cache_tree chunk_cache;
9773 struct block_group_tree block_group_cache;
9774 struct device_extent_tree dev_extent_cache;
9775 struct cache_tree extent_cache;
9776 struct cache_tree seen;
9777 struct cache_tree pending;
9778 struct cache_tree reada;
9779 struct cache_tree nodes;
9780 struct extent_io_tree excluded_extents;
9781 struct cache_tree corrupt_blocks;
9782 struct btrfs_path path;
9783 struct btrfs_key key;
9784 struct btrfs_key found_key;
9785 int ret, err = 0;
9786 struct block_info *bits;
9787 int bits_nr;
9788 struct extent_buffer *leaf;
9789 int slot;
9790 struct btrfs_root_item ri;
9791 struct list_head dropping_trees;
9792 struct list_head normal_trees;
9793 struct btrfs_root *root1;
9794 u64 objectid;
9795 u32 level_size;
9796 u8 level;
9797
9798 dev_cache = RB_ROOT;
9799 cache_tree_init(&chunk_cache);
9800 block_group_tree_init(&block_group_cache);
9801 device_extent_tree_init(&dev_extent_cache);
9802
9803 cache_tree_init(&extent_cache);
9804 cache_tree_init(&seen);
9805 cache_tree_init(&pending);
9806 cache_tree_init(&nodes);
9807 cache_tree_init(&reada);
9808 cache_tree_init(&corrupt_blocks);
9809 extent_io_tree_init(&excluded_extents);
9810 INIT_LIST_HEAD(&dropping_trees);
9811 INIT_LIST_HEAD(&normal_trees);
9812
9813 if (repair) {
9814 root->fs_info->excluded_extents = &excluded_extents;
9815 root->fs_info->fsck_extent_cache = &extent_cache;
9816 root->fs_info->free_extent_hook = free_extent_hook;
9817 root->fs_info->corrupt_blocks = &corrupt_blocks;
9818 }
9819
9820 bits_nr = 1024;
9821 bits = malloc(bits_nr * sizeof(struct block_info));
9822 if (!bits) {
9823 perror("malloc");
9824 exit(1);
9825 }
9826
9827 if (ctx.progress_enabled) {
9828 ctx.tp = TASK_EXTENTS;
9829 task_start(ctx.info);
9830 }
9831
9832 again:
9833 root1 = root->fs_info->tree_root;
9834 level = btrfs_header_level(root1->node);
9835 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9836 root1->node->start, 0, level, 0,
9837 root1->nodesize, NULL);
9838 if (ret < 0)
9839 goto out;
9840 root1 = root->fs_info->chunk_root;
9841 level = btrfs_header_level(root1->node);
9842 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9843 root1->node->start, 0, level, 0,
9844 root1->nodesize, NULL);
9845 if (ret < 0)
9846 goto out;
9847 btrfs_init_path(&path);
9848 key.offset = 0;
9849 key.objectid = 0;
9850 key.type = BTRFS_ROOT_ITEM_KEY;
9851 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9852 &key, &path, 0, 0);
9853 if (ret < 0)
9854 goto out;
9855 while(1) {
9856 leaf = path.nodes[0];
9857 slot = path.slots[0];
9858 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9859 ret = btrfs_next_leaf(root, &path);
9860 if (ret != 0)
9861 break;
9862 leaf = path.nodes[0];
9863 slot = path.slots[0];
9864 }
9865 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9866 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9867 unsigned long offset;
9868 u64 last_snapshot;
9869
9870 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9871 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9872 last_snapshot = btrfs_root_last_snapshot(&ri);
9873 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9874 level = btrfs_root_level(&ri);
9875 level_size = root->nodesize;
9876 ret = add_root_item_to_list(&normal_trees,
9877 found_key.objectid,
9878 btrfs_root_bytenr(&ri),
9879 last_snapshot, level,
9880 0, level_size, NULL);
9881 if (ret < 0)
9882 goto out;
9883 } else {
9884 level = btrfs_root_level(&ri);
9885 level_size = root->nodesize;
9886 objectid = found_key.objectid;
9887 btrfs_disk_key_to_cpu(&found_key,
9888 &ri.drop_progress);
9889 ret = add_root_item_to_list(&dropping_trees,
9890 objectid,
9891 btrfs_root_bytenr(&ri),
9892 last_snapshot, level,
9893 ri.drop_level,
9894 level_size, &found_key);
9895 if (ret < 0)
9896 goto out;
9897 }
9898 }
9899 path.slots[0]++;
9900 }
9901 btrfs_release_path(&path);
9902
9903 /*
9904 * check_block can return -EAGAIN if it fixes something, please keep
9905 * this in mind when dealing with return values from these functions, if
9906 * we get -EAGAIN we want to fall through and restart the loop.
9907 */
9908 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9909 &seen, &reada, &nodes, &extent_cache,
9910 &chunk_cache, &dev_cache, &block_group_cache,
9911 &dev_extent_cache);
9912 if (ret < 0) {
9913 if (ret == -EAGAIN)
9914 goto loop;
9915 goto out;
9916 }
9917 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9918 &pending, &seen, &reada, &nodes,
9919 &extent_cache, &chunk_cache, &dev_cache,
9920 &block_group_cache, &dev_extent_cache);
9921 if (ret < 0) {
9922 if (ret == -EAGAIN)
9923 goto loop;
9924 goto out;
9925 }
9926
9927 ret = check_chunks(&chunk_cache, &block_group_cache,
9928 &dev_extent_cache, NULL, NULL, NULL, 0);
9929 if (ret) {
9930 if (ret == -EAGAIN)
9931 goto loop;
9932 err = ret;
9933 }
9934
9935 ret = check_extent_refs(root, &extent_cache);
9936 if (ret < 0) {
9937 if (ret == -EAGAIN)
9938 goto loop;
9939 goto out;
9940 }
9941
9942 ret = check_devices(&dev_cache, &dev_extent_cache);
9943 if (ret && err)
9944 ret = err;
9945
9946 out:
9947 task_stop(ctx.info);
9948 if (repair) {
9949 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9950 extent_io_tree_cleanup(&excluded_extents);
9951 root->fs_info->fsck_extent_cache = NULL;
9952 root->fs_info->free_extent_hook = NULL;
9953 root->fs_info->corrupt_blocks = NULL;
9954 root->fs_info->excluded_extents = NULL;
9955 }
9956 free(bits);
9957 free_chunk_cache_tree(&chunk_cache);
9958 free_device_cache_tree(&dev_cache);
9959 free_block_group_tree(&block_group_cache);
9960 free_device_extent_tree(&dev_extent_cache);
9961 free_extent_cache_tree(&seen);
9962 free_extent_cache_tree(&pending);
9963 free_extent_cache_tree(&reada);
9964 free_extent_cache_tree(&nodes);
9965 return ret;
9966 loop:
9967 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9968 free_extent_cache_tree(&seen);
9969 free_extent_cache_tree(&pending);
9970 free_extent_cache_tree(&reada);
9971 free_extent_cache_tree(&nodes);
9972 free_chunk_cache_tree(&chunk_cache);
9973 free_block_group_tree(&block_group_cache);
9974 free_device_cache_tree(&dev_cache);
9975 free_device_extent_tree(&dev_extent_cache);
9976 free_extent_record_cache(&extent_cache);
9977 free_root_item_list(&normal_trees);
9978 free_root_item_list(&dropping_trees);
9979 extent_io_tree_cleanup(&excluded_extents);
9980 goto again;
9981 }
9982
9983 /*
9984 * Check backrefs of a tree block given by @bytenr or @eb.
9985 *
9986 * @root: the root containing the @bytenr or @eb
9987 * @eb: tree block extent buffer, can be NULL
9988 * @bytenr: bytenr of the tree block to search
9989 * @level: tree level of the tree block
9990 * @owner: owner of the tree block
9991 *
9992 * Return >0 for any error found and output error message
9993 * Return 0 for no error found
9994 */
9995 static int check_tree_block_ref(struct btrfs_root *root,
9996 struct extent_buffer *eb, u64 bytenr,
9997 int level, u64 owner)
9998 {
9999 struct btrfs_key key;
10000 struct btrfs_root *extent_root = root->fs_info->extent_root;
10001 struct btrfs_path path;
10002 struct btrfs_extent_item *ei;
10003 struct btrfs_extent_inline_ref *iref;
10004 struct extent_buffer *leaf;
10005 unsigned long end;
10006 unsigned long ptr;
10007 int slot;
10008 int skinny_level;
10009 int type;
10010 u32 nodesize = root->nodesize;
10011 u32 item_size;
10012 u64 offset;
10013 int tree_reloc_root = 0;
10014 int found_ref = 0;
10015 int err = 0;
10016 int ret;
10017
10018 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
10019 btrfs_header_bytenr(root->node) == bytenr)
10020 tree_reloc_root = 1;
10021
10022 btrfs_init_path(&path);
10023 key.objectid = bytenr;
10024 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
10025 key.type = BTRFS_METADATA_ITEM_KEY;
10026 else
10027 key.type = BTRFS_EXTENT_ITEM_KEY;
10028 key.offset = (u64)-1;
10029
10030 /* Search for the backref in extent tree */
10031 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10032 if (ret < 0) {
10033 err |= BACKREF_MISSING;
10034 goto out;
10035 }
10036 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10037 if (ret) {
10038 err |= BACKREF_MISSING;
10039 goto out;
10040 }
10041
10042 leaf = path.nodes[0];
10043 slot = path.slots[0];
10044 btrfs_item_key_to_cpu(leaf, &key, slot);
10045
10046 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10047
10048 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10049 skinny_level = (int)key.offset;
10050 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10051 } else {
10052 struct btrfs_tree_block_info *info;
10053
10054 info = (struct btrfs_tree_block_info *)(ei + 1);
10055 skinny_level = btrfs_tree_block_level(leaf, info);
10056 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10057 }
10058
10059 if (eb) {
10060 u64 header_gen;
10061 u64 extent_gen;
10062
10063 if (!(btrfs_extent_flags(leaf, ei) &
10064 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10065 error(
10066 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10067 key.objectid, nodesize,
10068 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10069 err = BACKREF_MISMATCH;
10070 }
10071 header_gen = btrfs_header_generation(eb);
10072 extent_gen = btrfs_extent_generation(leaf, ei);
10073 if (header_gen != extent_gen) {
10074 error(
10075 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10076 key.objectid, nodesize, header_gen,
10077 extent_gen);
10078 err = BACKREF_MISMATCH;
10079 }
10080 if (level != skinny_level) {
10081 error(
10082 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10083 key.objectid, nodesize, level, skinny_level);
10084 err = BACKREF_MISMATCH;
10085 }
10086 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10087 error(
10088 "extent[%llu %u] is referred by other roots than %llu",
10089 key.objectid, nodesize, root->objectid);
10090 err = BACKREF_MISMATCH;
10091 }
10092 }
10093
10094 /*
10095 * Iterate the extent/metadata item to find the exact backref
10096 */
10097 item_size = btrfs_item_size_nr(leaf, slot);
10098 ptr = (unsigned long)iref;
10099 end = (unsigned long)ei + item_size;
10100 while (ptr < end) {
10101 iref = (struct btrfs_extent_inline_ref *)ptr;
10102 type = btrfs_extent_inline_ref_type(leaf, iref);
10103 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10104
10105 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10106 (offset == root->objectid || offset == owner)) {
10107 found_ref = 1;
10108 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10109 /*
10110 * Backref of tree reloc root points to itself, no need
10111 * to check backref any more.
10112 */
10113 if (tree_reloc_root)
10114 found_ref = 1;
10115 else
10116 /* Check if the backref points to valid referencer */
10117 found_ref = !check_tree_block_ref(root, NULL,
10118 offset, level + 1, owner);
10119 }
10120
10121 if (found_ref)
10122 break;
10123 ptr += btrfs_extent_inline_ref_size(type);
10124 }
10125
10126 /*
10127 * Inlined extent item doesn't have what we need, check
10128 * TREE_BLOCK_REF_KEY
10129 */
10130 if (!found_ref) {
10131 btrfs_release_path(&path);
10132 key.objectid = bytenr;
10133 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10134 key.offset = root->objectid;
10135
10136 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10137 if (!ret)
10138 found_ref = 1;
10139 }
10140 if (!found_ref)
10141 err |= BACKREF_MISSING;
10142 out:
10143 btrfs_release_path(&path);
10144 if (eb && (err & BACKREF_MISSING))
10145 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10146 bytenr, nodesize, owner, level);
10147 return err;
10148 }
10149
10150 /*
10151 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10152 *
10153 * Return >0 any error found and output error message
10154 * Return 0 for no error found
10155 */
10156 static int check_extent_data_item(struct btrfs_root *root,
10157 struct extent_buffer *eb, int slot)
10158 {
10159 struct btrfs_file_extent_item *fi;
10160 struct btrfs_path path;
10161 struct btrfs_root *extent_root = root->fs_info->extent_root;
10162 struct btrfs_key fi_key;
10163 struct btrfs_key dbref_key;
10164 struct extent_buffer *leaf;
10165 struct btrfs_extent_item *ei;
10166 struct btrfs_extent_inline_ref *iref;
10167 struct btrfs_extent_data_ref *dref;
10168 u64 owner;
10169 u64 disk_bytenr;
10170 u64 disk_num_bytes;
10171 u64 extent_num_bytes;
10172 u64 extent_flags;
10173 u32 item_size;
10174 unsigned long end;
10175 unsigned long ptr;
10176 int type;
10177 u64 ref_root;
10178 int found_dbackref = 0;
10179 int err = 0;
10180 int ret;
10181
10182 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10183 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10184
10185 /* Nothing to check for hole and inline data extents */
10186 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10187 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10188 return 0;
10189
10190 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10191 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10192 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10193
10194 /* Check unaligned disk_num_bytes and num_bytes */
10195 if (!IS_ALIGNED(disk_num_bytes, root->sectorsize)) {
10196 error(
10197 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10198 fi_key.objectid, fi_key.offset, disk_num_bytes,
10199 root->sectorsize);
10200 err |= BYTES_UNALIGNED;
10201 } else {
10202 data_bytes_allocated += disk_num_bytes;
10203 }
10204 if (!IS_ALIGNED(extent_num_bytes, root->sectorsize)) {
10205 error(
10206 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10207 fi_key.objectid, fi_key.offset, extent_num_bytes,
10208 root->sectorsize);
10209 err |= BYTES_UNALIGNED;
10210 } else {
10211 data_bytes_referenced += extent_num_bytes;
10212 }
10213 owner = btrfs_header_owner(eb);
10214
10215 /* Check the extent item of the file extent in extent tree */
10216 btrfs_init_path(&path);
10217 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10218 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10219 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10220
10221 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10222 if (ret) {
10223 err |= BACKREF_MISSING;
10224 goto error;
10225 }
10226
10227 leaf = path.nodes[0];
10228 slot = path.slots[0];
10229 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10230
10231 extent_flags = btrfs_extent_flags(leaf, ei);
10232
10233 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10234 error(
10235 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10236 disk_bytenr, disk_num_bytes,
10237 BTRFS_EXTENT_FLAG_DATA);
10238 err |= BACKREF_MISMATCH;
10239 }
10240
10241 /* Check data backref inside that extent item */
10242 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10243 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10244 ptr = (unsigned long)iref;
10245 end = (unsigned long)ei + item_size;
10246 while (ptr < end) {
10247 iref = (struct btrfs_extent_inline_ref *)ptr;
10248 type = btrfs_extent_inline_ref_type(leaf, iref);
10249 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10250
10251 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10252 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10253 if (ref_root == owner || ref_root == root->objectid)
10254 found_dbackref = 1;
10255 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10256 found_dbackref = !check_tree_block_ref(root, NULL,
10257 btrfs_extent_inline_ref_offset(leaf, iref),
10258 0, owner);
10259 }
10260
10261 if (found_dbackref)
10262 break;
10263 ptr += btrfs_extent_inline_ref_size(type);
10264 }
10265
10266 /* Didn't found inlined data backref, try EXTENT_DATA_REF_KEY */
10267 if (!found_dbackref) {
10268 btrfs_release_path(&path);
10269
10270 btrfs_init_path(&path);
10271 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10272 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10273 dbref_key.offset = hash_extent_data_ref(root->objectid,
10274 fi_key.objectid, fi_key.offset);
10275
10276 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10277 &dbref_key, &path, 0, 0);
10278 if (!ret)
10279 found_dbackref = 1;
10280 }
10281
10282 if (!found_dbackref)
10283 err |= BACKREF_MISSING;
10284 error:
10285 btrfs_release_path(&path);
10286 if (err & BACKREF_MISSING) {
10287 error("data extent[%llu %llu] backref lost",
10288 disk_bytenr, disk_num_bytes);
10289 }
10290 return err;
10291 }
10292
10293 /*
10294 * Get real tree block level for the case like shared block
10295 * Return >= 0 as tree level
10296 * Return <0 for error
10297 */
10298 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10299 {
10300 struct extent_buffer *eb;
10301 struct btrfs_path path;
10302 struct btrfs_key key;
10303 struct btrfs_extent_item *ei;
10304 u64 flags;
10305 u64 transid;
10306 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10307 u8 backref_level;
10308 u8 header_level;
10309 int ret;
10310
10311 /* Search extent tree for extent generation and level */
10312 key.objectid = bytenr;
10313 key.type = BTRFS_METADATA_ITEM_KEY;
10314 key.offset = (u64)-1;
10315
10316 btrfs_init_path(&path);
10317 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10318 if (ret < 0)
10319 goto release_out;
10320 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10321 if (ret < 0)
10322 goto release_out;
10323 if (ret > 0) {
10324 ret = -ENOENT;
10325 goto release_out;
10326 }
10327
10328 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10329 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10330 struct btrfs_extent_item);
10331 flags = btrfs_extent_flags(path.nodes[0], ei);
10332 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10333 ret = -ENOENT;
10334 goto release_out;
10335 }
10336
10337 /* Get transid for later read_tree_block() check */
10338 transid = btrfs_extent_generation(path.nodes[0], ei);
10339
10340 /* Get backref level as one source */
10341 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10342 backref_level = key.offset;
10343 } else {
10344 struct btrfs_tree_block_info *info;
10345
10346 info = (struct btrfs_tree_block_info *)(ei + 1);
10347 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10348 }
10349 btrfs_release_path(&path);
10350
10351 /* Get level from tree block as an alternative source */
10352 eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
10353 if (!extent_buffer_uptodate(eb)) {
10354 free_extent_buffer(eb);
10355 return -EIO;
10356 }
10357 header_level = btrfs_header_level(eb);
10358 free_extent_buffer(eb);
10359
10360 if (header_level != backref_level)
10361 return -EIO;
10362 return header_level;
10363
10364 release_out:
10365 btrfs_release_path(&path);
10366 return ret;
10367 }
10368
10369 /*
10370 * Check if a tree block backref is valid (points to a valid tree block)
10371 * if level == -1, level will be resolved
10372 * Return >0 for any error found and print error message
10373 */
10374 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10375 u64 bytenr, int level)
10376 {
10377 struct btrfs_root *root;
10378 struct btrfs_key key;
10379 struct btrfs_path path;
10380 struct extent_buffer *eb;
10381 struct extent_buffer *node;
10382 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10383 int err = 0;
10384 int ret;
10385
10386 /* Query level for level == -1 special case */
10387 if (level == -1)
10388 level = query_tree_block_level(fs_info, bytenr);
10389 if (level < 0) {
10390 err |= REFERENCER_MISSING;
10391 goto out;
10392 }
10393
10394 key.objectid = root_id;
10395 key.type = BTRFS_ROOT_ITEM_KEY;
10396 key.offset = (u64)-1;
10397
10398 root = btrfs_read_fs_root(fs_info, &key);
10399 if (IS_ERR(root)) {
10400 err |= REFERENCER_MISSING;
10401 goto out;
10402 }
10403
10404 /* Read out the tree block to get item/node key */
10405 eb = read_tree_block(root, bytenr, root->nodesize, 0);
10406 if (!extent_buffer_uptodate(eb)) {
10407 err |= REFERENCER_MISSING;
10408 free_extent_buffer(eb);
10409 goto out;
10410 }
10411
10412 /* Empty tree, no need to check key */
10413 if (!btrfs_header_nritems(eb) && !level) {
10414 free_extent_buffer(eb);
10415 goto out;
10416 }
10417
10418 if (level)
10419 btrfs_node_key_to_cpu(eb, &key, 0);
10420 else
10421 btrfs_item_key_to_cpu(eb, &key, 0);
10422
10423 free_extent_buffer(eb);
10424
10425 btrfs_init_path(&path);
10426 path.lowest_level = level;
10427 /* Search with the first key, to ensure we can reach it */
10428 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10429 if (ret < 0) {
10430 err |= REFERENCER_MISSING;
10431 goto release_out;
10432 }
10433
10434 node = path.nodes[level];
10435 if (btrfs_header_bytenr(node) != bytenr) {
10436 error(
10437 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10438 bytenr, nodesize, bytenr,
10439 btrfs_header_bytenr(node));
10440 err |= REFERENCER_MISMATCH;
10441 }
10442 if (btrfs_header_level(node) != level) {
10443 error(
10444 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10445 bytenr, nodesize, level,
10446 btrfs_header_level(node));
10447 err |= REFERENCER_MISMATCH;
10448 }
10449
10450 release_out:
10451 btrfs_release_path(&path);
10452 out:
10453 if (err & REFERENCER_MISSING) {
10454 if (level < 0)
10455 error("extent [%llu %d] lost referencer (owner: %llu)",
10456 bytenr, nodesize, root_id);
10457 else
10458 error(
10459 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10460 bytenr, nodesize, root_id, level);
10461 }
10462
10463 return err;
10464 }
10465
10466 /*
10467 * Check if tree block @eb is tree reloc root.
10468 * Return 0 if it's not or any problem happens
10469 * Return 1 if it's a tree reloc root
10470 */
10471 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
10472 struct extent_buffer *eb)
10473 {
10474 struct btrfs_root *tree_reloc_root;
10475 struct btrfs_key key;
10476 u64 bytenr = btrfs_header_bytenr(eb);
10477 u64 owner = btrfs_header_owner(eb);
10478 int ret = 0;
10479
10480 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
10481 key.offset = owner;
10482 key.type = BTRFS_ROOT_ITEM_KEY;
10483
10484 tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
10485 if (IS_ERR(tree_reloc_root))
10486 return 0;
10487
10488 if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
10489 ret = 1;
10490 btrfs_free_fs_root(tree_reloc_root);
10491 return ret;
10492 }
10493
10494 /*
10495 * Check referencer for shared block backref
10496 * If level == -1, this function will resolve the level.
10497 */
10498 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10499 u64 parent, u64 bytenr, int level)
10500 {
10501 struct extent_buffer *eb;
10502 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10503 u32 nr;
10504 int found_parent = 0;
10505 int i;
10506
10507 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10508 if (!extent_buffer_uptodate(eb))
10509 goto out;
10510
10511 if (level == -1)
10512 level = query_tree_block_level(fs_info, bytenr);
10513 if (level < 0)
10514 goto out;
10515
10516 /* It's possible it's a tree reloc root */
10517 if (parent == bytenr) {
10518 if (is_tree_reloc_root(fs_info, eb))
10519 found_parent = 1;
10520 goto out;
10521 }
10522
10523 if (level + 1 != btrfs_header_level(eb))
10524 goto out;
10525
10526 nr = btrfs_header_nritems(eb);
10527 for (i = 0; i < nr; i++) {
10528 if (bytenr == btrfs_node_blockptr(eb, i)) {
10529 found_parent = 1;
10530 break;
10531 }
10532 }
10533 out:
10534 free_extent_buffer(eb);
10535 if (!found_parent) {
10536 error(
10537 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10538 bytenr, nodesize, parent, level);
10539 return REFERENCER_MISSING;
10540 }
10541 return 0;
10542 }
10543
10544 /*
10545 * Check referencer for normal (inlined) data ref
10546 * If len == 0, it will be resolved by searching in extent tree
10547 */
10548 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10549 u64 root_id, u64 objectid, u64 offset,
10550 u64 bytenr, u64 len, u32 count)
10551 {
10552 struct btrfs_root *root;
10553 struct btrfs_root *extent_root = fs_info->extent_root;
10554 struct btrfs_key key;
10555 struct btrfs_path path;
10556 struct extent_buffer *leaf;
10557 struct btrfs_file_extent_item *fi;
10558 u32 found_count = 0;
10559 int slot;
10560 int ret = 0;
10561
10562 if (!len) {
10563 key.objectid = bytenr;
10564 key.type = BTRFS_EXTENT_ITEM_KEY;
10565 key.offset = (u64)-1;
10566
10567 btrfs_init_path(&path);
10568 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10569 if (ret < 0)
10570 goto out;
10571 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10572 if (ret)
10573 goto out;
10574 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10575 if (key.objectid != bytenr ||
10576 key.type != BTRFS_EXTENT_ITEM_KEY)
10577 goto out;
10578 len = key.offset;
10579 btrfs_release_path(&path);
10580 }
10581 key.objectid = root_id;
10582 key.type = BTRFS_ROOT_ITEM_KEY;
10583 key.offset = (u64)-1;
10584 btrfs_init_path(&path);
10585
10586 root = btrfs_read_fs_root(fs_info, &key);
10587 if (IS_ERR(root))
10588 goto out;
10589
10590 key.objectid = objectid;
10591 key.type = BTRFS_EXTENT_DATA_KEY;
10592 /*
10593 * It can be nasty as data backref offset is
10594 * file offset - file extent offset, which is smaller or
10595 * equal to original backref offset. The only special case is
10596 * overflow. So we need to special check and do further search.
10597 */
10598 key.offset = offset & (1ULL << 63) ? 0 : offset;
10599
10600 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10601 if (ret < 0)
10602 goto out;
10603
10604 /*
10605 * Search afterwards to get correct one
10606 * NOTE: As we must do a comprehensive check on the data backref to
10607 * make sure the dref count also matches, we must iterate all file
10608 * extents for that inode.
10609 */
10610 while (1) {
10611 leaf = path.nodes[0];
10612 slot = path.slots[0];
10613
10614 if (slot >= btrfs_header_nritems(leaf))
10615 goto next;
10616 btrfs_item_key_to_cpu(leaf, &key, slot);
10617 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10618 break;
10619 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10620 /*
10621 * Except normal disk bytenr and disk num bytes, we still
10622 * need to do extra check on dbackref offset as
10623 * dbackref offset = file_offset - file_extent_offset
10624 */
10625 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10626 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10627 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10628 offset)
10629 found_count++;
10630
10631 next:
10632 ret = btrfs_next_item(root, &path);
10633 if (ret)
10634 break;
10635 }
10636 out:
10637 btrfs_release_path(&path);
10638 if (found_count != count) {
10639 error(
10640 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10641 bytenr, len, root_id, objectid, offset, count, found_count);
10642 return REFERENCER_MISSING;
10643 }
10644 return 0;
10645 }
10646
10647 /*
10648 * Check if the referencer of a shared data backref exists
10649 */
10650 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10651 u64 parent, u64 bytenr)
10652 {
10653 struct extent_buffer *eb;
10654 struct btrfs_key key;
10655 struct btrfs_file_extent_item *fi;
10656 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10657 u32 nr;
10658 int found_parent = 0;
10659 int i;
10660
10661 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10662 if (!extent_buffer_uptodate(eb))
10663 goto out;
10664
10665 nr = btrfs_header_nritems(eb);
10666 for (i = 0; i < nr; i++) {
10667 btrfs_item_key_to_cpu(eb, &key, i);
10668 if (key.type != BTRFS_EXTENT_DATA_KEY)
10669 continue;
10670
10671 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10672 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10673 continue;
10674
10675 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10676 found_parent = 1;
10677 break;
10678 }
10679 }
10680
10681 out:
10682 free_extent_buffer(eb);
10683 if (!found_parent) {
10684 error("shared extent %llu referencer lost (parent: %llu)",
10685 bytenr, parent);
10686 return REFERENCER_MISSING;
10687 }
10688 return 0;
10689 }
10690
10691 /*
10692 * This function will check a given extent item, including its backref and
10693 * itself (like crossing stripe boundary and type)
10694 *
10695 * Since we don't use extent_record anymore, introduce new error bit
10696 */
10697 static int check_extent_item(struct btrfs_fs_info *fs_info,
10698 struct extent_buffer *eb, int slot)
10699 {
10700 struct btrfs_extent_item *ei;
10701 struct btrfs_extent_inline_ref *iref;
10702 struct btrfs_extent_data_ref *dref;
10703 unsigned long end;
10704 unsigned long ptr;
10705 int type;
10706 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10707 u32 item_size = btrfs_item_size_nr(eb, slot);
10708 u64 flags;
10709 u64 offset;
10710 int metadata = 0;
10711 int level;
10712 struct btrfs_key key;
10713 int ret;
10714 int err = 0;
10715
10716 btrfs_item_key_to_cpu(eb, &key, slot);
10717 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10718 bytes_used += key.offset;
10719 else
10720 bytes_used += nodesize;
10721
10722 if (item_size < sizeof(*ei)) {
10723 /*
10724 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10725 * old thing when on disk format is still un-determined.
10726 * No need to care about it anymore
10727 */
10728 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10729 return -ENOTTY;
10730 }
10731
10732 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10733 flags = btrfs_extent_flags(eb, ei);
10734
10735 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10736 metadata = 1;
10737 if (metadata && check_crossing_stripes(global_info, key.objectid,
10738 eb->len)) {
10739 error("bad metadata [%llu, %llu) crossing stripe boundary",
10740 key.objectid, key.objectid + nodesize);
10741 err |= CROSSING_STRIPE_BOUNDARY;
10742 }
10743
10744 ptr = (unsigned long)(ei + 1);
10745
10746 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10747 /* Old EXTENT_ITEM metadata */
10748 struct btrfs_tree_block_info *info;
10749
10750 info = (struct btrfs_tree_block_info *)ptr;
10751 level = btrfs_tree_block_level(eb, info);
10752 ptr += sizeof(struct btrfs_tree_block_info);
10753 } else {
10754 /* New METADATA_ITEM */
10755 level = key.offset;
10756 }
10757 end = (unsigned long)ei + item_size;
10758
10759 next:
10760 /* Reached extent item end normally */
10761 if (ptr == end)
10762 goto out;
10763
10764 /* Beyond extent item end, wrong item size */
10765 if (ptr > end) {
10766 err |= ITEM_SIZE_MISMATCH;
10767 error("extent item at bytenr %llu slot %d has wrong size",
10768 eb->start, slot);
10769 goto out;
10770 }
10771
10772 /* Now check every backref in this extent item */
10773 iref = (struct btrfs_extent_inline_ref *)ptr;
10774 type = btrfs_extent_inline_ref_type(eb, iref);
10775 offset = btrfs_extent_inline_ref_offset(eb, iref);
10776 switch (type) {
10777 case BTRFS_TREE_BLOCK_REF_KEY:
10778 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10779 level);
10780 err |= ret;
10781 break;
10782 case BTRFS_SHARED_BLOCK_REF_KEY:
10783 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10784 level);
10785 err |= ret;
10786 break;
10787 case BTRFS_EXTENT_DATA_REF_KEY:
10788 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10789 ret = check_extent_data_backref(fs_info,
10790 btrfs_extent_data_ref_root(eb, dref),
10791 btrfs_extent_data_ref_objectid(eb, dref),
10792 btrfs_extent_data_ref_offset(eb, dref),
10793 key.objectid, key.offset,
10794 btrfs_extent_data_ref_count(eb, dref));
10795 err |= ret;
10796 break;
10797 case BTRFS_SHARED_DATA_REF_KEY:
10798 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10799 err |= ret;
10800 break;
10801 default:
10802 error("extent[%llu %d %llu] has unknown ref type: %d",
10803 key.objectid, key.type, key.offset, type);
10804 err |= UNKNOWN_TYPE;
10805 goto out;
10806 }
10807
10808 ptr += btrfs_extent_inline_ref_size(type);
10809 goto next;
10810
10811 out:
10812 return err;
10813 }
10814
10815 /*
10816 * Check if a dev extent item is referred correctly by its chunk
10817 */
10818 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10819 struct extent_buffer *eb, int slot)
10820 {
10821 struct btrfs_root *chunk_root = fs_info->chunk_root;
10822 struct btrfs_dev_extent *ptr;
10823 struct btrfs_path path;
10824 struct btrfs_key chunk_key;
10825 struct btrfs_key devext_key;
10826 struct btrfs_chunk *chunk;
10827 struct extent_buffer *l;
10828 int num_stripes;
10829 u64 length;
10830 int i;
10831 int found_chunk = 0;
10832 int ret;
10833
10834 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10835 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10836 length = btrfs_dev_extent_length(eb, ptr);
10837
10838 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10839 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10840 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10841
10842 btrfs_init_path(&path);
10843 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10844 if (ret)
10845 goto out;
10846
10847 l = path.nodes[0];
10848 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10849 if (btrfs_chunk_length(l, chunk) != length)
10850 goto out;
10851
10852 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10853 for (i = 0; i < num_stripes; i++) {
10854 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10855 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10856
10857 if (devid == devext_key.objectid &&
10858 offset == devext_key.offset) {
10859 found_chunk = 1;
10860 break;
10861 }
10862 }
10863 out:
10864 btrfs_release_path(&path);
10865 if (!found_chunk) {
10866 error(
10867 "device extent[%llu, %llu, %llu] did not find the related chunk",
10868 devext_key.objectid, devext_key.offset, length);
10869 return REFERENCER_MISSING;
10870 }
10871 return 0;
10872 }
10873
10874 /*
10875 * Check if the used space is correct with the dev item
10876 */
10877 static int check_dev_item(struct btrfs_fs_info *fs_info,
10878 struct extent_buffer *eb, int slot)
10879 {
10880 struct btrfs_root *dev_root = fs_info->dev_root;
10881 struct btrfs_dev_item *dev_item;
10882 struct btrfs_path path;
10883 struct btrfs_key key;
10884 struct btrfs_dev_extent *ptr;
10885 u64 dev_id;
10886 u64 used;
10887 u64 total = 0;
10888 int ret;
10889
10890 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10891 dev_id = btrfs_device_id(eb, dev_item);
10892 used = btrfs_device_bytes_used(eb, dev_item);
10893
10894 key.objectid = dev_id;
10895 key.type = BTRFS_DEV_EXTENT_KEY;
10896 key.offset = 0;
10897
10898 btrfs_init_path(&path);
10899 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
10900 if (ret < 0) {
10901 btrfs_item_key_to_cpu(eb, &key, slot);
10902 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
10903 key.objectid, key.type, key.offset);
10904 btrfs_release_path(&path);
10905 return REFERENCER_MISSING;
10906 }
10907
10908 /* Iterate dev_extents to calculate the used space of a device */
10909 while (1) {
10910 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
10911 goto next;
10912
10913 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10914 if (key.objectid > dev_id)
10915 break;
10916 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
10917 goto next;
10918
10919 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
10920 struct btrfs_dev_extent);
10921 total += btrfs_dev_extent_length(path.nodes[0], ptr);
10922 next:
10923 ret = btrfs_next_item(dev_root, &path);
10924 if (ret)
10925 break;
10926 }
10927 btrfs_release_path(&path);
10928
10929 if (used != total) {
10930 btrfs_item_key_to_cpu(eb, &key, slot);
10931 error(
10932 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
10933 total, used, BTRFS_ROOT_TREE_OBJECTID,
10934 BTRFS_DEV_EXTENT_KEY, dev_id);
10935 return ACCOUNTING_MISMATCH;
10936 }
10937 return 0;
10938 }
10939
10940 /*
10941 * Check a block group item with its referener (chunk) and its used space
10942 * with extent/metadata item
10943 */
10944 static int check_block_group_item(struct btrfs_fs_info *fs_info,
10945 struct extent_buffer *eb, int slot)
10946 {
10947 struct btrfs_root *extent_root = fs_info->extent_root;
10948 struct btrfs_root *chunk_root = fs_info->chunk_root;
10949 struct btrfs_block_group_item *bi;
10950 struct btrfs_block_group_item bg_item;
10951 struct btrfs_path path;
10952 struct btrfs_key bg_key;
10953 struct btrfs_key chunk_key;
10954 struct btrfs_key extent_key;
10955 struct btrfs_chunk *chunk;
10956 struct extent_buffer *leaf;
10957 struct btrfs_extent_item *ei;
10958 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10959 u64 flags;
10960 u64 bg_flags;
10961 u64 used;
10962 u64 total = 0;
10963 int ret;
10964 int err = 0;
10965
10966 btrfs_item_key_to_cpu(eb, &bg_key, slot);
10967 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
10968 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
10969 used = btrfs_block_group_used(&bg_item);
10970 bg_flags = btrfs_block_group_flags(&bg_item);
10971
10972 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
10973 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10974 chunk_key.offset = bg_key.objectid;
10975
10976 btrfs_init_path(&path);
10977 /* Search for the referencer chunk */
10978 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10979 if (ret) {
10980 error(
10981 "block group[%llu %llu] did not find the related chunk item",
10982 bg_key.objectid, bg_key.offset);
10983 err |= REFERENCER_MISSING;
10984 } else {
10985 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
10986 struct btrfs_chunk);
10987 if (btrfs_chunk_length(path.nodes[0], chunk) !=
10988 bg_key.offset) {
10989 error(
10990 "block group[%llu %llu] related chunk item length does not match",
10991 bg_key.objectid, bg_key.offset);
10992 err |= REFERENCER_MISMATCH;
10993 }
10994 }
10995 btrfs_release_path(&path);
10996
10997 /* Search from the block group bytenr */
10998 extent_key.objectid = bg_key.objectid;
10999 extent_key.type = 0;
11000 extent_key.offset = 0;
11001
11002 btrfs_init_path(&path);
11003 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
11004 if (ret < 0)
11005 goto out;
11006
11007 /* Iterate extent tree to account used space */
11008 while (1) {
11009 leaf = path.nodes[0];
11010
11011 /* Search slot can point to the last item beyond leaf nritems */
11012 if (path.slots[0] >= btrfs_header_nritems(leaf))
11013 goto next;
11014
11015 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
11016 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
11017 break;
11018
11019 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
11020 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
11021 goto next;
11022 if (extent_key.objectid < bg_key.objectid)
11023 goto next;
11024
11025 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
11026 total += nodesize;
11027 else
11028 total += extent_key.offset;
11029
11030 ei = btrfs_item_ptr(leaf, path.slots[0],
11031 struct btrfs_extent_item);
11032 flags = btrfs_extent_flags(leaf, ei);
11033 if (flags & BTRFS_EXTENT_FLAG_DATA) {
11034 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
11035 error(
11036 "bad extent[%llu, %llu) type mismatch with chunk",
11037 extent_key.objectid,
11038 extent_key.objectid + extent_key.offset);
11039 err |= CHUNK_TYPE_MISMATCH;
11040 }
11041 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
11042 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
11043 BTRFS_BLOCK_GROUP_METADATA))) {
11044 error(
11045 "bad extent[%llu, %llu) type mismatch with chunk",
11046 extent_key.objectid,
11047 extent_key.objectid + nodesize);
11048 err |= CHUNK_TYPE_MISMATCH;
11049 }
11050 }
11051 next:
11052 ret = btrfs_next_item(extent_root, &path);
11053 if (ret)
11054 break;
11055 }
11056
11057 out:
11058 btrfs_release_path(&path);
11059
11060 if (total != used) {
11061 error(
11062 "block group[%llu %llu] used %llu but extent items used %llu",
11063 bg_key.objectid, bg_key.offset, used, total);
11064 err |= ACCOUNTING_MISMATCH;
11065 }
11066 return err;
11067 }
11068
11069 /*
11070 * Check a chunk item.
11071 * Including checking all referred dev_extents and block group
11072 */
11073 static int check_chunk_item(struct btrfs_fs_info *fs_info,
11074 struct extent_buffer *eb, int slot)
11075 {
11076 struct btrfs_root *extent_root = fs_info->extent_root;
11077 struct btrfs_root *dev_root = fs_info->dev_root;
11078 struct btrfs_path path;
11079 struct btrfs_key chunk_key;
11080 struct btrfs_key bg_key;
11081 struct btrfs_key devext_key;
11082 struct btrfs_chunk *chunk;
11083 struct extent_buffer *leaf;
11084 struct btrfs_block_group_item *bi;
11085 struct btrfs_block_group_item bg_item;
11086 struct btrfs_dev_extent *ptr;
11087 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
11088 u64 length;
11089 u64 chunk_end;
11090 u64 type;
11091 u64 profile;
11092 int num_stripes;
11093 u64 offset;
11094 u64 objectid;
11095 int i;
11096 int ret;
11097 int err = 0;
11098
11099 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11100 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11101 length = btrfs_chunk_length(eb, chunk);
11102 chunk_end = chunk_key.offset + length;
11103 if (!IS_ALIGNED(length, sectorsize)) {
11104 error("chunk[%llu %llu) not aligned to %u",
11105 chunk_key.offset, chunk_end, sectorsize);
11106 err |= BYTES_UNALIGNED;
11107 goto out;
11108 }
11109
11110 type = btrfs_chunk_type(eb, chunk);
11111 profile = type & BTRFS_BLOCK_GROUP_PROFILE_MASK;
11112 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
11113 error("chunk[%llu %llu) has no chunk type",
11114 chunk_key.offset, chunk_end);
11115 err |= UNKNOWN_TYPE;
11116 }
11117 if (profile && (profile & (profile - 1))) {
11118 error("chunk[%llu %llu) multiple profiles detected: %llx",
11119 chunk_key.offset, chunk_end, profile);
11120 err |= UNKNOWN_TYPE;
11121 }
11122
11123 bg_key.objectid = chunk_key.offset;
11124 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11125 bg_key.offset = length;
11126
11127 btrfs_init_path(&path);
11128 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11129 if (ret) {
11130 error(
11131 "chunk[%llu %llu) did not find the related block group item",
11132 chunk_key.offset, chunk_end);
11133 err |= REFERENCER_MISSING;
11134 } else{
11135 leaf = path.nodes[0];
11136 bi = btrfs_item_ptr(leaf, path.slots[0],
11137 struct btrfs_block_group_item);
11138 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11139 sizeof(bg_item));
11140 if (btrfs_block_group_flags(&bg_item) != type) {
11141 error(
11142 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11143 chunk_key.offset, chunk_end, type,
11144 btrfs_block_group_flags(&bg_item));
11145 err |= REFERENCER_MISSING;
11146 }
11147 }
11148
11149 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11150 for (i = 0; i < num_stripes; i++) {
11151 btrfs_release_path(&path);
11152 btrfs_init_path(&path);
11153 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11154 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11155 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11156
11157 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11158 0, 0);
11159 if (ret)
11160 goto not_match_dev;
11161
11162 leaf = path.nodes[0];
11163 ptr = btrfs_item_ptr(leaf, path.slots[0],
11164 struct btrfs_dev_extent);
11165 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11166 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11167 if (objectid != chunk_key.objectid ||
11168 offset != chunk_key.offset ||
11169 btrfs_dev_extent_length(leaf, ptr) != length)
11170 goto not_match_dev;
11171 continue;
11172 not_match_dev:
11173 err |= BACKREF_MISSING;
11174 error(
11175 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11176 chunk_key.objectid, chunk_end, i);
11177 continue;
11178 }
11179 btrfs_release_path(&path);
11180 out:
11181 return err;
11182 }
11183
11184 /*
11185 * Main entry function to check known items and update related accounting info
11186 */
11187 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11188 {
11189 struct btrfs_fs_info *fs_info = root->fs_info;
11190 struct btrfs_key key;
11191 int slot = 0;
11192 int type;
11193 struct btrfs_extent_data_ref *dref;
11194 int ret;
11195 int err = 0;
11196
11197 next:
11198 btrfs_item_key_to_cpu(eb, &key, slot);
11199 type = key.type;
11200
11201 switch (type) {
11202 case BTRFS_EXTENT_DATA_KEY:
11203 ret = check_extent_data_item(root, eb, slot);
11204 err |= ret;
11205 break;
11206 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11207 ret = check_block_group_item(fs_info, eb, slot);
11208 err |= ret;
11209 break;
11210 case BTRFS_DEV_ITEM_KEY:
11211 ret = check_dev_item(fs_info, eb, slot);
11212 err |= ret;
11213 break;
11214 case BTRFS_CHUNK_ITEM_KEY:
11215 ret = check_chunk_item(fs_info, eb, slot);
11216 err |= ret;
11217 break;
11218 case BTRFS_DEV_EXTENT_KEY:
11219 ret = check_dev_extent_item(fs_info, eb, slot);
11220 err |= ret;
11221 break;
11222 case BTRFS_EXTENT_ITEM_KEY:
11223 case BTRFS_METADATA_ITEM_KEY:
11224 ret = check_extent_item(fs_info, eb, slot);
11225 err |= ret;
11226 break;
11227 case BTRFS_EXTENT_CSUM_KEY:
11228 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11229 break;
11230 case BTRFS_TREE_BLOCK_REF_KEY:
11231 ret = check_tree_block_backref(fs_info, key.offset,
11232 key.objectid, -1);
11233 err |= ret;
11234 break;
11235 case BTRFS_EXTENT_DATA_REF_KEY:
11236 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11237 ret = check_extent_data_backref(fs_info,
11238 btrfs_extent_data_ref_root(eb, dref),
11239 btrfs_extent_data_ref_objectid(eb, dref),
11240 btrfs_extent_data_ref_offset(eb, dref),
11241 key.objectid, 0,
11242 btrfs_extent_data_ref_count(eb, dref));
11243 err |= ret;
11244 break;
11245 case BTRFS_SHARED_BLOCK_REF_KEY:
11246 ret = check_shared_block_backref(fs_info, key.offset,
11247 key.objectid, -1);
11248 err |= ret;
11249 break;
11250 case BTRFS_SHARED_DATA_REF_KEY:
11251 ret = check_shared_data_backref(fs_info, key.offset,
11252 key.objectid);
11253 err |= ret;
11254 break;
11255 default:
11256 break;
11257 }
11258
11259 if (++slot < btrfs_header_nritems(eb))
11260 goto next;
11261
11262 return err;
11263 }
11264
11265 /*
11266 * Helper function for later fs/subvol tree check. To determine if a tree
11267 * block should be checked.
11268 * This function will ensure only the direct referencer with lowest rootid to
11269 * check a fs/subvolume tree block.
11270 *
11271 * Backref check at extent tree would detect errors like missing subvolume
11272 * tree, so we can do aggressive check to reduce duplicated checks.
11273 */
11274 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11275 {
11276 struct btrfs_root *extent_root = root->fs_info->extent_root;
11277 struct btrfs_key key;
11278 struct btrfs_path path;
11279 struct extent_buffer *leaf;
11280 int slot;
11281 struct btrfs_extent_item *ei;
11282 unsigned long ptr;
11283 unsigned long end;
11284 int type;
11285 u32 item_size;
11286 u64 offset;
11287 struct btrfs_extent_inline_ref *iref;
11288 int ret;
11289
11290 btrfs_init_path(&path);
11291 key.objectid = btrfs_header_bytenr(eb);
11292 key.type = BTRFS_METADATA_ITEM_KEY;
11293 key.offset = (u64)-1;
11294
11295 /*
11296 * Any failure in backref resolving means we can't determine
11297 * whom the tree block belongs to.
11298 * So in that case, we need to check that tree block
11299 */
11300 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11301 if (ret < 0)
11302 goto need_check;
11303
11304 ret = btrfs_previous_extent_item(extent_root, &path,
11305 btrfs_header_bytenr(eb));
11306 if (ret)
11307 goto need_check;
11308
11309 leaf = path.nodes[0];
11310 slot = path.slots[0];
11311 btrfs_item_key_to_cpu(leaf, &key, slot);
11312 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11313
11314 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11315 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11316 } else {
11317 struct btrfs_tree_block_info *info;
11318
11319 info = (struct btrfs_tree_block_info *)(ei + 1);
11320 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11321 }
11322
11323 item_size = btrfs_item_size_nr(leaf, slot);
11324 ptr = (unsigned long)iref;
11325 end = (unsigned long)ei + item_size;
11326 while (ptr < end) {
11327 iref = (struct btrfs_extent_inline_ref *)ptr;
11328 type = btrfs_extent_inline_ref_type(leaf, iref);
11329 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11330
11331 /*
11332 * We only check the tree block if current root is
11333 * the lowest referencer of it.
11334 */
11335 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11336 offset < root->objectid) {
11337 btrfs_release_path(&path);
11338 return 0;
11339 }
11340
11341 ptr += btrfs_extent_inline_ref_size(type);
11342 }
11343 /*
11344 * Normally we should also check keyed tree block ref, but that may be
11345 * very time consuming. Inlined ref should already make us skip a lot
11346 * of refs now. So skip search keyed tree block ref.
11347 */
11348
11349 need_check:
11350 btrfs_release_path(&path);
11351 return 1;
11352 }
11353
11354 /*
11355 * Traversal function for tree block. We will do:
11356 * 1) Skip shared fs/subvolume tree blocks
11357 * 2) Update related bytes accounting
11358 * 3) Pre-order traversal
11359 */
11360 static int traverse_tree_block(struct btrfs_root *root,
11361 struct extent_buffer *node)
11362 {
11363 struct extent_buffer *eb;
11364 struct btrfs_key key;
11365 struct btrfs_key drop_key;
11366 int level;
11367 u64 nr;
11368 int i;
11369 int err = 0;
11370 int ret;
11371
11372 /*
11373 * Skip shared fs/subvolume tree block, in that case they will
11374 * be checked by referencer with lowest rootid
11375 */
11376 if (is_fstree(root->objectid) && !should_check(root, node))
11377 return 0;
11378
11379 /* Update bytes accounting */
11380 total_btree_bytes += node->len;
11381 if (fs_root_objectid(btrfs_header_owner(node)))
11382 total_fs_tree_bytes += node->len;
11383 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11384 total_extent_tree_bytes += node->len;
11385 if (!found_old_backref &&
11386 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11387 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11388 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11389 found_old_backref = 1;
11390
11391 /* pre-order tranversal, check itself first */
11392 level = btrfs_header_level(node);
11393 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11394 btrfs_header_level(node),
11395 btrfs_header_owner(node));
11396 err |= ret;
11397 if (err)
11398 error(
11399 "check %s failed root %llu bytenr %llu level %d, force continue check",
11400 level ? "node":"leaf", root->objectid,
11401 btrfs_header_bytenr(node), btrfs_header_level(node));
11402
11403 if (!level) {
11404 btree_space_waste += btrfs_leaf_free_space(root, node);
11405 ret = check_leaf_items(root, node);
11406 err |= ret;
11407 return err;
11408 }
11409
11410 nr = btrfs_header_nritems(node);
11411 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11412 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11413 sizeof(struct btrfs_key_ptr);
11414
11415 /* Then check all its children */
11416 for (i = 0; i < nr; i++) {
11417 u64 blocknr = btrfs_node_blockptr(node, i);
11418
11419 btrfs_node_key_to_cpu(node, &key, i);
11420 if (level == root->root_item.drop_level &&
11421 is_dropped_key(&key, &drop_key))
11422 continue;
11423
11424 /*
11425 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11426 * to call the function itself.
11427 */
11428 eb = read_tree_block(root, blocknr, root->nodesize, 0);
11429 if (extent_buffer_uptodate(eb)) {
11430 ret = traverse_tree_block(root, eb);
11431 err |= ret;
11432 }
11433 free_extent_buffer(eb);
11434 }
11435
11436 return err;
11437 }
11438
11439 /*
11440 * Low memory usage version check_chunks_and_extents.
11441 */
11442 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11443 {
11444 struct btrfs_path path;
11445 struct btrfs_key key;
11446 struct btrfs_root *root1;
11447 struct btrfs_root *cur_root;
11448 int err = 0;
11449 int ret;
11450
11451 root1 = root->fs_info->chunk_root;
11452 ret = traverse_tree_block(root1, root1->node);
11453 err |= ret;
11454
11455 root1 = root->fs_info->tree_root;
11456 ret = traverse_tree_block(root1, root1->node);
11457 err |= ret;
11458
11459 btrfs_init_path(&path);
11460 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11461 key.offset = 0;
11462 key.type = BTRFS_ROOT_ITEM_KEY;
11463
11464 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11465 if (ret) {
11466 error("cannot find extent treet in tree_root");
11467 goto out;
11468 }
11469
11470 while (1) {
11471 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11472 if (key.type != BTRFS_ROOT_ITEM_KEY)
11473 goto next;
11474 key.offset = (u64)-1;
11475
11476 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11477 cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
11478 &key);
11479 else
11480 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11481 if (IS_ERR(cur_root) || !cur_root) {
11482 error("failed to read tree: %lld", key.objectid);
11483 goto next;
11484 }
11485
11486 ret = traverse_tree_block(cur_root, cur_root->node);
11487 err |= ret;
11488
11489 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11490 btrfs_free_fs_root(cur_root);
11491 next:
11492 ret = btrfs_next_item(root1, &path);
11493 if (ret)
11494 goto out;
11495 }
11496
11497 out:
11498 btrfs_release_path(&path);
11499 return err;
11500 }
11501
11502 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11503 struct btrfs_root *root, int overwrite)
11504 {
11505 struct extent_buffer *c;
11506 struct extent_buffer *old = root->node;
11507 int level;
11508 int ret;
11509 struct btrfs_disk_key disk_key = {0,0,0};
11510
11511 level = 0;
11512
11513 if (overwrite) {
11514 c = old;
11515 extent_buffer_get(c);
11516 goto init;
11517 }
11518 c = btrfs_alloc_free_block(trans, root,
11519 root->nodesize,
11520 root->root_key.objectid,
11521 &disk_key, level, 0, 0);
11522 if (IS_ERR(c)) {
11523 c = old;
11524 extent_buffer_get(c);
11525 overwrite = 1;
11526 }
11527 init:
11528 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11529 btrfs_set_header_level(c, level);
11530 btrfs_set_header_bytenr(c, c->start);
11531 btrfs_set_header_generation(c, trans->transid);
11532 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11533 btrfs_set_header_owner(c, root->root_key.objectid);
11534
11535 write_extent_buffer(c, root->fs_info->fsid,
11536 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11537
11538 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11539 btrfs_header_chunk_tree_uuid(c),
11540 BTRFS_UUID_SIZE);
11541
11542 btrfs_mark_buffer_dirty(c);
11543 /*
11544 * this case can happen in the following case:
11545 *
11546 * 1.overwrite previous root.
11547 *
11548 * 2.reinit reloc data root, this is because we skip pin
11549 * down reloc data tree before which means we can allocate
11550 * same block bytenr here.
11551 */
11552 if (old->start == c->start) {
11553 btrfs_set_root_generation(&root->root_item,
11554 trans->transid);
11555 root->root_item.level = btrfs_header_level(root->node);
11556 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11557 &root->root_key, &root->root_item);
11558 if (ret) {
11559 free_extent_buffer(c);
11560 return ret;
11561 }
11562 }
11563 free_extent_buffer(old);
11564 root->node = c;
11565 add_root_to_dirty_list(root);
11566 return 0;
11567 }
11568
11569 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11570 struct extent_buffer *eb, int tree_root)
11571 {
11572 struct extent_buffer *tmp;
11573 struct btrfs_root_item *ri;
11574 struct btrfs_key key;
11575 u64 bytenr;
11576 u32 nodesize;
11577 int level = btrfs_header_level(eb);
11578 int nritems;
11579 int ret;
11580 int i;
11581
11582 /*
11583 * If we have pinned this block before, don't pin it again.
11584 * This can not only avoid forever loop with broken filesystem
11585 * but also give us some speedups.
11586 */
11587 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11588 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11589 return 0;
11590
11591 btrfs_pin_extent(fs_info, eb->start, eb->len);
11592
11593 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11594 nritems = btrfs_header_nritems(eb);
11595 for (i = 0; i < nritems; i++) {
11596 if (level == 0) {
11597 btrfs_item_key_to_cpu(eb, &key, i);
11598 if (key.type != BTRFS_ROOT_ITEM_KEY)
11599 continue;
11600 /* Skip the extent root and reloc roots */
11601 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11602 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11603 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11604 continue;
11605 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11606 bytenr = btrfs_disk_root_bytenr(eb, ri);
11607
11608 /*
11609 * If at any point we start needing the real root we
11610 * will have to build a stump root for the root we are
11611 * in, but for now this doesn't actually use the root so
11612 * just pass in extent_root.
11613 */
11614 tmp = read_tree_block(fs_info->extent_root, bytenr,
11615 nodesize, 0);
11616 if (!extent_buffer_uptodate(tmp)) {
11617 fprintf(stderr, "Error reading root block\n");
11618 return -EIO;
11619 }
11620 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11621 free_extent_buffer(tmp);
11622 if (ret)
11623 return ret;
11624 } else {
11625 bytenr = btrfs_node_blockptr(eb, i);
11626
11627 /* If we aren't the tree root don't read the block */
11628 if (level == 1 && !tree_root) {
11629 btrfs_pin_extent(fs_info, bytenr, nodesize);
11630 continue;
11631 }
11632
11633 tmp = read_tree_block(fs_info->extent_root, bytenr,
11634 nodesize, 0);
11635 if (!extent_buffer_uptodate(tmp)) {
11636 fprintf(stderr, "Error reading tree block\n");
11637 return -EIO;
11638 }
11639 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11640 free_extent_buffer(tmp);
11641 if (ret)
11642 return ret;
11643 }
11644 }
11645
11646 return 0;
11647 }
11648
11649 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11650 {
11651 int ret;
11652
11653 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11654 if (ret)
11655 return ret;
11656
11657 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11658 }
11659
11660 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11661 {
11662 struct btrfs_block_group_cache *cache;
11663 struct btrfs_path path;
11664 struct extent_buffer *leaf;
11665 struct btrfs_chunk *chunk;
11666 struct btrfs_key key;
11667 int ret;
11668 u64 start;
11669
11670 btrfs_init_path(&path);
11671 key.objectid = 0;
11672 key.type = BTRFS_CHUNK_ITEM_KEY;
11673 key.offset = 0;
11674 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11675 if (ret < 0) {
11676 btrfs_release_path(&path);
11677 return ret;
11678 }
11679
11680 /*
11681 * We do this in case the block groups were screwed up and had alloc
11682 * bits that aren't actually set on the chunks. This happens with
11683 * restored images every time and could happen in real life I guess.
11684 */
11685 fs_info->avail_data_alloc_bits = 0;
11686 fs_info->avail_metadata_alloc_bits = 0;
11687 fs_info->avail_system_alloc_bits = 0;
11688
11689 /* First we need to create the in-memory block groups */
11690 while (1) {
11691 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11692 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11693 if (ret < 0) {
11694 btrfs_release_path(&path);
11695 return ret;
11696 }
11697 if (ret) {
11698 ret = 0;
11699 break;
11700 }
11701 }
11702 leaf = path.nodes[0];
11703 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11704 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11705 path.slots[0]++;
11706 continue;
11707 }
11708
11709 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11710 btrfs_add_block_group(fs_info, 0,
11711 btrfs_chunk_type(leaf, chunk),
11712 key.objectid, key.offset,
11713 btrfs_chunk_length(leaf, chunk));
11714 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11715 key.offset + btrfs_chunk_length(leaf, chunk));
11716 path.slots[0]++;
11717 }
11718 start = 0;
11719 while (1) {
11720 cache = btrfs_lookup_first_block_group(fs_info, start);
11721 if (!cache)
11722 break;
11723 cache->cached = 1;
11724 start = cache->key.objectid + cache->key.offset;
11725 }
11726
11727 btrfs_release_path(&path);
11728 return 0;
11729 }
11730
11731 static int reset_balance(struct btrfs_trans_handle *trans,
11732 struct btrfs_fs_info *fs_info)
11733 {
11734 struct btrfs_root *root = fs_info->tree_root;
11735 struct btrfs_path path;
11736 struct extent_buffer *leaf;
11737 struct btrfs_key key;
11738 int del_slot, del_nr = 0;
11739 int ret;
11740 int found = 0;
11741
11742 btrfs_init_path(&path);
11743 key.objectid = BTRFS_BALANCE_OBJECTID;
11744 key.type = BTRFS_BALANCE_ITEM_KEY;
11745 key.offset = 0;
11746 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11747 if (ret) {
11748 if (ret > 0)
11749 ret = 0;
11750 if (!ret)
11751 goto reinit_data_reloc;
11752 else
11753 goto out;
11754 }
11755
11756 ret = btrfs_del_item(trans, root, &path);
11757 if (ret)
11758 goto out;
11759 btrfs_release_path(&path);
11760
11761 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11762 key.type = BTRFS_ROOT_ITEM_KEY;
11763 key.offset = 0;
11764 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11765 if (ret < 0)
11766 goto out;
11767 while (1) {
11768 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11769 if (!found)
11770 break;
11771
11772 if (del_nr) {
11773 ret = btrfs_del_items(trans, root, &path,
11774 del_slot, del_nr);
11775 del_nr = 0;
11776 if (ret)
11777 goto out;
11778 }
11779 key.offset++;
11780 btrfs_release_path(&path);
11781
11782 found = 0;
11783 ret = btrfs_search_slot(trans, root, &key, &path,
11784 -1, 1);
11785 if (ret < 0)
11786 goto out;
11787 continue;
11788 }
11789 found = 1;
11790 leaf = path.nodes[0];
11791 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11792 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11793 break;
11794 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11795 path.slots[0]++;
11796 continue;
11797 }
11798 if (!del_nr) {
11799 del_slot = path.slots[0];
11800 del_nr = 1;
11801 } else {
11802 del_nr++;
11803 }
11804 path.slots[0]++;
11805 }
11806
11807 if (del_nr) {
11808 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11809 if (ret)
11810 goto out;
11811 }
11812 btrfs_release_path(&path);
11813
11814 reinit_data_reloc:
11815 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11816 key.type = BTRFS_ROOT_ITEM_KEY;
11817 key.offset = (u64)-1;
11818 root = btrfs_read_fs_root(fs_info, &key);
11819 if (IS_ERR(root)) {
11820 fprintf(stderr, "Error reading data reloc tree\n");
11821 ret = PTR_ERR(root);
11822 goto out;
11823 }
11824 record_root_in_trans(trans, root);
11825 ret = btrfs_fsck_reinit_root(trans, root, 0);
11826 if (ret)
11827 goto out;
11828 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11829 out:
11830 btrfs_release_path(&path);
11831 return ret;
11832 }
11833
11834 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11835 struct btrfs_fs_info *fs_info)
11836 {
11837 u64 start = 0;
11838 int ret;
11839
11840 /*
11841 * The only reason we don't do this is because right now we're just
11842 * walking the trees we find and pinning down their bytes, we don't look
11843 * at any of the leaves. In order to do mixed groups we'd have to check
11844 * the leaves of any fs roots and pin down the bytes for any file
11845 * extents we find. Not hard but why do it if we don't have to?
11846 */
11847 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11848 fprintf(stderr, "We don't support re-initing the extent tree "
11849 "for mixed block groups yet, please notify a btrfs "
11850 "developer you want to do this so they can add this "
11851 "functionality.\n");
11852 return -EINVAL;
11853 }
11854
11855 /*
11856 * first we need to walk all of the trees except the extent tree and pin
11857 * down the bytes that are in use so we don't overwrite any existing
11858 * metadata.
11859 */
11860 ret = pin_metadata_blocks(fs_info);
11861 if (ret) {
11862 fprintf(stderr, "error pinning down used bytes\n");
11863 return ret;
11864 }
11865
11866 /*
11867 * Need to drop all the block groups since we're going to recreate all
11868 * of them again.
11869 */
11870 btrfs_free_block_groups(fs_info);
11871 ret = reset_block_groups(fs_info);
11872 if (ret) {
11873 fprintf(stderr, "error resetting the block groups\n");
11874 return ret;
11875 }
11876
11877 /* Ok we can allocate now, reinit the extent root */
11878 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11879 if (ret) {
11880 fprintf(stderr, "extent root initialization failed\n");
11881 /*
11882 * When the transaction code is updated we should end the
11883 * transaction, but for now progs only knows about commit so
11884 * just return an error.
11885 */
11886 return ret;
11887 }
11888
11889 /*
11890 * Now we have all the in-memory block groups setup so we can make
11891 * allocations properly, and the metadata we care about is safe since we
11892 * pinned all of it above.
11893 */
11894 while (1) {
11895 struct btrfs_block_group_cache *cache;
11896
11897 cache = btrfs_lookup_first_block_group(fs_info, start);
11898 if (!cache)
11899 break;
11900 start = cache->key.objectid + cache->key.offset;
11901 ret = btrfs_insert_item(trans, fs_info->extent_root,
11902 &cache->key, &cache->item,
11903 sizeof(cache->item));
11904 if (ret) {
11905 fprintf(stderr, "Error adding block group\n");
11906 return ret;
11907 }
11908 btrfs_extent_post_op(trans, fs_info->extent_root);
11909 }
11910
11911 ret = reset_balance(trans, fs_info);
11912 if (ret)
11913 fprintf(stderr, "error resetting the pending balance\n");
11914
11915 return ret;
11916 }
11917
11918 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
11919 {
11920 struct btrfs_path path;
11921 struct btrfs_trans_handle *trans;
11922 struct btrfs_key key;
11923 int ret;
11924
11925 printf("Recowing metadata block %llu\n", eb->start);
11926 key.objectid = btrfs_header_owner(eb);
11927 key.type = BTRFS_ROOT_ITEM_KEY;
11928 key.offset = (u64)-1;
11929
11930 root = btrfs_read_fs_root(root->fs_info, &key);
11931 if (IS_ERR(root)) {
11932 fprintf(stderr, "Couldn't find owner root %llu\n",
11933 key.objectid);
11934 return PTR_ERR(root);
11935 }
11936
11937 trans = btrfs_start_transaction(root, 1);
11938 if (IS_ERR(trans))
11939 return PTR_ERR(trans);
11940
11941 btrfs_init_path(&path);
11942 path.lowest_level = btrfs_header_level(eb);
11943 if (path.lowest_level)
11944 btrfs_node_key_to_cpu(eb, &key, 0);
11945 else
11946 btrfs_item_key_to_cpu(eb, &key, 0);
11947
11948 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
11949 btrfs_commit_transaction(trans, root);
11950 btrfs_release_path(&path);
11951 return ret;
11952 }
11953
11954 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
11955 {
11956 struct btrfs_path path;
11957 struct btrfs_trans_handle *trans;
11958 struct btrfs_key key;
11959 int ret;
11960
11961 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
11962 bad->key.type, bad->key.offset);
11963 key.objectid = bad->root_id;
11964 key.type = BTRFS_ROOT_ITEM_KEY;
11965 key.offset = (u64)-1;
11966
11967 root = btrfs_read_fs_root(root->fs_info, &key);
11968 if (IS_ERR(root)) {
11969 fprintf(stderr, "Couldn't find owner root %llu\n",
11970 key.objectid);
11971 return PTR_ERR(root);
11972 }
11973
11974 trans = btrfs_start_transaction(root, 1);
11975 if (IS_ERR(trans))
11976 return PTR_ERR(trans);
11977
11978 btrfs_init_path(&path);
11979 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
11980 if (ret) {
11981 if (ret > 0)
11982 ret = 0;
11983 goto out;
11984 }
11985 ret = btrfs_del_item(trans, root, &path);
11986 out:
11987 btrfs_commit_transaction(trans, root);
11988 btrfs_release_path(&path);
11989 return ret;
11990 }
11991
11992 static int zero_log_tree(struct btrfs_root *root)
11993 {
11994 struct btrfs_trans_handle *trans;
11995 int ret;
11996
11997 trans = btrfs_start_transaction(root, 1);
11998 if (IS_ERR(trans)) {
11999 ret = PTR_ERR(trans);
12000 return ret;
12001 }
12002 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
12003 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
12004 ret = btrfs_commit_transaction(trans, root);
12005 return ret;
12006 }
12007
12008 static int populate_csum(struct btrfs_trans_handle *trans,
12009 struct btrfs_root *csum_root, char *buf, u64 start,
12010 u64 len)
12011 {
12012 u64 offset = 0;
12013 u64 sectorsize;
12014 int ret = 0;
12015
12016 while (offset < len) {
12017 sectorsize = csum_root->sectorsize;
12018 ret = read_extent_data(csum_root, buf, start + offset,
12019 &sectorsize, 0);
12020 if (ret)
12021 break;
12022 ret = btrfs_csum_file_block(trans, csum_root, start + len,
12023 start + offset, buf, sectorsize);
12024 if (ret)
12025 break;
12026 offset += sectorsize;
12027 }
12028 return ret;
12029 }
12030
12031 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
12032 struct btrfs_root *csum_root,
12033 struct btrfs_root *cur_root)
12034 {
12035 struct btrfs_path path;
12036 struct btrfs_key key;
12037 struct extent_buffer *node;
12038 struct btrfs_file_extent_item *fi;
12039 char *buf = NULL;
12040 u64 start = 0;
12041 u64 len = 0;
12042 int slot = 0;
12043 int ret = 0;
12044
12045 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
12046 if (!buf)
12047 return -ENOMEM;
12048
12049 btrfs_init_path(&path);
12050 key.objectid = 0;
12051 key.offset = 0;
12052 key.type = 0;
12053 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
12054 if (ret < 0)
12055 goto out;
12056 /* Iterate all regular file extents and fill its csum */
12057 while (1) {
12058 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12059
12060 if (key.type != BTRFS_EXTENT_DATA_KEY)
12061 goto next;
12062 node = path.nodes[0];
12063 slot = path.slots[0];
12064 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
12065 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
12066 goto next;
12067 start = btrfs_file_extent_disk_bytenr(node, fi);
12068 len = btrfs_file_extent_disk_num_bytes(node, fi);
12069
12070 ret = populate_csum(trans, csum_root, buf, start, len);
12071 if (ret == -EEXIST)
12072 ret = 0;
12073 if (ret < 0)
12074 goto out;
12075 next:
12076 /*
12077 * TODO: if next leaf is corrupted, jump to nearest next valid
12078 * leaf.
12079 */
12080 ret = btrfs_next_item(cur_root, &path);
12081 if (ret < 0)
12082 goto out;
12083 if (ret > 0) {
12084 ret = 0;
12085 goto out;
12086 }
12087 }
12088
12089 out:
12090 btrfs_release_path(&path);
12091 free(buf);
12092 return ret;
12093 }
12094
12095 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12096 struct btrfs_root *csum_root)
12097 {
12098 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12099 struct btrfs_path path;
12100 struct btrfs_root *tree_root = fs_info->tree_root;
12101 struct btrfs_root *cur_root;
12102 struct extent_buffer *node;
12103 struct btrfs_key key;
12104 int slot = 0;
12105 int ret = 0;
12106
12107 btrfs_init_path(&path);
12108 key.objectid = BTRFS_FS_TREE_OBJECTID;
12109 key.offset = 0;
12110 key.type = BTRFS_ROOT_ITEM_KEY;
12111 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12112 if (ret < 0)
12113 goto out;
12114 if (ret > 0) {
12115 ret = -ENOENT;
12116 goto out;
12117 }
12118
12119 while (1) {
12120 node = path.nodes[0];
12121 slot = path.slots[0];
12122 btrfs_item_key_to_cpu(node, &key, slot);
12123 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12124 goto out;
12125 if (key.type != BTRFS_ROOT_ITEM_KEY)
12126 goto next;
12127 if (!is_fstree(key.objectid))
12128 goto next;
12129 key.offset = (u64)-1;
12130
12131 cur_root = btrfs_read_fs_root(fs_info, &key);
12132 if (IS_ERR(cur_root) || !cur_root) {
12133 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12134 key.objectid);
12135 goto out;
12136 }
12137 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12138 cur_root);
12139 if (ret < 0)
12140 goto out;
12141 next:
12142 ret = btrfs_next_item(tree_root, &path);
12143 if (ret > 0) {
12144 ret = 0;
12145 goto out;
12146 }
12147 if (ret < 0)
12148 goto out;
12149 }
12150
12151 out:
12152 btrfs_release_path(&path);
12153 return ret;
12154 }
12155
12156 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12157 struct btrfs_root *csum_root)
12158 {
12159 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12160 struct btrfs_path path;
12161 struct btrfs_extent_item *ei;
12162 struct extent_buffer *leaf;
12163 char *buf;
12164 struct btrfs_key key;
12165 int ret;
12166
12167 btrfs_init_path(&path);
12168 key.objectid = 0;
12169 key.type = BTRFS_EXTENT_ITEM_KEY;
12170 key.offset = 0;
12171 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12172 if (ret < 0) {
12173 btrfs_release_path(&path);
12174 return ret;
12175 }
12176
12177 buf = malloc(csum_root->sectorsize);
12178 if (!buf) {
12179 btrfs_release_path(&path);
12180 return -ENOMEM;
12181 }
12182
12183 while (1) {
12184 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12185 ret = btrfs_next_leaf(extent_root, &path);
12186 if (ret < 0)
12187 break;
12188 if (ret) {
12189 ret = 0;
12190 break;
12191 }
12192 }
12193 leaf = path.nodes[0];
12194
12195 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12196 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12197 path.slots[0]++;
12198 continue;
12199 }
12200
12201 ei = btrfs_item_ptr(leaf, path.slots[0],
12202 struct btrfs_extent_item);
12203 if (!(btrfs_extent_flags(leaf, ei) &
12204 BTRFS_EXTENT_FLAG_DATA)) {
12205 path.slots[0]++;
12206 continue;
12207 }
12208
12209 ret = populate_csum(trans, csum_root, buf, key.objectid,
12210 key.offset);
12211 if (ret)
12212 break;
12213 path.slots[0]++;
12214 }
12215
12216 btrfs_release_path(&path);
12217 free(buf);
12218 return ret;
12219 }
12220
12221 /*
12222 * Recalculate the csum and put it into the csum tree.
12223 *
12224 * Extent tree init will wipe out all the extent info, so in that case, we
12225 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12226 * will use fs/subvol trees to init the csum tree.
12227 */
12228 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12229 struct btrfs_root *csum_root,
12230 int search_fs_tree)
12231 {
12232 if (search_fs_tree)
12233 return fill_csum_tree_from_fs(trans, csum_root);
12234 else
12235 return fill_csum_tree_from_extent(trans, csum_root);
12236 }
12237
12238 static void free_roots_info_cache(void)
12239 {
12240 if (!roots_info_cache)
12241 return;
12242
12243 while (!cache_tree_empty(roots_info_cache)) {
12244 struct cache_extent *entry;
12245 struct root_item_info *rii;
12246
12247 entry = first_cache_extent(roots_info_cache);
12248 if (!entry)
12249 break;
12250 remove_cache_extent(roots_info_cache, entry);
12251 rii = container_of(entry, struct root_item_info, cache_extent);
12252 free(rii);
12253 }
12254
12255 free(roots_info_cache);
12256 roots_info_cache = NULL;
12257 }
12258
12259 static int build_roots_info_cache(struct btrfs_fs_info *info)
12260 {
12261 int ret = 0;
12262 struct btrfs_key key;
12263 struct extent_buffer *leaf;
12264 struct btrfs_path path;
12265
12266 if (!roots_info_cache) {
12267 roots_info_cache = malloc(sizeof(*roots_info_cache));
12268 if (!roots_info_cache)
12269 return -ENOMEM;
12270 cache_tree_init(roots_info_cache);
12271 }
12272
12273 btrfs_init_path(&path);
12274 key.objectid = 0;
12275 key.type = BTRFS_EXTENT_ITEM_KEY;
12276 key.offset = 0;
12277 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12278 if (ret < 0)
12279 goto out;
12280 leaf = path.nodes[0];
12281
12282 while (1) {
12283 struct btrfs_key found_key;
12284 struct btrfs_extent_item *ei;
12285 struct btrfs_extent_inline_ref *iref;
12286 int slot = path.slots[0];
12287 int type;
12288 u64 flags;
12289 u64 root_id;
12290 u8 level;
12291 struct cache_extent *entry;
12292 struct root_item_info *rii;
12293
12294 if (slot >= btrfs_header_nritems(leaf)) {
12295 ret = btrfs_next_leaf(info->extent_root, &path);
12296 if (ret < 0) {
12297 break;
12298 } else if (ret) {
12299 ret = 0;
12300 break;
12301 }
12302 leaf = path.nodes[0];
12303 slot = path.slots[0];
12304 }
12305
12306 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12307
12308 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12309 found_key.type != BTRFS_METADATA_ITEM_KEY)
12310 goto next;
12311
12312 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12313 flags = btrfs_extent_flags(leaf, ei);
12314
12315 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12316 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12317 goto next;
12318
12319 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12320 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12321 level = found_key.offset;
12322 } else {
12323 struct btrfs_tree_block_info *binfo;
12324
12325 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12326 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12327 level = btrfs_tree_block_level(leaf, binfo);
12328 }
12329
12330 /*
12331 * For a root extent, it must be of the following type and the
12332 * first (and only one) iref in the item.
12333 */
12334 type = btrfs_extent_inline_ref_type(leaf, iref);
12335 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12336 goto next;
12337
12338 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12339 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12340 if (!entry) {
12341 rii = malloc(sizeof(struct root_item_info));
12342 if (!rii) {
12343 ret = -ENOMEM;
12344 goto out;
12345 }
12346 rii->cache_extent.start = root_id;
12347 rii->cache_extent.size = 1;
12348 rii->level = (u8)-1;
12349 entry = &rii->cache_extent;
12350 ret = insert_cache_extent(roots_info_cache, entry);
12351 ASSERT(ret == 0);
12352 } else {
12353 rii = container_of(entry, struct root_item_info,
12354 cache_extent);
12355 }
12356
12357 ASSERT(rii->cache_extent.start == root_id);
12358 ASSERT(rii->cache_extent.size == 1);
12359
12360 if (level > rii->level || rii->level == (u8)-1) {
12361 rii->level = level;
12362 rii->bytenr = found_key.objectid;
12363 rii->gen = btrfs_extent_generation(leaf, ei);
12364 rii->node_count = 1;
12365 } else if (level == rii->level) {
12366 rii->node_count++;
12367 }
12368 next:
12369 path.slots[0]++;
12370 }
12371
12372 out:
12373 btrfs_release_path(&path);
12374
12375 return ret;
12376 }
12377
12378 static int maybe_repair_root_item(struct btrfs_path *path,
12379 const struct btrfs_key *root_key,
12380 const int read_only_mode)
12381 {
12382 const u64 root_id = root_key->objectid;
12383 struct cache_extent *entry;
12384 struct root_item_info *rii;
12385 struct btrfs_root_item ri;
12386 unsigned long offset;
12387
12388 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12389 if (!entry) {
12390 fprintf(stderr,
12391 "Error: could not find extent items for root %llu\n",
12392 root_key->objectid);
12393 return -ENOENT;
12394 }
12395
12396 rii = container_of(entry, struct root_item_info, cache_extent);
12397 ASSERT(rii->cache_extent.start == root_id);
12398 ASSERT(rii->cache_extent.size == 1);
12399
12400 if (rii->node_count != 1) {
12401 fprintf(stderr,
12402 "Error: could not find btree root extent for root %llu\n",
12403 root_id);
12404 return -ENOENT;
12405 }
12406
12407 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12408 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12409
12410 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12411 btrfs_root_level(&ri) != rii->level ||
12412 btrfs_root_generation(&ri) != rii->gen) {
12413
12414 /*
12415 * If we're in repair mode but our caller told us to not update
12416 * the root item, i.e. just check if it needs to be updated, don't
12417 * print this message, since the caller will call us again shortly
12418 * for the same root item without read only mode (the caller will
12419 * open a transaction first).
12420 */
12421 if (!(read_only_mode && repair))
12422 fprintf(stderr,
12423 "%sroot item for root %llu,"
12424 " current bytenr %llu, current gen %llu, current level %u,"
12425 " new bytenr %llu, new gen %llu, new level %u\n",
12426 (read_only_mode ? "" : "fixing "),
12427 root_id,
12428 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12429 btrfs_root_level(&ri),
12430 rii->bytenr, rii->gen, rii->level);
12431
12432 if (btrfs_root_generation(&ri) > rii->gen) {
12433 fprintf(stderr,
12434 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12435 root_id, btrfs_root_generation(&ri), rii->gen);
12436 return -EINVAL;
12437 }
12438
12439 if (!read_only_mode) {
12440 btrfs_set_root_bytenr(&ri, rii->bytenr);
12441 btrfs_set_root_level(&ri, rii->level);
12442 btrfs_set_root_generation(&ri, rii->gen);
12443 write_extent_buffer(path->nodes[0], &ri,
12444 offset, sizeof(ri));
12445 }
12446
12447 return 1;
12448 }
12449
12450 return 0;
12451 }
12452
12453 /*
12454 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12455 * caused read-only snapshots to be corrupted if they were created at a moment
12456 * when the source subvolume/snapshot had orphan items. The issue was that the
12457 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12458 * node instead of the post orphan cleanup root node.
12459 * So this function, and its callees, just detects and fixes those cases. Even
12460 * though the regression was for read-only snapshots, this function applies to
12461 * any snapshot/subvolume root.
12462 * This must be run before any other repair code - not doing it so, makes other
12463 * repair code delete or modify backrefs in the extent tree for example, which
12464 * will result in an inconsistent fs after repairing the root items.
12465 */
12466 static int repair_root_items(struct btrfs_fs_info *info)
12467 {
12468 struct btrfs_path path;
12469 struct btrfs_key key;
12470 struct extent_buffer *leaf;
12471 struct btrfs_trans_handle *trans = NULL;
12472 int ret = 0;
12473 int bad_roots = 0;
12474 int need_trans = 0;
12475
12476 btrfs_init_path(&path);
12477
12478 ret = build_roots_info_cache(info);
12479 if (ret)
12480 goto out;
12481
12482 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12483 key.type = BTRFS_ROOT_ITEM_KEY;
12484 key.offset = 0;
12485
12486 again:
12487 /*
12488 * Avoid opening and committing transactions if a leaf doesn't have
12489 * any root items that need to be fixed, so that we avoid rotating
12490 * backup roots unnecessarily.
12491 */
12492 if (need_trans) {
12493 trans = btrfs_start_transaction(info->tree_root, 1);
12494 if (IS_ERR(trans)) {
12495 ret = PTR_ERR(trans);
12496 goto out;
12497 }
12498 }
12499
12500 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12501 0, trans ? 1 : 0);
12502 if (ret < 0)
12503 goto out;
12504 leaf = path.nodes[0];
12505
12506 while (1) {
12507 struct btrfs_key found_key;
12508
12509 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12510 int no_more_keys = find_next_key(&path, &key);
12511
12512 btrfs_release_path(&path);
12513 if (trans) {
12514 ret = btrfs_commit_transaction(trans,
12515 info->tree_root);
12516 trans = NULL;
12517 if (ret < 0)
12518 goto out;
12519 }
12520 need_trans = 0;
12521 if (no_more_keys)
12522 break;
12523 goto again;
12524 }
12525
12526 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12527
12528 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12529 goto next;
12530 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12531 goto next;
12532
12533 ret = maybe_repair_root_item(&path, &found_key, trans ? 0 : 1);
12534 if (ret < 0)
12535 goto out;
12536 if (ret) {
12537 if (!trans && repair) {
12538 need_trans = 1;
12539 key = found_key;
12540 btrfs_release_path(&path);
12541 goto again;
12542 }
12543 bad_roots++;
12544 }
12545 next:
12546 path.slots[0]++;
12547 }
12548 ret = 0;
12549 out:
12550 free_roots_info_cache();
12551 btrfs_release_path(&path);
12552 if (trans)
12553 btrfs_commit_transaction(trans, info->tree_root);
12554 if (ret < 0)
12555 return ret;
12556
12557 return bad_roots;
12558 }
12559
12560 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12561 {
12562 struct btrfs_trans_handle *trans;
12563 struct btrfs_block_group_cache *bg_cache;
12564 u64 current = 0;
12565 int ret = 0;
12566
12567 /* Clear all free space cache inodes and its extent data */
12568 while (1) {
12569 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12570 if (!bg_cache)
12571 break;
12572 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12573 if (ret < 0)
12574 return ret;
12575 current = bg_cache->key.objectid + bg_cache->key.offset;
12576 }
12577
12578 /* Don't forget to set cache_generation to -1 */
12579 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12580 if (IS_ERR(trans)) {
12581 error("failed to update super block cache generation");
12582 return PTR_ERR(trans);
12583 }
12584 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12585 btrfs_commit_transaction(trans, fs_info->tree_root);
12586
12587 return ret;
12588 }
12589
12590 const char * const cmd_check_usage[] = {
12591 "btrfs check [options] <device>",
12592 "Check structural integrity of a filesystem (unmounted).",
12593 "Check structural integrity of an unmounted filesystem. Verify internal",
12594 "trees' consistency and item connectivity. In the repair mode try to",
12595 "fix the problems found. ",
12596 "WARNING: the repair mode is considered dangerous",
12597 "",
12598 "-s|--super <superblock> use this superblock copy",
12599 "-b|--backup use the first valid backup root copy",
12600 "--repair try to repair the filesystem",
12601 "--readonly run in read-only mode (default)",
12602 "--init-csum-tree create a new CRC tree",
12603 "--init-extent-tree create a new extent tree",
12604 "--mode <MODE> allows choice of memory/IO trade-offs",
12605 " where MODE is one of:",
12606 " original - read inodes and extents to memory (requires",
12607 " more memory, does less IO)",
12608 " lowmem - try to use less memory but read blocks again",
12609 " when needed",
12610 "--check-data-csum verify checksums of data blocks",
12611 "-Q|--qgroup-report print a report on qgroup consistency",
12612 "-E|--subvol-extents <subvolid>",
12613 " print subvolume extents and sharing state",
12614 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12615 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12616 "-p|--progress indicate progress",
12617 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12618 NULL
12619 };
12620
12621 int cmd_check(int argc, char **argv)
12622 {
12623 struct cache_tree root_cache;
12624 struct btrfs_root *root;
12625 struct btrfs_fs_info *info;
12626 u64 bytenr = 0;
12627 u64 subvolid = 0;
12628 u64 tree_root_bytenr = 0;
12629 u64 chunk_root_bytenr = 0;
12630 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12631 int ret;
12632 int err = 0;
12633 u64 num;
12634 int init_csum_tree = 0;
12635 int readonly = 0;
12636 int clear_space_cache = 0;
12637 int qgroup_report = 0;
12638 int qgroups_repaired = 0;
12639 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12640
12641 while(1) {
12642 int c;
12643 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12644 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12645 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12646 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12647 static const struct option long_options[] = {
12648 { "super", required_argument, NULL, 's' },
12649 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12650 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12651 { "init-csum-tree", no_argument, NULL,
12652 GETOPT_VAL_INIT_CSUM },
12653 { "init-extent-tree", no_argument, NULL,
12654 GETOPT_VAL_INIT_EXTENT },
12655 { "check-data-csum", no_argument, NULL,
12656 GETOPT_VAL_CHECK_CSUM },
12657 { "backup", no_argument, NULL, 'b' },
12658 { "subvol-extents", required_argument, NULL, 'E' },
12659 { "qgroup-report", no_argument, NULL, 'Q' },
12660 { "tree-root", required_argument, NULL, 'r' },
12661 { "chunk-root", required_argument, NULL,
12662 GETOPT_VAL_CHUNK_TREE },
12663 { "progress", no_argument, NULL, 'p' },
12664 { "mode", required_argument, NULL,
12665 GETOPT_VAL_MODE },
12666 { "clear-space-cache", required_argument, NULL,
12667 GETOPT_VAL_CLEAR_SPACE_CACHE},
12668 { NULL, 0, NULL, 0}
12669 };
12670
12671 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
12672 if (c < 0)
12673 break;
12674 switch(c) {
12675 case 'a': /* ignored */ break;
12676 case 'b':
12677 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12678 break;
12679 case 's':
12680 num = arg_strtou64(optarg);
12681 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12682 error(
12683 "super mirror should be less than %d",
12684 BTRFS_SUPER_MIRROR_MAX);
12685 exit(1);
12686 }
12687 bytenr = btrfs_sb_offset(((int)num));
12688 printf("using SB copy %llu, bytenr %llu\n", num,
12689 (unsigned long long)bytenr);
12690 break;
12691 case 'Q':
12692 qgroup_report = 1;
12693 break;
12694 case 'E':
12695 subvolid = arg_strtou64(optarg);
12696 break;
12697 case 'r':
12698 tree_root_bytenr = arg_strtou64(optarg);
12699 break;
12700 case GETOPT_VAL_CHUNK_TREE:
12701 chunk_root_bytenr = arg_strtou64(optarg);
12702 break;
12703 case 'p':
12704 ctx.progress_enabled = true;
12705 break;
12706 case '?':
12707 case 'h':
12708 usage(cmd_check_usage);
12709 case GETOPT_VAL_REPAIR:
12710 printf("enabling repair mode\n");
12711 repair = 1;
12712 ctree_flags |= OPEN_CTREE_WRITES;
12713 break;
12714 case GETOPT_VAL_READONLY:
12715 readonly = 1;
12716 break;
12717 case GETOPT_VAL_INIT_CSUM:
12718 printf("Creating a new CRC tree\n");
12719 init_csum_tree = 1;
12720 repair = 1;
12721 ctree_flags |= OPEN_CTREE_WRITES;
12722 break;
12723 case GETOPT_VAL_INIT_EXTENT:
12724 init_extent_tree = 1;
12725 ctree_flags |= (OPEN_CTREE_WRITES |
12726 OPEN_CTREE_NO_BLOCK_GROUPS);
12727 repair = 1;
12728 break;
12729 case GETOPT_VAL_CHECK_CSUM:
12730 check_data_csum = 1;
12731 break;
12732 case GETOPT_VAL_MODE:
12733 check_mode = parse_check_mode(optarg);
12734 if (check_mode == CHECK_MODE_UNKNOWN) {
12735 error("unknown mode: %s", optarg);
12736 exit(1);
12737 }
12738 break;
12739 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12740 if (strcmp(optarg, "v1") == 0) {
12741 clear_space_cache = 1;
12742 } else if (strcmp(optarg, "v2") == 0) {
12743 clear_space_cache = 2;
12744 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12745 } else {
12746 error(
12747 "invalid argument to --clear-space-cache, must be v1 or v2");
12748 exit(1);
12749 }
12750 ctree_flags |= OPEN_CTREE_WRITES;
12751 break;
12752 }
12753 }
12754
12755 if (check_argc_exact(argc - optind, 1))
12756 usage(cmd_check_usage);
12757
12758 if (ctx.progress_enabled) {
12759 ctx.tp = TASK_NOTHING;
12760 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12761 }
12762
12763 /* This check is the only reason for --readonly to exist */
12764 if (readonly && repair) {
12765 error("repair options are not compatible with --readonly");
12766 exit(1);
12767 }
12768
12769 /*
12770 * Not supported yet
12771 */
12772 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12773 error("low memory mode doesn't support repair yet");
12774 exit(1);
12775 }
12776
12777 radix_tree_init();
12778 cache_tree_init(&root_cache);
12779
12780 if((ret = check_mounted(argv[optind])) < 0) {
12781 error("could not check mount status: %s", strerror(-ret));
12782 err |= !!ret;
12783 goto err_out;
12784 } else if(ret) {
12785 error("%s is currently mounted, aborting", argv[optind]);
12786 ret = -EBUSY;
12787 err |= !!ret;
12788 goto err_out;
12789 }
12790
12791 /* only allow partial opening under repair mode */
12792 if (repair)
12793 ctree_flags |= OPEN_CTREE_PARTIAL;
12794
12795 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12796 chunk_root_bytenr, ctree_flags);
12797 if (!info) {
12798 error("cannot open file system");
12799 ret = -EIO;
12800 err |= !!ret;
12801 goto err_out;
12802 }
12803
12804 global_info = info;
12805 root = info->fs_root;
12806 if (clear_space_cache == 1) {
12807 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12808 error(
12809 "free space cache v2 detected, use --clear-space-cache v2");
12810 ret = 1;
12811 goto close_out;
12812 }
12813 printf("Clearing free space cache\n");
12814 ret = clear_free_space_cache(info);
12815 if (ret) {
12816 error("failed to clear free space cache");
12817 ret = 1;
12818 } else {
12819 printf("Free space cache cleared\n");
12820 }
12821 goto close_out;
12822 } else if (clear_space_cache == 2) {
12823 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12824 printf("no free space cache v2 to clear\n");
12825 ret = 0;
12826 goto close_out;
12827 }
12828 printf("Clear free space cache v2\n");
12829 ret = btrfs_clear_free_space_tree(info);
12830 if (ret) {
12831 error("failed to clear free space cache v2: %d", ret);
12832 ret = 1;
12833 } else {
12834 printf("free space cache v2 cleared\n");
12835 }
12836 goto close_out;
12837 }
12838
12839 /*
12840 * repair mode will force us to commit transaction which
12841 * will make us fail to load log tree when mounting.
12842 */
12843 if (repair && btrfs_super_log_root(info->super_copy)) {
12844 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12845 if (!ret) {
12846 ret = 1;
12847 err |= !!ret;
12848 goto close_out;
12849 }
12850 ret = zero_log_tree(root);
12851 err |= !!ret;
12852 if (ret) {
12853 error("failed to zero log tree: %d", ret);
12854 goto close_out;
12855 }
12856 }
12857
12858 uuid_unparse(info->super_copy->fsid, uuidbuf);
12859 if (qgroup_report) {
12860 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12861 uuidbuf);
12862 ret = qgroup_verify_all(info);
12863 err |= !!ret;
12864 if (ret == 0)
12865 report_qgroups(1);
12866 goto close_out;
12867 }
12868 if (subvolid) {
12869 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12870 subvolid, argv[optind], uuidbuf);
12871 ret = print_extent_state(info, subvolid);
12872 err |= !!ret;
12873 goto close_out;
12874 }
12875 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12876
12877 if (!extent_buffer_uptodate(info->tree_root->node) ||
12878 !extent_buffer_uptodate(info->dev_root->node) ||
12879 !extent_buffer_uptodate(info->chunk_root->node)) {
12880 error("critical roots corrupted, unable to check the filesystem");
12881 err |= !!ret;
12882 ret = -EIO;
12883 goto close_out;
12884 }
12885
12886 if (init_extent_tree || init_csum_tree) {
12887 struct btrfs_trans_handle *trans;
12888
12889 trans = btrfs_start_transaction(info->extent_root, 0);
12890 if (IS_ERR(trans)) {
12891 error("error starting transaction");
12892 ret = PTR_ERR(trans);
12893 err |= !!ret;
12894 goto close_out;
12895 }
12896
12897 if (init_extent_tree) {
12898 printf("Creating a new extent tree\n");
12899 ret = reinit_extent_tree(trans, info);
12900 err |= !!ret;
12901 if (ret)
12902 goto close_out;
12903 }
12904
12905 if (init_csum_tree) {
12906 printf("Reinitialize checksum tree\n");
12907 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
12908 if (ret) {
12909 error("checksum tree initialization failed: %d",
12910 ret);
12911 ret = -EIO;
12912 err |= !!ret;
12913 goto close_out;
12914 }
12915
12916 ret = fill_csum_tree(trans, info->csum_root,
12917 init_extent_tree);
12918 err |= !!ret;
12919 if (ret) {
12920 error("checksum tree refilling failed: %d", ret);
12921 return -EIO;
12922 }
12923 }
12924 /*
12925 * Ok now we commit and run the normal fsck, which will add
12926 * extent entries for all of the items it finds.
12927 */
12928 ret = btrfs_commit_transaction(trans, info->extent_root);
12929 err |= !!ret;
12930 if (ret)
12931 goto close_out;
12932 }
12933 if (!extent_buffer_uptodate(info->extent_root->node)) {
12934 error("critical: extent_root, unable to check the filesystem");
12935 ret = -EIO;
12936 err |= !!ret;
12937 goto close_out;
12938 }
12939 if (!extent_buffer_uptodate(info->csum_root->node)) {
12940 error("critical: csum_root, unable to check the filesystem");
12941 ret = -EIO;
12942 err |= !!ret;
12943 goto close_out;
12944 }
12945
12946 if (!ctx.progress_enabled)
12947 fprintf(stderr, "checking extents\n");
12948 if (check_mode == CHECK_MODE_LOWMEM)
12949 ret = check_chunks_and_extents_v2(root);
12950 else
12951 ret = check_chunks_and_extents(root);
12952 err |= !!ret;
12953 if (ret)
12954 error(
12955 "errors found in extent allocation tree or chunk allocation");
12956
12957 ret = repair_root_items(info);
12958 err |= !!ret;
12959 if (ret < 0) {
12960 error("failed to repair root items: %s", strerror(-ret));
12961 goto close_out;
12962 }
12963 if (repair) {
12964 fprintf(stderr, "Fixed %d roots.\n", ret);
12965 ret = 0;
12966 } else if (ret > 0) {
12967 fprintf(stderr,
12968 "Found %d roots with an outdated root item.\n",
12969 ret);
12970 fprintf(stderr,
12971 "Please run a filesystem check with the option --repair to fix them.\n");
12972 ret = 1;
12973 err |= !!ret;
12974 goto close_out;
12975 }
12976
12977 if (!ctx.progress_enabled) {
12978 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12979 fprintf(stderr, "checking free space tree\n");
12980 else
12981 fprintf(stderr, "checking free space cache\n");
12982 }
12983 ret = check_space_cache(root);
12984 err |= !!ret;
12985 if (ret) {
12986 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12987 error("errors found in free space tree");
12988 else
12989 error("errors found in free space cache");
12990 goto out;
12991 }
12992
12993 /*
12994 * We used to have to have these hole extents in between our real
12995 * extents so if we don't have this flag set we need to make sure there
12996 * are no gaps in the file extents for inodes, otherwise we can just
12997 * ignore it when this happens.
12998 */
12999 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
13000 if (!ctx.progress_enabled)
13001 fprintf(stderr, "checking fs roots\n");
13002 if (check_mode == CHECK_MODE_LOWMEM)
13003 ret = check_fs_roots_v2(root->fs_info);
13004 else
13005 ret = check_fs_roots(root, &root_cache);
13006 err |= !!ret;
13007 if (ret) {
13008 error("errors found in fs roots");
13009 goto out;
13010 }
13011
13012 fprintf(stderr, "checking csums\n");
13013 ret = check_csums(root);
13014 err |= !!ret;
13015 if (ret) {
13016 error("errors found in csum tree");
13017 goto out;
13018 }
13019
13020 fprintf(stderr, "checking root refs\n");
13021 /* For low memory mode, check_fs_roots_v2 handles root refs */
13022 if (check_mode != CHECK_MODE_LOWMEM) {
13023 ret = check_root_refs(root, &root_cache);
13024 err |= !!ret;
13025 if (ret) {
13026 error("errors found in root refs");
13027 goto out;
13028 }
13029 }
13030
13031 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
13032 struct extent_buffer *eb;
13033
13034 eb = list_first_entry(&root->fs_info->recow_ebs,
13035 struct extent_buffer, recow);
13036 list_del_init(&eb->recow);
13037 ret = recow_extent_buffer(root, eb);
13038 err |= !!ret;
13039 if (ret) {
13040 error("fails to fix transid errors");
13041 break;
13042 }
13043 }
13044
13045 while (!list_empty(&delete_items)) {
13046 struct bad_item *bad;
13047
13048 bad = list_first_entry(&delete_items, struct bad_item, list);
13049 list_del_init(&bad->list);
13050 if (repair) {
13051 ret = delete_bad_item(root, bad);
13052 err |= !!ret;
13053 }
13054 free(bad);
13055 }
13056
13057 if (info->quota_enabled) {
13058 fprintf(stderr, "checking quota groups\n");
13059 ret = qgroup_verify_all(info);
13060 err |= !!ret;
13061 if (ret) {
13062 error("failed to check quota groups");
13063 goto out;
13064 }
13065 report_qgroups(0);
13066 ret = repair_qgroups(info, &qgroups_repaired);
13067 err |= !!ret;
13068 if (err) {
13069 error("failed to repair quota groups");
13070 goto out;
13071 }
13072 ret = 0;
13073 }
13074
13075 if (!list_empty(&root->fs_info->recow_ebs)) {
13076 error("transid errors in file system");
13077 ret = 1;
13078 err |= !!ret;
13079 }
13080 out:
13081 if (found_old_backref) { /*
13082 * there was a disk format change when mixed
13083 * backref was in testing tree. The old format
13084 * existed about one week.
13085 */
13086 printf("\n * Found old mixed backref format. "
13087 "The old format is not supported! *"
13088 "\n * Please mount the FS in readonly mode, "
13089 "backup data and re-format the FS. *\n\n");
13090 err |= 1;
13091 }
13092 printf("found %llu bytes used, ",
13093 (unsigned long long)bytes_used);
13094 if (err)
13095 printf("error(s) found\n");
13096 else
13097 printf("no error found\n");
13098 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
13099 printf("total tree bytes: %llu\n",
13100 (unsigned long long)total_btree_bytes);
13101 printf("total fs tree bytes: %llu\n",
13102 (unsigned long long)total_fs_tree_bytes);
13103 printf("total extent tree bytes: %llu\n",
13104 (unsigned long long)total_extent_tree_bytes);
13105 printf("btree space waste bytes: %llu\n",
13106 (unsigned long long)btree_space_waste);
13107 printf("file data blocks allocated: %llu\n referenced %llu\n",
13108 (unsigned long long)data_bytes_allocated,
13109 (unsigned long long)data_bytes_referenced);
13110
13111 free_qgroup_counts();
13112 free_root_recs_tree(&root_cache);
13113 close_out:
13114 close_ctree(root);
13115 err_out:
13116 if (ctx.progress_enabled)
13117 task_deinit(ctx.info);
13118
13119 return err;
13120 }
(deprecated) Btrfs progs developments and patch integration