2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
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.
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.
23 #include <sys/types.h>
27 #include <uuid/uuid.h>
32 #include "print-tree.h"
33 #include "task-utils.h"
34 #include "transaction.h"
37 #include "free-space-cache.h"
38 #include "free-space-tree.h"
40 #include "qgroup-verify.h"
41 #include "rbtree-utils.h"
50 TASK_NOTHING, /* have to be the last element */
55 enum task_position tp;
57 struct task_info *info;
60 static u64 bytes_used = 0;
61 static u64 total_csum_bytes = 0;
62 static u64 total_btree_bytes = 0;
63 static u64 total_fs_tree_bytes = 0;
64 static u64 total_extent_tree_bytes = 0;
65 static u64 btree_space_waste = 0;
66 static u64 data_bytes_allocated = 0;
67 static u64 data_bytes_referenced = 0;
68 static int found_old_backref = 0;
69 static LIST_HEAD(duplicate_extents);
70 static LIST_HEAD(delete_items);
71 static int no_holes = 0;
72 static int init_extent_tree = 0;
73 static int check_data_csum = 0;
74 static struct btrfs_fs_info *global_info;
75 static struct task_ctx ctx = { 0 };
76 static struct cache_tree *roots_info_cache = NULL;
78 enum btrfs_check_mode {
82 CHECK_MODE_DEFAULT = CHECK_MODE_ORIGINAL
85 static enum btrfs_check_mode check_mode = CHECK_MODE_DEFAULT;
87 struct extent_backref {
88 struct list_head list;
89 unsigned int is_data:1;
90 unsigned int found_extent_tree:1;
91 unsigned int full_backref:1;
92 unsigned int found_ref:1;
93 unsigned int broken:1;
96 static inline struct extent_backref* to_extent_backref(struct list_head *entry)
98 return list_entry(entry, struct extent_backref, list);
101 struct data_backref {
102 struct extent_backref node;
116 #define ROOT_DIR_ERROR (1<<1) /* bad ROOT_DIR */
117 #define DIR_ITEM_MISSING (1<<2) /* DIR_ITEM not found */
118 #define DIR_ITEM_MISMATCH (1<<3) /* DIR_ITEM found but not match */
119 #define INODE_REF_MISSING (1<<4) /* INODE_REF/INODE_EXTREF not found */
120 #define INODE_ITEM_MISSING (1<<5) /* INODE_ITEM not found */
121 #define INODE_ITEM_MISMATCH (1<<6) /* INODE_ITEM found but not match */
122 #define FILE_EXTENT_ERROR (1<<7) /* bad FILE_EXTENT */
123 #define ODD_CSUM_ITEM (1<<8) /* CSUM_ITEM error */
124 #define CSUM_ITEM_MISSING (1<<9) /* CSUM_ITEM not found */
125 #define LINK_COUNT_ERROR (1<<10) /* INODE_ITEM nlink count error */
126 #define NBYTES_ERROR (1<<11) /* INODE_ITEM nbytes count error */
127 #define ISIZE_ERROR (1<<12) /* INODE_ITEM size count error */
128 #define ORPHAN_ITEM (1<<13) /* INODE_ITEM no reference */
129 #define NO_INODE_ITEM (1<<14) /* no inode_item */
130 #define LAST_ITEM (1<<15) /* Complete this tree traversal */
131 #define ROOT_REF_MISSING (1<<16) /* ROOT_REF not found */
132 #define ROOT_REF_MISMATCH (1<<17) /* ROOT_REF found but not match */
134 static inline struct data_backref* to_data_backref(struct extent_backref *back)
136 return container_of(back, struct data_backref, node);
140 * Much like data_backref, just removed the undetermined members
141 * and change it to use list_head.
142 * During extent scan, it is stored in root->orphan_data_extent.
143 * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
145 struct orphan_data_extent {
146 struct list_head list;
154 struct tree_backref {
155 struct extent_backref node;
162 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
164 return container_of(back, struct tree_backref, node);
167 /* Explicit initialization for extent_record::flag_block_full_backref */
168 enum { FLAG_UNSET = 2 };
170 struct extent_record {
171 struct list_head backrefs;
172 struct list_head dups;
173 struct list_head list;
174 struct cache_extent cache;
175 struct btrfs_disk_key parent_key;
180 u64 extent_item_refs;
182 u64 parent_generation;
186 unsigned int flag_block_full_backref:2;
187 unsigned int found_rec:1;
188 unsigned int content_checked:1;
189 unsigned int owner_ref_checked:1;
190 unsigned int is_root:1;
191 unsigned int metadata:1;
192 unsigned int bad_full_backref:1;
193 unsigned int crossing_stripes:1;
194 unsigned int wrong_chunk_type:1;
197 static inline struct extent_record* to_extent_record(struct list_head *entry)
199 return container_of(entry, struct extent_record, list);
202 struct inode_backref {
203 struct list_head list;
204 unsigned int found_dir_item:1;
205 unsigned int found_dir_index:1;
206 unsigned int found_inode_ref:1;
216 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
218 return list_entry(entry, struct inode_backref, list);
221 struct root_item_record {
222 struct list_head list;
229 struct btrfs_key drop_key;
232 #define REF_ERR_NO_DIR_ITEM (1 << 0)
233 #define REF_ERR_NO_DIR_INDEX (1 << 1)
234 #define REF_ERR_NO_INODE_REF (1 << 2)
235 #define REF_ERR_DUP_DIR_ITEM (1 << 3)
236 #define REF_ERR_DUP_DIR_INDEX (1 << 4)
237 #define REF_ERR_DUP_INODE_REF (1 << 5)
238 #define REF_ERR_INDEX_UNMATCH (1 << 6)
239 #define REF_ERR_FILETYPE_UNMATCH (1 << 7)
240 #define REF_ERR_NAME_TOO_LONG (1 << 8) // 100
241 #define REF_ERR_NO_ROOT_REF (1 << 9)
242 #define REF_ERR_NO_ROOT_BACKREF (1 << 10)
243 #define REF_ERR_DUP_ROOT_REF (1 << 11)
244 #define REF_ERR_DUP_ROOT_BACKREF (1 << 12)
246 struct file_extent_hole {
252 struct inode_record {
253 struct list_head backrefs;
254 unsigned int checked:1;
255 unsigned int merging:1;
256 unsigned int found_inode_item:1;
257 unsigned int found_dir_item:1;
258 unsigned int found_file_extent:1;
259 unsigned int found_csum_item:1;
260 unsigned int some_csum_missing:1;
261 unsigned int nodatasum:1;
274 struct rb_root holes;
275 struct list_head orphan_extents;
280 #define I_ERR_NO_INODE_ITEM (1 << 0)
281 #define I_ERR_NO_ORPHAN_ITEM (1 << 1)
282 #define I_ERR_DUP_INODE_ITEM (1 << 2)
283 #define I_ERR_DUP_DIR_INDEX (1 << 3)
284 #define I_ERR_ODD_DIR_ITEM (1 << 4)
285 #define I_ERR_ODD_FILE_EXTENT (1 << 5)
286 #define I_ERR_BAD_FILE_EXTENT (1 << 6)
287 #define I_ERR_FILE_EXTENT_OVERLAP (1 << 7)
288 #define I_ERR_FILE_EXTENT_DISCOUNT (1 << 8) // 100
289 #define I_ERR_DIR_ISIZE_WRONG (1 << 9)
290 #define I_ERR_FILE_NBYTES_WRONG (1 << 10) // 400
291 #define I_ERR_ODD_CSUM_ITEM (1 << 11)
292 #define I_ERR_SOME_CSUM_MISSING (1 << 12)
293 #define I_ERR_LINK_COUNT_WRONG (1 << 13)
294 #define I_ERR_FILE_EXTENT_ORPHAN (1 << 14)
296 struct root_backref {
297 struct list_head list;
298 unsigned int found_dir_item:1;
299 unsigned int found_dir_index:1;
300 unsigned int found_back_ref:1;
301 unsigned int found_forward_ref:1;
302 unsigned int reachable:1;
311 static inline struct root_backref* to_root_backref(struct list_head *entry)
313 return list_entry(entry, struct root_backref, list);
317 struct list_head backrefs;
318 struct cache_extent cache;
319 unsigned int found_root_item:1;
325 struct cache_extent cache;
330 struct cache_extent cache;
331 struct cache_tree root_cache;
332 struct cache_tree inode_cache;
333 struct inode_record *current;
342 struct walk_control {
343 struct cache_tree shared;
344 struct shared_node *nodes[BTRFS_MAX_LEVEL];
350 struct btrfs_key key;
352 struct list_head list;
355 struct extent_entry {
360 struct list_head list;
363 struct root_item_info {
364 /* level of the root */
366 /* number of nodes at this level, must be 1 for a root */
370 struct cache_extent cache_extent;
374 * Error bit for low memory mode check.
376 * Currently no caller cares about it yet. Just internal use for error
379 #define BACKREF_MISSING (1 << 0) /* Backref missing in extent tree */
380 #define BACKREF_MISMATCH (1 << 1) /* Backref exists but does not match */
381 #define BYTES_UNALIGNED (1 << 2) /* Some bytes are not aligned */
382 #define REFERENCER_MISSING (1 << 3) /* Referencer not found */
383 #define REFERENCER_MISMATCH (1 << 4) /* Referenceer found but does not match */
384 #define CROSSING_STRIPE_BOUNDARY (1 << 4) /* For kernel scrub workaround */
385 #define ITEM_SIZE_MISMATCH (1 << 5) /* Bad item size */
386 #define UNKNOWN_TYPE (1 << 6) /* Unknown type */
387 #define ACCOUNTING_MISMATCH (1 << 7) /* Used space accounting error */
388 #define CHUNK_TYPE_MISMATCH (1 << 8)
390 static void *print_status_check(void *p)
392 struct task_ctx *priv = p;
393 const char work_indicator[] = { '.', 'o', 'O', 'o' };
395 static char *task_position_string[] = {
397 "checking free space cache",
401 task_period_start(priv->info, 1000 /* 1s */);
403 if (priv->tp == TASK_NOTHING)
407 printf("%s [%c]\r", task_position_string[priv->tp],
408 work_indicator[count % 4]);
411 task_period_wait(priv->info);
416 static int print_status_return(void *p)
424 static enum btrfs_check_mode parse_check_mode(const char *str)
426 if (strcmp(str, "lowmem") == 0)
427 return CHECK_MODE_LOWMEM;
428 if (strcmp(str, "orig") == 0)
429 return CHECK_MODE_ORIGINAL;
430 if (strcmp(str, "original") == 0)
431 return CHECK_MODE_ORIGINAL;
433 return CHECK_MODE_UNKNOWN;
436 /* Compatible function to allow reuse of old codes */
437 static u64 first_extent_gap(struct rb_root *holes)
439 struct file_extent_hole *hole;
441 if (RB_EMPTY_ROOT(holes))
444 hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
448 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
450 struct file_extent_hole *hole1;
451 struct file_extent_hole *hole2;
453 hole1 = rb_entry(node1, struct file_extent_hole, node);
454 hole2 = rb_entry(node2, struct file_extent_hole, node);
456 if (hole1->start > hole2->start)
458 if (hole1->start < hole2->start)
460 /* Now hole1->start == hole2->start */
461 if (hole1->len >= hole2->len)
463 * Hole 1 will be merge center
464 * Same hole will be merged later
467 /* Hole 2 will be merge center */
472 * Add a hole to the record
474 * This will do hole merge for copy_file_extent_holes(),
475 * which will ensure there won't be continuous holes.
477 static int add_file_extent_hole(struct rb_root *holes,
480 struct file_extent_hole *hole;
481 struct file_extent_hole *prev = NULL;
482 struct file_extent_hole *next = NULL;
484 hole = malloc(sizeof(*hole));
489 /* Since compare will not return 0, no -EEXIST will happen */
490 rb_insert(holes, &hole->node, compare_hole);
492 /* simple merge with previous hole */
493 if (rb_prev(&hole->node))
494 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
496 if (prev && prev->start + prev->len >= hole->start) {
497 hole->len = hole->start + hole->len - prev->start;
498 hole->start = prev->start;
499 rb_erase(&prev->node, holes);
504 /* iterate merge with next holes */
506 if (!rb_next(&hole->node))
508 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
510 if (hole->start + hole->len >= next->start) {
511 if (hole->start + hole->len <= next->start + next->len)
512 hole->len = next->start + next->len -
514 rb_erase(&next->node, holes);
523 static int compare_hole_range(struct rb_node *node, void *data)
525 struct file_extent_hole *hole;
528 hole = (struct file_extent_hole *)data;
531 hole = rb_entry(node, struct file_extent_hole, node);
532 if (start < hole->start)
534 if (start >= hole->start && start < hole->start + hole->len)
540 * Delete a hole in the record
542 * This will do the hole split and is much restrict than add.
544 static int del_file_extent_hole(struct rb_root *holes,
547 struct file_extent_hole *hole;
548 struct file_extent_hole tmp;
553 struct rb_node *node;
560 node = rb_search(holes, &tmp, compare_hole_range, NULL);
563 hole = rb_entry(node, struct file_extent_hole, node);
564 if (start + len > hole->start + hole->len)
568 * Now there will be no overlap, delete the hole and re-add the
569 * split(s) if they exists.
571 if (start > hole->start) {
572 prev_start = hole->start;
573 prev_len = start - hole->start;
576 if (hole->start + hole->len > start + len) {
577 next_start = start + len;
578 next_len = hole->start + hole->len - start - len;
581 rb_erase(node, holes);
584 ret = add_file_extent_hole(holes, prev_start, prev_len);
589 ret = add_file_extent_hole(holes, next_start, next_len);
596 static int copy_file_extent_holes(struct rb_root *dst,
599 struct file_extent_hole *hole;
600 struct rb_node *node;
603 node = rb_first(src);
605 hole = rb_entry(node, struct file_extent_hole, node);
606 ret = add_file_extent_hole(dst, hole->start, hole->len);
609 node = rb_next(node);
614 static void free_file_extent_holes(struct rb_root *holes)
616 struct rb_node *node;
617 struct file_extent_hole *hole;
619 node = rb_first(holes);
621 hole = rb_entry(node, struct file_extent_hole, node);
622 rb_erase(node, holes);
624 node = rb_first(holes);
628 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
630 static void record_root_in_trans(struct btrfs_trans_handle *trans,
631 struct btrfs_root *root)
633 if (root->last_trans != trans->transid) {
634 root->track_dirty = 1;
635 root->last_trans = trans->transid;
636 root->commit_root = root->node;
637 extent_buffer_get(root->node);
641 static u8 imode_to_type(u32 imode)
644 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
645 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
646 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
647 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
648 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
649 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
650 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
651 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
654 return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
658 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
660 struct device_record *rec1;
661 struct device_record *rec2;
663 rec1 = rb_entry(node1, struct device_record, node);
664 rec2 = rb_entry(node2, struct device_record, node);
665 if (rec1->devid > rec2->devid)
667 else if (rec1->devid < rec2->devid)
673 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
675 struct inode_record *rec;
676 struct inode_backref *backref;
677 struct inode_backref *orig;
678 struct inode_backref *tmp;
679 struct orphan_data_extent *src_orphan;
680 struct orphan_data_extent *dst_orphan;
685 rec = malloc(sizeof(*rec));
687 return ERR_PTR(-ENOMEM);
688 memcpy(rec, orig_rec, sizeof(*rec));
690 INIT_LIST_HEAD(&rec->backrefs);
691 INIT_LIST_HEAD(&rec->orphan_extents);
692 rec->holes = RB_ROOT;
694 list_for_each_entry(orig, &orig_rec->backrefs, list) {
695 size = sizeof(*orig) + orig->namelen + 1;
696 backref = malloc(size);
701 memcpy(backref, orig, size);
702 list_add_tail(&backref->list, &rec->backrefs);
704 list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
705 dst_orphan = malloc(sizeof(*dst_orphan));
710 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
711 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
713 ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
720 rb = rb_first(&rec->holes);
722 struct file_extent_hole *hole;
724 hole = rb_entry(rb, struct file_extent_hole, node);
730 if (!list_empty(&rec->backrefs))
731 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
732 list_del(&orig->list);
736 if (!list_empty(&rec->orphan_extents))
737 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
738 list_del(&orig->list);
747 static void print_orphan_data_extents(struct list_head *orphan_extents,
750 struct orphan_data_extent *orphan;
752 if (list_empty(orphan_extents))
754 printf("The following data extent is lost in tree %llu:\n",
756 list_for_each_entry(orphan, orphan_extents, list) {
757 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
758 orphan->objectid, orphan->offset, orphan->disk_bytenr,
763 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
765 u64 root_objectid = root->root_key.objectid;
766 int errors = rec->errors;
770 /* reloc root errors, we print its corresponding fs root objectid*/
771 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
772 root_objectid = root->root_key.offset;
773 fprintf(stderr, "reloc");
775 fprintf(stderr, "root %llu inode %llu errors %x",
776 (unsigned long long) root_objectid,
777 (unsigned long long) rec->ino, rec->errors);
779 if (errors & I_ERR_NO_INODE_ITEM)
780 fprintf(stderr, ", no inode item");
781 if (errors & I_ERR_NO_ORPHAN_ITEM)
782 fprintf(stderr, ", no orphan item");
783 if (errors & I_ERR_DUP_INODE_ITEM)
784 fprintf(stderr, ", dup inode item");
785 if (errors & I_ERR_DUP_DIR_INDEX)
786 fprintf(stderr, ", dup dir index");
787 if (errors & I_ERR_ODD_DIR_ITEM)
788 fprintf(stderr, ", odd dir item");
789 if (errors & I_ERR_ODD_FILE_EXTENT)
790 fprintf(stderr, ", odd file extent");
791 if (errors & I_ERR_BAD_FILE_EXTENT)
792 fprintf(stderr, ", bad file extent");
793 if (errors & I_ERR_FILE_EXTENT_OVERLAP)
794 fprintf(stderr, ", file extent overlap");
795 if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
796 fprintf(stderr, ", file extent discount");
797 if (errors & I_ERR_DIR_ISIZE_WRONG)
798 fprintf(stderr, ", dir isize wrong");
799 if (errors & I_ERR_FILE_NBYTES_WRONG)
800 fprintf(stderr, ", nbytes wrong");
801 if (errors & I_ERR_ODD_CSUM_ITEM)
802 fprintf(stderr, ", odd csum item");
803 if (errors & I_ERR_SOME_CSUM_MISSING)
804 fprintf(stderr, ", some csum missing");
805 if (errors & I_ERR_LINK_COUNT_WRONG)
806 fprintf(stderr, ", link count wrong");
807 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
808 fprintf(stderr, ", orphan file extent");
809 fprintf(stderr, "\n");
810 /* Print the orphan extents if needed */
811 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
812 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
814 /* Print the holes if needed */
815 if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
816 struct file_extent_hole *hole;
817 struct rb_node *node;
820 node = rb_first(&rec->holes);
821 fprintf(stderr, "Found file extent holes:\n");
824 hole = rb_entry(node, struct file_extent_hole, node);
825 fprintf(stderr, "\tstart: %llu, len: %llu\n",
826 hole->start, hole->len);
827 node = rb_next(node);
830 fprintf(stderr, "\tstart: 0, len: %llu\n",
831 round_up(rec->isize, root->sectorsize));
835 static void print_ref_error(int errors)
837 if (errors & REF_ERR_NO_DIR_ITEM)
838 fprintf(stderr, ", no dir item");
839 if (errors & REF_ERR_NO_DIR_INDEX)
840 fprintf(stderr, ", no dir index");
841 if (errors & REF_ERR_NO_INODE_REF)
842 fprintf(stderr, ", no inode ref");
843 if (errors & REF_ERR_DUP_DIR_ITEM)
844 fprintf(stderr, ", dup dir item");
845 if (errors & REF_ERR_DUP_DIR_INDEX)
846 fprintf(stderr, ", dup dir index");
847 if (errors & REF_ERR_DUP_INODE_REF)
848 fprintf(stderr, ", dup inode ref");
849 if (errors & REF_ERR_INDEX_UNMATCH)
850 fprintf(stderr, ", index mismatch");
851 if (errors & REF_ERR_FILETYPE_UNMATCH)
852 fprintf(stderr, ", filetype mismatch");
853 if (errors & REF_ERR_NAME_TOO_LONG)
854 fprintf(stderr, ", name too long");
855 if (errors & REF_ERR_NO_ROOT_REF)
856 fprintf(stderr, ", no root ref");
857 if (errors & REF_ERR_NO_ROOT_BACKREF)
858 fprintf(stderr, ", no root backref");
859 if (errors & REF_ERR_DUP_ROOT_REF)
860 fprintf(stderr, ", dup root ref");
861 if (errors & REF_ERR_DUP_ROOT_BACKREF)
862 fprintf(stderr, ", dup root backref");
863 fprintf(stderr, "\n");
866 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
869 struct ptr_node *node;
870 struct cache_extent *cache;
871 struct inode_record *rec = NULL;
874 cache = lookup_cache_extent(inode_cache, ino, 1);
876 node = container_of(cache, struct ptr_node, cache);
878 if (mod && rec->refs > 1) {
879 node->data = clone_inode_rec(rec);
880 if (IS_ERR(node->data))
886 rec = calloc(1, sizeof(*rec));
888 return ERR_PTR(-ENOMEM);
890 rec->extent_start = (u64)-1;
892 INIT_LIST_HEAD(&rec->backrefs);
893 INIT_LIST_HEAD(&rec->orphan_extents);
894 rec->holes = RB_ROOT;
896 node = malloc(sizeof(*node));
899 return ERR_PTR(-ENOMEM);
901 node->cache.start = ino;
902 node->cache.size = 1;
905 if (ino == BTRFS_FREE_INO_OBJECTID)
908 ret = insert_cache_extent(inode_cache, &node->cache);
910 return ERR_PTR(-EEXIST);
915 static void free_orphan_data_extents(struct list_head *orphan_extents)
917 struct orphan_data_extent *orphan;
919 while (!list_empty(orphan_extents)) {
920 orphan = list_entry(orphan_extents->next,
921 struct orphan_data_extent, list);
922 list_del(&orphan->list);
927 static void free_inode_rec(struct inode_record *rec)
929 struct inode_backref *backref;
934 while (!list_empty(&rec->backrefs)) {
935 backref = to_inode_backref(rec->backrefs.next);
936 list_del(&backref->list);
939 free_orphan_data_extents(&rec->orphan_extents);
940 free_file_extent_holes(&rec->holes);
944 static int can_free_inode_rec(struct inode_record *rec)
946 if (!rec->errors && rec->checked && rec->found_inode_item &&
947 rec->nlink == rec->found_link && list_empty(&rec->backrefs))
952 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
953 struct inode_record *rec)
955 struct cache_extent *cache;
956 struct inode_backref *tmp, *backref;
957 struct ptr_node *node;
960 if (!rec->found_inode_item)
963 filetype = imode_to_type(rec->imode);
964 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
965 if (backref->found_dir_item && backref->found_dir_index) {
966 if (backref->filetype != filetype)
967 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
968 if (!backref->errors && backref->found_inode_ref &&
969 rec->nlink == rec->found_link) {
970 list_del(&backref->list);
976 if (!rec->checked || rec->merging)
979 if (S_ISDIR(rec->imode)) {
980 if (rec->found_size != rec->isize)
981 rec->errors |= I_ERR_DIR_ISIZE_WRONG;
982 if (rec->found_file_extent)
983 rec->errors |= I_ERR_ODD_FILE_EXTENT;
984 } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
985 if (rec->found_dir_item)
986 rec->errors |= I_ERR_ODD_DIR_ITEM;
987 if (rec->found_size != rec->nbytes)
988 rec->errors |= I_ERR_FILE_NBYTES_WRONG;
989 if (rec->nlink > 0 && !no_holes &&
990 (rec->extent_end < rec->isize ||
991 first_extent_gap(&rec->holes) < rec->isize))
992 rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
995 if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
996 if (rec->found_csum_item && rec->nodatasum)
997 rec->errors |= I_ERR_ODD_CSUM_ITEM;
998 if (rec->some_csum_missing && !rec->nodatasum)
999 rec->errors |= I_ERR_SOME_CSUM_MISSING;
1002 BUG_ON(rec->refs != 1);
1003 if (can_free_inode_rec(rec)) {
1004 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
1005 node = container_of(cache, struct ptr_node, cache);
1006 BUG_ON(node->data != rec);
1007 remove_cache_extent(inode_cache, &node->cache);
1009 free_inode_rec(rec);
1013 static int check_orphan_item(struct btrfs_root *root, u64 ino)
1015 struct btrfs_path path;
1016 struct btrfs_key key;
1019 key.objectid = BTRFS_ORPHAN_OBJECTID;
1020 key.type = BTRFS_ORPHAN_ITEM_KEY;
1023 btrfs_init_path(&path);
1024 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1025 btrfs_release_path(&path);
1031 static int process_inode_item(struct extent_buffer *eb,
1032 int slot, struct btrfs_key *key,
1033 struct shared_node *active_node)
1035 struct inode_record *rec;
1036 struct btrfs_inode_item *item;
1038 rec = active_node->current;
1039 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1040 if (rec->found_inode_item) {
1041 rec->errors |= I_ERR_DUP_INODE_ITEM;
1044 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
1045 rec->nlink = btrfs_inode_nlink(eb, item);
1046 rec->isize = btrfs_inode_size(eb, item);
1047 rec->nbytes = btrfs_inode_nbytes(eb, item);
1048 rec->imode = btrfs_inode_mode(eb, item);
1049 if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
1051 rec->found_inode_item = 1;
1052 if (rec->nlink == 0)
1053 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
1054 maybe_free_inode_rec(&active_node->inode_cache, rec);
1058 static struct inode_backref *get_inode_backref(struct inode_record *rec,
1060 int namelen, u64 dir)
1062 struct inode_backref *backref;
1064 list_for_each_entry(backref, &rec->backrefs, list) {
1065 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
1067 if (backref->dir != dir || backref->namelen != namelen)
1069 if (memcmp(name, backref->name, namelen))
1074 backref = malloc(sizeof(*backref) + namelen + 1);
1077 memset(backref, 0, sizeof(*backref));
1079 backref->namelen = namelen;
1080 memcpy(backref->name, name, namelen);
1081 backref->name[namelen] = '\0';
1082 list_add_tail(&backref->list, &rec->backrefs);
1086 static int add_inode_backref(struct cache_tree *inode_cache,
1087 u64 ino, u64 dir, u64 index,
1088 const char *name, int namelen,
1089 u8 filetype, u8 itemtype, int errors)
1091 struct inode_record *rec;
1092 struct inode_backref *backref;
1094 rec = get_inode_rec(inode_cache, ino, 1);
1095 BUG_ON(IS_ERR(rec));
1096 backref = get_inode_backref(rec, name, namelen, dir);
1099 backref->errors |= errors;
1100 if (itemtype == BTRFS_DIR_INDEX_KEY) {
1101 if (backref->found_dir_index)
1102 backref->errors |= REF_ERR_DUP_DIR_INDEX;
1103 if (backref->found_inode_ref && backref->index != index)
1104 backref->errors |= REF_ERR_INDEX_UNMATCH;
1105 if (backref->found_dir_item && backref->filetype != filetype)
1106 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1108 backref->index = index;
1109 backref->filetype = filetype;
1110 backref->found_dir_index = 1;
1111 } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1113 if (backref->found_dir_item)
1114 backref->errors |= REF_ERR_DUP_DIR_ITEM;
1115 if (backref->found_dir_index && backref->filetype != filetype)
1116 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1118 backref->filetype = filetype;
1119 backref->found_dir_item = 1;
1120 } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1121 (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1122 if (backref->found_inode_ref)
1123 backref->errors |= REF_ERR_DUP_INODE_REF;
1124 if (backref->found_dir_index && backref->index != index)
1125 backref->errors |= REF_ERR_INDEX_UNMATCH;
1127 backref->index = index;
1129 backref->ref_type = itemtype;
1130 backref->found_inode_ref = 1;
1135 maybe_free_inode_rec(inode_cache, rec);
1139 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1140 struct cache_tree *dst_cache)
1142 struct inode_backref *backref;
1147 list_for_each_entry(backref, &src->backrefs, list) {
1148 if (backref->found_dir_index) {
1149 add_inode_backref(dst_cache, dst->ino, backref->dir,
1150 backref->index, backref->name,
1151 backref->namelen, backref->filetype,
1152 BTRFS_DIR_INDEX_KEY, backref->errors);
1154 if (backref->found_dir_item) {
1156 add_inode_backref(dst_cache, dst->ino,
1157 backref->dir, 0, backref->name,
1158 backref->namelen, backref->filetype,
1159 BTRFS_DIR_ITEM_KEY, backref->errors);
1161 if (backref->found_inode_ref) {
1162 add_inode_backref(dst_cache, dst->ino,
1163 backref->dir, backref->index,
1164 backref->name, backref->namelen, 0,
1165 backref->ref_type, backref->errors);
1169 if (src->found_dir_item)
1170 dst->found_dir_item = 1;
1171 if (src->found_file_extent)
1172 dst->found_file_extent = 1;
1173 if (src->found_csum_item)
1174 dst->found_csum_item = 1;
1175 if (src->some_csum_missing)
1176 dst->some_csum_missing = 1;
1177 if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1178 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1183 BUG_ON(src->found_link < dir_count);
1184 dst->found_link += src->found_link - dir_count;
1185 dst->found_size += src->found_size;
1186 if (src->extent_start != (u64)-1) {
1187 if (dst->extent_start == (u64)-1) {
1188 dst->extent_start = src->extent_start;
1189 dst->extent_end = src->extent_end;
1191 if (dst->extent_end > src->extent_start)
1192 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1193 else if (dst->extent_end < src->extent_start) {
1194 ret = add_file_extent_hole(&dst->holes,
1196 src->extent_start - dst->extent_end);
1198 if (dst->extent_end < src->extent_end)
1199 dst->extent_end = src->extent_end;
1203 dst->errors |= src->errors;
1204 if (src->found_inode_item) {
1205 if (!dst->found_inode_item) {
1206 dst->nlink = src->nlink;
1207 dst->isize = src->isize;
1208 dst->nbytes = src->nbytes;
1209 dst->imode = src->imode;
1210 dst->nodatasum = src->nodatasum;
1211 dst->found_inode_item = 1;
1213 dst->errors |= I_ERR_DUP_INODE_ITEM;
1221 static int splice_shared_node(struct shared_node *src_node,
1222 struct shared_node *dst_node)
1224 struct cache_extent *cache;
1225 struct ptr_node *node, *ins;
1226 struct cache_tree *src, *dst;
1227 struct inode_record *rec, *conflict;
1228 u64 current_ino = 0;
1232 if (--src_node->refs == 0)
1234 if (src_node->current)
1235 current_ino = src_node->current->ino;
1237 src = &src_node->root_cache;
1238 dst = &dst_node->root_cache;
1240 cache = search_cache_extent(src, 0);
1242 node = container_of(cache, struct ptr_node, cache);
1244 cache = next_cache_extent(cache);
1247 remove_cache_extent(src, &node->cache);
1250 ins = malloc(sizeof(*ins));
1252 ins->cache.start = node->cache.start;
1253 ins->cache.size = node->cache.size;
1257 ret = insert_cache_extent(dst, &ins->cache);
1258 if (ret == -EEXIST) {
1259 conflict = get_inode_rec(dst, rec->ino, 1);
1260 BUG_ON(IS_ERR(conflict));
1261 merge_inode_recs(rec, conflict, dst);
1263 conflict->checked = 1;
1264 if (dst_node->current == conflict)
1265 dst_node->current = NULL;
1267 maybe_free_inode_rec(dst, conflict);
1268 free_inode_rec(rec);
1275 if (src == &src_node->root_cache) {
1276 src = &src_node->inode_cache;
1277 dst = &dst_node->inode_cache;
1281 if (current_ino > 0 && (!dst_node->current ||
1282 current_ino > dst_node->current->ino)) {
1283 if (dst_node->current) {
1284 dst_node->current->checked = 1;
1285 maybe_free_inode_rec(dst, dst_node->current);
1287 dst_node->current = get_inode_rec(dst, current_ino, 1);
1288 BUG_ON(IS_ERR(dst_node->current));
1293 static void free_inode_ptr(struct cache_extent *cache)
1295 struct ptr_node *node;
1296 struct inode_record *rec;
1298 node = container_of(cache, struct ptr_node, cache);
1300 free_inode_rec(rec);
1304 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1306 static struct shared_node *find_shared_node(struct cache_tree *shared,
1309 struct cache_extent *cache;
1310 struct shared_node *node;
1312 cache = lookup_cache_extent(shared, bytenr, 1);
1314 node = container_of(cache, struct shared_node, cache);
1320 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1323 struct shared_node *node;
1325 node = calloc(1, sizeof(*node));
1328 node->cache.start = bytenr;
1329 node->cache.size = 1;
1330 cache_tree_init(&node->root_cache);
1331 cache_tree_init(&node->inode_cache);
1334 ret = insert_cache_extent(shared, &node->cache);
1339 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1340 struct walk_control *wc, int level)
1342 struct shared_node *node;
1343 struct shared_node *dest;
1346 if (level == wc->active_node)
1349 BUG_ON(wc->active_node <= level);
1350 node = find_shared_node(&wc->shared, bytenr);
1352 ret = add_shared_node(&wc->shared, bytenr, refs);
1354 node = find_shared_node(&wc->shared, bytenr);
1355 wc->nodes[level] = node;
1356 wc->active_node = level;
1360 if (wc->root_level == wc->active_node &&
1361 btrfs_root_refs(&root->root_item) == 0) {
1362 if (--node->refs == 0) {
1363 free_inode_recs_tree(&node->root_cache);
1364 free_inode_recs_tree(&node->inode_cache);
1365 remove_cache_extent(&wc->shared, &node->cache);
1371 dest = wc->nodes[wc->active_node];
1372 splice_shared_node(node, dest);
1373 if (node->refs == 0) {
1374 remove_cache_extent(&wc->shared, &node->cache);
1380 static int leave_shared_node(struct btrfs_root *root,
1381 struct walk_control *wc, int level)
1383 struct shared_node *node;
1384 struct shared_node *dest;
1387 if (level == wc->root_level)
1390 for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1394 BUG_ON(i >= BTRFS_MAX_LEVEL);
1396 node = wc->nodes[wc->active_node];
1397 wc->nodes[wc->active_node] = NULL;
1398 wc->active_node = i;
1400 dest = wc->nodes[wc->active_node];
1401 if (wc->active_node < wc->root_level ||
1402 btrfs_root_refs(&root->root_item) > 0) {
1403 BUG_ON(node->refs <= 1);
1404 splice_shared_node(node, dest);
1406 BUG_ON(node->refs < 2);
1415 * 1 - if the root with id child_root_id is a child of root parent_root_id
1416 * 0 - if the root child_root_id isn't a child of the root parent_root_id but
1417 * has other root(s) as parent(s)
1418 * 2 - if the root child_root_id doesn't have any parent roots
1420 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1423 struct btrfs_path path;
1424 struct btrfs_key key;
1425 struct extent_buffer *leaf;
1429 btrfs_init_path(&path);
1431 key.objectid = parent_root_id;
1432 key.type = BTRFS_ROOT_REF_KEY;
1433 key.offset = child_root_id;
1434 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1438 btrfs_release_path(&path);
1442 key.objectid = child_root_id;
1443 key.type = BTRFS_ROOT_BACKREF_KEY;
1445 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1451 leaf = path.nodes[0];
1452 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1453 ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1456 leaf = path.nodes[0];
1459 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1460 if (key.objectid != child_root_id ||
1461 key.type != BTRFS_ROOT_BACKREF_KEY)
1466 if (key.offset == parent_root_id) {
1467 btrfs_release_path(&path);
1474 btrfs_release_path(&path);
1477 return has_parent ? 0 : 2;
1480 static int process_dir_item(struct btrfs_root *root,
1481 struct extent_buffer *eb,
1482 int slot, struct btrfs_key *key,
1483 struct shared_node *active_node)
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];
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;
1505 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1506 total = btrfs_item_size_nr(eb, slot);
1507 while (cur < total) {
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);
1514 rec->found_size += name_len;
1515 if (name_len <= BTRFS_NAME_LEN) {
1519 len = BTRFS_NAME_LEN;
1520 error = REF_ERR_NAME_TOO_LONG;
1522 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
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,
1534 fprintf(stderr, "invalid location in dir item %u\n",
1536 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1537 key->objectid, key->offset, namebuf,
1538 len, filetype, key->type, error);
1541 len = sizeof(*di) + name_len + data_len;
1542 di = (struct btrfs_dir_item *)((char *)di + len);
1545 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1546 rec->errors |= I_ERR_DUP_DIR_INDEX;
1551 static int process_inode_ref(struct extent_buffer *eb,
1552 int slot, struct btrfs_key *key,
1553 struct shared_node *active_node)
1561 struct cache_tree *inode_cache;
1562 struct btrfs_inode_ref *ref;
1563 char namebuf[BTRFS_NAME_LEN];
1565 inode_cache = &active_node->inode_cache;
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) {
1576 len = BTRFS_NAME_LEN;
1577 error = REF_ERR_NAME_TOO_LONG;
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);
1583 len = sizeof(*ref) + name_len;
1584 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1590 static int process_inode_extref(struct extent_buffer *eb,
1591 int slot, struct btrfs_key *key,
1592 struct shared_node *active_node)
1601 struct cache_tree *inode_cache;
1602 struct btrfs_inode_extref *extref;
1603 char namebuf[BTRFS_NAME_LEN];
1605 inode_cache = &active_node->inode_cache;
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) {
1617 len = BTRFS_NAME_LEN;
1618 error = REF_ERR_NAME_TOO_LONG;
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);
1625 len = sizeof(*extref) + name_len;
1626 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1633 static int count_csum_range(struct btrfs_root *root, u64 start,
1634 u64 len, u64 *found)
1636 struct btrfs_key key;
1637 struct btrfs_path path;
1638 struct extent_buffer *leaf;
1643 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1645 btrfs_init_path(&path);
1647 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1649 key.type = BTRFS_EXTENT_CSUM_KEY;
1651 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
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)
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);
1671 leaf = path.nodes[0];
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)
1679 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1680 if (key.offset >= start + len)
1683 if (key.offset > start)
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);
1698 btrfs_release_path(&path);
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)
1709 struct inode_record *rec;
1710 struct btrfs_file_extent_item *fi;
1712 u64 disk_bytenr = 0;
1713 u64 extent_offset = 0;
1714 u64 mask = root->sectorsize - 1;
1718 rec = active_node->current;
1719 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1720 rec->found_file_extent = 1;
1722 if (rec->extent_start == (u64)-1) {
1723 rec->extent_start = key->offset;
1724 rec->extent_end = key->offset;
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);
1736 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1737 extent_type = btrfs_file_extent_type(eb, fi);
1739 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1740 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
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;
1763 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1765 rec->extent_end = key->offset + num_bytes;
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
1775 if (disk_bytenr > 0 &&
1776 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1778 if (btrfs_file_extent_compression(eb, fi))
1779 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1781 disk_bytenr += extent_offset;
1783 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1786 if (extent_type == BTRFS_FILE_EXTENT_REG) {
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) {
1793 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1799 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1800 struct walk_control *wc)
1802 struct btrfs_key key;
1806 struct cache_tree *inode_cache;
1807 struct shared_node *active_node;
1809 if (wc->root_level == wc->active_node &&
1810 btrfs_root_refs(&root->root_item) == 0)
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);
1819 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1821 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
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);
1831 active_node->current = get_inode_rec(inode_cache,
1833 BUG_ON(IS_ERR(active_node->current));
1836 case BTRFS_DIR_ITEM_KEY:
1837 case BTRFS_DIR_INDEX_KEY:
1838 ret = process_dir_item(root, eb, i, &key, active_node);
1840 case BTRFS_INODE_REF_KEY:
1841 ret = process_inode_ref(eb, i, &key, active_node);
1843 case BTRFS_INODE_EXTREF_KEY:
1844 ret = process_inode_extref(eb, i, &key, active_node);
1846 case BTRFS_INODE_ITEM_KEY:
1847 ret = process_inode_item(eb, i, &key, active_node);
1849 case BTRFS_EXTENT_DATA_KEY:
1850 ret = process_file_extent(root, eb, i, &key,
1861 u64 bytenr[BTRFS_MAX_LEVEL];
1862 u64 refs[BTRFS_MAX_LEVEL];
1863 int need_check[BTRFS_MAX_LEVEL];
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);
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)
1874 struct extent_buffer *cur = path->nodes[0];
1875 struct btrfs_key key;
1879 int root_level = btrfs_header_level(root->node);
1881 int ret = 0; /* Final return value */
1882 int err = 0; /* Positive error bitmap */
1884 cur_bytenr = cur->start;
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);
1891 first_ino = key.objectid;
1892 if (key.type == BTRFS_INODE_ITEM_KEY ||
1893 (first_ino && first_ino != key.objectid))
1897 path->slots[0] = nritems;
1903 err |= check_inode_item(root, path, ext_ref);
1905 if (err & LAST_ITEM)
1908 /* still have inode items in thie leaf */
1909 if (cur->start == cur_bytenr)
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
1918 for (i = root_level; i >= 0; i--) {
1919 if (path->nodes[i]->start == nrefs->bytenr[i])
1922 ret = update_nodes_refs(root,
1923 path->nodes[i]->start,
1928 if (!nrefs->need_check[i]) {
1934 for (i = 0; i < *level; i++) {
1935 free_extent_buffer(path->nodes[i]);
1936 path->nodes[i] = NULL;
1941 * Convert any error bitmap to -EIO, as we should avoid
1942 * mixing positive and negative return value to represent
1950 static void reada_walk_down(struct btrfs_root *root,
1951 struct extent_buffer *node, int slot)
1960 level = btrfs_header_level(node);
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);
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
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.
1980 * Or the child node/leaf pointed by the key in parent is not valid.
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.
1986 static int check_child_node(struct btrfs_root *root,
1987 struct extent_buffer *parent, int slot,
1988 struct extent_buffer *child)
1990 struct btrfs_key parent_key;
1991 struct btrfs_key child_key;
1994 btrfs_node_key_to_cpu(parent, &parent_key, slot);
1995 if (btrfs_header_level(child) == 0)
1996 btrfs_item_key_to_cpu(child, &child_key, 0);
1998 btrfs_node_key_to_cpu(child, &child_key, 0);
2000 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2003 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2004 parent_key.objectid, parent_key.type, parent_key.offset,
2005 child_key.objectid, child_key.type, child_key.offset);
2007 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2009 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2010 btrfs_node_blockptr(parent, slot),
2011 btrfs_header_bytenr(child));
2013 if (btrfs_node_ptr_generation(parent, slot) !=
2014 btrfs_header_generation(child)) {
2016 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2017 btrfs_header_generation(child),
2018 btrfs_node_ptr_generation(parent, slot));
2024 * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2025 * in every fs or file tree check. Here we find its all root ids, and only check
2026 * it in the fs or file tree which has the smallest root id.
2028 static int need_check(struct btrfs_root *root, struct ulist *roots)
2030 struct rb_node *node;
2031 struct ulist_node *u;
2033 if (roots->nnodes == 1)
2036 node = rb_first(&roots->root);
2037 u = rb_entry(node, struct ulist_node, rb_node);
2039 * current root id is not smallest, we skip it and let it be checked
2040 * in the fs or file tree who hash the smallest root id.
2042 if (root->objectid != u->val)
2049 * for a tree node or leaf, we record its reference count, so later if we still
2050 * process this node or leaf, don't need to compute its reference count again.
2052 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2053 struct node_refs *nrefs, u64 level)
2057 struct ulist *roots;
2059 if (nrefs->bytenr[level] != bytenr) {
2060 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2061 level, 1, &refs, NULL);
2065 nrefs->bytenr[level] = bytenr;
2066 nrefs->refs[level] = refs;
2068 ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2073 check = need_check(root, roots);
2075 nrefs->need_check[level] = check;
2077 nrefs->need_check[level] = 1;
2084 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2085 struct walk_control *wc, int *level,
2086 struct node_refs *nrefs)
2088 enum btrfs_tree_block_status status;
2091 struct extent_buffer *next;
2092 struct extent_buffer *cur;
2097 WARN_ON(*level < 0);
2098 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2100 if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2101 refs = nrefs->refs[*level];
2104 ret = btrfs_lookup_extent_info(NULL, root,
2105 path->nodes[*level]->start,
2106 *level, 1, &refs, NULL);
2111 nrefs->bytenr[*level] = path->nodes[*level]->start;
2112 nrefs->refs[*level] = refs;
2116 ret = enter_shared_node(root, path->nodes[*level]->start,
2124 while (*level >= 0) {
2125 WARN_ON(*level < 0);
2126 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2127 cur = path->nodes[*level];
2129 if (btrfs_header_level(cur) != *level)
2132 if (path->slots[*level] >= btrfs_header_nritems(cur))
2135 ret = process_one_leaf(root, cur, wc);
2140 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2141 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2142 blocksize = root->nodesize;
2144 if (bytenr == nrefs->bytenr[*level - 1]) {
2145 refs = nrefs->refs[*level - 1];
2147 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2148 *level - 1, 1, &refs, NULL);
2152 nrefs->bytenr[*level - 1] = bytenr;
2153 nrefs->refs[*level - 1] = refs;
2158 ret = enter_shared_node(root, bytenr, refs,
2161 path->slots[*level]++;
2166 next = btrfs_find_tree_block(root, bytenr, blocksize);
2167 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2168 free_extent_buffer(next);
2169 reada_walk_down(root, cur, path->slots[*level]);
2170 next = read_tree_block(root, bytenr, blocksize,
2172 if (!extent_buffer_uptodate(next)) {
2173 struct btrfs_key node_key;
2175 btrfs_node_key_to_cpu(path->nodes[*level],
2177 path->slots[*level]);
2178 btrfs_add_corrupt_extent_record(root->fs_info,
2180 path->nodes[*level]->start,
2181 root->nodesize, *level);
2187 ret = check_child_node(root, cur, path->slots[*level], next);
2193 if (btrfs_is_leaf(next))
2194 status = btrfs_check_leaf(root, NULL, next);
2196 status = btrfs_check_node(root, NULL, next);
2197 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2198 free_extent_buffer(next);
2203 *level = *level - 1;
2204 free_extent_buffer(path->nodes[*level]);
2205 path->nodes[*level] = next;
2206 path->slots[*level] = 0;
2209 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2213 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2214 unsigned int ext_ref);
2216 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2217 int *level, struct node_refs *nrefs, int ext_ref)
2219 enum btrfs_tree_block_status status;
2222 struct extent_buffer *next;
2223 struct extent_buffer *cur;
2227 WARN_ON(*level < 0);
2228 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2230 ret = update_nodes_refs(root, path->nodes[*level]->start,
2235 while (*level >= 0) {
2236 WARN_ON(*level < 0);
2237 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2238 cur = path->nodes[*level];
2240 if (btrfs_header_level(cur) != *level)
2243 if (path->slots[*level] >= btrfs_header_nritems(cur))
2245 /* Don't forgot to check leaf/node validation */
2247 ret = btrfs_check_leaf(root, NULL, cur);
2248 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2252 ret = process_one_leaf_v2(root, path, nrefs,
2256 ret = btrfs_check_node(root, NULL, cur);
2257 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2262 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2263 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2264 blocksize = root->nodesize;
2266 ret = update_nodes_refs(root, bytenr, nrefs, *level - 1);
2269 if (!nrefs->need_check[*level - 1]) {
2270 path->slots[*level]++;
2274 next = btrfs_find_tree_block(root, bytenr, blocksize);
2275 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2276 free_extent_buffer(next);
2277 reada_walk_down(root, cur, path->slots[*level]);
2278 next = read_tree_block(root, bytenr, blocksize,
2280 if (!extent_buffer_uptodate(next)) {
2281 struct btrfs_key node_key;
2283 btrfs_node_key_to_cpu(path->nodes[*level],
2285 path->slots[*level]);
2286 btrfs_add_corrupt_extent_record(root->fs_info,
2288 path->nodes[*level]->start,
2289 root->nodesize, *level);
2295 ret = check_child_node(root, cur, path->slots[*level], next);
2299 if (btrfs_is_leaf(next))
2300 status = btrfs_check_leaf(root, NULL, next);
2302 status = btrfs_check_node(root, NULL, next);
2303 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2304 free_extent_buffer(next);
2309 *level = *level - 1;
2310 free_extent_buffer(path->nodes[*level]);
2311 path->nodes[*level] = next;
2312 path->slots[*level] = 0;
2317 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2318 struct walk_control *wc, int *level)
2321 struct extent_buffer *leaf;
2323 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2324 leaf = path->nodes[i];
2325 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2330 free_extent_buffer(path->nodes[*level]);
2331 path->nodes[*level] = NULL;
2332 BUG_ON(*level > wc->active_node);
2333 if (*level == wc->active_node)
2334 leave_shared_node(root, wc, *level);
2341 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2345 struct extent_buffer *leaf;
2347 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2348 leaf = path->nodes[i];
2349 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2354 free_extent_buffer(path->nodes[*level]);
2355 path->nodes[*level] = NULL;
2362 static int check_root_dir(struct inode_record *rec)
2364 struct inode_backref *backref;
2367 if (!rec->found_inode_item || rec->errors)
2369 if (rec->nlink != 1 || rec->found_link != 0)
2371 if (list_empty(&rec->backrefs))
2373 backref = to_inode_backref(rec->backrefs.next);
2374 if (!backref->found_inode_ref)
2376 if (backref->index != 0 || backref->namelen != 2 ||
2377 memcmp(backref->name, "..", 2))
2379 if (backref->found_dir_index || backref->found_dir_item)
2386 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2387 struct btrfs_root *root, struct btrfs_path *path,
2388 struct inode_record *rec)
2390 struct btrfs_inode_item *ei;
2391 struct btrfs_key key;
2394 key.objectid = rec->ino;
2395 key.type = BTRFS_INODE_ITEM_KEY;
2396 key.offset = (u64)-1;
2398 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2402 if (!path->slots[0]) {
2409 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2410 if (key.objectid != rec->ino) {
2415 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2416 struct btrfs_inode_item);
2417 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2418 btrfs_mark_buffer_dirty(path->nodes[0]);
2419 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2420 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2421 root->root_key.objectid);
2423 btrfs_release_path(path);
2427 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2428 struct btrfs_root *root,
2429 struct btrfs_path *path,
2430 struct inode_record *rec)
2434 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2435 btrfs_release_path(path);
2437 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2441 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2442 struct btrfs_root *root,
2443 struct btrfs_path *path,
2444 struct inode_record *rec)
2446 struct btrfs_inode_item *ei;
2447 struct btrfs_key key;
2450 key.objectid = rec->ino;
2451 key.type = BTRFS_INODE_ITEM_KEY;
2454 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2461 /* Since ret == 0, no need to check anything */
2462 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2463 struct btrfs_inode_item);
2464 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2465 btrfs_mark_buffer_dirty(path->nodes[0]);
2466 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2467 printf("reset nbytes for ino %llu root %llu\n",
2468 rec->ino, root->root_key.objectid);
2470 btrfs_release_path(path);
2474 static int add_missing_dir_index(struct btrfs_root *root,
2475 struct cache_tree *inode_cache,
2476 struct inode_record *rec,
2477 struct inode_backref *backref)
2479 struct btrfs_path path;
2480 struct btrfs_trans_handle *trans;
2481 struct btrfs_dir_item *dir_item;
2482 struct extent_buffer *leaf;
2483 struct btrfs_key key;
2484 struct btrfs_disk_key disk_key;
2485 struct inode_record *dir_rec;
2486 unsigned long name_ptr;
2487 u32 data_size = sizeof(*dir_item) + backref->namelen;
2490 trans = btrfs_start_transaction(root, 1);
2492 return PTR_ERR(trans);
2494 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2495 (unsigned long long)rec->ino);
2497 btrfs_init_path(&path);
2498 key.objectid = backref->dir;
2499 key.type = BTRFS_DIR_INDEX_KEY;
2500 key.offset = backref->index;
2501 ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
2504 leaf = path.nodes[0];
2505 dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
2507 disk_key.objectid = cpu_to_le64(rec->ino);
2508 disk_key.type = BTRFS_INODE_ITEM_KEY;
2509 disk_key.offset = 0;
2511 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2512 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2513 btrfs_set_dir_data_len(leaf, dir_item, 0);
2514 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2515 name_ptr = (unsigned long)(dir_item + 1);
2516 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2517 btrfs_mark_buffer_dirty(leaf);
2518 btrfs_release_path(&path);
2519 btrfs_commit_transaction(trans, root);
2521 backref->found_dir_index = 1;
2522 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2523 BUG_ON(IS_ERR(dir_rec));
2526 dir_rec->found_size += backref->namelen;
2527 if (dir_rec->found_size == dir_rec->isize &&
2528 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2529 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2530 if (dir_rec->found_size != dir_rec->isize)
2531 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2536 static int delete_dir_index(struct btrfs_root *root,
2537 struct cache_tree *inode_cache,
2538 struct inode_record *rec,
2539 struct inode_backref *backref)
2541 struct btrfs_trans_handle *trans;
2542 struct btrfs_dir_item *di;
2543 struct btrfs_path path;
2546 trans = btrfs_start_transaction(root, 1);
2548 return PTR_ERR(trans);
2550 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2551 (unsigned long long)backref->dir,
2552 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2553 (unsigned long long)root->objectid);
2555 btrfs_init_path(&path);
2556 di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
2557 backref->name, backref->namelen,
2558 backref->index, -1);
2561 btrfs_release_path(&path);
2562 btrfs_commit_transaction(trans, root);
2569 ret = btrfs_del_item(trans, root, &path);
2571 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
2573 btrfs_release_path(&path);
2574 btrfs_commit_transaction(trans, root);
2578 static int create_inode_item(struct btrfs_root *root,
2579 struct inode_record *rec,
2580 struct inode_backref *backref, int root_dir)
2582 struct btrfs_trans_handle *trans;
2583 struct btrfs_inode_item inode_item;
2584 time_t now = time(NULL);
2587 trans = btrfs_start_transaction(root, 1);
2588 if (IS_ERR(trans)) {
2589 ret = PTR_ERR(trans);
2593 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2594 "be incomplete, please check permissions and content after "
2595 "the fsck completes.\n", (unsigned long long)root->objectid,
2596 (unsigned long long)rec->ino);
2598 memset(&inode_item, 0, sizeof(inode_item));
2599 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2601 btrfs_set_stack_inode_nlink(&inode_item, 1);
2603 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2604 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2605 if (rec->found_dir_item) {
2606 if (rec->found_file_extent)
2607 fprintf(stderr, "root %llu inode %llu has both a dir "
2608 "item and extents, unsure if it is a dir or a "
2609 "regular file so setting it as a directory\n",
2610 (unsigned long long)root->objectid,
2611 (unsigned long long)rec->ino);
2612 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2613 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2614 } else if (!rec->found_dir_item) {
2615 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2616 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2618 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2619 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2620 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2621 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2622 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2623 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2624 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2625 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2627 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2629 btrfs_commit_transaction(trans, root);
2633 static int repair_inode_backrefs(struct btrfs_root *root,
2634 struct inode_record *rec,
2635 struct cache_tree *inode_cache,
2638 struct inode_backref *tmp, *backref;
2639 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2643 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2644 if (!delete && rec->ino == root_dirid) {
2645 if (!rec->found_inode_item) {
2646 ret = create_inode_item(root, rec, backref, 1);
2653 /* Index 0 for root dir's are special, don't mess with it */
2654 if (rec->ino == root_dirid && backref->index == 0)
2658 ((backref->found_dir_index && !backref->found_inode_ref) ||
2659 (backref->found_dir_index && backref->found_inode_ref &&
2660 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2661 ret = delete_dir_index(root, inode_cache, rec, backref);
2665 list_del(&backref->list);
2669 if (!delete && !backref->found_dir_index &&
2670 backref->found_dir_item && backref->found_inode_ref) {
2671 ret = add_missing_dir_index(root, inode_cache, rec,
2676 if (backref->found_dir_item &&
2677 backref->found_dir_index &&
2678 backref->found_dir_index) {
2679 if (!backref->errors &&
2680 backref->found_inode_ref) {
2681 list_del(&backref->list);
2687 if (!delete && (!backref->found_dir_index &&
2688 !backref->found_dir_item &&
2689 backref->found_inode_ref)) {
2690 struct btrfs_trans_handle *trans;
2691 struct btrfs_key location;
2693 ret = check_dir_conflict(root, backref->name,
2699 * let nlink fixing routine to handle it,
2700 * which can do it better.
2705 location.objectid = rec->ino;
2706 location.type = BTRFS_INODE_ITEM_KEY;
2707 location.offset = 0;
2709 trans = btrfs_start_transaction(root, 1);
2710 if (IS_ERR(trans)) {
2711 ret = PTR_ERR(trans);
2714 fprintf(stderr, "adding missing dir index/item pair "
2716 (unsigned long long)rec->ino);
2717 ret = btrfs_insert_dir_item(trans, root, backref->name,
2719 backref->dir, &location,
2720 imode_to_type(rec->imode),
2723 btrfs_commit_transaction(trans, root);
2727 if (!delete && (backref->found_inode_ref &&
2728 backref->found_dir_index &&
2729 backref->found_dir_item &&
2730 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2731 !rec->found_inode_item)) {
2732 ret = create_inode_item(root, rec, backref, 0);
2739 return ret ? ret : repaired;
2743 * To determine the file type for nlink/inode_item repair
2745 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2746 * Return -ENOENT if file type is not found.
2748 static int find_file_type(struct inode_record *rec, u8 *type)
2750 struct inode_backref *backref;
2752 /* For inode item recovered case */
2753 if (rec->found_inode_item) {
2754 *type = imode_to_type(rec->imode);
2758 list_for_each_entry(backref, &rec->backrefs, list) {
2759 if (backref->found_dir_index || backref->found_dir_item) {
2760 *type = backref->filetype;
2768 * To determine the file name for nlink repair
2770 * Return 0 if file name is found, set name and namelen.
2771 * Return -ENOENT if file name is not found.
2773 static int find_file_name(struct inode_record *rec,
2774 char *name, int *namelen)
2776 struct inode_backref *backref;
2778 list_for_each_entry(backref, &rec->backrefs, list) {
2779 if (backref->found_dir_index || backref->found_dir_item ||
2780 backref->found_inode_ref) {
2781 memcpy(name, backref->name, backref->namelen);
2782 *namelen = backref->namelen;
2789 /* Reset the nlink of the inode to the correct one */
2790 static int reset_nlink(struct btrfs_trans_handle *trans,
2791 struct btrfs_root *root,
2792 struct btrfs_path *path,
2793 struct inode_record *rec)
2795 struct inode_backref *backref;
2796 struct inode_backref *tmp;
2797 struct btrfs_key key;
2798 struct btrfs_inode_item *inode_item;
2801 /* We don't believe this either, reset it and iterate backref */
2802 rec->found_link = 0;
2804 /* Remove all backref including the valid ones */
2805 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2806 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2807 backref->index, backref->name,
2808 backref->namelen, 0);
2812 /* remove invalid backref, so it won't be added back */
2813 if (!(backref->found_dir_index &&
2814 backref->found_dir_item &&
2815 backref->found_inode_ref)) {
2816 list_del(&backref->list);
2823 /* Set nlink to 0 */
2824 key.objectid = rec->ino;
2825 key.type = BTRFS_INODE_ITEM_KEY;
2827 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2834 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2835 struct btrfs_inode_item);
2836 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2837 btrfs_mark_buffer_dirty(path->nodes[0]);
2838 btrfs_release_path(path);
2841 * Add back valid inode_ref/dir_item/dir_index,
2842 * add_link() will handle the nlink inc, so new nlink must be correct
2844 list_for_each_entry(backref, &rec->backrefs, list) {
2845 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2846 backref->name, backref->namelen,
2847 backref->filetype, &backref->index, 1);
2852 btrfs_release_path(path);
2856 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2857 struct btrfs_root *root,
2858 struct btrfs_path *path,
2859 struct inode_record *rec)
2861 char *dir_name = "lost+found";
2862 char namebuf[BTRFS_NAME_LEN] = {0};
2867 int name_recovered = 0;
2868 int type_recovered = 0;
2872 * Get file name and type first before these invalid inode ref
2873 * are deleted by remove_all_invalid_backref()
2875 name_recovered = !find_file_name(rec, namebuf, &namelen);
2876 type_recovered = !find_file_type(rec, &type);
2878 if (!name_recovered) {
2879 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2880 rec->ino, rec->ino);
2881 namelen = count_digits(rec->ino);
2882 sprintf(namebuf, "%llu", rec->ino);
2885 if (!type_recovered) {
2886 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2888 type = BTRFS_FT_REG_FILE;
2892 ret = reset_nlink(trans, root, path, rec);
2895 "Failed to reset nlink for inode %llu: %s\n",
2896 rec->ino, strerror(-ret));
2900 if (rec->found_link == 0) {
2901 lost_found_ino = root->highest_inode;
2902 if (lost_found_ino >= BTRFS_LAST_FREE_OBJECTID) {
2907 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2908 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2911 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2912 dir_name, strerror(-ret));
2915 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2916 namebuf, namelen, type, NULL, 1);
2918 * Add ".INO" suffix several times to handle case where
2919 * "FILENAME.INO" is already taken by another file.
2921 while (ret == -EEXIST) {
2923 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2925 if (namelen + count_digits(rec->ino) + 1 >
2930 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2932 namelen += count_digits(rec->ino) + 1;
2933 ret = btrfs_add_link(trans, root, rec->ino,
2934 lost_found_ino, namebuf,
2935 namelen, type, NULL, 1);
2939 "Failed to link the inode %llu to %s dir: %s\n",
2940 rec->ino, dir_name, strerror(-ret));
2944 * Just increase the found_link, don't actually add the
2945 * backref. This will make things easier and this inode
2946 * record will be freed after the repair is done.
2947 * So fsck will not report problem about this inode.
2950 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2951 namelen, namebuf, dir_name);
2953 printf("Fixed the nlink of inode %llu\n", rec->ino);
2956 * Clear the flag anyway, or we will loop forever for the same inode
2957 * as it will not be removed from the bad inode list and the dead loop
2960 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2961 btrfs_release_path(path);
2966 * Check if there is any normal(reg or prealloc) file extent for given
2968 * This is used to determine the file type when neither its dir_index/item or
2969 * inode_item exists.
2971 * This will *NOT* report error, if any error happens, just consider it does
2972 * not have any normal file extent.
2974 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
2976 struct btrfs_path path;
2977 struct btrfs_key key;
2978 struct btrfs_key found_key;
2979 struct btrfs_file_extent_item *fi;
2983 btrfs_init_path(&path);
2985 key.type = BTRFS_EXTENT_DATA_KEY;
2988 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
2993 if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
2994 ret = btrfs_next_leaf(root, &path);
3001 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3003 if (found_key.objectid != ino ||
3004 found_key.type != BTRFS_EXTENT_DATA_KEY)
3006 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3007 struct btrfs_file_extent_item);
3008 type = btrfs_file_extent_type(path.nodes[0], fi);
3009 if (type != BTRFS_FILE_EXTENT_INLINE) {
3015 btrfs_release_path(&path);
3019 static u32 btrfs_type_to_imode(u8 type)
3021 static u32 imode_by_btrfs_type[] = {
3022 [BTRFS_FT_REG_FILE] = S_IFREG,
3023 [BTRFS_FT_DIR] = S_IFDIR,
3024 [BTRFS_FT_CHRDEV] = S_IFCHR,
3025 [BTRFS_FT_BLKDEV] = S_IFBLK,
3026 [BTRFS_FT_FIFO] = S_IFIFO,
3027 [BTRFS_FT_SOCK] = S_IFSOCK,
3028 [BTRFS_FT_SYMLINK] = S_IFLNK,
3031 return imode_by_btrfs_type[(type)];
3034 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3035 struct btrfs_root *root,
3036 struct btrfs_path *path,
3037 struct inode_record *rec)
3041 int type_recovered = 0;
3044 printf("Trying to rebuild inode:%llu\n", rec->ino);
3046 type_recovered = !find_file_type(rec, &filetype);
3049 * Try to determine inode type if type not found.
3051 * For found regular file extent, it must be FILE.
3052 * For found dir_item/index, it must be DIR.
3054 * For undetermined one, use FILE as fallback.
3057 * 1. If found backref(inode_index/item is already handled) to it,
3059 * Need new inode-inode ref structure to allow search for that.
3061 if (!type_recovered) {
3062 if (rec->found_file_extent &&
3063 find_normal_file_extent(root, rec->ino)) {
3065 filetype = BTRFS_FT_REG_FILE;
3066 } else if (rec->found_dir_item) {
3068 filetype = BTRFS_FT_DIR;
3069 } else if (!list_empty(&rec->orphan_extents)) {
3071 filetype = BTRFS_FT_REG_FILE;
3073 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3076 filetype = BTRFS_FT_REG_FILE;
3080 ret = btrfs_new_inode(trans, root, rec->ino,
3081 mode | btrfs_type_to_imode(filetype));
3086 * Here inode rebuild is done, we only rebuild the inode item,
3087 * don't repair the nlink(like move to lost+found).
3088 * That is the job of nlink repair.
3090 * We just fill the record and return
3092 rec->found_dir_item = 1;
3093 rec->imode = mode | btrfs_type_to_imode(filetype);
3095 rec->errors &= ~I_ERR_NO_INODE_ITEM;
3096 /* Ensure the inode_nlinks repair function will be called */
3097 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3102 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3103 struct btrfs_root *root,
3104 struct btrfs_path *path,
3105 struct inode_record *rec)
3107 struct orphan_data_extent *orphan;
3108 struct orphan_data_extent *tmp;
3111 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3113 * Check for conflicting file extents
3115 * Here we don't know whether the extents is compressed or not,
3116 * so we can only assume it not compressed nor data offset,
3117 * and use its disk_len as extent length.
3119 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3120 orphan->offset, orphan->disk_len, 0);
3121 btrfs_release_path(path);
3126 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3127 orphan->disk_bytenr, orphan->disk_len);
3128 ret = btrfs_free_extent(trans,
3129 root->fs_info->extent_root,
3130 orphan->disk_bytenr, orphan->disk_len,
3131 0, root->objectid, orphan->objectid,
3136 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3137 orphan->offset, orphan->disk_bytenr,
3138 orphan->disk_len, orphan->disk_len);
3142 /* Update file size info */
3143 rec->found_size += orphan->disk_len;
3144 if (rec->found_size == rec->nbytes)
3145 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3147 /* Update the file extent hole info too */
3148 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3152 if (RB_EMPTY_ROOT(&rec->holes))
3153 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3155 list_del(&orphan->list);
3158 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3163 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3164 struct btrfs_root *root,
3165 struct btrfs_path *path,
3166 struct inode_record *rec)
3168 struct rb_node *node;
3169 struct file_extent_hole *hole;
3173 node = rb_first(&rec->holes);
3177 hole = rb_entry(node, struct file_extent_hole, node);
3178 ret = btrfs_punch_hole(trans, root, rec->ino,
3179 hole->start, hole->len);
3182 ret = del_file_extent_hole(&rec->holes, hole->start,
3186 if (RB_EMPTY_ROOT(&rec->holes))
3187 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3188 node = rb_first(&rec->holes);
3190 /* special case for a file losing all its file extent */
3192 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3193 round_up(rec->isize, root->sectorsize));
3197 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3198 rec->ino, root->objectid);
3203 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3205 struct btrfs_trans_handle *trans;
3206 struct btrfs_path path;
3209 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3210 I_ERR_NO_ORPHAN_ITEM |
3211 I_ERR_LINK_COUNT_WRONG |
3212 I_ERR_NO_INODE_ITEM |
3213 I_ERR_FILE_EXTENT_ORPHAN |
3214 I_ERR_FILE_EXTENT_DISCOUNT|
3215 I_ERR_FILE_NBYTES_WRONG)))
3219 * For nlink repair, it may create a dir and add link, so
3220 * 2 for parent(256)'s dir_index and dir_item
3221 * 2 for lost+found dir's inode_item and inode_ref
3222 * 1 for the new inode_ref of the file
3223 * 2 for lost+found dir's dir_index and dir_item for the file
3225 trans = btrfs_start_transaction(root, 7);
3227 return PTR_ERR(trans);
3229 btrfs_init_path(&path);
3230 if (rec->errors & I_ERR_NO_INODE_ITEM)
3231 ret = repair_inode_no_item(trans, root, &path, rec);
3232 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3233 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3234 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3235 ret = repair_inode_discount_extent(trans, root, &path, rec);
3236 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3237 ret = repair_inode_isize(trans, root, &path, rec);
3238 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3239 ret = repair_inode_orphan_item(trans, root, &path, rec);
3240 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3241 ret = repair_inode_nlinks(trans, root, &path, rec);
3242 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3243 ret = repair_inode_nbytes(trans, root, &path, rec);
3244 btrfs_commit_transaction(trans, root);
3245 btrfs_release_path(&path);
3249 static int check_inode_recs(struct btrfs_root *root,
3250 struct cache_tree *inode_cache)
3252 struct cache_extent *cache;
3253 struct ptr_node *node;
3254 struct inode_record *rec;
3255 struct inode_backref *backref;
3260 u64 root_dirid = btrfs_root_dirid(&root->root_item);
3262 if (btrfs_root_refs(&root->root_item) == 0) {
3263 if (!cache_tree_empty(inode_cache))
3264 fprintf(stderr, "warning line %d\n", __LINE__);
3269 * We need to record the highest inode number for later 'lost+found'
3271 * We must select an ino not used/referred by any existing inode, or
3272 * 'lost+found' ino may be a missing ino in a corrupted leaf,
3273 * this may cause 'lost+found' dir has wrong nlinks.
3275 cache = last_cache_extent(inode_cache);
3277 node = container_of(cache, struct ptr_node, cache);
3279 if (rec->ino > root->highest_inode)
3280 root->highest_inode = rec->ino;
3284 * We need to repair backrefs first because we could change some of the
3285 * errors in the inode recs.
3287 * We also need to go through and delete invalid backrefs first and then
3288 * add the correct ones second. We do this because we may get EEXIST
3289 * when adding back the correct index because we hadn't yet deleted the
3292 * For example, if we were missing a dir index then the directories
3293 * isize would be wrong, so if we fixed the isize to what we thought it
3294 * would be and then fixed the backref we'd still have a invalid fs, so
3295 * we need to add back the dir index and then check to see if the isize
3300 if (stage == 3 && !err)
3303 cache = search_cache_extent(inode_cache, 0);
3304 while (repair && cache) {
3305 node = container_of(cache, struct ptr_node, cache);
3307 cache = next_cache_extent(cache);
3309 /* Need to free everything up and rescan */
3311 remove_cache_extent(inode_cache, &node->cache);
3313 free_inode_rec(rec);
3317 if (list_empty(&rec->backrefs))
3320 ret = repair_inode_backrefs(root, rec, inode_cache,
3334 rec = get_inode_rec(inode_cache, root_dirid, 0);
3335 BUG_ON(IS_ERR(rec));
3337 ret = check_root_dir(rec);
3339 fprintf(stderr, "root %llu root dir %llu error\n",
3340 (unsigned long long)root->root_key.objectid,
3341 (unsigned long long)root_dirid);
3342 print_inode_error(root, rec);
3347 struct btrfs_trans_handle *trans;
3349 trans = btrfs_start_transaction(root, 1);
3350 if (IS_ERR(trans)) {
3351 err = PTR_ERR(trans);
3356 "root %llu missing its root dir, recreating\n",
3357 (unsigned long long)root->objectid);
3359 ret = btrfs_make_root_dir(trans, root, root_dirid);
3362 btrfs_commit_transaction(trans, root);
3366 fprintf(stderr, "root %llu root dir %llu not found\n",
3367 (unsigned long long)root->root_key.objectid,
3368 (unsigned long long)root_dirid);
3372 cache = search_cache_extent(inode_cache, 0);
3375 node = container_of(cache, struct ptr_node, cache);
3377 remove_cache_extent(inode_cache, &node->cache);
3379 if (rec->ino == root_dirid ||
3380 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3381 free_inode_rec(rec);
3385 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3386 ret = check_orphan_item(root, rec->ino);
3388 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3389 if (can_free_inode_rec(rec)) {
3390 free_inode_rec(rec);
3395 if (!rec->found_inode_item)
3396 rec->errors |= I_ERR_NO_INODE_ITEM;
3397 if (rec->found_link != rec->nlink)
3398 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3400 ret = try_repair_inode(root, rec);
3401 if (ret == 0 && can_free_inode_rec(rec)) {
3402 free_inode_rec(rec);
3408 if (!(repair && ret == 0))
3410 print_inode_error(root, rec);
3411 list_for_each_entry(backref, &rec->backrefs, list) {
3412 if (!backref->found_dir_item)
3413 backref->errors |= REF_ERR_NO_DIR_ITEM;
3414 if (!backref->found_dir_index)
3415 backref->errors |= REF_ERR_NO_DIR_INDEX;
3416 if (!backref->found_inode_ref)
3417 backref->errors |= REF_ERR_NO_INODE_REF;
3418 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3419 " namelen %u name %s filetype %d errors %x",
3420 (unsigned long long)backref->dir,
3421 (unsigned long long)backref->index,
3422 backref->namelen, backref->name,
3423 backref->filetype, backref->errors);
3424 print_ref_error(backref->errors);
3426 free_inode_rec(rec);
3428 return (error > 0) ? -1 : 0;
3431 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3434 struct cache_extent *cache;
3435 struct root_record *rec = NULL;
3438 cache = lookup_cache_extent(root_cache, objectid, 1);
3440 rec = container_of(cache, struct root_record, cache);
3442 rec = calloc(1, sizeof(*rec));
3444 return ERR_PTR(-ENOMEM);
3445 rec->objectid = objectid;
3446 INIT_LIST_HEAD(&rec->backrefs);
3447 rec->cache.start = objectid;
3448 rec->cache.size = 1;
3450 ret = insert_cache_extent(root_cache, &rec->cache);
3452 return ERR_PTR(-EEXIST);
3457 static struct root_backref *get_root_backref(struct root_record *rec,
3458 u64 ref_root, u64 dir, u64 index,
3459 const char *name, int namelen)
3461 struct root_backref *backref;
3463 list_for_each_entry(backref, &rec->backrefs, list) {
3464 if (backref->ref_root != ref_root || backref->dir != dir ||
3465 backref->namelen != namelen)
3467 if (memcmp(name, backref->name, namelen))
3472 backref = calloc(1, sizeof(*backref) + namelen + 1);
3475 backref->ref_root = ref_root;
3477 backref->index = index;
3478 backref->namelen = namelen;
3479 memcpy(backref->name, name, namelen);
3480 backref->name[namelen] = '\0';
3481 list_add_tail(&backref->list, &rec->backrefs);
3485 static void free_root_record(struct cache_extent *cache)
3487 struct root_record *rec;
3488 struct root_backref *backref;
3490 rec = container_of(cache, struct root_record, cache);
3491 while (!list_empty(&rec->backrefs)) {
3492 backref = to_root_backref(rec->backrefs.next);
3493 list_del(&backref->list);
3500 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3502 static int add_root_backref(struct cache_tree *root_cache,
3503 u64 root_id, u64 ref_root, u64 dir, u64 index,
3504 const char *name, int namelen,
3505 int item_type, int errors)
3507 struct root_record *rec;
3508 struct root_backref *backref;
3510 rec = get_root_rec(root_cache, root_id);
3511 BUG_ON(IS_ERR(rec));
3512 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3515 backref->errors |= errors;
3517 if (item_type != BTRFS_DIR_ITEM_KEY) {
3518 if (backref->found_dir_index || backref->found_back_ref ||
3519 backref->found_forward_ref) {
3520 if (backref->index != index)
3521 backref->errors |= REF_ERR_INDEX_UNMATCH;
3523 backref->index = index;
3527 if (item_type == BTRFS_DIR_ITEM_KEY) {
3528 if (backref->found_forward_ref)
3530 backref->found_dir_item = 1;
3531 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3532 backref->found_dir_index = 1;
3533 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3534 if (backref->found_forward_ref)
3535 backref->errors |= REF_ERR_DUP_ROOT_REF;
3536 else if (backref->found_dir_item)
3538 backref->found_forward_ref = 1;
3539 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3540 if (backref->found_back_ref)
3541 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3542 backref->found_back_ref = 1;
3547 if (backref->found_forward_ref && backref->found_dir_item)
3548 backref->reachable = 1;
3552 static int merge_root_recs(struct btrfs_root *root,
3553 struct cache_tree *src_cache,
3554 struct cache_tree *dst_cache)
3556 struct cache_extent *cache;
3557 struct ptr_node *node;
3558 struct inode_record *rec;
3559 struct inode_backref *backref;
3562 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3563 free_inode_recs_tree(src_cache);
3568 cache = search_cache_extent(src_cache, 0);
3571 node = container_of(cache, struct ptr_node, cache);
3573 remove_cache_extent(src_cache, &node->cache);
3576 ret = is_child_root(root, root->objectid, rec->ino);
3582 list_for_each_entry(backref, &rec->backrefs, list) {
3583 BUG_ON(backref->found_inode_ref);
3584 if (backref->found_dir_item)
3585 add_root_backref(dst_cache, rec->ino,
3586 root->root_key.objectid, backref->dir,
3587 backref->index, backref->name,
3588 backref->namelen, BTRFS_DIR_ITEM_KEY,
3590 if (backref->found_dir_index)
3591 add_root_backref(dst_cache, rec->ino,
3592 root->root_key.objectid, backref->dir,
3593 backref->index, backref->name,
3594 backref->namelen, BTRFS_DIR_INDEX_KEY,
3598 free_inode_rec(rec);
3605 static int check_root_refs(struct btrfs_root *root,
3606 struct cache_tree *root_cache)
3608 struct root_record *rec;
3609 struct root_record *ref_root;
3610 struct root_backref *backref;
3611 struct cache_extent *cache;
3617 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3618 BUG_ON(IS_ERR(rec));
3621 /* fixme: this can not detect circular references */
3624 cache = search_cache_extent(root_cache, 0);
3628 rec = container_of(cache, struct root_record, cache);
3629 cache = next_cache_extent(cache);
3631 if (rec->found_ref == 0)
3634 list_for_each_entry(backref, &rec->backrefs, list) {
3635 if (!backref->reachable)
3638 ref_root = get_root_rec(root_cache,
3640 BUG_ON(IS_ERR(ref_root));
3641 if (ref_root->found_ref > 0)
3644 backref->reachable = 0;
3646 if (rec->found_ref == 0)
3652 cache = search_cache_extent(root_cache, 0);
3656 rec = container_of(cache, struct root_record, cache);
3657 cache = next_cache_extent(cache);
3659 if (rec->found_ref == 0 &&
3660 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3661 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3662 ret = check_orphan_item(root->fs_info->tree_root,
3668 * If we don't have a root item then we likely just have
3669 * a dir item in a snapshot for this root but no actual
3670 * ref key or anything so it's meaningless.
3672 if (!rec->found_root_item)
3675 fprintf(stderr, "fs tree %llu not referenced\n",
3676 (unsigned long long)rec->objectid);
3680 if (rec->found_ref > 0 && !rec->found_root_item)
3682 list_for_each_entry(backref, &rec->backrefs, list) {
3683 if (!backref->found_dir_item)
3684 backref->errors |= REF_ERR_NO_DIR_ITEM;
3685 if (!backref->found_dir_index)
3686 backref->errors |= REF_ERR_NO_DIR_INDEX;
3687 if (!backref->found_back_ref)
3688 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3689 if (!backref->found_forward_ref)
3690 backref->errors |= REF_ERR_NO_ROOT_REF;
3691 if (backref->reachable && backref->errors)
3698 fprintf(stderr, "fs tree %llu refs %u %s\n",
3699 (unsigned long long)rec->objectid, rec->found_ref,
3700 rec->found_root_item ? "" : "not found");
3702 list_for_each_entry(backref, &rec->backrefs, list) {
3703 if (!backref->reachable)
3705 if (!backref->errors && rec->found_root_item)
3707 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3708 " index %llu namelen %u name %s errors %x\n",
3709 (unsigned long long)backref->ref_root,
3710 (unsigned long long)backref->dir,
3711 (unsigned long long)backref->index,
3712 backref->namelen, backref->name,
3714 print_ref_error(backref->errors);
3717 return errors > 0 ? 1 : 0;
3720 static int process_root_ref(struct extent_buffer *eb, int slot,
3721 struct btrfs_key *key,
3722 struct cache_tree *root_cache)
3728 struct btrfs_root_ref *ref;
3729 char namebuf[BTRFS_NAME_LEN];
3732 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3734 dirid = btrfs_root_ref_dirid(eb, ref);
3735 index = btrfs_root_ref_sequence(eb, ref);
3736 name_len = btrfs_root_ref_name_len(eb, ref);
3738 if (name_len <= BTRFS_NAME_LEN) {
3742 len = BTRFS_NAME_LEN;
3743 error = REF_ERR_NAME_TOO_LONG;
3745 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3747 if (key->type == BTRFS_ROOT_REF_KEY) {
3748 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3749 index, namebuf, len, key->type, error);
3751 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3752 index, namebuf, len, key->type, error);
3757 static void free_corrupt_block(struct cache_extent *cache)
3759 struct btrfs_corrupt_block *corrupt;
3761 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3765 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3768 * Repair the btree of the given root.
3770 * The fix is to remove the node key in corrupt_blocks cache_tree.
3771 * and rebalance the tree.
3772 * After the fix, the btree should be writeable.
3774 static int repair_btree(struct btrfs_root *root,
3775 struct cache_tree *corrupt_blocks)
3777 struct btrfs_trans_handle *trans;
3778 struct btrfs_path path;
3779 struct btrfs_corrupt_block *corrupt;
3780 struct cache_extent *cache;
3781 struct btrfs_key key;
3786 if (cache_tree_empty(corrupt_blocks))
3789 trans = btrfs_start_transaction(root, 1);
3790 if (IS_ERR(trans)) {
3791 ret = PTR_ERR(trans);
3792 fprintf(stderr, "Error starting transaction: %s\n",
3796 btrfs_init_path(&path);
3797 cache = first_cache_extent(corrupt_blocks);
3799 corrupt = container_of(cache, struct btrfs_corrupt_block,
3801 level = corrupt->level;
3802 path.lowest_level = level;
3803 key.objectid = corrupt->key.objectid;
3804 key.type = corrupt->key.type;
3805 key.offset = corrupt->key.offset;
3808 * Here we don't want to do any tree balance, since it may
3809 * cause a balance with corrupted brother leaf/node,
3810 * so ins_len set to 0 here.
3811 * Balance will be done after all corrupt node/leaf is deleted.
3813 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
3816 offset = btrfs_node_blockptr(path.nodes[level],
3819 /* Remove the ptr */
3820 ret = btrfs_del_ptr(trans, root, &path, level,
3825 * Remove the corresponding extent
3826 * return value is not concerned.
3828 btrfs_release_path(&path);
3829 ret = btrfs_free_extent(trans, root, offset, root->nodesize,
3830 0, root->root_key.objectid,
3832 cache = next_cache_extent(cache);
3835 /* Balance the btree using btrfs_search_slot() */
3836 cache = first_cache_extent(corrupt_blocks);
3838 corrupt = container_of(cache, struct btrfs_corrupt_block,
3840 memcpy(&key, &corrupt->key, sizeof(key));
3841 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
3844 /* return will always >0 since it won't find the item */
3846 btrfs_release_path(&path);
3847 cache = next_cache_extent(cache);
3850 btrfs_commit_transaction(trans, root);
3851 btrfs_release_path(&path);
3855 static int check_fs_root(struct btrfs_root *root,
3856 struct cache_tree *root_cache,
3857 struct walk_control *wc)
3863 struct btrfs_path path;
3864 struct shared_node root_node;
3865 struct root_record *rec;
3866 struct btrfs_root_item *root_item = &root->root_item;
3867 struct cache_tree corrupt_blocks;
3868 struct orphan_data_extent *orphan;
3869 struct orphan_data_extent *tmp;
3870 enum btrfs_tree_block_status status;
3871 struct node_refs nrefs;
3874 * Reuse the corrupt_block cache tree to record corrupted tree block
3876 * Unlike the usage in extent tree check, here we do it in a per
3877 * fs/subvol tree base.
3879 cache_tree_init(&corrupt_blocks);
3880 root->fs_info->corrupt_blocks = &corrupt_blocks;
3882 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3883 rec = get_root_rec(root_cache, root->root_key.objectid);
3884 BUG_ON(IS_ERR(rec));
3885 if (btrfs_root_refs(root_item) > 0)
3886 rec->found_root_item = 1;
3889 btrfs_init_path(&path);
3890 memset(&root_node, 0, sizeof(root_node));
3891 cache_tree_init(&root_node.root_cache);
3892 cache_tree_init(&root_node.inode_cache);
3893 memset(&nrefs, 0, sizeof(nrefs));
3895 /* Move the orphan extent record to corresponding inode_record */
3896 list_for_each_entry_safe(orphan, tmp,
3897 &root->orphan_data_extents, list) {
3898 struct inode_record *inode;
3900 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3902 BUG_ON(IS_ERR(inode));
3903 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3904 list_move(&orphan->list, &inode->orphan_extents);
3907 level = btrfs_header_level(root->node);
3908 memset(wc->nodes, 0, sizeof(wc->nodes));
3909 wc->nodes[level] = &root_node;
3910 wc->active_node = level;
3911 wc->root_level = level;
3913 /* We may not have checked the root block, lets do that now */
3914 if (btrfs_is_leaf(root->node))
3915 status = btrfs_check_leaf(root, NULL, root->node);
3917 status = btrfs_check_node(root, NULL, root->node);
3918 if (status != BTRFS_TREE_BLOCK_CLEAN)
3921 if (btrfs_root_refs(root_item) > 0 ||
3922 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3923 path.nodes[level] = root->node;
3924 extent_buffer_get(root->node);
3925 path.slots[level] = 0;
3927 struct btrfs_key key;
3928 struct btrfs_disk_key found_key;
3930 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3931 level = root_item->drop_level;
3932 path.lowest_level = level;
3933 if (level > btrfs_header_level(root->node) ||
3934 level >= BTRFS_MAX_LEVEL) {
3935 error("ignoring invalid drop level: %u", level);
3938 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3941 btrfs_node_key(path.nodes[level], &found_key,
3943 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3944 sizeof(found_key)));
3948 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
3954 wret = walk_up_tree(root, &path, wc, &level);
3961 btrfs_release_path(&path);
3963 if (!cache_tree_empty(&corrupt_blocks)) {
3964 struct cache_extent *cache;
3965 struct btrfs_corrupt_block *corrupt;
3967 printf("The following tree block(s) is corrupted in tree %llu:\n",
3968 root->root_key.objectid);
3969 cache = first_cache_extent(&corrupt_blocks);
3971 corrupt = container_of(cache,
3972 struct btrfs_corrupt_block,
3974 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
3975 cache->start, corrupt->level,
3976 corrupt->key.objectid, corrupt->key.type,
3977 corrupt->key.offset);
3978 cache = next_cache_extent(cache);
3981 printf("Try to repair the btree for root %llu\n",
3982 root->root_key.objectid);
3983 ret = repair_btree(root, &corrupt_blocks);
3985 fprintf(stderr, "Failed to repair btree: %s\n",
3988 printf("Btree for root %llu is fixed\n",
3989 root->root_key.objectid);
3993 err = merge_root_recs(root, &root_node.root_cache, root_cache);
3997 if (root_node.current) {
3998 root_node.current->checked = 1;
3999 maybe_free_inode_rec(&root_node.inode_cache,
4003 err = check_inode_recs(root, &root_node.inode_cache);
4007 free_corrupt_blocks_tree(&corrupt_blocks);
4008 root->fs_info->corrupt_blocks = NULL;
4009 free_orphan_data_extents(&root->orphan_data_extents);
4013 static int fs_root_objectid(u64 objectid)
4015 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4016 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4018 return is_fstree(objectid);
4021 static int check_fs_roots(struct btrfs_root *root,
4022 struct cache_tree *root_cache)
4024 struct btrfs_path path;
4025 struct btrfs_key key;
4026 struct walk_control wc;
4027 struct extent_buffer *leaf, *tree_node;
4028 struct btrfs_root *tmp_root;
4029 struct btrfs_root *tree_root = root->fs_info->tree_root;
4033 if (ctx.progress_enabled) {
4034 ctx.tp = TASK_FS_ROOTS;
4035 task_start(ctx.info);
4039 * Just in case we made any changes to the extent tree that weren't
4040 * reflected into the free space cache yet.
4043 reset_cached_block_groups(root->fs_info);
4044 memset(&wc, 0, sizeof(wc));
4045 cache_tree_init(&wc.shared);
4046 btrfs_init_path(&path);
4051 key.type = BTRFS_ROOT_ITEM_KEY;
4052 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4057 tree_node = tree_root->node;
4059 if (tree_node != tree_root->node) {
4060 free_root_recs_tree(root_cache);
4061 btrfs_release_path(&path);
4064 leaf = path.nodes[0];
4065 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4066 ret = btrfs_next_leaf(tree_root, &path);
4072 leaf = path.nodes[0];
4074 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4075 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4076 fs_root_objectid(key.objectid)) {
4077 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4078 tmp_root = btrfs_read_fs_root_no_cache(
4079 root->fs_info, &key);
4081 key.offset = (u64)-1;
4082 tmp_root = btrfs_read_fs_root(
4083 root->fs_info, &key);
4085 if (IS_ERR(tmp_root)) {
4089 ret = check_fs_root(tmp_root, root_cache, &wc);
4090 if (ret == -EAGAIN) {
4091 free_root_recs_tree(root_cache);
4092 btrfs_release_path(&path);
4097 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4098 btrfs_free_fs_root(tmp_root);
4099 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4100 key.type == BTRFS_ROOT_BACKREF_KEY) {
4101 process_root_ref(leaf, path.slots[0], &key,
4108 btrfs_release_path(&path);
4110 free_extent_cache_tree(&wc.shared);
4111 if (!cache_tree_empty(&wc.shared))
4112 fprintf(stderr, "warning line %d\n", __LINE__);
4114 task_stop(ctx.info);
4120 * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4121 * INODE_REF/INODE_EXTREF match.
4123 * @root: the root of the fs/file tree
4124 * @ref_key: the key of the INODE_REF/INODE_EXTREF
4125 * @key: the key of the DIR_ITEM/DIR_INDEX
4126 * @index: the index in the INODE_REF/INODE_EXTREF, be used to
4127 * distinguish root_dir between normal dir/file
4128 * @name: the name in the INODE_REF/INODE_EXTREF
4129 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4130 * @mode: the st_mode of INODE_ITEM
4132 * Return 0 if no error occurred.
4133 * Return ROOT_DIR_ERROR if found DIR_ITEM/DIR_INDEX for root_dir.
4134 * Return DIR_ITEM_MISSING if couldn't find DIR_ITEM/DIR_INDEX for normal
4136 * Return DIR_ITEM_MISMATCH if INODE_REF/INODE_EXTREF and DIR_ITEM/DIR_INDEX
4137 * not match for normal dir/file.
4139 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *ref_key,
4140 struct btrfs_key *key, u64 index, char *name,
4141 u32 namelen, u32 mode)
4143 struct btrfs_path path;
4144 struct extent_buffer *node;
4145 struct btrfs_dir_item *di;
4146 struct btrfs_key location;
4147 char namebuf[BTRFS_NAME_LEN] = {0};
4157 btrfs_init_path(&path);
4158 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4160 ret = DIR_ITEM_MISSING;
4164 /* Process root dir and goto out*/
4167 ret = ROOT_DIR_ERROR;
4169 "root %llu INODE %s[%llu %llu] ROOT_DIR shouldn't have %s",
4171 ref_key->type == BTRFS_INODE_REF_KEY ?
4173 ref_key->objectid, ref_key->offset,
4174 key->type == BTRFS_DIR_ITEM_KEY ?
4175 "DIR_ITEM" : "DIR_INDEX");
4183 /* Process normal file/dir */
4185 ret = DIR_ITEM_MISSING;
4187 "root %llu INODE %s[%llu %llu] doesn't have related %s[%llu %llu] namelen %u filename %s filetype %d",
4189 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4190 ref_key->objectid, ref_key->offset,
4191 key->type == BTRFS_DIR_ITEM_KEY ?
4192 "DIR_ITEM" : "DIR_INDEX",
4193 key->objectid, key->offset, namelen, name,
4194 imode_to_type(mode));
4198 /* Check whether inode_id/filetype/name match */
4199 node = path.nodes[0];
4200 slot = path.slots[0];
4201 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4202 total = btrfs_item_size_nr(node, slot);
4203 while (cur < total) {
4204 ret = DIR_ITEM_MISMATCH;
4205 name_len = btrfs_dir_name_len(node, di);
4206 data_len = btrfs_dir_data_len(node, di);
4208 btrfs_dir_item_key_to_cpu(node, di, &location);
4209 if (location.objectid != ref_key->objectid ||
4210 location.type != BTRFS_INODE_ITEM_KEY ||
4211 location.offset != 0)
4214 filetype = btrfs_dir_type(node, di);
4215 if (imode_to_type(mode) != filetype)
4218 if (name_len <= BTRFS_NAME_LEN) {
4221 len = BTRFS_NAME_LEN;
4222 warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4224 key->type == BTRFS_DIR_ITEM_KEY ?
4225 "DIR_ITEM" : "DIR_INDEX",
4226 key->objectid, key->offset, name_len);
4228 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4229 if (len != namelen || strncmp(namebuf, name, len))
4235 len = sizeof(*di) + name_len + data_len;
4236 di = (struct btrfs_dir_item *)((char *)di + len);
4239 if (ret == DIR_ITEM_MISMATCH)
4241 "root %llu INODE %s[%llu %llu] and %s[%llu %llu] mismatch namelen %u filename %s filetype %d",
4243 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4244 ref_key->objectid, ref_key->offset,
4245 key->type == BTRFS_DIR_ITEM_KEY ?
4246 "DIR_ITEM" : "DIR_INDEX",
4247 key->objectid, key->offset, namelen, name,
4248 imode_to_type(mode));
4250 btrfs_release_path(&path);
4255 * Traverse the given INODE_REF and call find_dir_item() to find related
4256 * DIR_ITEM/DIR_INDEX.
4258 * @root: the root of the fs/file tree
4259 * @ref_key: the key of the INODE_REF
4260 * @refs: the count of INODE_REF
4261 * @mode: the st_mode of INODE_ITEM
4263 * Return 0 if no error occurred.
4265 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4266 struct extent_buffer *node, int slot, u64 *refs,
4269 struct btrfs_key key;
4270 struct btrfs_inode_ref *ref;
4271 char namebuf[BTRFS_NAME_LEN] = {0};
4279 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4280 total = btrfs_item_size_nr(node, slot);
4283 /* Update inode ref count */
4286 index = btrfs_inode_ref_index(node, ref);
4287 name_len = btrfs_inode_ref_name_len(node, ref);
4288 if (name_len <= BTRFS_NAME_LEN) {
4291 len = BTRFS_NAME_LEN;
4292 warning("root %llu INODE_REF[%llu %llu] name too long",
4293 root->objectid, ref_key->objectid, ref_key->offset);
4296 read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
4298 /* Check root dir ref name */
4299 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4300 error("root %llu INODE_REF[%llu %llu] ROOT_DIR name shouldn't be %s",
4301 root->objectid, ref_key->objectid, ref_key->offset,
4303 err |= ROOT_DIR_ERROR;
4306 /* Find related DIR_INDEX */
4307 key.objectid = ref_key->offset;
4308 key.type = BTRFS_DIR_INDEX_KEY;
4310 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4313 /* Find related dir_item */
4314 key.objectid = ref_key->offset;
4315 key.type = BTRFS_DIR_ITEM_KEY;
4316 key.offset = btrfs_name_hash(namebuf, len);
4317 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4320 len = sizeof(*ref) + name_len;
4321 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4330 * Traverse the given INODE_EXTREF and call find_dir_item() to find related
4331 * DIR_ITEM/DIR_INDEX.
4333 * @root: the root of the fs/file tree
4334 * @ref_key: the key of the INODE_EXTREF
4335 * @refs: the count of INODE_EXTREF
4336 * @mode: the st_mode of INODE_ITEM
4338 * Return 0 if no error occurred.
4340 static int check_inode_extref(struct btrfs_root *root,
4341 struct btrfs_key *ref_key,
4342 struct extent_buffer *node, int slot, u64 *refs,
4345 struct btrfs_key key;
4346 struct btrfs_inode_extref *extref;
4347 char namebuf[BTRFS_NAME_LEN] = {0};
4357 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4358 total = btrfs_item_size_nr(node, slot);
4361 /* update inode ref count */
4363 name_len = btrfs_inode_extref_name_len(node, extref);
4364 index = btrfs_inode_extref_index(node, extref);
4365 parent = btrfs_inode_extref_parent(node, extref);
4366 if (name_len <= BTRFS_NAME_LEN) {
4369 len = BTRFS_NAME_LEN;
4370 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
4371 root->objectid, ref_key->objectid, ref_key->offset);
4373 read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
4375 /* Check root dir ref name */
4376 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4377 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
4378 root->objectid, ref_key->objectid, ref_key->offset,
4380 err |= ROOT_DIR_ERROR;
4383 /* find related dir_index */
4384 key.objectid = parent;
4385 key.type = BTRFS_DIR_INDEX_KEY;
4387 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4390 /* find related dir_item */
4391 key.objectid = parent;
4392 key.type = BTRFS_DIR_ITEM_KEY;
4393 key.offset = btrfs_name_hash(namebuf, len);
4394 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4397 len = sizeof(*extref) + name_len;
4398 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4408 * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
4409 * DIR_ITEM/DIR_INDEX match.
4411 * @root: the root of the fs/file tree
4412 * @key: the key of the INODE_REF/INODE_EXTREF
4413 * @name: the name in the INODE_REF/INODE_EXTREF
4414 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4415 * @index: the index in the INODE_REF/INODE_EXTREF, for DIR_ITEM set index
4417 * @ext_ref: the EXTENDED_IREF feature
4419 * Return 0 if no error occurred.
4420 * Return >0 for error bitmap
4422 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
4423 char *name, int namelen, u64 index,
4424 unsigned int ext_ref)
4426 struct btrfs_path path;
4427 struct btrfs_inode_ref *ref;
4428 struct btrfs_inode_extref *extref;
4429 struct extent_buffer *node;
4430 char ref_namebuf[BTRFS_NAME_LEN] = {0};
4441 btrfs_init_path(&path);
4442 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4444 ret = INODE_REF_MISSING;
4448 node = path.nodes[0];
4449 slot = path.slots[0];
4451 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4452 total = btrfs_item_size_nr(node, slot);
4454 /* Iterate all entry of INODE_REF */
4455 while (cur < total) {
4456 ret = INODE_REF_MISSING;
4458 ref_namelen = btrfs_inode_ref_name_len(node, ref);
4459 ref_index = btrfs_inode_ref_index(node, ref);
4460 if (index != (u64)-1 && index != ref_index)
4463 if (ref_namelen <= BTRFS_NAME_LEN) {
4466 len = BTRFS_NAME_LEN;
4467 warning("root %llu INODE %s[%llu %llu] name too long",
4469 key->type == BTRFS_INODE_REF_KEY ?
4471 key->objectid, key->offset);
4473 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
4476 if (len != namelen || strncmp(ref_namebuf, name, len))
4482 len = sizeof(*ref) + ref_namelen;
4483 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4488 /* Skip if not support EXTENDED_IREF feature */
4492 btrfs_release_path(&path);
4493 btrfs_init_path(&path);
4495 dir_id = key->offset;
4496 key->type = BTRFS_INODE_EXTREF_KEY;
4497 key->offset = btrfs_extref_hash(dir_id, name, namelen);
4499 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4501 ret = INODE_REF_MISSING;
4505 node = path.nodes[0];
4506 slot = path.slots[0];
4508 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4510 total = btrfs_item_size_nr(node, slot);
4512 /* Iterate all entry of INODE_EXTREF */
4513 while (cur < total) {
4514 ret = INODE_REF_MISSING;
4516 ref_namelen = btrfs_inode_extref_name_len(node, extref);
4517 ref_index = btrfs_inode_extref_index(node, extref);
4518 parent = btrfs_inode_extref_parent(node, extref);
4519 if (index != (u64)-1 && index != ref_index)
4522 if (parent != dir_id)
4525 if (ref_namelen <= BTRFS_NAME_LEN) {
4528 len = BTRFS_NAME_LEN;
4529 warning("root %llu INODE %s[%llu %llu] name too long",
4531 key->type == BTRFS_INODE_REF_KEY ?
4533 key->objectid, key->offset);
4535 read_extent_buffer(node, ref_namebuf,
4536 (unsigned long)(extref + 1), len);
4538 if (len != namelen || strncmp(ref_namebuf, name, len))
4545 len = sizeof(*extref) + ref_namelen;
4546 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4551 btrfs_release_path(&path);
4556 * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
4557 * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
4559 * @root: the root of the fs/file tree
4560 * @key: the key of the INODE_REF/INODE_EXTREF
4561 * @size: the st_size of the INODE_ITEM
4562 * @ext_ref: the EXTENDED_IREF feature
4564 * Return 0 if no error occurred.
4566 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4567 struct extent_buffer *node, int slot, u64 *size,
4568 unsigned int ext_ref)
4570 struct btrfs_dir_item *di;
4571 struct btrfs_inode_item *ii;
4572 struct btrfs_path path;
4573 struct btrfs_key location;
4574 char namebuf[BTRFS_NAME_LEN] = {0};
4587 * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
4588 * ignore index check.
4590 index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
4592 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4593 total = btrfs_item_size_nr(node, slot);
4595 while (cur < total) {
4596 data_len = btrfs_dir_data_len(node, di);
4598 error("root %llu %s[%llu %llu] data_len shouldn't be %u",
4599 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4600 "DIR_ITEM" : "DIR_INDEX",
4601 key->objectid, key->offset, data_len);
4603 name_len = btrfs_dir_name_len(node, di);
4604 if (name_len <= BTRFS_NAME_LEN) {
4607 len = BTRFS_NAME_LEN;
4608 warning("root %llu %s[%llu %llu] name too long",
4610 key->type == BTRFS_DIR_ITEM_KEY ?
4611 "DIR_ITEM" : "DIR_INDEX",
4612 key->objectid, key->offset);
4614 (*size) += name_len;
4616 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4617 filetype = btrfs_dir_type(node, di);
4619 btrfs_init_path(&path);
4620 btrfs_dir_item_key_to_cpu(node, di, &location);
4622 /* Ignore related ROOT_ITEM check */
4623 if (location.type == BTRFS_ROOT_ITEM_KEY)
4626 /* Check relative INODE_ITEM(existence/filetype) */
4627 ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
4629 err |= INODE_ITEM_MISSING;
4630 error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
4631 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4632 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4633 key->offset, location.objectid, name_len,
4638 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4639 struct btrfs_inode_item);
4640 mode = btrfs_inode_mode(path.nodes[0], ii);
4642 if (imode_to_type(mode) != filetype) {
4643 err |= INODE_ITEM_MISMATCH;
4644 error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
4645 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4646 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4647 key->offset, name_len, namebuf, filetype);
4650 /* Check relative INODE_REF/INODE_EXTREF */
4651 location.type = BTRFS_INODE_REF_KEY;
4652 location.offset = key->objectid;
4653 ret = find_inode_ref(root, &location, namebuf, len,
4656 if (ret & INODE_REF_MISSING)
4657 error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
4658 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4659 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4660 key->offset, name_len, namebuf, filetype);
4663 btrfs_release_path(&path);
4664 len = sizeof(*di) + name_len + data_len;
4665 di = (struct btrfs_dir_item *)((char *)di + len);
4668 if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
4669 error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
4670 root->objectid, key->objectid, key->offset);
4679 * Check file extent datasum/hole, update the size of the file extents,
4680 * check and update the last offset of the file extent.
4682 * @root: the root of fs/file tree.
4683 * @fkey: the key of the file extent.
4684 * @nodatasum: INODE_NODATASUM feature.
4685 * @size: the sum of all EXTENT_DATA items size for this inode.
4686 * @end: the offset of the last extent.
4688 * Return 0 if no error occurred.
4690 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
4691 struct extent_buffer *node, int slot,
4692 unsigned int nodatasum, u64 *size, u64 *end)
4694 struct btrfs_file_extent_item *fi;
4697 u64 extent_num_bytes;
4699 unsigned int extent_type;
4700 unsigned int is_hole;
4704 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4706 extent_type = btrfs_file_extent_type(node, fi);
4707 /* Skip if file extent is inline */
4708 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4709 struct btrfs_item *e = btrfs_item_nr(slot);
4710 u32 item_inline_len;
4712 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4713 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4714 if (extent_num_bytes == 0 ||
4715 extent_num_bytes != item_inline_len)
4716 err |= FILE_EXTENT_ERROR;
4717 *size += extent_num_bytes;
4721 /* Check extent type */
4722 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4723 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4724 err |= FILE_EXTENT_ERROR;
4725 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4726 root->objectid, fkey->objectid, fkey->offset);
4730 /* Check REG_EXTENT/PREALLOC_EXTENT */
4731 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4732 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4733 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4734 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4736 /* Check EXTENT_DATA datasum */
4737 ret = count_csum_range(root, disk_bytenr, disk_num_bytes, &found);
4738 if (found > 0 && nodatasum) {
4739 err |= ODD_CSUM_ITEM;
4740 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4741 root->objectid, fkey->objectid, fkey->offset);
4742 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4744 (ret < 0 || found == 0 || found < disk_num_bytes)) {
4745 err |= CSUM_ITEM_MISSING;
4746 error("root %llu EXTENT_DATA[%llu %llu] datasum missing",
4747 root->objectid, fkey->objectid, fkey->offset);
4748 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && found > 0) {
4749 err |= ODD_CSUM_ITEM;
4750 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have datasum",
4751 root->objectid, fkey->objectid, fkey->offset);
4754 /* Check EXTENT_DATA hole */
4755 if (no_holes && is_hole) {
4756 err |= FILE_EXTENT_ERROR;
4757 error("root %llu EXTENT_DATA[%llu %llu] shouldn't be hole",
4758 root->objectid, fkey->objectid, fkey->offset);
4759 } else if (!no_holes && *end != fkey->offset) {
4760 err |= FILE_EXTENT_ERROR;
4761 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4762 root->objectid, fkey->objectid, fkey->offset);
4765 *end += extent_num_bytes;
4767 *size += extent_num_bytes;
4773 * Check INODE_ITEM and related ITEMs (the same inode number)
4774 * 1. check link count
4775 * 2. check inode ref/extref
4776 * 3. check dir item/index
4778 * @ext_ref: the EXTENDED_IREF feature
4780 * Return 0 if no error occurred.
4781 * Return >0 for error or hit the traversal is done(by error bitmap)
4783 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4784 unsigned int ext_ref)
4786 struct extent_buffer *node;
4787 struct btrfs_inode_item *ii;
4788 struct btrfs_key key;
4797 u64 extent_size = 0;
4799 unsigned int nodatasum;
4804 node = path->nodes[0];
4805 slot = path->slots[0];
4807 btrfs_item_key_to_cpu(node, &key, slot);
4808 inode_id = key.objectid;
4810 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4811 ret = btrfs_next_item(root, path);
4817 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4818 isize = btrfs_inode_size(node, ii);
4819 nbytes = btrfs_inode_nbytes(node, ii);
4820 mode = btrfs_inode_mode(node, ii);
4821 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4822 nlink = btrfs_inode_nlink(node, ii);
4823 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4826 ret = btrfs_next_item(root, path);
4828 /* out will fill 'err' rusing current statistics */
4830 } else if (ret > 0) {
4835 node = path->nodes[0];
4836 slot = path->slots[0];
4837 btrfs_item_key_to_cpu(node, &key, slot);
4838 if (key.objectid != inode_id)
4842 case BTRFS_INODE_REF_KEY:
4843 ret = check_inode_ref(root, &key, node, slot, &refs,
4847 case BTRFS_INODE_EXTREF_KEY:
4848 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4849 warning("root %llu EXTREF[%llu %llu] isn't supported",
4850 root->objectid, key.objectid,
4852 ret = check_inode_extref(root, &key, node, slot, &refs,
4856 case BTRFS_DIR_ITEM_KEY:
4857 case BTRFS_DIR_INDEX_KEY:
4859 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4860 root->objectid, inode_id,
4861 imode_to_type(mode), key.objectid,
4864 ret = check_dir_item(root, &key, node, slot, &size,
4868 case BTRFS_EXTENT_DATA_KEY:
4870 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4871 root->objectid, inode_id, key.objectid,
4874 ret = check_file_extent(root, &key, node, slot,
4875 nodatasum, &extent_size,
4879 case BTRFS_XATTR_ITEM_KEY:
4882 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4883 key.objectid, key.type, key.offset);
4888 /* verify INODE_ITEM nlink/isize/nbytes */
4891 err |= LINK_COUNT_ERROR;
4892 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4893 root->objectid, inode_id, nlink);
4897 * Just a warning, as dir inode nbytes is just an
4898 * instructive value.
4900 if (!IS_ALIGNED(nbytes, root->nodesize)) {
4901 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
4902 root->objectid, inode_id, root->nodesize);
4905 if (isize != size) {
4907 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
4908 root->objectid, inode_id, isize, size);
4911 if (nlink != refs) {
4912 err |= LINK_COUNT_ERROR;
4913 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
4914 root->objectid, inode_id, nlink, refs);
4915 } else if (!nlink) {
4919 if (!nbytes && !no_holes && extent_end < isize) {
4920 err |= NBYTES_ERROR;
4921 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
4922 root->objectid, inode_id, isize);
4925 if (nbytes != extent_size) {
4926 err |= NBYTES_ERROR;
4927 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
4928 root->objectid, inode_id, nbytes, extent_size);
4935 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4937 struct btrfs_path path;
4938 struct btrfs_key key;
4942 btrfs_init_path(&path);
4943 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4944 key.type = BTRFS_INODE_ITEM_KEY;
4947 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4952 err |= INODE_ITEM_MISSING;
4955 err |= check_inode_item(root, &path, ext_ref);
4960 btrfs_release_path(&path);
4965 * Iterate all item on the tree and call check_inode_item() to check.
4967 * @root: the root of the tree to be checked.
4968 * @ext_ref: the EXTENDED_IREF feature
4970 * Return 0 if no error found.
4971 * Return <0 for error.
4973 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
4975 struct btrfs_path path;
4976 struct node_refs nrefs;
4977 struct btrfs_root_item *root_item = &root->root_item;
4982 * We need to manually check the first inode item(256)
4983 * As the following traversal function will only start from
4984 * the first inode item in the leaf, if inode item(256) is missing
4985 * we will just skip it forever.
4987 ret = check_fs_first_inode(root, ext_ref);
4991 memset(&nrefs, 0, sizeof(nrefs));
4992 level = btrfs_header_level(root->node);
4993 btrfs_init_path(&path);
4995 if (btrfs_root_refs(root_item) > 0 ||
4996 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
4997 path.nodes[level] = root->node;
4998 path.slots[level] = 0;
4999 extent_buffer_get(root->node);
5001 struct btrfs_key key;
5003 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5004 level = root_item->drop_level;
5005 path.lowest_level = level;
5006 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5013 wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5019 wret = walk_up_tree_v2(root, &path, &level);
5027 btrfs_release_path(&path);
5032 * Find the relative ref for root_ref and root_backref.
5034 * @root: the root of the root tree.
5035 * @ref_key: the key of the root ref.
5037 * Return 0 if no error occurred.
5039 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5040 struct extent_buffer *node, int slot)
5042 struct btrfs_path path;
5043 struct btrfs_key key;
5044 struct btrfs_root_ref *ref;
5045 struct btrfs_root_ref *backref;
5046 char ref_name[BTRFS_NAME_LEN] = {0};
5047 char backref_name[BTRFS_NAME_LEN] = {0};
5053 u32 backref_namelen;
5058 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5059 ref_dirid = btrfs_root_ref_dirid(node, ref);
5060 ref_seq = btrfs_root_ref_sequence(node, ref);
5061 ref_namelen = btrfs_root_ref_name_len(node, ref);
5063 if (ref_namelen <= BTRFS_NAME_LEN) {
5066 len = BTRFS_NAME_LEN;
5067 warning("%s[%llu %llu] ref_name too long",
5068 ref_key->type == BTRFS_ROOT_REF_KEY ?
5069 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5072 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5074 /* Find relative root_ref */
5075 key.objectid = ref_key->offset;
5076 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5077 key.offset = ref_key->objectid;
5079 btrfs_init_path(&path);
5080 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5082 err |= ROOT_REF_MISSING;
5083 error("%s[%llu %llu] couldn't find relative ref",
5084 ref_key->type == BTRFS_ROOT_REF_KEY ?
5085 "ROOT_REF" : "ROOT_BACKREF",
5086 ref_key->objectid, ref_key->offset);
5090 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5091 struct btrfs_root_ref);
5092 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5093 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5094 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5096 if (backref_namelen <= BTRFS_NAME_LEN) {
5097 len = backref_namelen;
5099 len = BTRFS_NAME_LEN;
5100 warning("%s[%llu %llu] ref_name too long",
5101 key.type == BTRFS_ROOT_REF_KEY ?
5102 "ROOT_REF" : "ROOT_BACKREF",
5103 key.objectid, key.offset);
5105 read_extent_buffer(path.nodes[0], backref_name,
5106 (unsigned long)(backref + 1), len);
5108 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5109 ref_namelen != backref_namelen ||
5110 strncmp(ref_name, backref_name, len)) {
5111 err |= ROOT_REF_MISMATCH;
5112 error("%s[%llu %llu] mismatch relative ref",
5113 ref_key->type == BTRFS_ROOT_REF_KEY ?
5114 "ROOT_REF" : "ROOT_BACKREF",
5115 ref_key->objectid, ref_key->offset);
5118 btrfs_release_path(&path);
5123 * Check all fs/file tree in low_memory mode.
5125 * 1. for fs tree root item, call check_fs_root_v2()
5126 * 2. for fs tree root ref/backref, call check_root_ref()
5128 * Return 0 if no error occurred.
5130 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5132 struct btrfs_root *tree_root = fs_info->tree_root;
5133 struct btrfs_root *cur_root = NULL;
5134 struct btrfs_path path;
5135 struct btrfs_key key;
5136 struct extent_buffer *node;
5137 unsigned int ext_ref;
5142 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5144 btrfs_init_path(&path);
5145 key.objectid = BTRFS_FS_TREE_OBJECTID;
5147 key.type = BTRFS_ROOT_ITEM_KEY;
5149 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5153 } else if (ret > 0) {
5159 node = path.nodes[0];
5160 slot = path.slots[0];
5161 btrfs_item_key_to_cpu(node, &key, slot);
5162 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5164 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5165 fs_root_objectid(key.objectid)) {
5166 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5167 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5170 key.offset = (u64)-1;
5171 cur_root = btrfs_read_fs_root(fs_info, &key);
5174 if (IS_ERR(cur_root)) {
5175 error("Fail to read fs/subvol tree: %lld",
5181 ret = check_fs_root_v2(cur_root, ext_ref);
5184 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5185 btrfs_free_fs_root(cur_root);
5186 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5187 key.type == BTRFS_ROOT_BACKREF_KEY) {
5188 ret = check_root_ref(tree_root, &key, node, slot);
5192 ret = btrfs_next_item(tree_root, &path);
5202 btrfs_release_path(&path);
5206 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5208 struct list_head *cur = rec->backrefs.next;
5209 struct extent_backref *back;
5210 struct tree_backref *tback;
5211 struct data_backref *dback;
5215 while(cur != &rec->backrefs) {
5216 back = to_extent_backref(cur);
5218 if (!back->found_extent_tree) {
5222 if (back->is_data) {
5223 dback = to_data_backref(back);
5224 fprintf(stderr, "Backref %llu %s %llu"
5225 " owner %llu offset %llu num_refs %lu"
5226 " not found in extent tree\n",
5227 (unsigned long long)rec->start,
5228 back->full_backref ?
5230 back->full_backref ?
5231 (unsigned long long)dback->parent:
5232 (unsigned long long)dback->root,
5233 (unsigned long long)dback->owner,
5234 (unsigned long long)dback->offset,
5235 (unsigned long)dback->num_refs);
5237 tback = to_tree_backref(back);
5238 fprintf(stderr, "Backref %llu parent %llu"
5239 " root %llu not found in extent tree\n",
5240 (unsigned long long)rec->start,
5241 (unsigned long long)tback->parent,
5242 (unsigned long long)tback->root);
5245 if (!back->is_data && !back->found_ref) {
5249 tback = to_tree_backref(back);
5250 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5251 (unsigned long long)rec->start,
5252 back->full_backref ? "parent" : "root",
5253 back->full_backref ?
5254 (unsigned long long)tback->parent :
5255 (unsigned long long)tback->root, back);
5257 if (back->is_data) {
5258 dback = to_data_backref(back);
5259 if (dback->found_ref != dback->num_refs) {
5263 fprintf(stderr, "Incorrect local backref count"
5264 " on %llu %s %llu owner %llu"
5265 " offset %llu found %u wanted %u back %p\n",
5266 (unsigned long long)rec->start,
5267 back->full_backref ?
5269 back->full_backref ?
5270 (unsigned long long)dback->parent:
5271 (unsigned long long)dback->root,
5272 (unsigned long long)dback->owner,
5273 (unsigned long long)dback->offset,
5274 dback->found_ref, dback->num_refs, back);
5276 if (dback->disk_bytenr != rec->start) {
5280 fprintf(stderr, "Backref disk bytenr does not"
5281 " match extent record, bytenr=%llu, "
5282 "ref bytenr=%llu\n",
5283 (unsigned long long)rec->start,
5284 (unsigned long long)dback->disk_bytenr);
5287 if (dback->bytes != rec->nr) {
5291 fprintf(stderr, "Backref bytes do not match "
5292 "extent backref, bytenr=%llu, ref "
5293 "bytes=%llu, backref bytes=%llu\n",
5294 (unsigned long long)rec->start,
5295 (unsigned long long)rec->nr,
5296 (unsigned long long)dback->bytes);
5299 if (!back->is_data) {
5302 dback = to_data_backref(back);
5303 found += dback->found_ref;
5306 if (found != rec->refs) {
5310 fprintf(stderr, "Incorrect global backref count "
5311 "on %llu found %llu wanted %llu\n",
5312 (unsigned long long)rec->start,
5313 (unsigned long long)found,
5314 (unsigned long long)rec->refs);
5320 static int free_all_extent_backrefs(struct extent_record *rec)
5322 struct extent_backref *back;
5323 struct list_head *cur;
5324 while (!list_empty(&rec->backrefs)) {
5325 cur = rec->backrefs.next;
5326 back = to_extent_backref(cur);
5333 static void free_extent_record_cache(struct btrfs_fs_info *fs_info,
5334 struct cache_tree *extent_cache)
5336 struct cache_extent *cache;
5337 struct extent_record *rec;
5340 cache = first_cache_extent(extent_cache);
5343 rec = container_of(cache, struct extent_record, cache);
5344 remove_cache_extent(extent_cache, cache);
5345 free_all_extent_backrefs(rec);
5350 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5351 struct extent_record *rec)
5353 if (rec->content_checked && rec->owner_ref_checked &&
5354 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5355 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5356 !rec->bad_full_backref && !rec->crossing_stripes &&
5357 !rec->wrong_chunk_type) {
5358 remove_cache_extent(extent_cache, &rec->cache);
5359 free_all_extent_backrefs(rec);
5360 list_del_init(&rec->list);
5366 static int check_owner_ref(struct btrfs_root *root,
5367 struct extent_record *rec,
5368 struct extent_buffer *buf)
5370 struct extent_backref *node;
5371 struct tree_backref *back;
5372 struct btrfs_root *ref_root;
5373 struct btrfs_key key;
5374 struct btrfs_path path;
5375 struct extent_buffer *parent;
5380 list_for_each_entry(node, &rec->backrefs, list) {
5383 if (!node->found_ref)
5385 if (node->full_backref)
5387 back = to_tree_backref(node);
5388 if (btrfs_header_owner(buf) == back->root)
5391 BUG_ON(rec->is_root);
5393 /* try to find the block by search corresponding fs tree */
5394 key.objectid = btrfs_header_owner(buf);
5395 key.type = BTRFS_ROOT_ITEM_KEY;
5396 key.offset = (u64)-1;
5398 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5399 if (IS_ERR(ref_root))
5402 level = btrfs_header_level(buf);
5404 btrfs_item_key_to_cpu(buf, &key, 0);
5406 btrfs_node_key_to_cpu(buf, &key, 0);
5408 btrfs_init_path(&path);
5409 path.lowest_level = level + 1;
5410 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5414 parent = path.nodes[level + 1];
5415 if (parent && buf->start == btrfs_node_blockptr(parent,
5416 path.slots[level + 1]))
5419 btrfs_release_path(&path);
5420 return found ? 0 : 1;
5423 static int is_extent_tree_record(struct extent_record *rec)
5425 struct list_head *cur = rec->backrefs.next;
5426 struct extent_backref *node;
5427 struct tree_backref *back;
5430 while(cur != &rec->backrefs) {
5431 node = to_extent_backref(cur);
5435 back = to_tree_backref(node);
5436 if (node->full_backref)
5438 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5445 static int record_bad_block_io(struct btrfs_fs_info *info,
5446 struct cache_tree *extent_cache,
5449 struct extent_record *rec;
5450 struct cache_extent *cache;
5451 struct btrfs_key key;
5453 cache = lookup_cache_extent(extent_cache, start, len);
5457 rec = container_of(cache, struct extent_record, cache);
5458 if (!is_extent_tree_record(rec))
5461 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5462 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5465 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5466 struct extent_buffer *buf, int slot)
5468 if (btrfs_header_level(buf)) {
5469 struct btrfs_key_ptr ptr1, ptr2;
5471 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5472 sizeof(struct btrfs_key_ptr));
5473 read_extent_buffer(buf, &ptr2,
5474 btrfs_node_key_ptr_offset(slot + 1),
5475 sizeof(struct btrfs_key_ptr));
5476 write_extent_buffer(buf, &ptr1,
5477 btrfs_node_key_ptr_offset(slot + 1),
5478 sizeof(struct btrfs_key_ptr));
5479 write_extent_buffer(buf, &ptr2,
5480 btrfs_node_key_ptr_offset(slot),
5481 sizeof(struct btrfs_key_ptr));
5483 struct btrfs_disk_key key;
5484 btrfs_node_key(buf, &key, 0);
5485 btrfs_fixup_low_keys(root, path, &key,
5486 btrfs_header_level(buf) + 1);
5489 struct btrfs_item *item1, *item2;
5490 struct btrfs_key k1, k2;
5491 char *item1_data, *item2_data;
5492 u32 item1_offset, item2_offset, item1_size, item2_size;
5494 item1 = btrfs_item_nr(slot);
5495 item2 = btrfs_item_nr(slot + 1);
5496 btrfs_item_key_to_cpu(buf, &k1, slot);
5497 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5498 item1_offset = btrfs_item_offset(buf, item1);
5499 item2_offset = btrfs_item_offset(buf, item2);
5500 item1_size = btrfs_item_size(buf, item1);
5501 item2_size = btrfs_item_size(buf, item2);
5503 item1_data = malloc(item1_size);
5506 item2_data = malloc(item2_size);
5512 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5513 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5515 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5516 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5520 btrfs_set_item_offset(buf, item1, item2_offset);
5521 btrfs_set_item_offset(buf, item2, item1_offset);
5522 btrfs_set_item_size(buf, item1, item2_size);
5523 btrfs_set_item_size(buf, item2, item1_size);
5525 path->slots[0] = slot;
5526 btrfs_set_item_key_unsafe(root, path, &k2);
5527 path->slots[0] = slot + 1;
5528 btrfs_set_item_key_unsafe(root, path, &k1);
5533 static int fix_key_order(struct btrfs_trans_handle *trans,
5534 struct btrfs_root *root,
5535 struct btrfs_path *path)
5537 struct extent_buffer *buf;
5538 struct btrfs_key k1, k2;
5540 int level = path->lowest_level;
5543 buf = path->nodes[level];
5544 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5546 btrfs_node_key_to_cpu(buf, &k1, i);
5547 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5549 btrfs_item_key_to_cpu(buf, &k1, i);
5550 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5552 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5554 ret = swap_values(root, path, buf, i);
5557 btrfs_mark_buffer_dirty(buf);
5563 static int delete_bogus_item(struct btrfs_trans_handle *trans,
5564 struct btrfs_root *root,
5565 struct btrfs_path *path,
5566 struct extent_buffer *buf, int slot)
5568 struct btrfs_key key;
5569 int nritems = btrfs_header_nritems(buf);
5571 btrfs_item_key_to_cpu(buf, &key, slot);
5573 /* These are all the keys we can deal with missing. */
5574 if (key.type != BTRFS_DIR_INDEX_KEY &&
5575 key.type != BTRFS_EXTENT_ITEM_KEY &&
5576 key.type != BTRFS_METADATA_ITEM_KEY &&
5577 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5578 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5581 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5582 (unsigned long long)key.objectid, key.type,
5583 (unsigned long long)key.offset, slot, buf->start);
5584 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5585 btrfs_item_nr_offset(slot + 1),
5586 sizeof(struct btrfs_item) *
5587 (nritems - slot - 1));
5588 btrfs_set_header_nritems(buf, nritems - 1);
5590 struct btrfs_disk_key disk_key;
5592 btrfs_item_key(buf, &disk_key, 0);
5593 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5595 btrfs_mark_buffer_dirty(buf);
5599 static int fix_item_offset(struct btrfs_trans_handle *trans,
5600 struct btrfs_root *root,
5601 struct btrfs_path *path)
5603 struct extent_buffer *buf;
5607 /* We should only get this for leaves */
5608 BUG_ON(path->lowest_level);
5609 buf = path->nodes[0];
5611 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5612 unsigned int shift = 0, offset;
5614 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5615 BTRFS_LEAF_DATA_SIZE(root)) {
5616 if (btrfs_item_end_nr(buf, i) >
5617 BTRFS_LEAF_DATA_SIZE(root)) {
5618 ret = delete_bogus_item(trans, root, path,
5622 fprintf(stderr, "item is off the end of the "
5623 "leaf, can't fix\n");
5627 shift = BTRFS_LEAF_DATA_SIZE(root) -
5628 btrfs_item_end_nr(buf, i);
5629 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5630 btrfs_item_offset_nr(buf, i - 1)) {
5631 if (btrfs_item_end_nr(buf, i) >
5632 btrfs_item_offset_nr(buf, i - 1)) {
5633 ret = delete_bogus_item(trans, root, path,
5637 fprintf(stderr, "items overlap, can't fix\n");
5641 shift = btrfs_item_offset_nr(buf, i - 1) -
5642 btrfs_item_end_nr(buf, i);
5647 printf("Shifting item nr %d by %u bytes in block %llu\n",
5648 i, shift, (unsigned long long)buf->start);
5649 offset = btrfs_item_offset_nr(buf, i);
5650 memmove_extent_buffer(buf,
5651 btrfs_leaf_data(buf) + offset + shift,
5652 btrfs_leaf_data(buf) + offset,
5653 btrfs_item_size_nr(buf, i));
5654 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5656 btrfs_mark_buffer_dirty(buf);
5660 * We may have moved things, in which case we want to exit so we don't
5661 * write those changes out. Once we have proper abort functionality in
5662 * progs this can be changed to something nicer.
5669 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5670 * then just return -EIO.
5672 static int try_to_fix_bad_block(struct btrfs_root *root,
5673 struct extent_buffer *buf,
5674 enum btrfs_tree_block_status status)
5676 struct btrfs_trans_handle *trans;
5677 struct ulist *roots;
5678 struct ulist_node *node;
5679 struct btrfs_root *search_root;
5680 struct btrfs_path path;
5681 struct ulist_iterator iter;
5682 struct btrfs_key root_key, key;
5685 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5686 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5689 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5693 btrfs_init_path(&path);
5694 ULIST_ITER_INIT(&iter);
5695 while ((node = ulist_next(roots, &iter))) {
5696 root_key.objectid = node->val;
5697 root_key.type = BTRFS_ROOT_ITEM_KEY;
5698 root_key.offset = (u64)-1;
5700 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5707 trans = btrfs_start_transaction(search_root, 0);
5708 if (IS_ERR(trans)) {
5709 ret = PTR_ERR(trans);
5713 path.lowest_level = btrfs_header_level(buf);
5714 path.skip_check_block = 1;
5715 if (path.lowest_level)
5716 btrfs_node_key_to_cpu(buf, &key, 0);
5718 btrfs_item_key_to_cpu(buf, &key, 0);
5719 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5722 btrfs_commit_transaction(trans, search_root);
5725 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5726 ret = fix_key_order(trans, search_root, &path);
5727 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5728 ret = fix_item_offset(trans, search_root, &path);
5730 btrfs_commit_transaction(trans, search_root);
5733 btrfs_release_path(&path);
5734 btrfs_commit_transaction(trans, search_root);
5737 btrfs_release_path(&path);
5741 static int check_block(struct btrfs_root *root,
5742 struct cache_tree *extent_cache,
5743 struct extent_buffer *buf, u64 flags)
5745 struct extent_record *rec;
5746 struct cache_extent *cache;
5747 struct btrfs_key key;
5748 enum btrfs_tree_block_status status;
5752 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5755 rec = container_of(cache, struct extent_record, cache);
5756 rec->generation = btrfs_header_generation(buf);
5758 level = btrfs_header_level(buf);
5759 if (btrfs_header_nritems(buf) > 0) {
5762 btrfs_item_key_to_cpu(buf, &key, 0);
5764 btrfs_node_key_to_cpu(buf, &key, 0);
5766 rec->info_objectid = key.objectid;
5768 rec->info_level = level;
5770 if (btrfs_is_leaf(buf))
5771 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5773 status = btrfs_check_node(root, &rec->parent_key, buf);
5775 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5777 status = try_to_fix_bad_block(root, buf, status);
5778 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5780 fprintf(stderr, "bad block %llu\n",
5781 (unsigned long long)buf->start);
5784 * Signal to callers we need to start the scan over
5785 * again since we'll have cowed blocks.
5790 rec->content_checked = 1;
5791 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5792 rec->owner_ref_checked = 1;
5794 ret = check_owner_ref(root, rec, buf);
5796 rec->owner_ref_checked = 1;
5800 maybe_free_extent_rec(extent_cache, rec);
5804 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5805 u64 parent, u64 root)
5807 struct list_head *cur = rec->backrefs.next;
5808 struct extent_backref *node;
5809 struct tree_backref *back;
5811 while(cur != &rec->backrefs) {
5812 node = to_extent_backref(cur);
5816 back = to_tree_backref(node);
5818 if (!node->full_backref)
5820 if (parent == back->parent)
5823 if (node->full_backref)
5825 if (back->root == root)
5832 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5833 u64 parent, u64 root)
5835 struct tree_backref *ref = malloc(sizeof(*ref));
5839 memset(&ref->node, 0, sizeof(ref->node));
5841 ref->parent = parent;
5842 ref->node.full_backref = 1;
5845 ref->node.full_backref = 0;
5847 list_add_tail(&ref->node.list, &rec->backrefs);
5852 static struct data_backref *find_data_backref(struct extent_record *rec,
5853 u64 parent, u64 root,
5854 u64 owner, u64 offset,
5856 u64 disk_bytenr, u64 bytes)
5858 struct list_head *cur = rec->backrefs.next;
5859 struct extent_backref *node;
5860 struct data_backref *back;
5862 while(cur != &rec->backrefs) {
5863 node = to_extent_backref(cur);
5867 back = to_data_backref(node);
5869 if (!node->full_backref)
5871 if (parent == back->parent)
5874 if (node->full_backref)
5876 if (back->root == root && back->owner == owner &&
5877 back->offset == offset) {
5878 if (found_ref && node->found_ref &&
5879 (back->bytes != bytes ||
5880 back->disk_bytenr != disk_bytenr))
5889 static struct data_backref *alloc_data_backref(struct extent_record *rec,
5890 u64 parent, u64 root,
5891 u64 owner, u64 offset,
5894 struct data_backref *ref = malloc(sizeof(*ref));
5898 memset(&ref->node, 0, sizeof(ref->node));
5899 ref->node.is_data = 1;
5902 ref->parent = parent;
5905 ref->node.full_backref = 1;
5909 ref->offset = offset;
5910 ref->node.full_backref = 0;
5912 ref->bytes = max_size;
5915 list_add_tail(&ref->node.list, &rec->backrefs);
5916 if (max_size > rec->max_size)
5917 rec->max_size = max_size;
5921 /* Check if the type of extent matches with its chunk */
5922 static void check_extent_type(struct extent_record *rec)
5924 struct btrfs_block_group_cache *bg_cache;
5926 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
5930 /* data extent, check chunk directly*/
5931 if (!rec->metadata) {
5932 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
5933 rec->wrong_chunk_type = 1;
5937 /* metadata extent, check the obvious case first */
5938 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
5939 BTRFS_BLOCK_GROUP_METADATA))) {
5940 rec->wrong_chunk_type = 1;
5945 * Check SYSTEM extent, as it's also marked as metadata, we can only
5946 * make sure it's a SYSTEM extent by its backref
5948 if (!list_empty(&rec->backrefs)) {
5949 struct extent_backref *node;
5950 struct tree_backref *tback;
5953 node = to_extent_backref(rec->backrefs.next);
5954 if (node->is_data) {
5955 /* tree block shouldn't have data backref */
5956 rec->wrong_chunk_type = 1;
5959 tback = container_of(node, struct tree_backref, node);
5961 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
5962 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
5964 bg_type = BTRFS_BLOCK_GROUP_METADATA;
5965 if (!(bg_cache->flags & bg_type))
5966 rec->wrong_chunk_type = 1;
5971 * Allocate a new extent record, fill default values from @tmpl and insert int
5972 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
5973 * the cache, otherwise it fails.
5975 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
5976 struct extent_record *tmpl)
5978 struct extent_record *rec;
5981 rec = malloc(sizeof(*rec));
5984 rec->start = tmpl->start;
5985 rec->max_size = tmpl->max_size;
5986 rec->nr = max(tmpl->nr, tmpl->max_size);
5987 rec->found_rec = tmpl->found_rec;
5988 rec->content_checked = tmpl->content_checked;
5989 rec->owner_ref_checked = tmpl->owner_ref_checked;
5990 rec->num_duplicates = 0;
5991 rec->metadata = tmpl->metadata;
5992 rec->flag_block_full_backref = FLAG_UNSET;
5993 rec->bad_full_backref = 0;
5994 rec->crossing_stripes = 0;
5995 rec->wrong_chunk_type = 0;
5996 rec->is_root = tmpl->is_root;
5997 rec->refs = tmpl->refs;
5998 rec->extent_item_refs = tmpl->extent_item_refs;
5999 rec->parent_generation = tmpl->parent_generation;
6000 INIT_LIST_HEAD(&rec->backrefs);
6001 INIT_LIST_HEAD(&rec->dups);
6002 INIT_LIST_HEAD(&rec->list);
6003 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6004 rec->cache.start = tmpl->start;
6005 rec->cache.size = tmpl->nr;
6006 ret = insert_cache_extent(extent_cache, &rec->cache);
6011 bytes_used += rec->nr;
6014 rec->crossing_stripes = check_crossing_stripes(global_info,
6015 rec->start, global_info->tree_root->nodesize);
6016 check_extent_type(rec);
6021 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6023 * - refs - if found, increase refs
6024 * - is_root - if found, set
6025 * - content_checked - if found, set
6026 * - owner_ref_checked - if found, set
6028 * If not found, create a new one, initialize and insert.
6030 static int add_extent_rec(struct cache_tree *extent_cache,
6031 struct extent_record *tmpl)
6033 struct extent_record *rec;
6034 struct cache_extent *cache;
6038 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6040 rec = container_of(cache, struct extent_record, cache);
6044 rec->nr = max(tmpl->nr, tmpl->max_size);
6047 * We need to make sure to reset nr to whatever the extent
6048 * record says was the real size, this way we can compare it to
6051 if (tmpl->found_rec) {
6052 if (tmpl->start != rec->start || rec->found_rec) {
6053 struct extent_record *tmp;
6056 if (list_empty(&rec->list))
6057 list_add_tail(&rec->list,
6058 &duplicate_extents);
6061 * We have to do this song and dance in case we
6062 * find an extent record that falls inside of
6063 * our current extent record but does not have
6064 * the same objectid.
6066 tmp = malloc(sizeof(*tmp));
6069 tmp->start = tmpl->start;
6070 tmp->max_size = tmpl->max_size;
6073 tmp->metadata = tmpl->metadata;
6074 tmp->extent_item_refs = tmpl->extent_item_refs;
6075 INIT_LIST_HEAD(&tmp->list);
6076 list_add_tail(&tmp->list, &rec->dups);
6077 rec->num_duplicates++;
6084 if (tmpl->extent_item_refs && !dup) {
6085 if (rec->extent_item_refs) {
6086 fprintf(stderr, "block %llu rec "
6087 "extent_item_refs %llu, passed %llu\n",
6088 (unsigned long long)tmpl->start,
6089 (unsigned long long)
6090 rec->extent_item_refs,
6091 (unsigned long long)tmpl->extent_item_refs);
6093 rec->extent_item_refs = tmpl->extent_item_refs;
6097 if (tmpl->content_checked)
6098 rec->content_checked = 1;
6099 if (tmpl->owner_ref_checked)
6100 rec->owner_ref_checked = 1;
6101 memcpy(&rec->parent_key, &tmpl->parent_key,
6102 sizeof(tmpl->parent_key));
6103 if (tmpl->parent_generation)
6104 rec->parent_generation = tmpl->parent_generation;
6105 if (rec->max_size < tmpl->max_size)
6106 rec->max_size = tmpl->max_size;
6109 * A metadata extent can't cross stripe_len boundary, otherwise
6110 * kernel scrub won't be able to handle it.
6111 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6115 rec->crossing_stripes = check_crossing_stripes(
6116 global_info, rec->start,
6117 global_info->tree_root->nodesize);
6118 check_extent_type(rec);
6119 maybe_free_extent_rec(extent_cache, rec);
6123 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6128 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6129 u64 parent, u64 root, int found_ref)
6131 struct extent_record *rec;
6132 struct tree_backref *back;
6133 struct cache_extent *cache;
6136 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6138 struct extent_record tmpl;
6140 memset(&tmpl, 0, sizeof(tmpl));
6141 tmpl.start = bytenr;
6145 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6149 /* really a bug in cache_extent implement now */
6150 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6155 rec = container_of(cache, struct extent_record, cache);
6156 if (rec->start != bytenr) {
6158 * Several cause, from unaligned bytenr to over lapping extents
6163 back = find_tree_backref(rec, parent, root);
6165 back = alloc_tree_backref(rec, parent, root);
6171 if (back->node.found_ref) {
6172 fprintf(stderr, "Extent back ref already exists "
6173 "for %llu parent %llu root %llu \n",
6174 (unsigned long long)bytenr,
6175 (unsigned long long)parent,
6176 (unsigned long long)root);
6178 back->node.found_ref = 1;
6180 if (back->node.found_extent_tree) {
6181 fprintf(stderr, "Extent back ref already exists "
6182 "for %llu parent %llu root %llu \n",
6183 (unsigned long long)bytenr,
6184 (unsigned long long)parent,
6185 (unsigned long long)root);
6187 back->node.found_extent_tree = 1;
6189 check_extent_type(rec);
6190 maybe_free_extent_rec(extent_cache, rec);
6194 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6195 u64 parent, u64 root, u64 owner, u64 offset,
6196 u32 num_refs, int found_ref, u64 max_size)
6198 struct extent_record *rec;
6199 struct data_backref *back;
6200 struct cache_extent *cache;
6203 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6205 struct extent_record tmpl;
6207 memset(&tmpl, 0, sizeof(tmpl));
6208 tmpl.start = bytenr;
6210 tmpl.max_size = max_size;
6212 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6216 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6221 rec = container_of(cache, struct extent_record, cache);
6222 if (rec->max_size < max_size)
6223 rec->max_size = max_size;
6226 * If found_ref is set then max_size is the real size and must match the
6227 * existing refs. So if we have already found a ref then we need to
6228 * make sure that this ref matches the existing one, otherwise we need
6229 * to add a new backref so we can notice that the backrefs don't match
6230 * and we need to figure out who is telling the truth. This is to
6231 * account for that awful fsync bug I introduced where we'd end up with
6232 * a btrfs_file_extent_item that would have its length include multiple
6233 * prealloc extents or point inside of a prealloc extent.
6235 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6238 back = alloc_data_backref(rec, parent, root, owner, offset,
6244 BUG_ON(num_refs != 1);
6245 if (back->node.found_ref)
6246 BUG_ON(back->bytes != max_size);
6247 back->node.found_ref = 1;
6248 back->found_ref += 1;
6249 back->bytes = max_size;
6250 back->disk_bytenr = bytenr;
6252 rec->content_checked = 1;
6253 rec->owner_ref_checked = 1;
6255 if (back->node.found_extent_tree) {
6256 fprintf(stderr, "Extent back ref already exists "
6257 "for %llu parent %llu root %llu "
6258 "owner %llu offset %llu num_refs %lu\n",
6259 (unsigned long long)bytenr,
6260 (unsigned long long)parent,
6261 (unsigned long long)root,
6262 (unsigned long long)owner,
6263 (unsigned long long)offset,
6264 (unsigned long)num_refs);
6266 back->num_refs = num_refs;
6267 back->node.found_extent_tree = 1;
6269 maybe_free_extent_rec(extent_cache, rec);
6273 static int add_pending(struct cache_tree *pending,
6274 struct cache_tree *seen, u64 bytenr, u32 size)
6277 ret = add_cache_extent(seen, bytenr, size);
6280 add_cache_extent(pending, bytenr, size);
6284 static int pick_next_pending(struct cache_tree *pending,
6285 struct cache_tree *reada,
6286 struct cache_tree *nodes,
6287 u64 last, struct block_info *bits, int bits_nr,
6290 unsigned long node_start = last;
6291 struct cache_extent *cache;
6294 cache = search_cache_extent(reada, 0);
6296 bits[0].start = cache->start;
6297 bits[0].size = cache->size;
6302 if (node_start > 32768)
6303 node_start -= 32768;
6305 cache = search_cache_extent(nodes, node_start);
6307 cache = search_cache_extent(nodes, 0);
6310 cache = search_cache_extent(pending, 0);
6315 bits[ret].start = cache->start;
6316 bits[ret].size = cache->size;
6317 cache = next_cache_extent(cache);
6319 } while (cache && ret < bits_nr);
6325 bits[ret].start = cache->start;
6326 bits[ret].size = cache->size;
6327 cache = next_cache_extent(cache);
6329 } while (cache && ret < bits_nr);
6331 if (bits_nr - ret > 8) {
6332 u64 lookup = bits[0].start + bits[0].size;
6333 struct cache_extent *next;
6334 next = search_cache_extent(pending, lookup);
6336 if (next->start - lookup > 32768)
6338 bits[ret].start = next->start;
6339 bits[ret].size = next->size;
6340 lookup = next->start + next->size;
6344 next = next_cache_extent(next);
6352 static void free_chunk_record(struct cache_extent *cache)
6354 struct chunk_record *rec;
6356 rec = container_of(cache, struct chunk_record, cache);
6357 list_del_init(&rec->list);
6358 list_del_init(&rec->dextents);
6362 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6364 cache_tree_free_extents(chunk_cache, free_chunk_record);
6367 static void free_device_record(struct rb_node *node)
6369 struct device_record *rec;
6371 rec = container_of(node, struct device_record, node);
6375 FREE_RB_BASED_TREE(device_cache, free_device_record);
6377 int insert_block_group_record(struct block_group_tree *tree,
6378 struct block_group_record *bg_rec)
6382 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6386 list_add_tail(&bg_rec->list, &tree->block_groups);
6390 static void free_block_group_record(struct cache_extent *cache)
6392 struct block_group_record *rec;
6394 rec = container_of(cache, struct block_group_record, cache);
6395 list_del_init(&rec->list);
6399 void free_block_group_tree(struct block_group_tree *tree)
6401 cache_tree_free_extents(&tree->tree, free_block_group_record);
6404 int insert_device_extent_record(struct device_extent_tree *tree,
6405 struct device_extent_record *de_rec)
6410 * Device extent is a bit different from the other extents, because
6411 * the extents which belong to the different devices may have the
6412 * same start and size, so we need use the special extent cache
6413 * search/insert functions.
6415 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6419 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6420 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6424 static void free_device_extent_record(struct cache_extent *cache)
6426 struct device_extent_record *rec;
6428 rec = container_of(cache, struct device_extent_record, cache);
6429 if (!list_empty(&rec->chunk_list))
6430 list_del_init(&rec->chunk_list);
6431 if (!list_empty(&rec->device_list))
6432 list_del_init(&rec->device_list);
6436 void free_device_extent_tree(struct device_extent_tree *tree)
6438 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6441 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6442 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6443 struct extent_buffer *leaf, int slot)
6445 struct btrfs_extent_ref_v0 *ref0;
6446 struct btrfs_key key;
6449 btrfs_item_key_to_cpu(leaf, &key, slot);
6450 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6451 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6452 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6455 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6456 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6462 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6463 struct btrfs_key *key,
6466 struct btrfs_chunk *ptr;
6467 struct chunk_record *rec;
6470 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6471 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6473 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6475 fprintf(stderr, "memory allocation failed\n");
6479 INIT_LIST_HEAD(&rec->list);
6480 INIT_LIST_HEAD(&rec->dextents);
6483 rec->cache.start = key->offset;
6484 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6486 rec->generation = btrfs_header_generation(leaf);
6488 rec->objectid = key->objectid;
6489 rec->type = key->type;
6490 rec->offset = key->offset;
6492 rec->length = rec->cache.size;
6493 rec->owner = btrfs_chunk_owner(leaf, ptr);
6494 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6495 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6496 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6497 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6498 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6499 rec->num_stripes = num_stripes;
6500 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6502 for (i = 0; i < rec->num_stripes; ++i) {
6503 rec->stripes[i].devid =
6504 btrfs_stripe_devid_nr(leaf, ptr, i);
6505 rec->stripes[i].offset =
6506 btrfs_stripe_offset_nr(leaf, ptr, i);
6507 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6508 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6515 static int process_chunk_item(struct cache_tree *chunk_cache,
6516 struct btrfs_key *key, struct extent_buffer *eb,
6519 struct chunk_record *rec;
6520 struct btrfs_chunk *chunk;
6523 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6525 * Do extra check for this chunk item,
6527 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6528 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6529 * and owner<->key_type check.
6531 ret = btrfs_check_chunk_valid(global_info->tree_root, eb, chunk, slot,
6534 error("chunk(%llu, %llu) is not valid, ignore it",
6535 key->offset, btrfs_chunk_length(eb, chunk));
6538 rec = btrfs_new_chunk_record(eb, key, slot);
6539 ret = insert_cache_extent(chunk_cache, &rec->cache);
6541 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6542 rec->offset, rec->length);
6549 static int process_device_item(struct rb_root *dev_cache,
6550 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6552 struct btrfs_dev_item *ptr;
6553 struct device_record *rec;
6556 ptr = btrfs_item_ptr(eb,
6557 slot, struct btrfs_dev_item);
6559 rec = malloc(sizeof(*rec));
6561 fprintf(stderr, "memory allocation failed\n");
6565 rec->devid = key->offset;
6566 rec->generation = btrfs_header_generation(eb);
6568 rec->objectid = key->objectid;
6569 rec->type = key->type;
6570 rec->offset = key->offset;
6572 rec->devid = btrfs_device_id(eb, ptr);
6573 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6574 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6576 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6578 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6585 struct block_group_record *
6586 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6589 struct btrfs_block_group_item *ptr;
6590 struct block_group_record *rec;
6592 rec = calloc(1, sizeof(*rec));
6594 fprintf(stderr, "memory allocation failed\n");
6598 rec->cache.start = key->objectid;
6599 rec->cache.size = key->offset;
6601 rec->generation = btrfs_header_generation(leaf);
6603 rec->objectid = key->objectid;
6604 rec->type = key->type;
6605 rec->offset = key->offset;
6607 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6608 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6610 INIT_LIST_HEAD(&rec->list);
6615 static int process_block_group_item(struct block_group_tree *block_group_cache,
6616 struct btrfs_key *key,
6617 struct extent_buffer *eb, int slot)
6619 struct block_group_record *rec;
6622 rec = btrfs_new_block_group_record(eb, key, slot);
6623 ret = insert_block_group_record(block_group_cache, rec);
6625 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6626 rec->objectid, rec->offset);
6633 struct device_extent_record *
6634 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6635 struct btrfs_key *key, int slot)
6637 struct device_extent_record *rec;
6638 struct btrfs_dev_extent *ptr;
6640 rec = calloc(1, sizeof(*rec));
6642 fprintf(stderr, "memory allocation failed\n");
6646 rec->cache.objectid = key->objectid;
6647 rec->cache.start = key->offset;
6649 rec->generation = btrfs_header_generation(leaf);
6651 rec->objectid = key->objectid;
6652 rec->type = key->type;
6653 rec->offset = key->offset;
6655 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6656 rec->chunk_objecteid =
6657 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6659 btrfs_dev_extent_chunk_offset(leaf, ptr);
6660 rec->length = btrfs_dev_extent_length(leaf, ptr);
6661 rec->cache.size = rec->length;
6663 INIT_LIST_HEAD(&rec->chunk_list);
6664 INIT_LIST_HEAD(&rec->device_list);
6670 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6671 struct btrfs_key *key, struct extent_buffer *eb,
6674 struct device_extent_record *rec;
6677 rec = btrfs_new_device_extent_record(eb, key, slot);
6678 ret = insert_device_extent_record(dev_extent_cache, rec);
6681 "Device extent[%llu, %llu, %llu] existed.\n",
6682 rec->objectid, rec->offset, rec->length);
6689 static int process_extent_item(struct btrfs_root *root,
6690 struct cache_tree *extent_cache,
6691 struct extent_buffer *eb, int slot)
6693 struct btrfs_extent_item *ei;
6694 struct btrfs_extent_inline_ref *iref;
6695 struct btrfs_extent_data_ref *dref;
6696 struct btrfs_shared_data_ref *sref;
6697 struct btrfs_key key;
6698 struct extent_record tmpl;
6703 u32 item_size = btrfs_item_size_nr(eb, slot);
6709 btrfs_item_key_to_cpu(eb, &key, slot);
6711 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6713 num_bytes = root->nodesize;
6715 num_bytes = key.offset;
6718 if (!IS_ALIGNED(key.objectid, root->sectorsize)) {
6719 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6720 key.objectid, root->sectorsize);
6723 if (item_size < sizeof(*ei)) {
6724 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6725 struct btrfs_extent_item_v0 *ei0;
6726 BUG_ON(item_size != sizeof(*ei0));
6727 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6728 refs = btrfs_extent_refs_v0(eb, ei0);
6732 memset(&tmpl, 0, sizeof(tmpl));
6733 tmpl.start = key.objectid;
6734 tmpl.nr = num_bytes;
6735 tmpl.extent_item_refs = refs;
6736 tmpl.metadata = metadata;
6738 tmpl.max_size = num_bytes;
6740 return add_extent_rec(extent_cache, &tmpl);
6743 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6744 refs = btrfs_extent_refs(eb, ei);
6745 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6749 if (metadata && num_bytes != root->nodesize) {
6750 error("ignore invalid metadata extent, length %llu does not equal to %u",
6751 num_bytes, root->nodesize);
6754 if (!metadata && !IS_ALIGNED(num_bytes, root->sectorsize)) {
6755 error("ignore invalid data extent, length %llu is not aligned to %u",
6756 num_bytes, root->sectorsize);
6760 memset(&tmpl, 0, sizeof(tmpl));
6761 tmpl.start = key.objectid;
6762 tmpl.nr = num_bytes;
6763 tmpl.extent_item_refs = refs;
6764 tmpl.metadata = metadata;
6766 tmpl.max_size = num_bytes;
6767 add_extent_rec(extent_cache, &tmpl);
6769 ptr = (unsigned long)(ei + 1);
6770 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6771 key.type == BTRFS_EXTENT_ITEM_KEY)
6772 ptr += sizeof(struct btrfs_tree_block_info);
6774 end = (unsigned long)ei + item_size;
6776 iref = (struct btrfs_extent_inline_ref *)ptr;
6777 type = btrfs_extent_inline_ref_type(eb, iref);
6778 offset = btrfs_extent_inline_ref_offset(eb, iref);
6780 case BTRFS_TREE_BLOCK_REF_KEY:
6781 ret = add_tree_backref(extent_cache, key.objectid,
6784 error("add_tree_backref failed: %s",
6787 case BTRFS_SHARED_BLOCK_REF_KEY:
6788 ret = add_tree_backref(extent_cache, key.objectid,
6791 error("add_tree_backref failed: %s",
6794 case BTRFS_EXTENT_DATA_REF_KEY:
6795 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6796 add_data_backref(extent_cache, key.objectid, 0,
6797 btrfs_extent_data_ref_root(eb, dref),
6798 btrfs_extent_data_ref_objectid(eb,
6800 btrfs_extent_data_ref_offset(eb, dref),
6801 btrfs_extent_data_ref_count(eb, dref),
6804 case BTRFS_SHARED_DATA_REF_KEY:
6805 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6806 add_data_backref(extent_cache, key.objectid, offset,
6808 btrfs_shared_data_ref_count(eb, sref),
6812 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6813 key.objectid, key.type, num_bytes);
6816 ptr += btrfs_extent_inline_ref_size(type);
6823 static int check_cache_range(struct btrfs_root *root,
6824 struct btrfs_block_group_cache *cache,
6825 u64 offset, u64 bytes)
6827 struct btrfs_free_space *entry;
6833 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6834 bytenr = btrfs_sb_offset(i);
6835 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
6836 cache->key.objectid, bytenr, 0,
6837 &logical, &nr, &stripe_len);
6842 if (logical[nr] + stripe_len <= offset)
6844 if (offset + bytes <= logical[nr])
6846 if (logical[nr] == offset) {
6847 if (stripe_len >= bytes) {
6851 bytes -= stripe_len;
6852 offset += stripe_len;
6853 } else if (logical[nr] < offset) {
6854 if (logical[nr] + stripe_len >=
6859 bytes = (offset + bytes) -
6860 (logical[nr] + stripe_len);
6861 offset = logical[nr] + stripe_len;
6864 * Could be tricky, the super may land in the
6865 * middle of the area we're checking. First
6866 * check the easiest case, it's at the end.
6868 if (logical[nr] + stripe_len >=
6870 bytes = logical[nr] - offset;
6874 /* Check the left side */
6875 ret = check_cache_range(root, cache,
6877 logical[nr] - offset);
6883 /* Now we continue with the right side */
6884 bytes = (offset + bytes) -
6885 (logical[nr] + stripe_len);
6886 offset = logical[nr] + stripe_len;
6893 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
6895 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
6896 offset, offset+bytes);
6900 if (entry->offset != offset) {
6901 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
6906 if (entry->bytes != bytes) {
6907 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
6908 bytes, entry->bytes, offset);
6912 unlink_free_space(cache->free_space_ctl, entry);
6917 static int verify_space_cache(struct btrfs_root *root,
6918 struct btrfs_block_group_cache *cache)
6920 struct btrfs_path path;
6921 struct extent_buffer *leaf;
6922 struct btrfs_key key;
6926 root = root->fs_info->extent_root;
6928 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
6930 btrfs_init_path(&path);
6931 key.objectid = last;
6933 key.type = BTRFS_EXTENT_ITEM_KEY;
6934 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6939 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
6940 ret = btrfs_next_leaf(root, &path);
6948 leaf = path.nodes[0];
6949 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
6950 if (key.objectid >= cache->key.offset + cache->key.objectid)
6952 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
6953 key.type != BTRFS_METADATA_ITEM_KEY) {
6958 if (last == key.objectid) {
6959 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6960 last = key.objectid + key.offset;
6962 last = key.objectid + root->nodesize;
6967 ret = check_cache_range(root, cache, last,
6968 key.objectid - last);
6971 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6972 last = key.objectid + key.offset;
6974 last = key.objectid + root->nodesize;
6978 if (last < cache->key.objectid + cache->key.offset)
6979 ret = check_cache_range(root, cache, last,
6980 cache->key.objectid +
6981 cache->key.offset - last);
6984 btrfs_release_path(&path);
6987 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
6988 fprintf(stderr, "There are still entries left in the space "
6996 static int check_space_cache(struct btrfs_root *root)
6998 struct btrfs_block_group_cache *cache;
6999 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7003 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7004 btrfs_super_generation(root->fs_info->super_copy) !=
7005 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7006 printf("cache and super generation don't match, space cache "
7007 "will be invalidated\n");
7011 if (ctx.progress_enabled) {
7012 ctx.tp = TASK_FREE_SPACE;
7013 task_start(ctx.info);
7017 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7021 start = cache->key.objectid + cache->key.offset;
7022 if (!cache->free_space_ctl) {
7023 if (btrfs_init_free_space_ctl(cache,
7024 root->sectorsize)) {
7029 btrfs_remove_free_space_cache(cache);
7032 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7033 ret = exclude_super_stripes(root, cache);
7035 fprintf(stderr, "could not exclude super stripes: %s\n",
7040 ret = load_free_space_tree(root->fs_info, cache);
7041 free_excluded_extents(root, cache);
7043 fprintf(stderr, "could not load free space tree: %s\n",
7050 ret = load_free_space_cache(root->fs_info, cache);
7055 ret = verify_space_cache(root, cache);
7057 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7058 cache->key.objectid);
7063 task_stop(ctx.info);
7065 return error ? -EINVAL : 0;
7068 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7069 u64 num_bytes, unsigned long leaf_offset,
7070 struct extent_buffer *eb) {
7073 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7075 unsigned long csum_offset;
7079 u64 data_checked = 0;
7085 if (num_bytes % root->sectorsize)
7088 data = malloc(num_bytes);
7092 while (offset < num_bytes) {
7095 read_len = num_bytes - offset;
7096 /* read as much space once a time */
7097 ret = read_extent_data(root, data + offset,
7098 bytenr + offset, &read_len, mirror);
7102 /* verify every 4k data's checksum */
7103 while (data_checked < read_len) {
7105 tmp = offset + data_checked;
7107 csum = btrfs_csum_data(NULL, (char *)data + tmp,
7108 csum, root->sectorsize);
7109 btrfs_csum_final(csum, (u8 *)&csum);
7111 csum_offset = leaf_offset +
7112 tmp / root->sectorsize * csum_size;
7113 read_extent_buffer(eb, (char *)&csum_expected,
7114 csum_offset, csum_size);
7115 /* try another mirror */
7116 if (csum != csum_expected) {
7117 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7118 mirror, bytenr + tmp,
7119 csum, csum_expected);
7120 num_copies = btrfs_num_copies(
7121 &root->fs_info->mapping_tree,
7123 if (mirror < num_copies - 1) {
7128 data_checked += root->sectorsize;
7137 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7140 struct btrfs_path path;
7141 struct extent_buffer *leaf;
7142 struct btrfs_key key;
7145 btrfs_init_path(&path);
7146 key.objectid = bytenr;
7147 key.type = BTRFS_EXTENT_ITEM_KEY;
7148 key.offset = (u64)-1;
7151 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7154 fprintf(stderr, "Error looking up extent record %d\n", ret);
7155 btrfs_release_path(&path);
7158 if (path.slots[0] > 0) {
7161 ret = btrfs_prev_leaf(root, &path);
7164 } else if (ret > 0) {
7171 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7174 * Block group items come before extent items if they have the same
7175 * bytenr, so walk back one more just in case. Dear future traveller,
7176 * first congrats on mastering time travel. Now if it's not too much
7177 * trouble could you go back to 2006 and tell Chris to make the
7178 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7179 * EXTENT_ITEM_KEY please?
7181 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7182 if (path.slots[0] > 0) {
7185 ret = btrfs_prev_leaf(root, &path);
7188 } else if (ret > 0) {
7193 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7197 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7198 ret = btrfs_next_leaf(root, &path);
7200 fprintf(stderr, "Error going to next leaf "
7202 btrfs_release_path(&path);
7208 leaf = path.nodes[0];
7209 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7210 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7214 if (key.objectid + key.offset < bytenr) {
7218 if (key.objectid > bytenr + num_bytes)
7221 if (key.objectid == bytenr) {
7222 if (key.offset >= num_bytes) {
7226 num_bytes -= key.offset;
7227 bytenr += key.offset;
7228 } else if (key.objectid < bytenr) {
7229 if (key.objectid + key.offset >= bytenr + num_bytes) {
7233 num_bytes = (bytenr + num_bytes) -
7234 (key.objectid + key.offset);
7235 bytenr = key.objectid + key.offset;
7237 if (key.objectid + key.offset < bytenr + num_bytes) {
7238 u64 new_start = key.objectid + key.offset;
7239 u64 new_bytes = bytenr + num_bytes - new_start;
7242 * Weird case, the extent is in the middle of
7243 * our range, we'll have to search one side
7244 * and then the other. Not sure if this happens
7245 * in real life, but no harm in coding it up
7246 * anyway just in case.
7248 btrfs_release_path(&path);
7249 ret = check_extent_exists(root, new_start,
7252 fprintf(stderr, "Right section didn't "
7256 num_bytes = key.objectid - bytenr;
7259 num_bytes = key.objectid - bytenr;
7266 if (num_bytes && !ret) {
7267 fprintf(stderr, "There are no extents for csum range "
7268 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7272 btrfs_release_path(&path);
7276 static int check_csums(struct btrfs_root *root)
7278 struct btrfs_path path;
7279 struct extent_buffer *leaf;
7280 struct btrfs_key key;
7281 u64 offset = 0, num_bytes = 0;
7282 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7286 unsigned long leaf_offset;
7288 root = root->fs_info->csum_root;
7289 if (!extent_buffer_uptodate(root->node)) {
7290 fprintf(stderr, "No valid csum tree found\n");
7294 btrfs_init_path(&path);
7295 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7296 key.type = BTRFS_EXTENT_CSUM_KEY;
7298 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7300 fprintf(stderr, "Error searching csum tree %d\n", ret);
7301 btrfs_release_path(&path);
7305 if (ret > 0 && path.slots[0])
7310 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7311 ret = btrfs_next_leaf(root, &path);
7313 fprintf(stderr, "Error going to next leaf "
7320 leaf = path.nodes[0];
7322 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7323 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7328 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7329 csum_size) * root->sectorsize;
7330 if (!check_data_csum)
7331 goto skip_csum_check;
7332 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7333 ret = check_extent_csums(root, key.offset, data_len,
7339 offset = key.offset;
7340 } else if (key.offset != offset + num_bytes) {
7341 ret = check_extent_exists(root, offset, num_bytes);
7343 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7344 "there is no extent record\n",
7345 offset, offset+num_bytes);
7348 offset = key.offset;
7351 num_bytes += data_len;
7355 btrfs_release_path(&path);
7359 static int is_dropped_key(struct btrfs_key *key,
7360 struct btrfs_key *drop_key) {
7361 if (key->objectid < drop_key->objectid)
7363 else if (key->objectid == drop_key->objectid) {
7364 if (key->type < drop_key->type)
7366 else if (key->type == drop_key->type) {
7367 if (key->offset < drop_key->offset)
7375 * Here are the rules for FULL_BACKREF.
7377 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7378 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7380 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7381 * if it happened after the relocation occurred since we'll have dropped the
7382 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7383 * have no real way to know for sure.
7385 * We process the blocks one root at a time, and we start from the lowest root
7386 * objectid and go to the highest. So we can just lookup the owner backref for
7387 * the record and if we don't find it then we know it doesn't exist and we have
7390 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7391 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7392 * be set or not and then we can check later once we've gathered all the refs.
7394 static int calc_extent_flag(struct btrfs_root *root,
7395 struct cache_tree *extent_cache,
7396 struct extent_buffer *buf,
7397 struct root_item_record *ri,
7400 struct extent_record *rec;
7401 struct cache_extent *cache;
7402 struct tree_backref *tback;
7405 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7406 /* we have added this extent before */
7410 rec = container_of(cache, struct extent_record, cache);
7413 * Except file/reloc tree, we can not have
7416 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7421 if (buf->start == ri->bytenr)
7424 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7427 owner = btrfs_header_owner(buf);
7428 if (owner == ri->objectid)
7431 tback = find_tree_backref(rec, 0, owner);
7436 if (rec->flag_block_full_backref != FLAG_UNSET &&
7437 rec->flag_block_full_backref != 0)
7438 rec->bad_full_backref = 1;
7441 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7442 if (rec->flag_block_full_backref != FLAG_UNSET &&
7443 rec->flag_block_full_backref != 1)
7444 rec->bad_full_backref = 1;
7448 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7450 fprintf(stderr, "Invalid key type(");
7451 print_key_type(stderr, 0, key_type);
7452 fprintf(stderr, ") found in root(");
7453 print_objectid(stderr, rootid, 0);
7454 fprintf(stderr, ")\n");
7458 * Check if the key is valid with its extent buffer.
7460 * This is a early check in case invalid key exists in a extent buffer
7461 * This is not comprehensive yet, but should prevent wrong key/item passed
7464 static int check_type_with_root(u64 rootid, u8 key_type)
7467 /* Only valid in chunk tree */
7468 case BTRFS_DEV_ITEM_KEY:
7469 case BTRFS_CHUNK_ITEM_KEY:
7470 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7473 /* valid in csum and log tree */
7474 case BTRFS_CSUM_TREE_OBJECTID:
7475 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7479 case BTRFS_EXTENT_ITEM_KEY:
7480 case BTRFS_METADATA_ITEM_KEY:
7481 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7482 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7485 case BTRFS_ROOT_ITEM_KEY:
7486 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7489 case BTRFS_DEV_EXTENT_KEY:
7490 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7496 report_mismatch_key_root(key_type, rootid);
7500 static int run_next_block(struct btrfs_root *root,
7501 struct block_info *bits,
7504 struct cache_tree *pending,
7505 struct cache_tree *seen,
7506 struct cache_tree *reada,
7507 struct cache_tree *nodes,
7508 struct cache_tree *extent_cache,
7509 struct cache_tree *chunk_cache,
7510 struct rb_root *dev_cache,
7511 struct block_group_tree *block_group_cache,
7512 struct device_extent_tree *dev_extent_cache,
7513 struct root_item_record *ri)
7515 struct extent_buffer *buf;
7516 struct extent_record *rec = NULL;
7527 struct btrfs_key key;
7528 struct cache_extent *cache;
7531 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7532 bits_nr, &reada_bits);
7537 for(i = 0; i < nritems; i++) {
7538 ret = add_cache_extent(reada, bits[i].start,
7543 /* fixme, get the parent transid */
7544 readahead_tree_block(root, bits[i].start,
7548 *last = bits[0].start;
7549 bytenr = bits[0].start;
7550 size = bits[0].size;
7552 cache = lookup_cache_extent(pending, bytenr, size);
7554 remove_cache_extent(pending, cache);
7557 cache = lookup_cache_extent(reada, bytenr, size);
7559 remove_cache_extent(reada, cache);
7562 cache = lookup_cache_extent(nodes, bytenr, size);
7564 remove_cache_extent(nodes, cache);
7567 cache = lookup_cache_extent(extent_cache, bytenr, size);
7569 rec = container_of(cache, struct extent_record, cache);
7570 gen = rec->parent_generation;
7573 /* fixme, get the real parent transid */
7574 buf = read_tree_block(root, bytenr, size, gen);
7575 if (!extent_buffer_uptodate(buf)) {
7576 record_bad_block_io(root->fs_info,
7577 extent_cache, bytenr, size);
7581 nritems = btrfs_header_nritems(buf);
7584 if (!init_extent_tree) {
7585 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7586 btrfs_header_level(buf), 1, NULL,
7589 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7591 fprintf(stderr, "Couldn't calc extent flags\n");
7592 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7597 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7599 fprintf(stderr, "Couldn't calc extent flags\n");
7600 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7604 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7606 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7607 ri->objectid == btrfs_header_owner(buf)) {
7609 * Ok we got to this block from it's original owner and
7610 * we have FULL_BACKREF set. Relocation can leave
7611 * converted blocks over so this is altogether possible,
7612 * however it's not possible if the generation > the
7613 * last snapshot, so check for this case.
7615 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7616 btrfs_header_generation(buf) > ri->last_snapshot) {
7617 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7618 rec->bad_full_backref = 1;
7623 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7624 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7625 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7626 rec->bad_full_backref = 1;
7630 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7631 rec->flag_block_full_backref = 1;
7635 rec->flag_block_full_backref = 0;
7637 owner = btrfs_header_owner(buf);
7640 ret = check_block(root, extent_cache, buf, flags);
7644 if (btrfs_is_leaf(buf)) {
7645 btree_space_waste += btrfs_leaf_free_space(root, buf);
7646 for (i = 0; i < nritems; i++) {
7647 struct btrfs_file_extent_item *fi;
7648 btrfs_item_key_to_cpu(buf, &key, i);
7650 * Check key type against the leaf owner.
7651 * Could filter quite a lot of early error if
7654 if (check_type_with_root(btrfs_header_owner(buf),
7656 fprintf(stderr, "ignoring invalid key\n");
7659 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7660 process_extent_item(root, extent_cache, buf,
7664 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7665 process_extent_item(root, extent_cache, buf,
7669 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7671 btrfs_item_size_nr(buf, i);
7674 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7675 process_chunk_item(chunk_cache, &key, buf, i);
7678 if (key.type == BTRFS_DEV_ITEM_KEY) {
7679 process_device_item(dev_cache, &key, buf, i);
7682 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7683 process_block_group_item(block_group_cache,
7687 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7688 process_device_extent_item(dev_extent_cache,
7693 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7694 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7695 process_extent_ref_v0(extent_cache, buf, i);
7702 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7703 ret = add_tree_backref(extent_cache,
7704 key.objectid, 0, key.offset, 0);
7706 error("add_tree_backref failed: %s",
7710 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7711 ret = add_tree_backref(extent_cache,
7712 key.objectid, key.offset, 0, 0);
7714 error("add_tree_backref failed: %s",
7718 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7719 struct btrfs_extent_data_ref *ref;
7720 ref = btrfs_item_ptr(buf, i,
7721 struct btrfs_extent_data_ref);
7722 add_data_backref(extent_cache,
7724 btrfs_extent_data_ref_root(buf, ref),
7725 btrfs_extent_data_ref_objectid(buf,
7727 btrfs_extent_data_ref_offset(buf, ref),
7728 btrfs_extent_data_ref_count(buf, ref),
7729 0, root->sectorsize);
7732 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7733 struct btrfs_shared_data_ref *ref;
7734 ref = btrfs_item_ptr(buf, i,
7735 struct btrfs_shared_data_ref);
7736 add_data_backref(extent_cache,
7737 key.objectid, key.offset, 0, 0, 0,
7738 btrfs_shared_data_ref_count(buf, ref),
7739 0, root->sectorsize);
7742 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7743 struct bad_item *bad;
7745 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7749 bad = malloc(sizeof(struct bad_item));
7752 INIT_LIST_HEAD(&bad->list);
7753 memcpy(&bad->key, &key,
7754 sizeof(struct btrfs_key));
7755 bad->root_id = owner;
7756 list_add_tail(&bad->list, &delete_items);
7759 if (key.type != BTRFS_EXTENT_DATA_KEY)
7761 fi = btrfs_item_ptr(buf, i,
7762 struct btrfs_file_extent_item);
7763 if (btrfs_file_extent_type(buf, fi) ==
7764 BTRFS_FILE_EXTENT_INLINE)
7766 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7769 data_bytes_allocated +=
7770 btrfs_file_extent_disk_num_bytes(buf, fi);
7771 if (data_bytes_allocated < root->sectorsize) {
7774 data_bytes_referenced +=
7775 btrfs_file_extent_num_bytes(buf, fi);
7776 add_data_backref(extent_cache,
7777 btrfs_file_extent_disk_bytenr(buf, fi),
7778 parent, owner, key.objectid, key.offset -
7779 btrfs_file_extent_offset(buf, fi), 1, 1,
7780 btrfs_file_extent_disk_num_bytes(buf, fi));
7784 struct btrfs_key first_key;
7786 first_key.objectid = 0;
7789 btrfs_item_key_to_cpu(buf, &first_key, 0);
7790 level = btrfs_header_level(buf);
7791 for (i = 0; i < nritems; i++) {
7792 struct extent_record tmpl;
7794 ptr = btrfs_node_blockptr(buf, i);
7795 size = root->nodesize;
7796 btrfs_node_key_to_cpu(buf, &key, i);
7798 if ((level == ri->drop_level)
7799 && is_dropped_key(&key, &ri->drop_key)) {
7804 memset(&tmpl, 0, sizeof(tmpl));
7805 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7806 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7811 tmpl.max_size = size;
7812 ret = add_extent_rec(extent_cache, &tmpl);
7816 ret = add_tree_backref(extent_cache, ptr, parent,
7819 error("add_tree_backref failed: %s",
7825 add_pending(nodes, seen, ptr, size);
7827 add_pending(pending, seen, ptr, size);
7830 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7831 nritems) * sizeof(struct btrfs_key_ptr);
7833 total_btree_bytes += buf->len;
7834 if (fs_root_objectid(btrfs_header_owner(buf)))
7835 total_fs_tree_bytes += buf->len;
7836 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7837 total_extent_tree_bytes += buf->len;
7838 if (!found_old_backref &&
7839 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7840 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7841 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7842 found_old_backref = 1;
7844 free_extent_buffer(buf);
7848 static int add_root_to_pending(struct extent_buffer *buf,
7849 struct cache_tree *extent_cache,
7850 struct cache_tree *pending,
7851 struct cache_tree *seen,
7852 struct cache_tree *nodes,
7855 struct extent_record tmpl;
7858 if (btrfs_header_level(buf) > 0)
7859 add_pending(nodes, seen, buf->start, buf->len);
7861 add_pending(pending, seen, buf->start, buf->len);
7863 memset(&tmpl, 0, sizeof(tmpl));
7864 tmpl.start = buf->start;
7869 tmpl.max_size = buf->len;
7870 add_extent_rec(extent_cache, &tmpl);
7872 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7873 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7874 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7877 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7882 /* as we fix the tree, we might be deleting blocks that
7883 * we're tracking for repair. This hook makes sure we
7884 * remove any backrefs for blocks as we are fixing them.
7886 static int free_extent_hook(struct btrfs_trans_handle *trans,
7887 struct btrfs_root *root,
7888 u64 bytenr, u64 num_bytes, u64 parent,
7889 u64 root_objectid, u64 owner, u64 offset,
7892 struct extent_record *rec;
7893 struct cache_extent *cache;
7895 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
7897 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
7898 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
7902 rec = container_of(cache, struct extent_record, cache);
7904 struct data_backref *back;
7905 back = find_data_backref(rec, parent, root_objectid, owner,
7906 offset, 1, bytenr, num_bytes);
7909 if (back->node.found_ref) {
7910 back->found_ref -= refs_to_drop;
7912 rec->refs -= refs_to_drop;
7914 if (back->node.found_extent_tree) {
7915 back->num_refs -= refs_to_drop;
7916 if (rec->extent_item_refs)
7917 rec->extent_item_refs -= refs_to_drop;
7919 if (back->found_ref == 0)
7920 back->node.found_ref = 0;
7921 if (back->num_refs == 0)
7922 back->node.found_extent_tree = 0;
7924 if (!back->node.found_extent_tree && back->node.found_ref) {
7925 list_del(&back->node.list);
7929 struct tree_backref *back;
7930 back = find_tree_backref(rec, parent, root_objectid);
7933 if (back->node.found_ref) {
7936 back->node.found_ref = 0;
7938 if (back->node.found_extent_tree) {
7939 if (rec->extent_item_refs)
7940 rec->extent_item_refs--;
7941 back->node.found_extent_tree = 0;
7943 if (!back->node.found_extent_tree && back->node.found_ref) {
7944 list_del(&back->node.list);
7948 maybe_free_extent_rec(extent_cache, rec);
7953 static int delete_extent_records(struct btrfs_trans_handle *trans,
7954 struct btrfs_root *root,
7955 struct btrfs_path *path,
7956 u64 bytenr, u64 new_len)
7958 struct btrfs_key key;
7959 struct btrfs_key found_key;
7960 struct extent_buffer *leaf;
7965 key.objectid = bytenr;
7967 key.offset = (u64)-1;
7970 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
7977 if (path->slots[0] == 0)
7983 leaf = path->nodes[0];
7984 slot = path->slots[0];
7986 btrfs_item_key_to_cpu(leaf, &found_key, slot);
7987 if (found_key.objectid != bytenr)
7990 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
7991 found_key.type != BTRFS_METADATA_ITEM_KEY &&
7992 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
7993 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
7994 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
7995 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
7996 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
7997 btrfs_release_path(path);
7998 if (found_key.type == 0) {
7999 if (found_key.offset == 0)
8001 key.offset = found_key.offset - 1;
8002 key.type = found_key.type;
8004 key.type = found_key.type - 1;
8005 key.offset = (u64)-1;
8009 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8010 found_key.objectid, found_key.type, found_key.offset);
8012 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8015 btrfs_release_path(path);
8017 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8018 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8019 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8020 found_key.offset : root->nodesize;
8022 ret = btrfs_update_block_group(trans, root, bytenr,
8029 btrfs_release_path(path);
8034 * for a single backref, this will allocate a new extent
8035 * and add the backref to it.
8037 static int record_extent(struct btrfs_trans_handle *trans,
8038 struct btrfs_fs_info *info,
8039 struct btrfs_path *path,
8040 struct extent_record *rec,
8041 struct extent_backref *back,
8042 int allocated, u64 flags)
8045 struct btrfs_root *extent_root = info->extent_root;
8046 struct extent_buffer *leaf;
8047 struct btrfs_key ins_key;
8048 struct btrfs_extent_item *ei;
8049 struct data_backref *dback;
8050 struct btrfs_tree_block_info *bi;
8053 rec->max_size = max_t(u64, rec->max_size,
8054 info->extent_root->nodesize);
8057 u32 item_size = sizeof(*ei);
8060 item_size += sizeof(*bi);
8062 ins_key.objectid = rec->start;
8063 ins_key.offset = rec->max_size;
8064 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8066 ret = btrfs_insert_empty_item(trans, extent_root, path,
8067 &ins_key, item_size);
8071 leaf = path->nodes[0];
8072 ei = btrfs_item_ptr(leaf, path->slots[0],
8073 struct btrfs_extent_item);
8075 btrfs_set_extent_refs(leaf, ei, 0);
8076 btrfs_set_extent_generation(leaf, ei, rec->generation);
8078 if (back->is_data) {
8079 btrfs_set_extent_flags(leaf, ei,
8080 BTRFS_EXTENT_FLAG_DATA);
8082 struct btrfs_disk_key copy_key;;
8084 bi = (struct btrfs_tree_block_info *)(ei + 1);
8085 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8088 btrfs_set_disk_key_objectid(©_key,
8089 rec->info_objectid);
8090 btrfs_set_disk_key_type(©_key, 0);
8091 btrfs_set_disk_key_offset(©_key, 0);
8093 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8094 btrfs_set_tree_block_key(leaf, bi, ©_key);
8096 btrfs_set_extent_flags(leaf, ei,
8097 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8100 btrfs_mark_buffer_dirty(leaf);
8101 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8102 rec->max_size, 1, 0);
8105 btrfs_release_path(path);
8108 if (back->is_data) {
8112 dback = to_data_backref(back);
8113 if (back->full_backref)
8114 parent = dback->parent;
8118 for (i = 0; i < dback->found_ref; i++) {
8119 /* if parent != 0, we're doing a full backref
8120 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8121 * just makes the backref allocator create a data
8124 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8125 rec->start, rec->max_size,
8129 BTRFS_FIRST_FREE_OBJECTID :
8135 fprintf(stderr, "adding new data backref"
8136 " on %llu %s %llu owner %llu"
8137 " offset %llu found %d\n",
8138 (unsigned long long)rec->start,
8139 back->full_backref ?
8141 back->full_backref ?
8142 (unsigned long long)parent :
8143 (unsigned long long)dback->root,
8144 (unsigned long long)dback->owner,
8145 (unsigned long long)dback->offset,
8149 struct tree_backref *tback;
8151 tback = to_tree_backref(back);
8152 if (back->full_backref)
8153 parent = tback->parent;
8157 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8158 rec->start, rec->max_size,
8159 parent, tback->root, 0, 0);
8160 fprintf(stderr, "adding new tree backref on "
8161 "start %llu len %llu parent %llu root %llu\n",
8162 rec->start, rec->max_size, parent, tback->root);
8165 btrfs_release_path(path);
8169 static struct extent_entry *find_entry(struct list_head *entries,
8170 u64 bytenr, u64 bytes)
8172 struct extent_entry *entry = NULL;
8174 list_for_each_entry(entry, entries, list) {
8175 if (entry->bytenr == bytenr && entry->bytes == bytes)
8182 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8184 struct extent_entry *entry, *best = NULL, *prev = NULL;
8186 list_for_each_entry(entry, entries, list) {
8188 * If there are as many broken entries as entries then we know
8189 * not to trust this particular entry.
8191 if (entry->broken == entry->count)
8195 * Special case, when there are only two entries and 'best' is
8205 * If our current entry == best then we can't be sure our best
8206 * is really the best, so we need to keep searching.
8208 if (best && best->count == entry->count) {
8214 /* Prev == entry, not good enough, have to keep searching */
8215 if (!prev->broken && prev->count == entry->count)
8219 best = (prev->count > entry->count) ? prev : entry;
8220 else if (best->count < entry->count)
8228 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8229 struct data_backref *dback, struct extent_entry *entry)
8231 struct btrfs_trans_handle *trans;
8232 struct btrfs_root *root;
8233 struct btrfs_file_extent_item *fi;
8234 struct extent_buffer *leaf;
8235 struct btrfs_key key;
8239 key.objectid = dback->root;
8240 key.type = BTRFS_ROOT_ITEM_KEY;
8241 key.offset = (u64)-1;
8242 root = btrfs_read_fs_root(info, &key);
8244 fprintf(stderr, "Couldn't find root for our ref\n");
8249 * The backref points to the original offset of the extent if it was
8250 * split, so we need to search down to the offset we have and then walk
8251 * forward until we find the backref we're looking for.
8253 key.objectid = dback->owner;
8254 key.type = BTRFS_EXTENT_DATA_KEY;
8255 key.offset = dback->offset;
8256 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8258 fprintf(stderr, "Error looking up ref %d\n", ret);
8263 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8264 ret = btrfs_next_leaf(root, path);
8266 fprintf(stderr, "Couldn't find our ref, next\n");
8270 leaf = path->nodes[0];
8271 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8272 if (key.objectid != dback->owner ||
8273 key.type != BTRFS_EXTENT_DATA_KEY) {
8274 fprintf(stderr, "Couldn't find our ref, search\n");
8277 fi = btrfs_item_ptr(leaf, path->slots[0],
8278 struct btrfs_file_extent_item);
8279 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8280 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8282 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8287 btrfs_release_path(path);
8289 trans = btrfs_start_transaction(root, 1);
8291 return PTR_ERR(trans);
8294 * Ok we have the key of the file extent we want to fix, now we can cow
8295 * down to the thing and fix it.
8297 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8299 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8300 key.objectid, key.type, key.offset, ret);
8304 fprintf(stderr, "Well that's odd, we just found this key "
8305 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8310 leaf = path->nodes[0];
8311 fi = btrfs_item_ptr(leaf, path->slots[0],
8312 struct btrfs_file_extent_item);
8314 if (btrfs_file_extent_compression(leaf, fi) &&
8315 dback->disk_bytenr != entry->bytenr) {
8316 fprintf(stderr, "Ref doesn't match the record start and is "
8317 "compressed, please take a btrfs-image of this file "
8318 "system and send it to a btrfs developer so they can "
8319 "complete this functionality for bytenr %Lu\n",
8320 dback->disk_bytenr);
8325 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8326 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8327 } else if (dback->disk_bytenr > entry->bytenr) {
8328 u64 off_diff, offset;
8330 off_diff = dback->disk_bytenr - entry->bytenr;
8331 offset = btrfs_file_extent_offset(leaf, fi);
8332 if (dback->disk_bytenr + offset +
8333 btrfs_file_extent_num_bytes(leaf, fi) >
8334 entry->bytenr + entry->bytes) {
8335 fprintf(stderr, "Ref is past the entry end, please "
8336 "take a btrfs-image of this file system and "
8337 "send it to a btrfs developer, ref %Lu\n",
8338 dback->disk_bytenr);
8343 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8344 btrfs_set_file_extent_offset(leaf, fi, offset);
8345 } else if (dback->disk_bytenr < entry->bytenr) {
8348 offset = btrfs_file_extent_offset(leaf, fi);
8349 if (dback->disk_bytenr + offset < entry->bytenr) {
8350 fprintf(stderr, "Ref is before the entry start, please"
8351 " take a btrfs-image of this file system and "
8352 "send it to a btrfs developer, ref %Lu\n",
8353 dback->disk_bytenr);
8358 offset += dback->disk_bytenr;
8359 offset -= entry->bytenr;
8360 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8361 btrfs_set_file_extent_offset(leaf, fi, offset);
8364 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8367 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8368 * only do this if we aren't using compression, otherwise it's a
8371 if (!btrfs_file_extent_compression(leaf, fi))
8372 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8374 printf("ram bytes may be wrong?\n");
8375 btrfs_mark_buffer_dirty(leaf);
8377 err = btrfs_commit_transaction(trans, root);
8378 btrfs_release_path(path);
8379 return ret ? ret : err;
8382 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8383 struct extent_record *rec)
8385 struct extent_backref *back;
8386 struct data_backref *dback;
8387 struct extent_entry *entry, *best = NULL;
8390 int broken_entries = 0;
8395 * Metadata is easy and the backrefs should always agree on bytenr and
8396 * size, if not we've got bigger issues.
8401 list_for_each_entry(back, &rec->backrefs, list) {
8402 if (back->full_backref || !back->is_data)
8405 dback = to_data_backref(back);
8408 * We only pay attention to backrefs that we found a real
8411 if (dback->found_ref == 0)
8415 * For now we only catch when the bytes don't match, not the
8416 * bytenr. We can easily do this at the same time, but I want
8417 * to have a fs image to test on before we just add repair
8418 * functionality willy-nilly so we know we won't screw up the
8422 entry = find_entry(&entries, dback->disk_bytenr,
8425 entry = malloc(sizeof(struct extent_entry));
8430 memset(entry, 0, sizeof(*entry));
8431 entry->bytenr = dback->disk_bytenr;
8432 entry->bytes = dback->bytes;
8433 list_add_tail(&entry->list, &entries);
8438 * If we only have on entry we may think the entries agree when
8439 * in reality they don't so we have to do some extra checking.
8441 if (dback->disk_bytenr != rec->start ||
8442 dback->bytes != rec->nr || back->broken)
8453 /* Yay all the backrefs agree, carry on good sir */
8454 if (nr_entries <= 1 && !mismatch)
8457 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8458 "%Lu\n", rec->start);
8461 * First we want to see if the backrefs can agree amongst themselves who
8462 * is right, so figure out which one of the entries has the highest
8465 best = find_most_right_entry(&entries);
8468 * Ok so we may have an even split between what the backrefs think, so
8469 * this is where we use the extent ref to see what it thinks.
8472 entry = find_entry(&entries, rec->start, rec->nr);
8473 if (!entry && (!broken_entries || !rec->found_rec)) {
8474 fprintf(stderr, "Backrefs don't agree with each other "
8475 "and extent record doesn't agree with anybody,"
8476 " so we can't fix bytenr %Lu bytes %Lu\n",
8477 rec->start, rec->nr);
8480 } else if (!entry) {
8482 * Ok our backrefs were broken, we'll assume this is the
8483 * correct value and add an entry for this range.
8485 entry = malloc(sizeof(struct extent_entry));
8490 memset(entry, 0, sizeof(*entry));
8491 entry->bytenr = rec->start;
8492 entry->bytes = rec->nr;
8493 list_add_tail(&entry->list, &entries);
8497 best = find_most_right_entry(&entries);
8499 fprintf(stderr, "Backrefs and extent record evenly "
8500 "split on who is right, this is going to "
8501 "require user input to fix bytenr %Lu bytes "
8502 "%Lu\n", rec->start, rec->nr);
8509 * I don't think this can happen currently as we'll abort() if we catch
8510 * this case higher up, but in case somebody removes that we still can't
8511 * deal with it properly here yet, so just bail out of that's the case.
8513 if (best->bytenr != rec->start) {
8514 fprintf(stderr, "Extent start and backref starts don't match, "
8515 "please use btrfs-image on this file system and send "
8516 "it to a btrfs developer so they can make fsck fix "
8517 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8518 rec->start, rec->nr);
8524 * Ok great we all agreed on an extent record, let's go find the real
8525 * references and fix up the ones that don't match.
8527 list_for_each_entry(back, &rec->backrefs, list) {
8528 if (back->full_backref || !back->is_data)
8531 dback = to_data_backref(back);
8534 * Still ignoring backrefs that don't have a real ref attached
8537 if (dback->found_ref == 0)
8540 if (dback->bytes == best->bytes &&
8541 dback->disk_bytenr == best->bytenr)
8544 ret = repair_ref(info, path, dback, best);
8550 * Ok we messed with the actual refs, which means we need to drop our
8551 * entire cache and go back and rescan. I know this is a huge pain and
8552 * adds a lot of extra work, but it's the only way to be safe. Once all
8553 * the backrefs agree we may not need to do anything to the extent
8558 while (!list_empty(&entries)) {
8559 entry = list_entry(entries.next, struct extent_entry, list);
8560 list_del_init(&entry->list);
8566 static int process_duplicates(struct btrfs_root *root,
8567 struct cache_tree *extent_cache,
8568 struct extent_record *rec)
8570 struct extent_record *good, *tmp;
8571 struct cache_extent *cache;
8575 * If we found a extent record for this extent then return, or if we
8576 * have more than one duplicate we are likely going to need to delete
8579 if (rec->found_rec || rec->num_duplicates > 1)
8582 /* Shouldn't happen but just in case */
8583 BUG_ON(!rec->num_duplicates);
8586 * So this happens if we end up with a backref that doesn't match the
8587 * actual extent entry. So either the backref is bad or the extent
8588 * entry is bad. Either way we want to have the extent_record actually
8589 * reflect what we found in the extent_tree, so we need to take the
8590 * duplicate out and use that as the extent_record since the only way we
8591 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8593 remove_cache_extent(extent_cache, &rec->cache);
8595 good = to_extent_record(rec->dups.next);
8596 list_del_init(&good->list);
8597 INIT_LIST_HEAD(&good->backrefs);
8598 INIT_LIST_HEAD(&good->dups);
8599 good->cache.start = good->start;
8600 good->cache.size = good->nr;
8601 good->content_checked = 0;
8602 good->owner_ref_checked = 0;
8603 good->num_duplicates = 0;
8604 good->refs = rec->refs;
8605 list_splice_init(&rec->backrefs, &good->backrefs);
8607 cache = lookup_cache_extent(extent_cache, good->start,
8611 tmp = container_of(cache, struct extent_record, cache);
8614 * If we find another overlapping extent and it's found_rec is
8615 * set then it's a duplicate and we need to try and delete
8618 if (tmp->found_rec || tmp->num_duplicates > 0) {
8619 if (list_empty(&good->list))
8620 list_add_tail(&good->list,
8621 &duplicate_extents);
8622 good->num_duplicates += tmp->num_duplicates + 1;
8623 list_splice_init(&tmp->dups, &good->dups);
8624 list_del_init(&tmp->list);
8625 list_add_tail(&tmp->list, &good->dups);
8626 remove_cache_extent(extent_cache, &tmp->cache);
8631 * Ok we have another non extent item backed extent rec, so lets
8632 * just add it to this extent and carry on like we did above.
8634 good->refs += tmp->refs;
8635 list_splice_init(&tmp->backrefs, &good->backrefs);
8636 remove_cache_extent(extent_cache, &tmp->cache);
8639 ret = insert_cache_extent(extent_cache, &good->cache);
8642 return good->num_duplicates ? 0 : 1;
8645 static int delete_duplicate_records(struct btrfs_root *root,
8646 struct extent_record *rec)
8648 struct btrfs_trans_handle *trans;
8649 LIST_HEAD(delete_list);
8650 struct btrfs_path path;
8651 struct extent_record *tmp, *good, *n;
8654 struct btrfs_key key;
8656 btrfs_init_path(&path);
8659 /* Find the record that covers all of the duplicates. */
8660 list_for_each_entry(tmp, &rec->dups, list) {
8661 if (good->start < tmp->start)
8663 if (good->nr > tmp->nr)
8666 if (tmp->start + tmp->nr < good->start + good->nr) {
8667 fprintf(stderr, "Ok we have overlapping extents that "
8668 "aren't completely covered by each other, this "
8669 "is going to require more careful thought. "
8670 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8671 tmp->start, tmp->nr, good->start, good->nr);
8678 list_add_tail(&rec->list, &delete_list);
8680 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8683 list_move_tail(&tmp->list, &delete_list);
8686 root = root->fs_info->extent_root;
8687 trans = btrfs_start_transaction(root, 1);
8688 if (IS_ERR(trans)) {
8689 ret = PTR_ERR(trans);
8693 list_for_each_entry(tmp, &delete_list, list) {
8694 if (tmp->found_rec == 0)
8696 key.objectid = tmp->start;
8697 key.type = BTRFS_EXTENT_ITEM_KEY;
8698 key.offset = tmp->nr;
8700 /* Shouldn't happen but just in case */
8701 if (tmp->metadata) {
8702 fprintf(stderr, "Well this shouldn't happen, extent "
8703 "record overlaps but is metadata? "
8704 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8708 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8714 ret = btrfs_del_item(trans, root, &path);
8717 btrfs_release_path(&path);
8720 err = btrfs_commit_transaction(trans, root);
8724 while (!list_empty(&delete_list)) {
8725 tmp = to_extent_record(delete_list.next);
8726 list_del_init(&tmp->list);
8732 while (!list_empty(&rec->dups)) {
8733 tmp = to_extent_record(rec->dups.next);
8734 list_del_init(&tmp->list);
8738 btrfs_release_path(&path);
8740 if (!ret && !nr_del)
8741 rec->num_duplicates = 0;
8743 return ret ? ret : nr_del;
8746 static int find_possible_backrefs(struct btrfs_fs_info *info,
8747 struct btrfs_path *path,
8748 struct cache_tree *extent_cache,
8749 struct extent_record *rec)
8751 struct btrfs_root *root;
8752 struct extent_backref *back;
8753 struct data_backref *dback;
8754 struct cache_extent *cache;
8755 struct btrfs_file_extent_item *fi;
8756 struct btrfs_key key;
8760 list_for_each_entry(back, &rec->backrefs, list) {
8761 /* Don't care about full backrefs (poor unloved backrefs) */
8762 if (back->full_backref || !back->is_data)
8765 dback = to_data_backref(back);
8767 /* We found this one, we don't need to do a lookup */
8768 if (dback->found_ref)
8771 key.objectid = dback->root;
8772 key.type = BTRFS_ROOT_ITEM_KEY;
8773 key.offset = (u64)-1;
8775 root = btrfs_read_fs_root(info, &key);
8777 /* No root, definitely a bad ref, skip */
8778 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8780 /* Other err, exit */
8782 return PTR_ERR(root);
8784 key.objectid = dback->owner;
8785 key.type = BTRFS_EXTENT_DATA_KEY;
8786 key.offset = dback->offset;
8787 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8789 btrfs_release_path(path);
8792 /* Didn't find it, we can carry on */
8797 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8798 struct btrfs_file_extent_item);
8799 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8800 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8801 btrfs_release_path(path);
8802 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8804 struct extent_record *tmp;
8805 tmp = container_of(cache, struct extent_record, cache);
8808 * If we found an extent record for the bytenr for this
8809 * particular backref then we can't add it to our
8810 * current extent record. We only want to add backrefs
8811 * that don't have a corresponding extent item in the
8812 * extent tree since they likely belong to this record
8813 * and we need to fix it if it doesn't match bytenrs.
8819 dback->found_ref += 1;
8820 dback->disk_bytenr = bytenr;
8821 dback->bytes = bytes;
8824 * Set this so the verify backref code knows not to trust the
8825 * values in this backref.
8834 * Record orphan data ref into corresponding root.
8836 * Return 0 if the extent item contains data ref and recorded.
8837 * Return 1 if the extent item contains no useful data ref
8838 * On that case, it may contains only shared_dataref or metadata backref
8839 * or the file extent exists(this should be handled by the extent bytenr
8841 * Return <0 if something goes wrong.
8843 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8844 struct extent_record *rec)
8846 struct btrfs_key key;
8847 struct btrfs_root *dest_root;
8848 struct extent_backref *back;
8849 struct data_backref *dback;
8850 struct orphan_data_extent *orphan;
8851 struct btrfs_path path;
8852 int recorded_data_ref = 0;
8857 btrfs_init_path(&path);
8858 list_for_each_entry(back, &rec->backrefs, list) {
8859 if (back->full_backref || !back->is_data ||
8860 !back->found_extent_tree)
8862 dback = to_data_backref(back);
8863 if (dback->found_ref)
8865 key.objectid = dback->root;
8866 key.type = BTRFS_ROOT_ITEM_KEY;
8867 key.offset = (u64)-1;
8869 dest_root = btrfs_read_fs_root(fs_info, &key);
8871 /* For non-exist root we just skip it */
8872 if (IS_ERR(dest_root) || !dest_root)
8875 key.objectid = dback->owner;
8876 key.type = BTRFS_EXTENT_DATA_KEY;
8877 key.offset = dback->offset;
8879 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8880 btrfs_release_path(&path);
8882 * For ret < 0, it's OK since the fs-tree may be corrupted,
8883 * we need to record it for inode/file extent rebuild.
8884 * For ret > 0, we record it only for file extent rebuild.
8885 * For ret == 0, the file extent exists but only bytenr
8886 * mismatch, let the original bytenr fix routine to handle,
8892 orphan = malloc(sizeof(*orphan));
8897 INIT_LIST_HEAD(&orphan->list);
8898 orphan->root = dback->root;
8899 orphan->objectid = dback->owner;
8900 orphan->offset = dback->offset;
8901 orphan->disk_bytenr = rec->cache.start;
8902 orphan->disk_len = rec->cache.size;
8903 list_add(&dest_root->orphan_data_extents, &orphan->list);
8904 recorded_data_ref = 1;
8907 btrfs_release_path(&path);
8909 return !recorded_data_ref;
8915 * when an incorrect extent item is found, this will delete
8916 * all of the existing entries for it and recreate them
8917 * based on what the tree scan found.
8919 static int fixup_extent_refs(struct btrfs_fs_info *info,
8920 struct cache_tree *extent_cache,
8921 struct extent_record *rec)
8923 struct btrfs_trans_handle *trans = NULL;
8925 struct btrfs_path path;
8926 struct list_head *cur = rec->backrefs.next;
8927 struct cache_extent *cache;
8928 struct extent_backref *back;
8932 if (rec->flag_block_full_backref)
8933 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
8935 btrfs_init_path(&path);
8936 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
8938 * Sometimes the backrefs themselves are so broken they don't
8939 * get attached to any meaningful rec, so first go back and
8940 * check any of our backrefs that we couldn't find and throw
8941 * them into the list if we find the backref so that
8942 * verify_backrefs can figure out what to do.
8944 ret = find_possible_backrefs(info, &path, extent_cache, rec);
8949 /* step one, make sure all of the backrefs agree */
8950 ret = verify_backrefs(info, &path, rec);
8954 trans = btrfs_start_transaction(info->extent_root, 1);
8955 if (IS_ERR(trans)) {
8956 ret = PTR_ERR(trans);
8960 /* step two, delete all the existing records */
8961 ret = delete_extent_records(trans, info->extent_root, &path,
8962 rec->start, rec->max_size);
8967 /* was this block corrupt? If so, don't add references to it */
8968 cache = lookup_cache_extent(info->corrupt_blocks,
8969 rec->start, rec->max_size);
8975 /* step three, recreate all the refs we did find */
8976 while(cur != &rec->backrefs) {
8977 back = to_extent_backref(cur);
8981 * if we didn't find any references, don't create a
8984 if (!back->found_ref)
8987 rec->bad_full_backref = 0;
8988 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
8996 int err = btrfs_commit_transaction(trans, info->extent_root);
9002 fprintf(stderr, "Repaired extent references for %llu\n",
9003 (unsigned long long)rec->start);
9005 btrfs_release_path(&path);
9009 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9010 struct extent_record *rec)
9012 struct btrfs_trans_handle *trans;
9013 struct btrfs_root *root = fs_info->extent_root;
9014 struct btrfs_path path;
9015 struct btrfs_extent_item *ei;
9016 struct btrfs_key key;
9020 key.objectid = rec->start;
9021 if (rec->metadata) {
9022 key.type = BTRFS_METADATA_ITEM_KEY;
9023 key.offset = rec->info_level;
9025 key.type = BTRFS_EXTENT_ITEM_KEY;
9026 key.offset = rec->max_size;
9029 trans = btrfs_start_transaction(root, 0);
9031 return PTR_ERR(trans);
9033 btrfs_init_path(&path);
9034 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9036 btrfs_release_path(&path);
9037 btrfs_commit_transaction(trans, root);
9040 fprintf(stderr, "Didn't find extent for %llu\n",
9041 (unsigned long long)rec->start);
9042 btrfs_release_path(&path);
9043 btrfs_commit_transaction(trans, root);
9047 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9048 struct btrfs_extent_item);
9049 flags = btrfs_extent_flags(path.nodes[0], ei);
9050 if (rec->flag_block_full_backref) {
9051 fprintf(stderr, "setting full backref on %llu\n",
9052 (unsigned long long)key.objectid);
9053 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9055 fprintf(stderr, "clearing full backref on %llu\n",
9056 (unsigned long long)key.objectid);
9057 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9059 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9060 btrfs_mark_buffer_dirty(path.nodes[0]);
9061 btrfs_release_path(&path);
9062 ret = btrfs_commit_transaction(trans, root);
9064 fprintf(stderr, "Repaired extent flags for %llu\n",
9065 (unsigned long long)rec->start);
9070 /* right now we only prune from the extent allocation tree */
9071 static int prune_one_block(struct btrfs_trans_handle *trans,
9072 struct btrfs_fs_info *info,
9073 struct btrfs_corrupt_block *corrupt)
9076 struct btrfs_path path;
9077 struct extent_buffer *eb;
9081 int level = corrupt->level + 1;
9083 btrfs_init_path(&path);
9085 /* we want to stop at the parent to our busted block */
9086 path.lowest_level = level;
9088 ret = btrfs_search_slot(trans, info->extent_root,
9089 &corrupt->key, &path, -1, 1);
9094 eb = path.nodes[level];
9101 * hopefully the search gave us the block we want to prune,
9102 * lets try that first
9104 slot = path.slots[level];
9105 found = btrfs_node_blockptr(eb, slot);
9106 if (found == corrupt->cache.start)
9109 nritems = btrfs_header_nritems(eb);
9111 /* the search failed, lets scan this node and hope we find it */
9112 for (slot = 0; slot < nritems; slot++) {
9113 found = btrfs_node_blockptr(eb, slot);
9114 if (found == corrupt->cache.start)
9118 * we couldn't find the bad block. TODO, search all the nodes for pointers
9121 if (eb == info->extent_root->node) {
9126 btrfs_release_path(&path);
9131 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9132 ret = btrfs_del_ptr(trans, info->extent_root, &path, level, slot);
9135 btrfs_release_path(&path);
9139 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9141 struct btrfs_trans_handle *trans = NULL;
9142 struct cache_extent *cache;
9143 struct btrfs_corrupt_block *corrupt;
9146 cache = search_cache_extent(info->corrupt_blocks, 0);
9150 trans = btrfs_start_transaction(info->extent_root, 1);
9152 return PTR_ERR(trans);
9154 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9155 prune_one_block(trans, info, corrupt);
9156 remove_cache_extent(info->corrupt_blocks, cache);
9159 return btrfs_commit_transaction(trans, info->extent_root);
9163 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9165 struct btrfs_block_group_cache *cache;
9170 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9171 &start, &end, EXTENT_DIRTY);
9174 clear_extent_dirty(&fs_info->free_space_cache, start, end,
9180 cache = btrfs_lookup_first_block_group(fs_info, start);
9185 start = cache->key.objectid + cache->key.offset;
9189 static int check_extent_refs(struct btrfs_root *root,
9190 struct cache_tree *extent_cache)
9192 struct extent_record *rec;
9193 struct cache_extent *cache;
9199 * if we're doing a repair, we have to make sure
9200 * we don't allocate from the problem extents.
9201 * In the worst case, this will be all the
9204 cache = search_cache_extent(extent_cache, 0);
9206 rec = container_of(cache, struct extent_record, cache);
9207 set_extent_dirty(root->fs_info->excluded_extents,
9209 rec->start + rec->max_size - 1,
9211 cache = next_cache_extent(cache);
9214 /* pin down all the corrupted blocks too */
9215 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9217 set_extent_dirty(root->fs_info->excluded_extents,
9219 cache->start + cache->size - 1,
9221 cache = next_cache_extent(cache);
9223 prune_corrupt_blocks(root->fs_info);
9224 reset_cached_block_groups(root->fs_info);
9227 reset_cached_block_groups(root->fs_info);
9230 * We need to delete any duplicate entries we find first otherwise we
9231 * could mess up the extent tree when we have backrefs that actually
9232 * belong to a different extent item and not the weird duplicate one.
9234 while (repair && !list_empty(&duplicate_extents)) {
9235 rec = to_extent_record(duplicate_extents.next);
9236 list_del_init(&rec->list);
9238 /* Sometimes we can find a backref before we find an actual
9239 * extent, so we need to process it a little bit to see if there
9240 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9241 * if this is a backref screwup. If we need to delete stuff
9242 * process_duplicates() will return 0, otherwise it will return
9245 if (process_duplicates(root, extent_cache, rec))
9247 ret = delete_duplicate_records(root, rec);
9251 * delete_duplicate_records will return the number of entries
9252 * deleted, so if it's greater than 0 then we know we actually
9253 * did something and we need to remove.
9266 cache = search_cache_extent(extent_cache, 0);
9269 rec = container_of(cache, struct extent_record, cache);
9270 if (rec->num_duplicates) {
9271 fprintf(stderr, "extent item %llu has multiple extent "
9272 "items\n", (unsigned long long)rec->start);
9276 if (rec->refs != rec->extent_item_refs) {
9277 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9278 (unsigned long long)rec->start,
9279 (unsigned long long)rec->nr);
9280 fprintf(stderr, "extent item %llu, found %llu\n",
9281 (unsigned long long)rec->extent_item_refs,
9282 (unsigned long long)rec->refs);
9283 ret = record_orphan_data_extents(root->fs_info, rec);
9289 if (all_backpointers_checked(rec, 1)) {
9290 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9291 (unsigned long long)rec->start,
9292 (unsigned long long)rec->nr);
9296 if (!rec->owner_ref_checked) {
9297 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9298 (unsigned long long)rec->start,
9299 (unsigned long long)rec->nr);
9304 if (repair && fix) {
9305 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9311 if (rec->bad_full_backref) {
9312 fprintf(stderr, "bad full backref, on [%llu]\n",
9313 (unsigned long long)rec->start);
9315 ret = fixup_extent_flags(root->fs_info, rec);
9323 * Although it's not a extent ref's problem, we reuse this
9324 * routine for error reporting.
9325 * No repair function yet.
9327 if (rec->crossing_stripes) {
9329 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9330 rec->start, rec->start + rec->max_size);
9334 if (rec->wrong_chunk_type) {
9336 "bad extent [%llu, %llu), type mismatch with chunk\n",
9337 rec->start, rec->start + rec->max_size);
9341 remove_cache_extent(extent_cache, cache);
9342 free_all_extent_backrefs(rec);
9343 if (!init_extent_tree && repair && (!cur_err || fix))
9344 clear_extent_dirty(root->fs_info->excluded_extents,
9346 rec->start + rec->max_size - 1,
9352 if (ret && ret != -EAGAIN) {
9353 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9356 struct btrfs_trans_handle *trans;
9358 root = root->fs_info->extent_root;
9359 trans = btrfs_start_transaction(root, 1);
9360 if (IS_ERR(trans)) {
9361 ret = PTR_ERR(trans);
9365 btrfs_fix_block_accounting(trans, root);
9366 ret = btrfs_commit_transaction(trans, root);
9375 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9379 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9380 stripe_size = length;
9381 stripe_size /= num_stripes;
9382 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9383 stripe_size = length * 2;
9384 stripe_size /= num_stripes;
9385 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9386 stripe_size = length;
9387 stripe_size /= (num_stripes - 1);
9388 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9389 stripe_size = length;
9390 stripe_size /= (num_stripes - 2);
9392 stripe_size = length;
9398 * Check the chunk with its block group/dev list ref:
9399 * Return 0 if all refs seems valid.
9400 * Return 1 if part of refs seems valid, need later check for rebuild ref
9401 * like missing block group and needs to search extent tree to rebuild them.
9402 * Return -1 if essential refs are missing and unable to rebuild.
9404 static int check_chunk_refs(struct chunk_record *chunk_rec,
9405 struct block_group_tree *block_group_cache,
9406 struct device_extent_tree *dev_extent_cache,
9409 struct cache_extent *block_group_item;
9410 struct block_group_record *block_group_rec;
9411 struct cache_extent *dev_extent_item;
9412 struct device_extent_record *dev_extent_rec;
9416 int metadump_v2 = 0;
9420 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9423 if (block_group_item) {
9424 block_group_rec = container_of(block_group_item,
9425 struct block_group_record,
9427 if (chunk_rec->length != block_group_rec->offset ||
9428 chunk_rec->offset != block_group_rec->objectid ||
9430 chunk_rec->type_flags != block_group_rec->flags)) {
9433 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9434 chunk_rec->objectid,
9439 chunk_rec->type_flags,
9440 block_group_rec->objectid,
9441 block_group_rec->type,
9442 block_group_rec->offset,
9443 block_group_rec->offset,
9444 block_group_rec->objectid,
9445 block_group_rec->flags);
9448 list_del_init(&block_group_rec->list);
9449 chunk_rec->bg_rec = block_group_rec;
9454 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9455 chunk_rec->objectid,
9460 chunk_rec->type_flags);
9467 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9468 chunk_rec->num_stripes);
9469 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9470 devid = chunk_rec->stripes[i].devid;
9471 offset = chunk_rec->stripes[i].offset;
9472 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9473 devid, offset, length);
9474 if (dev_extent_item) {
9475 dev_extent_rec = container_of(dev_extent_item,
9476 struct device_extent_record,
9478 if (dev_extent_rec->objectid != devid ||
9479 dev_extent_rec->offset != offset ||
9480 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9481 dev_extent_rec->length != length) {
9484 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9485 chunk_rec->objectid,
9488 chunk_rec->stripes[i].devid,
9489 chunk_rec->stripes[i].offset,
9490 dev_extent_rec->objectid,
9491 dev_extent_rec->offset,
9492 dev_extent_rec->length);
9495 list_move(&dev_extent_rec->chunk_list,
9496 &chunk_rec->dextents);
9501 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9502 chunk_rec->objectid,
9505 chunk_rec->stripes[i].devid,
9506 chunk_rec->stripes[i].offset);
9513 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9514 int check_chunks(struct cache_tree *chunk_cache,
9515 struct block_group_tree *block_group_cache,
9516 struct device_extent_tree *dev_extent_cache,
9517 struct list_head *good, struct list_head *bad,
9518 struct list_head *rebuild, int silent)
9520 struct cache_extent *chunk_item;
9521 struct chunk_record *chunk_rec;
9522 struct block_group_record *bg_rec;
9523 struct device_extent_record *dext_rec;
9527 chunk_item = first_cache_extent(chunk_cache);
9528 while (chunk_item) {
9529 chunk_rec = container_of(chunk_item, struct chunk_record,
9531 err = check_chunk_refs(chunk_rec, block_group_cache,
9532 dev_extent_cache, silent);
9535 if (err == 0 && good)
9536 list_add_tail(&chunk_rec->list, good);
9537 if (err > 0 && rebuild)
9538 list_add_tail(&chunk_rec->list, rebuild);
9540 list_add_tail(&chunk_rec->list, bad);
9541 chunk_item = next_cache_extent(chunk_item);
9544 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9547 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9555 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9559 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9570 static int check_device_used(struct device_record *dev_rec,
9571 struct device_extent_tree *dext_cache)
9573 struct cache_extent *cache;
9574 struct device_extent_record *dev_extent_rec;
9577 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9579 dev_extent_rec = container_of(cache,
9580 struct device_extent_record,
9582 if (dev_extent_rec->objectid != dev_rec->devid)
9585 list_del_init(&dev_extent_rec->device_list);
9586 total_byte += dev_extent_rec->length;
9587 cache = next_cache_extent(cache);
9590 if (total_byte != dev_rec->byte_used) {
9592 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9593 total_byte, dev_rec->byte_used, dev_rec->objectid,
9594 dev_rec->type, dev_rec->offset);
9601 /* check btrfs_dev_item -> btrfs_dev_extent */
9602 static int check_devices(struct rb_root *dev_cache,
9603 struct device_extent_tree *dev_extent_cache)
9605 struct rb_node *dev_node;
9606 struct device_record *dev_rec;
9607 struct device_extent_record *dext_rec;
9611 dev_node = rb_first(dev_cache);
9613 dev_rec = container_of(dev_node, struct device_record, node);
9614 err = check_device_used(dev_rec, dev_extent_cache);
9618 dev_node = rb_next(dev_node);
9620 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9623 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9624 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9631 static int add_root_item_to_list(struct list_head *head,
9632 u64 objectid, u64 bytenr, u64 last_snapshot,
9633 u8 level, u8 drop_level,
9634 int level_size, struct btrfs_key *drop_key)
9637 struct root_item_record *ri_rec;
9638 ri_rec = malloc(sizeof(*ri_rec));
9641 ri_rec->bytenr = bytenr;
9642 ri_rec->objectid = objectid;
9643 ri_rec->level = level;
9644 ri_rec->level_size = level_size;
9645 ri_rec->drop_level = drop_level;
9646 ri_rec->last_snapshot = last_snapshot;
9648 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9649 list_add_tail(&ri_rec->list, head);
9654 static void free_root_item_list(struct list_head *list)
9656 struct root_item_record *ri_rec;
9658 while (!list_empty(list)) {
9659 ri_rec = list_first_entry(list, struct root_item_record,
9661 list_del_init(&ri_rec->list);
9666 static int deal_root_from_list(struct list_head *list,
9667 struct btrfs_root *root,
9668 struct block_info *bits,
9670 struct cache_tree *pending,
9671 struct cache_tree *seen,
9672 struct cache_tree *reada,
9673 struct cache_tree *nodes,
9674 struct cache_tree *extent_cache,
9675 struct cache_tree *chunk_cache,
9676 struct rb_root *dev_cache,
9677 struct block_group_tree *block_group_cache,
9678 struct device_extent_tree *dev_extent_cache)
9683 while (!list_empty(list)) {
9684 struct root_item_record *rec;
9685 struct extent_buffer *buf;
9686 rec = list_entry(list->next,
9687 struct root_item_record, list);
9689 buf = read_tree_block(root->fs_info->tree_root,
9690 rec->bytenr, rec->level_size, 0);
9691 if (!extent_buffer_uptodate(buf)) {
9692 free_extent_buffer(buf);
9696 ret = add_root_to_pending(buf, extent_cache, pending,
9697 seen, nodes, rec->objectid);
9701 * To rebuild extent tree, we need deal with snapshot
9702 * one by one, otherwise we deal with node firstly which
9703 * can maximize readahead.
9706 ret = run_next_block(root, bits, bits_nr, &last,
9707 pending, seen, reada, nodes,
9708 extent_cache, chunk_cache,
9709 dev_cache, block_group_cache,
9710 dev_extent_cache, rec);
9714 free_extent_buffer(buf);
9715 list_del(&rec->list);
9721 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9722 reada, nodes, extent_cache, chunk_cache,
9723 dev_cache, block_group_cache,
9724 dev_extent_cache, NULL);
9734 static int check_chunks_and_extents(struct btrfs_root *root)
9736 struct rb_root dev_cache;
9737 struct cache_tree chunk_cache;
9738 struct block_group_tree block_group_cache;
9739 struct device_extent_tree dev_extent_cache;
9740 struct cache_tree extent_cache;
9741 struct cache_tree seen;
9742 struct cache_tree pending;
9743 struct cache_tree reada;
9744 struct cache_tree nodes;
9745 struct extent_io_tree excluded_extents;
9746 struct cache_tree corrupt_blocks;
9747 struct btrfs_path path;
9748 struct btrfs_key key;
9749 struct btrfs_key found_key;
9751 struct block_info *bits;
9753 struct extent_buffer *leaf;
9755 struct btrfs_root_item ri;
9756 struct list_head dropping_trees;
9757 struct list_head normal_trees;
9758 struct btrfs_root *root1;
9763 dev_cache = RB_ROOT;
9764 cache_tree_init(&chunk_cache);
9765 block_group_tree_init(&block_group_cache);
9766 device_extent_tree_init(&dev_extent_cache);
9768 cache_tree_init(&extent_cache);
9769 cache_tree_init(&seen);
9770 cache_tree_init(&pending);
9771 cache_tree_init(&nodes);
9772 cache_tree_init(&reada);
9773 cache_tree_init(&corrupt_blocks);
9774 extent_io_tree_init(&excluded_extents);
9775 INIT_LIST_HEAD(&dropping_trees);
9776 INIT_LIST_HEAD(&normal_trees);
9779 root->fs_info->excluded_extents = &excluded_extents;
9780 root->fs_info->fsck_extent_cache = &extent_cache;
9781 root->fs_info->free_extent_hook = free_extent_hook;
9782 root->fs_info->corrupt_blocks = &corrupt_blocks;
9786 bits = malloc(bits_nr * sizeof(struct block_info));
9792 if (ctx.progress_enabled) {
9793 ctx.tp = TASK_EXTENTS;
9794 task_start(ctx.info);
9798 root1 = root->fs_info->tree_root;
9799 level = btrfs_header_level(root1->node);
9800 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9801 root1->node->start, 0, level, 0,
9802 root1->nodesize, NULL);
9805 root1 = root->fs_info->chunk_root;
9806 level = btrfs_header_level(root1->node);
9807 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9808 root1->node->start, 0, level, 0,
9809 root1->nodesize, NULL);
9812 btrfs_init_path(&path);
9815 key.type = BTRFS_ROOT_ITEM_KEY;
9816 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9821 leaf = path.nodes[0];
9822 slot = path.slots[0];
9823 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9824 ret = btrfs_next_leaf(root, &path);
9827 leaf = path.nodes[0];
9828 slot = path.slots[0];
9830 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9831 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9832 unsigned long offset;
9835 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9836 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9837 last_snapshot = btrfs_root_last_snapshot(&ri);
9838 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9839 level = btrfs_root_level(&ri);
9840 level_size = root->nodesize;
9841 ret = add_root_item_to_list(&normal_trees,
9843 btrfs_root_bytenr(&ri),
9844 last_snapshot, level,
9845 0, level_size, NULL);
9849 level = btrfs_root_level(&ri);
9850 level_size = root->nodesize;
9851 objectid = found_key.objectid;
9852 btrfs_disk_key_to_cpu(&found_key,
9854 ret = add_root_item_to_list(&dropping_trees,
9856 btrfs_root_bytenr(&ri),
9857 last_snapshot, level,
9859 level_size, &found_key);
9866 btrfs_release_path(&path);
9869 * check_block can return -EAGAIN if it fixes something, please keep
9870 * this in mind when dealing with return values from these functions, if
9871 * we get -EAGAIN we want to fall through and restart the loop.
9873 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9874 &seen, &reada, &nodes, &extent_cache,
9875 &chunk_cache, &dev_cache, &block_group_cache,
9882 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9883 &pending, &seen, &reada, &nodes,
9884 &extent_cache, &chunk_cache, &dev_cache,
9885 &block_group_cache, &dev_extent_cache);
9892 ret = check_chunks(&chunk_cache, &block_group_cache,
9893 &dev_extent_cache, NULL, NULL, NULL, 0);
9900 ret = check_extent_refs(root, &extent_cache);
9907 ret = check_devices(&dev_cache, &dev_extent_cache);
9912 task_stop(ctx.info);
9914 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9915 extent_io_tree_cleanup(&excluded_extents);
9916 root->fs_info->fsck_extent_cache = NULL;
9917 root->fs_info->free_extent_hook = NULL;
9918 root->fs_info->corrupt_blocks = NULL;
9919 root->fs_info->excluded_extents = NULL;
9922 free_chunk_cache_tree(&chunk_cache);
9923 free_device_cache_tree(&dev_cache);
9924 free_block_group_tree(&block_group_cache);
9925 free_device_extent_tree(&dev_extent_cache);
9926 free_extent_cache_tree(&seen);
9927 free_extent_cache_tree(&pending);
9928 free_extent_cache_tree(&reada);
9929 free_extent_cache_tree(&nodes);
9932 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9933 free_extent_cache_tree(&seen);
9934 free_extent_cache_tree(&pending);
9935 free_extent_cache_tree(&reada);
9936 free_extent_cache_tree(&nodes);
9937 free_chunk_cache_tree(&chunk_cache);
9938 free_block_group_tree(&block_group_cache);
9939 free_device_cache_tree(&dev_cache);
9940 free_device_extent_tree(&dev_extent_cache);
9941 free_extent_record_cache(root->fs_info, &extent_cache);
9942 free_root_item_list(&normal_trees);
9943 free_root_item_list(&dropping_trees);
9944 extent_io_tree_cleanup(&excluded_extents);
9949 * Check backrefs of a tree block given by @bytenr or @eb.
9951 * @root: the root containing the @bytenr or @eb
9952 * @eb: tree block extent buffer, can be NULL
9953 * @bytenr: bytenr of the tree block to search
9954 * @level: tree level of the tree block
9955 * @owner: owner of the tree block
9957 * Return >0 for any error found and output error message
9958 * Return 0 for no error found
9960 static int check_tree_block_ref(struct btrfs_root *root,
9961 struct extent_buffer *eb, u64 bytenr,
9962 int level, u64 owner)
9964 struct btrfs_key key;
9965 struct btrfs_root *extent_root = root->fs_info->extent_root;
9966 struct btrfs_path path;
9967 struct btrfs_extent_item *ei;
9968 struct btrfs_extent_inline_ref *iref;
9969 struct extent_buffer *leaf;
9975 u32 nodesize = root->nodesize;
9982 btrfs_init_path(&path);
9983 key.objectid = bytenr;
9984 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
9985 key.type = BTRFS_METADATA_ITEM_KEY;
9987 key.type = BTRFS_EXTENT_ITEM_KEY;
9988 key.offset = (u64)-1;
9990 /* Search for the backref in extent tree */
9991 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
9993 err |= BACKREF_MISSING;
9996 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
9998 err |= BACKREF_MISSING;
10002 leaf = path.nodes[0];
10003 slot = path.slots[0];
10004 btrfs_item_key_to_cpu(leaf, &key, slot);
10006 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10008 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10009 skinny_level = (int)key.offset;
10010 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10012 struct btrfs_tree_block_info *info;
10014 info = (struct btrfs_tree_block_info *)(ei + 1);
10015 skinny_level = btrfs_tree_block_level(leaf, info);
10016 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10023 if (!(btrfs_extent_flags(leaf, ei) &
10024 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10026 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10027 key.objectid, nodesize,
10028 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10029 err = BACKREF_MISMATCH;
10031 header_gen = btrfs_header_generation(eb);
10032 extent_gen = btrfs_extent_generation(leaf, ei);
10033 if (header_gen != extent_gen) {
10035 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10036 key.objectid, nodesize, header_gen,
10038 err = BACKREF_MISMATCH;
10040 if (level != skinny_level) {
10042 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10043 key.objectid, nodesize, level, skinny_level);
10044 err = BACKREF_MISMATCH;
10046 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10048 "extent[%llu %u] is referred by other roots than %llu",
10049 key.objectid, nodesize, root->objectid);
10050 err = BACKREF_MISMATCH;
10055 * Iterate the extent/metadata item to find the exact backref
10057 item_size = btrfs_item_size_nr(leaf, slot);
10058 ptr = (unsigned long)iref;
10059 end = (unsigned long)ei + item_size;
10060 while (ptr < end) {
10061 iref = (struct btrfs_extent_inline_ref *)ptr;
10062 type = btrfs_extent_inline_ref_type(leaf, iref);
10063 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10065 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10066 (offset == root->objectid || offset == owner)) {
10068 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10069 /* Check if the backref points to valid referencer */
10070 found_ref = !check_tree_block_ref(root, NULL, offset,
10076 ptr += btrfs_extent_inline_ref_size(type);
10080 * Inlined extent item doesn't have what we need, check
10081 * TREE_BLOCK_REF_KEY
10084 btrfs_release_path(&path);
10085 key.objectid = bytenr;
10086 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10087 key.offset = root->objectid;
10089 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10094 err |= BACKREF_MISSING;
10096 btrfs_release_path(&path);
10097 if (eb && (err & BACKREF_MISSING))
10098 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10099 bytenr, nodesize, owner, level);
10104 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10106 * Return >0 any error found and output error message
10107 * Return 0 for no error found
10109 static int check_extent_data_item(struct btrfs_root *root,
10110 struct extent_buffer *eb, int slot)
10112 struct btrfs_file_extent_item *fi;
10113 struct btrfs_path path;
10114 struct btrfs_root *extent_root = root->fs_info->extent_root;
10115 struct btrfs_key fi_key;
10116 struct btrfs_key dbref_key;
10117 struct extent_buffer *leaf;
10118 struct btrfs_extent_item *ei;
10119 struct btrfs_extent_inline_ref *iref;
10120 struct btrfs_extent_data_ref *dref;
10122 u64 file_extent_gen;
10124 u64 disk_num_bytes;
10125 u64 extent_num_bytes;
10133 int found_dbackref = 0;
10137 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10138 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10139 file_extent_gen = btrfs_file_extent_generation(eb, fi);
10141 /* Nothing to check for hole and inline data extents */
10142 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10143 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10146 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10147 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10148 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10150 /* Check unaligned disk_num_bytes and num_bytes */
10151 if (!IS_ALIGNED(disk_num_bytes, root->sectorsize)) {
10153 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10154 fi_key.objectid, fi_key.offset, disk_num_bytes,
10156 err |= BYTES_UNALIGNED;
10158 data_bytes_allocated += disk_num_bytes;
10160 if (!IS_ALIGNED(extent_num_bytes, root->sectorsize)) {
10162 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10163 fi_key.objectid, fi_key.offset, extent_num_bytes,
10165 err |= BYTES_UNALIGNED;
10167 data_bytes_referenced += extent_num_bytes;
10169 owner = btrfs_header_owner(eb);
10171 /* Check the extent item of the file extent in extent tree */
10172 btrfs_init_path(&path);
10173 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10174 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10175 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10177 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10179 err |= BACKREF_MISSING;
10183 leaf = path.nodes[0];
10184 slot = path.slots[0];
10185 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10187 extent_flags = btrfs_extent_flags(leaf, ei);
10188 extent_gen = btrfs_extent_generation(leaf, ei);
10190 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10192 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10193 disk_bytenr, disk_num_bytes,
10194 BTRFS_EXTENT_FLAG_DATA);
10195 err |= BACKREF_MISMATCH;
10198 if (file_extent_gen < extent_gen) {
10200 "extent[%llu %llu] backref generation mismatch, wanted: <=%llu, have: %llu",
10201 disk_bytenr, disk_num_bytes, file_extent_gen,
10203 err |= BACKREF_MISMATCH;
10206 /* Check data backref inside that extent item */
10207 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10208 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10209 ptr = (unsigned long)iref;
10210 end = (unsigned long)ei + item_size;
10211 while (ptr < end) {
10212 iref = (struct btrfs_extent_inline_ref *)ptr;
10213 type = btrfs_extent_inline_ref_type(leaf, iref);
10214 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10216 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10217 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10218 if (ref_root == owner || ref_root == root->objectid)
10219 found_dbackref = 1;
10220 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10221 found_dbackref = !check_tree_block_ref(root, NULL,
10222 btrfs_extent_inline_ref_offset(leaf, iref),
10226 if (found_dbackref)
10228 ptr += btrfs_extent_inline_ref_size(type);
10231 /* Didn't found inlined data backref, try EXTENT_DATA_REF_KEY */
10232 if (!found_dbackref) {
10233 btrfs_release_path(&path);
10235 btrfs_init_path(&path);
10236 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10237 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10238 dbref_key.offset = hash_extent_data_ref(root->objectid,
10239 fi_key.objectid, fi_key.offset);
10241 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10242 &dbref_key, &path, 0, 0);
10244 found_dbackref = 1;
10247 if (!found_dbackref)
10248 err |= BACKREF_MISSING;
10250 btrfs_release_path(&path);
10251 if (err & BACKREF_MISSING) {
10252 error("data extent[%llu %llu] backref lost",
10253 disk_bytenr, disk_num_bytes);
10259 * Get real tree block level for the case like shared block
10260 * Return >= 0 as tree level
10261 * Return <0 for error
10263 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10265 struct extent_buffer *eb;
10266 struct btrfs_path path;
10267 struct btrfs_key key;
10268 struct btrfs_extent_item *ei;
10271 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10276 /* Search extent tree for extent generation and level */
10277 key.objectid = bytenr;
10278 key.type = BTRFS_METADATA_ITEM_KEY;
10279 key.offset = (u64)-1;
10281 btrfs_init_path(&path);
10282 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10285 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10293 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10294 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10295 struct btrfs_extent_item);
10296 flags = btrfs_extent_flags(path.nodes[0], ei);
10297 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10302 /* Get transid for later read_tree_block() check */
10303 transid = btrfs_extent_generation(path.nodes[0], ei);
10305 /* Get backref level as one source */
10306 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10307 backref_level = key.offset;
10309 struct btrfs_tree_block_info *info;
10311 info = (struct btrfs_tree_block_info *)(ei + 1);
10312 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10314 btrfs_release_path(&path);
10316 /* Get level from tree block as an alternative source */
10317 eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
10318 if (!extent_buffer_uptodate(eb)) {
10319 free_extent_buffer(eb);
10322 header_level = btrfs_header_level(eb);
10323 free_extent_buffer(eb);
10325 if (header_level != backref_level)
10327 return header_level;
10330 btrfs_release_path(&path);
10335 * Check if a tree block backref is valid (points to a valid tree block)
10336 * if level == -1, level will be resolved
10337 * Return >0 for any error found and print error message
10339 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10340 u64 bytenr, int level)
10342 struct btrfs_root *root;
10343 struct btrfs_key key;
10344 struct btrfs_path path;
10345 struct extent_buffer *eb;
10346 struct extent_buffer *node;
10347 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10351 /* Query level for level == -1 special case */
10353 level = query_tree_block_level(fs_info, bytenr);
10355 err |= REFERENCER_MISSING;
10359 key.objectid = root_id;
10360 key.type = BTRFS_ROOT_ITEM_KEY;
10361 key.offset = (u64)-1;
10363 root = btrfs_read_fs_root(fs_info, &key);
10364 if (IS_ERR(root)) {
10365 err |= REFERENCER_MISSING;
10369 /* Read out the tree block to get item/node key */
10370 eb = read_tree_block(root, bytenr, root->nodesize, 0);
10371 if (!extent_buffer_uptodate(eb)) {
10372 err |= REFERENCER_MISSING;
10373 free_extent_buffer(eb);
10377 /* Empty tree, no need to check key */
10378 if (!btrfs_header_nritems(eb) && !level) {
10379 free_extent_buffer(eb);
10384 btrfs_node_key_to_cpu(eb, &key, 0);
10386 btrfs_item_key_to_cpu(eb, &key, 0);
10388 free_extent_buffer(eb);
10390 btrfs_init_path(&path);
10391 path.lowest_level = level;
10392 /* Search with the first key, to ensure we can reach it */
10393 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10395 err |= REFERENCER_MISSING;
10399 node = path.nodes[level];
10400 if (btrfs_header_bytenr(node) != bytenr) {
10402 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10403 bytenr, nodesize, bytenr,
10404 btrfs_header_bytenr(node));
10405 err |= REFERENCER_MISMATCH;
10407 if (btrfs_header_level(node) != level) {
10409 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10410 bytenr, nodesize, level,
10411 btrfs_header_level(node));
10412 err |= REFERENCER_MISMATCH;
10416 btrfs_release_path(&path);
10418 if (err & REFERENCER_MISSING) {
10420 error("extent [%llu %d] lost referencer (owner: %llu)",
10421 bytenr, nodesize, root_id);
10424 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10425 bytenr, nodesize, root_id, level);
10432 * Check referencer for shared block backref
10433 * If level == -1, this function will resolve the level.
10435 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10436 u64 parent, u64 bytenr, int level)
10438 struct extent_buffer *eb;
10439 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10441 int found_parent = 0;
10444 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10445 if (!extent_buffer_uptodate(eb))
10449 level = query_tree_block_level(fs_info, bytenr);
10453 if (level + 1 != btrfs_header_level(eb))
10456 nr = btrfs_header_nritems(eb);
10457 for (i = 0; i < nr; i++) {
10458 if (bytenr == btrfs_node_blockptr(eb, i)) {
10464 free_extent_buffer(eb);
10465 if (!found_parent) {
10467 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10468 bytenr, nodesize, parent, level);
10469 return REFERENCER_MISSING;
10475 * Check referencer for normal (inlined) data ref
10476 * If len == 0, it will be resolved by searching in extent tree
10478 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10479 u64 root_id, u64 objectid, u64 offset,
10480 u64 bytenr, u64 len, u32 count)
10482 struct btrfs_root *root;
10483 struct btrfs_root *extent_root = fs_info->extent_root;
10484 struct btrfs_key key;
10485 struct btrfs_path path;
10486 struct extent_buffer *leaf;
10487 struct btrfs_file_extent_item *fi;
10488 u32 found_count = 0;
10493 key.objectid = bytenr;
10494 key.type = BTRFS_EXTENT_ITEM_KEY;
10495 key.offset = (u64)-1;
10497 btrfs_init_path(&path);
10498 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10501 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10504 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10505 if (key.objectid != bytenr ||
10506 key.type != BTRFS_EXTENT_ITEM_KEY)
10509 btrfs_release_path(&path);
10511 key.objectid = root_id;
10512 key.type = BTRFS_ROOT_ITEM_KEY;
10513 key.offset = (u64)-1;
10514 btrfs_init_path(&path);
10516 root = btrfs_read_fs_root(fs_info, &key);
10520 key.objectid = objectid;
10521 key.type = BTRFS_EXTENT_DATA_KEY;
10523 * It can be nasty as data backref offset is
10524 * file offset - file extent offset, which is smaller or
10525 * equal to original backref offset. The only special case is
10526 * overflow. So we need to special check and do further search.
10528 key.offset = offset & (1ULL << 63) ? 0 : offset;
10530 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10535 * Search afterwards to get correct one
10536 * NOTE: As we must do a comprehensive check on the data backref to
10537 * make sure the dref count also matches, we must iterate all file
10538 * extents for that inode.
10541 leaf = path.nodes[0];
10542 slot = path.slots[0];
10544 btrfs_item_key_to_cpu(leaf, &key, slot);
10545 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10547 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10549 * Except normal disk bytenr and disk num bytes, we still
10550 * need to do extra check on dbackref offset as
10551 * dbackref offset = file_offset - file_extent_offset
10553 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10554 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10555 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10559 ret = btrfs_next_item(root, &path);
10564 btrfs_release_path(&path);
10565 if (found_count != count) {
10567 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10568 bytenr, len, root_id, objectid, offset, count, found_count);
10569 return REFERENCER_MISSING;
10575 * Check if the referencer of a shared data backref exists
10577 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10578 u64 parent, u64 bytenr)
10580 struct extent_buffer *eb;
10581 struct btrfs_key key;
10582 struct btrfs_file_extent_item *fi;
10583 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10585 int found_parent = 0;
10588 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10589 if (!extent_buffer_uptodate(eb))
10592 nr = btrfs_header_nritems(eb);
10593 for (i = 0; i < nr; i++) {
10594 btrfs_item_key_to_cpu(eb, &key, i);
10595 if (key.type != BTRFS_EXTENT_DATA_KEY)
10598 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10599 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10602 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10609 free_extent_buffer(eb);
10610 if (!found_parent) {
10611 error("shared extent %llu referencer lost (parent: %llu)",
10613 return REFERENCER_MISSING;
10619 * This function will check a given extent item, including its backref and
10620 * itself (like crossing stripe boundary and type)
10622 * Since we don't use extent_record anymore, introduce new error bit
10624 static int check_extent_item(struct btrfs_fs_info *fs_info,
10625 struct extent_buffer *eb, int slot)
10627 struct btrfs_extent_item *ei;
10628 struct btrfs_extent_inline_ref *iref;
10629 struct btrfs_extent_data_ref *dref;
10633 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10634 u32 item_size = btrfs_item_size_nr(eb, slot);
10639 struct btrfs_key key;
10643 btrfs_item_key_to_cpu(eb, &key, slot);
10644 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10645 bytes_used += key.offset;
10647 bytes_used += nodesize;
10649 if (item_size < sizeof(*ei)) {
10651 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10652 * old thing when on disk format is still un-determined.
10653 * No need to care about it anymore
10655 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10659 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10660 flags = btrfs_extent_flags(eb, ei);
10662 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10664 if (metadata && check_crossing_stripes(global_info, key.objectid,
10666 error("bad metadata [%llu, %llu) crossing stripe boundary",
10667 key.objectid, key.objectid + nodesize);
10668 err |= CROSSING_STRIPE_BOUNDARY;
10671 ptr = (unsigned long)(ei + 1);
10673 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10674 /* Old EXTENT_ITEM metadata */
10675 struct btrfs_tree_block_info *info;
10677 info = (struct btrfs_tree_block_info *)ptr;
10678 level = btrfs_tree_block_level(eb, info);
10679 ptr += sizeof(struct btrfs_tree_block_info);
10681 /* New METADATA_ITEM */
10682 level = key.offset;
10684 end = (unsigned long)ei + item_size;
10687 err |= ITEM_SIZE_MISMATCH;
10691 /* Now check every backref in this extent item */
10693 iref = (struct btrfs_extent_inline_ref *)ptr;
10694 type = btrfs_extent_inline_ref_type(eb, iref);
10695 offset = btrfs_extent_inline_ref_offset(eb, iref);
10697 case BTRFS_TREE_BLOCK_REF_KEY:
10698 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10702 case BTRFS_SHARED_BLOCK_REF_KEY:
10703 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10707 case BTRFS_EXTENT_DATA_REF_KEY:
10708 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10709 ret = check_extent_data_backref(fs_info,
10710 btrfs_extent_data_ref_root(eb, dref),
10711 btrfs_extent_data_ref_objectid(eb, dref),
10712 btrfs_extent_data_ref_offset(eb, dref),
10713 key.objectid, key.offset,
10714 btrfs_extent_data_ref_count(eb, dref));
10717 case BTRFS_SHARED_DATA_REF_KEY:
10718 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10722 error("extent[%llu %d %llu] has unknown ref type: %d",
10723 key.objectid, key.type, key.offset, type);
10724 err |= UNKNOWN_TYPE;
10728 ptr += btrfs_extent_inline_ref_size(type);
10737 * Check if a dev extent item is referred correctly by its chunk
10739 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10740 struct extent_buffer *eb, int slot)
10742 struct btrfs_root *chunk_root = fs_info->chunk_root;
10743 struct btrfs_dev_extent *ptr;
10744 struct btrfs_path path;
10745 struct btrfs_key chunk_key;
10746 struct btrfs_key devext_key;
10747 struct btrfs_chunk *chunk;
10748 struct extent_buffer *l;
10752 int found_chunk = 0;
10755 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10756 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10757 length = btrfs_dev_extent_length(eb, ptr);
10759 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10760 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10761 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10763 btrfs_init_path(&path);
10764 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10769 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10770 if (btrfs_chunk_length(l, chunk) != length)
10773 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10774 for (i = 0; i < num_stripes; i++) {
10775 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10776 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10778 if (devid == devext_key.objectid &&
10779 offset == devext_key.offset) {
10785 btrfs_release_path(&path);
10786 if (!found_chunk) {
10788 "device extent[%llu, %llu, %llu] did not find the related chunk",
10789 devext_key.objectid, devext_key.offset, length);
10790 return REFERENCER_MISSING;
10796 * Check if the used space is correct with the dev item
10798 static int check_dev_item(struct btrfs_fs_info *fs_info,
10799 struct extent_buffer *eb, int slot)
10801 struct btrfs_root *dev_root = fs_info->dev_root;
10802 struct btrfs_dev_item *dev_item;
10803 struct btrfs_path path;
10804 struct btrfs_key key;
10805 struct btrfs_dev_extent *ptr;
10811 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10812 dev_id = btrfs_device_id(eb, dev_item);
10813 used = btrfs_device_bytes_used(eb, dev_item);
10815 key.objectid = dev_id;
10816 key.type = BTRFS_DEV_EXTENT_KEY;
10819 btrfs_init_path(&path);
10820 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
10822 btrfs_item_key_to_cpu(eb, &key, slot);
10823 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
10824 key.objectid, key.type, key.offset);
10825 btrfs_release_path(&path);
10826 return REFERENCER_MISSING;
10829 /* Iterate dev_extents to calculate the used space of a device */
10831 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10833 if (key.objectid > dev_id)
10835 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
10838 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
10839 struct btrfs_dev_extent);
10840 total += btrfs_dev_extent_length(path.nodes[0], ptr);
10842 ret = btrfs_next_item(dev_root, &path);
10846 btrfs_release_path(&path);
10848 if (used != total) {
10849 btrfs_item_key_to_cpu(eb, &key, slot);
10851 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
10852 total, used, BTRFS_ROOT_TREE_OBJECTID,
10853 BTRFS_DEV_EXTENT_KEY, dev_id);
10854 return ACCOUNTING_MISMATCH;
10860 * Check a block group item with its referener (chunk) and its used space
10861 * with extent/metadata item
10863 static int check_block_group_item(struct btrfs_fs_info *fs_info,
10864 struct extent_buffer *eb, int slot)
10866 struct btrfs_root *extent_root = fs_info->extent_root;
10867 struct btrfs_root *chunk_root = fs_info->chunk_root;
10868 struct btrfs_block_group_item *bi;
10869 struct btrfs_block_group_item bg_item;
10870 struct btrfs_path path;
10871 struct btrfs_key bg_key;
10872 struct btrfs_key chunk_key;
10873 struct btrfs_key extent_key;
10874 struct btrfs_chunk *chunk;
10875 struct extent_buffer *leaf;
10876 struct btrfs_extent_item *ei;
10877 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10885 btrfs_item_key_to_cpu(eb, &bg_key, slot);
10886 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
10887 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
10888 used = btrfs_block_group_used(&bg_item);
10889 bg_flags = btrfs_block_group_flags(&bg_item);
10891 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
10892 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10893 chunk_key.offset = bg_key.objectid;
10895 btrfs_init_path(&path);
10896 /* Search for the referencer chunk */
10897 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10900 "block group[%llu %llu] did not find the related chunk item",
10901 bg_key.objectid, bg_key.offset);
10902 err |= REFERENCER_MISSING;
10904 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
10905 struct btrfs_chunk);
10906 if (btrfs_chunk_length(path.nodes[0], chunk) !=
10909 "block group[%llu %llu] related chunk item length does not match",
10910 bg_key.objectid, bg_key.offset);
10911 err |= REFERENCER_MISMATCH;
10914 btrfs_release_path(&path);
10916 /* Search from the block group bytenr */
10917 extent_key.objectid = bg_key.objectid;
10918 extent_key.type = 0;
10919 extent_key.offset = 0;
10921 btrfs_init_path(&path);
10922 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
10926 /* Iterate extent tree to account used space */
10928 leaf = path.nodes[0];
10929 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
10930 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
10933 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
10934 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
10936 if (extent_key.objectid < bg_key.objectid)
10939 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
10942 total += extent_key.offset;
10944 ei = btrfs_item_ptr(leaf, path.slots[0],
10945 struct btrfs_extent_item);
10946 flags = btrfs_extent_flags(leaf, ei);
10947 if (flags & BTRFS_EXTENT_FLAG_DATA) {
10948 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
10950 "bad extent[%llu, %llu) type mismatch with chunk",
10951 extent_key.objectid,
10952 extent_key.objectid + extent_key.offset);
10953 err |= CHUNK_TYPE_MISMATCH;
10955 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
10956 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
10957 BTRFS_BLOCK_GROUP_METADATA))) {
10959 "bad extent[%llu, %llu) type mismatch with chunk",
10960 extent_key.objectid,
10961 extent_key.objectid + nodesize);
10962 err |= CHUNK_TYPE_MISMATCH;
10966 ret = btrfs_next_item(extent_root, &path);
10972 btrfs_release_path(&path);
10974 if (total != used) {
10976 "block group[%llu %llu] used %llu but extent items used %llu",
10977 bg_key.objectid, bg_key.offset, used, total);
10978 err |= ACCOUNTING_MISMATCH;
10984 * Check a chunk item.
10985 * Including checking all referred dev_extents and block group
10987 static int check_chunk_item(struct btrfs_fs_info *fs_info,
10988 struct extent_buffer *eb, int slot)
10990 struct btrfs_root *extent_root = fs_info->extent_root;
10991 struct btrfs_root *dev_root = fs_info->dev_root;
10992 struct btrfs_path path;
10993 struct btrfs_key chunk_key;
10994 struct btrfs_key bg_key;
10995 struct btrfs_key devext_key;
10996 struct btrfs_chunk *chunk;
10997 struct extent_buffer *leaf;
10998 struct btrfs_block_group_item *bi;
10999 struct btrfs_block_group_item bg_item;
11000 struct btrfs_dev_extent *ptr;
11001 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
11013 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11014 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11015 length = btrfs_chunk_length(eb, chunk);
11016 chunk_end = chunk_key.offset + length;
11017 if (!IS_ALIGNED(length, sectorsize)) {
11018 error("chunk[%llu %llu) not aligned to %u",
11019 chunk_key.offset, chunk_end, sectorsize);
11020 err |= BYTES_UNALIGNED;
11024 type = btrfs_chunk_type(eb, chunk);
11025 profile = type & BTRFS_BLOCK_GROUP_PROFILE_MASK;
11026 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
11027 error("chunk[%llu %llu) has no chunk type",
11028 chunk_key.offset, chunk_end);
11029 err |= UNKNOWN_TYPE;
11031 if (profile && (profile & (profile - 1))) {
11032 error("chunk[%llu %llu) multiple profiles detected: %llx",
11033 chunk_key.offset, chunk_end, profile);
11034 err |= UNKNOWN_TYPE;
11037 bg_key.objectid = chunk_key.offset;
11038 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11039 bg_key.offset = length;
11041 btrfs_init_path(&path);
11042 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11045 "chunk[%llu %llu) did not find the related block group item",
11046 chunk_key.offset, chunk_end);
11047 err |= REFERENCER_MISSING;
11049 leaf = path.nodes[0];
11050 bi = btrfs_item_ptr(leaf, path.slots[0],
11051 struct btrfs_block_group_item);
11052 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11054 if (btrfs_block_group_flags(&bg_item) != type) {
11056 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11057 chunk_key.offset, chunk_end, type,
11058 btrfs_block_group_flags(&bg_item));
11059 err |= REFERENCER_MISSING;
11063 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11064 for (i = 0; i < num_stripes; i++) {
11065 btrfs_release_path(&path);
11066 btrfs_init_path(&path);
11067 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11068 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11069 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11071 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11074 goto not_match_dev;
11076 leaf = path.nodes[0];
11077 ptr = btrfs_item_ptr(leaf, path.slots[0],
11078 struct btrfs_dev_extent);
11079 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11080 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11081 if (objectid != chunk_key.objectid ||
11082 offset != chunk_key.offset ||
11083 btrfs_dev_extent_length(leaf, ptr) != length)
11084 goto not_match_dev;
11087 err |= BACKREF_MISSING;
11089 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11090 chunk_key.objectid, chunk_end, i);
11093 btrfs_release_path(&path);
11099 * Main entry function to check known items and update related accounting info
11101 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11103 struct btrfs_fs_info *fs_info = root->fs_info;
11104 struct btrfs_key key;
11107 struct btrfs_extent_data_ref *dref;
11112 btrfs_item_key_to_cpu(eb, &key, slot);
11116 case BTRFS_EXTENT_DATA_KEY:
11117 ret = check_extent_data_item(root, eb, slot);
11120 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11121 ret = check_block_group_item(fs_info, eb, slot);
11124 case BTRFS_DEV_ITEM_KEY:
11125 ret = check_dev_item(fs_info, eb, slot);
11128 case BTRFS_CHUNK_ITEM_KEY:
11129 ret = check_chunk_item(fs_info, eb, slot);
11132 case BTRFS_DEV_EXTENT_KEY:
11133 ret = check_dev_extent_item(fs_info, eb, slot);
11136 case BTRFS_EXTENT_ITEM_KEY:
11137 case BTRFS_METADATA_ITEM_KEY:
11138 ret = check_extent_item(fs_info, eb, slot);
11141 case BTRFS_EXTENT_CSUM_KEY:
11142 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11144 case BTRFS_TREE_BLOCK_REF_KEY:
11145 ret = check_tree_block_backref(fs_info, key.offset,
11149 case BTRFS_EXTENT_DATA_REF_KEY:
11150 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11151 ret = check_extent_data_backref(fs_info,
11152 btrfs_extent_data_ref_root(eb, dref),
11153 btrfs_extent_data_ref_objectid(eb, dref),
11154 btrfs_extent_data_ref_offset(eb, dref),
11156 btrfs_extent_data_ref_count(eb, dref));
11159 case BTRFS_SHARED_BLOCK_REF_KEY:
11160 ret = check_shared_block_backref(fs_info, key.offset,
11164 case BTRFS_SHARED_DATA_REF_KEY:
11165 ret = check_shared_data_backref(fs_info, key.offset,
11173 if (++slot < btrfs_header_nritems(eb))
11180 * Helper function for later fs/subvol tree check. To determine if a tree
11181 * block should be checked.
11182 * This function will ensure only the direct referencer with lowest rootid to
11183 * check a fs/subvolume tree block.
11185 * Backref check at extent tree would detect errors like missing subvolume
11186 * tree, so we can do aggressive check to reduce duplicated checks.
11188 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11190 struct btrfs_root *extent_root = root->fs_info->extent_root;
11191 struct btrfs_key key;
11192 struct btrfs_path path;
11193 struct extent_buffer *leaf;
11195 struct btrfs_extent_item *ei;
11201 struct btrfs_extent_inline_ref *iref;
11204 btrfs_init_path(&path);
11205 key.objectid = btrfs_header_bytenr(eb);
11206 key.type = BTRFS_METADATA_ITEM_KEY;
11207 key.offset = (u64)-1;
11210 * Any failure in backref resolving means we can't determine
11211 * whom the tree block belongs to.
11212 * So in that case, we need to check that tree block
11214 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11218 ret = btrfs_previous_extent_item(extent_root, &path,
11219 btrfs_header_bytenr(eb));
11223 leaf = path.nodes[0];
11224 slot = path.slots[0];
11225 btrfs_item_key_to_cpu(leaf, &key, slot);
11226 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11228 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11229 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11231 struct btrfs_tree_block_info *info;
11233 info = (struct btrfs_tree_block_info *)(ei + 1);
11234 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11237 item_size = btrfs_item_size_nr(leaf, slot);
11238 ptr = (unsigned long)iref;
11239 end = (unsigned long)ei + item_size;
11240 while (ptr < end) {
11241 iref = (struct btrfs_extent_inline_ref *)ptr;
11242 type = btrfs_extent_inline_ref_type(leaf, iref);
11243 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11246 * We only check the tree block if current root is
11247 * the lowest referencer of it.
11249 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11250 offset < root->objectid) {
11251 btrfs_release_path(&path);
11255 ptr += btrfs_extent_inline_ref_size(type);
11258 * Normally we should also check keyed tree block ref, but that may be
11259 * very time consuming. Inlined ref should already make us skip a lot
11260 * of refs now. So skip search keyed tree block ref.
11264 btrfs_release_path(&path);
11269 * Traversal function for tree block. We will do:
11270 * 1) Skip shared fs/subvolume tree blocks
11271 * 2) Update related bytes accounting
11272 * 3) Pre-order traversal
11274 static int traverse_tree_block(struct btrfs_root *root,
11275 struct extent_buffer *node)
11277 struct extent_buffer *eb;
11278 struct btrfs_key key;
11279 struct btrfs_key drop_key;
11287 * Skip shared fs/subvolume tree block, in that case they will
11288 * be checked by referencer with lowest rootid
11290 if (is_fstree(root->objectid) && !should_check(root, node))
11293 /* Update bytes accounting */
11294 total_btree_bytes += node->len;
11295 if (fs_root_objectid(btrfs_header_owner(node)))
11296 total_fs_tree_bytes += node->len;
11297 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11298 total_extent_tree_bytes += node->len;
11299 if (!found_old_backref &&
11300 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11301 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11302 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11303 found_old_backref = 1;
11305 /* pre-order tranversal, check itself first */
11306 level = btrfs_header_level(node);
11307 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11308 btrfs_header_level(node),
11309 btrfs_header_owner(node));
11313 "check %s failed root %llu bytenr %llu level %d, force continue check",
11314 level ? "node":"leaf", root->objectid,
11315 btrfs_header_bytenr(node), btrfs_header_level(node));
11318 btree_space_waste += btrfs_leaf_free_space(root, node);
11319 ret = check_leaf_items(root, node);
11324 nr = btrfs_header_nritems(node);
11325 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11326 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11327 sizeof(struct btrfs_key_ptr);
11329 /* Then check all its children */
11330 for (i = 0; i < nr; i++) {
11331 u64 blocknr = btrfs_node_blockptr(node, i);
11333 btrfs_node_key_to_cpu(node, &key, i);
11334 if (level == root->root_item.drop_level &&
11335 is_dropped_key(&key, &drop_key))
11339 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11340 * to call the function itself.
11342 eb = read_tree_block(root, blocknr, root->nodesize, 0);
11343 if (extent_buffer_uptodate(eb)) {
11344 ret = traverse_tree_block(root, eb);
11347 free_extent_buffer(eb);
11354 * Low memory usage version check_chunks_and_extents.
11356 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11358 struct btrfs_path path;
11359 struct btrfs_key key;
11360 struct btrfs_root *root1;
11361 struct btrfs_root *cur_root;
11365 root1 = root->fs_info->chunk_root;
11366 ret = traverse_tree_block(root1, root1->node);
11369 root1 = root->fs_info->tree_root;
11370 ret = traverse_tree_block(root1, root1->node);
11373 btrfs_init_path(&path);
11374 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11376 key.type = BTRFS_ROOT_ITEM_KEY;
11378 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11380 error("cannot find extent treet in tree_root");
11385 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11386 if (key.type != BTRFS_ROOT_ITEM_KEY)
11388 key.offset = (u64)-1;
11390 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11391 if (IS_ERR(cur_root) || !cur_root) {
11392 error("failed to read tree: %lld", key.objectid);
11396 ret = traverse_tree_block(cur_root, cur_root->node);
11400 ret = btrfs_next_item(root1, &path);
11406 btrfs_release_path(&path);
11410 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11411 struct btrfs_root *root, int overwrite)
11413 struct extent_buffer *c;
11414 struct extent_buffer *old = root->node;
11417 struct btrfs_disk_key disk_key = {0,0,0};
11423 extent_buffer_get(c);
11426 c = btrfs_alloc_free_block(trans, root,
11428 root->root_key.objectid,
11429 &disk_key, level, 0, 0);
11432 extent_buffer_get(c);
11436 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11437 btrfs_set_header_level(c, level);
11438 btrfs_set_header_bytenr(c, c->start);
11439 btrfs_set_header_generation(c, trans->transid);
11440 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11441 btrfs_set_header_owner(c, root->root_key.objectid);
11443 write_extent_buffer(c, root->fs_info->fsid,
11444 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11446 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11447 btrfs_header_chunk_tree_uuid(c),
11450 btrfs_mark_buffer_dirty(c);
11452 * this case can happen in the following case:
11454 * 1.overwrite previous root.
11456 * 2.reinit reloc data root, this is because we skip pin
11457 * down reloc data tree before which means we can allocate
11458 * same block bytenr here.
11460 if (old->start == c->start) {
11461 btrfs_set_root_generation(&root->root_item,
11463 root->root_item.level = btrfs_header_level(root->node);
11464 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11465 &root->root_key, &root->root_item);
11467 free_extent_buffer(c);
11471 free_extent_buffer(old);
11473 add_root_to_dirty_list(root);
11477 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11478 struct extent_buffer *eb, int tree_root)
11480 struct extent_buffer *tmp;
11481 struct btrfs_root_item *ri;
11482 struct btrfs_key key;
11485 int level = btrfs_header_level(eb);
11491 * If we have pinned this block before, don't pin it again.
11492 * This can not only avoid forever loop with broken filesystem
11493 * but also give us some speedups.
11495 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11496 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11499 btrfs_pin_extent(fs_info, eb->start, eb->len);
11501 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11502 nritems = btrfs_header_nritems(eb);
11503 for (i = 0; i < nritems; i++) {
11505 btrfs_item_key_to_cpu(eb, &key, i);
11506 if (key.type != BTRFS_ROOT_ITEM_KEY)
11508 /* Skip the extent root and reloc roots */
11509 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11510 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11511 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11513 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11514 bytenr = btrfs_disk_root_bytenr(eb, ri);
11517 * If at any point we start needing the real root we
11518 * will have to build a stump root for the root we are
11519 * in, but for now this doesn't actually use the root so
11520 * just pass in extent_root.
11522 tmp = read_tree_block(fs_info->extent_root, bytenr,
11524 if (!extent_buffer_uptodate(tmp)) {
11525 fprintf(stderr, "Error reading root block\n");
11528 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11529 free_extent_buffer(tmp);
11533 bytenr = btrfs_node_blockptr(eb, i);
11535 /* If we aren't the tree root don't read the block */
11536 if (level == 1 && !tree_root) {
11537 btrfs_pin_extent(fs_info, bytenr, nodesize);
11541 tmp = read_tree_block(fs_info->extent_root, bytenr,
11543 if (!extent_buffer_uptodate(tmp)) {
11544 fprintf(stderr, "Error reading tree block\n");
11547 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11548 free_extent_buffer(tmp);
11557 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11561 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11565 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11568 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11570 struct btrfs_block_group_cache *cache;
11571 struct btrfs_path path;
11572 struct extent_buffer *leaf;
11573 struct btrfs_chunk *chunk;
11574 struct btrfs_key key;
11578 btrfs_init_path(&path);
11580 key.type = BTRFS_CHUNK_ITEM_KEY;
11582 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11584 btrfs_release_path(&path);
11589 * We do this in case the block groups were screwed up and had alloc
11590 * bits that aren't actually set on the chunks. This happens with
11591 * restored images every time and could happen in real life I guess.
11593 fs_info->avail_data_alloc_bits = 0;
11594 fs_info->avail_metadata_alloc_bits = 0;
11595 fs_info->avail_system_alloc_bits = 0;
11597 /* First we need to create the in-memory block groups */
11599 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11600 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11602 btrfs_release_path(&path);
11610 leaf = path.nodes[0];
11611 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11612 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11617 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11618 btrfs_add_block_group(fs_info, 0,
11619 btrfs_chunk_type(leaf, chunk),
11620 key.objectid, key.offset,
11621 btrfs_chunk_length(leaf, chunk));
11622 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11623 key.offset + btrfs_chunk_length(leaf, chunk),
11629 cache = btrfs_lookup_first_block_group(fs_info, start);
11633 start = cache->key.objectid + cache->key.offset;
11636 btrfs_release_path(&path);
11640 static int reset_balance(struct btrfs_trans_handle *trans,
11641 struct btrfs_fs_info *fs_info)
11643 struct btrfs_root *root = fs_info->tree_root;
11644 struct btrfs_path path;
11645 struct extent_buffer *leaf;
11646 struct btrfs_key key;
11647 int del_slot, del_nr = 0;
11651 btrfs_init_path(&path);
11652 key.objectid = BTRFS_BALANCE_OBJECTID;
11653 key.type = BTRFS_BALANCE_ITEM_KEY;
11655 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11660 goto reinit_data_reloc;
11665 ret = btrfs_del_item(trans, root, &path);
11668 btrfs_release_path(&path);
11670 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11671 key.type = BTRFS_ROOT_ITEM_KEY;
11673 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11677 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11682 ret = btrfs_del_items(trans, root, &path,
11689 btrfs_release_path(&path);
11692 ret = btrfs_search_slot(trans, root, &key, &path,
11699 leaf = path.nodes[0];
11700 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11701 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11703 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11708 del_slot = path.slots[0];
11717 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11721 btrfs_release_path(&path);
11724 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11725 key.type = BTRFS_ROOT_ITEM_KEY;
11726 key.offset = (u64)-1;
11727 root = btrfs_read_fs_root(fs_info, &key);
11728 if (IS_ERR(root)) {
11729 fprintf(stderr, "Error reading data reloc tree\n");
11730 ret = PTR_ERR(root);
11733 record_root_in_trans(trans, root);
11734 ret = btrfs_fsck_reinit_root(trans, root, 0);
11737 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11739 btrfs_release_path(&path);
11743 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11744 struct btrfs_fs_info *fs_info)
11750 * The only reason we don't do this is because right now we're just
11751 * walking the trees we find and pinning down their bytes, we don't look
11752 * at any of the leaves. In order to do mixed groups we'd have to check
11753 * the leaves of any fs roots and pin down the bytes for any file
11754 * extents we find. Not hard but why do it if we don't have to?
11756 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11757 fprintf(stderr, "We don't support re-initing the extent tree "
11758 "for mixed block groups yet, please notify a btrfs "
11759 "developer you want to do this so they can add this "
11760 "functionality.\n");
11765 * first we need to walk all of the trees except the extent tree and pin
11766 * down the bytes that are in use so we don't overwrite any existing
11769 ret = pin_metadata_blocks(fs_info);
11771 fprintf(stderr, "error pinning down used bytes\n");
11776 * Need to drop all the block groups since we're going to recreate all
11779 btrfs_free_block_groups(fs_info);
11780 ret = reset_block_groups(fs_info);
11782 fprintf(stderr, "error resetting the block groups\n");
11786 /* Ok we can allocate now, reinit the extent root */
11787 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11789 fprintf(stderr, "extent root initialization failed\n");
11791 * When the transaction code is updated we should end the
11792 * transaction, but for now progs only knows about commit so
11793 * just return an error.
11799 * Now we have all the in-memory block groups setup so we can make
11800 * allocations properly, and the metadata we care about is safe since we
11801 * pinned all of it above.
11804 struct btrfs_block_group_cache *cache;
11806 cache = btrfs_lookup_first_block_group(fs_info, start);
11809 start = cache->key.objectid + cache->key.offset;
11810 ret = btrfs_insert_item(trans, fs_info->extent_root,
11811 &cache->key, &cache->item,
11812 sizeof(cache->item));
11814 fprintf(stderr, "Error adding block group\n");
11817 btrfs_extent_post_op(trans, fs_info->extent_root);
11820 ret = reset_balance(trans, fs_info);
11822 fprintf(stderr, "error resetting the pending balance\n");
11827 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
11829 struct btrfs_path path;
11830 struct btrfs_trans_handle *trans;
11831 struct btrfs_key key;
11834 printf("Recowing metadata block %llu\n", eb->start);
11835 key.objectid = btrfs_header_owner(eb);
11836 key.type = BTRFS_ROOT_ITEM_KEY;
11837 key.offset = (u64)-1;
11839 root = btrfs_read_fs_root(root->fs_info, &key);
11840 if (IS_ERR(root)) {
11841 fprintf(stderr, "Couldn't find owner root %llu\n",
11843 return PTR_ERR(root);
11846 trans = btrfs_start_transaction(root, 1);
11848 return PTR_ERR(trans);
11850 btrfs_init_path(&path);
11851 path.lowest_level = btrfs_header_level(eb);
11852 if (path.lowest_level)
11853 btrfs_node_key_to_cpu(eb, &key, 0);
11855 btrfs_item_key_to_cpu(eb, &key, 0);
11857 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
11858 btrfs_commit_transaction(trans, root);
11859 btrfs_release_path(&path);
11863 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
11865 struct btrfs_path path;
11866 struct btrfs_trans_handle *trans;
11867 struct btrfs_key key;
11870 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
11871 bad->key.type, bad->key.offset);
11872 key.objectid = bad->root_id;
11873 key.type = BTRFS_ROOT_ITEM_KEY;
11874 key.offset = (u64)-1;
11876 root = btrfs_read_fs_root(root->fs_info, &key);
11877 if (IS_ERR(root)) {
11878 fprintf(stderr, "Couldn't find owner root %llu\n",
11880 return PTR_ERR(root);
11883 trans = btrfs_start_transaction(root, 1);
11885 return PTR_ERR(trans);
11887 btrfs_init_path(&path);
11888 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
11894 ret = btrfs_del_item(trans, root, &path);
11896 btrfs_commit_transaction(trans, root);
11897 btrfs_release_path(&path);
11901 static int zero_log_tree(struct btrfs_root *root)
11903 struct btrfs_trans_handle *trans;
11906 trans = btrfs_start_transaction(root, 1);
11907 if (IS_ERR(trans)) {
11908 ret = PTR_ERR(trans);
11911 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
11912 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
11913 ret = btrfs_commit_transaction(trans, root);
11917 static int populate_csum(struct btrfs_trans_handle *trans,
11918 struct btrfs_root *csum_root, char *buf, u64 start,
11925 while (offset < len) {
11926 sectorsize = csum_root->sectorsize;
11927 ret = read_extent_data(csum_root, buf, start + offset,
11931 ret = btrfs_csum_file_block(trans, csum_root, start + len,
11932 start + offset, buf, sectorsize);
11935 offset += sectorsize;
11940 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
11941 struct btrfs_root *csum_root,
11942 struct btrfs_root *cur_root)
11944 struct btrfs_path path;
11945 struct btrfs_key key;
11946 struct extent_buffer *node;
11947 struct btrfs_file_extent_item *fi;
11954 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
11958 btrfs_init_path(&path);
11962 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
11965 /* Iterate all regular file extents and fill its csum */
11967 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11969 if (key.type != BTRFS_EXTENT_DATA_KEY)
11971 node = path.nodes[0];
11972 slot = path.slots[0];
11973 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
11974 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
11976 start = btrfs_file_extent_disk_bytenr(node, fi);
11977 len = btrfs_file_extent_disk_num_bytes(node, fi);
11979 ret = populate_csum(trans, csum_root, buf, start, len);
11980 if (ret == -EEXIST)
11986 * TODO: if next leaf is corrupted, jump to nearest next valid
11989 ret = btrfs_next_item(cur_root, &path);
11999 btrfs_release_path(&path);
12004 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12005 struct btrfs_root *csum_root)
12007 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12008 struct btrfs_path path;
12009 struct btrfs_root *tree_root = fs_info->tree_root;
12010 struct btrfs_root *cur_root;
12011 struct extent_buffer *node;
12012 struct btrfs_key key;
12016 btrfs_init_path(&path);
12017 key.objectid = BTRFS_FS_TREE_OBJECTID;
12019 key.type = BTRFS_ROOT_ITEM_KEY;
12020 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12029 node = path.nodes[0];
12030 slot = path.slots[0];
12031 btrfs_item_key_to_cpu(node, &key, slot);
12032 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12034 if (key.type != BTRFS_ROOT_ITEM_KEY)
12036 if (!is_fstree(key.objectid))
12038 key.offset = (u64)-1;
12040 cur_root = btrfs_read_fs_root(fs_info, &key);
12041 if (IS_ERR(cur_root) || !cur_root) {
12042 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12046 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12051 ret = btrfs_next_item(tree_root, &path);
12061 btrfs_release_path(&path);
12065 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12066 struct btrfs_root *csum_root)
12068 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12069 struct btrfs_path path;
12070 struct btrfs_extent_item *ei;
12071 struct extent_buffer *leaf;
12073 struct btrfs_key key;
12076 btrfs_init_path(&path);
12078 key.type = BTRFS_EXTENT_ITEM_KEY;
12080 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12082 btrfs_release_path(&path);
12086 buf = malloc(csum_root->sectorsize);
12088 btrfs_release_path(&path);
12093 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12094 ret = btrfs_next_leaf(extent_root, &path);
12102 leaf = path.nodes[0];
12104 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12105 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12110 ei = btrfs_item_ptr(leaf, path.slots[0],
12111 struct btrfs_extent_item);
12112 if (!(btrfs_extent_flags(leaf, ei) &
12113 BTRFS_EXTENT_FLAG_DATA)) {
12118 ret = populate_csum(trans, csum_root, buf, key.objectid,
12125 btrfs_release_path(&path);
12131 * Recalculate the csum and put it into the csum tree.
12133 * Extent tree init will wipe out all the extent info, so in that case, we
12134 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12135 * will use fs/subvol trees to init the csum tree.
12137 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12138 struct btrfs_root *csum_root,
12139 int search_fs_tree)
12141 if (search_fs_tree)
12142 return fill_csum_tree_from_fs(trans, csum_root);
12144 return fill_csum_tree_from_extent(trans, csum_root);
12147 static void free_roots_info_cache(void)
12149 if (!roots_info_cache)
12152 while (!cache_tree_empty(roots_info_cache)) {
12153 struct cache_extent *entry;
12154 struct root_item_info *rii;
12156 entry = first_cache_extent(roots_info_cache);
12159 remove_cache_extent(roots_info_cache, entry);
12160 rii = container_of(entry, struct root_item_info, cache_extent);
12164 free(roots_info_cache);
12165 roots_info_cache = NULL;
12168 static int build_roots_info_cache(struct btrfs_fs_info *info)
12171 struct btrfs_key key;
12172 struct extent_buffer *leaf;
12173 struct btrfs_path path;
12175 if (!roots_info_cache) {
12176 roots_info_cache = malloc(sizeof(*roots_info_cache));
12177 if (!roots_info_cache)
12179 cache_tree_init(roots_info_cache);
12182 btrfs_init_path(&path);
12184 key.type = BTRFS_EXTENT_ITEM_KEY;
12186 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12189 leaf = path.nodes[0];
12192 struct btrfs_key found_key;
12193 struct btrfs_extent_item *ei;
12194 struct btrfs_extent_inline_ref *iref;
12195 int slot = path.slots[0];
12200 struct cache_extent *entry;
12201 struct root_item_info *rii;
12203 if (slot >= btrfs_header_nritems(leaf)) {
12204 ret = btrfs_next_leaf(info->extent_root, &path);
12211 leaf = path.nodes[0];
12212 slot = path.slots[0];
12215 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12217 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12218 found_key.type != BTRFS_METADATA_ITEM_KEY)
12221 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12222 flags = btrfs_extent_flags(leaf, ei);
12224 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12225 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12228 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12229 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12230 level = found_key.offset;
12232 struct btrfs_tree_block_info *binfo;
12234 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12235 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12236 level = btrfs_tree_block_level(leaf, binfo);
12240 * For a root extent, it must be of the following type and the
12241 * first (and only one) iref in the item.
12243 type = btrfs_extent_inline_ref_type(leaf, iref);
12244 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12247 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12248 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12250 rii = malloc(sizeof(struct root_item_info));
12255 rii->cache_extent.start = root_id;
12256 rii->cache_extent.size = 1;
12257 rii->level = (u8)-1;
12258 entry = &rii->cache_extent;
12259 ret = insert_cache_extent(roots_info_cache, entry);
12262 rii = container_of(entry, struct root_item_info,
12266 ASSERT(rii->cache_extent.start == root_id);
12267 ASSERT(rii->cache_extent.size == 1);
12269 if (level > rii->level || rii->level == (u8)-1) {
12270 rii->level = level;
12271 rii->bytenr = found_key.objectid;
12272 rii->gen = btrfs_extent_generation(leaf, ei);
12273 rii->node_count = 1;
12274 } else if (level == rii->level) {
12282 btrfs_release_path(&path);
12287 static int maybe_repair_root_item(struct btrfs_fs_info *info,
12288 struct btrfs_path *path,
12289 const struct btrfs_key *root_key,
12290 const int read_only_mode)
12292 const u64 root_id = root_key->objectid;
12293 struct cache_extent *entry;
12294 struct root_item_info *rii;
12295 struct btrfs_root_item ri;
12296 unsigned long offset;
12298 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12301 "Error: could not find extent items for root %llu\n",
12302 root_key->objectid);
12306 rii = container_of(entry, struct root_item_info, cache_extent);
12307 ASSERT(rii->cache_extent.start == root_id);
12308 ASSERT(rii->cache_extent.size == 1);
12310 if (rii->node_count != 1) {
12312 "Error: could not find btree root extent for root %llu\n",
12317 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12318 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12320 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12321 btrfs_root_level(&ri) != rii->level ||
12322 btrfs_root_generation(&ri) != rii->gen) {
12325 * If we're in repair mode but our caller told us to not update
12326 * the root item, i.e. just check if it needs to be updated, don't
12327 * print this message, since the caller will call us again shortly
12328 * for the same root item without read only mode (the caller will
12329 * open a transaction first).
12331 if (!(read_only_mode && repair))
12333 "%sroot item for root %llu,"
12334 " current bytenr %llu, current gen %llu, current level %u,"
12335 " new bytenr %llu, new gen %llu, new level %u\n",
12336 (read_only_mode ? "" : "fixing "),
12338 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12339 btrfs_root_level(&ri),
12340 rii->bytenr, rii->gen, rii->level);
12342 if (btrfs_root_generation(&ri) > rii->gen) {
12344 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12345 root_id, btrfs_root_generation(&ri), rii->gen);
12349 if (!read_only_mode) {
12350 btrfs_set_root_bytenr(&ri, rii->bytenr);
12351 btrfs_set_root_level(&ri, rii->level);
12352 btrfs_set_root_generation(&ri, rii->gen);
12353 write_extent_buffer(path->nodes[0], &ri,
12354 offset, sizeof(ri));
12364 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12365 * caused read-only snapshots to be corrupted if they were created at a moment
12366 * when the source subvolume/snapshot had orphan items. The issue was that the
12367 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12368 * node instead of the post orphan cleanup root node.
12369 * So this function, and its callees, just detects and fixes those cases. Even
12370 * though the regression was for read-only snapshots, this function applies to
12371 * any snapshot/subvolume root.
12372 * This must be run before any other repair code - not doing it so, makes other
12373 * repair code delete or modify backrefs in the extent tree for example, which
12374 * will result in an inconsistent fs after repairing the root items.
12376 static int repair_root_items(struct btrfs_fs_info *info)
12378 struct btrfs_path path;
12379 struct btrfs_key key;
12380 struct extent_buffer *leaf;
12381 struct btrfs_trans_handle *trans = NULL;
12384 int need_trans = 0;
12386 btrfs_init_path(&path);
12388 ret = build_roots_info_cache(info);
12392 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12393 key.type = BTRFS_ROOT_ITEM_KEY;
12398 * Avoid opening and committing transactions if a leaf doesn't have
12399 * any root items that need to be fixed, so that we avoid rotating
12400 * backup roots unnecessarily.
12403 trans = btrfs_start_transaction(info->tree_root, 1);
12404 if (IS_ERR(trans)) {
12405 ret = PTR_ERR(trans);
12410 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12414 leaf = path.nodes[0];
12417 struct btrfs_key found_key;
12419 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12420 int no_more_keys = find_next_key(&path, &key);
12422 btrfs_release_path(&path);
12424 ret = btrfs_commit_transaction(trans,
12436 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12438 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12440 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12443 ret = maybe_repair_root_item(info, &path, &found_key,
12448 if (!trans && repair) {
12451 btrfs_release_path(&path);
12461 free_roots_info_cache();
12462 btrfs_release_path(&path);
12464 btrfs_commit_transaction(trans, info->tree_root);
12471 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12473 struct btrfs_trans_handle *trans;
12474 struct btrfs_block_group_cache *bg_cache;
12478 /* Clear all free space cache inodes and its extent data */
12480 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12483 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12486 current = bg_cache->key.objectid + bg_cache->key.offset;
12489 /* Don't forget to set cache_generation to -1 */
12490 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12491 if (IS_ERR(trans)) {
12492 error("failed to update super block cache generation");
12493 return PTR_ERR(trans);
12495 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12496 btrfs_commit_transaction(trans, fs_info->tree_root);
12501 const char * const cmd_check_usage[] = {
12502 "btrfs check [options] <device>",
12503 "Check structural integrity of a filesystem (unmounted).",
12504 "Check structural integrity of an unmounted filesystem. Verify internal",
12505 "trees' consistency and item connectivity. In the repair mode try to",
12506 "fix the problems found. ",
12507 "WARNING: the repair mode is considered dangerous",
12509 "-s|--super <superblock> use this superblock copy",
12510 "-b|--backup use the first valid backup root copy",
12511 "--repair try to repair the filesystem",
12512 "--readonly run in read-only mode (default)",
12513 "--init-csum-tree create a new CRC tree",
12514 "--init-extent-tree create a new extent tree",
12515 "--mode <MODE> allows choice of memory/IO trade-offs",
12516 " where MODE is one of:",
12517 " original - read inodes and extents to memory (requires",
12518 " more memory, does less IO)",
12519 " lowmem - try to use less memory but read blocks again",
12521 "--check-data-csum verify checksums of data blocks",
12522 "-Q|--qgroup-report print a report on qgroup consistency",
12523 "-E|--subvol-extents <subvolid>",
12524 " print subvolume extents and sharing state",
12525 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12526 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12527 "-p|--progress indicate progress",
12528 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12532 int cmd_check(int argc, char **argv)
12534 struct cache_tree root_cache;
12535 struct btrfs_root *root;
12536 struct btrfs_fs_info *info;
12539 u64 tree_root_bytenr = 0;
12540 u64 chunk_root_bytenr = 0;
12541 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12545 int init_csum_tree = 0;
12547 int clear_space_cache = 0;
12548 int qgroup_report = 0;
12549 int qgroups_repaired = 0;
12550 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12554 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12555 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12556 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12557 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12558 static const struct option long_options[] = {
12559 { "super", required_argument, NULL, 's' },
12560 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12561 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12562 { "init-csum-tree", no_argument, NULL,
12563 GETOPT_VAL_INIT_CSUM },
12564 { "init-extent-tree", no_argument, NULL,
12565 GETOPT_VAL_INIT_EXTENT },
12566 { "check-data-csum", no_argument, NULL,
12567 GETOPT_VAL_CHECK_CSUM },
12568 { "backup", no_argument, NULL, 'b' },
12569 { "subvol-extents", required_argument, NULL, 'E' },
12570 { "qgroup-report", no_argument, NULL, 'Q' },
12571 { "tree-root", required_argument, NULL, 'r' },
12572 { "chunk-root", required_argument, NULL,
12573 GETOPT_VAL_CHUNK_TREE },
12574 { "progress", no_argument, NULL, 'p' },
12575 { "mode", required_argument, NULL,
12577 { "clear-space-cache", required_argument, NULL,
12578 GETOPT_VAL_CLEAR_SPACE_CACHE},
12579 { NULL, 0, NULL, 0}
12582 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
12586 case 'a': /* ignored */ break;
12588 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12591 num = arg_strtou64(optarg);
12592 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12594 "super mirror should be less than %d",
12595 BTRFS_SUPER_MIRROR_MAX);
12598 bytenr = btrfs_sb_offset(((int)num));
12599 printf("using SB copy %llu, bytenr %llu\n", num,
12600 (unsigned long long)bytenr);
12606 subvolid = arg_strtou64(optarg);
12609 tree_root_bytenr = arg_strtou64(optarg);
12611 case GETOPT_VAL_CHUNK_TREE:
12612 chunk_root_bytenr = arg_strtou64(optarg);
12615 ctx.progress_enabled = true;
12619 usage(cmd_check_usage);
12620 case GETOPT_VAL_REPAIR:
12621 printf("enabling repair mode\n");
12623 ctree_flags |= OPEN_CTREE_WRITES;
12625 case GETOPT_VAL_READONLY:
12628 case GETOPT_VAL_INIT_CSUM:
12629 printf("Creating a new CRC tree\n");
12630 init_csum_tree = 1;
12632 ctree_flags |= OPEN_CTREE_WRITES;
12634 case GETOPT_VAL_INIT_EXTENT:
12635 init_extent_tree = 1;
12636 ctree_flags |= (OPEN_CTREE_WRITES |
12637 OPEN_CTREE_NO_BLOCK_GROUPS);
12640 case GETOPT_VAL_CHECK_CSUM:
12641 check_data_csum = 1;
12643 case GETOPT_VAL_MODE:
12644 check_mode = parse_check_mode(optarg);
12645 if (check_mode == CHECK_MODE_UNKNOWN) {
12646 error("unknown mode: %s", optarg);
12650 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12651 if (strcmp(optarg, "v1") == 0) {
12652 clear_space_cache = 1;
12653 } else if (strcmp(optarg, "v2") == 0) {
12654 clear_space_cache = 2;
12655 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12658 "invalid argument to --clear-space-cache, must be v1 or v2");
12661 ctree_flags |= OPEN_CTREE_WRITES;
12666 if (check_argc_exact(argc - optind, 1))
12667 usage(cmd_check_usage);
12669 if (ctx.progress_enabled) {
12670 ctx.tp = TASK_NOTHING;
12671 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12674 /* This check is the only reason for --readonly to exist */
12675 if (readonly && repair) {
12676 error("repair options are not compatible with --readonly");
12681 * Not supported yet
12683 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12684 error("low memory mode doesn't support repair yet");
12689 cache_tree_init(&root_cache);
12691 if((ret = check_mounted(argv[optind])) < 0) {
12692 error("could not check mount status: %s", strerror(-ret));
12696 error("%s is currently mounted, aborting", argv[optind]);
12702 /* only allow partial opening under repair mode */
12704 ctree_flags |= OPEN_CTREE_PARTIAL;
12706 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12707 chunk_root_bytenr, ctree_flags);
12709 error("cannot open file system");
12715 global_info = info;
12716 root = info->fs_root;
12717 if (clear_space_cache == 1) {
12718 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12720 "free space cache v2 detected, use --clear-space-cache v2");
12724 printf("Clearing free space cache\n");
12725 ret = clear_free_space_cache(info);
12727 error("failed to clear free space cache");
12730 printf("Free space cache cleared\n");
12733 } else if (clear_space_cache == 2) {
12734 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12735 printf("no free space cache v2 to clear\n");
12739 printf("Clear free space cache v2\n");
12740 ret = btrfs_clear_free_space_tree(info);
12742 error("failed to clear free space cache v2: %d", ret);
12745 printf("free space cache v2 cleared\n");
12751 * repair mode will force us to commit transaction which
12752 * will make us fail to load log tree when mounting.
12754 if (repair && btrfs_super_log_root(info->super_copy)) {
12755 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12761 ret = zero_log_tree(root);
12764 error("failed to zero log tree: %d", ret);
12769 uuid_unparse(info->super_copy->fsid, uuidbuf);
12770 if (qgroup_report) {
12771 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12773 ret = qgroup_verify_all(info);
12780 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12781 subvolid, argv[optind], uuidbuf);
12782 ret = print_extent_state(info, subvolid);
12786 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12788 if (!extent_buffer_uptodate(info->tree_root->node) ||
12789 !extent_buffer_uptodate(info->dev_root->node) ||
12790 !extent_buffer_uptodate(info->chunk_root->node)) {
12791 error("critical roots corrupted, unable to check the filesystem");
12797 if (init_extent_tree || init_csum_tree) {
12798 struct btrfs_trans_handle *trans;
12800 trans = btrfs_start_transaction(info->extent_root, 0);
12801 if (IS_ERR(trans)) {
12802 error("error starting transaction");
12803 ret = PTR_ERR(trans);
12808 if (init_extent_tree) {
12809 printf("Creating a new extent tree\n");
12810 ret = reinit_extent_tree(trans, info);
12816 if (init_csum_tree) {
12817 printf("Reinitialize checksum tree\n");
12818 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
12820 error("checksum tree initialization failed: %d",
12827 ret = fill_csum_tree(trans, info->csum_root,
12831 error("checksum tree refilling failed: %d", ret);
12836 * Ok now we commit and run the normal fsck, which will add
12837 * extent entries for all of the items it finds.
12839 ret = btrfs_commit_transaction(trans, info->extent_root);
12844 if (!extent_buffer_uptodate(info->extent_root->node)) {
12845 error("critical: extent_root, unable to check the filesystem");
12850 if (!extent_buffer_uptodate(info->csum_root->node)) {
12851 error("critical: csum_root, unable to check the filesystem");
12857 if (!ctx.progress_enabled)
12858 fprintf(stderr, "checking extents\n");
12859 if (check_mode == CHECK_MODE_LOWMEM)
12860 ret = check_chunks_and_extents_v2(root);
12862 ret = check_chunks_and_extents(root);
12866 "errors found in extent allocation tree or chunk allocation");
12868 ret = repair_root_items(info);
12873 fprintf(stderr, "Fixed %d roots.\n", ret);
12875 } else if (ret > 0) {
12877 "Found %d roots with an outdated root item.\n",
12880 "Please run a filesystem check with the option --repair to fix them.\n");
12886 if (!ctx.progress_enabled) {
12887 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12888 fprintf(stderr, "checking free space tree\n");
12890 fprintf(stderr, "checking free space cache\n");
12892 ret = check_space_cache(root);
12898 * We used to have to have these hole extents in between our real
12899 * extents so if we don't have this flag set we need to make sure there
12900 * are no gaps in the file extents for inodes, otherwise we can just
12901 * ignore it when this happens.
12903 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
12904 if (!ctx.progress_enabled)
12905 fprintf(stderr, "checking fs roots\n");
12906 if (check_mode == CHECK_MODE_LOWMEM)
12907 ret = check_fs_roots_v2(root->fs_info);
12909 ret = check_fs_roots(root, &root_cache);
12914 fprintf(stderr, "checking csums\n");
12915 ret = check_csums(root);
12920 fprintf(stderr, "checking root refs\n");
12921 /* For low memory mode, check_fs_roots_v2 handles root refs */
12922 if (check_mode != CHECK_MODE_LOWMEM) {
12923 ret = check_root_refs(root, &root_cache);
12929 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
12930 struct extent_buffer *eb;
12932 eb = list_first_entry(&root->fs_info->recow_ebs,
12933 struct extent_buffer, recow);
12934 list_del_init(&eb->recow);
12935 ret = recow_extent_buffer(root, eb);
12941 while (!list_empty(&delete_items)) {
12942 struct bad_item *bad;
12944 bad = list_first_entry(&delete_items, struct bad_item, list);
12945 list_del_init(&bad->list);
12947 ret = delete_bad_item(root, bad);
12953 if (info->quota_enabled) {
12954 fprintf(stderr, "checking quota groups\n");
12955 ret = qgroup_verify_all(info);
12960 ret = repair_qgroups(info, &qgroups_repaired);
12967 if (!list_empty(&root->fs_info->recow_ebs)) {
12968 error("transid errors in file system");
12973 if (found_old_backref) { /*
12974 * there was a disk format change when mixed
12975 * backref was in testing tree. The old format
12976 * existed about one week.
12978 printf("\n * Found old mixed backref format. "
12979 "The old format is not supported! *"
12980 "\n * Please mount the FS in readonly mode, "
12981 "backup data and re-format the FS. *\n\n");
12984 printf("found %llu bytes used err is %d\n",
12985 (unsigned long long)bytes_used, ret);
12986 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
12987 printf("total tree bytes: %llu\n",
12988 (unsigned long long)total_btree_bytes);
12989 printf("total fs tree bytes: %llu\n",
12990 (unsigned long long)total_fs_tree_bytes);
12991 printf("total extent tree bytes: %llu\n",
12992 (unsigned long long)total_extent_tree_bytes);
12993 printf("btree space waste bytes: %llu\n",
12994 (unsigned long long)btree_space_waste);
12995 printf("file data blocks allocated: %llu\n referenced %llu\n",
12996 (unsigned long long)data_bytes_allocated,
12997 (unsigned long long)data_bytes_referenced);
12999 free_qgroup_counts();
13000 free_root_recs_tree(&root_cache);
13004 if (ctx.progress_enabled)
13005 task_deinit(ctx.info);